diff --git a/01_intro.ipynb b/01_intro.ipynb
index 39b96cc..7138821 100644
--- a/01_intro.ipynb
+++ b/01_intro.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -57,7 +57,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "TK Add an introduction here. Todo when preface is settled"
+    "TK Add an introduction here. Todo when preface is settled. Maybe the `Deep learning is for everyone` can be this intro."
    ]
   },
   {
@@ -91,14 +91,14 @@
     "|======\n",
     "```\n",
     "\n",
-    "Deep learning is a computer technique to extract and transform data – with use cases ranging from human speech recognition to animal imagery classification – by using multiple layers of neural networks. Each of these layers takes the inputs from previous layers and progressively refines them. The algorithms involved can train the layers by learning to minimize errors and improve their own accuracy."
+    "Deep learning is a computer technique to extract and transform data – with use cases ranging from human speech recognition to animal imagery classification – by using multiple layers of neural networks. Each of these layers takes the inputs from previous layers and progressively refines them. The algorithms involved can train the layers by learning to minimize errors and improve their own accuracy (we will discuss those in details in the next section)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Deep learning has power, flexibility, and simplicity. That's why we believe it should be applied across many disciplines. These include the social and physical sciences, the arts, medicine, finance, scientific research, and much more. To give a personal example, despite having no background in medicine, Jeremy started Enlitic, a company that uses deep learning algorithms to diagnose illness and disease. And Enlitic now does better than doctors in certain cases. TK Melissa: Give an example\n",
+    "Deep learning has power, flexibility, and simplicity. That's why we believe it should be applied across many disciplines. These include the social and physical sciences, the arts, medicine, finance, scientific research, and much more. To give a personal example, despite having no background in medicine, Jeremy started Enlitic, a company that uses deep learning algorithms to diagnose illness and disease. And Enlitic now does better than doctors in certain cases. TK Jeremy: Give an example\n",
     "\n",
     "Here's a list of some of the thousands of tasks that deep learning (or methods heavily using deep learning) is now the best in the world at:\n",
     "\n",
@@ -117,7 +117,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Deep learning is based on a type of models called neural networks. Before we explain to you all about it, let's start with a bit of history."
+    "Deep learning is based on a type of models called neural networks. Before we explain all about them to you, let's start with a bit of history."
    ]
   },
   {
@@ -167,7 +167,7 @@
     "\n",
     "> : _…people are smarter than today's computers because the brain employs a basic computational architecture that is more suited to deal with a central aspect of the natural information processing tasks that people are so good at. …we will introduce a computational framework for modeling cognitive processes that seems… closer than other frameworks to the style of computation as it might be done by the brain._ (Parallel distributed processing, chapter 1)\n",
     "\n",
-    "TK Melissa: Tell the reader what the takeaways from this are in your own words, before you dive into the list of requirements.\n",
+    "TK Jeremy: Tell the reader what the takeaways from this are in your own words, before you dive into the list of requirements.\n",
     "\n",
     "It defined \"Parallel Distributed Processing\" as requiring:\n",
     "\n",
@@ -182,7 +182,7 @@
     "\n",
     "We will learn in this book about how modern neural networks handle each of these requirements. In the 1980's most models were built with a second layer of neurons, thus avoiding the problem that had been identified by Minsky (this was their \"pattern of connectivity among units\", to use the framework above). And indeed, neural networks were widely used during the 80s and 90s for real, practical projects. However, again a misunderstanding of the theoretical issues held back the field. In theory, adding just one extra layer of neurons was enough to allow any mathematical model to be approximated with these neural networks, but in practice such networks were often too big and slow to be useful.\n",
     "\n",
-    "Although there were researchers 30 years ago showing that to get good performance in practice you need to use even more layers of neurons, it is only in the last decade that this has been more widely appreciated. Thanks to this understanding, along with the improved ability to use these in practice thanks to improvements in computer hardware, increases in data availability, and algorithmic tweaks that allow neural networks to be trained faster and more easily, neural networks are now finally living up to their potential. We now have what Rosenblatt had promised: \"a machine capable of perceiving, recognizing and identifying its surroundings without any human training or control\". And you will learn how to build them in this book."
+    "Although researchers showed 30 years ago that to get practical good performance you need to use even more layers of neurons, it is only in the last decade that this has been more widely appreciated. Neural networks are now finally living up to their potential, thanks to the understanding to use more layers as well as improved ability to do so thanks to improvements in computer hardware, increases in data availability, and algorithmic tweaks that allow neural networks to be trained faster and more easily. We now have what Rosenblatt had promised: \"a machine capable of perceiving, recognizing and identifying its surroundings without any human training or control\". And you will learn how to build them in this book."
    ]
   },
   {
@@ -233,7 +233,7 @@
    "source": [
     "Since we are going to be spending a lot of time together, let's get to know each other a bit… We are Sylvain and Jeremy, your guides on this journey. We hope that you will find us well suited for this position.\n",
     "\n",
-    "Jeremy has been using and teaching machine learning for around 30 years. He started using neural networks 25 years ago. During this time he has led many companies and projects which have machine learning at their core, including founding the first company to focus on deep learning and medicine, Enlitic, and taking on the role of Pres and chief scientist of the world's largest machine learning community, Kaggle. He is the co-founder, along with Dr Rachel Thomas, of fast.ai, the organisation that built the course this book is based on.\n",
+    "Jeremy has been using and teaching machine learning for around 30 years. He started using neural networks 25 years ago. During this time he has led many companies and projects which have machine learning at their core, including founding the first company to focus on deep learning and medicine, Enlitic, and taking on the role of President and Chief Scientist of the world's largest machine learning community, Kaggle. He is the co-founder, along with Dr Rachel Thomas, of fast.ai, the organisation that built the course this book is based on.\n",
     "\n",
     "From time to time you will hear directly from us, in sidebars like this one from Jeremy:"
    ]
@@ -310,7 +310,7 @@
    "source": [
     "The hardest part of deep learning is artisanal: how do you know if you've got enough data; whether it is in the right format; if your model is training properly; and if it's not, what should you do about it? That is why we believe in learning by doing. As with basic data science skills, with deep learning you only get better through practical experience. Trying to spend too much time on the theory can be counterproductive. The key is to just code and try to solve problems: the theory can come later, when you have context and motivation.\n",
     "\n",
-    "There will be times when the journey will feel hard. Times where you feel stuck. Don't give up! Rewind through the book to find the last bit where you definitely weren't stuck, and then read slowly through from there to find the first thing that isn't clear. Then try some code experiments yourself, and Google around for more tutorials on whatever the issue you're stuck with is--often you'll find some different angle on the material which might help it to click. Also, it's ok to not understand everything on first reading. Trying to understand the material serially before proceeding can sometimes be hard. Sometimes things click into place after you got more context from parts down the road, from having a bigger picture. So if you do get stuck on a section, try moving on anyway and make a note to come back to it later.\n",
+    "There will be times when the journey will feel hard. Times where you feel stuck. Don't give up! Rewind through the book to find the last bit where you definitely weren't stuck, and then read slowly through from there to find the first thing that isn't clear. Then try some code experiments yourself, and Google around for more tutorials on whatever the issue you're stuck with is--often you'll find some different angle on the material which might help it to click. Also, it's expected and normal to not understand everything (especially the code) on first reading. Trying to understand the material serially before proceeding can sometimes be hard. Sometimes things click into place after you got more context from parts down the road, from having a bigger picture. So if you do get stuck on a section, try moving on anyway and make a note to come back to it later.\n",
     "\n",
     "Remember, you don't need any particular academic background to succeed at deep learning. Many important breakthroughs are made in research and industry by folks without a PhD, such as the paper [Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks](https://arxiv.org/abs/1511.06434), one of the most influential papers of the last decade, with over 5000 citations, which was written by Alec Radford when he was an under-graduate. Even at Tesla, where they're trying to solve the extremely tough challenge of making a self-driving car, CEO [Elon Musk says](https://twitter.com/elonmusk/status/1224089444963311616):\n",
     "\n",
@@ -335,7 +335,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Whether you're excited to identify if plants are diseased from pictures of their leaves, auto-generate knitting patterns, diagnose TB from x-rays, or determine when a raccoon is using your cat door, we will get you using deep learning on your own problems (via pre-trained models from others) as quickly as possible, and then will progressively drill into more details. You'll learn how to use deep learning to solve your own problems at state-of-the-art accuracy within the first 30 minutes of the next chapter! (And feel free to skip straight to there now if you're dying to get coding right away.) There is a pernicious myth out there that you need to have computing resources and datasets the size of those at Google to be able to do deep learning, and it's not true.\n",
+    "Whether you're excited to identify if plants are diseased from pictures of their leaves, auto-generate knitting patterns, diagnose TB from x-rays, or determine when a raccoon is using your cat door, we will get you using deep learning on your own problems (via pre-trained models from others) as quickly as possible, and then will progressively drill into more details. You'll learn how to use deep learning to solve your own problems at state-of-the-art accuracy within the first 30 minutes of the next chapter! (And feel free to skip straight there now if you're dying to get coding right away.) There is a pernicious myth out there that you need to have computing resources and datasets the size of those at Google to be able to do deep learning, and it's not true.\n",
     "\n",
     "So, what sort of tasks make for good test cases? You could train your model to distinguish between Picasso and Monet paintings or to pick out pictures of your daughter instead of pictures of your son. It helps to focus on your hobbies and passions–setting yourself four of five little projects rather than striving to solve a big, grand problem tends to work better when you're getting started. Since it is easy to get stuck, trying to be too ambitious too early can often backfire. Then, once you've got the basics mastered, aim to complete something you're really proud of!"
    ]
@@ -344,7 +344,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> J: Deep learning can be set to work on almost any problem. For instance, my first startup was a company called FastMail, which provided enhanced email services when it launched in 1999 (and still does to this day). In 2002 I set it up to use a primitive form of deep learning – single-layer neural networks – to help to categorise emails and stop customers from receiving spam."
+    "> J: Deep learning can be set to work on almost any problem. For instance, my first startup was a company called FastMail, which provided enhanced email services when it launched in 1999 (and still does to this day). In 2002 I set it up to use a primitive form of deep learning – single-layer neural networks – to help categorise emails and stop customers from receiving spam."
    ]
   },
   {
@@ -434,7 +434,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To do nearly everything in this course, you'll need access to a computer with an NVIDIA GPU (unfortunately other brands of GPU are not fully supported by the main deep learning libraries). However, we don't recommend you buy one; in fact, even if you already have one, we don't suggest you use it just yet! Setting up a computer takes time and energy, and you want all your energy to focus on deep learning right now. Therefore, we instead suggest you rent access to a computer that already has everything you need preinstalled and ready to go. Costs can be as little as US$0.25 per hour while you're using it, and some options are even free."
+    "To do nearly everything in this book, you'll need access to a computer with an NVIDIA GPU (unfortunately other brands of GPU are not fully supported by the main deep learning libraries). However, we don't recommend you buy one; in fact, even if you already have one, we don't suggest you use it just yet! Setting up a computer takes time and energy, and you want all your energy to focus on deep learning right now. Therefore, we instead suggest you rent access to a computer that already has everything you need preinstalled and ready to go. Costs can be as little as US$0.25 per hour while you're using it, and some options are even free."
    ]
   },
   {
@@ -452,7 +452,7 @@
     "\n",
     "> A: My two cents: heed this advice! If you like computers you will be tempted to setup your own box. Beware! It is feasible but surprisingly involved and distracting. There is a good reason this book is not titled, _Everything you ever wanted to know about Ubuntu system administration, NVIDIA driver installation, apt-get, conda, pip, and Jupyter notebook configuration_. That would be a book of its own. Having designed and deployed our production machine learning infrastructure at work, I can testify it has its satisfactions but it is as unrelated to understanding models as maintaining an airplane is from flying one.\n",
     "\n",
-    "Each option shown on the book website includes a tutorial; after completing the tutorial, you will end up with a screen looking like this:"
+    "Each option shown on the book website includes a tutorial; after completing the tutorial, you will end up with a screen looking like <<notebook_init>>."
    ]
   },
   {
@@ -501,7 +501,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To open a notebook, just click on it. The notebook will open, and it will look something like this (note that there may be slight differences in details across different platforms; you can ignore those differences):"
+    "To open a notebook, just click on it. The notebook will open, and it will look something like <<jupyter>> (note that there may be slight differences in details across different platforms; you can ignore those differences):"
    ]
   },
   {
@@ -533,7 +533,7 @@
    "source": [
     "When you click on a cell it will be selected. Click on the cell now which begins with the line \"# CLICK ME\". The first character in that line represents a comment in Python, so is ignored when executing the cell. The rest of the cell is, believe it or not, a complete system for creating and training a state-of-the-art model for recognizing cats versus dogs. So, let's train it now! To do so, just press shift-enter on your keyboard, or press the \"play\" button on the toolbar. Then, wait a few minutes while the following things happen:\n",
     "\n",
-    "1. A dataset containing called the [Oxford-IIT Pet Dataset](http://www.robots.ox.ac.uk/~vgg/data/pets/) that contains 7,349 images of cats and dogs from 37 different breeds will be downloaded from the fast.ai datasets collection to your GPU server, and will then be extracted\n",
+    "1. A dataset containing called the [Oxford-IIT Pet Dataset](http://www.robots.ox.ac.uk/~vgg/data/pets/) that contains 7,349 images of cats and dogs from 37 different breeds will be downloaded from the fast.ai datasets collection to the GPU server you are using, and will then be extracted\n",
     "2. A *pretrained model* will be downloaded from the Internet, which has already been trained on 1.3 million images, using a competition winning model\n",
     "3. The pretrained model will be *fine-tuned* using the latest advances in transfer learning, to create a model that is specially customised for recognising dogs and cats\n",
     "\n",
@@ -542,7 +542,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -561,9 +561,9 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <td>0</td>\n",
-       "      <td>0.167097</td>\n",
-       "      <td>0.032373</td>\n",
-       "      <td>0.008796</td>\n",
+       "      <td>0.188673</td>\n",
+       "      <td>0.012107</td>\n",
+       "      <td>0.002706</td>\n",
        "      <td>00:14</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -592,9 +592,9 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <td>0</td>\n",
-       "      <td>0.044406</td>\n",
-       "      <td>0.008025</td>\n",
-       "      <td>0.002706</td>\n",
+       "      <td>0.056649</td>\n",
+       "      <td>0.009575</td>\n",
+       "      <td>0.004736</td>\n",
        "      <td>00:18</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -647,7 +647,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -656,7 +656,7 @@
        "2"
       ]
      },
-     "execution_count": 3,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -674,17 +674,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJcAAADACAIAAACGdmZhAADHOElEQVR4nEz9SZMlS5Ymhp1JVc3s3uvX3WN888vMl5mVWVVd1SXdaAjBrhZ0NwiSIhAA/AEk/wmF/BvcQMgFNxQhKMItNwTYKPYgXSxUVlbO+caIF4OHu9/BTFXPwIX5y+Zd+Cpc/Iapqeo533QQ4J99+vHV//5/97/9L//Ln/zf/y//h+fXx89+cNXbWWizzPlXv379q19/8+pm4zAgOIYDOHGULMv5dD7fEyKAM1MZByVU1XAnQvRw7ahWEKz2en+s84xmZOhqDJhSgggza605QhnHNJYyjrvLPSaMCA1XV2CilICoqnUHImHJQRgKQpJkQCB3QGREImQAcHczNTMl7+LuTohZUs6DsJiqdWNiEVE1bYvwEdf/RkSYR2gS0dogAiDcPaVksc25iKRuGoFSSm2mZkjMKROzh8fSyB0ptM/uLUuIULh572YGERiETEpuXYeUh5zb0uZlpiQo7EINrLlbeLScRJgoTIkiM7srhoE7RjAjExJdmIOaurk8ecb/1f/qn/3lX/75/+O//W9qna8ePa1VwYfjGV68uP3d79++fdvMN0gOEBER4W6G4O7OxEQIgMwYABjBgMgCGO5GiAFxPi+xNFfzbr1WAQpzQ4wIBFifkYabW/SOwq015hQIjgDIAAiAASiSGcmBANCdiBARzSxCCTmlBEDhEQCADhgRToQ5iamFmbtpqygOAeAaEGGI7uFa+yIiKQkBBqIH1dbcLKXETAwwpOQwEEkEhAcAIkApSTwBIiA7gHULMxGWRMRu3QHNzM16mLkZAgAgYgBTwpQkMXMqOTAsApiQKAEEIFh4BEYAGBEyIhIOeQQz9x5mEWERS2sBhAjILP/Vf/0XP/hh+X//q//2629+9cc/fF8tXr2Z27nd3LSvvrp/9cZYng8o7g4QABgeqrqcF7fGTMJEzAAPDwDUHIAIKQKDzNGbe1UwT0TAKcwBKQDDIQAAiCVb7+5gatStd60JSQiBnQARAtgdkQWRwSEChRgRCRAAIgIRAIIoHBwC3C1CER2JiAkdLJDcAkC7g7m7BRJad/ewlokgwJoignsEBCABRSA4YkRUNwp3Vwdw9wDArmUcRcgDArCvOx8BmJAQA4OQiMysWYeIAEBAIVT33jyxcASYAwBxAvcABCAg8jAPN2uBTiQESAgR0VqDCIj15UcIqGYBjkgAIc/fP5/nvz+8u33/2cXr12+++v3tcjof7ut8xnnJPTZDuRBaADoAMKFFuKm2ykwlpyQswoCBQGZeHcxNiIUZ1WpTynk+L/U8k4cgGTEJYQAFICAhmrtBrN/MIzxCCUUkSWbkQGJid3QA03CHdXciETETUUTAw/4DpIAIDMcIWvewG4cTBiIQOER4uCAQAoUDRGYqlLpqdwMAFhFJlKT2FhFL6613Ihw5l1yklFLKus7gbuDrOYFhDE7CSNG01Ta7tZwRMNY/HAiIDMgBruaE6EROhAAE6AEAAQEUxOGkgaaI68pzBFrvzIzAQAIPn0iSTL2rurm0+fMvX99f7za/+XU93922c01ctAvJNg370Dx3SDBjVCICYXftrQXEMOSSM2IQMlBYV23mahEB6OAA7gwUBtq0nhtoFxIaMiBihHsQYBBp7wZBKAChprW1wJEkYR6IEgYzyTzX3oyQcy7MrKpJOCVeH6a7ATgRIaHpw6kKgAGB5gH48I5AIIQIEBEDAgQAhKNXxwABYmHOSVJ2BOi9m3VzdWCm1jsEIjPnTIRuCOHgYeGIRIGZBQgCQ91ab9pnCxJhZPFwdABEJ/QgD1A3C0+cwtwiKImpERAhR3gLyIwIzgD8cOo7ITsCADiAG7gHZDCA7q7uMh/eFEk3r1+jI7hInhAyWDjm5m7YeCjYLHoHEkZGxPWJEGF41F4ZIACsKwQSYmJGRO/q2r315TyjxZizBahaXWoSwQBXI8Qksm4wYXDziA7nJdronJBCCBHIDN2T8HBxsX/65Ok0jct8vr2/6b2rNTcNCE4kCQEiwgP8YeHWI9cfqhQIDwgEJCAgRHcARAjESJKQGRB8XT6A1rWHIXEeyzCOcY4IMDMzE0ksSITR3dXh4fgEBQ8AIkRCD69dAZKIhIVDIKA7oEgRdnfOpYyTqbVlIeIIJCQhDooMLUQAiYWIWMEDXNWRiSQxMwsFhEEgkyTxCGFPpEJevAeBcBprMw9D74AumTkbepznhr2he4ABOEBYVwTstR3mMzEPkt0BCZnFWtfWQrUez3WudV6wa0IZh2xgEWCq2pUAzAMQutqpNhTiLGrOdbvZ5QCq1cJwPs9XF9ePHz95/OjpxX47lGF4mu+Ody9efPn6zcvWLKADMiEgBgAwE9FaSlC4W6iaYQQiIn63tqZdu5lhxCi5lEySam+1tW6mHt3NAZCQUcyAAhAJEYmICJk5IoQRgN3MvIe7E2nvxDgNxWwx68xs7rU3BM5ZAMUDiEUQAnhuJsypTNo6cIIAc2CUadoB1NobIAkLYnQORAZKSEzIHuGBxOuNGQQg2AYNQCVXi8AeEW6EQawknQjCnBwTRiAGWpgxIVNi5lCzrmbGRIgEAW5h9l2l6FBbV1U3B3OCiGAUREQSEUBCZGZipmSgquDuCEiJ8nJc8m4Dzlbj049+eLG9nsZpKKN2OlnXjkPZffThZ4Ty1Te/d0CEUG1I62HK6xNHJEQyCAB72JuITGhdrVeHYEbhBMjdNZr33lutTR1YkiQgASIkCntYPgByd1U19/VMZggAN1fv6kyEiGbqnRHXa1uI3ELdzSAlTiKMaO6q3rVhAAKEOwUgQAJOzIlFwQUJHAIIMEQSIgcx0bqeiOAOjhHmHhFijQEw3DEwwk07kTOjsCMZWDfQiCyZ156qu4qwsBCghyNSlpxTJhYEcHAEQgYCAg9iRiQkIhECREQPX5/wQ69ApKYkIgDuyoxSMimOw4AdCub3P/zgow++Hy4BYBranQgJIqW02+6ePtO7w927229b9JSBECMcwhFxXTAiZoYACDcAIwIg7LaoKRIKJSLqptrMIRAliJAAkAiFSYAYEAEAmZiZiBDW28kdgBEQPMApTEOjQcpZw/p8TomQE0QI8zgMrZl5MHGiBGqA5AGOAYSACIAP7RBGAAgwsLCkiPAIBBhSXo9/RIqHC12ALNwN0DyEgtf6FRkjIqIzQyIUDAwIDzSPAGQiJDNDiCSMEK4dkIZSImdEjEAghAiLIEAHdwCS5AHmQYjCKRDDOgQ5xHpRuUVXlQyKoRZBIRpRlQYQoSePn330wffckhk6kFkPgDwwUu6dWl2Gsnv/+Sc3N69a78O4AVB3cA+EtfFDZHKPCPBY60UQWuEBRgRVUzNiqt4BUJhFZO1OIci6I6FwEibntSgWEWJCBDTTCMMIgCAIwdAIimB38GBAIqq9YeAwjkKpdiNidIgeQICIxATMgBhgDugBCOjIhuwBRAwYECGMIklVAwDcEeK7DisiHMMxTJjAXD2U0IksXIWQENGRAyGyuDivd6wB+npOQYSGoTuzEJKrAnEaBgDwUELU1mc7L7XOddHe1343IgyABMPd3cODEInYAczD3V015nmafL47fvDkk4/f+9jmaL2lYYeBHgDk4VibgeRWtZTxyeNnm83+eG7MomoAGBGAyEjEiVISSRAO6BARodqqAyIJEZipqQ1DZkB3twDzQERmdlvBg/U6SspBRMRETESEAKZm2sE9XMFDiEgAIgRxzCnCyQPN1TuUTWIJd/fACAIMcwNXc+sQiEgYHkiILCQixNWwmQFAYgKUWC91dw/DAABHwhVMIHdwF6Lo2s0qQLA4kTMRBcGKtYEwcmftqmtvQAQRIcRG1paqXRnJzYIYUxHhUNTwqv18Pp/r0t2ZGRBab62bZyEEAlz/CCJGhLkFQMoZGANRl+WDZx89vX4sQMgiMngwAIogcNAK/gDlPECgemw3u9buW+sRth51TJzTEMRmQOvBigEY4VDr3M0jLJOQsGPUXpkEAd2cAEVyGAgKZWIURMYAZiFCRPIIN+OI3lW1uXZwZwJmYsquhkKbYTjNJzMVFouw3p0hPMyBA0YkAFjXIzA8AmLtkggI1C0CKA1tmcOVidRMmyYhcEOzCAcICsoEgGyOACQOM1AjiCScRMAjIRMArNd3RLcWUFLO2ru7c0I1b83MIKQQYjOXkinzGSosJohoUe8P7XCCueUgJAIAEBIMB0Rfa0XC8PU0aV3HzVRVBVM3093lJz/+RxfXz7XJOF6FJ0A5zWf3RRIDWXjvoUg8q0pKZXOJxzsga+3s3nIpwFyjYyCEhHpiYAKts7aZtVHvSJiQA9gcWoitVVZhQgpApwjAZsYIKVGAsy4szLwij009IDojEIEHEUjmoREqKxEFhOS1JbaEiACtVQ8PgoYJeOPhEYwQae11VkgowglZhFgyBgh15e4REN08SxIUlMQRGObuDoWZURCJBNn5YacDBiGAOzAJEVoYuFESDYRggIgwkRTREZyQ3B0Q1+YjJRbEpr1Vtbme7u/1vHBg+EPpKSLEYOaMyIDAjg7hgeBZJDyEREh6t48+/UmZrpumknc573oDtSBMTG5Ww1sqHBhq6mCUhDgHCBEhCYQjSmCYGaEzgXXFCETTVrUu4UYRuMIAAExpGHduBgCAHAhmhkSAEIGYmIu4u5/PjkZI7l21RhghiyTk5EaIOaVByQDXiw6Zc7i6ahC4m1tzAkB0iHM44YrForu7uanhA3JHBgDuBdezlBZT8wiWZm5AjOCO6BEWYYYMTMwcIrAiHRFuQETMvB7/QZAEIoSl9WquAMFMIowIRNR7X5ZlRXwDPSqAIARo7/W8tKWamUeEmpuvUOcK2iARrVjZetAjlpKXplIG9bjYX/3w+3+UeQzjcbsTGdxcredSEvFcdelNUoqwCFBQ7bB2K2bNzQICMeChekCiAHZwUzdzU1MzQ+IIbN2JhTmZW5hFOHEgkxCmJERkZMSE4a49nMwIANxBjSLWJSFmQsoI0h5wWyRmBgw1N2QkZDJXNANwJDYDd6UkhASwFs9uYYLCIrQiD+EWwCJAoeGIkVOyrgErRL4ijtg5gJwJCEPAOoXH2g0iMMswjK326i4sxFS7qTkRAiIzi8jDRfvdBwCIyE3NVACFyQRFKDBMVYiEJcJXqCzCwDmIAdZ6xnMZPAKZu7o6/PRPfjiWq3G4LnmT00WtRjIWKk0XEiaZ4rz0thBzyskMAHyaxmEox+MZIogIIMIj3MI00ImBGb2bau2mEJBQHMgcgIQphelKFAQ6MSNi5gQIQBEeEa6tUyAGYxAgkjAgqvbuZCxMQpQASCEikNZDDSOQgCjnhOAZsLtaeLgjERLxun3MAEGSrM8xVjwZwM0kJWYUJ4RImRtYeKADWAASU3TQCKAgdBRQFSQSiqC1jOyqS2u1q0gm5taUwIl4LW/d3cx676q6tn3uzsws3NXAggEECdzDo+RcJBGRqS11MdeIMFMIRQQMWEs+C5RUTovurx599tlP0cdNeTSOOzUObykP3brWM7iWMW03m/NsDsgsajMAbsZpKKVVYRkQjQh7b9q7u1IAI3qYtdZ6NY+cC1Ii4HAASkh5zKyd/IHuCndrbSFCMxMREYaSsSOzIGM4AzgICY/r/kUpwILAbj3CNdARCRiJACOIAyg4BQKEIwTHuuceqKqVETKztURf+2jDlb5jEWYIQkDw9emHO0ZEICUIQiIEAFn5UkBs6mqm3mqzQCJOS9folvMAama2/rGIqLWqKjOnlFTV3SMgSfK+nE8nbx27M0BiGnIiJPSwcIBgRMnk7hCACMJILA6eh103IpYffPbTq0fvQzwe0kWdAyVNm8kiBCX8UHuzUCRLIt2B0MEDIlJiEV4pF5HEjIQgLMBuPptpaz3UiClJEikeDMDEgigeSO5rA4FI8d2RFQFro0nEKSFzWSsAiK7uoSA5hUd310BBBiDOhQLCHdxRKDFBhIXW1k5zdfSUiwigr5vQ/rArAGB9mBGx8snuqN0EURIjhodlQgtwRyfCAAwqyYOAiQNCci6q6rAeb0CyolgYsIK7SMwEHKYrNFlrXdcSEVcQg5kRoLfqrYEZqGmrocqErqrrW+auvasFE+WcmBAgCJBYLIRY7m9Pl9cf/PDHf4Y8jXIJJr01sJi2AyLUPk+7i353mufTdkNugQDaOhNShBBvxuGOwM3CEVlKFlU3aIjkQQZubok45YzIYQQoSQbkDADgqr2vx0lAIFPOufceDtqNUIkokEsuDm4VEcwBzMUiLBwd3SJCizAhIZGwMKGvdK5D6wpAzPxwXROuK9dai4ic8wpjrT+Z2c3YwsNX+sysIYBgsKCzhEIEIDBHd10BKRINWrpHABIhU0r5oQc3A7AI6FoLrkwnrDfi+u6srR4illKQKOqM5hRgZvPx3E9zYkHi3ntAPMDQEREhLDkzrd+b0uHY7u7PavLp93/69Nn3Ihg6LdY8iAnNopp2M1txZE8YhkHM0K2nzCyECKVkZnLH9UoEwNZatxnZXNVUI8wdzYxZfIXYmFEEINiTOxKTB7hDztk8PJAl01odBQij5OwAHJgdHMg8KJzRgQCBDD0APMLdaT3E1QDW19gkJc5s4RCQVmYR0d1brevDhAg3i3gAZbo7gJlZuHedmZmZkiTC7IkiECmRLr1XVcMIqT3UV1UAIRKyUESgc7h6oNtKca6ftYb9w4oiYkpJRADQrWkFUI3eyZ0JBSHMwi0iSDjnVApmSUho5l1rAAJaVzyd+kef/ugf/Pk/KeVKlUcZzudmanmY8jCEKgUdDmeiVPI4n98KOhaEiJUKR4gwQw9CgIAwD3S3Fu6A3loLB6bExB4B4UCEjEHo3t3BkTBlQGqtRUCipKYohYnWW7+25tCint2hdgNKyEjM7A7huELFoYmZAFYOPRDx4XjTiEAIBEgi6EEWEZCYMWU096YkiYktoPWGiDklgMBgACSEzCKMiMhILByYAAQlSycOXKyamRhmEAZEjwBfZSUAgMIEQRDAEonEANZadH1b6LsPIj7IkHqvx/N8OFnr4c4PFMeKGAEACDOLYFC4OXgEeoCHAwyb7fRHP/2HH330w/OZkIZE5N5bU1gyjVOeplCYNpv5vNTTEZxUm7kFey4YTmZhZkiIAb138+D17RUKUCUD8CSyXgFEFEgkTIK6vvwu3ZQJkDNEqCNxcXcHXL9koDiCgptDAAgLkQQQowIEBhIAB6IbEGZhNAw3cKdwRsqMvgrPIsDBuqlZdCUiIVZXsJVqBgpg5iFlHhO6QXSEIBYEd1NwMiVfS1mHxIKSUA0BhWRCMETUVs27uhMGYQRGYgQIYVgvtnX9Vqa0lCIi644EgN57b91ab7VGV+8K3QDpD3sXkQAAArV7gBECEQcEGNamz95//tlnP0EYHWIoOz3NiD6OJYTm+XTuzdGTkHu01hOJAXWta0Fu5hy4rtpaGYTH2hGZeTcDoPU/jg8UhzgyMAA7AiFiGLWugphzBkQHMHezAIiUUioljxSwCAsnghCREQJ7VzfkgAdABENNIVBEAtF7uCsSikAAd9eVBliRBUE0VU65rFexmgeYGXhQBHiYObr1eoaoWQBDV2YlIHqouQR22U4GZMghJMEZVn7V3bsTJYAeEQgeoe6qjhHFzNe9J8LMnJIQ4Sp5MbOlLn2ZTRe3TghJ0AMxgjBYeC2dIsKdIiSCgTwCVLU2s+Dr66dPHj+/vT2W8TFE5lS5Qy553F+24GNrhKi9JsnTuJkPc8KUqGmswrJg5LHkJGIdMydkIMTe21Jbd4cgDDeInDmXrGsr6YpOQABEYZzyICIr4pFLXpYFzQBAJEkSQFQ7AzkBYTAhmjoFZZZwIIpVR6TNzKNHgJmrMgIDegSBE4RDIHpC2U0bSbwsdV0YJUZEVYNwJmEgV1NzBG+9cvRRBDEggCAMEQIMAAEWcw3vCBEg4gsARGgKzYJoHcGZIBzc1j6YGwImYRFCEQ4iDg81DzdEcLda6/k026nWagIkQOAAAZgEiN29hboBh43hgAEOYymFUwJYNO82O1U7d49B2XVbhn44m2thCCLhnIrc3S65FE6b4/m1WUNmhLSSqEgsZaAktgRmJooIU9Vmc4QzETMnScTFgNVdHZobg1JGICJOOWUhjggiZkpDRl+xpYimEeFJMgAhMjEGmrqyEJi7WiDFKv8IDLemNWKF2ygikBBIwCHChErOg6SLnFNw7b25KSURoagVEAGCEIGAETw8l1GooBDhyuSRAxNTZg4ANzVVU3V3yX4EiN47swzj2FtzdyYhyYLi4UTUyRzYgDQIAqFTrFcEhHCYWe9LrS06IWQ3d0AwcA9zZ6cOoEDBDBQTmyQ5HE56tghJNHHZbDfb81I57xrqOCJA5jLQMBrTqS6HZR5p9ALO2HpPF+X+3R0rr+WFA/vaHos0N8nhK4mWkZpJmAcxC0tWI20BkgPRXQmFkiBwliHc0YOJGDm6oYcQB2FXMzdABBMzgIQo4NiVWw/Q6O6WMAtJ7+621jLAzEhUzRChSCEKCgLzTAPLdEaZO5hjU7euiJBW6VdKqxQGEcI6AuRhCoDFfChDybm1FqoQHma9N8QeEWiKERLAiMjCKQlzxiK1VkQWSVyotT6f57wb1i3lvuooNVzNlNEDQdt5mY9tOWPtRJhWIHEVPHYLCBQSJhTOCOSOQNvNrnscj5o3+fLJ88vHz1OZ6gIbGTdpQuucuLaWVIdSTnW+fXeznVKA9lpzknEY6/kcgQTMCCuwm5gEgfxB0M0RCSQBBzKBoKK5QTAzEQuzsCQGDgBicAgIg1WYgxTozIRMwAFGAdDPhiu9vKr7DM3M1MEhyMMdMVS7hzHLQw3oHgCq/UEkgAgIpq32Gu7hAeFuHcIyD8LMzBjWe++9B8Ja+WvvRDSUknMhImqt965q7uDWViRPEAUlAQALOGAzBwiU5BC6KhKRFAKalTExi/XWWhckprBWHc0izqfb4/2NLvPgJMhZRJAMgoCJ0sqFO3pYR0QGOB9PMm553JhWL9PHP/rp048+3Wwu52XOLoNzSgAQ797dtIj906ePrvZfvTgc7o7bUSLCet9MG2hNdSFI4iARzDCmVFjMFg+13jw8mnkwizBlosQojkQkzMXAEAgUuqmlMwIQgBs0rWtRHZAIxMM9LAByHiDAPXQxIATkkkuIhhkFgBmEISEBr500AKzA1opTrp9w1+jWq5knkZwzphzuOQkhEaI7ERCT5JLcXdUQRST17uY1ImIVTTDkzBgGq8w4XFByQACiqc21EdIwDhFhq0CXJA2bYz0DcZLUW+/LzDnlzK7u2jA8dA5dOEIgEoEwChFDODEiqftDEYGAqr0pIN0fz9Fxunr2g5/++Sc//ZPLZ+9v8/XxcIsGomjYWTgl7lrPp9vd5eVuym/evLVUhPz2eNhOgwiEBoeBOTomoSlJxqiq4WrLEuEUSFRKniQPxAUpBxIAoYh6BwgLQwOl8yo2BwizbqoI6CBkycAdARDHchWBVRc3DUBJDA4YTATobuiInlMChD+QBCLCzA8gM/PabiGEDGyGTCjkARiO4WauBkhIOZeRxATnefawnAsxz0sVSUQUAbo2Eh7bcQT31nvvLiAc7sTs7t2dGVd2HhEtwiEwyQAjBHi3RCiDRBi4u87WFxYEq5kcGVgdwsAVaOWCH+r2Va75APIZpnEQoMsPP/nkJ3/2/Z/8BcnFYVaG3pZ6Os20WMuLgadMSz+/enlXBrJ2Cl3AgMGykLaFXDM7uro6WGSSgohdvVYAx9YZEWRM0zYPI3LxQF0PNWYEUF8FuhABDOrWTQ3MIQIDEMHU3JojUBIRESLkxEla7xqGBLpCkuHh5qpmHQFJZBU9r1K5dSFXnPI7dWUkBid0s947AjIJAhs4xMobESCahnByCwgilHDV7iIEgKag6u7ee18FaUmSqK3aOCZOSB2Jl9pzppTY3FQ9IoSTtta0CiET1mWxufX5ZLoEg9UFV5WKr76j8O9EPg/uHIeAdWsHiTSLx+9/8I//6T9/8smPlijfvj69XObHm3p6ffCj+nmGq+hhwOLh727efPDBo9BjYaNoRHaxHc6ng0cncAKlcAxCddOqywzaEQK7DkOJnCylhhDhzVzDgEgwwlytQQS6BSrbssyL1oYBiZgQe2tAGERByEnKUNp4LsM2iQQAOgMBE60vuYWufbQDIvMKLKzA24p2/QHqAkCM6tiYRXuHoFxG4RSBgqIduqkuCzJByivAv3rHgMjCV17bYJVs0Ly0xCwpSWapbSmlIDIipCQejgSAHvBA7XoYOgkxMTMGeAjEvJxdG4XX46xzIwNQYEQWQaQIXxdUtbtHJnQPBsy5IOaUx/c//cHH3/8xTNf3N+d5ttcvX8/DspNxMyXAmoZBexfx7W771de/+fLzX3zvex9fXZBZC/Nl7h6V2ZhAJIgCvNfF6vmodcEwgkiEm6Foye9cdamUBkNyZhZavKk2puh16UtNgtBvz+ezN00sHdG61taISXJ2DEcYp4l2+10ESWrdOGeRYhau3ayDexYhsNYfmJ8HaPQ7kOtBW2SmqmEtqIdgUxtKHsbBLHr3lBK4abcISFIYVw9heHhrzc0l/cGh8R/wUBRGpkAUInS3rs3dAONBJe8rQxJIkCWBAgQIMYN3t7acrXcw867Rg10GCiggSgHoHg7RTQNBSFYYOiIgvIHL5fb9D7/3/ic/GDd75XEq3JZvtbbNo/H9J082KQ0iB1oup0fH47HrcRj889//7Pmz8epyB8BtCa2a2MZSEiNxLPP9svg4sGnLiU11GgacRvJwiLkePYLADLi5A5KZg2tC9Na0L76EzbemFmrLKgj1UFUgNBENNwhfFsZ9ylSmDZAgmJuuGJZ1AzDGYCJiMA8zyznnnL/j7B4W0t3dLQIDxQJzmrram3d3zImQm9lKVCCihtflLMwAoKsIIZH5arskSZyyuLsZASIQI7NAmKu79ohV6LhuvzBXj1VmJ7BChYQEGKZtWax38rAW3oA9JS6IEOxqtmr0mrkHKEOooeBKBTrBzJz2l3l7gTRwJDZlo+uLfckkIzx6tmeMeuplwAAGpGdPdvP51fHu26n0cShCXUQ3G9kMg/fe+mzRGcDcAP3yYjMvuBlGAry7vQVu3JurhZsG1tYUAgE4ItygV2tVu0LXlR321kGdEMEMCMFjPb2ARPu9w1ZoYCRHd6uurqpuxgiAQEhZqKpH+Iotr/tv3TXrvlyNBl0JEMchqUVTnTYcxF0ViSRLBHTtCMEiARBqAcEsMoh2dXckAnC1bhE9gNU5RLLQgyIfCREhoqv/QU6BiAY2ypYiVjqREZiod+212WLebe3nRRjQLEIBgsjRNdwMGNkxiQADpmlz/eknl++9N+4uS5ncini73lzkq1T76c27bzaX4N7c6e3tbWLOApLs6mo0PdSZBEfzHr4AKMnQtDVbONEwJvBFGDe7DQuim7auvZmZLLX3jjokZjMl83DjCF/maI166601R1pZJbWVJzE3JEa1FfhCFrOj+9Fh9FjbBwKg73x4axsRxCxCqj0i1rZvLWoevHmw1gnokRDRIK0GsjyOHoYIDqAU7t5DB6KV5grQVdpNxMQR4AEaEYgWSN1czROhMAIBrK8PAKhqN32QxyNCBCMwIRj0ruDN1RjJu7W5R/foEB6IqO4avWo3BBR24nUrQ2AQBUA4cMqPP/7o8YcfbPZXIqN3SsEjJdWWE1KOU7+n5H2G8/GYs1Q0t6VIJDGI2hXc1KyaqkVDwlwSIeWBtWEZSzgNRc6HY6/tYn9xOp3xdPJliVwxJwxgt4hAVTsdWDWBY9cOpfcOFplFiMOcQBCQgSEcLcjQvZovFvPKA5oxIBMirtgrqGnYKkler7S1xEP8w891RR1I8qaUQqsqlyHAFcAJfRXDuDsBMQU6IpQhr9xytwYAQKGuCMBChhmgqzkCiHl/kB5bAKCZQjgiM7EABgATmfZe+1KP0Ku1udcGAMwUir7yksBmVlWb9niAKgiR3CPcWqgHUAC03iPSMALRvJygifVaMh1u7sZ9Eqbbu7eUQexBedu1D2NyzUQU4W4a4CnxSt0x0zBswpTYmctmc2HaEhMGAeBmmoZ3tz7PFKYEAR6utXZTBet6OuMqnjIEBOsG5qveCREJMCAgPFwtQrUlEMQgWitQJmJTXE0BTL4yvLpKmInWGxMetKZhtqJCSMQAXPK02WzMFRA0+vl8AnJby3lwj0CI1hsEsLCwrHDB+vtgoNoCQoSB1gQDI0TB7ODu6ktriXKWkiJBEDqj44qJ17iPaOStt6WfTtaMgiJgsW6BQBLhDECr7DsMzQamoLBwyqI91KCUIU+7nPO4G7qebs/fFBpvjt/klHY7++K3v/34k/f3+4vlPOtGNaykkko+He/z9hGEGpJganVOaQiriGzuA44pFwp27rm0zufD6a1MNJR8qPd90PGSn4wjCWPgzbvbt/f3Ote5xaE6UCYvXWMyH8terfcwQEIJJGx9RndiZgSkTlhK2iTMESQpS8RiCki0Om6ATBJUJGcmFHGnruH4HaHOnBApUMPQkE61IQIRtKa9msiqQgQRcTdV72mUVXZlq8ESI8JWSR4OgdAcBDr0ThEUJOG4+kaSpCQFgwJt9d4GPiQdrDbaImNCPPW2nO97a6r94Z3zQBSLMLDV57mSfADAiUsZANUsLi73T997VnI+H48ZiodXXVqdg3prlThMm3nzUAFHAn6QDkZ4Q1ixdVTtEb60So0AQpMmYkIL7F2PqnNKpEHRAkOSTLTRMhgjmZsqRkiZl7vDYrF0QLXW57aYRygzlSREuGI34fZQGwAgwC6NTGLm2ru2xZysBxJAIDEypbGII9SlzfMiQnnIOdFqgVU1ICLkUgSb1bqw8lpd/kHBJEkIERFac3eXcEKS1aXtEWbwXe1JEOt3ekgVcQcASTKEVsdAErPQtvB6KrvHqjl1CAQiScIB2JdF5FTNarPe1RxozVAIRwRiRoSIcABilJxIZNikadx9/3s/+PAH3+cnTwgiMZJ5a00kMCxJ7HYDsDk2JE3U2QM0DACjI64QCap6bZWYz3XmTAhRmDUMKMzaUm9rOwd4ymksm5QGz2MNOB9P52VGgHHcbLcXavH1N99qf9MsHCgFUO1a56YGm2GzGUUEBQDS6j8GjCwCQa4IIgyEwEgc9KCMUlPAQAimHEFMCQjMw7uulkkgglXKFGHmqusZ63+g2Vf/0tryASCSIMAKmBKAu5krIK2gEkIgQfgqzgpmzjlLKEWspm4JdzXn1a3qD+1OQARiAKoHEaVcyjidT+d1fX09zAEQQYhW7joiRCjllFPOOe92+/eef/ijH/7R848+mrcDKBTOoEDd8sUY5h48TGigKSEyZ1ILsza7o0AQi3YDYHe3cAhyXMMWtPUF7MzYTKvqoc7Hc7X9xfU47SBCkXhQ7pggcTgjCFFXEyBbFlXlVAYClNVd5OTqvXn4wIMgArKGEfFYxiFtBcfMpQf06hbQ1l6KOHHJJeWce3MPt7DzctC5lSGRYECUMiCl3lcRIHBK7uYesdYWyLHCAqpmDsApMWOselaKgAhHAPBVku8ABh6wtm6BBAQovQdhoodK1kUCVuH2g0c+YjVTIToFB6EkIEYSEkF1MP3DSjtiIDogEknJZSjb7fbRo8ePHj15dP1kczEhh0QgAXgLcyGFHGFAzNvdxf3pPg3MjmSVENawFUACchAmZiCSUnJKyDxttlpPAb31E8bsNrd+6lYxVm1pNjOzLPlimNJmMgZv51OdZwq83G2fXF/e3d+rWTfngDJmG1KEW++tt5WAQiIIIJYkOeHgHdsSqqAKTHK526dcShk2291muxvHsbuq27ycX7365vXbVx7NHYgYKeFqfyViRObUe7jDmlSzSoWZGZEibA0PEjAmwgcgM5hWwJeQ0AEgEAC6rSdluLtkKZIEkcy0e41AFvFwDAeGdR8Gydr/Y7gjVTVHJGEmcmb3lYoOc0SH/2B4KLK92H748YePHz0FwPNy8tvgzS4laVVdjZ2+E2KlUjIvKIndUVvPKeWUIsggajcRZhHk5ICljJx1mjYVovf77gq2uC9LO7rjZne13++Zd+HWU1/suOgigUXIgc09Cz9/9kxEXrx4cXNzY11LLiKytFq7InPKpZsD0EPqApeUN0QDeGYYhmkYN9vrqycpjwjCklgSSSKkxCiFWejR48f7F1++ePHV4XRwwLXM7WYeICIspI6h4AiB4ABmLimzCJmZOay9H6xeKiCktUpZD19YXU4RYRZmyJyYpTcNj5QSxJo6ZL7Mq/BemB6QHMluUbU1bdoVmdczlpPoGgIUQCzmbk2FoXUjhu12SokBnDlYklvM8yH6QogCnEhEkpCYKwQdDrdEZBZN+3aYIpCIgchViSiVfLG/AkrmlsrYumYIRO/356o6Hw/LfD/mNGymadqWYWoPzU1aFmiOw7jVdpqXhkS5DNdXl621b1+92l9ePn02nO7b+XzuunR1AJaUADmQhnG6fvr08ZMnm2l7+dFPU5lSypIyoQQiQmLJRMkM1bCkrKE9VISHYfvRx9+rrR2W2UzZIZcBSWttLKkMxSNYZJVJAqKk1FXVjGglK820ZklCFBECKCK1VW+OiXIahKJpX2/ElSoRRFhpjhXDLaW03iMwgNZrOTCCUrfWWkdVjOBcgEjN4oHDot7N3ZklpcTkpQgTuOluu82Jz6fjMEzjOEXQUhcHBJEkyMSEmkqpvZdhcpSqVoYLoQgPQERmKTwxm8fF/noct3NrATCoI8bxeCQpxGPguL8ctdfz4pzj7ni+vW+MJU9ToFzsr8dEkViEBoqcea7LuNv95E/++DzPd/fHnK2+/Da4ba/2V9ePpt3Fdn81braXV48urx+VcQzHBS+AHnJyPDAcSFKgOKYIDiD15AAA2sx89Z6lMk1bs25uqtbVAskBVBUJIcBWfbYkdyekiFB1ImIpIonWkAkAAgAwyVDbol0NlqDQ8EQiZaDV8Lff71rvrdau3T0CMQ/Dmg+xZjm5GaQCHr4aFtV6beZu4aqdUSQlRFL1klISBrBpKizRl+X+9t3TR9eGzYTbAofDwa1DwDRN2yybcSucl+ZELFxABsDIw5QEAaKrRUTKgyQhonFzWUoxkNYagJ7Op1l9mC4umC8vHwn53/zNv9fW9lebkDxshVA48T5dhXXv87jdPX68j77M50PmiXLqqlgKpGEcedo/JknXj588evJs3F6UaRMoBuSBqtZUKcYAcgpCIiZCDqDAFCGB7M5u5BYOZtakgxSMYCJRczOLcPMHQ7KFrRhp710kMUtrjSmpmpoLYpYc2n3FT3NOhCsjEsRVq8NqPAOJGHJKOauqECqCBhhAECOQEAkAelAYdHMzD/RA4pzRrC3zvCxrwlNXNVjxQw4DN2/uJFGGfHV14aHjMLRaD4f7cZymcXs43J0PtxGxmSYOKymlrRDidrtVY6RyeX3pTpv9VlI6n8/LMqeUiOjqai/M81Jb09b0fD7fz8fpYr/bbELbVNKvfvH39wf69NMfXj5+r6k+fbytvb56/Y5hGEq6uBjHTPP927v7wzCkYUiIeJrnSHnYX0/ydBwnKSWCnBi4KLI6LBqqbiiIGWhcOV6kFZwU84jVUAsJUMzAgRzg4SBj8gAz8JX9RQTw1tXCRZC+w+RiveyAmSUCCQ2CwlGDmMhIHNiRAAkApUQkad5aq7raoFfJL5Ecj4c1kC1nIUlISd0jVrnzQzpHU7cIIuFSdEmBqF3VbHWVmimwIJE39bAUqLUVScM4aevz6ZRzTsTWWz2fbt68IJL5mK1VbX1/+QRoGncMvN1Nm6ur54SJLzbjZrNd5tPpyAim/fL6ca+1Lqo92tL70rrao6eXOZUxFVS/v49PP/0Hf/qnP1avL15/1az3aCgBBvN8EhxM7XyeDdGJFvXNbrudNnSe3eDR9gMuqXU7nJdWLUirNU4jyuAJAyiQE2YkeBDuolsAUgJigEQ0IEhrQGCCQISUgHm98lhyBsWIUGu9d3YilqbrxjNQXcXOAUjEKRd3V3PgLDkR4qLWe0tCQBjEHu5AAQScKCzCH3zaOa8eZjL1rr1b93iIoAhkAIYVWQD3Hq5txe7OdQnVnBP4iua1KY1Cea4niDjc3r0b80efvL+ddqfTaZnPrdaIWM6nktM0TUMehpIIgZmI+Xw6D5vNcm7fvni92e6vrx8Nm30uU8ojYbSlEpUkkfNwOp3b0rTb4ydPn7//wXKsu+nixZffqMn3v/fxMF4ezzdlGO9Pd0F1GEs/IiXJpSzzXes95Uwp7XbbMo3H49kQyjidu4KaAyGm4OiOQcmQ3cIcgSiVZBYMlFJiWWUaYI7hBJgSl8Ac6NoWBGTOxA7RW+tmxlkAejzc8pxzksS+Kpow4cM+A49AIkmkuio5eKBEhNoVEAbJLNAdITyMOGWRIZ/PaxAbAMixDms0FhJ28A62tIWSZwZi8HANJXOwjq1y7ykiI05J5gWs6SBljQBz7pgjEXmYMd0cjunt/XsfvO+Jl+43Ny2lYbd5b9ycyzhN26v91ZNhuhoevZ+mqwFK66x5++svv3nz9otnv/vVn/3DP//e939A0yYNY7TuRFaXttjRb4/O+6unjz75fh2KZL893f/+9de8xekyVb2/vXsjlPopps3l7bvXF/vBun39zaupDMAiedxs95zEQHhMhSczw7gTzuC5K/YFLQQ4twrOkMYMgktbkj1K4xaiuLGUQUiAqNfWegsnEU4Fjl4daF7utlNSm7vPlHtAI1S1zgDTOJU8CgIztujVGxAJs615jhiH06lqyzkJRq/VmT0sEBVpqZpLXsU4AqFdJU8IYBHhIcO4WWptrSFRIK4WuAjorgSxwn29NWsVtZP1cF9tbBHh6k5GQIjYm05D3l3vb97dLdXKiPeH4/m3v5M0sIyAnErK0243bXOZ8rgt26vt5ZPnH//g8dOPmouU7ctX7/6f//1f/f0vflXy+Ve/+91nP/rRf/yf/NNn729kHFNOJPn08tu703L95MkHz57Tdl8hJPSuVvW2vZi6tV7bUMrpdBROu81+txkPpzcv37zEgE6UUi5l5JSIE5BgGDF4hEUFRwxhyakIagEZwhGTpHFIOQVFP+04bZDQg8IzoFAwIyYmXq3KtXnYuZ5ECCHevHld+yJJzDoKcgiLiAwB4eaIsloZEZAIAWUFL3MWQGemaD2IOHEE9N4Opto1LWLuZrbGPFNa8TkHCjGP1nrrvQxDziUAyJObW3h4kEhKyc3XtCJwBAQmHsYRzbU2ClqV5iVzbbM0+vDD9w6n4+F4OJ1BNKUE0yYN41DGcZymy+tdyoMDA+Uy7h49eTJdXRXM2uGXv/nV7z7/rWTpQJ9/8+Kv/+7vv725/xf/s//8s8++5wCQpWw3j549e//p48uLizMEuHp3JthfXIwc45DevHoHpqr26SffQ6Lzcv/t5zet+wfP37fehQWQIFBSCYLo3dxZZMi7ZbbWLYgoF+KCNLJkTIlzkpJTFpMtU16DlnIaEDE8mIiAhTiCYNXa67zZbs7nu5cvvtFokkLNVB2RidLaWycKWeN4EYPAVuzNTSQJsMMqETViAAu0sNa7u6wZiWoeLkg5ZdNusQbKruHbOTsiEnezbopE5t5VI0ICiFgk0eDQ0FwBgJhWa39ECCGllPOIoB6LiGy2m3EzsGD3KMMkabi4vLy8fHR19eTy8mrcjCmPS+09RIMpDTBNjOmLX/7uN7/77bTbDNPmb372xek0q/n/8b/5P81B/5tn/+vr660FPnr+3pOnT9G7EZBrdO3LIojXl3tv5/l8Pp/PhLGZpu3Fxe9+9/tvX784npbnz97f7C5ub94BUmuasomqI7TW1VSEGkAIpzSJXKgO3nipkDAnmUgSIEdIHqZ1FcGp5AIR2jpA1wdlTTATmW4nFok3X79Y5pPkqEsPQrVAQqJVgWiQ/4OH7EEiAxDmTMEiQG6qPcC6KjYAoABC2oyjuzdoZgbmlIBJVqoKAGTRGkyJ8yoPYUqwQuOrluu7UAYAWHtHU3Nf89UVbRU5gAjmzBfTvvf2zddf/fgnf7R/dPW7332hbuEGSKkMeZzSMFDepXHjrBbklKvj6NHa8u3rV/fnw9yXv/p//evff/PV6XT6n/7lf/qLf/Pv/tW/+bc/+Qd/9i/+xf8EGFMuCDAfDwTuplqX5Xxo9cyEc6v3t+82m+2j66syDG/fHW7vTxdXjz7+wSf73f725kZKLakwc+tm5yUgmpkDqAZmnHa7cbpWm97d2zKry9BBMERwZEoAFCiBjAgsCEDWGwWgh/fu3i16azVoHoa4v3t1uL1hxgevdhmI3RzNKRCQI0gdg4mQEHzNngoCQmAwQEMGIfbeG6itEcdrFRsWhUUBVdW7UqY/SOLEASlxRKxa9JJL176ahL/7N6Du4Q7fBWAzC/OqpVpzutdMA9fedhcXyPjll18+++C9n/zxT799/daDhnEkyep+WjpkzphoKAgUyFXdg5ARRe6Px1dv33z18pvXN3cI+G///V8vTV/d3P7Vv/l3P/nTP/no/b1atHNFhLn2drwn66q91ZoYh2Hy3cVuu62tCaX709uPvv/ZJ9//JCW4f3fbqodzm+dhHO/v77pZgAcjsQCCY/QIUA2A6eJye3XRWjqfVxWHSJSw4KEkTuiBgezYWnPVsMbgwes7vYj0pqeXL750b8JQ1Ta7LRAj4bJ0VQMQTgysQQAEBGRgoC7EkCSJgMWaoeMU4M4iEOBqqn12R8RhGISlBgjxqlcEDFyDzYgexhgg0tJa7/qHhAlcE4/d17AmREiSmMm/S70j5tVyFeG91/vj7TgOz58/AwAP+/R7n773wQcffPwxp3Rze3talmNtp24GhJLKtG3uXTvnTElO82lezswEDn/yp3/2P/9f/BfMKYJ+/Zvfff7FF+tXlpzUfa611VbrAhF5KMwiKW0uLqkMhnxzf5quHn30/R/vHz8HLtWoKpAMm4vr1h1QENkdmVJOAwDPTY/ndlo6SNrur/aPn1DOediUcZfTJFKECz1wsuhm2mpidq2n453qzBweldhJ7HB4d5zvA2yaxu12S8hu0FuPgJRyEk7CKQtAmJmH/UFhWnLJnJmFSdb8gzVBBXC1Lq+4AayiumEYEDGnLJIImZAl5SEA1Iwl5ZxabdVqziXiIQSCHrRxa4IIMrMC5pwsZ21tzd6SJKsDqC327vYmj0VKefvuXQ/iNL56+9adgdLhOF88zSRi4TmlzcUu57xK6/YXF9vtTnufpjGX6ebtu2++eTlMmydPnkTEty+/7f6nbjAkbgAANo6D1XAzcA8CyeM4bUmEh11T31zsedyps2OyYJSBg3OSXm2zyWrd64KI7qDmQWyBAOyBi1pdGkoet8U7RjdGGobSwcJUu9XjuZ6OoL23ZZiYM87toNjKlu9Px3f37/oa0oXCktZYB3dgAkBxA/NFezNzBiIQQkLmVShkCB4BRGus8h/yliEh0BrHHevVtvovlmVR05UUEkPovbdeycghCFFSyrms2mIIEBbAAk5qagCqWmtdlqXWGuYJGBFNLThEyCPm+XR7ezPt90uz+9Py8ac/VIsvvvxSHT/48JP98VDGIQAGnEpJRFTrgpQ+/uTjf/If/UevXr1GoNNM2vVXP//7P/7JT//0p39srmAmAOaGQb3ObT5LEkqlIHUi7Y0YgjlYyla2w7jZX0keI/T87u39cQ5KlBiJ8zidTye1cEfw1R1FwonTiJwsCC0IA5mFkoe32tZCfTONx8P9u9dvTre3ArApecgoKZZ+anGSgd4dbr598+I4Hw0iIGpTSYmZITDLAwnsqogdH5xyuBqsASivuSZrqDMSCyc0M1sPPIJAw9XUgczA6AjApNXMfDUOSFMl5pyH1UI9lIGIa+0QwZSyJFUlYkRXemA/WmsrMJGIi2TzqFXVbCg45BGTuPvpeOyBc5/vf/7zT773w6fvPb8/LFX74XTz6MllShnA1Zq2Oe12klMq+Z/8o3/89s2Nd99unz199mwYx/c//PDy+voXv/z5lEsm6IRoNh/u+nxWmgQF14QCByCklIdhk4YxOIWMirnX9ubt4ebuNOW8GYbtNHkZ3aJWROQ1/FQiGYVQJkwQiIiSOKdtKLSu7v18ON2+apCYkTLQ5voqEzI6st0db2ocZUOHdvf1zZen5UgiTORqBsgPyfIoa4aiKWpjcWGxeEgetu9UMRquXd2A10RuZogA8DX0D+C7EG0if9C1xkoSRIQIi0YkQE65m7XaiDrFmiYRQykg2Ls1qwTq6mvVU0rxzWZ2r+cZDYi4DCUnmUbYXOzzOLDIbKZLE8Fzrd++ev2TP/7zH/zwyeu3b2/fvX455Ovrx+M4mXZEj3BQq/Ppvefv/Wf//F8+vnz0tz/7bW19bsvx9lYQbJkvt9tQEIj5eN+XZVPSWEZznOezKkgeNtMURJyHsrkwFAdy5nOz43kmKWWcLnbby92Ft4qId/fvluV4nudWKyGmkrU7ePe+FGzIJqzaPdwyIyaq3ZlT5jTkVFjAequn5XxCts1muG23X774vGEr28FMyaJBB7MVqhYkdEDvgIYSQRFrKiUJsRiD+YPpWt3Nw4IwHCF6uPmDtDwgaFU7rAEZ7khEzqa2apxls9nM8+zqksTVWmullMwZAhAfMt5Cw8EfypmUPBcvpc9z/y4uiYiTrBUfCPNmuxmQ+u2dLfrBk2fDdGmupeTPfviDN2++fP3mhWodxvH29g0iEZb8ZIQgTPTBBx88e/r8H/3F3a9+9du//tn/+OLbl19//fXjR4+uLvdWXQrf393aslzsH3VkpyjDsN1uRYiQ1jKwKuRJSPC4wN39WdX3l1e7YZg2m5Tz4XRcYwXXMTHuQUkQxQJaba2eDDecm/uJnF0VvE9jfnSxlWHqS2vnc53PuI4Osb65HI9++Pb1i7v5VsaUWNzJvBsErsngHoZGrq49euMHnWes6ZT0nfdu5fGBKAAcSQHQtZv+/xsECGLNLocIZmJmYYRAVdfehVHAESJKKWWbtFWESIKuiqFCKBJAhThbY5PAQomd2Uom221QIxG7BkrNU9CAkLmhVCUarqYhB2/G3dNcLrvKJBdP3v8Lyq9Ox+Px4Juht/NLMMzCaZj4DBE4bIcPL8anz3/82Ufbv/ubn//i737x5Ory6TgSxTwfFl1wos5qS2MaEROiyLg9nE7V4mK3K0NeZXjzzbeH199Medzv9mNJInJe6mlZmtnSzBSSZGZJTIl81qbuJWWG3pYjjwyYAC1lIQ/KZHOt5zm8BtXFjsrz5qoc29uvXn15e/fGe5+tGU8c7D3Yg8EYjZMQQut1XqqaSxIhYXSRRMwRYL2ZuSQSwDCPsITICL2v9CTjA7loAUbBGOhua/Y1Y0qW1SwQ5XB3eAjvVgew1aIe1t2UCSDYXUWQk0B0V0IU0SRZCk8g0s5LQaJEMGDeE/FYNrs0XRbeSsd5iXFzmcsFxGhKp6PRtM+DtPoWYhAahpwSoWtdzl29cyrtVDd7Rb/Pcfe0+HwxbAtfbgew+vb1SxC4uLia67yhDTpHYuR8OPcaNF5ele3Qe6uncxHcJnt0uRllur6+TMytnu/qbIROjMzgCEbgYaE5RxEWylAKDYUS97Ygo7sF8nk+nw63cAbkqO2+6vHiMl8/neZ+fP36y7d333ara/NJDcEhAQuEMDIGeDcID3ciRXLKBpS6IidCCXBEZ7LEAgCKgQQJHWx1fiMxIZJZi/BuHRQjfCUDW3cmYZYyDJKSJEQkQgLXtuaKrDUuCSCiBXYDSWzmvaq2jrpor7Uu0WboSu40jNtxiqQNeyBbIDsC02azffz0itNoxu5R1djclxOFPX7yeMzkEZwSkiTJCmgWkmmZl3a60ePpeLg3XSLqMt+8ffHbPO/O59P2crcbdg1YT8osnJOSIeHVdpuG5BGcKKWBwbe8v9hdiowRPt/dns5zt2DJNMIudlZzrYu2ygwQlvOoVDoW4lTK5nLc9epv7169vb07392Rx/XuYpPHwDoMeHW9dW+//dUvvnn94thmJyJiZCIMQiBEBoJwc++9eTinNAwFLcwxwnU145ghoEUgkq9ZkMQsyQFaa8w5Yp3UEADoiGFgraNEzpkQXL1DXzN1RUR2U3nAWIeBZY3jde0WjsAUxDIk5tA+QwSLYLAR7Pe75WBvb9/5stS5HG7fTdcXl+89KtMuT5fAU4PcDJb7U5l4t73cby/GYUTOhhnD3928OXJcfP+T/eWVuQHLkMtpqe6xzMt8+3q5u337xdd3L1+d797t5Prbr351Gc8xlWiDnTuZAPl4Mcxd75fl0bPnqaQKYeEUnhA9IOeEzr26a63mxtTDq/aM6EiKoOGYOOchwpfutVkIgARx3++yzsf5eH8+3KLr1eX++mo0ayNBoH3xxS9+/8UvX717beSUcxoGSqwQjMEU+CAD7qoVwjklJAbkVe0WQQHkDuvYpFXwHV3XYWEiOSIATRB9naS0jmQgzjz23tCCAjLnYAddBwkRAIj1BQM3wzBMY1e7PxxKHpHWmSECiCKCNrs6AuaUPLoRWuiynM36tBkvd9tNKSb5uFiLCu0YbMGbNFwM290alAOSe6C1tt1ue/fXr19vN8O03e4vr+4Ph/NSd3k081bb6XRsd4evf/v7m6+/fn6xff+HH6TNUHKb798cFRPmvHncqpchH5fZEK+uH0mWDms0IlePWhsTVIXCMA7FlEaSPAwppeO91PnY3ZqaYTAiJjHlqktTSjmxZAw83R9CVRiEHNAEtcddRK16+OLzX//y13/b+pzHlKaBAkLJCLoFhjMnCEcMZkSUlRoGZrM1sB2BAFZZ6INHPCKiqzMLroMsCVMKwXVyRtDDNhVhYiB3o0ACFM7qD+GmACAcQEyM0GuttfWmOUEgSs6S0zK3XrWAWzfwIKZu2mqrx2PTPm2GzHSaj3U+jpdPxv2TMm4gjYpZYUAparG0WvUeOD+6fjyUfPPujXXd7bcfffjhxcUVSkrD8PU3Lz+gMm4247hZaofg6+2+PJqvBsFo9XRzbgfa7jtNtsw6q559bksT3OyvhnEKhFOD2/vD119//bO/+7sXX319td9eXewHkQ+ePvvsBz+42u9IUt7udoJ0C60vSJA6W29NNbDkcccuQMUNA2M+nyi8L+fj4V09HrwfP9xtzOvXX//m17/669PhZhyy17n5rMjGabq4lDIyMlh4WKxezzWNNpDWGVj0EPBmAGuQ5UOgZgSYpZzd10IlpULc6xpRuy52ILWmzJyTBERbVMnxoYdAAJDdduMOh9OxqxHLOIwASGuiSLCkvHRFIIgggDBvSz0fT/PxNEi6uNiRWZ2XISVKeZ67FN5t95wvFKS6dKdhHMzx9u7Qmk7TZL3Xpb7//vtPnj7llPePn0613h7Op9NchpFYtpvt5vrZFPjVu5u7t2/qfDfsSk+8Habdfuzn+cXnX0ZPdL179PEHeRxM4cW3dz/79e//u//h/zNOm8Ph8OLLb//9zd+dj8cXX33+o88+/su//Kf/2b/4Tz/96MNQ80AUQWJicVunEiFQQkC18NaW5qEHV/O+3Lx+eT7eJooyckr95t3X33z198fbl4xajwdkTMPoLFSmhHYxJavmrXtEV1u92oAsOTGJMDgggJKTPaS340N8ympZpFXJqBEhTIIrJuC0dpbgtc15EEY2NUQEQ86MhA+cxooVuUNKee2c6jxLLkI0DNPlOC61TjDf6DzPej6fWtdhnC425fpiW5iW0zlUd+MGyuZepQzTbns57h4FDyED54koLc3O59ndkbC3SozPnj17+vw5pnR3nBnx408+e/XtN3d396UMbhbdbdF2rIXLsL1Ege1uh5ihx9zPoCE4The7durC5eWLV//6b37+t7/8dV30vWdPf/erb372t7/59d//nLs3qIHWLd6+efsv//k/++mPfrDfbKzVlIv1qr1HQE5JneZ5vr0/QiSmvJzn7TgdD7fufX+1vbraPrq69Pjq5Ve/ffv6y3p+Z8t5GNLFxYWgYk4yCIPqctAKDOu8OUfMyGQOGo4esDpBmSWRB9p3+c2IuJodv4tSQTMjWq1iEBixjrAA2OwuhmGEAHdf0fBu8x9+V05LG4FYShlH9yCPkkfJKecyDDklNuU+zxFWSipycX0xDYJ9Prb59ObN3e2bt/PpnIhl2sG4u9g/xrSpJmWDlGipXsZNkZIuLlQtVHmjtdd5OUlOZdi8eXtjau+/996jx89aXZa51qVtuQhmxqKLlTxg8LZcw7hRKnMzbbN5H9rll7/9zbTb/+v/79/enObDzd2zDz8eeHj94vVXn3/9n//L/+Vf/9t/9/nnv7y/Pz958vyrr17+1V/9281QfvrDzxBJODEyE4Wi9l7tFGGMEWFZYNjvCGK3Gy8vh+ur7cXFKIyvvvj5m2+/Prx9k9FIcKCY0MNaNOKUYon7w23iUaYdgiRGFHJOEYyrwACR4WGQT6gSOMZqykAhSCUNJRFRFnIPZoyqrbeHPPeu0zTmPJRSmHmV4YeHLe0hkwZA8rBzRMfOUrKQcCqlqGpttZ6PYAXMUuKcqNUw1R66HOd3r18f390c7u+X07nPPZHw0CAfzucOlB9TmbbXm+2mOwPSmhl+Os/nw/3tu7fDNLXe3757t9nYdn95Ps6v3tw8e/z4YhjOh8PV1SX3/osXb5dTXI5XA2OeRrfsNWtGVe2thflFP738/IvqIYGffPDkeD78/lc/B+sDRyxnsr4ZMkQ/HM6pjLvLq/m8/P3PfzlJ2o2sSwWPLKWwBHg3HQpD5DprWCMOEd4/vd5dTJttbu309t2bF199cffmDZtNhUNjRLDjvRFiGVtbPBUXkQHdMiMQCq5JkFI4ZQ9a3S6rKztMiXFNykQEBJTEjACwDje0sFW05kkYIrQricg655MFAlrTrnY+nSN0Rcwlj1uAyCNeXOy0t/BYliUi1oHfob0vy9u3X797+9JdS+Kri62UAYDVKPEom7FTJ+THz55MVxsHTpJMdZnPedjkcUNJiJJlS0KbQRitWVxdX0+b7c3d3dLj+fP3Wl1u7+6vdpvLR9do9u7tu1/94jcTyidPPxkkY+YZzB1Dvfdlng+9t+1xIruzpj/60U8vn3/wyfc/+O/+1b85no/bEZ5eb/5v/9f/MwZOlxdPnr3PIDkNP/7RDz9678l8OmMn9g5qBMDEpk6oTJg35QzUmjHH4yfXu/0G2M/19O7+5uWrl199/oXXts1loHBAMcewMmTHONWzah/3FxTNdUEiJ+R1Esca/7yyswCq6qbMuLK2AE5IRBSural7rKZUwABw4HWiSjh5d0sydXMCj4i5tt672TqfJNxdtheXvXdESGVs3cK7fjfFpetyqvPNzbv59DoxXl1eI0TOAl23my0akFGiolW309apf/P6y/PSIb2m/BXmX07766fvfXD16On+8ipJRlwpfXp3d/v61av9o2ci+bws81Kv95f3794tS7vY7+tSAwmQzqd+POrzTz+NxGzLmXvXY+u96QLRrd8NqW52m+dPxqun2x9cP0Wy//5/+NeJ2vPnF97fG1I+9vjkk+8R8uXl1U9++ifXu+nFF7899zoIQLeMDoKuBqHgMIzDNEyumMo4jhMSHefTYb6/ub/96tWL491pzCMh5eh5nKAvqp2MQEkAzMHr7CAoCSU5cJgbGKAxreOMhQnDTF3RnZDWaILVpdpaM9XV/i8sRNhAh3EEJncl4aU1oLnWtnLI87yY+ZQYMVTVIyRtdlEXbXVpzb0TKHlzbcv5tCwnU7W2DEnGIWfJvTdA3lzsVsHx3c3d62+/efPqLQFePd7LhreX+0fP3798/H7eXHLZbvdXV9dPJefampmbdg0OlM+/+KpsH33w0SfTMN0djymXzdUlWL87H3Pmy2fvf/TR97782W/ffXMDz3G7uWLo7Idznd0wSFAomBxif7EdxzJsiun5L/7iT0vJ6OZat2PZDKVDevLRxz/94ff+k//4H//ks08O714X1OPtGxpkWJtBDySYMrnBWu4ZIoXP7czu2o7ejsv967df/x7m+xIa1sy6gmlt2hU9IAfkJJm8VndiYEDBRIgVAc3DNUiSDBNxBuTwHu27KIY1F8+gtdZqM7ecs7A8jI4keZD/r4Ph1ogWUGJZrVARThBEwAHyrvfNODLHcrrDfqyndxmNbInlrt7fBvg0jRfDc6aREqV9MfTb0+lurkfVt/V4u9x0PgvEjHK1f//qyXsXj57JdGEyeio6bE6Y5mM39VJGKZvrZ4mHY/c416gtgIGH6XZZfEzDfpytmbX3QIbhYl92O+X7n/02vbeMz64k88EK+lg5aEpHHGlTPF9G3tXFeEjQ2g8/+37J5fmzZ198/sUy12Ecvve9j//kJz/6+P0nw7hsep2H07v73x8OJE8eO6TaVRJjPQzT47LZKGx7jxotp2b9bjm+uP/6y/vf/i6/+prwWBKWadCF5uNRxs2w2bWuusarORFBO59t6dGalAVLl2FrXFoskUYngiRIIpKjU61tjTpX894VQBwMkIEGhwSBedzUbsKELqEmzAwoiFV7EFBCM3erzDjkBCAySHg7ne9uluOteGXTc5t7Pc3n2ZyHYSplGjb73sMJgUW1iaT9/rIvs3elwP3FxXYou+tH26tHQy7adGn3DRaj4/Fsj5/idn+1u94Pwxhud2+6gbfW3r55I1Iurx9vtjvOwnzW1pAgZ7FeD8fTqdXraXsiX968jPntsqFDtkj0aP94/+RyW+j+7o6EzNUh6jyT+u5i/4PPPv3gg/dPh/O8VGLe73clS6IAcUfGlDiXu9t3nWK32yOTdYXQDMgppTRS83nptzdvX371i9uXn5/efDvf3jHi5fU1g2dJMFpmNrXee2hfcwsxYGkNgMDhcLjHqmkEsohkmDZSIDGim7l5r6DWugZYzpk5I5KaTdMUQIgoLJwkhHV148OD+rDWGgHCbA+6jVAL/G7ktSy3L8O0zUerp9AW6G0+uzmnsUw5lwEIZ8ele2bJqYA7JSfXYRgeXV9NguQ25Xw+n97+7nSxv949fn71+IOnTz/Mm6vgYZx202Yvkls1s8aS1MwcuurxeMppFM7cNJqdmHLmi4udGRjS2ezl6X42G7bTUpfX9/e24Q9//MlH3/+Ik2wnvrzaV7VcCjFihHlvvZY0ppSuH18SgQcEQBi0eorTPJ/PTkw5Hdu53jcuKZfiqgaWmqbWR3aA0La8+OqLX/7sf6x33+4SDgl3uw0hqC4WHhiKULWnxEXGzDSMIwjPdTneHVqtTsQOLCmIGFlyIe9ez6baPcANH4ayICAhAhBBxDgMgay9M3FKefFuZkycWJAgiUSEIGi49dZaW2fqEBIaAoC0wyuKkLDwZVnOzQzcRIZhGDmP7tC7RS4wEpWEaSD3PrfWWkrp+nJ/05ably/fHO5Aynj9JHHeDtvNuM1chjSk6QJ5zGlIqYAQ8cYm2Z/Oh/t5HKecSl3a159/vZl2l5eXWaRaW277KOSSbRjenFot6b3rZ7vn10xdNunx80f7q6ssPGyYCrfaau8W7gHde9dWykAEYdGb177i936el9s3Lw+3r5bjbTVrpkub05gmHy2C8+ZU1Q8n89HdD3e39XxAq1PBx7uJeo9e53pW68KSgCinQdjdOGJV7zXtc61qDRESE1OQd4xWxIcMhmq6uCkRr0FtOWdY55e760MikRCiEQEREGXO8DBWmb2b9o5EsM7OBmDmcCSWkksqmZAk+3kdcqp10VaFeJg2SQbkYsYOkrJ43uShAPjSdc2pi/C+LK9evnz7zde6nLfDuL16vH387PGT9/bXT/K4gcBWFcQ5r6qRJCnlLM396snTw+mr81I3G9Bub769OY8NlS+2FxBgs/7d269e3tym/eWT7z959PTxow+f5+tduR6HUXpboC055dYroJt5M5OUXbWr1t7scAcOzCLEZjAvvbfz/e3r19++PLx7BbZouCEelzPcRuA+lTEoKVJXa731urx7+/L47s12YGaJPvd5Xk7ndDHmxAjYezeKVDJ9N03oXJdlWWpvZRjGlB2gNtPlmJjQRuizJEABWwN0IZuv4X7g4bFq3ZBjlY0S4zruIqcwJ0QG1Nq197S6xsPgO+5Q1buDAKOIsNZ6PnVVNRemzXa73V5FpKVF657ysNs/ujVz5Fpr9Pn6YhCm13fv7l+/vHv3DtzHMhARuIfau5ubU/W8OcvmKk9aakw7nDZXNAhRQmKWYX/9GL54MZ+qiOw2V9vxcjks9VRv5lsMZJR6Op7Unj9/74/+/B9ePnvskzQJH6hn4ESIUJf68u03izeHoFwePX3SzO7uD2lepmkjJIm5Oi7NDnO7v3u3zIemRqWQQ0DnkvudLm0J2OUinhIlQWbE0LYc726Od2/3IybimOdELkO+m2cgXNMuOaUyTcIcEbXWakpJrjbTJMIAS2vzfLs0ZeF24N563l3KAA/zqzEchzXvLRBzLpIyfCeTYklEHECre4JFBEmJesQqRm3aUBiJ1I2NVaN39+hy++ZtAHCScZjW8M0QNmVHoMycR4BUxtK8q3aGmOfj25ffvHvzys7nej6G9iQSDsfj8e39cbq4vnwcV+ViFFHtxzdvj2frRh9+mC6vNmraAz2QU3HsVfsF0e5i2m+v0Lgv/XQ4n8/L9tHTCgTT5p2qtTrsuKewcJjbCHaRMgdeP33vUI93x6MG3B/PBtjUulakVNgX89760tppqcsya6/ImEsJxwAtw0QiAOvsCpCUzSzIXXubj9aXwtHnI8a5IAR4awsSiqRhHFNKHmFm1RQgFByJkiQhrq2DqZoRRhYk0NClWW9mZecy7pxEHULSup2YuQxjKcU8amvMMkybiDidT8CRRACgtda1r2Nny1CEZW6VmEl4GAdXM28UWbSDpMRcOA+SC6YClJ3JKEyhNZ+pnbs2X8ZMyenbb3737Re/Od/eJFd0g/BW29Itj9MwjWOSxEjoQri73G0un1MaD3P/5sU3EXj19PGpLqfjcnX9BIJvD/fTuNsMEzICIibZXu7314/+f1T9yY9lWZKnicl0hnvfoKo2+JARWVlV2V0NkCsC3PSO/z9AgBuCRLFryKyMCHc3t0H1vXfvGWToxTWPbtrCANeNwu1OR0R+8n2/vP1rlNVzbQHJY7/N8q6QgE3cjgjT19d0Ltd3z5eXj9Ptsbf76+uXr7c59VS3nBIDhrn67LO7GREQYFdv2973HUjC8fXbrUpiym7f3j1/rJlttMfb1+3tS9tvOL5Nf4Rw4VSWAkgpZ4i43+8OUUrpo5uZCK/LMlq/vb2aQclCiClnNhdGYmdOmJkIhWlZVsX6mAwANedcFkT8nseJHIBzqocj0noqNnTOMXs3s4MfX0plNwVXs97HIpkZECJ8SilPda2y1LxUrkWDLCiQyAMdENAjsgBoaN/7/rq/fu6Pt7nfknBNHEiza3xn4Prj/vr59TH++19w+c8f//wf/+//6//jP/6nf/y5nLe951yRaFkuNuG0XoTk06dPX29fVfW8XAsvHsiUOdP6/qOc2mzt9bHX55eF0+PWWbFkTLlKhLf2dt+V5d3793U5hZRtGr6+bW+Pt29v4JE5lZQBRx83VZOc1mVlopxLe9y//v56v/VFJFHy7pvf1lxpou3j2+ffbt9+j75F3927ZKGEFGQ2daqFjzmDySNKzikl/J50MziQnciJgoQ9TOfQPrDYZb2mJAbReoMkKdUIQJKIOPKoJIlY4hhpwXeTxtEUOKKjlGiMcVQdx1aFAIArQriaq8l6/ricVxSBTJizzbm3HsERBETHJrtrz2T37bW9fVozpdBH26Jk7WoabhhBamr7SPWUc1rW8+X9D3mtv/7y148//ePP/+7988s7YrFA13h6LqPvp+uThd1vt9t2y7Uuy1kwoVFQlPWJ+0Jv96HRtiZF0srtsX/97VtG/eFyfvrwQfY53V5vTboD4+i+1It8qNv9Nluzrrfb1sfX+/2vt9tel+XHH//h/fv3l9MFzW7r11P5msCXtL5/fk8xR9/mrccwnz0xTjBiEBYgGmY2JhOrWTCezifO2dwOdWl/bPu2o/m761MsqyOBT+07Is4xiL8DxM3UyAIFPEKIEOece2vEIik/tkaEdnRciQQEhvt390mEuYOnnBDQ/OCOZGRKcyPwPkZru1A6kywz3C3YcFfXAERCJjqAoQxjvzFO8ZnQ3Sf4SByM0XWGMXOKI65Fhui1luu7l6cfP14//On6/qfHdvvll7/9+NM/vHv3EUhAKcL76ICQa6G25ZSdXWEmZhIJhMlEuVxfsu/t/vWt9379cIHsiUQIxpxfe6vrU6Z1b7sNK2s5X548kKgvZU2INvX2et/uIPht9GE2W98fj0ffm/ZxPV/H5eXt90/31+3DO6PkoaNvU7ehY0uM0+04cCBROFpgioMFzIlFJE3D3nuomVpCKrVclpOvpxYx9wfSEBEECEQn3LYNnOWcSzkZsw49/LsHTDUAI3xMPyQAEHAkalxVVUMVzCFgrYuBo8IRjIoIATMbr9++fPr8qyAVwOLe1AIDASiVRQ51sQYGJ5aiMvsmjCHybXssOeGyWB9hccDMhoIkqQtzXi/P148/fXz3Dz9e3v+Yzy/3Zre317KsxIk4T1jMJwLUWuoiT8/Xx/3hHo/9nouvi+Scc60xtIaMaW+vNyQcewsLxYlkA0N99vsDOU/V70OcJE9Pz3OOvjdUFxK4EPjXxw1qZuRckrj73ke73ea+LXWVl3fo9um3z1vuSz6Pbd4+v+rjzfrbnB19ArkzCyfJkBEzgSG42RwDhY9/ymVZlksWRO/z8di28H5/s74fUd599Ee7YRkFJJezbpsTYBKAKLWupZq7OdRaWx9EBoiOBHEoVT3cCSmVdCwFBAIxCQoxDVPt2+z759//9m//+i8yl5iw9dlqXdo+GRmUAoMQInDq2Ns+AHg5+76p3cnLvIPewyegIjAC0fmyxHKJdx8//PwPHz7+eLq8pHqeA2DbMtf98fbX/3Ifr68ff/4TJmEIxmV9ek9Cb29vlquajTFu25h+XyGWMGaOZOmlnM7vxrTf+yMZssRwHU1PawnG+/Z2vVz3bfv0y9enp+fr5UJSDIa5q/pjzN4b9xs+bkHlcv3xwqe9D/e+tweJ0Pk0fb9x2MyjbWST6+xt2+fNTQm4lIWWMmwYOdcc3/PkBmE0sZRyXs9zztfXm5sjgk2qkp6fPmD4tm33+w0cSkbkTHPA/RumHXMnyZVXBkUbidOhvTjX5dgfBUDTKWZd0YwU0TCzcID7bHM8wHsVSD7t118fnz7Zr7+8e/smfNi1RQDJ5nSPnMpxEj62qiLANNwNpx5U8WnWew8zJCpLredzLjU9vT/9+PP5+sySzSKAALEPRZ5jWuutj798u+0f/kSXy7mWAggekUv5cFojYqoeS4l7bzFGHGXZsrIkAUBiwLA5tG89TEfnNbc5wmfJJcLut1cwTcKCqGD7fu+tm+kw33rvrdf8e4QcW5d1WbZ+W5ZaSN7ubwBsU2EO732OcaDdVX1vMw6oH6NqiEhZapJEAQCgXefUMabDdyosoSQu5j57670D0flydcD7GL336ZBrMNewUDONyYECaEFuhjhVXURKTiwCDsAO5u4eNmMYE2AcOeh5e3v78uUTffq6ffu6329ZWOAPwynA9+YApGMUiABIxBDo5qaddB6Mh4Cgwzkpcjqfr+/e1dMpXT/W55enl5fr5V1eVuQKlIELSDk/VU5ZJFOqy/mUl0rC042QUi2S5HB4RcTj8bjdbtDG3kdXdUJi6aMRE4XZHK4qfLjt9LKUtjVkPtXy9vpqfS+lntcTuPoc2puOqY4O3Gb//O2VZV3WS14XLgyPQP4uKuE/CL1EzMgIpOZh7s5mIDnXWk/rSQ7+nvmcc45+5Eh1moiUUhAgUXXD7XHrY2hYQOzbo6sbMXFmIjqknwgWh7jRgNEDjpWvICAWlhRh294Uwg/YLQCGSwBCgM7t9nb/8tvrp1/h85v3LkSnWgWZdOiYlg99cZLj1xy86QA4yqPJGj6QyMzULCAcQoik5PVyen73Xi7vfTmpIzCX9eyRurpOHZtKjvO11LKmZaGcAAGTJCJHREQHiPAEnGq6pGteKo352LYxJ6fsiN/lBzbc5vf5OELbHpfTh+56//bl/fv3O0LfHqjzMTszJ0YOm+acl9OVSAZi7uoVDpOuXJ9f3u5fHntPudy+PhgtEzIKMgMicxLhda1HHEYkmxfQg1SJuZScF3BrrQF8l8MCeG/jftv2/VFLvl6vqvr12zezCYCUUIRyYhDSw1QE4EgOaEgBkFJNGYUwEHSqixz4MZ8jpnloyhxjv3365be//Eu7ffPRcc4l56VKAhAIwu9B8XSsCgMQwh/wMKIIyKkEjphiRB7h4VJyIkLi6f56vzfz8W3veKp1eXuMHyYs61NXvz8mcj5RRU51XXNdNzACovDex5hTkrx7987cFEyHIxLnlBACluQZSQJAmKb22UGb2hg62mN2jT5aSRR97Ojz48v1yxft+2Nst5qLJEnknhPi84V0vaBOZ0hOvPeh2kvhw3zFzJfTBUMTmYQIagbd7l9z4mVZRMQ9AJOkM5N898GGA1qEIiXTgRC9t6mTMaecA6JkSYlV9Xw+L6fTfW9dBwzKOdHxcByWRyIDVIcIkENz7eFuY8630Y69fWFgQnaK7d5un1//+pfHp99QR8aAiAzIDuZDtrYjEhAD0RjT2jidTof3BpEQncC3cdu3jaYik+R8ulza27c+R11WFBo+99urJrx8/PCnP//jhx9+znVVD0n5x58/5HJezk+lnoGozTnRzKZt99776XL+8eNLSmxBY2gfAw/FM2NeUsIcgOYgicxoJhioA3S2OUYrGe7fvizLQqFfP/3yw8cfquA2u47hs9daEgKWAnQxHwVZp5s5Mph617Fte8okkr58/vJUzr31XTeB4fOhc84xCcJzoFCStCzrur4TPm4N6+3R90EY5kCSAVxb84hwC0QW6WNs+wB3Dx9mEXpQht2GzRY+MTIxOYB6qAexWES4EWMWhMQZBCPQNaZa30HH11/+8vbpl7df/yY+Tzn5HBZus0/AnFg8ACJYEhKXInbcfOHgxAzEwkQ0SVKiMCfKJTdhSpxzSrXkWk4vL5TShHO9XALg/rgXi7o+saQxJuDA1oPSKqksBZm/fvniEcu6rMtKmFQ98NCyHJLCQI7DVjumAkAqXKJOdNAWyqicKQWM1y9f5P17DH/7dnt5ui61JIYgYPC3r1/Pp1NZl8fcc1kAkOiIGpnqsDnMdW5zjp5YHvdHWH/cv1l7ExgEvdSMAH0MwLSuGSixZBaBI1GPgpQCLC/nJBjhkjNAaLd23/b2IEcIGnMgYUkSAODBhDkJ1TwJAzRC3CzQkfMRdHq6rGzTxl5LOkkGM2sTKYb2r3/7y1/+2/9vvH6Lvp9KghGhEy1IQDjlIpJSVrUIMIuURFIquSJxROj03vsYExhzzhBqB8g254Y43cIsC62Xc15P25TW2+31tdb1dFqJ2cxSrkQojEspS8kktPUuQiJSSiKCOScePl0hlhQBxMgRbhHgksjMRtsR3HUePjdEdzdiAPDWNp2zj/319evz9enperm/3QIAPI+2B9haz7330ft3kIQDU5REmOvoYL0nZqnClItYf6gNm8Ml5SwSQWNO2PcABtqEj23XCARJGdBzImJ0HXggDt0O5QUQCedjbQkQcxZQV9O23QgF+BKhnsIwHJgT55wYYvQN5xQfFnN73Mh9tk232+Pzp9//8j/m2yvqyMwJ6dhfYwJCYUJEEGJBh3D/7t1FmmpEh5QRJWXidB+bjgFjuKlDsAgyIdP56fL08pKWCkKLrO/eva/LCgi3b18v1/enywuycMrX0+l8Xollb63tLaeUc5Gje4jkEMKcEjpAHM5qwPA/4vcO6koRTC4iLqRhvbdSmVnGVPCIgC9fXjEoJ/FAM82lbvP+eOzlvPp3OduYczJCFgqGYyZrwo6RUjJtqn3OjqDMMbURVZbMlCRnqRXwKBAALRAcwkXIA8NiDNv2oXO0fQOby7LkzDr6bbbWWwRKSUmYD6GeG8xGhBgFGIjggLtn4nb/lmzkwrP1NNts+/b189vvv95+/3T/8ju7JsT03SLl3Wwl4gS5pnoucjitU0oiCQBMnQhV3aybBQAwcpKEntruvbXHY3vcb+q2ruv5csklT/c1J+Hct/vb27elXl4+/ABhoWNZ1rSU07qURPu+399uHsg5gRsGZcGSxcwTYxIwg+kBHkYadNQLAwCXdRn7FuZEB8ufhdHcOSUMyEv1gLbtX75+Pa2rhfc+AFByHq3t+56Ya04zNHxo32+PMfYNwA8jYk756d3L6Dh7IkvMCwGHjgAQolyqpMXM1jMhUpj5d/KakyQidjdzMIOpsJ7OYeP+9jq+3kMVw3LOkgQQ1eIAu5N1skYhRE4MIRwEGF5yUnRhTxh7e9C+bZ9///bLL7evn3R7VHZ3Z6Bw7w4BSHnJGUopda11LQKITPxdomuu8N29Gt9BU0DMQ62PceyCpJxOp5NnZqZH2+9TI92e/cPTKQuvl8vz6XRdz2upJaXEhJkJQtv2uN8fbWtyfiIAMEMi9LAxiZmPSZ2Cq6lZZDtUnGZGRJLSfp/adtRpoyNEyblbP8bfxJxS2mFXMzXPKavqnEpMAKFjlrWmlAQ1JsaEPvd9e9M5MICJKPzz5085QU4MlU119FYShTsLns6ryDpnOBhTHLSF8AhnCzd1G7P1efD65hg2u3sQ0neU6t9l4GEQIEjmNtuDWDAvKAahERSux7Cy7/f+ut+//f7tL3/7+vXzeNzJZ4IoSdocTAREZgCcUi5LiVwJKaabHL35w1x3kPvamHzoGgHtYHx8RzmoRZBwLsUppk5mfnr/Lp/O6XS6rOdzekqlplxrKctaOZcAcNX9cZ8GfUwEyHJQDBwB5pg6385PV5uEhGbmqhCRRA5hTE7sAK11D3ePse19u0XfwC2SlFz2fXbQMcwCEsmclnJd6mnf9tHHY9u3/RGuS80cnpOQJ90pMcaEP8ZCZmjBiBAsnDgnVteRck45Hb4KIjIfiCSS4YhbuJu5mc8DGuOYUoEAEVyWaqPs91vfb2aKjMx8DJbNItgJc7genpKDf9x6G7vuX7/cfv/r4+un7e3L/Pp1tP1Sy+W0+Gg+R6iyZJRkCEGCqUoeTOgAbiY5r63tvU8RKaUuS+r9m3vUKkR8v91utxtmzunktPXe5utnHveMhuYx2wimQaJlH3usaQGYc+77vu33lBcp63p9iZHaBJK0nq5LFbMJEYx5tJ7rQkDfX1IwDKaHm17dk8EknhQzohN3kAfWltlHju2x82QOTaA4NYNO77Z3ldTQJGVFH8Q5xfb1b58f+OOP/7Be3w1Ad1lPvG/e2zcpURK4j8d+27bJMCkaYheCcJCaS1mQxdwDgD0hCnkmooBAMIhOhJQZA81VuAtMm/3xuG/37fBJM1cE3LdN1XKpJckEDMTCUHCG3ufcUGM8Htvt29fffrt//rU/bjFn9fO1vMsi3mZrYAZBBVPhxKeKpRYpso22R+TAhCxmzpzWNX/vMHksy0JE67qKiOrsoxu4gwIgARABYeho4MFMPqY1NdIGY8K2t6amBLSeTs/P71fE7Y7BdYbE7I60Xt67awAFhhkcTokwCHcLVZ+mE9qZmQQIAyMU0WZ08EaouUiSFdyjBwcGhI5GEIngQLrOgeY2po3pBf2y0Jdv2/Z4W9drThVDPMH58oIQvb+az5RQpttU5D/gFARTndoE7CmxJE4p17QyizAfjsIAdSYiiJCdbdvbHDuggdmhF5TEAhm+E6EJwgkIA/Hgf7nC7DG0t75v++317cuvv7x++cw2c6KUBHsqlF29tXFYjS7X9XxdWSjAgEB1K6cFGIUolSyHc4wP9QKAux0fxUPleezVWcQ0nxrAOZXFretoiMipSFlyXVKtUhaQhBCFa0qplnXMqW9vJ2CnmM7L+bosS9cZcEDOGMAADuCjAoajHefJaDcpOWV0bTYbglJT2AzGDCSCyEoKhEJoNs0JjJlYMBwAnMIwJphZjFLW5+caAbN34XLIgXOW/O5pu6trv5yqzzliYihGCGEWhsPxODXIpNBaU8kFkQ9hPYA74GxuphDmHhBg5kzATCIp52BmcJhjBMayrgfsEgJwDtV2fxtwu6vR/dEe932739v2KJTX5ZQIfFo4WUxzDfRUJZf09HLJJTmYxbEHyel0OuSO4XHEEr9j4v6OQlVV5u/ywCRJ/cCaV1lOEW1qrzmVVFOuUp9TfaK0UC7r5XpaK0Rsj8d9e7Dk6/NqZr3vM+R0eco5qUMSkZSI6Yg/I4JZAPofDkuE9iAwCXKf0Qf44KHU1XZ1RHCwps09L0sqdQkHGz4ngHo4eIhwJcAM3p1JLufSx+E7dyAP1/vjbUm01sX1YAbN0Bkx+DAGEp+WhYCBEgkJBYObKaJHyCFeI6SU0pza9vbY79t2n6Pp2AkDApg550KCBwsxp4SIScRUfXNte3u0fR9t+NZmb5OB363XNZcwnW2fHibu7gaKGXOWsuRAGDbMp+R0uiw5Z0Oexx4ggBywqXVdU0pzzm3bjut3gI8O3iIp5rquCaCyphgYb19/GzY/Xj++fPyxrC/AxZDzclpPp0NYlMuSUp1mf/3rL8v5+tM//ofL5dJbL9eXXErOGSmpHbZXM5uBxoAIjod/cW4BxGFuc4zde4eh6MDIGCjOaobhNdUkJ5jStlvf5+wdATiMkNiNCTmSebj5HK3U5bRWDrN5n2MjCne/32+CYeTggREUQRHyXWOD4WazDwTOTJwiQigR0QHZVD2UzphzIcSak9AfogyHNntrPQnTIZuGo6LjPKJSdB26Ne/GhiUJu/f7o297eLBIj+bheBDFBYN8H1tZcl7K6bTWtWo4IGMAJYgIOT6Hf18zL6XE9wOVHew+dxvDJeWlCnBs4w55q+dnDJzI96aWtHABkunRppacTpcnVWttPLYNkU6n09P5fDqfphMLl1KOcPQYDdF0tDZ2AM2ZAUy1o9nWJlHkxHPsj/u9bQ9VZZTTmoRS0jjVgoWPd1piLEmsxdDhYS4ASKGaU0pU25g50d5a77+WUkrJ//APP37+/Zf+uNVSGM2GCho4myLYBAcWiQA3CwQnDU8eHqYRAR6ITIhjDFVNKef8cizaEjkj6tR930dvvQ83AxF1G/ugRhGgY2fTy1JAde7NfLpT9LZtbU4Dw5KLIBsoMSWRVFMSOSgLlFhKzmtN64KqBgXYOTkSyZGSOzjgKaVaKwAQUWvt4KOWUu1waPtQjemoQYYpwu9tdH97kuX0/L7Uc5DkUvi7RHgQ6/ly4bSs53NrnXNbzlfOwowROoeFqY6uNtVagPo8VBUz9FgZbuGKFG6ze1OdhIITS148ATFEWIRGmMZMQkzAFAiE4ctS9qazdZBMyOtS1Px2u9/evrnrDx+eT6VyzNm2pdRUYc/yePsWk5hSeNgwIDrsoUyQswTjVDPV4CyCHkhEKaUZbodY2sx0YvgRdyJO6+WyLEuEt3030yRyVG0cQQQ1pXMtPnTOsOlb7xF8Pl1zKtM0Fal1yTXRQaZmIJZUk+TkiI5QljpjJceIYCb5P38OiWjO2Xv/+38e4deKGG7oiqWcLtea8PVL7Ptu5n3bDL+QpNPV8+nqjuAqwlnkfL4Qp2mYmCNi9M55iOzhiojaJyLatDn28Gk+JkxEI8bwQAK1tve7CDKSLATMpja8hwUGuYVHMCOBjX0LVB1NZ4twUz6fl/NpfcSwSX10JI2w83lhWb99/fzrL7+8f7lkDlNFBocpkkpZMjFhzN7icAYRITESm+scLYIOhLOqCifT0ceYbR+zI5owqrrqdLNwc1eEaK3tj3uEC5O7B3hiLiRqBgi15Dj53vpr21iwluV8PQNQf0wpabksdVkO0B+L5JwOKbkBjhnEwHXFEHeH4xNwXEgzO94SRDTGOLaT3X30nsqamIhSQELNPuTy9FKXpfUBIOfz9XRacy0sFQTJOWdZakkpiRQP4pQdOMJG24ELmSKRmxIhGnNMswZzd++BighCwkLCLhThs3+XpEUguKuaEjIYhNnEUJ+6PxzdbJiOve0AVJfl6fn5fDr3LeaYvXcPL6d8Pa+XU/n86dftcYOSUuLRd/Oe+GjrMkVA0H7fPEGpqayVRCLcdJayMBdT02EGMOfUOc39YDtCBLMwi+p0U1fyUJZ0ulwy89Qxey+lLimzWQbIeSLe+uhqajHq6Xy5nCjztg1FP53OeVnzUomJmERSKXkfffRBzCVl4Dw8IWXORMRCRKUUROy9zzlzzkeD/pg25JyxlNnmVBNyDCdEkXRaks4a3755UKlpPdV6Psv6VJKgW2Y6nj9VRTpCIa4WgXpC+45/9QkW7gQ2OCaRTh9z7FMnyZJqSaEGOnXMsc05jk09BUpSSqnobL310V076uQlZ0aT1Kmrxd6atM6RMeR8PidNfTQb/e11nM/16Xq6xQDzOca+7eulmHk4UrAApCy2kIeqw9SgMHVDTu7ObMLsHKPPcD9mxpNpzqazmzMTARAgAREYpZQiuLWt7Q83JaHBTBYlJSmU50BB4Dg/rSDsyYe3TiqXfHq61FpzqSxCiCSCRIEayEBigX1YS5CyJMpEJMcfItr3/dhn2/fdzEopInKwc8InmCo6xgAPYZ46Wtu3bZtTISCJTFgWvhwhETfr0cFDRIiB05GRRAht+z3nTAChHhgSFNoRFGKAtRibjT5tyigAAXML3a09KIIYPWIMNWI+nS/Xj5zo3vroe+go4sJMgsuyWkDw4WRzMueSxFWFkMRjtLYlIQCYox8kmntrifm0nDJwmBFArqcx+tSmQQxIkpBo6jDzJOWoqueYwpxYuBBRgHsgEjNiQLCZhKvb1NmIKOdsio/H/X67C5ZwSwKCeLqepchjb482DBUSr+t6Ol9TLpJEJLMwECORhSNlTKAGcxtuxu9+llS5LAEoBxflDyYuHB/FQ7J5fCOn6tNS2GWMxxzTtENM9xFutWQz27fH21eeeBp4aZkFYC3fpzHMcvjDv792TEO7owegzkmBKuQxfLYxH3Nsbt1h3n+/W61IMeemvvexIwYzDdVt35KkZDNdX6RKjEQ+FZUxmKiWlEqZjoYcRIiSJDPT3uyoIwElXFtvCEFIAUZEb49bFkmUOQuQZElzNpEMTIGea6pL1dnMwA0xUITLtfQ2IowCAixjFeI46MSIEaY652zBQAyAgeSqo7U21YWRwZlzXithTjNNsId2LJRqwlTyuZAJIAcxSZaUAGEMTYkQeZoiolR6BAUkKQtzEgQ4qPKIwIhzjKOfoqqqExFLTgiO4qAQRPX8lBPeb69AUjCpQd/3vt/OMQr7mnNO6djuicBuTkDaumt4xLJUyRdmNtUI1zCflhjH3B+3t6l7FmTGvX8dk4lCdSBZ2zcAQ4Ixx7btJeVLTdYb5XVZTikvcwxAZObEDIBj6t46BhJAt0GKyMRIrT3GuDOj+7S2uVqYTR2ZBA3aY/c2Sk6YqNYSABYxbU4z2xWdhViYdLq7AUZKTCgQccCphfMM6zpM9RhLhdtpqfVy2bfHtzcf2EouzOAgJcl6WUtKvT3apjoxy7KUxZDmGNabpJVZkpAII6EFGSEm5krowZJKycOuzqU7M6K4TiYiPNKE3FsDRDNjQsmZmN3jvn/JiYZqd+N0UuF0EtbW++9Ljczko/XbF0Sx08VJQOq7Dx/X81O3zk7Wd5i+lCQA3SyYFRwYBAnDAkwSAbpOzVKEEy5q0QNw6w8G6taTMAYQQk5MFAAjAoQXKRSc1GmawXHi6E1ErosEOCDsbG17MIJwuPvsgwsvOd+2V/ORsnjgijWXzO5qk2Ka7kHsxJIXTEV77xrZxZlFSMTavj32N0JIKQkxIgplRAoaiv5dLsM5MZJ7v+29tfEYo2k4JcnIWRBdcUK4CkQC44ySIZsFeSyBKSFzZEHJ4iTq5ACYCqQawRPJWHJ9CaDphJJlzCkiOWcA2Pd9zElEqgoAOeeIaK2F+SEtS6Uudem9HUyAw+gOMbfHff/6LU/5yLmsEuH7th1mszkGuhYRFrYIH0OYIMLdgZGZwyKXWpal9+YBLGlZn4SZCIcCRJwvhRAjnAmZCBFqLUAc4dMwwuFwVxKbTlWlLKkUCENKFyG3uW/3ZiNcWcTdESHnghAQDn8s2ROTIB/btPu+UcpIiUuttVbk5EIIh/9FhFMuYdZ7bx61LLVWCAhHZlnX9dCuWG8skksOCHWVJMig6o99CBGiB0BZUqnPQPH5y1cYdL48LSlJyZQrIDsn4AIkcOjKU3USm+4YOdG6LObobgAhR8dIVd39qDRqrUeZcVzFCF+WtRZhybkuB4psf9wSp/V8affXfR8A9P7jR6rX+/7gUj+8f051MY0jDplLqankxEjEIiI8uo4xDEI4juVqkbSsp5ITp7SszwAhKV2fkQmTpHAdYyBETnIUsgGkNk3VYhpgAEQgE54uFxv9dnsrwsu5CMrpdAqbj8dQVXADPBpSDgBEXAr70NF1eiBaTkmEU5Lp3toOakDCKTMyAB7SWJacAnWORIQACNhHjwAjPyDRTMjBBBE6j39SU59T22M3dwd0je4KESXlkrPkVNYqpaa15rJQypDPpS6U8rRo0xUo1TPlRQNcuzqg01mEAu2gMxx1xVH4i8j5fBaR76+FUo4VSLfNHbKkUioSl6oIYKN70Pn6cj1fdeyGtM+Zy0KEfQxOpS6nLAUCGAIDPAzcKUJVTfX4jWMqIWu4BdT1lEUQYr28b70Tc1mRAEQYwh12M9UAAGAgVbcw/P4poIDj9o5jawDh1LdH7yPXHBHT1F0Pm7Zrn3/UecScJWOCObqNHh4eak6lLHNvbW8zuiOlXCyfhFlECJmlHOpmkVNJojZ0dAjsMbt2mGYQgsAR4d57vz+2bX+oTkQSoUAMU4uI0GGuY7jFcjlJWblUzIVTsbRMkNF0Hyp5PV1fKC/AiQA96VAnlqmGgEfrTY7q4uidHmuPx9NZSjmOqczsevg7YEw1n2rmwM2iT1+XU018e3UEqCUzp6naWnt5+fByfY4AN+9tn3MIYUrZ3FpTU2VCAurdtjZL4gBWU0D7HkklcMSth6muqzCyYQ5kDQ934DwNKEyOfXyScE91IQCzudS81LIzq0Xvvfd+JD/iaI65GhBEmHv0gYGFhQUFM2IckbLDAMXCh9TdI/becs4kklIOB9OZCjEiIBAnyRRhycEhzIebTvWpw0afYyLR6XwhJgsNCAC3OQAWBFed+7632WS5ELOTGCUD3jrMuU+PlJecTyFVQTyIpCwlZcCpZsOO8ND3SvH4e4zRez9KjjlnrfXvww2RxExI3PscU49BQwCdrs9B8fX11vbRbY64//jxp+d3L3W5jtE/ffqESPvezCYBLEu5HF1/dYBg5nCbqmFayhnc9z5oYpLUdZg6C/cJpl6DIyIwSyEMUJ0skktiFpYELBYY+P2GE+beR2+bsOTE+z5rrSmRjrZv99YmR0qC4A7gprP1ZgBMWBInEUKMiMf94UDImYkDUSQd7UhAUgMADBBJyXTO0QncwaYOB2cRRgqdMaaZOqAkuT6dy1IC4r49Htut9w3Ckdzdp81hY2JEGAISC1BS5wlZScpSr88vkpcR4QZmkRBLrULsoKC7uY4xWmuiqsccY4wx51yWxf/4c8wd55yMLmkJhz5GAHOuzLm1Bj4dwzGh1Jrz9bKUZf367XX/66e1ni6Xl97nVL0+XThngwhE8DigLcSMhESytd38yKGmAO9qAK6qpH6+PiFGScnmjPDEEmCBQJKQBRCmedgM4gBkSWra984INs1UUy5E9J0nQ1xKgRjdD63WJkKIuG0PZ8hJEmfVQ0vpx6ZDAALAsqzr6cSSEMkM51DXIKDZOmII8XRT1QhvvZFQQtI+QxX9gKH62+2O97uB9zlMByMEoLtNVQ0HEQp0ZOfUjTwi5Ur5dM6llMp1QcmV2RyHhZOoIyMBJZZZUmpErTU5XpsHuDjnzH/8OYC4xw+FsdQKQEPDgoSz1ISS++NuNlBKIpnRfv/y+fb6r2F4Pb8UqY/7nYh//vnnXNLWNiB0CrXZe0PEUjIxM5M79KEiLLkAHNRlRERhzqUwQhKeEKYKCBgIeORn3QMsTOOwRrD6+H5HH7JYCFW16fHdykPhnESg5H0fB9qbmHNOPvc+po0mLDknpkSMY06HSDUz0ZzqxClLTkUEdJorEhdCd5869XhVp1oSy+y9zeFjoJqpCkbKWRJPm3vvqm6uY+5lkdP1rKpvjy18tmnt0bEsuSaRZTk/n87nZT05oJqb47AxHQjAPTx8TM1qeDTZI+R4Co/H7hgx9t4PNNFBXck547FzEK7mKAe8NSXHmWYAckEfo+/32/bocxYuzNx77/usdVFVYsw5l7Ui0mEmzzkvy0IE27YN1bf7VmvJJQGgBvrovXfPKRfG72/10XsnRADXqUAEKSOAIyIe1sJERGYIru4WiASMSJLYbLqZme777jqSSJI0EbdtE+GUUlmw7U17MxuIlQoLicixWehzTkGmiD7mNqcpCUlONeckCQhNp+yd52x9jGlq5gDAJMBgClM9cKiTQyARMvvU0dXDj9vaAR3ZkFmWXM/l9C6frpIXyQWQVW1M/w41piAiomMzJ3rvznQUF3IMLv5+rjnmG8x8nF2PLAcLQ4CqewAHDT1kokCcDuHD1rVPZeG6sDb7/OXLnR9Pl5da10+fPq2X9fndSyC20XkYERESQKhaRAgnM5tqQHRMxCLm7A9TqpmoFDfobW/bBhCI4OaIkfBCnAIQiDSAzVnSUsocXXsgAsbR12QAR7Dw48bTJEF4Cus6OwAIy+vr70yUkkDAnHPO28vz+1rrMGjdfE5OJY6agtAjtjZb88S81LScUioLSqiJ3e42JmZAWMls9gbuhr315s1YCIUqL5yWXHLXbQwNikAaY6DU9fx8ev5ByouUFUnG8KndIywA8CDjhluY6dGr5u9vMgcAQTwsGaGqxzE153zobP/YJfYkFRHJdV1PuZ4cqM/h7h7HJ5mAxDyCEDDmnOS+np+enp5ExNSESc3a/UYRJ2SE1HuHWxChu5dahk5z19aORz8TqPYY0WshDISIUI8Z5iJ0RMmOtDGxIKcg8YDW2pychFKSLPnoZrq5mYcHEddaXUNnA4B1XRHDTUsWOK/btm3bLizXy/V0ukJgABAgM6IkIt62LeVaZMmS3Tgcc0rlsML6VFM1QzyWBVlKWUTCTn3b2n4npmk94LhDUURSuvCkx/42dAxAzimV8/n6cnn+iHIBSqrzCEanXJnIAyJQbZobjEGUAMHchJCZc87CLCwsiBGg1hlxqv6xuRgiwsKtNVVzoPVcllqnxZwa6ACgHkJEKCyFPLu5JCMjQPjy5cvr69sPP/707of3pmYY6/lMwwFRp3p4zsJ0RBoVIsacbg4nSClUdfT+yIIEB7eQmYJQWACDiPoYw6DUmkgg4hDf55RrFtcJoY9tszGSyJzdbGC4h4F5n3OOljlKLqoE4Ul4KaV7HKNWM0NMU6dHkrxIqUi8lApIGo5uIjnL93bStGk6D/nl+XwFh/7Y5mgRSMS5ZJHLsi5qs8/+2DcbZki1pFMRYLTHW+sDgv/IZB2YdbAIdRMikYRMfcyUkkHE0KOrQMFcShJxN0QULHVrrZQSOeuYpS5zTkc8n9cIaK3lJMEMbCmlWpPPNrbmYxIIO27bvDcNCErvtKdpG9fFx/6f/9t/vb++/eOf/vHDjx8v5/f3bURQ6NUQLRRwCoPq6O21b/dwLZyFYgyFbRunBCzbuNv9EWUR4b53yVJKGUSIwEmiRQIGSuERNjCAEQl6uIE7AGSsu+17+wZEjqRHuCPIuU7y3z590v54Pq3XtdDmC5dpwwx8kV1jhlI6cVqBq1MWzjnngAh3CA9uxjrVIoCRUz0LXmyamwKGlOJ+66NlgZBQc0wSkgATYfGk9zm3YVVSLu/Plue4TbUclYLAzXm0GUgLSwZENRAkcBytn5YFdZtzJmYPD7c5NMLDv8e9aI7JTEutZpZSIsQIOEpGndp1pJQk5T7mGLs7tDnm2HW6e0jNo48xjUhyKXPf9j4B+Pr07s//+O8vl6dPnz614dfnDzoHcMo5bds25sgJhoUFplRZcowJHCRZLVhKrmsAtjYIA4jIQdVFkJgpKC85YWIh9HAPQtQ59259oJsR4KGmJGL1cAyRVGtGjMfjEaolFwoNwKmG5vu2TVWSpGo5Mzr/Yf4R4oTERwEtJc2hboZMzDinjanucewqWcS23Wdvglhy6u0xx54TE7P32fsIiCNo+Ha7DeHzWvrUMeeyXEDSVNtb8wndUVhSSkc3++g4HgyCv6faEDGV42XrbW8CHkVS790tUpLeuxx4Oski+cim9jkdMHDMqb1PJN721vsMwCMQ1vV44wqATQ3E9ONPf76czyT5v//L//CgH3/60+m0qDoIT7X7fZMUpa6A4sCST8TiCiREqW7jQVyWBc0UUZDIXMcwN1RxEVcLSkyJ0fEImoC7mWEAEoFHSZmFGdP3us3dHGgCC5/rqSBmxPbIWej5tJh4+/3T4djo09kh5+ooJElSIs7m2FqP4FoZ4dhMkqXUOWfbNjUb3SYahUW4u3HhKokp7jYiIqWEwoC0jxERl8vl6XLRsW/3W5+a8pLq6nmVnFkKppqBCOQoE8YYR1vm7/4UVT1+yDUrgHmAJNHRcs5JeI7hEDmJmZ1Op5zznGNORWROpencxxTJlItHOCHXCsBDp4YrUaqnUy3knqXut7dEOBX+7a+/nNbrP/3Tf7hcLkd6wzHu99vex/N64XwiNWTntESgo4FAsCAWYpJghx4hHpDSgghEyMQIYDM2a+aeU46IcQCgxzySn0KMQlIyOZGKQui0YTr6tF3BTciZGYIiKNcF4XltYx/dwAPIgmouQYW4IB4Idl7qxczarutSc87hjkDCKaWKqHPq6IPRAALA970rBmOUUuboj/sdWHIugXx/PMbYz+uScuE0kIfa7K0zLRDIgMSSMIXhcfGOpcTvG1ERf1QNEREGqEPNbamLuFnbN2YmRFMtpXQbh/Bh37qZkZBIblNb7xloWQoCclngu2mHATECxpi6zywieZVqbd/a/R4OPz+9lLo8HhsTLet5N2ut5WVJZZkaDknK2SnPoeaJmDQwlZO5W1d3CeawCD4IZSicAlzt+6ygpwl/KA1IOLEc/yNBaGEImEpNiF4w6xxjztG3/aFqQpLLAqFjBgXn9dr9bj5FEpB09VQIKZkFBKbMOS9zToBgTuE4hz2sAQQBllJrRTdr+9vo4yi42+wEXotExGPbLCDlGogppZRp7N3dAsmJhynkPC36fd/8ls8sGdjhu3pI5Hj+1nUF+P6NOwLfe5+qCojRhzDG7XZflqWUMoZDAAGa+ehzTnUA1HAGi+hTh+0GnHIJkt7aY+8AmEttNohzyXV/bDY1IAGXvOJpWdrQ//Jf/+sPHz78+PGH3vfNIyCer08sfN92ACjl5IB9qgVlyqpWcnFrFkxCeamMgBBEkJPUWgJ8tDYYAb8T0Y4YbTo0rwDuwUR/hD+JRJilcqoFwjQL396+5cwpSWv3rnqSul7zNm104LQYUN/7iRekOEQkhXPblfioKWmqucfr/c1dE0mppZScJUsSM8pZGBdQ0tl77xBWS9WAPmzvgzDWRRzg9Xbftj0t64effjCS2/S7Ym9D8zyl5el8Pi7e8UVsrf09VXpcRUJ0j5S/x94EzIpwe9zQ4/x0DcCI2B97ACALEhPRMGNKLMksAFgjAolLSQ7DvLkBc05ryetUH6rIwmU9na4U9i//+t+va316Ot/uX5HZUjmtp3BVBeasc84Z7nrfWi2lrOfeumS5PbbbvX34+G5d1ghLjG4zJa51QYh5+EEodExmXtd1qVWIwmP0zkSSEkSYQp8j5kBgBCRH1eGul9P59e3L1LasOZU0Vfe2GwpQNZSUCwFPw1Cv9cRSp8Ycg5ndDrCag9u+bSkLCu77Y2/b5XwuWXRCmyMJrsslrLy9fXvcOpGgCBMSmen49OnT6/3eh5JkPiVelmV9XtPyHPLWLCiV5YSIx8fv7e3ter3mnMcYx9fxGBpen55ia1trNiciCrgnJkyJMEznmDanSS4A2PYWAaVkJ0agkhZlD8C+DZJEklOhUJuq09S9m6HF0bxFMBuj3b5+vm/3sHb6kgTn+Xr1GY/bJHwaw1qbT08vCPLly7cffvyx1vz58+enp+u+b1PNEKb63ju4qVAimFO/ffsSbhHx2G7MJCJzzn3fhMgAS8ovzy86577vSRJLuu+P3trcBwJdT+ckPPucoWYTEczm3rSkk6MBV8wCRA4MKIASmIIEiMHp2AYkOpw0FgZPz1cmQog+VHU+7m+wJhHORfq+9fuN8buJb4yBDpLKtVTTpvOhU9/e7s5Cy/WJ6/L0XpbzQ3HeuiGnWvv99n2PWg6J3/+x1HZ8HccY7kYAyIyE8nh7FRGWxACzj9FVI0gScyJiNR9q0zUAAgiB/ejDEZn59mjDDJlrXRmZUQJgqM5p2vfZt65mYW3M3jfTalN2a0yMCKOZA4XH69dXYXFzVU853+9ba3sq5aV8OC1La1vb7m7jVPOy5LA55yBE1ZnSUlJW1VDXNsz9obf761vJmZn3xyPQy5LDfe7dtJuWpabzeZ1zdyhj7lOng6uVqRGURDIzA5GaMyXihCAYjHRwEo9xx0GNCus6fCI4IjBDuH75+oqgjDFm994Y0V3NfE616QuQkJSy/PjjD13ttvdH9xkYkoPTDOrmM0LVxu3+DFFKOc41InKMe/9+TB1jvL29Sc6J4Eg1C7iFo3BBRJvTzVnEzUXofF7MYW87qLmH+VQ/VABJ0bvN1vp0l5yJxCHcx7Rp4SxUZJGE4AOFADSlQLZt+2aQ6/np9cvvEXK+vNzf3h6P9vzy/nF/jDFSltvbjRJTymFj2Nza1vaHEGzbVG01S04HaCsnFj649wD745FS0jF/+ctfw/1yvlxOFy7gALnmxFdrU5DIjYVSqoFz6MPRUi6jkzoCComQcAQQBlNmToHkgITkNhEAEBgPJwLXJZuB6fQwszl6n2NHtEQkLJFT2zYmuFyuc2hTSykDUG/drCVJz88vWfHp6V1ezve9a8duKLmC4WN7mEBiPk43Y4wjTJNSOh7K0+mUUgIMVe19mqo8Xc8RmEoBoKmDmZHZ3OeckgoRIfBa8lTde/c52pyYgzRGBBEL8YF+zykvtQICUAARIAXCodOBaRZT5x7u63kpiXb4bk7a2j1Jfdzvp+vqZm/fHjnJ+nwZvb/e7pnIdEqSRND7o/WhJZ9OizDpGAxogOAOiGDx+5dP7nZeTr3t337//Pr5K1fIZ3q5vlzqqdaMDmqjtYHsQ5vaQIplrSznfUdVRSIPMI+USpLMksPB3QEYwwHjOOcDBUGEzwBjAfQAgFwognSqqi6llHzKQvtjm3O6g3sAECKNOXrbEOl0vnBwkNy23QWoZod0jMbGnADzGNHnnI8PobsfPzkupEegTQrPjOggjPQ9BoFIhCllDTL10fveJ0sWESTEgCzJDboqAUaEzTn9oMhJSsXDet8tjjGw6Rxt20xnzhJOqkN15JSWmiPs+ekantyEkwTSNGt7ZxoelhJv29b7PsZIpVhYb+02d/SRhfqM9vnR27bf2/P16en6ZFMBYSn1WFxy1nVZay7bY7u322YjLOAal7IKILi56b7fDTTiO/M75TJm94hj5Zs8WJIcY2FHd0SEtj/M1N3cFMAhDEKZKScKMHcN81ySCM99b+3hRELQ2v6474SigSnVdTn1xmbKnE7LuXCJtAJxWk7ndx8eXbeuEIFEOvT4pv79o3gEoI4ag4jMfbQtJS6HYczTShC5rlNn27v45Fxvb68plyTZ+9Z7zPW0z9F7V4umgynCeEwdaufLlVge+0YEkIQA2LRQQmIx37e9v95I74/5OFtbf/gxgEtekmQNHF3baEehPnQfU1nEcfQ3QcL+sNuXz0zBFPe3++WyBtL9sf/Lv/y3peYzjE9vf5vvf7y8+0HqBdbr+z+9MMJ+f2Ofp0TXM9/vveuG+mrdPD+7ZCPX8OnkniWvIhyR3Eh4jXAMoUMxYsNIEEN9BLQAktMCc9jYuvXR7hgqBBVkBs3ezbzkEhaCnNI6x2itq0/jqqQIuJ5PX9++fXn9Us6Xm7wEYM1P5pTS+Xp57yRJ9cxxPomDP8LcvwfYHo9H7/35+XmM8Xg8RKTWepyzWhRwEVpSSQJIrbVpj2MtllJalppSEhaAUJ0WPl5nM3MP9RhjsjtIMtXZdZaeCzIcyhUU5D3G25cvodrv3758+uvKfqp1ScAEDGDqZjM8/ACHIVm4u6uNPoa32Hd2WIX5119+62P78O75fvvGFB/yorq/3W4//PDj89NT0be+vZVaz9fr+fmHvF5zqZn5tNR2++pjI8DTuhaLtrfZrUnLFSXV9VxJtOtwQwCOOPKVGTEAGIEQWW1YKKIHGKCGweV07eBHu40Ixr6jMGaBiNnHGFMAWyg4MJOaDh3hAUBlWd3dIDDx/mjb7Q3XFybJdY2QVE8plUfvNYIhpqqDMbi6H6ngY7L0eDyOGf5xCccYiHh8tjz+CAuzMDEJiXno1H1vc6p5HLUjAPTRA5AYMQzCA4IiEPAgv0QYEZ7WRW1uj1uoj7a9ffmcKf7pz38uqGP71h5f326jLOtpacJAx0ZeypzEAPc+YXqATZ19xHD97dffWttqTn/9pTHZDx/f/frrr8ywb/1yWs7np5dy0fFsmJb1UpdFciailHMqAtr66EEEzuG5lJpLLbUSJVNSDQsBJwAQzpKymhNwIJiFqrp1C7cxEJ0TEoObffnye815XfKpPtlsv9y/TtPBhBGqEw7qg81wEGD/PkmM++MBiNfLdeqcrpQFKE33lEUkBWViUndEJmYiMugAkEsRKMz8eDyOpeA5p6oeR9ajG4CIjEGgrmCuoqYeEBYeZsdSEmIc+HrAJEJE8/gOqLsZEzCimUJAFk7M4T563zhGe7THnpgZ7bKWl8vpTx9fQre//dvbbXRL2dTm3K2yELEgCxBiOJiPMdo87uo5v273//G3/0EIWaTvj59//OHLl2+//vUv754uOXHmDEFAVM9PkleQohEUwMiBCIClVL5erMl2U7dRy1rLKaUagW4xLdxBFdVBDUXNUREZ4Dv6Vd0cQt0iNJEwhLrRHI4xZgvtS5Wffvxxv99m7zYnAaSU1NR0EtERYFfA3uY++rbv0/10vrRpNme9niSVup7ysnpwgHiAqt/uW64Z+YgUQErHRvb3GM2RDT5Kz//T1rCHgbopgCAnIG+9A2CudT1d3u73AHBAVQ04KpJjuXeaqUi2iN47ICMnYjS13hvEzAmvl/Xt85f767cfXp5+fP9UEqW83pa6lYIIU2fyYTbMmX0GCKBEOMBkRkm4N70/3n75sqe1vn37+suvX7Nwb/vb189PlzMjfHh5+fD+BwK5t/3p6ZTqyYEP8CDi4e8zkVQv58HEBE/n81TzQLeQUkloe7tNdQtmSY60T9vnJsKJM6NwypxKbxuR/CEKBkDw1tponJDQ234XwtOpDoo93NXd3caUjJyJEomkYJpuT+/f6Zcvv337+k/Xp+u791+/fNmG5ZpAsiM7MCAGkJSkbqQmlIhZmI/D8BFmO96rR3/j+7sUgIgOOs/39JRHSM6BOKZGhAMGYMol5YyqzDLntD5cAwNKqanUvQ33IEERSZIIvS61JibU+7fX++3tVPPz5VwTPZ2XsCmJU07HpA0x9GAogLEwSow5ATwXdkhj7J8//9a0krAsVVq9vb1++fxZIH7+8ccff/zpf/nnf15KFUplFZQ8LQwssbd9M50MC4eaTT8AlwiMpmShPufB1UzAMVo34CysanvbZ3RSItSDVI1ExCIMpqHaIyIlDvTH7fb0fLlcTvebRjhG1FoB8P76mHMupQZZG3ub/WiYBKEHlPVUg9+2nkrmelJHDTouIUlmSsBCgWATEFtvnOi8nrs+UkpPT09E9PXr12MqeVzL1pqqLutKaAZHqB9E3UsprU+LOMAkDmAQ2oe7j4NeBgcINMJBJOeM2WI9nfc2t9Y8YN8HgYC3r1+/Msaf/uGnj0/XTBFuczRmKcuahKUsAKamFF6gqo6Sk5maq5mbDdUx54h8CSYQnwAGcHl+elrWf/6f/vl/+g//8ePHD7fX15zkdCoGpu6BNHWAofb9nNnDxvYAU3Aj37a334CZKQXyGI9AlnIqa3KkMft9e9weD0iSJOfEc04KrbUSAAAjERKBm6qdSnEdo/ddIAB6a8xoqgRU1/V+fww14phurW/MudbVgO5bH9OB86NroUxckCiXtZST5DKGI1MtSx9DqKiNMWYMM/Xrejm+f0fhDwCttWVZ4vsmqJtqziLCRzdHhhmotTmOswwGpFIo5db7mBMMcymcJOWMMt5u9/u2a8B0mAaGSJwJ0aI9WucYOeen9fp0vbrpnEqOc4y6nJ4Rh87pwe6IIJJyyR6h+kfoCI+TFDKzIr08v/c5ze1yPheEf/r55z/9+c8i/O3btypiplOZMzMxIkUEkPW93V/hVLOO1rfHdr+D39C/uRNJ5lyBkqF0n0AZpAZBsIGAE+46AzlJ4pQkZ0IM1zAM+C6NPeIE5tZai7DHtgPG7LPkUssaJFu3pSALkyUHbOYeYMAgCYEYJa+XZT0DS1rO6/nKnP3R3FEdHSiXnCIBkdo4ujOPx+Ognvz9QTw+h0fa1N0tgIUO0pogsTsAkjA7gCGoWspp4VMADp2AGCic14QSW9+HkaQgaOqcitTVPdKiBIM9LM+6rqUUGOE6tn0ChJRlyRlGb60zp4N3zJzmtN66mkPgwT0VEZGUlsv55QOZ1VzXxGTj3fn0+vaawTliYDxfr+bCIHTs7pqZDrRx/7aVl6u47qPNtj3uvy9leCBnXVJKeSFMjzaHKbICpaE23Ujy1OnQK2AEIdtSUsAhFwARWWqlrZEk16OR6lLqtm3TnZGCEqdVwPf+qt4ASMPnaIEJuUhZARNgKqen8/UJRDTAgJCYU57T+5zufsqZBQ0MJ9SSj2t2FPgHHfFo3xDRcWo1MwNFYGYmdDkKmlRyymWqmoeDjanEIqUCi5ljKl1ha+rIlBPnvFICJJKkHtveuaxVqu4+9W2qmUdJyUP7NkgkCAIkLTnV85oNgMIPZmcEQko5HcdLyufz/vTU9vou1Yv1RnlKYhjwr//6b5dM15rvX38HHZn/XbkUTwJExBRgELoI7r31O4B76Fhrmk0iZk7Lcrqsl+dUzoqCbLc2LThIWJgFhxuXIpT6nGM4EoErhuscczZhJCScqh7q4KbuGg7qoMFtRuBUdbWY08wmp+xBvRuwMJIrpFLqclnOL84lPJChDzVn80NNTISYUiYOZjKj4/15PHnbth3ndgA4wt/HcMPMus4UKIIRIYCgpoAkOQ1Vc1+WpQ3d9v2QDkpCzOu99W2ok7Dk6XFaFgPkVOYYw9q6LMSGUzgv58vT6Xyh2QKOdzR0iwBIpeTE2fcxp6q6QQSKyPXpvSOaB9K+rufLpbfzj3U5Uzk9PL59+XT//Zf759/+b//X//Tl6+//8r/9f//dTz99+fobLelJMFxrYglPGB4j+v7t8RZupjPnsuQFSep6Xk9POZ81pO32emuP7m02dbSg6dZxXxcGsG3bwIEJy/XKQgAx+r6PrqbVB0QYwFQ3N4AATm746HPrjiDglHJGNgBGkkAA5KmAAevTZb28K+vFHM0mUqibqR33Rc75fD6xJAgj4pQSM40+jgbN0XJblqX3fqyZttYiorcGtTAxSBIiMbUxJyDmlKeoBwRQKSWl3A78DZOO2aYFJxF0h6k6A/a9na/1cn1BLmZhvhEJEudcaykHANLD7ts2zKGUADZ1DjPzCBQ+8Bv5dDpN821vOqeOaVMt6PVtq5mBpPUZQD//6R++vX37y3/5z5U8fvqAYHvb9HdYsixZ1sQl4ePtdd/v2hsTMaJ1f3l5R3xoMFafvPe5T8jpqmF73/e9A0KIKEbrjTk5ABMBYO8jrTWnNFIyGzp1mCYhJlFU84Ntzh762LpplLLmvLDFaM2Icz6RpJQqyHo6v/v5T/8IXPr0QA6M1m61rEkKwJihxEkkjTHNupmzsDCXlP/OHvp7vPsY9H8/QNTqKQOyO6qZKIYTCJG6ElPG1PtMknJKmeTAoSgTAZxKApY2bElZ1bqOPHtd8lpwqo1N+7QJ+Pvt8fS4Pi2LO8wAAKiJEoOOe+9tJGZJktN3UB0X56rhm89fvu3/9vvb4zF+3f+39XTpyD7msiwfn5e5ff7//L/+nzzbT3/6c831sjwDztv9byqJlhMgOov3DtNzqsvpbBBAwOs1p0pM22y3x5c2zSWltIKTow91BMlcKgxycFU0W5d6Xuvvv/6y13y9nAB8zoEBMyhTatt99KZjNx215t737e3rmLMvNacSHF07c12YEbPkp6fnjz/+/OcPH3++79v+7Rti5MIprUtdhFMWHJ3cbH/ckggzZ8pt35/eP9WUjqfwmGMc2xY555zzsZe4rutddeiYOgNC3C0lWZeVSTqM0XqWFO7t/jgWRxKJhXqgSHJCQGBOc/ScE1FsjzfXyQIsyGlZz7jr/NuXN305Z3BK5ZKlYKCN4V4FLS3IFEFbm6lkovzt0b6+PX7/9va3b4+3CZBPS46na9IWFlxTymL/+t//+mi3n57OQ9tST2t5HvKa0dmnoMV0VzulWlAwp3I9K9MM60Fg2Ef//Prp9nilkqtczEBDkDwlhpDCOZ/P99fb4+1GCLTURDHafbYQMiGavUME5Boe3+777LvPffZtjDRn3/s2RlfvVkpPRTmtaWGqOZ/r9cNy/SDlfNBSCEN1D8ck7DrVDcLAh6uXUgiscGYus41Eufd2LGAcHVBmvl6vx/7aEYNblmWObu4Hi1RSSr31++2OgKqGf5zNgtAcIqCsS2saDkAcIPC9aUu5Vk6p7Y/eWs5ccs2LSEo22uvjDqE/vlxP63lJlMJm2wiJswdKBKq76feB1Xb7/NvXb9u0XOrzC/c5rx+fTDExlaes20Pnre1jWU9j6tvtniQtp1WKi7MYJE6EVjiXVArABFebKHn2dtteM6Sjh5nLmXJxT9s2tn3rLQhLLqXWWBLerIX3UjP6uH37ve9v7k4wGHHfdwAoNRnhuH+ZOsfoc3Y/tk9lCcqWMqynxMTEuZ7rcl6X6+XylCRtj83Nx2hgJsgeOoZDAmJyc1UFpFKrqZorM+Wc9n1Tbcem+3EtmXlZljnnccz5HuMIEGIAGH1I31oEpJSOw8ixGjiHiqT1ejooZ5lKpgwiwwIDfSggHCiroFRWTkyOONVEZKlPYydF7MHJERVPpaZLxr72voMhSwoPU9ss/NG2ocH5elpR0tvtYfc7QDpOQ7UszZ0zvLz/0O6f5tDz8zOXkkuVAmTIHgk5CSwpm87D37Rvm8+9zXG/3dA819Pp8kJ52Ya93vYv3+69T0Q6rygkpv23v/06Wq8UmWg8vj5GD910zvu8M5PqhIACMj3m/haAbqoeUs9djeR0XlfJVXJJIgiYJF/OL+fTlam4BRP0bY+wpZSc0rDZTRMLEk6fABzuc86cEiH13gGitV2Eaq0H4ORQE7fWvjfbRI5BY0LiI+foIdY1pZylBKDqjhHLevm9f9n6fs2JmA1QysJ51QDfG6AYuCEIZ6fgXJeaEaLPEaAWHpJkuc6+fX20Plkw3l3Pz5cTy4JUfMz9ABb0ocCcsnNyYsUUTiBluciOXpeCkdQQkUXS+w8//Ot/+X/b1PcfPgZg11mXzD4IQqQsiQmwtd0hcs0k4GDnc1kKja2DFBJxF520b+1201ryaU1J4nH/pW13sv04Phg0TrIkzmseM9yMKYLZzHJsXUeCLuVEuQgmw/RwoLKeX36QcpJczlkkgEmul6fny5P2OfpILLVkwmCE2ffRmzE5BiMxSUoR7kfQFCGaa61L750IjwfxGPEfAoWD6fZ/hBktMIIBM4s8X59bG/fbpqYocrpckTgQiZORTHcSREokKdQMiSRLkKmlsuTMbd8NmSCIy3k565xzNCbBvDza3nQkjKa3r/dGCGGu6n30rc1pLiWR1LyetjaGITIGJyRZqtSytvtw9VxWGIbMSZJPXtaFRFQdqSAkAEMWSnm0TQHczfpGiQQg57RcT3q1PqhrHh37oIC8Lk8iATFmf2j7BrqdUlJVJl5LWk85pewz9U5zDubjyNrj8dVbQ3VZ14SZ0mlyETktzx/o/DyD0vkpJ1kCAFAV+vCcSnIQIiYKHVPnaM1skqwARCQARmRItCyVKMw8pfT+/bvX129m3+eLRxLuKDCOVtzfd4TRUcf35Q0BlLqIQIwxNWKabdvmQMvpVJa1H3FHyQ7IkhGVEmbJ1gYxs2TJFu4WgcIp5ZTSw8zdSi3mwYiEce/9dbuHGXic1lXy6bxcgQWQgljqIiCpLuqxv7454poXBIagnLLANN9NbU49rFilZBJkZEI+hnNI3IZOd4gwVUaKMBzIhO7hQYBswW/329dvWykpvKt3gbYUSEupHgCZmU/ndanVPYa71GQCgBARoNCs9+0+nXAOWE6GQuX07vLh9PJxgjy6UlqJOVSPOq9PNbWEaGa3t9eY41BUMQlJqqUezhcmPvaZ5xz7tiPC3nckRMe/d1CPB/HvTcq/w4kuy/m4qKoqQy3XSmGUQoCGKSCXmjgVZE54wKjT1mcqKzElSoiElAJgqkrKRC7IbfTee5aESEOHcEpS11oBHKmHa7jb1HI6SUrTHJEcsavd3+7T4lpPFjbMz+cTE8+hwrLk0u57mN1vty+ff//xaQ3TkrimdAw4hf/gFTIGEgsRch+7uQJz+LAAoAycOWWSrnGP3q4nOtUlk6M7RV8Dc1ncXDASgYUbeCkp8sFgN5VhpUgZ7HzfR6ks5XR6+WF99yOW09btRJFEhCS65VKen67t8fa435xwurrZMTw7NmNqPa1L3baHRyQRIhyj22G80Olul8vl909fjkPNkb5x9+v1emRij/ni0cdJKZVSAEDmMfZGAcYACI/T+eSELAmZIzQgEJGJ5xiEJFkoyN3nVAtwjMTES45NCdDmtDEFOablVG63fc5eUjqwGsvpCsKYCsIcUwPBA7s6Me/7bgAp5amWjDMLooAHBbTWfv/1V+09NM2+MYFw6Bw5y1IrYYw5KOeMYDZdhxm6gw0jyFLWVK9N09absz+/vybBNXmlLflgKBJUAkotx+47mjPA9XxGloMZNchEZjMekZxLSpeXDz+fPv65Xj+6LH1aglhLup5PZy5Y1pSEIHQOxjBXj1jXhQDCQojSsnBKvY1972P0ARChKVEiTkmSUM4M4EcsAwBOp9NBPTmeub/3V83s2D89fiKRMuQEAKCEEegQSMcZkhxMLQBKpprpsTeAQI/v4UwIRMRwt5htt96XXEfvCbCU+rjfhIgRNWhdzqOPMQZTmjolI5A42FSfqjnnlLNFCPGyLKpG4BiBYdoHoWvfH6/fxnZb/uHl5emMNtvjJqecSi5Vwt2cEAmdwQ0kZSACqLWksgYtFqJmW9+3dheR0/lcaFbgBUpBKRwpPJds5lvrZp5SuVyvAdD6aK1bDETO5w/WKdXrhz/9hw9/+ufmad86MBDRc5LTqT6fUpV1NB39MXUwBuWDCYypCJOEIzgY0Nj7aLvOCYiEAMgYQcQsHGYRfjBIjkt1gE5FjvkB//+ZT6Yfr0N3l+7BHogIhymyxBgzLBAwIMgRiWbbKRV3YyTEEAIkVHMhDkfTMbrOtmcPV0UkcrOh27iHuR36ZD9yU8A5b3trrTlgSqmW4vT9lZ+ES63uHm0bY0bw6K0wvH379uXzbwT+8w8f/vTTD2sW8glOOvtMBySjuImKpJwhAjwYSYQR6zbkMfqIQCYpJAmCughUTific8JFOJMh0d576xOZz6dzKYt5mKMHI4pWeND64+nj6fkDlUs3akNZ6ul0OuUkCJkiz0dNC1BsYw+wWiU8AEGEmUUou9PoE5FySmGWRIhJCAC8bbcAd4c4pBQQy3L9O3joGA5v23aoFg7qwtRZykJI7mbh4gQDAgIwLIgYKR2dWTzsxEBAe++nkhOTkCiAHIn2MRxBdc7Rw5TUHamkNPvcb/dzKUiccjGzdTnlVEqpB1ui997HqHU9QJBlXdoYSAgAbd8RoACgGwGBWYT97S//9vbpt3/685/+0z//+9NaLnVJkbcYEOph5nhwFVNOGJkC6WAj6QxICMV0zNCpw2ImFkmcMq9luTBdkqxJcrLe55weDkR8vlxLWaebAznMAErT77eHrGeuT90FQ+ppqXW9rOuCYfsN9kdK5LQEpJLY3JhAAYhxWSpxMkNtFsREMsfxi2iMMcNS4kB0UwAiwkQScUjLKaX099DGQQpGRBGppRwgJkBU865TlmUlEj0yHQAaWHJlDjx8ZG6OLinnUrvGNFftFgjEckhJhyJAyoXZBUmIBri7L+vlILMgQtu3OdUiHGOEBmE9rbUuSNR7zwAQIcyHPpWIPUIjBLVm6o+31y+/ic7/y//8P//jz38mg1ISGZJjSsIEptPdmRITB4R5BAsgGtJUe923Xa1DPFrrc1wuS63L01oviU6EJ+EimEQCMG7gjnVZluV6vj7tfRoUjf3R7tvYqZyH8X2bUlJCIgcfY4AFhLUb2ahp7e3RDxSj6z6HhxEfEj9ofW77QKDEWae5TWae2gGcOLMIQbAgEyGFUNKOvTVIIJymTlUNwAPSYQDDfbprG0wcEQgk0sFhkjt0TWUNAnN1cGAg5mBCgpKfutMEGH/ECLatAVHiFJKQikeEdUN9e71xkuvzU7eBMVvX0+mk5kHIRKnmbhiq5nabreZCSaZqKQUhZp825zS303kDjH77uKZPf/0Ljrcff/jwn/7871+W66WkhDBtRxELGH0wck3FLTBizrmPiSX5weWo0NyiJoK6/RaPu354t767/PTxuqZ5r9BOizCYheeSnDCYrx9/lPVp8mmQ0nrFaG9f//b73sr1+rQu67q6+xh7Rs9YxmOYSC7LtPzVpWTEmIFY65K9HFWdquqcGHY95Qifsx98GGIunBEBiVrbOVHF1IdG+PlUC6ddd4dA4D7aup7KumgYAIBIi1CWTJIlqSpziH7HmH1nFwEhAlh4HEgdxJKKh+97W3IONWAO4pveA1AKrUsFpNfXN7B5Oq8LYACquoWHURs9lwpEKaWSM4nobT9AR4coIsIBkVgwwGF6BBId9S9h7b1t27a3/tOPP7378HE5nQkikAOJjhrDfM6hw8LD3NUchCsxMweABnnANDM3lix5yWW9XN8dbH5eznnJYMNshAOVNS3GeaVcm4YGNfW3x96G5rrUy5WYEKmUnFI+1Agi+UiZIHgEhH/vXB8962MieBR5R20Oh2cM6djzRgQzPWoZAJ40PTxJIqJ99rIuEQBzpJT6HNApIIAwI4mwEPXeA4yzIICklI7WOBAS04GbDg9OB/sSmZmBrXcUGXtTVTwM3kQ6BkSkXF6uF+GnWuV+e/Qx2pjmIUlUvY85zbLkoYZMgHjg8kS41AoRqgoIFn7YmUVYVcOdkQMZmR3w+d2HejoF0DTt5gH/e1NvtiNHsmVZnkkGVRucDMbNi+zuBKqA+v9/ahQ6GzcjgqS7manKcIZ6EA9Wvbo9OAyiKnaGvddGJEFgd1fTsIXW4iwpmAIwzB3j0dvPp6/uVsqFBvQeGhJCnIMSmqQIHk4KjuWeLwLlaryNaX89Hj8+ns9Xw7L//tu/8ZZbbwuMS8SIiEgp5TmHu6+UCET2VcRxmPl5LI5+MvsM2WVm5pRTCfBt2xCx96Y6F3Iv3E0NAefUVAoinudJwoXqj58/f/z8WWvd952B0NzdlcLAMQIQBIkCQliQ6RPfpUpEjBQBs/VwF3TtrQWM4wiEjFUQEJGYIcB7X37zV+tHGwHAkpKk6/Waa2OW8fExA9DAXY3c1WEFSW/AxKr9aafNOXpfsCRJWYcTEhHlXADo7eu37XInEXPvGmFA7oTIKYUDI2VJgMxJNOATZQ8QgCQ15Swp3yFPxY+j//XjKb/dE18mwgAGFkNRcN4yWe6R52ltxHP4hJQuJTNzrrXSislj5gh3j1UxmpG7pyQiSXWe5wEAa362JmdjTEQEwJTSvu+IPIdDIMIiJHlrrfeWUorwRX9CouFq09rstRRhRsTr9caIMbXZkURSSnmvYwUduouGqVtNe5ZPQce+76sv6WO4eaipnSnAe8tMAcDhl1oRMZcqKfWpCCAiQdTTkFwQcEwFpFyrqfeplYVEwp3BkR0AAXGMGQA5l/M8Z5+Iv4LEWDAX5GhDJG/7/vblS912yYwAEQoIvtjPwgxESEmyWSBJZrE5INzCLRC4AktgLhunfJ7Px7/+fLep14z/eLuSVKZknIZNZTms//z+Ouc7YAqifLkDy5imROaKQCJExKqwLIxEGAFmvqJLVj++BitLYJhSqrWoWmunmSFCzlsEq84xBiC21nqftW6llDk7ACCSzjWv5svtSkg6ZqmlSHaz0bu2FiIcCNXDjAkJk3w8n733XGtlWjO6um1LTN6Oo48BURLKvuU5ZpI65zxbz7Wo2mhnYt5T8nAWcYC6bff7F3d/PJ6IMPpQtaUxFxEhULQFiTY1D7Wheb+4jt7PlBJTEcbvPz8InATm8xitiTCLqLsHYUqMTAAKAczEyZ0YEUAiFElSyiNizNl7OxsPiKDYmGst97evrvb9/fH+830X1P/4d8l7zcko2tAx4M/neH9/HK2V/Vb3y4Y5pgfyZavt9d10igiA/7ISmsWyCiOOtUVaJwdA+HenSJRSkpzVPRZCyD8nLyuALVZ2FcC6kM0sEM0YSq5J5Hg+Px4fs4+YVkq57hdTdTVTteczIqQUEZJfotWlG1+DH1VdgUVEZKpznOhISKnmrRbTie41J/NgBBY8Xv1xnoc5IvScW5+qysIQBuD/+PbbVDter7IVBx2mzGvcFzWn0Y6cxHIyVZszmDOFj5FSliKjnRjw5X6fc3R0wqhZJKWaCiCOMQRJcpl9TjMfUx0dEBzndKBsFjD0228XMxfhb7//Y5xHf72a6b++P1DK/Xadeow555jvz9Y1vv3z/yZO67mJCMnp6POWUuKVFuYA+KkyRFwTst56TtndiOqiCu37vhRsEXC/30up53mO0RFmyRdPMedYpQ0CusecCgBzagRcrlfEmGO088SI2/XauaFHEsGIRSdMkmJqEhELn00kZ4sYc+hTF3r68Xh8SnQ8IhwZIAIJtr2IpDH1y9tNUlEzVTf00c/Rz7OPSAmZvv/5XyI5lTLaCRZ7KcR8tq6qFBakYINw5WI4GNTEYZ4uNacUHs/nu01jiCrUz2mjf7ldak6E4IvAb+DgwIlZANg/wa9AlIhSAAbAKp8y1rvcCGDqiIhSc6gS1OtewQNC/3h/vh/tuvFKnblcv7x9EUcw91wKu/feCaOUxKZM0sZQNWbRqQ3aMsQQUUoFACNwBam7x6ecHlnVeh/rhFTNtI0ezCySImIM7b1VqETLjJFyToRIEUTkqnNMWCmYZu5OiECYctnqpueJABzgAPLxfCSRum28whiJhXmMMftASTnnWmo/jwj79u03SfnPv/4kJBIAdwsdUxfZ6Jr3VHeI+Pnx4TbQKLHUkpBY5wSfey2Xy3aOJxmJUBYxMwzMSbqeppZr2fZShObQ5+MjxgmzJ7R/+/a1ZgLXQHQMcASM3vti2gkuMgoHAACN8Knau04NJ8NkJWfVlnK6brtOHZmFZU49j9e0QAc1r9sVWt/27X6/9zGGzlxyH2NOR9CwzsyZeZqaUSl5jHkcxyoaFxjqr7++5yycSkT/pcMv5VPvtO45RIKApewmp5zy/f6muoswMQF8Ct3cYyUkB5AjIRMWfP/4AIAsCREdYIbrGAgQi/y+7RszMxETJ5Es6Xi9Ru8EeL1eF8Ri22vr7WhHWY7RcA1vvZ1tLPFdyiXlEohmdrvUj4/HbGfZ6jhHSmn04XMaem8+x8unuutQMlUI8CngEWbzCAFLCB8fP64lC9j//1//+f7Xn//jv/1fRRB8BgAxEQlRTHMAQEBHsJVXjeQBMc0szuOcYZoEfDKncE/oQq42w6fUlFKVxO4giFfB337/9v3Hj+fz43whEmJ4Pz5aa0jEyHMcKsXVVZ1IEBnRcq45V5Ec8fmeMXOEuQUEusUi3COQWzBzyTVJgmCRihhrX2++wAtz9VfEuIgaX69XMxtnW9jDNoaIhAgmTpKQ0DDkUsOsq4ZOud1u53kerVFAydlE39/fCem674y0uBwi4K4fH434FRAA1OY4W5tTJSXJCQjUOq14ssS3y2Ye4IaAJYkQWclAZDpiDiFiDBvdVUWEHOpWCQoAhM2pet+373/98a///H9jnP/x7//893/7nRBCp2JAkCm5BUgmZgxwizkVA4XFECMQADXCzPOeuDCjA4PbaOfUOTEAMUqWXLMaYvi98FbydSv9IJ0DINSmufrUXFIRDBQf/jpeAZFzPs8zIkopzLyCDxbhi2jxW9ISVSxk9+PxWAF6C3UyRn8++7bVWou7j76CoCmly1ozLchcP84+ejuOcGeklZ6HRA4AjMBMREFuc3XKIn9+/6u3jgC1rLKzA6IIzz7+9fFAxH3bPj5eSIBC3qeZPY9m7hHIIpfbdb/sc2o7j5JyEj7Odqm1z/nz/SOXcjyfffS1pXebAJZEhPAcCqGJRQTBzcEyCxG668fPd/B5u16+3f9x32hPf6P/P+1bGGGcC/HGq74HXDNbMweElWbpCNtWI7PpWMpc98hFRPJUPc5DcpWcBdJxPI/jcPdtK2Y6Ri8pEWfVCRhZqJRyuo4xUk7MfByHiKzRzC/A+r7vSzf6963oc04R2fettb48KO6ectpqMYsxhrv+8nnf7/cxBkDsl50AecxnQBQn4VXOlm3T8N77MBUREs6JjMAiCEP0OWJqrpUUz9dHROQkr+OYvRNhKeUIex0/tm2TSH0MRKyJHLirMVNAnP3ctstt38/H43g8ci41sfXzmqhk7q3drpWJHs+PTFBQK+dlQjfGW70+n08pdLvfEF0ED0D1PwDHf/uPy31nPT98nIyRWSAQXQpSAIT2TFOyOBATB3Ezx1QM6fE6LN2ESLEgkKOYWgQkSVP9OF9bqUyRwc6PnwNCw81t27Y59fl4EPNt28ec7lxKAUxjUj9eieK+16lzni8q5XK5zNECckIYru35gVWMAlxNzcwwYhqtcrZkfrtfVefzdQDONl6IkHNOBSy4VDnbcRxHRHj4Vrc59f04U07IfJ5PA5BUQieCb3VvrTFTrr+L5DnHcZziDjnnLKJmfSgTpMseEQggTCxsqstd5mbhrgFjGiDV/XK93eq2O+Lsw2MwUUrJTJ8fHwGQcz5erxVW0lQRMNw4oakxeckFANdxllKYqPXTncyMEVKWKsKhQ8ccJxGNOYUZMY7xyKVwrmHNhkyHgEjbhYl84aHcwx2J55hqVnJZJXd4EHNlZlgDM4QIdzPw1WtFRC6F/o/EdDNTJRFMIuV+R0Q3u9/vv3RNbgYA27blnB/9mK5brSknM5u9E+JWNyISZDMVkdv9erZOhNu2jTnmnPu+RcTj8Rhj7JediFpvdo6VsgCIqeTAZd3B13EsrcYcE4+zVEDEWoqoKaIMM3CXlBLjX399LzldLhchPF6vHz9/3t52yTkicqmAxMl6n2st0lqr2y45W2sMmHPuvavZGvg+Hg8iWnLKfd97P4k4AFTVNBB5jLFKq4ggQhGZk3Scl2slsH4c7fno58dAsKm17Enq6Hq7fynBEz3likBhmLBu2+YgTa0THapmjlA5SZEUEDZVkuSUCWD0AbHQBciS9iREdBwHAJRSWmvrAlwwxN47EbFOJloMtuv1uv64vtfyh44xmAglTVVyl2VRW2Z6QHM7jiOn5O6Pj4eqrpDE1nqStPDtkPKl7jml8zjUdKt1zmF/s8Mej8e+7+uf5pLP1no/EVGEiUi+fv16HEdrfWHFj7MhIhGPMR69Q8S333//+vXt7OfrOCLAQnsfxELMah7qIspJumprnwFHgDDn9IiUEovUbWu9E1EAEMtWd9WYswvTEv/MOSJMUmaR1+t07TVdyO04XjpajKGh7TjtbMzl7NOm/vYPSGKUgTjFjPGiknKuCUFmyQeTapSccL8wkc4JAIws+Bkjsl44Id5qLfK/xZ8LaPHXX38tStcvPCkTHr3lnDmnYUpJ5pyzaR9DTXcmFkGKYXO2EwEg59WB9NaVNYv41PP5MjMA8qH/+ef/V0v57ds3IuqvQ4CIQPuwMRdHMyLWHA8RzT99ghERhCnnAjCHu3YHIRF5nX2MMcfY973UCoCzt7U+KaWw8PVyDeKjjT6s7hchQmRYz7EkZnH3/ny5OzJFxFqNOkx1Q+FAmKZA2FWRuc+ZcwxVdU/EyAnZA3xGYESf+v395+9J3q7X0Hba3EpC2UEnqY0xfToa9uP148/xeMj97evbl3/kek0cNs8+J/BemCvLBM8pK8Dow80gwObs7oSIAMIS5oCYc27HY5kffqEQlublV5HSWoMk4R5/J8gsXdMSGKacx5xkBkJIeLtecymE2M9mAcLExIzUtc8551TmdL/dRVIthUk+Hh+ElJIgoE4jJkKec7Yx14M1pyJRKXVOPXpzxN6HiCQhBg+byCjv7+8pZ0mFWIiYUyJCnXPOtm1lq1tO6Rjz6IYo+35lZnMw97N3ca+1LvNAzZkzrHBxHWONhlctfhzHgh/fbrfezwA0i2UBHWOY+bYVYkAIJhJOBctWaz+Gu9WcSk2znbGZ6wtQ7vc7AE1/vT4epkpIFw8PVg+DJIWCkptqVx7DhE1VmIXYzEbvpRRhFmY3c11uMDjP89dSd0Hz1vnFZ0pLPF/Pr1++IFFv5/V2G72b+9lOM0859dERiZ0Bg0oRIiYeiIiYpeQVgNUaIn55ewtHnSrEs4/mDTw4kam52crsdLMfTz2Po9QiScacWSQCHOF2v+/75fl8jjnfrjeMGHP03uTt61dG6r0/nq/e++162a8XVT1eDyKpdRtzHn2mvCFCn0YWgQyIueQI6H0QEQCqquSERJ/MHgBTRaKvv/3WW3s8n/fbvfVBjI/XM0sNwKF6vdwlOTKqzbe3m+q4XK/x+K4eQx0wlVoFFMRecO7X+2W/BzJBMuDv75MYc80OrjY5Qk0NGzJ6hLmN0S0JeEwdsm3bti0xZk7JzY7ni5l1zqVt+XznAC6XyyKnI+JxHMuvRGA5pcfj4RGv18vMxpwppb1Wd19hAaZKBKb68f6xBhrC7IBGNMf4W3WIqv7z/UGEtVYiQRIPF07H2ft4qvntdpfUtwuomlsQiwOOPiQJM7XWI9A9VCf8vduXZY/ilGj0MfVsI6dca3X31trPjw83e3RnSbWWILYI5uQ+FwwnIrYszCvJbNEnAYhi3eNTV4GwbtrZ5jw7IiFMxLTVnCSd7WTOTJFScleW9P5sfQJI2W9f3367tud7AG9XFMmX/T6nRxBacHpK2vbrW95uKBdOe837MPnr+8f0yPumgGCeRNZKqbfWW9vqBpLCXERWaI3O1ntfQ7KlGVxI4GWoj4haq/CnuoBF1kciQszmvm6dT9UuMyGFOyKWlMLjE8WsyoCCxEh8qW+IZzuPsxHTtm3gRCKSk059Hsd0W5RsQFwzWXVnkW3fL9crMR2tnef58XotppS5y3m2nDMzpVyWfuL98Zha5hjP5/NkLjnlcnHkNhzGmn2Ah1GAmQOoIEWAJFroJEqCgAunAwIe4RCcJABIuKa91nq8+krrO/pAYk5J1duYZ2tjTof885iJIOWL84bZhMstXUrZa9nPc051H5a3L+Vyk3qXekXZDFJg6m6vOSmny/UNSjGWdp69dzdLOe/bXktNzKM1RAy3H9/fmWPprJdIcE1eXq/X6/VaF6y7H70lkTnnZ9OyhExmq49iZlsE+nWeAQTExEgrKQeFGDLlnByxzVkuO5U8fvzwCClFzZqpI6Z9KzlLSr33zBKIptp1uup22XOpxELCpUAEKJOwRMQ8TyFmjwBzJBIWJjKdY6iZl1JqraUUk/2c1s8TkRCiH+e21brX2ZuOpbHzPub0AQFr/ebha6YsJU3T1tqP95/ElEtmSYGdhHMpK00BiYYq9OhTA5C22399f/7+7X57+3L6SOXC4UK8bRfCNKDbsNBWbnh9+43y1XnjtInUj1f7+TioFA18HycvJc4nqQn62YiocHqe53meW63Lnavafp3N2iuVUlZH+EsyUxITkUfQ37reX17tXwJtcAgPC1vX6URMIhERap/JJtMgMaU8I4CZRFrv55yI+Hwd6/12gBxrW8yEGALkDuRrbaJqiVg414oHwDQDxHq7yfV6XfZGhFBznZOJphkh1H1PktztdfZA2S7XlJKONscwc1MzczObM8wMGYskD//VMgNAkpQkadL1q3O73RhZ1QGQkOacqlZyVbM5ZimSUy6lHpRb618wbfdvqAe5hs1t22q9qAZbYrQUk+Fab1/S/gUlAedz2H/9eH+1eX37gsgWwITouKgxiFhy3uvGzK/Xc6mbwLym5PnzPH6ZktaYekWmfa6fEgat3Ef71U0RERAZhJoupHgEICIC+JoXrNGhu6QkxG7qiArx8/v3XIoTSslAOObkLPWyEVEuhQDn2db7bvHZF72/v3NK27YRs0Oc5+nEwcTM++Uiv2zHARhmc06bo+T85e22yoExbejgLBD0fD51jLpfYs7WGiNKkpoSEXKispf1/f+m6sIq/1R1cZO2bVOdYzRmLnljFggyNXPVaRFoqs/nc7/cEfmP7+/bVv77//NPHwdY2q73mmtrypME7cslzXECC6WCnL+/P348ntMCmJ/tvL59yylRgLBHeEopsZRSbtfbAjhnEZ3z1fr1dl0U7dVjrGbj+XwyL4XsZyjJ6/hYqrWUMi8575wAQYhzTndLObM7MCVhQDKylCQ85hiIkCAnkRkx5vw4zjbHdrkg0ePxmKorIWqauscesdeakpjadIMISZKZ5xzTrPeeSs457/s+A4EwSZIk0o9T1cx027bpQciYyzD/8/1R+8w5BwkAMIX5NFcQnK7DBgufOkvOhhChN9mt6+idiLctteEOyYIQ8eyNyHO9OqYe4BEUeNmqmh/j7NYjbMZ8f39XV2LZLhcLfz3n//zXDy63395uRJDwAlysBOGg1gfThz0ej+f//Phzqplbqdvbl98cYNv3n+8ficknkMlte9u2EmFHa/86D2K21Q3X/TzaMQNIdU4WQus65vDe7RCURFXNus5sRY04JRTCnMtln6rj8UgpOXHEBHRVQJaQ1B0AXHLubmO01loSLrfbGf48D3fIkHLeN+DhUTk7wuVy890t4PF8UKpKwpwcDcxTEkTsvVO6vN0qfN78klPq5wkGlIQxSWJh4udzuLm7P57P3779tl8uH8/nq/W87QBg3kyVmXNJJHIeBzJxTkc/Z3czCzD3qMR127dtY+bjHCljAJmFOZgHS7yOni8Xd9cxLWCaOgQKJeJtr+GhC5VFSCLb5daO88+fL4PUjteen/f7dSsli2Cuw3zyhgVNdWpDTnW/kxRw//OP7wjQ4qxyYcqMqNPcJwBMm+08TM0Cb1ehVIgp3EggF/aw0UegT5uBIMkBWN1hauKcchUEQELJEcF1c4CjDx8zS4KA1tUCidDckwcCADGmNKa+P5/mhgFb2WZzndqpsaRL2Yfr8/Fsc+6XqwOdrVfks/VS68JxB0SQAFIfWmtV1e/f30vOlJO5z6EQKO8fH2uKGPiJrOq9397u21bVNFYi+qdqFHNKRIvIKsvR4e7ILJKy5EQSDsfrjAi3qHV3dzfNqSKSm5trIWJEZzOzgNi2TYRtDlUlJEQkZGLJpaaUI9ADnq/z+fHxAHx/PIowsyThcr2jyL7tROS3TxzFx8eDiP/4489//vOfo820+75ldz1eRxsnMizdaEqZDHRY64OZwXvOEkE6pykA4r5dRVKtGwSPYYgYAGsFZma9taEzr19NC5KcRXrrfycqM4SNoSuMZ6tb5JUz77mWfbs0nHaegBQAXYdFeMQYM1cl4uNsJEmIS84RMMZABGHZ9+35fLqHiKhaxEgA5kaIa1IovfeUMyL20X//x+9m9vF4lJxvt9uYc9EBlkwLPiMd3F3nVKbP3oiJjvPojmtbpqo/f/7c6rZfdvg7H/fvKaUlEUnZIeZQzEKUurvNSUTMyMJOAhzEKMWllJRkv9xNJ7I4klsQcwCEWZ9zVSWllNfr9fHxERFfvnxR1UDovWcaRGAAvzS3NrzWipwQxJHDY8wzg7ihKniAG+S8r8ELAK215b5lJPYIg3BzRGJOCMAbF0mJxczhk67vxCnQzLT3SYTCJJIQccz58Jdw3fY9EI92Hq2TMKf8j3+7ApJ6kAxEvOxXBBqzmzkzA6A71HpZ7Orb7X4chwMG0BjKPAVZkHVlAATg16/fhur3H99TrqXWP/74AxklZ1ADAJ1zzOFmOWWIkMTHccw5LPw8GwMRMecEhEAYBGulycyxorxF5pwAmIQDaKoCgKol4XzJBKA65xyhYEYiBJQoVclZUnWdtZQsrHOWUkh4ztF7P89zrSBKKV+/fv3x48fb25fH4+N6u64E98CQSB7J3IXherubmZqVUq7XWxIZfUtJVIcjBuJ5tmmwCP8pZRbiwJzS0mgx5yA0N05Z53w9z4btsu1LRzLm9M8tBIEDIDh462NMTcLu+BonxKy1AlEbExAdsJ8tl8083H2rm6oPU3cfvQMiCkO4QeyX/TgPj7hebuoWiCtOq48uS3f8fL04pd/f3s7eztZyzpzSUA3CXxnFS3DQe9tKIcQxJwuFeeZ0vV3AIADXQERVS92+fP26SHQp5VJE5wwk5qyfMeG0cgZa7yldRZLO6QEpFSdh4pwzAJFkQzY1CCQpUqRPUwOfPcKZhEmWg5yQucrb/cvz8cypzK4oWSnmGEP7IkibG0nqfbpjrUJClNI1FSQYvUnK2z5FnmbaxyTOIoUFCSVw6Jyp5G3fR+j5/sGciOSgNsYUVvAIYk6YiIVp9EbMiCCcZdtN1U05C6Xcu75GR0RgSpIkpWjjzz//un35EgHLKTPH3PadeSkKluEteUTOOTymWspF3ZgFdJqZREDKJc3JtCibYR7M3Prw8JRySnlOVdXeBwuamokhwuPjI3QDj1ILmDGzeuRSaq2v12sN8JbHziNKzu4OSCFsw1RNRJDYAEqpKaXFogekQCJOJOgRJOIRauYBOvXn+/u2bYLYx3Sbc/bVCQDAksO01r5+/fp6PVNK7kZCvY/n60ECKYtIISFVP8729uXr7X4bYzLL979+JpEAZ8Y+dDp4UNkupnEOLbmqQxEulYcqimibKRckTsxfvnwdvY/jJCSRjIRm6gAOPLXdLpd2nul6DXUFtD5FkhOZWU6JEEvdiNmRh1qt+9QZAbfbHRz2y6X3rmpzzm3bzrOJpJQkArXPiEi5SEp2xuhDWh8e0MZgSdH5y9cvM3zMaWMCIQIuhae5jTErJTdT1VpymNlUIvKpP96fUmrKVdXONswjl23lk+dciVgkmTkSKzKzmCsu5qB72TKxRDgxh+McUyQH4uidCcMDEJOIjXmeJxHLVh+Pn7XkOQ2R3MHdmIU5IaJZpFSYhYi2und0OIA5MTMxlLox8/M4icUjnseZc2ljPo9DdRDD1J5zgghG7taFmEs5XmfYvFwvaNi6vp6tbBWA5wxHrttF20JrCKZlxuVceYyRSv14PIk51ZqhttYCYvTOLJxLREhKgBwwr7d7qRU6msX1elfTUisgqJn5k1PqrdctsQgAyOLesiyoLLP8L4S47qLEeCHYAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<PIL.Image.Image image mode=RGB size=151x192 at 0x7FAD7DA5FD10>"
+       "<PIL.Image.Image image mode=RGB size=151x192 at 0x7FB714B9C9D0>"
       ]
      },
-     "execution_count": 4,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -705,20 +705,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So, how do we know if this model is any good? You can see the error rate (proportion of images that were incorrectly identified) printed as the last column of the table. As you can see, the model is nearly perfect, even though the training time was only a few seconds (not including the one-time downloading of the dataset and pretrained model). In fact, the accuracy you've achieved already is far better than anybody had ever achieved just 10 years ago!\n",
+    "So, how do we know if this model is any good? You can see the error rate (proportion of images that were incorrectly identified) printed as the second last column of the table. As you can see, the model is nearly perfect, even although the training time was only a few seconds (not including the one-time downloading of the dataset and pretrained model). In fact, the accuracy you've achieved already is far better than anybody had ever achieved just 10 years ago!\n",
     "\n",
     "Finally, let's check that this model actually works. Go and get a photo of a dog, or a cat; if you don't have one handy, just search Google images and download an image that you find there. Now execute the cell with `uploader` defined. It will output a button you can click, so you can select the image you want to classify."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "396649734fe5456893208bc29eb1d8db",
+       "model_id": "22613e22f0c9475cb9696273da3c3d60",
        "version_major": 2,
        "version_minor": 0
       },
@@ -782,7 +782,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Is this a cat?: True; Probability it's a cat: 0.999060\n"
+      "Is this a cat?: True; Probability it's a cat: 0.999992\n"
      ]
     }
    ],
@@ -821,7 +821,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "hide_input": true
+    "hide_input": false
    },
    "outputs": [
     {
@@ -875,7 +875,7 @@
        "</svg>\n"
       ],
       "text/plain": [
-       "<graphviz.files.Source at 0x7f3e2d1e5fd0>"
+       "<graphviz.files.Source at 0x7fb712ad6310>"
       ]
      },
      "execution_count": null,
@@ -926,7 +926,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To understand this statement, we need to understand what Samuel means by a *weight assignment*. To do so, we need to change our basic program model diagram above, and replace it with something like this (where *inputs* might be the pixels of a photo, and *results* might be the word \"dog\" or \"cat\"):"
+    "To understand this statement, we need to understand what Samuel means by a *weight assignment*. To do so, we need to change our basic program model of <<basic_program>>, and replace it with something like <<weight_assignment>> (where *inputs* might be the pixels of a photo, and *results* might be the word \"dog\" or \"cat\"):"
    ]
   },
   {
@@ -999,7 +999,7 @@
        "</svg>\n"
       ],
       "text/plain": [
-       "<graphviz.files.Source at 0x7f3e2d1e5c10>"
+       "<graphviz.files.Source at 0x7fb71350edd0>"
       ]
      },
      "execution_count": null,
@@ -1009,6 +1009,8 @@
    ],
    "source": [
     "#hide_input\n",
+    "#caption A program using weight assignment\n",
+    "#id weight_assignment\n",
     "gv('''model[shape=box3d width=1 height=0.7]\n",
     "inputs->model->results; weights->model''')"
    ]
@@ -1023,7 +1025,7 @@
     "\n",
     "Finally, he says we need *a mechanism for altering the weight assignment so as to maximize the performance*. For instance, he could look at the difference in weights between the winning model and the losing model, and adjust the weights a little further in the winning *direction*. We can now see why he said that such a procedure *could be made entirely automatic and... a machine so programmed would \"learn\" from its experience*.\n",
     "\n",
-    "Here is the full picture of Samuel's idea of training a machine learning model:"
+    "<<training_loop>> shows the full picture of Samuel's idea of training a machine learning model."
    ]
   },
   {
@@ -1141,7 +1143,7 @@
     "For instance, the *results* for a checkers model are the moves that are made, and the *performance*\n",
     "is the win or loss (possibly also including the number of moves the game lasted).\n",
     "\n",
-    "Note that once the model is trained, we can think of the weights as being *part of the model*, since we're not varying them any more. Therefore actually *using* a model after it's trained looks like this:"
+    "Note that once the model is trained, we can think of the weights as being *part of the model*, since we're not varying them any more. Therefore actually *using* a model after it's trained looks like <<using_model>>."
    ]
   },
   {
@@ -1202,7 +1204,7 @@
        "</svg>\n"
       ],
       "text/plain": [
-       "<graphviz.files.Source at 0x7f3ecc428210>"
+       "<graphviz.files.Source at 0x7fb712ade110>"
       ]
      },
      "execution_count": null,
@@ -1212,6 +1214,8 @@
    ],
    "source": [
     "#hide_input\n",
+    "#caption Using a trained model as a program\n",
+    "#id using_model\n",
     "gv('''model[shape=box3d width=1 height=0.7]\n",
     "inputs->model->results''')"
    ]
@@ -1279,7 +1283,7 @@
     "- The measure of *performance* is called the *loss* (or *cost* or *error*);\n",
     "- The loss depends not only on the predictions, but also the correct *labels* (or *targets*), e.g. \"dog\" or \"cat\".\n",
     "\n",
-    "After making these changes, our diagram in <<training_loop>> looks like this:"
+    "After making these changes, our diagram in <<training_loop>> looks like <<detailed_loop>>."
    ]
   },
   {
@@ -1393,6 +1397,8 @@
    ],
    "source": [
     "#hide_input\n",
+    "#caption Detailed training loop\n",
+    "#id detailed_loop\n",
     "gv('''ordering=in\n",
     "model[shape=box3d width=1 height=0.7 label=architecture]\n",
     "inputs->model->predictions; parameters->model; labels->loss; predictions->loss\n",
@@ -1406,7 +1412,7 @@
     "We can now see some critically important things about training a deep learning model:\n",
     "\n",
     "- A model can not be created without data;\n",
-    "- A model model can only learn to operate on the patterns seen in the input data used to train it;\n",
+    "- A model can only learn to operate on the patterns seen in the input data used to train it;\n",
     "- This learning approach only creates *predictions*, not recommended *actions*;\n",
     "- It's not enough to just have examples of input data; we need *labels* for that data too (e.g. pictures of dogs and cats aren't enough to train a model; we need a label for each one, saying which ones are dogs, and which are cats).\n",
     "\n",
@@ -1440,7 +1446,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### What our image recognizer did"
+    "### How our image recognizer works"
    ]
   },
   {
@@ -1492,15 +1498,13 @@
     "    label_func=is_cat, item_tfms=Resize(224))\n",
     "```\n",
     "\n",
-    "The third line tells fastai what kind of dataset we have, and how it is structured. There are various different classes for different kinds of deep learning dataset and problem--here we're using `ImageDataLoaders`. The first part of the class name will generally be the type of data you have, such as image, or text. The second part will generally be the type of problem you are solving, such as classification, or regression.\n",
+    "The fourth line tells fastai what kind of dataset we have, and how it is structured. There are various different classes for different kinds of deep learning dataset and problem--here we're using `ImageDataLoaders`. The first part of the class name will generally be the type of data you have, such as image, or text. The second part will generally be the type of problem you are solving, such as classification, or regression.\n",
     "\n",
-    "The other important piece of information that we have to tell fastai is how to get the labels from the dataset. Computer vision datasets are normally structured in such a way that the label for an image is part of the file name, or path, most commonly the parent folder name. Fastai comes with a number of standardized labelling methods, and ways to write your own. Here we define a function `is_cat` which labels cats based on a filename rule provided by the dataset creators.\n",
-    "\n",
-    "TK Sylvain. Check conversion here, there is a problem with formatting\n",
+    "The other important piece of information that we have to tell fastai is how to get the labels from the dataset. Computer vision datasets are normally structured in such a way that the label for an image is part of the file name, or path, most commonly the parent folder name. Fastai comes with a number of standardized labelling methods, and ways to write your own. Here we define a function on the third line: `is_cat` which labels cats based on a filename rule provided by the dataset creators.\n",
     "\n",
     "Finally, we define the `Transform`s that we need. A `Transform` contains code that is applied automatically during training; fastai includes many pre-defined `Transform`s, and adding new ones is as simple as creating a Python function. There are two kinds: `item_tfms` are applied to each item (in this case, each item is resized to a 224 pixel square); `batch_tfms` are applied to a *batch* of items at a time using the GPU, so they're particularly fast (we'll see many examples of these throughout this book).\n",
     "\n",
-    "Why 224 pixels? This is the standard size for historical reasons (old pretrained models require this size exactly), but you can pass pretty much anything. If you increase the size, you'll often get a model with better results (since it will be able to focus on more details) but at the price of speed and memory consumption; or visa versa if you decrease the size. "
+    "Why 224 pixels? This is the standard size for historical reasons (old pretrained models require this size exactly), but you can pass pretty much anything. If you increase the size, you'll often get a model with better results (since it will be able to focus on more details) but at the price of speed and memory consumption; or vice versa if you decrease the size. "
    ]
   },
   {
@@ -1522,21 +1526,21 @@
     "\n",
     "Even when your model has not fully memorized all your data, earlier on in training it may have memorized certain parts of it. As a result, the longer you train for, the better your accuracy will get on the training set; and the validation set accuracy will also improve for a while, but eventually it will start getting worse, as the model starts to memorize the training set, rather than finding generalizable underlying patterns in the data. When this happens, we say that the model is *over-fitting*.\n",
     "\n",
-    "Here's an example of what happens when you overfit, using a simplified example where we have just one parameter, and some randomly generated data based on the function `x**2`; as you see, although the predictions in the overfit model are accurate for data near the observed data, they are way off when outside of that range:"
+    "<<img_overfit>> shows what happens when you overfit, using a simplified example where we have just one parameter, and some randomly generated data based on the function `x**2`; as you see, although the predictions in the overfit model are accurate for data near the observed data, they are way off when outside of that range."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"images/att_00000.png\" alt=\"Example of overfitting\" title=\"Example of overfitting\" width=\"700\">"
+    "<img src=\"images/att_00000.png\" alt=\"Example of overfitting\" caption=\"Example of overfitting\" id=\"img_overfit\" width=\"700\">"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Overfitting is the singe most important and challenging issue** when training for all machine learning practitioners, and all algorithms. As we will see, it is very easy to create a model that does a great job at making predictions on the exact data which it has been trained on, but it is much harder to make predictions on data that it has never seen before. And of course this is the data that will actually matter in practice. For instance, if you create a hand-written digit classifier (as we will very soon!) and use it to recognise numbers written on cheques, then you are never going to see any of the numbers that the model was trained on -- every cheque will have slightly different variations of writing to deal with. We will learn many methods to avoid overfitting in this book. However, you should only use those methods after you have confirmed that overfitting is actually occurring (i.e. you have actually observed the validation accuracy getting worse during training). We often see practitioners using over-fitting avoidance techniques even when they have enough data that they didn't need to do so, ending up with a model that could be less accurate than what they could have gotten."
+    "**Overfitting is the single most important and challenging issue** when training for all machine learning practitioners, and all algorithms. As we will see, it is very easy to create a model that does a great job at making predictions on the exact data which it has been trained on, but it is much harder to make predictions on data that it has never seen before. And of course this is the data that will actually matter in practice. For instance, if you create a hand-written digit classifier (as we will very soon!) and use it to recognise numbers written on cheques, then you are never going to see any of the numbers that the model was trained on -- every cheque will have slightly different variations of writing to deal with. We will learn many methods to avoid overfitting in this book. However, you should only use those methods after you have confirmed that overfitting is actually occurring (i.e. you have actually observed the validation accuracy getting worse during training). We often see practitioners using over-fitting avoidance techniques even when they have enough data that they didn't need to do so, ending up with a model that could be less accurate than what they could have achieved."
    ]
   },
   {
@@ -1554,7 +1558,7 @@
     "learn = cnn_learner(dls, resnet34, metrics=error_rate)\n",
     "```\n",
     "\n",
-    "The fourth line tells fastai to create a *convolutional neural network* (CNN), and selects what *architecture* to use (i.e. what kind of model to create), what data we want to train it on, and what *metric* to use. A CNN is the current state of the art approach to creating computer vision models. We'll be learning all about how they work in this book. Their structure is inspired by how the human vision system works.\n",
+    "The fifth line tells fastai to create a *convolutional neural network* (CNN), and selects what *architecture* to use (i.e. what kind of model to create), what data we want to train it on, and what *metric* to use. A CNN is the current state of the art approach to creating computer vision models. We'll be learning all about how they work in this book. Their structure is inspired by how the human vision system works.\n",
     "\n",
     "There are many different architectures in fastai, which we will be learning about in this book, as well as discussing how to create your own. Most of the time, however, picking an architecture isn't a very important part of the deep learning process. It's something that academics love to talk about, but in practice it is unlikely to be something you need to spend much time on. There are some standard architectures that work most of the time, and in this case we're using one called _ResNet_ that we'll be learning a lot about during the book; it is both fast and accurate for many datasets and problems. The \"34\" in `resnet34` refers to the number of layers in this variant of the architecture (other options are \"18\", \"50\", \"101\", and \"152\"). Models using architectures with more layers take longer to train, and are more prone to overfitting (i.e. you can't train them for as many epochs before the accuracy on the validation set starts getting worse). On the other hand, when using more data, they can be quite a bit more accurate.\n",
     "\n",
@@ -1580,7 +1584,7 @@
     "learn.fine_tune(1)\n",
     "```\n",
     "\n",
-    "The fifth line tells fastai how to *fit* the model. As we've discussed, the architecture only describes a *template* for a mathematical function; but it doesn't actually do anything until we provide values for the millions of parameters it contains.\n",
+    "The sixth line tells fastai how to *fit* the model. As we've discussed, the architecture only describes a *template* for a mathematical function; but it doesn't actually do anything until we provide values for the millions of parameters it contains.\n",
     "\n",
     "This is the key to deep learning — how to fit the parameters of a model to get it to solve your problem. In order to fit a model, we have to provide at least one piece of information: how many times to look at each image (known as number of *epochs*). The number of epochs you select will largely depend on how much time you have available, and how long you find it takes in practice to fit your model. If you select a number that is too small, you can always train for more epochs later.\n",
     "\n",
@@ -1619,46 +1623,58 @@
    "source": [
     "At this stage we have an image recogniser that is working very well, but we have no idea what it is actually doing! Although many people complain that deep learning results in impenetrable \"black box\" models (that is, something that gives predictions but that no one can understand), this really couldn't be further from the truth. There is a vast body of research showing how to deeply inspect deep learning models, and get rich insights from them.\n",
     "\n",
-    "In 2013 a PhD student, Matt Zeiler, and his supervisor, Rob Fergus, published the paper [Visualizing and Understanding Convolutional Networks](https://arxiv.org/pdf/1311.2901.pdf), which showed how to visualise the neural network weights learned in each layer of a model. They carefully analysed the model that won the 2012 ImageNet competition, and used this analysis to greatly improve the model, such that they were able to go on to win the 2013 competition! Here is the picture that they published of the first two layers' weights:"
+    "In 2013 a PhD student, Matt Zeiler, and his supervisor, Rob Fergus, published the paper [Visualizing and Understanding Convolutional Networks](https://arxiv.org/pdf/1311.2901.pdf), which showed how to visualise the neural network weights learned in each layer of a model. They carefully analysed the model that won the 2012 ImageNet competition, and used this analysis to greatly improve the model, such that they were able to go on to win the 2013 competition! <<img_layer1>> is the picture that they published of the first layers' weights."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"images/chapter2_layer1and2.PNG\" alt=\"Activations of early layers of a CNN\" width=\"800\">"
+    "<img src=\"images/layer1.png\" alt=\"Activations of early layers of a CNN\" width=\"300\" caption=\"Activations of early layers of a CNN\" id=\"img_layer1\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This picture requires some explanation. For each layer, the image part with the light grey background shows the reconstructed weights pictures, and the other section shows the parts of the training images which most strongly matched each set of weights. For layer 1, what we can see is that the model has discovered weights which represent diagonal, horizontal, and vertical edges, as well as various different gradients. (Note that for each layer only a subset of the features are shown; in practice there are thousands across all of the layers.) These are the basic building blocks that it has created automatically for computer vision. They have been widely analysed by neuroscientists and computer vision researchers, and it turns out that these learned building blocks are very similar to the basic visual machinery in the human eye, as well as the handcrafted computer vision features that were developed prior to the days of deep learning. The next layer is represented in <<img_layer2>>."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"images/layer2.png\" alt=\"Activations of early layers of a CNN\" width=\"800\" caption=\"Activations of early layers of a CNN\" id=\"img_layer2\">"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This picture requires some explanation. For each layer, the image part with the light grey background shows the reconstructed weights pictures, and the other section shows the parts of the training images which most strongly matched each set of weights. For layer 1, what we can see is that the model has discovered weights which represent diagonal, horizontal, and vertical edges, as well as various different gradients. (Note that for each layer only a subset of the features are shown; in practice there are thousands across all of the layers.) These are the basic building blocks that it has created automatically for computer vision. They have been widely analysed by neuroscientists and computer vision researchers, and it turns out that these learned building blocks are very similar to the basic visual machinery in the human eye, as well as the handcrafted computer vision features that were developed prior to the days of deep learning.\n",
-    "\n",
     "For layer 2, there are nine examples of weight reconstructions for each of the features found by the model. We can see that the model has learned to create feature detectors that look for corners, repeating lines, circles, and other simple patterns. These are built from the basic building blocks developed in the first layer. For each of these, the right-hand side of the picture shows small patches from actual images which these features most closely match. For instance, the particular pattern in row 2 column 1 matches the gradients and textures associated with sunsets.\n",
     "\n",
-    "Here is the image from the paper showing the results of reconstructing the features of layer 3:"
+    "<<img_layer3>> shows the image from the paper showing the results of reconstructing the features of layer 3."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"images/chapter2_layer3.PNG\" alt=\"Activations of medium layers of a CNN\" width=\"650\">"
+    "<img src=\"images/chapter2_layer3.PNG\" alt=\"Activations of medium layers of a CNN\" width=\"800\" caption=\"Activations of medium layers of a CNN\" id=\"img_layer3\">"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you can see by looking at the right-hand side of this picture, the features are now able to identify and match with higher levels' semantic components, such as car wheels, text, and flower petals. Using these components layers four and five can identify even higher-level concepts:"
+    "As you can see by looking at the right-hand side of this picture, the features are now able to identify and match with higher levels semantic components, such as car wheels, text, and flower petals. Using these components, layers four and five can identify even higher-level concepts, as shown in <<img_layer4>>."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"images/chapter2_layer4and5.PNG\" alt=\"Activations of end layers of a CNN\" width=\"650\">"
+    "<img src=\"images/chapter2_layer4and5.PNG\" alt=\"Activations of end layers of a CNN\" width=\"800\" caption=\"Activations of end layers of a CNN\" id=\"img_layer4\">"
    ]
   },
   {
@@ -1683,14 +1699,14 @@
    "source": [
     "An image recogniser can, as its name suggests, only recognise images. But a lot of things can be represented as images, which means that an image recogniser can learn to complete many tasks.\n",
     "\n",
-    "For instance, a sound can be converted to a spectrogram, which is a chart that shows the amount of each frequency at each time in an audio file. Fast.ai student Ethan Sutin used this approach to easily beat the published accuracy on [environmental sound detection](https://medium.com/@etown/great-results-on-audio-classification-with-fastai-library-ccaf906c5f52) using a dataset of 8732 urban sounds. fastai's `show_batch` clearly shows how each different sound has a quite distinctive spectrogram:"
+    "For instance, a sound can be converted to a spectrogram, which is a chart that shows the amount of each frequency at each time in an audio file. Fast.ai student Ethan Sutin used this approach to easily beat the published accuracy on [environmental sound detection](https://medium.com/@etown/great-results-on-audio-classification-with-fastai-library-ccaf906c5f52) using a dataset of 8732 urban sounds. fastai's `show_batch` clearly shows how each different sound has a quite distinctive spectrogram, as you can see in <<img_spect>>."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img alt=\"show_batch with spectrograms of sounds\" width=\"400\" caption=\"show_batch with spectrograms of sounds\" id=\"spect\" src=\"images/att_00012.png\">"
+    "<img alt=\"show_batch with spectrograms of sounds\" width=\"400\" caption=\"show_batch with spectrograms of sounds\" id=\"img_spect\" src=\"images/att_00012.png\">"
    ]
   },
   {
@@ -1725,7 +1741,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Another example comes from the paper [Malware Classification with Deep Convolutional Neural Networks](https://ieeexplore.ieee.org/abstract/document/8328749) which explains that \"the malware binary file is divided into 8-bit sequences which are then converted to equivalent decimal values. This decimal vector is reshaped and gray-scale image is generated that represent the malware sample\", like in <<malware_proc>>"
+    "Another examples comes from the paper [Malware Classification with Deep Convolutional Neural Networks](https://ieeexplore.ieee.org/abstract/document/8328749) which explains that \"the malware binary file is divided into 8-bit sequences which are then converted to equivalent decimal values. This decimal vector is reshaped and gray-scale image is generated that represent the malware sample\", like in <<malware_proc>>."
    ]
   },
   {
@@ -1769,7 +1785,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We have introduced quite a few new terms, <<jargon>> contains a handy recap of most of them.\n",
+    "We just covered a lot of information so let's recap breifly. <<dljargon>> provides a handy list.\n",
     "\n",
     "```asciidoc\n",
     "[[dljargon]]\n",
@@ -2105,7 +2121,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This model is using the the IMDb dataset from the paper [Learning Word Vectors for Sentiment Analysis]((http://ai.stanford.edu/~amaas/data/sentiment/)). It works well with movie reviews of many thousands of words. But let's test it out on a very short one, to see it do its thing:"
+    "This model is using the IMDb dataset from the paper [Learning Word Vectors for Sentiment Analysis]((https://ai.stanford.edu/~amaas/data/sentiment/)). It works well with movie reviews of many thousands of words. But let's test it out on a very short one, to see it do its thing:"
    ]
   },
   {
@@ -2168,11 +2184,11 @@
     "learn.fine_tune(4, 1e-2)\n",
     "```\n",
     "\n",
-    "The outputs themselves can be deceiving: they have the results of the last time the cell was executed, but if you change the code inside a cell without executing it, you will keep them.\n",
+    "The outputs themselves can be deceiving: they have the results of the last time the cell was executed, but if you change the code inside a cell without executing it, the old (misleading) results will remain.\n",
     "\n",
     "Except when we mention it explicitly, the notebooks provided on the book website are meant to be run in order, from top to bottom. In general, when experimenting, you will find yourself executing cells in any order to go fast (which is a super neat feature of Jupyter Notebooks) but once you have explored and arrive at the final version of your code, make sure you can run the cells of your notebooks in order (your future self won't necessarily remember the convoluted path you took otherwise!). \n",
     "\n",
-    "In edit mode, pressing `0` twice will restart the *kernel* (which is the engine powering your notebook). This will wipe your state clean and make it as if you had just started in the notebook. Click on the \"Cell\" menu and then on \"Run All Above\" to run all cells above the point where you are. We have found this to be very useful when developing the fastai library."
+    "In command mode, pressing `0` twice will restart the *kernel* (which is the engine powering your notebook). This will wipe your state clean and make it as if you had just started in the notebook. Click on the \"Cell\" menu and then on \"Run All Above\" to run all cells above the point where you are. We have found this to be very useful when developing the fastai library."
    ]
   },
   {
@@ -2723,7 +2739,7 @@
     "\n",
     "One case might be if you are looking at time series data. For a time series, choosing a random subset of the data will be both too easy (you can look at the data both before and after the dates your are trying to predict) and not representative of most business use cases (where you are using historical data to build a model for use in the future). If your data includes the date and you are building a model to use in the future, you will want to choose a continuous section with the latest dates as your validation set (for instance, the last two weeks or last month of the available data).\n",
     "\n",
-    "Suppose you want to split the time series data in <<timeseries1>> into training and validation sets:"
+    "Suppose you want to split the time series data in <<timeseries1>> into training and validation sets."
    ]
   },
   {
@@ -2737,7 +2753,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "A random subset is a poor choice (too easy to fill in the gaps, and not indicative of what you'll need in production), as we can see in <<timeseries2>>"
+    "A random subset is a poor choice (too easy to fill in the gaps, and not indicative of what you'll need in production), as we can see in <<timeseries2>>."
    ]
   },
   {
@@ -2765,7 +2781,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For example, Kaggle had a competition to [predict the sales in a chain of Ecuadorian grocery stores](https://www.kaggle.com/c/favorita-grocery-sales-forecasting). Kaggle's *training data* ran from Jan 1 2013 to Aug 15 2017 and the test data spanned Aug 16 2017 to Aug 31 2017. That way, the competition organizer ensured that entrants were making predictions for a time period that was *in the future*, from the perspective of their model. This is similar to the way quant hedge fund traders do *back-testing* to check whether their models are predictive of future periods, based on passed data."
+    "For example, Kaggle had a competition to [predict the sales in a chain of Ecuadorian grocery stores](https://www.kaggle.com/c/favorita-grocery-sales-forecasting). Kaggle's *training data* ran from Jan 1 2013 to Aug 15 2017 and the test data spanned Aug 16 2017 to Aug 31 2017. That way, the competition organizer ensured that entrants were making predictions for a time period that was *in the future*, from the perspective of their model. This is similar to the way quant hedge fund traders do *back-testing* to check whether their models are predictive of future periods, based on past data."
    ]
   },
   {
@@ -2774,21 +2790,14 @@
    "source": [
     "After time series, a second common case is when you can easily anticipate ways the data you will be making predictions for in production may be *qualitatively different* from the data you have to train your model with.\n",
     "\n",
-    "In the Kaggle [distracted driver competition](https://www.kaggle.com/c/state-farm-distracted-driver-detection), the independent data are pictures of drivers at the wheel of a car, and the dependent variable is a category such as texting, eating, or safely looking ahead.  If you were the insurance company building a model from this data, note that you would be most interested in how the model performs on drivers you haven't seen before (since you would likely have training data only for a small group of people).  This is true of the Kaggle competition as well: the test data consists of people that weren't used in the training set."
+    "In the Kaggle [distracted driver competition](https://www.kaggle.com/c/state-farm-distracted-driver-detection), the independent data are pictures of drivers at the wheel of a car, and the dependent variable is a category such as texting, eating, or safely looking ahead. Lots of pictures were of the same drivers in different positions, as we can see in <<imng_driver>>. If you were the insurance company building a model from this data, note that you would be most interested in how the model performs on drivers you haven't seen before (since you would likely have training data only for a small group of people). This is true of the Kaggle competition as well: the test data consists of people that weren't used in the training set."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img src=\"images/driver_phone.png\" width=\"300\" id=\"driver1\" caption=\"Picture of a driver\" alt=\"A picture of a driver\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<img src=\"images/driver_phone2.png\" width=\"300\" id=\"driver2\" caption=\"Picture of the same driver should be in the same subset\" alt=\"A picture of the same driver\">"
+    "<img src=\"images/driver.PNG\" width=\"600\" id=\"img_driver\" caption=\"Two pictures from the training data\" alt=\"Two pictures from the training data, showing the same driver\">"
    ]
   },
   {
@@ -2941,5 +2950,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/02_production.ipynb b/02_production.ipynb
index 0237d68..74790ed 100644
--- a/02_production.ipynb
+++ b/02_production.ipynb
@@ -29,25 +29,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The five lines of code we've seen in <<chaptter_intro>> are just one small part of the process of using deep learning in practice. In this chapter, we're going to use a computer vision example to look at the end-to-end process of creating a deep learning application. More specifically: we're going to build a bear classifier! In the process, we'll discuss the capabilities and constraints of deep learning, learn about how to create datasets, look at possible gotchas when using deep learning in practice, and more. Let's start with how you should frame your problem.\n",
+    "The five lines of code we saw in <<chaptter_intro>> are just one small part of the process of using deep learning in practice. In this chapter, we're going to use a computer vision example to look at the end-to-end process of creating a deep learning application. More specifically: we're going to build a bear classifier! In the process, we'll discuss the capabilities and constraints of deep learning, learn about how to create datasets, look at possible gotchas when using deep learning in practice, and more. Many of the key points will apply equally well to other deep learning problems, such as we showed in <<chaptter_intro>>. If you work through a problem similar in key respects to our example problems, we expect you to get excellent results with little code, quickly.\n",
     "\n",
-    "TK: the next section title seems a bit inadequate, let's double check"
+    "Let's start with how you should frame your problem."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Picking a problem"
+    "## The practice of deep learning"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We've seen that deep learning can solve a lot of challenging problems quickly and with little code. However, deep learning isn't magic! We often talk to people who overestimate both the constraints, and the capabilities of deep learning. Both of these can be problems: underestimating the capabilities means that you might not even try things which could be very beneficial; underestimating the constraints might mean that you fail to consider and react to important issues.\n",
+    "We've seen that deep learning can solve a lot of challenging problems quickly and with little code. As a beginner there's a sweet spot of problems that are similar enough to our example problems that you can very quickly get extremely useful results. However, deep learning isn't magic! The same 5 lines of code won't work on every problem anyone can think of today. Underestimating the constraints and overestimating the capabilities of deep learning may lead to frustratingly poor results. At least until you gain some experience to solve the problems that arise. Overestimating the constraints and underestimating the capabilities of deep learning may mean you do not attempt a solvable problem because you talk yourself out of it. \n",
     "\n",
-    "The best thing to do is to keep an open mind. If you remain open to the possibility that deep learning might solve part of your problem with less data or complexity than you expect, then it is possible to design a process where you can find the specific capabilities and constraints related to your particular problem as you work through the process. This doesn't mean making any risky bets — we will show you how you can gradually roll out models so that they don't create significant risks, and can even backtest them prior to putting them in production."
+    "We often talk to people who overestimate both the constraints, and the capabilities of deep learning. Both of these can be problems: underestimating the capabilities means that you might not even try things which could be very beneficial; underestimating the constraints might mean that you fail to consider and react to important issues.\n",
+    "\n",
+    "The best thing to do is to keep an open mind. If you remain open to the possibility that deep learning might solve part of your problem with less data or complexity than you expect, then it is possible to design a process where you can find the specific capabilities and constraints related to your particular problem as you work through the process. This doesn't mean making any risky bets — we will show you how you can gradually roll out models so that they don't create significant risks, and can even backtest them prior to putting them in production.\n",
+    "\n",
+    "Let's start with how you should frame your problem."
    ]
   },
   {
@@ -103,7 +107,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First things first, let's make sure that deep learning cn be any good at the problem you are considering. In general, here is a summary of the state of deep learning is at the start of 2020. However, things move very fast, and by the time you read this some of these constraints may no longer exist. We will try to keep the book website up-to-date; in addition, a Google search for \"what can AI do now\" there is likely to provide some up-to-date information."
+    "Let's start by considering whether deep learning can be any good at the problem you are looking to work on. In general, here is a summary of the state of deep learning is at the start of 2020. However, things move very fast, and by the time you read this some of these constraints may no longer exist. We will try to keep the book website up-to-date; in addition, a Google search for \"what can AI do now\" there is likely to provide some up-to-date information."
    ]
   },
   {
@@ -117,9 +121,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There are many domains in which deep learning has not been used to analyse images yet, but those where it has been tried have nearly universally shown that computers can recognise what items are in an image at least as well as people can — even specially trained people, such as radiologists. This is known as *object recognition*. Deep learning is also good at recognizing whereabouts objects in an image are, and can highlight their location and name each found object. This is known as *object detection* (there is also a variant of this we saw in <<chapter_intro>>, where every pixel is categorized based on what kind of object it is part of--this is called *segmentation*). Deep learning algorithms are generally not good at recognizing images that are significantly different in structure or style to those used to train the model. For instance, if there were no black-and-white images in the training data, the model may well do poorly on black-and-white images. If the training data did not contain hand-drawn images then the model will probably do poorly on hand-drawn images. There is no general way to check what types of image are missing in your training set, but we will show in this chapter some ways to try to recognize when unexpected image types arise in the data when the model is being used in production (this is known as checking for *out of domain* data).\n",
+    "There are many domains in which deep learning has not been used to analyse images yet, but those where it has been tried have nearly universally shown that computers can recognise what items are in an image at least as well as people can — even specially trained people, such as radiologists. This is known as *object recognition*. Deep learning is also good at recognizing whereabouts objects in an image are, and can highlight their location and name each found object. This is known as *object detection* (there is also a variant of this we saw in <<chapter_intro>>, where every pixel is categorized based on what kind of object it is part of--this is called *segmentation*). Deep learning algorithms are generally not good at recognizing images that are significantly different in structure or style to those used to train the model. For instance, if there were no black-and-white images in the training data, the model may do poorly on black-and-white images. If the training data did not contain hand-drawn images then the model will probably do poorly on hand-drawn images. There is no general way to check what types of image are missing in your training set, but we will show in this chapter some ways to try to recognize when unexpected image types arise in the data when the model is being used in production (this is known as checking for *out of domain* data). TK previous chapter showed a parabola overfitting. possibly a good place to show out of domain data outside the sampled parabola?\n",
     "\n",
-    "One major challenge for object detection systems is that image labelling can be slow and expensive. There is a lot of work at the moment going into tools to try to make this labelling faster and more easy, and require less handcrafted labels to train accurate object detection models. One approach which is particularly helpful is to synthetically generate variations of input images, such as by rotating them, or changing their brightness and contrast; this is called *data augmentation* and also works well for text and other types of model. We will be discussing it in detail in this chapter.\n",
+    "One major challenge for object detection systems is that image labelling can be slow and expensive. There is a lot of work at the moment going into tools to try to make this labelling faster and easier, and require less handcrafted labels to train accurate object detection models. One approach which is particularly helpful is to synthetically generate variations of input images, such as by rotating them, or changing their brightness and contrast; this is called *data augmentation* and also works well for text and other types of model. We will be discussing it in detail in this chapter.\n",
     "\n",
     "Another point to consider is that although your problem might not look like a computer vision problem, it might be possible with a little imagination to turn it into one. For instance, if what you are trying to classify is sounds, you might try converting the sounds into images of their acoustic waveforms and then training a model on those images."
    ]
@@ -135,11 +139,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Just like in computer vision, computers are very good at categorising both short and long documents based on categories such as spam, sentiment, author, source website, and so forth. We are not aware of any rigourous work done in this area to compare to human performance, but anecdotally it seems to us that deep learning performance is similar to human performance here. Deep learning is also very good at generating context-appropriate text, such as generating replies to social media posts, and imitating a particular author's style. It is also good at making this content compelling to humans, and has been shown to be even more compelling than human-generated text. However, deep learning is currently not good at generating *correct* responses! We don't currently have a reliable way to, for instance, combine a knowledge base of medical information, along with a deep learning model for generating medically correct natural language responses. This is very dangerous, because it is so easy to create content which appears to a layman to be compelling, but actually is entirely incorrect.\n",
+    "Just like in computer vision, computers are very good at categorising both short and long documents based on categories such as spam, sentiment (e.g. is the review positive or negative), author, source website, and so forth. We are not aware of any rigourous work done in this area to compare to human performance, but anecdotally it seems to us that deep learning performance is similar to human performance here. Deep learning is also very good at generating context-appropriate text, such as generating replies to social media posts, and imitating a particular author's style. It is also good at making this content compelling to humans, and has been shown to be even more compelling than human-generated text. However, deep learning is currently not good at generating *correct* responses! We don't currently have a reliable way to, for instance, combine a knowledge base of medical information, along with a deep learning model for generating medically correct natural language responses. This is very dangerous, because it is so easy to create content which appears to a layman to be compelling, but actually is entirely incorrect.\n",
     "\n",
     "Another concern is that context-appropriate, highly compelling responses on social media can be used at massive scale — thousands of times greater than any troll farm previously seen — to spread disinformation, create unrest, and encourage conflict. As a rule of thumb, text generation will always be technologically a bit ahead of the ability of models to recognize automatically generated text. For instance, it is possible to use a model that can recognize artificially generated content to actually improve the generator that creates that content, until the classification model is no longer able to complete its task.\n",
     "\n",
-    "Despite these issues, deep learning can be used to translate text from one language to another, summarize long documents into something which can be digested more quickly, find all mentions of a concept of interest, and so forth. Unfortunately, the translation or summary could well include completely incorrect information! However, it is already good enough that many people are using the systems — for instance Google's online translation system (and every other online service we are aware of) is based on deep learning."
+    "Despite these issues, deep learning can be used to translate text from one language to another, summarize long documents into something which can be digested more quickly, find all mentions of a concept of interest, and many more. Unfortunately, the translation or summary could well include completely incorrect information! However, it is already good enough that many people are using the systems — for instance Google's online translation system (and every other online service we are aware of) is based on deep learning."
    ]
   },
   {
@@ -155,7 +159,7 @@
    "source": [
     "The ability of deep learning to combine text and images into a single model is, generally, far better than most people intuitively expect. For example, a deep learning model can be trained on input images, and output captions written in English, and can learn to generate surprisingly appropriate captions automatically for new images! But again, we have the same warning that we discussed in the previous section: there is no guarantee that these captions will actually be correct.\n",
     "\n",
-    "Because of this serious issue we generally recommend that deep learning be used not as a entirely automated process, but as part of a process in which the model and a human user interact closely. This can potentially make humans orders of magnitude more productive than they would be with entirely manual methods, and actually result in more accurate processes than using a human alone. For instance, an automatic system can be used to identify potential strokes directly from CT scans, send a high priority alert to have potential/scans looked at quickly. There is only a three-hour window to treat strokes, so this fast feedback loop could save lives. At the same time, however, all scans could continue to be sent to radiologists in the usual way, so there would be no reduction in human input. Other deep learning models could automatically measure items seen on the scan, and insert those measurements into report, warn the radiologist about findings that they may have missed, and tell the radiologist about other cases which might be relevant."
+    "Because of this serious issue we generally recommend that deep learning be used not as an entirely automated process, but as part of a process in which the model and a human user interact closely. This can potentially make humans orders of magnitude more productive than they would be with entirely manual methods, and actually result in more accurate processes than using a human alone. For instance, an automatic system can be used to identify potential strokes directly from CT scans, send a high priority alert to have potential/scans looked at quickly. There is only a three-hour window to treat strokes, so this fast feedback loop could save lives. At the same time, however, all scans could continue to be sent to radiologists in the usual way, so there would be no reduction in human input. Other deep learning models could automatically measure items seen on the scan, and insert those measurements into reports, warning the radiologist about findings that they may have missed, and tell the radiologist about other cases which might be relevant."
    ]
   },
   {
@@ -169,7 +173,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For analysing timeseries and tabular data, deep learning has recently been making great strides. However, deep learning is generally used as part of a ensemble of multiple types of model. If you already have a system that is using random forests or gradient boosting machines (popular tabular modelling tools that we will learn about soon) then switching to, or adding, deep learning may not result in any dramatic improvement. Deep learning does greatly increase the variety of columns that you can include, for example columns containing natural language (e.g. book titles, reviews, etc), and *high cardinality categorical* columns (i.e. something that contains a large number of discrete choices, such as zip code or product id). On the downside, deep learning models generally take longer to train than random forests or gradient boosting machines, although this is changing thanks to libraries such as [RAPIDS](https://rapids.ai/), which provides GPU acceleration for the whole modeling pipeline. We cover the pros and cons of all these methods in detail in <<chapter_tabular>> in this book."
+    "For analysing timeseries and tabular data, deep learning has recently been making great strides. However, deep learning is generally used as part of an ensemble of multiple types of model. If you already have a system that is using random forests or gradient boosting machines (popular tabular modelling tools that we will learn about soon) then switching to, or adding, deep learning may not result in any dramatic improvement. Deep learning does greatly increase the variety of columns that you can include, for example columns containing natural language (e.g. book titles, reviews, etc), and *high cardinality categorical* columns (i.e. something that contains a large number of discrete choices, such as zip code or product id). On the downside, deep learning models generally take longer to train than random forests or gradient boosting machines, although this is changing thanks to libraries such as [RAPIDS](https://rapids.ai/), which provides GPU acceleration for the whole modeling pipeline. We cover the pros and cons of all these methods in detail in <<chapter_tabular>> in this book."
    ]
   },
   {
@@ -256,16 +260,28 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For many types of projects, you may be able to find all the data you need online. The project we'll be completing in this chapter is a *bear detector*. It will discriminate between three types of bear: grizzly, black, and teddy bear. There are many images on the internet of each type of bear we can use. We just need a way to find them and download them. We've provided a tool you can use for this purpose, so you can follow along with this chapter, creating your own image recognition application for whatever kinds of object you're interested in. In the fast.ai course, thousands of students have presented their work on the course forums, displaying everything from Trinidad hummingbird varieties, to Panama bus types, and even an application that helped one student let his fiancee recognize his sixteen cousins during Christmas vacation!"
+    "For many types of projects, you may be able to find all the data you need online. The project we'll be completing in this chapter is a *bear detector*. It will discriminate between three types of bear: grizzly, black, and teddy bear. There are many images on the Internet of each type of bear we can use. We just need a way to find them and download them. We've provided a tool you can use for this purpose, so you can follow along with this chapter, creating your own image recognition application for whatever kinds of object you're interested in. In the fast.ai course, thousands of students have presented their work on the course forums, displaying everything from Trinidad hummingbird varieties, to Panama bus types, and even an application that helped one student let his fiancee recognize his sixteen cousins during Christmas vacation!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To download images, you should sign up at Microsoft for *Bing Image Search*. You will be given a key, which you can either paste over `os.environ('AZURE_SEARCH_KEY')` below, or you can set in your terminal as:\n",
-    "\n",
-    "    export AZURE_SEARCH_KEY=your_key_here"
+    "As at the time of writing, Bing Image Search is the best option we know of for finding and downloading images. It's free for up to 1000 queries per month, and each query can download up to 150 images. However, something better might have come along between when we wrote this and when you're reading the book, so be sure to check out [book.fast.ai](https://book.fast.ai) where we'll let you know our current recommendation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> important: Services that can be used for creating datasets come and go all the time, and their features, interfaces, and pricing change regularly too. In this section, we'll show how to use one particular provider, *Bing Image Search*, using the service they have as this book as written. We'll be providing more options and more up to date information on the [book website](https://book.fast.ai), so be sure to have a look there now to get the most current information on how to download images from the web to create a dataset for deep learning."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To download images with Bing Image Search, you should sign up at Microsoft for *Bing Image Search*. You will be given a key, which you can either paste here, replacing \"XXX\":"
    ]
   },
   {
@@ -274,14 +290,44 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "key = os.environ['AZURE_SEARCH_KEY']"
+    "key = 'XXX'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As at the time of writing, Bing Image Search is the best option we know of for finding and downloading images. It's free for up to 1000 queries per month, and each query can download up to 150 images. However, something better might have come along between when we wrote this and when you're reading the book, so be sure to check out [book.fast.ai](https://book.fast.ai) where we'll let you know our current recommendation."
+    "...or, if you're comfortable at the command line, you can set it in your terminal with:\n",
+    "\n",
+    "    export AZURE_SEARCH_KEY=your_key_here\n",
+    "\n",
+    "and then restart jupyter notebooks, and finally execute in this notebook:\n",
+    "\n",
+    "```python\n",
+    "key = os.environ['AZURE_SEARCH_KEY']\n",
+    "```\n",
+    "\n",
+    "Once you've set `key`, you can use `search_images_bing`. This function is provided by the small `utils` class included in the book. Remember, if you're not sure where a symbol is defined, you can just type it in your notebook to find out (or prefix with `?` to get help, including the name of the file where it's defined, or with `??` to get its source code):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function utils.search_images_bing(key, term, min_sz=128)>"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "search_images_bing"
    ]
   },
   {
@@ -428,7 +474,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Often when we download files from the internet, there's a few that are corrupt. Let's check:"
+    "Often when we download files from the Internet, there are a few that are corrupt. Let's check:"
    ]
   },
   {
@@ -462,6 +508,22 @@
     "failed"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To remove the failed images, we can use `unlink` on each. Note that, like most fastai functions that return a collection, `verify_images` returns an object of type `L`, which includes the `map` method. This calls the passed function on each element of the collection."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "failed.map(Path.unlink);"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -490,7 +552,7 @@
     "```\n",
     "It tells us what argument the function accepts (`fns`) then shows us the source code and the file it comes from. Looking at that source code, we can see it applies the function `verify_image` in parallel and only keep the ones for which the result of that function is `False`, which is consistent with the doc string: it finds the images in `fns` that can't be opened.\n",
     "\n",
-    "Here are the commands that are very useful in jupyter notebooks:\n",
+    "Here are the commands that are very useful in Jupyter notebooks:\n",
     "\n",
     "- at any point, if you don't remember the exact spelling of a function or argument name, you can press \"tab\" to get suggestions of auto-completion.\n",
     "- when inside the parenthesis of a function, pressing \"shift\" and \"tab\" simultaneously will display a window with the signature of the function and a short documentation. Pressing it twice will expand the documentation and pressing it three times will open a full window with the same information at the bottom of your screen.\n",
@@ -507,22 +569,6 @@
     "### End sidebar"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To remove the failed images, we can use `unlink` on each. Note that, like most fastai functions that return a collection, `verify_images` returns an object of type `L`, which includes the `map` method. This calls the passed function on each element of the collection."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "failed.map(Path.unlink);"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -541,7 +587,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So with this as your training data, you would end up not with a healthy skin detector, but a *young white woman touching her face* detector! Be sure to think carefully about the types of data that you might expect to see in practice in your application, and check carefully to ensure that all these types are reflected in your model's source data. (Thanks to Deb Raji, who came up with the *healthy skin* example. See her paper *Actionable Auditing: Investigating the Impact of Publicly Naming Biased Performance Results of Commercial AI Products* for more fascinating insights into model bias.)"
+    "So with this as your training data, you would end up not with a healthy skin detector, but a *young white woman touching her face* detector! Be sure to think carefully about the types of data that you might expect to see in practice in your application, and check carefully to ensure that all these types are reflected in your model's source data.footnote:[Thanks to Deb Raji, who came up with the *healthy skin* example. See her paper *Actionable Auditing: Investigating the Impact of Publicly Naming Biased Performance Results of Commercial AI Products* for more fascinating insights into model bias.]"
    ]
   },
   {
@@ -562,7 +608,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we have downloaded and verified of the data that we want to use, we need to turn it into a `DataLoaders` object. `DataLoaders` is a thin class which just stores whatever `DataLoader` objects you pass to it, and makes them available as `train` and `valid` . Although it's a very simple class, it's very important in fastai: it provides the data for your model. The key functionality in `DataLoaders` is provided with just these 4 lines of code (it has some other minor functionality we'll skip over for now):\n",
+    "Now that we have downloaded and verified the data that we want to use, we need to turn it into a `DataLoaders` object. `DataLoaders` is a thin class which just stores whatever `DataLoader` objects you pass to it, and makes them available as `train` and `valid` . Although it's a very simple class, it's very important in fastai: it provides the data for your model. The key functionality in `DataLoaders` is provided with just these 4 lines of code (it has some other minor functionality we'll skip over for now):\n",
     "\n",
     "```python\n",
     "class DataLoaders(GetAttr):\n",
@@ -646,7 +692,7 @@
     "item_tfms=Resize(128)\n",
     "```\n",
     "\n",
-    "Our images are all different sizes, and this is a problem for deep learning: we don't feed the model one image at a time but several (what we call a *mini-batch*) of them. To group them in a big array (usually called *tensor*) that is going to go through our model, they all need to be of the same size. So we need to add a transform twhich will resize these images to the same size. *item transforms* are pieces of code which run on each individual item, whether it be an image, category, or so forth. fastai includes many predefined transforms; we will use the `Resize` transform here.\n",
+    "Our images are all different sizes, and this is a problem for deep learning: we don't feed the model one image at a time but several (what we call a *mini-batch*) of them. To group them in a big array (usually called *tensor*) that is going to go through our model, they all need to be of the same size. So we need to add a transform which will resize these images to the same size. *item transforms* are pieces of code which run on each individual item, whether it be an image, category, or so forth. fastai includes many predefined transforms; we will use the `Resize` transform here.\n",
     "\n",
     "This command has given us a `DataBlock` object. This is like a *template* for creating a `DataLoaders`. We still need to tell fastai the actual source of our data — in this case, the path where the images can be found."
    ]
@@ -748,7 +794,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "All of these approaches seem somewhat wasteful, or problematic. If we squished or stretch the images then the end up unrealistic shapes, leading to a model that learns that things look different to how they actually are, which we would expect to result in lower accuracy. If we crop the images then we remove some of the features that allow us to recognize them. For instance, if we were trying to recognise the breed of dog or cat, we may end up cropping out a key part of the body or the face necessary to distinguish between similar breeds. If we pad the images then we have a whole lot of empty space, which is just wasted computation for our model, and results in a lower effective resolution for the part of the image we actually use.\n",
+    "All of these approaches seem somewhat wasteful, or problematic. If we squished or stretch the images then they end up unrealistic shapes, leading to a model that learns that things look different to how they actually are, which we would expect to result in lower accuracy. If we crop the images then we remove some of the features that allow us to recognize them. For instance, if we were trying to recognise the breed of dog or cat, we may end up cropping out a key part of the body or the face necessary to distinguish between similar breeds. If we pad the images then we have a whole lot of empty space, which is just wasted computation for our model, and results in a lower effective resolution for the part of the image we actually use.\n",
     "\n",
     "Instead, what we normally do in practice is to randomly select part of the image, and crop to just that part. On each epoch (which is one complete pass through all of our images in the dataset) we randomly select a different part of each image. This means that our model can learn to focus on, and recognize, different features in our images. It also reflects how images work in the real world; different photos of the same thing may be framed in slightly different ways.\n",
     "\n",
@@ -784,7 +830,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> note: The second line in this code is a little bit magic, and you absolutely don't have to understand it at this point. So feel free to ignore the entirety of this paragraph! This is for just if you're curious… Showing different randomly varied versions of the same image is not something we normally have to do in deep learning, so it's not something that fastai provides directly. Therefore to draw the picture of data augmentation on the same image, we had to take advantage of fastai's sophisticated customisation features. DataLoader has a method called `get_idx`, which is called to decide which items should be selected next. Normally when we are training, this returns a random permutation of all of the indexes in the dataset. But pretty much everything in fastai can be changed, including how the `get_idx` method is defined, which means we can change how we sample data. So in this case, we are replacing it with a version which always returns the number one. That way, our DataLoader shows the same image again and again! This is a great example of the flexibility that fastai provides. "
+    "> note: The `…get_idx` assignment in this code is a little bit magic, and you absolutely don't have to understand it at this point. So feel free to ignore the entirety of this paragraph! This is just if you're curious… Showing different randomly varied versions of the same image is not something we normally have to do in deep learning, so it's not something that fastai provides directly. Therefore to draw the picture of data augmentation on the same image, we had to take advantage of fastai's sophisticated customisation features. DataLoader has a method called `get_idx`, which is called to decide which items should be selected next. Normally when we are training, this returns a random permutation of all of the indexes in the dataset. But pretty much everything in fastai can be changed, including how the `get_idx` method is defined, which means we can change how we sample data. So in this case, we are replacing it with a version which always returns the number one. That way, our DataLoader shows the same image again and again! This is a great example of the flexibility that fastai provides. "
    ]
   },
   {
@@ -807,7 +853,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Data augmentation refers to creating random variations of our input data, such that they appear a different, but are not expected to change the meaning of the data. Examples of common data augmentation for images are rotation, flipping, perspective warping, brightness changes, contrast changes, and much more. For natural photo images such as the ones we are using here, there is a standard set of augmentations which we have found work pretty well, and are provided with the get transforms function. Because the images are now all the same size, we can apply these augmentations to an entire batch of them using the GPU, which will save a lot of time. To tell fastai we want to use these transforms to a batch, we use the `batch_tfms` parameter. (Note that's we're not using `RandomResizedCrop` in this example, so you can see the differences more clearly; we're also using double the amount of augmentation compared to the default, for the same reason)."
+    "Data augmentation refers to creating random variations of our input data, such that they appear different, but are not expected to change the meaning of the data. Examples of common data augmentation for images are rotation, flipping, perspective warping, brightness changes, contrast changes, and much more. For natural photo images such as the ones we are using here, there is a standard set of augmentations which we have found work pretty well, and are provided with the get transforms function. Because the images are now all the same size, we can apply these augmentations to an entire batch of them using the GPU, which will save a lot of time. To tell fastai we want to use these transforms to a batch, we use the `batch_tfms` parameter. (Note that's we're not using `RandomResizedCrop` in this example, so you can see the differences more clearly; we're also using double the amount of augmentation compared to the default, for the same reason)."
    ]
   },
   {
@@ -855,7 +901,7 @@
    "source": [
     "Time to use the same lined of codes as in <<chapter_intro>> to train our bear classifier.\n",
     "\n",
-    "We don't have a lot of data for our pblem (150 pictures of each sort of bear at most), so to train our model, we'll use `RandomResizedCrop` and default `aug_transforms` for our model, on an image size of 224px, which is fairly standard for image classification."
+    "We don't have a lot of data for our problem (150 pictures of each sort of bear at most), so to train our model, we'll use `RandomResizedCrop` and default `aug_transforms` for our model, on an image size of 224px, which is fairly standard for image classification."
    ]
   },
   {
@@ -1017,7 +1063,9 @@
    "source": [
     "Each row here represents all the black, grizzly, and teddy bears in our dataset, respectively. Each column represents the images which the model predicted as black, grizzly, and teddy bears, respectively. Therefore, the diagonal of the matrix shows the images which were classified correctly, and the other, off diagonal, cells represent those which were classified incorrectly. This is called a *confusion matrix* and is one of the many ways that fastai allows you to view the results of your model. It is (of course!) calculated using the validation set. With the color coding, the goal is to have white everywhere, except the diagonal where we want dark blue. Our bear classifier isn't making many mistakes!\n",
     "\n",
-    "It's helpful to see where exactly our errors are occuring, to see whether it's due to a dataset problem (e.g. images that aren't bears at all, or are labelled incorrectly, etc), or a model problem (e.g. perhaps it isn't handling images taken with unusual lighting, or from a different angle, etc.) To do this, we can sort out images by their *loss*. The *loss* is a number that is higher if the model is incorrect (and especially if it's also confident of its incorrect answer), or if it's correct, but not confident of its correct answer. (We'll learn how loss is calculated later in the book.) `plot_top_losses` shows us the images with the highest loss in our dataset. As the title of the output says, each image is labeled with four things: prediction, actual (target label), loss, and probability. The *probability* here is the confidence level, from zero to one, that the model has assigned to its prediction."
+    "It's helpful to see where exactly our errors are occuring, to see whether it's due to a dataset problem (e.g. images that aren't bears at all, or are labelled incorrectly, etc), or a model problem (e.g. perhaps it isn't handling images taken with unusual lighting, or from a different angle, etc). To do this, we can sort out images by their *loss*.\n",
+    "\n",
+    "The *loss* is a number that is higher if the model is incorrect (and especially if it's also confident of its incorrect answer), or if it's correct, but not confident of its correct answer. In a couple chapters we'll learn in depth how loss is calculated and used in training process. For now, `plot_top_losses` shows us the images with the highest loss in our dataset. As the title of the output says, each image is labeled with four things: prediction, actual (target label), loss, and probability. The *probability* here is the confidence level, from zero to one, that the model has assigned to its prediction."
    ]
   },
   {
@@ -1103,7 +1151,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img alt=\"Cleaner widget\" width=\"700\" caption=\"Cleaner widget\" id=\"cleaner\" src=\"images/att_00007.png\">"
+    "<img alt=\"Cleaner widget\" width=\"700\" src=\"images/att_00007.png\">"
    ]
   },
   {
@@ -1166,7 +1214,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Once you've got a model you're happy with, you need to save it, so that you can then copy it over to a server where you'll use it in production. Do you remember exactly what a model is? It consists of two parts: the *architecture*, and the trained *parameters*. The easiest way to save a model is to save both of these, because that way when you load a model you can be sure that you have the matching architecture and parameters. To save both parts, use the `export` method.\n",
+    "Once you've got a model you're happy with, you need to save it, so that you can then copy it over to a server where you'll use it in production. Remember that a model consists of two parts: the *architecture*, and the trained *parameters*. The easiest way to save a model is to save both of these, because that way when you load a model you can be sure that you have the matching architecture and parameters. To save both parts, use the `export` method.\n",
     "\n",
     "This method even saves the definition of how to create your `DataLoaders`. This is important, because otherwise you would have to redefine how to transform your data in order to use your model in production. When you call export, fastai will save a file called `export.pkl`."
    ]
@@ -1681,14 +1729,14 @@
     "\n",
     "There is quite a few upsides to this approach. The initial installation is easier, because you only have to deploy a small GUI application, which connects to the server to do all the heavy lifting. More importantly perhaps, upgrades of that core logic can happen on your server, rather than needing to be distributed to all of your users. Your server can have a lot more memory and processing capacity than most edge devices, and it is far easier to scale those resources if your model becomes more demanding. The hardware that you will have on a server is going to be more standard and more easily supported by fastai and PyTorch, so you don't have to compile your model into a different form.\n",
     "\n",
-    "There are downsides too, of course. Your application will require a network connection, and there will be some latency each time the model is called. It takes a while for a neural network model to run anyway, so this additional network latency may not make a big difference to your users in practice. In fact, since you can use better hardware on the server, the overall latency may even be less! If your application uses sensitive data then your users may be concerned about an approach which sends that data to a remote server, so sometimes privacy considerations will mean that you need to run the model on the edge device. Sometimes this can be avoided by having a *on premise* server, such as inside a company's firewall. Managing the complexity and scaling the server can create additional overhead, whereas if your model runs on the edge devices then each user is bringing their own compute resources, which leads to easier scaling with an increasing number of users (also known as _horizontal scaling_)."
+    "There are downsides too, of course. Your application will require a network connection, and there will be some latency each time the model is called. It takes a while for a neural network model to run anyway, so this additional network latency may not make a big difference to your users in practice. In fact, since you can use better hardware on the server, the overall latency may even be less! If your application uses sensitive data then your users may be concerned about an approach which sends that data to a remote server, so sometimes privacy considerations will mean that you need to run the model on the edge device. Sometimes this can be avoided by having an *on premise* server, such as inside a company's firewall. Managing the complexity and scaling the server can create additional overhead, whereas if your model runs on the edge devices then each user is bringing their own compute resources, which leads to easier scaling with an increasing number of users (also known as _horizontal scaling_)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> A: I've had a chance to see up close how the mobile ML landscape is changing in my work. We offer an iPhone app that depends on computer vision and for years we ran our own computer vision models in the cloud. This was the only way to do it then since those models needed significant memory and compute resources and took minutes to process. This approach required building not only the models (fun!) but infrastructure to ensure a certain number of \"compute worker machines\" was absolutely always running (scary), that more machines would automatically come online if traffic increased, that there was stable storage for large inputs and outputs, that the iOS app could know and tell the user how their job was doing, etc... Nowadays, Apple provides APIs for converting models to run efficiently on device and most iOS devices have dedicated ML hardware, so we run our new models on device. So, in a few years that strategy has gone from impossible to possible but it's still not easy. In our case it's worth it, for a faster user experiene and to worry less about servers. What works for you will depend, realistically, on the user experience you're trying to create and what you personally find it easy to do. If you really know how to run servers, do it. If you really know how to build native mobile apps, do that. There are many roads up the hill.\n",
+    "> A: I've had a chance to see up close how the mobile ML landscape is changing in my work. We offer an iPhone app that depends on computer vision and for years we ran our own computer vision models in the cloud. This was the only way to do it then since those models needed significant memory and compute resources and took minutes to process. This approach required building not only the models (fun!) but infrastructure to ensure a certain number of \"compute worker machines\" was absolutely always running (scary), that more machines would automatically come online if traffic increased, that there was stable storage for large inputs and outputs, that the iOS app could know and tell the user how their job was doing, etc... Nowadays, Apple provides APIs for converting models to run efficiently on device and most iOS devices have dedicated ML hardware, so we run our new models on device. So, in a few years that strategy has gone from impossible to possible but it's still not easy. In our case it's worth it, for a faster user experience and to worry less about servers. What works for you will depend, realistically, on the user experience you're trying to create and what you personally find it easy to do. If you really know how to run servers, do it. If you really know how to build native mobile apps, do that. There are many roads up the hill.\n",
     "\n",
     "Overall, we'd recommend using a simple CPU-based server approach where possible, for as long as you can get away with it. If you're lucky enough to have a very successful application, then you'll be able to justify the investment in more complex deployment approaches at that time.\n",
     "\n",
@@ -1706,7 +1754,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In practice, a deep learning model will be just one piece of a much bigger system. As we discussed at the start of this chapter, a *data product* requires thinking about the entire end to end process within which our model lives.\n",
+    "In practice, a deep learning model will be just one piece of a much bigger system. As we discussed at the start of this chapter, a *data product* requires thinking about the entire end to end process within which our model lives. In this book, we can't hope to cover all the complexity of managing deployed data products, such as managing multiple versions of models, A/B testing, canarying, refreshing the data (should we just grow and grow our datasets all the time, or should we regularly remove some of the old data), handling data labelling, monitoring all this, detecting model rot, and so forth. However, there is an excellent book that covers many deployment issues, which is [Building Machine Learning Powered Applications](https://www.amazon.com/Building-Machine-Learning-Powered-Applications/dp/149204511X), by Emmanuel Ameisen. In this section, we will give an overview of some of the most important issues to consider.\n",
     "\n",
     "One of the biggest issues with this is that understanding and testing the behavior of a deep learning model is much more difficult than most code that you would write. With normal software development you can analyse the exact steps that the software is taking, and carefully study with of these steps match the desired behaviour that you are trying to create. But with a neural network the behavior emerges from the models attempt to match the training data, rather than being exactly defined.\n",
     "\n",
@@ -1757,13 +1805,6 @@
     "> j: I started a company 20 years ago called *Optimal Decisions* which used machine learning and optimisation to help giant insurance companies set their pricing, impacting tens of billions of dollars of risks. We used the approaches described above to manage the potential downsides of something that might go wrong. Also, before we worked with our clients to put anything in production, we tried to simulate the impact by testing the end to end system on their previous year's data. It was always quite a nerve-wracking process, putting these new algorithms in production, but every rollout was successful."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As you analyze the results while deploying your model progressively, you should check for the following unexpected behaviors."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1777,20 +1818,13 @@
    "source": [
     "One of the biggest challenges in rolling out a model is that your model may change the behaviour of the system it is a part of. For instance, consider YouTube's recommendation system. A couple of years ago Google talked about how they had introduced reinforcement learning (closely related to deep learning, but where your loss function represents a result which could be a long time after an action occurs) to improve their recommendation system. They described how they used an algorithm which made recommendations such that watch time would be optimised.\n",
     "\n",
-    "However, human beings tend to be drawn towards controversial content. This meant that videos about wings like conspiracy theories started to get recommended more and more by the recommendation system. Furthermore, it turns out that the kinds of people that are interested in conspiracy theories are also people that watch a lot of online videos! So, they started to get drawn more and more towards YouTube. The increasing number of conspiracy theorists watching YouTube resulted in the algorithm recommending more and more conspiracy theories and other extremist content, which resulted in more extremists watching videos on YouTube, and more people watching YouTube developing extremist views, which led to the algorithm recommending more extremist content... The system became so out of control that in February 2019 it led the New York Times to run the headline \"YouTube Unleashed a Conspiracy Theory Boom. Can It Be Contained?\"\n",
+    "However, human beings tend to be drawn towards controversial content. This meant that videos about things like conspiracy theories started to get recommended more and more by the recommendation system. Furthermore, it turns out that the kinds of people that are interested in conspiracy theories are also people that watch a lot of online videos! So, they started to get drawn more and more towards YouTube. The increasing number of conspiracy theorists watching YouTube resulted in the algorithm recommending more and more conspiracy theories and other extremist content, which resulted in more extremists watching videos on YouTube, and more people watching YouTube developing extremist views, which led to the algorithm recommending more extremist content... The system became so out of control that in February 2019 it led the New York Times to run the headline \"YouTube Unleashed a Conspiracy Theory Boom. Can It Be Contained?\"footnote:[https://www.nytimes.com/2019/02/19/technology/youtube-conspiracy-stars.html]\n",
     "\n",
     "A helpful exercise prior to rolling out a significant machine learning system is to consider this question: \"what would happen if it went really, really well?\" In other words, what if the predictive power was extremely high, and its ability to influence behaviour was extremely significant? In that case, who would be most impacted? What would the most extreme results potentially look like? How would you know what was really going on?\n",
     "\n",
     "Such a thought exercise might help you to construct a more careful rollout plan, ongoing monitoring systems, and human oversight. Of course, human oversight isn't useful if it isn't listened to; so make sure that there are reliable and resilient communication channels so that the right people will be aware of issues, and will have the power to fix them."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Congratulations, you have finished your first deep learning project! To help with understanding the material, we really recommend you start writing about what you learned."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1924,5 +1958,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/03_ethics.ipynb b/03_ethics.ipynb
index b237e82..74a329b 100644
--- a/03_ethics.ipynb
+++ b/03_ethics.ipynb
@@ -18,7 +18,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Acknowledgement: Dr Rachel Thomas"
+    "**Acknowledgement: Dr Rachel Thomas**"
    ]
   },
   {
@@ -28,13 +28,6 @@
     "This chapter was co-authored by Dr Rachel Thomas, the co-founder of fast.ai, and founding director of the Center for Applied Data Ethics at the University of San Francisco. It largely follows a subset of her syllabus for the \"Introduction to Data Ethics\" course that she developed."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction to data ethics"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -73,7 +66,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Getting started with some examples"
+    "## Key examples for data ethics"
    ]
   },
   {
@@ -130,7 +123,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Dr. Latanya Sweeney is a professor at Harvard and director of their data privacy lab. In the paper [Discrimination in Online Ad Delivery](https://arxiv.org/abs/1301.6822) she describes her discovery that googling her name resulted in advertisements saying \"Latanya Sweeney arrested\" even although she is the only Latanya Sweeney and has never been arrested. However when she googled other names, such as Kirsten Lindquist, she got more neutral ads, even though Kirsten Lindquist has been arrested three times."
+    "Dr. Latanya Sweeney is a professor at Harvard and director of their data privacy lab. In the paper [Discrimination in Online Ad Delivery](https://arxiv.org/abs/1301.6822) (see <<lantanya_arrested>>) she describes her discovery that googling her name resulted in advertisements saying \"Latanya Sweeney arrested\" even although she is the only Latanya Sweeney and has never been arrested. However when she googled other names, such as Kirsten Lindquist, she got more neutral ads, even though Kirsten Lindquist has been arrested three times."
    ]
   },
   {
@@ -153,7 +146,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## So what?"
+    "TK Jeremy: \"Why does this matter?\" as an alternative title."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### So what?"
    ]
   },
   {
@@ -222,7 +222,7 @@
     "\n",
     "These are not just algorithm questions. They are data product design questions. But the product managers, executives, judges, journalists, doctors… whoever ends up developing and using the system of which your model is a part will not be well-placed to understand the decisions that you made, let alone change them.\n",
     "\n",
-    "For instance, two studies found that Amazon’s facial recognition software produced [inaccurate](https://www.nytimes.com/2018/07/26/technology/amazon-aclu-facial-recognition-congress.html) and [racially biased results](https://www.theverge.com/2019/1/25/18197137/amazon-rekognition-facial-recognition-bias-race-gender). Amazon claimed that the researchers should have changed the default parameters. However, it turned out that [Amazon was not instructing police departments](https://gizmodo.com/defense-of-amazons-face-recognition-tool-undermined-by-1832238149) that use its software to do this either. There was, presumably, a big distance between the researchers that developed these algorithms, and the Amazon documentation staff that wrote the guidelines provided to the police. A lack of tight integration led to serious problems for society, the police, and Amazon themselves. It turned out that their system erroneously *matched* 28 members of congress to criminal mugshots!  (And these members of congress wrongly matched to criminal mugshots disproportionately included people of color.)"
+    "For instance, two studies found that Amazon’s facial recognition software produced [inaccurate](https://www.nytimes.com/2018/07/26/technology/amazon-aclu-facial-recognition-congress.html) and [racially biased results](https://www.theverge.com/2019/1/25/18197137/amazon-rekognition-facial-recognition-bias-race-gender). Amazon claimed that the researchers should have changed the default parameters, they did not explain how it would change the racially baised results. Further more, it turned out that [Amazon was not instructing police departments](https://gizmodo.com/defense-of-amazons-face-recognition-tool-undermined-by-1832238149) that use its software to do this either. There was, presumably, a big distance between the researchers that developed these algorithms, and the Amazon documentation staff that wrote the guidelines provided to the police. A lack of tight integration led to serious problems for society, the police, and Amazon themselves. It turned out that their system erroneously *matched* 28 members of congress to criminal mugshots!  (And these members of congress wrongly matched to criminal mugshots disproportionately included people of color as seen in <<congressmen>>.)"
    ]
   },
   {
@@ -255,6 +255,7 @@
    "metadata": {},
    "source": [
     "Data ethics is a big field, and we can't cover everything. Instead, we're going to pick a few topics which we think are particularly relevant:\n",
+    "\n",
     "- need for recourse and accountability\n",
     "- feedback loops\n",
     "- bias\n",
@@ -265,14 +266,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Errors and recourse"
+    "TK Jeremy-Rachel: Explain why those topics are important and transition to errors and recourse."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In a complex system it is easy for no one person to feel responsible for outcomes. While this is understandable, it does not lead to good results. In the example above of the Arkansas healthcare system in which a bug led to people with cerebral palsy losing access to needed care, the creator of the algorithm blamed government officials, and government officials could blame those who implemented the software. NYU professor danah boyd described this phenomenon: \"bureaucracy has often been used to evade responsibility, and today's algorithmic systems are extending bureaucracy.\"\n",
+    "### Errors and recourse"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In a complex system it is easy for no one person to feel responsible for outcomes. While this is understandable, it does not lead to good results. In the earlier example of the Arkansas healthcare system in which a bug led to people with cerebral palsy losing access to needed care, the creator of the algorithm blamed government officials, and government officials could blame those who implemented the software. NYU professor danah boyd described this phenomenon: \"bureaucracy has often been used to evade responsibility, and today's algorithmic systems are extending bureaucracy.\"\n",
     "\n",
     "An additional reason why recourse is so necessary, is because data often contains errors. Mechanisms for audits and error-correction are crucial. A database of suspected gang members maintained by California law enforcement officials was found to be full of errors, including 42 babies who had been added to the database when they were less than 1 year old (28 of whom were marked as “admitting to being gang members”). In this case, there was no process in place for correcting mistakes or removing people once they’ve been added. Another example is the US credit report system; in a large-scale study of credit reports by the FTC in 2012, it was found that 26% of consumers had at least one mistake in their files, and 5% had errors that could be devastating.  Yet, the process of getting such errors corrected is incredibly slow and opaque. When public-radio reporter Bobby Allyn discovered that he was erroneously listed as having a firearms conviction, it took him \"more than a dozen phone calls, the handiwork of a county court clerk and six weeks to solve the problem. And that was only after I contacted the company’s communications department as a journalist.\" (as covered in the article [How the careless errors of credit reporting agencies are ruining people’s lives](https://www.washingtonpost.com/posteverything/wp/2016/09/08/how-the-careless-errors-of-credit-reporting-agencies-are-ruining-peoples-lives/))\n",
     "\n",
@@ -283,14 +291,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Feedback loops"
+    "### Feedback loops"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The New York Times published another article on YouTube's recommendation system, titled [On YouTube’s Digital Playground, an Open Gate for Pedophiles](https://www.nytimes.com/2019/06/03/world/americas/youtube-pedophiles.html). The article started with this chilling story:"
+    "We have already explained in <<chapter_intro>> how an algorithm can interact with its enviromnent to create a feedback loop, making prediction that reinforces actions taken in the field, which lead to predictions even more pronounced in the same direciton. The New York Times published another article on YouTube's recommendation system, titled [On YouTube’s Digital Playground, an Open Gate for Pedophiles](https://www.nytimes.com/2019/06/03/world/americas/youtube-pedophiles.html). The article started with this chilling story:"
    ]
   },
   {
@@ -312,7 +320,7 @@
     "\n",
     "Part of the problem here is the centrality of metrics in driving a financially important system. When an algorithm has a metric to optimise, as you have seen, it will do everything it can to optimise that number. This tends to lead to all kinds of edge cases, and humans interacting with a system will search for, find, and exploit these edge cases and feedback loops for their advantage.\n",
     "\n",
-    "There are signs that this is exactly what has happened with YouTube's recommendation system. The Guardian ran an article [How an ex-YouTube insider investigated its secret algorithm](https://www.theguardian.com/technology/2018/feb/02/youtube-algorithm-election-clinton-trump-guillaume-chaslot) about Guillaume Chaslot, an ex-YouTube engineer who created AlgoTransparency, which tracks these issues. Chaslot published this chart, following the release of Robert Mueller's \"Report on the Investigation Into Russian Interference in the 2016 Presidential Election\":"
+    "There are signs that this is exactly what has happened with YouTube's recommendation system. The Guardian ran an article [How an ex-YouTube insider investigated its secret algorithm](https://www.theguardian.com/technology/2018/feb/02/youtube-algorithm-election-clinton-trump-guillaume-chaslot) about Guillaume Chaslot, an ex-YouTube engineer who created AlgoTransparency, which tracks these issues. Chaslot published the chart in <<ethics_yt_rt>>, following the release of Robert Mueller's \"Report on the Investigation Into Russian Interference in the 2016 Presidential Election\"."
    ]
   },
   {
@@ -342,6 +350,13 @@
     "> : \"once people join a single conspiracy-minded \\[Facebook\\] group, they are algorithmically routed to a plethora of others. Join an anti-vaccine group, and your suggestions will include anti-GMO, chemtrail watch, flat Earther (yes, really), and ‘curing cancer naturally’ groups. Rather than pulling a user out of the rabbit hole, the recommendation engine pushes them further in.\""
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is extremely important to keep in mind this kind of behavior can happen, and to either anticipate a feedback loop or take positive action to break it when you can the first signs of it in your own projects. Another thing to keep in mind is bias."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -355,7 +370,7 @@
    "source": [
     "Discussions of bias online tend to get pretty confusing pretty fast. The word bias mean so many different things. Statisticians often think that when data ethicists are talking about bias that they're talking about the statistical definition of the term bias. But they're not. And they're certainly not talking about the bias is that appear in the weights and bias is which are the parameters of your model!\n",
     "\n",
-    "What they're talking about is the social science concept of bias. In [A Framework for Understanding Unintended Consequences of Machine Learning](https://arxiv.org/abs/1901.10002) MIT's Suresh and Guttag describe six types of bias in machine learning, summarized in this figure from their paper:"
+    "What they're talking about is the social science concept of bias. In [A Framework for Understanding Unintended Consequences of Machine Learning](https://arxiv.org/abs/1901.10002) MIT's Suresh and Guttag describe six types of bias in machine learning, summarized in <<bias>> from their paper."
    ]
   },
   {
@@ -365,6 +380,13 @@
     "<img src=\"images/ethics/image5.png\" id=\"bias\" caption=\"Bias in machine learning can come from multiple sources\" alt=\"A diagram showing all sources where bias can appear in machine learning\" width=\"650\">"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: \"Why only four? Tell the reader.\" If you have anything interesting to say about that here, otherwise we can ignore."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -454,7 +476,7 @@
     "\n",
     "One of the MIT researchers, Joy Buolamwini, warned, \"We have entered the age of automation overconfident yet underprepared. If we fail to make ethical and inclusive artificial intelligence, we risk losing gains made in civil rights and gender equity under the guise of machine neutrality\".\n",
     "\n",
-    "Part of the issue appears to be a systematic imbalance in the make up of popular datasets used for training models. The abstract to the paper [No Classification without Representation: Assessing Geodiversity Issues in Open Data Sets for the Developing World](https://arxiv.org/abs/1711.08536) states, \"We analyze two large, publicly available image data sets to assess geo-diversity and find that these data sets appear to exhibit an observable amerocentric and eurocentric representation bias. Further, we analyze classifiers trained on these data sets to assess the impact of these training distributions and find strong differences in the relative performance on images from different locales\". Here is one of the charts from the paper, showing the geographic make up of what was, at the time (and still, as this book is being written), the two most important image datasets for training models:"
+    "Part of the issue appears to be a systematic imbalance in the make up of popular datasets used for training models. The abstract to the paper [No Classification without Representation: Assessing Geodiversity Issues in Open Data Sets for the Developing World](https://arxiv.org/abs/1711.08536) states, \"We analyze two large, publicly available image data sets to assess geo-diversity and find that these data sets appear to exhibit an observable amerocentric and eurocentric representation bias. Further, we analyze classifiers trained on these data sets to assess the impact of these training distributions and find strong differences in the relative performance on images from different locales\". <<image_provenance>> shows one of the charts from the paper, showing the geographic make up of what was, at the time (and still, as this book is being written), the two most important image datasets for training models."
    ]
   },
   {
@@ -468,7 +490,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The vast majority of the images are from the United States and other Western countries, leading to models trained on ImageNet performing worse on scenes from other countries and cultures. For instance, [research](https://arxiv.org/pdf/1906.02659.pdf) found that such models are worse at identifying household items (such as soap, spices, sofas, or beds) from lower-income countries. Below is an image from the paper, [Does Object Recognition Work for Everyone?](https://arxiv.org/pdf/1906.02659.pdf)."
+    "The vast majority of the images are from the United States and other Western countries, leading to models trained on ImageNet performing worse on scenes from other countries and cultures. For instance, [research](https://arxiv.org/pdf/1906.02659.pdf) found that such models are worse at identifying household items (such as soap, spices, sofas, or beds) from lower-income countries. <<object_detect>> shows an image from the paper, [Does Object Recognition Work for Everyone?](https://arxiv.org/pdf/1906.02659.pdf)."
    ]
   },
   {
@@ -482,7 +504,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As we will discuss shortly, in addition, the vast majority of AI researchers and developers are young white men. Most projects that we have seen do most user testing using friends and families of the immediate product development group. Given this, the kinds of problems we saw above should not be surprising.\n",
+    "TK Jeremy: \"Tell the reader what the figure shows, what's the takeaway?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we will discuss shortly, in addition, the vast majority of AI researchers and developers are young white men. Most projects that we have seen do most user testing using friends and families of the immediate product development group. Given this, the kinds of problems we just discussed should not be surprising.\n",
     "\n",
     "Similar historical bias is found in the texts used as data for natural language processing models. This crops up in downstream machine learning tasks in many ways. For instance, until last year Google Translate showed systematic bias in how it translated the Turkish gender-neutral pronoun \"bir\" into English. For instance, when applied to jobs which are often associated with males, it used \"he\", and when applied to jobs which are often associated with females, it used \"she\":"
    ]
@@ -494,6 +523,13 @@
     "<img src=\"images/ethics/image11.png\" width=\"600\">"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Link to the study needed"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -553,7 +589,7 @@
    "source": [
     "The abstract of the paper [Bias in Bios: A Case Study of Semantic Representation Bias in a High-Stakes Setting](https://arxiv.org/abs/1901.09451) notes that there is gender imbalance in occupations (e.g. females are more likely to be nurses, and males are more likely to be pastors), and says that: \"differences in true positive rates between genders are correlated with existing gender imbalances in occupations, which may compound these imbalances\".\n",
     "\n",
-    "What this is saying is that the researchers noticed that models predicting occupation did not only reflect the actual gender imbalance in the underlying population, but actually amplified it! This is quite common, particularly for simple models. When there is some clear, easy to see underlying relationship, a simple model will often simply assume that that relationship holds all the time. As the show with the paper, for occupations which had a higher percentage of females, the model tended to overestimate the prevalence of that occupation:"
+    "What this is saying is that the researchers noticed that models predicting occupation did not only reflect the actual gender imbalance in the underlying population, but actually amplified it! This is quite common, particularly for simple models. When there is some clear, easy to see underlying relationship, a simple model will often simply assume that that relationship holds all the time. As <<representation_bias>> from the paper shows, for occupations which had a higher percentage of females, the model tended to overestimate the prevalence of that occupation."
    ]
   },
   {
@@ -567,14 +603,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For example, in the training dataset, 14.6% of surgeons were women, yet in the model predictions, only 11.6% of the true positives were women."
+    "For example, in the training dataset, 14.6% of surgeons were women, yet in the model predictions, only 11.6% of the true positives were women. The model is thus amplifying the bias existing in the training set.\n",
+    "\n",
+    "Now that we saw those bias existed, what can we do to mitigate them?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Addressing different types of bias"
+    "## Addressing different types of bias"
    ]
   },
   {
@@ -597,10 +635,10 @@
    "source": [
     "We often hear this question — \"humans are biased, so does algorithmic bias even matter?\" This comes up so often, there must be some reasoning that makes sense to the people that ask it, but it doesn't seem very logically sound to us! Independently of whether this is logically sound, it's important to realise that algorithms and people are different. Machine learning, particularly so. Consider these points about machine learning algorithms:\n",
     "\n",
-    "  - *Machine learning can create feedback loops*: small amounts of bias can very rapidly, exponentially increase due to feedback loops\n",
-    "  - *Machine learning can amplify bias*: human bias can lead to larger amounts of machine learning bias\n",
-    "  - *Algorithms & humans are used differently*: human decision makers and algorithmic decision makers are not used in a plug-and-play interchangeable way in practice.  For instance, algorithmic decisions are more likely to be implemented at scale and without a process for recourse.  Furthermore, people are more likely to mistakenly believe that the result of an algorithm is objective and error-free.\n",
-    "  - *Technology is power*. And with that comes responsibility.\n",
+    "  - _Machine learning can create feedback loops_:: small amounts of bias can very rapidly, exponentially increase due to feedback loops\n",
+    "  - _Machine learning can amplify bias_:: human bias can lead to larger amounts of machine learning bias\n",
+    "  - _Algorithms & humans are used differently_:: human decision makers and algorithmic decision makers are not used in a plug-and-play interchangeable way in practice.  For instance, algorithmic decisions are more likely to be implemented at scale and without a process for recourse.  Furthermore, people are more likely to mistakenly believe that the result of an algorithm is objective and error-free.\n",
+    "  - _Technology is power_:: And with that comes responsibility.\n",
     "\n",
     "As the Arkansas healthcare example showed, machine learning is often implemented in practice not because it leads to better outcomes, but because it is cheaper and more efficient. Cathy O'Neill, in her book *Weapons of Math Destruction*, described the pattern of how the privileged are processed by people, the poor are processed by algorithms. This is just one of a number of ways that algorithms are used differently than human decision makers. Others include:\n",
     "\n",
@@ -614,14 +652,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Data contains errors"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Because data is likely to contain errors, mechanisms for audits and error-correction are important. A database of suspected gang members maintained by California law enforcement officials was found to be full of errors, including 42 babies who had been added to the database when they were less than 1 year old (28 of whom were marked as *admitting to being gang members*). In this case, there was no process in place for correcting mistakes or removing people once they’ve been added. Another example is the US credit report system; in a large-scale study of credit reports by the FTC in 2012, it was found that 26% of consumers had at least one mistake in their files, and 5% had errors that could be devastating.  Yet, the process of getting such errors corrected is incredibly slow and opaque. When public-radio reporter Bobby Allyn discovered that he was erroneously listed as having a firearms conviction, it took him \"more than a dozen phone calls, the handiwork of a county court clerk and six weeks to solve the problem. And that was only after I contacted the company’s communications department as a journalist.\" (as covered in the article [How the careless errors of credit reporting agencies are ruining people’s lives](https://www.washingtonpost.com/posteverything/wp/2016/09/08/how-the-careless-errors-of-credit-reporting-agencies-are-ruining-peoples-lives/))"
+    "TK Jeremy: Takeaway for readers and transition to disinformation."
    ]
   },
   {
@@ -662,6 +693,13 @@
     "One proposed approach is to develop some form of digital signature, implement it in a seamless way, and to create norms that we should only trust content which has been verified.  Head of the Allen Institute on AI, Oren Etzioni, wrote such a proposal in an article titled [How Will We Prevent AI-Based Forgery?](https://hbr.org/2019/03/how-will-we-prevent-ai-based-forgery), \"AI is poised to make high-fidelity forgery inexpensive and automated, leading to potentially disastrous consequences for democracy, security, and society. The specter of AI forgery means that we need to act to make digital signatures de rigueur as a means of authentication of digital content.\""
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Wrap up section and transition to next. Also change next title to What to do about bla or What to do with foo."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -683,6 +721,13 @@
     "- increase diversity"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's walk through each step next, staring with analyzing a project you are working on."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -705,6 +750,13 @@
     "  - How diverse is the team that built it?"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Expand--add some additional details and takeaways from the reader. What will they get out of doing this and how should they go about it? Then transition to \"Process to Implement\""
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -726,6 +778,13 @@
     "  - Who might use this product that we didn’t expect to use it, or for purposes we didn’t initially intend?"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Add takeaways and transition to Ethical Lenses"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -739,11 +798,11 @@
    "source": [
     "Another useful resource from the Markkula Center is [Conceptual Frameworks in Technology and Engineering Practice](https://www.scu.edu/ethics-in-technology-practice/conceptual-frameworks/). This considers how different foundational ethical lenses can help identify concrete issues, and lays out the following approaches and key questions:\n",
     "\n",
-    "  - The Rights Approach: Which option best respects the rights of all who have a stake?\n",
-    "  - The Justice Approach: Which option treats people equally or proportionately?\n",
-    "  - The Utilitarian Approach: Which option will produce the most good and do the least harm?\n",
-    "  - The Common Good Approach: Which option best serves the community as a whole, not just some members?\n",
-    "  - The Virtue Approach: Which option leads me to act as the sort of person I want to be?"
+    "  - The Rights Approach:: Which option best respects the rights of all who have a stake?\n",
+    "  - The Justice Approach:: Which option treats people equally or proportionately?\n",
+    "  - The Utilitarian Approach:: Which option will produce the most good and do the least harm?\n",
+    "  - The Common Good Approach:: Which option best serves the community as a whole, not just some members?\n",
+    "  - The Virtue Approach:: Which option leads me to act as the sort of person I want to be?"
    ]
   },
   {
@@ -807,6 +866,13 @@
     "In philosophy, and especially philosophy of ethics, this is one of the most effective tools: first, come up with a process, definition, set of questions, etc, which is designed to resolve some problem. Then try to come up with an example where that apparent solution results in a proposal that no-one would consider acceptable. This can then lead to a further refinement of the solution."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Add takeaways for the reader and transition to Role of Policy."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -821,16 +887,25 @@
     "The ethical issues that arise in the use of automated decision systems, such as machine learning, can be complex and far-reaching. To better address them, we will need thoughtful policy, in addition to the ethical efforts of those in industry.  Neither is sufficient on its own.\n",
     "\n",
     "Policy is the appropriate tool for addressing:\n",
+    "\n",
     "- Negative externalities\n",
     "- Misaligned economic incentives\n",
     "- “Race to the bottom” situations\n",
     "- Enforcing accountability.\n",
     "\n",
     "Ethical behavior in industry is necessary as well, since:\n",
+    "\n",
     "- Law will not always keep up\n",
     "- Edge cases will arise in which practitioners must use their best judgement."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TK Jeremy: Expand this section. What does this mean for the reader? Add transition to The Power of Diversity"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/04_mnist_basics.ipynb b/04_mnist_basics.ipynb
index ead7153..ad4d6f7 100644
--- a/04_mnist_basics.ipynb
+++ b/04_mnist_basics.ipynb
@@ -27,6 +27,15 @@
     "# Under the hood: training a digit classifier"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we’ve seen what it looks like to actually train a variety of models, let’s now dig under the hood and see exactly what is going on. We’ll start with computer vision, and will use that to introduce many of the key concepts of deep learning. In future chapters we’ll do deep dives into other applications as well, and we’ll see how to use these insights to both improve our model’s accuracy, speed up its training, and turn it into a real working web application.\n",
+    "\n",
+    "First, let's start by how images are represented in a computer, then we will make our way up to how to classify different type of images."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -38,8 +47,6 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we’ve seen what it looks like to actually train a variety of models, let’s now dig under the hood and see exactly what is going on. We’ll start with computer vision, and will use that to introduce many of the key concepts of deep learning. In future chapters we’ll do deep dives into other applications as well, and we’ll see how to use these insights to both improve our model’s accuracy, speed up its training, and turn it into a real working web application.\n",
-    "\n",
     "In order to understand what happens in a computer vision model, we first have to understand how computers handle images. We'll use one of the most famous datasets in computer vision, [MNIST](https://en.wikipedia.org/wiki/MNIST_database), for our experiments. MNIST contains hand-written digits, collected by the National Institute of Standards and Technology, and collated into a machine learning dataset by Yann Lecun and his colleagues. Lecun used MNIST in 1998 to demonstrate [Lenet 5](http://yann.lecun.com/exdb/lenet/), the first computer system to demonstrate practically useful recognition of hand-written digit sequences. This was one of the most important breakthroughs in the history of AI."
    ]
   },
@@ -1750,6 +1757,13 @@
     "> j: When I first came across this \"L1\" thingie, I looked it up to see what on Earth it meant, found on Google that it is a _vector norm_ using _absolute value_, so looked up _vector norm_ and started reading: _Given a vector space V over a field F of the real or complex numbers, a norm on V is a nonnegative-valued any function p: V → \\[0,+∞) with the following properties: For all a ∈ F and all u, v ∈ V, p(u + v) ≤ p(u) + p(v)..._ Then I stopped reading. \"Ugh, I'll never understand math!\" I thought, for the thousandth time. Since then I've learned that every time these complex mathy bits of jargon come up in practice, it turns out I can replace them with a tiny bit of code! Like the _L1 loss_ is just equal to `(a-b).abs().mean()`, where `a` and `b` are tensors. I guess mathy folks just think differently to me... I'll make sure, in this book, every time some mathy jargon comes up, I'll give you the little bit of code it's equal to as well, and explain in common sense terms what's going on."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the above code we completed various mathematical operations on *PyTorch tensors*. If you've done some numeric programming in Pytorch before, you may recognize these as being similar to *Numpy arrays*. Let's have a look at those two very important classes."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -1761,7 +1775,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the above code we completed various mathematical operations on *PyTorch tensors*. If you've done some numeric programming in Pytorch before, you may recognize these as being similar to *Numpy arrays*. [Numpy](https://numpy.org/) is the most widely used library for scientific and numeric programming in Python, and provides very similar functionality and a very similar API to that provided by PyTorch; however, it does not support using the GPU, or calculating gradients, which are both critical for deep learning. Therefore, in this book we will generally use PyTorch tensors instead of NumPy arrays, where possible. (Note that fastai adds some features to NumPy and PyTorch to make them a bit more similar to each other; if any code in this book doesn't work on your computer, it's possible that you forgot to include a line at the start of your notebook such as: `from fastai.vision.all import *`.)\n",
+    "[Numpy](https://numpy.org/) is the most widely used library for scientific and numeric programming in Python, and provides very similar functionality and a very similar API to that provided by PyTorch; however, it does not support using the GPU, or calculating gradients, which are both critical for deep learning. Therefore, in this book we will generally use PyTorch tensors instead of NumPy arrays, where possible. (Note that fastai adds some features to NumPy and PyTorch to make them a bit more similar to each other; if any code in this book doesn't work on your computer, it's possible that you forgot to include a line at the start of your notebook such as: `from fastai.vision.all import *`.)\n",
     "\n",
     "So, what's an array? And what's a tensor?\n",
     "\n",
@@ -2012,14 +2026,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Broadcasting and metrics"
+    "So, is our baseline model any good? To quantify this, we will use a metric."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So, is our baseline model any good? To quantify this, we will use a metric. A metric is a number which is calculated from the predictions of our model, and the correct labels in our dataset, and tells us something about how good our model is. For instance, we could use either of the functions we saw in the previous section, mean squared error or mean absolute error, and take the average of them over the whole dataset. However, neither of these are numbers that are very understandable to most people; in practice, we normally use *accuracy* as the metric for classification models.\n",
+    "## Metrics and broadcasting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A metric is a number which is calculated from the predictions of our model, and the correct labels in our dataset, and tells us something about how good our model is. For instance, we could use either of the functions we saw in the previous section, mean squared error or mean absolute error, and take the average of them over the whole dataset. However, neither of these are numbers that are very understandable to most people; in practice, we normally use *accuracy* as the metric for classification models.\n",
     "\n",
     "As we've discussed, we need to use a *validation set* to calculate our metric. That means we need to do is remove some of the data from training entirely, so it is not seen by the model at all. As it turns out, the creators of the MNIST dataset have already done this for us. Do you remember how there was a whole separate directory called \"valid\"? That's what this directory is for!\n",
     "\n",
@@ -2300,7 +2321,7 @@
     "\n",
     "> : _Suppose we arrange for some automatic means of testing the effectiveness of any current weight assignment in terms of actual performance and provide a mechanism for altering the weight assignment so as to maximize the performance. We need not go into the details of such a procedure to see that it could be made entirely automatic and to see that a machine so programed would \"learn\" from its experience._\n",
     "\n",
-    "As we discussed, this is the key to allowing us to have something which can get better and better — to learn. But our pixel similarity approach does not really do this. We do not have any kind of weight assignment, or any way of improving based on testing the effectiveness of a weight assignment. In other words, we can't really improve our pixel similarity approach by modifying a set of parameters. In order to take advantage of the power of deep learning, we will first have to represent our task in the way that Arthur Samuel described it.\n",
+    "As we discussed, this is the key to allowing us to have something which can get better and better — to learn. But our pixel similarity approach does not really do this. We do not have any kind of weight assignment, or any way of improving based on testing the effectiveness of a weight assignment. In other words, we can't really improve our pixel similarity approach by modifying a set of parameters (which will be the SGD part, as we will see). In order to take advantage of the power of deep learning, we will first have to represent our task in the way that Arthur Samuel described it.\n",
     "\n",
     "Instead of trying to find the similarity between an image and a \"ideal image\" we could instead look at each individual pixel, and come up with a set of weights for each pixel, such that the highest weights are associated with those pixels most likely to be black for a particular category. For instance, pixels towards the bottom right are not very likely to be activated for a seven, so they should have a low weight for a seven, but are more likely to be activated for an eight, so they should have a high weight for an eight. This can be represented as a function for each possible category, for instance the probability of being the number eight:\n",
     "\n",
@@ -2448,14 +2469,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "These seven steps are the key to the training of all deep learning models， and we'll be using the seven terms in the above diagram throughout this book. That deep learning turns out to rely entirely on these steps is extremely surprising and counter-intuitive. It's amazing that this process can solve such complex problems. But, as you'll see, it really does!\n",
+    "These seven steps, illustrated in <<gradient_descent>> are the key to the training of all deep learning models， and we'll be using the seven terms in the above diagram throughout this book. That deep learning turns out to rely entirely on these steps is extremely surprising and counter-intuitive. It's amazing that this process can solve such complex problems. But, as you'll see, it really does!\n",
     "\n",
     "There are many different ways to do each of these seven steps, and we will be learning about them throughout the rest of this book. These are the details which make a big difference for deep learning practitioners. But it turns out that the general approach to each one generally follows some basic principles:\n",
     "\n",
-    "- **Initialize**: we initialise the parameters to random values. This may sound surprising. There are certainly other choices we could make, such as initialising them to the percentage of times that that pixel is activated for that category. But since we already know that we have a routine to improve these weights, it turns out that just starting with random weights works perfectly well\n",
-    "- **Loss**: This is the thing Arthur Samuel refered to: \"*testing the effectiveness of any current weight assignment in terms of actual performance*\". We need some function that will return a number that is small if the performance of the model is good, and vice versa (the standard approach is to treat a small loss as good, and a large loss as bad, although this is just a convention)\n",
-    "- **Step**: A simple way to figure out whether a weight should be increased a bit, or decreased a bit, would be just to try it. Increase the weight by a small amount, and see if the loss goes up or down. Once you find the correct direction, you could then change that amount by a bit more, and a bit less, until you find an amount which works well. However, this is slow! As we will see, the magic of calculus allows us to directly figure out which direction, and roughly how much, to change each weight, without having to try all these small changes, by calculating *gradients*. This is just a performance optimisation, we would get exactly the same results by using the slower manual process as well\n",
-    "- **Stop**: We have already discussed how to choose how many epochs to train a model for. This is where that decision is applied. For our digit classifier, we would keep training until the accuracy of the model started getting worse, or we ran out of time."
+    "- **Initialize**:: we initialise the parameters to random values. This may sound surprising. There are certainly other choices we could make, such as initialising them to the percentage of times that that pixel is activated for that category. But since we already know that we have a routine to improve these weights, it turns out that just starting with random weights works perfectly well\n",
+    "- **Loss**:: This is the thing Arthur Samuel refered to: \"*testing the effectiveness of any current weight assignment in terms of actual performance*\". We need some function that will return a number that is small if the performance of the model is good, and vice versa (the standard approach is to treat a small loss as good, and a large loss as bad, although this is just a convention)\n",
+    "- **Step**:: A simple way to figure out whether a weight should be increased a bit, or decreased a bit, would be just to try it. Increase the weight by a small amount, and see if the loss goes up or down. Once you find the correct direction, you could then change that amount by a bit more, and a bit less, until you find an amount which works well. However, this is slow! As we will see, the magic of calculus allows us to directly figure out which direction, and roughly how much, to change each weight, without having to try all these small changes, by calculating *gradients*. This is just a performance optimisation, we would get exactly the same results by using the slower manual process as well\n",
+    "- **Stop**:: We have already discussed how to choose how many epochs to train a model for. This is where that decision is applied. For our digit classifier, we would keep training until the accuracy of the model started getting worse, or we ran out of time."
    ]
   },
   {
@@ -2544,7 +2565,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img alt=\"A graph showing the squared function with the slope at one point\" width=\"400\" caption=\"The slope of a function\" src=\"images/grad_illustration.svg\" id=\"slope\"/>"
+    "<img alt=\"A graph showing the squared function with the slope at one point\" width=\"400\" src=\"images/grad_illustration.svg\"/>"
    ]
   },
   {
@@ -2558,7 +2579,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<img alt=\"An illustration of gradient descent\" width=\"400\" caption=\"Gradient descent\" src=\"images/chapter2_perfect.svg\" id=\"descent\"/>"
+    "<img alt=\"An illustration of gradient descent\" width=\"400\" src=\"images/chapter2_perfect.svg\"/>"
    ]
   },
   {
@@ -2776,15 +2797,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Stepping with a learning rate"
+    "The gradient only tells us the slope of our function, it doesn't actually tell us how far to adjust the parameters. It gives us some idea of how far to adjust them; if the slope is very large, then that may suggest that we have more adjustments to do, whereas if the slope is very small, that may suggest that we are close to the optimal value."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Stepping with a learning rate"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The gradient only tells us the slope of our function, it doesn't actually tell us how far to adjust the parameters. It gives us some idea of how far to adjust them; if the slope is very large, then that may suggest that we have more adjustments to do, whereas if the slope is very small, that may suggest that we are close to the optimal value.\n",
-    "\n",
     "Deciding how to change our parameters based on the value of the gradients is an important part of the deep learning process. Nearly all approaches start with the basic idea of multiplying the gradient by some small number, called the *learning rate* (LR). The learning rate is often a number between 0.001 and 0.1, although it could be anything. Often, people select a learning rate just by trying a few, and finding which results in the best model after training (we'll show you a better approach later in this book, called the *learning rate finder*). Once you've picked a learning rate, you can adjust your parameters using this simple function:\n",
     "\n",
     "```\n",
@@ -2793,7 +2819,7 @@
     "\n",
     "This is known as *stepping* your parameters, using a *optimiser step*.\n",
     "\n",
-    "If you pick a learning rate that's too low, it can mean having to do for a lot of steps:"
+    "If you pick a learning rate that's too low, it can mean having to do for a lot of steps. <<descent_small>> illustrates that."
    ]
   },
   {
@@ -2807,7 +2833,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Although picking a learning rate that's too high is even worse--it can actually result in the loss getting *worse*!"
+    "Although picking a learning rate that's too high is even worse--it can actually result in the loss getting *worse* as we see in <<descent_div>>!"
    ]
   },
   {
@@ -2821,7 +2847,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If the learning rate is too high, it may also \"bounce\" around, rather than actually diverging; this has the result of taking many steps to train successfully:"
+    "If the learning rate is too high, it may also \"bounce\" around, rather than actually diverging; <<descent_bouncy>> shows how this has the result of taking many steps to train successfully."
    ]
   },
   {
@@ -2831,6 +2857,13 @@
     "<img alt=\"An illustation of gradient descent with a bouncy LR\" width=\"400\" caption=\"Gradient descent with bouncy LR\" src=\"images/chapter2_bouncy.svg\" id=\"descent_bouncy\"/>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's apply all of this on an end-to-end example."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -3371,7 +3404,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`torch.where(a,b,c)` is the same as running the list comprehension `[b[i] if a[i] else c[i] for i in range(len(a))]`, except it works on tensors, at C/CUDA speed. (It's important to learn about PyTorch functions like this, because looping over tensors in Python performs at Python speed, not C/CUDA speed!) Try running `help(torch.where)` now to read the docs for this function, or, better still, look it up on the PyTorch documentation site."
+    "`torch.where(a,b,c)` is the same as running the list comprehension `[b[i] if a[i] else c[i] for i in range(len(a))]`, except it works on tensors, at C/CUDA speed. \n",
+    "\n",
+    "> note: It's important to learn about PyTorch functions like this, because looping over tensors in Python performs at Python speed, not C/CUDA speed!\n",
+    "\n",
+    "Try running `help(torch.where)` now to read the docs for this function, or, better still, look it up on the PyTorch documentation site."
    ]
   },
   {
@@ -3448,6 +3485,13 @@
     "mnist_loss(tensor([0.9, 0.4, 0.8]),tgt)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One problem with mnist_loss as currently defined is that it assumes that inputs are always between zero and one. We need to ensure, then, that this is actually the case! As it happens, there is a function that does exactly that--it always outputs a number between zero and one and it's called sigmoid."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -3459,7 +3503,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "One problem with `mnist_loss` as currently defined is that it assumes that inputs are always between zero and one. We need to ensure, then, that this is actually the case! As it happens, there is a function that does exactly that--it always outputs a number between one and one. This function is called *sigmoid* and is defined by:"
+    "The function called *sigmoid* is defined by:"
    ]
   },
   {
@@ -3531,7 +3575,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Stochastic gradient descent and mini-batches"
+    "### SGD and mini-batches"
    ]
   },
   {
@@ -3631,6 +3675,13 @@
     "list(dl)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We are now read to write our first training loop for a model using SGD!"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -3642,7 +3693,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In code, our process will be implemented something like this for each epoch:\n",
+    "it's time to implement the graph we saw in <<gradient_descent>>. In code, our process will be implemented something like this for each epoch:\n",
     "\n",
     "```python\n",
     "for x,y in dl:\n",
@@ -3885,7 +3936,7 @@
    "source": [
     "Whilst we could use a python for loop to calculate the prediction for each image, that would be very slow. Because Python loops don't run on the GPU, and because Python is a slow language for loops in general, we need to represent as much of the computation in a model as possible using higher-level functions.\n",
     "\n",
-    "In this case, there's an extremely convenient mathematical operation that calculates `w*x` for every row of a matrix--it's called *matrix multiplication*. Here's what matrix multiplication looks like (diagram from Wikipedia):"
+    "In this case, there's an extremely convenient mathematical operation that calculates `w*x` for every row of a matrix--it's called *matrix multiplication*. <<matmul>> show what matrix multiplication looks like (diagram from Wikipedia)."
    ]
   },
   {
@@ -4090,7 +4141,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Our only remaining step will be to update the weights and bias based on the gradient and learning rate. When we do so, we have to tell PyTorch not to take the gradient of this step too, otherwise things will get very confusing! If we assign to the `data` attribute of a tensor then PyTorch will not take the gradient of that step. Here's our basic training loop for an epoch:"
+    "Our only remaining step will be to update the weights and bias based on the gradient and learning rate. When we do so, we have to tell PyTorch not to take the gradient of this step too, otherwise things will get very confusing when we try to compute the derivative at the next batch! If we assign to the `data` attribute of a tensor then PyTorch will not take the gradient of that step. Here's our basic training loop for an epoch:"
    ]
   },
   {
@@ -4274,7 +4325,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Looking good! We're already about at the same accuracy as our \"pixel similarity\" approach, and we've created a general purpose foundation we can build on."
+    "Looking good! We're already about at the same accuracy as our \"pixel similarity\" approach, and we've created a general purpose foundation we can build on. Our next step will be to create an object that will handle the SGD step for us. In PyTorch, it's called an *optimizer*."
    ]
   },
   {
@@ -4288,7 +4339,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Because this is such a useful general foundation, PyTorch provides some useful classes to make it easier to implement. The first we'll use is to replace our `linear()` function with PyTorch's `nn.Linear` *module*. A \"module\" is an object of a class that inherits from the PyTorch `nn.Module` class. Objects of this class behave identically to a standard Python function, in that you can call it using parentheses, and it will return the activations of a model.\n",
+    "Because this is such a general foundation, PyTorch provides some useful classes to make it easier to implement. The first we'll use is to replace our `linear()` function with PyTorch's `nn.Linear` *module*. A \"module\" is an object of a class that inherits from the PyTorch `nn.Module` class. Objects of this class behave identically to a standard Python function, in that you can call it using parentheses, and it will return the activations of a model.\n",
     "\n",
     "`nn.Linear` does the same thing as our `init_params` and `linear` together. It contains both the *weights* and *bias* in a single class. Here's how we replicate our model from the previous section:"
    ]
@@ -4649,7 +4700,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So far we have a general procedure for optimising the parameters of a function, and we have tried it out on a very boring function: a simple linear classifier. A linear classifier is very constrained in terms of what it can do. Let's instead use a neural network. Here is the entire definition of a basic neural network:"
+    "So far we have a general procedure for optimising the parameters of a function, and we have tried it out on a very boring function: a simple linear classifier. A linear classifier is very constrained in terms of what it can do. To make it a bit more complex (and able to handle more tasks), we need to add a non-linearity between two linear classifiers, and this is what will gived us a neural network.\n",
+    "\n",
+    "Here is the entire definition of a basic neural network:"
    ]
   },
   {
@@ -4692,7 +4745,7 @@
    "source": [
     "The key point about this is that `w1` has 30 output activations (which means that `w2` must have 30 input activations, so they match). That means that the first layer can construct 30 different features, each representing some different mix of pixels. You can change that `30` to anything you like, to make the model more or less complex.\n",
     "\n",
-    "That little function `res.max(tensor(0.0))` is called a *rectified linear unit*, also known as *ReLU*. I think we can all agree that *rectified linear unit* sounds pretty fancy and complicated... But actually, there's nothing more to it than `res.max(tensor(0.0))`, in other words: replace every negative number with a zero. This tiny function is also available in PyTorch as `F.relu`:"
+    "That little function `res.max(tensor(0.0))` is called a *rectified linear unit*, also known as *ReLU*. We think we can all agree that *rectified linear unit* sounds pretty fancy and complicated... But actually, there's nothing more to it than `res.max(tensor(0.0))`, in other words: replace every negative number with a zero. This tiny function is also available in PyTorch as `F.relu`:"
    ]
   },
   {
@@ -4730,8 +4783,20 @@
    "source": [
     "The basic idea is that by using more linear layers, we can have our model do more computation, and therefore model more complex functions. But there's no point just putting one linear layout directly after another one, because when we multiply things together and then at them up multiple times, that can be replaced by multiplying different things together and adding them up just once! That is to say, a series of any number of linear layers in a row can be replaced with a single linear layer with a different set of parameters.\n",
     "\n",
-    "But if we put a non-linear function between them, such as max, then this is no longer true. Now, each linear layer is actually somewhat decoupled from the other ones, and can do its own useful work. The max function is particularly interesting, because it operates as a simple \"if\" statement. For any arbitrarily wiggly function, we can approximate it as a bunch of lines joined together; to make it more close to the wiggly function, we just have to use shorter lines.\n",
-    "\n",
+    "But if we put a non-linear function between them, such as max, then this is no longer true. Now, each linear layer is actually somewhat decoupled from the other ones, and can do its own useful work. The max function is particularly interesting, because it operates as a simple \"if\" statement. For any arbitrarily wiggly function, we can approximate it as a bunch of lines joined together; to make it more close to the wiggly function, we just have to use shorter lines."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "> s: Mathematically, we say the composition of two linear functions is another linear function. So we can stack as many linear classifiers on top or each other, without non-linear functions between them, it will jsut be the same as one linear classifier."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
     "Amazingly enough, it can be mathematically proven that this little function can solve any computable problem to an arbitrarily high level of accuracy, if you can find the right parameters for `w1` and `w2`, and if you make these matrices big enough. This is known as the *universal approximation theorem* . The three lines of code that we have here are known as *layers*. The first and third are known as *linear layers*, and the second line of code is known variously as a *nonlinearity*, or *activation function*.\n",
     "\n",
     "Just like the previous section, we can replace this code with something a bit simpler, by taking advantage of PyTorch:"
@@ -5217,7 +5282,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Deep learning"
+    "## Jargon recap"
    ]
   },
   {
@@ -5250,7 +5315,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### _Choose Your Own Adventure_ reminder"
+    "#### _Choose Your Own Adventure_ reminder"
    ]
   },
   {
diff --git a/05_pet_breeds.ipynb b/05_pet_breeds.ipynb
index d4cf37c..9008ff1 100644
--- a/05_pet_breeds.ipynb
+++ b/05_pet_breeds.ipynb
@@ -2466,6 +2466,31 @@
    "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.5"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": true,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/06_multicat.ipynb b/06_multicat.ipynb
index e0a107e..4c0220a 100644
--- a/06_multicat.ipynb
+++ b/06_multicat.ipynb
@@ -1898,6 +1898,31 @@
    "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.5"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": false,
+   "sideBar": true,
+   "skip_h1_title": true,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/08_collab.ipynb b/08_collab.ipynb
index 213f7ad..c650451 100644
--- a/08_collab.ipynb
+++ b/08_collab.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -55,7 +55,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -73,7 +73,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -152,7 +152,7 @@
        "4   166    346       1  886397596"
       ]
      },
-     "execution_count": 3,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -188,7 +188,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -204,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -220,7 +220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -229,7 +229,7 @@
        "2.1420000000000003"
       ]
      },
-     "execution_count": 6,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -261,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -277,7 +277,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -286,7 +286,7 @@
        "-1.611"
       ]
      },
-     "execution_count": 8,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -345,7 +345,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -412,7 +412,7 @@
        "4      5     Copycat (1995)"
       ]
      },
-     "execution_count": 9,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -432,7 +432,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -517,7 +517,7 @@
        "4   306    242       5  876503793  Kolya (1996)"
       ]
      },
-     "execution_count": 10,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -536,7 +536,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -637,7 +637,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -660,7 +660,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -669,7 +669,7 @@
        "tensor([-0.4586, -0.9915, -0.4052, -0.3621, -0.5908])"
       ]
      },
-     "execution_count": 13,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -688,7 +688,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -697,7 +697,7 @@
        "tensor([-0.4586, -0.9915, -0.4052, -0.3621, -0.5908])"
       ]
      },
-     "execution_count": 14,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -755,7 +755,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -773,7 +773,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -782,7 +782,7 @@
        "'Hello Sylvain, nice to meet you.'"
       ]
      },
-     "execution_count": 16,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -803,7 +803,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -829,7 +829,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -838,7 +838,7 @@
        "torch.Size([64, 2])"
       ]
      },
-     "execution_count": 18,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -857,7 +857,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -874,7 +874,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -944,7 +944,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -962,7 +962,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1036,7 +1036,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1065,7 +1065,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1153,7 +1153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {
     "hide_input": true
    },
@@ -1205,7 +1205,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1291,7 +1291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1300,7 +1300,7 @@
        "(#0) []"
       ]
      },
-     "execution_count": 30,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1321,7 +1321,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1331,7 +1331,7 @@
        "tensor([1., 1., 1.], requires_grad=True)]"
       ]
      },
-     "execution_count": 32,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1352,7 +1352,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1364,7 +1364,7 @@
        "        [ 0.8159]], requires_grad=True)]"
       ]
      },
-     "execution_count": 37,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1379,7 +1379,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1388,7 +1388,7 @@
        "torch.nn.parameter.Parameter"
       ]
      },
-     "execution_count": 41,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1406,7 +1406,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1423,7 +1423,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1452,7 +1452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -2227,31 +2227,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/11_nlp_dive.ipynb b/11_nlp_dive.ipynb
index 08962b7..767b4d3 100644
--- a/11_nlp_dive.ipynb
+++ b/11_nlp_dive.ipynb
@@ -1281,31 +1281,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/12_better_rnn.ipynb b/12_better_rnn.ipynb
index 39c859a..88d9e23 100644
--- a/12_better_rnn.ipynb
+++ b/12_better_rnn.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "hide_input": false
    },
@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -133,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -154,7 +154,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -399,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -432,7 +432,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -462,7 +462,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -471,7 +471,7 @@
        "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
       ]
      },
-     "execution_count": 22,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -482,7 +482,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -491,7 +491,7 @@
        "(tensor([0, 1, 2, 3, 4]), tensor([5, 6, 7, 8, 9]))"
       ]
      },
-     "execution_count": 23,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -516,7 +516,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -538,7 +538,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -736,7 +736,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -821,7 +821,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -853,7 +853,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -871,7 +871,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -888,7 +888,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1122,34 +1122,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {
-    "height": "245px",
-    "width": "258px"
-   },
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/14_deep_conv.ipynb b/14_deep_conv.ipynb
index 52c4826..87e1134 100644
--- a/14_deep_conv.ipynb
+++ b/14_deep_conv.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,12 +28,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Since we are so good at recognizing threes from sevens, let's move onto something harder—recognized all 10 digits. That means we'll need to use `MNIST` instead of `MNIST_SAMPLE`:"
+    "Since we are so good at recognizing threes from sevens, let's move onto something harder—recognizing all 10 digits. That means we'll need to use `MNIST` instead of `MNIST_SAMPLE`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -61,7 +61,7 @@
        "(#2) [Path('testing'),Path('training')]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -79,7 +79,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -104,7 +104,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -147,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -163,7 +163,7 @@
    "source": [
     "Let's start with a basic CNN as a baseline. We'll use the same as we had in the last chapter, but with one tweak: we'll use more activations.\n",
     "\n",
-    "As we discussed, we generally want to double the number of filters each time we have a stride 2 layer. So, one way to increase the number of filters throughout our network is to double the number of activations in the first layer them – then every layer after that will end up twice as big as the previous version as well.\n",
+    "As we discussed, we generally want to double the number of filters each time we have a stride 2 layer. So, one way to increase the number of filters throughout our network is to double the number of activations in the first layer – then every layer after that will end up twice as big as the previous version as well.\n",
     "\n",
     "But there is a subtle problem with this. Consider the kernel which is being applied to each pixel. By default, we use a 3x3 pixel kernel. That means that there are a total of 3×3 = 9 pixels that the kernel is being applied to at each location. Previously, our first layer had four filters output. That meant that there were four values being computed from nine pixels at each location. Think about what happens if we double this output to 8 filters. Then when we apply our kernel we would be using nine pixels to calculate eight numbers. That means that it isn't really learning much at all — the output size is almost the same as the input size. Neural networks will only create useful features if they're forced to do so—that is, that the number of outputs from an operation is smaller than the number of inputs.\n",
     "\n",
@@ -172,7 +172,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -191,12 +191,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you'll see in a moment, we're going to look inside our models while they're training, in order to try to find ways to make them train better. To do this, we use the `ActivationStats` callback, which records the mean, standard deviation, and histogram of activations of every trainable layer (as we've seen, callbacks are used to add behavior to the training loop; we'll see how they work in <<chapter_callbacks>>)."
+    "As you'll see in a moment, we're going to look inside our models while they're training in order to try to find ways to make them train better. To do this, we use the `ActivationStats` callback, which records the mean, standard deviation, and histogram of activations of every trainable layer (as we've seen, callbacks are used to add behavior to the training loop; we'll see how they work in <<chapter_callbacks>>)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -212,7 +212,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -225,7 +225,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -270,14 +270,14 @@
    "source": [
     "This didn't train at all well! Let's find out why.\n",
     "\n",
-    "One handy feature of callbacks that you pass to `Learner` is that they are made available automatically, with the same name as the callback class, except in `camel_case`. So our `ActivationStats` callback can be accessed through `activation_stats`. In fact--I'm sure you remember `learn.recorder`... can you guess how that is implemented? That's right, it's a callback called `Recorder`!\n",
+    "One handy feature of the callbacks passed to `Learner` is that they are made available automatically, with the same name as the callback class, except in `camel_case`. So our `ActivationStats` callback can be accessed through `activation_stats`. In fact--I'm sure you remember `learn.recorder`... can you guess how that is implemented? That's right, it's a callback called `Recorder`!\n",
     "\n",
     "`ActivationStats` includes some handy utilities for plotting the activations during training. `plot_layer_stats(idx)` plots the mean and standard deviation of the activations of layer number `idx`, along with the percent of activations near zero. Here's the first layer's plot:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -306,7 +306,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -349,7 +349,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -358,7 +358,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -406,7 +406,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -446,7 +446,7 @@
    "source": [
     "Our initial weights are not well suited to the task we're trying to solve. Therefore, it is dangerous to begin training with a high learning rate: we may very well make the training diverge instantly, as we've seen above. We probably don't want to end training with a high learning rate either, so that we don't skip over a minimum. But we want to train at a high learning rate for the rest of training, because we'll be able to train more quickly. Therefore, we should change the learning rate during training, from low, to high, and then back to low again.\n",
     "\n",
-    "Leslie Smith (yes, the same guy that invented the learning rate finder!) developed this idea in his article [Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates](https://arxiv.org/abs/1708.07120) by designing a schedule for learning rate separated in two phases: one were the learning rate grows from the minimum value to the maximum value (*warm-up*) then one where it decreases back to the minimum value (*annealing*). Smith called this combination of approaches *1cycle training*.\n",
+    "Leslie Smith (yes, the same guy that invented the learning rate finder!) developed this idea in his article [Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates](https://arxiv.org/abs/1708.07120) by designing a schedule for learning rate separated in two phases: one were the learning rate grows from the minimum value to the maximum value (*warm-up*), and then one where it decreases back to the minimum value (*annealing*). Smith called this combination of approaches *1cycle training*.\n",
     "\n",
     "1cycle training allows us to use a much higher maximum learning rate than other types of training, which gives two benefits:\n",
     "\n",
@@ -457,14 +457,14 @@
     "\n",
     "Then, once we have found a nice smooth area for our parameters, we then want to find the very best part of that area, which means we have to bring out learning rates down again. This is why 1cycle training has a gradual learning rate warmup, and a gradual learning rate cooldown. Many researchers have found that in practice this approach leads to more accurate models, and trains more quickly. That is why it is the approach that is used by default for `fine_tune` in fastai.\n",
     "\n",
-    "Later in this book we'll learn all about *momentum* in SGD. Briefly, momentum is a technique where the optimizer takes a step not only in the direction of the gradients, but also continues in the direction of previous steps. Leslie Smith introduced cyclical momentums in [A disciplined approach to neural network hyper-parameters: Part 1](https://arxiv.org/pdf/1803.09820.pdf). It suggests that the momentum vary in the opposite direction of the learning rate: when we are at high learning rate, we use less momentum, and we use more again in the annealing phase.\n",
+    "Later in this book we'll learn all about *momentum* in SGD. Briefly, momentum is a technique where the optimizer takes a step not only in the direction of the gradients, but also continues in the direction of previous steps. Leslie Smith introduced cyclical momentums in [A disciplined approach to neural network hyper-parameters: Part 1](https://arxiv.org/pdf/1803.09820.pdf). It suggests that the momentum varies in the opposite direction of the learning rate: when we are at high learning rate, we use less momentum, and we use more again in the annealing phase.\n",
     "\n",
     "We can use 1cycle training in fastai by calling `fit_one_cycle`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -477,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -527,7 +527,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -564,7 +564,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -595,7 +595,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -656,7 +656,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -729,7 +729,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -749,7 +749,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -797,7 +797,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -830,7 +830,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -1037,31 +1037,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/16_arch_details.ipynb b/16_arch_details.ipynb
index 6c5492a..5a6dc7d 100644
--- a/16_arch_details.ipynb
+++ b/16_arch_details.ipynb
@@ -444,31 +444,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/17_accel_sgd.ipynb b/17_accel_sgd.ipynb
index 4c6ffcd..d0c1e09 100644
--- a/17_accel_sgd.ipynb
+++ b/17_accel_sgd.ipynb
@@ -953,31 +953,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/18_callbacks.ipynb b/18_callbacks.ipynb
index 475640a..91281a0 100644
--- a/18_callbacks.ipynb
+++ b/18_callbacks.ipynb
@@ -392,31 +392,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/20_CAM.ipynb b/20_CAM.ipynb
index 9d0c824..82957c9 100644
--- a/20_CAM.ipynb
+++ b/20_CAM.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "hide_input": false
    },
@@ -55,7 +55,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -140,7 +140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -157,7 +157,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -174,7 +174,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -191,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -207,7 +207,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -232,7 +232,7 @@
        "tensor([[2.7374e-09, 1.0000e+00]], device='cuda:5')"
       ]
      },
-     "execution_count": 8,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -250,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -259,7 +259,7 @@
        "(#2) [False,True]"
       ]
      },
-     "execution_count": 9,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -284,7 +284,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -293,7 +293,7 @@
        "torch.Size([1, 3, 224, 224])"
       ]
      },
-     "execution_count": 10,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -304,7 +304,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -313,7 +313,7 @@
        "torch.Size([2, 7, 7])"
       ]
      },
-     "execution_count": 11,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -334,7 +334,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -369,7 +369,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -385,7 +385,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -406,7 +406,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -440,7 +440,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -462,7 +462,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -484,7 +484,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -494,7 +494,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -526,7 +526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -540,7 +540,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -557,7 +557,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -637,31 +637,6 @@
    "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.5"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": false,
-   "sideBar": true,
-   "skip_h1_title": true,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
   }
  },
  "nbformat": 4,
diff --git a/21_learner.ipynb b/21_learner.ipynb
index f352f07..81054d7 100644
--- a/21_learner.ipynb
+++ b/21_learner.ipynb
@@ -23,7 +23,7 @@
    "source": [
     "This final chapter (other than the conclusion, and the online chapters) is going to look a bit different. We will have far more code, and far less pros than previous chapters. We will introduce new Python keywords and libraries without discussing them. This chapter is meant to be the start of a significant research project for you. You see, we are going to implement all of the key pieces of the fastai and PyTorch APIs from scratch, building on nothing other than the components that we developed in <<chapter_foundations>>! The key goal here is to end up with our own `Learner` class, and some callbacks--enough to be able to train a model on Imagenette, including examples of each of the key techniques we've studied. On the way to building Learner, we will be creating Module, Parameter, and even our own parallel DataLoader… and much more.\n",
     "\n",
-    "The end of chapter questionnaire is particularly important for this chapter. This is where we will be getting you started on the many interesting directions that you could take, using this chapter as your starting out point. What we really saying is: follow through with this chapter on your computer, not on paper, and do lots of experiments, web searches, and whatever else you need to understand what's going on. You've built up the skills and expertise to do this in the rest of this book, so we think you are going to go great!"
+    "The end of chapter questionnaire is particularly important for this chapter. This is where we will be getting you started on the many interesting directions that you could take, using this chapter as your starting out point. What we are really saying is: follow through with this chapter on your computer, not on paper, and do lots of experiments, web searches, and whatever else you need to understand what's going on. You've built up the skills and expertise to do this in the rest of this book, so we think you are going to go great!"
    ]
   },
   {
diff --git a/images/0_jupyter.png b/images/0_jupyter.png
index edba285..a358186 100644
Binary files a/images/0_jupyter.png and b/images/0_jupyter.png differ
diff --git a/images/Dropout.png b/images/Dropout.png
index fc9c1a8..fcc51ce 100644
Binary files a/images/Dropout.png and b/images/Dropout.png differ
diff --git a/images/Dropout1.png b/images/Dropout1.png
index dad87e6..0d6d169 100644
Binary files a/images/Dropout1.png and b/images/Dropout1.png differ
diff --git a/images/LSTM.png b/images/LSTM.png
index 41e2d93..30e7c1a 100644
Binary files a/images/LSTM.png and b/images/LSTM.png differ
diff --git a/images/att_00000.png b/images/att_00000.png
index 8e12ffe..092a75e 100644
Binary files a/images/att_00000.png and b/images/att_00000.png differ
diff --git a/images/att_00001.png b/images/att_00001.png
index dbd0732..861f39e 100644
Binary files a/images/att_00001.png and b/images/att_00001.png differ
diff --git a/images/att_00002.png b/images/att_00002.png
index e04fa2a..40c710b 100644
Binary files a/images/att_00002.png and b/images/att_00002.png differ
diff --git a/images/att_00003.png b/images/att_00003.png
index 555d26e..e497368 100644
Binary files a/images/att_00003.png and b/images/att_00003.png differ
diff --git a/images/att_00004.png b/images/att_00004.png
index 6e6f8cc..21577bf 100644
Binary files a/images/att_00004.png and b/images/att_00004.png differ
diff --git a/images/att_00005.png b/images/att_00005.png
index 721bc8f..3c39e1b 100644
Binary files a/images/att_00005.png and b/images/att_00005.png differ
diff --git a/images/att_00006.png b/images/att_00006.png
index b68aa7b..5feff29 100644
Binary files a/images/att_00006.png and b/images/att_00006.png differ
diff --git a/images/att_00007.png b/images/att_00007.png
index e04fa2a..40c710b 100644
Binary files a/images/att_00007.png and b/images/att_00007.png differ
diff --git a/images/att_00008.png b/images/att_00008.png
index 555d26e..e497368 100644
Binary files a/images/att_00008.png and b/images/att_00008.png differ
diff --git a/images/att_00009.png b/images/att_00009.png
index 6e6f8cc..21577bf 100644
Binary files a/images/att_00009.png and b/images/att_00009.png differ
diff --git a/images/att_00010.png b/images/att_00010.png
index 721bc8f..3c39e1b 100644
Binary files a/images/att_00010.png and b/images/att_00010.png differ
diff --git a/images/att_00011.png b/images/att_00011.png
index b68aa7b..5feff29 100644
Binary files a/images/att_00011.png and b/images/att_00011.png differ
diff --git a/images/att_00012.png b/images/att_00012.png
index d2a05dd..8abb382 100644
Binary files a/images/att_00012.png and b/images/att_00012.png differ
diff --git a/images/att_00013.png b/images/att_00013.png
index 62a324d..bb5618d 100644
Binary files a/images/att_00013.png and b/images/att_00013.png differ
diff --git a/images/att_00014.png b/images/att_00014.png
index 1856310..b922165 100644
Binary files a/images/att_00014.png and b/images/att_00014.png differ
diff --git a/images/att_00015.png b/images/att_00015.png
index f551cf5..f9a7c1e 100644
Binary files a/images/att_00015.png and b/images/att_00015.png differ
diff --git a/images/att_00016.png b/images/att_00016.png
index ce94b4e..d46cd16 100644
Binary files a/images/att_00016.png and b/images/att_00016.png differ
diff --git a/images/att_00017.png b/images/att_00017.png
index 9ff8f3a..94d65a8 100644
Binary files a/images/att_00017.png and b/images/att_00017.png differ
diff --git a/images/att_00018.png b/images/att_00018.png
index 8e50df2..ddb5eea 100644
Binary files a/images/att_00018.png and b/images/att_00018.png differ
diff --git a/images/att_00019.png b/images/att_00019.png
index a223387..bcb48ed 100644
Binary files a/images/att_00019.png and b/images/att_00019.png differ
diff --git a/images/att_00020.png b/images/att_00020.png
index 26e686e..747c201 100644
Binary files a/images/att_00020.png and b/images/att_00020.png differ
diff --git a/images/att_00021.png b/images/att_00021.png
index 63de323..e00dd02 100644
Binary files a/images/att_00021.png and b/images/att_00021.png differ
diff --git a/images/att_00022.png b/images/att_00022.png
index 62f0986..4630e88 100644
Binary files a/images/att_00022.png and b/images/att_00022.png differ
diff --git a/images/att_00023.png b/images/att_00023.png
index 99e8be6..ca3f514 100644
Binary files a/images/att_00023.png and b/images/att_00023.png differ
diff --git a/images/att_00024.png b/images/att_00024.png
index 9ec3434..a9c1f7f 100644
Binary files a/images/att_00024.png and b/images/att_00024.png differ
diff --git a/images/att_00025.png b/images/att_00025.png
index 15c4682..64465f6 100644
Binary files a/images/att_00025.png and b/images/att_00025.png differ
diff --git a/images/att_00026.png b/images/att_00026.png
index b717939..e76ecf4 100644
Binary files a/images/att_00026.png and b/images/att_00026.png differ
diff --git a/images/att_00027.png b/images/att_00027.png
index 8cebce1..a16ca0c 100644
Binary files a/images/att_00027.png and b/images/att_00027.png differ
diff --git a/images/att_00028.png b/images/att_00028.png
index bcbc411..8a34a4c 100644
Binary files a/images/att_00028.png and b/images/att_00028.png differ
diff --git a/images/att_00029.png b/images/att_00029.png
index 9c1b12d..20e5dbe 100644
Binary files a/images/att_00029.png and b/images/att_00029.png differ
diff --git a/images/att_00030.png b/images/att_00030.png
index 00c58f5..84a8f8d 100644
Binary files a/images/att_00030.png and b/images/att_00030.png differ
diff --git a/images/att_00031.png b/images/att_00031.png
index edc3e52..2f57fdf 100644
Binary files a/images/att_00031.png and b/images/att_00031.png differ
diff --git a/images/att_00032.png b/images/att_00032.png
index 1e117ca..40ac666 100644
Binary files a/images/att_00032.png and b/images/att_00032.png differ
diff --git a/images/att_00033.png b/images/att_00033.png
index 220c369..4ceb02c 100644
Binary files a/images/att_00033.png and b/images/att_00033.png differ
diff --git a/images/att_00034.png b/images/att_00034.png
index e02bbc5..2cda351 100644
Binary files a/images/att_00034.png and b/images/att_00034.png differ
diff --git a/images/att_00035.png b/images/att_00035.png
index e252d32..8a71cd5 100644
Binary files a/images/att_00035.png and b/images/att_00035.png differ
diff --git a/images/att_00036.png b/images/att_00036.png
index b2eb07c..e02df25 100644
Binary files a/images/att_00036.png and b/images/att_00036.png differ
diff --git a/images/att_00037.png b/images/att_00037.png
index e6090f5..5ea5428 100644
Binary files a/images/att_00037.png and b/images/att_00037.png differ
diff --git a/images/att_00038.png b/images/att_00038.png
index ec6a0cd..10702f7 100644
Binary files a/images/att_00038.png and b/images/att_00038.png differ
diff --git a/images/att_00039.png b/images/att_00039.png
index 011fca3..d69a3f0 100644
Binary files a/images/att_00039.png and b/images/att_00039.png differ
diff --git a/images/att_00040.png b/images/att_00040.png
index 54621fe..aca0292 100644
Binary files a/images/att_00040.png and b/images/att_00040.png differ
diff --git a/images/att_00041.png b/images/att_00041.png
index deac415..5b32634 100644
Binary files a/images/att_00041.png and b/images/att_00041.png differ
diff --git a/images/att_00042.png b/images/att_00042.png
index 321add7..fe42139 100644
Binary files a/images/att_00042.png and b/images/att_00042.png differ
diff --git a/images/att_00043.png b/images/att_00043.png
index 5b1dc67..ce34eaa 100644
Binary files a/images/att_00043.png and b/images/att_00043.png differ
diff --git a/images/att_00044.png b/images/att_00044.png
index 8a6f579..f8160d8 100644
Binary files a/images/att_00044.png and b/images/att_00044.png differ
diff --git a/images/att_00045.png b/images/att_00045.png
index 8e283ed..1907f9d 100644
Binary files a/images/att_00045.png and b/images/att_00045.png differ
diff --git a/images/att_00046.png b/images/att_00046.png
index 42dc575..b19c31a 100644
Binary files a/images/att_00046.png and b/images/att_00046.png differ
diff --git a/images/att_00047.png b/images/att_00047.png
index 2a08960..975d096 100644
Binary files a/images/att_00047.png and b/images/att_00047.png differ
diff --git a/images/att_00048.png b/images/att_00048.png
index f88319c..f6c01ed 100644
Binary files a/images/att_00048.png and b/images/att_00048.png differ
diff --git a/images/att_00049.png b/images/att_00049.png
index 229828f..c41a47a 100644
Binary files a/images/att_00049.png and b/images/att_00049.png differ
diff --git a/images/att_00050.png b/images/att_00050.png
index b0b907d..5c86f9d 100644
Binary files a/images/att_00050.png and b/images/att_00050.png differ
diff --git a/images/att_00051.png b/images/att_00051.png
index 547eaec..83f9468 100644
Binary files a/images/att_00051.png and b/images/att_00051.png differ
diff --git a/images/att_00052.png b/images/att_00052.png
index 2b0f38f..b8991ab 100644
Binary files a/images/att_00052.png and b/images/att_00052.png differ
diff --git a/images/att_00053.png b/images/att_00053.png
index af53b15..28c6128 100644
Binary files a/images/att_00053.png and b/images/att_00053.png differ
diff --git a/images/att_00054.png b/images/att_00054.png
index 2729935..03d8c42 100644
Binary files a/images/att_00054.png and b/images/att_00054.png differ
diff --git a/images/att_00055.png b/images/att_00055.png
index 2745d59..d53c42a 100644
Binary files a/images/att_00055.png and b/images/att_00055.png differ
diff --git a/images/att_00056.png b/images/att_00056.png
index d944304..a8bc11b 100644
Binary files a/images/att_00056.png and b/images/att_00056.png differ
diff --git a/images/att_00057.png b/images/att_00057.png
index f6d1e6d..17d572d 100644
Binary files a/images/att_00057.png and b/images/att_00057.png differ
diff --git a/images/att_00058.png b/images/att_00058.png
index d9ac5a1..86dd849 100644
Binary files a/images/att_00058.png and b/images/att_00058.png differ
diff --git a/images/att_00059.png b/images/att_00059.png
index 87e8ae6..9598a90 100644
Binary files a/images/att_00059.png and b/images/att_00059.png differ
diff --git a/images/att_00060.png b/images/att_00060.png
index 5e708b4..f25fd81 100644
Binary files a/images/att_00060.png and b/images/att_00060.png differ
diff --git a/images/att_00061.png b/images/att_00061.png
index 1912167..1af8595 100644
Binary files a/images/att_00061.png and b/images/att_00061.png differ
diff --git a/images/att_00062.png b/images/att_00062.png
index 9d6e758..25ad1b8 100644
Binary files a/images/att_00062.png and b/images/att_00062.png differ
diff --git a/images/att_00063.png b/images/att_00063.png
index 737b25e..4f61e2c 100644
Binary files a/images/att_00063.png and b/images/att_00063.png differ
diff --git a/images/att_00064.png b/images/att_00064.png
index 202669d..50c5ead 100644
Binary files a/images/att_00064.png and b/images/att_00064.png differ
diff --git a/images/att_00065.png b/images/att_00065.png
index f2911db..997170e 100644
Binary files a/images/att_00065.png and b/images/att_00065.png differ
diff --git a/images/att_00066.png b/images/att_00066.png
index 0217de2..2fc99e2 100644
Binary files a/images/att_00066.png and b/images/att_00066.png differ
diff --git a/images/att_00067.png b/images/att_00067.png
index 613ed9c..841f132 100644
Binary files a/images/att_00067.png and b/images/att_00067.png differ
diff --git a/images/att_00068.png b/images/att_00068.png
index c995e85..ffe29d4 100644
Binary files a/images/att_00068.png and b/images/att_00068.png differ
diff --git a/images/att_00069.png b/images/att_00069.png
index ae4ead1..8db76f5 100644
Binary files a/images/att_00069.png and b/images/att_00069.png differ
diff --git a/images/att_00070.png b/images/att_00070.png
index edbdd02..e614898 100644
Binary files a/images/att_00070.png and b/images/att_00070.png differ
diff --git a/images/att_00071.png b/images/att_00071.png
index 856fc5c..1483d74 100644
Binary files a/images/att_00071.png and b/images/att_00071.png differ
diff --git a/images/chapter1_add.png b/images/chapter1_add.png
index 2647935..aa92da5 100644
Binary files a/images/chapter1_add.png and b/images/chapter1_add.png differ
diff --git a/images/chapter1_busy.png b/images/chapter1_busy.png
index d4198d7..4e0407d 100644
Binary files a/images/chapter1_busy.png and b/images/chapter1_busy.png differ
diff --git a/images/chapter1_markdown.png b/images/chapter1_markdown.png
index c38852f..55d97b3 100644
Binary files a/images/chapter1_markdown.png and b/images/chapter1_markdown.png differ
diff --git a/images/chapter1_new_notebook.png b/images/chapter1_new_notebook.png
index ca52feb..61c4942 100644
Binary files a/images/chapter1_new_notebook.png and b/images/chapter1_new_notebook.png differ
diff --git a/images/chapter1_run.png b/images/chapter1_run.png
index 7a02242..0d69367 100644
Binary files a/images/chapter1_run.png and b/images/chapter1_run.png differ
diff --git a/images/chapter1_save.png b/images/chapter1_save.png
index d232d49..1321fb6 100644
Binary files a/images/chapter1_save.png and b/images/chapter1_save.png differ
diff --git a/images/chapter1_terminal.png b/images/chapter1_terminal.png
index b0265d3..3b1c7a4 100644
Binary files a/images/chapter1_terminal.png and b/images/chapter1_terminal.png differ
diff --git a/images/chapter2_bouncing.PNG b/images/chapter2_bouncing.PNG
index 99124a9..982896a 100644
Binary files a/images/chapter2_bouncing.PNG and b/images/chapter2_bouncing.PNG differ
diff --git a/images/chapter2_derivative.PNG b/images/chapter2_derivative.PNG
index df6a1bc..4bf0238 100644
Binary files a/images/chapter2_derivative.PNG and b/images/chapter2_derivative.PNG differ
diff --git a/images/chapter2_layer1and2.PNG b/images/chapter2_layer1and2.PNG
index 0709ed8..a4fcc2c 100644
Binary files a/images/chapter2_layer1and2.PNG and b/images/chapter2_layer1and2.PNG differ
diff --git a/images/chapter2_layer3.PNG b/images/chapter2_layer3.PNG
index e8ba124..6d5c534 100644
Binary files a/images/chapter2_layer3.PNG and b/images/chapter2_layer3.PNG differ
diff --git a/images/chapter2_layer4and5.PNG b/images/chapter2_layer4and5.PNG
index 97b5129..3b49d47 100644
Binary files a/images/chapter2_layer4and5.PNG and b/images/chapter2_layer4and5.PNG differ
diff --git a/images/chapter2_sgd.PNG b/images/chapter2_sgd.PNG
index 8bb27bb..28e59cc 100644
Binary files a/images/chapter2_sgd.PNG and b/images/chapter2_sgd.PNG differ
diff --git a/images/chapter4_1cycle_schedule.png b/images/chapter4_1cycle_schedule.png
index eac204f..576bd78 100644
Binary files a/images/chapter4_1cycle_schedule.png and b/images/chapter4_1cycle_schedule.png differ
diff --git a/images/chapter4_overfit.png b/images/chapter4_overfit.png
index 68dec22..eb4cc32 100644
Binary files a/images/chapter4_overfit.png and b/images/chapter4_overfit.png differ
diff --git a/images/chapter7_neuron.png b/images/chapter7_neuron.png
index e5a8e6c..778c767 100644
Binary files a/images/chapter7_neuron.png and b/images/chapter7_neuron.png differ
diff --git a/images/chapter9_bottleneck.png b/images/chapter9_bottleneck.png
index 7afbbea..dd868e7 100644
Binary files a/images/chapter9_bottleneck.png and b/images/chapter9_bottleneck.png differ
diff --git a/images/chapter9_cat_conv.png b/images/chapter9_cat_conv.png
index 5ef6991..da9d963 100644
Binary files a/images/chapter9_cat_conv.png and b/images/chapter9_cat_conv.png differ
diff --git a/images/chapter9_conv_basic.png b/images/chapter9_conv_basic.png
index dd39b7c..54300d8 100644
Binary files a/images/chapter9_conv_basic.png and b/images/chapter9_conv_basic.png differ
diff --git a/images/chapter9_conv_pad.png b/images/chapter9_conv_pad.png
index b13301f..62e3503 100644
Binary files a/images/chapter9_conv_pad.png and b/images/chapter9_conv_pad.png differ
diff --git a/images/chapter9_conv_rgb.png b/images/chapter9_conv_rgb.png
index e92353b..efd6330 100644
Binary files a/images/chapter9_conv_rgb.png and b/images/chapter9_conv_rgb.png differ
diff --git a/images/chapter9_conv_stride.png b/images/chapter9_conv_stride.png
index d7eaf3f..88f6261 100644
Binary files a/images/chapter9_conv_stride.png and b/images/chapter9_conv_stride.png differ
diff --git a/images/chapter9_loss_landscape.png b/images/chapter9_loss_landscape.png
index 0c40bc0..4ab0603 100644
Binary files a/images/chapter9_loss_landscape.png and b/images/chapter9_loss_landscape.png differ
diff --git a/images/chapter9_skip_connection.png b/images/chapter9_skip_connection.png
index 60a29b3..74506ee 100644
Binary files a/images/chapter9_skip_connection.png and b/images/chapter9_skip_connection.png differ
diff --git a/images/colorful_summ.png b/images/colorful_summ.png
index cf108ee..81a3a79 100644
Binary files a/images/colorful_summ.png and b/images/colorful_summ.png differ
diff --git a/images/cover.png b/images/cover.png
index 15912ad..933b56d 100644
Binary files a/images/cover.png and b/images/cover.png differ
diff --git a/images/driver_phone.png b/images/driver_phone.png
index 20a64a2..989ad9d 100644
Binary files a/images/driver_phone.png and b/images/driver_phone.png differ
diff --git a/images/driver_phone2.png b/images/driver_phone2.png
index a024d1d..fa2f37f 100644
Binary files a/images/driver_phone2.png and b/images/driver_phone2.png differ
diff --git a/images/drivetrain-approach.png b/images/drivetrain-approach.png
index 814ec06..c2480f5 100644
Binary files a/images/drivetrain-approach.png and b/images/drivetrain-approach.png differ
diff --git a/images/ethics/image1.png b/images/ethics/image1.png
index e0cae59..f0e866b 100644
Binary files a/images/ethics/image1.png and b/images/ethics/image1.png differ
diff --git a/images/ethics/image10.png b/images/ethics/image10.png
index 8755ab2..207cf3f 100644
Binary files a/images/ethics/image10.png and b/images/ethics/image10.png differ
diff --git a/images/ethics/image11.png b/images/ethics/image11.png
index d130c77..017199d 100644
Binary files a/images/ethics/image11.png and b/images/ethics/image11.png differ
diff --git a/images/ethics/image12.png b/images/ethics/image12.png
index 27684c9..fed0575 100644
Binary files a/images/ethics/image12.png and b/images/ethics/image12.png differ
diff --git a/images/ethics/image13.png b/images/ethics/image13.png
index 064ad92..03b0e8e 100644
Binary files a/images/ethics/image13.png and b/images/ethics/image13.png differ
diff --git a/images/ethics/image14.png b/images/ethics/image14.png
index 68b8a4f..f93d6c1 100644
Binary files a/images/ethics/image14.png and b/images/ethics/image14.png differ
diff --git a/images/ethics/image16.png b/images/ethics/image16.png
index 3671f28..48978c6 100644
Binary files a/images/ethics/image16.png and b/images/ethics/image16.png differ
diff --git a/images/ethics/image17.png b/images/ethics/image17.png
index f9095ba..27545c2 100644
Binary files a/images/ethics/image17.png and b/images/ethics/image17.png differ
diff --git a/images/ethics/image2.png b/images/ethics/image2.png
index a9be469..a54e2e9 100644
Binary files a/images/ethics/image2.png and b/images/ethics/image2.png differ
diff --git a/images/ethics/image4.png b/images/ethics/image4.png
index 7fa7b94..7d311ac 100644
Binary files a/images/ethics/image4.png and b/images/ethics/image4.png differ
diff --git a/images/ethics/image5.png b/images/ethics/image5.png
index fe5926e..909f141 100644
Binary files a/images/ethics/image5.png and b/images/ethics/image5.png differ
diff --git a/images/ethics/image6.png b/images/ethics/image6.png
index 0263728..7a75e40 100644
Binary files a/images/ethics/image6.png and b/images/ethics/image6.png differ
diff --git a/images/ethics/image7.png b/images/ethics/image7.png
index 2e8cb03..37b4f10 100644
Binary files a/images/ethics/image7.png and b/images/ethics/image7.png differ
diff --git a/images/ethics/image8.png b/images/ethics/image8.png
index 83877e1..0fe0319 100644
Binary files a/images/ethics/image8.png and b/images/ethics/image8.png differ
diff --git a/images/fast_template/image1.png b/images/fast_template/image1.png
index 6e3bdac..9ff57b9 100644
Binary files a/images/fast_template/image1.png and b/images/fast_template/image1.png differ
diff --git a/images/fast_template/image10.png b/images/fast_template/image10.png
index 1d08559..e06e8d5 100644
Binary files a/images/fast_template/image10.png and b/images/fast_template/image10.png differ
diff --git a/images/fast_template/image11.png b/images/fast_template/image11.png
index 9f2ddff..725d460 100644
Binary files a/images/fast_template/image11.png and b/images/fast_template/image11.png differ
diff --git a/images/fast_template/image12.png b/images/fast_template/image12.png
index 37960c7..2d01a59 100644
Binary files a/images/fast_template/image12.png and b/images/fast_template/image12.png differ
diff --git a/images/fast_template/image13.png b/images/fast_template/image13.png
index 266110e..f6b4815 100644
Binary files a/images/fast_template/image13.png and b/images/fast_template/image13.png differ
diff --git a/images/fast_template/image14.png b/images/fast_template/image14.png
index 4a56112..27bddfc 100644
Binary files a/images/fast_template/image14.png and b/images/fast_template/image14.png differ
diff --git a/images/fast_template/image15.png b/images/fast_template/image15.png
index ddcb0fe..a6efa7f 100644
Binary files a/images/fast_template/image15.png and b/images/fast_template/image15.png differ
diff --git a/images/fast_template/image16.png b/images/fast_template/image16.png
index 10b3192..3e662d1 100644
Binary files a/images/fast_template/image16.png and b/images/fast_template/image16.png differ
diff --git a/images/fast_template/image2.png b/images/fast_template/image2.png
index d221317..7e5453e 100644
Binary files a/images/fast_template/image2.png and b/images/fast_template/image2.png differ
diff --git a/images/fast_template/image3.png b/images/fast_template/image3.png
index 7ecf264..5641140 100644
Binary files a/images/fast_template/image3.png and b/images/fast_template/image3.png differ
diff --git a/images/fast_template/image4.png b/images/fast_template/image4.png
index d25c0a6..023a78c 100644
Binary files a/images/fast_template/image4.png and b/images/fast_template/image4.png differ
diff --git a/images/fast_template/image5.png b/images/fast_template/image5.png
index 28a41f0..f4de339 100644
Binary files a/images/fast_template/image5.png and b/images/fast_template/image5.png differ
diff --git a/images/fast_template/image6.png b/images/fast_template/image6.png
index 52aef3a..7350800 100644
Binary files a/images/fast_template/image6.png and b/images/fast_template/image6.png differ
diff --git a/images/fast_template/image7.png b/images/fast_template/image7.png
index 90cb8fc..d0bd236 100644
Binary files a/images/fast_template/image7.png and b/images/fast_template/image7.png differ
diff --git a/images/fast_template/image8.png b/images/fast_template/image8.png
index 86e3a9f..b3b661d 100644
Binary files a/images/fast_template/image8.png and b/images/fast_template/image8.png differ
diff --git a/images/fast_template/image9.png b/images/fast_template/image9.png
index 267e97e..87196a7 100644
Binary files a/images/fast_template/image9.png and b/images/fast_template/image9.png differ
diff --git a/images/gitblog/commit.png b/images/gitblog/commit.png
index 4b8312b..25d757d 100644
Binary files a/images/gitblog/commit.png and b/images/gitblog/commit.png differ
diff --git a/images/gitblog/image1.png b/images/gitblog/image1.png
index ddcb0fe..a6efa7f 100644
Binary files a/images/gitblog/image1.png and b/images/gitblog/image1.png differ
diff --git a/images/gitblog/image2.png b/images/gitblog/image2.png
index 10b3192..3e662d1 100644
Binary files a/images/gitblog/image2.png and b/images/gitblog/image2.png differ
diff --git a/images/gitblog/image3.png b/images/gitblog/image3.png
index 077736d..50495ca 100644
Binary files a/images/gitblog/image3.png and b/images/gitblog/image3.png differ
diff --git a/images/gitblog/image4.png b/images/gitblog/image4.png
index f3c5798..143b76a 100644
Binary files a/images/gitblog/image4.png and b/images/gitblog/image4.png differ
diff --git a/images/gitblog/image5.png b/images/gitblog/image5.png
index 8972dbc..eea557d 100644
Binary files a/images/gitblog/image5.png and b/images/gitblog/image5.png differ
diff --git a/images/pratchett.png b/images/pratchett.png
index c33f6a4..7f3bb81 100644
Binary files a/images/pratchett.png and b/images/pratchett.png differ
diff --git a/images/sklearn_features.png b/images/sklearn_features.png
index 32466bf..48de773 100644
Binary files a/images/sklearn_features.png and b/images/sklearn_features.png differ
diff --git a/images/tarsier.png b/images/tarsier.png
index 8c7a5f6..8ca1bbd 100644
Binary files a/images/tarsier.png and b/images/tarsier.png differ
diff --git a/images/timeseries1.png b/images/timeseries1.png
index 9d3b987..9132290 100644
Binary files a/images/timeseries1.png and b/images/timeseries1.png differ
diff --git a/images/timeseries2.png b/images/timeseries2.png
index 5af3a51..b98c65e 100644
Binary files a/images/timeseries2.png and b/images/timeseries2.png differ
diff --git a/images/timeseries3.png b/images/timeseries3.png
index 6816358..aad1de3 100644
Binary files a/images/timeseries3.png and b/images/timeseries3.png differ