Intro to python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Number\n",
    "1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 1\n",
    "num2 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1 + num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "float_num = 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1 + float_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8//4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(8/2)+(4/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#DMAS\n",
    "8/2+6*3+10-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Strings\n",
    "str = 'Hello World'\n",
    "str1 = 'Live long'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello WorldLive long'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str + str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = str + ' ' + str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World Live long'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[6:11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_new = 'hello World Live long'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello World Live long'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World Live long'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      S.__format__(format_spec) -> str\n",
      " |      \n",
      " |      Return a formatted version of S as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      S.__sizeof__() -> size of S in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(...)\n",
      " |      S.capitalize() -> str\n",
      " |      \n",
      " |      Return a capitalized version of S, i.e. make the first character\n",
      " |      have upper case and the rest lower case.\n",
      " |  \n",
      " |  casefold(...)\n",
      " |      S.casefold() -> str\n",
      " |      \n",
      " |      Return a version of S suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(...)\n",
      " |      S.center(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S centered in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space)\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(...)\n",
      " |      S.encode(encoding='utf-8', errors='strict') -> bytes\n",
      " |      \n",
      " |      Encode S using the codec registered for encoding. Default encoding\n",
      " |      is 'utf-8'. errors may be given to set a different error\n",
      " |      handling scheme. Default is 'strict' meaning that encoding errors raise\n",
      " |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n",
      " |      'xmlcharrefreplace' as well as any other name registered with\n",
      " |      codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(...)\n",
      " |      S.expandtabs(tabsize=8) -> str\n",
      " |      \n",
      " |      Return a copy of S where all tab characters are expanded using spaces.\n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found, \n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(...)\n",
      " |      S.isalnum() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphanumeric\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isalpha(...)\n",
      " |      S.isalpha() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphabetic\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isdecimal(...)\n",
      " |      S.isdecimal() -> bool\n",
      " |      \n",
      " |      Return True if there are only decimal characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isdigit(...)\n",
      " |      S.isdigit() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are digits\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isidentifier(...)\n",
      " |      S.isidentifier() -> bool\n",
      " |      \n",
      " |      Return True if S is a valid identifier according\n",
      " |      to the language definition.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers\n",
      " |      such as \"def\" and \"class\".\n",
      " |  \n",
      " |  islower(...)\n",
      " |      S.islower() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are lowercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  isnumeric(...)\n",
      " |      S.isnumeric() -> bool\n",
      " |      \n",
      " |      Return True if there are only numeric characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isprintable(...)\n",
      " |      S.isprintable() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are considered\n",
      " |      printable in repr() or S is empty, False otherwise.\n",
      " |  \n",
      " |  isspace(...)\n",
      " |      S.isspace() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are whitespace\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  istitle(...)\n",
      " |      S.istitle() -> bool\n",
      " |      \n",
      " |      Return True if S is a titlecased string and there is at least one\n",
      " |      character in S, i.e. upper- and titlecase characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |      Return False otherwise.\n",
      " |  \n",
      " |  isupper(...)\n",
      " |      S.isupper() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are uppercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  join(...)\n",
      " |      S.join(iterable) -> str\n",
      " |      \n",
      " |      Return a string which is the concatenation of the strings in the\n",
      " |      iterable.  The separator between elements is S.\n",
      " |  \n",
      " |  ljust(...)\n",
      " |      S.ljust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S left-justified in a Unicode string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(...)\n",
      " |      S.lower() -> str\n",
      " |      \n",
      " |      Return a copy of the string S converted to lowercase.\n",
      " |  \n",
      " |  lstrip(...)\n",
      " |      S.lstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(...)\n",
      " |      S.partition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, and return the part before it,\n",
      " |      the separator itself, and the part after it.  If the separator is not\n",
      " |      found, return S and two empty strings.\n",
      " |  \n",
      " |  replace(...)\n",
      " |      S.replace(old, new[, count]) -> str\n",
      " |      \n",
      " |      Return a copy of S with all occurrences of substring\n",
      " |      old replaced by new.  If the optional argument count is\n",
      " |      given, only the first count occurrences are replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(...)\n",
      " |      S.rjust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S right-justified in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(...)\n",
      " |      S.rpartition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, starting at the end of S, and return\n",
      " |      the part before it, the separator itself, and the part after it.  If the\n",
      " |      separator is not found, return two empty strings and S.\n",
      " |  \n",
      " |  rsplit(...)\n",
      " |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string, starting at the end of the string and\n",
      " |      working to the front.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified, any whitespace string\n",
      " |      is a separator.\n",
      " |  \n",
      " |  rstrip(...)\n",
      " |      S.rstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with trailing whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(...)\n",
      " |      S.split(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified or is None, any\n",
      " |      whitespace string is a separator and empty strings are\n",
      " |      removed from the result.\n",
      " |  \n",
      " |  splitlines(...)\n",
      " |      S.splitlines([keepends]) -> list of strings\n",
      " |      \n",
      " |      Return a list of the lines in S, breaking at line boundaries.\n",
      " |      Line breaks are not included in the resulting list unless keepends\n",
      " |      is given and true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(...)\n",
      " |      S.strip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading and trailing\n",
      " |      whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(...)\n",
      " |      S.swapcase() -> str\n",
      " |      \n",
      " |      Return a copy of S with uppercase characters converted to lowercase\n",
      " |      and vice versa.\n",
      " |  \n",
      " |  title(...)\n",
      " |      S.title() -> str\n",
      " |      \n",
      " |      Return a titlecased version of S, i.e. words start with title case\n",
      " |      characters, all remaining cased characters have lower case.\n",
      " |  \n",
      " |  translate(...)\n",
      " |      S.translate(table) -> str\n",
      " |      \n",
      " |      Return a copy of the string S in which each character has been mapped\n",
      " |      through the given translation table. The table must implement\n",
      " |      lookup/indexing via __getitem__, for instance a dictionary or list,\n",
      " |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n",
      " |      this operation raises LookupError, the character is left untouched.\n",
      " |      Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(...)\n",
      " |      S.upper() -> str\n",
      " |      \n",
      " |      Return a copy of S converted to uppercase.\n",
      " |  \n",
      " |  zfill(...)\n",
      " |      S.zfill(width) -> str\n",
      " |      \n",
      " |      Pad a numeric string S with zeros on the left, to fill a field\n",
      " |      of the specified width. The string S is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.count('ll')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#starting index of substring\n",
    "#convert string to uppercase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.find('World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD LIVE LONG'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tuples\n",
    "my_tuple = (30, 'Hello world', 60.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30, 'Hello world', 60.5)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello worldanother string'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple[1]+ 'another string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-d0d262204ef6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m40\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tuple[0] = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on tuple object:\n",
      "\n",
      "class tuple(object)\n",
      " |  tuple() -> empty tuple\n",
      " |  tuple(iterable) -> tuple initialized from iterable's items\n",
      " |  \n",
      " |  If the argument is a tuple, the return value is the same object.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  count(...)\n",
      " |      T.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple.__len__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#List\n",
    "my_list = [30, var, 50.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 'Hello World Live long', 50.5]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0] = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[40, 'Hello World Live long', 50.5]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0] = 'replced string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['replced string', 'Hello World Live long', 50.5]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'replced string'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-e44f24d36056>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'p'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_list[0][0] = 'p'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append([2,5,8.4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['replced string', 'Hello World Live long', 50.5, [2, 5, 8.4]]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.4"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[-1][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#delete an elemet from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.__delitem__(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello World Live long', 50.5, [2, 5, 8.4]]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dictionay\n",
    "my_dict = {'id':1,'name':'Sam','age':20, 'quizez_marks':[20,30,25]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'id': 1, 'name': 'Sam', 'age': 20, 'quizez_marks': [20, 30, 25]}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sam'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['quizez_marks'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on dict object:\n",
      "\n",
      "class dict(object)\n",
      " |  dict() -> new empty dictionary\n",
      " |  dict(mapping) -> new dictionary initialized from a mapping object's\n",
      " |      (key, value) pairs\n",
      " |  dict(iterable) -> new dictionary initialized as if via:\n",
      " |      d = {}\n",
      " |      for k, v in iterable:\n",
      " |          d[k] = v\n",
      " |  dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
      " |      in the keyword argument list.  For example:  dict(one=1, two=2)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      True if D has a key k, else False.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      D.__sizeof__() -> size of D in memory, in bytes\n",
      " |  \n",
      " |  clear(...)\n",
      " |      D.clear() -> None.  Remove all items from D.\n",
      " |  \n",
      " |  copy(...)\n",
      " |      D.copy() -> a shallow copy of D\n",
      " |  \n",
      " |  fromkeys(iterable, value=None, /) from builtins.type\n",
      " |      Returns a new dict with keys from iterable and values equal to value.\n",
      " |  \n",
      " |  get(...)\n",
      " |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n",
      " |  \n",
      " |  items(...)\n",
      " |      D.items() -> a set-like object providing a view on D's items\n",
      " |  \n",
      " |  keys(...)\n",
      " |      D.keys() -> a set-like object providing a view on D's keys\n",
      " |  \n",
      " |  pop(...)\n",
      " |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      " |      If key is not found, d is returned if given, otherwise KeyError is raised\n",
      " |  \n",
      " |  popitem(...)\n",
      " |      D.popitem() -> (k, v), remove and return some (key, value) pair as a\n",
      " |      2-tuple; but raise KeyError if D is empty.\n",
      " |  \n",
      " |  setdefault(...)\n",
      " |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\n",
      " |  \n",
      " |  update(...)\n",
      " |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      " |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      " |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      " |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      " |  \n",
      " |  values(...)\n",
      " |      D.values() -> an object providing a view on D's values\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#find all keys\n",
    "#find all values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "keys = my_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 'Sam', 20, [20, 30, 25]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'quizez_marks'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#type casting\n",
    "list(keys)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sets\n",
    "my_set = {1,2,3,4,4,5,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.add(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 8}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.add(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 8}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_set = {5,6,10,11,15}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 6, 10, 11, 15}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 8, 10, 11, 15}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set.union(new_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set.intersection(new_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Comparison operators\n",
    "value = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value == 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value != 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value < 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value > 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value <= 6 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value >= 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5+6 == 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get input from user\n",
    "#compare input number with a hidden number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number : 5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "user_input = input('Enter a number : ')\n",
    "print(user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess the number : 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden_number = 10\n",
    "user_input = input('Guess the number : ')\n",
    "hidden_number == int(user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 == int('10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#logical operators\n",
    "10==10 and 5==4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10==10 and 5==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(10==10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(5==4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dicision making\n",
    "weather = 'cloudy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am confused\n"
     ]
    }
   ],
   "source": [
    "if weather == 'sunny':\n",
    "    print(\"Play outside\")\n",
    "elif weather == 'rainy':\n",
    "    print('Play inside')\n",
    "else:\n",
    "    print('I am confused')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weather == 'rainy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess the number : 5\n",
      "You lost, try next time\n"
     ]
    }
   ],
   "source": [
    "user_input = int(input('Guess the number : '))\n",
    "if hidden_number == user_input:\n",
    "    print('heyyy, You won')\n",
    "elif hidden_number != user_input:\n",
    "    print('You lost, try next time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call friends\n",
      "play soccer\n"
     ]
    }
   ],
   "source": [
    "weather = 'sunny'\n",
    "friends = 'available'\n",
    "if weather == 'sunny':\n",
    "    print(\"call friends\")\n",
    "    if friends == 'available':\n",
    "        print('play soccer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess the number : 5\n",
      "Your entered number is smaller than the actual number\n"
     ]
    }
   ],
   "source": [
    "user_input = int(input('Guess the number : '))\n",
    "if hidden_number == user_input:\n",
    "    print('heyyy, You won')\n",
    "elif hidden_number != user_input:\n",
    "    if hidden_number < user_input:\n",
    "        print('Your entered number is greater than the actual number')\n",
    "    elif hidden_number > user_input:\n",
    "        print('Your entered number is smaller than the actual number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess the number : 5\n",
      "Your entered number is smaller than the actual number\n"
     ]
    }
   ],
   "source": [
    "user_input = int(input('Guess the number : '))\n",
    "if hidden_number == user_input:\n",
    "    print('heyyy, You won')\n",
    "elif hidden_number < user_input:\n",
    "    print('Your entered number is greater than the actual number')\n",
    "else:\n",
    "    print('Your entered number is smaller than the actual number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "28\n",
      "30\n",
      "32\n",
      "34\n",
      "36\n",
      "38\n",
      "40\n",
      "42\n",
      "44\n",
      "46\n",
      "48\n",
      "50\n",
      "52\n",
      "54\n",
      "56\n",
      "58\n",
      "60\n",
      "62\n",
      "64\n",
      "66\n",
      "68\n",
      "70\n",
      "72\n",
      "74\n",
      "76\n",
      "78\n",
      "80\n",
      "82\n",
      "84\n",
      "86\n",
      "88\n",
      "90\n",
      "92\n",
      "94\n",
      "96\n",
      "98\n",
      "100\n",
      "102\n",
      "104\n",
      "106\n",
      "108\n",
      "110\n",
      "112\n",
      "114\n",
      "116\n",
      "118\n",
      "120\n",
      "122\n",
      "124\n",
      "126\n",
      "128\n",
      "130\n",
      "132\n",
      "134\n",
      "136\n",
      "138\n",
      "140\n",
      "142\n",
      "144\n",
      "146\n",
      "148\n",
      "150\n",
      "152\n",
      "154\n",
      "156\n",
      "158\n",
      "160\n",
      "162\n",
      "164\n",
      "166\n",
      "168\n",
      "170\n",
      "172\n",
      "174\n",
      "176\n",
      "178\n",
      "180\n",
      "182\n",
      "184\n",
      "186\n",
      "188\n",
      "190\n",
      "192\n",
      "194\n",
      "196\n",
      "198\n",
      "200\n",
      "202\n",
      "204\n",
      "206\n",
      "208\n",
      "210\n",
      "212\n",
      "214\n",
      "216\n",
      "218\n",
      "220\n",
      "222\n",
      "224\n",
      "226\n",
      "228\n",
      "230\n",
      "232\n",
      "234\n",
      "236\n",
      "238\n",
      "240\n",
      "242\n",
      "244\n",
      "246\n",
      "248\n",
      "250\n",
      "252\n",
      "254\n",
      "256\n",
      "258\n",
      "260\n",
      "262\n",
      "264\n",
      "266\n",
      "268\n",
      "270\n",
      "272\n",
      "274\n",
      "276\n",
      "278\n",
      "280\n",
      "282\n",
      "284\n",
      "286\n",
      "288\n",
      "290\n",
      "292\n",
      "294\n",
      "296\n",
      "298\n",
      "300\n",
      "302\n",
      "304\n",
      "306\n",
      "308\n",
      "310\n",
      "312\n",
      "314\n",
      "316\n",
      "318\n",
      "320\n",
      "322\n",
      "324\n",
      "326\n",
      "328\n",
      "330\n",
      "332\n",
      "334\n",
      "336\n",
      "338\n",
      "340\n",
      "342\n",
      "344\n",
      "346\n",
      "348\n",
      "350\n",
      "352\n",
      "354\n",
      "356\n",
      "358\n",
      "360\n",
      "362\n",
      "364\n",
      "366\n",
      "368\n",
      "370\n",
      "372\n",
      "374\n",
      "376\n",
      "378\n",
      "380\n",
      "382\n",
      "384\n",
      "386\n",
      "388\n",
      "390\n",
      "392\n",
      "394\n",
      "396\n",
      "398\n",
      "400\n",
      "402\n",
      "404\n",
      "406\n",
      "408\n",
      "410\n",
      "412\n",
      "414\n",
      "416\n",
      "418\n",
      "420\n",
      "422\n",
      "424\n",
      "426\n",
      "428\n",
      "430\n",
      "432\n",
      "434\n",
      "436\n",
      "438\n",
      "440\n",
      "442\n",
      "444\n",
      "446\n",
      "448\n",
      "450\n",
      "452\n",
      "454\n",
      "456\n",
      "458\n",
      "460\n",
      "462\n",
      "464\n",
      "466\n",
      "468\n",
      "470\n",
      "472\n",
      "474\n",
      "476\n",
      "478\n",
      "480\n",
      "482\n",
      "484\n",
      "486\n",
      "488\n",
      "490\n",
      "492\n",
      "494\n",
      "496\n",
      "498\n",
      "500\n",
      "502\n",
      "504\n",
      "506\n",
      "508\n",
      "510\n",
      "512\n",
      "514\n",
      "516\n",
      "518\n",
      "520\n",
      "522\n",
      "524\n",
      "526\n",
      "528\n",
      "530\n",
      "532\n",
      "534\n",
      "536\n",
      "538\n",
      "540\n",
      "542\n",
      "544\n",
      "546\n",
      "548\n",
      "550\n",
      "552\n",
      "554\n",
      "556\n",
      "558\n",
      "560\n",
      "562\n",
      "564\n",
      "566\n",
      "568\n",
      "570\n",
      "572\n",
      "574\n",
      "576\n",
      "578\n",
      "580\n",
      "582\n",
      "584\n",
      "586\n",
      "588\n",
      "590\n",
      "592\n",
      "594\n",
      "596\n",
      "598\n",
      "600\n",
      "602\n",
      "604\n",
      "606\n",
      "608\n",
      "610\n",
      "612\n",
      "614\n",
      "616\n",
      "618\n",
      "620\n",
      "622\n",
      "624\n",
      "626\n",
      "628\n",
      "630\n",
      "632\n",
      "634\n",
      "636\n",
      "638\n",
      "640\n",
      "642\n",
      "644\n",
      "646\n",
      "648\n",
      "650\n",
      "652\n",
      "654\n",
      "656\n",
      "658\n",
      "660\n",
      "662\n",
      "664\n",
      "666\n",
      "668\n",
      "670\n",
      "672\n",
      "674\n",
      "676\n",
      "678\n",
      "680\n",
      "682\n",
      "684\n",
      "686\n",
      "688\n",
      "690\n",
      "692\n",
      "694\n",
      "696\n",
      "698\n",
      "700\n",
      "702\n",
      "704\n",
      "706\n",
      "708\n",
      "710\n",
      "712\n",
      "714\n",
      "716\n",
      "718\n",
      "720\n",
      "722\n",
      "724\n",
      "726\n",
      "728\n",
      "730\n",
      "732\n",
      "734\n",
      "736\n",
      "738\n",
      "740\n",
      "742\n",
      "744\n",
      "746\n",
      "748\n",
      "750\n",
      "752\n",
      "754\n",
      "756\n",
      "758\n",
      "760\n",
      "762\n",
      "764\n",
      "766\n",
      "768\n",
      "770\n",
      "772\n",
      "774\n",
      "776\n",
      "778\n",
      "780\n",
      "782\n",
      "784\n",
      "786\n",
      "788\n",
      "790\n",
      "792\n",
      "794\n",
      "796\n",
      "798\n",
      "800\n",
      "802\n",
      "804\n",
      "806\n",
      "808\n",
      "810\n",
      "812\n",
      "814\n",
      "816\n",
      "818\n",
      "820\n",
      "822\n",
      "824\n",
      "826\n",
      "828\n",
      "830\n",
      "832\n",
      "834\n",
      "836\n",
      "838\n",
      "840\n",
      "842\n",
      "844\n",
      "846\n",
      "848\n",
      "850\n",
      "852\n",
      "854\n",
      "856\n",
      "858\n",
      "860\n",
      "862\n",
      "864\n",
      "866\n",
      "868\n",
      "870\n",
      "872\n",
      "874\n",
      "876\n",
      "878\n",
      "880\n",
      "882\n",
      "884\n",
      "886\n",
      "888\n",
      "890\n",
      "892\n",
      "894\n",
      "896\n",
      "898\n",
      "900\n",
      "902\n",
      "904\n",
      "906\n",
      "908\n",
      "910\n",
      "912\n",
      "914\n",
      "916\n",
      "918\n",
      "920\n",
      "922\n",
      "924\n",
      "926\n",
      "928\n",
      "930\n",
      "932\n",
      "934\n",
      "936\n",
      "938\n",
      "940\n",
      "942\n",
      "944\n",
      "946\n",
      "948\n",
      "950\n",
      "952\n",
      "954\n",
      "956\n",
      "958\n",
      "960\n",
      "962\n",
      "964\n",
      "966\n",
      "968\n",
      "970\n",
      "972\n",
      "974\n",
      "976\n",
      "978\n",
      "980\n",
      "982\n",
      "984\n",
      "986\n",
      "988\n",
      "990\n",
      "992\n",
      "994\n",
      "996\n",
      "998\n",
      "1000\n",
      "1002\n",
      "1004\n",
      "1006\n",
      "1008\n",
      "1010\n",
      "1012\n",
      "1014\n",
      "1016\n",
      "1018\n",
      "1020\n",
      "1022\n",
      "1024\n",
      "1026\n",
      "1028\n",
      "1030\n",
      "1032\n",
      "1034\n",
      "1036\n",
      "1038\n",
      "1040\n",
      "1042\n",
      "1044\n",
      "1046\n",
      "1048\n",
      "1050\n",
      "1052\n",
      "1054\n",
      "1056\n",
      "1058\n",
      "1060\n",
      "1062\n",
      "1064\n",
      "1066\n",
      "1068\n",
      "1070\n",
      "1072\n",
      "1074\n",
      "1076\n",
      "1078\n",
      "1080\n",
      "1082\n",
      "1084\n",
      "1086\n",
      "1088\n",
      "1090\n",
      "1092\n",
      "1094\n",
      "1096\n",
      "1098\n",
      "1100\n",
      "1102\n",
      "1104\n",
      "1106\n",
      "1108\n",
      "1110\n",
      "1112\n",
      "1114\n",
      "1116\n",
      "1118\n",
      "1120\n",
      "1122\n",
      "1124\n",
      "1126\n",
      "1128\n",
      "1130\n",
      "1132\n",
      "1134\n",
      "1136\n",
      "1138\n",
      "1140\n",
      "1142\n",
      "1144\n",
      "1146\n",
      "1148\n",
      "1150\n",
      "1152\n",
      "1154\n",
      "1156\n",
      "1158\n",
      "1160\n",
      "1162\n",
      "1164\n",
      "1166\n",
      "1168\n",
      "1170\n",
      "1172\n",
      "1174\n",
      "1176\n",
      "1178\n",
      "1180\n",
      "1182\n",
      "1184\n",
      "1186\n",
      "1188\n",
      "1190\n",
      "1192\n",
      "1194\n",
      "1196\n",
      "1198\n",
      "1200\n",
      "1202\n",
      "1204\n",
      "1206\n",
      "1208\n",
      "1210\n",
      "1212\n",
      "1214\n",
      "1216\n",
      "1218\n",
      "1220\n",
      "1222\n",
      "1224\n",
      "1226\n",
      "1228\n",
      "1230\n",
      "1232\n",
      "1234\n",
      "1236\n",
      "1238\n",
      "1240\n",
      "1242\n",
      "1244\n",
      "1246\n",
      "1248\n",
      "1250\n",
      "1252\n",
      "1254\n",
      "1256\n",
      "1258\n",
      "1260\n",
      "1262\n",
      "1264\n",
      "1266\n",
      "1268\n",
      "1270\n",
      "1272\n",
      "1274\n",
      "1276\n",
      "1278\n",
      "1280\n",
      "1282\n",
      "1284\n",
      "1286\n",
      "1288\n",
      "1290\n",
      "1292\n",
      "1294\n",
      "1296\n",
      "1298\n",
      "1300\n",
      "1302\n",
      "1304\n",
      "1306\n",
      "1308\n",
      "1310\n",
      "1312\n",
      "1314\n",
      "1316\n",
      "1318\n",
      "1320\n",
      "1322\n",
      "1324\n",
      "1326\n",
      "1328\n",
      "1330\n",
      "1332\n",
      "1334\n",
      "1336\n",
      "1338\n",
      "1340\n",
      "1342\n",
      "1344\n",
      "1346\n",
      "1348\n",
      "1350\n",
      "1352\n",
      "1354\n",
      "1356\n",
      "1358\n",
      "1360\n",
      "1362\n",
      "1364\n",
      "1366\n",
      "1368\n",
      "1370\n",
      "1372\n",
      "1374\n",
      "1376\n",
      "1378\n",
      "1380\n",
      "1382\n",
      "1384\n",
      "1386\n",
      "1388\n",
      "1390\n",
      "1392\n",
      "1394\n",
      "1396\n",
      "1398\n",
      "1400\n",
      "1402\n",
      "1404\n",
      "1406\n",
      "1408\n",
      "1410\n",
      "1412\n",
      "1414\n",
      "1416\n",
      "1418\n",
      "1420\n",
      "1422\n",
      "1424\n",
      "1426\n",
      "1428\n",
      "1430\n",
      "1432\n",
      "1434\n",
      "1436\n",
      "1438\n",
      "1440\n",
      "1442\n",
      "1444\n",
      "1446\n",
      "1448\n",
      "1450\n",
      "1452\n",
      "1454\n",
      "1456\n",
      "1458\n",
      "1460\n",
      "1462\n",
      "1464\n",
      "1466\n",
      "1468\n",
      "1470\n",
      "1472\n",
      "1474\n",
      "1476\n",
      "1478\n",
      "1480\n",
      "1482\n",
      "1484\n",
      "1486\n",
      "1488\n",
      "1490\n",
      "1492\n",
      "1494\n",
      "1496\n",
      "1498\n",
      "1500\n",
      "1502\n",
      "1504\n",
      "1506\n",
      "1508\n",
      "1510\n",
      "1512\n",
      "1514\n",
      "1516\n",
      "1518\n",
      "1520\n",
      "1522\n",
      "1524\n",
      "1526\n",
      "1528\n",
      "1530\n",
      "1532\n",
      "1534\n",
      "1536\n",
      "1538\n",
      "1540\n",
      "1542\n",
      "1544\n",
      "1546\n",
      "1548\n",
      "1550\n",
      "1552\n",
      "1554\n",
      "1556\n",
      "1558\n",
      "1560\n",
      "1562\n",
      "1564\n",
      "1566\n",
      "1568\n",
      "1570\n",
      "1572\n",
      "1574\n",
      "1576\n",
      "1578\n",
      "1580\n",
      "1582\n",
      "1584\n",
      "1586\n",
      "1588\n",
      "1590\n",
      "1592\n",
      "1594\n",
      "1596\n",
      "1598\n",
      "1600\n",
      "1602\n",
      "1604\n",
      "1606\n",
      "1608\n",
      "1610\n",
      "1612\n",
      "1614\n",
      "1616\n",
      "1618\n",
      "1620\n",
      "1622\n",
      "1624\n",
      "1626\n",
      "1628\n",
      "1630\n",
      "1632\n",
      "1634\n",
      "1636\n",
      "1638\n",
      "1640\n",
      "1642\n",
      "1644\n",
      "1646\n",
      "1648\n",
      "1650\n",
      "1652\n",
      "1654\n",
      "1656\n",
      "1658\n",
      "1660\n",
      "1662\n",
      "1664\n",
      "1666\n",
      "1668\n",
      "1670\n",
      "1672\n",
      "1674\n",
      "1676\n",
      "1678\n",
      "1680\n",
      "1682\n",
      "1684\n",
      "1686\n",
      "1688\n",
      "1690\n",
      "1692\n",
      "1694\n",
      "1696\n",
      "1698\n",
      "1700\n",
      "1702\n",
      "1704\n",
      "1706\n",
      "1708\n",
      "1710\n",
      "1712\n",
      "1714\n",
      "1716\n",
      "1718\n",
      "1720\n",
      "1722\n",
      "1724\n",
      "1726\n",
      "1728\n",
      "1730\n",
      "1732\n",
      "1734\n",
      "1736\n",
      "1738\n",
      "1740\n",
      "1742\n",
      "1744\n",
      "1746\n",
      "1748\n",
      "1750\n",
      "1752\n",
      "1754\n",
      "1756\n",
      "1758\n",
      "1760\n",
      "1762\n",
      "1764\n",
      "1766\n",
      "1768\n",
      "1770\n",
      "1772\n",
      "1774\n",
      "1776\n",
      "1778\n",
      "1780\n",
      "1782\n",
      "1784\n",
      "1786\n",
      "1788\n",
      "1790\n",
      "1792\n",
      "1794\n",
      "1796\n",
      "1798\n",
      "1800\n",
      "1802\n",
      "1804\n",
      "1806\n",
      "1808\n",
      "1810\n",
      "1812\n",
      "1814\n",
      "1816\n",
      "1818\n",
      "1820\n",
      "1822\n",
      "1824\n",
      "1826\n",
      "1828\n",
      "1830\n",
      "1832\n",
      "1834\n",
      "1836\n",
      "1838\n",
      "1840\n",
      "1842\n",
      "1844\n",
      "1846\n",
      "1848\n",
      "1850\n",
      "1852\n",
      "1854\n",
      "1856\n",
      "1858\n",
      "1860\n",
      "1862\n",
      "1864\n",
      "1866\n",
      "1868\n",
      "1870\n",
      "1872\n",
      "1874\n",
      "1876\n",
      "1878\n",
      "1880\n",
      "1882\n",
      "1884\n",
      "1886\n",
      "1888\n",
      "1890\n",
      "1892\n",
      "1894\n",
      "1896\n",
      "1898\n",
      "1900\n",
      "1902\n",
      "1904\n",
      "1906\n",
      "1908\n",
      "1910\n",
      "1912\n",
      "1914\n",
      "1916\n",
      "1918\n",
      "1920\n",
      "1922\n",
      "1924\n",
      "1926\n",
      "1928\n",
      "1930\n",
      "1932\n",
      "1934\n",
      "1936\n",
      "1938\n",
      "1940\n",
      "1942\n",
      "1944\n",
      "1946\n",
      "1948\n",
      "1950\n",
      "1952\n",
      "1954\n",
      "1956\n",
      "1958\n",
      "1960\n",
      "1962\n",
      "1964\n",
      "1966\n",
      "1968\n",
      "1970\n",
      "1972\n",
      "1974\n",
      "1976\n",
      "1978\n",
      "1980\n",
      "1982\n",
      "1984\n",
      "1986\n",
      "1988\n",
      "1990\n",
      "1992\n",
      "1994\n",
      "1996\n",
      "1998\n",
      "2000\n",
      "2002\n",
      "2004\n",
      "2006\n",
      "2008\n",
      "2010\n",
      "2012\n",
      "2014\n",
      "2016\n",
      "2018\n",
      "2020\n",
      "2022\n",
      "2024\n",
      "2026\n",
      "2028\n",
      "2030\n",
      "2032\n",
      "2034\n",
      "2036\n",
      "2038\n",
      "2040\n",
      "2042\n",
      "2044\n",
      "2046\n",
      "2048\n",
      "2050\n",
      "2052\n",
      "2054\n",
      "2056\n",
      "2058\n",
      "2060\n",
      "2062\n",
      "2064\n",
      "2066\n",
      "2068\n",
      "2070\n",
      "2072\n",
      "2074\n",
      "2076\n",
      "2078\n",
      "2080\n",
      "2082\n",
      "2084\n",
      "2086\n",
      "2088\n",
      "2090\n",
      "2092\n",
      "2094\n",
      "2096\n",
      "2098\n",
      "2100\n",
      "2102\n",
      "2104\n",
      "2106\n",
      "2108\n",
      "2110\n",
      "2112\n",
      "2114\n",
      "2116\n",
      "2118\n",
      "2120\n",
      "2122\n",
      "2124\n",
      "2126\n",
      "2128\n",
      "2130\n",
      "2132\n",
      "2134\n",
      "2136\n",
      "2138\n",
      "2140\n",
      "2142\n",
      "2144\n",
      "2146\n",
      "2148\n",
      "2150\n",
      "2152\n",
      "2154\n",
      "2156\n",
      "2158\n",
      "2160\n",
      "2162\n",
      "2164\n",
      "2166\n",
      "2168\n",
      "2170\n",
      "2172\n",
      "2174\n",
      "2176\n",
      "2178\n",
      "2180\n",
      "2182\n",
      "2184\n",
      "2186\n",
      "2188\n",
      "2190\n",
      "2192\n",
      "2194\n",
      "2196\n",
      "2198\n",
      "2200\n",
      "2202\n",
      "2204\n",
      "2206\n",
      "2208\n",
      "2210\n",
      "2212\n",
      "2214\n",
      "2216\n",
      "2218\n",
      "2220\n",
      "2222\n",
      "2224\n",
      "2226\n",
      "2228\n",
      "2230\n",
      "2232\n",
      "2234\n",
      "2236\n",
      "2238\n",
      "2240\n",
      "2242\n",
      "2244\n",
      "2246\n",
      "2248\n",
      "2250\n",
      "2252\n",
      "2254\n",
      "2256\n",
      "2258\n",
      "2260\n",
      "2262\n",
      "2264\n",
      "2266\n",
      "2268\n",
      "2270\n",
      "2272\n",
      "2274\n",
      "2276\n",
      "2278\n",
      "2280\n",
      "2282\n",
      "2284\n",
      "2286\n",
      "2288\n",
      "2290\n",
      "2292\n",
      "2294\n",
      "2296\n",
      "2298\n",
      "2300\n",
      "2302\n",
      "2304\n",
      "2306\n",
      "2308\n",
      "2310\n",
      "2312\n",
      "2314\n",
      "2316\n",
      "2318\n",
      "2320\n",
      "2322\n",
      "2324\n",
      "2326\n",
      "2328\n",
      "2330\n",
      "2332\n",
      "2334\n",
      "2336\n",
      "2338\n",
      "2340\n",
      "2342\n",
      "2344\n",
      "2346\n",
      "2348\n",
      "2350\n",
      "2352\n",
      "2354\n",
      "2356\n",
      "2358\n",
      "2360\n",
      "2362\n",
      "2364\n",
      "2366\n",
      "2368\n",
      "2370\n",
      "2372\n",
      "2374\n",
      "2376\n",
      "2378\n",
      "2380\n",
      "2382\n",
      "2384\n",
      "2386\n",
      "2388\n",
      "2390\n",
      "2392\n",
      "2394\n",
      "2396\n",
      "2398\n",
      "2400\n",
      "2402\n",
      "2404\n",
      "2406\n",
      "2408\n",
      "2410\n",
      "2412\n",
      "2414\n",
      "2416\n",
      "2418\n",
      "2420\n",
      "2422\n",
      "2424\n",
      "2426\n",
      "2428\n",
      "2430\n",
      "2432\n",
      "2434\n",
      "2436\n",
      "2438\n",
      "2440\n",
      "2442\n",
      "2444\n",
      "2446\n",
      "2448\n",
      "2450\n",
      "2452\n",
      "2454\n",
      "2456\n",
      "2458\n",
      "2460\n",
      "2462\n",
      "2464\n",
      "2466\n",
      "2468\n",
      "2470\n",
      "2472\n",
      "2474\n",
      "2476\n",
      "2478\n",
      "2480\n",
      "2482\n",
      "2484\n",
      "2486\n",
      "2488\n",
      "2490\n",
      "2492\n",
      "2494\n",
      "2496\n",
      "2498\n",
      "2500\n",
      "2502\n",
      "2504\n",
      "2506\n",
      "2508\n",
      "2510\n",
      "2512\n",
      "2514\n",
      "2516\n",
      "2518\n",
      "2520\n",
      "2522\n",
      "2524\n",
      "2526\n",
      "2528\n",
      "2530\n",
      "2532\n",
      "2534\n",
      "2536\n",
      "2538\n",
      "2540\n",
      "2542\n",
      "2544\n",
      "2546\n",
      "2548\n",
      "2550\n",
      "2552\n",
      "2554\n",
      "2556\n",
      "2558\n",
      "2560\n",
      "2562\n",
      "2564\n",
      "2566\n",
      "2568\n",
      "2570\n",
      "2572\n",
      "2574\n",
      "2576\n",
      "2578\n",
      "2580\n",
      "2582\n",
      "2584\n",
      "2586\n",
      "2588\n",
      "2590\n",
      "2592\n",
      "2594\n",
      "2596\n",
      "2598\n",
      "2600\n",
      "2602\n",
      "2604\n",
      "2606\n",
      "2608\n",
      "2610\n",
      "2612\n",
      "2614\n",
      "2616\n",
      "2618\n",
      "2620\n",
      "2622\n",
      "2624\n",
      "2626\n",
      "2628\n",
      "2630\n",
      "2632\n",
      "2634\n",
      "2636\n",
      "2638\n",
      "2640\n",
      "2642\n",
      "2644\n",
      "2646\n",
      "2648\n",
      "2650\n",
      "2652\n",
      "2654\n",
      "2656\n",
      "2658\n",
      "2660\n",
      "2662\n",
      "2664\n",
      "2666\n",
      "2668\n",
      "2670\n",
      "2672\n",
      "2674\n",
      "2676\n",
      "2678\n",
      "2680\n",
      "2682\n",
      "2684\n",
      "2686\n",
      "2688\n",
      "2690\n",
      "2692\n",
      "2694\n",
      "2696\n",
      "2698\n",
      "2700\n",
      "2702\n",
      "2704\n",
      "2706\n",
      "2708\n",
      "2710\n",
      "2712\n",
      "2714\n",
      "2716\n",
      "2718\n",
      "2720\n",
      "2722\n",
      "2724\n",
      "2726\n",
      "2728\n",
      "2730\n",
      "2732\n",
      "2734\n",
      "2736\n",
      "2738\n",
      "2740\n",
      "2742\n",
      "2744\n",
      "2746\n",
      "2748\n",
      "2750\n",
      "2752\n",
      "2754\n",
      "2756\n",
      "2758\n",
      "2760\n",
      "2762\n",
      "2764\n",
      "2766\n",
      "2768\n",
      "2770\n",
      "2772\n",
      "2774\n",
      "2776\n",
      "2778\n",
      "2780\n",
      "2782\n",
      "2784\n",
      "2786\n",
      "2788\n",
      "2790\n",
      "2792\n",
      "2794\n",
      "2796\n",
      "2798\n",
      "2800\n",
      "2802\n",
      "2804\n",
      "2806\n",
      "2808\n",
      "2810\n",
      "2812\n",
      "2814\n",
      "2816\n",
      "2818\n",
      "2820\n",
      "2822\n",
      "2824\n",
      "2826\n",
      "2828\n",
      "2830\n",
      "2832\n",
      "2834\n",
      "2836\n",
      "2838\n",
      "2840\n",
      "2842\n",
      "2844\n",
      "2846\n",
      "2848\n",
      "2850\n",
      "2852\n",
      "2854\n",
      "2856\n",
      "2858\n",
      "2860\n",
      "2862\n",
      "2864\n",
      "2866\n",
      "2868\n",
      "2870\n",
      "2872\n",
      "2874\n",
      "2876\n",
      "2878\n",
      "2880\n",
      "2882\n",
      "2884\n",
      "2886\n",
      "2888\n",
      "2890\n",
      "2892\n",
      "2894\n",
      "2896\n",
      "2898\n",
      "2900\n",
      "2902\n",
      "2904\n",
      "2906\n",
      "2908\n",
      "2910\n",
      "2912\n",
      "2914\n",
      "2916\n",
      "2918\n",
      "2920\n",
      "2922\n",
      "2924\n",
      "2926\n",
      "2928\n",
      "2930\n",
      "2932\n",
      "2934\n",
      "2936\n",
      "2938\n",
      "2940\n",
      "2942\n",
      "2944\n",
      "2946\n",
      "2948\n",
      "2950\n",
      "2952\n",
      "2954\n",
      "2956\n",
      "2958\n",
      "2960\n",
      "2962\n",
      "2964\n",
      "2966\n",
      "2968\n",
      "2970\n",
      "2972\n",
      "2974\n",
      "2976\n",
      "2978\n",
      "2980\n",
      "2982\n",
      "2984\n",
      "2986\n",
      "2988\n",
      "2990\n",
      "2992\n",
      "2994\n",
      "2996\n",
      "2998\n",
      "3000\n",
      "3002\n",
      "3004\n",
      "3006\n",
      "3008\n",
      "3010\n",
      "3012\n",
      "3014\n",
      "3016\n",
      "3018\n",
      "3020\n",
      "3022\n",
      "3024\n",
      "3026\n",
      "3028\n",
      "3030\n",
      "3032\n",
      "3034\n",
      "3036\n",
      "3038\n",
      "3040\n",
      "3042\n",
      "3044\n",
      "3046\n",
      "3048\n",
      "3050\n",
      "3052\n",
      "3054\n",
      "3056\n",
      "3058\n",
      "3060\n",
      "3062\n",
      "3064\n",
      "3066\n",
      "3068\n",
      "3070\n",
      "3072\n",
      "3074\n",
      "3076\n",
      "3078\n",
      "3080\n",
      "3082\n",
      "3084\n",
      "3086\n",
      "3088\n",
      "3090\n",
      "3092\n",
      "3094\n",
      "3096\n",
      "3098\n",
      "3100\n",
      "3102\n",
      "3104\n",
      "3106\n",
      "3108\n",
      "3110\n",
      "3112\n",
      "3114\n",
      "3116\n",
      "3118\n",
      "3120\n",
      "3122\n",
      "3124\n",
      "3126\n",
      "3128\n",
      "3130\n",
      "3132\n",
      "3134\n",
      "3136\n",
      "3138\n",
      "3140\n",
      "3142\n",
      "3144\n",
      "3146\n",
      "3148\n",
      "3150\n",
      "3152\n",
      "3154\n",
      "3156\n",
      "3158\n",
      "3160\n",
      "3162\n",
      "3164\n",
      "3166\n",
      "3168\n",
      "3170\n",
      "3172\n",
      "3174\n",
      "3176\n",
      "3178\n",
      "3180\n",
      "3182\n",
      "3184\n",
      "3186\n",
      "3188\n",
      "3190\n",
      "3192\n",
      "3194\n",
      "3196\n",
      "3198\n",
      "3200\n",
      "3202\n",
      "3204\n",
      "3206\n",
      "3208\n",
      "3210\n",
      "3212\n",
      "3214\n",
      "3216\n",
      "3218\n",
      "3220\n",
      "3222\n",
      "3224\n",
      "3226\n",
      "3228\n",
      "3230\n",
      "3232\n",
      "3234\n",
      "3236\n",
      "3238\n",
      "3240\n",
      "3242\n",
      "3244\n",
      "3246\n",
      "3248\n",
      "3250\n",
      "3252\n",
      "3254\n",
      "3256\n",
      "3258\n",
      "3260\n",
      "3262\n",
      "3264\n",
      "3266\n",
      "3268\n",
      "3270\n",
      "3272\n",
      "3274\n",
      "3276\n",
      "3278\n",
      "3280\n",
      "3282\n",
      "3284\n",
      "3286\n",
      "3288\n",
      "3290\n",
      "3292\n",
      "3294\n",
      "3296\n",
      "3298\n",
      "3300\n",
      "3302\n",
      "3304\n",
      "3306\n",
      "3308\n",
      "3310\n",
      "3312\n",
      "3314\n",
      "3316\n",
      "3318\n",
      "3320\n",
      "3322\n",
      "3324\n",
      "3326\n",
      "3328\n",
      "3330\n",
      "3332\n",
      "3334\n",
      "3336\n",
      "3338\n",
      "3340\n",
      "3342\n",
      "3344\n",
      "3346\n",
      "3348\n",
      "3350\n",
      "3352\n",
      "3354\n",
      "3356\n",
      "3358\n",
      "3360\n",
      "3362\n",
      "3364\n",
      "3366\n",
      "3368\n",
      "3370\n",
      "3372\n",
      "3374\n",
      "3376\n",
      "3378\n",
      "3380\n",
      "3382\n",
      "3384\n",
      "3386\n",
      "3388\n",
      "3390\n",
      "3392\n",
      "3394\n",
      "3396\n",
      "3398\n",
      "3400\n",
      "3402\n",
      "3404\n",
      "3406\n",
      "3408\n",
      "3410\n",
      "3412\n",
      "3414\n",
      "3416\n",
      "3418\n",
      "3420\n",
      "3422\n",
      "3424\n",
      "3426\n",
      "3428\n",
      "3430\n",
      "3432\n",
      "3434\n",
      "3436\n",
      "3438\n",
      "3440\n",
      "3442\n",
      "3444\n",
      "3446\n",
      "3448\n",
      "3450\n",
      "3452\n",
      "3454\n",
      "3456\n",
      "3458\n",
      "3460\n",
      "3462\n",
      "3464\n",
      "3466\n",
      "3468\n",
      "3470\n",
      "3472\n",
      "3474\n",
      "3476\n",
      "3478\n",
      "3480\n",
      "3482\n",
      "3484\n",
      "3486\n",
      "3488\n",
      "3490\n",
      "3492\n",
      "3494\n",
      "3496\n",
      "3498\n",
      "3500\n",
      "3502\n",
      "3504\n",
      "3506\n",
      "3508\n",
      "3510\n",
      "3512\n",
      "3514\n",
      "3516\n",
      "3518\n",
      "3520\n",
      "3522\n",
      "3524\n",
      "3526\n",
      "3528\n",
      "3530\n",
      "3532\n",
      "3534\n",
      "3536\n",
      "3538\n",
      "3540\n",
      "3542\n",
      "3544\n",
      "3546\n",
      "3548\n",
      "3550\n",
      "3552\n",
      "3554\n",
      "3556\n",
      "3558\n",
      "3560\n",
      "3562\n",
      "3564\n",
      "3566\n",
      "3568\n",
      "3570\n",
      "3572\n",
      "3574\n",
      "3576\n",
      "3578\n",
      "3580\n",
      "3582\n",
      "3584\n",
      "3586\n",
      "3588\n",
      "3590\n",
      "3592\n",
      "3594\n",
      "3596\n",
      "3598\n",
      "3600\n",
      "3602\n",
      "3604\n",
      "3606\n",
      "3608\n",
      "3610\n",
      "3612\n",
      "3614\n",
      "3616\n",
      "3618\n",
      "3620\n",
      "3622\n",
      "3624\n",
      "3626\n",
      "3628\n",
      "3630\n",
      "3632\n",
      "3634\n",
      "3636\n",
      "3638\n",
      "3640\n",
      "3642\n",
      "3644\n",
      "3646\n",
      "3648\n",
      "3650\n",
      "3652\n",
      "3654\n",
      "3656\n",
      "3658\n",
      "3660\n",
      "3662\n",
      "3664\n",
      "3666\n",
      "3668\n",
      "3670\n",
      "3672\n",
      "3674\n",
      "3676\n",
      "3678\n",
      "3680\n",
      "3682\n",
      "3684\n",
      "3686\n",
      "3688\n",
      "3690\n",
      "3692\n",
      "3694\n",
      "3696\n",
      "3698\n",
      "3700\n",
      "3702\n",
      "3704\n",
      "3706\n",
      "3708\n",
      "3710\n",
      "3712\n",
      "3714\n",
      "3716\n",
      "3718\n",
      "3720\n",
      "3722\n",
      "3724\n",
      "3726\n",
      "3728\n",
      "3730\n",
      "3732\n",
      "3734\n",
      "3736\n",
      "3738\n",
      "3740\n",
      "3742\n",
      "3744\n",
      "3746\n",
      "3748\n",
      "3750\n",
      "3752\n",
      "3754\n",
      "3756\n",
      "3758\n",
      "3760\n",
      "3762\n",
      "3764\n",
      "3766\n",
      "3768\n",
      "3770\n",
      "3772\n",
      "3774\n",
      "3776\n",
      "3778\n",
      "3780\n",
      "3782\n",
      "3784\n",
      "3786\n",
      "3788\n",
      "3790\n",
      "3792\n",
      "3794\n",
      "3796\n",
      "3798\n",
      "3800\n",
      "3802\n",
      "3804\n",
      "3806\n",
      "3808\n",
      "3810\n",
      "3812\n",
      "3814\n",
      "3816\n",
      "3818\n",
      "3820\n",
      "3822\n",
      "3824\n",
      "3826\n",
      "3828\n",
      "3830\n",
      "3832\n",
      "3834\n",
      "3836\n",
      "3838\n",
      "3840\n",
      "3842\n",
      "3844\n",
      "3846\n",
      "3848\n",
      "3850\n",
      "3852\n",
      "3854\n",
      "3856\n",
      "3858\n",
      "3860\n",
      "3862\n",
      "3864\n",
      "3866\n",
      "3868\n",
      "3870\n",
      "3872\n",
      "3874\n",
      "3876\n",
      "3878\n",
      "3880\n",
      "3882\n",
      "3884\n",
      "3886\n",
      "3888\n",
      "3890\n",
      "3892\n",
      "3894\n",
      "3896\n",
      "3898\n",
      "3900\n",
      "3902\n",
      "3904\n",
      "3906\n",
      "3908\n",
      "3910\n",
      "3912\n",
      "3914\n",
      "3916\n",
      "3918\n",
      "3920\n",
      "3922\n",
      "3924\n",
      "3926\n",
      "3928\n",
      "3930\n",
      "3932\n",
      "3934\n",
      "3936\n",
      "3938\n",
      "3940\n",
      "3942\n",
      "3944\n",
      "3946\n",
      "3948\n",
      "3950\n",
      "3952\n",
      "3954\n",
      "3956\n",
      "3958\n",
      "3960\n",
      "3962\n",
      "3964\n",
      "3966\n",
      "3968\n",
      "3970\n",
      "3972\n",
      "3974\n",
      "3976\n",
      "3978\n",
      "3980\n",
      "3982\n",
      "3984\n",
      "3986\n",
      "3988\n",
      "3990\n",
      "3992\n",
      "3994\n",
      "3996\n",
      "3998\n",
      "4000\n",
      "4002\n",
      "4004\n",
      "4006\n",
      "4008\n",
      "4010\n",
      "4012\n",
      "4014\n",
      "4016\n",
      "4018\n",
      "4020\n",
      "4022\n",
      "4024\n",
      "4026\n",
      "4028\n",
      "4030\n",
      "4032\n",
      "4034\n",
      "4036\n",
      "4038\n",
      "4040\n",
      "4042\n",
      "4044\n",
      "4046\n",
      "4048\n",
      "4050\n",
      "4052\n",
      "4054\n",
      "4056\n",
      "4058\n",
      "4060\n",
      "4062\n",
      "4064\n",
      "4066\n",
      "4068\n",
      "4070\n",
      "4072\n",
      "4074\n",
      "4076\n",
      "4078\n",
      "4080\n",
      "4082\n",
      "4084\n",
      "4086\n",
      "4088\n",
      "4090\n",
      "4092\n",
      "4094\n",
      "4096\n",
      "4098\n",
      "4100\n",
      "4102\n",
      "4104\n",
      "4106\n",
      "4108\n",
      "4110\n",
      "4112\n",
      "4114\n",
      "4116\n",
      "4118\n",
      "4120\n",
      "4122\n",
      "4124\n",
      "4126\n",
      "4128\n",
      "4130\n",
      "4132\n",
      "4134\n",
      "4136\n",
      "4138\n",
      "4140\n",
      "4142\n",
      "4144\n",
      "4146\n",
      "4148\n",
      "4150\n",
      "4152\n",
      "4154\n",
      "4156\n",
      "4158\n",
      "4160\n",
      "4162\n",
      "4164\n",
      "4166\n",
      "4168\n",
      "4170\n",
      "4172\n",
      "4174\n",
      "4176\n",
      "4178\n",
      "4180\n",
      "4182\n",
      "4184\n",
      "4186\n",
      "4188\n",
      "4190\n",
      "4192\n",
      "4194\n",
      "4196\n",
      "4198\n",
      "4200\n",
      "4202\n",
      "4204\n",
      "4206\n",
      "4208\n",
      "4210\n",
      "4212\n",
      "4214\n",
      "4216\n",
      "4218\n",
      "4220\n",
      "4222\n",
      "4224\n",
      "4226\n",
      "4228\n",
      "4230\n",
      "4232\n",
      "4234\n",
      "4236\n",
      "4238\n",
      "4240\n",
      "4242\n",
      "4244\n",
      "4246\n",
      "4248\n",
      "4250\n",
      "4252\n",
      "4254\n",
      "4256\n",
      "4258\n",
      "4260\n",
      "4262\n",
      "4264\n",
      "4266\n",
      "4268\n",
      "4270\n",
      "4272\n",
      "4274\n",
      "4276\n",
      "4278\n",
      "4280\n",
      "4282\n",
      "4284\n",
      "4286\n",
      "4288\n",
      "4290\n",
      "4292\n",
      "4294\n",
      "4296\n",
      "4298\n",
      "4300\n",
      "4302\n",
      "4304\n",
      "4306\n",
      "4308\n",
      "4310\n",
      "4312\n",
      "4314\n",
      "4316\n",
      "4318\n",
      "4320\n",
      "4322\n",
      "4324\n",
      "4326\n",
      "4328\n",
      "4330\n",
      "4332\n",
      "4334\n",
      "4336\n",
      "4338\n",
      "4340\n",
      "4342\n",
      "4344\n",
      "4346\n",
      "4348\n",
      "4350\n",
      "4352\n",
      "4354\n",
      "4356\n",
      "4358\n",
      "4360\n",
      "4362\n",
      "4364\n",
      "4366\n",
      "4368\n",
      "4370\n",
      "4372\n",
      "4374\n",
      "4376\n",
      "4378\n",
      "4380\n",
      "4382\n",
      "4384\n",
      "4386\n",
      "4388\n",
      "4390\n",
      "4392\n",
      "4394\n",
      "4396\n",
      "4398\n",
      "4400\n",
      "4402\n",
      "4404\n",
      "4406\n",
      "4408\n",
      "4410\n",
      "4412\n",
      "4414\n",
      "4416\n",
      "4418\n",
      "4420\n",
      "4422\n",
      "4424\n",
      "4426\n",
      "4428\n",
      "4430\n",
      "4432\n",
      "4434\n",
      "4436\n",
      "4438\n",
      "4440\n",
      "4442\n",
      "4444\n",
      "4446\n",
      "4448\n",
      "4450\n",
      "4452\n",
      "4454\n",
      "4456\n",
      "4458\n",
      "4460\n",
      "4462\n",
      "4464\n",
      "4466\n",
      "4468\n",
      "4470\n",
      "4472\n",
      "4474\n",
      "4476\n",
      "4478\n",
      "4480\n",
      "4482\n",
      "4484\n",
      "4486\n",
      "4488\n",
      "4490\n",
      "4492\n",
      "4494\n",
      "4496\n",
      "4498\n",
      "4500\n",
      "4502\n",
      "4504\n",
      "4506\n",
      "4508\n",
      "4510\n",
      "4512\n",
      "4514\n",
      "4516\n",
      "4518\n",
      "4520\n",
      "4522\n",
      "4524\n",
      "4526\n",
      "4528\n",
      "4530\n",
      "4532\n",
      "4534\n",
      "4536\n",
      "4538\n",
      "4540\n",
      "4542\n",
      "4544\n",
      "4546\n",
      "4548\n",
      "4550\n",
      "4552\n",
      "4554\n",
      "4556\n",
      "4558\n",
      "4560\n",
      "4562\n",
      "4564\n",
      "4566\n",
      "4568\n",
      "4570\n",
      "4572\n",
      "4574\n",
      "4576\n",
      "4578\n",
      "4580\n",
      "4582\n",
      "4584\n",
      "4586\n",
      "4588\n",
      "4590\n",
      "4592\n",
      "4594\n",
      "4596\n",
      "4598\n",
      "4600\n",
      "4602\n",
      "4604\n",
      "4606\n",
      "4608\n",
      "4610\n",
      "4612\n",
      "4614\n",
      "4616\n",
      "4618\n",
      "4620\n",
      "4622\n",
      "4624\n",
      "4626\n",
      "4628\n",
      "4630\n",
      "4632\n",
      "4634\n",
      "4636\n",
      "4638\n",
      "4640\n",
      "4642\n",
      "4644\n",
      "4646\n",
      "4648\n",
      "4650\n",
      "4652\n",
      "4654\n",
      "4656\n",
      "4658\n",
      "4660\n",
      "4662\n",
      "4664\n",
      "4666\n",
      "4668\n",
      "4670\n",
      "4672\n",
      "4674\n",
      "4676\n",
      "4678\n",
      "4680\n",
      "4682\n",
      "4684\n",
      "4686\n",
      "4688\n",
      "4690\n",
      "4692\n",
      "4694\n",
      "4696\n",
      "4698\n",
      "4700\n",
      "4702\n",
      "4704\n",
      "4706\n",
      "4708\n",
      "4710\n",
      "4712\n",
      "4714\n",
      "4716\n",
      "4718\n",
      "4720\n",
      "4722\n",
      "4724\n",
      "4726\n",
      "4728\n",
      "4730\n",
      "4732\n",
      "4734\n",
      "4736\n",
      "4738\n",
      "4740\n",
      "4742\n",
      "4744\n",
      "4746\n",
      "4748\n",
      "4750\n",
      "4752\n",
      "4754\n",
      "4756\n",
      "4758\n",
      "4760\n",
      "4762\n",
      "4764\n",
      "4766\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4768\n",
      "4770\n",
      "4772\n",
      "4774\n",
      "4776\n",
      "4778\n",
      "4780\n",
      "4782\n",
      "4784\n",
      "4786\n",
      "4788\n",
      "4790\n",
      "4792\n",
      "4794\n",
      "4796\n",
      "4798\n",
      "4800\n",
      "4802\n",
      "4804\n",
      "4806\n",
      "4808\n",
      "4810\n",
      "4812\n",
      "4814\n",
      "4816\n",
      "4818\n",
      "4820\n",
      "4822\n",
      "4824\n",
      "4826\n",
      "4828\n",
      "4830\n",
      "4832\n",
      "4834\n",
      "4836\n",
      "4838\n",
      "4840\n",
      "4842\n",
      "4844\n",
      "4846\n",
      "4848\n",
      "4850\n",
      "4852\n",
      "4854\n",
      "4856\n",
      "4858\n",
      "4860\n",
      "4862\n",
      "4864\n",
      "4866\n",
      "4868\n",
      "4870\n",
      "4872\n",
      "4874\n",
      "4876\n",
      "4878\n",
      "4880\n",
      "4882\n",
      "4884\n",
      "4886\n",
      "4888\n",
      "4890\n",
      "4892\n",
      "4894\n",
      "4896\n",
      "4898\n",
      "4900\n",
      "4902\n",
      "4904\n",
      "4906\n",
      "4908\n",
      "4910\n",
      "4912\n",
      "4914\n",
      "4916\n",
      "4918\n",
      "4920\n",
      "4922\n",
      "4924\n",
      "4926\n",
      "4928\n",
      "4930\n",
      "4932\n",
      "4934\n",
      "4936\n",
      "4938\n",
      "4940\n",
      "4942\n",
      "4944\n",
      "4946\n",
      "4948\n",
      "4950\n",
      "4952\n",
      "4954\n",
      "4956\n",
      "4958\n",
      "4960\n",
      "4962\n",
      "4964\n",
      "4966\n",
      "4968\n",
      "4970\n",
      "4972\n",
      "4974\n",
      "4976\n",
      "4978\n",
      "4980\n",
      "4982\n",
      "4984\n",
      "4986\n",
      "4988\n",
      "4990\n",
      "4992\n",
      "4994\n",
      "4996\n",
      "4998\n",
      "5000\n",
      "5002\n",
      "5004\n",
      "5006\n",
      "5008\n",
      "5010\n",
      "5012\n",
      "5014\n",
      "5016\n",
      "5018\n",
      "5020\n",
      "5022\n",
      "5024\n",
      "5026\n",
      "5028\n",
      "5030\n",
      "5032\n",
      "5034\n",
      "5036\n",
      "5038\n",
      "5040\n",
      "5042\n",
      "5044\n",
      "5046\n",
      "5048\n",
      "5050\n",
      "5052\n",
      "5054\n",
      "5056\n",
      "5058\n",
      "5060\n",
      "5062\n",
      "5064\n",
      "5066\n",
      "5068\n",
      "5070\n",
      "5072\n",
      "5074\n",
      "5076\n",
      "5078\n",
      "5080\n",
      "5082\n",
      "5084\n",
      "5086\n",
      "5088\n",
      "5090\n",
      "5092\n",
      "5094\n",
      "5096\n",
      "5098\n",
      "5100\n",
      "5102\n",
      "5104\n",
      "5106\n",
      "5108\n",
      "5110\n",
      "5112\n",
      "5114\n",
      "5116\n",
      "5118\n",
      "5120\n",
      "5122\n",
      "5124\n",
      "5126\n",
      "5128\n",
      "5130\n",
      "5132\n",
      "5134\n",
      "5136\n",
      "5138\n",
      "5140\n",
      "5142\n",
      "5144\n",
      "5146\n",
      "5148\n",
      "5150\n",
      "5152\n",
      "5154\n",
      "5156\n",
      "5158\n",
      "5160\n",
      "5162\n",
      "5164\n",
      "5166\n",
      "5168\n",
      "5170\n",
      "5172\n",
      "5174\n",
      "5176\n",
      "5178\n",
      "5180\n",
      "5182\n",
      "5184\n",
      "5186\n",
      "5188\n",
      "5190\n",
      "5192\n",
      "5194\n",
      "5196\n",
      "5198\n",
      "5200\n",
      "5202\n",
      "5204\n",
      "5206\n",
      "5208\n",
      "5210\n",
      "5212\n",
      "5214\n",
      "5216\n",
      "5218\n",
      "5220\n",
      "5222\n",
      "5224\n",
      "5226\n",
      "5228\n",
      "5230\n",
      "5232\n",
      "5234\n",
      "5236\n",
      "5238\n",
      "5240\n",
      "5242\n",
      "5244\n",
      "5246\n",
      "5248\n",
      "5250\n",
      "5252\n",
      "5254\n",
      "5256\n",
      "5258\n",
      "5260\n",
      "5262\n",
      "5264\n",
      "5266\n",
      "5268\n",
      "5270\n",
      "5272\n",
      "5274\n",
      "5276\n",
      "5278\n",
      "5280\n",
      "5282\n",
      "5284\n",
      "5286\n",
      "5288\n",
      "5290\n",
      "5292\n",
      "5294\n",
      "5296\n",
      "5298\n",
      "5300\n",
      "5302\n",
      "5304\n",
      "5306\n",
      "5308\n",
      "5310\n",
      "5312\n",
      "5314\n",
      "5316\n",
      "5318\n",
      "5320\n",
      "5322\n",
      "5324\n",
      "5326\n",
      "5328\n",
      "5330\n",
      "5332\n",
      "5334\n",
      "5336\n",
      "5338\n",
      "5340\n",
      "5342\n",
      "5344\n",
      "5346\n",
      "5348\n",
      "5350\n",
      "5352\n",
      "5354\n",
      "5356\n",
      "5358\n",
      "5360\n",
      "5362\n",
      "5364\n",
      "5366\n",
      "5368\n",
      "5370\n",
      "5372\n",
      "5374\n",
      "5376\n",
      "5378\n",
      "5380\n",
      "5382\n",
      "5384\n",
      "5386\n",
      "5388\n",
      "5390\n",
      "5392\n",
      "5394\n",
      "5396\n",
      "5398\n",
      "5400\n",
      "5402\n",
      "5404\n",
      "5406\n",
      "5408\n",
      "5410\n",
      "5412\n",
      "5414\n",
      "5416\n",
      "5418\n",
      "5420\n",
      "5422\n",
      "5424\n",
      "5426\n",
      "5428\n",
      "5430\n",
      "5432\n",
      "5434\n",
      "5436\n",
      "5438\n",
      "5440\n",
      "5442\n",
      "5444\n",
      "5446\n",
      "5448\n",
      "5450\n",
      "5452\n",
      "5454\n",
      "5456\n",
      "5458\n",
      "5460\n",
      "5462\n",
      "5464\n",
      "5466\n",
      "5468\n",
      "5470\n",
      "5472\n",
      "5474\n",
      "5476\n",
      "5478\n",
      "5480\n",
      "5482\n",
      "5484\n",
      "5486\n",
      "5488\n",
      "5490\n",
      "5492\n",
      "5494\n",
      "5496\n",
      "5498\n",
      "5500\n",
      "5502\n",
      "5504\n",
      "5506\n",
      "5508\n",
      "5510\n",
      "5512\n",
      "5514\n",
      "5516\n",
      "5518\n",
      "5520\n",
      "5522\n",
      "5524\n",
      "5526\n",
      "5528\n",
      "5530\n",
      "5532\n",
      "5534\n",
      "5536\n",
      "5538\n",
      "5540\n",
      "5542\n",
      "5544\n",
      "5546\n",
      "5548\n",
      "5550\n",
      "5552\n",
      "5554\n",
      "5556\n",
      "5558\n",
      "5560\n",
      "5562\n",
      "5564\n",
      "5566\n",
      "5568\n",
      "5570\n",
      "5572\n",
      "5574\n",
      "5576\n",
      "5578\n",
      "5580\n",
      "5582\n",
      "5584\n",
      "5586\n",
      "5588\n",
      "5590\n",
      "5592\n",
      "5594\n",
      "5596\n",
      "5598\n",
      "5600\n",
      "5602\n",
      "5604\n",
      "5606\n",
      "5608\n",
      "5610\n",
      "5612\n",
      "5614\n",
      "5616\n",
      "5618\n",
      "5620\n",
      "5622\n",
      "5624\n",
      "5626\n",
      "5628\n",
      "5630\n",
      "5632\n",
      "5634\n",
      "5636\n",
      "5638\n",
      "5640\n",
      "5642\n",
      "5644\n",
      "5646\n",
      "5648\n",
      "5650\n",
      "5652\n",
      "5654\n",
      "5656\n",
      "5658\n",
      "5660\n",
      "5662\n",
      "5664\n",
      "5666\n",
      "5668\n",
      "5670\n",
      "5672\n",
      "5674\n",
      "5676\n",
      "5678\n",
      "5680\n",
      "5682\n",
      "5684\n",
      "5686\n",
      "5688\n",
      "5690\n",
      "5692\n",
      "5694\n",
      "5696\n",
      "5698\n",
      "5700\n",
      "5702\n",
      "5704\n",
      "5706\n",
      "5708\n",
      "5710\n",
      "5712\n",
      "5714\n",
      "5716\n",
      "5718\n",
      "5720\n",
      "5722\n",
      "5724\n",
      "5726\n",
      "5728\n",
      "5730\n",
      "5732\n",
      "5734\n",
      "5736\n",
      "5738\n",
      "5740\n",
      "5742\n",
      "5744\n",
      "5746\n",
      "5748\n",
      "5750\n",
      "5752\n",
      "5754\n",
      "5756\n",
      "5758\n",
      "5760\n",
      "5762\n",
      "5764\n",
      "5766\n",
      "5768\n",
      "5770\n",
      "5772\n",
      "5774\n",
      "5776\n",
      "5778\n",
      "5780\n",
      "5782\n",
      "5784\n",
      "5786\n",
      "5788\n",
      "5790\n",
      "5792\n",
      "5794\n",
      "5796\n",
      "5798\n",
      "5800\n",
      "5802\n",
      "5804\n",
      "5806\n",
      "5808\n",
      "5810\n",
      "5812\n",
      "5814\n",
      "5816\n",
      "5818\n",
      "5820\n",
      "5822\n",
      "5824\n",
      "5826\n",
      "5828\n",
      "5830\n",
      "5832\n",
      "5834\n",
      "5836\n",
      "5838\n",
      "5840\n",
      "5842\n",
      "5844\n",
      "5846\n",
      "5848\n",
      "5850\n",
      "5852\n",
      "5854\n",
      "5856\n",
      "5858\n",
      "5860\n",
      "5862\n",
      "5864\n",
      "5866\n",
      "5868\n",
      "5870\n",
      "5872\n",
      "5874\n",
      "5876\n",
      "5878\n",
      "5880\n",
      "5882\n",
      "5884\n",
      "5886\n",
      "5888\n",
      "5890\n",
      "5892\n",
      "5894\n",
      "5896\n",
      "5898\n",
      "5900\n",
      "5902\n",
      "5904\n",
      "5906\n",
      "5908\n",
      "5910\n",
      "5912\n",
      "5914\n",
      "5916\n",
      "5918\n",
      "5920\n",
      "5922\n",
      "5924\n",
      "5926\n",
      "5928\n",
      "5930\n",
      "5932\n",
      "5934\n",
      "5936\n",
      "5938\n",
      "5940\n",
      "5942\n",
      "5944\n",
      "5946\n",
      "5948\n",
      "5950\n",
      "5952\n",
      "5954\n",
      "5956\n",
      "5958\n",
      "5960\n",
      "5962\n",
      "5964\n",
      "5966\n",
      "5968\n",
      "5970\n",
      "5972\n",
      "5974\n",
      "5976\n",
      "5978\n",
      "5980\n",
      "5982\n",
      "5984\n",
      "5986\n",
      "5988\n",
      "5990\n",
      "5992\n",
      "5994\n",
      "5996\n",
      "5998\n",
      "6000\n",
      "6002\n",
      "6004\n",
      "6006\n",
      "6008\n",
      "6010\n",
      "6012\n",
      "6014\n",
      "6016\n",
      "6018\n",
      "6020\n",
      "6022\n",
      "6024\n",
      "6026\n",
      "6028\n",
      "6030\n",
      "6032\n",
      "6034\n",
      "6036\n",
      "6038\n",
      "6040\n",
      "6042\n",
      "6044\n",
      "6046\n",
      "6048\n",
      "6050\n",
      "6052\n",
      "6054\n",
      "6056\n",
      "6058\n",
      "6060\n",
      "6062\n",
      "6064\n",
      "6066\n",
      "6068\n",
      "6070\n",
      "6072\n",
      "6074\n",
      "6076\n",
      "6078\n",
      "6080\n",
      "6082\n",
      "6084\n",
      "6086\n",
      "6088\n",
      "6090\n",
      "6092\n",
      "6094\n",
      "6096\n",
      "6098\n",
      "6100\n",
      "6102\n",
      "6104\n",
      "6106\n",
      "6108\n",
      "6110\n",
      "6112\n",
      "6114\n",
      "6116\n",
      "6118\n",
      "6120\n",
      "6122\n",
      "6124\n",
      "6126\n",
      "6128\n",
      "6130\n",
      "6132\n",
      "6134\n",
      "6136\n",
      "6138\n",
      "6140\n",
      "6142\n",
      "6144\n",
      "6146\n",
      "6148\n",
      "6150\n",
      "6152\n",
      "6154\n",
      "6156\n",
      "6158\n",
      "6160\n",
      "6162\n",
      "6164\n",
      "6166\n",
      "6168\n",
      "6170\n",
      "6172\n",
      "6174\n",
      "6176\n",
      "6178\n",
      "6180\n",
      "6182\n",
      "6184\n",
      "6186\n",
      "6188\n",
      "6190\n",
      "6192\n",
      "6194\n",
      "6196\n",
      "6198\n",
      "6200\n",
      "6202\n",
      "6204\n",
      "6206\n",
      "6208\n",
      "6210\n",
      "6212\n",
      "6214\n",
      "6216\n",
      "6218\n",
      "6220\n",
      "6222\n",
      "6224\n",
      "6226\n",
      "6228\n",
      "6230\n",
      "6232\n",
      "6234\n",
      "6236\n",
      "6238\n",
      "6240\n",
      "6242\n",
      "6244\n",
      "6246\n",
      "6248\n",
      "6250\n",
      "6252\n",
      "6254\n",
      "6256\n",
      "6258\n",
      "6260\n",
      "6262\n",
      "6264\n",
      "6266\n",
      "6268\n",
      "6270\n",
      "6272\n",
      "6274\n",
      "6276\n",
      "6278\n",
      "6280\n",
      "6282\n",
      "6284\n",
      "6286\n",
      "6288\n",
      "6290\n",
      "6292\n",
      "6294\n",
      "6296\n",
      "6298\n",
      "6300\n",
      "6302\n",
      "6304\n",
      "6306\n",
      "6308\n",
      "6310\n",
      "6312\n",
      "6314\n",
      "6316\n",
      "6318\n",
      "6320\n",
      "6322\n",
      "6324\n",
      "6326\n",
      "6328\n",
      "6330\n",
      "6332\n",
      "6334\n",
      "6336\n",
      "6338\n",
      "6340\n",
      "6342\n",
      "6344\n",
      "6346\n",
      "6348\n",
      "6350\n",
      "6352\n",
      "6354\n",
      "6356\n",
      "6358\n",
      "6360\n",
      "6362\n",
      "6364\n",
      "6366\n",
      "6368\n",
      "6370\n",
      "6372\n",
      "6374\n",
      "6376\n",
      "6378\n",
      "6380\n",
      "6382\n",
      "6384\n",
      "6386\n",
      "6388\n",
      "6390\n",
      "6392\n",
      "6394\n",
      "6396\n",
      "6398\n",
      "6400\n",
      "6402\n",
      "6404\n",
      "6406\n",
      "6408\n",
      "6410\n",
      "6412\n",
      "6414\n",
      "6416\n",
      "6418\n",
      "6420\n",
      "6422\n",
      "6424\n",
      "6426\n",
      "6428\n",
      "6430\n",
      "6432\n",
      "6434\n",
      "6436\n",
      "6438\n",
      "6440\n",
      "6442\n",
      "6444\n",
      "6446\n",
      "6448\n",
      "6450\n",
      "6452\n",
      "6454\n",
      "6456\n",
      "6458\n",
      "6460\n",
      "6462\n",
      "6464\n",
      "6466\n",
      "6468\n",
      "6470\n",
      "6472\n",
      "6474\n",
      "6476\n",
      "6478\n",
      "6480\n",
      "6482\n",
      "6484\n",
      "6486\n",
      "6488\n",
      "6490\n",
      "6492\n",
      "6494\n",
      "6496\n",
      "6498\n",
      "6500\n",
      "6502\n",
      "6504\n",
      "6506\n",
      "6508\n",
      "6510\n",
      "6512\n",
      "6514\n",
      "6516\n",
      "6518\n",
      "6520\n",
      "6522\n",
      "6524\n",
      "6526\n",
      "6528\n",
      "6530\n",
      "6532\n",
      "6534\n",
      "6536\n",
      "6538\n",
      "6540\n",
      "6542\n",
      "6544\n",
      "6546\n",
      "6548\n",
      "6550\n",
      "6552\n",
      "6554\n",
      "6556\n",
      "6558\n",
      "6560\n",
      "6562\n",
      "6564\n",
      "6566\n",
      "6568\n",
      "6570\n",
      "6572\n",
      "6574\n",
      "6576\n",
      "6578\n",
      "6580\n",
      "6582\n",
      "6584\n",
      "6586\n",
      "6588\n",
      "6590\n",
      "6592\n",
      "6594\n",
      "6596\n",
      "6598\n",
      "6600\n",
      "6602\n",
      "6604\n",
      "6606\n",
      "6608\n",
      "6610\n",
      "6612\n",
      "6614\n",
      "6616\n",
      "6618\n",
      "6620\n",
      "6622\n",
      "6624\n",
      "6626\n",
      "6628\n",
      "6630\n",
      "6632\n",
      "6634\n",
      "6636\n",
      "6638\n",
      "6640\n",
      "6642\n",
      "6644\n",
      "6646\n",
      "6648\n",
      "6650\n",
      "6652\n",
      "6654\n",
      "6656\n",
      "6658\n",
      "6660\n",
      "6662\n",
      "6664\n",
      "6666\n",
      "6668\n",
      "6670\n",
      "6672\n",
      "6674\n",
      "6676\n",
      "6678\n",
      "6680\n",
      "6682\n",
      "6684\n",
      "6686\n",
      "6688\n",
      "6690\n",
      "6692\n",
      "6694\n",
      "6696\n",
      "6698\n",
      "6700\n",
      "6702\n",
      "6704\n",
      "6706\n",
      "6708\n",
      "6710\n",
      "6712\n",
      "6714\n",
      "6716\n",
      "6718\n",
      "6720\n",
      "6722\n",
      "6724\n",
      "6726\n",
      "6728\n",
      "6730\n",
      "6732\n",
      "6734\n",
      "6736\n",
      "6738\n",
      "6740\n",
      "6742\n",
      "6744\n",
      "6746\n",
      "6748\n",
      "6750\n",
      "6752\n",
      "6754\n",
      "6756\n",
      "6758\n",
      "6760\n",
      "6762\n",
      "6764\n",
      "6766\n",
      "6768\n",
      "6770\n",
      "6772\n",
      "6774\n",
      "6776\n",
      "6778\n",
      "6780\n",
      "6782\n",
      "6784\n",
      "6786\n",
      "6788\n",
      "6790\n",
      "6792\n",
      "6794\n",
      "6796\n",
      "6798\n",
      "6800\n",
      "6802\n",
      "6804\n",
      "6806\n",
      "6808\n",
      "6810\n",
      "6812\n",
      "6814\n",
      "6816\n",
      "6818\n",
      "6820\n",
      "6822\n",
      "6824\n",
      "6826\n",
      "6828\n",
      "6830\n",
      "6832\n",
      "6834\n",
      "6836\n",
      "6838\n",
      "6840\n",
      "6842\n",
      "6844\n",
      "6846\n",
      "6848\n",
      "6850\n",
      "6852\n",
      "6854\n",
      "6856\n",
      "6858\n",
      "6860\n",
      "6862\n",
      "6864\n",
      "6866\n",
      "6868\n",
      "6870\n",
      "6872\n",
      "6874\n",
      "6876\n",
      "6878\n",
      "6880\n",
      "6882\n",
      "6884\n",
      "6886\n",
      "6888\n",
      "6890\n",
      "6892\n",
      "6894\n",
      "6896\n",
      "6898\n",
      "6900\n",
      "6902\n",
      "6904\n",
      "6906\n",
      "6908\n",
      "6910\n",
      "6912\n",
      "6914\n",
      "6916\n",
      "6918\n",
      "6920\n",
      "6922\n",
      "6924\n",
      "6926\n",
      "6928\n",
      "6930\n",
      "6932\n",
      "6934\n",
      "6936\n",
      "6938\n",
      "6940\n",
      "6942\n",
      "6944\n",
      "6946\n",
      "6948\n",
      "6950\n",
      "6952\n",
      "6954\n",
      "6956\n",
      "6958\n",
      "6960\n",
      "6962\n",
      "6964\n",
      "6966\n",
      "6968\n",
      "6970\n",
      "6972\n",
      "6974\n",
      "6976\n",
      "6978\n",
      "6980\n",
      "6982\n",
      "6984\n",
      "6986\n",
      "6988\n",
      "6990\n",
      "6992\n",
      "6994\n",
      "6996\n",
      "6998\n",
      "7000\n",
      "7002\n",
      "7004\n",
      "7006\n",
      "7008\n",
      "7010\n",
      "7012\n",
      "7014\n",
      "7016\n",
      "7018\n",
      "7020\n",
      "7022\n",
      "7024\n",
      "7026\n",
      "7028\n",
      "7030\n",
      "7032\n",
      "7034\n",
      "7036\n",
      "7038\n",
      "7040\n",
      "7042\n",
      "7044\n",
      "7046\n",
      "7048\n",
      "7050\n",
      "7052\n",
      "7054\n",
      "7056\n",
      "7058\n",
      "7060\n",
      "7062\n",
      "7064\n",
      "7066\n",
      "7068\n",
      "7070\n",
      "7072\n",
      "7074\n",
      "7076\n",
      "7078\n",
      "7080\n",
      "7082\n",
      "7084\n",
      "7086\n",
      "7088\n",
      "7090\n",
      "7092\n",
      "7094\n",
      "7096\n",
      "7098\n",
      "7100\n",
      "7102\n",
      "7104\n",
      "7106\n",
      "7108\n",
      "7110\n",
      "7112\n",
      "7114\n",
      "7116\n",
      "7118\n",
      "7120\n",
      "7122\n",
      "7124\n",
      "7126\n",
      "7128\n",
      "7130\n",
      "7132\n",
      "7134\n",
      "7136\n",
      "7138\n",
      "7140\n",
      "7142\n",
      "7144\n",
      "7146\n",
      "7148\n",
      "7150\n",
      "7152\n",
      "7154\n",
      "7156\n",
      "7158\n",
      "7160\n",
      "7162\n",
      "7164\n",
      "7166\n",
      "7168\n",
      "7170\n",
      "7172\n",
      "7174\n",
      "7176\n",
      "7178\n",
      "7180\n",
      "7182\n",
      "7184\n",
      "7186\n",
      "7188\n",
      "7190\n",
      "7192\n",
      "7194\n",
      "7196\n",
      "7198\n",
      "7200\n",
      "7202\n",
      "7204\n",
      "7206\n",
      "7208\n",
      "7210\n",
      "7212\n",
      "7214\n",
      "7216\n",
      "7218\n",
      "7220\n",
      "7222\n",
      "7224\n",
      "7226\n",
      "7228\n",
      "7230\n",
      "7232\n",
      "7234\n",
      "7236\n",
      "7238\n",
      "7240\n",
      "7242\n",
      "7244\n",
      "7246\n",
      "7248\n",
      "7250\n",
      "7252\n",
      "7254\n",
      "7256\n",
      "7258\n",
      "7260\n",
      "7262\n",
      "7264\n",
      "7266\n",
      "7268\n",
      "7270\n",
      "7272\n",
      "7274\n",
      "7276\n",
      "7278\n",
      "7280\n",
      "7282\n",
      "7284\n",
      "7286\n",
      "7288\n",
      "7290\n",
      "7292\n",
      "7294\n",
      "7296\n",
      "7298\n",
      "7300\n",
      "7302\n",
      "7304\n",
      "7306\n",
      "7308\n",
      "7310\n",
      "7312\n",
      "7314\n",
      "7316\n",
      "7318\n",
      "7320\n",
      "7322\n",
      "7324\n",
      "7326\n",
      "7328\n",
      "7330\n",
      "7332\n",
      "7334\n",
      "7336\n",
      "7338\n",
      "7340\n",
      "7342\n",
      "7344\n",
      "7346\n",
      "7348\n",
      "7350\n",
      "7352\n",
      "7354\n",
      "7356\n",
      "7358\n",
      "7360\n",
      "7362\n",
      "7364\n",
      "7366\n",
      "7368\n",
      "7370\n",
      "7372\n",
      "7374\n",
      "7376\n",
      "7378\n",
      "7380\n",
      "7382\n",
      "7384\n",
      "7386\n",
      "7388\n",
      "7390\n",
      "7392\n",
      "7394\n",
      "7396\n",
      "7398\n",
      "7400\n",
      "7402\n",
      "7404\n",
      "7406\n",
      "7408\n",
      "7410\n",
      "7412\n",
      "7414\n",
      "7416\n",
      "7418\n",
      "7420\n",
      "7422\n",
      "7424\n",
      "7426\n",
      "7428\n",
      "7430\n",
      "7432\n",
      "7434\n",
      "7436\n",
      "7438\n",
      "7440\n",
      "7442\n",
      "7444\n",
      "7446\n",
      "7448\n",
      "7450\n",
      "7452\n",
      "7454\n",
      "7456\n",
      "7458\n",
      "7460\n",
      "7462\n",
      "7464\n",
      "7466\n",
      "7468\n",
      "7470\n",
      "7472\n",
      "7474\n",
      "7476\n",
      "7478\n",
      "7480\n",
      "7482\n",
      "7484\n",
      "7486\n",
      "7488\n",
      "7490\n",
      "7492\n",
      "7494\n",
      "7496\n",
      "7498\n",
      "7500\n",
      "7502\n",
      "7504\n",
      "7506\n",
      "7508\n",
      "7510\n",
      "7512\n",
      "7514\n",
      "7516\n",
      "7518\n",
      "7520\n",
      "7522\n",
      "7524\n",
      "7526\n",
      "7528\n",
      "7530\n",
      "7532\n",
      "7534\n",
      "7536\n",
      "7538\n",
      "7540\n",
      "7542\n",
      "7544\n",
      "7546\n",
      "7548\n",
      "7550\n",
      "7552\n",
      "7554\n",
      "7556\n",
      "7558\n",
      "7560\n",
      "7562\n",
      "7564\n",
      "7566\n",
      "7568\n",
      "7570\n",
      "7572\n",
      "7574\n",
      "7576\n",
      "7578\n",
      "7580\n",
      "7582\n",
      "7584\n",
      "7586\n",
      "7588\n",
      "7590\n",
      "7592\n",
      "7594\n",
      "7596\n",
      "7598\n",
      "7600\n",
      "7602\n",
      "7604\n",
      "7606\n",
      "7608\n",
      "7610\n",
      "7612\n",
      "7614\n",
      "7616\n",
      "7618\n",
      "7620\n",
      "7622\n",
      "7624\n",
      "7626\n",
      "7628\n",
      "7630\n",
      "7632\n",
      "7634\n",
      "7636\n",
      "7638\n",
      "7640\n",
      "7642\n",
      "7644\n",
      "7646\n",
      "7648\n",
      "7650\n",
      "7652\n",
      "7654\n",
      "7656\n",
      "7658\n",
      "7660\n",
      "7662\n",
      "7664\n",
      "7666\n",
      "7668\n",
      "7670\n",
      "7672\n",
      "7674\n",
      "7676\n",
      "7678\n",
      "7680\n",
      "7682\n",
      "7684\n",
      "7686\n",
      "7688\n",
      "7690\n",
      "7692\n",
      "7694\n",
      "7696\n",
      "7698\n",
      "7700\n",
      "7702\n",
      "7704\n",
      "7706\n",
      "7708\n",
      "7710\n",
      "7712\n",
      "7714\n",
      "7716\n",
      "7718\n",
      "7720\n",
      "7722\n",
      "7724\n",
      "7726\n",
      "7728\n",
      "7730\n",
      "7732\n",
      "7734\n",
      "7736\n",
      "7738\n",
      "7740\n",
      "7742\n",
      "7744\n",
      "7746\n",
      "7748\n",
      "7750\n",
      "7752\n",
      "7754\n",
      "7756\n",
      "7758\n",
      "7760\n",
      "7762\n",
      "7764\n",
      "7766\n",
      "7768\n",
      "7770\n",
      "7772\n",
      "7774\n",
      "7776\n",
      "7778\n",
      "7780\n",
      "7782\n",
      "7784\n",
      "7786\n",
      "7788\n",
      "7790\n",
      "7792\n",
      "7794\n",
      "7796\n",
      "7798\n",
      "7800\n",
      "7802\n",
      "7804\n",
      "7806\n",
      "7808\n",
      "7810\n",
      "7812\n",
      "7814\n",
      "7816\n",
      "7818\n",
      "7820\n",
      "7822\n",
      "7824\n",
      "7826\n",
      "7828\n",
      "7830\n",
      "7832\n",
      "7834\n",
      "7836\n",
      "7838\n",
      "7840\n",
      "7842\n",
      "7844\n",
      "7846\n",
      "7848\n",
      "7850\n",
      "7852\n",
      "7854\n",
      "7856\n",
      "7858\n",
      "7860\n",
      "7862\n",
      "7864\n",
      "7866\n",
      "7868\n",
      "7870\n",
      "7872\n",
      "7874\n",
      "7876\n",
      "7878\n",
      "7880\n",
      "7882\n",
      "7884\n",
      "7886\n",
      "7888\n",
      "7890\n",
      "7892\n",
      "7894\n",
      "7896\n",
      "7898\n",
      "7900\n",
      "7902\n",
      "7904\n",
      "7906\n",
      "7908\n",
      "7910\n",
      "7912\n",
      "7914\n",
      "7916\n",
      "7918\n",
      "7920\n",
      "7922\n",
      "7924\n",
      "7926\n",
      "7928\n",
      "7930\n",
      "7932\n",
      "7934\n",
      "7936\n",
      "7938\n",
      "7940\n",
      "7942\n",
      "7944\n",
      "7946\n",
      "7948\n",
      "7950\n",
      "7952\n",
      "7954\n",
      "7956\n",
      "7958\n",
      "7960\n",
      "7962\n",
      "7964\n",
      "7966\n",
      "7968\n",
      "7970\n",
      "7972\n",
      "7974\n",
      "7976\n",
      "7978\n",
      "7980\n",
      "7982\n",
      "7984\n",
      "7986\n",
      "7988\n",
      "7990\n",
      "7992\n",
      "7994\n",
      "7996\n",
      "7998\n",
      "8000\n",
      "8002\n",
      "8004\n",
      "8006\n",
      "8008\n",
      "8010\n",
      "8012\n",
      "8014\n",
      "8016\n",
      "8018\n",
      "8020\n",
      "8022\n",
      "8024\n",
      "8026\n",
      "8028\n",
      "8030\n",
      "8032\n",
      "8034\n",
      "8036\n",
      "8038\n",
      "8040\n",
      "8042\n",
      "8044\n",
      "8046\n",
      "8048\n",
      "8050\n",
      "8052\n",
      "8054\n",
      "8056\n",
      "8058\n",
      "8060\n",
      "8062\n",
      "8064\n",
      "8066\n",
      "8068\n",
      "8070\n",
      "8072\n",
      "8074\n",
      "8076\n",
      "8078\n",
      "8080\n",
      "8082\n",
      "8084\n",
      "8086\n",
      "8088\n",
      "8090\n",
      "8092\n",
      "8094\n",
      "8096\n",
      "8098\n",
      "8100\n",
      "8102\n",
      "8104\n",
      "8106\n",
      "8108\n",
      "8110\n",
      "8112\n",
      "8114\n",
      "8116\n",
      "8118\n",
      "8120\n",
      "8122\n",
      "8124\n",
      "8126\n",
      "8128\n",
      "8130\n",
      "8132\n",
      "8134\n",
      "8136\n",
      "8138\n",
      "8140\n",
      "8142\n",
      "8144\n",
      "8146\n",
      "8148\n",
      "8150\n",
      "8152\n",
      "8154\n",
      "8156\n",
      "8158\n",
      "8160\n",
      "8162\n",
      "8164\n",
      "8166\n",
      "8168\n",
      "8170\n",
      "8172\n",
      "8174\n",
      "8176\n",
      "8178\n",
      "8180\n",
      "8182\n",
      "8184\n",
      "8186\n",
      "8188\n",
      "8190\n",
      "8192\n",
      "8194\n",
      "8196\n",
      "8198\n",
      "8200\n",
      "8202\n",
      "8204\n",
      "8206\n",
      "8208\n",
      "8210\n",
      "8212\n",
      "8214\n",
      "8216\n",
      "8218\n",
      "8220\n",
      "8222\n",
      "8224\n",
      "8226\n",
      "8228\n",
      "8230\n",
      "8232\n",
      "8234\n",
      "8236\n",
      "8238\n",
      "8240\n",
      "8242\n",
      "8244\n",
      "8246\n",
      "8248\n",
      "8250\n",
      "8252\n",
      "8254\n",
      "8256\n",
      "8258\n",
      "8260\n",
      "8262\n",
      "8264\n",
      "8266\n",
      "8268\n",
      "8270\n",
      "8272\n",
      "8274\n",
      "8276\n",
      "8278\n",
      "8280\n",
      "8282\n",
      "8284\n",
      "8286\n",
      "8288\n",
      "8290\n",
      "8292\n",
      "8294\n",
      "8296\n",
      "8298\n",
      "8300\n",
      "8302\n",
      "8304\n",
      "8306\n",
      "8308\n",
      "8310\n",
      "8312\n",
      "8314\n",
      "8316\n",
      "8318\n",
      "8320\n",
      "8322\n",
      "8324\n",
      "8326\n",
      "8328\n",
      "8330\n",
      "8332\n",
      "8334\n",
      "8336\n",
      "8338\n",
      "8340\n",
      "8342\n",
      "8344\n",
      "8346\n",
      "8348\n",
      "8350\n",
      "8352\n",
      "8354\n",
      "8356\n",
      "8358\n",
      "8360\n",
      "8362\n",
      "8364\n",
      "8366\n",
      "8368\n",
      "8370\n",
      "8372\n",
      "8374\n",
      "8376\n",
      "8378\n",
      "8380\n",
      "8382\n",
      "8384\n",
      "8386\n",
      "8388\n",
      "8390\n",
      "8392\n",
      "8394\n",
      "8396\n",
      "8398\n",
      "8400\n",
      "8402\n",
      "8404\n",
      "8406\n",
      "8408\n",
      "8410\n",
      "8412\n",
      "8414\n",
      "8416\n",
      "8418\n",
      "8420\n",
      "8422\n",
      "8424\n",
      "8426\n",
      "8428\n",
      "8430\n",
      "8432\n",
      "8434\n",
      "8436\n",
      "8438\n",
      "8440\n",
      "8442\n",
      "8444\n",
      "8446\n",
      "8448\n",
      "8450\n",
      "8452\n",
      "8454\n",
      "8456\n",
      "8458\n",
      "8460\n",
      "8462\n",
      "8464\n",
      "8466\n",
      "8468\n",
      "8470\n",
      "8472\n",
      "8474\n",
      "8476\n",
      "8478\n",
      "8480\n",
      "8482\n",
      "8484\n",
      "8486\n",
      "8488\n",
      "8490\n",
      "8492\n",
      "8494\n",
      "8496\n",
      "8498\n",
      "8500\n",
      "8502\n",
      "8504\n",
      "8506\n",
      "8508\n",
      "8510\n",
      "8512\n",
      "8514\n",
      "8516\n",
      "8518\n",
      "8520\n",
      "8522\n",
      "8524\n",
      "8526\n",
      "8528\n",
      "8530\n",
      "8532\n",
      "8534\n",
      "8536\n",
      "8538\n",
      "8540\n",
      "8542\n",
      "8544\n",
      "8546\n",
      "8548\n",
      "8550\n",
      "8552\n",
      "8554\n",
      "8556\n",
      "8558\n",
      "8560\n",
      "8562\n",
      "8564\n",
      "8566\n",
      "8568\n",
      "8570\n",
      "8572\n",
      "8574\n",
      "8576\n",
      "8578\n",
      "8580\n",
      "8582\n",
      "8584\n",
      "8586\n",
      "8588\n",
      "8590\n",
      "8592\n",
      "8594\n",
      "8596\n",
      "8598\n",
      "8600\n",
      "8602\n",
      "8604\n",
      "8606\n",
      "8608\n",
      "8610\n",
      "8612\n",
      "8614\n",
      "8616\n",
      "8618\n",
      "8620\n",
      "8622\n",
      "8624\n",
      "8626\n",
      "8628\n",
      "8630\n",
      "8632\n",
      "8634\n",
      "8636\n",
      "8638\n",
      "8640\n",
      "8642\n",
      "8644\n",
      "8646\n",
      "8648\n",
      "8650\n",
      "8652\n",
      "8654\n",
      "8656\n",
      "8658\n",
      "8660\n",
      "8662\n",
      "8664\n",
      "8666\n",
      "8668\n",
      "8670\n",
      "8672\n",
      "8674\n",
      "8676\n",
      "8678\n",
      "8680\n",
      "8682\n",
      "8684\n",
      "8686\n",
      "8688\n",
      "8690\n",
      "8692\n",
      "8694\n",
      "8696\n",
      "8698\n",
      "8700\n",
      "8702\n",
      "8704\n",
      "8706\n",
      "8708\n",
      "8710\n",
      "8712\n",
      "8714\n",
      "8716\n",
      "8718\n",
      "8720\n",
      "8722\n",
      "8724\n",
      "8726\n",
      "8728\n",
      "8730\n",
      "8732\n",
      "8734\n",
      "8736\n",
      "8738\n",
      "8740\n",
      "8742\n",
      "8744\n",
      "8746\n",
      "8748\n",
      "8750\n",
      "8752\n",
      "8754\n",
      "8756\n",
      "8758\n",
      "8760\n",
      "8762\n",
      "8764\n",
      "8766\n",
      "8768\n",
      "8770\n",
      "8772\n",
      "8774\n",
      "8776\n",
      "8778\n",
      "8780\n",
      "8782\n",
      "8784\n",
      "8786\n",
      "8788\n",
      "8790\n",
      "8792\n",
      "8794\n",
      "8796\n",
      "8798\n",
      "8800\n",
      "8802\n",
      "8804\n",
      "8806\n",
      "8808\n",
      "8810\n",
      "8812\n",
      "8814\n",
      "8816\n",
      "8818\n",
      "8820\n",
      "8822\n",
      "8824\n",
      "8826\n",
      "8828\n",
      "8830\n",
      "8832\n",
      "8834\n",
      "8836\n",
      "8838\n",
      "8840\n",
      "8842\n",
      "8844\n",
      "8846\n",
      "8848\n",
      "8850\n",
      "8852\n",
      "8854\n",
      "8856\n",
      "8858\n",
      "8860\n",
      "8862\n",
      "8864\n",
      "8866\n",
      "8868\n",
      "8870\n",
      "8872\n",
      "8874\n",
      "8876\n",
      "8878\n",
      "8880\n",
      "8882\n",
      "8884\n",
      "8886\n",
      "8888\n",
      "8890\n",
      "8892\n",
      "8894\n",
      "8896\n",
      "8898\n",
      "8900\n",
      "8902\n",
      "8904\n",
      "8906\n",
      "8908\n",
      "8910\n",
      "8912\n",
      "8914\n",
      "8916\n",
      "8918\n",
      "8920\n",
      "8922\n",
      "8924\n",
      "8926\n",
      "8928\n",
      "8930\n",
      "8932\n",
      "8934\n",
      "8936\n",
      "8938\n",
      "8940\n",
      "8942\n",
      "8944\n",
      "8946\n",
      "8948\n",
      "8950\n",
      "8952\n",
      "8954\n",
      "8956\n",
      "8958\n",
      "8960\n",
      "8962\n",
      "8964\n",
      "8966\n",
      "8968\n",
      "8970\n",
      "8972\n",
      "8974\n",
      "8976\n",
      "8978\n",
      "8980\n",
      "8982\n",
      "8984\n",
      "8986\n",
      "8988\n",
      "8990\n",
      "8992\n",
      "8994\n",
      "8996\n",
      "8998\n",
      "9000\n",
      "9002\n",
      "9004\n",
      "9006\n",
      "9008\n",
      "9010\n",
      "9012\n",
      "9014\n",
      "9016\n",
      "9018\n",
      "9020\n",
      "9022\n",
      "9024\n",
      "9026\n",
      "9028\n",
      "9030\n",
      "9032\n",
      "9034\n",
      "9036\n",
      "9038\n",
      "9040\n",
      "9042\n",
      "9044\n",
      "9046\n",
      "9048\n",
      "9050\n",
      "9052\n",
      "9054\n",
      "9056\n",
      "9058\n",
      "9060\n",
      "9062\n",
      "9064\n",
      "9066\n",
      "9068\n",
      "9070\n",
      "9072\n",
      "9074\n",
      "9076\n",
      "9078\n",
      "9080\n",
      "9082\n",
      "9084\n",
      "9086\n",
      "9088\n",
      "9090\n",
      "9092\n",
      "9094\n",
      "9096\n",
      "9098\n",
      "9100\n",
      "9102\n",
      "9104\n",
      "9106\n",
      "9108\n",
      "9110\n",
      "9112\n",
      "9114\n",
      "9116\n",
      "9118\n",
      "9120\n",
      "9122\n",
      "9124\n",
      "9126\n",
      "9128\n",
      "9130\n",
      "9132\n",
      "9134\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9136\n",
      "9138\n",
      "9140\n",
      "9142\n",
      "9144\n",
      "9146\n",
      "9148\n",
      "9150\n",
      "9152\n",
      "9154\n",
      "9156\n",
      "9158\n",
      "9160\n",
      "9162\n",
      "9164\n",
      "9166\n",
      "9168\n",
      "9170\n",
      "9172\n",
      "9174\n",
      "9176\n",
      "9178\n",
      "9180\n",
      "9182\n",
      "9184\n",
      "9186\n",
      "9188\n",
      "9190\n",
      "9192\n",
      "9194\n",
      "9196\n",
      "9198\n",
      "9200\n",
      "9202\n",
      "9204\n",
      "9206\n",
      "9208\n",
      "9210\n",
      "9212\n",
      "9214\n",
      "9216\n",
      "9218\n",
      "9220\n",
      "9222\n",
      "9224\n",
      "9226\n",
      "9228\n",
      "9230\n",
      "9232\n",
      "9234\n",
      "9236\n",
      "9238\n",
      "9240\n",
      "9242\n",
      "9244\n",
      "9246\n",
      "9248\n",
      "9250\n",
      "9252\n",
      "9254\n",
      "9256\n",
      "9258\n",
      "9260\n",
      "9262\n",
      "9264\n",
      "9266\n",
      "9268\n",
      "9270\n",
      "9272\n",
      "9274\n",
      "9276\n",
      "9278\n",
      "9280\n",
      "9282\n",
      "9284\n",
      "9286\n",
      "9288\n",
      "9290\n",
      "9292\n",
      "9294\n",
      "9296\n",
      "9298\n",
      "9300\n",
      "9302\n",
      "9304\n",
      "9306\n",
      "9308\n",
      "9310\n",
      "9312\n",
      "9314\n",
      "9316\n",
      "9318\n",
      "9320\n",
      "9322\n",
      "9324\n",
      "9326\n",
      "9328\n",
      "9330\n",
      "9332\n",
      "9334\n",
      "9336\n",
      "9338\n",
      "9340\n",
      "9342\n",
      "9344\n",
      "9346\n",
      "9348\n",
      "9350\n",
      "9352\n",
      "9354\n",
      "9356\n",
      "9358\n",
      "9360\n",
      "9362\n",
      "9364\n",
      "9366\n",
      "9368\n",
      "9370\n",
      "9372\n",
      "9374\n",
      "9376\n",
      "9378\n",
      "9380\n",
      "9382\n",
      "9384\n",
      "9386\n",
      "9388\n",
      "9390\n",
      "9392\n",
      "9394\n",
      "9396\n",
      "9398\n",
      "9400\n",
      "9402\n",
      "9404\n",
      "9406\n",
      "9408\n",
      "9410\n",
      "9412\n",
      "9414\n",
      "9416\n",
      "9418\n",
      "9420\n",
      "9422\n",
      "9424\n",
      "9426\n",
      "9428\n",
      "9430\n",
      "9432\n",
      "9434\n",
      "9436\n",
      "9438\n",
      "9440\n",
      "9442\n",
      "9444\n",
      "9446\n",
      "9448\n",
      "9450\n",
      "9452\n",
      "9454\n",
      "9456\n",
      "9458\n",
      "9460\n",
      "9462\n",
      "9464\n",
      "9466\n",
      "9468\n",
      "9470\n",
      "9472\n",
      "9474\n",
      "9476\n",
      "9478\n",
      "9480\n",
      "9482\n",
      "9484\n",
      "9486\n",
      "9488\n",
      "9490\n",
      "9492\n",
      "9494\n",
      "9496\n",
      "9498\n",
      "9500\n",
      "9502\n",
      "9504\n",
      "9506\n",
      "9508\n",
      "9510\n",
      "9512\n",
      "9514\n",
      "9516\n",
      "9518\n",
      "9520\n",
      "9522\n",
      "9524\n",
      "9526\n",
      "9528\n",
      "9530\n",
      "9532\n",
      "9534\n",
      "9536\n",
      "9538\n",
      "9540\n",
      "9542\n",
      "9544\n",
      "9546\n",
      "9548\n",
      "9550\n",
      "9552\n",
      "9554\n",
      "9556\n",
      "9558\n",
      "9560\n",
      "9562\n",
      "9564\n",
      "9566\n",
      "9568\n",
      "9570\n",
      "9572\n",
      "9574\n",
      "9576\n",
      "9578\n",
      "9580\n",
      "9582\n",
      "9584\n",
      "9586\n",
      "9588\n",
      "9590\n",
      "9592\n",
      "9594\n",
      "9596\n",
      "9598\n",
      "9600\n",
      "9602\n",
      "9604\n",
      "9606\n",
      "9608\n",
      "9610\n",
      "9612\n",
      "9614\n",
      "9616\n",
      "9618\n",
      "9620\n",
      "9622\n",
      "9624\n",
      "9626\n",
      "9628\n",
      "9630\n",
      "9632\n",
      "9634\n",
      "9636\n",
      "9638\n",
      "9640\n",
      "9642\n",
      "9644\n",
      "9646\n",
      "9648\n",
      "9650\n",
      "9652\n",
      "9654\n",
      "9656\n",
      "9658\n",
      "9660\n",
      "9662\n",
      "9664\n",
      "9666\n",
      "9668\n",
      "9670\n",
      "9672\n",
      "9674\n",
      "9676\n",
      "9678\n",
      "9680\n",
      "9682\n",
      "9684\n",
      "9686\n",
      "9688\n",
      "9690\n",
      "9692\n",
      "9694\n",
      "9696\n",
      "9698\n",
      "9700\n",
      "9702\n",
      "9704\n",
      "9706\n",
      "9708\n",
      "9710\n",
      "9712\n",
      "9714\n",
      "9716\n",
      "9718\n",
      "9720\n",
      "9722\n",
      "9724\n",
      "9726\n",
      "9728\n",
      "9730\n",
      "9732\n",
      "9734\n",
      "9736\n",
      "9738\n",
      "9740\n",
      "9742\n",
      "9744\n",
      "9746\n",
      "9748\n",
      "9750\n",
      "9752\n",
      "9754\n",
      "9756\n",
      "9758\n",
      "9760\n",
      "9762\n",
      "9764\n",
      "9766\n",
      "9768\n",
      "9770\n",
      "9772\n",
      "9774\n",
      "9776\n",
      "9778\n",
      "9780\n",
      "9782\n",
      "9784\n",
      "9786\n",
      "9788\n",
      "9790\n",
      "9792\n",
      "9794\n",
      "9796\n",
      "9798\n",
      "9800\n",
      "9802\n",
      "9804\n",
      "9806\n",
      "9808\n",
      "9810\n",
      "9812\n",
      "9814\n",
      "9816\n",
      "9818\n",
      "9820\n",
      "9822\n",
      "9824\n",
      "9826\n",
      "9828\n",
      "9830\n",
      "9832\n",
      "9834\n",
      "9836\n",
      "9838\n",
      "9840\n",
      "9842\n",
      "9844\n",
      "9846\n",
      "9848\n",
      "9850\n",
      "9852\n",
      "9854\n",
      "9856\n",
      "9858\n",
      "9860\n",
      "9862\n",
      "9864\n",
      "9866\n",
      "9868\n",
      "9870\n",
      "9872\n",
      "9874\n",
      "9876\n",
      "9878\n",
      "9880\n",
      "9882\n",
      "9884\n",
      "9886\n",
      "9888\n",
      "9890\n",
      "9892\n",
      "9894\n",
      "9896\n",
      "9898\n",
      "9900\n",
      "9902\n",
      "9904\n",
      "9906\n",
      "9908\n",
      "9910\n",
      "9912\n",
      "9914\n",
      "9916\n",
      "9918\n",
      "9920\n",
      "9922\n",
      "9924\n",
      "9926\n",
      "9928\n",
      "9930\n",
      "9932\n",
      "9934\n",
      "9936\n",
      "9938\n",
      "9940\n",
      "9942\n",
      "9944\n",
      "9946\n",
      "9948\n",
      "9950\n",
      "9952\n",
      "9954\n",
      "9956\n",
      "9958\n",
      "9960\n",
      "9962\n",
      "9964\n",
      "9966\n",
      "9968\n",
      "9970\n",
      "9972\n",
      "9974\n",
      "9976\n",
      "9978\n",
      "9980\n",
      "9982\n",
      "9984\n",
      "9986\n",
      "9988\n",
      "9990\n",
      "9992\n",
      "9994\n",
      "9996\n",
      "9998\n"
     ]
    }
   ],
   "source": [
    "#Loops\n",
    "#for loop \n",
    "for index in range(1,10000):\n",
    "    if index%2==0:\n",
    "        print(index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello World Live long', 50.5, [2, 5, 8.4]]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Turn :  1\n",
      "Guess the number : 5\n",
      "Your entered number is smaller than the actual number\n",
      "Turn :  2\n",
      "Guess the number : 8\n",
      "Your entered number is smaller than the actual number\n",
      "Turn :  3\n",
      "Guess the number : 90\n",
      "Your entered number is greater than the actual number\n",
      "Turn :  4\n",
      "Guess the number : 80\n",
      "Your entered number is greater than the actual number\n",
      "Turn :  5\n",
      "Guess the number : 50\n",
      "Your entered number is greater than the actual number\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,6):\n",
    "    print('Turn : ',i)\n",
    "    user_input = int(input('Guess the number : '))\n",
    "    if hidden_number == user_input:\n",
    "        print('heyyy, You won')\n",
    "    elif hidden_number < user_input:\n",
    "        print('Your entered number is greater than the actual number')\n",
    "    else:\n",
    "        print('Your entered number is smaller than the actual number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "outside the loop 5\n"
     ]
    }
   ],
   "source": [
    "value = 0\n",
    "while value<5:\n",
    "    print(value)\n",
    "    value+=1\n",
    "print('outside the loop',value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "#simple function\n",
    "def print_hello_world():\n",
    "    print(\"hello World\")\n",
    "\n",
    "def print_name(name):\n",
    "    print('My name is ', name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello World\n",
      "hello World\n",
      "hello World\n"
     ]
    }
   ],
   "source": [
    "print_hello_world()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is  Sam\n",
      "My name is  Jack\n"
     ]
    }
   ],
   "source": [
    "print_name(\"Sam\")\n",
    "print_name(\"Jack\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is  Sam\n",
      "My name is  Jack\n",
      "My name is  Sajjad\n",
      "My name is  Chadad\n",
      "My name is  Last name\n"
     ]
    }
   ],
   "source": [
    "names_list = ['Sam','Jack','Sajjad','Chadad','Last name']\n",
    "for name in names_list:\n",
    "    print_name(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Boolian functions\n",
    "def is_even(num):\n",
    "    return True if num%2==0 else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "if is_even(5):\n",
    "    print('number is even')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Value returning functions\n",
    "def join_name(first_name, second_name):\n",
    "    return first_name + ' ' + second_name\n",
    "    print('bla bla bla')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bla bla bla\n"
     ]
    }
   ],
   "source": [
    "full_name = join_name('Sajjad','Mustafa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sajjad Mustafa'"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(num1, num2):\n",
    "    return num1 + num2\n",
    "\n",
    "def subtraction(num1, num2):\n",
    "    return num1 - num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def take_input():\n",
    "    num1 = int(input('Enter num 1 : '))\n",
    "    num2 = int(input('Enter num 2 : '))\n",
    "    return num1, num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate(choice):\n",
    "    if choice == 1:\n",
    "        num1, num2 = take_input()\n",
    "        addition(num1, num2)\n",
    "    elif choice == 2:\n",
    "        num1, num2 = take_input()\n",
    "        subtraction(num1, num2)\n",
    "    elif choice == 3:\n",
    "        num1, num2 = take_input()\n",
    "        multiplication(num1, num2)\n",
    "    elif choice == 4:\n",
    "        num1, num2 = take_input()\n",
    "        division(num1, num2)\n",
    "    elif choice == 0:\n",
    "        print('Good bye!')\n",
    "    else:\n",
    "        print('wrong choice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculator():\n",
    "    choice = -1\n",
    "    while choice !=0:\n",
    "        print('For addition, press 1\\n')\n",
    "        print('For subtraction, press 2\\n')\n",
    "        print('For multiplication, press 3\\n')\n",
    "        print('For division, press 4\\n')\n",
    "        print('For Exit, press 0\\n')\n",
    "        choice = int(input('Enter the choice : '))\n",
    "        calculate(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For addition, press 1\n",
      "\n",
      "For subtraction, press 2\n",
      "\n",
      "For multiplication, press 3\n",
      "\n",
      "For division, press 4\n",
      "\n",
      "For Exit, press 0\n",
      "\n",
      "Enter the choice : 1\n",
      "Enter num 1 : 5\n",
      "Enter num 2 : 20\n",
      "25\n",
      "For addition, press 1\n",
      "\n",
      "For subtraction, press 2\n",
      "\n",
      "For multiplication, press 3\n",
      "\n",
      "For division, press 4\n",
      "\n",
      "For Exit, press 0\n",
      "\n",
      "Enter the choice : 2\n",
      "Enter num 1 : 50\n",
      "Enter num 2 : 20\n",
      "For addition, press 1\n",
      "\n",
      "For subtraction, press 2\n",
      "\n",
      "For multiplication, press 3\n",
      "\n",
      "For division, press 4\n",
      "\n",
      "For Exit, press 0\n",
      "\n",
      "Enter the choice : 0\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "calculator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}