Python_OOPs.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/CodewithRadheRadhe/OOPs-in-Python/blob/main/Python_OOPs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tf50zpi50JOf"
      },
      "source": [
        "#**OOPS IN Python**\n",
        "\n",
        "1. Class\n",
        "2. Objects/Instances\n",
        "3. Constructors (Default,Parameterised)\n",
        "4. Attributes (Object Attributes > Class Attributes)\n",
        "5. Creating Methods (....)\n",
        "6. Decorators (Staticmethod, Classmethod, Property,GetterSetter)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "chVBrJFsyiQ3"
      },
      "outputs": [],
      "source": [
        "# Proceduaral Programming/Sequential Programming/\n",
        "# writing codes in step by step\n",
        "# Reduces redundancy and increase resuability"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "OHuIWuFI0uwD"
      },
      "outputs": [],
      "source": [
        "# Class is a blueprimt for creating objects"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "aajT7uD41JcI",
        "outputId": "20287328-d094-45bf-a148-af8361ffe935"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra Singh\n"
          ]
        }
      ],
      "source": [
        "class student: #class student is created\n",
        "  name = \"Narendra Singh\" #class attribute\n",
        "s1 = student() #object is created\n",
        "print(s1.name)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "artoKQFL1qs1",
        "outputId": "989635d4-fe84-4282-b4a3-fb7da1c1b267"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "red\n",
            "mercedes\n"
          ]
        }
      ],
      "source": [
        "class car:\n",
        "  color=\"red\"\n",
        "  brand = \"mercedes\"\n",
        "c1=car()\n",
        "print(c1.color)\n",
        "print(c1.brand)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JB50dhNa6DQ0"
      },
      "source": [
        "**Constructor**\n",
        "1. Deafault Constructor\n",
        "2. Parameterised Constructor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "9vNeJmQ62CLj",
        "outputId": "f99a0de8-accf-45ed-eef6-7e89a9024849"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hey this is narendra\n"
          ]
        }
      ],
      "source": [
        "#  __init__() function invoke/execute when object is executed/initiated\n",
        "class student:\n",
        "  name=\"Narendra\"\n",
        "  def __init__(self):\n",
        "    print(\"hey this is narendra\") #constructor is a function that always takes a i/p , by default self arg is taken\n",
        "s1=student()\n",
        "# constructor apne ap invoke hua when we initiated s1 object"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "ucdpmCKU3VkX",
        "outputId": "f734c324-a288-4cfb-fb77-c55c37792ae8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hey this is narendra\n",
            "narendra\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,fullname): # if we don't create consturctor then python by defaults create constructor in backend\n",
        "    self.name=fullname\n",
        "    print(\"hey this is narendra\")\n",
        "s1=student(\"narendra\" ) #when we provide input to object then self.name create a variable that stores the input assigned here\n",
        "print(s1.name)\n",
        "#Note \"self\" is random word taken by the programmer we can use any arg/input\n",
        "# Self is used to access the variable that belongs to the class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "ykUqYu9Q4nzZ",
        "outputId": "9c847a35-ff7a-4fb9-f594-f8b0f010e983"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hey this is narendra\n",
            "nandu\n",
            "90\n",
            "nandu 90\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name\n",
        "    self.marks=marks\n",
        "    print(\"hey this is narendra\")\n",
        "s1=student(\"nandu\",90)\n",
        "print(s1.name)\n",
        "print(s1.marks)\n",
        "print(s1.name,s1.marks)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jV44e3NU6YxD"
      },
      "source": [
        "**Attributes**\n",
        "\n",
        "\n",
        "1.   Class Attributes\n",
        "2.   Object Attributes\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "rrQpSg0h50lD",
        "outputId": "dd214ccb-691b-4737-aff8-c9ce0dc314fd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hey this is narendra\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  college_name=\"NIT Trichy\" #Class Attributes common for all student in class\n",
        "\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name #Object Attributes\n",
        "    self.marks=marks #Object Attributes\n",
        "    print(\"hey this is narendra\")\n",
        "s1=student(\"nandu\",90)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "N8GFWptr7jOv",
        "outputId": "15dcb909-e735-4c53-b08b-2bf6cb430d17"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "hey this is narendra\n",
            "nandu\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  college_name=\"NIT Trichy\" #Class Attributes common for all student in class\n",
        "  name=\"Anonymous\"\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name #Object Attributes\n",
        "    self.marks=marks #Object Attributes\n",
        "    print(\"hey this is narendra\")\n",
        "s1=student(\"nandu\",90)\n",
        "print(s1.name)\n",
        "# nandu is printed because object/instance has more precedance over class attributes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ycj6MQuN8H0u"
      },
      "source": [
        "**Methods**\n",
        "\n",
        "Methods are functions that belong to the objects"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "ufNzXEIP7x8Q",
        "outputId": "181dbc95-b8bd-451b-9d66-bdf6599e7f66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "welcome to the class nandu\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "90"
            ]
          },
          "execution_count": 103,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name #Object Attributes\n",
        "    self.marks=marks #Object Attributes\n",
        "\n",
        "  def welcome(self):\n",
        "    print(\"welcome to the class\",self.name)\n",
        "  def getmarks(self):\n",
        "    return self.marks\n",
        "s1=student(\"nandu\",90)\n",
        "s1.welcome()\n",
        "s1.getmarks()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HBLNruhDAcl2"
      },
      "source": [
        "***Static Method***\n",
        "\n",
        "1. These methods do not have self arg hence they work at class level as w/o self it wont run at object level\n",
        "\n",
        "2. **Decorator**\n",
        "\n",
        "\n",
        "*   It is used to make the static method being w/o use of self arg.\n",
        "*   Decorators are used to wrap another function in order to extend the behavior of wrapped function, w/o permanently modifying it.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fb88lCIRCPLE",
        "outputId": "bc24a009-fc42-4096-93eb-809af2cd30ae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi nandu  your avg score is :  80.0\n",
            "NIT Trichy\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name\n",
        "    self.marks=marks\n",
        "  @staticmethod # decorators\n",
        "  def college():\n",
        "    print(\"NIT Trichy\")\n",
        "  def avg_marks(self):\n",
        "    sum=0\n",
        "    for i in self.marks:\n",
        "      sum+=i\n",
        "    print(\"Hi\",self.name,\" your avg score is : \", sum/len(self.marks))\n",
        "s1=student(\"nandu\",[90,80,70])\n",
        "s1.avg_marks()\n",
        "s1.college()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qePtf3XnZGeG"
      },
      "source": [
        "#** IMPORTANT Concepts in OOPs**\n",
        "1. **Delete Keyword**\n",
        "\n",
        "- Del keyword :- used to delete object properties or object itself.\n",
        "\n",
        "2. **Private(Like) attributes and methods**\n",
        "\n",
        "-  Private function can be accessed by only internal function\n",
        "- We can use it externally through internal access.\n",
        "\n",
        "3. **Class Method Decorator**\n",
        "- Static method (no self arg)\n",
        "- Class Method (cls key arg is used)\n",
        "- Instance Method(self arg is used)\n",
        "\n",
        "4. **Property Decorator**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ct139Smg4b7H"
      },
      "source": [
        "**Delete Keyword**\n",
        "\n",
        "- Del keyword :- used to delete object properties or object itself."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "355wYKGHY6Lx",
        "outputId": "483a8bb1-ed65-4aa3-c405-7babe40c2114"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name):\n",
        "    self.name=name\n",
        "s1=student(\"Narendra\")\n",
        "print(s1.name)\n",
        "# del s1.name\n",
        "# print(s1.name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yNrj19fZ6HN"
      },
      "source": [
        "**Private(Like) attributes and methods**\n",
        "\n",
        "1. Private function can be accessed by only internal function\n",
        "2. We can use it externally through internal access."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "0IW2sNsfaCl_",
        "outputId": "a7d03f4c-c230-4353-e7a6-cff8454a31d5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12345\n",
            "abc\n"
          ]
        }
      ],
      "source": [
        "class account:\n",
        "  def __init__(self,acc,password):\n",
        "    self.acc=acc\n",
        "    self.password=password\n",
        "s1=account(12345,\"abc\")\n",
        "print(s1.acc)\n",
        "print(s1.password)\n",
        "  #   self.__password=password\n",
        "  # def get_password(self):\n",
        "  #   return self.__password\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "id": "CdZB1xvUbB5r",
        "outputId": "42af7589-197d-4fa3-e848-be4d2c2921a2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12345\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'AttributeError                            Traceback (most recent call last)\\n<ipython-input-43-911313b3dc57> in <cell line: 0>()\\n      5 s1=account(12345,\"abc\")\\n      6 print(s1.acc)\\n----> 7 print(s1.password)\\n      8   #   self.__password=password\\n      9   # def get_password(self):\\nAttributeError: \\'account\\' object has no attribute \\'password\\''"
            ]
          },
          "execution_count": 107,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "class account:\n",
        "  def __init__(self,acc,password):\n",
        "    self.acc=acc\n",
        "    self.__password=password\n",
        "s1=account(12345,\"abc\")\n",
        "print(s1.acc)\n",
        "#print(s1.password) gives error\n",
        "#   self.__password=password\n",
        "# def get_password(self):\n",
        "#   return self.__password\n",
        "\"\"\"AttributeError                            Traceback (most recent call last)\n",
        "<ipython-input-43-911313b3dc57> in <cell line: 0>()\n",
        "      5 s1=account(12345,\"abc\")\n",
        "      6 print(s1.acc)\n",
        "----> 7 print(s1.password)\n",
        "      8   #   self.__password=password\n",
        "      9   # def get_password(self):\n",
        "AttributeError: 'account' object has no attribute 'password'\"\"\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "saCQmn8Auk-X"
      },
      "source": [
        "**Class Method decorator**\n",
        "1. Static method (no self arg)\n",
        "2. Class Method (cls key arg is used)\n",
        "3. Instance Method(self arg is used)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "E7YDc--WuoqD",
        "outputId": "e4ecc93e-5012-4b2b-9bdd-92bdbdd749c6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra Singh\n",
            "anonymous\n"
          ]
        }
      ],
      "source": [
        "class person():\n",
        "  name=\"anonymous\"\n",
        "  def changename(self,name):\n",
        "    self.name=name\n",
        "\n",
        "p1=person()\n",
        "p1.changename(\"Narendra Singh\")\n",
        "print(p1.name)\n",
        "print(person.name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "YmjKZNKsy9YI",
        "outputId": "0caf821d-2852-4250-cb30-fcbbf8bec11c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra Singh\n",
            "Narendra Singh\n"
          ]
        }
      ],
      "source": [
        "class person():\n",
        "  name=\"anonymous\"\n",
        "  def changename(self,name):\n",
        "    person.name=name\n",
        "\n",
        "p1=person()\n",
        "p1.changename(\"Narendra Singh\")\n",
        "print(p1.name)\n",
        "print(person.name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "qisEsNwN0EkM",
        "outputId": "773a0896-0b56-4d3e-a3c6-bf07a0c0761d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra Singh\n",
            "Narendra Singh\n"
          ]
        }
      ],
      "source": [
        "class person():\n",
        "  name=\"anonymous\"\n",
        "  def changename(self,name):\n",
        "    self.__class__.name=name\n",
        "\n",
        "p1=person()\n",
        "p1.changename(\"Narendra Singh\")\n",
        "print(p1.name)\n",
        "print(person.name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "khA-t_jP0jK0",
        "outputId": "aeca6bc7-962a-4816-bfb2-b4ec43607b45"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Narendra Singh\n",
            "Narendra Singh\n"
          ]
        }
      ],
      "source": [
        "class person():\n",
        "  name=\"anonymous\"\n",
        "  # def changename(self,name):\n",
        "  #   self.__class__.name=name\n",
        "  @classmethod\n",
        "  def changename(cls,name):\n",
        "    cls.name=name\n",
        "\n",
        "p1=person()\n",
        "p1.changename(\"Narendra Singh\")\n",
        "print(p1.name)\n",
        "print(person.name)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "5b5IIt06bLFX",
        "outputId": "7b24b8ed-79ce-49f6-b884-2c01e0e3d3c8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12345\n",
            "abc\n"
          ]
        }
      ],
      "source": [
        "class account:\n",
        "  def __init__(self,acc,password):\n",
        "    self.acc=acc\n",
        "    self.__password=password\n",
        "  def get_password(self):\n",
        "    return self.__password\n",
        "s1=account(12345,\"abc\")\n",
        "print(s1.acc)\n",
        "print(s1.get_password())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JMHFqm6M4hkd"
      },
      "source": [
        "**Property Decorator**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "GBb978pR4mfj",
        "outputId": "74bf9aca-7d20-46d0-8e51-bcca61f605d5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "80.0%\n",
            "96\n",
            "82.0%\n"
          ]
        }
      ],
      "source": [
        "class student():\n",
        "  def __init__(self,phy,che,math):\n",
        "    self.phy=phy\n",
        "    self.che=che\n",
        "    self.math=math\n",
        "    self.percentage=str((self.phy+self.che+self.math)/3)+'%'\n",
        "  def calcpercentage(self):\n",
        "    return str((self.phy+self.che+self.math)/3)+'%'\n",
        "s1=student(90,80,70)\n",
        "print(s1.percentage)\n",
        "s1.phy=96\n",
        "print(s1.phy)\n",
        "print(s1.calcpercentage())\n",
        "  #  \"@property\n",
        "  # def avg(self):\n",
        "  #   return (self.phy+self.che+self.math)/3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "qFukjTWV5J-g",
        "outputId": "9e1fac1f-1b92-4068-f337-fd6975c3c12e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "80.0%\n",
            "96\n",
            "82.0%\n"
          ]
        }
      ],
      "source": [
        "class student():\n",
        "  def __init__(self,phy,che,math):\n",
        "    self.phy=phy\n",
        "    self.che=che\n",
        "    self.math=math\n",
        "    self.percentage=str((self.phy+self.che+self.math)/3)+'%'\n",
        "  def calcpercentage(self):\n",
        "    self.percentage=str((self.phy+self.che+self.math)/3)+'%'\n",
        "s1=student(90,80,70)\n",
        "print(s1.percentage)\n",
        "s1.phy=96\n",
        "print(s1.phy)\n",
        "s1.calcpercentage()\n",
        "print(s1.percentage)\n",
        "  #  \"@property\n",
        "  # def avg(self):\n",
        "  #   return (self.phy+self.che+self.math)/3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "VyzuKR9977kP",
        "outputId": "d8acb768-1e02-4025-bddf-98e2c08062fe"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "80.0%\n",
            "82.0%\n"
          ]
        }
      ],
      "source": [
        "class student():\n",
        "  def __init__(self,phy,che,math):\n",
        "    self.phy=phy\n",
        "    self.che=che\n",
        "    self.math=math\n",
        "  @property\n",
        "  def percentage(self):\n",
        "    return str((self.phy+self.che+self.math)/3 )+\"%\"\n",
        "s1=student(90,80,70)\n",
        "print(s1.percentage)\n",
        "s1.phy=96\n",
        "print(s1.percentage)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AfUk5KD2Cr41"
      },
      "source": [
        "#**Four Pillars of OOPS**\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "![OOPS4Pillars.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABCEAAAHwCAYAAACYKHXTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAgAElEQVR4nOzde1xUZf4H8M9wl6ugIuAFTVA0S81LBmqmrgpmaqZltT/LvFBtoWW1lW1tmnvRvFRbSNquu22tlmWZoNVWWmLq6q6VqIA3BFQUFEHkfn5/wAxn5py5MsyZM+fzfr2el865POd5nvMMc873ORedIAgCiIiIiIiIiIjamJfSBSAiIiIiIiIibWAQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJH6UL4O4EQTD61/T/RETkejqdzur/iYiIiMj9MAghQxAEQzpbcR3ZRaU4UX4dl2vqAABHLlUoXEIiIm27sWMIACDI1xu9QgNxW0w44sKDodPpDInIHA4wEBG5Hw4waIdO4K+ugT7wUF1Xj+0nziPz9CXAS4dBUR3QNTQQYe18AQB9OoQpXFIiIm07XloOAKiqbUBB+TUcPl+Gqro6jOrSAVN7RaJjUDsGI8iIeIChqvAsLu7di6qTJ1B7+TIAoPxojsIlJCLStrC+/QAAPsHBCLzhBnS89TaE9OrFAQYPxCAEWg5MGhsbse3EeWw5cQGDojtgVGxnRAe3U7p4RERkg9KqGuwruogfz17EiOj2mBYfhbAAfx64aJz+N76+uhpFWZm4sCMLOp0OnQYMQFCXrvAPaxpYaN+7j8IlJSLStiu5xwEAddeqUFl0Fpd++gl1VdfQacRIxEyegnYdO/I33UNoPgihDz6UV9dg2f4T6BwShDv7dEWov5/SRSMiIgdU1dXj3yfO4ciFMvx2yA2ICQ2El5cXD1o0RjzAULT9CxR/9ik6DRiEmBEjEBgVrXTxiIjIBtWXLuHCfw7g/L4fEZGUhK5TpsE/NJTBCJXTdBDCcHBSfg0r/nsGU/p2R2/eakFE5BHOV17HhoO5eLR/F/SPbA9vb28esGiE/ve95upVHFu+DMGdO6NHyp3wCw1VumhEROSA+uvXcfabr3Ep5wj6LH4OQTExHGBQMc0GIQRBQENDA4rKr2H5wdN4ZHBvRPHWCyIij1JVV4+39h/F7N6dMSgqgoEIDdAHICqLipC/eiV63XkXb7UgIvIQVRfO48hf30OP+akIv/FG/q6rlCaDEPoDlLJrVXj1wGk8ODCOAQgiIg9VVVePNdlH8NtB3dEtPIQHLB5MP8BQWVSEvD//ETc+PAeBnaOULhYRETlR/fXrOPz2m+j64P+hw8BB/F1XIc0FIQwjJNersezASfyqD2/BICLydOcrr+PvB4/j98N7ISKIz4jwRPrf96rLl5H72qvoe/+DDEAQEXmo+uvX8d831qDX4mcR2q0bAxEqo7kgRGNjI+rq6vDx0bM4J/jgnn49lC4SERG5wL9PFONqRQUeHRALPz8/eHl5KV0kchJ9AKK6shLH/7gcN4wdh/bxvZUuFhERtaGqC+fxy/t/R9/f/R6B4eEcYFARTR2B6S/TrKi6jqzicvyqVwwEgImJiYlJA2lkjygcLK3EhauVqK+vh8Zi8B5NEATU19ejMHM7QiM7MwBBRKQBgZ2jEH3LEBR88E/U1dXxd11FfJQugKsY3hNeX4/MkxcwIKoDQv38mo5MiYjI4/l6eeGO2Gh8lF+CxwYGwtvbm6MmHkA/wHC9ogJlX+7A4EWLAR6IEhFpQpekEShcvhSVFy4gNDoavr6+/F1XAU1dCdHQ0IDa2lpkFZdjdI9oxUflmJiYmJhcm0b0iMKeCxWovF6NhoYGkLqJBxiKd2Sh080D+RpOIiIN8fL1RddRo1H8yRbU19ejsbGRV0SogKauhGhoaMAvJVcQEdgOEYH+YPckItIWH28v9I8KR3ZRGSbEt4OPjw9HTFROP8BQ9uUODHlyEXgVBBGRtnRJGoFTLz6P6gcehI+PD5/5pAKaCELoH1hVV1eHAyWV6N85XOkiERGRQvpHRuDAmUKM6VFnuGyTgQh10g8wXD5yBO3CwxEQEcEgBBGRxnj5+KDjjTfi4o970e5X4znAoAKaCEIATW/FqK+vR1FVDYZ3CeRVEEREGtU5pB3OVdWhtrYWAQEB8Pb2VrpI5ADxAEP5wQPo2K+/0kUiIiKFdOh/E87+5wDqRt/BAQYV0EQQwuhApa4RIf6+DEIQEWlUiL8vyuuafhMaGho4YqJi+gGGmuJiBA4bzqsgiIg0KiiyM2rOn+cAg0poIggBwBCEuFrfgDC+FYOISLNC/fxQWd+Auro6PsBKxcQDDPVXy+EfGgL+uBMRaZNfSDAarpZzgEElNBGE0D89u6GhAZdrGhDOh1ISEWkeAxDqpw9CNFy9Cr+QUMYgiIg0yi8kFA2VlRxgUAlNBCGAlhETgMcoRETEIITaiQcY6i9fRkBEOPgLT0SkbfxtVwfNBCEAGIIQREREPEhRP/EAA58HQUREDEKog2aCEOLOyG5JRETkGTjAQEREegxAqINmghBAS6dk1yQiIlI/o4NNHngSERGpgqaCEAY8TnGZYz8fxpXSUgBA+w4dkHDTANnlSi+WoPDUSVyvqkK7wEBERscgult3u7fR/5bBCA4Nc7gcpmXKO/KL4bO5vM+dLcCZE/k2lRUA2gUGYsCw4XblE9srzvB/W9sFsFzvyqvl+OXQQZvzkhPVpSt6xPe2uIxcvWzdB3pt3T8sbbPozGmUnCsyTE+4eZDVejurTxCRdYZABH/biYiIVEGTQQgep7jGvu++wZxJY42mfX3sjOTk8dzZAoxLiJWsPzplMl59ez06dIq0eRvP/GElHnryaYfKYWpkj85Gn+XyPv7zYdw9fKDFfOSYbt/efBY8twQTpt2DPhZO5K3V+6O/rceK5xfbWXKpI9csf6PGyuxbAPjg2702nXi3df+Q297OTz+y2jb3zk3FvXNTJfvAWX2CiOzFX/eC4nPILzhj8/KBAQEYPlD696qktBQnz55FVXU1AgMCEBPZGd1jom3K8/CxYyi9cgUAMPjG/ggLCbZpPf02TxcVo6jkgmH6oL590bVzFHr37GFTPnpybdGhfXsMSEiwOQ9xO4jp2wQAAvz9ENmhg11lK6+oxNET+fg5Lw9XKysN03v36IHu0dEWyyhuX3vqk3vqNAovnDeUv2+vONl942j+lji6L8orKnFQNBjkCNO+05r66fuD6X4DbNt35vJz5feMyF0wCEFtRq6dBZnp5kaMv8vchreWvYzfrX3H5m3I5W9rOayRW+dy8wi7vUzzsjefdX9ahnV/WoYFzy3BE79banYblrbrrO+BpXyO/3zY7LxdO7bjZhuCEG3dP0zz/M2Mu6yWCQA2rU/HpvXp2PLj/4wCEc7qE0RkJ41/gQ4fO4aB06bZvd6Zb75B9+iWE5+Cc+cQO2aMZLnJd9yB9UuXWjzh/ubHHzH24YcNn1c++yyeFn2WU3DuHD7asQOL//xni8ul3ncfUu+91+aTPLk6AMDeDz+UDbzIlctcHqYm33EH7r/zTiSPGoWwYMsng9u+/RZ3PfaY1fyWPvmkpK6m7QtI9585fZKTjT5nvPoq5s2Y4bT8LXF0X6z/6COr/cIWwtGjAByvn619VO/D11+32hdc/T0jcjdeSheAyJLN69Mtnshq3bo/LcPHf31X6WKY9eWnH5udt+5Py1B5tbxV+Tuzf2R99C+bAxBiJ48ddcr2iaiVBEHTqfTyZae0W/7p07KLbfv2W7z85pvWy2LHftn27beIHTPGppO79H/9CwOnTcPho0etluHwUfN/l7fv2mVTe5prB3NtM+vpp/HrZ5+1WL6X1q61GoDQ5zdw2rRWt6+l9a5WVjo3/7bYF87Sivr9a/t2m/uonr4vlFy6ZHf/aovvmaYSqQavhKA2I9fOgsx0a/tj0/p0vGRmtNvcNhwphy1syfv9b/ciMjrGYj5R3bobrWtLPiXnivH5Pzdi8/p0o+Ve+c18JI6bILmU31q9x0+bgYSbB0mWKbtYgmcfmmU0bfEfVsouGxAYaLYdK6+WY92flpmZ2+TAD7sxOmWyxWXaun8ATVdsPGNSZ6Dplo/pD89Dj/g+8A8IMCz7/c5Mw364cK7I7n0px7RPEBG5m/RNm+y6GsGSf2VmYtZi+28JPHrypNXtf/zll2bnLUtPx+I5c6xeseCIbd9+i23ffovjmZno3aOH8bzvvsOy9HT5FT2YUvvCGRzto0BTX5j7u99h/auv2n27jjO/Z0TuSpNBCFKXzevTMX7aDNw62rbLIpVmz0MT7cknult3DBg2HO07dESGycl9wYl8u7cZ3a277DrnzhZIpiXcPMju9j9hcoXA/OeW4ErpJaMgyvc7M60GIaxxRv9469WXJNPmP7cEDy9cLHmQZXS37hidMhl3PTAb61cslw3OmHJWnyAiCzgKJrH3gw8QE2n+uTkA0D0qyq62S9+0Ce/87ne2LWxmdPLw8eOyJ3eTR4/GvBkz0KdHDwT4+xuWzdy9G+mbNgEAii5csFje8spKqyf7uw8cwOTRo22rg4i4PatranAoJweznnlGstzqjRslbWR6BcTk0aPxwvz5GD6g5Xa+ktJSfLNvX0uetuwXR0eAbV2vFSPMrd0XM8aPxyCZE/GS0lJJu6985hkM6ttXsmxgQIDl8pup3zf79sn20dR770XqvfciPDQU3aOjUVJaiisVFdj23XdYvGKF0bLbvv0WL7/1lu3fFxFnfM+I3JkmgxD8nrqG7Ci0zN9J0+XmP7sEx385jF2Z2wzT/vGXNRh2u/QkU3Jlgg35m1vOmjbN2458fjX1HkkQ4ujh/0rax9GyyV7lZ2a6Jbuztht9HjVhEi6XXjQKQmxen47HXvw9Iiw8XLKt+8dP+3/Ed6K8AOD2lMl4KG0xgkLCzNb75qHDsXz9PxAcaryMs/oEEVFrxURGtvp+flPpmzZhxoQJGHPrrQ7n8dIbb0imLVmwQHZUvHt0NCaPHo3ZU6ZgeUaG7Imm2NETJyT5XrpyxRDEAIDM3bsdCkKYtmfvHj0w5tZb0XnUKKPl0jdtwvPz5hmWzZW59H7ejBlGAQgAiOzQAfelpCB51ChJPdSotfuie3S0bP8tOHdOMm1Q376t6pNi5ZWVWPP3v0umf7hiBe5LSTGaFtmhAyI7dMDTDz2EcbfdhoF3320033BVQ58+dpXBGd8zInemyWdCCEwuSba2vamQ9u2RMvN+o2m7Mrdh365vHNqGreVwZd6tySekfXibl6219aq4Wo6MPxsHSnom9EX/IdIf05/+s8+usji7f3z2z42SZR58fCGCQsOs1lNuGVu2yaR8Ig+k9L3I7pCc1SYiSxYskJwkrvn7320rg8z8H//3P2z77jujxSaPHo3FDz+MsKAgs/kOv/lm/OOPf8SYYcMsln37rl1GeU8aNQopI0caTUvftMni/fr2tGdkRAQ+NBkBB4D8M2cMyxSePy+Z3yc21ux2w4KCMPzmm527j21dz9H823pfuLAdDv7yi6SPrly8GPclJ1vMe0Dv3rJ94eOdO13+PdNsItXQZBCC3N+I8cmSae//ZU2rH2ToCa5ekT58LGGA9VsCXCnnvweNPs97dgmCQ8MQ0SkSMx5JNZr3/Y5Mu/N3Vv+ovFqOjzZILxXtN2iw3WUiIoUpffDrDslZbSLSPiQE95uM/m777jt88+OPDpVh42efSRZZ+OCDFgMQ+mRtmfKKCixbt84o77433IBbb7pJss19P/3ktPaMDJcZHLCS16GcHNfuYzlt2Iecvi/aqh1klvlo507JYjPGj7cp/+QRIyTrLlu3zuXfM80mUg1NBiEEJsVGG21ZTkDTCPMf//ah0fRdmdvw/ZdZVte1pRwl54pRfLbAYnKk7JaWc1ZbfSXzxomuN8Q5tWytrdOXn3xktP7IiZMM80ZMNP6R/WhDOk7n5dpcHmf2j0sXLsDUvGeX2HQVRFu2H1PbJyKyXbLJ6DUArHn/fZRXVtqVT3llJdI3b5ZMH3zjjQ6XTezgkSNGn5fMn4+w4GBERkQgdeZMo3mZ33/vlG3aomvnzpJps559Ft/s2+eyMriau+4La+T6aOrMmTbf1hQWHIwl8+dLpsvdQmLKWd8zIjVgEILJpQf69iyXJDPa/duHZqHiarnd2zD1f2NuQ3LfWItJji15J/eNxcBgnWx669WXHGqr0oslOP7zYbz16kt41+Q2h6eWrzS8WcHR9nfWevqyml5d0DOhr2G+3C0ZOYcP2V0eZ/SP88WFkvkh7ds7vd872ieY2i6RB1J6BM4dkrPaxCSPsKAgfPinPxlN3vbdd8javdvquuJ04eJFSRGXzJ9v01UQtqSPTN7EMGnUKMM8yW0Amzcj99Qpp7RnSWmpZFHDAxEFAb1jYzH59tsly4ydOxePLl2Kw8eOtf0+tnU9R/Nv633honaQ66O39O1rV9mGyVztIb49p62/Z5pOpBqaDEKQOgSHhuEPJqPdAPDDl1kKlMY51v/Z8isrxVL6xmJQsA6DgnUY27Mz7r1toGT9uc8uwa+ffNrZxWyVX/5jPLIzt/lWDL2ITpG4x+SWjKzNH9i9nbbqH31cfGuLPX2CiCxQ+uBX6SQjdsIE6G6+WTa99Oabth/EC/KXmc967jmUV1RYXVefCmWuPmsfEuKU+peUlkpGsPv27GmYf2v//pJtHzp61L6TGTPLfpApva3whi5djJZZ+OCDslmmb96MgTNm4K4nnmi6MsLeE6zWnJw5M/+23BfOagsb1pHro726drWrbEHNr/S2uC0z853xPdN0ItXQZBBCYFJ0tNHacuLpSeOTMcrkFY7PPzQLpRdLrK5rrRz2clbezshnVMpkrPnoczz2u6VOaf/WriNOps94GCG6FUOfTG/J2J25zeItGebK4oz+0Zq6tnWfYGq7RKR1y959167lw4KDJaO0AJD1ww+tKofcKxgdse/nn40+L5k3z+hNG5EREUidMcNoGbnggT3KKyvx0ltvYZvJAxiXzJuHyIgIo2ljhg2TbT+9bbt2Yey8ebjrySfx408/tapcSlNiX3iKtvqeEbkbvqKT2o5MO8sGKs0sBwBBIWG4/7GF2G3yCsXtH/4DDz7xtMV1LeXvKFvyfuTZJQht3152/e5xveX7n51lHJU8GSMnTrbcl21tf5ll5PKy5XtTdrEEH5veitGnr2TdGwdLb8k4+r9D6B7XW3bb5srY6v4hM//6tWut+xvhrD5BRHbS+hfJ0RCotWktobvkEUmYfPvtRifds557DmOGDW0+6Ta/ruXttX7fmT5XYNKokZJ8U0aOQPpHLc8s2rZrF3JPn0bvHrFmymXs3S1b0D40BACQX3DWKC+xedPvll3/vokTEBkRjjXv/1MSuBCXaduuXfjwT3/EfRMnWi2T4+0nt55z8nf+vpArkyPltGU9Z7SBI9tx5veMyP1pMghB6jL09jEYlTwZu7NaTjRXv7AY46bOsLCWZdtzziCqW3eLywwO0TmU990PzbOaty2W//VDRHSKBAB89elH2CI6uV/2xHycO1uAx15a2urtONOBXd8YfX7E5FYMvYhOkZj+SKpRnXZs/gAT7rnP7m06u38U5Oc6tJ4lzuoTRGSB1qN5MvVfMm8u2oeEyi7eW/+KSGv5CC3TwoKCsPCB+yUn0P/Y9gWe/r9fW1zXXBmvVV1v9b4rKSuTBAQMl/+LyN8GkIPesTJ/n2XKZMvVI//bvAndo6LM1mnM0KEY3Lcvsn74AR9kZWHbrt2yy8167rfoER3d9KpOC2Vy+DJ0033jpPzbZF/IlcmRctqynjPa2JHtOPN7RqQCvB2DqU2TrW1vbZlZjy+U5PW/fdk2rWtPOVpbdlvztiWfm29NxJDbx2DI7WPw/Jp3sHD5SqP5G/68DLuztjmlDs5ab4fJsx02/HkZBofoZNMWkysmdmdtw/GfD7u0f4RGdJCsV3Ai32X9nkm5RKQF8+6+G0//369l0+TbRzmU55hhwyTrLl61yqan/8vJPXPGofXEvtm/3+jzknlzjS7/12u6DeAeo2kfZDnnOVOpM+7BmaxMDOgtc0WfibDgYNw3cSI+X7sW/85YZ3ZfLN+wwSllcyV32BeewNnfMyJ3wyAEk0sP9G1ZTm7+kNvHYLrJwwxffHgWrlddszt/S8u1tuy25u1IPlNmz5Uss2jmXZK3QTijbI6sdzov1+hqBEccObjfpf2jQ5T0lVtbNqRbbNO2aj8m1ybyQEo/EM0dkqRNHGwX00xM5i+8/37JprL/d9jquh3CpFfG5RcUtLreH2Qan7wue3c9dAMHyab0j4xfc71t124cPn7ctvYUWfnUIqx8ahE+X7sGx7d+indeeKHlCgg70pihQ/H5mjX48A9/kGxj267dKCg+55x9bKJ3bPc26UNtti+MkswOcdJ3pGtkpGSR/9rz9hJBaFreRFzXbi77nmk6kWpoMghB6nS3yUkmAOzZqZ0HGQWHhuG1v0rfBvHfPfKXcrra8cOHWp3Ha09I361tK0f6R0SnSIxMniyZnq3iN7AQaZbSB7+KJ9lGaX0+grRtxwwditR7phstNuv553Ht+nWL60Z3kF59lv7xx8ZP/rcz5Z4+jW27W/c7uP+XX2xqzzOZ2yEcOgjh0EE8/eCDePrBBzF55Ej07m7mhN6OdN+E8Vgy9xHJNotLSiyW6fLVcqt5y71CNMg/wKY629OH2m5fmCS5gsr0U0fq117mqo1d/zlo177c9Z+Dkjy6R3V22fdM04lUQ5NBCIFJsZHG1iwXf9MAyYmm6SX9cuvamr8j6zmat6P53DY+WbLcp399t1V5Omtd01sx7n4kFWnLV1pMcoGDXJNbMmwti6P9Y8JM6UjDiw/PwrmzBVbrfO5sgWQ5W8vLpGwiotZJveceybRMK0/wj4yIwORR0lsPsvbscbgch2RGne01f6l7vCr5jiFDLc6P695NMu3oqVNW8z136ZJkWqC510i2gifsC7k+um33bptvGzqcmysJxMgFl2zlyPeMSA20+WBKHoG6hlw7y50ByH02s4+mz0nFJzInlnblb2UbiuVtQz7BIWFIe20l1r642DDt+6xtyPvpMOJvGuCcsjmw3pn8XHxvcivGrMcXIVbubRcieT8fluzP/d9+jfj+orq0cf9I/JU0sAMAd/WLxYZ/78VNQ4dL5pVdLMHu7Z9h+ZPzkfbaSjzwxNPmy2ulzETkJJofBZOpv0OjgzJ/dGXyGBAfj9Tp05G+ZYthWvrHW0yWkq57/8QJkpO0Wc+/gMSbb266ncGCgvPnAcBouQ+ydhgtkzp9uuzJulh+wVmjcgPA4ePHTZ7n4Kz2bHqVJwDZZyOIlZRJr1iI6dTRsM2woCDJ/FnPv4DkxESLeZve9gAAN3SJkalL6+rcdvtCpkzSiTaU07b6yfXRf3yxHUsfe9Ri7uWVlXjp7Xck0+8ZO9aGtnbu94zI3WkyCMGvqWu0QQwCcTcNwJOvrcQbopNwe/O3tg1zbM3707+9ixAzr2PUmzJ7rtFbI+wp49DR4yTTtryXjudWG//wuTAGgf/+IH3VWPe43la3FWcaOAGw9sXFuEvUPm3dP4JCw/CXbf/G45PHSpZ/ZOxtGJk8GYNG3G6YVngy3yjQYZqns/oEEZG7S71nuuQE0prkpCTZ6bGT7sTev/0Vw2+6STKvpKwMn+3ahfnLXsPKRQvx9IMPAmh6qKXpyeKiB+5vevOHBYdzcyXl/nr/fpseKumI9Vu3YtfBQ1h4/yyMGSp/tUNJWRlmvfCiZLo44BIWHIwljzyCZSYPrFz5939g8f/9WjYQ8a+dOyV1TZ0+vflVj86jln1hi8QB0mMTfZuba+eC8+fxh/f+KmmD1OnTW10XR75nRO6OQQhqM44GIcxN0xszdYbZk0y5dZ05MG1L3n9dYf1SwqGjxxlduWBPGeNuGoARyZPxg+jKg082pOP/nnre6DWQrgxCLH/S+FkOz7+RYXP7Pv9GBv5gsv6p40fRv/kKhLbuHwAw+PYxWPreh3hpzizJvO+ztkmu8hALCgm1GoRwpE8QkZ20PhIoU/93P/kE7UNCLK42d+pU45Mq03wsjIQPiI/HyoVpWLxmrfkymawbFhSEf7/zNsY++phk8dseehiTR43E7bfcYpiWf7bQ+ARMlOeug9JnERmez2DBgPh4ybTFq9dg7pQpLW0hl4ej950LArbt3m04Qc148UX06trFMPtEYRHmv/aaZLXPV6+SbO/XKcmSIMSyDRuwbMMGo3xLyi7jg507sG3395J8F90/y3z9TMROutNi1S58uRORERFtuy9sKKdN+8bG9bp37oyMF1+U7BN9O69cmIZBffoAAK5VV2P/L79g2Yb3ZDf5+wXzbWtrJ3/PiNydJoMQpG5R3brLnriqSbnMJZf2mPrQPKMgBAD8vC/bKAjhKnk/H5ZM6zd4mM3ryy27Z8d2QxDCXo72j1/dcx/aBQVh8b132bzOiOTJGDlpir1FlNXaPkGkeVo/CJepvrkTI7FxQ4dhQG/RiaDs5Wfm23bG2LEWTo7k1x0zZAg+fG0ZZr24RDJv2+7vZU+c9UKDggx5mp4kZrz4gs39IOPFFzD/teVG046ePNlyJYZsBNzRIITxR7mAg6klc+Zg8ogRku317t7dbNvZku+Hry0zHxxwoGrnLl5CZHh42+4LSTnNlN1qEMJMXjLrzZs6BQXnzmHZe1t3z+8AACAASURBVNLvkNn+buJ///wnIsPDbWvrNvieEbkzPpiSqc1Spy5dJW3vFxAgWS40wvhp2YHNI8uW0l0PzcMTr62U5D9k9DiHy2GaHn7G+Ae+Y3QXyTJ9Bg3GCJm3K1hzQ7/+FttgRPJki2UckDRKst2TR484pd5+AQGSvEMjOphdvrra+CnNI5InI+6mATb3E/2VHWJ5v7Q8nLKt+4c4JSVPxleFV/Dqex9a3K/THknFm9v+jRWbPkd4p8g26RNMbZuIqElpeXmr1u8eFdV0wmmn+8aPx+erXrdrnckjR2JK80MDD+fmSeYP63ejzXnJLbv9B8cfkGlJ0oCb7Vp+yZw5WPqo9MHNeo60HQB8vup13Dd+vN3rWaOmfWGPpY+mOtS3U6ffjTPbPjcO7rWSo98zInelySsheADqGt3ieiP7qrS1TafE3TRAspwt+2jWE09jlviBgGbWtbUcpua9tBTzXlpqcZ2g0DD8edPn1gsrQ5yXXBtYKqO57YqXd7Te7TtFWs1b7Mahwx3af2KWttfW/cNUUGgYxt1zH8bdcx8uXyxBbXW18fywMLPPq9Cv74w+QUR20vhI4OCEPpg8ciS2fW/+KgI5/W/oadR2HcJCjeaLrzwwZ96UKbhaWYnFa98wmj5u2FCL604eMQJXvvk3srKz8cHOL82WPfXuuzFj3FiMGTKkaYIg4LrJ3+bJI0diQHyczf1gQHycpL0O5+UZ1jdth8kjRyLA19ehfja8f3+c+fwz7PxxH+YvX252uSVzHsY9Y8c23aJgZTuTR4ywKU8A+HDZ0pYHf1rI15E+FN0hAieLio3L5uR9YSrA11eyfIewUKvb69qpk2xeltabN2UKJtx6q03tvGTOw5iUNALDb+rfNMFCvq78nhG5I50geH6vbWhoQFVVFUpKSvDYoQt4ZUKi0kUiIiIFvbIzG2/f0hmRkZEIDAyEt7e30kUiO4l/2wvSfoM7fveK0kWiViopK0N1ba3RtLDgYKtvlVCbgvPnUV1bi8KSEgQGBCCmY8dW11OcJwB0jYxEgJ+f1TeOkH30b2jJLywEAHQIC0N4SAjb2U18++or6L72Lf62qwCvhCAiIiIixTn7jQ3uSn/C2ru7857j1BZ5kpS+nRl0IGodBiGIiIhI/Tz/wk4iIiKPoMkgBBEREXkYBiGIiIhUQZNBCB6mEBEREREREbmeJoMQRERE5GF4JQQREZEqaDIIweMUIiIiD8MfdyIiIlXwUroARERERERERKQN2rwSQukCEBERkXPxSggiIiJV0GQQgoiIiDwMgxBERESqoMkgBA9TiIiIiIiIiFxPk0EIIiIi8jC8EoKIiEgVNBmE4HEKERERERERketpMwihdAGIiIjIuTjCQEREpAp8RSeZkY8t43UYE67DmPAF2Kd0cYjIRBZWhTd/R8evRZHSxSFSmsDExMTEpOlEqqHJIITS3w9VpK9W4C8HmhvsoakY5kAehV8taA5i6PD6V/mK1aXwnZZyPPGOcuVwSjq1Fq8bgkNNJ5+Frqy3HdvXQlK2byUj6SE0ObAZe08p3x5qSuSJlO5VSqdCrH18NHSjR0M3eiWyFC8PExOT89OPWDC6+Xv++EdQ+VFtGyRSCwYhmGTTvswMQ3tNSkk2mZ+PfYuS8GS4DmP1aXwSVr2TZXxCmv+LIY/T+crVpTC3pS5HcvMUb1uH06m1ePKWhdiuDw4BwIEc80EIZ9fbzu1rISndt4amzG/eejZ27eChiD2JPJDSnUrp9OO/sPBIc1vcOQLJSpfHDVL+R69DN/oO6EbfgaSPihQvT6tS4cdY8PgdhvroHv8Y+a6qs43b1kpStl/diql3osmR77BdywdhcolUg8+EIBlZ2PM3/f/nI/FX4jbLwprwFGw3XeVANrYfSMEp5GHto3GSHJX829Cl93wATSeL/XrHq3b/F+/YDP3xZb/lxu0sVydn19ve7XuEU2uRdstC5ADAQ5nYuDoZMaLZivetX03FJGRgO4Ajn25H0aNpRuUj0hSNPxMi64cvDP+fnzTMTHsUIWvLJiz77hSyjxwRTb8RiTf2RP/RSXhm+q2Q/oqrU96ZljbJPnMWEFT6F7JoC5J+/Rdki6cdOYM8QZDsK6fX2Y5ta4XS/So56U7giy8AHMHmvYVIm97FpdsncgZtBiG0fZxi3alcnNL/f/ZUDBVaTjIPLGoJQPRbnolnU5tPyk5l4dM3lmEXWtrXtJmVavfo1HX4MnWd4uVorcLj+kOARNw+Ic5qPZxdb3u37xHEdTySC0FINpqkfN+KR/ehAA4AOLAZP55Mw7Seri4DkbvQwh8lc/Zjq+G8aBKm3ipti/x9qzD7+e3GJ5MGR5B95Aiyj3yBjDN/gPDUsLYrqgvFx04Cmo9aEmO7QK19JP/H7wz7LfHxv2OP4aRTWh9n19mebXuMoi1I+vXbTfW+8w/Ie2qYUcBF8X51axLm4wtkAMj+bi/yp0/XbECI1EuTQQiy4kRO08gvgH594kUzsrBno/7/ibh9gmhUuGcypq1OxjRXlVFz8lGYY30pz90+yYvDrdMS8c6BbADZOHMCAIMQpFWaiIyaUXQWhhsgJyUh2aQt8rekIf5t/ZUPN2L+Yw/gmemiE6uiIuQX7cOK999GhiB4TFvG3b0Iwt2LWiaotF55p1v23cxbYyzWw9l1tmfbHkNcxVNnAWGo0Wzl+1UM+t0I4AiAI7uwvfBupPFiCFIZPhOCSZL2bW+5z71HXJzZW62s5dNosnzh1wuwcIIO4yOa0sJF8g81LDyVhTUTkrAwomXZ8RFJWLgoS7r81wsM8z851fSsCsPnr5vzMyyjw8L0lvvmC9P1yza9/aPw6wVG2zRXPqG5fOONyidKE2x7WGPh12ul+UxIwpp043o2lTMe7xiexZCNdwZL6yPN3zn1tmf7ttbJ5n0nV1ZxH5qwFvtOtdTXmf1r3yIdxg9eaAjI4cBCPGTSnuba2JH2cLQ/Rsf1N3zHTufzuRC2JvJASncqJVPhmZbR6tguJvM+wWxRAGLNxrVYd/cwxImXiemCuKF3Y93aryEsGqZ8fZhEqQi5p9FCM9tWOIkpXRZJ6oJJt9/YXLgjyOFzIeT3G7k1BiGYLHx/E9Gtl3hePLoZgsHZSB+chDVf51s84dbLeSEec2ZmIEf0UMOcjQsxZ4L0hHfO4BRkHsiG8cB7NnI2pmBOxALsN7ON3anxeGljtmH5M/plRA/IhOy6v+DDCbqm8onLvHGhdHtfL8CE5vJZYq2N9y9KwpyZC6X5HMhG5gspknZxaFtOrLct27e3TjbtO7myivvQgYV4afACrFkkM6+V/csaa23seHvY0R9NyppzXMUPXnVxIk+kdK9SLmXtaXlSU/+uMcbzNr/dEqB47FmkdbEj7/2roRs3DrpxT2JtURGyVj/Z8nm/8bL5+7dgQZp+fnNKexILPtkneYJ//ictyy3Yb26b45D0SZHMOquRBQH5+1cjKa1lW0lpq5FVZFomO/ISlTtp9Rb5tw4U7ZPW0ai+ZtYzrb+NbdVUztktDxzFESycLa1PW9TZnm3bs+9t6VPW9/UWw76WzDOz7/Kb912S0T57EkmrjcuYtXocdLNbvjM48jbiTdrTXBu37rtgX1+M69rD8J3/pVC+L2gzkVowCMFkkqSX3bfMi8PUZ+aL5mQja2Y8HolIwlOLsmD6J9BUv+WZ2FAmIOtgJpL1wYwDC/Hx1ybrDJ2PBZvzmpYtE5BVlocFhuBHBrK/lttOttEJqLjsctOMpzetK1s+o+3l49MV+qtE5uPVg03l27C5pU36Lc9D1s6mhwOabeOvF7SccA9tySfrYGZLPQ8sxOvNI+sxqXtM2iARC5rXeT01zux2nFVvm7ZvZ53s33fNZZ0tKqthXgayNpqZ14r+NWS1gKyDa9DPsN4awzr6eptrY0faQ1JXq/2xOfXq11LGnFzJ95DJtu8HeQD9bQRaTAb90K+LeN5+bN3eMm/mrdEO5735T7ORsl1/gJCDHNEyWavTEP/CO8g4YnIAcSQHGW+/iPgnP0G+Ub5W9pvsPMNEbF2dhvgXtiNb9GzN7CPbkTI7DWuLROucPWUlr1NY9uSvmvISFSl7+zuIH7caWeJ19q2GbvaL0joa9UHr/dC+tjK/KbPbcFqdbdu2/fvelj4lU1ajff0OUmavxoLVMvO2vyPZZv6WNMQ37zvjYYEcZG9/0bjellht49Z8F+zoiyZlzT5TqPzfIHdJpBoMQjBZPECXzBu3Dhs2z0eCUYs2jSI/EpGET09J8wCAhOV5WJmajGgAQs9k3DMt0TDvlOgS8ujUPcjcuQ5TxsU1LQtAQByGmVlebjuZZQIyy/LwxDjp/EYL61kvXx4K9CfLs6diSM/mMo97BvObTxKtj0SLAxmJmJ++zpCP0DMZU9LXGNo254UVZq/6sGcftr7e1rbveJ1My2Jp32F2JlauFpV1eaJN81rbv0xvK7Lexo61h2lb2LNfLJWRyfr3gzyE0ge/iqVC5J4y0w7iZ0WgB3pHt8zLWj0eul9JU9InohMagxxkS869m5fZv6blRLJfCjL/thPClzsh/G0p1ugjpDnvYLZsvqJ8ZOc1ykzPRMb2HCBlKfK+3Anhy/datoMcLNy0z468muqV+GhzXn9bivmGvDKxdX9LG6/9Z2bz9JY65r2WYsgp8dH3IKyZijhL+8rOtoqbttqkfv2wpnmdPdPMBJScVGebtt2qfW+hT5mWNUVUVsO8TGRsNzMv5x2s2G/SJv1SsOa195r7jGm/aal3ctpOCH9LheFXt1+qYR1Dvc21sRPaw3pfbE5dureU8dRZaaBHq4lUQ5NBCLIkD2cNo9L90UXmIXfR49ZhVVleUzDC6Fk92cgYvAAyg9rSPET3sR87nmc079ypLGxdlISnJuiQEtGUHnnB8u0PAIDZmViVqn/MVuueEyxfPtHtKBu34kDzQd+5r1cgo7nSCUYP8pRjpX179hY9V/AXFJ2CS1naL+Y5oU427DvTthWX1dI8Uw73L5s5fx87tl+INEbpg193OfBuFE1vFM3r1w3xthysC2bWB5CYugHCzh0Qdm7AuiECjE/O+2HN4ieRrA90RA9F2uIFhhOl7Hc+kh9lbxTMb9OonqJ1+i1AXtrQ5hP+GKPtIDNbfjtm8kpM3YA9U5vzih6KZ0YZzvzwy1n9yWIRcvQnzCm3GeoYN2S64eQy+0yRlf3kaFtZ2L+yyVl1trZtB+tjtU+Z1CFlKfakicqa2s+meeJ6xE1dBWH1k0gbEiMKEsVgkrl6G5XR1jZu/XfBrv1itYwaTaQamgxCCEwWkvi5D00nSPLLxSFq3Dq8vlPA+s3iWzQysNf08ncz7S43rzg9CY8MTkHGxmwcsxDNsJaPLduyv3xxmGK4HSUDLw9uPoGd2TLqPWqC+dsjBACC+PWnQ/uhi2QZcfsbl8tSG7Rtva1s30l1srcO7tK/JPPbqD0cncdkfb8RqVtxywkyYtHb3FPycwogDmEmp+1oPvnbgTzxiZ05KUuxZ5o+c/2/VrbdpStaQqhnkFtkfTO2SBxl/MpEZ24nrkus4f/ZBcXN/4tBP30TZWYjqzn//P0fY2Fz/RO7G94XZoYybWUL+Tpb44T6yPYpY6btKi6rpXmm8osOYO3ap5C0aCJ0E5pSfLozX/vl/P3r2H4hUgcGIZgsHqDbsmzUuHV4ZbZ8G1tqd+m8LHxsGJFOxLzNefiiTMAXZQLeFV96bzUfW7blSPmAA/o3hwxNFN2SkoiE2WvwysE9uKun+TIIAISevdFDv9qBHJmHeopu+UB/xPSUL5O9+7G19ba4/VbUydK2nFXWlnlt078k89uoPRydx2R9v5GHUHoETrEkOkHGGeQWiubFdDE+8Sk0l4e4HUVtaa19Cwtbbvfo1934SgtJ2SC/PZisYzLLahlt3Y6tecnWOQZps/RPG8pCypzmk9iXsvSVx8yhMZb3k1Paysx+sGVf2l1nK9t2tD421cXWsto2L/+TpxA/5yUszJS7BcRKW8mWU2Y9Z+xfm/eLI/1CI4lUg0EIJpMUhy6GP5LZOHvCtvXMtbGldpfMO5WL0/oJs5fgrnG2vR7U0jZas660fGvxr41NnydO24gVZQK2lQnYVrYHK1anYbC1AAQAq1eaiNtgaD+jB1yasne/OFxvq9t3Tp3srYO79C/p/LZpD7PzTuTgmH5Gv96IMlNOJsv9mTyA0ge/iiVxIzQ/ncYwbwimGp7Um4PN+4vl8zB9soxs3jLrxcS0BDlyCpAnybvQeHQ4RmZ7FusDG8pouh1RG5hbx2Je8nXOym4OOPRLaLn1AwlITJ6PzA0rkRYj0z7OaCuL+9eOfelAnS1u2yn1sbMOlvqH2Xn7sWKdviAJWPPqBghZmRCyMpG3IEE+L6OMbCyfM74LFutjWgYrZdRqItVgEILJ4sG50bxTa/FMRBLeSs9C8amW6cVfL8ArzSfnGLoG08bZkJfcvJ69EaufsHErDp7S578Wq0zu2bepvDYsY1f5RJ93vBCPyRG6ljQhCc9MWGAos/kUhyGGhwxm493UtS3rnMrCZ6kLDSeUCdMmSU4ordWzreptefuO18nStpxVVsM8R/qXeJ0DOYZ+X2yxDG3THrbMS+gT36Z/GzwpkQdS+uBXsRSF3rH6RjiGHJOrHZKHTzQ0Ufa6FVhbLJeHhXa02MZd0M9wHncKuaZ5Fxe1jA4niJ9J0ZLlL4XGgZGsvVlmttcyObug0Px2jB7Aaa7sVvqNaZ2Lt2JZc7Hmj1iMPZnbIWRuh5D5OvY8MaXl3n+LydG2EkzOU61tx0l1trrtVtTH3LbsLast88TlSJ6FtCFR1rcj1ii3Hbn1Wv9dsGu/FBa0vEUjtovlB6JqKZFqaDIIQZZF92mJ8Z/JzzeZm42dL6RgwWAd7opoSgtEz0SYm56GaIe3nIzbZuv/n4FXBuvzbzlpU1TPNNw3O1F+3oFsHDvQVOa/fG05m+jUjZgrek2jvp53DU7Bev0DLmdn4s+prXu4piupo06O9C/5dVanm34vjLmyPQ7pbxECEBunnj5D5HRKH/wqmowawnjekN8g0xCHOIaFjzyNBQeKRU/TL8b2gmPy61tt3yhMGpXQkveKrcjSn3wVH8DaFRmGE6XEUUMNJ0pxXXoYss3O+Lh5nWJkvfE0UrKMNipflqyXoXvjQFMdTLczfzqSZU9IzJ2oWDiJkZmekTEXupRJLempp5H01Jst9TabHGsr2/aDDXVzpM4W5zlYH1vqYmtZbZkXJbpCIWuvoYz5B7ZidoaZfi9e51gB8vTrWCyDE9rDwf2S2M3KrUBaSqQamgxCCEwWU9SEmYbnHRz7dHvLqG/PNCzcvAYTjJ6HgKbnI8zORHrZHkw28wwDuXbXS+jTMm3Q6jy8vNz4FaAJQ+fj5YOZmGAmL7l8jJLJmxIcL18W9uY0/4TMzsRnZUJzysPLomcK7NyeZaWN4zB5Zx7SJW8Xaarr3M15+NPqZMl6XUyeG2Z1Xzqt3rZs37E6mduWLXWwtR7ieY70r0Gr8zDXKPiUiNi4OCvla117WKqPcVvlo9BweWciuvVS7u+G2hKRJ4nv3vJX7Zeic5L5yU+8i8yJLSdIGS/PQ/ykO6GbdCd0k+Zh4Q7Htx035WmsMWT9LlLmNuc79xUsbD7HS5z4CvZMEQ1RDJnesg52NK8zDyk7jgEJ4tsdLNjxSlMdRNsBJmLJFMeHQsyKnoIlExPk5x07huxjTXVY8B/L2TjUVm5MHfUZgqmGINwOQxnjX34X5t+LJb/O7M+k3y0xV7ZH1t6WL23/LuroL0RiPkoXQAkMlFnRYxKShi5senvAgRwUC0BU86yosWl4dGya/HqC8cF91II92LpANFs8c+w6bC1dJzMvDoMWrMOgBetgalCpgEdNlzebj6gcZpaxt3zn0pdh5wEASMQjTyQbl3n8TPR5IRvHASAnF8VCspUrQuIQNXYd/jhWWk/5esRh0CoBW1dZWsaYs+pt+/btrFMr9p3V9Z3Vv5rXuXPVHty5ynh5QbBSPjvbw7H9InrI5dCZGNyDf99IwzTc+eOGjkRixjFkA8jevR/5d91l8rLjKCT/ZgWE6Qexdsu/sPn0MWSLB4ETEpDYYySWTB+K5OiolrYUNWliN5hp4yikrczApP98gtn/2mGUb2LCRMy8726kDYk2WbdpHby1Cgt3GG5Qw/xXnsIzQ4qx4s5Xmk4QxaOb4rLMy8DGLp9g9is7WkaXJ76Cjb8Z3DTCrBfTA9Bf62YmL8kIqmydD2Lr6eZ8Jr4C4TeDm5c4h6zPViHl3aZ5GXv/g3WDB8M8R9pKQG9RNZrKa2ETTquzLdt2oD629ClzdbCjHuJ5yb/JQGa3T7DsXVF/SZiIJU8Px9Z5ryBDJq/k32RgDYz7Z/+Y5u+G2fK1rj1s3y/nkHtaPycB/WKs9AkiN6QTBM//1W5oaEBVVRVKSkrw2KELeHSsTTF2TTv0lA5Lm5/zMH6TgEfHKVsedyBukz6vZSItVR9oyMe2ifF474B+Xh7+qKJbKUjFvl6Aafc23Y7Bfmefd/6djbdv6YzIyEgEBgbC29tb6SKRncS/7QVpv8EdqY8pXSQFncPaZxY0j7ZOQOa2x5FsbRWVyf/8WcQ3n+wnzluHPXe5bvS3ZdsJWJPxZ6SJN33ucyTNX990cpswF3krTANARM52CAsmNwdP2OeMfJv+NrqvfYu/7SqgzSshlC6ACgx6Yg36bFyI4wC+zMxC6jhPO5yx36CU+cDGphO+4y+m4LEXZRYaugZPpsaxj5FLHMpseR5L0gT2O9I4zx9TsaD54ZTHAGAnth58DMm3KFwkZ7M0YtzG8gzPzDiGzfsPYtJdtzSf9J3D2lXrW0bXRwwxvhKDqC0c2gvDrz/7HKkUgxAkr+ckJA5diOMHAGzcikOrkjFI6TIpbdw6bPnPVHzx5jJkb2y+9aJZn6Hzkbj4Gdw5rumwhH2M2l4W9hneSjMTt/RkvyON0/iBePK0R5C4cwOyAWTsPYh1gzw6CuHS/Z08fDyw80sAQPb63yN+vcxCCY9g4+QozfdDantZe3c2/68PZg5hnyN10mQQgmwRhzt3CLhT6WK4m57JuHNVsuT5AESul4zUUgGpSheDiNxD9BDMTNjQdB/6zh+R9dgtnnVLRpdYoDn837+Li7d9y2MQ0odj7aebsHnncaMHGiYmjMfMe6ch7RY+HJBc4RC26mMQCSMwid2OVEpzQYggH29U1dainZ+f0kUhIiIiZ9H8aGAU0v74KQyPjvaw9ogb9CiErY+2THB1/aIGIe3RQUh71Mx8D2tvcleDsG7rpzA8qpr9jlRKU0EInU6HIG/gWk0dAnwZhCAi0qKa+noEeGnyDdUeyzsoCLVVVfBr107pohAREZEVmglC6HS65iCEDlU1tYgIDlK6SEREpICq2joE+jT9JpD66XQ66AKDUHvtGvwCApQuDhERKaC+thZe/vwNUAvNBCEAwMvLCx28BVytruED3IiINKriejXCmoMQDESom34fegUHo6bqGoIjIpQuEhERKaC26hq8AgP5u64SmglCeHl5wcvLC/3aCfi+9DISukQpXSQiIlJAUell9POrh5eXFw9WPICXlxcQHo7qikqli0JERAq5XlEBr/btOcCgEpoIQug7o4+PD+KD/fDRmXLU1NfDz0cT1SciIpET5y/izmgfeHt782BF5fQDDLqEvijdm40uCQlKF4mIiBRQWlyExj4JHGBQCU2chet0Onh7e8PX1xdBAf7o5VeNMxfLEBcdqXTRiIjIhc5fKUdHHwEdAtvBz8+vaRSdVEk8wBAQF4/LWz9BfU0NfPj2KyIizTl/8iQCJqRwgEElNBGEAJpGS3x9fREQEICRwZfxadE59IjsCG8egBIRaUbO6ULc3q4WAQER8PX1NRyskPqIBxj8g4JQ2aMnLp45jei4eKWLRkRELnTl/HnowiMQ0KEDBxhUQhNBCJ1OZxSE6BbSDlEVV5FbdB4J3WKULh4REbnA2Ytl8K68jD7RAWjXrh18fX15oKJy4t92XdIIFG77HJ179ISXt7fSRSMiIhc5nXMEjSNHISAggAMMKqGJIASAlks2AwIQFBSEUUEVeL/gLHp07ogAXrpJROTRGhobcTj/BO4OrENQULjhQIWXbKqX6QBDYNduuBrZGUW5uejGZ0MQEWnCxYKzuOLtjcDefTjAoCKa2kNeXl7w9/dHUFAQosJCMN7nKvYdy0N9YyMEgImJiYnJQ9O+Y7kYLlxBbFgQgoOD4e/vz5ESD2A6wKBLGoHTJ/JRe/260kUjIqI21tjQgNyfD6Nx9B0ICgriAIOKaOpKCP2ISVBQEEJDQ9G7uhrll4qQfcQLt93Yh8+HICLyQMfOnEX7yxcwKNwfoaGhCAoKMtwzyoMU9RMPMIRERaF0zDjk7P8RNyeN4G0ZREQeLGf/PlQMGYaI7rEcYFAZzQQhAOMRk9DQUNTV1WFQfT3qygqQ/UsjhiTE89YMIiIP0dDYiEO5+Qi5VIxxoY1o374jQkND0a5dO/j4+PAgxQPIDTBUx8fjXHk5vPbuQf/hiQxEEBF5oFPHjuJCaCgCBw7kAIMKaS4IoT9YCQwMRH19Perr6zFUKEPo5dP49kAl+vbqhdjOHZUuKhERtULJlXIczs3HgNpLGBTijfDwDmjfvr3hIIUjJZ5DboChfuBAFNbXoXHPD+g3ZBj82gUoXUwiInKCxoYGHDt0EMXBwfC6Yyzat2/PAQYV0lQQAmh5pZe/vz9CQkIgCAIAIEGnQ9iVEuzKq0Z+YXv0ie2Grh0jFC4tERHZ49LVChwvKETNlVKMxhXcEBaI8PBwREREIDQ0FAEBAQxAeBhzAwzC4CEoDAlFxXffoHfffugcG6t0UYmIqBWulFzA0Z/+h8v9B8BvwECEh4dzgEGldIL+LFxjo7iqlAAAIABJREFUGhsbUV9fj+rqalRUVODKlSu4fPkyKioqcLaqDvt1YbgIf/SMikTnDuEIDw7irRpERG6mtr4eVyqvobj0MgrOX0BgYz2GNJYhLkCHkJAQwwGKfpSED6zyXOLf9atXr6KsrAyXL1/G1XPnEPjDboRWVaFHnwR06tpV6aISEZEdrl66hNO5x1F6/Toqk0YiqGdPwwBDWFgY34qhQpoNQgiCAEEQUF9fj5qaGly7dg1Xr15FeXk5KioqUFVVhSs1dciv98UZnzCUwQfVjZpsKiIit+Wn0yHCuwHda66gl089Ivy8EBgYiODgYISFhSEsLIxPzNYQSwMMtYWFCD50AD4XLyK6R0906NwZIeER8AvgrRpERO6kvq4OlZfLcOnceZw7ewb1AQG4OmgwvHvFcYDBQ2g2CKHX2NiIhoYG1NXV4fr166isrERlZSWuXbuGqqoqXL9+HbW1tWhoaDAELjTeZKRS4n7LP9Kkdvo+7OXlBW9vb/j6+iIgIACBgYEICmp6DWdwcDDatWsHPz8/w32i7PuezZYBhrorV+B18gRCzhbA63IZhOpqpYtNREQiOl8/COHhuNqtOxp73gDviAgOMHgYzQchgKaDFv3oSW1tLaqrq3H9+nVDEKKmpgZ1dXVobGw0CkKw6UgN9P00JycHNTU1AIAbb7wRfn5+/INNqqPvs/oDDi8vL/j4+MDf3x/t2rUzpICAAPj7+8PHxwdeXl68RFNjOMBARKQ+HGDQDgYhmukPQPTBiLq6OtTV1aG2tha1tbWor69HY2OjJBBB5M70fbWhoQETJ05EcXExACArKwvdunXja4xItfSBBX0QwtfXF35+fvDz84Ovry+8vb0ND6hiH9cmDjCQVvBKR1I7DjBoj+bejmGOvtObdvyGhgZD8EF8oMKDFFID8WXJ4gOToKAgRERE8CE+pEqmf6/1ydvb2/B/Bh9I/NYM8YhacHAwBxjII+j77OHDh1FTU4P9+/dj9uzZCA0N5d8/UiUOMGgHgxAmxAe33t7e8PHxMRodER+g8GCF3F1jY6PhQNt0pCQgIAABAQG8GoJURdxXTUdOxJ+JAA4wkOcSP//kueeew9mzZwEADz/8MDp27MjfdlIdDjBoC4MQZpgezPLAhNSooaHBEICIiYkx3I5RUFCA/v37w8fHh+9UJtVj/yVrOMBAnkYfgKiurjbqs15eXoaH9fFKR1ILDjBoD4MQNmLHJzXS//E2PchubGyULENE5Ok4wECeQn8VT319Pfz8/AzTS0tLodPpDPfM8/ed1Ip917MxCEGkAXIjfTz4JiKt40EuqZk+CBEREYGTJ08CaApCNDQ0AOAgAxG5L16nRaQBOp0OHTt2NHy+ePEiAxFEREQqp3+miZ7+eSf8fScid8YgBJEG6HQ6o8s1Te8hJSIiInUKDg42/L+kpISDDETk9hiEIPJg4of6mF6SyYMUIiIiddPpdAgJCTF85iADEakBgxBEHk4fgBAfpFy9etXoyfBERESkHtYGGYiI3BmDEEQaYRqEICIiIvWSG2QQP/OJwQgiclcMQhBpgNzTsXmAQkREpH7iIERNTQ1/24nI7TEIQeTh9CMl/v7+hmk8SCEiIlI/DjIQkRoxCEGkEeJXdF66dIkHKERERCqmH2QQ/74XFxfz952I3B6DEEQawAdXEREReR6dToeAgADDZ14FQURqwCAEkYcz9/RsgIEIIiIiteLvOxGpFYMQRBqg0+nQpUsXw+eioiIeoBAREamc6e0Y/H0nIjVgEIJIA8zdjsEDFSIiIvUyvR0D4O87Ebk/BiGIPJgtl2ryQIWIiEhdzP2+19bW8vediNwegxBEGqDT6dCpUyfD59LSUo6UEBERqZxOp0PXrl0Nn/Vvv+LvOxG5MwYhiDTA9HLNmpoaHqAQERGpmLmrIfj7TkTujkEIIg+nPzjh07OJiIg8j/j3vba2FgB/34nIvfkoXQAialv6UZLQ0FDDtIqKCh6gEHkAc99juaAjEXkW/e+7+HYM/e2WRETujEEIIg0wDUJUVlbyIIU8mhb6tyAIaGxsxAMPPIDz588DaPquv//++4iJidF8IEILfYAs8+Q+IAgCGhoa0NjYKKlnY2OjQqUiIrINgxBEGiAIguSEpKGhwZDIsx0+fBhXrlxRuhgu58lPiNc/eK6hoQHfffcdSkpKDPO++uorxMTEwMvLC7t371awlMrzxH1vi/Lycvz0009KF0MxWtnv+kBkXV0dgoODIQgC+vbtywdTEpHbYxCCyIOJnwfxwQcfGM2Li4tTokhE1MbmzJmjdBGISCHiN2EREbkrPpiSyMPpR0p8fX2VLgoRERG1IZ1OBy8vL83fjkVE7o1XQhB5MPEl27w0U7tiY2MRERGhdDEU5Wn9X/zdzs3NRV1dnWFefHw8AgIC4OXlhf79+2s6AOlp+91Wfn5+6Nu3r9LFUIxW9rv474B+sKFnz57w9fWFlxfHGYnIfekErfylJtIgQRBQV1eHiooKXLx4EefPn0dFRYXhYMXHx8ejR0zEzwQQ/6njnz3PJ74VSdy/PaWvNzY2ora2FhUVFXj88cdRVlZmmLdq1Sr06tXLEIjwlDrbQvz8G9N9T57P9JXUWtj/+t83Ly8vBAQEICwsDBEREQgNDYWfn58m2oCI1IdXQhB5OC8vL/j6+sLf3x8hISHw8vIyPIxSKyco+pMRLdSVWugvS/bEft7Y2IiamhrDyYdYYGAgQkJC0K5dO4+suzXi77u+/lprAy0z3e9a2Pf6vwO+vr4IDAxEu3bt4O3trXSxiIjMYhCCyMPpdDr4+voaAhAhISGGIIQWDs6AlmCLFk/ItMz0RNSTNDQ0oKamBv7+/pIgREREBDp37mw4EfG0ulsjPvnUykkoSa9+0n8vtLL/dTodvL294ePjY7gdQyt1JyL1YRCCyIPpD8R8fX0RFBQEf39/1NfXa+52BK2NilELT93nDQ0NqK6uBgBJECI0NBTh4eEIDAzUbBBC7l/SBq3ud319efUPEakBgxBEHk4/OqK/IkJr7w/nCQl5Iv3VTP7+/pI+7efnB39/fwQEBGg6CEHapfU+oPX6E5H7YxCCSAPEl6ZqHQ/OyFN4e3vL3vft5eVlmKfFIAQRERG5NwYhiDSCJyJEnqlDhw44d+6c4fOlS5cULA0RERGRZRwaJSIiUjF/f3+jz/pnRRARERG5IwYhiIiIVMbag1a19uwXIiIiUg8GIYiIiFRKLgjBAAQRERG5MwYhiIiIiIiIiMglGIQgIiIiIiIiIpdgEIKIiIiIiIiIXIJBCCIiIiIiIiJyCQYhiIiIiIiIiMglGIQgIiIiIiIiIpdgEIKIiIiIiIiIXIJBCCIiIhXr2LGj0eeLFy8qVBIiIiIi6xiEICIiUimdTgd/f3+jaTU1NQqVhoiIiMg6BiGIiIhUSKfTmZ0nCAIEQXBhaYiIiIhswyAEERGRSskFIhiAICIiInfGIAQREZFKmQtCEBEREbkrBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJBiGIiIiIiIiIyCUYhCAiIiIiIiIil2AQgoiISMU6duxo9PnSpUsKlYSIiIjIOgYhiIiIVMzPz8/oc01NDQRBUKg0RERERJYxCEFERKRCOp0OOp1Odp4gCIZERERE5E4YhCAiIlIpa4EIIiIiInfDIAQREZEH4RUQRERE5M4YhCAiIiIiIiIil2AQgoiIiIiIiIhcgkEIIiIiIiIiInIJH6ULQESkJNN753kvPalBY2OjIcn1YfF8IrUxfdiquYevEhGROukEHnETkcboH9x37NgxbN26FT/88AOKi4sBAIcPH1a4dERE2jZgwAAAQHh4OEaOHImpU6di4MCBFt8GQ0RE6sEgBBFphiAIuH79Ot58802sXbsW165dQ1VVFerr65UuGhERmREWFgYfHx888MADePbZZxETEwOAV0gQEakVgxBE5PH0Vz688cYbWLp0KWpqanDt2jWli0VERHbw8fFBWFgYHn74Yfz2t79FREQEAxFERCrEIAQReTRBEFBaWoqxY8fi1KlTqKioULpIRETUCgEBAYiKisJXX32FG264gbdpEBGpDIMQROSR9Fc/nDx5EuPHj8epU6eULhIRETlRp06dsGXLFiQmJsLLy4uBCCIilWAQgog8jj4AceLECYwaNQrnz59XukhERNQGIiIi8OGHH2Ls2LEMRBARqQSDEETkcRobG3Hx4kXcdtttvAKCiMjDderUCd9//z3i4uIYiCAiUgEvpQtARORMjY2NqKysRHJyMgMQREQacPHiRUyYMAGXLl0Cx9aIiNwfgxBE5DEEQUBDQwPeeOMN5ObmKl0cIiJykaKiIjz33HOor69HY2Oj0sUhIiILeDsGEXkEQRDQ2NiI8vJyxMfHo6ysTOkiERGRC4WGhuK///0vunfvDm9vb96WQUTkpnglBBF5BEEQUF9fj7feegs1NTVKF4eIiFysqqoKv//971FfX8/bMoiI3BivhCAi1dPfhlFdXY3Y2FheBUFEpFH+/v4oKChAREQEr4YgInJTvBKCiDxCQ0MD9uzZw3uBiYg0zN/fH1u3buXVEEREboxBCCJSPf2VEFu2bEFlZaXSxSEiIoVcvXoVmzZtYhCCiMiNMQhBRKqmfyBlfX09fv75Z9TX1ytdJCIiUlBubq7hLRkMRBARuR8GIYhI9RobG1FXV4eSkhKli0JERAq7cuUK6urqGIQgInJTDEIQkaqJr4TgAymJiKiystIQhCAiIvfDIAQRqZ4+CHHlyhWli0JERG6goaGBV0IQEbkpBiGISNUEQTBcDUFERASAwQciIjfGIAQReQQGIYiISE8foCYiIvfDIAQRqR4PNImISIy/C0RE7otBCCLyCDzgJCIiIiJyfwxCEBEREREREZFLMAhBRERERPT/7N15XBT1/wfw13LfoCAoKnjiLZJpKJYKVqJhpyb+LCsTqSw1rb4Vdnylm+z6VqRdVh75rUwt7RDs8PpqJWoeIYqAVwgpeOAiML8/YJedndmTZY/Z1/PxmIfuHJ9rPsvsvOczM0REZBcMQhARERERERGRXTAIQURERERERER2wSAEEREREREREdmFl6MLQEREZKnFixdjwIABiI6ORlRUFHx9fSXrVFVVoaqqCkVFRdi0aROys7Otzi8zMxMTJ040e/0LFy6gsLAQRUVFyM3NtTpfXTk5OUhISEBAQACio6Nx5swZVFZWYteuXZg/f77RbS0tvyEXLlzAhAkTrN7e2H5Tq9X4+++/Te6vvLw8q/M3R0v7ChERERmnEvheOyJyYfX19aipqUFFRQW6du3q6OJQK8vLy0NSUpJs0MGUqqoqbNiwAenp6RZtl5mZiXfffdfi/DTUajUOHjyIjRs3mgwWGHPp0iWD9VapVAa3a2n59S1YsMDik3Rr9pvc/srLy0NycrJFeVuqtLQUsbGxrZoHtb7i4mJERETA398fnp6eji4OERHp4O0YRETk9NauXYtLly4hOTnZqgAEAISGhmLy5Mk4e/YssrKyzN6uR48eVuWn4evri/j4eMybNw9//fVXi9KxRkvLry8sLMzsdRcvXmz1ftPsr5KSEu08W9dFTkxMTKvnQURE5M4YhCAiIqdWUFCAtLQ0q0/C9YWGhmLhwoVYsWKFTdKzRFxcHP7++2+75+sIBQUFmDFjRov3W0xMDNauXWujUhEREZGjMQhBREROq6CgAPHx8a2S9uTJk5GTk9MqaRsTGRkpurqvRLbeb7169QIAnDlzxmZpGlJVVdXqeRAREbkzPpiSiIic0rZt28w6kS0vL8eRI0dw8eJFANA+uNGcYfWzZs1q0XMadu/ejcrKSu3n8PBwtGnTxuDDMjViYmKQk5PTorxtQfPwTkuYKvPatWvNDkCUlpaKPhvaZ35+fgCAAwcOtFpQSuPo0aOtmj4REZG7YxCCiIicTk5ODhITE42uU1hYiNdee83o2ydMPcjQ19cXBQUFGDRokFXlNPawybVr1yItLc3gtmPGjLEqT1v6/fffkZKSYrP0MjMzcd111xldR61WY/Xq1QYfELpixQoMHz5cNiCRnp5u8sGiOTk5mDdvnuyy/Px8m9aXiIiILMfbMYiIyOmYep3kypUr0atXL5Ovv0xJScGrr74KtVptcJ34+HhkZmZaVU5jJkyYgPz8fIPL27RpY/M8HW3u3LlGR4CUl5fDz8/PaCAhPT0dsbGxWLJkiXaUxokTJ2xeViIiInIMBiGIiMip5OTkGL2VYt26dRa9ZnP+/PlYvXq10XVMBT2sZeyqe1RUVKvk6SiZmZmIi4szuLy8vNyiOmdkZCAsLAz5+fn49ttvbVFEIiIicgK8HYOIiJyKsdsUSktLMWHCBIvTTE9PNzjEHwD69+9vcZokZmo0yVtvvWVVurx9goiISFk4EoKIiJyKsQcPfv/991ana2zbyMjIVrklwxilvaqzd+/eBpft3r0b2dnZdiwNEREROSsGIYiIyGkYe2WmWq1GRkaG1Wmb2vaKK66wOm1DjAU2lPScg5ycHKPPgtixY4cdS0NERETOjEEIIiJyGgkJCQaXlZSUtDh9/VdC6urevXuL09c3d+5cg8uWLl1q8/wcxdh+a2nwiIiIiJSFQQgiInIanTp1Mrjs2LFjLU7/zJkzBpcFBAS0OH1dBQUFBh/UmJ+fb/LNHq4kPDzc4DKl3XZCRERELcMgBBEROQ0/Pz+Dyw4fPtzi9CsrKw0ui46Otji9O+64AyUlJZJJEASDz7bYvXu30zxsMTk5GYIgmDUZu1XG2OtGi4qKWqPoRERE5KL4dgwiInIaxoIQ1dXVdiyJeSIjI81et7y8HGvWrHHZWxOM3XIRGhpqx5IQERGRK+NICCIichqWnNS7msjISNx4441YsWKFo4ticwxCEBERkbkYhCAiIrKTyMhITJ48mc9JICIiIrfFIAQREZGdRUZG4uzZs44uhkXKy8sdXQQiIiJSAD4TgoiInEZ5ebnDbsm4dOmSxdusW7cOhYWFkvlxcXGIiYlB79694evrK7ttaGgoSkpKEBsba3G+trJ7925s3LjRrHXnz5/fyqUhIiIid8AgBBEROQ1jgQBDr7u0hLHXcFrzCtDCwkKTJ+d//fWXwbLHxMQgJyfHYSf4lZWVNsm7tLQUMTExssts/epTIiIicm28HYOIiFxCYGBgi9Mw9hrOCxcutDh9Ob169UJVVZXB5UlJSa2Sr7Ow5tWnREREpFwMQhARkdMoKioyuKxHjx4tTj8qKsrgMrnbKmzll19+MbhMCSfpxvaboRESRERE5J4YhCAiIqdh7OGHLT2ZXbx4scHnM6jV6la9JcJYgMNYYMRVmHpopRJfS0pERETWYRCCiIicxs8//2x0eUtOZq+//nqDy0pKSqxOt6WseSCmszG134YPH26nkhAREZGzYxCCiIicRm5urtHnJ6SmplqVbk5OjtGRFKZOolsqJCTE4DJj9XUVubm5JkexcDQEERERAQxCEBGRkzH2/ITQ0FAUFBRYlF5WVhZmzZplcHlVVRUyMjIsStNSxkZhnDlzpkVpO0sQIz8/3+jym2++GVlZWRalmZOTg5KSEuTl5bWkaEREROREGIQgIiKnMmHCBKjVaoPL4+PjzQ5E5OTkICsry+CzIABgw4YNFpfREgUFBUZHYezYsUP7/6ysLOTk5EjWWbt2rcHtnSUIkZ6ebrQsvr6+yMrKMloXjczMTBQUFGDevHmIiYmxyUNJiYiIyDl4OboARERE+rZs2YLk5GSDy+Pj43H27FkcOHAAW7ZsET1UMjMzEyNHjsQVV1yBuLg4o/mUlpYiPT3d6nLGxcXJBg00y6655hqEhoYa3F5/FMaMGTMQExODiRMnat84ERAQgMTERINpnDhxwsrSA+Hh4QbLb4ixB3iuWrUKM2bMMLjc19cXaWlp2n23d+9eVFdXa5cnJCSgf//+iIyMtKhMRERE5DoYhCAiIqeTkpKCv//+2+jJaGhoKBITE5GYmIh58+ZZnIdarUZsbGxLiom0tLQWbf/++++LPmtGTMTExJj9NpC9e/danX98fDzi4+Mt2iYkJMTg7SsZGRkYOnSoyTR19x0RERG5F96OQURETikqKsrobRktoVarkZ2d3Sppm2vlypUtfi2oPZ5noa979+5Glw8aNMjkKzuJiIjIfTEIQURETsvPz8/mJ7Tl5eWYM2eOw4IQarUaS5YsadFtIBqrVq2yQYlsLyoqCrt377ZZet9//73N0iIiIiLHYhCCiIicWlRUFPLz81s8KkKtViM/Px9RUVHIzc21Ueksz9/Pz8/g6IXS0lKz08vPz7f7KAhLDBo0CEuWLGnRgzOrqqqwZMkSp64nERERWYZBCCIicnopKSnw8/PDunXrLB4ZUV5ejnXr1sHPzw8pKSkW5z1//nyrruqXl5ejtLQU+fn5ePXVV83Kf8mSJSbrV15ejldffdXsulhbfkM2bdpk9roZGRkICwvDypUrUVhYaPZ2hYWFWLlyJcLCwiwOQBQVFckGPtRqNQ4fPmxRWkRERGR7KkEQBEcXgojIWvX19aipqUFFRQW6du3q6OKQHeXk5CAuLg6BgYGSZRcuXEBhYWGLn7ngKJo3fOg+mPPw4cP4448/HDKKw5YM7bfy8nIcP37cpvtM8+YPV+0HZL3i4mJERETA398fnp6eji4OERHpYBCCiFwagxBERKSPQQgiIufF2zGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGISDECAwMdXQQiIiIiIjKCQQgiUgSVSoXQ0FBHF4OIiBzM19fX0UUgIiIjGIQgIpenUqkAAG3btnVwSYiIyNGCg4MdXQQiIjKCQQgiUgQPDw/ExMQ4uhhERORg7du31waniYjI+TAIQUQuTaVSQaVSwcPDA2PHjkVYWJiji0RERA4SEBCA8ePHw8PDg4EIIiInxSAEEbk8Dw8PeHp64qqrroJarXZ0cYiIyEHq6+uRkpICT09PbZCaiIicC4MQROTSND8yvby8EBwcjKFDhzq6SERE5CCdO3dGhw4d4OXlBQ8P/swlInJG/OtMRC7Pw8MD3t7e8PX1RWZmJh9QSUTkhsLCwvDQQw/B19cX3t7evCWDiMhJMQhBRC5N8zwILy8v+Pr6olevXkhMTISXl5eji0ZERHYUGxuLYcOGiYIQRETkfPjXmYhcnuZ2DD8/PwQEBCAjI4OvaCMiciNBQUF4+OGHERAQAD8/P+3tGBwJQUTkfBiEICKXp1Kp4OnpCR8fHwQEBKBz58545plnEBER4eiiERFRK2vbti0efPBB9OnTRxuE0DyYkoiInA+DEETk8jS3ZGiCEEFBQbjyyitx77338pWdREQKFhYWhhEjRiA1NRVBQUEICAiAj48PgxBERE6MN00TkSJoRkP4+fkhODgYtbW1SE1NhVqtxqeffoqKigpHF5GIiGyoTZs2GDFiBObMmYOQkBAEBwfD398fXl5eDEAQETkxBiGISBH0b8moq6tDfX090tLSEB0djeeeew5nz551dDGJiMgGgoODceeddyItLQ0hISEIDQ1FUFAQfHx8+CwIIiInpxIEQXB0IYiIbKWhoQGXL19GTU0NqqqqcObMGZw9exbHjh3Da6+9hsOHD6OqqsrRxSQiIiuEhYUhLCwMc+bMQf/+/REWFoY2bdogNDQUgYGB8Pb2hqenp6OLSURERjAIQUSKIggCGhoaUFdXh4sXL6K6uhpVVVWoqqrChQsXcODAAXz44YcoLCyEl5cXLl686OgiExGREb6+vlCpVAgPD8c999yDxMREBAYGIiQkBGFhYQgJCdE+C4KjIIiInB+DEESkOLqBiJqaGpw/fx7V1dU4d+4cLly4gEuXLqG8vBzbtm3DTz/9hLKyMtTU1Di62EREpMPHxwfR0dEYNWoUEhMT0bFjR/j5+SEwMBDBwcEICQnRPozS29ubAQgiIhfBIAQRKZImEFFfXw+1Wo2LFy/iwoULOH/+PC5evIiamhrU1tbi8uXLaGhoQENDA/jnkFyNpp+r1WrMmTNH9ADWRYsWoWPHjnxIH7kkzVuPPDw84OXlBW9vb/j7+2vfgBQYGKh9HaeXlxcDEERELoQPpiQiRdL8gFWpVNqHVvr6+sLf3x81NTWoqanBpUuXUFtbq32IJQMR5GoEQcDly5dlT768vb0RGBgIHx8f7feAyBXoByB8fHy0f781k5+fn/b5D+zfRESuhUEIIlIszQ9TzQ9azY/ZgIAAqNVq7UiIuro61NXVMQhBLqehoQG1tbWorq6Gh4eHaFlISAjCw8Ph7+/Pq8TkUjR/sz09PbWjIHx8fLSTJvig6fPs20REroVBCCJSPN2rap6envD29oavry/q6+u1E2/JIFekud1I7paL0NBQREREICAgQHu1mMgV6I5g0500f8N1A8xEROR6GIQgIreg+bGqG4wQBEEyAWAgglxGfX09Ll26hLq6OskJWUBAAIKDgxEYGMggBLkM3X6qf1udZhn7MhGRa2MQgojciu6PWP1gA4MP5Go0o3i8vb0lJ2aa2498fHwYhCCXo99f2X+JiJSDQQgiclv8kUuuThAE7egefZr5mon9m4iIiJyB9FcLEREREREREVErYBCCiIiIiIiIiOzTuCNDAAAgAElEQVSCQQgiIiIFCA8PF32uqKhwUEmIiIiIDGMQgoiISAF8fX1Fny9duuSgkhAREREZxiAEERGRi9J/daE+3VfPEhERETkDBiGIiIhcnFwQggEIIiIickYMQhARERERERGRXTAIQURERERERER2wSAEEREREREREdkFgxBEREREREREZBcMQhARERERERGRXTAIQURERERERER2wSAEEREREREREdkFgxBEREQKEBERIfp8+vRpB5WEiIiIyDAGIYiIiFycSqWCr6+vaJ5arXZQaYiIiIgMYxCCiIjIhalUKoPLBEGAIAh2LA0RERGRcQxCEBERuTi5QAQDEEREROSMGIQgIiJycYaCEERERETOhkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIiIiIiIiu2AQgoiIiIiIiIjsgkEIIiIiIiIiIrILBiGIiIiIiIiIyC4YhCAiIlKAiIgI0eeKigoHlYSIiIjIMAYhiIiIFMDHx0f0Wa1WQxAEB5WGiIiISB6DEERERC5MpVJBpVLJLhMEQTsREREROQMGIYiIiFycqUAEERERkbPwcnQBiIiIyPY4AoJIeXS/04YCj0REzo5BCCIiIiIiJ6YJKm7fvh01NTX4+eefMWfOHLRp04bBCCJyOQxCECkIr5CQO+FVftPPfNBdrsT2UmKdyDLu0Ac0dayrq8OUKVNQUlICAJg6dSpCQ0Ph4eHBYz4RuRQGIYgUQBAENDQ0iK6QzJ49G2FhYfxh4iZ2796Ns2fPOroYdqf5ce4OJyJyBEFAfn4+1Go1duzYIVq2Y8cOvPTSS/D19YWnp6di/xa4676vqqrCnj17HF0Mh3G3/a45zp86dUo7r6amBnV1dfD29lbs95uIlEkluNtfcSKF0fwwuXz5Mjp27Ih//vnH0UUiIiKiVvbdd98hKSkJ/v7+HA1BRC6Fb8cgUoC6ujpcuHDB7a4MERERuavTp0+jrq6Ox34icjm8HYPIxWlGQVRXV8PDg3FFdxUbG4u2bds6uhgO5a4/xHv37g0AKCgowMGDB0XzBw0aBG9vb0VfJXXX/e7j44M+ffo4uhgO4077vaGhAfX19bh06RI+/PBDlJaWAmi8AFFfX+9WbUFEysAgBJGLEwQBdXV1UKvV6NixIyorKwEATz75JIYOHQo/Pz+3OAHRf/Aef5Qpn6ZPq1QqUf9Wal+Xo/n+X7x4EYMHD0ZJSQkuX74Mb29vxMbGolu3bggICICXl5di2kUQBIP7npRPd9/r/qtkmosNFy5cQLt27bRBiNOnTwPg8Y6IXA+DEEQKoFKpJCfhHh4e8PT0hJeXl6IfSqehORlRej1JTKVSwcPDQ9GBNmM0V0h9fHzQs2dPtG/fXhuECA4ORnBwMPz8/ODp6amokVK633fNvnfH/e+u9Pe70vd9fX09amtr4efnh9DQUO18tVrNAAQRuSQGIYgUQKVSwcvLC8HBwdp5tbW1iIiIUNxVUEM0P0jd9WTUXemfiLobQRC0Jyg1NTWoqanRBiH8/f3h7+8PHx8fxQUidU8+3eEklBrpj4DRBNaUvv8bGhqgVqvh6+sLX19f7Xyl15uIlItBCCIXp/kh5u3tLbpC4u3tjfDwcAQFBbnF67vc6aoYibn7PteMhqitrUVdXR0aGhrg4eEBLy8vbQBCSaMgAPcckk/N3G2/NzQ0wNvbG/X19aLjfEVFhXYUpO5tSkREzo5BCCIXpwlCaG670PDx8UFAQIBbBCF4QkLuTHMC4u/vLzoZUfKtCkqrD1nOnfpAQ0MDGhoa4OnpydsxiEgRGIQgUgDNyUZISIh23j///AMvLy/tpLQroca4049TIg25kxF+F4hcn/7tJ7r0nwdFROQKGIQgUhDdZ0Ko1WoAfGAjkbvgd5xIuTTH8YiICO28EydOMABBRC7JfS6NEimc3AkIr5AQEREpg0qlgp+fn/Yzj/FE5KoYhCBSAF4hISIiUi5joxp5rCciV8MgBJFC8AoJERGRculfbDh+/DiP80TkkhiEIFIAXiEhIiJSNv2LDQAvOBCRa2IQgkgheIWEiIhIeQxdaKitrdUe53m8JyJXwiAEkULwCgkREZFyqVQqdOrUSfu5oqKCx3kickkMQhC5OF4hISIiUjZDx3oe34nIFTEIQaQQvEJCRESkbLpBiNraWgAMRBCR62EQgkgBeIWEiIhIuTTHeN2LDZWVlTzOE5FLYhCCSEF4hYSIiEiZeLGBiJTCy9EFcDS5e+b5B51ciSAIaGhoQENDAzp06KCdX1lZibq6OtTX16O+vt6BJSSynO4PbUP/J7IEj/fkyhoaGrT9NSEhAfX19RgyZAgaGhp4nCeXxuO9e1IJbngE1twnLwgCGs6Uov7wZqCyCLj4T+Pyk386uIRERO5N1aF/4398goCIHvDomgTPyJ4Gbz0ikqN7vK84WYUDf5TiVNkZnK+6BAAoPVTu4BISEbm3mJ6RAAC/AB+07xyGXgmdER0bzuO9wrlVEEIbeLh8CXV71wL7v4EKAjw7xUMV2gkq/xAAgEdkLweXlIjIvTWU/wUAEGpr0HCmDA0n9qCh9iI8eoyGauAt8Apuxx8nZJDmeF+rvoydm/7C778UQQUP9OjXERHtwxAY7A8A6Nw90sElJSJyb2WHG4PB6ku1OH3iDA7vP46amlr0GxKLxDG9ENo2iMd7BXKLIIQ2+NDQgLo9a4A9q+DZcRA8uyXBI6S9o4tHRERmEC5Uoq5kJxpKdqCh20h4DroNXgGh/HFCWrrH+x35f2HbDwfRo18nDBzSHW0iQxxdPCIiMkP1mQv4a3cJ9v9xFH0Gd8Kw6/ogMNifx3sFUXwQQht8uFgF4fun4RkcAa++46Hy448RIiJXJNReRF1hPupOHYDHtQvg1aYjPDw8+MPEzWmO9xfO1WDVO7+iTUQohqX0R0Cwn6OLRkREVlDX1GLXlr9QXHgCt2YkITwqlMd7hVB0EELzg+TyP8egyn8e3v1vgEe7OEcXi4iIbKCh+hQu7/gYDUkPwbvjAHh6evKHiZvSHO8rTp3F1x9sx/BrB6JzN95qQUSkBGdOV2P959twffoV6BLXnsd7BVBsEEIQBNTX1+PyP8fgsfFZeA+dxlsviIgURqitQe3md9EwdDq8Ywbzh4kb0hzvK06dxZfvbUXq7cPQph1HOxIRKYm6phZrlv6KkTf1Q49+HXm8d3GKDEJoroioz/0Dz++z4D14MjyCGYAgIlIiobYGtb++hbrkBfCNiOEPEzeiOd5Xnz2PVW9vxrU3D2UAgohIodSXavHl+5twc0YiIqPb8njvwhQXhND8IKmtOQ/hu6fh13s0PNr1dHSxiIioFTWc+xuXdiwDxr0A3+C2vGfUDWiO9xcv1OC/72zGldf04y0YREQKd+Z0Nb77YhvSHxqJkLAgHu9dlOKCEA0NDbh8+TLUv38O//Nl8B54s6OLREREdlB3aBMuXaqB19Wz4OPjAw8PD0cXiVqR5ni/ecNenKusxzXjBjm6SEREZAe7tvyF6nNVSE0fwuO9i1LUHtPcF6q+eA4+hd/CKy4ZgMCJEydOnNxg8uqeBK9jO6A+ewp1dXVQWIyddGiO9xfOX0TB5hJceXVvRxeJiIjsZOBVPXDkz3L8c7qKx3sX5fnMM8884+hC2ILm3eCXL1/G5YKv4OfvD8+OvCpCROQ2VJ4ABFwu2wVV5yHae0U5TFNZdI/323/cj+DgYPTo18nRxSIiIjvx8FABgoBDf5ahe/8OPN67IC9HF8CW6uvrUVtb2zgKYuRDAKNiRERuxatbEnzWZUE95G54eXlxiKZCaY73BZtLMPHeFPBoT0TkXgZc1QOLX1iDUTfV8HjvghQThNC+kvP4XvgFhEEV2AbgzxIiIvfi4QXP6H6oP7wZ9QNS4eXlxSsjCqM53h8tPIWQ0ECEhAXycE9E5GY8PT3RrVc0DvxRiiuv6c3jvYtRRMhI84Tsy5cvw7NsOzza93V0kYiIyEE82/eDZ9l2XL58GQ0NDbxXVEF0j/dFe0+ia69oRxeJiIgcpGuvaBzee4rHexekmJEQDQ0NqKurg+rsMXh0v5K3YhARuSlVUCQ8z/8IdW0t/Pz84Onp6egikQ1pjvdn/j6PTld25uGeiMhNhUWE4OzpC6jl8d7lKCIIoXtlxE9dBZVfMDg2k4jIPan8guBxqRqXL19GfX09h2gqiO7x/uL5WgQE+Tm6SERE5CCBwX64eKGWx3sXpIggBND8vvCA2mqofII5EoKIyE2pfIPhUXuOwzMVSnO8r7lwGYFBvty/RERuyj/QF5cuXObx3gUpIgiheV1XfX09PGv+4UMpiYiIP0gUSPd4f6HqEoLDAh1dJCIicjAe712PIoIQQPMQzaYPji0MERE5HH+UKJPu8Z67l4iIeLx3PYp4O4aGNghBRERujz9IlIvHeyIi0uDx3vUoaiSEzieHlYOIiIhaj+h4z8M9ERGRy1FMEALQ+WHCaBgREZFiaY73PNoTERG5HkUFIZrxZ4m9lB4/haKjx0TzwtuEIr5vzxalAQAB/r6Ijmqn/RzTsb3F5as6dx4HDhVj71+HUX3ugnZ+XLcYxES3l5Sz6tx5/L7noMX56OrUoR3iusVqPxuqHwD06NJJ+39r6qfLFvtCTnnFPzhSehxHj53E8VOntfMT+vWS1BVonTbcvf8QKs9UAbC8Tpry6/cBwHA/MCe9izVqbR81d9/p1mPwwN4IDQ4yO18iksGLDqioOI2SsmLU1FwUzff3D0D7qA4AAF8fP0REtJPb3KI8Dvy1D+fOnxMt6961BzpGd0a/PgPMTm/fgb04c6YSANCmTbhZ21ZUnMbBwn3az/7+ARicMNSivACga5fu6BjdWZSubvu1aROOsNAw0TqWqKg4jarqszh56rjBPM1Jw5btffxEGYqPHpZd1rVLd+3/rSmjrfqdLfpE/IArEBwc0uK0z52rRmHRQUn7m9P2ztifiJwRgxDUIrHDJsjO3/b1B0i8or/J7XfvP4RBY6eand/il57A9ddcZdZJ37qNv2LCPfONrpM25mosnD9TexL6/oqvMT/7TbPLY4hQ+j8Altcv66G7cdu4FKsCBy3dF/pKj5/Cf7/NM9kemVNvQebUW1qtDfO3/IaU9AdEy0q2rTHZB8wtv8aK/yxE6ujhRgMDpcdPIXbYjZL5aWOuxvsvP4HIiLYGt9WvR07WQ5iX8X9mlY2ISM7xE2UYnNTbrHWvSxmHW26chJRR18ueqBlKf+361Xj2ucfNWj/3zY9Npr9560+47f/Gi+b9vuWgyZOqP3bvxJ33ThTNy3nhP5g6+W6D2xw+cggp4xJF855+8gXcd+9DAIy333Up47DoxXcsCt78kLdeUkaNT97/L65LGWd0+9Zo730H9krawJi5sx7DDeNuNnqibet+Z22f6D+ki+iz7r61Nm1j+1DjupRxeGzeU5I2crb+ROTMFPVgSi2Bkz2m3fsOGdwF3+ZtNisNzVVhc2U89jxih93YmLeRdBe8kmsyAAE0BioGjZ3avK2tWFm/7Dc/wqCxU7HglVy77wvdad2PvyJ22I1mncDnfvYVBo2d2rxPbMXYPjFR/pVrfjC7/BrpsxbgjtnPoPz0PwbTNTSiZd3GX/H0oiXGy2VFPTi1YCK3IAjuPR0plr+6LeeHvPXIfOguPDB3Ov7cv9dk2qvX/heDk3qbfUIMQJv+6YrTRtO2Zj8mDhkh2W7+47NQXV1tcJsf8jZItrl6+Giz2u+HvPV4+bVss/fF6YrTRk9eDx8pckh7//NPpemEdLz2n5eQMi4RL776b7v2O33mtLl0o5al/eKr/zYZgNDUKWVcokXtYu/+5E4TuSZlBiEc/uvXPaYv1ucZ3APZb32EqnPnzEzLcoNSp6LwSIlseus2/orstz6yMEXry2I8PevSzH7rIyxZ8TXsvy8ErFz7AyZMNx3A0XegqBj2a0Pj5U9/cIFVOa7b+Cvufew5lFdUGslDXu5nX2H3/kKjZbOkHpxaOhGRnB/y1mPM+EQcLjYcvP563X9x3+y7rE5/3r/uR0XladMrWyA4OATvvvGxZH7eT9/Lrl9ReRrPPi8+ob9zyr0W3cbwyfL3za7HroKdZqerzxnb+/X/vIRlKz+yWXrm9DtH+jFvPV7/z0utmoe9+hORK1Dm7RgMi7W6qnPnTZ7o//K/XUhLkV65EJHZV9u+WoLoqAjt5xN/V2Dpl+uRu2y1aL1Pv9qAhfMyJNvrn0CnjRmBJ+6fJrolobziDPK3/Yb0B58SlWNi6mgkyNwKUV55pnndJjlPPoiEfnGSdQP8/Jrr1YL6ZfzrBVx/9VCTtx3YbF8A2H3gkOwJfNqYEZiRfiN6dY2Bn69P47oHi7A+f6u23MdPlQOCYJc2NBT+zt/6m2z5M//vZmROvRltQoIR07E9yivO4Gz1OazL24z5z70lWnfdxs14etESvPvco/L5GpH72Vfy28ltyxA+UcvxKyTxzRebtPfkX1Jfwt59BbInuIs/+A9eWviGZP7mbT/Jrn/nlHtx55R7tfe3V1Q23qv+Y94GPPuC+GT/h7z1eOW1bNn0ZZkZO0wZeb1k3uq1q3DTDdIrxpu3/iRbB1P53DnlXnyy/H3t5127duJaM4a9f6Z3wn5dyjj8kLe+eYaBOjqivXX7CACc+vskVn21TFRvAJj/xCyMunqMWc8faGm/k7AmnmzuNjLr3TlD3IeuSxmHh+57RPTckYrK0+L9ZUZe9u5PRK5CmUEIfitb3YFDxaLPWQ/ehYp/qkQn0uvztyItJcnitKOjIhDTMUr7OaZjFPr0jJWcpGe/9REWzpshmld4pFSS3oz0CUi8oh90+0VkRBgmp41B6qhEHDh0VLsspmOUKG+N0uN/S+Yl9ItD8vDBBmphuA/K1S/xin6IaBuK7Lc+Fq1bVHJMtjy6bLkvFry6WDIv68G7MD9jiuRZCTEdo5CWkoRpt6bi+Xc+aQomCHZpQ7nlVefO4/UPP5esteKtZzE57VrRdpERYYiMCMO8bukYM+JKDEqdJtomd9lqZE69CfF9LHs2R+6y1Zg4PtlInYzXgYgs4+7fILn6R0V1QLTOSWO3rj2RNGwUBg7tIlrvk+Xv48H75otOMM+dq8bij96WpPnOGx+LTvQFAOHh7RAe3g4z7+2JEUmjce0N4ucOfLL8fdwhM/JArszmnk8FBYfgnTc+xv06J7c/5K3Hr9t+wohho0T10D8BvnPKvejbZ4AoH7k8U0ZdLzpp3PjT9xhj4qTxcPEh0QninVPuRZfY7qJ5cnV0VHvr95Ho6M64ImEo2rYJx+tvi0cDHCk5LFrX3DQt6Xct6ROmtjEnbbnRGf93+924ImGoaL3w8Ha48YaJSB55PQqLDpqVlz37E5ErUebtGI6+OckNpm/zt4qafPzoYRg3ephoXu6y1U3315tIT7oDJeuEBgUi58lZJvf1sZPlklV6delsMO/QoEAkJvQzo4wy5TS3vcyoHwQBt6WOlqy5a99fdtsX2//Yi3UbN4u2S0tJwvwZUxAaFGhwu8SEfvh00VNIHnaFQ9vw9z0HJeXPeXIWJt8wxmja8b17YMWbz0py+OLbTSbLkjXrLklw5/UPVppZD/t9X91yIvfg6H7m8Mm8NoloG4F3Xv9Ysmrx0cOi9Xbv/QM/6l5tBfDU48/jpvG3GS1Hv979ZdP/dsNXVpfZ0JRyzXWSzZd8+LakHvruSJ9uVlkS4q8Uff5k+fs4fKTQaJm2/0987Jl48xRIE5du52ztPX7sTZJV/9y3u9X7ndV9QrqRVWU9efK4ZJVuXXsYzDc4KBiDBw1xuv7kthO5JGUGIahVVZ27gOz/fCya16dHV1wV31ey7v9277dTqQz7Y1+ho4tgljahwRZvY8t9sfRL6QO85txzO0KDA02Ww5x1Wtt/1+dL5k0cl2zWtqmjhknm6bernLDQIEy5UfyDeF3eFuRv/d2sfImI7CUi3PRT+b/Z8JVkXlrqzWalnzJSGhx4/e2XzdrWEsHBIZIT2x/z12Pfgb3az0v0RhfcOWW62c+CiAhvhzkPiG+r27tvt9FtHtG7SBLXw7w3Rzhbe4eFhrVoeznm9DtnZGqfm8ue/YnIlSgzCOHoiJzCp9/3HBA1d9asaQgNCkBkeBgyp4ij6Ovzt1oewTSw3s/bd4lWy3lilmSdTu0jJMmlP/Q08rf8ZvtIq423O3O2WrJqQp+edtkXVdXnkbvsa0n+g/v3sm3/aaU2lCt/5pSbENMh0qz0Q4MCkDVrmiSb0uOnjJdFAFJHSl999vqHn6Oq+rzJbW3atpyM9xlSJEd3M0dPlgwwMzQuXbO8uroanyz/QLT4jvTpiO7Q2ayyBAWFYPb90mfiHDteZnWZDU3JMqMhvtmwGoIA7Nu/Fz/mi0cX3DH5XovaL3nUWNG81WtXGSzLb7t2iNadff+jCAoKkaatt50ztvfZs2cl6/bvE9+q/a4lfcJUuuam3T4qWrLO/XPuwuatP9vk+2iP/uTOE7kmZQYhHP5UdmVP+lecx48epl02brT4hCx3+dcoLC41kaY+6Tor123EurwtorUmjhslWS+ua2fZZx+kTJ2N+7Jewe4Dh1pQd9PlbMl2X2zYJFmzR5eORtO21b74u0L6Cq+sWdMQGhzQgvayXxvKlf+K/nEWlW1ofB9JGkVHy0yURUBocABWvPGMaO66vC3Y8NM2k9tyas2JiHTJPZXfz99f+//yCulzewb2S7Aoj4T4IZJ5R0uOWJSGOYKDQ/DOax+L5r3xzsuoqDyNb74TPz/qjvTp6GvBGzEAIK67+Mrzj/nrsV9npIWuvE3fiT7fMNa8kQzO2N76bQcAXWK7WZ0eYLrfGXKq/CSOnygzOtlK9649cW2y9DkNk+4cj389NdvgvjeXPfoTkatR5oMpGRZrNeWVZ5C7fI1oXp/usdo2v0rmRO6PP/9CXJdOZuexZMVahIU035rw844CUQAiLSUJC+dOb77KrWfO3RMlAQsAyF2+BrnL1yAtJQlz7p7Y+AwDcxnqU9b0NZ3QbXnlGZwsr8QXG35C9tufiFbLefwBg3XUbGurfSH3LI2w4CDbfpdaqQ0B+fJ3j4m2KO1Afz/DeRksR+Py1JFXSRalz34GqSOvMnyrimAibSIyzd2/QnL1NxCHW71ulWRebKeu2nVPnTwhXd65q0VtHOAXYLo8FpTZGLnREF9+vQJvvCO+JeHOdCNvxDBQluCmUQa6aRXs+R19e4uDGRWVpyX59e09wKz8nKW9KypPo/z0KXzz3WpJXZ761/Po2KGzNA0b9jtD6U2YaN7tlLLlMPZZM09v/oxpD0hG0ADApys+wKcrPsC1yeMwY9oDSBo20vy8m+bZoz8RuRqFjoSg1vK/Ar3h/w/cKTrJigxvg8wpN4rWWb52o0V5ZL/9Cea/8LZ20g9AzLg9DV06dTC4ffKwK7DijacNLl+XtwUpU+dgQsbj2L5rn0Vls4XYqydC1f0aqLpfg6ihN2LQDfdIAhBZD9yJeffebjSd1t4XCf0sezOEOwsNDpTtcxt+3u6A0hC5D0ePt3GGyVSbVJ+rxsuv/1tygjX7/kcRHt7OorRsUR5b5RMUHIK39UZD/PvFJ0Sf70ifjj69B1hV3hS9IfSPZM1C9blq0bZ/7P5NtM7L2f8xmHZrtYM5aegbOqoPOsYFoWNcEOKHdcW1E4ZJTn5n3/8oMu55yC79Ti49a7SkjYYPGynpT7p+zF+PSdPG467MSfi9YIdT9id3ncg1KXMkBLtkq1n/0zbR5/GjE6Hf3uNGJYqu0K/L24LC4lLEdZV7z7Rl+2pd3hZtUKLgmw8Q36eH7HqTb0hGZHgYXv/ov1iXt1V2HU1aK954CpNvSDGRs7FDi6XbGZaWMhwzbk9DWspwk9vadl9YWz9L2LIN9bezRfmtyad5eerIq5CWMlzU39JnP4vkYQmIDG9jdFsiIltZvuojhIQ0PmDwaMlhfLriA9n1pky6257FahVyoyF03ZF+r9Vp9+wufRjgocMHccWgodrPy1d9JFo+aKC5r2d2Xtcmj8OUSXfj2uRUi7ZTQr+7cfxtiGjbDu8vfVt2VATQGIz4MX893n7tY9w4/jaz03bX/kRkiDKDEBzi3CpMDf/XuCpe+of2jz8L5W/JkNlXWQ/cgbCQIO3ns9Xnkf32p5L1Bt0wHQXr3jcYiEhOTMDgfnHY8PP/sHztRqzLlw9GpM/+N7pERzW+qtMQuT5lzhNxLOyLacnDkZY8zOR2Nt8XMvlduFhj2++SLdtQfztr025xPs3LQ4MCMOeu2yRBr09Xf4950283ui0RWcntv0PS+utf0Zbzw5qt6Nihk177GQjEWtTG5qRhg7/XTYKDgvH2oo/wwMPSE9s7Jk9H3179TaRroCxNac++71G88W5ze+Zt+g5XND2H4UjxIdGJ6rXJqeL8ZOPOTtLeRlw7OhXXjh5rcbtZ3+8sL6PRYpmTtpH+lpR4DQb2G4T8X37A19+swo/50jeHAcADc+9C5+jOoiCCY/sTkWvh7Rhktvxt4rdTZD1wh+z97o23AUwQzbPkNoAZt9+AedNv104L506HUPQTVrz+lGTdBa99aDSt0OBATL4hGWsXP4+8TxchLXm47HrPv7vM7PK11IrXn0Lep4uQ9+kiSTtlPJmDBa/JXz3QZY99UVhsu4c+uYvkYVdI+tj8F95F6QnpA8iIqOVae5ivK0yWmDp5OrZv2m/wFgV9tihPa+WjmUYbGA0xNX16i8s7bqz4LVNvvPsyTleehgBg207xs6duumGSyf3iLO399qKPsHLpN1i59BtMnTxdtOzRBQ/i5dcX2rXfyaW3fdN+lP11zugkxxb9LSg4BBPG34YP312FlUu/MTgq5K33cpyqP7nrRK6JIyHIbPonr9lvfyo7QkHOuvyt2L2/CPF9uosXWHAFe/L40fj5fx7kEywAACAASURBVAXIXbFWlG7hEUO3eoglJyYgOTEBK7/JR/rchZLylR4/hZjoKPmNbXgVf3hCX20+yYkJ6BHTEfNffFe7PPvtTzF0YG+DARPA9vsiPDREsl7R0eO2/S614kiITlHSV7Pu2ncIyYnmP2l8175Dknk99B9uqV8WQTpvzl23SkbdbP39T0SG671/XWZbIrKQu3+FTNR/wWPPAwC6denROHXtaXC7DpHS1xTu278HSVeNNLs4+/bvkczr0rmbOD9jZ2pWCA4KwYLHnsfCl8TPg+jby8gD/UyVRTcNPQW7f8OY0al4bMGDovn9+8RblJ8j23vwoKvQMbrxd1PSVSPRNba7qP3efPdlJAy8EmNGG7glw4b9zuB8a/uE/jYtTDvpqpFIumok1n77BR6YJx5x82P+Bhw/XqZtS0f2JyJXo9CREI6OySlvKiwuNXg7g7l27Dkgk7Ycw+WYmCo9OB87ddqiuky+YTSy7p8qSedEeYWJbS0rq7nb3DtJ+lqoCTOfRNW587Jptsa+6BDZRrJO7oq1Bstg/SSn5duEhUhHgfy8o8CisjWuLxYTHWmiLNJ0koclIDM9TbRW+tyFuFBzycJ6c7J9XyNSvu35+1F28BzKDp5Dxt0PIuPuBzFmdGrziaABmvv5RWnt+NWyvGXW156guaiXFr4l+pz38/f4o2CHaN7UydNNtq8+Z2rv9NumSebdfd8knDtXbX5ZrOx3rmLC+Nvw0H2PSub/XX7SonRaqz8RuRplBiE0V0k52Wz6Q+YqsaUysl6VT1+y/0zsQxvs79FXDbIwHZkKmZufifqFBgVgxWtZktV+2bHbbvsism1Y47Mo9Gz4+X827Eet14Zy5V+Xvw2FR0rNSn/3gSKsyxc/6DPr/qlW9z/9IAQArP9J5k0Zdvjuuu1EbsHR3cwZJkmbWNku4W3bSa58/7hpAw4XHzJr+30H9uLHTeL75x/KfLRVy2w0TRttF99f/HDAz1Z+gBsnix9mnXzN9SbTdub2DgoKwX9e/Uiy3vadW1q937UkPck2rVzWYUOvMZmnqeWt1Z/ceSLXpMzbMcjmlq/LE33OTE9Dj9iORrcpKjmO3BXrRPN2HzyM+N7dDWxh2q4DRZJ5ndo3D8WvOncBAGSfj6Cr/J+zknnRkdIh/faSes1Qybwlq76VDQy01r6YkpYiORFPn5uN4Qn9mkYEGFZ6ohwATK7XmuTK/+majVg4x/iTuKvOXcCC1z+SzL9trPTHhrnie3dHZnqaqM3125+IyNncdMMkbNQ7sf1qzUrMn73A6Hbnzlcj582Fkvnjrr9JZm3X0re3dAi9vkEDr7QqbWdqb7lnayz/70eGb8lQkHPnG0d8BAdJb03VVfnPacm8qCjDr4yX05r9iciVKDQIwbCYLRUWH5Oc3M2961bEdZV524WO3QcPS068Nm79HfG9u+nMkdtXguz87QX7Mf/FXMn8xnI0rv/+f7/Fzzv2YM60W5A8TP55AOWVZ5A+N1syPya6nYHyWFZOa7YLDQ5Azr9mYv6L72nnrcvfht0Hi0SBgtbcF6nXDJHdNnZUOratehOJg/pKlpVXnsGavG3IyFqEnH/NxLx7JhopReu24fAEafmy3/kMgID50yfJBqZKT5TjhfdWSNo0Mz2tqW3085b7LF/+zPQbTAQezKk7ERnl7pfBjF16tcLgQdKA+Ju5LwMQMPOe2bInacdPluHtxYskJ9NTbzfwdgobl7kpAfk0TW5m3nYvPfsmHnv6Idkkpt4+HRFtI2S2k/mst44ztXdwYDCyHn0O2S8/qZ23cdMG7D+wR3ribOt9aLP0DAwZMJH2iv9+jO07N2P6HfcjKXGkbMoVlacxa570okbH9jpv+3BwfyJyJcoMQvBLaVM/79gtmRfXpaPJdo7v1U0yb/6L7+He21J1TgilaSz5/FvRKzqBpiv5K7+RrLs2d6G4HELjybvmpHLxwrnoHtMcpT5cehIZC14znY4+2WXmHADMP7COkQma5C5fh3efna393Jr7IjQoAHlLX0bKNOk9j8MmPYS05ESMHBKvnSfZJwIc2oYxHdph8cK5kv2b/c4yZL+zDDmPzURC38aAzoUaNXbsPohsA29FefbBOw2XV/+jgfLH9+qGnMdmYv5L78kuN9leRGQSv0FSLQlvRnfojBeffRP/0jtBejP3FbyZ+wqyHn0O/XoPBABcvHQRBXt+w1u5r8imNXfWE2aXY1iKkVdkA/j918OICG9nZmqNrG0Due0GDhgsM7fRrTdNMTsv/fUc1d6G+khS4ijJvM8+/xDPPS393WRumtayNj1ztpFLe+OmDdrAzovPvonYzl21y0rKiiX7CAA+eOdzqy6jtFZ/InIlygxC8GtpU/ondYsXzoG5bbx44RxkLHhdNO/A4RIkDupjcBtDJ4b6su6bgrTRV+mVRVwuuYCDeenos2SEhCnyh9b43t2QlpyIdfnNzw7IXfkNHp85WXubQ2vvi+TEQVix6AmkP/y8ZPt1+dtFZdMXEuRvoiyt34YzJqWi9MTfyH53uWSZwWCAnoI1uYgMDzWzXMZ/Jk0ce7WRfDkSgqjF+BWSauGflvTb7sLxE2V46z3pya7uVXJjNny1BRFt29ls/5SfPtWYniFmxIzNJrOd3FsNNHp262Ve/gb2i0Pa20BZ+vYagDGjUrHxp+ZRFp99/gHun/EwOnYw8cBLZ4hCmLuN/np628gFHPQ9OPMRjBmZajo/O/cnIlehzAdTip6Qzqkl0+6DhyWtO3RgL7O3b1xX7Nuf/qe3nuXylr6EhXOmSfJLukI6JN+YrPumyKYjP+kztx3N327GJOm9l1t37YP99oWAyeNHYm3uszLlNiwtORE3pgwzoxz6bN+GC+dMawrOWCZz8niUbPoU8b272qwsMdHtTJTF8d9x5U5EZK35Dy3Ai8++afF2U2+fjq0b9xk9yXJVb73yoWTegzMfMfkcAXM4U3unT7xLMu/3Xf+zWfrOaHBCokXrPzjzEcx/yPhzO0xpzf5E5AqUGYRw9G9fBU01NWpR06aNTmwc2m/m9vG9uiFttPiP++6DR7TLB/ftKVkuJ3PyeCxeOAfbVr4O4eD3SL5qkGx+ifF9UJL/qcmT0Kz7pqDg63excPY0s+rh5+MjKWd4aIjJ7cJDxQeTtNGJ8PPxMbj+NYMHSPLZd6jELvtCd0oblYizO7/CilcfN7p/MiePR97HL2HtO88ism1Yq7RhJ5kHhhprQwjAjImpZvUDoLEvbFv5Ot595iHEdIi0aH+GBAWYLP+MianIeSxDku+YYQkO/34reiK34Oinsjt6CgttK2qPMaNS4ePtZ5O0J996F7b8uA8vPGP65PjBmY/gq2V5yF7wGqLbdzaabv++CRgzyrKHHbYLb280zahI8cMB/2/SdKvbz9C6Vwy6SlLum9PSzS5TYGCwQ9rb0j4ydHCSpJ6FRQdatd9FRUofrm1Oeg/OfES0TVRkB6vSThg4xKy2f3DmI9jw5RbMe3CB0/cnd5rINakEwfV3X319PS5evIjy8nJEr78X/tf9y9FFIidReqIcl9S1OPZ3BQL8fBEdGY7Q4ECTb88gsfLKs7ikrhXNc6V21Ly9o6j0BAAgPCwEbUKCHPo2D2pdNT+8iBPj3kdkZCQCAgLg6enp6CKRDege75dmb8b0+bc4ukhu4/jJMgBASekRAECbsLYICQkzPUyfrML2dpzjJ8ugVqtx6u/j8PMLQFRke4QEh3KUgpP6IOcrTMsaweO9i1HmMyFcP65CNhLTofEe0rguepFw9hGLRLYNlV/gIu2o6Qeaf7VcpPxEJE8B11FcRnT7TqJ/NbgPWgfb23E0bd41VvxKebY9ke0oMwjBsbhERERERERETkeZQQhGKomIiBSPh3siIiLXo8wHUxIRERERERGR01HmSAjejkFERKR8PNwTERG5HGUGITg+k4iISPEERiGIiIhcjjKDEERERKR8jEEQERG5HIUGIfirhIiIiIiIiMjZKDMIwdsxiIiIFE/g8Z6IiMjl8O0YRERERERERGQXHAlBREREromHeyIiIpejzCAEf5UQEREpHo/2RERErkeZQQiOhCAiIlI+Hu+JiIhcDp8JQURERERERER2wZEQpOMk3pg2C3MKAOBarN+diVRHF4lI8XZhZnw2FgPAoLtxaOkN6OHoIhG5CPc43Bdj6T2D8dweAJiG9397Ddc4ukhE5EQ2YsGVk/A5AAx8Hj9+mIlYRxeJyASFjoQQOFkzbV7TFIAAcNtQpNogzaJluVDF3wpV/K1IWnbCvG02y29jTVpOO5V+g5nTbtXWRzXtGxTZsA1tmb87TI7tW4Nw021oVLAV35Y6vj2UMREpxJY3mwIQAG4Z71QBiJItcxF3ZVvEXdkWt68obnmCZblYcE9bbZpx9+SiBEDJCtvlY8u0HMpAW8lplTpbkL87cGy/GoNrb2n6757V+KnMztkTWYEjIUhrw6Yftf/PGDWouR03L4ZqVtOy256AkJUg3XbZkxj3SmHjtv95C++NaA8AOHSkOc2tR04CQnvTBTmqcxgToC2HVWk5o7JvkZT2Mbbqzis4hkOCIHsF3Ob1tjB/d+DovpU66lrgix8B/IVVv5zE7P9z0b5NZGfucLj/5eel2v/fPnJMc52PbcRTNzdd/ZSRMGAaUu99CNOGd221sgkl+3U+tHB/HMvF5JufwC7deXv+wlEBQHFzG+wqPgxBsL5OR22YlsMYaasYmdVtXmcL83cHju5XV4+cBny1FMBOrP+1GHemu2C/JrfCkRCcmqZd+PoLTfuNwU0jjF1VlNm+uFC79M+S5vk9u47Rzh/etb2ZZZHPy7q0nG8q+mWrNgAw/JE3IRSsglAww+DIE1vX29L8FTGVfYukQROhGjQRquxdklEfDu9bI4Ygoyn/rd//7tajUmw3ESnBRmz8SvP/aRgzXHdZEQqlG2jt2rsUz88ejMkvbGy10tlSya+rtSe1CQ//jr92/oO/djbeehLbZZp2vYQu3VuUjy3TchRjbSXH1nW2NH9FOJaLyUPaoteQtuj1wkbJqA+H96vh43F70393/fi9W49KIdfAkRDUqOw4/tT8/9YhSDXUhoIg376C3oemdXpMmQFhygzx9haxZVrO4dARzc/GOEy6OspkPWxdb0vzVwTdOhYeB4R40WLH960o9B0IYA+APVvxbWkqZne2cxGIXJCg9L9fxw41BxpuHoerBaH5cKtb9wHP4fsPmu8DL9n2MK6f3XhldtdXr2Dp1BTc2cn2xRP0PrVkfxwt3tn0vyFIHdFFlFbM5EU4OHlRc04tyMeWaTmKsbaSY+s6W5q/IujW8dAhCEKKqP87vl91Q/cBAPYC2LsaP5XNbJXvPJGtcCQEp8ap9Hjz1fFu+leCzWlbW+4DW6blbNMpFB5yZN0cnb+jJn2OLo/+FIXx18c1la0Q+/lcCBtMRApQVth8xbmr+VdXY4ctwuKbNZ92YsPmYluXzMaKcbTI0WVwFY5uK0fnT/K6YuS1Q5r+vxOH+VwIcnIMQnACIGDDpubhmv1jI2XWMdW2uhq084u2LIEqYTJUCZORtPyk3jYnsSH7KSQ1LVclPIWZy09anFbR8qea5i/Bhqb1mtOcjKTs9fLD28t2Yea0p7TrSaZpBrbTm4q2rJemM+0pzFwuHvbfWM7ZmKN5wBgKMWeCobYRbF5vS/I3t06AAGjL9xTeKGvcp9rPW4yUdZpOWaetx4ay5vqKlhnYf0VN+y9JtN+eQpLe7RYbsidDNWFp8zMw9ixFT732NN5PLWsPa/tjj9jmoQ9/lhjuD5zMnYhc3y8/Nd9nHhdr2T3esV2HGF1esu1hpE8PR++hmmks0l/YiJJjcmsX45cXxiJdZ92nVxabLIM5eZSsHIveQ6/E83s1c3bi+Vsa109vyqNk28PaNNJ18m3cNhy9hz6MXzT5DW3OL/0F6cMSbZkWAODYRjw9faxOHfWm6aYf2FiyLVeaxvSxeHqleNi/OW0ln75t6mxJ/ubWCQCgLd9YfHKssa9pP28zUladvpU+PRe/HGuur2iZgX1X0rTv0kX7rKmP6qz3ywvh6H3Lk83PwNj7JK7Xa09DbWxNe1jbF2Nj+2r/X1hi+vtJ5Ei8HYP09ETfzoL4N3yD7nLBdPsKaF7naKn8fPyNN+6aq3NCDACFWPzK3MZXFVqSljbNUmRPS8dWUZrA1i8/Qc8vj2P9H9ObXzm6+QOoHsozXg8z6rrhuacx7stD0gV7CrF4z0tY/P0dOPRxauMDH42lJRhZbqt6m5m/RXUCdPqHgFVZc3XKUYj9DYJe3QyUdc8nGDfhODJuzcPiL2XqcUgQ5Vm0/Gn0zJEpIwqx9cuX0PPLFPH+NlVvg/3Uivawpj8Cou9Z48Mxo0yVnsjtuc/hfgi6ddKrr37d9Q7dJdoh80DPmK462xbj1xevRMZq/Tx2Ytfq23H96mlY/L9FuBrN639y75V4Ya943c8XXSl+KKbokGlBHsb2oSbNowYegKnddj/enR6OXXvFm+9a/SSuX10oro8t09r2MPrMWQqTBMPV/PXFschYvVO6YO9OfL73dnz+43P4/v3Mxgc+mtNWcmxVZzPzt6hOeuluePpKnXLsRJEmXVNl3fskMm4pxKSbl2KVXr/btfpJXF8EUZ6lK8fi+tdkymjwe2Ci3obaGC1pDwv6omg7F37oKrkNjoTgBPOG6Fu7XH5+0fJ3mgMQA+/AoT+WQfhjEdbf2tPitJodwtY9wPD5jzamt+ZRZAzULMvD15ub6/vG+5oARDLWr1kG4Y9lOPRmsjal4fMXQfh4LHoYa7fN7zefnA5sTkdY8yhe1+S751NMW34KgIAeU56B8Mei5mXoidebttkyRW70iW3rbVb+FtZJXJZDkhNug2W9Vaes2mWNAQjZZXs+xSub9fIbmIzX31zU1HeW6dWtud6pTy6DsOYOaJ/npu1vuu1uoI2tag/L9ot2io1uLuOhk3w4ZYsncguO7matOhWjWHfYu6lurrPdryvH6gQApmFMYvPy0pX3aZclzP0c32+vxIHtlfj+tWlN6y9FxosbRetrAxADnmta/zcsvllmpIUVecTc/h0ObP8Njw/QJDIEj3/RuP7y27vKf50l9d+JXXt18vric0zSprcUG7caaLMWpVWMTz7QBCCmYfEX+nUEEub+hgNLMhFjaB9vfbj55HRAcxoHvvi8uT32Pol/rSw2v63M+XNoZZ3Nyt/COonLslNywm2wrDfrlFW7rDEAIbts75P4QL8fDJiGx1/7Tds/xXVrrvfVj1XiwBfPQftuOO33wIw+ak17WLhftFOnuOYyFhXBbe7sJJekzCCE5uGJnMyfjLWfri9fhuqK/5NM4740tL3c/FP49gdN1KMnXv/39eghCIAQidQnnsb6WyxJSzx/+LxXsSV9YGN6nQbikWubgxp/lpxqWv8k9mvfuT4YqZ0a0+mRNF57Ytl4JdpYm53CG+/n69ThHm066DQQs/89VXtCuTXnG2wwt61lJ1vV21T+VtZJz/B5r0L4/TMIv7+K95Jk6nDLI9jyhE5Z5/U0a5luPXqkPw3ho3swOymyqe809p/xZtXb3Da2dh9buV9MlpGTRRO5BUHhk6n6au19EtcnhqNPYjj6JF6JjNeaT3re+2IRRmi3KcZPGzVXZKch8/Yx6Ny0rPOwB5tPilavxy+S9Yfg8aczm9bvihGPfYf3tM+d0C2fpXlYWFcD8xPm/oZlmrw6jcE9Y5qDJIdKi1shrcM4rDlhvnkcRnSS1nHX0cNG9m8xPvlQE8QYgsefXqRNQ+g0Bnc83XzSu+u1tyxqK1N9yZbtJ07PNnVKmPsb9m+vxP7tv+GZYTLr3Pw5lj2mU9a5Q8xapluPzrd/h/1LFuGOYV21/VNAV4y0ot8YXt7y9rBkv5hTRiVO5JqUeTsGu6SFdE7K0RlxnVvafqYOU8bz69m1J4BDettYmkejxvvsG9PaWnwSQCREbyL46ndsuHMgUjsDRVu+1Y7OGN41ykD6GibarHN79AeankNQhsIyAamdNeXTL68lWlJvU/lbWycdt8zXGV0gN8pA2ra6ZTW2TL+ORWW78e0na7CqSG4EhnR96TJDzOunZrWH2fvF0jISEQCFf010TnLRF106QlzfBukWIgOm4b0Fi3C1aDvdNJdiZqKRWwkE02WIjR0CYGfz+pJtzMlDRoPeMv3/CybmA4jp3Fdbtl3FhwHN0HSbpdW9+W0Eq9fj1/QxuLozULrtLe3IkYTY7kb6qIn927EHegJNzyHYj6OlwNVyb03Sbys5tmw/o/lbWSfddW76HMsmaUYX6OSps45+u+qW1dgy/TqWlm3Ez8tz8N1hmREY+uvrf9+M/ZyS/S5Y2R6W7BdTZSRyIsoMQvAqmIV0TspRhsJSvZMp3fa8ZT6EJwZC34bn78Q47bvMBQP7oGl+2cnm14EO7ICeRveXibRMzZe78o9IzJ4+GnNmbwKQj3E35YvXQU9MGhFpvB+ZrINumzblKzSVT788FnXXltTbRP7W1slgXmbWQW4EgIllRSsWouercs+EMJCPsTwMbWf1PjZQBkk5YH47EJEsZb8asCu69Qca/xDtR3GZgBGiV+7pvK6zfzY2LM5EDI7g188fQOYbO4G9SzFzkoDcrTr3jeu+8tOoxtdtCrrr9++JGEEQnx+J/oQ1NO4PS/MAADSI04Jg8M+jNh8j8yULIZjcxvK0umDqXXfihXmfAFiKmZP0gy1DcP3wLob7qIm2Fe9/3TYx3lZybNl+RvO3tk4G8zJdB/2F5i4r/TwVqW/IPRPCUD7i1+MKgoXfBQvaw7r9YrqMRM5EmUEIfuUsZCycK7euGSeZsus0zde9grznBA5BaH6on6VpWVS+5mUbft7UOGtgTwzfc6jpanZPDL9lKLLuuA6ppkaDmKzDKZ2r6J10rqJb0tbG62DefP1lRvK3uk7mlsPSshpatgevvKpzO88bMzA7qfEhjkUrsnWCE6bSMlG+Vm8PU23Fv2NEZKluuPr2DcgtiUDm1wDwCTJfHod9j46RrqoNXBjRqfFKbQEA/FmIEsD4+tbk4cJ+/fWTxv/0H4JBf+5sbCcMwaCbbkTmlExc3cnIxibb9ggOayPhfdDFWFrOwmXqtBEfvtF8m9G/Xn0bdwzrBsC84ITZXKY9iOyPz4TgBAiRiNOeXR3C/lK95eLGlU9DbxXZZbrztRqHsTev/7fO8yLMTMuc+bplL/se2U2jNjLGzMCWnR9D2PkxhJ1PYsvj1zbf9290ikJf7cOB9OsgiK+iD2i6ii4IeuedguH2NNS+Lam3yfytrJPBvCysg7nLdMtxSxpmD480o7/pzje3fNbuY2v2iwCUnmh+jWiPKJ1nXXCyaiK34Ohu1rpTN8R209R0Jw6XGe/muvNHpGdjkGbB1+vxi2ZZ0/BvAMCfa/CTTJqG8ziAYtH6R/BTnvhkzdo8BAGSq8qGlomWG+sPugsaWiGtslzkft04a2LK2/hsSwX+3FKBP7dswGePZGJER9P7t1t/Q20LCGVF2psR0T8OMea2lYm2bXH7Gc3fyjoZy8vSspqzTLccE+ZhamI3s9IymIfB7WzQHsbqo99WZYVNgTAA3Xqgszl9QwETuSZlBiG0Z1qczJ+MtZ/cTWbmbi83fwBu0j58sghznvqh6U0Af2PDC49izl65bSzNw1jZmy1e9ChUQ+5qnu7JRtI9H2HDMVPt1Q7jr9W+MBJznvqheZtje/DGU8u1J5TDr43Xe8uGsfK2tG3N2WeG5v9/e/cfHHWd33H8tT+++yOb3wkckEBIBJRO8LCKnAi0KnoFLVemB6RzHHczdbR2bjzP1l8t49A7hjlrrXDX09OeNz10aCpWrI449UCPH4JCHVMSTysxAhKQEEkgPzbZ3ez2j93NfhPyY4mwm/3u8zHzndnsfn98vp98k/dn39/P5/Md6zl9letj8PZJfFYe7aEgKTqnR6yMjfvf1Pf+eZip5M3b1DfrSHybEcs31vpI9lwHf574bMH0rw2xLcvFLUAWK79N3+z/p7dFz7zYFHu9RDcvj79/SI/95JfaeyKx2fETO/UPdy/VmhHWjz7QuEl7H7tejzVoCBd7jMy3bfP1qr6xNLHcvVRr7r5/wHlfqEp/dEt8ksFB9XRip57/ybr+L5Rzb7ktQ3qTZMg5lZsSZa/u6C/j8Xd/qb8brheEeZuGT3Qsvs2IB0pffcytrBp9JSCNrDkcg7TYRZs5fYak6Be4hmOnpRuGmTBvuLRjZNAPQ/4OEu8vffhHuuvlJ/WsJNVv1cx5WxOrzZmhBfWNsS94o+8rufdNZS9bonUrDmrZ9sYL16lv1H41atmK3bpr86/1zA1D70qSZtTcqU2/fTiaNKnfqmUrtl6wzoIVP9I7NRNMZRpUtqFS3iP6CuedxPHHdk7DHetizyHZz6r1ZyukZ7dL0m4tW7E7iX0Nvc2C+3+qd2oGX+uJ7b5yfST9e5He+F3iPKorhtsfADOr/5lMm56Y+PHIsSZF5pu+WIz477xKa76/Vo/9bXS4QN3mf9GeldG5IRY+WKuVTTXa1iCpYZ3uWb3uguPOvTlRtwsfrNXKV2u0TdH1l91oWt88DCEyaJuLOMYFBv3rHLCe6bPh3o//PGCXo2xz0fsq+yvdtfy/9NevDvGlteGQ6nRI96zeopX/1KpHv3HhKpI0deUv9NCuWDJnuHpaXqvnV1aNLWyayzvE+mOpv9GOP6ZzSuJYSZc1qc+W6Kbl0rZXJWmL7lm9JYlzG3qbufce1POrqoYt31jqY6y/l727E+cxc+oI1wwwDtATgkVSRDMWXpd43OBv60x3iOPLKHVbmRgtX10RTrxfMcW0rel9VeuZl+/TphXmUfYzdNfmjYo8d0firrWS2ZeGeX/g5wsq4z8f1iuNsQTEivsUOfhcbNmoHfcn8a0vjwAADFdJREFUyvPs7w6PUm8T9MPnNurI5sVa0N9tP3asOYu1afNGvfNI9aBtwqahLyPUp3m5ZOedzPHHck7DHSuZcxh8Lsl9tvSRjdpx/+L+azZevh0v36e7htnX0kc2XnC9VVdMGKV8Y6kPDbOvkerqC33SnxOboT+Ymv7/CZm/ICuk+zK7zMu0Bd/qH1ZR99abOj7SJT54+/k/0EOm3hBvH4h/tkSPPn1QT927VnOrB+5ibvVaPfT4QT2/ssq0ryV6tLZWDy03PQZR87Ty8YOqf/pvNNO8A/M2F3UMmYaeDHE+U2cP/dlodRA/5vTLsa+dersploBYXqv6va2x5aCeujdRV9v27Bzhd1ylNU8f1OuPj1BPDyy5YLsR62qo5VLW36jHH9s5DXesUc9hqHNJ4rNFD8Suz0Hle6q2ViuH2deiBw5e8Hcwc2rVKOUbQ30MllRdNelYf+eieaoqH2I7qy7ISLaIBaaW7uvrU3d3t1paWjRlx53yzl+T7iJloNPafOffx4ZCLNaO99ZqabqLdJk01v5UM59slDRDm/7zYf3QPBHQiZ268c9ro70w5tToyK+WjDBpJnCp1Ovu+ZujPYO47i4J/3sv6OSyX2nixInKycmRw+FId5FwCZjj/W827NOqv7w93UW6zJr0wj3zY8Me1uqpvU8knnSBtDq+bZlu/9khSfP0UO0OrSkzfdj8jL5bE+tqX71Brz99d4YMp0Dm2qUfL4r1WMqya+7F517X99YtJN5nGGsOxyAtNgaxySnrJWmPXjnwXS0dYShCJjtyNH7LuVEv7jus22vmxL7wtWjz+trEOP8lc2Lj/IHL7MAH0QSEuO6Ai5H5t1FGU6WKSsUe4bdFb737hBbOT3ORIEk69ll8GMYh/fc7u7Ro5S2xL31NemGDaaz/TbdGJwhMSymRNd7bEU1AiGsOmcGaSYjI4MnfkIyl31mlBdtf1H5Jz+4+rGe+UT3qNplo6eJF0va9kqT9T/5MM58cYqU5q/Sb1aVcS0iJN3bvib2q0qobue6ApGVBK3vhX2zQ3NeiX2pf2rNLj15/S7qLBEkLF62VXovNufHzGt3x8yFWqt6gDd+uyorrFOm1b098Poh5uu0GrjmMf8wJwZJYyqu1Kj7ufXud3kh3eS7XcsN3FHnpB9q0omrAnAKStGDOIm168seK/OvNg55owcJyuZZ6vbJdUXOu0+3l6S6PVRbAIspu1W3xewKv7dC+tBYG/eY/ocNba/Xgn84bMK+AFB3r/+A/vqfDv8ieLvFIp11667XYy+pvaXHZiCsD44I154SYV5PuIgEA0sh/qJY5ISxo8JwQ3/6+1eeEAACM5KV/Y06ITGS54Rhhw6dIwC+b4Ul3UQAAwGXi9hrq6e6Vx+tOd1EAAMBFsFQSwmazKWT4FAn6ZTNolABANor0BRVxEAOszGazye11yu/vkdvrSndxAABpEAwEZbjo+ZCJLJOEsNls0SSEM1eRgF/yFqS7SACANIgE/OozfLLZbOkuCi6DeLx35zjU090rFaW7RACAdOjp7pXLaxDvM5BlkhCSZLfb1esuUaS3S1nw3C4AwBAivZ0KuAr7v6zCeux2u7x5hro7/YR7AMhSXZ1+5eQ5ifcZyDJJCLvdLrvdrvbiOSo9s1OaUJnuIgEA0iDc2aIvC+fIbbfTKLGgeLyfVJWr5oYzqpzF8wcAIBudPtmiidNzZCfeZxxLJCHi2S+n06lAyZUKfPrvMkK9sjmMdBcNAJBigdbP1fX11cpxOLg7YjHmeD+pokB1uz5WoDcow0W8B4Bsc/zoSf3x/Eo5iPcZxzJJCIfDIcMwZHh8Opc7Q55zJ+Us5u4IAGSTcGeretwlcuSWyuVyyW63p7tIuITM8d6b41FJmVcnPz+tiqrydBcNAJBCZ05/KV++ofwiH/E+A1kiCSFFu2cahiGPx6OTk29SafN/yFlYJtm4IAEgW4RaP9PxSbfK5/HIMIz+uyOwDnO8r5pbqI/3HlN5xWTZHcR7AMgWjR99qspr8uUh3mckSyQhbDbbgEaJvWiamk+VaVrrUTmZGwIAskLfuVNq7XUpWDpbXq9XhmFwZ8RiBsf70skFchW06eiR46q6cnq6iwcASIFTJ04rEOnSlMrpxPsMZYkkhKT+MaIej0c+n0+nJt+kkqZfK79wsmxOnhcPAJYWCav7VKOOlteowOfrvzPCGFHrGRzvr7imUHVvfqYp0ybL7SXeA4CVhfvC+v3hjzR7cYF8xPuMZZkkhBTtoul2u+Xz+dRVNFkfTrxD1518W66pVzMsAwAsLND8oT4qWCRnyXTl5ubK7XbTNdPCzPG+ZGKhKq/rVt2hw5q34FqGZQCAhdUdPKxJsw1NLCsi3mcwyyQhzF00fT6f8vPz1TLhSn3Q265rPq+Tq7yaRAQAWFDwy+P6rG+Cesqv1cT8fPl8iUmqaJRYz1Dxfsr0Hvk7T+v9dz/QH86/hkQEAFjQpx9/qrD7vCqumqh84n1Gs0wSQhrYRTM/P1/BYFBnQteqrjmouSfqZUy+kqEZAGAVkbACX3yipkCxTpb/iUoLC5Wfny+v1yun00mDxMKGivcVV4XUFDqj/znwvr5+3dVye4j3AGAF4b6w6j9oUNDRplnXl6iQeJ/xHOvXr1+f7kJcKvGxQOYlEonovLNEn/fkqPjUPhkOh+ye3HQXFQDwFYS7zqrzWIMajKt1ZtIiFRcXq7i4WHl5efJ4PDRKLG64eO/Jsylg69CH7x6T4XIrr4B4DwCZrLXlrN4/8L5yJveo8uoi4r1FWKonhJR4hrjb7VZeXp4ikYgkqc02WweMAs1u3alJ7c1yFpfLkf+1NJcWAHAxwt3tCp09obbukBoKvylb6RUqKYo2SvLzo4/qYmxodhgu3ttsNnl8bfrsfz/S0cajumJWlSaVEe8BIJO0fdmupk+a1NHdrrKrXZo0tUhFxHvLsEXiUdtiwuGwQqGQenp61NHRofb2drW1tamjo0POc8d11fn9Kgq1yF08RfacItm9eQzVAIBxJtIXUqTnvPo6z6q3/Qv5bV79PvcGdRTMUl5enoqKigZ0y2SG7OwzUrz/8otOnf6/kLrbwyqvKNOESaUqKMxnqAYAjDPBYFDn2zrU8sUZNR9vltMV0YRZDk2Y6iPeW5BlkxCRSESRSEShUEi9vb3q6urS+fPnde7cOXV0dKi7u1vyt6m084imBT9VXvCsnOGedBcbAGAStrvUaRTrmLNSrb6ZCnlLlJOTo9zcXBUUFKiggEd0Zbtk4n3X+R6dbe5VZ4tNPR1hBXv70l1sAICJ07DLm+dUzoQ+FZe55StwE+8tzLJJiLhwOKy+vj4Fg0H5/X51dnaqs7NTXV1d6u7ult/vVyAQUF9fX39DxuJVAgDjXrxhYbfb5XA4ZBiGPB6PcnJy5PP5lJubq9zcXHm9Xrlcrv4xoTRIshfxHgAyD/E+O1k+CSFF75LEu2sGAgH19PTI7/f3N0p6e3sVDAYVDocHNEqyoGoAYFyJNyriDQy73S6n0ym32y2v19u/eDweud1uOZ1O2e122e08khHEewDIFMT77JYVSQgp0V0z3jgJBoMKBoMKBAIKBAIKhUIKh8MXNEwAAKkXb2jEGyWGYcjlcsnlcskwDDkcjv4JqbgbAjPiPQBkDuJ9dsqaJEScuXES77oZf21ukGRZtQDAuGF+7KK5ceJwOPpf0xjBaIj3ADC+Ee+zV9YlIeLMXTCHem1eBwCQGuaGxuCumuafgWQR7wFg/CHeZ7esTUIMRjUAwPhEIwSXEvEeAMYn4n32IAkBAAAAAABSgulFAQAAAABASpCEAAAAAAAAKUESAgAAAAAApARJCAAAAAAAkBIkIQAAAAAAQEqQhAAAAAAAAClBEgIAAAAAAKQESQgAAAAAAJASJCEAAAAAAEBKkIQAAAAAAAApQRICAAAAAACkBEkIAAAAAACQEiQhAAAAAABASpCEAAAAAAAAKUESAgAAAAAApARJCAAAAAAAkBIkIQAAAAAAQEqQhAAAAAAAAClBEgIAAAAAAKQESQgAAAAAAJASJCEAAAAAAEBKkIQAAAAAAAApQRICAAAAAACkBEkIAAAAAACQEiQhAAAAAABASpCEAAAAAAAAKUESAgAAAAAApARJCAAAAAAAkBIkIQAAAAAAQEqQhAAAAAAAAClBEgIAAAAAAKQESQgAAAAAAJASJCEAAAAAAEBK/D+o1KrOhmM8WQAAAABJRU5ErkJggg==)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D8PiWbIuDW5D"
      },
      "source": [
        "#**ABSTRACTION**\n",
        "\n",
        "1. Abstraction is one of the fundamental principles of object-oriented programming (OOP).\n",
        "2. It involves simplifying complex systems by hiding unnecessary details and exposing only essential information to the user.\n",
        "3. In the context of classes, abstraction is achieved through abstract classes and interfaces.\n",
        "4. An abstract class is a class that cannot be instantiated directly. Instead, it serves as a blueprint for other classes (concrete classes) to inherit from.\n",
        "5. It may contain both abstract methods (methods without implementation) and concrete methods (methods with implementation).\n",
        "6. Subclasses are required to provide implementations for the abstract methods defined in the abstract class.\n",
        "7. This ensures that all subclasses adhere to a specific contract, while allowing them to define their own specific behaviors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "-kO5VUytCcwl",
        "outputId": "a270f050-0b29-42ed-ce08-b2d3c7a709a2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Car started\n",
            "Car stopped\n",
            "Motorcycle started\n",
            "Motorcycle stopped\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# Example using Python's abc module for abstract classes:\n",
        "from abc import ABC, abstractmethod\n",
        "\n",
        "class Vehicle(ABC): #Abstract class\n",
        "\n",
        "    @abstractmethod # Decorator to define an abstract method\n",
        "    def start(self):\n",
        "        pass\n",
        "\n",
        "    @abstractmethod\n",
        "    def stop(self):\n",
        "        pass\n",
        "\n",
        "class Car(Vehicle):\n",
        "    def start(self):\n",
        "        print(\"Car started\")\n",
        "    def stop(self):\n",
        "        print(\"Car stopped\")\n",
        "\n",
        "class Motorcycle(Vehicle):\n",
        "    def start(self):\n",
        "        print(\"Motorcycle started\")\n",
        "    def stop(self):\n",
        "        print(\"Motorcycle stopped\")\n",
        "# Example usage\n",
        "my_car = Car()\n",
        "my_car.start()\n",
        "my_car.stop()\n",
        "\n",
        "my_motorcycle = Motorcycle()\n",
        "my_motorcycle.start()\n",
        "my_motorcycle.stop()\n",
        "\n",
        "#In the example above, the Vehicle class is an abstract class.\n",
        "# It has two abstract methods start and stop.\n",
        "#The Car and Motorcycle classes inherit from the Vehicle class and provide implementations for the abstract methods.\n",
        "# Attempting to create an instance of the Vehicle class directly will result in a TypeError because it is an abstract class.\n",
        "#my_vehicle = Vehicle() #This will cause an error\n",
        "#Abstraction simplifies the interaction with complex objects by hiding internal details and presenting a well-defined interface.\n",
        "# It promotes code reusability and maintainability.\n",
        "\n",
        "class car:\n",
        "  def __init__(self):\n",
        "    pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oawxux4vh_Uy"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e587NAY3jHIn"
      },
      "source": [
        "#**Encapsulation**\n",
        "\n",
        "1. Encapsulation is one of the fundamental concepts in object-oriented programming (OOP).\n",
        "2. It describes the idea of bundling data and the methods that operate on that data within a single unit, or class.\n",
        "3. This bundling provides several benefits, including data hiding, code reusability, and increased maintainability.\n",
        "\n",
        "4. Data Hiding:\n",
        "- Encapsulation helps protect the internal state of an object from direct external access.\n",
        "- It enforces controlled access to the data through methods (getters and setters).\n",
        "- This prevents accidental modification of data and improves the overall integrity of the system.\n",
        "\n",
        "5. Code Reusability:\n",
        "- By encapsulating data and methods, you can reuse the same class in different parts of your program.\n",
        "- You can create multiple objects from the same class, and each object will have its own data and methods.\n",
        "\n",
        "6. Increased Maintainability:\n",
        "- When data and methods are encapsulated within a class, changes to the internal implementation of the class\n",
        "- do not necessarily affect other parts of the program, as long as the interface (public methods) remains the same.\n",
        "- This makes it easier to maintain and update your code over time."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "gQ3S1qiVj_LF",
        "outputId": "aea291ac-9f02-4819-ac50-100c6580eb1a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Deposited 500. New balance: 1500\n",
            "Withdrew 200. New balance: 1300\n",
            "Current balance: 1300\n"
          ]
        }
      ],
      "source": [
        "# Example\n",
        "class BankAccount:\n",
        "    def __init__(self, account_number, balance):\n",
        "        self.__account_number = account_number  # Private attribute using double underscore\n",
        "        self.__balance = balance\n",
        "\n",
        "    def deposit(self, amount):\n",
        "        if amount > 0:\n",
        "            self.__balance += amount\n",
        "            print(f\"Deposited {amount}. New balance: {self.__balance}\")\n",
        "        else:\n",
        "            print(\"Invalid deposit amount.\")\n",
        "\n",
        "    def withdraw(self, amount):\n",
        "        if 0 < amount <= self.__balance:\n",
        "            self.__balance -= amount\n",
        "            print(f\"Withdrew {amount}. New balance: {self.__balance}\")\n",
        "        else:\n",
        "            print(\"Insufficient funds or invalid withdrawal amount.\")\n",
        "\n",
        "    def get_balance(self): #getter method\n",
        "        return self.__balance\n",
        "\n",
        "\n",
        "# Create a BankAccount object\n",
        "my_account = BankAccount(\"1234567890\", 1000)\n",
        "\n",
        "# Access data through methods (Encapsulation)\n",
        "my_account.deposit(500)\n",
        "my_account.withdraw(200)\n",
        "\n",
        "#Trying to directly access the balance would not work because it is private.\n",
        "#print(my_account.__balance)  # This will raise an AttributeError\n",
        "\n",
        "# Instead, use the get_balance() method\n",
        "print(f\"Current balance: {my_account.get_balance()}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFBiy7oBkMbb"
      },
      "source": [
        "#**Inheritence**\n",
        "\n",
        "Inheritance is a mechanism in object-oriented programming that allows you to create new classes (derived classes)based on existing classes (base classes). The derived class inherits the attributes and methods of the base class, and can also add its own attributes and methods or override existing ones.\n",
        "\n",
        "1. Types of Inheritance:\n",
        "\n",
        "- Single Inheritance: A class inherits from a single base class. (e.g., Dog inherits from Animal)\n",
        "- Multiple Inheritance: A class inherits from multiple base classes.  (Less common in Python due to potential ambiguity)\n",
        "- Multilevel Inheritance: A class inherits from a derived class, creating a chain of inheritance.\n",
        "- Hierarchical Inheritance: Multiple derived classes inherit from a single base class. (e.g., Dog and Cat both inherit from Animal)\n",
        "- Hybrid Inheritance: A combination of multiple inheritance types.\n",
        "\n",
        "\n",
        "2. Benefits of Inheritance:\n",
        "\n",
        "- Code Reusability: Avoids redundant code by inheriting attributes and methods from base classes.\n",
        "- Extensibility: Easily extend the functionality of existing classes without modifying them.\n",
        "- Polymorphism: Objects of different classes can be treated as objects of a common base class.\n",
        "- Maintainability: Changes to the base class automatically reflect in derived classes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "b-YDT4iPkFVs",
        "outputId": "3aed0070-95ab-4d2e-e7a1-6faab3e5abc6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Generic animal sound\n",
            "Woof!\n",
            "Meow!\n"
          ]
        }
      ],
      "source": [
        "# Example:\n",
        "\n",
        "class Animal:  # Base class\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "\n",
        "    def speak(self):\n",
        "        print(\"Generic animal sound\")\n",
        "\n",
        "class Dog(Animal):  # Derived class inheriting from Animal\n",
        "    def speak(self):  # Overriding the speak method\n",
        "        print(\"Woof!\")\n",
        "\n",
        "class Cat(Animal): #Derived class inheriting from Animal\n",
        "    def speak(self): #Overriding the speak method\n",
        "        print(\"Meow!\")\n",
        "\n",
        "# Create instances of the classes\n",
        "animal = Animal(\"Generic Animal\")\n",
        "dog = Dog(\"Buddy\")\n",
        "cat = Cat(\"Whiskers\")\n",
        "\n",
        "\n",
        "# Call the speak method for each object\n",
        "animal.speak()  # Output: Generic animal sound\n",
        "dog.speak()  # Output: Woof!\n",
        "cat.speak() # Output: Meow!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "A9veNQ1xlEXM",
        "outputId": "2af8224f-e6ac-4892-cf89-6da7d0e68225"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "car started...\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "class car():\n",
        "  @staticmethod\n",
        "  def start():\n",
        "    print(\"car started...\")\n",
        "  @staticmethod\n",
        "  def stop():\n",
        "    print(\"car stopped...\")\n",
        "class tata(car):\n",
        "  def __init__(self,brand,color):\n",
        "    self.brand=brand\n",
        "    self.color=color\n",
        "class nexon(tata):\n",
        "  def __init__(self,type):\n",
        "    self.type=type\n",
        "\n",
        "car1=nexon(\"petrol\")\n",
        "car2=tata(\"Nano\",\"red\")\n",
        "print(car1.start())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dzrV-JfppaWj"
      },
      "source": [
        "**Super Method**:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "93LpiiLmpZnx",
        "outputId": "4f89ec21-17a1-4c18-a410-f86e0099432c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "petrol\n"
          ]
        }
      ],
      "source": [
        "class car():\n",
        "  def __init__(self,type):\n",
        "    self.type=type\n",
        "  @staticmethod\n",
        "  def start():\n",
        "    print(\"car started...\")\n",
        "  @staticmethod\n",
        "  def stop():\n",
        "    print(\"car stopped...\")\n",
        "class tata(car):\n",
        "  def __init__(self,brand,type):\n",
        "    self.brand=brand\n",
        "    super().__init__(type)\n",
        "\n",
        "car1=tata(\"nexon\",\"petrol\")\n",
        "print(car1.type)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J1CN6kfd8xRO"
      },
      "source": [
        "#**Polymorphism**\n",
        "\n",
        "1. Polymorphism (meaning \"many forms\") is a key concept in object-oriented programming.\n",
        "2. It allows objects of different classes to be treated as objects of a common type.\n",
        "3. This means that the same method call can behave differently depending on the specific object it is called on.\n",
        "\n",
        "4. There are two main types of polymorphism:\n",
        "\n",
        "4.1. Compile-time Polymorphism (Method Overloading):\n",
        "- Not directly supported in Python.\n",
        "- In languages like Java or C++, you can have multiple methods with the same name but different parameters within the same class.\n",
        "- The compiler determines which method to call based on the arguments passed at compile time.\n",
        "\n",
        "\n",
        "4.2. Runtime Polymorphism (Method Overriding):\n",
        "- Achieved through inheritance and method overriding.\n",
        "- A subclass provides a specific implementation for a method that is already defined in its superclass.\n",
        "- The decision of which method to call is made at runtime based on the actual object type.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "FGNqWM4a_UI0",
        "outputId": "c1982456-f922-4c94-949c-d3c466c9a0ff"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "12\n",
            "narendrasingh\n",
            "[1, 2, 3, 4, 5, 6]\n"
          ]
        }
      ],
      "source": [
        "print(1+2) #3 sum\n",
        "print(\"1\"+\"2\") #12 concatenation\n",
        "print(\"narendra\"+\"singh\")#narendrasingh  concatenation\n",
        "print([1,2,3]+[4,5,6]) # merge"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/",
          "height": 211
        },
        "id": "sMASAI39_97G",
        "outputId": "2f243b37-f8a8-42d9-daa8-8f124f1ab91f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 i + 3 j\n",
            "6 i + 7 j\n"
          ]
        }
      ],
      "source": [
        "class complex():\n",
        "  def __init__(self,real,img):\n",
        "    self.real=real\n",
        "    self.img=img\n",
        "  def shownum(self):\n",
        "    print(self.real,\"i +\",self.img,\"j\")\n",
        "  def add(self,num2):\n",
        "    newreal=self.real+num2.real\n",
        "    newimg=self.img+num2.img\n",
        "    return complex(newreal,newimg)\n",
        "num1=complex(2,3)\n",
        "num1.shownum()\n",
        "num2=complex(6,7)\n",
        "num2.shownum()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Ub8Q-5NChai"
      },
      "source": [
        "#**Dunder Functions**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "xGsAm-tJClPW",
        "outputId": "6d69c9c7-15fd-46eb-fb8d-9fbc063bbe85"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 i + 3 j\n",
            "6 i + 7 j\n",
            "8 i + 10 j\n"
          ]
        }
      ],
      "source": [
        "class complex():\n",
        "  def __init__(self,real,img):\n",
        "    self.real=real\n",
        "    self.img=img\n",
        "  def shownum(self):\n",
        "    print(self.real,\"i +\",self.img,\"j\")\n",
        "  def __add__(self,num2):\n",
        "    newreal=self.real+num2.real\n",
        "    newimg=self.img+num2.img\n",
        "    return complex(newreal,newimg)\n",
        "num1=complex(2,3)\n",
        "num1.shownum()\n",
        "num2=complex(6,7)\n",
        "num2.shownum()\n",
        "num3=num1+num2\n",
        "num3.shownum()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "DFojM3ZaDBBX",
        "outputId": "9f2c4677-de17-4e3a-e4b4-d10a1097cb2f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 i + 3 j\n",
            "6 i + 7 j\n",
            "8 i + 10 j\n",
            "-4i + -4j\n",
            "-4i + -4j\n",
            "complex(-4, -4)\n",
            "-9i + 32j\n",
            "0.38823529411764707i + 0.047058823529411764j\n",
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# prompt: Dunder Functions\n",
        "\n",
        "class complex():\n",
        "  def __init__(self,real,img):\n",
        "    self.real=real\n",
        "    self.img=img\n",
        "  def shownum(self):\n",
        "    print(self.real,\"i +\",self.img,\"j\")\n",
        "  def __add__(self,num2):\n",
        "    newreal=self.real+num2.real\n",
        "    newimg=self.img+num2.img\n",
        "    return complex(newreal,newimg)\n",
        "  def __sub__(self, num2):\n",
        "    newreal = self.real - num2.real\n",
        "    newimg = self.img - num2.img\n",
        "    return complex(newreal, newimg)\n",
        "  def __mul__(self, num2):\n",
        "    newreal = (self.real * num2.real) - (self.img * num2.img)\n",
        "    newimg = (self.real * num2.img) + (self.img * num2.real)\n",
        "    return complex(newreal, newimg)\n",
        "  def __truediv__(self, num2):\n",
        "    denominator = num2.real**2 + num2.img**2\n",
        "    newreal = ((self.real * num2.real) + (self.img * num2.img)) / denominator\n",
        "    newimg = ((self.img * num2.real) - (self.real * num2.img)) / denominator\n",
        "    return complex(newreal, newimg)\n",
        "  def __eq__(self, num2):\n",
        "      return self.real == num2.real and self.img == num2.img\n",
        "  def __ne__(self, num2):\n",
        "      return not self.__eq__(num2)\n",
        "  def __str__(self):\n",
        "    return f\"{self.real}i + {self.img}j\"\n",
        "  def __repr__(self):\n",
        "    return f\"complex({self.real}, {self.img})\"\n",
        "\n",
        "\n",
        "num1=complex(2,3)\n",
        "num1.shownum()\n",
        "num2=complex(6,7)\n",
        "num2.shownum()\n",
        "num3=num1+num2\n",
        "num3.shownum()\n",
        "num4 = num1 - num2\n",
        "print(num4) # Output from __str__\n",
        "print(num4.__str__()) # Output from __str__\n",
        "print(num4.__repr__()) # Output from __repr__\n",
        "num5 = num1 * num2\n",
        "print(num5)\n",
        "\n",
        "num6 = num1 / num2\n",
        "print(num6)\n",
        "\n",
        "print(num1 == num2)  # Output: False (because 2+3i != 6+7i)\n",
        "print(num1 != num2) #Output: True\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "wBVWSWTV-KwG",
        "outputId": "c5227aad-967a-41c6-a5f7-57729046cc82"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Woof!\n",
            "Meow!\n",
            "Moo!\n",
            "78.5\n",
            "16\n"
          ]
        }
      ],
      "source": [
        "# Example (Method Overriding):\n",
        "\n",
        "from abc import ABC, abstractmethod\n",
        "\n",
        "class Animal(ABC):\n",
        "    @abstractmethod\n",
        "    def speak(self):\n",
        "        pass\n",
        "\n",
        "class Dog(Animal):\n",
        "    def speak(self):\n",
        "        print(\"Woof!\")\n",
        "\n",
        "class Cat(Animal):\n",
        "    def speak(self):\n",
        "        print(\"Meow!\")\n",
        "\n",
        "class Cow(Animal):\n",
        "    def speak(self):\n",
        "        print(\"Moo!\")\n",
        "\n",
        "animals = [Dog(), Cat(), Cow()]\n",
        "\n",
        "for animal in animals:\n",
        "    animal.speak()  # Polymorphism in action!  The correct speak() method is called for each object.\n",
        "\n",
        "\n",
        "# Another Example:\n",
        "\n",
        "class Shape:\n",
        "    def area(self):\n",
        "        pass\n",
        "\n",
        "class Circle(Shape):\n",
        "    def __init__(self, radius):\n",
        "        self.radius = radius\n",
        "    def area(self):\n",
        "        return 3.14 * self.radius * self.radius\n",
        "\n",
        "class Square(Shape):\n",
        "    def __init__(self, side):\n",
        "        self.side = side\n",
        "    def area(self):\n",
        "        return self.side * self.side\n",
        "\n",
        "shapes = [Circle(5), Square(4)]\n",
        "for shape in shapes:\n",
        "  print(shape.area())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WC8bl6Nv94sW"
      },
      "source": [
        "#**Practice Questions**\n",
        "**Q1. Create student class that takes name & marks of three subjects as argument in constructors. Create method to print average.**\n",
        "\n",
        "**Q2. Create account class with 2 attributes - balance & account no. Create methods for debit, credit & printing the balance.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "8nWpWRM59BDT",
        "outputId": "93233374-47db-474d-fac6-0ad4ec69f843"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "80.0"
            ]
          },
          "execution_count": 126,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name,phy,chem,math):\n",
        "    self.name=name\n",
        "    self.phy=phy\n",
        "    self.chem=chem\n",
        "    self.math=math\n",
        "  def avg_marks(self):\n",
        "    return (self.phy+self.chem+self.math)/3\n",
        "s1=student(\"nandu\",90,80,70)\n",
        "s1.avg_marks()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ux77I9Zq-uet",
        "outputId": "74d39eb5-cb70-400f-e6c0-677e0a5396f9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi nandu  your avg score is :  80.0\n"
          ]
        }
      ],
      "source": [
        "class student:\n",
        "  def __init__(self,name,marks):\n",
        "    self.name=name\n",
        "    self.marks=marks\n",
        "  def avg_marks(self):\n",
        "    sum=0\n",
        "    for i in self.marks:\n",
        "      sum+=i\n",
        "    print(\"Hi\",self.name,\" your avg score is : \", sum/len(self.marks))\n",
        "s1=student(\"nandu\",[90,80,70])\n",
        "s1.avg_marks()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "OO00xp64_35i",
        "outputId": "b479536f-6de8-4d57-ba3a-6b8bc5eef594"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi Ironman  your avg score is :  80.0\n"
          ]
        }
      ],
      "source": [
        "s1.name=\"Ironman\"\n",
        "s1.avg_marks()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0VEdDLfmTWb0"
      },
      "source": [
        "**Q2. Create account class with 2 attributes - balance & account no. Create methods for debit, credit & printing the balance.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "ugmtFCDJT2pW",
        "outputId": "8575c6ae-1f3b-4882-b00e-70704b2a2904"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Your account is debited by :  1000\n",
            "Your current balance is :  9000\n",
            "Your account is credited by :  1000\n",
            "Your current balance is :  10000\n",
            "Your total current balance is :  10000\n"
          ]
        }
      ],
      "source": [
        "class account:\n",
        "  def __init__(self,acc_no,balance):\n",
        "    self.acc_no=acc_no\n",
        "    self.balance=balance\n",
        "  #debit method\n",
        "  def debit(self,deb_amt):\n",
        "    self.deb_amt=deb_amt\n",
        "    self.balance-=self.deb_amt\n",
        "    print(\"Your account is debited by : \",self.deb_amt)\n",
        "    print(\"Your current balance is : \",self.balance)\n",
        "  #credit method\n",
        "  def credit(self,cred_amt):\n",
        "    self.cred_amt=cred_amt\n",
        "    self.balance+=self.cred_amt\n",
        "    print(\"Your account is credited by : \",self.cred_amt)\n",
        "    print(\"Your current balance is : \",self.balance)\n",
        "  #print balance method\n",
        "  def get_balance(self):\n",
        "    print(\"Your total current balance is : \",self.balance)\n",
        "a1=account(123456789,10000)\n",
        "a1.debit(1000)\n",
        "a1.credit(1000)\n",
        "a1.get_balance()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XqvpwTGpECwZ"
      },
      "source": [
        "**Q3. Define a circleclass to create a circle with radius r using constructor.\n",
        "Define an area Method of cxlass which calc area of the circle. Define perimeter method of the class which calc perimeter of the circle.***"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "26I2fwH9EIr-",
        "outputId": "38c5d28d-0d99-4977-ad80-e31d1dbf1c2e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2464.0\n",
            "176.0\n"
          ]
        }
      ],
      "source": [
        "class circle:\n",
        "  def __init__(self,radius):\n",
        "    self.radius=radius\n",
        "  def area(self):\n",
        "    return 22/7*self.radius*self.radius\n",
        "  def perimeter(self):\n",
        "    return 2*22/7*self.radius\n",
        "c1=circle(28)\n",
        "print(c1.area())\n",
        "print(c1.perimeter())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rUm4Dm41FTRs"
      },
      "source": [
        "**Q4. Define a Employeeclass with attributes role, dept & salary. This class also has a showDetails() method**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "9loafOczGGq5",
        "outputId": "0ba456fe-9cbf-448d-ca35-e67551150155"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Role :  Data Analyst\n",
            "Department :  Finance\n",
            "Salary :  900000\n"
          ]
        }
      ],
      "source": [
        "class employee():\n",
        "  def __init__(self,role,dept,salary):\n",
        "    self.role=role\n",
        "    self.dept=dept\n",
        "    self.salary=salary\n",
        "  def showDetails(self):\n",
        "    print(\"Role : \",self.role)\n",
        "    print(\"Department : \",self.dept)\n",
        "    print(\"Salary : \",self.salary)\n",
        "emp1=employee(\"Data Analyst\",\"Finance\",900000)\n",
        "emp1.showDetails()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7RByt0llGHFM"
      },
      "source": [
        "**Q5. Create an engineer class that inherits properties from Employee and has additional attributes : name & age**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "HmnpYsPYHWx8",
        "outputId": "f55e3aac-7817-4751-fe81-2ca04b3153f6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Role :  Data Analyst\n",
            "Department :  Finance\n",
            "Salary :  900000\n"
          ]
        }
      ],
      "source": [
        "class employee():\n",
        "  def __init__(self,role,dept,salary):\n",
        "    self.role=role\n",
        "    self.dept=dept\n",
        "    self.salary=salary\n",
        "  def showDetails(self):\n",
        "    print(\"Role : \",self.role)\n",
        "    print(\"Department : \",self.dept)\n",
        "    print(\"Salary : \",self.salary)\n",
        "class engineer(employee):\n",
        "  def __init__(self,name,age):\n",
        "    self.name=name\n",
        "    self.age=age\n",
        "    super().__init__(\"Data Analyst\",\"Finance\",900000)\n",
        "eng1=engineer(\"Narendra Singh\",24)\n",
        "eng1.showDetails()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fxMjnLDJVy9"
      },
      "source": [
        "**Q6.Create a class called orer which stores item & its price. Use dunder function __gt__() to convey that: order1>order2 if price of order1>price of order2**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "7sC6H-w4JwFB",
        "outputId": "8544af45-ab10-4d73-a648-c243e44c14ef"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 133,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "class order():\n",
        "  def __init__(self,item,price):\n",
        "    self.item=item\n",
        "    self.price=price\n",
        "  def __gt__(self,other):\n",
        "    return self.price>other.price\n",
        "ord1=order(\"pen\",10)\n",
        "ord2=order(\"pencil\",5)\n",
        "ord1>ord2"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "Tf50zpi50JOf",
        "qePtf3XnZGeG",
        "saCQmn8Auk-X",
        "D8PiWbIuDW5D",
        "e587NAY3jHIn",
        "TFBiy7oBkMbb",
        "1Ub8Q-5NChai",
        "XqvpwTGpECwZ"
      ],
      "provenance": [],
      "authorship_tag": "ABX9TyO6nO8Jz8nyb6JS8VJWMg6Q",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}