InteractionsWorksheet1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:red\">Primary </span> <span style=\"color:orange\"> School </span> <span style=\"color:yellow\"> Science </span> <span style=\"color:green\"> Worksheet </span> <span style=\"color:blue\"> Rainbow </span> <span style=\"color:indigo\"> Series </span><span style=\"color:purple\">(Experiments) </span>\n",
    "## <span style=\"color:blue\">Theme: Interactions </span>\n",
    "## <span style=\"color:blue\">Topic: Factors that Affect the Survival of an Organism </span>\n",
    "### Let's watch the video clip below on the life cycle of a chicken.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     0,
     1
    ]
   },
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2MBERISGBUYLxoaL2NCOEJjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY//AABEIAWgB4AMBIgACEQEDEQH/xAAbAAACAwEBAQAAAAAAAAAAAAAAAwECBAUGB//EAD0QAAICAgECBAMECAYDAQEAAwECAAMEERIhMQUTQVEUImEGMnHRFiNCUlOBkZIVM0NiobFywdIk4TRjov/EABkBAQEBAQEBAAAAAAAAAAAAAAABAgMEBf/EAB8RAQEAAwEBAAMBAQAAAAAAAAABAhESITEDE0FRIv/aAAwDAQACEQMRAD8A+fwhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQhCAQm8eE3n9qv+p/KWHg2Qf26v6n8pOovNc6E6f8AgeT+/V/U/lAeB5J/bp/qfyk6i81zITqf4DlfxKf6n8pI8Ayz/qU/1P5R1DmuVCdb9Hsv+JT/AHH8pP6O5f8AEo/uP5R1DmuRCdgfZzMP+pR/cfykH7OZg/1KP7j+UdQ5rkQnYX7N5jdrKP7j+Usfsxmj/Vx/7m/KOoc1xYTtD7M5p/1cf+4/lJ/RfO/i4/8Ac35R1DmuJCdv9F83+Lj/ANzflLD7K5x7XY39zflHUOa4UJ3T9lM4f6uP/c35Sp+y2aB/m4/9zflHUTmuJCd0fZTOPa7G/ub8pP6JZ+v83G/ub8o6hzXBhO9+ief/ABcb+5vyh+iWf/Fxv7m/KOovNcGE7p+ymcD/AJuP/c35SV+yWe3+tjf3N+Udw5rgwnfP2Qzx/rYv9zf/ADD9Ec/+Njf3N/8AMdROa4EJ3/0Rz/42N/c35SP0Szz/AKuN/c35R1DmuDCd/wDRDxD+Ljf3N+UP0Rzx/rY39zflHUOa4EJ3h9ks8/62N/c3/wAyf0Rz/wCNjf3N+UdQ5rgQnf8A0Rz/AONjf3N/8yf0Q8Q/jYv9zf8AzHUOa8/Ceh/Q7xD+Ni/3N/8AMg/ZDxAf62N/c35R1DmvPwnf/RHxD+Ljf3N+UP0Q8Q/i439zf/MdQ5rgQnf/AERz/wCNjf3N+UP0Rz/42N/c3/zHUOa4EJ3T9lM4f6uN/c35SR9k88j/ADsb+5vyjqHNcGE7/wCiWf8Axsb+5vygfslnj/Wxv7m/KOoc1wITvfonn/xsb+5vykn7I54G/Oxv7m/KOoc1wITu/opnfxcb+5vyk/onn/xcb+5vyjqHNcGE7h+yucP9XH/ub8pU/ZnNHe3H/ub8o6hzXFhOyfs1mD/Vx/7m/KH6NZn8Sj+4/lHUXmuNCdo/ZnMH+rj/ANx/KV/RvM/iUf3H8o6hzXHhOw32czFGzZR/cfylB4BlE68yn+4/lHUOa5UJ2D9ms0DfmUa/8j+Uo3gGUp62U/1P5R1DmuVCdT/AcrW/Mp/qfylG8GyFPV6v6n8o6hzXXTvHA6EVGp804uxq6IkkagFA9ZbhykEaJl0U9pCjRjBvcgltwU9ZcfWUPRukBinrLFQYIAZYakVVBxjOG+0pr2jVJAgU0RLpsSjmXU9O0C51rcFb6SOXSGhCLOwKxQ0T6xmge0g167QLr01Lk9ItNnpuXKkekCAdGXLfSLO99BGoN9CYCx1aX4De5ZlUH0llP0gV4+okDYPeWckeoEUDs99wGcD9JUdD2l1JHcSpgXUk7g0qjAeskty7CUK5DfaNADDcpw331JVNdpBJVYLJIOugka16yi5J1KMD3kqP5yxPTsIFQenaGzKnY7ywYa6gwJ5DUje/SV31l9qRuAtlBHWKIAPQRrEHoBI4chAuqgr7Srge8r93psyQOUA46HSVZzrUsdgaJkBNjfeEK0e8YHOu0nfEdpGt9d9JBBBI2YtyoH1jwyhdERD/ADHp2lVTRPpLitSvWWTjx+YxZYdgIC3AB6CTx2ntLheQO+kUw103IE2+25VV0uxHLXyHbrEOWTY7SqYbjx10iXUspIhWvM+5jvuAjUispc8NaiuJePcFj06SawFY7gZB1lxpTK60egjFQt2m2VgdxtZO9GLC6PeWUaO5Axge8tWd+ksvUdRK9Q3tIGb6wIBl1AZeplNDetQJrI3Gms62IsIw6jpGB+muUioUEestrUqOjb7x4Ox2gJB36S67HcyFHzdZtqw7LQCiE/U9IGfiCO8gKJ1K/CHYfOwX8Jpr8IoU/MzsfxmpKztxApHroQJ2NbE9Evh2MO9YP4y4wsYf6S/0jmnTzdY0e00k7XWp3fg8b+Ev9JRvDsZv9PX4GXip086xAPUywKjtOxZ4PSdlGZT9esxW+G2oTx0w/DUlxsWVl3v2khSD1MGqKH5tg+0kKD7mZVVl2e8qoZT92P0R6CVfr7QI0W69JIAHeRW4B7S5Oz0HSBUgHsJIUSdD1IlNjsBuBDADsNyyfMO0kLtfSL0UPUmBcgj1lSCOo6y6fMJDkqOmoEAsB0kdT3gD8u+8lXGvumBIYa1owI/lKkk/SXUpx0TCFkL6mU2N6AEY4X0EqlZbudQLqgZZVgB0hw4+pMsELdNQqgXl2ECGUSdOvfpDq3SUJ3yl0sYD7skgr2WULcuh6GBYgvITSdDLV2AHtJc8+wkFd8h0HSVIA7wrGm6mWs49dSjI7Afd6xlA5dG1KKh5fSMaoqdhpAWIF31iV6nUseROtdJJrZTsQKvtD6CZG3YxBmmwkt1MjhxAOoUlVapu0u1nLv0k229hFFdjl6QoZQp3E3Wjl8omhrAa9EdRMti8m36QKsnIbHSWqPE63Jq6nUs1ZVtgTTIceupKMSdaluXy6Ii0KhvmMgcpIPUx6orL9ZQFCux3k1udwLAaPbUGU94w17G9xZG+nUyC1bA9NySCp7ExdYZW+70nSooa8dtL7wMalnIVVJM6GL4bdYAbG4D29ZuxsWqgbVfm9SZpUzUiWl0YNFXUIC3u3WawNdhFhpYNNsmiWEWDLAiVFoSNydyiZIldyRKJkOnNSB0MmTvXUyMuVdULGam0DzB2YTFTi5FjMqqu16EE9ZGRmcPEnbe0LdDNeWfkTIrYhj0JE4Wx3sulD4dla+6D+BiTh5CHrQx/DrLfG5P8Vo6rxS5P8wBx/QxMsU5yY2rde6Mv4jUhSu+p/wCZ3cbKqy1IC6Ps0i3w3GftWFPuJvnfxjrX1w3KgdNSqLv2E35HhVqAmtg6+3rOe1flkhid/WZssa3tbXEdyZQgt6HcbWhYdBKsrr7CRVULAe0q2z169IA7PXZMaD03xgKW0AfdP9JIJYb9JSwFgdDUZjMijRMAHGWHH0H/ABLEJ14iVVfm79DAZwB7mJdAvrv+cfwUDuTKeXs60IC69t04y/F19ZThYjdxLBz2OzKK9W6He5ALA64nYjByU/dMo1hZ9EakFGYsdHpE6CWfN3mjpvrIdkYjpKBLEPYah05RTqN+0enllR7wF2hNgg9YniS3SPsVd9IGvab3oiQVarYB3EMSra7xrqddDIWkuv8AuEC4rLV8hFW81H0kmx6xonpLVnzgQO4gZeJI5Abgztw1qNdmrBAEzBjYddjCwsjzOvqJau5a0KkR1ZVD1HWJtZHOgNGVVGIcfLFhQCeXaWq/V27MbaKnPSBjXmp6DpNCtzXUXz2smmwA61DKPut80cqqRsDrJt48dgdZWo7GuWoFkGz31GGsL15dIo1hTvkTLqSRAfU2xqBRlboIqtrEPUAToUfrRyYdIE42ObdNZ0X0E6iEKuh0mZCAIwNKjQGlg0zhpYNNbRoDdZZX6zOG6y3KBqDywbrMytGBty7Gga9O8ncUralwQZUXkiVk7gXmbxC1kxmWsbsYaEcW0pJPaYLsvozAAn6+kznlJDGbrikkHjauvxmmiwLUay3JD/wYvIyA++QG5ha3R76nl6erW43yCZgGQ6ne+Q9ppqvW0dD19pC46dHw65UtKv0DDv8AWdqmzmCCQSJ5kGbvCbSuVwLdGHb6zt+PPXjhnjv13IjJw6slNOvX0YdxHwnq1K4vP24t+LZp+q+jD1iyS/TrPRW1rYhVgCDOPlUNi2bALIexnHLHTcy2whuJ+6dw58t9NGXewMe3/MhCnfpuYaUTiD1hwTZ4DqZZuDEkd4urpZ6iA1E9zI8vix0xIjGQfsmKNbcukKNtv5dalyHUd4tksrf0IkO7/iIE8zz4mSQVbXE/jK8WGm0esscjqAw1AlrtfeEUbAG6/wAo1zvuOhi3aviA2ukqLtahA6RVihj21KsV2OnT3mlfL8rTd4UnghTT94GlQOhhaqcflMnHBcFWMCiLsEM0HGl7yz0Ejo0QqsG4E7EBlSl/l/pBhYAZUF6zqVWxy+iOhgUG3bgw7y9Zao9ustYhrcHX4RRy/n0yyC7W8m0R3iWArs2w7dRGkbPI9jIvtqKgN6QrLbcjWe0qatty/wCZW0qTtV2PeaVZBRxYj8ZQu3yiq7PzTNYB+z2l7kRl2p3F4nVir9vrClVuOmxHnXHYAirGGo2sI40TDK6gMutxPlis72TLtUEPQxzUM1fy63AqgZ16CAFqdx0k1eZUfm7Rt9o4QCpTawG50k0qgDsJjxOtYbWtzUDAaGlw0QDJ5SjQGkhpnDyweEaA0uGmYNGB42aaA8urzMHjVMpppDS4aZlaMVpdpppVvrJLherEAfWZ2t4IW9fSZzVz+awlj7yXLRIjLzxZaKKSeJPzNK1VcGYtosJjuo8trFGyGPJD7H2mxLeRrJP+Yuv5zhl/1fXXWp4z+IYqsvKsa31E4t9bId9x/wBT07jdPFu5/wC5xcxVQnmdAnqR6Gcq3jXNocFgNbmh6Lan5oCR9IhMexMtPlHFj6HoR7iduhq1Ioc7BXase/4TN3G9slF4sHXoR6TVjW8Mitt9mExZSiu07XTD1HrLU3AkE9dHtJ3cbGLNx7Le+sJnxcqrJrHA9QOqnvNE+pLuPJ8TuUtrW1CrDYMtCEcC+jyL2RgOnUH3EQ3l8+ned3OxxdVvXzL1E4B4PZ0JBE45Y6dJdgIGfY2JezHBHINoyGTT/K2pFispBD7+kw0rVtW0WjnDJ1HXcQ9TqQydd+8OdqjqYEWvbveoEspBIkuW4q5HSKszABx0f6Sh7ZBVe3SLZuY5+kFZnQEjQMuroikHtGxK318OJ7yloRk7bll8ojagGMq8sghugPaIEJWvlkHp7SgrUD75MfZUjLoOdTNjoPNK8iRAdj1g7BOwYGlx0VtQ8qxWIUgCLPmraAzbEqBGdX4s2xGPWyE6G5W2lq22BvfaU8zJHUr0hWe970JPHpJrDIRY2yDH2q9iK/pFPlV0rxI3qA2zL2B8hP8AKKtU2KHUSUyPOQ8FjqbERCr+sgULq0q4Oesq3k2JtRuSa6GGx1lMfitx6aWBWpawrAjoZkNSknbzfbVWWIV+kwmpK7hpievaURRWPO0DtZe7H0x4NqWyK3VwaezTJal6EMX/AJQqy11uOpk8FRgFlK69WcQ3SXah+WwRKhxrd12JaprUPFpWqx0PE9ZFtpVwSDIHZAbQIBk0urDTL/WWoyEtHHUqdfEAAdJBrToJfcovaWlE7kbkGV3CmcpIeJ3DlIHhvrLh5nDS4aBoDdI1X6TIGjFeEalb6xqt17zIHjFeXY2IV7N1ELAVGtfziFeOWwMpVu0WbGDMy+FRIU/fAJA7CQR+pXidFSSs6lVFOT4e6cAA+xOZQjG01N0G9fXYmLjqN43bZZYvkI7ftaM4nizDVnX12J2Mjqo460o/4nD8QHR0P8jOWmox+GZbpUV3tQex9JvewXFWHl+aBsbHRpxsW3Q4V65a5bPrNiWB+hTgwO+h9fcTFnremh7xkApYvl2Dt16H8DM6MRv3EHrschiDr37fzlQx8wE+vQyXHxXQoyrBxKOQV7a9J6Pw3OOVWVcDmvf6zyKko/TtOjhZHlPyDFSexE3+H8lxrnnht6yEyY+VzYJZoP6Edmmnc98u3l0sdTz/AIjieVkFkYKG6zvTmeM0GytHVuJB1M5zcaxcnh8w/WbM0vS5VSvWI+EZFFo2x9tx4fK4bCAATk0Rd59YHy9Pxk1oWXm/aNcvZTzYaA7xPxIpXiVLb9hCr228E0EJWZXfa7ROnr0mtck2poVkD6iVXy1Vg2tGBRMioU6cjrJFlLLoAGZ3qxF2xHL+cZhtUbDxXS9pBeqoIxPQKZYUI29vLGvewbOn0mY1im0acsCe0C61cbtBiV+sh8eyqw+VrUfYj7Hl60fWZbRlVuCSCsoqwyFbbuuo9qyumHzbEz5FLIFsZiQeoAlV8RtHypSxA+kI023XIB+rJEjdllfI9F/6gt1l9RbjoShyVx6WDjYPeBc3pVXx1sTK9yWKSibP4R1GXVcOKJuTXUtdpcgAQrNi3CskvpQfSWF2O7HqCZGRViNaSW6e25lZsdLVFCknco1VDhbsL8vrJtp3YQHAUzQ1XmKCCF95iy8V0+cW9PaAu2jyjtbST+MbdjE1LdWNt6iStS/DCwAsfUStvxXD9WNCBmdMsnvxAjManzq25tyZf+YtFvyLDVY/E/SVXI+BZkRSzAwKPj2huSyavOYkH0jPNfyj7iZqsrynJYd5Q4MyWbI3qa0urdeo6xKZKsN8Qf5SFsVrSdACQXrsRb/QCa9Vs3NTuZhjV2bPORjL5djIGJ1IOiISAekmVUGUJlj3lDIsRuG5BldwGbkhorckGRTg8uHmcNLBoGoNLhpmVpcPBprV5Z7ONbfhMyvEZeRpNAnXqYuWkk273hFgbC79iZlzmWjLfj0J0SZx8bINLFTYRW/3XB9Ze6x1sPPZJ/aJ3uS5bx01MLK3taNAb7DU5PidmkLDrqN84FQGOj6EzleJZSIOPMMB31MxuRWsrVXWXq5cl7MdAf0jU4E8l6AdSD6TFXcLqgy8n4nRBHYTRSBooNjZ9R2mMvFdDErNrG1z8uiB+crdSKVGtnbR+M9YRQzBVXsSdCXuux7U/V2s5A7KuhOXVyNsLEdeveOos0OMzXggD+sms/IDM60r1lVRsxkB6NxGp0K9hAGOyB1nN8Kzhk0hSNWAdfrOih3PfhXly+rxGevLFfQJI0ekfE5hYYthQbbXSdL8ZcWy3IVf1dcWj5NqcmIUDuJc2ZFqHjoFe43KJlV0VnkwJPecmj0zK0r4gcunWUXLRlISv/iKpz1fpTRv+UfWqhubaAbuI2paWrWWNhABlD8NYpG9/wA5fycZyTa/ISK6qUyF8mvaHv7QEU01JfpV+UyLsJzYfLuCp6TZfjlWPlldHtuc22i6qznbkjif2RAZ8OK7VAuZye4mi2lkYBVJ32MGqWhEeqs2M3Y99Sj2Z4XmagFEBTJnBt8lCR4BekMTuQfMsqDu36sxHxnwvyV1Gz8IDb8lqawPKLj8IoW33oTUgA9d+k0U5rZCkGvRA7alcZjWzlxpTCFY99WIhF9gJPeXTKxbgQqgxQPhxbfHzD/WACNepop4gdzCiva5QdFASNsahrG5W9D6S91YsbSuAD3ExXYGPWC/mEuPrAMjDoO7EJ3Lvjg4ytUALB3migC3FXSaYd9iZsyjIs+Wpwo/GBm+GyD81mQF+gjcQeerIzcuJ6H3isTHByTVkW8j9DHO747mvHoOwe8orauSq6oSLqOT5qpewXcn4vLqP69OK+8q1ZNq3Wv9RAvZWMa5i2y0x2eIOLDqnr76mu3xNS3THLkDW9Sr2PkUcq6QPQ9O0ox1ZArPF/WXtesfsb3Iyra+wTrGVBLccBiA0CcRqyjB9CMbHqK9HmSzDQDl5x37TRVR5uMGUkkSC2KgbkoYkiDV317ZF6ygryKhyqT8Zoosveos3p3EDVW20G5fcyY9jBir+vaaOUCd9ZQydyhMjQMqYGVJgTuG5WEKvuSGlBJBkDQ0sXCjbHQigYvJB2p9NSLF/iy7cU6D1Mi0G0K1Z+4d695y7s4LYaU6enKHh11xyEpUFmJ1OWcys8dJNNrV2VsRWOVZ66ljbZWn3yo9FJ6zR4ng2YNa3nbIe5UnofrOHfmVIp3rZ7ATWMul3toyckouyd/znJvtOR5nYaAlGyXufQXp6DW5oxsQb5Wixgf2VHSdZjr2parhmzQFWxs6H/szqIeA23cSgsCLpaxWPrKG9Qd72fwnHO3K/EbcdGtINnyp7HuZ1U8sIVWs9fXU4OPkXO+knTx7bE+e1yzegMzjNLonNXSV/wDkQYgNwIU9jNGa4alfcvv85lyRutD6iYyno7nhav8AD+ZWdMrdDO7j3i5A46HsR7Gea8AzD5opY/K/b8Z6CioecbFJA7ED1nf8dscs43biM3k2I4U6JjdzF4lm14lam0jRM7bctMCWVYwJLcie+ovH+Gvu41VbPr07RuNmU2jePRz2ep1NSI7t8qcFPfprc4fk/Jx89ak2z01NXeWYKq+ijrHjDQszkllPUD2jhXWjabbEenoIxW5H5V2Jzx/Jnv1rTiW01U5AKKx2eoM12UX740qFrI79tTqAHe+C79zLbP7QWduqy89ZhZYs2LuY9VlcjACFbXDtv9k+k7t2Otg+TaN7ic578iq1aMmohHOlcddH8olv9HOszMvkqUUMQPcRy+fkVHnZoD7w9pW5/EbAwp4jieL79IrFuXw9LHy7g+/vATYf8VTRSa9c19ZNfiNXH9VRv+UpTmYt3+TVuTVsZgtVFWv1EADscgXsAi+0tbbi3EoH799GUtbE89y15Kk/d9ou3FxXXzMflz9DAxu2LjXqmMjM++s7NlBsRCrisEdZnNLtjBqeC3epPrMT4WTy53Zqj6QjTfhJWeS5JLD2MVSoeg28S1i9x7y/hwXIqdUPJ6/+Za2vJ4HygFMKW6Zl1f6r9XE45uW00Xv8x7GU3li9ar7OBboOse/l02cX+a4CUZTWMK4uwZrJQ+J5b2HVRC++o6/xK5bAr06HvqLyfjbkHDitLj70qNFyPbjq19nyGZmy6qUUFC6g95NWdj4uKKMhvMIjEzqMhStVAI+sCfjBYh8isf0hiN8KlhyXGn9JnpFlWb5oAWo9xBhhtYxe0v17QpoqovVSCOUyZOKKm5ebr6RddRx8lT5mwTrUd4hQ62b4lt9tQGW44OOroCxPtFVtl4/aohJSnIy6yF4FU9zHX3ZK/K7dDAfZdetYb9lpTHy68ZW83ZBlUzaTQtF3UiMFuNapTytke8g1+fjGrmE/A6i67Q6giTiLXZi8HIUg9Ir4Q1Xc/PUIfSKH8pUmLDhuxBgTILEyJG5BMNJ3DcrDcKuJIMoDLAyC4lcnGGXQtfnNUQe4G9yQZcGBym8BbmoFwZfcHr/Sd7whMPEXVY+fsznqTM4MUhCWED33M21re49Wopy6GrcBlYaIPrPnPi3hqYPidtCszKDtd+xnrsW+yoclPQdZxvH6muevNGuvysR/xLM4mMsrk0UnfQa/Cbq+Sjoz/hM9ZI67H9I0FW6b4/8AjM210S9rMNc1P0MVw5Hrw/lNIrVhs2En6pILV1d9Gct6+KvQnAfqk2x9fSPT5O55e7H1i61svIUDQP7PqZf9W7FFYsqD5ivqfxk9/qMjXedcxH3E+Vfx9ZFjBwF67X2lxXUrDy+ag7JV9bH9JNaENy13OxLl5SNng2Dc+UtgPFEOyfWerXQAA9J5nE8a+H/UfD70OhB7zfR47VYAXr4/gZ0xykjGfrtgznPmY92U1Xk+dYvy9t6mivMptQMjbHsBFVCqtytCceR2dDqT+Mftlc9Vpx6uCbCKnTog6a/GM5+UhNhHI9gItrlpQDp+AmKzI2SxPX39pjLOfw00dWbt37/WOLFV6DQnncnMy3YeQfLQe/eXxPE8kWKtu2DaBBHcRJfta5rt+cB3b/mNrdX7TCyW891ISh9zG0ca7dEFTrtNzaU+wMd8No4/oZeuzlUC6jf7QhW/Lo2g25DLwv5/s2fKR9ZbKjHkUnEutyCS1T/eXXac+34OtR/+TzAx3rv1noGANfFhsdjMC4dVDWJWm+7jZ31l2jipkG7LrOPieVWvc61OjcuO1nS5QSPu+0Tn4tt7qaslKK2GyvqDOefDsXFU2HP5WDtrrubDsvDxqVa9CzP30O01cOWFVbioCWOnHt9ZWmtcjEW/qbFHzL/7ibsfPt18KzKPUa0IFsrByLF/V2ab/wAukyphHIvOPk2fOB0KnoZo8Px7vPsqus3ao3rfpKgLWxvDFiD949oRhOQ+A7V4WM/MHROpoxsjKZk+KDoG7b6RLeK5Tu+k4jf3+PSXyKslyj5mSorHUa9ZQ/Jx9uHt6FTsame/xJa7t/DcnA1yI7y7eM47utYTnxGuRjLstRUClaHl0BA3CqrZblUlzWqqR3lBfTj4TUZDFge2vSTjBqMO2nLcLW/UH1BiT8DZUK+bOSNEj1lRmYeHKocVNZuGLk8/EEanH4VAaYHsZJFGJlVilCQPvA9Zo8Rx7LbNUWpXUw39RAZmDGNxJvGj+yD2nKzMaipTZW7Fj16CQcGqpWa3KBYe02YFYzMTkR+sT0PqICLanO3VSSIzFzL7WKWLpv2dycPKttB5DQHcRTZDLkradBUMCl9+SSRayoAZtrzsbJCoV5OBM+Rbh5BNzKTv2iKrMZL0NFbA76mBqy/IC7SvTzTYosxqmpKq/wC1uGRiox5o69fTfac27Get+bXfJ6gGQasnEJ09d4BHcCaGqbIwUYbbXQzLbUMPgq8n83qDEtmZGKRWDob6gekA5ZFLcUobjvrNaWbXeiJW+63grJboEesRieI149dteR+s5HYP1ga+UnlM3mEVh26Ke2zLK413hdncpIMWGk7kXZgMsIoGWBkU0GWBigYAk/QQpmyx4r0HqZS4BOLKNa6GXDAAaHQeglbla2pkGl5DWzJVlMFxA6GW8Puqtc0ZC8q7OnWc1LbsX5b6mtX0ZOplReA+02NdtjRnOx0iPEcX/D801/eQ9U37TOLT+yP+I7xrMN1ldjA79u8y1Zmh/lgn8NCa1dbTemlKLLeoXiv7xOhH1DDx7FVn820+3QL/ADnPuzLLRprOP4ROKq2WlhvivqfUy87nqdOtl5rOvlY44q3RiO5/nNHgeP55uUdCF/5nOGurtoeg+gnT8AuFbm39kvqcsvIbYa0IuKv+9o/1nYTFDUXOD1QdJXxnB8q0ZNQHludkj0MZiZCMtisdK46xfVcurG4srO3XfXc204t9WWr1Upauuu3Erkr8hTuw6RCjVyno5QDZDaP8prLEd5csInWoKB3Gwf8AqPW8eXzGgT0E84jW5F/Dk/Hl694/O8QAIxqD8zdN77D85x51dRmx0myQ5ZyxCKdb9zK4viOLkWNTWCrjrtvWcrIvGvLDHhWNHQ31manDu5i6hls4ne1PUfiJvHH+pp1jer5TrxINfRgfeP8AiESxWI2ePQ+0w25Ndr+aE4XcdWfWZ3uLFNHuNTpCt/xjnYLluvv1mirLLL2c8fczz/xK1obLW6bm/ByKMpCFt0da5Kf+5rTLv42QLV1shtdj3E0i3zF6zhYrtx471ZUfX2m4ZGmU7+9JtNOpY2h0lUbm6np1BiarTY3X23DHPFm5dJn7F05Hi/hh+Ja6m1UUjqHPSKwcbCtwWylr5tWdMqzT4piJ4g7OzWapPzVr02D6zit4sMKp6cGo1netAb3OmPxh0QfEbOXw1BpT0+sEuy7bPhmHl362Ax6NM+HdmZ7hTkW17GwPf8JoaqnHKu97ecD3PVvwmhUOuNb51SGy9eh17xI8WyHsCvQtQZuxEvd4hjLl2OcTjb0PzHW/wl7LG8Sqevy0oZeuyvWWBfivxtoFFa/q26luwi3txqsJKc48yp6FZsuy8QY1VeVePMr6bXrucy6nw/y/Ot86xAehJlDK8rFA44+Dy3NHh4ao2eegrrfsD+zMPhebWviIXHqYUN0PTevrNWVhm7Ibz85QgPRdwK/C13ofOuDL/tEy3pjYprOKrOwb5ie2pN9aYi//AJ8jzR61jruOZEqprvxa2t849R34GA66s2sllC6rZevuDOVfiZbXcwVRda6tNVmJn3EEXeWvsTqJorOVXbitbq5D1IO9/hKKYeHTl12sTysp2SB+0JQZWQU44tTIo6b1JV18OUmoFXI1s9SZmrzslgORasb760IGnEvFFrtksOLjRAj3GLlVaXfFe5mXIoxW+Ys2vpG+H1pbTfTUT0+6T6iQUwTirnClATWwIO/eGTjZJsYVKqgesRkV3UsVqTqPUS2HVdkFltdg6jetyhmKl9FwW5gefQdexiMotXkMlp2R6SOa0W8/mcj3kXZDZTs71gWAf1kFz4ne/l1BBpOxMvktcKedjLzPcTCtrueJAQe+o9rqLLN2ksQNaEuhZM1FxUqtUswPSUvdLP8ALpK6mW2yst0BJ9Ok0VZVxqFKqBzOiTGhU2WlOLHp6SK8i6nrzUj2MXlqK+VZYlh6iLqWoptyZdDppnVkheWyR6TStwPrOAxCNyqQ/wA43m/Hdrsr+2pLibd4WfWWDj3nApzLFJ5WHiO2xGr4owOiu5Oau3c5ywsnGr8URu4Il/8AFKu3zf0k5pt2PMlvMHvOM3iVa99n8Iv/ABcHoqNJzabjsX3qg+Y9+2pi7ufrMKZtb3bvBVPp1Mm/xCuwFKdqP3m7yXCtzOQzLDOSwI6dBMbBifmO41cqv4IY7VDzN783fWJGSOo49R06zcxsmkuW166Dy6sBv2mxOFdet8VHcmZxsjr0P+2KapeQNlhP4yWb+m2myzzFLH7gOlX3M7Pho4Yie56zhLwPEbPQ9NTtG34fHUb+bss8/wCaeajUdM+JpjnyLV82thpl9hLjwxLh5mFcpX91u4nmcSzzb222zvqZpybyHAUlSB6HUmubpW3J87HYG1SvsSO8591wZtoCD7QuSzW2YtruSe0z1H5ix6hev4zpvbTpJkmmh3YkuBwU/WJXVBDt1t9/rM2M5uurU9l2x+pjWfncwHzNsATFmqzTvLR69Gwhu5/GWU20DkG5ge/Q/wBYnLIVOCjk2+p30B9omrIyaRolSvsZcZdIb8RzvL9QWGmH1kpboKT6HR/ERN4W4cq1RXHoOhilt2CT0/eE3oL8S3ZjMV9DOf4VlvjZagMeDHRE6Z6fUGZ/gaxZzAK66zrhlJNVzyxu9u8uaRkrYD3A3OnTaLaTroVO1nmq21ozpYVxC9+/SefJ0j02HZ8u/pHGznpRrcw4z6p2PUTRUCNGZwvlWk33203u1GO1rkaPsZzafErMjkmNTSuQP2CgmuzxS0574tAr470TrbSMikC6u02M1lR2q1oFA/Ez0Y/HGuezeIfE1ZWXdVQKj0Hr/SbD414dZczVY3Ow9294rxGrwzxDI52XstvH51Tr1mAjwjFRhWL7X9N9JdDqZIOVUxOLXWzD5Wc9R+EVwut8L8q5xTfUQFdjoOI7w7/9nhyPdqm9OgsYd1iMvCw7kKW5fzE997MorZj+HWUqljob9a2sp4ciLknEtDWY7dnca0YiivEx/EVoudnrYf5hGtGbLhlX5d2PXX5RT9oDuPxgZ8zFzarDVirVWnuDqYfgcilHsyMiv31y3uMspzcWx2YGxB3Zj2hd4ZjDFXNe9zTZ6DuD7SjdX5Q8PTIxsfmT8rL6gzK9WeKldFK6bfljtqYh4s2MhqwK2UE9yNkzXRdl5NwrutetiNgH1/CNCa/Ny7TSf1dw6hT6iVL0Yjl6UL3Ke8myhKcqu42stq/sjqYuzxKo5lrrQquT13AU3iFr3A31CsMe/GKy6su5uJ0KT1DHsZtua/OQJxVQR+76SCaacBsXKtGl+4fUGBnyahT5dibdbl2PYRBGXX1qUr+Er8TbzWpWPD06djGFshkYWOUZTrr6wB/MsxBZ5hD70SZmpyxiX+abC7a1r3j6smiipq7NvyO+nvE2DFQ/5LGEOGU16EpQoU9YkWWecvygBZfGfzHdFTgpXpuUtof1I/kYUnIG7CRaAPaU51qayAOQOjr1lxRSlgG98vSLtWus9EPSUOew74ogJ7jQiXquI5B9a9AYLazWBeykdJapSxY2NoD0hFGqApFnmAsT1U9xFg+UNnrGX+VsDba+kURUenzEiUaK3suUhQAImzzTafMPLp3k0deg30jr6kav5d8vrH9Gby2ddjsJbTWuCqAkDrxla1ZR5Zb66EsGSo7G9yimimyASSZDhjoheIEcz/rAa7Nqfp2MhFd2bzDoQJpcrpfLDE9jIvR0JsKag5RNbJJH7saPKsUc319GJkNMwJsHResjWt7GvrHCo8m8v7vuekl6Fbqb0H4dZdmlSvnqCgHTvqXGHbYPuqPqYpVVLP1dm9dd61Nt2ZYaAtVW3I6kDepLv+Lpla6xLQGPJB34jULMhmA8mtv59ZFmIwTzGs19CIUPcnyC0KD2GpdQa/DBbbkDzE4hepJGpo8QuHxPJn0qLoD6xaP8NRprFLOw5tv0mEt8Vc7sdbPr7Tncd5baldPCRa6zYvzFvX3gW55AQLy2fmYnpEteroKad1qBrkZXzlCFK7l8zsWPoPpMc3e16Py7WvfirAVg+/eU5aRlUen9Zz/msBAuYxmO71Aq6732JmuNQ7bMMmquyxuhnR8IxudByGXr+z9SZyq7G8plWrzCT92dTPzPg/DqcdG4PZ3I/ZHrMZY23X+r0Vk5KJZwoVLLOzMey/QRGt/Nc/X91ROfXkolh47ImxbkUBgAd+sXG4+EoNTWNsAp9TLfDgHYs6/h3h8UvsDKnJB71ybou1bKuyNf9Sg2V6A/hIJrtHRuJ+sZ1TqANQqtatvYB17TfiISRvpF45Wz7p03sZuqVlPVenuJjNuOpihmUDr0HabiD5B49WHpvU5/h1nG7W+s6d4/VPxIUlen0lwkkTJxsxMiwq+Fj1KVfkXrOyT7EzZdbiNeLcu+teVY5U8t6aUY/E41VyI/F9h0B4AEev8AOYbPA8NXNzZwT+ezO8jgvlYNWW63VGwKB8opr0D+JjsVDbgPUKaTm1DY7Ha/nK4Ntedg34gZyaj0CnXmLK349+LTwxlNbEdFoXf9SZRgs8O8WzLQbn8tPqdCOxk+EzBi2WVFrR8tgG+J+sTXVkPfVXnM1Js+UHl6xmTXheEWuHL33f8AEDXfUyMUsrW20Ho7gD+gmC23xhnbktgHoVkN4zlXkWsnCvWgwXrqabrLbkRUa91s6cx2hAtIs8NF9lgfZ1tj0B+sSc34TFesVecja3yGlH4CTX8P4dRbTk3eZXYPuL6H3lDkYmcyVJjlwB020oSuc9pAw6qidbI4jYlVTMyMpb8s+WtY2CemvwkuorykONWENR6hB6/UzT4ouNmOtlmT5ZK/Oi9esKi/xHBFgPDnbrq3uYqzyramtXFUE9iTM4XwuillJssY+vtNHhS+YONg/VudVFu6mERgPccK7HvPldNpYemj7SnkYjVfrLFezXYDcbleHm4FWt4sDrZPeYXxUwB5hyFcj9gddwpFxyHABZQu97mjIyMS+yux7GDKoDgDoZW3Gxy7D4oHr06zP5WPRYpFos2dMuvSRDb0wmHIeZo+0Kg74Y4IGdTr+UZbV5dxx66+QHVT7iZ2XMU7VLAF7gDQMKrbj5T9CeIk/DMEKhwzJ1P4RjVM4FvMhHGxs9otbasRmf5n2NEa6QEEV1EOdsw9pcZFt3Ty1A+ojmeg1hzUoB9zITIsuatFrHlKfQSjKfNsbRQaHqJa4Vu43ZxOuo7zXdi8u2SgHtymXyKaf1huVyPQQieKW1lQ5bX0lDWwAYV8m7HUa1SUt91n5dRrtC5rPKBp8wH10pHSFJsx8lh0QiWoaxF4cU5A6PL0jEqe35jcwXXcmQDRjElrDYT6CPoXdX5RNzgk/wBBKpc7D5a0/pNi2Y9lYZq11/uJMURZbYBTSFrB7gaEBWrnOnrHD+kvYlRIW12U99KO80NiIw/WZyIB6Ab1F30Y3D//ADmscfd+TpGzRO8Yghanc+hJlseq1weFRLA9iPSaaKj5Yspo82w9CANxz+HeK3gfIal9vuwM9uFk2px8pE36tYJlXE8mzy7CrdN/KdidDH8Nvu5qrtzr+/wHPX9JDV04xLLU1tg9bO+/wgIGMiIbK6dn05Df/EqtuXvb1kIeg5KQBNi5viLKFRWq32ATiDFvT4hksDfbpP3rG6CBmXGsHJ8u1VX0G9mUezGrI40G3/c86Vg8PsCrk3WWuo+7WOIP9ZVcvBrAppwGZv8A/ZZAwJkJy0cYIT93im9xi4bci9usao+tjDf9J1MLHvfDsX5cd+9dj9B+EW3hobkLvF8UMejcFLH+sowWY/h2uuXY5H7qdJldMUFVx/NsYnrsf+hOrjY+JjZqUHI8+pzouU48T9NzTfVn1W2U4WAwKnXOtNkj8ZN6GKzwvJSr9XWlYPZrGC//ANibMVUq/XXJz91bc1HwvxKpWuvptJHVi50FH8+5hf4TTStWbdlk49y8kATqT6g+0DmVr5dXmAsV3ogGXz3TJBYluYGgAp1HjN5KUwcZF13Y9SZVB4hkKxFfMr3TsfxiT3YwVb7OdAdyB1lX+Ung7Bfdj3nUOFxYG90VvWur5j/MzIz0cyleO2x+8es0miqcvR1b930IEb8TRvozH+UU2OxA44z/AE0I6rGepSbVqrLD/UPUfykslXdDWIE8w7471vUdUnNtIwY630MUyGtNOVdfTY6RarcGDUqVO9jgJnmLMq3APU+mBU/WdLCzmQgN1HvOTV5YYvlG0Wepb5iZX4jjb+prtK+vKc7g3M3rU8u5g6ni3uJ1sWrkp5NyJHSeS8PzPUHp6j2npsC4EqeXQzOm7XO8R8Ju1VYmUqXAkv5j/Lr8Jbw1via3WwKzUk7UL0tH0mjJ8Ppt8UsyGLOU0fK3ofiZk8yhPEfiqHe6xV+6p0iido4Uu+/Lq23h+NXXvoWTqRF49uU2Qo8RFoD9O+huMwfGVclKKq6GZvRd7+sfnYuRlAHIywlYPL5hrrAx5GNmtkHzFoxa99P2mI+kZkeKYlbVV3Y/nWquub+svleIYL1pRZY9t3HiXTpse25kyK/DsOtbXxgxbqoLkmUazm5eWgXHw6gh7HXSRjFMBLcbJt/V2AsevY/SU8Dy2v8AOq0yVvsg8dBJWvw3Hru83Kzldta1AKkxLU23K5R69AJny3VGrGBi8GVtlh139JFtVGNZzxrjcu9lAOgHrOiyrVRU+DX8l3XfcgwC6oXVC77nJetZOus413h9trhnuqrC/uzXd4Rl32c7MsKP9zRVNQyWfw9rwGTsy/tfSBPhdeLbkNRaBZr7j+5kXNn2XCmqjy61OunSLPl+GMFA4P6E9WmRc3KvtI52svv2hD7sbJxLmsOnrHU8jHvRXkUDJK8qz2UDqDIx8Jivn23c6vr2lK8nyVyRVu1W7j0AhWbGxUN9tFbBmC8kb39xEXaT5vL231jMPJWkquOObod7lxmFqzd5NfHej031hCasnNvYKrcW7DpHZC5DKqq7bI67PQQN2Rdw0ERUPIaGpqvfDtud3v1zHQa7GBmpemvGFGS3LbbXgO0u3wf8G06iLcfArG2ybC3caX1mvHU5WDXdSvJweLCSimMiZD2qiKqn7gPoYmzDzXGuKKPo2pe7DzWGgrr+EouJbbS4L8Hq+/8Ah7wpdWG9Fi12Mn6zto70ZVqqaTt1LN7ektT8PS3Ww2uD01Ndee9rMvkVhh7rvcDGuVdyVawFTsDrtGrZnMWU71269BGW2ZWTWa1REU+oGo+wY91dXn5Pl2IunC9d+0DIq49VRXJYhSenD0gzeHAaGLZYfqY9qfD2Qg5GQ/0CwxE3RYEr52V/cB9Vk2M2GEfJZa6GSsjYB66M1W4OTYnE2U1/+T6lbMPxW8aFfBT6DpK4uFkLYMe9eNjDa8j3lCHwkxhuy6pyx0VRtybq8TFcA1Fm1sb7RopppbdhNrg9VA6COHimTW4rqSqtdfKeO/5R6rK2XkcA1LMoHdVHedLwrwfI8YJYZhRR6NvcWub4tZaa7GdNDrwAAhj+IjwxLf1rKzdQEPIqfr6Qlew8E8Cq8HFhSxrHs+8TOoaaydlF3+E819n/ALRPl2mnMsVdjdbEa5fSen6/SbZV8pCNFFIH0mDxDw3wt6mszaKuC9Sx6To7b2E8v9o84WEoL6vKrP8Alg7Zz+Elg4GUvgTs3wYySf2VGtD+Z6zZVQ1nh/nYmOjZdZCuNbbXpqVy8bEw1pyqcZrxaNprsD6jpFsvieTjBqK7al/ZrSvW5hpSzwfxXK+a4Mu/3mAkYXgyXXviX2ouQBzR0bkCPYya/Drcmp2sZkas/rg7fck+ZhYDBqq3yLR1G+g/pAUj1UXH4VC5QEGywA6P4dpAz/Er24WZTrXvQsT7o/GbqfGcnKJSqqmuwnfAVDcXbdm+IKaD596A/MoUVoPx3qBmyfC8mqw/G5xRB35deQ+gjl8Sx8PFXFqx/iaeWwb+uj76mzIbwy7Gpp8RyOd9QIBqGyR7bmPzPAsbarh5Lg/vORKF5Hi2VRULKsfHWs9Ay0rqNwK85slc7JsUIRxY2DiCvtrU3eCg87a/KWrFtG0HcVn32ZnyfCltu5Zvi9ZB9OpMDBfj+DJba3x2U6Fj8tSgBfpuZLv8NqAOAtzXb6Fm3/wJvtxvDsLTY2Sb3DDkvDS69Z0bsR6Frt8HwhYl68i6j5lP8+0uxmuwMrIorfHNWKrLtxaeJBnKu8DUNzv8Vxuntszbd4L4vkWeZZWqjWiHtH/PWRi+DYuTRY1jFbKP8wKd7/CSXSsGNi42Q7Usxsav5lO9cpIbKyG8rEx3FfYcFP8A3GjOwvDmPwGLyt/iWDZmujxjxLLAQXNUzdF0ullRz/8ACc/FXzLwy1b+Zj//AGbrMU4aI1rglxtNDvJbw/NucnxTINSA9Nt3/lNLeMeH01U4pqOV5R+VrBJRw7UtSzzq98Sfm1PR+E2WW1GypT5S6HU/N/OXTxK+9Q9GNiog/aK9BDw6ywZVmRY/KuzpYSOK6+kzcZYsrT8X5OYb7WDsV48F67H1mWvxio1mvEwE0T1U9zEW+HeEh7L2zbypbp5Z6D6Sl+VgWeXV4cG+IU9Gbp/WWTU0U/xJMt8NeOPWjkg8Kh1H4ma2HxOJjnMZK7V+Vwx7iaGpe/GrdLFx2P8Am77kzmZnhVd+QpbNAC9gvU/jKht+J4XWp1y3+9x3E+GLXbfZQ9Jej/Tawesv4Vk44zXxGs80dkYjuZOWPELLWqq0uu+vSArIxvEXsZUFKVA6GzqY/gPgkV7rlubl9xesajZeHW3L9YPVyO0Xb4YwAy3y2FR68pRvzuONj1ti4/NbR7dj7THlHMrppfbE761r2Ak/42uNQKcbVg33bqZfGzsrKdhyVABsjXWBWprs4msVhX78T7STXh4DBgC1y9enoYLVZV4gmV55X6HuYw52CuZc3Hbk9Qe25BkfxQX5Be3HC7/aImfJyM2xiuPWBW3qBqdHKyHyl41Y6H2PtKYKNXh2Y1tg6jYb2jYVi2pjYFlGUeSsOqqd6MSufg1UtXVjkhu/XvE/4coRjZmjXrqJs+GxzWMd/MsB6y6Fa86qh/1eHpp0MAIfOVwqJkJtRrorSlyvZhUW0VKbPuuPYiKqwcq6qw29Dr5eupUR8FbZ/m2ooH+6Wqw8anMprNqOtnQ+vEyiYtluFY3MLZS2nB69PeVR6qgOKGxvQyDRm0qt1jPSSazxPTpMa5eVWR5SOidzxHSb6/EcvItCAIpOuXIdde8TkZGe1j1KwA7b495FPtrt8tX+JfTjfeLx76cPkzk3F1KuO/IRmKKfglx82wBlO1IPpDy8BG2L2/ALKEWX+H0hWXw/lsdDuWpv+JyK7aKFQVnqB6iacGuiy+ygITWy8qy370zrVnvaAMYpXvR4yDbk4BssJXJRKz1UFtTFd4dRSjWnLqawDoAd7+ks2HZRlKtu/LtOtsexk249eNayZCguv7KiAyyimuirIQFktHQD0PtE2W201k0/qW9Ao2TLL4k9KiqqgLVvYLDejNLZeeE5cgNjpxQbMgzUrl5mObBfaOPR15aIlUpqxL1vsy2Lp1C73NeDb8PdbdmHVdylXBbqfaVK+DgaY3WfgohUnNxMtncYfmepHPQET8UuVW9GPh0IfcfMRGDIxEy8cYWNaOJ+fmPvLNmZ4dlG8jBVVpcchx0veAu+qvJw6kvzkxrU6NvryHpsTK2L4WlRrPieweh8unZMZb4Fei+dbbQpA+6XlLPDMIYK5x5hN6dU95YK+H0Y+X5+Fj2MzIOdLsNFvpOj4fl/aGvGFddT8fQ2r1E4p8SFK8cCnyf9wG2M0YrZ3iQKrfd5ijZRjrf4S7R2h4n4zVYtee1dddp4ckI5Azm34K4OU/n22XODviq8V69tmIPhrJqzMvFWuuuW2m5/EvDc9q6bsX4h6xxDO5Xf9I2FWeJZVCrXi8K6j/DXfEyG/wAXfyWfJsurs/dJGo0eI0Y9rY+Nh0U2dtV1FzG4t9RxMjBzMg07PJG7HrMqpiWDBvay1g1bKRZVWC5b8TKpd4dYvOnBa8fvPZr/AIl8c+HYlbVLm5Du3TaKB/LctTTjeHZVTV1eXS3Rkus2zb9QICPOstsrbBwFpatg20BJP0JnWzRj5DCyzJrQlRulmPFT+A7xGZg+I3k14tmqj1AHy9Jzz4JkYZbIsyaqyB1UvsmA98LEvHzXvcF7JRi8dfgY3DoNmJbWcYHJpHKrzOvJfr9Yy3G+NxKMip7ra2GvJV+Kg/XUy2ua0ahc2mmwdESpi2j9TCLUYHiWW7LnUBayPl1ZrX4CZa/DvhsqunMepqrSQAr8mT8ZVfD8/Mu8uy6xLCNr16H8JuA+HoTHNwFvZuCgs0DPlYtfhTsq4zXuOzMOh/AesxnO8TtfQLir+HX0/wCp1cnxZ8d6kuxgvy6R7euxC/N8RKjyOAVh+wg3CsK4WRfQLkcuh6NzfXD8ZOI9Ph7u6cr31oqg+Wa8F/gVtGfavlWj5l313G1t4dcoWmrItHoFbiIRjTxd3GsPw3H5exUcpmfK8U8TIqaooqNvSjQ2JuyPKryKziVVVWKdkc+RImrxLEuzeDUZSYysvzqfeXak54wM1McZ+RwvrXTCs7LTKU8DpXpRfZr36bjLPCsHylFudWbV7ug6xvh1FV9L1tWXKE+WW6c4FfBb6rMuypcby8Wz7oPUKfePt8ORyxystT1PFS2hqZMqnxS1eNCBU9lERRhZeLqzL0at9eR6wHW4eHjgvTaLbAeldY2I/MqSjGTMwcQPa3RgB1Ux2XTZVwsr/wAlx8iVL/2Zltyc+qsisLX/ALe5gJGPm568nS6ll6nkejR3hmOTZbSyhcjW+p9Jm14tkg8LmVv3T0mrFZcLT3sDk/tEdTIM1tOPgE310szKen4wq8ayb7G8ytlBPcCa38YW6/gMYbJ/aHSK8SvyVXy6ak+YdSohF8ihrKgz2O6P6b0P5ylmXh1YhxrF81f3V9I/wwccA05xAA7bMrbTit0rfiv+0d4GB8zDo4nHwVdtb7dpXAyXys85AQ1lR90DoY9ceujITyVJXfz8vWM8Rxsksq4IVK2GzKH3LiLebWcB269T2nMyMLCHO5bWYnr0kv4ZZ5HmXWoLB9ZpwaxlYzIe9foP2pFL8ItGRi21BdON8SfWVPh73V8rrSo/dHSJyXvx6z8OgRt6Opkpuy2Yeby4+sqK5OKcfoXBr393fUx2Vh4+HSmUql+Xp7Gasqg1ohqQaI2XbrFfFeRjMtiG0H1I6S7XTmpbbZ9xnC/temo18W+t18y0kEbHXuJT43Ju2nlhUboSBN9j4+RiU15FvCykcdj9oRfGYrRkVYt1th+ap04Mo9pSnJwMaxSlLk+hYyQuAazUHZuXsJbAppyaMjH48nr+evY6n6RtTQ5+Lqya6gqg/N1+8I7xHGaxyab1CHqBvXSYqasrIUjg9QH0hi0WpmLXercXOlL9tyBb+FrX+sfLQFevfceakvwK7l2wHR1HvFZGFXj3Mtr9j90wp8QXEU11VbRz132gFd7g+XURX7S6J4her/rXVk+8Jotz7q1UrVWeXbSS+FktXmfFZDaBUq6n1EDNUgUH4l+b+m5sOfTfYFsxy9iLrZOtiKZfCFuNhss3vY1LWHEsK3YgdnU927agS2arqyV4VfXpsnepqx92+GCm21arq2+U+6wy8NmKWYCDhaNkKPumZv8AAc5/nZjsderSCz+H1Hf/AO+pd/7eRMPDcalclsM2G1WG0fWuvtLpg+ZgtcLOPBuL8RsiIAqwj5isFfuGtbrAvZ8YpZMajiR09zFpjZdbK+XXZ5TnW2P3TH4fimflMy1WgMO/Ad5N3xV5/wD2ZTmr1VjqFJt8PtpySMlqgnccQSSJb/Ef8PDV00ckfXLn1E12ZmLeKabkex1GgVOtiT8VhptFw6uY9Hs2YGdfF/EDopRUtZ7MiAya8jPsz6cvJYIlfQBu5H4Ca/DXaxr6LkWlLBtCB0UyVw3SkgZuMtx6GxvmI/CAjJbwa26y9xe4Y7Kp2BmXIzPDFpNeJ4e3M9nZu0mzEr8OuFtueMhnPzIV1ua8ykYvGzExQ4s6qwG9RsbWW7L8NrehSb1+VkUhC38zMNngt2RXwyq8bHA68vO20zJj+MXOXIdVHULrQM0Ni5V+MbarUpas6sUryMbRPh2LSMp8Lz1sYLtHX39pFS+fmWNo0mrozlNsfwgr+UPNSnzbU/bA4yieNeI3WcaqkRyfVepkC1ty1ynLpkvi70HsHHQjsjw2qsh8i8qrdQe+47xGzLuxFqVnZ3++zNpV/lG134wwasfxBlsZexAjSsFfi1HhqNRjUtajnrz7TcPFCmH5+1A9Eop2RK/FeFYxPHw9nPpsbh4fkmzOcjFOPjuNa9JRRbrMm5MqxrqXQ/L5hHX+Qk3ZPgr5hyWFj3DrpOwM1W4rtexrtx60HZrPnJmTKw8SpTcWDXDr+rXXKBfz/D8422phjko+Z7iekdgWV5fhz0cmUofkfWtylhJ8OW3DoDMfvqB1icnCyGxVFdNj3P8A7uKpAXb4Lik8r81f59YoDBwLq1x73tDHTj01HYWHZz+FzVTmR00dxeWuNhOVFJawdt9pBsfAWhN4qhEbqOC7YzLb4PkXtz5MnT9tplq8R8Qtt6o4qHok25AvepWxqiaz0Z7HJI/lKF4fhOK6m4N+soPzcT3lq845FvHDT516At6Sca0YCs6oWJHzKOxik8ZcMfhsRdn+sC1Gblteab7WHXQKjQMVl+HuzFsjIPDv8xmxrHycdbMhSnHtWg0SZezyMilVySqt7bgZqvH6cWlcVAbAvZjNSZpao3fqUQdzrZmVsXwnH62AtDAy6HzvKqp1QRrZEqL05D3ZYyBY2h06jQ1F5NPhpzWyHuYN34gzbl46JZxrHMd9k6AmK/w+tt2uyq3sJFRdf4fltqlS9wGl9NTdQofENZYC1B1ImLHqp+GbIpr3av07ylNWRfju+mq79B6wF5XhF2Q5c5Hy+xMinh4fbWhvD8jrp6S+MLRqnIB2/ruLysGjEfnaSddRCNuThmpvMpHLl15Me052S2S2hVYze+h0g3jTuq1LWeA6dZpFzeQWUcm/dAj4rCnhl+UDq08l7gmaVzK8Nqq1bk69CB6mXxLxjubH6Fu4mWzJwVyWs8rbb32j6LDxItewNYU79YZjZN1Rrr0qn11FPlV5lpSqnix/a1N9BF+I1fZk6b94+BCZlFGGtOU4Yr2imyaMv5VXkPbtKN4Mt78zaF39ZS2rG8OtREt5sT1IMefxScvByBl2LU6+Xvod+kq2M1NfmXsjFf3T3E458RvavgeOvfruLXLsVg3Q69515rl1Ho8jHXHeu5BtLBtdSrWvUnnUqVf6Cc1ftBlrStXCkovbanp/zD9IswDQSj+0/nJzV6jqV3+IWJ5qWEpvTDsRLXvviXsYsp31nHp8ey6hcAlJFw+YFT0/DrFVeLX1jQStv/IH85OKdR6WzOxsuzm9HOwDR6xTZ9PArXhLv6zz1fit9d3mhKyfYg6P/MYfGrySRTQPwU/nHFO49LgB8rw967FC2Idrv1EqmBeG21lIU99meXbxXKY72B9BL2+MZNnpWv8A4g/nHFO49Pi4NAzBis6v5g+Uj0PtFuvkXtQKWGjonU89V43k1FSEqZl7Eg/nNp+13iBYt5eNs+vA/nHFO46zvdTeqLZZ5ZHXQ0BGvXcjf/oZ+B7Hl3nBu+1XiF6FHSjifZT+crb9ps26muqyrHIrGgeJ3/3HFOo9DT4jV4cr+XUzo40w9JoXNqNZuOPTrXdhueUH2jyQvE4+MR7FW/OTT9pMmlGRcbF4k70Vbp+HzRxTuPQVeItZn1WpjmtUP7K6BE3ZmJiZNzOchVR+vEntPIH7R5h710f2n84qvxzJS0v5VJ36FTr/ALjinceutxvD1qStMlnsX7gUdY63FqswlyUxwb06NobM8gPtHlBgwoxgR7KfzjE+1fiNe+C0rvvpT+ccU7j0jeH5eXXtTYu/Q9JXG8KtpylqudRbranvuedP2s8Sbuav6H84pftHmretwWouvbYP5xxTuPTPgV3X2WZLeYyfeZzoLF2eNPS4x8fKQqB0KjtOK/2tzLCS+JhNvuCjdf8A/qQftXl8Cow8ID6Vt/8AUfrp3Hoinilw22UQh9QdTVj20YCsLX5Bhp+veeRP2qzzjeRwo4/vcTv/ALmarxzIrs5mqh292Un/ANx+uncewrPhOOPOFdp692c/nHXZfxQqbCqr0p3sHrPG1/aHJrZiMfGIbuCrEf8Acsn2lzK1K1U49YP7qkf+44p3HvL6UusquNgQa+dD7zn5fhtOS3m5GeeK9Qq6AWeLfxrKduThGP1B/ONP2gyji/DiqgJ7gHf/AHHFO49n4NdRYLK6yLXT7pI7xV1Xi2axVV4LvuOgnksP7Q5OE4eijGVvfi35zU/2z8Uca1Qv4KfzjincempxcvB15rqwb9o9dGVsxGwbxbfmu6nsDrU8jb9pM+5gbTWwHoQdf9x9v2szb6lruxsSxV7ckb/6jincensz8pV3hopHrrvG4FmdlW7vuZEA6p2nlqfthnUDVWLhr+CN/wDUov2u8QXINwrx+RGiOLa/7k/XTuPStXf/AIkLzadIdKg69Jrfxamy9kekG0D1E8X+k+b8/GuhS/cgNsfh1mVPGLkfn5VTNvezyP8A7j9dO499b4hnOvCjBVR76k+Gtbj0umWAORJ69hPKn7ceKmkVCvGUAa2Ebf8A3OdkePZmR/mcNewB/OOKdx7dcVHZrLMpmXvodBFX3Y1JHwtPKzfUzxy/aDMWryuNRT20ev8AzIq8dyKd+XTQN/Rvzl4p3Husyu7JWpqWCL+1EZfh3m1qtbqmupb1M8e/2jz39UUewB/ORT9ocyp+XGpj/uBP/uOKdx63HqBY036YjsTM15yamKY9HH6iedH2jzPiDdwpLfgdD/maR9sfER/o4v8AY35ycU7js4teerGzJVmX0Bmq2jJuUWq6rV+6BPL3/avxG9SrCkA/uqfzk0favPox/JFeOy+7K2/+5eKdx6Vrraaj5Kbb2mP4nxGwhQOH01OLX9qs2s7FGNv6q35ybvtXn3EE1Y6kfuqfzk4q9x6N1sqRS/W73PpGX5+Oyqtq8j+E8lkfaPMySpdKRx9gev8AzF3+N5F7KWrpHHsAD+cvFO49Pbl1VDdWNsynhVt1mWzWJpG/4nAo+0eXSCFpx2B/eU/nLP8AabOdeIShB/tU/nHFO49PlYnK0ioqo9SZms8OopRnusBb0nmF8ayw/IlWP13+crb4vkWvyda9/gfzjjI7j12KlXwbWV17cf8AMxpXmXI7ceHsJxKvtDmVJxRKQP8AxP5wb7RZzDX6sfgp/OTjI7jpKMillW5uh+svk41VGrWHIntOFZ4tk2jT8T9dGNPjmS1QraukgepB3/3LxkdxzIQhOziIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhAIQhA//9k=\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/_nw46FH1-WY\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x1f9bd48a8d0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Click the 'Run' button to activate the video clip..\n",
    "# https://www.youtube.com/watch?v=_nw46FH1-WY\n",
    "from IPython.lib.display import YouTubeVideo\n",
    "YouTubeVideo('_nw46FH1-WY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiment Detail:\n",
    "### A farmer conducted an experiment. He fed some of his chickens with normal feed, some with a special feed X and some with a special feed Y over a period of 6 months.\n",
    "### The histogram below show the outcomes of the experiment.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The histogram:\n",
    "# Import matplotlib.pyplot\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# data to plot\n",
    "n_groups = 6\n",
    "y1=(500,750,1000,1500,2000,2250)\n",
    "y2=(500,600,800,1200,1800,2250)\n",
    "y3=(500,800,1150,1900,2150,2500)\n",
    "\n",
    "# create plot\n",
    "fig, ax = plt.subplots()\n",
    "index = np.arange(n_groups)\n",
    "bar_width = 0.2\n",
    "opacity = 0.8\n",
    "\n",
    "rects1 = plt.bar(index, y1, bar_width, alpha=opacity, color='r', label='Special Feed X')\n",
    "\n",
    "rects2 = plt.bar(index + bar_width, y2, bar_width, alpha=opacity, color='g',label='Normal Feed')\n",
    "\n",
    "rects3 = plt.bar(index + 2*bar_width, y3, bar_width, alpha=opacity, color='b',label='Special Feed Y')\n",
    "\n",
    "plt.xlabel('Month')\n",
    "plt.ylabel('Chicken Weight in Gram')\n",
    "plt.title('Chicken Growth with Different Feed')\n",
    "plt.xticks(index + bar_width, ('1', '2', '3', '4','5','6'))\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 1: \n",
    "### Based on the histogram above, if the chickens were ready for slaughter at the mass of 2000g, how long should the farmer feed them with the special feeds X and Y?                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Type your answer:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "code_folding": [
     0
    ],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"BlankPage.jpg\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Click the 'Run' button for some hints if you are stuck..\n",
    "from IPython.display import display\n",
    "from IPython.display import clear_output\n",
    "from IPython.display import Image\n",
    "import time\n",
    "\n",
    "clear_output(wait=True)\n",
    "display(Image(url='AnswerKeyQ16_a.jpg'))\n",
    "time.sleep(10)\n",
    "clear_output(wait=True)\n",
    "display(Image(url='BlankPage.jpg'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2: \n",
    "### Besides the chickens involved in this experiment, list two variables that must be kept the same for this test to be a fair one.                                                                                          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type your answer:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"BlankPage.jpg\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Click the 'Run' button for some hints if you are stuck\n",
    "from IPython.display import display\n",
    "from IPython.display import clear_output\n",
    "from IPython.display import Image\n",
    "import time\n",
    "\n",
    "clear_output(wait=True)\n",
    "display(Image(url='AnswerKeyQ16_b.jpg'))\n",
    "time.sleep(10)\n",
    "clear_output(wait=True)\n",
    "display(Image(url='BlankPage.jpg'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions 3: \n",
    "### What is the purpose of comparison made to growth of chicken with the normal feed?                                                                              "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Answer c:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "code_folding": [
     0
    ],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/0A55QRyJHPM\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x16bbfd263c8>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Watch the video clip below if you are stuck..\n",
    "#https://www.youtube.com/watch?v=0A55QRyJHPM\n",
    "from IPython.lib.display import YouTubeVideo\n",
    "YouTubeVideo('0A55QRyJHPM')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Learning Points:\n",
    "### 1) Ensure you use the following key words when you answer the questions:\n",
    "#### -control variables\n",
    "#### -normal feed\n",
    "#### -special feed\n",
    "#### -growth of chicken\n",
    "### 2) There are three groups of variables in an experiment namely dependant variable, independant variable and control variable.\n",
    "### 3) Depedent Variable is typcially the y variable in the graph.\n",
    "### 4) Indepedant Variable is typically the x variable in the graph.\n",
    "### 5) The Dependant Variable changes in response to changes in the Independant Variable.\n",
    "### 6) Control variables remain the same to cancel the influence of other variables that may affect the outcomes of the experiment.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:red\">Thumbs </span> <span style=\"color:orange\"> Up </span> <span style=\"color:yellow\"> for </span> <span style=\"color:green\"> completing </span> <span style=\"color:blue\"> this </span> <span style=\"color:indigo\"> worksheet </span><span style=\"color:purple\"> !!! </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# You deserve some fireworks your GREAT efforts... \n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML(\"\"\"\n",
    "<div align=\"middle\">\n",
    "<video width=\"50%\" controls>\n",
    "      <source src=\"Fireworks.mp4\" type=\"video/mp4\">\n",
    "</video></div>\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:red\">Let's </span> <span style=\"color:orange\"> have </span> <span style=\"color:yellow\"> fun </span> <span style=\"color:green\"> learning </span> <span style=\"color:blue\"> some </span> <span style=\"color:indigo\"> coding </span><span style=\"color:purple\"> techniques.... </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Have Fun with Python Programming: To draw a histogram/bar chart..\n",
    "\n",
    "# Can you modify the chart by changing the colour, title, label of x and y axes and the width of the bar?\n",
    "\n",
    "# Import matplotlib.pyplot\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# data to plot\n",
    "n_groups = 6\n",
    "y1=(500,750,1000,1500,2000,2250)\n",
    "\n",
    "\n",
    "# create plot\n",
    "fig, ax = plt.subplots()\n",
    "index = np.arange(n_groups)\n",
    "bar_width = 0.2\n",
    "opacity = 0.8\n",
    "\n",
    "rects1 = plt.bar(index, y1, bar_width, alpha=opacity, color='r', label='Premium Dog Food')\n",
    "\n",
    "\n",
    "plt.xlabel('Month')\n",
    "plt.ylabel('Weight of my dog in Gram')\n",
    "plt.title('Growing Up of My dog')\n",
    "plt.xticks(index + bar_width, ('2', '4', '6', '8','10','12'))\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tutor's Feedback:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}