Python_Basics_12(scipy and sympy).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNmgG5jWuuwHKqjifTgz5T5",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Dhinesh-Fedor/Python---Basics/blob/main/Python_Basics_12(scipy%20and%20sympy).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QskySxdcnq9e",
        "outputId": "9320ea1e-5fac-480b-edbf-85194f4dc2e8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[7 2]\n",
            " [4 5]]\n",
            "\n",
            " [[ 8]\n",
            " [10]]\n",
            "\n",
            " [[0.74074074]\n",
            " [1.40740741]]\n"
          ]
        }
      ],
      "source": [
        "#SciPy linar algebra\n",
        "#SciPy => scientific  python\n",
        "\n",
        "#Solving Linear equations using scipy linalg\n",
        "\n",
        "#equations => 7x+2y = 8 , 4x+5y=10\n",
        "#importing linalg from scipy\n",
        "from scipy import linalg\n",
        "import numpy as n\n",
        "\n",
        "a = n.matrix('7,2;4,5')\n",
        "b = n.matrix('8;10')\n",
        "\n",
        "print(a)\n",
        "print(\"\\n\",b)\n",
        "\n",
        "res = linalg.solve(a,b)\n",
        "print(\"\\n\",res)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as  plt\n",
        "\n",
        "x = n.linspace(0,2*n.pi)\n",
        "y = n.sin(x)\n",
        "\n",
        "#plotting\n",
        "plt.rc('font',size = 14)\n",
        "plt.plot(x,y,'black',label = 'sin(x)')\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "id": "Br1g5N7nwyu4",
        "outputId": "42fa7af4-86cb-492d-9cdd-e5fea34aeef4"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAG6CAYAAACr0yo5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABuVklEQVR4nO3dd1QU1/8+8GdpK1IVNFixoTHWGDV2LBGwRBNjbAmCxhobYkEssYMFNbF3RI01fuyxJSpGLLFrrNh7VJRdQal7f3/42/1KKFIW7u7yvM7Zc8LM3Zln0TjvvXPnXoUQQoCIiIiI8pyZ7ABERERE+RULMSIiIiJJWIgRERERScJCjIiIiEgSFmJEREREkrAQIyIiIpKEhRgRERGRJBayA1D6NBoNHj9+DDs7OygUCtlxiIiIKBOEEHj9+jWKFy8OM7OM+7xYiBmwx48fo1SpUrJjEBERUTY8ePAAJUuWzLANCzEDZmdnB+DdH6S9vb3kNERERJQZarUapUqV0l3HM8JCzIBpb0fa29uzECMiIjIymRlWxMH6RERERJKwECMiIiKShIUYERERkSQsxIiIiIgkYSFGREREJAkLMSIiIiJJOH0FERGRniQmJiI5OVl2DNIzc3NzWFpa5sqxWYgRERHlkFqtxosXLxAfHy87CuUSpVIJZ2dnvc/raZKF2Nq1a/HXX3/hzJkzuHTpEhISEhAaGgpfX98sHUej0WDBggVYunQpbt68CVtbW3zxxReYOnUqypUrl+Z79u3bh6CgIJw9exYKhQKfffYZxo4dixYtWujhkxERkaFRq9V49OgRbG1t4ezsDEtLS64PbEKEEEhMTIRKpcKjR48AQK/FmEkWYmPHjsW9e/fg7OyMYsWK4d69e9k6Tt++fbF8+XJUqVIFgwcPxuPHj7Fp0ybs378fJ06cgJubW4r2a9euhbe3N4oUKaIr+jZu3IiWLVti06ZN6NixY04/GhERGZgXL17A1tYWJUuWZAFmoqytrWFnZ4eHDx/ixYsXei3ETHKw/vLly3H37l08f/4c/fr1y9YxDh06hOXLl6NJkyY4e/Yspk+fjjVr1mDbtm14+fIlBg4cmKL9q1evMGjQIDg7O+Ps2bOYN28e5s2bh7Nnz8LJyQn9+/fH69ev9fHxiIjIQCQmJiI+Ph4ODg4swkycQqGAg4MD4uPjkZiYqLfjmmQh9sUXX8DV1TVHx1i2bBkAYPLkybCystJtb9WqFZo2bYr9+/fj/v37uu2bN29GdHQ0Bg0alGKl9ZIlS2LgwIF48eIFtm7dmqNMRERkWLQD83NrIDcZFu2fsz4fyDDJQkwfDh8+DBsbGzRs2DDVPk9PTwBAeHh4ivYA4OHhkan2RNkRExODf//9V6/fxogo59gblj/kxp+zSY4Ry6nY2Fg8efIEVatWhbm5ear92rFhkZGRum3a//7vuLH02qclPj4+xRM3arU66+HJZAghcPv2bRw7dgzHjx/HsWPHcOnSJWg0GgCAg4MDnJycdC9nZ2fdf5ctWxbt2rXT+9M9RESkXyzE0qBSqQC8u9ClRXtx07b70HvSap+W4OBgTJw4MeuBySS8ffsWp0+fTlF4PX/+PN32KpUKKpUKt2/fTnO/tbU1vv76a/j6+qJ58+ZpfqkgIiK5WIgZkMDAQPj7++t+VqvVKFWqlMRElBeio6Mxa9Ys/Pzzz4iJiUmxz8rKCp999hnq16+PBg0aoH79+vjoo4/w6tUrREVF4cWLF4iKitK9tD9HRETg6tWrWLduHdatW4eSJUvC29sbPj4+qFSpkqRPSkRE/8VCLA3aXq30erC0twzf7/16/z1OTk4fbJ8WpVIJpVKZvdBkdGJjYzF37lzMnDkTr169AgC4uLigQYMGuqKrVq1aKFCgQKr3Ojs7w9nZOd2iSgiB06dPY9WqVVi/fj0ePnyI4OBgBAcHo169evD19UXnzp3h6OiYmx+RiAjAu7FV7u7uuvHUOfHmzRu4ubmhTZs2WLp0abaO8ccff6Bly5bYvXs3WrduneNMOcHB+mmwsbFBsWLFcOfOnTSfjEhrPFhG48AyGj9G+U98fDzmzp2L8uXLY/To0Xj16hU++eQTbNmyBY8fP8aWLVswbNgwNGjQIM0iLDMUCgXq1KmDBQsW4MmTJ9i8eTPatGkDc3NznDhxAv369UOxYsUQHByMpKQkPX9CIqLcM3PmTLx48QJjx47N9jG++OILNGrUCCNHjpS+JBULsXS4u7sjNjYWERERqfbt27cPANCkSZMU7QFg//796bbXtqH8KSkpCStWrICbmxuGDBmCf//9F+XKlcOaNWtw8eJFdOjQIVeeyFEqlejYsSN27dqFhw8fIiQkBFWqVEFcXBxGjx6N+vXr4/Lly3o/LxGR1tWrV7F69eocH0etViMkJASdO3dG6dKlc3SskSNH4vLly9iwYUOOc+WIMHHBwcECgAgNDU1z//Pnz8XVq1fF8+fPU2w/ePCgACCaNGki4uPjddt///13AUB4eHikaP/y5Uvh4OAgnJ2dxYMHD3TbHzx4IJydnYWzs7NQq9VZyq5SqQQAoVKpsvQ+MiwajUasX79euLm5CQACgChRooRYvHixSEhIkJYpLCxMODo6CgDCyspKBAUFicTERCl5iIzV27dvxZUrV8Tbt29lR8kX5s+fLwCIAwcO5PhYCQkJwtnZWTRq1CjT78nsn3dWrt8mWYgtW7ZM+Pj4CB8fH1GrVi0BQDRs2FC3bdmyZbq248ePFwDE+PHjUx2nV69eAoCoUqWKGDlypPD29hZWVlaicOHC4vr166nar1mzRgAQRYoUEQMHDhQDBw4URYoUEQqFQmzatCnLn4OFmPF7/fq1+Oabb3QFmLOzs5g9e7Z48+aN7GhCCCEePXok2rRpo8tXu3ZtcenSJdmxiIwGCzEhfvvtN9GkSRNRpEgRoVQqRbFixUSLFi3Eb7/9pmsDQLi7u6d4n4+PjwAgbt++LX755RdRqVIlYWVlJUqXLi0mTJggkpOTU53rs88+E4ULF061b/369QKAaNWqldBoNJnep73OR0ZGZuqzshDLJO0fbnovHx8fXduMCrHk5GTxyy+/iCpVqgilUimcnJxE586dxc2bN9M99549e0Tjxo2FjY2NsLW1Fe7u7tmu3FmIGbdbt26JatWqCQDC0tJSTJw4Mcu9onlBo9GI1atXp+gdmzp1KnvHiDIhowuzRqMRMTExBv36b2GSVQsXLhQARLFixUSfPn1EYGCg6NGjh6hSpYr47rvvdO0yKsS++eYb4ezsLHx9fcXgwYNF6dKlBQAxevToFO1fvnwpzMzMhJeXV5pZtMebM2eObtudO3eEg4OD+Oijj8S///6b6j0rVqwQAMSSJUsy9XlZiOUzLMSM14EDB0ThwoUFAOHi4iIiIiJkR/qgR48eibZt2+q+sHz22WfsHSP6gIwuzDExMRl2ChjCKyYmJkefv1atWsLKyirNIufFixe6/86oECtbtqx4/Pixbvvz58+Fo6OjsLOzSzE0aPfu3QKAGDNmTJpZXr9+LSpUqCCUSqU4d+6cSEpKEg0aNBAKhULs3bs3zfdcuHBBABDdu3fP1OfNjUKMg/WJ9EgIgTlz5sDT0xMvX75E3bp1cfr0aTRo0EB2tA8qXrw4duzYgdWrV8PR0RFnzpxBrVq1sHjxYtnRiMiAWVpaprnW5n+nckrPuHHjUKxYMd3Pzs7OaN++PV6/fo3r16/rtj98+BAA8NFHH6V5HFtbW6xfvx4ajQZdu3bFqFGjcOzYMfj5+emWGvwv7bG0x5aB84gR6cnbt2/Rt29frFmzBgDg4+ODxYsXZ3sKChkUCgW8vb3xxRdfoG/fvti5cyf69+8PlUqFgIAA2fGIjErBggVTTdJsaAoWLJij93fp0gUjR45E1apV0a1bNzRr1gyNGjXK0vJqn332WaptJUuWBPBuwmutqKgoAMhw/sPatWtj8uTJGDVqFK5du4aaNWti2rRp6bYvXLgwAODFixeZzqtvLMSI9ODBgwfo0KEDTp8+DXNzc8yaNQuDBw822oWAixUrhu3bt2PcuHGYOnUqRo0aBbVajSlTphjtZyLKawqFAjY2NrJj5Krhw4fDyckJixYtwqxZsxASEgILCwu0adMGc+bMQdmyZT94jLSKNguLd+XJ+3N8WVtbAwDi4uIyPF779u0xevRoaDQa9OnTB1ZWVum2ffv2LYCcF6Q5wVuTRDl09OhR1K5dG6dPn4aTkxP279+PIUOGGH3BolAoMGXKFN23yaCgIPj5+ekWHSciUigU6NmzJ06dOoXnz59j69at6NChA7Zv3462bdvqdbLUIkWKAABevnyZbpvExER8//33AN71nI0dOzbD247aY2mPLQMLMaIcWLduHZo3b45nz56hevXqOHXqFJo3by47ll4FBARgwYIFAIC5c+eiV69e0meiJiLD4+TkhK+++gobN25E8+bNceXKFdy8eVNvx69WrRoApBg39l+jR4/GmTNnMHr0aKxZswYvX76Et7d3ul8gtcfSHlsGFmJE2bRjxw50794diYmJ+Pbbb3Hs2LFMdcMbox9//BFhYWEwMzNDaGgounbtioSEBNmxiEiyw4cPQwiRYltiYqKup0mfY2SrVauGwoUL4+TJk2nuP3DgAGbNmoV69eph/PjxaNu2LQYMGIDDhw+nO05MeyyZK99wjBhRNoSHh6NTp05ITk6Gj48PVq5cCTMz0/5e0717d9ja2qJLly7YvHkz3rx5g82bN+vGbRBR/vPVV1/B3t4e9erVg6urKxITE3HgwAFcuXIFHTt2hKurq97OpVAo0L59e6xatQoPHz7UDegH3g229/HxgZ2dHdatW6cbYxYSEoLw8HCMHz8eLVq0wOeff57imAcOHEChQoVSLFmY10z7ykGUC86dO4d27dohPj4e7dq1w/Lly02+CNPq0KEDdu7cCWtra+zevRtt2rTB69evZcciIkmCg4Px6aef4u+//8b8+fOxdu1a2NraYtGiRVi3bp3ez9evXz8IIVIdu0ePHnjy5AkWLlyY4s5EgQIFsH79elhYWKBbt24p/r26e/cuIiIi4OPjI/XpdoX4b58iGQy1Wg0HBweoVKosPQpMuefGjRto1KgRnj9/Dnd3d+zdu9eopqfQl7/++ktXhH3++ef4/fffdY+BE+UncXFxuHPnDsqWLZsv/y2QoXHjxnj+/DmuXLmSoy/BY8eOxYwZM3D16lWUL18+U+/J7J93Vq7f+eNrPJEePHz4EB4eHnj+/Dlq1aqFHTt25Nt/eBs3boyDBw/qxmt4enrizZs3smMRUT4wc+ZMXL9+HRs2bMj2MV69eoV58+ahf//+mS7CcgsLMaJMiIqKgqenJ+7duwc3Nzfs2bMn3/dS1q5dG+Hh4XBycsLp06fxww8/pBq0S0Skb/Xq1cOSJUty9PT2nTt3MHToUPz00096TJY9HKxP9AExMTFo06YNrly5ghIlSuDAgQMoWrSo7FgGoWrVqtiyZQu++OILbNiwAVWrVsWYMWNkxyIiE9enT58cvb9WrVqoVauWntLkDHvEiDIQHx+PDh064OTJkyhcuDD279+v16eATIG7u7tunrGxY8di27ZtcgMRERkRFmJE6UhOToa3tzcOHDgAGxsb7NmzB5988onsWAapT58+GDhwIADg+++/x8WLFyUnIiIyDizEiNIxZMgQbN68GZaWlti2bRvq1q0rO5JBmzNnDlq0aIHY2Fi0a9cOz58/lx2JiMjgsRAjSsP69euxYMECKBQKrFu3Dl988YXsSAbPwsICmzZtQoUKFXDv3j188803nH2f8g0+qJI/5MafMwsxov+4ceOGbiDo2LFj0bFjR8mJjEfhwoWxY8cO2Nvb46+//sLAgQN5gSKTZmlpCYVCgdjYWNlRKA/ExsZCoVDA0tJSb8fkU5NE74mLi0OnTp0QExMDd3d3jB8/XnYko1O5cmWsX78ebdu2xbJly1CtWjUMGjRIdiyiXGFubg4HBwc8f/4c8fHxsLe3h4WFBRQKhexopCdCCCQlJUGtVkOtVsPR0RHm5uZ6Oz5n1jdgnFk/7/Xv3x+LFy9GkSJFcP78eRQvXlx2JKMVEhKCESNGwNzcHHv37uXtXTJZQgioVCo8e/YsR3NbkWEzNzdH0aJF4eDg8MFCOyvXbxZiBoyFWN7atGkTOnfuDIVCgb1798LDw0N2JKMmhICvry9Wr14NR0dH/P3333Bzc5MdiyjXCCGQnJyMpKQk2VFIzywsLGBubp7pns6sXL95a5IIwM2bN9GrVy8AQGBgIIswPVAoFFiyZAlu3LiBEydOoF27djh9+jRsbGxkRyPKFQqFAhYWFrCw4KWVMo+D9Snf044Le/36NRo3boyJEyfKjmQyChQogK1bt6J48eK4du0aRo0aJTsSEZFBYSFG+d7w4cNx7tw5ODk5Yd26dfw2q2cuLi5YtWoVAGD+/Pn4448/5AYiIjIgLMQoX/vtt990y/OsWbMGJUuWlJzINLVs2RI//vgjAKBHjx6Ijo6WG4iIyECwEKN86/bt2/jhhx8AACNHjkSrVq0kJzJtM2bMQIUKFfDw4UMMGTJEdhwiIoPAQozypfj4eHTu3BlqtRoNGjTAlClTZEcyeTY2NggLC4OZmRlWr16NrVu3yo5ERCQdCzHKl0aOHInTp0+jcOHC2LBhg15nSab0NWjQACNHjgQA9O3bF8+ePZOciIhILpMtxE6dOoXWrVvD0dERNjY2qFevHjZt2pTp95cpUwYKhSLD119//ZXiPRm19fX11fMnpOw6fPgw5s6dCwAICwtDqVKlJCfKXyZMmIDq1avj+fPn6NOnD5dAIqJ8zSQfDzt06BA8PT1RoEABdOnSBXZ2dtiyZQs6d+6MBw8eYNiwYR88hp+fX5oDil+8eIEFCxagUKFCqFOnTqr9rq6uaRZdNWvWzMYnIX17+/atbh3Jvn37om3btpIT5T9KpRKrV69GnTp1sH37dqxevRo+Pj6yYxERySFMTGJioihfvrxQKpXi3Llzuu3R0dGiYsWKwsrKSty9ezfbxw8JCREAxKBBg1LtAyDc3d2zfez/UqlUAoBQqVR6O2Z+N2bMGAFAFCtWTERHR8uOk68FBQUJAMLe3l7cu3dPdhwiIr3JyvXb5G5NHjx4ELdu3UK3bt1S9EI5ODhg9OjRSEhIQFhYWLaPv2LFCgDQPW1HxuPSpUuYPn06gHfzWTk4OEhOlL+NGDEC9erVg1qtRs+ePaHRaGRHIiLKcyZXiB0+fBgA0lyixtPTEwAQHh6erWMfO3YMV69eRe3atVGjRo0020RHR2Pp0qUICgrC4sWLcenSpWydi/QrOTkZvXv3RlJSEr766it06NBBdqR8z8LCAqtXr0bBggXx559/6uZzIyLKT0xujFhkZCQApLm4sIuLC2xtbXVtskrbG6ZdkzAtFy5cQN++fVNs8/LyQlhYGIoWLZrh8ePj4xEfH6/7Wa1WZysnpbZo0SKcPHkSdnZ2mD9/vuw49P+5ublhxowZGDhwIAICAuDp6YmKFSvKjkVElGdMrkdMpVIBQLq3nezt7XVtsiImJgabNm1CwYIF0bVr1zTbDBs2DMeOHcOLFy+gVqtx7NgxtGrVCnv37kXbtm2RnJyc4TmCg4Ph4OCge/FpPv148OABAgMDAQDTpk1DiRIlJCei9/Xv3x8tW7bE27dv0b17dyQlJcmORESUZ0yuEMstGzduRExMDL799lvY29un2SYkJAT169eHk5MT7OzsUL9+fezatQvu7u44deoUtm/fnuE5AgMDoVKpdK8HDx7kxkfJV4QQGDBgAGJiYtCgQQP069dPdiT6DzMzM6xcuRIODg44efIkFi1aJDsSEVGeMblCTNsTll6vl1qtztYg7czclkyLmZkZevfuDQCIiIjIsK1SqYS9vX2KF+XMli1bsHPnTlhaWmLp0qUwMzO5v/ImoWTJkroHKcaNG4d///1XciIiorxhclcl7diwtMaBPX36FDExMWmOH8vIlStXcPz4cXz88cdo1KhRljM5OzsDAGJjY7P8Xsq+V69eYdCgQQCAUaNGoUqVKpITUUZ69eqFWrVqQaVS6W4lExGZOpMrxNzd3QEA+/fvT7Vv3759KdpkVk6nrDh58iSAd7P1U94JCAjA06dPUalSJYwePVp2HPoAc3Nz3ZOToaGhOHHihORERES5TyGEaa0vkpSUhEqVKuHRo0c4ceKEbi4xlUqFunXr4u7du7h+/bquKHry5AlUKhWKFSuW5i3LxMRElChRAtHR0Xj48GG6Tz5eunQJH3/8cao1C48dO4aWLVsiMTERV69eRfny5TP9WbS3UVUqFW9TZtGRI0d0BXd4eDiaNGkiORFlVs+ePREaGopatWrh77//hrm5uexIRERZkpXrt8n1iFlYWGD58uXQaDRo0qQJ+vTpg2HDhqFGjRq4ceMGgoKCUvRMBQYGonLlyti6dWuax9uxYweeP3+OL7/8MsPpJ2bNmoXixYvj66+/xuDBgzFs2DB4eXmhUaNGiIuLw9y5c7NUhFH2xcXF6ZYx6t27N4swI6N9evjs2bNYvny57DhERLnK5AoxAGjWrBmOHj2Khg0bYuPGjVi0aBE++ugjbNiwIVPrTL4vs4P027dvj4YNG+LChQtYuXIl5s2bhytXrqBLly44fvw4n9bLQ0FBQbh+/TpcXFwwY8YM2XEoiz766CNMmjQJADB69GhERUVJTkRElHtM7takKeGtyay7du0aqlevjsTERGzevBkdO3aUHYmyISkpCbVq1cKlS5fQr18/TmlBREYlX9+apPxtxIgRSExMRJs2bfDNN9/IjkPZZGFhoVsBYcmSJThz5ozkREREuYOFGJmMP//8E7t27YKFhQVmzZoFhUIhOxLlQJMmTdCtWzcIITBw4EAuCk5EJomFGJmE5ORk3fi//v37o1KlSpITkT7MnDkTtra2OHHiBFavXi07DhGR3rEQI5MQFhaGCxcuwNHREePHj5cdh/SkePHiuj/PkSNHIjo6Wm4gIiI9YyFGRi8mJgZjxowBAIwdOxZOTk6SE5E+DR48GB9//DGeP3/OIpuITA4LMTJ6M2fOxNOnT1GuXDkMHDhQdhzSMysrK8ydOxcAMH/+fFy8eFFyIiIi/WEhRkbt4cOHmDlzJgBgxowZUCqVkhNRbmjZsiW++eYbaDQaDBo0CJx1h4hMBQsxMmpjxozB27dv0ahRI3To0EF2HMpFs2fPhrW1NY4cOYKNGzfKjkNEpBcsxMhonTlzRvckHaerMH2lS5dGYGAggHcFeEJCguREREQ5x0KMjJIQQjddxXfffYe6detKTkR5YejQofjoo49w+/ZtrkNJRCaBhRgZpe3btyM8PBwFChRAUFCQ7DiUR2xtbTFu3DgAwKRJkxATEyM5ERFRzrAQI6OTkJCAkSNHAgD8/f1RunRpyYkoL/Xu3RvlypXDv//+i19++UV2HCKiHGEhRkZn0aJFiIyMRNGiRTFq1CjZcSiPWVlZYfLkyQDePSkbFRUlORERUfaxECOj8vLlS0ycOBEAMHnyZNjZ2UlORDJ06dIFNWrUgFqtRnBwsOw4RETZxkKMjMqUKVPw6tUrVK1aFT179pQdhyQxMzPTFWDz58/H/fv3JSciIsoeFmJkNG7evIn58+cDAEJCQmBhYSE5Ecnk5eUFd3d3xMfH63pJiYiMDQsxMho//fQTEhMT4enpCU9PT9lxSDKFQoFp06YBAFatWoUrV65ITkRElHUsxMgoXL58GRs2bAAAjgkinXr16uGrr76CRqPB2LFjZcchIsoyFmJkFCZMmAAhBDp06IBPP/1UdhwyIFOnToWZmRm2bt2KEydOyI5DRJQlLMTI4F24cAG//fYbFAoFJkyYIDsOGZhPPvkEPj4+AIBRo0ZxQXAiMiosxMjgaYuvTp06oVq1anLDkEGaMGEClEolwsPDsW/fPtlxiIgyjYUYGbQzZ85g27ZtMDMzw/jx42XHIQNVunRpDBgwAAAQGBgIjUYjORERUeawECODpi2+unXrhsqVK0tOQ4Zs9OjRsLe3x/nz57Fx40bZcYiIMoWFGBmsEydOYPfu3TA3N8dPP/0kOw4ZOCcnJ4wYMQIAMHbsWCQkJEhORET0YSzEyGBpe8O6d+8ONzc3yWnIGPj5+eGjjz7C7du3sXz5ctlxiIg+iIUYGaSjR49i//79sLCwwLhx42THISNha2ur+/sSFBSE+Ph4yYmIiDLGQowMkvZWZM+ePVG2bFnJaciY9OrVCyVKlMCjR4+watUq2XGIiDJksoXYqVOn0Lp1azg6OsLGxgb16tXDpk2bMv3+VatWQaFQpPs6fPhwrpyXgEOHDuHQoUOwsrLCmDFjZMchI6NUKjFy5EgA71ZhSExMlJyIiCh9Jrlq8qFDh+Dp6YkCBQqgS5cusLOzw5YtW9C5c2c8ePAAw4YNy/Sx2rdvj5o1a6baXqZMmVw9b34lhND1hvXu3RulS5eWnIiMUe/evREUFIR79+5hzZo16Nmzp+xIRERpEyYmMTFRlC9fXiiVSnHu3Dnd9ujoaFGxYkVhZWUl7t69+8HjhIaGCgAiNDQ0T8/7PpVKJQAIlUqVpfcZs/379wsAQqlUikePHsmOQ0YsJCREABDlypUTiYmJsuMQUT6Sleu3yd2aPHjwIG7duoVu3bql6MlycHDA6NGjkZCQgLCwMJM5rykRQugGWvfv3x/FixeXnIiMWb9+/eDs7Izbt29j3bp1suMQEaXJ5Aox7dgtDw+PVPs8PT0BAOHh4Zk+3rlz5zBr1ixMnz4dGzduRFRUVJ6cNz/as2cPTp48CWtra4waNUp2HDJyNjY2uuEAU6dORXJysuRERESpmdwYscjISABIc94pFxcX2Nra6tpkxty5c1P8bG1tjfHjxyMgIEDv542Pj0/xuL1arc50TmMn3hsbNnDgQHz00UeSE5EpGDBgAGbOnIkbN25g06ZN6Nq1q+xIREQpmFyPmEqlAvDulmBa7O3tdW0yUrZsWcybNw83btzAmzdv8PDhQ6xevRqFCxfGqFGjMG/ePL2fNzg4GA4ODrpXqVKlPpjTVOzYsQNnzpyBra2t7ok3opyys7ODn58fAGDKlClcg5KIDI7JFWL64u7ujoEDB8LNzQ3W1tYoUaIEvL29sW/fPhQoUAATJkxAUlKSXs8ZGBgIlUqlez148ECvxzdUQghMmjQJADB48GA4OztLTkSmZNCgQXBwcMCVK1fwv//9T3YcIqIUTK4Q0/ZIpdf7pFar0+21yowqVaqgUaNGePnyJa5evarX8yqVStjb26d45QcHDhzA2bNnUbBgQfj7+8uOQybG0dERgwcPBgBMnjyZvWJEZFBMrhDTjtFKazzW06dPERMTk+N1C7U9NrGxsXl6XlMVFBQEAOjbty+cnJwkpyFT5OfnB1tbW1y8eBE7d+6UHYeISMfkCjF3d3cAwP79+1Pt27dvX4o22ZGcnIzTp08DAFxdXfPsvKbq2LFjCA8Ph6WlJXvDKNcULlwYAwcOBPCuV0wIITkREdH/l8tzmuW5xMREUa5cuQwnVr1z545u++PHj8XVq1dFdHR0iuOcPn061bGTkpLE8OHDBQDRrFmzHJ03M/LDhK5t27YVAMQPP/wgOwqZuGfPnomCBQsKAGL37t2y4xCRCcvK9VshhOl9NUxvqaF79+4hJCQkxVJDvr6+CAsLQ2hoKHx9fXXbFQoFqlevjurVq6NEiRJ4+fIlwsPDcePGDZQsWRLh4eEoV65cts+bGdpxZSqVyiTHi126dAnVq1eHmZkZrl27xlu3lOuGDx+OWbNm4fPPP8fx48ehUChkRyIiE5Sl63eul4WSnDx5Unh5eQl7e3thbW0t6tatKzZs2JCqnY+PT5pLGQ0bNkw0bNhQfPTRR8LS0lLY2NiIGjVqiLFjx4qXL1/m+LyZYeo9Yt26dRMARKdOnWRHoXziyZMnokCBAgKA2L9/v+w4RGSi8n2PmKkw5R6xW7duoWLFitBoNDh37lyaC6sT5YYhQ4Zg7ty5aNSoEY4cOcJeMSLSu6xcv01usD4Zh5kzZ0Kj0aBVq1YswihPjRw5ElZWVjh69CiXHSMi6ViIUZ57/PgxQkNDAbybxJYoL5UoUQI//PADgHdPUBIRycRCjPLcnDlzkJCQgEaNGqFx48ay41A+FBAQAHNzcxw8eFA3HQ0RkQwsxChPvXz5EosWLQLA3jCSx9XVVbcA+MyZMyWnIaL8jIUY5an58+cjNjYWNWrUQKtWrWTHoXxsxIgRAIDffvsNt27dkpyGiPIrFmKUZ2JiYvDLL78AeNcbxqfVSKbq1avDy8sLGo0Gs2fPlh2HiPIpFmKUZ5YtW4aXL1+iQoUK6Nixo+w4RBg5ciQAYOXKlXj+/LnkNESUH7EQozwRHx+PWbNmAfi/gdJEsjVt2hR16tRBXFwc5s+fLzsOEeVDLMQoT6xZswaPHj1C8eLF4e3tLTsOEYB3S5lpe8W04xeJiPISCzHKdcnJyZg+fTqAd2v9KZVKyYmI/s/XX3+N8uXL4+XLl1i5cqXsOESUz7AQo1z322+/4ebNmyhcuDB69+4tOw5RCubm5hg+fDgAYNasWUhKSpKciIjyExZilKuEEJg2bRoAYPDgwbC1tZWciCg1Hx8fFClSBPfu3cPmzZtlxyGifISFGOWqgwcP4vz58yhYsCAGDhwoOw5RmqytrTF48GAAwIwZMyCEkJyIiPILFmKUq7RPSvbs2RNOTk6S0xCl78cff0TBggVx/vx5/PHHH7LjEFE+wUKMcs3ly5exZ88eKBQK+Pn5yY5DlKH3xzDOmDFDchoiyi9YiFGu0c5Wrn0qjcjQDR06FObm5vjjjz9w9uxZ2XGIKB9gIUa54unTp1i7di0AYNiwYZLTEGWOq6srunTpAoCLgRNR3mAhRrliwYIFSEhIQP369dGgQQPZcYgyTbsY+KZNm3Dnzh3JaYjI1LEQI72LjY3FwoULAbA3jIxPjRo14OnpycXAiShPsBAjvQsLC8PLly9Rrlw5fPXVV7LjEGWZdtmjFStW4MWLF5LTEJEpYyFGepWcnIw5c+YAAPz8/Li4NxmlZs2a4bPPPsPbt2+xYMEC2XGIyISxECO92rlzJ27evIlChQqhR48esuMQZcv7i4HPmzcPb968kZyIiEwVCzHSq5CQEABAv379uJwRGbUOHTqgbNmyiIqKwpo1a2THISITxUKM9ObkyZOIiIiApaUllzMio2dhYaFb9ujnn3+GRqORnIiITBELMdIb7XJG3bp1Q/HixSWnIcq5nj17ws7ODteuXcO+fftkxyEiE8RCjPTizp072LJlCwBOWUGmw97eHr169QIA3UMoRET6xEKM9EJ768bDwwPVqlWTHYdIbwYPHgwzMzMcOHAA//zzj+w4RGRiTLYQO3XqFFq3bg1HR0fY2NigXr162LRpU6beK4TAnj170L9/f1SvXh0ODg4oWLAgatSogaCgIMTFxaX5PoVCke7L19dXj5/OsLx69QorVqwAwN4wMj1lypTB119/DeDdFw4iIn1SCCGE7BD6dujQIXh6eqJAgQLo0qUL7OzssGXLFty7dw8hISEfLBbi4uJgbW0NpVKJpk2bolq1aoiLi8O+ffsQGRmJOnXq4PDhwyhYsGCK9ykUCri6uqZZdNWsWTPLk5uq1Wo4ODhApVLB3t4+S+/NS9OnT8eoUaNQrVo1XLhwAQqFQnYkIr2KiIhAo0aNoFQqcf/+fRQtWlR2JCIyYFm6fgsTk5iYKMqXLy+USqU4d+6cbnt0dLSoWLGisLKyEnfv3s3wGAkJCWLKlCni5cuXqbZ/+eWXAoCYMWNGqvcBEO7u7vr4GEIIIVQqlQAgVCqV3o6pb/Hx8aJ48eICgFi1apXsOES5QqPRiDp16ggAYuLEibLjEJGBy8r12+RuTR48eBC3bt1Ct27dULNmTd12BwcHjB49GgkJCQgLC8vwGJaWlhgzZgwKFSqUantgYCAAIDw8XO/ZjdGGDRvw+PFjFCtWDF27dpUdhyhXKBQKDB06FACwcOFCxMfHS05ERKbC5Aqxw4cPAwA8PDxS7fP09ASQsyLK0tISwLs5htISHR2NpUuXIigoCIsXL8alS5eyfS5DJ4TQLYo8aNAgWFlZSU5ElHs6duyIkiVL4t9//8X69etlxyEiE2FyhVhkZCQAwM3NLdU+FxcX2Nra6tpkx8qVKwGkXegBwIULF9C3b1+MGTNGN9i/VatWePbs2QePHR8fD7VaneJlyA4dOoQLFy6gYMGC6Nu3r+w4RLnq/YmKZ8+eDWF6w2uJSAKTK8RUKhWAd7ci02Jvb69rk1V79uzBkiVLULlyZfzwww+p9g8bNgzHjh3DixcvoFarcezYMbRq1Qp79+5F27ZtkZycnOHxg4OD4eDgoHuVKlUqWznzyi+//AIA8PX1ReHChSWnIcp9ffr0QcGCBXHp0iUcPHhQdhwiMgEmV4jlllOnTqFz585wcHDA5s2boVQqU7UJCQlB/fr14eTkBDs7O9SvXx+7du2Cu7s7Tp06he3bt2d4jsDAQKhUKt3rwYMHufVxcuzWrVvYuXMnAOiWgSEyde8vZs8JXolIH0yuENP2hKXX66V9pDQrTp8+DQ8PD5iZmWHfvn2oUqVKpt9rZmaG3r17A3j3CHxGlEol7O3tU7wM1bx58yCEgJeXFypVqiQ7DlGeGTJkCBQKBXbv3o3r16/LjkNERs7kCjHt2LC0xoE9ffoUMTExaY4fS8/p06fRsmVLaDQa7Nu3D3Xq1MlyJmdnZwBAbGxslt9riNRqtW6snJ+fn9wwRHnMzc0Nbdu2BfB/t+eJiLLL5Aoxd3d3AMD+/ftT7dMu2qtt8yHaIiw5ORl79+7F559/nq1MJ0+eBPBuhm5TEBoaitevX+Pjjz9O96EFIlOmncoiLCwML1++lJyGiIyZyRViLVq0QLly5bBu3TqcP39et12lUiEoKAhWVlbo3r27bvuTJ09w7dq1VLcyz5w5g5YtWyIpKQl79uxB/fr1MzzvpUuXkJiYmGr7sWPHMH36dFhaWuLbb7/N2YczAMnJyZg3bx6A/7tFQ5TfNG3aFDVq1MCbN2+wdOlS2XGIyIjl+yWOfH19ERYWhtDQUN3SRC9fvkSFChXw6tUreHl5pdkT5ujomOK2nK+vL3bv3o1GjRqhVKlSsLS0xOXLl7F//34oFAosWLAA/fr1y9LnMMQljnbu3Il27drB0dERDx8+hI2NjexIRFKEhYXB19cXJUqUwJ07d3RzDBIRZeX6nfaspEauWbNmOHr0KMaPH4+NGzciMTER1apVw/Tp09G5c+cPvl+tVuPVq1cAgL1792Lv3r2p2ri6uqYoxNq3b4/o6GhcuHABBw4cQEJCAlxcXNClSxf4+fmhbt26evt8MmkXPe7Tpw+LMMrXunTpgoCAADx69AibN29Gt27dZEciIiNkkj1ipsLQesQuXbqE6tWrw9zcHLdv30bp0qVlRyKSavLkyfjpp59Qu3Zt/P3337xVT0QAsnb9NrkxYpR7tE+IdejQgUUYEYB+/fpBqVTi9OnTH5yehogoLSzEKFNevHiBX3/9FcC7QfpEBBQpUgTe3t4AgLlz50pOQ0TGiIUYZcrSpUsRFxeHzz77DA0aNJAdh8hgDBo0CADwv//9z6BXwyAiw8RCjD4oMTERCxYsAPBuAleOgyH6P9WrV0fTpk2RnJyMRYsWyY5DREaGhRh90G+//YbHjx/DxcUFnTp1kh2HyOBo11tdunQp3r59KzkNERkTFmL0QdpB+j/++COsrKwkpyEyPO3atYOrqyuioqKwbt062XGIyIiwEKMMnThxAidPnoSVlRX69u0rOw6RQTI3N8fAgQMBvBu0z1mBiCizWIhRhrS9Yd999x2KFi0qOQ2R4frhhx9QsGBBXLx4EUeOHJEdh4iMBAsxStfDhw+xefNmAJyyguhDChUqpFvHVvsFhojoQ1iIUboWLlyI5ORkuLu7o0aNGrLjEBk87VQW27dvx927d+WGISKjwEKM0vTmzRssXboUAFKsqUlE6fvkk0/wxRdfQKPRYOHChbLjEJERYCFGaVq3bh2ioqJQtmxZfPnll7LjEBkN7VQWy5YtQ2xsrOQ0RGToWIhRKkIIzJs3DwAwcOBAmJubS05EZDzatGmD8uXLIzo6GmvXrpUdh4gMHAsxSuXIkSO4ePEiChYsiJ49e8qOQ2RUzMzMOJUFEWUaCzFKRbt4cffu3eHo6Cg3DJER6tGjB2xtbXHlyhUcPHhQdhwiMmAsxCiF+/fvY9u2bQCg+1ZPRFnj4OAAX19fAP/3xYaIKC0sxCiFhQsXQqPRoEWLFqhSpYrsOERGS/tFZufOnbh165bkNERkqFiIkc7bt2+xbNkyAP/35BcRZU+lSpXg5eUFIQQWLFggOw4RGSgWYqSzbt06vHz5EmXKlEGbNm1kxyEyetovNCtWrEBMTIzkNERkiFiIEYB3U1Zox7Jwygoi/fD09ETFihWhVquxevVq2XGIyACxECMAwF9//cUpK4j0zMzMTLfs0dy5c6HRaCQnIiJDw0KMAPzfk13e3t4oVKiQ5DREpsPHxwd2dna4fv069u/fLzsOERkYFmLEKSuIcpGdnZ2ul1m7YgURkRYLMcKiRYuQnJyM5s2bo2rVqrLjEJmcgQMHQqFQYM+ePbh586bsOERkQFiI5XNv377F0qVLAXDKCqLcUqFCBbRq1YpTWRBRKizE8rn169frpqxo27at7DhEJkv7RWflypWcyoKIdFiI5WPvT1kxYMAATllBlItatmzJqSyIKBWTLsROnTqF1q1bw9HRETY2NqhXrx42bdqUpWPEx8dj0qRJcHNzQ4ECBVC8eHH06dMHz549S/c9v/76K+rWrQsbGxsUKlQIbdu2xdmzZ3P6cfTu6NGjuHDhAqytrTllBVEuMzMz0z0MM2/ePAghJCciIkNgsoXYoUOH0LBhQxw9ehSdOnVCv3798PTpU3Tu3BmzZs3K1DE0Gg3at2+P8ePHw9nZGX5+fqhfvz6WL1+O+vXr4/nz56neM3XqVHz//fd49uwZ+vXrh2+//RZHjhxBgwYNEBERoe+PmSPvT1lRuHBhyWmITJ92Kotr167hjz/+kB2HiAyBMEGJiYmifPnyQqlUinPnzum2R0dHi4oVKworKytx9+7dDx5n5cqVAoDo2rWr0Gg0uu2LFi0SAESfPn1StL9x44awsLAQFStWFNHR0brt586dE0qlUlSuXFkkJydn+nOoVCoBQKhUqky/J7Pu378vzM3NBQBx6dIlvR+fiNI2aNAgAUB8+eWXsqMQUS7JyvU72z1irVq1wtatW5GcnKyfilCPDh48iFu3bqFbt26oWbOmbruDgwNGjx6NhIQEhIWFffA42gWwg4ODoVAodNv79u2LcuXK4ddff8Xbt29120NDQ5GUlIQxY8bAwcFBt71mzZro2rUrrl69iqNHj+rhE+acdsqKZs2accoKojykvT25a9cu3L59W3IaIpIt24XYvn370LFjR5QsWRKBgYEGNTfO4cOHAQAeHh6p9nl6egIAwsPDMzxGXFwcTp48iUqVKsHV1TXFPoVCgZYtWyI2NhanT5/W63nzAqesIJKnYsWK8PLy4lQWRJJFRUXh1KlTsmNkvxC7efMmRo4cCTMzM0yfPh2VKlVCixYtsGHDBiQkJOgzY5ZFRkYCANzc3FLtc3Fxga2tra5Nem7dugWNRpPmMd4/9vvHiYyMhK2tLVxcXDLV/r/i4+OhVqtTvHLD+vXrERUVBVdXV3z55Ze5cg4iSp92/ckVK1ZwKgsiSZYuXYq6deuid+/eUnNkuxArV64cgoODcf/+fWzduhWtW7fGkSNH8N1336F48eLw9/fHlStX9Jk101QqFQCkuD34Pnt7e12bnBzj/Xba/85K+/8KDg6Gg4OD7lWqVKkMM2bXixcvYG1tzSkriCTx8vJChQoVoFKpsHbtWtlxiPKdpKQkLFy4EADQuHFjqVly/NSkubk52rdvj507d+L+/fuYNGkSHB0d8csvv6BatWpo1KgRwsLCEBcXp4+8Ji0wMBAqlUr3evDgQa6cZ+TIkXj06BH69euXK8cnooxxKgsiubZt24aHDx+iSJEi6Ny5s9Qsep2+olixYggICEBwcDCKFSsGIQSOHTuGnj17omTJkpg5cyY0Go0+T5kmba9Uer1ParU63Z6rrBzj/Xba/85K+/9SKpWwt7dP8cothQoVgp2dXa4dn4gy5uvrCxsbG1y5cgUHDx6UHYcoX9FO39S3b18olUqpWfRWiN24cQMjR45EyZIl0aVLF7x8+RLe3t74448/MH36dNja2mLUqFEICAjQ1ynTldF4rKdPnyImJibdsV9a5cqVg5mZWbpjutIah+bm5oaYmBg8ffo0U+2JKP9ycHCAr68vgHe9YkSUN86fP4+//voLFhYWBnFnKEeFWFxcHNasWQN3d3dUrlwZISEhKFy4MGbNmoVHjx4hLCwMzZs3x/Dhw3H9+nU0bNgwT5b2cHd3BwDs378/1b59+/alaJMea2tr1K1bF9evX8e9e/dS7BNC4MCBA7CxsUHt2rX1el4iyj+0tyd37tyJO3fuSE5DlD9ov/h88803KFGihOQ0yP6ErgMGDBCFChUSZmZmQqlUiq5du4rDhw9n+J4pU6YIMzOz7J4y0xITE0W5cuUynND1zp07uu2PHz8WV69eTTEJqxBZn9D1+vXrRjOhKxEZhpYtWwoAYvjw4bKjEJm858+fC6VSKQCIiIiIXDtPVq7f2S7EFAqFqFChgpgxY4Z4/vx5pt5z9OhRMWHChOyeMksOHjwoLC0thZ2dnejdu7fw9/cXrq6uAoAICQlJ0dbHx0cAEKGhoSm2JycnC09PTwFA1KtXTwQEBIhvvvlGKBQKUbZsWfHs2bNU550yZYoAIFxdXYW/v7/o3bu3sLOzE0qlUhw9ejRLn4GFGJHp27lzpwAgHB0dRUxMjOw4RCYtODhYABC1atVK0cGib3lSiP3xxx/ZfWueOXnypPDy8hL29vbC2tpa1K1bV2zYsCFVu/QKMSGEiIuLExMmTBDly5cXVlZWwsXFRfTq1Us8ffo03fOuXbtW1K5dW1hbWwsHBwfRunVrcebMmSznZyFGZPqSkpJEuXLlBACxZMkS2XGITFZiYqIoWbKkACBWrVqVq+fKyvVbIQSfmzZU2qc7VSpVrj5BSURyzZkzB/7+/qhatSouXryYYkk1ItKP3377Dd9++y2cnZ3x4MEDFChQINfOlZXrt16nryAioqzr0aMHChYsiH/++ccglkEjMkXaQfp9+/bN1SIsq1iIERFJ5ujoiO7duwMAfvnlF8lpiEzPhQsXcOTIEZibm6N///6y46TAQoyIyABo15/csWMH7t69KzcMkYkxuCkr3sNCjIjIAHzyySdo2bIlNBqNbg08Isq5qKgo/PrrrwCAwYMHS06TGgsxIiIDob1ILFu2DLGxsZLTEJmG5cuXIy4uDp9++ikaNGggO04qLMSIiAxE69atUb58eURHR2Pt2rWy4xAZvaSkJCxYsADAuy86hvhEMgsxIiIDYWZmplv2aO7cueDsQkQ5s337djx48ADOzs7o0qWL7DhpYiFGRGRAevToAVtbW1y5cgUHDx6UHYfIqGkH6ffp08egpqx4HwsxIiID4uDgAF9fXwCcyoIoJy5evIjw8HCDnLLifSzEiIgMjPb25K5du3Dr1i3JaYiM0/tTVpQsWVJymvSxECMiMjCVKlWCl5cXhBC6gcZElHlRUVG6B160c/QZKhZiREQGaMiQIQCAFStW4PXr15LTEBmXFStW6KasaNiwoew4GWIhRkRkgDw8PFCxYkWo1WqsXr1adhwio5GUlIT58+cDeNcbZohTVryPhRgRkQEyMzPT3VKZN28eNBqN5ERExmHr1q148OABihQpgq5du8qO80EsxIiIDJSPjw/s7e1x/fp1HDhwQHYcIqOgfdq4X79+BjtlxftYiBERGSg7Ozv07NkTAKeyIMqM06dPIyIiApaWlgY9ZcX7WIgRERmwAQMGQKFQYM+ePbhx44bsOEQGTfuFpVOnTihWrJjkNJnDQoyIyIBVqFABbdq0AQDdAGQiSu3JkyfYuHEjAMDPz09umCxgIUZEZOC0U1mEhoZCrVZLTkNkmBYtWoTExEQ0aNAAtWvXlh0n01iIEREZuBYtWqBy5cqIiYlBaGio7DhEBicuLg6LFy8GYFy9YQALMSIig6dQKDB48GAAnMqCKC3r16/H8+fPUapUKXz99dey42QJCzEiIiPg7e0NR0dH3Lp1C3v27JEdh8hgCCF0g/QHDhwICwsLyYmyhoUYEZERsLGxQa9evQBwKgui9x05cgQXLlyAtbW17v8RY8JCjIjISAwYMABmZmY4cOAA/vnnH9lxiAzCzz//DADo3r07ChcuLDdMNrAQIyIyEmXKlNGNf9FefIjys9u3b2P79u0AoBtHaWxYiBERGZGhQ4cCANauXYtnz55JTkMk1/z58yGEgIeHBz755BPZcbKFhRgRkRFp0KAB6tSpg/j4eN3j+kT50evXr7FixQoAxjdlxftMshBTq9Xw9/eHq6srlEolypQpgxEjRiAmJibTx4iMjERQUBCaNGmC4sWLw8rKCqVKlUL37t1x7dq1NN/j6+sLhUKR7ouIKKcUCoWuV2zhwoWIj4+XnIhIjlWrVkGtVqNixYrw9PSUHSfbjOsZz0yIjY2Fu7s7zp8/Dw8PD3Tt2hXnzp1DSEgIwsPDceTIkUytxj5u3Dhs3LgRVatWRfv27WFvb49Lly5hzZo1+O2337B37140adIkzfcOGTIEjo6Oev5kRETvdOzYESNHjsTDhw+xfv16+Pr6yo5ElKc0Gg3mzp0L4N0118zMiPuVhIn56aefBAAREBCQYntAQIAAIIKCgjJ1nNDQUHH27NlU29evXy8AiE8++STVPh8fHwFA3LlzJ1vZ/0ulUgkAQqVS6eV4RGQ6pk2bJgCI6tWrC41GIzsOUZ7auXOnACAcHBzE69evZcdJJSvXb4UQQsgrA/VLCIGSJUtCrVbj6dOnsLGx0e2LjY2Fi4sLihYtilu3buXoPJUqVcKNGzfw/PlzODs767b7+voiLCwMd+7cQZkyZXJ0DuDdLVYHBweoVCrY29vn+HhEZDpevXqFkiVL4s2bN/jzzz/RvHlz2ZGI8kzLli3xxx9/YNiwYQgJCZEdJ5WsXL+NuC8vtcjISDx+/BgNGzZMUYQB7yZDbNiwIW7fvo0HDx7k6DyWlpYAkO7svbt27UJwcDBmz56NPXv2ICEhIUfnIyL6r0KFCuluSc6ZM0duGKI8dPnyZfzxxx8wMzPDwIEDZcfJMZMaIxYZGQkAcHNzS3O/m5sb9u3bh8jISJQqVSpb5/j7779x+fJl1KlTJ91xYIMGDUrxc7FixRAaGvrBwYTx8fEpBt6q1epsZSSi/GHIkCFYuHAhdu3ahRs3bqBixYqyIxHlOu3KEl999ZVe7j7JZlI9YiqVCgDg4OCQ5n5t96C2XXaO7+PjAzMzM8yYMSPV/iZNmmDTpk24f/8+3r59i8jISEyaNAnR0dFo164dTp8+neHxg4OD4eDgoHtlt1gkovyhYsWKaNu2LQAue0T5w/Pnz7FmzRoA776ImAKD7BEbNmxYlh7JHjJkSLq9YPry9u1bfP3117h27RqmTp2Kpk2bpmrTs2fPFD9XqFAB48aNQ4kSJfDDDz9g0qRJ2LFjR7rnCAwMhL+/v+5ntVrNYoyIMjR06FDs2rULq1atwuTJk41yiReizFq0aBHi4uLw2WefoXHjxrLj6IVBFmJLlixBbGxsptt37NgRbm5uup6w9Hq8tLf60usxS09cXBzat2+PQ4cOITAwEKNHj87S+318fDBgwABERERk2E6pVEKpVGbp2ESUvzVr1gzVq1fHxYsXsXTpUowaNUp2JKJcERcXhwULFgB412FjKvNzGuStyZiYGAghMv3S9k5pe8W0Y8X+60NjyNLy9u1btGvXDgcOHMDIkSMRFBSU5c9jbm4OR0fHLBWXRESZ8f4Er/Pnz0diYqLkRES5Q7usV+nSpdGxY0fZcfTGIAux7HJzc0Px4sURERGRquiJjY1FREQEypYtm+nbfW/fvkX79u1x4MABDB8+HNOnT89Wrvv37+Pp06cmMaiQiAxP165d8dFHH+HRo0fYvHmz7DhEeqfRaDBr1iwA74YjaWcvMAUmVYgpFAr06tULMTExmDx5cop9kydPRkxMDHr37p1i+5s3b3Dt2jXcv38/xXbt7cgDBw7A398fM2fOzPDcT58+xaNHj1Jtj46O1j1i3q1bt2x8KiKijCmVSvz4448A3k1lYULTQxIBAPbs2YNr167B3t4evXr1kh1Hr0xqQlfgXc9Xw4YNceHCBXh4eKBWrVo4e/Ys9u/fjzp16iA8PBzW1ta69ocPH0azZs3g7u6Ow4cP67ZrJ2d1cXFB37590zyXr6+vrpfr8OHDaNmyJRo0aAA3NzcUKVIEDx48wN69exEVFYXmzZtj9+7dmVpeSYsTuhJRZmlv2cTHx+Ovv/5Co0aNZEci0pvmzZvj0KFDBjuB639l5fptkIP1c8LGxgbh4eGYMGECtmzZgkOHDqFYsWIYNmwYxo8fn6IIy8jdu3cBvOvpmjhxYpptmjZtqivEypcvD19fX5w6dQrbtm2DSqWCra0tqlevjm7duqFXr14wNzfXx0ckIkqlaNGi8Pb2xvLlyzFnzhwWYmQyzp49i0OHDsHCwsJkpqx4n8n1iJkS9ogRUVZcvnwZVatWhZmZGW7evImyZcvKjkSUY9999x3WrVuHbt264ddff5UdJ1Py7RJHRET5WZUqVeDh4QGNRoO5c+fKjkOUYw8ePMDGjRsBvJuywhSxECMiMiHaqSxWrFiR7VVEiAzF3LlzkZycjKZNm6JWrVqy4+QKFmJERCbE09MTn3zyCV6/fo0lS5bIjkOUbWq1GkuXLgUADB8+XHKa3MNCjIjIhCgUCowYMQIA8PPPP2dpuTgiQ7J8+XKo1Wp8/PHHaNWqlew4uYaFGBGRienWrRuKFy+OJ0+eGM3gZqL3JSUl6Ray9/f3h5mZ6ZYrpvvJiIjyKSsrK91YsZkzZ0Kj0UhORJQ1v/32G+7fv48iRYrA29tbdpxcxUKMiMgE9enTB/b29rh27Rp27dolOw5RpgkhdJO2Dhw4MEsToRsjFmJERCbI3t4e/fv3BwDMmDFDchqizDty5AjOnDmDAgUK6P4OmzIWYkREJmrw4MGwsrJCREQEIiIiZMchyhTt4t4+Pj4oUqSI5DS5j4UYEZGJKl68uG58zcyZMyWnIfqw69evY+fOnVAoFLpxjqaOhRgRkQnTzr+0fft2XLt2TXIaoozNmTMHAPDll1+iUqVKktPkDRZiREQm7OOPP0b79u0BQDcAmsgQPXv2DGFhYQBMdzmjtLAQIyIycSNHjgQArFmzBo8fP5achihtv/zyC+Li4lCnTh00btxYdpw8w0KMiMjENWjQAA0bNkRCQgIXAyeDpFarsWDBAgBAYGAgFAqF5ER5h4UYEVE+oO0VW7RoEdRqteQ0RCktWrQIKpUKlStX1t1Kzy9YiBER5QNt27bFxx9/nGIhZSJD8PbtW8yePRsAMGrUKJNezigt+evTEhHlU2ZmZrrFwOfMmYOEhATJiYjeCQ0NxbNnz+Dq6oquXbvKjpPnWIgREeUT3333HYoVK4bHjx9j3bp1suMQITExUbfyw4gRI2BpaSk5Ud5jIUZElE8olUr4+fkB4GLgZBg2bNiAe/fuoWjRoujZs6fsOFKwECMiykf69u0LOzs7XLlyBb///rvsOJSPaTQaTJs2DQDg5+cHa2tryYnkYCFGRJSPODg4oF+/fgC4GDjJtWPHDly5cgX29vb48ccfZceRhoUYEVE+M2TIEFhaWuKvv/7CsWPHZMehfEgIgeDgYADAgAED4ODgIDmRPCzEiIjymRIlSqB79+4AgClTpkhOQ/nRwYMH8ffff6NAgQK6cYv5FQsxIqJ8KDAwEObm5tizZw9OnTolOw7lM9resF69eqFo0aKS08jFQoyIKB8qX748unXrBoC9YpS3/v77b/z555+wsLDA8OHDZceRjoUYEVE+NWbMGCgUCuzYsQPnz5+XHYfyCW1v2HfffQdXV1fJaeRjIUZElE9VqlQJXbp0AcBeMcobV65cwbZt26BQKBAQECA7jkEwyUJMrVbD398frq6uUCqVKFOmDEaMGIGYmJgsHUehUKT78vX1zdVzExHlhTFjxgAAtmzZgn/++UdyGjJ12nnDvv76a1SuXFlyGsOgEEII2SH0KTY2Fo0aNcL58+fh4eGBTz/9FOfOncP+/ftRp04dHDlyBAUKFMjUsRQKBVxdXdMsumrWrImvvvoq184NvCvqHBwcoFKpYG9vn+n3ERFlxbfffovffvsNXbp0wfr162XHIRN19+5dVKhQAcnJyTh16hRq164tO1KuydL1W5iYn376SQAQAQEBKbYHBAQIACIoKCjTxwIg3N3dpZxbCCFUKpUAIFQqVZbeR0SUFefPnxcAhEKhEFevXpUdh0zUgAEDBADxxRdfyI6S67Jy/TapHjEhBEqWLAm1Wo2nT5/CxsZGty82NhYuLi4oWrQobt26lanjKRQKuLu74/Dhw3l+boA9YkSUd7766its374d33//PdasWSM7DpmYf//9F2XKlEFcXBwOHjyIZs2ayY6Uq7Jy/TapMWKRkZF4/PgxGjZsmKIQAgAbGxs0bNgQt2/fxoMHDzJ9zOjoaCxduhRBQUFYvHgxLl26lGfnJiLKK+PGjQMArFu3Djdv3pSchkzNzJkzERcXh88//xxNmzaVHcegmFwhBgBubm5p7tdu17bLjAsXLqBv374YM2YM+vfvj+rVq6NVq1Z49uyZ3s8dHx8PtVqd4kVElBc+++wztG7dGhqNBkFBQbLjkAl58uQJFixYAAAYP348FAqF5ESGxaQKMZVKBQDprlml7R7UtvuQYcOG4dixY3jx4gXUajWOHTuGVq1aYe/evWjbti2Sk5P1eu7g4GA4ODjoXqVKlcpUTiIifdD2iq1ZswZ37tyRnIZMxbRp0xAXF4f69evDy8tLdhyDYyE7QFqGDRuG+Pj4TLcfMmRIuj1RORESEpLi5/r162PXrl1o3rw5wsPDsX37dnTo0EFv5wsMDIS/v7/uZ7VazWKMiPJMvXr10LJlSxw4cADTpk3DkiVLZEciI/fw4UMsXrwYADBp0iT2hqXBIAuxJUuWIDY2NtPtO3bsCDc3N11vVHq9TtpbfTlZ5d3MzAy9e/dGeHg4IiIidIWYPs6tVCqhVCqznY2IKKd++uknHDhwAKGhoRg7diy/DFKOBAUFISEhAU2aNEGLFi1kxzFIBnlrMiYmBkKITL+0A/8+NA7rQ+O4MsvZ2RkAUhSLeXVuIqLc1KhRIzRt2hSJiYmYPn267DhkxO7du4fly5cDYG9YRgyyEMsuNzc3FC9eHBEREal61GJjYxEREYGyZcvm+BveyZMnAQBlypTJ83MTEeW2n376CQCwfPlyPH78WHIaMlZTpkxBYmIiWrRoAXd3d9lxDJZJFWIKhQK9evVCTEwMJk+enGLf5MmTERMTg969e6fY/ubNG1y7dg33799Psf3SpUtITExMdY5jx45h+vTpsLS0xLfffpujcxMRGaKmTZuiUaNGiI+Px8yZM2XHISN069YthIaGAnjXG0bpM6kJXYF3vU8NGzbEhQsX4OHhgVq1auHs2bO6ZYbCw8NhbW2ta3/48GE0a9Ys1cStvr6+2L17Nxo1aoRSpUrB0tISly9fxv79+6FQKLBgwQL069cvR+f+EE7oSkSy7N+/H56enihQoADu3r2Ljz76SHYkMiK+vr4ICwuDl5cX9uzZIztOnsvXSxwJIUR0dLTw8/MTpUqVEpaWlqJ06dJi2LBhQq1Wp2p76NChNJcy+t///ifat28vypYtK2xsbISlpaUoVaqU6Nq1qzh58qRezv0hXOKIiGTRaDTi888/FwCEn5+f7DhkRK5duybMzMwEgAyvl6Ys3y5xZGrYI0ZEMml7xaysrHDjxg24urrKjkRG4LvvvsO6devw5ZdfYseOHbLjSJFvlzgiIiL9admyJZo1a4aEhARMmDBBdhwyApcvX8b69esBABMnTpScxjiwECMiojQpFApMmzYNALB69WpcvnxZciIydBMnToQQAh06dMCnn34qO45RYCFGRETpqlu3Ljp06ACNRoMxY8bIjkMG7MKFC9i8eTMUCgV7ULOAhRgREWVoypQpMDMzw/bt23H8+HHZcchAjR8/HgDQqVMnVKtWTXIa48FCjIiIMlS5cmX06NEDADBq1CjwGS/6rzNnzmD79u0wMzPTFWSUOSzEiIjog8aPHw+lUokjR45g7969suOQgdGuxtCtWzdUrlxZchrjwkKMiIg+qFSpUhg0aBAAIDAwEBqNRnIiMhQnTpzA77//DnNzc11BRpnHQoyIiDJl1KhRsLe3x4ULF7BhwwbZccgACCEQEBAAAPD29oabm5vkRMaHhRgREWWKk5OT7qI7btw4JCQkSE5Esm3fvh1HjhxBgQIFOG9YNrEQIyKiTBsyZAhcXFxw+/ZtLFu2THYckighIQEjRowAAPj7+6N06dKSExknFmJERJRpNjY2unFAkyZNQkxMjOREJMuiRYtw8+ZNFC1aFKNGjZIdx2ixECMioizp1asXypcvj2fPnuHnn3+WHYckePnype5W5OTJk2FnZyc5kfFiIUZERFliaWmJyZMnAwBmzJiBFy9eSE5EeW3KlCl49eoVqlatip49e8qOY9RYiBERUZZ17twZNWvWxOvXrxEcHCw7DuWhyMhIzJ8/HwAwa9YsWFhYSE5k3FiIERFRlpmZmekKsAULFuD+/fuSE1FeCQgIQGJiIry8vODh4SE7jtFjIUZERNni6emJpk2bIj4+HmPHjpUdh/LAkSNHsHXrVpiZmSEkJER2HJPAQoyIiLJFoVBg+vTpAIA1a9bg2LFjkhNRbtJoNPD39wcA9OnTB1WqVJGcyDSwECMiomyrW7eubrD2wIEDkZycLDkR5ZZ169bhzJkzsLOz4+StesRCjIiIcmTatGlwdHTEuXPnOMmriXrz5g0CAwMBAKNHj0bRokUlJzIdLMSIiChHihQpopvOYvTo0ZzOwgTNnj0bDx8+hKurK/z8/GTHMSksxIiIKMf69euH6tWr49WrVxgzZozsOKRHT58+xbRp0wAAwcHBKFCggOREpoWFGBER5ZiFhYVubqlly5bh9OnTkhORvowbNw6xsbH4/PPP0aVLF9lxTA4LMSIi0ovGjRvj+++/hxACAwcOhEajkR2JcujixYtYuXIlgHe3JxUKheREpoeFGBER6c2MGTNga2uLkydPYtWqVbLjUA4IIeDn5weNRoNvv/0WDRo0kB3JJLEQIyIivSlWrBgmTJgAABg1ahRevXolNxBlW1hYGA4dOgRra2vdfHGkfyzEiIhIrwYPHozKlSvj+fPnGD9+vOw4lA3Pnj3DsGHDAAATJ05E2bJlJScyXSzEiIhIrywtLTFv3jwA79ahvHjxouRElFV+fn54+fIlatasiaFDh8qOY9JMshBTq9Xw9/eHq6srlEolypQpgxEjRiAmJibTx5gwYQIUCkWGrx9++CHFe3x9fTNsT0SUX7Ro0QLffvstNBoNBg4cCCGE7EiUSXv27MH69ethZmaG5cuXw8LCQnYkk2Zyv93Y2Fi4u7vj/Pnz8PDwQNeuXXHu3DmEhIQgPDwcR44cydQcKE2bNk133/Lly/Ho0SN4enqmuX/IkCFwdHTM5icgIjINs2bNwu7du/HXX39h3bp1+O6772RHog+IiYlB//79AbzrFfvss88kJ8oHhIn56aefBAAREBCQYntAQIAAIIKCgnJ0/KdPnwoLCwvh5OQk4uPjU+zz8fERAMSdO3dydA4tlUolAAiVSqWX4xER5bWgoCABQLi4uPDfMiMwdOhQAUC4urqK169fy45jtLJy/TapW5NCCCxfvhy2trYYN25cin3jxo2Dra0tli9fnqNzhIWFISkpCd7e3rCyssrRsYiITJ2/vz8qVKiAp0+fYtKkSbLjUAZOnTqFX375BQCwePFi2NraSk6UP5hUIRYZGYnHjx+jYcOGsLGxSbHPxsYGDRs2xO3bt/HgwYNsn2PFihUAgF69eqXbZteuXQgODsbs2bOxZ88eJCQkZPt8RETGTKlUYu7cuQCAOXPm4MSJE5ITUVoSExPRu3dvaDQadOvWDV5eXrIj5RsmNUYsMjISAODm5pbmfjc3N+zbtw+RkZEoVapUlo//119/4caNG6hXrx6qVKmSbrtBgwal+LlYsWIIDQ1Nd0yZVnx8POLj43U/q9XqLGckIjI0rVq1wvfff4+1a9eie/fuOH/+PAoWLCg7Fr1nzpw5uHDhAgoXLow5c+bIjpOvmFSPmEqlAgA4ODikud/e3j5Fu6z6UG9YkyZNsGnTJty/fx9v375FZGQkJk2ahOjoaLRr1+6Da68FBwfDwcFB98pOsUhEZIjmzZuHEiVKIDIyEgEBAbLj0Htu3bqlm+9t1qxZKFq0qORE+YtB9ogNGzYsRc/QhwwZMiTdXjB9UavV2Lx5M2xtbdG5c+c02/Ts2TPFzxUqVMC4ceNQokQJ/PDDD5g0aRJ27NiR7jkCAwPh7++f4pwsxojIFDg6OiI0NBQeHh6YP38+2rdvjy+++EJ2rHxPCIG+ffsiLi4OzZs3h4+Pj+xI+Y5BFmJLlixBbGxsptt37NgRbm5uup6w9Hq8tLf60usxy8iGDRvw5s0b/PDDD1kewOjj44MBAwYgIiIiw3ZKpRJKpTLL2YiIjEHLli3x448/YuHChejRowcuXbrEqX4kW7NmDf78808UKFAAS5Ys4ZyXEhjkrcmYmBgIITL90s75pe0V044V+68PjSHLiPZpy4wG6afH3Nwcjo6OWSouiYhM0YwZM1ChQgU8fPgQQ4YMkR0nX3v+/LnuLsz48eNRoUIFyYnyJ4MsxLLLzc0NxYsXR0RERKqiJzY2FhEREShbtmyWb/ddunQJp06dQpUqVVCvXr0s57p//z6ePn2KMmXKZPm9RESmxMbGBmFhYTAzM8Pq1auxdetW2ZHyLT8/P0RFRaF69eq6dSUp75lUIaZQKNCrVy/ExMRg8uTJKfZNnjwZMTEx6N27d4rtb968wbVr13D//v10j6sdpP/fJY3e9/TpUzx69CjV9ujoaPj6+gIAunXrltmPQkRksho0aICRI0cCAPr27Ytnz55JTpT/rF27FuvWrYNCocCyZctgaWkpO1K+pRDCtBYAi42NRcOGDXHhwgV4eHigVq1aOHv2LPbv3486deogPDwc1tbWuvaHDx9Gs2bN4O7ujsOHD6c6XkJCAooXL47Xr1/j8ePHcHJySvO8hw8fRsuWLdGgQQO4ubmhSJEiePDgAfbu3YuoqCg0b94cu3fvztTySlpqtRoODg5QqVS6Jz6JiExBfHw86tati4sXL6J9+/bYunUrxyflkWvXrqF27dqIjY3F+PHjMWHCBNmRTE5Wrt8m1SMGvOv2Dg8Ph5+fH65evYpZs2bh2rVrGDZsGP78888URVhmbNu2DVFRUfjqq6/SLcIAoHz58vD19YVKpcK2bdsQEhKC3bt3o0qVKli8eDH279+fpSKMiMiUKZVKrFmzBpaWlti+fTtWr14tO1K+8PbtW3Tq1AmxsbFo1qxZqlVoKO+ZXI+YKWGPGBGZuuDgYIwePRr29va4dOkSSpcuLTuSSevTpw+WLVuGokWL4vz58yhWrJjsSCYpX/eIERGR8RgxYgTq168PtVqNHj16QKPRyI5kstavX49ly5ZBoVBg7dq1LMIMBAsxIiKSxsLCAmFhYShYsCAOHjyI+fPny45kkm7cuIE+ffoAAMaMGYOWLVtKTkRaLMSIiEgqNzc3zJgxAwAQEBDwweXgKGvi4uLQqVMnxMTEoEmTJrrljMgwsBAjIiLp+vfvj7Zt2yIuLg5fffUVnjx5IjuSyfD398eFCxfg7OyMdevWwcLCIBfVybdYiBERkXRmZmb49ddfUblyZTx69Ahff/014uLiZMcyeps2bcKiRYsAvFvOqESJEpIT0X+xECMiIoNgb2+PHTt2oFChQjh58iT69OkDPtiffTdv3tQtyzdq1Ch4eXlJTkRpYSFGREQGo0KFCti8eTPMzc2xZs0ahISEyI5klOLj49G5c2e8fv0aDRs2TLXaDBkOFmJERGRQWrRogZ9//hnAu8H7u3fvlhvICA0fPhxnz56Fk5MTNmzYwHFhBoyFGBERGZwBAwbobk127doVV65ckR3JaCxatEg3Dcjq1atRsmRJyYkoIyzEiIjI4CgUCsybNw9NmjTB69ev0a5dO0RFRcmOZfA2bNiAAQMGAADGjx+P1q1bS05EH8JCjIiIDJKVlRW2bNmCMmXK4NatW+jUqRMSExNlxzJYe/fuhbe3N4QQGDBgAOcLMxIsxIiIyGA5Oztjx44dsLW1xcGDBzF06FDZkQzSsWPH0KFDByQlJaFr166YO3cuFAqF7FiUCSzEiIjIoFWrVg1r166FQqHAggULsGTJEtmRDMqlS5fQpk0bvH37Fl5eXli1ahXMzHh5Nxb8kyIiIoPXvn17TJkyBQAwcOBAbN26VXIiw3D79m14enoiOjoaDRo0wJYtW2BlZSU7FmUBCzEiIjIKgYGB8Pb2RlJSEr799lusXbtWdiSpnj59Cg8PDzx58gTVqlXDrl27ULBgQdmxKItYiBERkVFQKBQIDQ1Fjx49kJycDG9vb93yPflNdHQ0vLy8cOvWLZQtWxb79u1DoUKFZMeibGAhRkRERsPc3BzLly/HoEGDAAA//vgjZs6cKTlV3nrz5g2+/PJLXLhwAS4uLjhw4ACKFSsmOxZlEwsxIiIyKmZmZvjll18wevRoAMDIkSMxbty4fLEuZUJCAjp16oSjR4/CwcEB+/btQ/ny5WXHohxgIUZEREZHoVBg6tSpmDZtGgBgypQp8PPzg0ajkZws9/z7779o0aIFdu/eDWtra+zevRvVq1eXHYtyiIUYEREZrYCAACxYsAAAMHfuXPTu3RvJycmSU+nf6dOnUbt2bRw9ehT29vbYvn07GjZsKDsW6QELMSIiMmo//vgjwsLCYGZmhpUrV6Jbt25ISEiQHUtv1q5di8aNG+Phw4eoVKkS/v77b7Rs2VJ2LNITFmJERGT0unfvjk2bNsHS0hKbNm1Chw4d8ObNG9mxciQpKQnDhg2Dt7c34uLi0KZNG5w8eRKVKlWSHY30iIUYERGZhG+++QY7duzQjZ+qWbMmIiIiZMfKlpcvX6J169aYPXs2AGDMmDHYvn07HBwcJCcjfWMhRkREJsPLywv79+9HiRIlEBkZicaNG8Pf39+oescuXbqEOnXq4MCBAyhYsCA2b96MKVOmwNzcXHY0ygUsxIiIyKQ0atQI//zzD3r06AEhBObMmYOaNWvi6NGjsqN90P/+9z/Ur18ft2/fRtmyZXH8+HF07NhRdizKRSzEiIjI5Dg6OmLlypX4/fffdb1jTZo0wdChQw2yd+zu3bvo0aMHvvnmG8TGxqJFixY4deoUp6fIB1iIERGRyWrVqhX++ecf9OzZE0II/Pzzz6hRo4bB9I49efIEAwcORMWKFbFq1SoAgJ+fH/bu3QsnJye54ShPmFwhdv78eYwePRqenp4oUqQIFAoFmjZtmu3jnTp1Cq1bt4ajoyNsbGxQr149bNq0Kd32T548wQ8//IBixYqhQIECqFSpEqZOnYrExMRsZyAiouxzdHTEihUrdL1jN2/eRJMmTeDn54fXr19LyRQVFYWAgACUL18eCxYsQGJiIlq0aIHjx49jzpw5sLCwkJKLJBAmZvz48QKAsLKyElWrVhUAhLu7e7aOdfDgQWFpaSns7OxE7969hb+/v3B1dRUAREhISKr2T548EaVKlRIKhUJ06NBBBAQEiHr16gkAol27dkKj0WTp/CqVSgAQKpUqW/mJiCil6Oho0bNnTwFAABAFCxYU3bt3F3/++adITk7O9fOr1WoxceJEYW9vr8tQv359cfDgwVw/N+WdrFy/Ta4Q++eff8SZM2dEQkKCePLkSbYLscTERFG+fHmhVCrFuXPndNujo6NFxYoVhZWVlbh7926K93Tv3l0AEIsWLdJt02g0okuXLgKAWLduXZYysBAjIsode/bsEZUqVdIVQwBE6dKlxbhx40RkZKTezxcdHS1CQkKEs7Oz7nw1atQQO3fuzPKXdDJ8+boQe19OCrF9+/YJAKJHjx6p9q1atUoAEBMnTtRtU6vVQqlUinLlyqX6n+ru3bsCgGjWrFmWMrAQIyLKPRqNRhw7dkz06dNHODg4pCjKGjVqJJYvX56tf381Go24fv26WLVqlejTp4+oVq2aUCgUumNXrFhRbNy4MU964EiOrFy/eRM6HYcPHwYAeHh4pNrn6ekJAAgPD9dtO378OOLj49GyZUsoFIoU7V1dXVGpUiVEREQgOTmZc8EQERkAhUKB+vXro379+vj555+xfft2rFq1CgcOHMDRo0dx9OhRDBo0CJ9++imcnJzg7OwMJyenFC/ttufPn+P48eM4duwYjh8/jqioqFTnq1SpEgICAuDt7c0xYKTDvwnpiIyMBAC4ubml2ufi4gJbW1tdmw+1126/fv067t27h3LlyqXZJj4+HvHx8bqf1Wp1tvMTEVHmWVtbo0uXLujSpQsePXqEtWvXIiwsDFevXsWxY8eyfDylUonatWujQYMGumLPxcUlF5KTsWMhlg6VSgUA6S4nYW9vr2uT2fbvt0tLcHAwJk6cmK28RESkHyVKlEBAQABGjhyJCxcu4NatW4iKikJUVBRevHih++/3t2mfqtcWXp9++imsrKxkfxQyAgZZiA0bNixFz9CHDBkyJN2eKGMSGBgIf39/3c9qtRqlSpWSmIiIKP9SKBSoWbMmatasKTsKmTCDLMSWLFmC2NjYTLfv2LGj3gsxbc9Wej1YarUahQoVylL799ulRalUQqlUZisvERERGR+DLMRiYmJkR9AVdpGRkfjss89S7Hv69CliYmJQt27dNNunJTIyElZWVihdunQuJSYiIiJjY3Iz6+uLu7s7AGD//v2p9u3bty9FGwCoV68erKyscODAAQghUrS/d+8erl+/joYNG/JJGSIiItLJ94VYYmIirl27hlu3bqXY3qJFC5QrVw7r1q3D+fPnddtVKhWCgoJgZWWF7t2767bb29ujS5cuuH37NpYsWaLbLoRAYGAgAKB37965+2GIiIjIqCjEf7tvjNy1a9cwbdo0AMDbt2+xadMmfPTRR/Dy8tK10S6sCrxb8b5s2bJwdXXF3bt3Uxzr0KFD8PT0RIECBdClSxfY2dlhy5YtuHfvHkJCQjBs2LAU7Z88eYLPP/8cDx8+RIcOHVChQgWEh4fjxIkT+PLLL7F9+/ZUc4xlRK1Ww8HBASqVSvfUJRERERm2rFy/Ta4QO3z4MJo1a5Zhm/c/ckaFGAD8/fffGD9+PI4dO4bExERUq1YN/v7+6Ny5c5rHfvLkCcaOHYvdu3fj1atXcHV1Rffu3TFy5MgsP8rMQoyIiMj45OtCzJSwECMiIjI+Wbl+5/sxYkRERESysBAjIiIikoSFGBEREZEkLMSIiIiIJGEhRkRERCQJCzEiIiIiSViIEREREUnChQ8NmHaKN7VaLTkJERERZZb2up2ZqVpZiBmw169fAwBKlSolOQkRERFl1evXr+Hg4JBhG86sb8A0Gg0eP34MOzu7LK1RmRlqtRqlSpXCgwcPOGv/f/B3kzH+fjLG30/G+PtJH383GTOm348QAq9fv0bx4sVhZpbxKDD2iBkwMzMzlCxZMlfPYW9vb/B/oWXh7yZj/P1kjL+fjPH3kz7+bjJmLL+fD/WEaXGwPhEREZEkLMSIiIiIJGEhlk8plUqMHz8eSqVSdhSDw99Nxvj7yRh/Pxnj7yd9/N1kzFR/PxysT0RERCQJe8SIiIiIJGEhRkRERCQJCzEiIiIiSViIEREREUnCQiyfOXXqFFq3bg1HR0fY2NigXr162LRpk+xY0q1duxZ9+/ZF7dq1oVQqoVAosGrVKtmxDMKjR4/w888/w8PDA6VLl4aVlRVcXFzwzTff4OTJk7LjSRcXFwd/f380adIExYsXR4ECBeDi4oKGDRsiNDQUiYmJsiManOnTp0OhUEChUODEiROy40hXpkwZ3e/jv6+mTZvKjmcQtm7dipYtW8LJyQkFChRA2bJl0bVrVzx48EB2tBzjzPr5yKFDh+Dp6YkCBQqgS5cusLOzw5YtW9C5c2c8ePAAw4YNkx1RmrFjx+LevXtwdnZGsWLFcO/ePdmRDMa8efMwffp0lC9fHh4eHihSpAgiIyOxbds2bNu2DevWrUPnzp1lx5QmJiYGixYtQt26ddGmTRsUKVIEr169wp49e9CzZ09s2LABe/bs+eAyJ/nFP//8g/Hjx8PGxgaxsbGy4xgMBwcH+Pn5pdpepkyZPM9iSIQQ6NevH5YuXYry5cvrrl2PHz9GeHg47t27Z/zrMQvKFxITE0X58uWFUqkU586d022Pjo4WFStWFFZWVuLu3bvyAkp24MAB3ecPDg4WAERoaKjcUAZiy5Yt4vDhw6m2HzlyRFhaWopChQqJuLg4CckMQ3JysoiPj0+1PTExUTRt2lQAELt27ZKQzPAkJCSIWrVqic8//1x8//33AoA4fvy47FjSubq6CldXV9kxDNLPP/8sAIgff/xRJCUlpdqfmJgoIZV+8StaPnHw4EHcunUL3bp1Q82aNXXbHRwcMHr0aCQkJCAsLExeQMm++OILuLq6yo5hkDp06AB3d/dU2xs3boxmzZrh1atXuHTpkoRkhsHMzAxWVlaptltYWODrr78GANy8eTOvYxmkqVOn4vLly1i5ciXMzc1lxyED9/btW0ycOBHlypXDL7/8kubfGQsL47+xZ/yfgDLl8OHDAAAPD49U+zw9PQEA4eHheRmJTIClpSUA0/jHUN80Gg327t0LAKhatarkNPKdPXsWU6dOxaRJk/DJJ5/IjmNw4uPjsWrVKjx+/Bj29vaoU6cOPv/8c9mxpNq/fz9evXqFHj16IDk5GTt27MCNGzfg6OiIL774AhUqVJAdUS/4r2c+ERkZCQBwc3NLtc/FxQW2tra6NkSZcf/+ffzxxx8oVqwYqlWrJjuOdAkJCQgKCoIQAlFRUfjzzz9x7do19OjRAy1atJAdT6r4+Hh0794dNWvWxMiRI2XHMUhPnz5Fjx49UmyrU6cO1q9fj/Lly0tKJdeZM2cAAObm5qhevTpu3Lih22dmZoahQ4ciJCREVjy9YSGWT6hUKgDvbkWmxd7eXteG6EMSExPh7e2N+Ph4TJ8+nbeZ8K4Qmzhxou5nhUKB4cOHIzg4WGIqw/DTTz8hMjISZ86c4d+VNPTo0QONGzdG1apVYWtrixs3bmD27NlYs2YNWrRogUuXLsHOzk52zDz37NkzAMDs2bNRq1Yt/P3336hcuTLOnTuHPn36YNasWShfvjz69+8vOWnOcIwYEWWJRqOBr68vjhw5gt69e8Pb21t2JINga2sLIQSSk5Px4MEDLFiwAMuXL0fTpk2hVqtlx5Pm+PHjCAkJwdixY3mLNh3jx49H8+bNUbRoURQsWBA1a9bE6tWr4e3tjXv37mHZsmWyI0qh0WgAAFZWVti2bRvq1KkDW1tbNG7cGJs3b4aZmRlmzZolOWXOsRDLJ7Q9Yen1eqnV6nR7y4i0NBoNevbsiXXr1uH777/H4sWLZUcyOGZmZihZsiT69++PpUuXIiIiAlOnTpUdS4qkpCT4+PigevXqGDVqlOw4Rqdv374AgIiICMlJ5NBek2rXro3ixYun2Fe1alWUK1cOt27dQnR0tIR0+sNCLJ/Qjg1LaxzY06dPERMTk+b4MSItjUaDHj16ICwsDF27dsWqVas4N9YHaB+O0T4sk9/ExMQgMjIS58+fh5WVVYqJSrVPadevXx8KhQLbtm2TG9YAOTs7A0C+nW+tUqVKAABHR8c092u3v337No8S5Q6OEcsn3N3dERwcjP3796NLly4p9u3bt0/Xhigt2iJs9erV6Ny5M9asWcOxPpnw+PFjAP/3dGl+o1Qq8cMPP6S578iRI4iMjES7du1QpEiRfD9xaVq0K1fk199Ns2bNAABXr15NtS8xMRE3b96EjY0NihQpktfR9Ev2RGaUNxITE0W5cuUynND1zp070vIZEk7omlJycrLw8fERAMS3335rEhMo6tPly5dFbGxsqu2xsbHCy8tLABBTp06VkMywaf9O5fcJXa9evZrm35+rV68KFxcXAUCEh4dLSGYYPDw8BACxbNmyFNsnTZokAIjvv/9eUjL9YY9YPmFhYYHly5fD09MTTZo0SbHE0b179xASEpJvv3UBwPLly3H06FEA0E1Ounz5ct0tpUaNGqFXr16y4kk1adIkhIWFwdbWFhUrVsSUKVNStfnqq69STBScn2zatAmzZ89Go0aNUKZMGdjb2+PRo0fYs2cPoqKi0LhxYwwdOlR2TDJQGzZswOzZs9GkSRO4urrCxsYGN27cwO+//47ExEQEBgaiSZMmsmNKs3DhQjRo0AC9e/fGtm3b8PHHH+PcuXM4ePAgXF1dMXPmTNkRc052JUh56+TJk8LLy0vY29sLa2trUbduXbFhwwbZsaTTfjtP7+Xj4yM7ojQf+t0gn/cenjp1SvTu3VtUqVJFODo6CgsLC+Hk5CSaNWsmlixZwh7EdLBH7J3Dhw+LTp06CTc3N2Fvby8sLCyEi4uLaN++vdi3b5/seAbh/v37wtfXV7i4uAhLS0tRqlQpMWDAAPHvv//KjqYXCiGEyPvyj4iIiIj4yBMRERGRJCzEiIiIiCRhIUZEREQkCQsxIiIiIklYiBERERFJwkKMiIiISBIWYkRERESSsBAjIiIikoSFGBEREZEkLMSIiIiIJGEhRkRERCQJCzEiIiIiSViIEREREUnCQoyIKA8IIdC6dWsoFAps3Lgx1b5WrVqluY+ITJtCCCFkhyAiyg/+/fdfVK9eHfHx8bhw4QJcXV0BAHPmzIG/vz98fX0RGhoqOSUR5SUWYkREeWjv3r1o3bo16tevjyNHjuDSpUv4/PPP4erqirNnz8LW1lZ2RCLKQ7w1SUSUh7y8vDBkyBAcO3YMo0aNQteuXSGEwPr161mEEeVD7BEjIspj8fHxqFevHs6fPw8AmD59OkaOHCk3FBFJwR4xIqI8plQq0apVKwBAgQIF0KtXL8mJiEgWFmJERHns5MmTmDlzJpycnBAXF4f+/fvLjkREkrAQIyLKQ69fv0a3bt1gYWGBw4cP45tvvsGmTZuwcuVK2dGISAKOESMiykPe3t5Yu3Yt5s+fjwEDBuDVq1eoUaMGXr58ibNnz6JixYqyIxJRHmIhRkSUR9auXQtvb298+eWX2LFjh277kSNH0KxZM3z66ac4fvw4LC0tJaYkorzEW5NERHngzp07GDBgAIoVK5bqNmSTJk0QGBiIM2fOYPTo0ZISEpEM7BEjIiIikoQ9YkRERESSsBAjIiIikoSFGBEREZEkLMSIiIiIJGEhRkRERCQJCzEiIiIiSViIEREREUnCQoyIiIhIEhZiRERERJKwECMiIiKShIUYERERkSQsxIiIiIgk+X9eqrXre/Ud/QAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Scipy quad => to solve integrals\n",
        "#scipy.integrate.quad module is used\n",
        "#Note:- Quadrature (quad) requries function f(x)\n",
        "\n",
        "from scipy.integrate import quad as q\n",
        "\n",
        "#integral = 3x^2 + 1 from x = 0 to x = 1\n",
        "\n",
        "def f(x):\n",
        "  return 3.0*x*x + 1.0\n",
        "\n",
        "lower_bound = 0\n",
        "upper_bound = 1\n",
        "\n",
        "#quad has two variables one is I and the other is error\n",
        "I_quad , err = q(f,lower_bound,upper_bound)\n",
        "print(I_quad)\n",
        "print(err)\n",
        "\n",
        "#finding only I value\n",
        "I_quad = q(f,lower_bound,upper_bound)[0]\n",
        "print(I_quad)\n",
        "\n",
        "#or\n",
        "\n",
        "I_quad , _= q(f,lower_bound,upper_bound)\n",
        "print(I_quad)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s8ZeF_wbxwv5",
        "outputId": "d65aefa8-341f-41e3-9cab-6aa4a7b3b831"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.0\n",
            "2.220446049250313e-14\n",
            "2.0\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Scipy.integrate.simps => solving integrals\n",
        "#Note:- simps doesnot require a function (ie) f(x)\n",
        "\n",
        "#importing simps from scipy.integrate\n",
        "from scipy.integrate import simps as s\n",
        "\n",
        "x =  n.arange(0,10)\n",
        "y = n.arange(0,10)\n",
        "\n",
        "I_simps = s(x,y)\n",
        "print(I_simps)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zCiE_1dBz6Op",
        "outputId": "98edcb95-ea80-4e21-cfe4-cf029d27cd00"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "40.5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-12-2e70fd09969b>:10: DeprecationWarning: 'scipy.integrate.simps' is deprecated in favour of 'scipy.integrate.simpson' and will be removed in SciPy 1.14.0\n",
            "  I_simps = s(x,y)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Special functions (scipy.special)\n",
        "from scipy import special\n",
        "\n",
        "#Cubic root function\n",
        "#importing cbrt from scipy.special\n",
        "from scipy.special import cbrt as c\n",
        "\n",
        "a = c([27,64])\n",
        "print(a)\n",
        "\n",
        "#Exponential function\n",
        "from scipy.special import exp10 as e\n",
        "\n",
        "b = e([1,15])\n",
        "print(b)\n",
        "\n",
        "\n",
        "#Combinations\n",
        "from scipy.special import comb as co\n",
        "\n",
        "d = co(5,2,exact = False , repetition = True)\n",
        "print(d)\n",
        "\n",
        "\n",
        "#Permutations\n",
        "from scipy.special import perm as p\n",
        "\n",
        "d = p(5,2,exact = True)\n",
        "print(d)\n",
        "\n",
        "#log sum exponential function\n",
        "from scipy.special import logsumexp as lo\n",
        "\n",
        "x = 1\n",
        "d = lo(x)\n",
        "print(d)\n",
        "\n",
        "\n",
        "#Gamma function\n",
        "from scipy.special import gamma as g\n",
        "\n",
        "d = g([0,0.5,1,1,5])\n",
        "print(d)\n",
        "\n",
        "\n",
        "#to find sin degree\n",
        "sin = special.sindg(90)\n",
        "print(sin)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjVZu4UA1NW5",
        "outputId": "cdc19af9-37a4-4ac6-880d-750eb961ee73"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3. 4.]\n",
            "[1.e+01 1.e+15]\n",
            "15.0\n",
            "20\n",
            "1.0\n",
            "[        inf  1.77245385  1.          1.         24.        ]\n",
            "1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Symbolic Math\n",
        "#Sympy Module\n",
        "\n",
        "#importing sympy\n",
        "import sympy as sp\n",
        "sp.init_printing()# to get pretty output\n",
        "\n",
        "#Note:- use display() instead of print for good output\n",
        "\n",
        "#Symbol variable\n",
        "\n",
        "#Syntax\n",
        "\n",
        "x,y,z = sp.symbols('x,y,z') #Note:- name of the variable doesnot need to be the same as the symbol\n",
        "\n",
        "ell = sp.symbols('L')\n",
        "\n",
        "exp1 = x*sp.cos(x)\n",
        "exp2 = x**2 + y**2 + z\n",
        "exp3 = sp.sqrt(x+y/2)\n",
        "\n",
        "#Note:- use display to get the output as symbols\n",
        "display(x)\n",
        "display(ell)\n",
        "display(exp1)\n",
        "display(exp2)\n",
        "display(exp3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 144
        },
        "id": "pP-k3nBE4lgo",
        "outputId": "7dcb6974-7e3e-478e-a1f4-39f05153f96d"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "x"
            ],
            "text/latex": "$\\displaystyle x$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "L"
            ],
            "text/latex": "$\\displaystyle L$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "x⋅cos(x)"
            ],
            "text/latex": "$\\displaystyle x \\cos{\\left(x \\right)}$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              " 2    2    \n",
              "x  + y  + z"
            ],
            "text/latex": "$\\displaystyle x^{2} + y^{2} + z$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "    _______\n",
              "   ╱     y \n",
              "  ╱  x + ─ \n",
              "╲╱       2 "
            ],
            "text/latex": "$\\displaystyle \\sqrt{x + \\frac{y}{2}}$"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Convert strings to sympy expressions\n",
        "\n",
        "#importing libs\n",
        "from sympy import *\n",
        "\n",
        "#String\n",
        "exp = \"x**2 + 3*x -1/2\"\n",
        "\n",
        "#converting into expression\n",
        "expr = sympify(exp)\n",
        "display(expr)\n",
        "\n",
        "\n",
        "#converting expression to string\n",
        "x,y,z = symbols('x,y,z')\n",
        "print(str(Integral(sqrt(1/x),x)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "id": "rZwynAXG6v9y",
        "outputId": "02838242-3448-42a0-c79e-78227f74ac8e"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              " 2         1\n",
              "x  + 3⋅x - ─\n",
              "           2"
            ],
            "text/latex": "$\\displaystyle x^{2} + 3 x - \\frac{1}{2}$"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Integral(sqrt(1/x), x)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Algebraic operations => simplify , factor , expand\n",
        "\n",
        "ex = x**2 / x**2\n",
        "print(sp.simplify(ex))\n",
        "\n",
        "ex = (x+2)*(x-3)\n",
        "print(sp.expand(ex))\n",
        "\n",
        "ex = x**3 - x**2 + x - 1\n",
        "print(sp.factor(ex))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4q3MtbVv8Gf3",
        "outputId": "eaf8776d-06b5-49a2-9ec3-4eaa7a9212ea"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "x**2 - x - 6\n",
            "(x - 1)*(x**2 + 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Evalf => to evaluate a numerical expression into a floating point number\n",
        "\n",
        "ex = sqrt(8)\n",
        "ex.evalf()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "5ocshcWO81Bv",
        "outputId": "c3f098bc-0529-470b-ad4c-3e236ce0c8f6"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.82842712474619"
            ],
            "text/latex": "$\\displaystyle 2.82842712474619$"
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Substitute a number into an expression\n",
        "ex = x**3 - x**2 + x - 1\n",
        "ans1 = ex.subs(x,2.) #evaluates numerically\n",
        "ans2 = ex.subs(x,2) #treats as a symbol\n",
        "\n",
        "display(ans1)\n",
        "display(ans2)\n",
        "\n",
        "#Substitute a symbol into an expression\n",
        "ans3 = ex.subs(x,y)\n",
        "ans4 = ex.subs(x,y**2+z)\n",
        "\n",
        "display(ans3)\n",
        "display(ans4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 103
        },
        "id": "ak0G7HMb9Dhw",
        "outputId": "c4972312-af02-41a0-e86b-af189ba9e06e"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "5.00000000000000"
            ],
            "text/latex": "$\\displaystyle 5.0$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "5"
            ],
            "text/latex": "$\\displaystyle 5$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              " 3    2        \n",
              "y  - y  + y - 1"
            ],
            "text/latex": "$\\displaystyle y^{3} - y^{2} + y - 1$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "                 3           2    \n",
              " 2       ⎛ 2    ⎞    ⎛ 2    ⎞     \n",
              "y  + z + ⎝y  + z⎠  - ⎝y  + z⎠  - 1"
            ],
            "text/latex": "$\\displaystyle y^{2} + z + \\left(y^{2} + z\\right)^{3} - \\left(y^{2} + z\\right)^{2} - 1$"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Calculus\n",
        "\n",
        "#derivatives are done using sp.diff(expr,var,[order])\n",
        "#indefinite integrals => sp.integrate(expr,var)\n",
        "#definite integrals => sp.integrate(expr,(var,lb,ub))\n",
        "\n",
        "#Examples of derivatives\n",
        "ex = sp.exp(x**2)\n",
        "display(sp.diff(ex,x)) #single derivative\n",
        "display(sp.diff(ex,x,3)) #third  derivative\n",
        "\n",
        "ex = sp.exp(x*y*z)\n",
        "dxdy = sp.diff(ex,x,y) #partial derivatives\n",
        "display(dxdy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "id": "faMEny2Z-cyv",
        "outputId": "5f388901-3ab9-4cc2-84b3-92e604e31712"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "     ⎛ 2⎞\n",
              "     ⎝x ⎠\n",
              "2⋅x⋅ℯ    "
            ],
            "text/latex": "$\\displaystyle 2 x e^{x^{2}}$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "                ⎛ 2⎞\n",
              "    ⎛   2    ⎞  ⎝x ⎠\n",
              "4⋅x⋅⎝2⋅x  + 3⎠⋅ℯ    "
            ],
            "text/latex": "$\\displaystyle 4 x \\left(2 x^{2} + 3\\right) e^{x^{2}}$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "               x⋅y⋅z\n",
              "z⋅(x⋅y⋅z + 1)⋅ℯ     "
            ],
            "text/latex": "$\\displaystyle z \\left(x y z + 1\\right) e^{x y z}$"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Integrals\n",
        "\n",
        "display(sp.integrate(x**3,x)) #indefinte integral\n",
        "display(sp.integrate(x**2,(x,0,1))) #definte integral\n",
        "\n",
        "display(sp.integrate(sp.exp(-x),(x,0,sp.oo))) #integral with infinity as upper limit\n",
        "display(sp.integrate(x*sp.exp(-x),(x,y,sp.oo))) #double integral with infinity as limit\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "id": "3Q5o0ZTH_zG_",
        "outputId": "fd3a85dc-1ac4-428f-d637-6675123a483e"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              " 4\n",
              "x \n",
              "──\n",
              "4 "
            ],
            "text/latex": "$\\displaystyle \\frac{x^{4}}{4}$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "1/3"
            ],
            "text/latex": "$\\displaystyle \\frac{1}{3}$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "1"
            ],
            "text/latex": "$\\displaystyle 1$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "           -y\n",
              "-(-y - 1)⋅ℯ  "
            ],
            "text/latex": "$\\displaystyle - \\left(- y - 1\\right) e^{- y}$"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Exercise\n",
        "\n",
        "sp.Integral(sp.exp(-x),(x,0,sp.oo))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 77
        },
        "id": "0OjwShf-Ay3f",
        "outputId": "fbb43f61-09ac-4041-b806-6d1ec50015d1"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "∞       \n",
              "⌠       \n",
              "⎮  -x   \n",
              "⎮ ℯ   dx\n",
              "⌡       \n",
              "0       "
            ],
            "text/latex": "$\\displaystyle \\int\\limits_{0}^{\\infty} e^{- x}\\, dx$"
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Limits\n",
        "\n",
        "\n",
        "expr = Limit((cos(x)-1)/x,x,0) #to display expression with limit\n",
        "display(expr)\n",
        "\n",
        "# doit() => evaluates the expression\n",
        "display(expr.doit())\n",
        "\n",
        "\n",
        "#fourier series\n",
        "ex = sp.exp(x**3)\n",
        "sp.series(ex,0,4)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "id": "OP0rv1I7BdCo",
        "outputId": "d5c08510-611d-4949-cf41-88345c98f4d5"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "     ⎛cos(x) - 1⎞\n",
              " lim ⎜──────────⎟\n",
              "x─→0⁺⎝    x     ⎠"
            ],
            "text/latex": "$\\displaystyle \\lim_{x \\to 0^+}\\left(\\frac{\\cos{\\left(x \\right)} - 1}{x}\\right)$"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "0"
            ],
            "text/latex": "$\\displaystyle 0$"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              " ⎛ 3⎞\n",
              " ⎝x ⎠\n",
              "ℯ    "
            ],
            "text/latex": "$\\displaystyle e^{x^{3}}$"
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sympy import Function, dsolve,Derivative , checkodesol\n",
        "from sympy.abc import x   #sympy.abc => This module exports all latin and greek letters as Symbols\n",
        "\n",
        "\n",
        "y = Function('y')\n",
        "\n",
        "res = dsolve(Derivative(y(x),x,x) + 9*y(x), y(x))\n",
        "print(res)\n",
        "checkodesol(Eq(Derivative(y(x),x,x) + 9*y(x), y(x)),res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h3gcq0enGBeY",
        "outputId": "944fd64d-e03a-45ca-bfaf-7c12d7efe446"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Eq(y(x), C1*sin(3*x) + C2*cos(3*x))\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(False, C1*sin(3*x) + C2*cos(3*x))"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Series expansion\n",
        "from sympy import *\n",
        "\n",
        "expr = exp(sin(x))\n",
        "expr.series(exp,0,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 39
        },
        "id": "AeaAiaoYHuyB",
        "outputId": "abad0775-8b84-4aa6-99f6-d6cdb402977d"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              " sin(x)\n",
              "ℯ      "
            ],
            "text/latex": "$\\displaystyle e^{\\sin{\\left(x \\right)}}$"
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f,g = symbols('f g',cls = Function)\n",
        "differentiate_finite(f(x)*g(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 58
        },
        "id": "xhYpXsbTIJ3h",
        "outputId": "62cc7d66-37dc-47b0-8d5c-8c4deb6461ee"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-f(x - 1/2)⋅g(x - 1/2) + f(x + 1/2)⋅g(x + 1/2)"
            ],
            "text/latex": "$\\displaystyle - f{\\left(x - \\frac{1}{2} \\right)} g{\\left(x - \\frac{1}{2} \\right)} + f{\\left(x + \\frac{1}{2} \\right)} g{\\left(x + \\frac{1}{2} \\right)}$"
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Norm => finds the norm of the given vector\n",
        "\n",
        "from scipy import linalg as l\n",
        "\n",
        "x = n.array([6,3])\n",
        "\n",
        "a = l.norm(x)\n",
        "a = l.norm(x,1)\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SVDmpkOYI2_1",
        "outputId": "81bb520a-0bbf-458e-ac27-63582e036cff"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9.0\n",
            "[1.e+01 1.e+15]\n"
          ]
        }
      ]
    }
  ]
}