{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a4c93ebd",
   "metadata": {},
   "source": [
    "# CLIPS Constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4eafe4d",
   "metadata": {},
   "source": [
    "Refer the details in lecture notes 7."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b772938",
   "metadata": {},
   "source": [
    "# Section A: Conflict Resolution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0592f70",
   "metadata": {},
   "source": [
    "* Set the **conflict resolution** strategies: \n",
    " * **FCFS**: (set-strategy breadth) \n",
    " * **Specificity**: (set-strategy lex) \n",
    " * **Recency**: (set-strategy depth) \n",
    " * **Highest Priority**: default (set-strategy lex), use salience\n",
    "\n",
    "1. Refer to the Lab 4, question 3 - Create the conflict resolution based on **ordered fact**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a4ebbfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# env.build(\"\"\"(deffacts init\n",
    "#                 (engine wont_start)\n",
    "#                 (sound clicking_noise))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R1\n",
    "               (engine wont_start)\n",
    "             =>\n",
    "             (printout t \"battery may be weak!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R2\n",
    "               (engine wont_start)\n",
    "               (sound silence)\n",
    "             =>\n",
    "             (printout t \"starter is faulty!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R3\n",
    "                (engine wont_start)\n",
    "                (sound clicking_noise)\n",
    "             =>\n",
    "            (printout t \"battery may be dead!\" crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "# Debug\n",
    "# env.eval(\"(watch rules)\") #(watch facts), ...\n",
    "\n",
    "# Method 1: Set the conflict resolution strategy\n",
    "#env.strategy = clips.Strategy.BREADTH  \n",
    "#env.strategy = clips.Strategy.DEPTH    \n",
    "#env.strategy = clips.Strategy.LEX      \n",
    "\n",
    "# Method 2: Set the conflict resolution strategy\n",
    "#env.eval(\"(set-strategy breadth)\")\n",
    "#env.eval(\"(set-strategy depth)\")\n",
    "#env.eval(\"(set-strategy lex)\")\n",
    "\n",
    "# Scenario 1\n",
    "env.eval(\"(assert (engine wont_start)(sound clicking_noise))\")\n",
    "\n",
    "# Scenario 2\n",
    "# env.eval(\"(assert (sound clicking_noise))\")\n",
    "# env.eval(\"(assert (engine wont_start))\")\n",
    "  \n",
    "#env.eval(\"(agenda)\")\n",
    "\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b330e7ea",
   "metadata": {},
   "source": [
    "2. Based on highest priority based on user's salience"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98e32b61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# env.build(\"\"\"(deffacts init\n",
    "#                 (engine wont_start)\n",
    "#                 (sound clicking_noise))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R1\n",
    "               (declare (salience 50))\n",
    "               (engine wont_start)\n",
    "             =>\n",
    "             (printout t \"battery may be weak!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R2\n",
    "               (engine wont_start)\n",
    "               (sound silence)\n",
    "             =>\n",
    "             (printout t \"starter is faulty!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R3\n",
    "                (declare (salience 30))\n",
    "                (engine wont_start)\n",
    "                (sound clicking_noise)\n",
    "             =>\n",
    "            (printout t \"battery may be dead!\" crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "# Debug\n",
    "# env.eval(\"(watch rules)\") #(watch facts), ...\n",
    "\n",
    "env.eval(\"(set-strategy lex)\")\n",
    "\n",
    "# Scenario 1\n",
    "env.eval(\"(assert (engine wont_start)(sound clicking_noise))\")\n",
    "\n",
    "# Scenario 2\n",
    "# env.eval(\"(assert (sound clicking_noise))\")\n",
    "# env.eval(\"(assert (engine wont_start))\")\n",
    "  \n",
    "#env.eval(\"(agenda)\")\n",
    "\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da69c8d3",
   "metadata": {},
   "source": [
    "3. Refer to the same question - Create the conflict resolution based on **unordered fact**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47283fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "env.build(\"\"\"(deftemplate car\n",
    "               (slot engine)\n",
    "               (slot sound))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R1\n",
    "               (car (engine wont_start))\n",
    "             =>\n",
    "             (printout t \"battery may be weak!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R2\n",
    "               (car (engine wont_start)\n",
    "                    (sound silence))\n",
    "             =>\n",
    "             (printout t \"starter is faulty!\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule R3\n",
    "               (car (engine wont_start)\n",
    "                    (sound clicking_noise))\n",
    "             =>\n",
    "            (printout t \"battery may be dead!\" crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "# Debug\n",
    "# env.eval(\"(watch rules)\") #(watch facts), ...\n",
    "\n",
    "#env.eval(\"(set-strategy breadth)\")\n",
    "#env.eval(\"(set-strategy depth)\")\n",
    "#env.eval(\"(set-strategy lex)\")\n",
    "\n",
    "# Scenario 3\n",
    "env.eval(\"(assert (car (engine wont_start)(sound clicking_noise)))\")\n",
    "\n",
    "# Scenario 4\n",
    "# env.eval(\"(assert (car (sound clicking_noise)))\")\n",
    "# env.eval(\"(assert (car (engine wont_start)))\")\n",
    "  \n",
    "#env.eval(\"(agenda)\")\n",
    "\n",
    "env.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5e6149c",
   "metadata": {},
   "source": [
    "* **Questions:** <br>\n",
    "  1. **FCFS**: Explain why both assertions (car (engine wont_start)(sound clicking_noise)) or (car (sound clicking_noise)(engine wont_start)) the output still R1 -> R3? <br>\n",
    "  2. **Recency**: Explain why changing from (car (engine wont_start)(sound clicking_noise)) to (car (sound clicking_noise)(engine wont_start)) the output still R3 -> R1? <br>\n",
    "  3. Why the result for scenario 3 and scenario 4 are different? <br> (**Hints**) **ordered fact** vs **unordered fact**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8ed6964",
   "metadata": {},
   "source": [
    "# Section B: Backward Chaining "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "828999f5",
   "metadata": {},
   "source": [
    "In **CLIPS**, **default inference** is using **forward chaining** technique. Example **backward chaining** technique below is just a basic implementation. For complete backward chaining, the implementation must consider for the **conflict resolution** as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81963351",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips\n",
    "\n",
    "# Initialize CLIPS environment\n",
    "env = clips.Environment()\n",
    "\n",
    "# Initialize facts\n",
    "env.build(\"\"\"(deffacts init (ingredient flour)\n",
    "                          (ingredient eggs)\n",
    "                          (ingredient sugar)\n",
    "                          (have-time yes))\"\"\")\n",
    "\n",
    "# Define CLIPS rules and facts\n",
    "env.build(\"\"\"(defrule rule1\n",
    "               (ingredient flour)\n",
    "               (ingredient eggs)\n",
    "               (ingredient sugar)\n",
    "             => (assert (action bake-cake)))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule rule2\n",
    "                (or (not (ingredient flour))\n",
    "                (not (ingredient eggs))\n",
    "                (not (ingredient sugar)))\n",
    "             => (assert (action buy-cake)))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule rule3\n",
    "                (have-time yes)\n",
    "             => (assert (result bake-cake)))\"\"\")\n",
    "\n",
    "\n",
    "env.reset()\n",
    "\n",
    "#Backward chaining function\n",
    "def backward_chain(goal):\n",
    "    \n",
    "    # Check the goal before running inference\n",
    "    for fact in env.facts():\n",
    "        if str(fact) == goal:\n",
    "            return True\n",
    "\n",
    "    # Before inference\n",
    "    initial_facts = len(list(env.facts())) #return 4\n",
    "    \n",
    "    # After inference\n",
    "    env.run()  \n",
    "    final_facts = len(list(env.facts())) # return 6\n",
    "\n",
    "    # Check the goal after running inference\n",
    "    for fact in env.facts():\n",
    "        if str(fact) == goal:\n",
    "            return True\n",
    "\n",
    "    if initial_facts == final_facts:\n",
    "        return False\n",
    "\n",
    "    # Recursive function\n",
    "    return backward_chain(goal)\n",
    "\n",
    "# Goal to achieve\n",
    "goal = \"(result bake-cake)\"\n",
    "\n",
    "# Perform backward chaining\n",
    "if backward_chain(goal):\n",
    "    print(f\"Goal achieved: {goal}\")\n",
    "else:\n",
    "    print(f\"Goal could not be achieved: {goal}\")\n",
    "\n",
    "#Print final facts\n",
    "print(\"\\nFinal Facts in the Knowledge Base:\")\n",
    "for fact in env.facts():\n",
    "    print(fact)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1116f64a",
   "metadata": {},
   "source": [
    "# Section C: Semantic-based Expert System"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAFACAYAAAAyKD/8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAHu1SURBVHhe7d13dFTV2sfx76T3kEIKJaEntNCRIkURpSvSlA4KgiAi3ldFRFCwF7o0BaVJ771K772lQUJI7z2Zet4/hFw4VxGVJJPk+azFEufZZybAzDm/2WcXjaIoCkIIIYQQf8JC/YAQQgghxIMkLAghhBDikSQsCCGEEOKRJCwIIYQQ4pEkLAghhBDikSQsCCGEEOKRJCwIIYQQ4pEkLAghhBDikTSyKJMoLUwmEwAGg4H7b2u9Xl/w+79iaWmJpaVlwe8tLCzQaDRoNBp1UyGEKFMkLIgSR1EU9Ho9BoMBo9FITk4OeXl5pKWlodFoiIyMRKvVYmVlxdWrV9FqtY91wffx8cHHxwcAd3d33N3dsbS0pHz58tjZ2WFtbY2NjQ2WlpZYWVk91nMKIURpIGFBmD2j0YhWq0Wv15OWlkZ6ejpRUVHExsaSnp7OsmXLuHXrFr1796ZatWrUqlULDw8PFEXB398fFxeXx7qwR0VFkZmZCUBoaCipqakcOXKEK1eu0LlzZ6pWrUqDBg1wcXHB29sbHx8f7OzssLW1xcbGBgsLuasnhCidJCwIs6TT6cjNzSUhIYHY2Fju3LnDrVu3WL9+PdWrV+eFF14gICCAqlWr4u/vj42NjfopnhhFUUhLSyMxMZGwsDBOnTrFyZMnsbGxoWXLltStWxd/f38qV66Mg4MD9vb2WFtbq59GCCFKLAkLwmzodDqysrJISUkhODiYy5cvs2HDBqpWrcorr7xCUFAQ1apVw9bWVn1oscjNzeXatWucO3eOw4cPk5ubS8eOHalfvz6+vr5UrFgRe3t7rKys1IcKIUSJImFBFCuTyURWVhaxsbGEhYVx4sQJIiIiaNq0Kc8++ywBAQE4OTmpDzNL2dnZnDlzhp07d7Jt2zbeeecdatWqRZUqVfDx8cHBwUF9iBBClAgSFkSx0Ov1JCQkEBUVxZkzZzhy5AgBAQEMGTKEmjVrFsxKKKny8/M5deoUW7ZsISYmhi5dutCgQQOqVKmCs7Oz9DYIIUoUCQuiSOn1eiIiIrh69SrHjh0jOTmZl19+mfbt2+Pm5qZuXiokJyezYsUKjh07RrNmzWjSpAlBQUF4eHiU+FAkhCgbJCyIImE0GomIiODcuXNs3ryZrKwsvvnmG+rUqaNuWmrl5eWxd+9e1q5di5eXF127dqVBgwaUL19e3VQIIcyKhAVRqBRFITExkYsXL7J27Vri4uL47rvvylRIUMvPz2fPnj2sXbuWypUr07NnT+rVq4ejo6O6qRBCmAUJC6LQaLVarl27xtatW4mMjGT06NG0aNFC3azM0mq1rFmzhn379tGmTRvatm1bKsZrCCFKHwkLolDEx8ezd+9eTp48SVBQEG+88YYsWvQnEhMTWbx4MREREfTp04eWLVvi4uKibiaEEMVGwoJ4ogwGA9evX2f16tVkZGTw9ttvExAQoG4m/sCuXbvYtGkTdevWpVevXlSqVEndRAghioWEBfHEaLVajhw5wsaNG6lcuTITJ058rGWWxX/dvXuXH374gbS0NEaMGEGTJk3UTYQQoshJWBBPRH5+Pjt37mTnzp107dqVnj17qpuIx2QwGPjss8+4fPkyH3zwAc2bN1c3EUKIIiVhQfxr+fn5bN++nSNHjjB8+HAaNmyobiL+gTVr1nDo0CGGDBlCy5Yt1WUhhCgyMuJM/CsSFApPv379aNu2LcuWLePkyZPqshBCFBkJC+If0+l07N+/nyNHjvDaa69JUCgE/fv3p02bNixfvpzz58+ry0IIUSQkLIh/xGQycfnyZbZs2cLQoUNp0KCBuol4Qvr370/jxo1ZtmwZoaGh6rIQQhQ6CQviH4mKimLx4sV06tSJxo0bq8viCRs6dCienp6sWbOGpKQkdVkIIQqVhAXxt2VnZ7Nq1So8PT3p1auXuiwKgZWVFW+++SYpKSkcOHBAXRZCiEIlYUH8LSaTievXr3Pz5k0+/PBDdVkUIg8PD1544QWOHz/OpUuX1GUhhCg0EhbE35KamsqKFSsYMGAATk5O6rIoZJ07d8bd3Z3Tp0+Tl5enLgshRKGQsCAem9Fo5MqVK6Snp9OpUyd1WRSR/v37c+jQIY4fP64uCSFEoZCwIB5bdnY2q1evZvjw4eqSKEIBAQE4OzsTHh6O0WhUl4UQ4omTsCAeW2xsLLdu3aJdu3bqkihiQ4YMITMzk8jISHVJCCGeOAkL4rHodDouXrxIhw4dzHaraVPUIb7ecIqbqVp16WFJp5j1/W/czjNQUtc6b9GiBadOneLy5cvqkhBCPHHmedYXZkev13Pz5k2eeeYZdclsmCIPMn/9ScLS8tWlhyWeZOb3R4nWGUtsWLCyssLDw4O0tDS5FSGEKHQSFsRjub+rZP369dUl82FlC/a2aCx+3xbbkH6VLdPGMWLAq4z+YSfBybrfw4GlHS6O6VzfNpcRw4cy5N1lnIjNQSGDK6umM3XtHnYv/pBBQ0cwad1F/qqjorh07twZOzs7MjMz1SUhhHiiJCyIx5KcnEx4eHjJmC6psQLtJRZ/sJQ9MTZUqeePzdmljPpuOzezAAsLLJNP8ttVHZUCquAQuoK35h4l3pjOza3zmfbxGi4rvtT2U7i88FN+OJ2sfgWz4OvrS3JyMhkZGeqSEEI8URIWxF9SFIWsrKwSs02yhTVknPyVJXfL0WH8ZD6Y+CXfjW2NYelq9l9PwWRUMFlUomn315n8/lRmvtOIO9uuE2PQYG3vhEtAc7oMfosPJk9hYIUQNl5LVL+EWahQoQI5OTnk5uaqS0II8URJWBB/SVEULCwsaN68ubpkhjRYWuUQfvws2Q1qU9/bAUvAqskL9HZJIT0tH6PJhMktiKZ1XLAAbL0r4ZVvxHhvAINH66bUsQONxoEKAeXJ0xvUL2IWXFxcsLS0lDELQohCJ2FBPBYLCwvs7e3VDxcv5RabJ/7I9sNR5ABW1lZoAJPJEjtHW0wKmApGMGrJzTFiNN37X0ur/775jUZMmt/HOfxeulfRaLCyscbigZo50Wg0Bb+EEKIwSVgQjyUnJ4dNmzapHy5emhzC9y/kh61nidVD4rXrGAxarHGkRtv2eB88zuFbmeiA9G0rWWhTHX8/J6wtAEX585kQyn8rygO/Nzfx8fEyuFEIUSQkLIi/ZGFhgY+PDyEhIepSMavFSx/3oeK5rxj6dBAv/JpP385PE+Rmi23DAXzc15b9o1/k+dZN6PRTIl0nvU6nWq5g0pKekY/+fg4waMnIyMeACV12Oun59247KAr6/Mz//r+Zyc7OpkKFCjg7O6tLQgjxRGkUc/7qJMxGamoq3bt3Z8+ePeY1I8KUwe3TJ7kckYShcmPaNgrA28kKACX7Dhd+u8CtjFysqjWlbYMaeDhYosmK5LezBuq1qYaHtQWajNscPK/QqH0F8q+c5KZzY56pXg6NoiP11nkuW9blmaou6lcudlu2bCEnJ4dOnTrh7u6uLgshxBMjYUE8lpycHL755hs6depEixYt1GVRDPr168ezzz7LyJEjZdyCEKJQyW0I8Visra2pX78+hw8fVpdEMdBqtVhZWVG5cmUJCkKIQidhQTwWGxsbatWqxezZs8160F9ZcebMGerUqUPNmjXVJSGEeOIkLIjHVrlyZbp168a+ffvUJVHEZs2ahYODA9WrV1eXhBDiiZOwIB6bi4sLw4YN44cfflCXRBEKCwujZs2atG7d2mx3ABVClC5yphGPzcLCgsDAQGrWrGl+ay6UIZMnT8bd3Z2mTZuqS0IIUSgkLIi/xdXVlVdeeYWFCxeSl5enLotCtnfvXqpVq0bnzp2lV0EIUWTkbCP+Fo1GQ2BgIM8//zxTp05Vl0UhSklJYefOnTRq1Ih69eqpy0IIUWgkLIi/zdHRkX79+qHValm/fr26LArJ+PHjsba2pmvXruqSEEIUKgkL4h+pUKECw4YNY9++fVy+fFldFk/YjBkzcHd3Z+zYsTg4OKjLQghRqCQsiH9Eo9FQt25dunXrxqRJk4iLi1M3EU/Ili1bCA8PZ8CAAfj7+6vLQghR6CQsiH/MysqK559/nuHDhzNq1CgJDIVgy5YtHDx4kEGDBtG8eXN1WQghioSEBfGv2Nra0q1bNwYPHswbb7zBrVu31E3EP7Rp0yYOHjzIK6+8IvtxCCGKlYQF8a/Z2NjQvXt3hgwZwsiRIzl48KC6ifibZs6cyapVq+jfvz8tW7ZUl4UQokjJrpPiiTGZTJw5c4YZM2bQunVrxo0bp24i/kJaWhpvvvkmWq2WWbNmUblyZXUTIYQochIWxBMXFRXFvHnziIuLY+bMmbi7u6ubiD9w4cIF5syZQ506dRg5ciSurq7qJkIIUSwkLIhCkZOTw/bt2/n111/p1asXgwYNUjcR96SkpDBjxgwiIiIYN24cTZo0wcrKSt1MCCGKjYQFUWhMJhO3bt1i4cKF3L17l48++oj69eurm5VZ+fn5HDx4kJUrV1K7dm3efPNN6YURQpglCQui0OXn53P06FGWLVtGxYoVGTduHBUqVFA3KzMUReH69evMmTOH7OxsJk6cKMs3CyHMmoQFUWSys7M5dOgQa9euxd/fn5EjR1K5cmU0Go26aamk1+u5cuUKS5YsITU1lffee4/69evLLQchhNmTsCCKXHZ2NgcPHmTJkiW4uroyduxYGjRogI2NjbppqZCZmcm+ffvYsGEDJpOJ999/nwYNGsiukUKIEkPCgig2+fn5nD9/np9++omEhAR69epFhw4dqFSpEpaWlurmJYaiKOj1ekJDQ9mwYQN79+6lc+fO9OvXj2rVqpXoP5sQomySsCCKnaIoxMbGcujQIb777jucnZ0ZN24cTZs2pWLFilhaWqLRaMz2doWiKJhMJgwGA+Hh4ezZs4edO3fi6OjI2LFjad68uUyDFEKUaBIWhFm5f8G9cOECM2bMwGQyFSx3XLNmTcqVK4e1tXVBeCjqAKEoSkE40Ov13L17l4iICPbv38+RI0eoX78+L774IvXr16dKlSrqw4UQokSSsCDMWnx8PFevXuXMmTP8+OOPVK5cmU6dOlGrVi38/f2pWLEirq6uWFlZFfRAAA+NB3icQPHgx+B+IAAwGo0FtxXS09OJjo7m9u3bnDp1ilOnTuHq6krPnj1p3LgxAQEBuLm5PfCsQghROkhYECVKamoq165d486dO4SFhfHzzz9ja2vLc889R40aNahYsSIANWrUwM7ODpPJhKenJ46OjgWhQaPRPBQOABITE8nLywMgOTmZlJQUTCYT586dIzk5mVWrVtGqVSvat29P06ZN8fX1JTAwEHt7+4eeRwghSiMJC6LE02q1pKSkEBkZSXp6OklJSURGRqLT6bCzs+OHH34gNTW1oLchPz8fW1vbgvCgKApdu3YlMDCw4NZG8+bN0Wg0VK9eHUdHR/z8/FSvKoQQZYeEBVHmODk5ERkZiaenp7okhBDiD8hEbyGEEEI8koQFIYQQQjyShAUhhBBCPJKEBSGEEEI8koQFIYQQQjyShAUhhBBCPJKEBSGEEEI8kqyzIMocWWdBmBtFUTAajZhMJnQ6HUajEY1Gg16vJz8//39WHAWwsrLC1ta2YLExKysrrK2tsbCweGjpcyGeBAkLosyRsCCKi8lkIj8/n7y8PPLz88nOziYpKalg11Kj0Uh6ejo6nQ5LS0syMjJITEzEYDA8dPFXFAVHR0e8vLywtbXFZDJha2tLuXLl0Gg02NjYoNFo8Pb2xtnZGRsbGxwdHQseF+LvkrAgyhwJC6KoGAwGsrKySE9PJy4ujqSkJAASEhJISUkhLCyMPXv2ULduXZ577jns7OyoUKECXl5eGI1GHBwc8PHxwd7e/qHeBQsLC1JSUkhKSsJgMGBlZUVsbCzx8fHk5+ezc+dOwsLCePHFFwkMDMTZ2ZmKFSui0Wjw8vLCzc0NV1dXXFxcHtp0TYg/I2FBlDkSFkRhURSFrKwskpKSSExMJC0tjZSUFEJCQjh27BgWFhYMGTIEPz8/fHx8qFSpEs7OzuqneWIyMjK4e/cuiYmJRERE8OOPP+Lv70+dOnXw9/fH1dUVPz8/ypcvj4eHBw4ODuqnEAIkLIiySMKCeJLuB4TY2FiuX79OXl4eISEhhISEEBgYSKtWrahTpw6+vr5YW1urDy9yOp2OW7ducfXqVfbs2YNGo6Fu3bpUrFgRa2trgoKC8PLyKtQQI0oeCQuizJGwIJ4EnU7H3bt3OXfuHAaDgZCQEPbt28ebb75Jy5YtqVGjhvoQs6TVarl9+zZ79uzhl19+oWfPnlSuXJlq1apRpUoVKleuLLcqhIQFUfZIWBD/RmZmJqGhoVy9epX4+Hg2b97MW2+9Rdu2bUvFVuY3b95k165dnD17lsaNG1O5cmXq169PtWrVsLe3VzcXZYSEBVHm9OvXj8WLF+Pi4qIuCfGnMjIyuHLlCpcuXSIiIgK9Xs/rr79OgwYN1E1LBZ1Ox+nTp1m+fDmVKlWiUqVK1K5dm/r16+Pk5KRuLko5CQtCCPEImZmZXLx4keDgYK5fv463tzdDhgyhUqVK6qal1u3bt/nll1+Ij48nKCiIFi1a0KBBA6ysrNRNRSklYUEIIf7EhQsXOHr0KMHBwdSvX59BgwaV6YF/kZGR/PLLL2RlZREQEEDbtm0JCAhQNxOlkIQFUSoYUkL4bd8JbtoH8VKHICo7/e+oc33WHa7FOFCvVnmIP8f6SE+6PuWPi6UsUiMeFh8fz88//0x2djZ2dnYMHTq0TPUkPIqiKFy/fp2FCxfi4+NDjRo1eOGFFyhXrpy6qShFZIirKBUS9y7kuwU/s+5kBOlao7oMQPb5RUzeFk6OAXLOLWLYjKMk6/64rSibFEXh+PHjLF26lIMHD9K7d28++ugjCQoP0Gg01KtXj1mzZtGqVSv27t3L4sWLuXLlirqpKEWkZ0GUeNqYfXw55h22WXThP5Mn0KOmgRu7dnI6Ko0c+wZ07fssde3CmDOyL1OSnuLDj6cwMGMG1ZZXYdUQdyJDUnBu9CKvtK2Ko4UGQ+ZNflu9i8s5FlhXb8crnRtRXpPB7SO/EWm0IPxmCn5detO5hgzyKk2ys7NZuXIlISEh1K5dm+HDh2NpaaluJlRSUlL44YcfyMzMpGXLlvTs2VOWlC6FLKdOnTpV/aAQJUle5DHWbdrPhUgTFZtUIXPjBnYeOUdYShpR50+wW1eVZ/0z2LVqC+di8/Bs8jztbS4xb91tvJ3TCLlwlH37buLQuA0NnGPYOWMFB2+EEpOazO3IcC5nVqRV7Sx2vDuYaefBmJGOQ/3WNKsg08hKi6ioKObPn8+tW7cYPnw4Xbp0kbUFHpODgwOtW7dGURQ2bNhAQkICdevWNYsFqMSTI58GUeI5Bw1hbMdmvPx/H/BGj6b42rhSb+hHfDppFM/UiGHXnrPccW3LhCH18Rs5g2971sfFWoPRxp92o75l5bpVjHc8xu5ryeSF7eTL6Zu47VWfoHp1qJ60l7n/t44reRbYuDjj2m4sS5d8w5tN3dQ/hiihwsLC+Omnn0hPT+fzzz+nYcOG8s34b7KysqJTp05MmjSJ69ev8/3333P37l11M1GCSVgQpUAeuXodeTk5mNJywa8ilkmXObj3CJdi9RhtbbG00JOTZ8CUl40JBUwmlPoNqFvOAtDgVN4JO2sNeXF3CK5YAce0EC5eukGSd2c+HtUEF72CpaULDepXUL+4KMHCwsJYtGgRlSpV4vPPP5dBev+CRqOhVq1aTJ06ldjYWD777DOio6PVzUQJJWFBlBoaC2tskw8zfcphkl1r8+yg0bz/ckNcMaEzKZiMBvL1llgoGjRowKBHD4AJkwlAg51XRao7N2fYnEX89NMi5n7QA5/GtajsrEHBhF5vUL+sKKHCwsJYuHAhgYGBDBkyBDs7O3UT8Q94eHjw6aefYmdnx/Tp00lISFA3ESWQhAVRCigY83PIzddicPCjaYNMjmxayqzvfmHz2Qi0Z8OITTPiWr02Tpu+ZsqmSyTlZUOuDpPy+/H63Cxy9Qr2tV5gfOtofhryGhPeHcuQiQvZcz0ZPSb0udnk6WU8cGmQkJDArFmzqF27NgMHDsTGxkbdRPwLHh4eTJo0CQcHB7755hu0Wq26iShhZICjKAU0WFjb41m9PrVq1qZxNUhJSCTD4EfbHh1oUqUmjZvWpFrVavhkJJLpU5+WdSpRrmJt2gV6YW9hgZWtK751mhBYsTK1W/tjGRFGlNYWj6f68/HI1nhbWGBl707luo2p6S4Dt0q6yZMnU7FiRV577TXZ76CQODo60rBhQ44dO8aNGzdo3bq1uokoQWTqpBCiTPnuu++4c+cOU6ZMwcPDQ10WT9itW7f4/PPP6dy5M71791aXRQkhtyGEEGXG6dOnuXTpEmPHjpWgUESqVq3K4MGD2bNnD8nJyeqyKCEkLIgy57333iMnJ0f9sCjlFEVh9uzZDBo0iGrVqqnLopBYWFjQrFkzGjduzH/+8x91WZQQEhZEmfPDDz+Ql5enfliUcmvWrMHX15cmTZrIbolFzMHBgWeeeYa8vDxOnz6tLosSQMKCEKLUy83NZevWrQwYMEBuPxSTWrVq8fLLLzNp0iR1SZQAEhaEEKXe8ePHCQwMxM/PT10SRcTCwoJ69erh7e0tm06VQBIWhBCl3vTp02natClubrJMd3GqXr06Xbp0YcWKFeqSMHMSFoQQpVp8fDzu7u7UqlXLbDaH0qfcZMt3b/DSuE9YEZz734KSypV13zPipf8wY0s4pW1kjZ2dHdWqVSM2NhaDQVZDLUnM45MjhBCF5OLFizz//PN4enqqS8XGmBNH8LH1bFm6lfVHov5bSAlj756f+XHLHs5cTkL34EGlhLe3NzVr1iQ4OFhdEmZMwoIQolS7efMmVatWNauVGjVYgKcX2Fpic+osYfceTwy+RkJoInhWRLHSYAmQepXNH4+iR5NGNHl2BJ+uvkASQOYVflq2mI/fG0n/7m1p3OQ5pq46TuL9hBF/gImfrefgrXRMBa9c/Nzd3alevTqhoaHqUpHQxp9gxfarJGX+vjOMeDwSFoQQpdqGDRuwsbHB1tZWXSo+JiMGlypUbl2f6m7nOXBTARK4fj6ZXJrTrp0/OqMF1sZrLPhsIT+HVuDljybyRisTexYs46c98WCVxqUVuzkVW4mOI97j/R4+HL4WzKXYfAASTm7gbEoKGktrszrR29vbU758eTIyMtSlIpF/eR2/hCSSbpBtyP8Oc3oPCSHEExcXF4ejo6P64WJmwogLfnUaU7GSDYcPh0HWbS5kZZDXtj1NvGzQ6/UYLKvQccibfPbFWwzp2ZeRw1+gqoOW21HpYGmBBeUJbP4C3Xp0o9+kMXSITCExOAFI5MTqTJoH1qamj3n92S0tLYmJiWHLli3q0hOWzIkFE+jxdAMCW43n57PJkPIbkz/bxpFPX2HgooPE5WSQcHQhg559mib1g3huyjYicg0k7J1Gv58vkK43ASaSDn9Fr/lnyCrDuyPI3hCizHFyciIyMtKs7mGXFnfu3KFnz54YDAY0muL/5mZpacnFixe5dOkSDRo0UJeLjTZyH1/OXMyRqsP5uNxNNh60o8cwR85su4bHC+2IXb+ds179WT29Dc6Z8URGRhF9+wKrl/3AvP2VeWf+HL5/+S5v9d+HR69XeW9gXRzI5eT0jzhWvTdDWiYy/q0LtP+/1xnS1g8z6lMBYOfOnXTt2pVGjRphNBrV5X8lIyODZatW0tziBK+uzqFD+9b4h63iP+caMHNaVzRr3mbcjfq8/+4EBtpt4cWPb/FMz3a0qKnlxDeLSR82h0n+u+k3JIspB96lhVsKO4b1YukzS1g5sBZPNW7Eg5fNSpUqsWPHjod+htJIwoIocyQsFJ4rV67Qvn17du7cSXZ2trpc5JydnenWrRt79uyhcePG6nKx0Ubu48sZCzkU+CGrW4axbPYSjqXXprZXc4ZN9mP55OVc9hvG6vfsWDF7Axcy3Gnbuh4eacf5anEMdYe/x7x+MYwdcJDyvV7h/wbUwQEwnJrBwFM+dDbsYUt2e8a/1o+2lc1nrMZ9mzZt4j//+Q+//vormZmZ6vK/otcbeKp1SxyvL+TZ4fNJfWokk7tUwdK3KR1a1cSwdhDdI/qwYlQ3AsolcGjzWQw+jiRsn820WWcJmLmbtcM92TlyDOcHzGNa3Qu81nwrXY7NpndlOw7s31/wWvn5+fTp06dsrAirCFHGODo6KklJSeqHxRNw6dIlpXLlyuqHi1XVqlWVc+fOqR8uVvkRe5Wp43oqT8+5rii5l5Uf32yi4NteGbMqQlHSDivvDRmpdP/0pBJ78ydl2NBhyltrIxRFyVYu/TRKqVf9JeWtFbcVJe+QMqbnZGXqiutKzv0n1t9UlnzQR6nr0kgZPv+4EqN9+HXNgcFgUNatW6eMGDFCXXqyTFol6fxWZeGPPykLpo1UWnf+UFlyIU4JWTZAafbpBuVmhkHJPvG90u/Db5QFS35R1uzcqHz3cjNl0LIrSrZRUdK2j1NqDlqtnNj0hlJ50Frlrs6ofgUlOztbsbW1VT9cKsmYBSFEqfbUU0+RlZX1UNdxcVNMeoy5OSi5BrD3J7BKMzqWr0CjllVAl48xJxdDlh7nwGfoUcvIyYmt8Wk9lLnh1tSw05J98zZpWXq0uXnk6x7oxrcKoG2ADXl+DalX2x9Pmwdf1TwYDAZsbGwIDAxUl54ghajNnzB+XRzVOw7ijXf70PDOTe5EJJOtM5CTp2ChsSTtxmGOZVfk6Z4D6dvag4yIFJIz8jAaodzTL9Mz+isGjjnF092a4GNVti+XchtClDlyG6LwXL58me7duxMV9cDaAcVs+vTpBAQE0K1bN7OZPqnoskhMSiHLxoca5W3JT0skNc2Ik18FXMgmNjYNrbU7VXwdyE+N4U5ULGm44Ovrhk1WPoqDG15eFiRGZ2Hl6kZ5N7t7o9VT2Dx4MIscX2LK1KE85W2tfulil5KSwtatW/H09KR79+7q8hNjijnKgpkz+GHHBVKSK9O67wg+mNyPoLRf6NNxMtd7zGDNkBzmjvmS32JzcekylOfvrmRJ9Rlc/PYl/OwNhCzqT/3xriwP/oG+fnaoR+Hk5OTg4eFBfv7vM1BKMwkLosyRsFB4zDEsbN++naioKPr370+5cuXU5dIjZifjXpvGvvQGvPvtRF5t7Y+j+upmBsLDw1m6dCn9+/enbt266vITZCQ3JYY7cSnk5NvjVaUyFTwcsTJlERt2hxR7X2r42pF99w6xGXlo3Cvia5NLisaTat4u2FhksW9IKyZWmc3eye1xt/rfv0wJCyWIyWQiOTkZo9FIbGwsaWlpf6u7sVq1atjb26PRaPD19VWXRSkkYaHwmGNYSEpKYtKkSXz00UeleyMpfSZ37ySQb+tGBR93HK3Ns9t8z549TJw4kQsXLqhL5iPzMB82foUZjn1YtfULXvR3/MN1BiQsmKH09HQiIyOJjY0lLCyM8PBwduzYgYeHB23atMHBwQE3Nzd8fHywtLRUH/6nrl69ikajITU1lXXr1mFjY8PAgQNxc3OjadOm+Pr64ufnh7Ozs/pQUUKYTKaH9gT4o7Cg1WrNa9GeEsocwwLAsGHDGDRoEO3atftb5wfxZOXm5rJ582bCwsKYMmWKumw+TDkkhMeQ4eBFlYrlsPnfTgWQsFD8FEUhOjqaS5cucfXqVVasWIG/vz/t2rXDx8eHqlWr4ujoiJOTEw4ODtjb22NhYYGVlRVWVlZ/a373/SkvJpOJjIwM8vLyyMrKIi0tjbS0NC5dukR4eDjnzp3jnXfeITAwkKCgICpXrqx+KmGm1qxZQ3p6Ov3798fZ2fmhsBAeHs5nn33Gl19+ibe3t/pQ8TeZa1jYsmULFy5cYNy4cXh4eKjLoogEBwfz3XffMW7cOOrXr68ulzgSFopBeno6586dY9++fZw/f57q1avz9NNP4+fnh4+PD+XKlcPOzg5ra2usra3/dij4O4xGI0ajEYPBgFarRavVkpKSQkJCAnfv3uXYsWNs27aNMWPG8NxzzxEUFGSGK8SJ+zIzM2nYsCGpqal89dVXjBs3jsOHD7Nw4UJ27txJ7969mTFjBjY2Zjh0vIQx17CgKApdunRh2rRpNG3aVF0WRUCn07F582Z+++03fvjhB3W5RJKwUESSk5M5deoUM2bMICMjg/79+9O0aVOqVKmCi4tLQTgwl25DvV6PwWAgLy+PhIQEoqKiOH36NBcvXqRChQr06dOHp556ymxGXIv/+vTTT/nyyy/RaDTk5uYSGBhIREQEWq2WkJAQatWqpT5E/APmGhYANm/ezPnz55kwYQJubm7qsihkoaGhfPHFF4wbN45GjRqpyyWShIVCZDAYuHz5Mj/++CMRERF07NiR1q1b4+/vT7ly5bCxsTGbcPBX7vc85Obmcvv2bXbv3s2ePXt4+umnGTlyJDVq1FAfIopJdnY2NWvWJD4+HgCNRoOiKIwYMYK5c+dKr8ITYs5hwWg0MmzYMAYMGECHDh2wsrJSNxGFJDs7mw0bNhAXF8cHH3ygLpdYEhYKQXp6Ovv372ft2rU4ODgwbNgw6tWrh5OTE9bW1g8NQCuJTCYTOp2O1NRULly4wPLly7l27RoLFiygTZs26uaiGHz++edMnz79oaVZpVfhyTLnsABw48YNxo0bx88//0ylSpXUZVFIjh49yrfffsvSpUtxd3dXl0ssCQtPUFZWFmvWrGHdunU0a9aMgQMHUqlSJRwcHEp8QPgzRqORnJwcQkNDWbt2LZcvX2bQoEG89NJLODk5qZuLIpKTk0O1atVITEwE4I033mD27NnSq/AEmXtYAFi8eDHnz5/nyy+/LN3rLpiJsLAwpk6dypgxY2jVqpW6XKKVpbBQaFfr/Px8Vq1aRa9evQgLC2Pu3Ll88sknBAQE4OTkVGqDAvd2unNxcaFJkyZMmzaN2bNnc+3aNfr168fevXvVzUURcXR0ZPz48djZ2QEwYcIECQpl0IgRI7C3t2fp0qVlYwOgYpSYmMj8+fNp06ZNqQsKZU2h9CxcvHiRWbNm4e7uzptvvkn16tXh3n3isspgMBAWFsZHH31EcnIyS5YsKfh7EUUnNzcXX19f+vfvz8yZM2VthSfMZDKh1WrNfpCvwWCgc+fOdOzYkXHjxhUESPHkZGZmMm/ePDIzM/n8889L5fm/LPUsPNGwkJGRwaeffsquXbtYsWIF9evXx9ra/NYmL046nY6DBw/y888/07x5c0aPHm32J9aS7M6dO+h0uoITlbW1NfPnz6dLly74+vo+dAIrX748rq6uDxwtSrPExEReeeUVOnXqxNtvvy3B8QnKyspi3rx5ZGRk8Nlnn5XanmQJC3+T0WjkxIkTzJ8/n6CgIEaPHi0n3b+Qnp7OzJkzuXXrFu+//z716tVTNxF/IScnh9TUVIKDg0lNTSUkJASj0ciPP/5IXFwciqLQt29f/P39HwoFiqL8z7ccjUbDkSNHOHfuHAA9evSgZs2auLm5ERgYiJeXF15eXlSrVu2h40TJlpiYSL9+/ejcuTPjx4+X21JPQHZ2NnPmzCE9Pb1gunJpJWHhb8jLy2PFihVs2rSJTz/9VBY8+RtMJhM7d+5k/fr1PPfcc/Tt21dOVn8iNzeXuLg4bt68SXBwMPPnz8dkMtGxY0caN26Mm5sbAQEB2NnZ4eXlhYuLCxqN5m+fqO5/HGJiYsjNzSUpKYmEhARCQkIICQlhzZo19O7dm2bNmtGoUSOqVKmCv7//HwaQUsWYS+j6/9DoUDdiFnThv8MC80k+uZr3e4Yz6Po4NJs+YVB4P2592ZaCPsW0Gyz/ZSHf5w3gwsTm/7Nz3x/Rhm/n0zHj+DwkiA8Wz+WLjoU3cyExMZG3336bpk2bMmLECFxcXNRNxGOKj4/ns88+w9HRkS+++KJ0fyYkLDy+1NRUZs2aRXBwMAsWLJCFTv6hiIgIpk+fjr+/P//5z39wcHBQNykz7l90DQYDsbGxXLhwgUOHDrF69WoaNmzIK6+8QkBAAH5+fnh7exfpbS5FUTAajYSGhhIZGcmNGzfYtWsX58+f54MPPqBNmzbUrFkTLy+vUhAeFEwmE4oCGo0FFkoeoesmEHSwG3GLuuFqNKJoLLC00ICiYFQ0WObFsG/FdIbefoXIr9phrSiY0EDKNZYtW8iM/EFc+lAdFhQUkwmTAmg0WFhYoMHArY2fs/CElqYjp9K3VuH/G+v1ej777DPu3r3LtGnT/ucWlXg0k8nE1atXmTp1Kr169aJ///6l9tbDg8pSWED5hxISEpSPP/5YmTJlipKVlaUui78pLS1Neemll5SBAwcqqamp6nKpZzKZFK1Wq4SHhyurV69WmjVrpjRo0ECZM2eOcvnyZSUvL099iFkwGo1KfHy8cuDAAeWTTz5RmjVrpgwfPlzZvn27kpSUpBiNRsVkMqkPM3MGJePGWuXdZyop1jZ+SsdJ+5Q4Q64Suup1RdP2DWVC/9oKts5Kvbc3Knf1WiX5xBJlsMcHysHkBOXQwlFKxfcPK/lKnHL0+wFKTRwU3wrPKh2HvKK0+Pqs8vDfhEHJDNmhfPJSQ0WDrVK1+Uhl4fEoJfbqGuWtjl4KWCqBfT5X9t41PnRUYVq7dq3SqlUrZcuWLYper1eXxR/Iy8tTFixYoDg7Oytnz55Vl0u17OxsxdbWVv1wqfSPol9iYiLz5s3D2tqaqVOnytoBT0C5cuXYsGEDVatW5csvvyQ5OVndpNRRFAVFUUhISGDz5s20b9+eoUOHYm1tzebNm7l06RJjx44lKCjIbEerW1hY4O3tzbPPPsvHH3/MyZMnee+99wgJCWHIkCGMHj2ao0ePkpGRgclkUh9unpQw1r09ics9NpGW+DNNV33C/GNpWCoKmmgbWn91AV3kJvpe+5JvDqVga2WB5n5/gcYCC1MmkYc3snC5K18lZhK+dwTV0+PQq2ZqG+4c4pvZP7Gz7hckK1nsesedw7M+ZbNVZyaPf4eJ73/ItC/fp2Olf3Sa+kf69OnDqlWrWLVqFRMnTiQuLq7k/LsVMYPBwLVr1xg1ahShoaHcuXNHbkOXYn/7U5icnMy8efOwsrLio48+UpfFv2BhYcEnn3yClZUV33zzDUlJSeompYKiKGi1Wm7cuMEnn3zC4MGDuXbtGmvWrOHo0aO8/PLLVKhQQX1YiWBpaUlAQAATJkxg06ZNvPHGG6xcuZLAwEAWL15MbGwsRqOxYGyEWcqOI+yGH13aBuLo+gyf3z7KJ0+Xw2BhhfVznXiukh04lMe/ki0Kqj+HBpS8DO7GxXCjaTc6lLfEoUIDWrcPQq/TP9BQITn6NnqtPT26t8EdawJaP0uFWp6cuBZFjpUGxaRAMfw9+fv7s3z5cpo2bUqfPn1Yv359yQp7hcxoNJKcnMzChQt56qmnGDx4MN99953chi7l/lZYyMzM5Ndff0Wj0TB58mR1WTwBGo2GTz/9tGArV6PRqG5SYimKQk5ODqdPn6ZXr14MGzaM9u3bs379eiZPnlzqtv22sbGhcePGLFy4kBs3bqDRaBg+fDjvvfceYWFh98YEFP3F8C9pLLC0NKIzmAAT+txscvX3LpTKf+OBovDHgxU1GiwsNFgadOgALC1xtHPAHXjwcqux0KBBQa83/P6AwYDJqGBpafHHz1uErK2t6devHxs3buTKlSu8/vrrHDlyhPz8/FL1mfw7DAYDSUlJrF69mhdffBGj0UhqairPPvusuqkohR47LOh0Onbt2sWBAwdK1UYg5sjS0pIffviBvLw8Nm7cqC6XSLm5uZw5c4ZBgwbx5ptvMnnyZM6cOUP79u1xdnZWNy913NzcGDlyJOvXr6d+/fqMGzeOiRMnFoQGs+JYkTpNk9m77yxRkXv59IVm9F8biaUFPNSRoCgo9y7rBRFCUdDYlcOvchXqX9rIr2fuEHPtGNt2nCTbxvqBE46G8v4BOLua2LVpN2Fp8ZzZf4Ckuzk829AfO70R0//2WxQ5Ly8vpk+fzpdffsm8efMYPHgwJ06cICcnB4PhXsgp5bRaLYmJiaxdu5aXXnqJ8PBw1qxZw7hx42RtijLkscKCoihcunSJH3/8kYULF5rt/ePSpGLFirz66qucOHGCkydPqsslhtFo5Pbt2wUn3AkTJnDhwgWeeuopddMywcnJiaFDh7Ju3Tpq1qzJ5MmTWbp0KUlJSebTy6CpTq8Z39Lu5Chq13uFzU2/YG7fGmisHHF3tvk9HmgssXV2xdFag8bKFmd3R6wtLLC2dcDFyQ3/lv14Z1IFdj7fgJb9N5FepTYe9g+fbiwqtGXCuFG8kjiLIPdaDF1p5Lm3JtG/qgM6jS2ODg7YPtYZqvBVr16dtWvX8u6777J9+3a6dOnCtm3buH37NlqtttT1NhgMBnJzc4mIiGDBggX07t27YOrwlClTZBOuMuixpk4mJiYydepUevfuLV1ORWzmzJnk5eXx+uuvU758eXXZrKWlpbF161a2bNlC79696dOnT5FOdSwJEhISmD17Nrdv32bUqFE0b95cVvQ0c4qicOfOnYK1ZT7++GMaN25Mw4YNsbGxwdbWtkROGzQajWi1WpKSkrh16xb79+/n+PHjDBw4kAEDBpTpKd1/pixNnfzLsKDX69myZQu//vorGzZsUJdFIcvOzmbcuHE899xz9O/fX102SwaDgeDgYH755RcSExOZNm0afn5+6mbiASdPnuSHH36gZs2avP766yV2gGdZYzAYOHDgABs2bCAyMpJ+/fpRt25dfH198fT0xMbGxmwDsqIo6HQ6tFotKSkp3Llzh/PnzzN9+nTeeOMNXn75ZZo1aybrTTyChIUHxMbGMnr0aGbPno2/v7+6LIrAli1buHDhAoMGDaJGjRrqslnJyclh3759bNmyheeee44BAwaom4g/kZqaysyZM4mOjuatt96iQYMGJfIbalmVlZXFsWPHWLlyJQcPHuStt96iSZMmVKxYEVdXV1xcXLC1tcXKygpLS0v14YVOr9cX/MrMzCQpKYnIyEhOnDjBkiVLmDBhAq1bt6ZVq1YyFuExSVi4R6fTsXHjRo4fP86cOXPUZVGExowZQ7t27ejbt6+6ZDbS09MLTpTTpk2jTp066ibiMWzZsoU9e/bQqVMnXnjhhRJ14tbpdCQmJpb5e9parZYLFy5w9uxZduzYQVhYGKNHj6ZWrVp4eHjg6OiIh4cHDg4OWFlZYWNjg6WlJVZWVmjurWT5d9xfs0RRFPR6fcHun0ajkezsbDIyMkhKSiIuLo67d+8yb948OnbsSMeOHWnUqBEBAQHFEmBKOgkL96SkpDB+/Hg++eQT2UCnmK1fv564uDj69OmDj4+PulzsUlJSWLp0KdeuXWP27Nmyvv6/dOHCBZYsWULz5s155ZVXSsyeIZcvX6Z79+5ERUWpS2VaXl4e4eHhBAcHc/LkSX777Td0Oh2dOnXCy8sLf39/HBwc8Pb2RlEU7OzssLOze2jQ6/3bAepTtkajIS8vj/z8fCwsLIiNjUWn03Hr1i1SUlLYvHkzgYGBNGzYkCZNmhAUFESVKlUkHDwBEhbuvSGvXbvGBx98wI4dO9TlQqQjMzaehNRM8gENCiaTHeW8vfEu74ytRdm8f5acnMyUKVPo168fbdu2VZeL1f2gEBISwuLFi9Vl8Q/duHGDJUuWEBQURL9+/UpED4OEhcen1WqJi4sjMTGRlJQU4uPjiYmJIS8vj+PHj3Pt2rWC8Q4ajQatVovBYMDW1vahC71er6dJkyY0b94cGxsbqlSpgqenJ5UrV6ZcuXJFvodKWSJh4d4becOGDeTn5zN8+HB1uRCFsOTVkXy69izZvp44WBjQZlWiSac+jJk8mA51vCmrEze7d+9O165dGTVqlLpUbCQoFK7r16+zZMkSGjZsSN++fc0+MEhYKDxnzpzh6tWrdOjQgSpVqqjLohiUpbDwpzfGdDodR48epVGjRupSITOgz2jF6K/2czM6iqioWBLS1tKHfSz5ZT+hab+3yUq4xZWLZzl1LpSYTC0mQMmJ50bIXeLj73DtwjnOXIogMUd/b2EXBUN2AuHnz3H27BnOXYkiRWsEFPQZ0Vy+cZfE+NtcPHuO89djSL+3Yp1i0pJ+N4QzZ89zMewusTG3CE/VPfwjF5HBgwfj4OBAWlqaulQsMjMzWbp0KTdu3JCgUEjq1q3L8OHDOXfuHJs3by518/nF41u3bh0jR47k4MGD6pIQhe5Pw4JWq+XkyZPUrl1bXSp8GhMGnYn/nhbLU7uOLQnaNNLyteTd2MPSL95h4MC+9Og1hvdnHyAiG/LPz+b5p19j8rdf8dZrA+je+XUm/HqBFD2Qc431M77gnd6v0v+Vl+nU5U0+WnOVTJOBuJ0f0rjRSL5e+A0j+vWmR88JfLYvEiN60oN38tUHo+n6yiAGvj+F90Z0pd/6uw/9uEUlICCAnJwcMjIy1KUip9Pp2L17N+fOnWPhwoXqsniC6taty8svv8z58+c5ffq0uizKgNOnT3P48GFMJhMHDx4kIiJC3USIQvWnYSEvL4/bt28Xw2qNFlhZZRIdcpZjR49z/NgxDm9dybrjjrSr14Qgj7usmfI9BzUDWHcsgsSb/8Fn+wpWH75FlsYBC2Mq6VWGs+V8COHzqrJl0SGuZenQ3jrBz8cq8J8r1wm9Fc3pibb8+MF2bugVLKwdUMhG02wK58JD2TfewOyvDxGhu8uhObPYVfNT4m5d5cSUFhCZgbN98QwM8vb2JjU1laysLHWpSCmKwuXLl9m0aRNfffWV3A8tAu3atSMoKIhff/2V69evq8uilNu8eTNnz54FYMOGDRw5ckTdRIhC9YdhQbm3bbCvr6+6VASssHW4w/ENX/P+qDd4443hvPb2NowvjmPM4Ja45d/m5PXyVHDJJ+ziEY5e1VClyhV+uxFGalY+xvId6Pl8DRwswLlmHfwyDOh0BqyD3mD3nndoYswmMeIyV7MUFEcbLOH3jW8qdqHfC7/PMihfsy6VkjJJTw3jzGYY0rclVljiWKU9L71cF72+eLqCra2tsba2LvZFUpKSkli5ciX9+/eXtTeK0MCBA0lPT2f9+vVotVp1WZRSp06d4sCBAwX/n5+fz969e6V3QRSpPw0LiqLQsWNHdakI6MjJaMDATzZw6vo1rl0PJTxiGzNHt6KCDZCbT7pDCNt++YIP3x3H2JHv80uEI3aO9lhZmDDZ2GFjpfl9/Xp7R2wtLbDQaDBm3mT9kuVs3LmLrat+4NOlxzGaHhjbaWuHjQWgscDW3gkbDSjZGSRl2mNvfe/irLHEytaqOHbNLfAn41GLjE6n48CBAyQnJ9O9e3d1WRSy6dOnk56eztGjR9UlUUpt3bq1oFfhvvXr18t7QBSpPwwLGo0GS0tLjh8/ri4VCY3GQH6ODr26wO8XdRenFoyZvZWjFy9x+fJFDqz9lcWDWuPrYPX7tr/3N/FTft8kT2OpELfjc0asvIuTfw2aDvyEX997DktLSwpmYipKQQhQFAVFY4G1Tw2aNM3k3PV4APQ5UYRcjcfSsni+2f/ZPOuiFBsby7Zt25gyZYq6JIqAv78/lSpV4tixY8TH//6+FKXX8ePH2blzJ+XKlcPNzY1q1arRtGlTDAYDGzZs4Pbt2+pDhCgUfxoWvL29uXXrlrpUBBQM6NErxj/entbtKUa+bEfs7iUs/GUtG1cuZNr495l/OJwMnR4LrQHT/YupyYA234BRMWG0daSWh47E+HjuXt3L8p1XsE+MJyXbiGLUQb4BkwZAQTEayM83YeVYnaffaMrNDYuYt2Ytv67fyYmbScV2G+B+1/PfXd3tSdFqtRw5coRKlSpRs2ZNdVkUkTFjxhATE8OZM2fUJVGKGAwGzpw5g6OjI3PmzKFDhw4MHz6c3bt3M3bsWKKiojh//rz6MCEKxZ9edWxsbPD19S2G+aMuVG/RgLqBXvzx3nuuNHvzQ4a2t+Pc2jl89t1p3Pt+yJhOgXhVrM/znepR0cn699sQTtV5vnNtvKxtqdp9IpPqRbFu5ld8uSuXdm9/yH/aumPKMuFQqSnduwRQDgALrMsH0rlTTVw1rgT1nsysZ/NZv2QZm2/ZUK1hTTwdi2eue3R0NLa2tsW2+1tGRgZr164t4nU3hJqdnR1Vq1YlKiqq2Ae7isKTnJxMixYt2LBhAwMHDiyYz+/h4cGsWbNYsWIFvr6+ZjE7SpR+f7ooU3Z2Np9//jl9+vQphrUWzINizCbuxiXOhCRjY2dBTkQwp6+m0mbyF7xYueh7F1auXIler+fFF1/Ezc1NXS5UiqJw5swZ3njjDS5duqQuiyIWGhrK8uXL6d27Nw0aNFCXi40sylR4Ro0aRfny5Zk2bZq6JIqJLMp0b+R9rVq1uHr1qrpURigoxixiL+zn57mz+G7mAlYcteCZdz6gezEEBYD9+/djZWVV5EGBe7cgrl27xsSJE9Wl4qekcG3bBlYs/pEfly7j11+Xs+znpSz5aTELV5wiMuv+wlylR61atYiMjCQ8PFxd+h/5+fmYTPcH8gghxN/3yLAQEBDAzz//rC6VERosbHxpOmQqm387xIH9O9my9j90rV3uz//SClFubi7p6enFEhR4YEXP+vXrq0vFT0kn9OAetq7bwKafv+D1oRP5atFy1m5Yy5ptV0nIN5S6sABQo0YN0tLSyM3NVZcASEtLY8uWLYSEhEhYEEL8K3963bOwsKBq1apkZGQQHBysLositnnzZtq0aUPjxo3VpSJxf3ObwMBAdan4WVTn5RmLWLt3Fzu2TKNV0/F8vXgdO3fu4+CaETTIuc76H+cza+Zy9l2KJceoACbSb+5jw6mznNryM3PnLWNXSBZKbjj7l8zlh0V7uZH+h/NxzEbLli2xsrIiOzv7ocfT0tLYtWsXH3/8Me+99x65ublYWVk91EYIIf6OPw0LAB4eHkyaNEnW/TcDhw4dwtPTs5gWyvp9w6i8vLxim4nx2LLyMelyyTQomADdrS18++PPrNi8j8O7NrLoqy/4+VQ0WgxE7fqUAW/NZfNvRzm8aRGT3pnCjHWHOHNiP+tnfca4WadIVT+/Gbk/uO3+IMe0tDR27tzJJ598wuDBg5k7dy7du3enTp066kOFEOJveeSZ39ramsaNGxMREcGdO3fUZVFENm/ejKurK82bN1eXioTJZCI7O5sOHTqoS2ZMgxXZnJ03nx15Lfh85Ro27lnM8MpX+PL7/YTnGrC0c8bGOoDu0xaxbuc0mv22gBW36/Lu4o1s/j6IEz+dxJzf9R4eHmRnZxMVFcXu3buZOnUqQ4cOZdasWSQnJ1OrVi3GjBmDq6ur+lAhhPhb/nQ2xH1arZaNGzdy/Phx5s6dqy6LQpafn8///d//0aZNG/r27asuFwmTycSVK1fYsWMHkyZNUpfNy90VdHj5Nq//NI5Xg+7wefW3yf1qEe+9VAsXK+DK11R4KZ9fzr+Dz8o+vJQ+kYvvt8XF+hpz6owle+k2JjZ3Rnd+JkEDYW3wOwSpX8NMZGRk8NNPP5GQkMC6dev+Z/nf+vXr0717dxwcHIpkzIKFhQXR0dEcOHCA0NBQdVn8SzIbwvzIbIgH2Nra8uyzz5Kdnc22bdvUZVHI5syZg7u7O+3atVOXipTRaCQ11Zw75f+IEb3h/lLd9x6ytMJaA5p7Qx6tbax+X8VTMaI3WWNzb3VOk9FA4V9e/528vDzy8/OpXLkyQ4YMoXHjxg9t6nX16lVu3LhBZGRkkfy6ffs2Op2OUaNGPfRzCiFKAeUxGI1G5eTJk8rrr7+uhIaGqsuikBw4cEDp3r27snv3bnWpSJlMJuXixYtKkyZN1CXzE7VcebbpJ8qqS8mKoqQrB0Z2VDpM3qCEZuoVRclQDn/6vOLdeYFyMTtbuTrnBaXWl0eVTL1JUUwXle8CnlW+OZOhKCaTknfqa6VmwPfKZfXzm5Fr164pX3zxhRISEqIoiqKcOHFCmTp1qtK4cWPF2tpaAZTVq1crBoNBfagogd544w3lo48+Uj8silF2drZia2urfrhU+sueBe51LzZo0IC2bduyYMECWTWuCNy6dYtNmzbRv39/nn/+eXW5SGk0Gtzc3EpG17JJT3Z2PjqTEQOutHxrEAFJ23jv7XcYP+JdFl7y5q23O1DL0RpFm02m1vj7BiIY0WZmozX+3uOgGLVkZekonv1FH09KSgouLi4FK3q2bNmSKVOmMGfOHCZPnkyDBg149913S8a/mxDCrD1WWACwt7enR48euLm58eWXX5aJezTFJTExkeXLl1O7dm26dOlSbHtRPMjZ2ZlGjRoRFxenLpkXt6aM/U8nmlRwwgKwr/cqU4d3p3EFexSH6nQdN5WxHarjgBU+bUbzUYdq2FpqgIo889FYnvWzAw1Y+3fgo0ntqaB+fjMSFhaGo6MjLi4uDz3eqlUrJk+ezPz58+nRowfJyckYDIaH2gghxN/xlwMc1RISEpgxYwZ2dna8//772Nv/8Q4O4p9JSEhg+fLlGI1GBgwYQKVKldRNikVeXh4//fQTNWvW5IUXXlCXRTHo1asXPXv2ZODAgepSAaPRSEpKCu7u7rLWQgknAxzNjwxwfARvb28mTJiAVqvlyy+/JC8vT91E/EP3g4LBYKB///5mExS4t7FYnTp12LRpk7okikFSUhLOzs5UrFhRXXqIpaUlXl5eEhSEEP/K3w4LAF5eXowfPx6DwcD06dNJTExUNxF/U3h4OAsWLCjoUahcubK6SbGytLSkZs2aBAcHk5KSoi6LIrZz506CgoJkwSUhRJH4R2GBez0Mb731FpaWlnz77bdcvnxZ3UQ8ptOnT7N48WLc3d3p37+/2QWF+zw8POjatSsbNmxQl0QRu3jxIpUrV8bb21tdEkKIJ+4fhwUAHx8fxo8fT82aNVm+fDmrV69WNxGPkJ+fz6xZs/juu+946qmnGDJkiNkGBQAHBwdefPFF9u7dKzNiitH69etxdnYutn1ChBBlz78KCwDu7u4MHDiQTp06cebMGT7++GNZGvoxhIWFMXv2bCIjIxk8eDA9evT4n1Ht5qhSpUq0bNlSBlkVk/T0dE6cOEHTpk2pXr26uiyEEIXiX4cF7k2rfOaZZxg5ciTu7u7Mnj2bX3755X92wxOQnZ3Nt99+y8SJE/Hz8+Pdd9+lW7duJWYAmoODAy+//DIRERHcvHlTXRaFbOnSpbi4uPDUU0+pS0KIIhAREfGnA/sVRSE7O7tUfmF+ImGBewPgAgMDef311+nSpQtRUVFMnTqVI0eOFMm69OYuNzeXtWvX8p///IecnBxee+01XnrpJbOa8fC4KlWqxMCBA/nss8/QarXqsigkhw8fJjIyko4dO+Lj46MuCyGKgKIodOnShZUrVz4UGtLT05kxYwZ9+/YtWCitNPnb6yw8DkVRiIuL4/Tp05w8eZLc3Fz69etHy5YtS8w36CdFq9Vy5MgR9u/fj6urK7Vr16Zly5Yl/mSfmZnJnDlzSElJ4fvvv1eXxRN2584dZsyYwVNPPUW/fv3Mf6tw8cTJOgvmQafT0alTJ0JCQmjZsiXbtm1j5syZbNu2jQsXLtCpUyd+/vln9WElXqGEhft0Oh3h4eFcvHiR0NBQkpOTad26Nd27d8fZ2VndvFTJzs5m8+bNHD58mNq1a1O7dm2CgoL+cl58SRITE8PMmTMJDAzktddeU5fFE6LT6fj4449xdXVlzJgxJWJsi3jyJCyYj3PnztGiRQuMRiMajQYPDw+Sk5Nxc3Pj4sWL+Pv7qw8p8Qo1LNyn0+mIjo7m+vXrhISEEBERQfny5enfvz+1atVSNy+xtFotN2/eZOPGjZw4cYK+ffvi4+NDkyZNqFChglks2/wkKYpCaGgoixYtomHDhgwaNEjdRPxL+fn5fP/992RmZjJ27NgSedtKPBkSFszH/YXz1q1bV/CYtbU1b7zxBnPmzHmobWlRJGHhvvtLz4aGhnL79m0uXrxIcnIyTz/9NM8//zxVqlQpcRdUg8HA7du3OXjwIMeOHaNGjRoEBATg6elJkyZNcHNzK3F/pr/DZDJx5coVli9fLoHhCcvPz2fGjBmkpaUxduxY/Pz81E1EGSJhwXwoisL58+dp3bo1Op0OAFdXV65evWrW09//jSINCw/Ky8sjKiqKW7ducffuXSIiIoiKiqJ+/fo8++yz1KlTxyxvVSiKQkZGBjdu3ODIkSOsX7+eHj16UK9ePdzd3fHz88PHx6dUDnD5M/cDw9KlS6latSrjx49XNxF/U2xsLLNmzQJg7NixpfYEJB6fhAXzotfrGThwIGvXrsXa2ppRo0Yxe/ZsdbNSo9jCwn0mk4nMzEySk5OJjo4mLS2NmJgY1q9fj5OTE127dqVu3bpUqVIFX19frK2t1U9RqO4P1rx+/Trnz5/n4sWLeHl5Ub9+fcqXL4+NjQ1169bFy8urTAUENZPJxM2bN/n5558xGo189tlnssnYP3Tjxg2WL1+Oi4sLAwYMkB4FARIWzI6iKFy8eJEWLVpga2vLzZs3S/VtwmIPC2parZb09HSio6PJzMwkKyuLxMREYmJi2LlzJ5UrV6Zhw4YEBgbi5uZGjRo1sLOzw83NDRsbG/XTPZbk5GSMRiPJyckkJiaSkJDA7du3WbJkCTY2NgwaNAgfHx/KlSuHp6cnXl5euLm54eLigp2dnfrpyixFUbh79y4rV67k5s2bvP/++9StW1fdTPwJRVHYtGkTu3bt4plnnqFr1664urqqm4kySsKC+dHpdIwZMwZ3d3e++uordblUMbuwoJaXl0dubi65ubkkJiaSnZ2NRqMhISGB7Oxs4uLiMBqN3Lhxg8uXL6PVajEajbRv357AwEAsLS2xtbVFr9djMpnQaDScOXOGixcvcv+P3rp1a6pWrYqDgwOVK1fG2toaT09P8vLycHd3p2LFijg4OODg4CDh4DGkpaWxf/9+Dh8+TOPGjRk0aFCR9wiVNMnJyfzwww9ERUUxbNgwmjRpIu818RAJC0UrMTGx4AvQ/eXtw8LCyMjIeKhddHQ0tra2eHt7F6wppNFo8PT0pGrVqiiKgpubGxUqVMDR0bHE9kCbfVhQUxQFo9FIfn4+er2evLy8glWzsrOzC/6xtFotJpMJKysr9u/fT+3atfHy8kKj0WBlZfXQxcvNzQ07OzusrKywt7cvCBhygfvn9Ho9ISEhrFu3jjt37vB///d/0svwBxRFYdu2bWzcuJGWLVvSuXNnKlWqJOsoiP8hYaFwpKamEhkZSUJCAsHBwZw8eZIzZ87QtWtXPDw88PDwoHz58mg0GpycnP6nt+/+Z/XBxQeNRiPx8fFw71x4584d8vLyuHHjBteuXaN169Y89dRTBAQEULVqVSpWrIitrW3B8eaoxIWFx2UymQp6DgIDA2nXrh2zZ8/G1tYWS0tLdXNRCBRFITk5mZMnT7J9+3ZsbW2ZMGECVatWVTctky5cuMDcuXOxtrbmtddeo169eiX2W4cofBIWnoz4+HiuXbvGmTNnWLp0KU8//TT169fH09MTf39/7OzsCnqXraysHvriaG1t/VhfIhVFKfjCqigK+fn5GAwG8vLySEtLIzc3F6PRSEREBJGRkZw8eZKsrCxGjx5N3bp1qVatGh4eHuqnLValNizct3XrVvr374+NjQ2nT5+mZs2a6iaikBkMBqKiojhy5AjHjh2jVq1avPbaa2b3YSgqd+7cYd68ecTFxTFgwAAaNGiAj49PqZ5iK/49CQv/XHBwMEePHuW7776jfv36vPDCC1SvXh0HBwd8fX1xcnLC2tq6ICgUNpPJhMFgID8/n/z8fDIyMkhKSiI1NZXQ0FB27dpFTk4OY8eO5emnnzaLQc6lPizUrl2b4OBgAF5//XXmzp1r9t09pZVWqyU2NpYTJ06wY8eOgi3OzeGDUNiMRiPnz59n8eLF6HQ6Bg8eTJ06dfD09CySk5Mo+SQs/D3h4eFs2bKFffv20bhxY1q3bo23tzfe3t6UK1cOe3t7s9p+4H5vRH5+Punp6cTGxnLr1i0OHz5McnIyXbp0oVu3blSoUEF9aJEo1WFh8+bNDBkyhMzMTLg3NkF6F4qfVqslOjqa8+fP8+OPP6LRaPj0008JCgoqddMtc3Jy2LJlCxs2bMDX15du3brRqFEjPDw8zOpEJcyfhIW/Fh8fz759+/jss89o06YNL774YsEieQ4ODtjY2JSYHjyTyUR+fj55eXlER0dz+fJlli1bhkaj4cMPP6RZs2Y4OTmpDys0pTosBAYGEhIS8tBjr732GvPnz5dvc2ZAr9eTkJBAWFgYBw8e5MqVKzRp0oSXX36Z2rVrl9ixJXl5eZw5c4Y1a9awZ88ePvjgA5o0aUKNGjVwcHCQkCD+EQkLfy4sLIxffvmFixcv0qVLF1q3bk2lSpVwcXHB2tq6xASEP2MymdDpdKSnpxMZGcnOnTu5cOEC3bp149VXX/2fQZeFodSGhY0bNzJ8+PCCaS7Ozs5kZ2djYWHBjRs3StWeFCWd0WgkLy+PxMRELl++zObNm4mJiaFDhw4888wz1K1b1yxX87zPZDKRkJDA1atX2blzJ2vXrmX8+PE0bdqUgIAA3N3dsbOzK/EnLFG8JCz8r4iICL755huSkpLo06cPLVu2pHz58tja2pbaz9v9Hoe7d+/y22+/sX37dpo0acLo0aPx9vZWN39iSm1YqFq1KgkJCXzyySdMmjSJXbt2sXz5cpYtW8bAgQNZsmSJfMMzM4qiFAz6SUtL49atW5w6dYqlS5dSoUIF+vbtS5MmTQgICMDV1bXYTgYmk4k7d+4QHh7OiRMn2L17N25ubvTu3ZuAgACqVKlSsEiYvMfEkyJh4b/u3LnDN998Q2xsLH369KF9+/aUL1++TH3eFEVBr9cTFxfHrl27OHToEM8//zz9+vUrlNsTpTIsbNmyhdu3b9OjRw+qV6+Ok5MTkZGRODk5cf36dZYuXcqYMWMIDAwstguO+GtGoxGdTkdOTg4xMTHExMQQEhLCggULMBqNPP/88zRp0oRKlSrh5+dHhQoVcHZ2fmJrFCiKwp07d8jJySE8PJyQkBCCg4NZt24dPXv25Omnn8bf359q1arh4+NTEA5K6u0TYd4kLPy+YuKSJUvYvXs33bp1o3v37nh6epbpz9z9L1mJiYksWLCA4OBgxowZQ7t27Z7o9a1UhgW9Xg+AlZVVwUIakZGReHp6Fsx5tbGxKdNvsJJGubcYl9FoRKvVkpOTQ2JiIlFRUcTFxREfH8/p06c5efIkaWlpjBw5Em9vbwwGAwEBAY/c/VOj0RASEkJaWhoAISEhbN++HUtLSwYNGoSbmxtNmjTB3t4ef39/KlWqVLCwl6WlJRYWFn/63EI8KWU9LISGhvL1119jb2/P+PHjqVatmnzuVO7Puvr666+pVasWb731Fr6+vupm/0ipDAtqD4YFUXooioLJZCr49WCYSEpKwmAwYGFhQVhYGHq9/pEnFg8Pj4L3h52dXcG9v/ujpy0tLdFoNBIMRLEpq2FBp9Px888/c/ToUQYPHkz79u1lgPojKIpCTk4OK1eu5OTJk7z22ms8/fTT//q8JWFBlEoPvq0fXIb1z2g0moc+TP/2gyXEk1YWw0JSUhLffPMN6enpTJw4UVZ//ZvOnDnDtGnT6N69O4MGDfpXU9OfzM1dIczM/Yv//V6Bv/p1v8dAHRqEEMUjJCSEKVOm4OnpycyZMyUo/APNmzdn6dKl/Pbbb3z++eekpKSomzw2CQtCCCHMSnBwMAsXLqRZs2a89957smfKv+Dp6cnSpUuxtbVl9uzZJCYmqps8FgkLosw5cOBAwaqeQgjzEhoayuLFi6lXrx7Dhg1Tl8U/YGtry0cffYSNjQ3z5s0jKSlJ3eQvSVgQZc7777/PsmXLCmbNCCHMQ2hoKIsWLaJOnToMHz5cXRb/0qRJk7C2tmbu3Ll/OzBIWBBlyunTp0lMTOSTTz75V/fvhBBPVmRkJMuXLy/YlVYUjo8++oj09HQ2b95Mdna2uvynJCyIMmXq1KnExMSQnJzMmjVrMBgM6iZCiCKWkZHBihUryM7OZuTIkeqyeMK+/PJLduzYwaFDhx77HChhQZQZp06d4ubNmwVTKadNm0Z0dLS6mRCiiO3YsYOwsDCmTJmiLolCYG9vz/fff8/MmTO5du2auvyHJCyIMuPTTz8lOjq6YGpkSkoKCxYseOxkLYR48i5evMiFCxcYO3Ys5cqVU5dFIalWrRpDhgxh27ZtpKamqsv/Q8KCKBPOnTtHREQERqMRb29v7OzsAPjqq6+IiopSNxdCFIGcnBwOHz6MwWCgWbNm6rIoZIMHD+bs2bNcvnz5Lxevk7AgyoTp06cTFRVF7dq1adWqFePHjy8IDTNmzJCZEUIUgwsXLnD9+nU++OADdUkUkYkTJ7Jp06a/nB0hYUGUerGxseTk5DB79myuXr3KyJEjadq0KREREWzcuJFLly6RnJysPkwIUYgyMjK4fPkyVapUwcfHR10WRaRly5ZERUVx+fJljEajulxAwoIo9fR6PTt37uS1117D0tISg8GAyWTCysqKzp07c/To0X+1ZroQ4u+LjIwkMjKSV199VV0SReytt97ixIkTZGVlqUsFJCyIUs/f3/8vd6mTgVVCFK2LFy9y5swZqlWrpi4VAiN5KXHERMWRnqvnwbvzpvwMYqPvEpOeh+mR2yoq6LKSiMvSqQslXocOHZg3bx4JCQnqUgEJC0IIIYpURkYGVlZWjBgxQl0qJPFsH/os9fyDeHPlZVIfuN7HbnybxrX8qD51L/F5f94NDzlcmvsiTede4lGtSqp+/foRERHxp+O3JCwIIYQoUunp6SQkJFCvXj11qZBYYOVgjTPpnLp6m5Sc+9Ol73Bk81WMBnC2s7p3QTSSlxZLaEgIwTeDuZWQic4IoMHSxgEnG0sATPpskqPCuBkcTEjoXZJz9NzvmFAMeaTG3uLmzVBu3U0l/17BpMshOTqcGzfDiIhN535mMemySYqJ4MaNG4TcukNCpq7guYpKu3btiI2NlbAghBDCPKSkpBAREUGNGjXUpUKiYNC507RDY/THrnA9LgMDwJ1jrLtblVZNvXGwtUCx0KAL28v86WN55rkOtH+6Ka2GT2PjjfSHbl0oxhQur5vBB0N70L5de9q1fJm3v97PHQNgyiXh7HL+M7QLTVu355mXJrPkagaQReSRRYzt35HGLTrQacBXrAnLBUMywXvm89brfWjR8ilaPd+N4bO2E5z+wAsWgXr16nHz5k10uj++zSJhQQghRJGKj4/n2LFjODs7q0uFRMGkB/dOfRhuHcrN67FkA1EH9hH9Uhe61C6Pg4UGC8tcbu7+mU02I7kSFkV8ynkmaVbw7qZr6AoGNCiYsm6wa845/L+4SELCXcK29yb+q2/ZFq5HyQln+9w5nG+1lNSk66wYZuKXlWeISb7CpsWriHtpM7kJR/m8cxYr1l0kMeUmB44F4zFoA5kZGZxd8ApWJxcw63TRztByc3MjJibmTxepk7AghBCiSCmK8peDjp84xYDOMpD2g6w4Gnyb1OxgDmxK46XGdfC1twHFhFFnT4O31nB0ejtsdRnE304Aa1scbH+/9fA7DZbl2vDhyS1MrK8nPSmW2zEG7DV22FgY0aVFEnLEnhe7NsbW0o22Y+dz+qt2WEWEE3XRlW7P18XCzp9e781lz4et8fJuw1tfLmJ2L08y0mJISczG1sEeG6vfV5otKu7u7uzcuZPc3Fx1CSQsCCGEKBsUjDo7Atu/gHLiBuf3b2ZVfHOaBFTA3kaDAmgsjORGHGDl8g1s3bGexVM+5LtDMRhUixsqulRubP6FnzdsZdvqBUwZP5cz1lZYKiaMGWkkZpSngpvNA0fo0aVnkpbtiW85qwceByUvnpvHNvHLyg1s+OUHvv/+R3be1mFvVbSXZxsbGywtLVGUPx4tUbQ/jRBCCHGvd6GoKUYDBLRlmPVpln22jNCODajt44gNCmCBpVUcO96bwE/hCj4VGzFg5hI+61AJaysN//2er6CL2MQ7g9aS7FmNwJbDmb11Ks11RhRLa2x8q1A74A7HLscDJvITb3Ppagoav8pU9Y/gxNUUwEBm7G2uhURz5+pefvl8DsdNVWjz4jDe++RDXqlmRZ6xaP9+8vPzcXJywtLywV6U/5KwIIQQokjZ2tri4uKifrgQKRh1OvR6PXqq8sygcpy7ZkOPRjXxsrHGqNOi1RtRFAOK3gsvowG9MZ87B9ew4WgCKbEZ5CpgMujQGkygV9BX9caozSc/I5y9P2/hpGMWSek6rJyr06R3TW5sWcrKLRtZ8OlHjPjoINm+dWnQqQIXNy1lzabVzPxoCu98c5gkC3scDG64KjrSY0I4vXs3hy9nkpuVp/5DFKrk5GSee+65P12gTsKCEEKIIlWpUqWCqXpFww7fJi1oUMMTGwW8W73MS/1G82KTCthhhXtgS9rU9MSK6vScM47qpxbywVuT+CW6PmO+m0AQ+aSZLHCt2ow2VcthW7c3s8e7sGHKBN6ZuAdD1zf5ZkQVctKzwLYSbYd9zDifU0yf9C3bcp5lzvLBBLpU5/mhExhgu5ePPlrIOecufDt3AM0aPUP3YfW59eU43vpmLznNBzN6RCdcMtPQqv8YhSg1NZWqVav+6VgSjVIcfUFFzMnJicjISDw9PdUlUQbt2LGD3NxcXnrppT/9YAhhbkaNGkX58uWZNm2aulTiREdHs2HDBpo3b07Lli3VZVEMli5dirW1Nb169frD3gXpWRBljqIoaDRFO9JYCPFfbm5ueHp6curUKXVJFJOtW7dSoUIFbGweHJj5XxIWRJnj6OhIWlpasQywEkL8/hl0dXXlwoUL6pIoBtnZ2dy6dYuqVavKAEch7vPz8yMkJOSR27EKIQpX9erVKV++PMeOHVOXRBFbtWoVo0ePxsvLS10qIGFBlDnW1tZYWT0811kIUbSqV69Oo0aN2Lx5s7okitjevXupX7/+H45VuE/Cgihz5PaDEMXPxsaGOnXqkJ2dLbcjitGSJUuoUqUKderUwcLizyPBn1eEEEKIQhQUFESHDh3YtGkTJpNqmURR6LKzs9m8eTOvvvoq7u7u6vJDJCwIIYQoFtbW1jRt2hRFUfj111/VZVHIPv74Yzp27EhAQIC69D8kLAghhCg2VatWpX379hw5coRLly6py6KQbNq0icuXL9O1a1ecnJzU5f8hYUGUSba2trLWghBmok2bNnTo0IENGzYQHR2tLosn7Pz586xcuZKvvvqKatWqqct/SFZwFGVOVFQUr776Km3atCmyFRz1ej1BQUH0799fXYKsSA5fiSLLrR7d6jx43zCZS2svke5RGT/vBKKynKhWvxF+Tg+EnITzLL+i0KhhXeqV//ORzAWUbCJObWXNnlj8ug+kdyMfbOQrQ4lQmlZw/CPJycmsWrWKnJwcRowYIefrQhITE8PHH39Mly5d6NatG7a2tuomf0hOE6LMKVeuHO3atSM9PZ2kpKQi+ZWYmEhGRob6R/ldynW2bN7Er6cSVQUFk9EEVgZijv7Kr1v2E5ymyvbRh5i9fB+norIffvzPaKLZ8p9VHLudTLbOBKX+q4IoKTw9PenZsyeKorBs2TKSkpLUTcS/FBUVxaJFi2jUqBHPPffcYwcFpGdBiKKmIyX0OFvW7iXcriE9+velheYQ78/bzDl9dV6tmMhNbSDde71M+2pGQvbcIMfbE/35H1gdXYUeI8bxjE8Uh5euYc9lC6p5BfNZeABTJgxjaJDHA6+Tx+0j61m55yKJSn1eHNqDZ2tZcmXW27z+3kV8B3/I9C97Ud/DWr4xlBClvWfhvqioKFasWIGdnR0DBw585EJB4vGFhYXxyy+/4O3tzcCBA3Fzc1M3eSQ5TwhRhLJvH2XDwoVsD4nlzpGN/PTdKq5mWWGfmkh8SCQJuTlEHVnHijV7iMiK5cwv61i/8QopGissNJbYWKZwfcky1u24QnJ+OpHBoaSnZWNh8eD4Cz13t85k1rKDhGeZUFJOMf+dpRy6nY4eS6w1RnIzM8nVyQqWwvz4+fkxcOBAtFotixcv5vbt2+om4m86duwYixYtwtfX9x8FBSQsCFGUcoi5cJaLlx3o9ukSFn45nl7NfLDW69BbuVK5RS/GfzCTL/rVxz7uMsHJJhwsHbDTWGOhAY2lFZYJZ1mxLwn3l9/lu0XTeLvPU3g7WWE0PdhBGM6Wrw6QVW0gX3w5k7kL36RFxm42n9JSb8zrtLLrwOjp/WjqaycnAGGW/Pz86N+/Pw4ODvz000+cPXtW3UQ8BpPJxLJly1i/fj2NGjVi0KBB/ygoIGFBiKKkJy9TwUbjQ1VPS5zqtKTTKx0IdAatmzvulX1wBCztbXBwssFSoxpSoNFgTEvgjltF3H3L4wyUr1uHSh7lsHxwQRtdEndiKhJUryrODgB1eeZZEynZaejTszGgIyfLIMMVhFnz9/dn2LBhBAUFMWvWLGbNmkVOTo66mfgTcXFxfP3115w9e5bu3bvTq1cvXFxc1M0em4QFIYqMDQ5uGnTKXULjTOSHHmTV0uXsi8zD1uL3bwHcW476D0cSKQqWnhWpmXKbO6ExJAGJN0JIScmEB5dptfGlRtUozl4IISMb4CLbt1vi7VIOW2uLP35uIcxQuXLl6NWrF7169SI4OJjZs2dz+fJldTOhsmPHDubOnYvBYGDMmDF06NDhbw1m/CMSFoQoMg5UbtqGVk8Z2TqhE13enMa6G1oc7TQoubko2t/HEJh0eeTm5aM3GtGTSz569Pm55GRnk+/WjCH962F1YDqjerzBJz/tJyIpi4fuQlCNnh/3wT9uOW++1peePWdzM6AHL7X0x9bSQA7ZaE2K9CyIEsHKyoqePXsyceJEPD09Wbx4MXPnziUxUT17SAQHB/PJJ5+wb98+GjRowNixYwkMDFQ3+0dkNoQQRUpPxp3LHN53hBD8aPlcF572zeT01ShyXAN4tqYrWRHnuZlsSYXaVdCfDSfNxQsvpziic5zwC6xLBYdUgvft4rdLOrxrupPhXIXWjQKp6f7gNwct0Rf3s+t4MClKTZ55sS2N/cphbYjh+IoIvLo1pbqnjFkoScrKbIhHyc3N5eTJk1y6dImEhAQaNWpEt27dcHZ2VjctU+Lj45kxYwbZ2dnUrVuXVq1aUa9evSe6u66EBSGEKAEkLPxXamoqv/32G9euXSMlJYWWLVvStWvXMhca7ty5w7p168jMzMTW1pZmzZrRtm1b7Ozs1E3/NQkLQghRAkhY+F93797l2LFjpKamcuLECRo2bMiQIUNK9doMRqORiIgI5s+fT3JyMk899RR16tShSZMmhRqWJCwIUUJlZ2dz8OBBGjVqROXKldVlUcpIWPhjiqKQkpLCwYMHiYuLIzw8HFdXVzp27Ejz5s2xt3+MZdBLgJSUFPbu3cvZs2dxd3fHw8OD6tWr06pVq8faCOrfkrAgRAmVkpLC/Pnz6dGjB0FBQeqyKGUkLPy1tLQ0bty4QXR0NKmpqWzbto3AwEB69uxJs2bNCqV7vjClpqZy6tQpDh48CED16tUpX748tWvXplq1akUahCQsCFFCpaamsnjxYrp27Uq9evXUZVHKSFh4fHq9nsTERM6ePUtqaipZWVlcv34de3t72rdvT4MGDfDz83uiAwCfhNzcXEJCQrhw4QJnz57F1taWhg0b4urqSuXKlalatSpubm5YWlqqDy10EhaEKKEkLJQtEhb+mfz8fBITE4mOjiYuLo68vDwSExPZtGkT9erVo127dlSsWJEaNWrg7e2NxYNrlhQig8FAbGwsoaGhhIWFcfz4cRISEujcuTPe3t64ubnh5eWFv78/bm5uxR5sJCwIUUJJWChbJCz8e0ajkYyMDNLS0ggPDyc7OxuDwUBiYiL5+fls3LiRvLw8Bg0ahKenJ1WrVsXCwoJatWqh0fy+/0r58uXVT/s/TCYTycnJcG9sUWxsLDqdjjt37hAZGcnatWvx9fXlxRdfpFy5cri4uGBlZYWjoyPVqlXDw8OjUAcr/hMSFoQooSQslC0SFp48g8FAbm4u2dnZ5OXlERERQUpKCuXKlSMnJ4f8/Hzy8vKIj4/n/qVyzZo1j+x9sLS0pE6dOtSpUwej0YiFhQUVKlTAzs4Oe3t77O3tycvLo1y5clSpUgUnJyccHR2xs7MrCCTmSMKCECWUhIWyRcJC0dHr9eh0OvLz8zEajWRlZRXUIiMjC4LDH9FoNLi5uVGuXDkURcHCwgInJycsLS2xtbXF1ta22G8p/BMSFoQooSQslC0SFkRx+vO+FCGEEEIICQtCCCGE+CsSFoQQQgjxSBIWhBBCCPFIEhaEEEII8UgSFoQQQgjxSBIWhBBCCPFIEhaEEEII8UgSFoQQQgjxSBIWhBBCCPFIEhaEKKE0Go1ZbzwjhCg9ZG8IIcxUTk4OKSkpBdvdJiQkYDAYCkJCTk4OFy5coFatWvj6+mI0GuHe9riVK1emXLlyAFSsWBE7OzvVs4uSRvaGEMVJwoIQxchgMJCWlkZERAShoaHEx8dz6dIlDhw4gEaj4bnnnqNixYo4Ozvj5+eHvb39QzvemUym/+lhsLKy4sqVK+Tk5KDValm5ciXJycn079+fihUr0rRpUypWrIiXlxfVq1d/5Ha7wnxIWBDFScKCEEUoNzeXmzdvcunSJX777TeuX7+On58fTz/9NFWqVKFixYr4+vri5uaGvb19QRBQB4K/YjKZAFAUBaPRiIWFBXfu3CErK4vo6GhCQkKIiorixx9/pF+/fjRt2pRGjRpRt27dgh4JYV4kLIjiJGFBiEJkNBqJiYnh5MmTLF++nAsXLvDGG2/QoEEDqlevTtWqVXFwcCjY9/6+vxMMHtf9j7qiKAW/N5lMREREcOPGDUJDQ9myZQve3t506NCBp59+mgYNGqieRRQXCQuiOElYEOIJMxqNxMbGcuTIETZs2IBer2fAgAHUrVuXqlWr4uTkVHCxLoxQ8E88GCRiYmI4e/Ysu3fv5pdffmH69Ol06tSJ+vXrqw8TRUjCgihOEhaEeAJMJhPp6ekcOXKElStXkp2dzZAhQ2jRogVVqlRRNy8RFEUhJSWFc+fOsX79eoKDgxkyZAjdunXDx8cHzCjslAUSFkRxkrAgxL9gMBi4e/cu69atY+vWrbz44ot07dqVgIAALC0t1c1LLEVRuHv3Lnv27GHJkiU8//zzdOvWjaZNm4KEhiIhYUEUJxkGLcQ/oNfruXXrFpMnT6Zx48ZUq1aNHTt28H//93/UqVOnVAUF7oUBPz8/RowYwYEDB2jbti3Tpk1j0KBBXLhwAZPJ9NAsDSFE6SJhQYi/wWg0EhcXx6effkrjxo1p0qQJCQkJ9O7dG1dXV3XzUsnBwYEOHTqwceNGBg8ezNSpUxk+fDghISEFszCEEKWLhAUhHlNWVhZLliyhb9++1KlTh+TkZHr37o2NjY26aZlgZWXF888/z8aNG3nllVeYOHEiX375JdHR0dLLIEQpI2FBiL+g1Wo5d+4cb731FmFhYaxfv55XX30Va2trddMyydramk6dOrF8+XIcHR1p1qwZhw8fLlhRUghR8klYEOIRsrKyWLZsGR06dGD48OF8/fXXeHt7q5uJewOJ3377bU6fPs3GjRv56KOPiI2NVTcTQpRAEhaE+AP3R/9PnjyZ0NBQYmJiaNu2rbqZ+AN+fn588cUXVK5cmVGjRnH+/HkZyyBECSdhQQgVRVG4cOEC48ePp1mzZnzzzTc4OTmpm4lHcHR0ZPTo0YwbN47333+f9evXq5sIIUoQCQtCPEBRFM6dO8eECRN4//33GTBggLqJeEz3N8KaM2cOhw8f5tdff5WBj0KUUBIWhLjnflD4v//7P3744QeaN2+ubiL+gdq1a/POO+9w/PhxVq9eLYFBiBJIwoIQ95w9e5b33nuPefPmUbduXXVZ/As1atRg3LhxnDhxgjVr1qjLQggzJ2FBCCA0NJR3332XuXPnSlAoJLVq1eLNN9/kxIkTbNq0SV0WQpgxCQuizEtKSuLzzz/nww8/pE6dOuqyeIJq165Nz549Wb16NWfPnlWXhRBmSsKCKNMURWHOnDnUr1+fF154QTZEKgLPPPMMffr0YcGCBSQlJanLQggzJGFBlGlHjhwpWJ3RwkI+DkWlY8eONG/enF9//VVdEkKYITk7ijIrPz+fb7/9lk8++USWbi5irq6uNGzYkLCwME6fPq0uCyHMjIQFUWYtWrSIoKAgGjZsKLcfikGzZs0ICgpi1apV6pIQwsxIWBBlkl6vZ8WKFQwZMgQrKyt1WRQBCwsLWrVqhZeXF8ePH1eXhRBmRMKCKJOOHDlC8+bN8fPzk16FYlSzZk1cXFzYs2ePuiSEMCMSFkSZtHz5cgYMGICNjY26ZAZyibsaSuj1BPLUpVLGxsaGGjVqkJ+fT2pqqrosHlCvXj1q1aqlfliIIqFRysDaq05OTkRGRuLp6akulWjGvARuJ1jg6+OOk52luiz+hFarpVKlSly9ehUfHx912QyEsmzoAs7bt2Lc/N5UV5dLmZiYGLZv30716tV57rnn1GUhhBmQnoUSTHtzNZ+vP83tFL26JB4hNDSUfv364erqqi6ZCQtsNQ44WNjwewTUk37nIns2r+Sn5bs4GZ7ye4+DNp7zVy5z/NB21q7YzbnIGG6fusTVk4dYt341vyz9meXnIknX3/8+kMWtvacIS8zFaEZfEdzd3cnKyuLMmTPqUimgJ+tuCCe3XCE2M4HbF08RnKbarjs/hZDgq5y4k0FuUgiXz57lVoZs6S3Mi4SFEkFLwvXDbFrxI/N/2cPF6BwwxbF/3XZ+2/cr6y7eIlOvRxd/lV2rV7Bk0SJW/hZCqt5EbuRJtlyNI9fw+9VBG3uGTReiyTOnq0URCw4OplGjRlhamntvjAZLIOvqTpbP+ZbvFvzEovlz+OLLNRwLyYWMs3w9cToffzWXn37ew+XYUPZNnsgn02cx75dVrPpxGiMm/Mr52Ozfny7zCFNG/8ChiEwM6pcqRvb29uj1eq5cuaIulQJ6smMiuHQgmDuRJ1n/7VRWBKvCfeo11i/7gWnbwsnLjCL4yhXuZJXdz6cwTxIWSgBT1AEW/bSYRWs2sm7BN/xnzk4uhd3iWmQGGVdPcDw4lozokyz8YSkLlm1g6841zP/ia9ZeiCMrbCOTPtzEzXQdkM/NnyYxaUso2WU4LMTFxeHp6Wn+izBpLLEhnoOLN3AipTUf/3yQ0ye+5yXNRfbsPEmizhrHOGtq9/yc5ftn8FqrQDwcM9HXG8SiZVvZc/wgcz2iCYtIJgfIPLqbS8++QItabtia2ZhOLy8v3Nzc1A+XLIqBzOizbJ43l/lLVrHzWipgh2vVurR7pTE+VlbYOTlilxPB1b1bWb75PLF6wNIaCwcHFGtrnCrWo+nTTxNgk8CVy6fZefAAO9b+yIJ1B7gaf28EizGZmwc38tOsX9m9/zd2ngomPLm0j24Rxa1MjFkoV64c77//Ps7OziVqe9z8fC0v9u5Jpbur6PzNFWr3mcC71a4z64gDLw7uS9Mr4+l1vQNfDu1Jc2U/78+KoF3/F6innGHesIncGLiMFSNcWdnzO5TpXzCqwV2+aPkpzvN/ZGzz8iyePx+9wZy+YxY+S0tLjh49ytixY2nZsqWZBoZw1gz7mcvObXjna1+W9f+CPdmePNOzHh62BqK2LWB/xRHMHFqJRR+do/boYYx5sSYOxLCm+xgudX2Xt4a2oYIdxP06hglZr/L9sJpcHDGUzc9/wVe9G+BmY15p4eTJk6xcuZKKFSvi4uKCyVRyuuEVRcHFxYmhfdqw8f33WXzNgF25XHKcWvH2Z29R99JKPvwgkVfXtSP4s885XXc4LxjOsHK3jrZDRzPhZSOLFq3hcMWBLKj+G/NWh1Ot2/PEbvqZDXfdaF89iTOXdTTu+w4fjn4G9i9h1tzNXM7ypU7FWDZkNeTdD8bzztO+6h9NiCemTISFd999lzt37qgfNnvZ2dm8P3ESzzxVifXfTOfnW840C6yAfbm6tH/xGXyOjmfgzTZ8/cYrtLC+yvqDwWj1+STdPMXOtb/hOH45S954iryVQxgQPoifOp2mz/85MX/raJq72zBgwAC0Wq36ZUu9zMxMvvnmG4KCgsxk2qRCdtRlrsXk4VanJQGuEax7bQmXHJ7mnenuzBkxlV+v51C3vjeWegUbezvcnx3Oey1TmPzuNRq9NYjRnathSzSru71DyMvv8sbAFvjYAHGreWlCDpM+cGDmsNN0WzKJXg3LY25zQM6fP893331HWloaTk5OJSrUm0wKXt7lmPvJQKa2eZPrI2bxaSc7rqzehX7A2zwXvplP30vi5Q1NOfPRdE61m8fOt2tyZdVMZixJp8fXL3Nn70b2eQ9gUeApftx4m6rPtyds8wbO+Axi7eT2xC/9P2ZecqbHa88SMmsNkXV6Mend9rBzCj1WGOj31luMb2mOg3VFaVEmwkJJlxl+nBNRCh5+1aiYvomh/XZSe/KnDLNewOjQ9sx+ewDV9w2myd4gvnm9B+2CLNj/2gA2tfmWea+3oXzKWl4auh0X+1vcfOZ79r7ZDDcbc/xGXTSmTJlCx44dadmypdmMW4jeMZXxCy9T5c2f+LZTNPNeXcw1nx589q0fq0fP4Ubl7rw78QWqWkHClXPE2lYiyPEsQ147R5O3hzC6SzXs7oeFnhN4Y1DL38MCsWwd/i27cy+zzeE1dnzbiyB3W/XLF7uDBw9y/fp1Ro0aVWKX3jbmx3FmzQLmbLhNpWeexk/R4N+pIwHhe/n2/UReWtuMqIXLyBu7incCIfnsCn5auhvLzsOxvbmb3eX7/zcsdGhD8NkzxNQaxi/9qnF77ccsvO7Ms89UYdvmUNzbvcqnPatB7GaGzLpL8269GNOmgvpHEuKJKbtXjBLElHSJjcsX8P0PC1m2O4XAxk15qqYXXv7VcDm2hoUbjxLtWo26aZc4vGUVy9du5+TtaM6GxpOpNUKFF/ig1R3Wb7Wmd4tqOFmX7X92b29vkpKSzOrbq1fdp2lWxYYzSz7knfEL2Gd0psaz1XC1rEWP3kFUSFjPlx99zJSPpvDZ5wvYfimKLIMBbW4+OsP9LnsT+txc8nUG/tuJX4HnX3Ni685ImrUKwM/J/IICQFRUFNeuXTOb8Pb3GTHkZJJvCuLNGZ8ztkNFci4sZcLMM2TbWWEBWFhqyLh7m4OrDhCdl05SdAzhd32p6mOL0fQH70WTCZPRCPdudZhMChauHlTMSSEnLoF0IDs8nOikVIyWZfszLQqfvMNKgHItX+fjUd2paxXH5et66gx/lU4tKlOhaV/eejYAJ20eDo0H8/5zVbBICCc8tzJd33uPYW2r4WgN4IqHoyNe3V/lhUBXrMyh570Y1apVi7S0NLO6L25TpT0jxoykfz1L4jI96Dh4AEO7VccSDZWeH8jgIc9TVZNA6C0dNV4azWsvNqecVwA9Bz9Ly1pu/L5gtSv1BvbjmSaVcX7gmqvJzcbJrysvN62Co7ndf7gnOTkZvV5vpmNIHo8hN46Lmxbw/fRZLNt6huhKHenZoiJW+jxy0aI3GcjPSCLq/D5+/n4GX21Jo0LnV+jgZ4E2Jw90RowGHdq8fHQGPeTno+h+f4+adPnk5eSgdW9Ar7a+GA8sZNLbnzNj2X5uJmdjsijjH2pR6OQ2RGmnj2D3tzP4fm0wzWf8yEdt/bAruefjJ+LGjRt8/fXX/PDDDzg4OKjLpUgSZ36azw9bD5PW5gNmj3oGfyfz2wcjJyeHZcuWodFoGDVqlLpcguhJjzjK+jkrOaFzp9LT/XinXwO4eYHfdudQZ0BlMk6fIatqXXSnj3DC2IgRI9vglxPFb2euEenaiJfLR3H2eipu1auSdDeKDI8m9G3oQeqVfZyOs6TKU89Su1wiF9dvYMepLJxMF5mfUIsx48Yw7ikv9Q8kxBMjYaG004WzaepCjlboxoTXnqaSfUnt5n1yjEYjzZo1Y9euXXh7e6vLpUg8R2fOZYupEa++2omGvo73FnkyL7dv32bfvn00aNCAFi1aqMviQcZsoi7+xs5jV4nPTCc9PpH0aj14c0AXmvua5y0mUTpIWBBl0ujRo3nxxRfp2LFjCb5PXjqsXr2aQ4cO8e233+Ls7KwuiwcZs7lzfh+b9p3mdlw2dgFt6f1iZ5r7yd+bKFwSFkSZdObMGWbOnMmPP/5Yym9FmLe8vDxmzJhBWloa33zzjboshDATZfzutSirmjZtilarJSIiwqxmRZQ1V69eJS8vj6FDh6pLQggzImFBlEkWFha8/vrrzJo1C71eNuIqDlqtlhs3buDs7EzdunXVZSGEGZGwIMqs5557jpycHI4ePWpW0yjLin379rFjxw5efvlldUkIYWYkLIgyy9ramnfffZdZs2aRmZmpLotCFBsby8mTJ2nWrBk1atRQl4UQZkbCgijTGjduTJs2bZg4cSKGMrapVnHJz8/n0KFDWFpa8uabb6rLQggzJGFBlHlvvvkmtra2LFiwQAY7FoFDhw5x8OBB+vXrh5OTk7oshDBDEhZEmefo6Mj777/PkSNH2L9/v7osnqAzZ86wevVq+vbtK4MahShBJCwIAfj6+jJhwgTWrVvH3r171WXxBFy4cIF58+bRs2dPXnjhBXVZCGHGJCwIcU+LFi0YPny4BIZCcOXKFWbMmMFLL73Eiy++qC4LIcychAUhHtCiRQtGjBjBmjVrmD17tros/iaTycTmzZsZNWoUffv25aWXXkKjkR0ShShpZLlnIf7A1atXWblyJampqSxatEhdFo8hNzeXtWvXsm3bNoYOHUq3bt0kKAhRQklYEOJP3L17lxUrVvDrr7+ybNkyGjZsqG4i/kRMTAyzZs1CURQGDBggf3dClHASFoR4hIyMDDZv3szJkyepWbMmEyZMkG/Hj6DT6VizZg3ffvstH3zwAc888ww+Pj7qZkKIEkbCghB/QVEUgoOD2bJlC7/88gs//fQTrVq1Ujcr0xRF4datWyxcuBCDwUCXLl1o06YNdnZ26qZCiBJIwoIQj0FRFFJTUzly5AgHDhwgPT2dd999l0aNGqmbljkZGRl8++23XLt2jcGDB9OqVSu8vb3VzYQQJZiEBSH+BpPJRFRUFOfOnePYsWNYWVkxYsQIAgIC1E1LvZSUFNatW8euXbvo168fjRo1olq1atja2qqbCiFKOAkLQvwDer2euLg4Ll68yN69e0lPT+e9996jQYMG6qaliqIohIaGsmrVKs6fP8+QIUOoX78+/v7+2Nvbq5sLIUoJCQtC/At6vZ74+HhCQkLYvXs3W7duZfr06bRo0QI/Pz918xJLp9Oxf/9+1qxZg6Io9OzZk7p161K5cmUJCUKUARIWhHgCjEYjKSkpREREcO3aNQ4cOICiKAwaNIhmzZpRvnx59SFmT6fTcebMGTZt2sTVq1fp0aNHwa0GNzc3GbwoRBkiYUGIJ0hRFHJzc8nIyCAmJoarV6+ybt064uPj+eCDDwgKCjLr+/q3b9/m8uXLbNmyhbt37/LSSy9Rv359atasiYuLCw4ODlhaWqoPE0KUchIWhCgkiqKQl5dHWloa0dHRREVFcejQIS5cuECtWrXo2LEjAQEBBAYG4uLioj680GVkZHDnzh1u377NiRMn+PHHH+nduzfNmjWjbt26VK1aFScnJ+zt7bGyslIfLoQoQyQsCFEEFEVBp9ORl5dHTk4OCQkJREVFcffuXbZv387Vq1fp2LEjLVq0oEKFCnh7e+Pl5UW5cuUoV64cFhb/bBuX+Ph49Ho9MTExZGRkEB4eTlRUFEuWLKFFixY0a9aM6tWrU6NGDSpUqICzszO2trbY2tr+49cUQpQ+EhaEKAaKoqDX6zEYDGi1WrKzs8nJySE6OprU1FTi4uKIj4/n7t27HD16lKSkJPR6fcG4AZ1Op35KLC0tiY2NZefOnaSmpmIwGOjZsyf+/v54eXnh6+uLh4cHbm5uVKxYEQcHB2xsbLCyssLa2lrCgRDiT0lYEMJMKIqC0WjEZDIV/NdkMqHT6QoeS0tLIz8//w+XnFYUBWtrazw8PLC2tsZkMmFnZ4elpSUWFhYF/73/SwghHpeEBSFKEEVReNRHVqPR/GGQEEKIf0PCghBCCCEeSfoihRBCCPFIEhaEEEII8Uj/D4btCSXzm50SAAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "id": "28529721",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22a9fb49",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "env.build(\"\"\"(deffacts family (father John Tom)\n",
    "                              (child Mary Tom)\n",
    "                              (child Jerry Tom)\n",
    "                              (stay Mary Malacca)\n",
    "                              (sibling Jerry Mary)\n",
    "                              (stay Jerry Penang))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule who-is-the-sibling-of-Jerry\n",
    "                    (sibling Jerry ?sis)\n",
    "                     => (printout t \"Jerry's sibling is \" ?sis crlf))\"\"\")\n",
    "\n",
    "\n",
    "env.build(\"\"\"(defrule where-does-Jerry-stay \n",
    "                    (stay Jerry ?place)\n",
    "                     =>(printout t \"Jerry stays at \" ?place crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "# inference\n",
    "env.run()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0599cc2d",
   "metadata": {},
   "source": [
    "# Section D: Knowledge-Based Expert System"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a75b7a42",
   "metadata": {},
   "source": [
    "* Diagram below is a **frame-based knowledge representation**. Create **CLIPS contructs** for **classes** and build **inheritance (is-a)** and **instance** relationships. As well as **has-a (aggregation)** and **has-a (composition)** relationships. The **reasoning** here is to locate the instance of garfield and snoopy. The **challenges of user interface** are **users' inputs are varies**, choose the facts from words and **match** with predefined facts in a Expert System is important. Additional to this, **auto word correction** and **lower case the words** could make further accurate results. Therefore, this example is enhanced with **natural language processing (NLP)** to overcome the challenges. Furthermore, the **text-to-speech** could make the Expert System more **interactive experience**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db333f20",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install pyttsx3"
   ]
  },
  {
   "attachments": {
    "image-5.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "ebfb26d4",
   "metadata": {},
   "source": [
    "![image-5.png](attachment:image-5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de1fe73",
   "metadata": {},
   "source": [
    "1. Create frames with **is-a** relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a695ec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "env.build(\"\"\"(defclass Animal (is-a USER)\n",
    "                (slot animalname))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defclass Dog (is-a Animal)\n",
    "               (slot animalname)\n",
    "               (slot has-toy))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defclass Cat (is-a Animal)\n",
    "               (slot animalname)\n",
    "               (slot place))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defclass Toy (is-a USER)\n",
    "               (slot toyname))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defclass Place (is-a USER)\n",
    "               (slot placename))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defclass Person (is-a USER)\n",
    "               (multislot pets))\"\"\")\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc2e85e4",
   "metadata": {},
   "source": [
    "2. Attach **function(s)** to a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "223f722b",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.build(\"\"\"(defmessage-handler Animal speak ()\n",
    "               (printout t \"Animal make sound ...\" crlf))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defmessage-handler Dog speak ()\n",
    "               (assert (animal \"Bark bark ...\")))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defmessage-handler Cat speak ()\n",
    "               (assert (animal \"Meow meow ...\")))\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30b3c993",
   "metadata": {},
   "source": [
    "2. Create an **instance** with **has-a (composition)** relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a5ea6c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.eval(\"\"\"(make-instance snoopy of Dog (animalname Snoopy)\n",
    "                                       (has-toy (make-instance toy1 of Toy (toyname Ball))))\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1e369d5",
   "metadata": {},
   "source": [
    "3. Create an **instance** with **has-a(aggregation)** relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef2ecf7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.eval(\"\"\"(make-instance place1 of Place (placename Garden))\"\"\")\n",
    "\n",
    "env.eval(\"\"\"(make-instance garfield of Cat (animalname Garfield)\n",
    "                                       (place place1))\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bf1c5c4",
   "metadata": {},
   "source": [
    "4. Create an **instance** with **has-a(aggregation)** relationship with **more than one instances**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "286005f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.eval(\"\"\"(make-instance tom of Person (pets (create$ snoopy garfield)))\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b610d5c",
   "metadata": {},
   "source": [
    "5. Adjust your speaker accordingly to experience the **text to speech**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "793498cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyttsx3\n",
    "\n",
    "engine = pyttsx3.init()\n",
    "\n",
    "engine.setProperty('rate',200)\n",
    "\n",
    "# Example input = garfield\n",
    "# Example input = snoopy\n",
    "user_input=input(\"Enter your favourite animal to speak with you.\")\n",
    "\n",
    "#env.eval(\"(find-all-instances ((?ins USER)) TRUE)\")\n",
    "\n",
    "try:\n",
    "    env.eval(\"(bind ?output (find-instance ((?ins USER)) (eq [\" + user_input + \"] ?ins)))\")\n",
    "    env.eval(\"\"\"(do-for-all-facts ((?f animal)) (retract ?f))\"\"\")\n",
    "    env.eval(\"\"\"(send (nth$ 1 ?output) speak)\"\"\")\n",
    "    engine.say(list(env.facts())[0][0])\n",
    "    engine.runAndWait()\n",
    "    \n",
    "except Exception as e:\n",
    "    engine.say(\"Sorry, cannot find!\")\n",
    "    engine.runAndWait()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "587a6bc4",
   "metadata": {},
   "source": [
    "6. Enhance user interface through **Natural Language Processing (NLP)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "317162e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install pyspellchecker\n",
    "#nltk.download('punkt_tab')\n",
    "#nltk.download('punkt')\n",
    "#nltk.download('wordnet')\n",
    "#nltk.download('stopwords')\n",
    "#nltk.download('averaged_perceptron_tagger')\n",
    "#nltk.download('averaged_perceptron_tagger_eng')\n",
    "#nltk.download('omw-1.4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "748cf0c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "from nltk.corpus import wordnet\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk import pos_tag\n",
    "from spellchecker import SpellChecker\n",
    "from clips import Environment\n",
    "\n",
    "# Function to enhance input\n",
    "def corrected_input(user_input):\n",
    "    \n",
    "    spell = SpellChecker()\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    stop_words = set(stopwords.words(\"english\"))\n",
    "\n",
    "    # Tokenize input\n",
    "    tokens = word_tokenize(user_input)\n",
    "    \n",
    "    # POS tagging\n",
    "    tagged_words =pos_tag(tokens)\n",
    "\n",
    "    corrected_words = []\n",
    "    for word,tag in tagged_words:\n",
    "         # Skip stop words\n",
    "        if word.lower() not in stop_words:\n",
    "            # Filtered words for (proper noun, singular), (common noun, singular, plural)\n",
    "            if tag in ['NNP','NN','NNS']: \n",
    "                if tag in ['NN','NNS']: # Only correct (common noun, singular, plural) in the dictionary\n",
    "                    corrected = spell.correction(word) if word.lower() not in spell and word.isalpha() else word\n",
    "                else: # Garfield & Snoopy\n",
    "                    corrected = word\n",
    "                \n",
    "                # Lemmatize the corrected word\n",
    "                lemma = lemmatizer.lemmatize(corrected)\n",
    "                corrected_words.append(lemma)\n",
    "\n",
    "    return \" \".join(corrected_words)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f6b1747",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyttsx3\n",
    "\n",
    "engine = pyttsx3.init()\n",
    "\n",
    "engine.setProperty('rate',200)\n",
    "\n",
    "# Example input = I love Garfield\n",
    "# Example input = I love Snoopy\n",
    "user_input=input(\"Enter your favourite animal to speak with you.\")\n",
    "filtered_user_input = corrected_input(user_input).lower()\n",
    "print(filtered_user_input)\n",
    "\n",
    "try:\n",
    "    env.eval(\"(bind ?output (find-instance ((?ins USER)) (eq [\" + filtered_user_input + \"] ?ins)))\")\n",
    "    env.eval(\"\"\"(do-for-all-facts ((?f animal)) (retract ?f))\"\"\")\n",
    "    env.eval(\"(send (nth$ 1 ?output) speak)\")\n",
    "    engine.say(list(env.facts())[0][0])\n",
    "    engine.runAndWait()\n",
    "    \n",
    "except Exception as e:\n",
    "    engine.say(\"Sorry, cannot find! Please provide additional context.\")\n",
    "    engine.runAndWait()   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f59ff300",
   "metadata": {},
   "source": [
    "# Section D: Car Troubleshooting Expert System Through Case-based Reasoning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abffb288",
   "metadata": {},
   "source": [
    "4R - **R**epresenting, **R**etrieve, **R**euse and **R**etain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4994b66",
   "metadata": {},
   "source": [
    "1. Create the facts below to the case_library.txt and save into the same folder with the Lab 7.ipynb <br>\n",
    "(car-troubleshooting (can-start yes) (engine-noise 200) (solution replace-belt)) <br>\n",
    "(car-troubleshooting (can-start yes) (engine-noise 80) (solution check-battery)) <br>\n",
    "(car-troubleshooting (can-start no) (engine-noise 0) (solution check-fuel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64cb2ef7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "from datetime import datetime\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Representing a case\n",
    "env.build(\"\"\"(deftemplate car-troubleshooting\n",
    "                   (slot can-start)\n",
    "                   (slot engine-noise)\n",
    "                   (slot solution))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(deftemplate car-query\n",
    "                   (slot can-start)\n",
    "                   (slot engine-noise))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(deftemplate similarity\n",
    "                   (slot solution)\n",
    "                   (slot score))\"\"\")\n",
    "\n",
    "\n",
    "# Load case library\n",
    "# env.build(\"\"\"(deffacts case (car-troubleshooting (can-start yes) (engine-noise 200) (solution replace-belt))\n",
    "#                             (car-troubleshooting (can-start yes) (engine-noise 80) (solution check-battery))\n",
    "#                             (car-troubleshooting (can-start no) (engine-noise 0) (solution check-fuel)))\"\"\")\n",
    "\n",
    "fact=\"\"\n",
    "with open('case_library.txt', 'r') as file:\n",
    "    for line in file:\n",
    "        fact=fact+line.strip()\n",
    "    env.build(\"\"\"(deffacts case \"\"\"+fact+\"\"\")\"\"\")\n",
    "        \n",
    "# Retrieve similar case\n",
    "env.build(\"\"\"(defrule calculate-similarity\n",
    "                 ?query <- (car-query (can-start ?query-start) (engine-noise ?query-noise))\n",
    "                 ?case <- (car-troubleshooting (can-start ?case-start) (engine-noise ?case-noise) (solution ?case-solution))\n",
    "              =>  (bind ?score 0)\n",
    "                  (if (eq ?query-start ?case-start) then (bind ?score (+ ?score 1)))                ;;+1 if can-start is match\n",
    "                  (bind ?noise-diff (abs (- ?query-noise ?case-noise)))                             ;;similarity of engine-noise\n",
    "                  (if (<= ?noise-diff 50) then (bind ?score (+ ?score (- 1 (/ ?noise-diff 50.0))))) ;;tolerance +/-50\n",
    "                  (assert (similarity (solution ?case-solution) (score ?score))))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(defrule retrieve-most-similar\n",
    "                  (similarity (solution ?case-solution) (score ?score))\n",
    "             =>(printout t \"Most similar case: \" ?case-solution \" with similarity score: \" ?score crlf))\"\"\")\n",
    "\n",
    "env.build(\"(defglobal ?*max-solution* = nil)\")\n",
    "env.build(\"(defglobal ?*max-score* = -1)\")\n",
    "env.build(\"\"\"(defrule find-max-score\n",
    "               (similarity (solution ?solution) (score ?score))\n",
    "               (test (> ?score ?*max-score*))\n",
    "              =>(bind ?*max-score* ?score)\n",
    "                (bind ?*max-solution* ?solution))\"\"\")\n",
    "\n",
    "env.eval(\"(ppdeffacts case)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dba7046",
   "metadata": {},
   "source": [
    "2. Reuse and retain the solution. Check the new solution has been added to the case_library.txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d5aea6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.reset()\n",
    "query=\"(car-query (can-start yes) (engine-noise 100))\" # remove hash tag for reuse solution\n",
    "env.eval(\"(assert \" +query+\")\")\n",
    "env.run()\n",
    "\n",
    "# Reuse the solution\n",
    "env.build(\"\"\"(defrule reuse-solution-retain\n",
    "                    (test (> 1.8 ?*max-score*))\n",
    "              => (printout t \"Suggested solution:\" ?*max-solution* \" with similarity score:\" ?*max-score* crlf))\"\"\")\n",
    "\n",
    "env.run()\n",
    "\n",
    "# Retain\n",
    "#print(\"(car-troubleshooting (\"+query[12:-1]+\"(solution \"+env.eval(\"?*max-solution*\")+\"))\")\n",
    "with open('case_library.txt', 'a') as file:\n",
    "    file.writelines(\"(car-troubleshooting (\"+query[12:-1]+\"(solution \"+env.eval(\"?*max-solution*\")+\"))\\n\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d868d648",
   "metadata": {},
   "source": [
    "3. Revise and retain as no solution. Check the facts without solution has been added to the case_library.txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ef7a927",
   "metadata": {},
   "outputs": [],
   "source": [
    "env.eval(\"(undefrule reuse-solution-retain)\")\n",
    "\n",
    "env.reset()\n",
    "query=\"(car-query (can-start no) (engine-noise 150))\"   # remove hash tag for revise solution\n",
    "\n",
    "env.eval(\"(assert \" +query+\")\")\n",
    "env.run()\n",
    "\n",
    "# Revise the solution\n",
    "env.build(\"\"\"(defrule revise-solution-retain\n",
    "                    (test (< 0.5 ?*max-score*))\n",
    "              => (bind ?*max-solution* None)\n",
    "                 (printout t \"No solution!\" crlf))\"\"\")\n",
    "\n",
    "env.run()\n",
    "\n",
    "# Retain\n",
    "#print(\"(car-troubleshooting (\"+query[12:-1]+\"(solution \"+env.eval(\"?*max-solution*\")+\"))\")\n",
    "with open('case_library.txt', 'a') as file:\n",
    "    file.writelines(\"(car-troubleshooting (\"+query[12:-1]+\"(solution \"+env.eval(\"?*max-solution*\")+\"))\\n\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d48624a1",
   "metadata": {},
   "source": [
    "* Manual Handling Unsolved Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "358702c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clips \n",
    "import logging\n",
    "from datetime import datetime\n",
    "\n",
    "# Setup working environment\n",
    "logging.basicConfig(level=logging.INFO,format='%(message)s')\n",
    "    \n",
    "env = clips.Environment()\n",
    "router = clips.LoggingRouter()\n",
    "env.add_router(router)\n",
    "\n",
    "# Representing a case\n",
    "env.build(\"\"\"(deftemplate car-troubleshooting\n",
    "                   (slot can-start)\n",
    "                   (slot engine-noise)\n",
    "                   (slot solution))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(deftemplate car-query\n",
    "                   (slot can-start)\n",
    "                   (slot engine-noise))\"\"\")\n",
    "\n",
    "env.build(\"\"\"(deftemplate similarity\n",
    "                   (slot solution)\n",
    "                   (slot score))\"\"\")\n",
    "\n",
    "\n",
    "fact=\"\"\n",
    "with open('case_library.txt', 'r') as file:\n",
    "    for line in file:\n",
    "        fact=fact+line.strip()\n",
    "    env.build(\"\"\"(deffacts case \"\"\"+fact+\"\"\")\"\"\")\n",
    "        \n",
    "# Retrieve all cases without solutions \n",
    "env.build(\"\"\"(defrule store-new-unsolved-case\n",
    "                    (car-troubleshooting (can-start ?p1)\n",
    "                                         (engine-noise ?p2)\n",
    "                                         (solution None))\n",
    "             => (printout t \"New unsolved case stored: can-start \" ?p1 \"; engine-noise \" ?p2 crlf))\"\"\")\n",
    "\n",
    "env.reset()\n",
    "\n",
    "env.run()\n",
    "\n",
    "# Domain expert manually update to the knowledge based\n",
    "# Open the case library and replace the text\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c00fce",
   "metadata": {},
   "source": [
    "## Excercise:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bb3e8e7",
   "metadata": {},
   "source": [
    "1. Simulate the FuzzyCLIPS (https://sourceforge.net/projects/clipsrules/files/)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:base] *",
   "language": "python",
   "name": "conda-base-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}