Exception handling, Modules and packages.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hZ4xeFRKej9h"
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 414,
     "status": "ok",
     "timestamp": 1728654182696,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "JNcnq46Sj5ch",
    "outputId": "a375fb3e-5258-4dbd-e084-62eee5d10662"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1728654190099,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "ebsTB-g00ODK",
    "outputId": "04a692ea-2db3-46fe-ebb4-8f5f650ea7cd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'math' (built-in)>\n"
     ]
    }
   ],
   "source": [
    "print(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 614,
     "status": "ok",
     "timestamp": 1728654204059,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "tlFdyUsG0OGg",
    "outputId": "4ae41d85-e09e-4716-cc1e-4788d62ac694"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1728654228206,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "miDsSeeK0OJd",
    "outputId": "401274ca-74ce-4e28-8951-ea11811a7ee8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.factorial(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1728654241313,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "_QmrL9lm0OMU",
    "outputId": "26405d09-3c5c-4a3d-f077-b087cd0a802a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(4.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1728654253067,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "im-PxHtn0OPH",
    "outputId": "328d554d-6b60-4aa3-b25f-82d9718ce026"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(4.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 624,
     "status": "ok",
     "timestamp": 1728655167035,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "Jz2wXUZ60OR2",
    "outputId": "0e217adf-5834-470c-8b31-8fbf8a478d09"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5005\n"
     ]
    }
   ],
   "source": [
    "print(math.comb(15,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 661,
     "status": "ok",
     "timestamp": 1728655196871,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "qYxh02cD0OUt",
    "outputId": "8ab5d39e-f8bf-4ea4-990b-0413fd31fecb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "336"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.perm(8,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 445,
     "status": "ok",
     "timestamp": 1728655221598,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "hPtx2M84kCF6",
    "outputId": "dca3b287-58df-4fa6-bc97-e2b08018636a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to the mathematical functions\n",
      "    defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "        \n",
      "        The result is between 0 and pi.\n",
      "    \n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        \n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "        \n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    comb(n, k, /)\n",
      "        Number of ways to choose k items from n items without repetition and without order.\n",
      "        \n",
      "        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        Also called the binomial coefficient because it is equivalent\n",
      "        to the coefficient of k-th term in polynomial expansion of the\n",
      "        expression (1 + x)**n.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "        \n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    dist(p, q, /)\n",
      "        Return the Euclidean distance between two points p and q.\n",
      "        \n",
      "        The points should be specified as sequences (or iterables) of\n",
      "        coordinates.  Both inputs must have the same dimension.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
      "    \n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "        \n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(x, /)\n",
      "        Find x!.\n",
      "        \n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "        \n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "        \n",
      "        x % y may differ.\n",
      "    \n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        \n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "        \n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(*integers)\n",
      "        Greatest Common Divisor.\n",
      "    \n",
      "    hypot(...)\n",
      "        hypot(*coordinates) -> value\n",
      "        \n",
      "        Multidimensional Euclidean distance from the origin to a point.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum(x**2 for x in coordinates))\n",
      "        \n",
      "        For a two dimensional point (x, y), gives the hypotenuse\n",
      "        using the Pythagorean theorem:  sqrt(x*x + y*y).\n",
      "        \n",
      "        For example, the hypotenuse of a 3/4/5 right triangle is:\n",
      "        \n",
      "            >>> hypot(3.0, 4.0)\n",
      "            5.0\n",
      "    \n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    isqrt(n, /)\n",
      "        Return the integer part of the square root of the input.\n",
      "    \n",
      "    lcm(*integers)\n",
      "        Least Common Multiple.\n",
      "    \n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "        \n",
      "        This is essentially the inverse of frexp().\n",
      "    \n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "        \n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        \n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "        \n",
      "        Both results carry the sign of x and are floats.\n",
      "    \n",
      "    nextafter(x, y, /)\n",
      "        Return the next floating-point value after x towards y.\n",
      "    \n",
      "    perm(n, k=None, /)\n",
      "        Number of ways to choose k items from n items without repetition and with order.\n",
      "        \n",
      "        Evaluates to n! / (n - k)! when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        If k is not specified or is None, then k defaults to n\n",
      "        and the function returns n!.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    prod(iterable, /, *, start=1)\n",
      "        Calculate the product of all the elements in the input iterable.\n",
      "        \n",
      "        The default start value for the product is 1.\n",
      "        \n",
      "        When the iterable is empty, return the start value.  This function is\n",
      "        intended specifically for use with numeric values and may reject\n",
      "        non-numeric types.\n",
      "    \n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "        \n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "    \n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "        \n",
      "        Uses the __trunc__ magic method.\n",
      "    \n",
      "    ulp(x, /)\n",
      "        Return the value of the least significant bit of the float x.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 608,
     "status": "ok",
     "timestamp": 1728658728498,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "D5EAVcX6FoR5",
    "outputId": "dd6d2858-d7d2-4938-abba-42fed58570da"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.995732273553991"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1728658738846,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "83RaTN3DFuk3",
    "outputId": "40a0d6ff-bbdd-4987-cb0a-6a232e9da137"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.321928094887362"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log2(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JeEdq92oF0Ig"
   },
   "source": [
    "# RANDOM "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EVRaYRGoFx1Q"
   },
   "outputs": [],
   "source": [
    "import random as r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 536,
     "status": "ok",
     "timestamp": 1728658786030,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "2O3rQEReF43H",
    "outputId": "afa43ddc-5c74-4483-df64-2c2a3afb39e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module random:\n",
      "\n",
      "NAME\n",
      "    random - Random variable generators.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.10/library/random.html\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "        bytes\n",
      "        -----\n",
      "               uniform bytes (values between 0 and 255)\n",
      "    \n",
      "        integers\n",
      "        --------\n",
      "               uniform within range\n",
      "    \n",
      "        sequences\n",
      "        ---------\n",
      "               pick random element\n",
      "               pick random sample\n",
      "               pick weighted random sample\n",
      "               generate random permutation\n",
      "    \n",
      "        distributions on the real line:\n",
      "        ------------------------------\n",
      "               uniform\n",
      "               triangular\n",
      "               normal (Gaussian)\n",
      "               lognormal\n",
      "               negative exponential\n",
      "               gamma\n",
      "               beta\n",
      "               pareto\n",
      "               Weibull\n",
      "    \n",
      "        distributions on the circle (angles 0 to 2pi)\n",
      "        ---------------------------------------------\n",
      "               circular uniform\n",
      "               von Mises\n",
      "    \n",
      "    General notes on the underlying Mersenne Twister core generator:\n",
      "    \n",
      "    * The period is 2**19937-1.\n",
      "    * It is one of the most extensively tested generators in existence.\n",
      "    * The random() method is implemented in C, executes in a single Python step,\n",
      "      and is, therefore, threadsafe.\n",
      "\n",
      "CLASSES\n",
      "    _random.Random(builtins.object)\n",
      "        Random\n",
      "            SystemRandom\n",
      "    \n",
      "    class Random(_random.Random)\n",
      "     |  Random(x=None)\n",
      "     |  \n",
      "     |  Random number generator base class used by bound module functions.\n",
      "     |  \n",
      "     |  Used to instantiate instances of Random to get generators that don't\n",
      "     |  share state.\n",
      "     |  \n",
      "     |  Class Random can also be subclassed if you want to use a different basic\n",
      "     |  generator of your own devising: in that case, override the following\n",
      "     |  methods:  random(), seed(), getstate(), and setstate().\n",
      "     |  Optionally, implement a getrandbits() method so that randrange()\n",
      "     |  can cover arbitrarily large ranges.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  getstate(self)\n",
      "     |      Return internal state; can be passed to setstate() later.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randbytes(self, n)\n",
      "     |      Generate n random bytes.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k, *, counts=None)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      Repeated elements can be specified one at a time or with the optional\n",
      "     |      counts parameter.  For example:\n",
      "     |      \n",
      "     |          sample(['red', 'blue'], counts=[4, 2], k=5)\n",
      "     |      \n",
      "     |      is equivalent to:\n",
      "     |      \n",
      "     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)\n",
      "     |      \n",
      "     |      To choose a sample from a range of integers, use range() for the\n",
      "     |      population argument.  This is especially fast and space efficient\n",
      "     |      for sampling from a large population:\n",
      "     |      \n",
      "     |          sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  seed(self, a=None, version=2)\n",
      "     |      Initialize internal state from a seed.\n",
      "     |      \n",
      "     |      The only supported seed types are None, int, float,\n",
      "     |      str, bytes, and bytearray.\n",
      "     |      \n",
      "     |      None or no argument seeds from current time or from an operating\n",
      "     |      system specific randomness source if available.\n",
      "     |      \n",
      "     |      If *a* is an int, all bits are used.\n",
      "     |      \n",
      "     |      For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "     |      bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "     |      sequences from older versions of Python), the algorithm for str and\n",
      "     |      bytes generates a narrower range of seeds.\n",
      "     |  \n",
      "     |  setstate(self, state)\n",
      "     |      Restore internal state from object returned by getstate().\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  __init_subclass__(**kwargs) from builtins.type\n",
      "     |      Control how subclasses generate random integers.\n",
      "     |      \n",
      "     |      The algorithm a subclass can use depends on the random() and/or\n",
      "     |      getrandbits() implementation available to it and determines\n",
      "     |      whether it can generate random integers from arbitrarily large\n",
      "     |      ranges.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  getrandbits(self, k, /)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  random(self, /)\n",
      "     |      random() -> x in the interval [0, 1).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class SystemRandom(Random)\n",
      "     |  SystemRandom(x=None)\n",
      "     |  \n",
      "     |  Alternate random number generator using sources provided\n",
      "     |  by the operating system (such as /dev/urandom on Unix or\n",
      "     |  CryptGenRandom on Windows).\n",
      "     |  \n",
      "     |   Not available on all systems (see os.urandom() for details).\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SystemRandom\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  getrandbits(self, k)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  getstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  randbytes(self, n)\n",
      "     |      Generate n random bytes.\n",
      "     |  \n",
      "     |  random(self)\n",
      "     |      Get the next random number in the range [0.0, 1.0).\n",
      "     |  \n",
      "     |  seed(self, *args, **kwds)\n",
      "     |      Stub method.  Not used for a system random number generator.\n",
      "     |  \n",
      "     |  setstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from Random:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k, *, counts=None)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      Repeated elements can be specified one at a time or with the optional\n",
      "     |      counts parameter.  For example:\n",
      "     |      \n",
      "     |          sample(['red', 'blue'], counts=[4, 2], k=5)\n",
      "     |      \n",
      "     |      is equivalent to:\n",
      "     |      \n",
      "     |          sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)\n",
      "     |      \n",
      "     |      To choose a sample from a range of integers, use range() for the\n",
      "     |      population argument.  This is especially fast and space efficient\n",
      "     |      for sampling from a large population:\n",
      "     |      \n",
      "     |          sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods inherited from Random:\n",
      "     |  \n",
      "     |  __init_subclass__(**kwargs) from builtins.type\n",
      "     |      Control how subclasses generate random integers.\n",
      "     |      \n",
      "     |      The algorithm a subclass can use depends on the random() and/or\n",
      "     |      getrandbits() implementation available to it and determines\n",
      "     |      whether it can generate random integers from arbitrarily large\n",
      "     |      ranges.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from Random:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from Random:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    betavariate(alpha, beta) method of Random instance\n",
      "        Beta distribution.\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        Returned values range between 0 and 1.\n",
      "    \n",
      "    choice(seq) method of Random instance\n",
      "        Choose a random element from a non-empty sequence.\n",
      "    \n",
      "    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance\n",
      "        Return a k sized list of population elements chosen with replacement.\n",
      "        \n",
      "        If the relative weights or cumulative weights are not specified,\n",
      "        the selections are made with equal probability.\n",
      "    \n",
      "    expovariate(lambd) method of Random instance\n",
      "        Exponential distribution.\n",
      "        \n",
      "        lambd is 1.0 divided by the desired mean.  It should be\n",
      "        nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "        a reserved word in Python.)  Returned values range from 0 to\n",
      "        positive infinity if lambd is positive, and from negative\n",
      "        infinity to 0 if lambd is negative.\n",
      "    \n",
      "    gammavariate(alpha, beta) method of Random instance\n",
      "        Gamma distribution.  Not the gamma function!\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        \n",
      "        The probability distribution function is:\n",
      "        \n",
      "                    x ** (alpha - 1) * math.exp(-x / beta)\n",
      "          pdf(x) =  --------------------------------------\n",
      "                      math.gamma(alpha) * beta ** alpha\n",
      "    \n",
      "    gauss(mu, sigma) method of Random instance\n",
      "        Gaussian distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.  This is\n",
      "        slightly faster than the normalvariate() function.\n",
      "        \n",
      "        Not thread-safe without a lock around calls.\n",
      "    \n",
      "    getrandbits(k, /) method of Random instance\n",
      "        getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "    \n",
      "    getstate() method of Random instance\n",
      "        Return internal state; can be passed to setstate() later.\n",
      "    \n",
      "    lognormvariate(mu, sigma) method of Random instance\n",
      "        Log normal distribution.\n",
      "        \n",
      "        If you take the natural logarithm of this distribution, you'll get a\n",
      "        normal distribution with mean mu and standard deviation sigma.\n",
      "        mu can have any value, and sigma must be greater than zero.\n",
      "    \n",
      "    normalvariate(mu, sigma) method of Random instance\n",
      "        Normal distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.\n",
      "    \n",
      "    paretovariate(alpha) method of Random instance\n",
      "        Pareto distribution.  alpha is the shape parameter.\n",
      "    \n",
      "    randbytes(n) method of Random instance\n",
      "        Generate n random bytes.\n",
      "    \n",
      "    randint(a, b) method of Random instance\n",
      "        Return random integer in range [a, b], including both end points.\n",
      "    \n",
      "    random() method of Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    randrange(start, stop=None, step=1) method of Random instance\n",
      "        Choose a random item from range(start, stop[, step]).\n",
      "        \n",
      "        This fixes the problem with randint() which includes the\n",
      "        endpoint; in Python this is usually not what you want.\n",
      "    \n",
      "    sample(population, k, *, counts=None) method of Random instance\n",
      "        Chooses k unique random elements from a population sequence or set.\n",
      "        \n",
      "        Returns a new list containing elements from the population while\n",
      "        leaving the original population unchanged.  The resulting list is\n",
      "        in selection order so that all sub-slices will also be valid random\n",
      "        samples.  This allows raffle winners (the sample) to be partitioned\n",
      "        into grand prize and second place winners (the subslices).\n",
      "        \n",
      "        Members of the population need not be hashable or unique.  If the\n",
      "        population contains repeats, then each occurrence is a possible\n",
      "        selection in the sample.\n",
      "        \n",
      "        Repeated elements can be specified one at a time or with the optional\n",
      "        counts parameter.  For example:\n",
      "        \n",
      "            sample(['red', 'blue'], counts=[4, 2], k=5)\n",
      "        \n",
      "        is equivalent to:\n",
      "        \n",
      "            sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)\n",
      "        \n",
      "        To choose a sample from a range of integers, use range() for the\n",
      "        population argument.  This is especially fast and space efficient\n",
      "        for sampling from a large population:\n",
      "        \n",
      "            sample(range(10000000), 60)\n",
      "    \n",
      "    seed(a=None, version=2) method of Random instance\n",
      "        Initialize internal state from a seed.\n",
      "        \n",
      "        The only supported seed types are None, int, float,\n",
      "        str, bytes, and bytearray.\n",
      "        \n",
      "        None or no argument seeds from current time or from an operating\n",
      "        system specific randomness source if available.\n",
      "        \n",
      "        If *a* is an int, all bits are used.\n",
      "        \n",
      "        For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "        bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "        sequences from older versions of Python), the algorithm for str and\n",
      "        bytes generates a narrower range of seeds.\n",
      "    \n",
      "    setstate(state) method of Random instance\n",
      "        Restore internal state from object returned by getstate().\n",
      "    \n",
      "    shuffle(x, random=None) method of Random instance\n",
      "        Shuffle list x in place, and return None.\n",
      "        \n",
      "        Optional argument random is a 0-argument function returning a\n",
      "        random float in [0.0, 1.0); if it is the default None, the\n",
      "        standard random.random will be used.\n",
      "    \n",
      "    triangular(low=0.0, high=1.0, mode=None) method of Random instance\n",
      "        Triangular distribution.\n",
      "        \n",
      "        Continuous distribution bounded by given lower and upper limits,\n",
      "        and having a given mode value in-between.\n",
      "        \n",
      "        http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "    \n",
      "    uniform(a, b) method of Random instance\n",
      "        Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "    \n",
      "    vonmisesvariate(mu, kappa) method of Random instance\n",
      "        Circular data distribution.\n",
      "        \n",
      "        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "        kappa is the concentration parameter, which must be greater than or\n",
      "        equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "        to a uniform random angle over the range 0 to 2*pi.\n",
      "    \n",
      "    weibullvariate(alpha, beta) method of Random instance\n",
      "        Weibull distribution.\n",
      "        \n",
      "        alpha is the scale parameter and beta is the shape parameter.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['Random', 'SystemRandom', 'betavariate', 'choice', 'choices...\n",
      "\n",
      "FILE\n",
      "    /usr/lib/python3.10/random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 474,
     "status": "ok",
     "timestamp": 1728659359243,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "ivYqhD-aF48j",
    "outputId": "5b183d34-3eab-4f1e-ff6c-2a29707dade8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.randint(1,9) #gives numbers between 1 to 9 randomly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1728659435290,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "ZzmSnpiaF5BC",
    "outputId": "8465d647-0d86-4f78-edd6-db5a32de78a9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.seed(4)\n",
    "r.randint(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TA1sJP_xF5FZ"
   },
   "outputs": [],
   "source": [
    "r.seed(44)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1728659464718,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "HMTlMVFWF5JY",
    "outputId": "9cece637-62c5-4b47-d485-3022ea9a2c58"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.randint(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1728659707891,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "qjSeOeutF5Nx",
    "outputId": "7eaef2b1-4767-41ec-ef04-bf2a5c037338"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.randrange(0,5,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZG9Ou5XMKzNR"
   },
   "source": [
    "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAxAAAADxCAYAAABbCVFHAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAGzASURBVHhe7d0FnBTlGwfwB46U7u7uBmkQkFAQQUWkQ1JKSuAPoiINAkp3CAjS3d0hId3djcLBHf7n99zOsbe3dzd7HMft3e+r+2FvdnZ2Zmf2nfd5M9J/BiEiIiIiIrIgsu1fIiIiIiKiIDGAICIiIiIiyxhAEBERERGRZQwgiIiIiIjIMgYQRERERERkGQMIIiIiIiKyjAEEERERERFZxgCCiIiIiIgsC7GJ5LAV71evjMd/+nhlPLDsFeepIyIiIiJ6ayJHiiTG/xI5ciTx8H1E1mVvwxsHEAgWXnq9Ei9vn+CBiIiIiIjeLQQRUTwiS9QokfV5SAp2AGEGDi+MRwhVYhARERERUQiKFCmSRDOCiJAMJIIVQLx46a2BA2sciIiIiIjCPgQPCCSiRfWwLQk+lwII9Gd48fKVeBoBBBERERERuZfoRgARLWpk7TcRXJYDCAQPz194a7MlIiIiIiJyT2jOFCOaR7CDCEvDuDJ4ICIiIiIKH5CnR94+uKOlWgog0GyJwQMRERERUfiggyEZefzgCDKAQIdp9nkgIiIiIgpfkMdHXt9VgQYQGGUJoy0REREREVH4E5yRVQMNIFC1waFaiYiIiIjCJ3NuN1cEGECw9oGIiIiIKPxztRYiwAACkUgw5pgjIiIiIiI3gjy/K7UQTgMIxA1e3qx9ICIiIiKKCJD3t1p34DSA8H7Fvg9ERERERBEF8v6IAawIIIBg8EBEREREFJFYjQEYQBARERER0ZsFEK8YQBARERERRShWY4AAO1ETEREREVHE8UadqF8xgiAiIiIiilCsxgBOAwgiIiIiIiJnGEAQEREREZFlDCCIiIiIiMgyBhBERERERGQZAwgiIiIiIrKMAQQRERH52rZls0yZPEGOHD5kW/J2vHjxQjZv2iArli0Rz+fPbUute9P3E1HwMYAgIiIKox4+eCD79+2RUydPyCtvb9vSt+vEiWMycvhQuXLlsm3J2/HXwQPSs3sX6fldV9m1a4dtqXVv+n4iCj4GEERERGHUxYsXpFnjBjL/jzny8uVL29LwIX78+BI3XjxJkTKlJEmazLbUuoDe/y6CLqKIhgEEERERhbps2XPIwiUr5c+FyyRnzly2pdYF9P7wHHQRhRUMIIiIiOideO+99yR2nDgSKVIk2xLXvOn7iSh4PPoabM99eb5klR8REdG7dvPmDVm88E/JlSu3lCxVWqJEiSL//vuvLjt+7G9JlTqN7Ny+TcaN/U0W/DlPTp44IenTZ5A4cePatvDaw4cPZfmyJTJx/BhZvGiB7N29y1gvjiRLnkIiR35dnnhg/z7Zt3ePVKj0oWTNmk1L8deuWSXbtm6WRIkSSbz48W1riu++oD9CylSpNUMP6OC8e9cOGf3rCN0vvNfb21v3N2rUqLqO/XFkyJhJnjx5LIsW/CmHDh2UlClSSaxYsXQ9043r12UhjvHkCUmbLp2xvVd+3o/9xN/79uyWv48ekWjRosn9+/flxPFjum/379+TBfPnyZnTp/Q7wuv2HLcfPXoM2ytEEUuMaB62ZwFjDQQREZEbQeZ844b1snLFMhlvBA6dOrSV1StXyK4d22Xm9CnSrUtHOX/+nG1tH+fOnpEO37SSn/r21vdi3SWLF2pTn2FDBsqzZ89sa/qHfgQH9u3VjtXIkNsz92Wpsa2nT57oMmxr6OAB0qZlc9/9wr/du3SS73v3kAe2bZjvxQPPY8eOox23hw4aIHv37tZ17CEgGT50kNy7e1dix4rt7/3m33Nmz9L1D/11UAMYc9/iGkHVkSOHZMTwIfL330d1HdN///0n69et8bN9IgoYAwgiIiI3dPDAfs3Yjxk/Sbbs2CvzFiyRMmXLydEjh2X92jWaKQZk2H8zMtLIUDdo2ESWr1qn6+N92bJll99nTjcy3ut03ZCA4V+XL10s5T+oKKvXb5bDx07Ltl375Isvv5I1q1bKzp3bbWv6hRqBwoWL6vM9u3b6CWr++ecf2b9/n9ZKoCYmsof/ElLUfrRu20569fZpWPFBhYoybuIU6fG/7yVJ0qRGABFPypQpp9vC8K8IOEyo/Th4cL8kSZJEypYr73T7RPQaAwgiIiI31bL1N0aGuoyOSIROxV/Vb6TLb9y4Lp6ePnMjINDYuH6d1P7sC2nbvqOkSZtO18f72nfqItlz5JTLly75yVC/ibt372gmPX2GDJLUNjoSMu8dOnaWjVt3yoeVq+oyZ/LlLyDvFy+hQdD1a1dtS0UunD9nBBU7pJjxWsZMmWxL/UIAkjdffslqBEWQKFFiKViwsBQoWMi3OVQB428ETQi8rl+7psvgxPHjGrSUKFlaMmXOYltKRAFhAEFEROSGkBF2zOymSJFSl9+8cUOeP/fU5kfHjvk01ylTrrzEjBlTn5tKlS4jf/y5WEvuHfsEBFd2I5DJmDGTzJs7Wwb8/KPs2rlda0HeMzLxyNSbfSBM94yAA0OvQqLEiaVQ4aLaBAv9KgA1KXh+584drUFAMGLP/v1BSZkqlRQqUlROnTppbHO/LsN3tGf3Tg16ypb7wN93RET+MYAgIiIKp9Cx+PGjR/o8fvwE+u/bljFTZm02lD5DRh1KtdXXTaVc6ffl0xpVZdGC+YHWdGA0pRIlS2lTot27dmrfhUcPHxpByA4NjFCD8CYQJJUrX0FrJLZu3SyPHz+SG0awtXfPbq35QA0IEQWNAQQREVF4ZWTIzfb8GAUpNCAIKFrsfZk1Z76s37Rd+1o0bd5SPD09pW+fXhpUmP0znEGtCpoSHfrrgM7pgNoCPEfNAWoQ3lSOnDm1KRSaLJ0/d05HfUKTqVKly2oNCBEFjQEEERFROBU9enRJkzatPsdwp44Z9wsXzmuH4rt37waaqTc5BiH/PH2qHZDtYTuoOcC66LyMvhYdOnWWH/sN1JoFNEfC+wKCJkTot4AmSxiNaZ9tRCbUHIREMyv7ztSrVy6XHdu26n7hMzmfBJE1DCCIiIjCsYKFikiKlCllzeqVOieCCaMczfl9pnT4prWsWrkswMxz9BgxjPf7lPzv3LHNN4hAU6TVq1Zo6b0JwcPE8WOl5PuFZOaMqX4CDnOOCGwvkt28E84ULVZc8uTNJzOnTZXZs2ZojQFqDqzAnBZoonTr1k15YgQqr1698hf4mNvHkK8rli9l52kiFzGAICIiCsfQqRlDqCKj3+rrJtKrRzf5bdQv8nXThvLHnN91uNVqH1W3re1c/gIFtZR+0oRx0rpFU33/N62/1gnp7DPeCELKfVBBO1Fj3oiO7dvoezC/Qpdv22utQsFChX2DiYCkSJFCipcopZO/oaYAoynFieN/cjxnUhrBDoKDrVs2S7PG9aTuF7X8BDlgbt/EztNErmEA8QYwBBxKb86cPm1bQkREFLZ4eHhI/QaNdX4EjISEORpQS4BMdeUq1aR7j//p6EiBQQDRolVbiRcvnuzZvUvf//TpU+n9/Y9G5r6QbS0fmL26/6ChUuz94rJ18yb5deRwmT51sr6G9Wt+WjvIpkLot1G4SFGtSUAwgo7VVpsXJTYCnbbtOkqu3Hnk4oULcuXyJT8zbQO2X7pMWUmYMBE7T0dwqIlbZvwmtmze6K+migIW6T8njR4f/RMyY0GbMETamTOn/bWTtBctWnQdizqkhpF723DBDej3g87kWenDKtL3x58ldpw4tleJiKwLLI1MkSKVJE6cWJt9EL0pjMqEUv1Hjx5JyhQpJVbs2C61+/d8/lxu3rwpMWLGMK7LJBqcBARNh54+faLrI/BAZt1xCNe3yfz86Eb+wtnvByNCoVN3l249pH7Dxi59DxEJMtUnTxzXifZw/eAcFipURPNsjoGZOzKvA9SwjRo9XnLmym17JeKKFyvovHioBBBIcIYM6i/z5821LfEP7Q8HDB6mk9uEJRhb+uzZ01p1miVLVt/RLPAjwhT5UydPlIaNm0q7Dt+6TfBDRGFLUGkkMl916taXxk2b+06IRUTBh07jP/TpKVevXJGhv4xi/4cA3Lh+XQYP+lknInT0cY2a0qXrd5IgYULbEtH5O+7fuyupUqXRfjfuYNuWzdK9ayfJkjWbDBg0LERG+nJ3YTKAwCyRKPFwhMlvOnXu6m+CmHcNU/83qv+lfP7Fl9K1e08/pRiIyv/556nEjPleqJaqEFH4Elga6fXSS06fOqElxs1btJI233QItNSXiJx7+PCh/DFnlvH7iSIH9u/TDuH8TQXMPl1Cc7Avv6ovKY2gAEPfou/Lsb+P+itAnTButIz+daQ2Yfvo4xq6LKxDNhijgqGAOKi+ORGFlQAi1OueOhvR6rgJU/w9vv+hX5gLHoKCBAf7zOCBiEKKYxo5aeoMmTztd51EC6WAFy+ct61JRK469Ndf2icDwcOHlavKV/UbMngIwKXLl2TPnt1SpOj7MmLUGKnxyadSuEgx7ZDfb8BgTZO2b92ifUzcGZquoQk6gwfXhHoNxPRZc7UzVkBQrYhxmTF29UfVP/FzQi9fuijr16/V2oqKlSprxt1cH5O/lCxVWjasWytbt2ySZ8ZnFi1aTD6t9bmf6jXAIWPs61UrlsnRo0d0WZ48eeWTT2tLqlSp9WL6999/ZcWyJXLu7Bkd5g37jLGssT9Vqn2sbZKPHD4k+/fvlcKFi2qpoSmg7Vf9qLpkyJDRTztLVJ2dOXtaKlT4UDw9n8uihX/qe9Fk4bPP6+iU/uGhjSERBSyoNBITcA0bMlBHzBn521gdDx/QFwsd/zZtXK81FEg30BwUGSP7EWWCk05iiE6Mv790ySLddubMWTVNihw5kqbDWYy/S5ctZ1s74HQP22aTAAoL0Cfi8qVLxu/hthb+odkSg4eAmS0wan32hXTv0UtixHidpqAZ96mTJzQfhpnHb1y/punCwf37ZJsRVCD/ljlLFj/5NUAt0Pp1a2THti2a/iRNklRq1KylI3PZ53XMvFHFih9KlChRZfbvM7U5OdK4ypWrSakyZS01G0caifRx3ZpVvp+HvFihwkV832+fPpr7aubvAuKY77N6XO7CSg2ER1+D7bkvz5ch2wvd28tLo31MYvNprc8keYoUtlf8u33rlg4Pd8v4F0PLxbBrMoSb03ddv5UECRJIiRKljIsqiu/6D+7f16nuJ44fo+tdvXJZR4q4ZAQdRYoV8w1EkIBg3OoundoZ+7Rd18MD1ZkIGHCjQ6KCAAJDz60yLiq4efOG3kzv3b2jw73FN/YBF1f/n/oa0XkxHXUC0KxpyaIFun1Mw2+/fYx8kShRIslqRO3mBbVm9Qr5deQvEiduHBn5y1DZZduns2fOyAbjx5jSCGgyZ8nKzl1E4VhQaSQy5/v37tGbWtVqH0v6DBnl3r270qdXDx0NB+mFmW7gZnnu7Fk/6Z6r6SRuuqNGDJOBP//ku+0jh//SYAXG/DpSMmTMqAUcEFS6hzkEkK4yHaN3Cdcf7t24ryKzyMK5wCHd+fvoEdm7Z5ckTZrMT8CFf5MmS+bbkd7MnyFAgzOnT+lM3/b5NaRvPbp31pnIzfQHQcjSxQu1szvmKzEDDd+8UZy4Rlo0VEfzwvpIjzCfyY0b13X0r8CG3jXTSOTl7D9vuZHXe/bsXyMIKOInH4nBLMx9NfN3OAZnD/t8nyvH5S5iRAs6sA43v561RnSJkSV+n/unbNmxVyZOmaHjQONmihuaCTdg3BgxlN0PP/WXjVt36uPbLt3Fy7iJT5k4Xi5dvKg30tZt2+mwd/BBhYoybuIU6fG/73VmzYAgYkfn6rhGlGy/fTzHMryGdRz9PnO61P2qga67duNW+bplax37evnSJfLIiGyJKOK6YtyQcBPHcJZp0qTVG93c2b9r+taqTTvZueegHD52WjZs3iG1P/tCl69cvkwzAPasppMojUOahCYKo0aPk83bdsvqdZu1ZmPCuDG2tV7DcKDjx43WksiZs+fJX0dPysEjJ/S9SGtnzZimw14TkftAQUbNWrX1OUYp+qpObR04Bh2lURhrL336DDJ52kxNfwDpEv7+vE5dzTyj8GLihLFy/txZ6fNDP9l74Igc+vuULFu5VsqULafpzc7t2/S99tCnonTpcrJ81TpNs5APQ38MFExgFEykhQFB0IG0DU2utu3ap2nk6vWbtXAaIy+dOHHctqZ/mHcE+2//wBDEGEkMncPRWgWCe1zhQagHEKgOy5crq7+Hs0y1KzD81jftOkruPHl1JKeixd7XsaYBETFupKiS18j1+nVp176TNlnC2Nd4YAg3jHKCzotoz4eqLVRPobYAsA4uKEx1H9AoKNg+qrAwUY7j9vEcy/Aa1sG69vB63XoNdN1kyZJLnS/raYR7+/YtefDwgW0tIgrvkHmfMnmC7+Pnn/pKm5bN5NSpk1K95qda+4BZfGt8UlMGDhmu6YbZ6Rrj339p/J02XXo5efKE1qTas5JOPn3yRHYYNzykc526dNMaVzRvwk2zddv2vhkEk5muPn70SNq266DpJkp2USpZpmx5qVX7Cw0wDh16szSeiEIXamyQNxk+crQ2xUGtwojhQ+TT6lXli9qfaAsNMy+Dmh30jzBrT9OmS6d/Z8ueQzsnHzywX/twIb1CmqOzkRvbR1rV7OtWmt7s2rldm3PaQ3rTtn1HSZM2naZZmPyvV58fND3avm2L3Lt3z7amf3fu3NZ/MYKmOQkhmlShz+3KNRu18CQg2D7233xkyJjJ+Lyt2tS8fcfOvvOGBPe4woNwUwORJWt2SZ0mre0vH2j6A2h29MLTU0vy8QPIn7+gVinhJJtws+vQqbNMnTHbT7teK65dvaL/BrZ9PMcyvIZ1HGsVcEO3b88XN25cjeidrUtE4Rf6XGEGX/Mxb+5sXY7aUEwGhrQK6QluqGjOFNO4YaH9LR7I/EeLGk2X3TdurGinbM9KOon2wOhvhptr9uw59TUTmgsUe7+E7S8fZrqHwOb5c0/Zv2+P7+PA/r2+EzOZ6SQRuQ8UBmCivcnTZmktZLfvemnagN88miwhoECTx8CgluDYsaP6HE2e/jq43086ce3aVUlkLL927Zr2H7BXplx5f82UkDdC80k0HUJTpoDkM/JbyMCjeRIeKKh+/PiRBjt4IC215+zzAcc3fuxorc1o3rK1Tr6INPhNjis8CPUAAh0EUY3k+AisY3VIQZMglJKhSj2mra1vSApq+1iG17AO1iUicoRAAdXlv42ZoKV+8L8+P2o1vH0hAzo2I8AoX6a4lC1ZVB8l3y8kn3xcWWsr3lTkyEag4qSNeLLkyW3PfJjp3rG/j0rHdq2lWeMGfh7jxvxqW5OI3BUCCZTK12vQSGb8/oeMmzhVmzguXvin9s8KDAoykEbAwP4/+UsjenbvooUWzsSPn8D27LUoRsYfhSRIexybUtnDTOa9+/6kNajoB4EWMKWLF5F6X36m/bkCe68JBSBzZs/UASzq1K2nTc3NwONNjis8CDc1EFZ4eEQWjyhRjIvGW/6zcOG4KqjtYxlewzpYl4jIEZpNosocNaG4YaEEDWPXo2bAhGYDkyaM1SZOGB0OwYYZdGBcdrznTQWUjt26edP2zIeZ7hV7v7hvO2Vnj/oNm9jeQUTuADWa6DeKQWTsIZgoXqKkFmogE3/ixDHbKwGIFMl3Et4x4yc5TR/wGDR0uLa+sGfWYAYHMvqopV24ZKWsWrtJfhk5Wuf0QifnHt06G0HEJtuazqFJJ5pnTho/VvtNtGzd1m9tyBscV3gQZnOxzm5e9+xuoMGRIEFC7fiCoVlRtWQPF8qO7Vu1iiuo6riABLZ9wDK8hnWwLhFRYND/oErVj2Trls2yZtUK307Rt4wb+v59e7UpQcdvu2qwYQYd1T/5VKvNgwtDVKP9LtKqM2dO25b6QOByyKEvg5nu3bl9W19HO2X7BwIMBDTmCE9EFPaheQ4KKBp89YUsmD/PaWdl+4l1A4Nh+dOk9Wk6iRGPHNMI1CagozWG1nUcGQvNlMx0z/T48WO5ePGCzhwdz3h/QFDDgCAIMMLmBxUraf+J7j3+p4HPASMNdWzmaQ+jyGHQHQwO0b5TZ+2jau9Njis8CHNHlDBRQq0iR6e7kydf95DHyVm2dLHtr+BBR0N0gkZH5oV/ztMmACYMvTV29K86DOGF8+dsS30ibdz8bt26KU+ePtULMqCI2H77M2dM1d75JnwWPhOvaUdsu5lmiYicQWkXOkVj9KU/5831l6F3hAz85o3r36jaHGlT8ZKlNK3CzRNteZHmoe3wnN9n6nCt9sx0DyOz/DF3tp8CGAyj2Lvnd1Lrk4/k9OlTtqVEFNahZB39nZD/WbZ0kc7xYN/kB7/3JYsW6nNzsBnALN9w7epVTTfwwPvQBxRNoBYY+SC814TXf/99hpQoWkCHQXWEGoATx1/XcCCNw9w0+/bukZw5c0ny5M6nBUCnZQzD+mGFMroNMwhB3wVzPoto0aOJRwAZe+wj+ncACmmQBjsT3OMKD8JcABE7VmzJX6CQRofdu3SSXj26yS/DBsvXzRpqZxmMIhJcuHCqVPtIq6JwshvW+0K3bY5ygqDlqwaNBKMGmFKmTKWlfCgBbNa4ntT9opau54z99levXCF169TSbeNR57NP9DPxGtbBukREQcmcKbOOhIKb01wjA48MOsZkz5Urt6ZF/X78XtatXa0jgfT6rquRyZ/1Rk2YkDZV+6i6Np/C9tGWt2DeHNp2GG2B0Qbann26h3bCXzdt6NtpsWXzJtrxsFz5D7TjIxG5D/QhQKdhjFzZ9dsOmv9p1aKpNGn4ldT/8jOdG+ujj2v49tUCDAiD9AdD1qPPQeeO7bTGILuRr0KTJ6QpyG8hX4R+CR3bt9G+XOZkvY5QQ9Dq6yaaF0Sa0rRRPS3YQKYdE9wFNA8EakcqVPpQn/f7oY82WUKNCp7/8H0v3UeMdGk2QXK03khTzbwe5s3Bcds/UJgCwT2u8CDMBRA4mbVqfy41a32mpfYY63falEkaVKDaCWPwvglUQf3v+x91aDBUuWPbGOXkXyNgwdBc9er5ndYewyK2bddRxx2+eOGCDvEaWFUUto8hwpo2a6Gda7BtPPAcn4nPdqwGIyIKCNLEj2vU1DHFMQkm5mvAzRFDBKJKHhPQdenUXjp1aGssjy79Bw2V1KnT2N4dPLgpd+7SXf7X5wft25A6TRr51EiXR/02zunN0ExXkW7jRorJ7fC4fu2qNG/RSseEtzJrLIUczLsxdPBAzex837un3u/CGtSUIVOHWYdDCwJwtGZAJ1qUElPAkBfCyG8DBg+T9BkyyMkTx3WyWwxdisnW8Nvu3rO3NtExIehAiT1mjEZa4O3tZeSZIvluC3NpIb+FfNGvI4frXA0YaanvT/2dzljfrsO3OpfEpg3rNE3BNpEfwxDW5lCqAXm/eEkZ+ssonTgQQ84iQ4/Z/pMmSy79BgzR14OC4AlpLo7b/vHkyWN9PbjHFR5E+s+xcZnh0T9+5yh4F7BbOEFI9DBxG8bwDelSe4yRjs5B0aNF13a/gbXn07Z0T5/oulbb/WH7ZjMmjALANsBEFJKQLqF0D0Owvq100tGaVSulW5eO0qV7D2ngpGO0K+kqvR2orerT6zvfElSMljN42EjNBIYl6HOIUmrMH9KiVVvb0rcLE4hhUjS0Zhg1erzkzJXb9goFBsHWEyOtQXNuFKwiaAhsdmXUHGC251ixYvsplAW8hgktUUicMkVKbQbpmG5hArnRv47UAhHUiP7z9KmmK8hLYWQmx20GxnHfXX2/VVaOy13EixV0gU+Yq4Ew4UvHBYqp0/Hv2zgJyNCjXVuq1KmDvMmh1gH74crNENvHtvFg8EBEIQ3pEjrrhWQ6iRn50Yerzmc1ZcXypbalPlB6u2f3Tq3+z5r1dbtne66kq/R2bNqwXoMH1Hpj7P6Ro8dpgEk+4/Xj+k2VOo1mJIMDHYpPnTyh/YMePogYE70iw425E9DEGzWOgQUPYHYedpZRx2uYMDdr1mwSO06cINMtvI71MGcNPtvVzL/jvr+N4AFcPS53F2YDCCIiCn1ompA6dVptromqeHTexnOUFv/80/falwvNmHLk9DvJHIUN6Dx64/o1ff5R9U+0rThm332TfjHhSakyZWXthq0ydsKUYDctQUkzOsaifxBGAyKKiBhAEBGRH+hvgT5h6Lv10w995OOqlbSpybIli3WEpnYdOmnpIoVtb6uk1Z2ZpdlsFUD0ZsJsHwgiInq3MHw25sd58PCBeET2kFy5c0uePPnYNCmU4TaNocZXrVgmR48e0WV58uSVqh9VlwwZMvo2lUBn5BMnjvvOaVT3q/qSNHlyrYGoWKlyoM1O0DwNHYsxahbacKMTbOXK1bTE3r4DPCYW279/rxQuXFSbAy1aOF/3CWPeo8ajTNny/jrMY+jN7Vu3yJo1K3XbmTNnlVqffa4BqmMfCEyYuHrlckmUOLFua9fO7bJi2RJ59vy5HvOntT53WnPgbP8xMhjmUrEfqcd+++Z3gn47+AyoVLmqHNy/z8++flWvge9n4vjRqdbxO85irId5WMA8Xwv/nC9nz56WqFGi6HCfGK0M54KChn489+/dlVSp0mgtGoUuK30gGEAQERGFUegAunTxQhkyqL8Ob24PzZK6du8pNWrW0toGs+OpI8y+i/UCCvww0kz/fn11uHJHHxoZ6u969fYdPRD9Ynp27yINGjU1MtAHfDtqmzp820UaNW7mW/uBjD2GS8cQv/aQKaxeo6axz2P8BBAY7bBb5w6SLn0GrSVY7DDvCN7XtVtPHYHMDJwC23/UpvX8X1/fTKi5/bz58vt+Jw8fPtRhPp8/fybZc+SU2bNm6LomDOX+488DtW+PefyOzGNAlgoj/mC4UMfzhU7sP/w0QIf2JArL3LoTNRERUUSHUm6MqR83Xjwj89lfNm7dqQ88xzK8hnWg4odVZNzEKfJBhYr6d6/efWXytJk6DGZAtQ/oMzF96iTNfGO43Z17DsrhY6dlw+Yd2gl77ZpVsnL5Mt+JuEwzp0/R8f/RSRv7g2EsEdCsXrFcrly+rOvgPZhAFcEDRoIaNXqcbN62W9+DwATBQ0DwuZhAzP495vDoU6dM1H45gP2fPHGc7n/Vah/L/EXLZMuOvfov/sZyvI71goLhSTE78Zjxk3Qb8xYs0QAEQdL6tWv0eAoWLOz0O8Z3D/fu3tXJFnFuxk+aJn8dPSkHj5yQfgMG66iSGJreyr4QhXUMIIiIiMIgNP1Zv26Nzgrern0nnVAQNQF44DmW4TWsg3VRQo4MrllbgBmCCxcppqPPBDRhFmY3x/urf1JTGjZqokNPAoa7bNi4mWb8d+3cIY8ePtTlJtQAYB4AlOzj81CbUL5CJTl16qTOQA54z47t23TI1C7de2pzIgzDife0/aaD1owExNl7Wn/TXmp/Xkcz9Hv37Nb1sP+bN23QjD7Wxwg4GJkM/+JvLMfrWM+Klq2/0UECsA18b1/V95k4ERPZeno+1/1w9h2bMxU/ffpUh29HU6UMGTPqSGmojalcpZosWb5Gvu36HZsAUrjAAIKIiCgMQgb8zOlTkj9/QW1DbzbZATzHMryGdRwz+FZhcjAEIRh+8sSJYzo0qfm4dOmCRIseXe7eua3NfOzlyJHTT0d61D6kS5dOn2O8frhtvO/Klcs6EWzOnLl0mQmZ6AqVKtv+8s/Ze9C3okTJ0vr8tHHMnp6evvtf9P3iOu+IPfyN5Xgd69m7du2a9quwh2AJQyLbQyCA5Tdv3JDnzz1tSwOWLHlybQaF2oy+vXvJ8qVL5NrVq3q+MJQuO29TeMEAgoiIKAxCG3o02XnPyJzHdJLxxDK8hnUc29tbhYmvYNKEcTosqf2jfdtW/vo4uAIz82K2aZTmO2tCZd+52VFQ78FcDPLff777nzBhIv3XkbncXO9tw/61addBa3QwS3yvHl2lWuUPpGzJotqPBZ24icIDBhBERERhkIdHZPGIEkVevfKW/169si19DcvwGtbBusHh4RFF/+3zQz9t9+/sMWnaTEmTNq2u5wo030HNhLexn/8Z/7nC6nvM/ces7M6Yy831QkPy5CmkX//BsmP3AZk5e5521kZzqFkzpsmg/j/J48ePbGsSuS8GEERERGFQggQJJVWq1HLu7Bm5du2qbelrWIbXsA7WDY5MmTPrv2iiEzdOHC35Nx9xjL8jR45k/BvXyIC7PqdEggQJdDQlNLG6d9dvDQA6JJ8+ddL2l3/O3gNnbX0ZEiVOos2rzP0/fuxv7QdiD39jOZjrhQZ0ksbQsJhvAqM91W/YWIYMH6X9Mf46uF+uXrliW5PIfTGAICIiCoPQoblAwULahn/mjKnaOdeEOQowwhFewzpm52dXZc2aXYcVXbZ0kRw8eMC21CeDv2b1SqlSsZzOSO7l5WV7xbpkyVPottEMavWqFX4y+Ah8li5ZZPvLP7wH+2Q/YhGCBwzriloNjACFfgXm/q9bs0o7S5ujReFfdLTGvBB4HeuFGONzzU7p165e0c/C94N/MSJW+TLFdahXszM5RIsWVaJEjSox34ul/xK5OwYQREREYRAyyJh8DBOirV65QurWqSU//9RXH3U++0QWGAEEXsM6WDc4MKpQnbr1tB/Ftx3aSq8e3WTK5Ak6LwLmMsBwpOjsHCWK602A0On54xo19TNGjRgmTRvVk99G/aKfgeeYnDAgmDPhz3lzpVmTBn7eg8CixiefSv78BXQ9c/9R4t/12w7SsnljXR//tm3VXI8Lr2O9kBI9enTtRA44Fw3r1ZHBA3+WF56ekiVLVh2hCoFLy+ZNdF8wP0eHb1rLxvXrJF/+/JIqpf+J8IjcDQMIIiKiMArDhX7/Qz/fORDmzZ2tDzzHPA3/+/5H3yFFg0ODlKofyQ/9BuhwqZinYOTwoToZWvoMGWXgkOH+RkNyBd6LbeTKnUcz/xPHj5VNG9Zppr5lG5/J45wpVKiI9BswRPsw4D3YL5TyY+jYdh07+w6Fau7/8JGj9TP27N6l6+PfLFmzyU8/D9LXgxtgBaRKtY+lRas2+hyzUyvjM1AT1LV7L6lbr4Fcv3ZV9wWT+506eULPV+cu3wW7togoLOFM1ERERG4ApexmMyZk9kN6SFDMev3w4QO5i2Fdk6eQuHHjakfokGBuG/ufMlXqAPfdnCkafRwGDB6mzZUwgtLzZ8+DHAYVn/Hk8WNtOoSgKo6x/8Hpu+EKNLHyfOEpsWOjv4jf78o8X3gdHas5hCu5CyszUTOAICIiojDBMYBAZ24iCl1WAgg2YSIiIiIiIssYQBARERERkWVswkRERERhAmbUxvwQ6LuQPUdOHcmJiEIX+0AQEREREZFl7ANBREREREQhigEEERERERFZxgCCiIiIiIgsYwBBRERERESWMYAgIiIiIiLLGEAQEREREZFlDCCIiIiIiMgyBhBERERERGQZAwgiIiIiIrKMAQQREREREVnGAIKIiIiIiCxjAEFERERERJYxgCAiIiIiIssYQBARERERkWUMIIiIiIiIyDIGEEREREREZBkDCCIiIiIisowBBBERERERWcYAgoiIiIiILGMAQUREREREljGAICIiIiIiyxhAEBERERGRZQwgiIiIiIjIskj/GWzPfd1+8Mz2jIiIiIiIIoqkCWLangXMaQDx6J8XtmdERERERBRRxIsVzfYsYGzCREREREREljGAICIiIiIiyxhAEBERERGRZQwgiIiIiIjIMgYQRERERERkGQMIIiIiIiKyjAEEERERERFZxgCCiIiIiIgseycTyXm/+k9eGY//8LAtI6I3EwmPyJEksvHwMB7knpg+vsZrmogo9IW5ieQQq7x8+Uq8vF753CBty4nozeH3hN8Vfl/4nTkpG6AwjOmjf7ymiYjCplALIMyb4yveAIjeOvzOmOFyH0wfg8Zrmogo7Ai1AMLLiyVqRKEJvzf87ijsY/poDa9pIqKwIVT6QKBNL6qgKWLBpXXh/FlJlDiJxIsX37Y0dGEfdu/aLhcvnpcv6tQXDw8P2yvuw9vbW+b9MUvSp88o7xcvJZEiudYWPEqUyGw/Hoa5kj5u3bJRli5dYPtLJNZ7saRFq/aSKlVq2xL3ce3aVZkwbpT88+8/tiUiNWrUljJlP7D9FTBe00REb0+Y6QOBNqzuaMf2LbJ2zQp5+fKlbQk5unfvrvwxd6ZcvXLZtuS1nTu2yvd9usvwYQPkn3+e2paGrkN/HZCJE36Tf41MireXl23pu/Xs2b+yaOEfcuzvI7YlgcN+Y/9xHDgeV7nr7y+icOX84NqJHi26fP75V/JVvcZS67MvJUGCBLZX3y1Xr2vsN/Yfx4HjwXFhG1bwmg4527ZsllUrl4f4fe7mzRuyYtkS45w+sy0hovAkVAIIjCbijk6dOiGHDx80blbetiXk6J+nT2XTxnVy/8E925LXYseJI1GjRtXahyhRotiWvpmbN69rBuXly6BryW5cvyZTp46XXLnyaiYlWvTotlferRcvXhjB1Ta5etV/0OUM9hv7j+PA8eC4XOGuv7+IwtXzE9/IeOcvUEgKFiwi+fIVlPfei2V75d1y9brGfmP/cRw4HhyXVRHpmj5y+JDM/2OO/PuvteDKVSdOHJMD+/bKK++Qvc8tXbxQen7XVU6dPGFbQu4Kv+01q1bK5UsXbUuIQiuAsP1LEQsyB+MmzJRO334n0aPHsC19M4cPHZRpUycEeTNFs5/lyxfJezFjSuOmLSVmzPdsr7gn7D+OA8eD48LxWcXfX9jG8+O6iPSdXblyWTZuWK+ZOHdSo2YtGTJspOTIkdO2hNwRapL69PpOunXpKPfv37ctJQrFTtSuQLv1J08e68NJFw2F6tZHjx6Kp+dz25KAmdt7+vRpgNsDq9vENrAtrBtYtS8yefhcM7OH6vmg9sEV2M/A9tfcz8C+R3vm9gI7Jle3GS1aNEtt9rEtK+fIqmtXr8iB/XulStUakihRYttS51y5lt4GK9874DhwPDguHB9RYNzluqbwKXnyFPJhlaoSPUbIFB5R6MJ9eMf2rdKyeWO5cf26JEmSxPYKkY9Q6UTt+SLo0tI1q5fLkSN/yQcfVJYpk8fKw4cPdHmFilWkabNW+hxeeHrKwoV/yMoVS42MuZdEjhxZSpf5QC/us2dPS/sOXbW0G9uaOX2y1Pz0c5n9+zTf7eXOk09at+ko8eO/ri4PaJuez5/Jc+MmaG4TTp8+qft35fIl/dvDI4pU+6iG1KpVR5ua4KY5auQQzQg/f/ZMq/MzZcoi6TNk1KY+r169Mo6psjRo2EyiRg26k4o93Iz7/fg/qf15XTly+C/ZtnWjbi9OnLjSs9ePkjZdetua/vcTx4tmMIsXzZcGjZpJ3rwFfPc1c+ascufOHd/tvffee1K/QVMpU7aCn8y/s21WqVpdVixfLG2+6aTbBJzLGdMn6XNo2Ki5VK7yse2v11w5R1Mmj5MN61fb/vKre4/vfT/bhH1YvWq59Or9kyRO7Dzhs3othTTzPJYqXU4e3L8nGzas0e89unH9VK9RW2p8UjvAzt53796Rn3/qbXzvHzv9TgMSPZr7dR6PKKykjyYznQzs2nTH69pMi/A7tnpdR5RresXypbJ86RIZMHiYkSbG1wIp9CmLFSu2fucXL1zQ9dJnyCAJEybS5/bQB+H8ubNagIWazMyZs/jJ1E8YN1pu37olXbv31HsYmqVGNs4T7gMmZBMcl2PZrVs3ffu/JU6c1LgHpdPrDRA44jNjx44jL1+8MK5zT91nx2sAtcloPhUrdmy93+CauXzpkpHW3Ta25aH3tUSJErk8eAS9Gc/nz+WX4cZvMl9+yZYtu/To1ll69u4r+QsUtK1B4ZmVTtQefQ225748X4ZsW0hv76BLlM8ZN7b9+/YYGeODUunDatL867ZStGhxzRynTpNW10GCteDPuUZGcpU0avy1NGveWkqVKifbtm2S3bt2SNKkyaTY+yW1vT0SNnSAvnjxgrFuC800Z8yYWbZs3iAPHtyX/PkLaUIX2DbR/yF5ipS+20Rb0cEDf5Bs2XNqsxxkfDMYgQEy5ZevXJKCBQvr9vbs2SkPHzyQ1m07SoEChWXTpvUSNUpUI6PbR1KnTiPr162WfMbn22eQrcBNFqOwnD513EicX0iLlu2kVu0vJU3a9JLEOPbYRgIMaCOPjsvJkiWXbzv3kE9rfWEk3LFkzmyfTHrJUmWN11Jo5gL7is7iSKTbd+gmH1auJveNm/+6tas0I58gQcJAt7ngT5+2ucg0YJuA/ciTN79+xziv2bLl0CDFkdVzBOhwWaBgEYkRI6Y8Mo6hSdOWUrZcBSlRsoyOToTlJpyDzcY2okaNImXKlHfa/8KVaymkmefxwIG9kjhJUunYqbt8UvMz7SuyePF8vUFnNIJOZzdM3HyPHz8qL168NL6PwpZvqlE8wmRlIxmspI8m/J7wuwno2nTX69pMi5CGOEsrnIko1/SZ06eMNP+UVKxU2UjnYmjm+vs+PTXd/bFvby1MWrpkoXHe50nKVKklQ8aM+j5cC6itbN+2pRFMLtNtzJg2WbZv22rcl173OTmwf58RkPxj3BdKG+fBW4YPHSTnzp2RQoWL6uuAoNR+OdabMW2KdOvcUU4b+7dn9y4Z+ctQefr0iRQsVET7vh09clgG9u9nBK/l5O6dO9KxfRu9z+AeaHr65Il837unBhs5cubS/fhl2GDp36+vnD9/TjZv2iDjx/yq12uevPl87wf09kU2fqcFCxeRXLlyy+NHj408wWopXbackSfyuc9T+BbDQgFNmPo1ItOIUnKUVOFGlz1HLh220nTjxjUtJa9Xv6mUK19RM+BIkL5p11mSJ09uW8uvevUba4KHmxi2hZJb3ITNUYEC22YaW+ACSODWrV0p2bPn0pty8uQpfbf5dYtvNPA5d/aMbW0xEsPcRnCRSTIZN0NsE/uA92TJkl0TdpQcBRdKdDoZmficufLo91SiRGnN2INP5nm9Bl6tWncwEuu0+vko1av9WV0t3XGUOXM24/ib6Lawj1/WbaifgVIrCGybGBrVEbaBjpEIIqz0PQjqHEF647vENnFOsE1sG3/jgX2x9+KFp3Et3ZNEiZIEWNIanGsppKEkEIEQvi/z+8QwluvXrw7w+sDx4LhwfDhOInvuel2Ta+7fvSu7d+6QyVNnyvRZc2XR0lVSsWJl+XPeXC28gksXL8qwIYOM9Ly+LF2xViYZ6y5ZvkYyZcoso38dIY8fP9L1ggMdoxctnC/DR46WGb//ITNnz5O58xfJ3j27tdO3o5SpUmnJ9X6HztqXL1/S4XxRyo3lc2fP0uaZ8xYulakzZsuceQv1MxAcbd2y2fYuCg2obUIhIVFAwlQAgUwwSvcDcvvWTS2ByO7QKQvVtpmNjLkjVJcmTer3ponMp7f369lMrW4TmdnLly5I8RKl/GWKsc/JU6SSCxfO2Za8XYUKF9Njc8bT01MuGfuZJ08+iRs3nm2paKkfghoEBo5Qy2J/TCg9QokPSgUhONu0yso5ehtcvZbeBtTw2J9HfJ+5cueVx48eyc0b121LiazjdR1x1KlbT5ImS6bPY8aMKRU/rCx379yWhw8fatq5ds0qyZQ5s9T45FPtiwYJEiaU+o2aGNdCFi3tDy4vLy+JHCmyESDG1/ML2bLnkGlGpr9I0WL6tz18fuHCRbW2xOyIi31E7QcCizRp0xnB7w3ZunmT1G/YxLeWAtdyocJFpGzZ8jpSFPvTEIUdYSuASJ5CE8KAoOoeJbCOGXgkYOiwFRxWt4mbH/o1xHMo7QY0lYkbN66RAIbOzTGVXRWwIzQjuHf3rm/TI3tx48TVdqauehvbDA2obQkoCHkb15KrHD8botn6xbwIYJhaHI+zWiQicNfrmlwX2L0STY4QTCJT75g+Z8yYSVq2/kZSpEhpW+I69LfInCWrdO/aScaP/U2bHz9+/Fg/C5l+Z3Lmyi3Pnz+Xc7aabQyacfDgfg0sEGDcMYKfa9euyK6d22XK5Am+j5kzpupEoBgNCO3yiShscKsGhaihQGbW2WRDt2/fsj1zjdVtxo0XT9v2o/29o5cvvTTxfJMEOaRoE5fEibU5mKMnT57Iv8EodXob23ybsL/JkibX5hwBTWL0Nq4lVzkLBMwMlpnhcoTjwXHh+HCcRPbc9bqmkIUOywgmnXWqDgmoif7x54EaiBw/dkz+17O7lC1ZVPr26SUPAhjqM1myZFK0WHHZs3unNldCX44nj59oYAG3bt7UZrLO0jW0xS9VuozWjhNR2OBWAUTChIm16vTSRZ9RJ0xoy4nOXcFhdZtoC5g6TTo5cGCfdmC2h6ZNN41MXbp0GWxLggdtQY8ePaSlR8GFEU+SJ0shZ8+c8tOHAM6fP6ulPq56G9t829B/Bm1pUaXvTHCvJcwIjc71ViezC8yB/Xv8fJ+oXcB2EagmSZLUttQvHA+OC8dH5Mhdr2sKWdGjRddg8uaNG7YlIQ81INU+qi4jfxsrK9ds1H4Q6Ae4fNkSpzW/aFNfuAiaMR2Wu3fvys4d26VAwUIaWECy5MklhrHNj6vXkKbNWvh71Kz1GYeEJQpD3CqAQNMdjCA0dcp42b1ru06sg2rPGdMnBXtcfKvbxJCr5T+opBn8mTOm6A0ZI1Hgxjhu3CjJkTOPZMqcxba267C9X0cOloH9+8rWrZtsS12HpgoVKlXR6l4cE44Fx4Rjmz/v9wCrlwPjyjbNjMjBg/vk6JFDWhKKiZDwNx4X37CfCPpr3L59UzZvWq8jSmFfnGV4MHQuMiy7jH10djML7rWEmTh/GTZQR7XBEINv4qxxs50ze4aee7Tt3W5sc8ni+TrkZkInc1fgOHA8OC4cH5Ejd7yuKeQho50uQwbt0IxR9eyhozMmBcPQrY6QyceIdhh1x76/wcNHD40A1KfpEWC7v8+crucYcA9AR+gyZctp8BpQIRiGA0VzpX17d+v9AQEFPhPQ7wFNgY8cOax/m3CfxVC2J08cty0horDArQIIDGFZq3YdKVioqIz+bbg0afSFfNuxlcSOFVuHFQ0OV7aJMcrbtOmkJWytWzaShvVry8ABfSV79pzS/Os2b9SkBKX8SZOl0H+TJH2zUro0adLpPAonjv8tHdu30GOaPXu6NGjUXEdGCQ6r28RwfWNHj5BhQ36WsWNGaLOnTRvX6t94bNy4zrZm8OTOnU8+rPyR/Dl/trRt3US6d20nFy6ct736GjIqyLDgsy9d9P96cK+lO3duaefywoWL+RvP3FXVq38qT4wbMK6lxg0/l4kTxki5chWlatXqGrQ5wnHgeJgRo4C443VNb0eFCh9qIcu4Mb9psICaqWN/H9V+BRjNDs1SHaGJUI5cuWT9+jU6iRgCULx3vLGNgwf229byqZHHiE+/z5yh80Og2RqCCoyUhL4RAdUUxIsfX4qXKClDBw/UvxFQmLA/H1appvNSbNm8UQMYNNlcvGiBHoM3+34RhSmR/nNSPBvSE8m9eOEtIT2eDkq2kbihNMNZp73gsLpNcyIffHUh+fnmqQipm6y5n4BRUd40YwBvY5vBYeVcoWnVkEE/6Y2zS7f/Bdge2JVraca0iTqRV4+ePxg3vDefmRPnHKOhIPOGMd4DCkJRijh0cD8dHatr997aVtgqXE3ROJFcmOVK+mhlIjmTO1zXJvTbcGUiuYh0TTtOJIeJ47p17uBvUq9Dfx2U/j/1lcHDRmonZ0DhCuZvwOhGgIx/jZq1pHXb9hIvns+IevYTySHjj0z7pAljjcc4fR3rNW3eUof1Tp0mjbRo1VbP7769e2TE8CEalAC2Xa9BI10XzZuwP+PHjvbdb9PfR49Ix3atpVGT5lK/YWM/9ztcrwsXzJcxv46QR498ajdwLB06dpHyFSoyAH1HArrmKPyyMpFcqAQQL71eyatXIR1CEAUNs6SOGDFIg53OXXr6GYbWVWYmB2PbN23WOtSCJzQTGDa0vwZuHTt2951Y0arIkSNJ1ChuVdkYobiSPjrO8o5A0nEWele9q+sazab6/9zHTx+qgGatd8Rr2jrUDmCCN1xjCCbNmaQDowHg06fi5e0tMREABlCjYBYoYduBrecqjLb0zHjgPL/LgiqiiCrMBBDeRuLiZdwkid4FBBHIpGDOijeBnwpuxLgJv0lzteBA0zFkFl0NHiCKkdHyMG7EFDa5kj4is4+hME0okX3TDNa7uq7ta3JNVmorgNc0EdHbE2YCCHj58pW88v9RRPQWRTYymFGjsqQ2rGP6aB2vaSKit8tKABFqqXCUKJG03SoRhQ783vC7o7CP6aM1vKaJiMKGUAsgUNWOUiOUHhHR22WW0rLToXtg+hg0XtNERGFHqNYDmzdJtF9F5yjeBohCDn5P+F3h98WMlvth+ugfr2kiorAp1PpAEBERERFR2Bam+kAQEREREZH7YwBBRERERESWMYAgIiIiIiLLGEAQEREREZFlDCCIiIiIiMgyBhBERERERGQZAwgiIiIiIrKMAQQREREREVnGAIKIiIiIiCxjAEFERERERJZF+s9ge+7r9oNntmdERERERBRRJE0Q0/YsYE4DiEf/vLA9IyIiIiKiiCJerGi2ZwFjEyYiIiIiIrKMAQQREREREVnGAIKIiIiIiCxjAEFERERERJYxgCAiIiIiIssYQBARERERkWUMIIiIiIiIyDIGEEREREREZFmoTySHT3v16j95ZTzBR/v/dCJyN9Gjedie0Ztg+hg8vP6IiEJOmJtIDjdGL+9X+sBz3hyJiHwwfSQiIncRagEEboje3v/pv0RE9BrTRyIiciehEkCgJM3buDGiWp6IiF5j+khERO4mVPpAoGQN1fJE4QF+Mrt3bZeLF8/LF3Xqi4cH21+zDXrwuZI+bt2yUZYuXWD7SyTWe7GkRav2kipVatuSiInXHxFRyAkzfSDctWRtx/YtsnbNCnn58qVtCTm6d++u/DF3ply9ctm2JPw79NcBmTjhN/n333/E28vLtpQoeFxJH589+9fILEeXzz//Sr6q11hqffalJEiQwPYq0ZvbtmWzrFq5PMTve48ePZJlSxfLg/v3bUvCBhQIHTl8SLp37SStWjSVnTu22V4hosCEUhMm9wwgTp06IYcPH5RXr7xtS8jRP0+fyqaN6+T+g3u2JeHbjevXZOrU8ZIrV17NwEWLHt32SvC8fPlCjv19RG7evG5bErrwufh87Ae9G66mj/GNgCF/gUJSsGARyZevoLz3XizbK8HDazBsQ+Z2yuQJTh+zZkyTu3fv2tYMGSdOHJMD+/bKK++Qve9t37ZF/tejm+zcud22JGw4fvyYdOvSUWJEjyGFCxeVSJFCdWwZIrcVan0giNydt3FDXb58kbwXM6Y0btpSYsZ8z/ZK8P37778ybeoEOXzooG1J6MLn4vOxH/RuvOv0kddg2HblymWZNnmi7Ny+Xfbu2e3ngeDi+fNntjXDtlKly8qgob/ov2HJxQvnJUfOXNK523fSvEUrKV6ipO0VIgpMmAy1USL35MljfQRUOofq1UePHoqn53PbkoCZ23v69GmA2wOr28Q2sC2sG1g1LzKc+Fz8C2h+ENQ+uAL7Gdj+mvsZ2Pdoz9xeYMfk6jbhXe2nlXMOOD+PHz8K8vOvXb0iB/bvlSpVa0iiRIltS50zr6WQPN9Wr0+T+R24cq4o/OA1GH7kyp1Xhv4ySsZNmOLnMXjYCEmdOo1trbAtXrx4Rtr5kf4b1iRKmEibBhKRdaHSidrzRdBVoWtWL5cjR/6SDz6oLFMmj5WHDx/o8goVq0jTZq30Obzw9JSFC/+QlSuWGhk/L4kcObKULvOBJEmSRM6ePS3tO3SV6NFj6LZmTp8sNT/9XGb/Ps13e7nz5JPWbTpK/Piv2w0HtE3P58/kuXGjNLcJp0+f1P27cvmS/u3hEUWqfVRDatWqo81ZcGMdNXKI3rSfP3smV69elkyZskj6DBm1qc+rV6+MY6osDRo2k6hRg+6kYg837n4//k9qf15Xjhz+S7Zt3ajbixMnrvTs9aOkTZfetqb//cTxosnN4kXzpUGjZpI3bwHffc2cOavcuXPHd3vvvfee1G/QVMqUrSCRIkXS94OzbVapWl1WLF8sbb7ppNuEd7mfuJz/PnpYxo0d6XvO06RNJ3W/aiSzZkzx3SYgcNiwfrXMn/e7b+knPr9ps9ZSsFARP8cOuEZXr1ouvXr/JIkTJ7Et9cvxWoJkyVNIy1btJVu2HPo3XL50Ufr/3EczVo7QPMX+mrN6zYPV39GUyeP02J3p3uN73+/IKnZiDT4r6aPJPL/259xRRLwGw/P1t2L5Ulm+dIkMGDzMSJ/i25b6hfTLy+ulxIoV28+gDgj4/vnnH2N5LON+E9V32flzZ/W8R4kSVbJkySqxYsfW12DCuNFy+9Yt6dq9p0SPEcO4Dz43rlFPiR07jp53k7Pl9+/fk4sXLhjps7fEjRtPMmXO4rs/SG//+eep7iPSb8f9MjluF+tevnRJ7t69bfztofePRIkS+UufnXlm3INxrCi8Q41xZmN/cExg7s+6tWvkyKG/pG27jhIjZgx/x0kUEVnpRO3R12B77svzZci2fcQoI0E5Z9yE9u/bY2Q4D0qlD6tJ86/bStGixTXTmTpNWl0HmcMFf841bjqrpFHjr6VZ89ZSqlQ52bZtk+zetUOSJk0mxd4vaSSKUeTWrZvaAfrixQvGui0045gxY2bZsnmDPHhwX/LnL6SJRGDbRP+H5ClS+m4TbUMHD/xBsmXPKZ2+/U6DkwxGYIDM7uUrl6RgwcK6vT17dsrDBw+kdduOUqBAYdm0ab1ENRLq7j36aGnR+nWrJZ/x+fZBjBXISGMUltOnjhs3gRfSomU7qVX7SyODnF6SGMce23YTQDv94cMGSLJkyeXbzj3k01pfaEI9Z7ZPIFWyVFnjtRSaEcC+orM4EuX2HbrJh5Wr6U1g3dpVGmwlSJAw0G0u+HOO3rxKlS6n24R3uZ8nTx6XYUN/1mXI1GCbOHfTp07ws02cp/XrVun+f1WviZ73qtVq6L7PMwKKrEZGK0mSpLpNwPqbjWsnatQoUqZMed2mMytXLjUCxbXSqnUHafZ1aylXvpJ2MN+5c5sUKfK+byYrarSoktEILJFJwrVfvERpqf3Zl1KiZBldhgAlqOvT8ZoHK78jQMfbAgWLSIwYMeWR8b00adpSyparoJ+fPn1GXe6KKB684QaXlfTRhPOLtM3+nDuKiNdgeL7+zpw+ZaSlp6RipcrGd+Jz7hzduX1bOndqZ5zb6JIlazbNXL948UJ+HTlctm/dbJzbUppRP3f2jK43Y9oUuXDhvCxcMF+WLF4gWbNml5QpU+m2Duzfp5n7kqVK6zlds3qljPl1lBEwlvPz+fbL8bn4u22r5sZ985Ac+uugTJ44ztjvk1KocBEt7EEQ8H2fnsa1lV88jOuq53dddRAKNB8yIbgZNWK49ksoUqSo/GsEAL8MGyz9+/WV8+fPyeZNG2T8mF91v/LkzRdgRh/XLGqL27dtKX/Om2sEuWdk5vSpsm7NaiNtzy7JjYAa+9OuTQtZ+Oc8475xQl8/dfKkv+MkiohiWCiUCVOpLjL2KH2u8UltvSllz5FL3i9eyvaqkeG8cU1Ln+vVb2rcFCtqBhwZym/adTYShOS2tfyqV7+xkYAVlXjx4uu2qlT9WG9wKHmAwLaZxu5mh4Rt3dqVkj17Lr2BJk+e0nebX7f4Rm+WSJxNOXLmNoKLTJIpc1bdJvYB78mSJbsmbiilDy6UkHQyMtw5c+XR76mEceNHJhx8Mrrr9WaNDETq1Gn18ytX+djIHNTV0hxHmTNnM46/iW4L+/hl3Yb6GSi5gcC2iWFMAxLa+4kSpS3GNhEo4hyZ20QtyWeff+Vnm/fv3dUAs+5XjX3Pe8KEiYxAp45kyphFt4PtmV688DSuz3uSKFES3wyYM3fu3NZMEpocoMQLx9useRtp1qyVlryZ0PEVHWDzGDdTrIdrDZ1i8cDN3Cy1C841H9TvCNIb1yY+C5+Lz8d+mJ+PzyD3xWsw/EEhypPHj+Thw4d+HmbNacpUqaRVm29k1szpGhjAju3bNCNfv1ET4/uNqQUuyJyjdnXVus0yaepMWbR0ld4TR40YJtevXdP3BcfNGzdkzqyZ0qV7T5kzb6FMnTFbFixZYVwHD2Tr5k22tV6LFz++9jX46+ABrSUw3b1zR44ePSyFjeAB5s6epU1H5y1cqtvEtoePHG0EtPNk65bNuo4z+A4GD/hZj23Nhq36XvxbvkIlGT50kB5rmrRpZdK0mdLnh35S89Pasm7jNhk0dLjEjRvXthUiCkyYCiBwo0PpfkBu37qpJQ7Zc/hdBxm/zEbG3BFulkmT+r3B4Ubl7f1KM7BgdZsIOC5fuqAlOdiGPexz8hSpjETrnG3J21WocDE/GQF7np6ecsnYzzx58mkVsgklUghqkOF2hFoW+2NCSRVKeMzmD8HZJoT2fuIcXTTOgbPPzZEjtwYrpmvXr8qDhw+0xuHgwX2+D9QyYZuorUDQ6Co0szpx/G8ZM/oXbcaBQBG1KijpDc58Ea5e8xDU74jCN16D4c+e3bvk46qVpGzJon4es2ZMta0hUrRYcSn/QUWZNX2qnD1zWl+rW6+B1pLDrp07tGah7lf19XoABBZffFlX34vXggvNp168fKHXhFkrgFL+kb+NlRo1a+nf9pDOFyhYSM4Y+3n92lXbUpHjx/6WhIkSGfeAnEbgekODj/oNm2jNPWDbqNEoW7a8jhTlLI3GvX392jWSNXt2aWgLngD/1mvQULePoVrxW8C9B7UNuJegbwb+NvefiAIXtgIII8Exf+zOoOoepb+OGXgkRkisgsPqNh8/eqT9GuI5KRlDsxaUWty4ETrDIKYKpNMcMsT37t71bdJjL66RgbZv62pVcLcZ2vuJGweCQ2c3AFxXqGY3Yf6Kly9eantt9JGxf9y+c0vix09oXAO2le2gFsMMPp0pXaa8NrF6+OC+DB38s7Rp1VhaNK+ntR32NRpWBeeaD+p3ROEbr8Hwp9j7xWX5qnWyZcdePw9krk3IENf+/Au5f/++tPq6ieTMlVubPeE8AUrys2fPIQkS+k1zMSBE23YdJEvWrLYlrsP5Rq1Bz+6dZcTwIbJj+1atTcA1EFDQmj59Bp0AESNJAZpc7d+/V9AUGIU9qEm7du2KEfhsF/uha2cagREm8bx584b2l3CE/joIerMZx+p4H8F2Ubt2+vQpLcQiouBzq1AbpVrIeKJDlKPbt2/ZnrnG6jbjxosnaLuPtrqOXr70ksePH0uKFCltS94d3OgTJU6sTQgcPXnyRP4NRimTu2wTndJxnpydy0ePjQDQ1mwNcNNEh8Ru3/WRocNG+3u0at1e99GE58mSJtfmHPZV7o5ws0ZztR/7DZHpM+fLiFETtJP33Dkz5Mzpk7a1rHsb1zyFb7wGwx8M1hEnbjxNs+wf6FtgDzUA7xcvoQUpZcuVl2jRfDpCIrOM+SLixourpe0hDZ/TrsO32tEbBWmDB/4sFcuXkg7tWmtnfWdix4mj/Sz22/pcoB+H2WcC1/Ctmzc1w2+fDpsKGuuUKl3G6bGgAzaCXnwXjrBdD4/IPnNcBFIQRERBc6sAImHCxOLl5SWXLl6wLfGBITjPnXvd/8AVVreJKt/UadLJgQP7jIDB7yhVaNp008hYpkuXwbYkeK5duypHjx7SEpTgQil78mQp5OyZU9qkx9758z4jb7jKXbaJ0i4039i9a7vWMJhQ6rp96yYdFcuEdtlw8sRx/dfk049ig5wx9ssR2nGjFO/undu2JX7hOkIp784dW/Vv3KzQEbt6jVp6M7sRjIm63sY1H1yYeRsDC3DSr7CL12DEhs7H6BT8QYWKMmvGdN90EOlt4sSJNYh4WyXvCCJKliojg4b8IouXrZZlK9dqJn3O7Flau+BM3nz55erly3rvO3TooNZIZMiYSV9Lljy5xDDS9I+r15CmzVr4e9Ss9ZnviEr2MBwrgt5rV6/6qy1G4PD8+XPtoB85GM35iOg1twog0CQGo+hMnTJeM4lIlFDNOWP6JM3YBYfVbaJ0u/wHlTSDP3PGFL15IrOJG9m4caMkR848OmRdcGF7v44cLAP795WtRmY3uJBhqFCpilbv4phwLDgmHBuGKw1O+0532iY6YWOovz7/6yorVyzRkZsG/NxHh4u17wOBkZhKliqnpbL4TLSlRQnrqpVLZdbMyZpRcYTheFELtctY31kzJlTVo9MgmkHhOsH1gW0iIEGtirMAE+1vkyZLpqPmoP8G+l7gYXob17w99Cu5ffumbN60Xj8X2w4oY4aSxF+GDdTRd/AdU9jDazDienD/vkyaMFaqfVxDOnXuZgR+CWXJ4oV6DQBGHzp08IDcuO43iMTgHx3btdF+E86g8Aw1ws/sJvrDNjE6lAnnZerkiZqeA9JidLSvUu1jHdY1oEkC0bcBTaf27Nopfx3Yr/0izKZveA1Ng48cOax/m/DZGNrWsfDHhKAiV+48cvTIISOAumdb6uPmzZs6ylSOXLneSk0MUUTiVgEEbo4YJadgoaIy+rfh0qTRF/Jtx1YSO1ZsHa4zOFzZJoY2bNOmk5EA7ZHWLRtJw/q1ZeCAvpI9e05p/nUbp1WtVqGEKKmRqcW/SZK+Hj40ONKkSadzXaAjZcf2LfSYZs+eLg0aNReMXhQc7rJNlLJ27d5bx7FftPAPIxiYYtygckiHjt38BBC4wdWq/YVUqlRVxoweIY0bfi7Nm35l3HDn69wSONeOEiZKLBj7HhmtSxd9Rjqxh23W+KSW5M1XUAYP/FGvD2wTgUyTZq10VC5HuGbq1GmgwxX26tlZ2rZuIr8b+4wSX3gb17y93LnzyYeVP5I/58/Wz+7etZ3vKC6O7ty5Zdy8vaRw4WK6XxT28BoMn1Ajixm7MTyu/QOjGKH5D0rWESzAJzVrafMgjL6EYUv37tmlywsWKizp0meQkSOGaqYeGXFk/CeOH2usHzvAJrgYUhdB6OJFC7SgC0048Xze3Nm2NXxG9MKQvhPGjta+DyhgwbZXr1wu2bJn9+207QiZfQxMMmXSBDl27G8jgChse0W0ieuHVarpvBRbNm+0FfL4fPa4Mb+Jt5OR+kyly5bXf4cO6q/7YR4rRptCJ+oSxmcSOYMgeMWyJXqthSRcf7NmTNNawMDgOl9l/G62BTLKWFgRKhPJvXjpHeLNDZGgoSQM1aaOnfuCy+o2kRih2Q2+upD8fPNUIBMQEsz9BIxKFBI3XHfZpiP8eAcP/km++eZbbYpkD+27Ua0NuBEGVjKFG/mQQT9p5qpLt/9pwOKMeS3hXFo5Jivfwdu45k1Wtj1j2kQd1adHzx+Mm7vfifQ4kVzwuZI+WplIzhSRrsHwPpFcz+5dbH/5lS1bdhk8bKSRKbkjgwf0k569+0r+AgX1NdxPVhrvnffHHOnXf5BOqInMC+aGWLzwT10HKhuZdNRYpEjpE0A4TiSH7Wxcv06GDO7vW3uB5kMZM2YygoadvhPcnTp5Qn77dYSfYVuxXsdOXbTjNoKWgQN+ku969Jb0GV7XhKGpUfeunXReB+wHzr8J1wPmqhhjbPfRo0e6DO/t0LGLlK9QMdB7JdL8X4YP0X03Vf+kpnzTvpOfzv/4flH7YR4v+YfBQ44eOayBHJrJxTS+J/SzqlDpwzDR9zMk4fof/etImT5rru9vKSRgSOX+P/XV36v99e8IAwMMMQJf1Aq3aNXWtjT0WZlILlQCiJder4wLMIQjCCInli9bJAcO7NWJ/szhYXGJI+OFieOcZX5dhUm5RowYpJmszl16+n5OeIYgC7OBY3x+zNTtmLlkABF8rqSPuI5nTJ9k+8tnVBnH2d3Dq8CuQV5/1iE9/OfpU/EyAsYoxneIkYqsFFohY/PMeAT2HmQ0nz59otczAgHHTt7BZX525MjWgmFTcI+VXkNJPJrGzfl9po4Ghvllnj9/psEjgjTM/fHRxzUsnxOrNm3cIFu3bDKCyq6heo9FDcSRQ4d0EIKQDCgZQAQTZlr18g64upEopFy5ckkGDfhBZ7z+/POvJH6CBLJn905ZvnyR1KlTX2fGDYkbCIII1EZgzoqIAMkEMgbIFDgr+WYGLvhcSR/ta8sA17IrGSp3Ftg1yOuPKOShadyM6VNl/bo10qNXHx0a2Lx/onYITX3GjxstPw8YoqNnhSTUDC1fusS3hsvdhccAwqOvwfbcl+dL18cKDwwuOEQp/kMVopCF2cELFCyizRwWLZynI9KggyZmsC5XvlKIlT5huFiMbhNR4HtD/xxMsudMFA+36k4VpriSPuL7R6dn84GMdESZ+Cqwa5DXH1HIO3/+nIz5bZS0bP2NFC32vp/7Jwot0mfIKBfOndPRvooUKaZBBQYgwaAz9usiU+y4HDOjnzh+XOf6wBxbKOxDWoZaLBTOnT51SjvqY1hivMf+vegngE7/Fy+cN+7vtyVOnDh+mr6hOSYKG6JEiaoDM+Bz8Hnx4sbT9AO1Upi08OrVy7qO/Xwh2DaacuLzAOuifxgKbuwfL154WjoeE2o2du7cLpWrVNX9M9fFaGAoBDK34+3lpRMdYp/QTMyE7+XSxYty9uxpHQwgqnG8GHDAfF9Ii2GhUCZUaiAAVZpe3v9pKRIRhS8sAX4zTB/fDK8/opD357y5snHDeuk/cIhmiJ1BkIGaCoxCuXLFMqe1Bva1CZjxe83qlVoanyJlKm3mhv4zGAL4u169jcAkivTo1lkz0aYSJUv7bhOjhv3Yt7cGF1myZtM5P6Brt57yQUWfQkKzv03BgoVk7ZrVRgY9lq5fzAhGPv/iSxk7+lcNJJDpx7DG/foP1okQATUF48eO1s9DXw/UBsw3vgdH5j7FNYKXlSuWy+CB/bSvD/pF4njy5i8gPXv18W1eiu2OHT1KJ3ecPGm8FkBiUALMf9K+Y2f5vE5dDcqc1UBgoAT0XVq6eKFggkSManbl8iV9vUGjJm+lBtpKDUSoFdug7WIUj0j6LxERvcb0kYjCEgQF169f087y9iX0jvB65ixZLZeE37xxQ+bMmql9J+bMWyhTZ8yWBUtW6PDT6ICPoXsHDR0ufX7o5zsDO/7GcgwCgJnOM2XKLCtWb9COzktXrJWWRkZ6xC9DtYO36b6x7tUrV2TytFm63vRZf8g14+8Rw4bIdz176+fOnb9YR+TCaGHIuDuKFj26dPy2q5/Z3xca+4r9KlKsmNZ8YMS4aVMnSfce/5NFS1fpdjEPSozoMWSZETThezSh3wj6dUyaOlNmzp6n62PelN9nzTCWOx91Ce+fO3uWDpk9b+FS3T6+t+EjR8uCP+cF+L7QEKr1vrg5Ro0S2Yj8Iuvzt1TzQkTkdpg+ElFYgaY8jx89CvHZy728XsqLly+0pN5s4oNRsUb+NlZq1Kyly9BpGk00zRnY8TeWoz/js2fPpVWbdlraD2i69FH1T3Rm8g3r1vjJsH/yaW2t8YA0adNIrjx5pVSZspIjR05dhiZAhYoUlWvXrmknfUcIijAkMmo+8EATyj/mztY5Sup+1UBL/lOmSi39Bw2VSpWr+h4Pag+qVvtY/j56RB4/eaLLADUh9Rs20fcD1sds7FWqfiQ7tm1xGsTcMAIuBFaO70Ofk7Jly8uBfXv1XL0LoRJAeL7w9vPwso06wtp6Cq+Q+UMmEJlBNK8I7w8KvvCYPob29R9ReBvXBUbteuFwzYT1B/YX+439J/fi7f0qRJtWJjOCBTQX6tm9s9Ym7Ni+VecOQWY+qKY4KIXPnj2Hb/BgQhCBDt5opvTUNhQ12G8vkvGfh5HxRmASnFnIEZj8Med37TuBOVbMCQ/xb5YsWbVZEZopHTywX5tVYR4TR9hH1NjYw77kyp1bLl68II8fP7YtfQ0Ta6KvxK6d22XK5Am+j5kzphrvOa99K5wFHqEhVGsgiCIKpLfart24aXIYY4poeP2HLGTgXr589Tq4tC13F9hf3+vBOA729Qn7MIQpStJv376lo7+FFGT223X4VvsP3LhxXQYP/Fkqli8lHdq11mFhA4K+CmjCFFCNCErlvby831pac/DgAZ1XBU2a7IMADHM75reR8mn1qjLyl6Eyfuxv0qj+l9KscX3bGq+h0zU6PzvC0NSo7UFfB0e3bt7U4bqdjX5YsHARrXl5V7OqM4Agesv0xun9HzNRFCHx+n8zZvDwKpxkunEcDCLcQ568+eWQkXHGZH/O4BzOnD5Vhg4a4FIzGgQR6DSN9v/oL7Bs5VotdZgze5aO5OQMmg8lTpxYJzl0VuL+7N9/tYkQ5vsIaegojuCgcbOv/Q1Xi2ZVWzZtlAmTp2v/hPGTpsmqtZtkxK9jbWu89q8RIGA/HSFIwPxUzjqqJ0ueXGLEjCkfV68hTZu18PfAZI3vagJEBhBEoQAJLarvec+kiIjXf/B5eblfjUNQcDw4Lgrb0FwofcaM2u4fJe2O0IEYIyoVKFhIS8GRgXfMJGPIUjQtMqGWYerkidr0BtDPACMVVan2sY6ehKZAAcmXv6AcO/a3XLt+zbbEB0Yz2rN7l2TNlj3QDt/BgSFqR/0yTGc+x6ztjp3FT586qX0r0MfChCFX/z562PbXa4cOHdQmUPYQMGE5Oobj+3OEfg/oQH7kiN/t4XvF6FYnTxy3LQl9DCCIXIR2h6N/G66JlitQAstSWHJ3uHHNmT1ddu3cpoGBVbz+XYegK7zUPDjCcbFPRNiGvgb1GzTWUvY+vb6Tvw4ekIcPH2qmeuP6dfK/Ht20XX+JUqV1/fTpMxqBxr+yeNECvT8i6MDzeUYAYnrvvViye9cOmTB2tPZ9QBqCoAIjIWXLbgQAtkx04sRJjADlnOzds0uuXLmsn5s3X37tAI1mT8f+PmoEoV5aIzFpwjhtDlWlashMFGtCTcfEcWPk6tUrmpH/6+B+2b9vjz7wXaDJUY4cuYy/92oAg7QRx7xsySJZvWqFbSuv4djGjvlVtmzeqDU2+I4ww/f2bVul6sfVnTZFQl+KD43AZcK40b7vM7/XcWN+M35D726SZgYQwYAfyKKFf8jyZYv8tQ00Xzv29xHbEnInSMwOHzooO7ZvsS3x77nx4z1x/G+ZOP43Pd+uCK+ZAYo4MNERJoWaOOE3OfTXAdtSa3j9uya8B1wMKMM+NNkZPHSEeHl7SeMGdaVsyaLyQZkS0rdPT22G1KFTF98OxenSp9dJ55YsXiClixeR9wvnkyOHD+kyU+IkSeTbLt3lzt07UqFcScmfO5tUr/ahJEyUWBo1buabiUawUL1GTenbu6d07vCNPHzwQD8H/SdSpkgpXzdtKIXy5ZRKH5TWmpDe3//oO+dCSMHITJcuXdIalK7fdpBmjRv4Pgb0+0HncMAEe9hPzF1RMG8OPeaTJ09Ij17f27byGmpQvu3STaZMmiCF8+fS72jZ0sXGur0lZ85ctrX8QkCE7det11B69+yu78NnzJg2WTp92zXA94WGUJlIDqMwuOrlyxdaNYToK3nylLalYcOjRw+l34//k5s3r0uHjt2kcJH3ba+8fq1ipSpSucrHtqWE7+re3btaxWjO8BjWvPD0lNm/T5MNG9ZI+Q8+lKbNWtle8Q8lEb+OGmKc4+ryRZ16lks9sFq0qBFn1BgKWnDSR3iXaSQC5zG//SKXLl+UHj18JoSygte/azB6UUhnscPSvRWpZrQINIqWu0PzIrOPAkrTA+q8i5J7ZL7RHwFNipzdH9HMB7NFI4hEnwhMKOcMPhOjJzm28zf3BaO9xY4dRztRv0vm/gR2zCbUVGC2a8As1FYngjO/VxyzK+8LjjA1kZyrcDKmTZ2gpcFhFX4Aq1ct870QKGA4jzifOK9hEQKcH37oKfsP7NUxp4OSv0AhI3CoL+vXrdJqVqtYAEsh5V2mkTFjvieNm7aU92LGlOXLF+kN0Qpe/655G19XWLq38nJwL8jkm3MiBDbyDzL7WAdzKASUkUaGH/darBdQ8AB4zVknYXNfzDki3jVzfwI7ZhMy/thvPFwJAszv1dX3vS2h/q2j/RZK6Z8+fepS+9nAuLJNc92QGJasXPmKcvfeXTmwf69tSeBc2U+8/uTJ4yDXxY0b7eiwbkh9n1bh87B/OCYcW0hB6aaVc2R+fkgc+5HDf0natOnkp58GS/oMGW1LA4YEokTJMpI0WXLZunlDqH/3FH65SxqZKFFiqVK1hqZ/GJ+d3i13uW6IKHwItSZMaB6ycOEfsnLFUiPT66XLMaFIy1btJVu2HPo3oDNN/5/7aKbQEUp923fo6jserrNtpjEygU2btZasWbPr30jMRo0cIvHiJdBOMH/On20s8zSityhSpuwHUq9+Yy1NcwUSSTRTqlCxsvH8kRz7+7B07d5bx+o1X7NvwmRlP+HIkb9k5vTJUvPTz7UpzcOHD3R57jz5pHWbjkbk+XqILwQOG9avlvnzfvct1cfr2GbBQkWCjIDf1OnTJ2XK5LFy5fIl/RvfZ0Xj+/iybkOd/t00ZfI43U9nuvf4XvLmLWD7S3TylYnjf5UTJ3ymo0epQvESpaV+g6YacQO+IzSdaNykhaxauVTOnj2ty9HhqkXLdpIrd17921WoRULnrhcvPPV6SZQoSaBNmEyLF82TnTu3Sc9eP/o5P4GJSBNfUdDMJkzumEbevXtHfv6ptxFIfGy5ySavf+usNG9z93srrweisMdKEyaPvgbbc1+eL4PXJjcg3t7/yUojs7dp41pp1bqDNPu6tZQrX0muXrmsma8iRd73TbiiRosqGTNl0YzlOSNziAxk7c++1NJeLENGERlLtOMcP+5X2bd3l3zdoq1mKD+o8KH2lkemOmu2nJIkSVJN/Pbs2SkH9u/Rzq8dO32n28uQIaOROC4RtMHLnTufbhOZ/969usj0aRNk4YK5/h6xY8eWzJmzasK5dctGyWTsJ/Zr44Y1Okax/WsZM2XWv63uJyADvXbNCp2RsFHjFtKgUTPJmDGzbNm8QR48uC/58xfS/UTMh6YzC/6cI1/VayLNmreWqtVq6GfP023m8N3m23DPyDSM/GWQZM6STTp920M++7yupEmTVpYs/lMSJEjopwQ/QYIEUqBgEYkRI6Y8MgKiJk1bStlyFfR7w4gNWA7379+TX4YN0LaD33buIbVq15F8+QrKRuOawahHBQsW1io7fEebN62Xo0Yg8WHlj/QmiUAOy9GcLGeuPL4Z+TWrl8v3vbs5PZe7d22XYu+X0FkpAW0wEXSZ1wuCiQLGZwYFU/Jv27pJihYrbjmAiOLBsQvoNaSP4A5ppCP8Jo8fP2oE3i/192Kl4ILXv3XmtREYd7xu7PF6IAp7YlgI7EMtgMCoNh5RPKTGJ7W1Jz0y40hcsmXNLkmSJvNNZNDBNnnyFBIvfnwdJrBAgUJSunR5SZEilVaZm+udOX1SS3+RgUTmDRlBdKTBxCfnz52Vy5cvSsFCRTWzjUQOJfadOveUlClT6bqpjQwvEkGMpISMKj4PQQAS1WoffSIffVzT3yNzlqwSJUoUP0FC3nw+Jejr1q6UQsbnYVpy+wDC6n6ameOdO7Zqol24SDHf/fTyeqkZ5veLl9Kbwf17dzXIqf1ZXW1GhUw4SnqyGBn6UydPyO3bNzXTHlTCHVwYeg0djT+p+ZkGUWgLmTp1Wv0u0qVL76fUKb4RUODc3blzS2srPv/iK+MGk0mXmcEDrF+3Wq5du2rchLob5yWZHjuui4QJE+nNKHee/Poc39H2bZvl01p19Jz4XEtxtObh76OHjO/mnuQzAi1kZBDUoFTU8Tzige8NNUaOGR5XAwjP5566Pzj2ZMlS2JYGjjdMsmdmEt0hjXSE9BBpzv37dzXNwt9B4fVvnZUAwh2vG3u8HojCHisBRKj9cpGZxtCXY0b/os1QUNqPXvwoEQlOZxB0XE1uJHzZsue0LfGBzGvxEqXk8qULfjo3o1QeGVB7mYx9Qob80qXz+jcyk8hUxosX3+nDLMlxVLRocZ2efLuRkDu2CHN1P9GzPmnS5La/fGBdb+/XM3deu35VHjx8oIHMwYP7fB9o+oMbOJo+oT3q24KxoZMaN6aJE0Zr5v66sT9o+oMahQQO37EVOI6TJ49JvLjxtEmS/TFhvOlX/72Sp3bV7piVEQGDfeYf3xuaep07f9b4Pn2mg8f5cnYe8XAWPBC9S+6QRlLYw+uGiN6FUAsgSpcpL+07dJOHD+7L0ME/S5tWjaVF83raZAclGK7CpCGYnS9qVP8lXvHiJ9BOX48fvZ7oK1q06P4SU5ScI8Nt9iFA1S3mb7DPwNo/MFKPM8g0V61aQzZtWqf7Zc/V/bQCmeqXL15qEx30lbB/3L5zS+LHT2hkjm0rvwXIfHfq3EOKvV9Sli1dKF07fyNNG38p/X7spTUErsLQZw/u39cbl+PxrFu3SptFIUAzRY0SVaI5GQoWNzhUpaMWAXC+nJ1HPHCecb7fFOaIdQwaiYLDHdJIR7j2MRodvTvueN0QkfsLtQACpb2FCheVH/sNkekz58uIUROkTNkKMnfODK0ydVWKFCnl8ePHRibQJ7NoD23tUY0bN97r4Thxk3PM6OHv//57pcNvwfPnz2XZsoX+MrHmA2NnBwTHljhRYtm8ca1u0+TqflqB6mYM5dXtuz4ydNhof49WrdsHWFsSUpCpb9iouYwdP12mTJsrXbv9Tx4+eih/zJ3pcu0H+h+gVgN9I5wdDx65cr3uHK3nzckAgDjHqJ1AJz7A+XJ2HvHAecb5flO3bt7Qm6djCRyRq9whjXSEGVFv3LgmyZImf+tpDjnnjtcNEbm/UAkgMN04SkPQvh+Q4KGNZPUatTTjdSOAkv3ApEuXQW4aNy5Up9pDqfKBA/skdZp0Wo1rOn7siI4YYu/UyePy5MkTSZU6rf6NkvXvevR1moHFAyNLBARNaCp9WE07rtnXQri6n1ag+RCcPHFc/zWhtAkdrs+cOWVb4hdmjz18+OAbl75jNI8/5s7yHSUKGYf8BQpLhQqVjWO9bmTMn+lyq/D+NMb3cPToYR2S1h6Gh0TNDvbdhM55mAHX/qaFKnV05sNQrGgHDDhfzs4jHjjPON9vAp9//NhRnUQrYcLEtqVErnOXNNLR3Tu39TeaPce7mw01InPX64aI3F+oBBAooX3w4IGW/B49ekgzuhjrH5ldJDJIsByhM1bSZMl0dImLF85pZtXMsEKmzFkkR848Mm7cKM0QY5vIfM6cMUU/o/wHlcR+xmM0rZk6eZzcMW54SHSxzswZkwVDnjr7/ODAUHhmp2qTq/tpBTrrlixVTkuYMJoQSvzxfWJY01kzJ/vJbNtDxv+XYQNl27ZNEjmy621jTaie3rFji/w5f44eCzLS2PaWzeslQ8ZM2gHZUfIUKbVzN0ZQwnnEebAPYsqWraDDC86YPklfQ6kWtjlmzAid9dmxinzJ4vmy3TgOHDv2Yc7sGXLJWL98+Ur+1g0KzgmGpUXTJgQmmDIfGSOzuVNATdcQLB38a7+OjsWSNnoT7phG4ne/y0h/UCKNwRQo9EWUeysRhT2hNg8EEjUkQNu2btTMIWBkhybNWkmxYiW05MQRMpBDh/6sw4ZCiRKlpWXrDr4jfSBRmzVzio4oYW7TcS4EdNDFWNXI1MYyHhg9COtixAnHOQascjbXgwkl0oMH/SR1v2ro+5qV/QRzjgPMKZA2XXpdBujrgFGK/tenn3YABmS+ly5eIEuWLDASeJ+qZmRicTyovnb2feK7nzD+N+nQsZsULvK+bWnw4MaCTnvmjQffZ8GCRaTZ122cfp+4CSHgWb1qmX4HGPHqu54/+JkH49KlCzLWCBjMuSXAcQ4M8zvCXBkYvtC8Npx9n1aZ1wiCB2fQVMvxPON4ZhrBDvanh3G+UOpnFcc9J3vmWP/ulkYi8zlwwA86hDRGALL6u+P1b52VeSDc/d7K64Eo7LEyD0SoBRAmJHboNIsECM1+giotRkbNHPEhoPUD26aZyJkTg5nrot09Ot2GJleP3Qocn9mWHwk5agcCMmPaRJ8Mr5FxT5Q4iW1p8JnnBpeQ1e8zqO8f20ITJdyI0JcBVeX2N0D7ICtV6jRBXhtvA/YRw/b+PmuqNGveJtCmbY5wKNGihs5+kntwzCS6QxqJeVuGDu6nGU5zEk0reP275oVxbfi7QQfAHa4bR0jZozGAIApzrAQQodaJ2oSEBaXoKJkIKoEDrIN1A1vflW2a61pN4EKSq8duBfoPYJt4BBY8ILG/dfumYGg+zM0QEsxz48r3GdT3jxsVMiNYB00j8HdArFwbbwPm+UDwgHbGJUuVtS21JrDjIQJX0wkrvwNXthnUbxSl0yNHDNZJFDH7uyt9iXj9uyZSZOvfV1i/bpxx5fiIKGwJ9QCC3g0MtYeZStEcx8rNhQKGCbPwXWIyO1e/y8jMQJGbQ2byyy8bSMeO3XXSMFfw+ndN5HCewQ7vx0cUnoX7ACKS8V+8eAkkTpw4tiURk1myjxoLd4b5H5IlSy4etra67wKq8tHG1+XgwbhZ8oZJYU1w0sgcOXO7Hjzw+neZB76zMBp0vem9FceF4yMi9xTqfSCIIiK9WXowA0X+RYT0kdd/8OEW/fLlK8t9IdwBroKoUSOzSRtRGBUm+0AQRTTINDHzRBEVr/83g0w2MtvhpfkXjoPBA5H7YwBB9Bbg3ogMUxSPyPpg5okiEl7/IcsMIqJE8fku3e3bxP7q9WDsP4MHovAhVJowERERERFR2McmTEREREREFKIYQBARERERkWUMIIiIiIiIyDIGEEREREREZBkDCCIiIiIissxpAMER1oiIiIiIIharMYDTAALjdhMRERERUcRhNQZgAEFERERERG8WQEQ13hw9qofbzXZJRERERESuQZ4feX/EAFY4nYna9MLrlbw0Ht6vXknAaxERERERkbtBnwePyJElapTIEs14WBVoAEFERERERGTPUqjxijEGEREREVG4Etw8PpswERERERFFQCHahAlLPF96ywvjwbiBiIiIiCj8QifqaFE9fAZRsjCKktNQ46X3Kw0gGDwQEREREYVvyPMj748YwAqnAYSXxTcTEREREVH4YDUGYABBRERERERvFkCwwzQRERERUcRiNQaw3t2aiIiIiIgiPAYQRERERERkGQMIIiIiIiKyjAEEERERERFZxgCCiIiIiIgsYwBBRERERESWMYAgIiIiIiKLRP4PlK4zhjPbofkAAAAASUVORK5CYII=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 481,
     "status": "ok",
     "timestamp": 1728660210947,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "vpdxxDc1K0QI",
    "outputId": "1d6d497d-3ac5-4c68-f8b0-a7b3d1e3e5a9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "82\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "# Set the seed to a specific value\n",
    "r.seed(42)\n",
    "\n",
    "# Generate random numbers\n",
    "random_number1 = r.randint(1, 100)\n",
    "random_number2 = r.randint(1, 100)\n",
    "\n",
    "print(random_number1)  # Output: 42 (or another random number)\n",
    "print(random_number2)  # Output: 99 (or another random number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x4Fi4wRiLZ08"
   },
   "source": [
    "**random.seed()** is a function in Python used to initialize the pseudorandom number generator. It sets the starting point for the sequence of random numbers that will be generated.\n",
    "\n",
    "**Why use it?**\n",
    "\n",
    "**Reproducibility:** By setting a specific seed, you can ensure that the same sequence of random numbers will be generated each time you run your code. This is useful for testing or debugging purposes.\n",
    "Control over randomness: While the numbers generated are still random, setting a seed allows you to have a certain degree of control over the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 497,
     "status": "ok",
     "timestamp": 1728660328136,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "XKCIM1QRLZDx",
    "outputId": "6c606adf-e881-48ac-b1a4-738d9c0a5dcc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.025010755222666936"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random.random() is a function in Python used to generate a random floating-point number between 0.0 and 1.0 (exclusive of 1.0).\n",
    "# This means the returned value will always be a decimal number greater than or equal to 0.0 and less than 1.0.\n",
    "\n",
    "r.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 516,
     "status": "ok",
     "timestamp": 1728660347265,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "1hI8GQOiLZJh",
    "outputId": "7ca57606-0ea0-4a58-aeec-2ee1a466e6c4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.28"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(r.random(),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6CqyWcXWL6uG"
   },
   "outputs": [],
   "source": [
    "a = list(range(0,99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 431,
     "status": "ok",
     "timestamp": 1728660677906,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "w2z4fPMRL6xw",
    "outputId": "d010df7d-733b-4d3e-cf78-98c3879327c8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[85, 49, 81, 72, 58, 31, 43, 69, 41, 8, 96, 70, 51, 37, 34, 57, 15, 21, 42, 18, 6, 14, 9, 39, 66, 29, 45, 12, 94, 59, 53, 23, 26, 82, 10, 47, 74, 64, 13, 17, 78, 22, 4, 84, 80, 86, 3, 0, 60, 89, 93, 91, 87, 50, 16, 73, 98, 36, 65, 2, 62, 52, 54, 61, 79, 5, 76, 25, 68, 30, 67, 1, 83, 11, 95, 27, 32, 40, 7, 71, 46, 35, 92, 19, 90, 44, 56, 97, 33, 38, 88, 24, 48, 77, 28, 55, 75, 20, 63]\n"
     ]
    }
   ],
   "source": [
    "r.shuffle(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ScwZ158iNQsm"
   },
   "source": [
    "# OS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nRHGBrwqL60u"
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 505,
     "status": "ok",
     "timestamp": 1728662103963,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "zN9oqvYsL66q",
    "outputId": "38fe50a1-4d3c-4df8-af81-a4312c214cb2"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'/content'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 141
    },
    "executionInfo": {
     "elapsed": 11,
     "status": "error",
     "timestamp": 1728662128754,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "xJtdERLYL6_x",
    "outputId": "b121402e-bad6-4da0-d81b-4f9ca44d4883"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "mkdir() missing required argument 'path' (pos 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-106-6dd48f39a3ce>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: mkdir() missing required argument 'path' (pos 1)"
     ]
    }
   ],
   "source": [
    "os.mkdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uKr_eU23S_H3"
   },
   "source": [
    "# SYS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dTzSHcWHSuO_"
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 526,
     "status": "ok",
     "timestamp": 1728662234438,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "7BGZ7AaSSuRA",
    "outputId": "35c20120-0004-4a61-a7fb-21583a009e9b"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'/usr/bin/python3'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.executable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 476,
     "status": "ok",
     "timestamp": 1728662274015,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "Tvhj7wPfSuVb",
    "outputId": "2997d1ef-f59f-43e4-fd5b-b0ca6806832a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/content',\n",
       " '/env/python',\n",
       " '/usr/lib/python310.zip',\n",
       " '/usr/lib/python3.10',\n",
       " '/usr/lib/python3.10/lib-dynload',\n",
       " '',\n",
       " '/usr/local/lib/python3.10/dist-packages',\n",
       " '/usr/lib/python3/dist-packages',\n",
       " '/usr/local/lib/python3.10/dist-packages/IPython/extensions',\n",
       " '/usr/local/lib/python3.10/dist-packages/setuptools/_vendor',\n",
       " '/root/.ipython']"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OnRZnr7tSuZW"
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jvO28QvwTZg5"
   },
   "outputs": [],
   "source": [
    "from math import sqrt, factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 442,
     "status": "ok",
     "timestamp": 1728662346752,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "KL_CZhGITepf",
    "outputId": "bd751ac0-62d2-4ede-dcdf-8f7fb08231bb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(100)     #when we specifically immport the functions from a library, no need to call the library each time as it got preloaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1728662388631,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "TJWOVKB3TqaL",
    "outputId": "51dc823c-945e-4dd4-a1ad-f6b2c2183101"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 158
    },
    "executionInfo": {
     "elapsed": 501,
     "status": "error",
     "timestamp": 1728662413908,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "36WdrJ3bTsD3",
    "outputId": "12bfbb45-a571-4c09-f304-f028a02596be"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'log' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-117-d45d75d36c8e>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#BUT WHEN YOU CALL THE FUNCTION THAT IS NOT PRELOADED, IT RETURNS AN ERROR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'log' is not defined"
     ]
    }
   ],
   "source": [
    "#BUT WHEN YOU CALL THE FUNCTION THAT IS NOT PRELOADED, IT RETURNS AN ERROR\n",
    "log(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 506,
     "status": "ok",
     "timestamp": 1728662425516,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "kb8ygRjXTynr",
    "outputId": "64852827-c933-4a87-c3e0-a84832c449fe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0986122886681098"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8j1LO3NzUA6w"
   },
   "source": [
    "# Exception Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1728662728596,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "mvJtat2wT1Z8",
    "outputId": "66c8e69c-943e-44af-de9a-8f179182e69a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__call__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__name__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__qualname__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__self__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__text_signature__']"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(__build_class__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 485,
     "status": "ok",
     "timestamp": 1728662881339,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "V0OQw-sjT1cd",
    "outputId": "9e8b9c06-698e-4653-e427-76bcadbc891d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ArithmeticError', 'AssertionError', 'AttributeError', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'EOFError', 'EnvironmentError', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'IOError', 'ImportError', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'NotADirectoryError', 'NotImplementedError', 'OSError', 'OverflowError', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'RuntimeError', 'SyntaxError', 'SystemError', 'TabError', 'TimeoutError', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'ValueError', 'ZeroDivisionError']\n"
     ]
    }
   ],
   "source": [
    "print([i for i in dir(__builtins__) if \"Error\" in i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QJyJgbSptFGr"
   },
   "outputs": [],
   "source": [
    "# BaseException\n",
    "#  ├── BaseExceptionGroup\n",
    "#  ├── GeneratorExit\n",
    "#  ├── KeyboardInterrupt\n",
    "#  ├── SystemExit\n",
    "#  └── Exception\n",
    "#       ├── ArithmeticError\n",
    "#       │    ├── FloatingPointError\n",
    "#       │    ├── OverflowError\n",
    "#       │    └── ZeroDivisionError\n",
    "#       ├── AssertionError\n",
    "#       ├── AttributeError\n",
    "#       ├── BufferError\n",
    "#       ├── EOFError\n",
    "#       ├── ExceptionGroup [BaseExceptionGroup]\n",
    "#       ├── ImportError\n",
    "#       │    └── ModuleNotFoundError\n",
    "#       ├── LookupError\n",
    "#       │    ├── IndexError\n",
    "#       │    └── KeyError\n",
    "#       ├── MemoryError\n",
    "#       ├── NameError\n",
    "#       │    └── UnboundLocalError\n",
    "#       ├── OSError\n",
    "#       │    ├── BlockingIOError\n",
    "#       │    ├── ChildProcessError\n",
    "#       │    ├── ConnectionError\n",
    "#       │    │    ├── BrokenPipeError\n",
    "#       │    │    ├── ConnectionAbortedError\n",
    "#       │    │    ├── ConnectionRefusedError\n",
    "#       │    │    └── ConnectionResetError\n",
    "#       │    ├── FileExistsError\n",
    "#       │    ├── FileNotFoundError\n",
    "#       │    ├── InterruptedError\n",
    "#       │    ├── IsADirectoryError\n",
    "#       │    ├── NotADirectoryError\n",
    "#       │    ├── PermissionError\n",
    "#       │    ├── ProcessLookupError\n",
    "#       │    └── TimeoutError\n",
    "#       ├── ReferenceError\n",
    "#       ├── RuntimeError\n",
    "#       │    ├── NotImplementedError\n",
    "#       │    ├── PythonFinalizationError\n",
    "#       │    └── RecursionError\n",
    "#       ├── StopAsyncIteration\n",
    "#       ├── StopIteration\n",
    "#       ├── SyntaxError\n",
    "#       │    └── IndentationError\n",
    "#       │         └── TabError\n",
    "#       ├── SystemError\n",
    "#       ├── TypeError\n",
    "#       ├── ValueError\n",
    "#       │    └── UnicodeError\n",
    "#       │         ├── UnicodeDecodeError\n",
    "#       │         ├── UnicodeEncodeError\n",
    "#       │         └── UnicodeTranslateError\n",
    "#       └── Warning\n",
    "#            ├── BytesWarning\n",
    "#            ├── DeprecationWarning\n",
    "#            ├── EncodingWarning\n",
    "#            ├── FutureWarning\n",
    "#            ├── ImportWarning\n",
    "#            ├── PendingDeprecationWarning\n",
    "#            ├── ResourceWarning\n",
    "#            ├── RuntimeWarning\n",
    "#            ├── SyntaxWarning\n",
    "#            ├── UnicodeWarning\n",
    "#            └── UserWarning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 211
    },
    "executionInfo": {
     "elapsed": 418,
     "status": "error",
     "timestamp": 1728669163706,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "s2EHbpnYtX0a",
    "outputId": "de1f6de4-0286-47a3-fa08-c723af883fff"
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-8522d8f39a29>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"we are the world\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = 0\n",
    "\n",
    "c = a/b\n",
    "print(c)\n",
    "print(\"we are the world\")     #this line does not get executed when there is error in the previous lines. In order to achieve this 4\n",
    "                              #we use try except concept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 523,
     "status": "ok",
     "timestamp": 1728669500153,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "J2kcM37htX7V",
    "outputId": "4e76b9c1-18f2-4b65-d22a-b087dfb5d135"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the error encountered in try was  invalid literal for int() with base 10: '5.5'\n",
      "this line got printed easily\n"
     ]
    }
   ],
   "source": [
    "a = '4'\n",
    "b = '5.5'\n",
    "try:\n",
    "  c = int(a)/int(b) #string cannot be converted to integer\n",
    "  print(c)\n",
    "  print(\"who the hell is alfred\")\n",
    "\n",
    "except Exception as e:\n",
    "  print(\"the error encountered in try was \",e)\n",
    "\n",
    "print(\"this line got printed easily\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 531,
     "status": "ok",
     "timestamp": 1728669575198,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "aikEqSyAtYAm",
    "outputId": "76d8021a-0ae8-4c51-b921-0f2a23c5e7f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am jack\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "  print(9/0)\n",
    "\n",
    "except:\n",
    "  print(\"I am jack\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8eJpslDRtYGU"
   },
   "outputs": [],
   "source": [
    "# do not do this: from math import *\n",
    "# Industry standards: import numpy as np\n",
    "# import tensorflow as tf\n",
    "# import pandas as pd\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Eb-d7wlVvk4q"
   },
   "source": [
    "**traceback is a builtin module of python which clearly give which line of code is having error.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 429,
     "status": "ok",
     "timestamp": 1728670327113,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "SZaU0QhWvlBj",
    "outputId": "37967f4a-84b0-4ec4-8e50-65ba61b94d33"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this value is: 1.5\n",
      "the error was:  division by zero\n",
      "__________\n",
      "the error was:  invalid literal for int() with base 10: 'hello'\n",
      "__________\n",
      "the error was:  int() argument must be a string, a bytes-like object or a real number, not 'NoneType'\n",
      "__________\n",
      "__________________________________________________\n"
     ]
    }
   ],
   "source": [
    "lst = [2,0,'hello',None]\n",
    "result = []\n",
    "\n",
    "for i in lst:\n",
    "  try:\n",
    "    res = 3/int(i)\n",
    "    print(\"this value is:\",res)\n",
    "\n",
    "  except Exception as er:\n",
    "    print(\"the error was: \",er)\n",
    "    print(\"_\"*10)\n",
    "\n",
    "\n",
    "print('_' * 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 521,
     "status": "ok",
     "timestamp": 1728670444453,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "Dw_pW8FByF-9",
    "outputId": "5bceb3e9-dfa8-4ef7-8803-aa0e17ef4df1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this value is: 1.5\n",
      "the error was:  division by zero\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-11-84d3945e31d3>\", line 8, in <cell line: 6>\n",
      "    res = 3/int(i)\n",
      "ZeroDivisionError: division by zero\n",
      "\n",
      "__________\n",
      "the error was:  invalid literal for int() with base 10: 'hello'\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-11-84d3945e31d3>\", line 8, in <cell line: 6>\n",
      "    res = 3/int(i)\n",
      "ValueError: invalid literal for int() with base 10: 'hello'\n",
      "\n",
      "__________\n",
      "the error was:  int() argument must be a string, a bytes-like object or a real number, not 'NoneType'\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-11-84d3945e31d3>\", line 8, in <cell line: 6>\n",
      "    res = 3/int(i)\n",
      "TypeError: int() argument must be a string, a bytes-like object or a real number, not 'NoneType'\n",
      "\n",
      "__________\n",
      "__________________________________________________\n"
     ]
    }
   ],
   "source": [
    "import traceback\n",
    "\n",
    "lst = [2,0,'hello',None]\n",
    "result = []\n",
    "\n",
    "for i in lst:\n",
    "  try:\n",
    "    res = 3/int(i)\n",
    "    print(\"this value is:\",res)\n",
    "\n",
    "  except Exception as er:\n",
    "    print(\"the error was: \",er)\n",
    "    print(traceback.format_exc())\n",
    "    print(\"_\"*10)\n",
    "\n",
    "><print('_' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MoNNam0TMKD1"
   },
   "source": [
    "# CATCHING SPECIFIC ERRORS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 467,
     "status": "ok",
     "timestamp": 1728711277543,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "aLZQ-_SQMIlI",
    "outputId": "114ac2e2-4dfa-4f59-959d-f8224299b03d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success  5.0\n",
      "Hooray!!\n",
      "__________\n",
      "0 got failed due to division by zero: division by zero\n",
      "hello got value error invalid literal for int() with base 10: 'hello'\n",
      "None got other errors  int() argument must be a string, a bytes-like object or a real number, not 'NoneType'\n",
      "__________________________________________________\n"
     ]
    }
   ],
   "source": [
    "lst = [1,0,\"hello\",None]\n",
    "res = []\n",
    "\n",
    "for element in lst:\n",
    "  try:\n",
    "    res = 5/int(element)\n",
    "    print(\"success \",res)\n",
    "  except ZeroDivisionError as e:\n",
    "    print(f\"{element} got failed due to division by zero:\",e)\n",
    "  except ValueError as e:\n",
    "    print(f\"{element} got value error\",e)\n",
    "  except AttributeError as e:\n",
    "    print(\"attribute\",e)\n",
    "  except Exception as e:\n",
    "    print(f\"{element} got other errors \",e)\n",
    "  else:\n",
    "    print(\"Hooray!!\")\n",
    "    print(\"_\" * 10)\n",
    "\n",
    "print(\"_\" * 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6764,
     "status": "ok",
     "timestamp": 1728711759585,
     "user": {
      "displayName": "Hillary Jude",
      "userId": "17943637264411223929"
     },
     "user_tz": -330
    },
    "id": "snGIq1TwO8wK",
    "outputId": "6995fc05-f605-4240-b88f-217d121e56e7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: yu\n",
      "Error occured : Name cannot be less than 3 charaters.\n",
      "\n",
      "100 lines of code\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "  name = input(\"Enter your name: \")\n",
    "  if len(name) < 3:\n",
    "    raise Exception(\"Name cannot be less than 3 charaters.\")\n",
    "  print(\"Hello, \",name)\n",
    "\n",
    "except Exception as e:\n",
    "  print(\"Error occured :\", e)\n",
    "\n",
    "\n",
    "print(\"\\n100 lines of code\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyN+bUiCvvriO3YOdHKVHczr",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}