A LOT OF CLEANUP IN examples/Notebook

examples/Notebook/Configuring the Notebook and Server.ipynb

@@ -1,379 +1,295 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Running the Notebook Server"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The IPython notebook server is a custom web server that runs the notebook web application. Most of the time, users run the notebook server on their local computer using IPython's command line interface."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Starting the notebook server using the command line"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can start the notebook server from the command line (Terminal on Mac/Linux, CMD prompt on Windows) by running the following command: \n",
-    "\n",
-    "    ipython notebook\n",
-    "\n",
-    "This will print some information about the notebook server in your terminal, including the URL of the web application (by default, `http://127.0.0.1:8888`). It will then open your default web browser to this URL.\n",
-    "\n",
-    "When the notebook opens, you will see the **notebook dashboard**, which will show a list of the notebooks and subdirectories in the directory where the notebook server was started. As of IPython 2.0, the dashboard allows you to navigate to different subdirectories. Because of this, it is no longer necessary to start a separate notebook server for each subdirectory. Most of the time, you will want to start a notebook server in the highest directory in your filesystem where notebooks can be found. Often this will be your home directory.\n",
-    "\n",
-    "You can start more than one notebook server at the same time. By default, the first notebook server starts on port 8888 and later notebook servers search for open ports near that one.\n",
-    "\n",
-    "You can also specify the port manually:\n",
-    "\n",
-    "    ipython notebook --port 9999\n",
-    "\n",
-    "Or start notebook server without opening a web browser.\n",
-    "\n",
-    "    ipython notebook --no-browser\n",
-    "\n",
-    "The notebook server has a number of other command line arguments that can be displayed with the `--help` flag: \n",
-    "\n",
-    "    ipython notebook --help\n",
-    "\n",
-    "<div class=\"alert alert-failure\">\n",
-    "It used to be possible to specify kernel options, such as <code>--pylab inline</code> from the command line. This is deprecated in IPython 2.0 and will be removed in IPython 3.0. To enable matplotlib based plotting for the Python kernel use the <code>%matplotlib</code> magic command.\n",
-    "</div>\n",
-    "\n"
+    "# Configuring the Notebook and Server"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Configuring the IPython Notebook"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The notebook web server can also be configured using IPython profiles and configuration files. The Notebook web server configuration options are set in a file named `ipython_notebook_config.py` in your IPython *profile directory*. The profile directory is a subfolder of your IPython directory, which itself is usually `.ipython` in your home directory.\n",
     "\n",
     "You can display the location of your default profile directory by running the command:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/Users/bgranger/.ipython/profile_default\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!ipython profile locate default"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The default version of `ipython_notebook_config.py` lists all of the options available along with documentation for each. Changes made to that file will affect all notebook servers run under that profile. Command line options always override those set in configuration files.\n",
     "\n",
     "You can create a new profile:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ProfileCreate] Generating default config file: u'/Users/bgranger/.ipython/profile_my_profile/ipython_config.py'\r\n",
-      "[ProfileCreate] Generating default config file: u'/Users/bgranger/.ipython/profile_my_profile/ipython_qtconsole_config.py'\r\n",
-      "[ProfileCreate] Generating default config file: u'/Users/bgranger/.ipython/profile_my_profile/ipython_notebook_config.py'\r\n",
-      "[ProfileCreate] Generating default config file: u'/Users/bgranger/.ipython/profile_my_profile/ipython_nbconvert_config.py'\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!ipython profile create my_profile"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "And then view its location:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/Users/bgranger/.ipython/profile_my_profile\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!ipython profile locate my_profile"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To start the notebook server using a given profile, run the following:\n",
     "\n",
     "    ipython notebook --profile=my_profile"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "More details about IPython configuration files and profiles can be found [here](http://ipython.org/ipython-doc/dev/config/intro.html)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Securing the notebook server"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The IPython Notebook allows arbitrary code execution on the computer running it. Thus, the notebook web server should never be run on the open internet without first securing it. By default, the notebook server only listens on local network interface (`127.0.0.1`) There are two steps required to secure the notebook server:\n",
     "\n",
     "1. Setting a password\n",
     "2. Encrypt network traffic using SSL"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Setting a password"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can protect your notebook server with a simple single password by setting the `NotebookApp.password` configurable. You can prepare a hashed password using the function `IPython.lib.passwd`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'sha1:6c2164fc2b22:ed55ecf07fc0f985ab46561483c0e888e8964ae6'"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython.lib import passwd\n",
     "password = passwd(\"secret\")\n",
     "password"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can then add this to your `ipython_notebook_config.py`:\n",
     "\n",
     "```python\n",
     "# Password to use for web authentication\n",
     "c = get_config()\n",
     "c.NotebookApp.password = \n",
     "u'sha1:6c2164fc2b22:ed55ecf07fc0f985ab46561483c0e888e8964ae6'\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Using SSL/HTTPS"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When using a password, it is a good idea to also use SSL, so that your \n",
     "password is not sent unencrypted by your browser to the web server. When running the notebook on the public internet this is absolutely required.\n",
     "\n",
     "The first step is to generate an SSL certificate. A self-signed certificate can be generated with ``openssl``.  For example, the following command will create a certificate valid for 365 days with both the key and certificate data written to the same file:\n",
     "\n",
     "    openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout mycert.pem -out mycert.pem\n",
     "\n",
     "In most cases, you should run this command in your profile directory, which will make it easy to use the generated key and certificate.\n",
     "\n",
     "When you connect to a notebook server over HTTPS using a self-signed certificate, your browser will warn you of a dangerous certificate because it is self-signed.  If you want to have a fully compliant certificate that will not raise warnings, it is possible (but rather involved) to obtain one,\n",
     "as explained in detail in [this tutorial](http://arstechnica.com/security/news/2009/12/how-to-get-set-with-a-secure-sertificate-for-free.ars)\n",
     "\t\n",
     "When you enable SSL support, you will need to access the notebook server over ``https://``, rather than plain ``http://``.  The startup message from the notebook server prints the correct URL, but it is easy to overlook and think the server is for some reason non-responsive.\n",
     "\n",
     "Once you have generated the key and certificate, you can configure the notebook server to use them, by adding the following to `ipython_notebook_config.py`:\n",
     "\n",
     "```python\n",
     "# The full path to an SSL/TLS certificate file.\n",
     "c.NotebookApp.certfile = u'/Users/bgranger/.ipython/profile_my_profile/mycert.crt'\n",
     "\n",
     "# The full path to a private key file for usage with SSL/TLS.\n",
     "c.NotebookApp.keyfile = u'/Users/bgranger/.ipython/profile_my_profile/mycert.key'\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Running a public notebook server"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<div class=\"alert alert-error\">\n",
     "Don't run a public notebook server unless you first secure it with a password and SSL/HTTPS as described above\n",
     "</div>\n",
     "\n",
     "By default the notebook server only listens on the `localhost/127.0.0.1` network interface. If you want to connect to the notebook from another computers, or over the internet, you need to configure the notebook server to listen on all network interfaces and not open the browser. You will often also want to disable the automatic launching of the web browser.\n",
     "\n",
     "This can be accomplished by passing a command line options.\n",
     "\n",
     "    ipython notebook --ip=* --no-browser\n",
     "\n",
     "You can also add the following to your`ipython_notebook_config.py` file:\n",
     "\n",
     "```python\n",
     "c.NotebookApp.ip = '*'\n",
     "c.NotebookApp.open_browser = False\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Running with a different URL prefix"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The notebook dashboard typically lives at the URL `http://localhost:8888/tree`. If you prefer that it lives, together with the \n",
     "rest of the notebook web application, under a base URL prefix, such as `http://localhost:8888/ipython/tree`, you can do so by adding the following lines to your `ipython_notebook_config.py` file.\n",
     "\n",
     "```python\n",
     "c.NotebookApp.base_url = '/ipython/'\n",
     "c.NotebookApp.webapp_settings = {'static_url_prefix':'/ipython/static/'}\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Using a different notebook store"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "By default, the notebook server stores the notebook documents that it saves as files in the working directory of the notebook server, also known as the\n",
     "`notebook_dir`. This  logic is implemented in the `FileNotebookManager` class. However, the server can be configured to use a different notebook manager class, which can store the notebooks in a different format. \n",
     "\n",
     "The [bookstore](https://github.com/rgbkrk/bookstore) package currently allows users to store notebooks on Rackspace CloudFiles or OpenStack Swift based object stores.\n",
     "\n",
     "Writing a notebook manager is as simple as extending the base class `NotebookManager`. The [simple_notebook_manager](https://github.com/khinsen/simple_notebook_manager) provides a great example\n",
     "of an in memory notebook manager, created solely for the purpose of\n",
     "illustrating the notebook manager API."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Known issues"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When behind a proxy, especially if your system or browser is set to autodetect the proxy, the notebook web application might fail to connect to the server's websockets, and present you with a warning at startup. In this case, you need to configure your system not to use the proxy for the server's address.\n",
     "\n",
     "For example, in Firefox, go to the Preferences panel, Advanced section,\n",
     "Network tab, click 'Settings...', and add the address of the notebook server\n",
     "to the 'No proxy for' field."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Connecting with the Qt Console.ipynb

@@ -1,155 +1,132 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Connecting to an existing IPython kernel using the Qt Console"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## The Frontend/Kernel Model"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The traditional IPython (`ipython`) consists of a single process that combines a terminal based UI with the process that runs the users code.\n",
     "\n",
     "While this traditional application still exists, the modern IPython consists of two processes:\n",
     "\n",
     "* Kernel: this is the process that runs the users code.\n",
     "* Frontend: this is the process that provides the user interface where the user types code and sees results.\n",
     "\n",
     "IPython currently has 3 frontends:\n",
     "\n",
     "* Terminal Console (`ipython console`)\n",
     "* Qt Console (`ipython qtconsole`)\n",
     "* Notebook (`ipython notebook`)\n",
     "\n",
     "The Kernel and Frontend communicate over a ZeroMQ/JSON based messaging protocol, which allows multiple Frontends (even of different types) to communicate with a single Kernel. This opens the door for all sorts of interesting things, such as connecting a Console or Qt Console to a Notebook's Kernel.  For example, you may want to connect a Qt console to your Notebook's Kernel and use it as a help\n",
     "browser, calling `??` on objects in the Qt console (whose pager is more flexible than the\n",
     "one in the notebook).  \n",
     "\n",
     "This Notebook describes how you would connect another Frontend to a Kernel that is associated with a Notebook."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Manual connection"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To connect another Frontend to a Kernel manually, you first need to find out the connection information for the Kernel using the `%connect_info` magic:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{\n",
-      "  \"stdin_port\": 52858, \n",
-      "  \"ip\": \"127.0.0.1\", \n",
-      "  \"hb_port\": 52859, \n",
-      "  \"key\": \"7efd45ca-d8a2-41b0-9cea-d9116d0fb883\", \n",
-      "  \"shell_port\": 52856, \n",
-      "  \"iopub_port\": 52857\n",
-      "}\n",
-      "\n",
-      "Paste the above JSON into a file, and connect with:\n",
-      "    $> ipython <app> --existing <file>\n",
-      "or, if you are local, you can connect with just:\n",
-      "    $> ipython <app> --existing kernel-b3bac7c1-8b2c-4536-8082-8d1df24f99ac.json \n",
-      "or even just:\n",
-      "    $> ipython <app> --existing \n",
-      "if this is the most recent IPython session you have started.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%connect_info"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can see that this magic displays everything you need to connect to this Notebook's Kernel."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Automatic connection using a new Qt Console"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also start a new Qt Console connected to your current Kernel by using the `%qtconsole` magic. This will detect the necessary connection\n",
     "information and start the Qt Console for you automatically."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "a = 10"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "%qtconsole"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Converting Notebooks With nbconvert.ipynb

@@ -1,503 +1,317 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# NbConvert"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Command line usage"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`NbConvert` is the library, and the command line tool that allow to convert from notebook to other formats.\n",
-    "It is a technological preview in 1.0 but is already usable and highly configurable.\n",
-    "It ships already with many default available formats : `html`, `latex`, `markdown`, `python`, `rst` and  `slides`\n",
-    "which are fully base on Jinja templating engine, so writing a converter for your custom format or tweeking the existing \n",
-    "one should be extra simple."
+    "`NbConvert` is both a library and command line tool that allows you to convert notebooks to other formats.  It ships with many common formats: `html`, `latex`, `markdown`, `python`, `rst`, and  `slides`\n",
+    "NbConvert relys on the Jinja templating engine, so implementing a new format or tweeking an existing one is easy."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can invoke nbconvert by doing\n",
+    "You can invoke nbconvert by running\n",
     "\n",
     "```bash\n",
     "$ ipython nbconvert <options and arguments>\n",
     "```\n",
     "\n",
-    "Call `ipython nbconvert` with the `--help` flag or no aruments to get basic help on how to use it.\n",
-    "For more information about configuration use the `--help-all` flag"
+    "Call `ipython nbconvert` with the `--help` flag or without any aruments to display the basic help.  For detailed configuration help, use the `--help-all` flag."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Basic export"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We will be converting `Custom Display Logic.ipynb`. \n",
-    "Be sure to have runed some of the cells in it to have output otherwise you will only see input in nbconvert.\n",
-    "Nbconvert **do not execute the code** in the notebook files, it only converts what is inside."
+    "As a test, the `Index.ipynb` notebook in the directory will be convert. \n",
+    "\n",
+    "If you're converting a notebook with code in it, make sure to run the code cells that you're interested in before attempting to convert the notebook.  Nbconvert **does not execute the code cell** of the notebooks that it converts."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[NbConvertApp] Using existing profile dir: u'/Users/bussonniermatthias/.ipython/profile_default'\n",
-      "[NbConvertApp] Converting notebook 04 - Custom Display Logic.ipynb to html\n",
-      "[NbConvertApp] Support files will be in 04 - Custom Display Logic_files/\n",
-      "[NbConvertApp] Loaded template html_full.tpl\n",
-      "[NbConvertApp] Writing 221081 bytes to 04 - Custom Display Logic.html\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%bash\n",
-    "ipython nbconvert  '04 - Custom Display Logic.ipynb'"
+    "ipython nbconvert  'Index.ipynb'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Html is the default value (that can be configured) , so the verbose form would be "
+    "Html is the (configurable) default value.  The verbose form of the same command as above is "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[NbConvertApp] Using existing profile dir: u'/Users/bussonniermatthias/.ipython/profile_default'\n",
-      "[NbConvertApp] Converting notebook 04 - Custom Display Logic.ipynb to html\n",
-      "[NbConvertApp] Support files will be in 04 - Custom Display Logic_files/\n",
-      "[NbConvertApp] Loaded template html_full.tpl\n",
-      "[NbConvertApp] Writing 221081 bytes to 04 - Custom Display Logic.html\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%bash\n",
-    "ipython nbconvert  --to=html '04 - Custom Display Logic.ipynb'"
+    "ipython nbconvert  --to=html 'Index.ipynb'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can also convert to latex, which will take care of extractin the embeded base64 encoded png, or the svg and call inkscape to convert those svg to pdf if necessary :"
+    "You can also convert to latex, which will extract the embeded images.  If the embeded images are SVGs, inkscape is used to convert them to pdf:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[NbConvertApp] Using existing profile dir: u'/Users/bussonniermatthias/.ipython/profile_default'\n",
-      "[NbConvertApp] Converting notebook 04 - Custom Display Logic.ipynb to latex\n",
-      "[NbConvertApp] Support files will be in 04 - Custom Display Logic_files/\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26432): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26472): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26512): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26552): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26592): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "[NbConvertApp] Loaded template latex_article.tplx\n",
-      "[NbConvertApp] Writing 41196 bytes to 04 - Custom Display Logic.tex\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%bash\n",
-    "ipython nbconvert  --to=latex '04 - Custom Display Logic.ipynb'"
+    "ipython nbconvert  --to=latex 'Index.ipynb'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You should just have to compile the generated `.tex` file. If you get the required packages installed, if should compile out of the box.\n",
+    "Note that the latex conversion creates latex, not a PDF.  To create a PDF you need the required third party packages to compile the latex.\n",
     "\n",
-    "For convenience we allow to run extra action after the conversion has been done, in particular for `latex` we have a `pdf` post-processor. \n",
-    "You can define the postprocessor tu run with the `--post` flag."
+    "A `--post` flag is provided for convinience which allows you to have nbconvert automatically compile a PDF for you from your output."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[NbConvertApp] Using existing profile dir: u'/Users/bussonniermatthias/.ipython/profile_default'\n",
-      "[NbConvertApp] Converting notebook 04 - Custom Display Logic.ipynb to latex\n",
-      "[NbConvertApp] Support files will be in 04 - Custom Display Logic_files/\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26658): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26698): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26738): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26778): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "Setting Language: .UTF-8\n",
-      "\n",
-      "(process:26818): Gtk-WARNING **: Locale not supported by C library.\n",
-      "\tUsing the fallback 'C' locale.\n",
-      "[NbConvertApp] Loaded template latex_article.tplx\n",
-      "[NbConvertApp] Writing 41196 bytes to 04 - Custom Display Logic.tex\n",
-      "[NbConvertApp] Building PDF: ['pdflatex', '04 - Custom Display Logic.tex']\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%bash\n",
-    "ipython nbconvert  --to=latex '04 - Custom Display Logic.ipynb' --post=pdf"
+    "ipython nbconvert  --to=latex 'Index.ipynb' --post=pdf"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Have a look at `04 - Custom Display Logic.pdf`, toward the end, where we compared `display()` vs `display_html()` and returning the object.\n",
-    "See how the cell where we use `display_html` was not able to display the circle, whereas the two other ones were able to select one of the oher representation they know how to display."
+    "## Custom templates"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Customizing template"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "let's look at the first 20 lines of the `python` exporter"
+    "Look at the first 20 lines of the `python` exporter"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "# 1. Implementing special display methods such as `_repr_html_`.\n",
-      "# 2. Registering a display function for a particular type.\n",
-      "# \n",
-      "# In this Notebook we show how both approaches work.\n",
-      "\n",
-      "# Before we get started, we will import the various display functions for displaying the different formats we will create.\n",
-      "\n",
-      "# In[54]:\n",
-      "\n",
-      "from IPython.display import display\n",
-      "from IPython.display import (\n",
-      "    display_html, display_jpeg, display_png,\n",
-      "    display_javascript, display_svg, display_latex\n",
-      ")\n",
-      "\n",
-      "\n",
-      "### Implementing special display methods\n",
-      "\n",
-      "# The main idea of the first approach is that you have to implement special display methods, one for each representation you want to use. Here is a list of the names of the special methods and the values they must return:\n",
-      "# \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pyfile = !ipython nbconvert --to python '04 - Custom Display Logic.ipynb' --stdout\n",
+    "pyfile = !ipython nbconvert --to python 'Index.ipynb' --stdout\n",
     "for l in pyfile[20:40]:\n",
     "    print l"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We see that the non-code cell are exported to the file. To have a cleaner script, we will export only the code contained in the code cells.\n",
-    "\n",
-    "To do so, we will inherit the python template, and overwrite the markdown blocks to be empty."
+    "From the code, you can see that non-code cells are also exported.  If you want to change this behavior, you can use a custom template.  The custom template inherits from the Python template and overwrites the markdown blocks so that they are empty."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Overwriting simplepython.tpl\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%writefile simplepython.tpl\n",
     "{% extends 'python.tpl'%}\n",
     "\n",
     "{% block markdowncell -%}\n",
     "{% endblock markdowncell %}\n",
     "\n",
     "## we also want to get rig of header cell\n",
     "{% block headingcell -%}\n",
     "{% endblock headingcell %}\n",
     "\n",
     "## and let's change the appearance of input prompt\n",
     "{% block in_prompt %}\n",
     "# This was input cell with prompt number : {{ cell.prompt_number if cell.prompt_number else ' ' }}\n",
     "{%- endblock in_prompt %}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "# This was input cell with prompt number : 54\n",
-      "from IPython.display import display\n",
-      "from IPython.display import (\n",
-      "    display_html, display_jpeg, display_png,\n",
-      "    display_javascript, display_svg, display_latex\n",
-      ")\n",
-      "\n",
-      "\n",
-      "# This was input cell with prompt number : 55\n",
-      "get_ipython().magic(u'load soln/mycircle.py')\n",
-      "\n",
-      "\n",
-      "# This was input cell with prompt number : 56\n",
-      "class MyCircle(object):\n",
-      "    \n",
-      "    def _repr_html_(self):\n",
-      "        return \"&#x25CB; (<b>html</b>)\"\n",
-      "\n",
-      "    def _repr_svg_(self):\n",
-      "        return \"\"\"<svg width='100px' height='100px'>\n",
-      "           <circle cx=\"50\" cy=\"50\" r=\"20\" stroke=\"black\" stroke-width=\"1\" fill=\"blue\"/>\n",
-      "        </svg>\"\"\"\n",
-      "    \n",
-      "    def _repr_latex_(self):\n",
-      "        return r\"$\\bigcirc \\LaTeX$\"\n",
-      "\n",
-      "    def _repr_javascript_(self):\n",
-      "        return \"alert('I am a circle!');\"\n",
-      "\n",
-      "\n",
-      "# This was input cell with prompt number : 57\n",
-      "c = MyCircle()\n",
-      "\n",
-      "\n",
-      "# This was input cell with prompt number : 58\n",
-      "...\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pyfile = !ipython nbconvert --to python '04 - Custom Display Logic.ipynb' --stdout --template=simplepython.tpl\n",
+    "pyfile = !ipython nbconvert --to python 'Index.ipynb' --stdout --template=simplepython.tpl\n",
     "\n",
     "for l in pyfile[4:40]:\n",
     "    print l\n",
     "print '...'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "I'll let you read Jinja manual for the exact syntax of the template."
+    "For details about the template syntax, refer to [Jinja's manual](http://jinja.pocoo.org/docs/dev/)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Template that use cells metadata"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Notebook fileformat support attaching arbitrary JSON metadata to each cell of a notebook. In this part we will use those metadata."
+    "The notebook file format supports attaching arbitrary JSON metadata to each cell.  Here, as an exercise, you will use the metadata to tags cells."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First you need to choose another notebook you want to convert to html, and tag some of the cell with metadata.\n",
-    "You can see the file `soln/celldiff.js` for a solution on how to tag, or follow the javascript tutorial to see how to do that. Use what we have written there to tag cells of some notebooks to `Easy`|`Medium`|`Hard`|`<None>`, and convert this notebook using your template."
+    "First you need to choose another notebook you want to convert to html, and tag some of the cell with metadata.  You can refere to the file `soln/celldiff.js` as an example or follow the Javascript tutorial to figure out how do change cell metadata.  Assuming you have a notebook with some of the cells tagged as `Easy`|`Medium`|`Hard`|`<None>`, the notebook can be converted specially using a custom template.  Design your remplate in the cells provided below.\n",
+    "\n",
+    "The following, unorganized lines of code, may be of help:"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "you might need the following : \n",
     "```\n",
     "{% extends 'html_full.tpl'%}\n",
     "{% block any_cell %}\n",
     "{{ super() }}\n",
     "<div style=\"background-color:red\">\n",
     "<div style='background-color:orange'>\n",
     "```\n",
     "\n",
-    "`metadata` might not exist, be sure to :\n",
+    "If your key name under `cell.metadata.example.difficulty`, the following code would get the value of it:\n",
     "\n",
     "`cell['metadata'].get('example',{}).get('difficulty','')`\n",
     "\n",
-    "tip: use `%%writefile` to edit the template in the notebook :-)"
+    "Tip: Use `%%writefile` to edit the template in the notebook."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "%%bash\n",
     "# ipython nbconvert --to html <your chosen notebook.ipynb> --template=<your template file>"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "%loadpy soln/coloreddiff.tpl"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "# ipython nbconvert --to html '04 - Custom Display Logic.ipynb' --template=soln/coloreddiff.tpl"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Get rid of all command line flags."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As of all of IPython nbconvert can be configured using profiles and passing the `--profile` flag. \n",
-    "Moreover if a `config.py` file exist in current working directory nbconvert will use that, or read the config file you give to it with the `--config=<file>` flag. \n",
-    "\n",
-    "In the end, if you are often running nbconvert on the sam project, `$ ipython nbconvert` should be enough to get you up and ready."
+    "IPython nbconvert can be configured using the default profile and by selecting a non-default a profile via `--profile` flag.  Additionally, if a `config.py` file exist in current working directory, nbconvert will use that as config."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Custom Keyboard Shortcuts.ipynb

@@ -1,165 +1,113 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Keyboard Shortcut Customization"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Starting with IPython 2.0 keyboard shortcuts in command and edit mode are fully customizable. These customizations are made using the IPython JavaScript API. Here is an example that makes the `r` key available for running a cell:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "\n",
-       "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
-       "    help : 'run cell',\n",
-       "    help_index : 'zz',\n",
-       "    handler : function (event) {\n",
-       "        IPython.notebook.execute_cell();\n",
-       "        return false;\n",
-       "    }}\n",
-       ");"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript at 0x10e8d1890>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%javascript\n",
     "\n",
     "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', {\n",
     "    help : 'run cell',\n",
     "    help_index : 'zz',\n",
     "    handler : function (event) {\n",
     "        IPython.notebook.execute_cell();\n",
     "        return false;\n",
     "    }}\n",
     ");"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There are a couple of points to mention about this API:\n",
     "\n",
     "* The `help_index` field is used to sort the shortcuts in the Keyboard Shortcuts help dialog. It defaults to `zz`.\n",
     "* When a handler returns `false` it indicates that the event should stop propagating and the default action should not be performed. For further details about the `event` object or event handling, see the jQuery docs.\n",
     "* If you don't need a `help` or `help_index` field, you can simply pass a function as the second argument to `add_shortcut`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "\n",
-       "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
-       "    IPython.notebook.execute_cell();\n",
-       "    return false;\n",
-       "});"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript at 0x1019baf90>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%javascript\n",
     "\n",
     "IPython.keyboard_manager.command_shortcuts.add_shortcut('r', function (event) {\n",
     "    IPython.notebook.execute_cell();\n",
     "    return false;\n",
     "});"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Likewise, to remove a shortcut, use `remove_shortcut`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "\n",
-       "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript at 0x10e8d1950>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%javascript\n",
     "\n",
     "IPython.keyboard_manager.command_shortcuts.remove_shortcut('r');"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you want your keyboard shortcuts to be active for all of your notebooks, put the above API calls into your `<profile>/static/custom/custom.js` file."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Importing Notebooks.ipynb

@@ -1,733 +1,521 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Importing IPython Notebooks as Modules"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "It is a common problem that people want to import code from IPython Notebooks.\n",
     "This is made difficult by the fact that Notebooks are not plain Python files,\n",
     "and thus cannot be imported by the regular Python machinery.\n",
     "\n",
     "Fortunately, Python provides some fairly sophisticated [hooks](http://www.python.org/dev/peps/pep-0302/) into the import machinery,\n",
     "so we can actually make IPython notebooks importable without much difficulty,\n",
     "and only using public APIs."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import io, os, sys, types"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "from IPython.nbformat import current\n",
     "from IPython.core.interactiveshell import InteractiveShell"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Import hooks typically take the form of two objects:\n",
     "\n",
     "1. a Module **Loader**, which takes a module name (e.g. `'IPython.display'`), and returns a Module\n",
     "2. a Module **Finder**, which figures out whether a module might exist, and tells Python what **Loader** to use"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "def find_notebook(fullname, path=None):\n",
     "    \"\"\"find a notebook, given its fully qualified name and an optional path\n",
     "    \n",
     "    This turns \"foo.bar\" into \"foo/bar.ipynb\"\n",
     "    and tries turning \"Foo_Bar\" into \"Foo Bar\" if Foo_Bar\n",
     "    does not exist.\n",
     "    \"\"\"\n",
     "    name = fullname.rsplit('.', 1)[-1]\n",
     "    if not path:\n",
     "        path = ['']\n",
     "    for d in path:\n",
     "        nb_path = os.path.join(d, name + \".ipynb\")\n",
     "        if os.path.isfile(nb_path):\n",
     "            return nb_path\n",
     "        # let import Notebook_Name find \"Notebook Name.ipynb\"\n",
     "        nb_path = nb_path.replace(\"_\", \" \")\n",
     "        if os.path.isfile(nb_path):\n",
     "            return nb_path\n",
     "            "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Notebook Loader"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here we have our Notebook Loader.\n",
     "It's actually quite simple - once we figure out the filename of the module,\n",
     "all it does is:\n",
     "\n",
     "1. load the notebook document into memory\n",
     "2. create an empty Module\n",
     "3. execute every cell in the Module namespace\n",
     "\n",
     "Since IPython cells can have extended syntax,\n",
     "the IPython transform is applied to turn each of these cells into their pure-Python counterparts before executing them.\n",
     "If all of your notebook cells are pure-Python,\n",
     "this step is unnecessary."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "class NotebookLoader(object):\n",
     "    \"\"\"Module Loader for IPython Notebooks\"\"\"\n",
     "    def __init__(self, path=None):\n",
     "        self.shell = InteractiveShell.instance()\n",
     "        self.path = path\n",
     "    \n",
     "    def load_module(self, fullname):\n",
     "        \"\"\"import a notebook as a module\"\"\"\n",
     "        path = find_notebook(fullname, self.path)\n",
     "        \n",
     "        print (\"importing IPython notebook from %s\" % path)\n",
     "                                       \n",
     "        # load the notebook object\n",
     "        with io.open(path, 'r', encoding='utf-8') as f:\n",
     "            nb = current.read(f, 'json')\n",
     "        \n",
     "        \n",
     "        # create the module and add it to sys.modules\n",
     "        # if name in sys.modules:\n",
     "        #    return sys.modules[name]\n",
     "        mod = types.ModuleType(fullname)\n",
     "        mod.__file__ = path\n",
     "        mod.__loader__ = self\n",
     "        sys.modules[fullname] = mod\n",
     "        \n",
     "        # extra work to ensure that magics that would affect the user_ns\n",
     "        # actually affect the notebook module's ns\n",
     "        save_user_ns = self.shell.user_ns\n",
     "        self.shell.user_ns = mod.__dict__\n",
     "        \n",
     "        try:\n",
     "          for cell in nb.worksheets[0].cells:\n",
     "            if cell.cell_type == 'code' and cell.language == 'python':\n",
     "                # transform the input to executable Python\n",
     "                code = self.shell.input_transformer_manager.transform_cell(cell.input)\n",
     "                # run the code in themodule\n",
     "                exec(code, mod.__dict__)\n",
     "        finally:\n",
     "            self.shell.user_ns = save_user_ns\n",
     "        return mod\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## The Module Finder"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The finder is a simple object that tells you whether a name can be imported,\n",
     "and returns the appropriate loader.\n",
     "All this one does is check, when you do:\n",
     "\n",
     "```python\n",
     "import mynotebook\n",
     "```\n",
     "\n",
     "it checks whether `mynotebook.ipynb` exists.\n",
     "If a notebook is found, then it returns a NotebookLoader.\n",
     "\n",
     "Any extra logic is just for resolving paths within packages."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "class NotebookFinder(object):\n",
     "    \"\"\"Module finder that locates IPython Notebooks\"\"\"\n",
     "    def __init__(self):\n",
     "        self.loaders = {}\n",
     "    \n",
     "    def find_module(self, fullname, path=None):\n",
     "        nb_path = find_notebook(fullname, path)\n",
     "        if not nb_path:\n",
     "            return\n",
     "        \n",
     "        key = path\n",
     "        if path:\n",
     "            # lists aren't hashable\n",
     "            key = os.path.sep.join(path)\n",
     "        \n",
     "        if key not in self.loaders:\n",
     "            self.loaders[key] = NotebookLoader(path)\n",
     "        return self.loaders[key]\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Register the hook"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Now we register the `NotebookFinder` with `sys.meta_path`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "sys.meta_path.append(NotebookFinder())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "After this point, my notebooks should be importable.\n",
     "\n",
     "Let's look at what we have in the CWD:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "__init__.py       mynotebook.ipynb  \u001b[34mnbs\u001b[m\u001b[m/\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "ls nbpackage"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "So I should be able to `import nbimp.mynotebook`.\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Aside: displaying notebooks"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here is some simple code to display the contents of a notebook\n",
     "with syntax highlighting, etc."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "<style type='text/css'>\n",
-       ".hll { background-color: #ffffcc }\n",
-       ".c { color: #408080; font-style: italic } /* Comment */\n",
-       ".err { border: 1px solid #FF0000 } /* Error */\n",
-       ".k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".o { color: #666666 } /* Operator */\n",
-       ".cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       ".cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       ".c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       ".cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       ".gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".ge { font-style: italic } /* Generic.Emph */\n",
-       ".gr { color: #FF0000 } /* Generic.Error */\n",
-       ".gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".gi { color: #00A000 } /* Generic.Inserted */\n",
-       ".go { color: #888888 } /* Generic.Output */\n",
-       ".gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".gs { font-weight: bold } /* Generic.Strong */\n",
-       ".gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".kt { color: #B00040 } /* Keyword.Type */\n",
-       ".m { color: #666666 } /* Literal.Number */\n",
-       ".s { color: #BA2121 } /* Literal.String */\n",
-       ".na { color: #7D9029 } /* Name.Attribute */\n",
-       ".nb { color: #008000 } /* Name.Builtin */\n",
-       ".nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".no { color: #880000 } /* Name.Constant */\n",
-       ".nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       ".ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       ".nf { color: #0000FF } /* Name.Function */\n",
-       ".nl { color: #A0A000 } /* Name.Label */\n",
-       ".nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".nv { color: #19177C } /* Name.Variable */\n",
-       ".ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       ".sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".sx { color: #008000 } /* Literal.String.Other */\n",
-       ".sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       ".s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "</style>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML at 0x1072303d0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pygments import highlight\n",
     "from pygments.lexers import PythonLexer\n",
     "from pygments.formatters import HtmlFormatter\n",
     "\n",
     "from IPython.display import display, HTML\n",
     "\n",
     "formatter = HtmlFormatter()\n",
     "lexer = PythonLexer()\n",
     "\n",
     "# publish the CSS for pygments highlighting\n",
     "display(HTML(\"\"\"\n",
     "<style type='text/css'>\n",
     "%s\n",
     "</style>\n",
     "\"\"\" % formatter.get_style_defs()\n",
     "))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<h4>heading cell</h4>\n",
-       "<pre>My Notebook</pre>\n",
-       "<h4>code cell</h4>\n",
-       "<div class=\"highlight\"><pre><span class=\"k\">def</span> <span class=\"nf\">foo</span><span class=\"p\">():</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"s\">&quot;foo&quot;</span>\n",
-       "</pre></div>\n",
-       "\n",
-       "<h4>code cell</h4>\n",
-       "<div class=\"highlight\"><pre><span class=\"k\">def</span> <span class=\"nf\">has_ip_syntax</span><span class=\"p\">():</span>\n",
-       "    <span class=\"n\">listing</span> <span class=\"o\">=</span> <span class=\"err\">!</span><span class=\"n\">ls</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">listing</span>\n",
-       "</pre></div>\n",
-       "\n",
-       "<h4>code cell</h4>\n",
-       "<div class=\"highlight\"><pre><span class=\"k\">def</span> <span class=\"nf\">whatsmyname</span><span class=\"p\">():</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">__name__</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML at 0x10775a150>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def show_notebook(fname):\n",
     "    \"\"\"display a short summary of the cells of a notebook\"\"\"\n",
     "    with io.open(fname, 'r', encoding='utf-8') as f:\n",
     "        nb = current.read(f, 'json')\n",
     "    html = []\n",
     "    for cell in nb.worksheets[0].cells:\n",
     "        html.append(\"<h4>%s cell</h4>\" % cell.cell_type)\n",
     "        if cell.cell_type == 'code':\n",
     "            html.append(highlight(cell.input, lexer, formatter))\n",
     "        else:\n",
     "            html.append(\"<pre>%s</pre>\" % cell.source)\n",
     "    display(HTML('\\n'.join(html)))\n",
     "\n",
     "show_notebook(os.path.join(\"nbpackage\", \"mynotebook.ipynb\"))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "So my notebook has a heading cell and some code cells,\n",
     "one of which contains some IPython syntax.\n",
     "\n",
     "Let's see what happens when we import it"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "importing IPython notebook from nbpackage/mynotebook.ipynb\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from nbpackage import mynotebook"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Hooray, it imported!  Does it work?"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'foo'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "mynotebook.foo()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Hooray again!\n",
     "\n",
     "Even the function that contains IPython syntax works:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['Animations Using clear_output.ipynb',\n",
-       " 'Connecting with the Qt Console.ipynb',\n",
-       " 'Importing Notebooks.ipynb',\n",
-       " 'Progress Bars.ipynb',\n",
-       " 'Raw Input.ipynb',\n",
-       " 'SymPy.ipynb',\n",
-       " 'Trapezoid Rule.ipynb',\n",
-       " 'nbpackage']"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "mynotebook.has_ip_syntax()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Notebooks in packages"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We also have a notebook inside the `nb` package,\n",
     "so let's make sure that works as well."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "__init__.py  other.ipynb\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "ls nbpackage/nbs"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Note that the `__init__.py` is necessary for `nb` to be considered a package,\n",
     "just like usual."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<h4>markdown cell</h4>\n",
-       "<pre>This notebook just defines `bar`</pre>\n",
-       "<h4>code cell</h4>\n",
-       "<div class=\"highlight\"><pre><span class=\"k\">def</span> <span class=\"nf\">bar</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">):</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"s\">&quot;bar&quot;</span> <span class=\"o\">*</span> <span class=\"n\">x</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML at 0x10775a250>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "show_notebook(os.path.join(\"nbpackage\", \"nbs\", \"other.ipynb\"))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "importing IPython notebook from nbpackage/nbs/other.ipynb\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'barbarbarbarbar'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from nbpackage.nbs import other\n",
     "other.bar(5)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "So now we have importable notebooks, from both the local directory and inside packages.\n",
     "\n",
     "I can even put a notebook inside IPython, to further demonstrate that this is working properly:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import shutil\n",
     "from IPython.utils.path import get_ipython_package_dir\n",
     "\n",
     "utils = os.path.join(get_ipython_package_dir(), 'utils')\n",
     "shutil.copy(os.path.join(\"nbpackage\", \"mynotebook.ipynb\"),\n",
     "            os.path.join(utils, \"inside_ipython.ipynb\")\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "and import the notebook from `IPython.utils`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "importing IPython notebook from /Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/utils/inside_ipython.ipynb\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'IPython.utils.inside_ipython'"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython.utils import inside_ipython\n",
     "inside_ipython.whatsmyname()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "This approach can even import functions and classes that are defined in a notebook using the `%%cython` magic."
    ]
   }
  ],
  "metadata": {
   "gist_id": "6011986",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Index.ipynb

@@ -1,92 +1,91 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<img src=\"../images/ipython_logo.png\">"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Back to the main [Index](../Index.ipynb)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Notebook"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The IPython Notebook is a web-based interactive computing system that enables users to author documents that include live code, narrative text, LaTeX equations, HTML, images and video. These documents contain a full record of a computation and its results and can be shared on email, [Dropbox](http://dropbox.com), version control systems (like git/[GitHub](http://github.com)) or [nbviewer.ipython.org](http://nbviewer.ipython.org)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Tutorials"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* [What is the IPython Notebook](What is the IPython Notebook.ipynb)\n",
-    "* [Running the Notebook Server](Running the Notebook Server.ipynb)\n",
     "* [Notebook Basics](Notebook Basics.ipynb)\n",
     "* [Running Code](Running Code.ipynb)\n",
     "* [Working With Markdown Cells](Working With Markdown Cells.ipynb)\n",
+    "* [Configuring the Notebook and Server](Configuring the Notebook and Server.ipynb)\n",
     "* [Custom Keyboard Shortcuts](Custom Keyboard Shortcuts.ipynb)\n",
     "* [JavaScript Notebook Extensions](JavaScript Notebook Extensions.ipynb)\n",
-    "* [Notebook Security](Notebook Security.ipynb)\n",
     "* [Converting Notebooks With nbconvert](Converting Notebooks With nbconvert.ipynb)\n",
     "* [Using nbconvert as a Library](Using nbconvert as a Library.ipynb)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Examples"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* [Importing Notebooks](Importing Notebooks.ipynb)\n",
     "* [Connecting with the Qt Console](Connecting with the Qt Console.ipynb)\n",
     "* [Typesetting Equations](Typesetting Equations.ipynb)"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/JavaScript Notebook Extensions.ipynb

@@ -1,773 +1,612 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Embrasing web standards"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "One of the main reason that allowed us to developp the current notebook web application \n",
     "was to embrase the web technology. \n",
     "\n",
     "By beeing a pure web application using HTML, Javascript and CSS, the Notebook can get \n",
     "all the web technology improvement for free. Thus, as browsers support for different \n",
     "media extend, The notebook web app should be able to be compatible without modification. \n",
     "\n",
     "This is also true with performance of the User Interface as the speed of javascript VM increase. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The other advantage of using only web technology is that the code of the interface is fully accessible to the end user, and modifiable live.\n",
     "Even if this task is not always easy, we strive to keep our code as accessible and reusable as possible.\n",
     "This should allow with minimum effort to develop small extensions that customize the behavior of the web interface. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Tempering with Notebook app"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The first tool that is availlable to you and that you shoudl be aware of are browser \"developpers tool\". The exact naming can change across browser, and might require the installation of extensions. But basically they can allow you to inspect/modify the DOM, and interact with the javascript code that run the frontend.\n",
     "\n",
     " - In Chrome and safari Developper tools are in the menu [Put mmenu name in english here] \n",
     " - In firefox you might need to install [Firebug](http://getfirebug.com/)\n",
     " - others ?\n",
     " \n",
     "Those will be your best friends to debug and try different approach for your extensions."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Injecting JS"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### using magics"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Above tools can be tedious to edit long javascipt files. Hopefully we provide the `%%javascript` magic. This allows you to quickly inject javascript into the notebook. Still the javascript injected this way will not survive reloading. Hence it is a good tool for testing an refinig a script.\n",
     "\n",
     "You might see here and there people modifying css and injecting js into notebook by reading file and publishing them into the notebook.\n",
     "Not only this often break the flow of the notebook and make the re-execution of the notebook broken, but it also mean that you need to execute those cells on all the notebook every time you need to update the code.\n",
     "\n",
     "This can still be usefull in some cases, like the `%autosave` magic that allows to control the time between each save. But this can be replaced by a Javascript dropdown menu to select save interval."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "## you can inspect the autosave code to see what it does.\n",
     "%autosave??"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### custom.js"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To inject Javascript we provide an entry point: `custom.js` that allow teh user to execute and load other resources into the notebook.\n",
     "Javascript code in `custom.js` will be executed when the notebook app start and can then be used to customise almost anything in the UI and in the behavior of the notebook.\n",
     "\n",
     "`custom.js` can be found in IPython profile dir, and so you can have different UI modification on a per profile basis, as well as share your modfication with others."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "##### Because we like you...."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You have been provided with an already existing profile folder with this tutorial...\n",
     "start the notebook from the root of the tutorial directory with :\n",
     "\n",
     "```bash\n",
     "$ ipython notebook --ProfileDir.location=./profile_euroscipy\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "##### but back to theory"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'/Users/bussonniermatthias/.ipython'"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "profile_dir = ! ipython locate\n",
     "profile_dir = profile_dir[0]\n",
     "profile_dir"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "and custom js is in "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import os.path\n",
     "custom_js_path = os.path.join(profile_dir,'profile_default','static','custom','custom.js')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "// we want strict javascript that fails\n",
-      "// on ambiguous syntax\n",
-      "\"using strict\";\n",
-      "\n",
-      "// notebook loaded is not perfect as it is re-triggerd on\n",
-      "// revert to checkpoint but this allow extesnsion to be loaded\n",
-      "// late enough to work.\n",
-      "$([IPython.events]).on('notebook_loaded.Notebook', function(){\n",
-      "\n",
-      "\n",
-      "    /**  Use path to js file relative to /static/ dir without leading slash, or\n",
-      "     *  js extension.\n",
-      "     *  Link directly to file is js extension isa simple file\n",
-      "     *\n",
-      "     *  first argument of require is a **list** that can contains several modules if needed.\n",
-      "     **/\n",
-      "\n",
-      "    //require(['custom/noscroll']);\n",
-      "    // require(['custom/clean_start'])\n",
-      "    // require(['custom/toggle_all_line_number'])\n",
-      "    // require(['custom/gist_it']);\n",
-      "    // require(['custom/autosavetime']);\n",
-      "\n",
-      "    /**\n",
-      "     *  Link to entrypoint if extesnsion is a folder.\n",
-      "     *  to be consistent with commonjs module, the entrypoint is main.js\n",
-      "     *  here youcan also trigger a custom function on load that will do extra\n",
-      "     *  action with the module if needed\n",
-      "     **/\n",
-      "    require(['custom/slidemode/main'])\n",
-      "\n",
-      "    // require(['custom/autoscroll']);\n",
-      "\n",
-      "    //require(['custom/css_selector/main'])\n",
-      "    require(['custom/pre_exec_strip']);\n",
-      "    // require(['custom/no_exec_dunder']);\n",
-      "    // load_ext('nbviewer_theme')\n",
-      "\n",
-      "\n",
-      "    require(['custom/clippytip/main']);\n",
-      "\n",
-      "    IPython.toolbar.add_buttons_group([\n",
-      "        {\n",
-      "             'label'   : 'run qtconsole',\n",
-      "             'icon'    : 'icon-paper-clip', // select your icon from http://jqueryui.com/themeroller/\n",
-      "             'callback': function(){\n",
-      "                IPython.tooltip.remove_and_cancel_tooltip(true)\n",
-      "                $('#tooltip').empty() \n",
-      "                $('#tooltip').attr('style','') \n",
-      "                IPython.tooltip = new IPython.ClippyTip()\n",
-      "             }\n",
-      "        },\n",
-      "        {\n",
-      "             'label'   : 'run qtconsole',\n",
-      "             'icon'    : 'icon-th-large', // select your icon from http://jqueryui.com/themeroller/\n",
-      "             'callback': function(){\n",
-      "                IPython.tooltip.remove_and_cancel_tooltip(true)\n",
-      "                $('#tooltip').empty() \n",
-      "                $('#tooltip').attr('style','')\n",
-      "                IPython.tooltip = new IPython.Tooltip()\n",
-      "            }\n",
-      "        }\n",
-      "        // add more button here if needed.\n",
-      "        ]);\n",
-      "    //\n",
-      "\n",
-      "});\n",
-      "\n",
-      "/*\n",
-      "$([IPython.events]).on('notebook_loaded.Notebook', function(){\n",
-      "    IPython.toolbar.add_buttons_group([\n",
-      "                    {\n",
-      "                'label'   : 'run qtconsole',\n",
-      "                'icon'    : 'ui-icon-calculator',\n",
-      "                'callback': function(){IPython.notebook.kernel.execute('%qtconsole')}\n",
-      "                }\n",
-      "            ]);\n",
-      "});\n",
-      "*/\n",
-      "\n",
-      "//$([IPython.events]).on('notebook_loaded.Notebook', function(){\n",
-      "//    mobile_preset = []\n",
-      "//    var edit = function(div, cell) {\n",
-      "//            var button_container = $(div);\n",
-      "//            var button = $('<div/>').button({icons:{primary:'ui-icon-pencil'}});\n",
-      "//                button.click(function(){\n",
-      "//                    cell.edit()\n",
-      "//                        })\n",
-      "//            button_container.append(button);\n",
-      "//    }\n",
-      "//\n",
-      "//    IPython.CellToolbar.register_callback('mobile.edit',edit);\n",
-      "//    mobile_preset.push('mobile.edit');\n",
-      "//\n",
-      "//    IPython.CellToolbar.register_preset('Mobile',mobile_preset);\n",
-      "//});\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "#  my custom js\n",
     "with open(custom_js_path) as f:\n",
     "    for l in f: \n",
     "        print l,"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Note that `custom.js` is ment to be modified by user, when writing a script, you can define it in a separate file and add a line of configuration into `custom.js` that will fetch and execute the file."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Warning** : even if modification of `custom.js` take effect immediately after browser refresh (except if browser cache is aggressive), *creating* a file in `static/` directory need a **server restart**."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Exercise :"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     " - Create a `custom.js` in the right location with the following content:\n",
     "```javascript\n",
     "alert(\"hello world from custom.js\")\n",
     "```\n",
     "\n",
     " - Restart your server and open any notebook.\n",
     " - Be greeted by custom.js"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Have a look at [default custom.js](https://github.com/ipython/ipython/blob/1.x/IPython/html/static/custom/custom.js), to see it's content and some more explanation."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### For the quick ones : "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We've seen above that you can change the autosave rate by using a magic. This is typically something I don't want to type everytime, and that I don't like to embed into my workwlow and documents. (reader don't care what my autosave time is), let's build an extension that allow to do it.  "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "foo": true
    },
    "source": [
     "Create a dropdow elemement in the toolbar (DOM `IPython.toolbar.element`), you will need \n",
     "\n",
     "- `IPython.notebook.set_autosave_interval(miliseconds)`\n",
     "- know that 1min = 60 sec, and 1 sec = 1000 ms"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "```javascript\n",
     "\n",
     "var label = jQuery('<label/>').text('AutoScroll Limit:');\n",
     "var select = jQuery('<select/>')\n",
     "     //.append(jQuery('<option/>').attr('value', '2').text('2min (default)'))\n",
     "     .append(jQuery('<option/>').attr('value', undefined).text('disabled'))\n",
     "\n",
     "     // TODO:\n",
     "     //the_toolbar_element.append(label)\n",
     "     //the_toolbar_element.append(select);\n",
     "     \n",
     "select.change(function() {\n",
     "     var val = jQuery(this).val() // val will be the value in [2]\n",
     "     // TODO\n",
     "     // this will be called when dropdown changes\n",
     "\n",
     "});\n",
     "\n",
     "var time_m = [1,5,10,15,30];\n",
     "for (var i=0; i < time_m.length; i++) {\n",
     "     var ts = time_m[i];\n",
     "                                          //[2]   ____ this will be `val` on [1]  \n",
     "                                          //     | \n",
     "                                          //     v \n",
     "     select.append($('<option/>').attr('value', ts).text(thr+'min'));\n",
     "     // this will fill up the dropdown `select` with\n",
     "     // 1 min\n",
     "     // 5 min\n",
     "     // 10 min\n",
     "     // 10 min\n",
     "     // ...\n",
     "}\n",
     "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### A non interactive example first"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "I like my cython to be nicely highlighted\n",
     "\n",
     "```javascript\n",
     "IPython.config.cell_magic_highlight['magic_text/x-cython'] = {}\n",
     "IPython.config.cell_magic_highlight['magic_text/x-cython'].reg = [/^%%cython/]\n",
     "```\n",
     "\n",
     "`text/x-cython` is the name of CodeMirror mode name, `magic_` prefix will just patch the mode so that the first line that contains a magic does not screw up the highlighting. `reg`is a list or regular expression that will trigger the change of mode."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Get more docs"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Sadly you will have to read the js source file (but there are lots of comments) an/or build the javascript documentation using yuidoc.\n",
     "If you have `node` and `yui-doc` installed:"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "```bash\n",
     "$ cd ~/ipython/IPython/html/static/notebook/js/\n",
     "$ yuidoc . --server\n",
     "warn: (yuidoc): Failed to extract port, setting to the default :3000\n",
     "info: (yuidoc): Starting YUIDoc@0.3.45 using YUI@3.9.1 with NodeJS@0.10.15\n",
     "info: (yuidoc): Scanning for yuidoc.json file.\n",
     "info: (yuidoc): Starting YUIDoc with the following options:\n",
     "info: (yuidoc):\n",
     "{ port: 3000,\n",
     "  nocode: false,\n",
     "  paths: [ '.' ],\n",
     "  server: true,\n",
     "  outdir: './out' }\n",
     "info: (yuidoc): Scanning for yuidoc.json file.\n",
     "info: (server): Starting server: http://127.0.0.1:3000\n",
     "```\n",
     "\n",
     "and browse http://127.0.0.1:3000 to get docs"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "foo": true
    },
    "source": [
     "#### Some convenience methods"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "By browsing the doc you will see that we have soem convenience methods that avoid to re-invent the UI everytime :\n",
     "```javascript\n",
     "IPython.toolbar.add_buttons_group([\n",
     "        {\n",
     "             'label'   : 'run qtconsole',\n",
     "             'icon'    : 'icon-terminal', // select your icon from \n",
     "                                          // http://fortawesome.github.io/Font-Awesome/icons/\n",
     "             'callback': function(){IPython.notebook.kernel.execute('%qtconsole')}\n",
     "        }\n",
     "        // add more button here if needed.\n",
     "        ]);\n",
     "```\n",
     "with a [lot of icons] you can select from. \n",
     "\n",
     "[lot of icons]: http://fortawesome.github.io/Font-Awesome/icons/"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "foo": true
    },
    "source": [
     "## Cell Metadata"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "foo": true
    },
    "source": [
     "The most requested feature is generaly to be able to distinguish individual cell in th enotebook, or run specific action with them.\n",
     "To do so, you can either use `IPython.notebook.get_selected_cell()`, or rely on `CellToolbar`. This allow you to register aset of action and graphical element that will be attached on individual cells."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Cell Toolbar"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can see some example of what can be done by toggling the `Cell Toolbar` selector in the toolbar on top of the notebook. It provide two default `presets` that are `Default` and `slideshow`. Default allow edit the metadata attached to each cell manually."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "First we define a function that takes at first parameter an element on the DOM in which to inject UI element. Second element will be the cell this element will be registerd with. Then we will need to register that function ad give it a name.\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Register a callback"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "var CellToolbar = IPython.CellToolbar\n",
-       "var toggle =  function(div, cell) {\n",
-       "     var button_container = $(div)\n",
-       "\n",
-       "     // let's create a button that show the  current value of the metadata\n",
-       "     var button = $('<button/>').addClass('btn btn-mini').text(String(cell.metadata.foo));\n",
-       "\n",
-       "     // On click, change the metadata value and update the button label\n",
-       "     button.click(function(){\n",
-       "                 var v = cell.metadata.foo;\n",
-       "                 cell.metadata.foo = !v;\n",
-       "                 button.text(String(!v));\n",
-       "             })\n",
-       "\n",
-       "     // add the button to the DOM div.\n",
-       "     button_container.append(button);\n",
-       "}\n",
-       "\n",
-       " // now we register the callback under the name foo to give the\n",
-       " // user the ability to use it later\n",
-       " CellToolbar.register_callback('tuto.foo', toggle);"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript at 0x10c94a590>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%javascript\n",
     "var CellToolbar = IPython.CellToolbar\n",
     "var toggle =  function(div, cell) {\n",
     "     var button_container = $(div)\n",
     "\n",
     "     // let's create a button that show the  current value of the metadata\n",
     "     var button = $('<button/>').addClass('btn btn-mini').text(String(cell.metadata.foo));\n",
     "\n",
     "     // On click, change the metadata value and update the button label\n",
     "     button.click(function(){\n",
     "                 var v = cell.metadata.foo;\n",
     "                 cell.metadata.foo = !v;\n",
     "                 button.text(String(!v));\n",
     "             })\n",
     "\n",
     "     // add the button to the DOM div.\n",
     "     button_container.append(button);\n",
     "}\n",
     "\n",
     " // now we register the callback under the name foo to give the\n",
     " // user the ability to use it later\n",
     " CellToolbar.register_callback('tuto.foo', toggle);"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Registering a preset"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "This function can now be part of many `preset` of the CellToolBar."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "foo": true,
     "slideshow": {
      "slide_type": "subslide"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "IPython.CellToolbar.register_preset('Tutorial 1',['tuto.foo','default.rawedit'])\n",
-       "IPython.CellToolbar.register_preset('Tutorial 2',['slideshow.select','tuto.foo'])"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript at 0x10c94a510>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%javascript\n",
     "IPython.CellToolbar.register_preset('Tutorial 1',['tuto.foo','default.rawedit'])\n",
     "IPython.CellToolbar.register_preset('Tutorial 2',['slideshow.select','tuto.foo'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You should now have access to two presets :\n",
     "\n",
     "  - Tutorial 1\n",
     "  - Tutorial 2\n",
     "  \n",
     "And check that the buttons you defin share state when you toggle preset. \n",
     "Check moreover that the metadata of the cell is modified when you clisk the button, and that when saved on reloaded the metadata is still availlable."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Exercise:"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Try to wrap the all code in a file, put this file in `{profile}/static/custom/<a-name>.js`, and add \n",
     "\n",
     "```\n",
     "require(['custom/<a-name>']);\n",
     "```\n",
     "\n",
     "in `custom.js` to have this script automatically loaded in all your notebooks.\n",
     "\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "`require` is provided by a [javascript library](http://requirejs.org/) that allow to express dependency. For simple extension like the previous one we directly mute the global namespace, but for more complexe extension you could pass acallback to `require([...], <callback>)` call, to allow the user to pass configuration information to your plugin.\n",
     "\n",
     "In Python lang, \n",
     "\n",
     "```javascript\n",
     "require(['a/b', 'c/d'], function( e, f){\n",
     "    e.something()\n",
     "    f.something()\n",
     "})\n",
     "```\n",
     "\n",
     "could be read as\n",
     "```python\n",
     "import a.b as e\n",
     "import c.d as f\n",
     "e.something()\n",
     "f.something()\n",
     "```\n",
     "\n",
     "\n",
     "See for example @damianavila [\"ZenMode\" plugin](https://github.com/ipython-contrib/IPython-notebook-extensions/blob/master/custom.example.js#L34) :\n",
     "\n",
     "```javascript\n",
     "\n",
     "// read that as\n",
     "// import custom.zenmode.main as zenmode\n",
     "require(['custom/zenmode/main'],function(zenmode){\n",
     "    zenmode.background('images/back12.jpg');\n",
     "})\n",
     "```\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### For the quickest"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Try to use [the following](https://github.com/ipython/ipython/blob/1.x/IPython/html/static/notebook/js/celltoolbar.js#L367) to bind a dropdown list to `cell.metadata.difficulty.select`. \n",
     "\n",
     "It should be able to take the 4 following values :\n",
     "\n",
     " - `<None>`\n",
     " - `Easy`\n",
     " - `Medium`\n",
     " - `Hard`\n",
     " \n",
     "We will use it to customise the output of the converted notebook depending of the tag on each cell"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "%load soln/celldiff.js"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Notebook Basics.ipynb

@@ -1,256 +1,313 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Notebook Basics"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This notebook assumes that you already have IPython [installed](http://ipython.org/install.html) and are able to start the notebook server by running:\n",
+    "## Running the Notebook Server"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The IPython notebook server is a custom web server that runs the notebook web application. Most of the time, users run the notebook server on their local computer using IPython's command line interface."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Starting the notebook server using the command line"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can start the notebook server from the command line (Terminal on Mac/Linux, CMD prompt on Windows) by running the following command: \n",
     "\n",
     "    ipython notebook\n",
     "\n",
-    "For more details on how to run the notebook server, see [Running the Notebook Server](Running the Notebook Server.ipynb)."
+    "This will print some information about the notebook server in your terminal, including the URL of the web application (by default, `http://127.0.0.1:8888`). It will then open your default web browser to this URL.\n",
+    "\n",
+    "When the notebook opens, you will see the **notebook dashboard**, which will show a list of the notebooks and subdirectories in the directory where the notebook server was started (as seen in the next section, below). Most of the time, you will want to start a notebook server in the highest directory in your filesystem where notebooks can be found. Often this will be your home directory."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## The Notebook dashboard"
+    "### Additional options"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When you first start the notebook server, your browser will open to the notebook dashboard. The dashboard serves as a home page for the notebook. Its main purpose is to display the notebooks in the current directory. For example, here is a screenshot of the dashboard page for the `examples` directory in the IPython repository:\n",
+    "You can start more than one notebook server at the same time. By default, the first notebook server starts on port 8888 and later notebook servers search for open ports near that one.\n",
     "\n",
-    "<img src=\"images/dashboard_notebooks_tab.png\" />\n",
+    "You can also specify the port manually:\n",
     "\n",
-    "The top of the notebook list displays clickable breadcrumbs of the current directory. By clicking on these breadcrumbs or on sub-directories in the notebook list, you can navigate your file system.\n",
+    "    ipython notebook --port 9999\n",
     "\n",
-    "To create a new notebook, click on the \"New Notebook\" button at the top of the list.\n",
+    "Or start notebook server without opening a web browser.\n",
     "\n",
-    "Notebooks can be uploaded to the current directory by dragging a notebook file onto the notebook list or by the \"click here\" text above the list.\n",
+    "    ipython notebook --no-browser\n",
     "\n",
-    "The notebook list shows a red \"Shutdown\" button for running notebooks and a \"Delete\" button for stopped notebooks. Notebook remain running until you explicitly click the \"Shutdown\" button; closing the notebook's page is not sufficient.\n",
+    "The notebook server has a number of other command line arguments that can be displayed with the `--help` flag: \n",
     "\n",
-    "To see all of your running notebooks along with their directories, click on the \"Running\" tab:\n",
+    "    ipython notebook --help"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Notebook dashboard"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When you first start the notebook server, your browser will open to the notebook dashboard. The dashboard serves as a home page for the notebook. Its main purpose is to display the notebooks and files in the current directory. For example, here is a screenshot of the dashboard page for the `examples` directory in the IPython repository:\n",
+    "\n",
+    "<img src=\"images/dashboard_files_tab.png\" width=\"791px\"/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The top of the notebook list displays clickable breadcrumbs of the current directory. By clicking on these breadcrumbs or on sub-directories in the notebook list, you can navigate your file system.\n",
     "\n",
-    "<img src=\"images/dashboard_running_tab.png\" />\n",
+    "To create a new notebook, click on the \"New\" button at the top of the list and select a kernel from the dropdown (as seen below).  Which kernels are listed depend on what's installed on the server.  Some of the kernels in the screenshot below may not exist as an option to you.\n",
     "\n",
-    "This view provides a convenient way to track notebooks that you start as you navigate the file system in a long running notebook server."
+    "<img src=\"images/dashboard_files_tab_new.png\" width=\"202px\" />"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Overview of the Notebook UI"
+    "Notebooks and files can be uploaded to the current directory by dragging a notebook file onto the notebook list or by the \"click here\" text above the list.\n",
+    "\n",
+    "The notebook list shows green \"Running\" text and a green notebook icon next to running notebooks (as seen below). Notebooks remain running until you explicitly shut them down; closing the notebook's page is not sufficient.\n",
+    "\n",
+    "<img src=\"images/dashboard_files_tab_run.png\" width=\"777px\"/>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<div class=\"alert\">\n",
-    "As of IPython 2.0, the user interface has changed significantly. Because of this we highly recommend existing users to review this information after upgrading to IPython 2.0. All new users of IPython should review this information as well.\n",
-    "</div>"
+    "To shutdown, delete, duplicate, or rename a notebook check the checkbox next to it and an array of controls will appear at the top of the notebook list (as seen below).  You can also use the same operations on directories and files when applicable.\n",
+    "\n",
+    "<img src=\"images/dashboard_files_tab_btns.png\" width=\"301px\" />"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To see all of your running notebooks along with their directories, click on the \"Running\" tab:\n",
+    "\n",
+    "<img src=\"images/dashboard_running_tab.png\" width=\"786px\" />\n",
+    "\n",
+    "This view provides a convenient way to track notebooks that you start as you navigate the file system in a long running notebook server."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overview of the Notebook UI"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you create a new notebook or open an existing one, you will be taken to the notebook user interface (UI). This UI allows you to run code and author notebook documents interactively. The notebook UI has the following main areas:\n",
     "\n",
     "* Menu\n",
     "* Toolbar\n",
     "* Notebook area and cells\n",
     "\n",
-    "IPython 2.0 has an interactive tour of these elements that can be started in the \"Help:User Interface Tour\" menu item."
+    "The notebook has an interactive tour of these elements that can be started in the \"Help:User Interface Tour\" menu item."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Modal editor"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Starting with IPython 2.0, the IPython Notebook has a modal user interface. This means that the keyboard does different things depending on which mode the Notebook is in. There are two modes: edit mode and command mode."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Edit mode"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Edit mode is indicated by a green cell border and a prompt showing in the editor area:\n",
     "\n",
     "<img src=\"images/edit_mode.png\">\n",
     "\n",
     "When a cell is in edit mode, you can type into the cell, like a normal text editor."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<div class=\"alert alert-success\">\n",
     "Enter edit mode by pressing `Enter` or using the mouse to click on a cell's editor area.\n",
     "</div>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Command mode"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Command mode is indicated by a grey cell border:\n",
     "\n",
     "<img src=\"images/command_mode.png\">\n",
     "\n",
     "When you are in command mode, you are able to edit the notebook as a whole, but not type into individual cells. Most importantly, in command mode, the keyboard is mapped to a set of shortcuts that let you perform notebook and cell actions efficiently. For example, if you are in command mode and you press `c`, you will copy the current cell - no modifier is needed."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<div class=\"alert alert-error\">\n",
     "Don't try to type into a cell in command mode; unexpected things will happen!\n",
     "</div>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<div class=\"alert alert-success\">\n",
     "Enter command mode by pressing `Esc` or using the mouse to click *outside* a cell's editor area.\n",
     "</div>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Mouse navigation"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "All navigation and actions in the Notebook are available using the mouse through the menubar and toolbar, which are both above the main Notebook area:\n",
     "\n",
-    "<img src=\"images/menubar_toolbar.png\">"
+    "<img src=\"images/menubar_toolbar.png\" width=\"786px\" />"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The first idea of mouse based navigation is that **cells can be selected by clicking on them.** The currently selected cell gets a grey or green border depending on whether the notebook is in edit or command mode. If you click inside a cell's editor area, you will enter edit mode. If you click on the prompt or output area of a cell you will enter command mode.\n",
     "\n",
     "If you are running this notebook in a live session (not on http://nbviewer.ipython.org) try selecting different cells and going between edit and command mode. Try typing into a cell."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The second idea of mouse based navigation is that **cell actions usually apply to the currently selected cell**. Thus if you want to run the code in a cell, you would select it and click the <button class='btn btn-default btn-xs'><i class=\"fa fa-play icon-play\"></i></button> button in the toolbar or the \"Cell:Run\" menu item. Similarly, to copy a cell you would select it and click the <button class='btn btn-default btn-xs'><i class=\"fa fa-copy icon-copy\"></i></button> button in the toolbar or the \"Edit:Copy\" menu item. With this simple pattern, you should be able to do most everything you need with the mouse.\n",
     "\n",
     "Markdown and heading cells have one other state that can be modified with the mouse. These cells can either be rendered or unrendered. When they are rendered, you will see a nice formatted representation of the cell's contents. When they are unrendered, you will see the raw text source of the cell. To render the selected cell with the mouse, click the <button class='btn btn-default btn-xs'><i class=\"fa fa-play icon-play\"></i></button> button in the toolbar or the \"Cell:Run\" menu item. To unrender the selected cell, double click on the cell."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Keyboard Navigation"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The modal user interface of the IPython Notebook has been optimized for efficient keyboard usage. This is made possible by having two different sets of keyboard shortcuts: one set that is active in edit mode and another in command mode.\n",
     "\n",
     "The most important keyboard shortcuts are `Enter`, which enters edit mode, and `Esc`, which enters command mode.\n",
     "\n",
-    "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts:\n",
-    "\n",
-    "<img src=\"images/edit_shortcuts.png\">"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In command mode, the entire keyboard is available for shortcuts, so there are many more:\n",
-    "\n",
-    "<img src=\"images/command_shortcuts.png\">"
+    "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts.  In command mode, the entire keyboard is available for shortcuts, so there are many more.  The `Help`->`Keyboard Shortcuts` dialog lists the available shortcuts."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We recommend learning the command mode shortcuts in the following rough order:\n",
     "\n",
     "1. Basic navigation: `enter`, `shift-enter`, `up/k`, `down/j`\n",
     "2. Saving the notebook: `s`\n",
     "2. Cell types: `y`, `m`, `1-6`, `t`\n",
     "3. Cell creation: `a`, `b`\n",
     "4. Cell editing: `x`, `c`, `v`, `d`, `z`, `shift+=`\n",
     "5. Kernel operations: `i`, `.`"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Running Code.ipynb

@@ -1,892 +1,289 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Running Code"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "First and foremost, the IPython Notebook is an interactive environment for writing and running code. IPython is capable of running code in a wide range of languages. However, this notebook, and the default kernel in IPython 2.0, runs Python code."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Code cells allow you to enter and run Python code"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Run a code cell using `Shift-Enter` or pressing the <button class='btn btn-default btn-xs'><i class=\"icon-play fa fa-play\"></i></button> button in the toolbar above:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "a = 10"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "10\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(a)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There are two other keyboard shortcuts for running code:\n",
     "\n",
     "* `Alt-Enter` runs the current cell and inserts a new one below.\n",
     "* `Ctrl-Enter` run the current cell and enters command mode."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Managing the IPython Kernel"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Code is run in a separate process called the IPython Kernel.  The Kernel can be interrupted or restarted.  Try running the following cell and then hit the <button class='btn btn-default btn-xs'><i class='icon-stop fa fa-stop'></i></button> button in the toolbar above."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import time\n",
     "time.sleep(10)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If the Kernel dies you will be prompted to restart it. Here we call the low-level system libc.time routine with the wrong argument via\n",
     "ctypes to segfault the Python interpreter:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import sys\n",
     "from ctypes import CDLL\n",
     "# This will crash a Linux or Mac system\n",
     "# equivalent calls can be made on Windows\n",
     "dll = 'dylib' if sys.platform == 'darwin' else 'so.6'\n",
     "libc = CDLL(\"libc.%s\" % dll) \n",
     "libc.time(-1)  # BOOM!!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Cell menu"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The \"Cell\" menu has a number of menu items for running code in different ways. These includes:\n",
     "\n",
     "* Run and Select Below\n",
     "* Run and Insert Below\n",
     "* Run All\n",
     "* Run All Above\n",
     "* Run All Below"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Restarting the kernels"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The kernel maintains the state of a notebook's computations. You can reset this state by restarting the kernel. This is done by clicking on the <button class='btn btn-default btn-xs'><i class='fa fa-repeat icon-repeat'></i></button> in the toolbar above."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## sys.stdout and sys.stderr"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The stdout and stderr streams are displayed as text in the output area."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "hi, stdout\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"hi, stdout\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "hi, stderr\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from __future__ import print_function\n",
     "print('hi, stderr', file=sys.stderr)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Output is asynchronous"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "All output is displayed asynchronously as it is generated in the Kernel. If you execute the next cell, you will see the output one piece at a time, not all at the end."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n",
-      "1\n",
-      "2\n",
-      "3\n",
-      "4\n",
-      "5\n",
-      "6\n",
-      "7\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import time, sys\n",
     "for i in range(8):\n",
     "    print(i)\n",
     "    time.sleep(0.5)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Large outputs"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To better handle large outputs, the output area can be collapsed. Run the following cell and then single- or double- click on the active area to the left of the output:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n",
-      "1\n",
-      "2\n",
-      "3\n",
-      "4\n",
-      "5\n",
-      "6\n",
-      "7\n",
-      "8\n",
-      "9\n",
-      "10\n",
-      "11\n",
-      "12\n",
-      "13\n",
-      "14\n",
-      "15\n",
-      "16\n",
-      "17\n",
-      "18\n",
-      "19\n",
-      "20\n",
-      "21\n",
-      "22\n",
-      "23\n",
-      "24\n",
-      "25\n",
-      "26\n",
-      "27\n",
-      "28\n",
-      "29\n",
-      "30\n",
-      "31\n",
-      "32\n",
-      "33\n",
-      "34\n",
-      "35\n",
-      "36\n",
-      "37\n",
-      "38\n",
-      "39\n",
-      "40\n",
-      "41\n",
-      "42\n",
-      "43\n",
-      "44\n",
-      "45\n",
-      "46\n",
-      "47\n",
-      "48\n",
-      "49\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for i in range(50):\n",
     "    print(i)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Beyond a certain point, output will scroll automatically:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0\n",
-      "1\n",
-      "3\n",
-      "7\n",
-      "15\n",
-      "31\n",
-      "63\n",
-      "127\n",
-      "255\n",
-      "511\n",
-      "1023\n",
-      "2047\n",
-      "4095\n",
-      "8191\n",
-      "16383\n",
-      "32767\n",
-      "65535\n",
-      "131071\n",
-      "262143\n",
-      "524287\n",
-      "1048575\n",
-      "2097151\n",
-      "4194303\n",
-      "8388607\n",
-      "16777215\n",
-      "33554431\n",
-      "67108863\n",
-      "134217727\n",
-      "268435455\n",
-      "536870911\n",
-      "1073741823\n",
-      "2147483647\n",
-      "4294967295\n",
-      "8589934591\n",
-      "17179869183\n",
-      "34359738367\n",
-      "68719476735\n",
-      "137438953471\n",
-      "274877906943\n",
-      "549755813887\n",
-      "1099511627775\n",
-      "2199023255551\n",
-      "4398046511103\n",
-      "8796093022207\n",
-      "17592186044415\n",
-      "35184372088831\n",
-      "70368744177663\n",
-      "140737488355327\n",
-      "281474976710655\n",
-      "562949953421311\n",
-      "1125899906842623\n",
-      "2251799813685247\n",
-      "4503599627370495\n",
-      "9007199254740991\n",
-      "18014398509481983\n",
-      "36028797018963967\n",
-      "72057594037927935\n",
-      "144115188075855871\n",
-      "288230376151711743\n",
-      "576460752303423487\n",
-      "1152921504606846975\n",
-      "2305843009213693951\n",
-      "4611686018427387903\n",
-      "9223372036854775807\n",
-      "18446744073709551615\n",
-      "36893488147419103231\n",
-      "73786976294838206463\n",
-      "147573952589676412927\n",
-      "295147905179352825855\n",
-      "590295810358705651711\n",
-      "1180591620717411303423\n",
-      "2361183241434822606847\n",
-      "4722366482869645213695\n",
-      "9444732965739290427391\n",
-      "18889465931478580854783\n",
-      "37778931862957161709567\n",
-      "75557863725914323419135\n",
-      "151115727451828646838271\n",
-      "302231454903657293676543\n",
-      "604462909807314587353087\n",
-      "1208925819614629174706175\n",
-      "2417851639229258349412351\n",
-      "4835703278458516698824703\n",
-      "9671406556917033397649407\n",
-      "19342813113834066795298815\n",
-      "38685626227668133590597631\n",
-      "77371252455336267181195263\n",
-      "154742504910672534362390527\n",
-      "309485009821345068724781055\n",
-      "618970019642690137449562111\n",
-      "1237940039285380274899124223\n",
-      "2475880078570760549798248447\n",
-      "4951760157141521099596496895\n",
-      "9903520314283042199192993791\n",
-      "19807040628566084398385987583\n",
-      "39614081257132168796771975167\n",
-      "79228162514264337593543950335\n",
-      "158456325028528675187087900671\n",
-      "316912650057057350374175801343\n",
-      "633825300114114700748351602687\n",
-      "1267650600228229401496703205375\n",
-      "2535301200456458802993406410751\n",
-      "5070602400912917605986812821503\n",
-      "10141204801825835211973625643007\n",
-      "20282409603651670423947251286015\n",
-      "40564819207303340847894502572031\n",
-      "81129638414606681695789005144063\n",
-      "162259276829213363391578010288127\n",
-      "324518553658426726783156020576255\n",
-      "649037107316853453566312041152511\n",
-      "1298074214633706907132624082305023\n",
-      "2596148429267413814265248164610047\n",
-      "5192296858534827628530496329220095\n",
-      "10384593717069655257060992658440191\n",
-      "20769187434139310514121985316880383\n",
-      "41538374868278621028243970633760767\n",
-      "83076749736557242056487941267521535\n",
-      "166153499473114484112975882535043071\n",
-      "332306998946228968225951765070086143\n",
-      "664613997892457936451903530140172287\n",
-      "1329227995784915872903807060280344575\n",
-      "2658455991569831745807614120560689151\n",
-      "5316911983139663491615228241121378303\n",
-      "10633823966279326983230456482242756607\n",
-      "21267647932558653966460912964485513215\n",
-      "42535295865117307932921825928971026431\n",
-      "85070591730234615865843651857942052863\n",
-      "170141183460469231731687303715884105727\n",
-      "340282366920938463463374607431768211455\n",
-      "680564733841876926926749214863536422911\n",
-      "1361129467683753853853498429727072845823\n",
-      "2722258935367507707706996859454145691647\n",
-      "5444517870735015415413993718908291383295\n",
-      "10889035741470030830827987437816582766591\n",
-      "21778071482940061661655974875633165533183\n",
-      "43556142965880123323311949751266331066367\n",
-      "87112285931760246646623899502532662132735\n",
-      "174224571863520493293247799005065324265471\n",
-      "348449143727040986586495598010130648530943\n",
-      "696898287454081973172991196020261297061887\n",
-      "1393796574908163946345982392040522594123775\n",
-      "2787593149816327892691964784081045188247551\n",
-      "5575186299632655785383929568162090376495103\n",
-      "11150372599265311570767859136324180752990207\n",
-      "22300745198530623141535718272648361505980415\n",
-      "44601490397061246283071436545296723011960831\n",
-      "89202980794122492566142873090593446023921663\n",
-      "178405961588244985132285746181186892047843327\n",
-      "356811923176489970264571492362373784095686655\n",
-      "713623846352979940529142984724747568191373311\n",
-      "1427247692705959881058285969449495136382746623\n",
-      "2854495385411919762116571938898990272765493247\n",
-      "5708990770823839524233143877797980545530986495\n",
-      "11417981541647679048466287755595961091061972991\n",
-      "22835963083295358096932575511191922182123945983\n",
-      "45671926166590716193865151022383844364247891967\n",
-      "91343852333181432387730302044767688728495783935\n",
-      "182687704666362864775460604089535377456991567871\n",
-      "365375409332725729550921208179070754913983135743\n",
-      "730750818665451459101842416358141509827966271487\n",
-      "1461501637330902918203684832716283019655932542975\n",
-      "2923003274661805836407369665432566039311865085951\n",
-      "5846006549323611672814739330865132078623730171903\n",
-      "11692013098647223345629478661730264157247460343807\n",
-      "23384026197294446691258957323460528314494920687615\n",
-      "46768052394588893382517914646921056628989841375231\n",
-      "93536104789177786765035829293842113257979682750463\n",
-      "187072209578355573530071658587684226515959365500927\n",
-      "374144419156711147060143317175368453031918731001855\n",
-      "748288838313422294120286634350736906063837462003711\n",
-      "1496577676626844588240573268701473812127674924007423\n",
-      "2993155353253689176481146537402947624255349848014847\n",
-      "5986310706507378352962293074805895248510699696029695\n",
-      "11972621413014756705924586149611790497021399392059391\n",
-      "23945242826029513411849172299223580994042798784118783\n",
-      "47890485652059026823698344598447161988085597568237567\n",
-      "95780971304118053647396689196894323976171195136475135\n",
-      "191561942608236107294793378393788647952342390272950271\n",
-      "383123885216472214589586756787577295904684780545900543\n",
-      "766247770432944429179173513575154591809369561091801087\n",
-      "1532495540865888858358347027150309183618739122183602175\n",
-      "3064991081731777716716694054300618367237478244367204351\n",
-      "6129982163463555433433388108601236734474956488734408703\n",
-      "12259964326927110866866776217202473468949912977468817407\n",
-      "24519928653854221733733552434404946937899825954937634815\n",
-      "49039857307708443467467104868809893875799651909875269631\n",
-      "98079714615416886934934209737619787751599303819750539263\n",
-      "196159429230833773869868419475239575503198607639501078527\n",
-      "392318858461667547739736838950479151006397215279002157055\n",
-      "784637716923335095479473677900958302012794430558004314111\n",
-      "1569275433846670190958947355801916604025588861116008628223\n",
-      "3138550867693340381917894711603833208051177722232017256447\n",
-      "6277101735386680763835789423207666416102355444464034512895\n",
-      "12554203470773361527671578846415332832204710888928069025791\n",
-      "25108406941546723055343157692830665664409421777856138051583\n",
-      "50216813883093446110686315385661331328818843555712276103167\n",
-      "100433627766186892221372630771322662657637687111424552206335\n",
-      "200867255532373784442745261542645325315275374222849104412671\n",
-      "401734511064747568885490523085290650630550748445698208825343\n",
-      "803469022129495137770981046170581301261101496891396417650687\n",
-      "1606938044258990275541962092341162602522202993782792835301375\n",
-      "3213876088517980551083924184682325205044405987565585670602751\n",
-      "6427752177035961102167848369364650410088811975131171341205503\n",
-      "12855504354071922204335696738729300820177623950262342682411007\n",
-      "25711008708143844408671393477458601640355247900524685364822015\n",
-      "51422017416287688817342786954917203280710495801049370729644031\n",
-      "102844034832575377634685573909834406561420991602098741459288063\n",
-      "205688069665150755269371147819668813122841983204197482918576127\n",
-      "411376139330301510538742295639337626245683966408394965837152255\n",
-      "822752278660603021077484591278675252491367932816789931674304511\n",
-      "1645504557321206042154969182557350504982735865633579863348609023\n",
-      "3291009114642412084309938365114701009965471731267159726697218047\n",
-      "6582018229284824168619876730229402019930943462534319453394436095\n",
-      "13164036458569648337239753460458804039861886925068638906788872191\n",
-      "26328072917139296674479506920917608079723773850137277813577744383\n",
-      "52656145834278593348959013841835216159447547700274555627155488767\n",
-      "105312291668557186697918027683670432318895095400549111254310977535\n",
-      "210624583337114373395836055367340864637790190801098222508621955071\n",
-      "421249166674228746791672110734681729275580381602196445017243910143\n",
-      "842498333348457493583344221469363458551160763204392890034487820287\n",
-      "1684996666696914987166688442938726917102321526408785780068975640575\n",
-      "3369993333393829974333376885877453834204643052817571560137951281151\n",
-      "6739986666787659948666753771754907668409286105635143120275902562303\n",
-      "13479973333575319897333507543509815336818572211270286240551805124607\n",
-      "26959946667150639794667015087019630673637144422540572481103610249215\n",
-      "53919893334301279589334030174039261347274288845081144962207220498431\n",
-      "107839786668602559178668060348078522694548577690162289924414440996863\n",
-      "215679573337205118357336120696157045389097155380324579848828881993727\n",
-      "431359146674410236714672241392314090778194310760649159697657763987455\n",
-      "862718293348820473429344482784628181556388621521298319395315527974911\n",
-      "1725436586697640946858688965569256363112777243042596638790631055949823\n",
-      "3450873173395281893717377931138512726225554486085193277581262111899647\n",
-      "6901746346790563787434755862277025452451108972170386555162524223799295\n",
-      "13803492693581127574869511724554050904902217944340773110325048447598591\n",
-      "27606985387162255149739023449108101809804435888681546220650096895197183\n",
-      "55213970774324510299478046898216203619608871777363092441300193790394367\n",
-      "110427941548649020598956093796432407239217743554726184882600387580788735\n",
-      "220855883097298041197912187592864814478435487109452369765200775161577471\n",
-      "441711766194596082395824375185729628956870974218904739530401550323154943\n",
-      "883423532389192164791648750371459257913741948437809479060803100646309887\n",
-      "1766847064778384329583297500742918515827483896875618958121606201292619775\n",
-      "3533694129556768659166595001485837031654967793751237916243212402585239551\n",
-      "7067388259113537318333190002971674063309935587502475832486424805170479103\n",
-      "14134776518227074636666380005943348126619871175004951664972849610340958207\n",
-      "28269553036454149273332760011886696253239742350009903329945699220681916415\n",
-      "56539106072908298546665520023773392506479484700019806659891398441363832831\n",
-      "113078212145816597093331040047546785012958969400039613319782796882727665663\n",
-      "226156424291633194186662080095093570025917938800079226639565593765455331327\n",
-      "452312848583266388373324160190187140051835877600158453279131187530910662655\n",
-      "904625697166532776746648320380374280103671755200316906558262375061821325311\n",
-      "1809251394333065553493296640760748560207343510400633813116524750123642650623\n",
-      "3618502788666131106986593281521497120414687020801267626233049500247285301247\n",
-      "7237005577332262213973186563042994240829374041602535252466099000494570602495\n",
-      "14474011154664524427946373126085988481658748083205070504932198000989141204991\n",
-      "28948022309329048855892746252171976963317496166410141009864396001978282409983\n",
-      "57896044618658097711785492504343953926634992332820282019728792003956564819967\n",
-      "115792089237316195423570985008687907853269984665640564039457584007913129639935\n",
-      "231584178474632390847141970017375815706539969331281128078915168015826259279871\n",
-      "463168356949264781694283940034751631413079938662562256157830336031652518559743\n",
-      "926336713898529563388567880069503262826159877325124512315660672063305037119487\n",
-      "1852673427797059126777135760139006525652319754650249024631321344126610074238975\n",
-      "3705346855594118253554271520278013051304639509300498049262642688253220148477951\n",
-      "7410693711188236507108543040556026102609279018600996098525285376506440296955903\n",
-      "14821387422376473014217086081112052205218558037201992197050570753012880593911807\n",
-      "29642774844752946028434172162224104410437116074403984394101141506025761187823615\n",
-      "59285549689505892056868344324448208820874232148807968788202283012051522375647231\n",
-      "118571099379011784113736688648896417641748464297615937576404566024103044751294463\n",
-      "237142198758023568227473377297792835283496928595231875152809132048206089502588927\n",
-      "474284397516047136454946754595585670566993857190463750305618264096412179005177855\n",
-      "948568795032094272909893509191171341133987714380927500611236528192824358010355711\n",
-      "1897137590064188545819787018382342682267975428761855001222473056385648716020711423\n",
-      "3794275180128377091639574036764685364535950857523710002444946112771297432041422847\n",
-      "7588550360256754183279148073529370729071901715047420004889892225542594864082845695\n",
-      "15177100720513508366558296147058741458143803430094840009779784451085189728165691391\n",
-      "30354201441027016733116592294117482916287606860189680019559568902170379456331382783\n",
-      "60708402882054033466233184588234965832575213720379360039119137804340758912662765567\n",
-      "121416805764108066932466369176469931665150427440758720078238275608681517825325531135\n",
-      "242833611528216133864932738352939863330300854881517440156476551217363035650651062271\n",
-      "485667223056432267729865476705879726660601709763034880312953102434726071301302124543\n",
-      "971334446112864535459730953411759453321203419526069760625906204869452142602604249087\n",
-      "1942668892225729070919461906823518906642406839052139521251812409738904285205208498175\n",
-      "3885337784451458141838923813647037813284813678104279042503624819477808570410416996351\n",
-      "7770675568902916283677847627294075626569627356208558085007249638955617140820833992703\n",
-      "15541351137805832567355695254588151253139254712417116170014499277911234281641667985407\n",
-      "31082702275611665134711390509176302506278509424834232340028998555822468563283335970815\n",
-      "62165404551223330269422781018352605012557018849668464680057997111644937126566671941631\n",
-      "124330809102446660538845562036705210025114037699336929360115994223289874253133343883263\n",
-      "248661618204893321077691124073410420050228075398673858720231988446579748506266687766527\n",
-      "497323236409786642155382248146820840100456150797347717440463976893159497012533375533055\n",
-      "994646472819573284310764496293641680200912301594695434880927953786318994025066751066111\n",
-      "1989292945639146568621528992587283360401824603189390869761855907572637988050133502132223\n",
-      "3978585891278293137243057985174566720803649206378781739523711815145275976100267004264447\n",
-      "7957171782556586274486115970349133441607298412757563479047423630290551952200534008528895\n",
-      "15914343565113172548972231940698266883214596825515126958094847260581103904401068017057791\n",
-      "31828687130226345097944463881396533766429193651030253916189694521162207808802136034115583\n",
-      "63657374260452690195888927762793067532858387302060507832379389042324415617604272068231167\n",
-      "127314748520905380391777855525586135065716774604121015664758778084648831235208544136462335\n",
-      "254629497041810760783555711051172270131433549208242031329517556169297662470417088272924671\n",
-      "509258994083621521567111422102344540262867098416484062659035112338595324940834176545849343\n",
-      "1018517988167243043134222844204689080525734196832968125318070224677190649881668353091698687\n",
-      "2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397375\n",
-      "4074071952668972172536891376818756322102936787331872501272280898708762599526673412366794751\n",
-      "8148143905337944345073782753637512644205873574663745002544561797417525199053346824733589503\n",
-      "16296287810675888690147565507275025288411747149327490005089123594835050398106693649467179007\n",
-      "32592575621351777380295131014550050576823494298654980010178247189670100796213387298934358015\n",
-      "65185151242703554760590262029100101153646988597309960020356494379340201592426774597868716031\n",
-      "130370302485407109521180524058200202307293977194619920040712988758680403184853549195737432063\n",
-      "260740604970814219042361048116400404614587954389239840081425977517360806369707098391474864127\n",
-      "521481209941628438084722096232800809229175908778479680162851955034721612739414196782949728255\n",
-      "1042962419883256876169444192465601618458351817556959360325703910069443225478828393565899456511\n",
-      "2085924839766513752338888384931203236916703635113918720651407820138886450957656787131798913023\n",
-      "4171849679533027504677776769862406473833407270227837441302815640277772901915313574263597826047\n",
-      "8343699359066055009355553539724812947666814540455674882605631280555545803830627148527195652095\n",
-      "16687398718132110018711107079449625895333629080911349765211262561111091607661254297054391304191\n",
-      "33374797436264220037422214158899251790667258161822699530422525122222183215322508594108782608383\n",
-      "66749594872528440074844428317798503581334516323645399060845050244444366430645017188217565216767\n",
-      "133499189745056880149688856635597007162669032647290798121690100488888732861290034376435130433535\n",
-      "266998379490113760299377713271194014325338065294581596243380200977777465722580068752870260867071\n",
-      "533996758980227520598755426542388028650676130589163192486760401955554931445160137505740521734143\n",
-      "1067993517960455041197510853084776057301352261178326384973520803911109862890320275011481043468287\n",
-      "2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936575\n",
-      "4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873151\n",
-      "8543948143683640329580086824678208458410818089426611079788166431288878903122562200091848347746303\n",
-      "17087896287367280659160173649356416916821636178853222159576332862577757806245124400183696695492607\n",
-      "34175792574734561318320347298712833833643272357706444319152665725155515612490248800367393390985215\n",
-      "68351585149469122636640694597425667667286544715412888638305331450311031224980497600734786781970431\n",
-      "136703170298938245273281389194851335334573089430825777276610662900622062449960995201469573563940863\n",
-      "273406340597876490546562778389702670669146178861651554553221325801244124899921990402939147127881727\n",
-      "546812681195752981093125556779405341338292357723303109106442651602488249799843980805878294255763455\n",
-      "1093625362391505962186251113558810682676584715446606218212885303204976499599687961611756588511526911\n",
-      "2187250724783011924372502227117621365353169430893212436425770606409952999199375923223513177023053823\n",
-      "4374501449566023848745004454235242730706338861786424872851541212819905998398751846447026354046107647\n",
-      "8749002899132047697490008908470485461412677723572849745703082425639811996797503692894052708092215295\n",
-      "17498005798264095394980017816940970922825355447145699491406164851279623993595007385788105416184430591\n",
-      "34996011596528190789960035633881941845650710894291398982812329702559247987190014771576210832368861183\n",
-      "69992023193056381579920071267763883691301421788582797965624659405118495974380029543152421664737722367\n",
-      "139984046386112763159840142535527767382602843577165595931249318810236991948760059086304843329475444735\n",
-      "279968092772225526319680285071055534765205687154331191862498637620473983897520118172609686658950889471\n",
-      "559936185544451052639360570142111069530411374308662383724997275240947967795040236345219373317901778943\n",
-      "1119872371088902105278721140284222139060822748617324767449994550481895935590080472690438746635803557887\n",
-      "2239744742177804210557442280568444278121645497234649534899989100963791871180160945380877493271607115775\n",
-      "4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231551\n",
-      "8958978968711216842229769122273777112486581988938598139599956403855167484720643781523509973086428463103\n",
-      "17917957937422433684459538244547554224973163977877196279199912807710334969441287563047019946172856926207\n",
-      "35835915874844867368919076489095108449946327955754392558399825615420669938882575126094039892345713852415\n",
-      "71671831749689734737838152978190216899892655911508785116799651230841339877765150252188079784691427704831\n",
-      "143343663499379469475676305956380433799785311823017570233599302461682679755530300504376159569382855409663\n",
-      "286687326998758938951352611912760867599570623646035140467198604923365359511060601008752319138765710819327\n",
-      "573374653997517877902705223825521735199141247292070280934397209846730719022121202017504638277531421638655\n",
-      "1146749307995035755805410447651043470398282494584140561868794419693461438044242404035009276555062843277311\n",
-      "2293498615990071511610820895302086940796564989168281123737588839386922876088484808070018553110125686554623\n",
-      "4586997231980143023221641790604173881593129978336562247475177678773845752176969616140037106220251373109247\n",
-      "9173994463960286046443283581208347763186259956673124494950355357547691504353939232280074212440502746218495\n",
-      "18347988927920572092886567162416695526372519913346248989900710715095383008707878464560148424881005492436991\n",
-      "36695977855841144185773134324833391052745039826692497979801421430190766017415756929120296849762010984873983\n",
-      "73391955711682288371546268649666782105490079653384995959602842860381532034831513858240593699524021969747967\n",
-      "146783911423364576743092537299333564210980159306769991919205685720763064069663027716481187399048043939495935\n",
-      "293567822846729153486185074598667128421960318613539983838411371441526128139326055432962374798096087878991871\n",
-      "587135645693458306972370149197334256843920637227079967676822742883052256278652110865924749596192175757983743\n",
-      "1174271291386916613944740298394668513687841274454159935353645485766104512557304221731849499192384351515967487\n",
-      "2348542582773833227889480596789337027375682548908319870707290971532209025114608443463698998384768703031934975\n",
-      "4697085165547666455778961193578674054751365097816639741414581943064418050229216886927397996769537406063869951\n",
-      "9394170331095332911557922387157348109502730195633279482829163886128836100458433773854795993539074812127739903\n",
-      "18788340662190665823115844774314696219005460391266558965658327772257672200916867547709591987078149624255479807\n",
-      "37576681324381331646231689548629392438010920782533117931316655544515344401833735095419183974156299248510959615\n",
-      "75153362648762663292463379097258784876021841565066235862633311089030688803667470190838367948312598497021919231\n",
-      "150306725297525326584926758194517569752043683130132471725266622178061377607334940381676735896625196994043838463\n",
-      "300613450595050653169853516389035139504087366260264943450533244356122755214669880763353471793250393988087676927\n",
-      "601226901190101306339707032778070279008174732520529886901066488712245510429339761526706943586500787976175353855\n",
-      "1202453802380202612679414065556140558016349465041059773802132977424491020858679523053413887173001575952350707711\n",
-      "2404907604760405225358828131112281116032698930082119547604265954848982041717359046106827774346003151904701415423\n",
-      "4809815209520810450717656262224562232065397860164239095208531909697964083434718092213655548692006303809402830847\n",
-      "9619630419041620901435312524449124464130795720328478190417063819395928166869436184427311097384012607618805661695\n",
-      "19239260838083241802870625048898248928261591440656956380834127638791856333738872368854622194768025215237611323391\n",
-      "38478521676166483605741250097796497856523182881313912761668255277583712667477744737709244389536050430475222646783\n",
-      "76957043352332967211482500195592995713046365762627825523336510555167425334955489475418488779072100860950445293567\n",
-      "153914086704665934422965000391185991426092731525255651046673021110334850669910978950836977558144201721900890587135\n",
-      "307828173409331868845930000782371982852185463050511302093346042220669701339821957901673955116288403443801781174271\n",
-      "615656346818663737691860001564743965704370926101022604186692084441339402679643915803347910232576806887603562348543\n",
-      "1231312693637327475383720003129487931408741852202045208373384168882678805359287831606695820465153613775207124697087\n",
-      "2462625387274654950767440006258975862817483704404090416746768337765357610718575663213391640930307227550414249394175\n",
-      "4925250774549309901534880012517951725634967408808180833493536675530715221437151326426783281860614455100828498788351\n",
-      "9850501549098619803069760025035903451269934817616361666987073351061430442874302652853566563721228910201656997576703\n",
-      "19701003098197239606139520050071806902539869635232723333974146702122860885748605305707133127442457820403313995153407\n",
-      "39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306815\n",
-      "78804012392788958424558080200287227610159478540930893335896586808491443542994421222828532509769831281613255980613631\n",
-      "157608024785577916849116160400574455220318957081861786671793173616982887085988842445657065019539662563226511961227263\n",
-      "315216049571155833698232320801148910440637914163723573343586347233965774171977684891314130039079325126453023922454527\n",
-      "630432099142311667396464641602297820881275828327447146687172694467931548343955369782628260078158650252906047844909055\n",
-      "1260864198284623334792929283204595641762551656654894293374345388935863096687910739565256520156317300505812095689818111\n",
-      "2521728396569246669585858566409191283525103313309788586748690777871726193375821479130513040312634601011624191379636223\n",
-      "5043456793138493339171717132818382567050206626619577173497381555743452386751642958261026080625269202023248382759272447\n",
-      "10086913586276986678343434265636765134100413253239154346994763111486904773503285916522052161250538404046496765518544895\n",
-      "20173827172553973356686868531273530268200826506478308693989526222973809547006571833044104322501076808092993531037089791\n",
-      "40347654345107946713373737062547060536401653012956617387979052445947619094013143666088208645002153616185987062074179583\n",
-      "80695308690215893426747474125094121072803306025913234775958104891895238188026287332176417290004307232371974124148359167\n",
-      "161390617380431786853494948250188242145606612051826469551916209783790476376052574664352834580008614464743948248296718335\n",
-      "322781234760863573706989896500376484291213224103652939103832419567580952752105149328705669160017228929487896496593436671\n",
-      "645562469521727147413979793000752968582426448207305878207664839135161905504210298657411338320034457858975792993186873343\n",
-      "1291124939043454294827959586001505937164852896414611756415329678270323811008420597314822676640068915717951585986373746687\n",
-      "2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493375\n",
-      "5164499756173817179311838344006023748659411585658447025661318713081295244033682389259290706560275662871806343945494986751\n",
-      "10328999512347634358623676688012047497318823171316894051322637426162590488067364778518581413120551325743612687890989973503\n",
-      "20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947007\n",
-      "41315998049390537434494706752048189989275292685267576205290549704650361952269459114074325652482205302974450751563959894015\n",
-      "82631996098781074868989413504096379978550585370535152410581099409300723904538918228148651304964410605948901503127919788031\n",
-      "165263992197562149737978827008192759957101170741070304821162198818601447809077836456297302609928821211897803006255839576063\n",
-      "330527984395124299475957654016385519914202341482140609642324397637202895618155672912594605219857642423795606012511679152127\n",
-      "661055968790248598951915308032771039828404682964281219284648795274405791236311345825189210439715284847591212025023358304255\n",
-      "1322111937580497197903830616065542079656809365928562438569297590548811582472622691650378420879430569695182424050046716608511\n",
-      "2644223875160994395807661232131084159313618731857124877138595181097623164945245383300756841758861139390364848100093433217023\n",
-      "5288447750321988791615322464262168318627237463714249754277190362195246329890490766601513683517722278780729696200186866434047\n",
-      "10576895500643977583230644928524336637254474927428499508554380724390492659780981533203027367035444557561459392400373732868095\n",
-      "21153791001287955166461289857048673274508949854856999017108761448780985319561963066406054734070889115122918784800747465736191\n",
-      "42307582002575910332922579714097346549017899709713998034217522897561970639123926132812109468141778230245837569601494931472383\n",
-      "84615164005151820665845159428194693098035799419427996068435045795123941278247852265624218936283556460491675139202989862944767\n",
-      "169230328010303641331690318856389386196071598838855992136870091590247882556495704531248437872567112920983350278405979725889535\n",
-      "338460656020607282663380637712778772392143197677711984273740183180495765112991409062496875745134225841966700556811959451779071\n",
-      "676921312041214565326761275425557544784286395355423968547480366360991530225982818124993751490268451683933401113623918903558143\n",
-      "1353842624082429130653522550851115089568572790710847937094960732721983060451965636249987502980536903367866802227247837807116287\n",
-      "2707685248164858261307045101702230179137145581421695874189921465443966120903931272499975005961073806735733604454495675614232575\n",
-      "5415370496329716522614090203404460358274291162843391748379842930887932241807862544999950011922147613471467208908991351228465151\n",
-      "10830740992659433045228180406808920716548582325686783496759685861775864483615725089999900023844295226942934417817982702456930303\n",
-      "21661481985318866090456360813617841433097164651373566993519371723551728967231450179999800047688590453885868835635965404913860607\n",
-      "43322963970637732180912721627235682866194329302747133987038743447103457934462900359999600095377180907771737671271930809827721215\n",
-      "86645927941275464361825443254471365732388658605494267974077486894206915868925800719999200190754361815543475342543861619655442431\n",
-      "173291855882550928723650886508942731464777317210988535948154973788413831737851601439998400381508723631086950685087723239310884863\n",
-      "346583711765101857447301773017885462929554634421977071896309947576827663475703202879996800763017447262173901370175446478621769727\n",
-      "693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455\n",
-      "1386334847060407429789207092071541851718218537687908287585239790307310653902812811519987203052069789048695605480701785914487078911\n",
-      "2772669694120814859578414184143083703436437075375816575170479580614621307805625623039974406104139578097391210961403571828974157823\n",
-      "5545339388241629719156828368286167406872874150751633150340959161229242615611251246079948812208279156194782421922807143657948315647\n",
-      "11090678776483259438313656736572334813745748301503266300681918322458485231222502492159897624416558312389564843845614287315896631295\n",
-      "22181357552966518876627313473144669627491496603006532601363836644916970462445004984319795248833116624779129687691228574631793262591\n",
-      "44362715105933037753254626946289339254982993206013065202727673289833940924890009968639590497666233249558259375382457149263586525183\n",
-      "88725430211866075506509253892578678509965986412026130405455346579667881849780019937279180995332466499116518750764914298527173050367\n",
-      "177450860423732151013018507785157357019931972824052260810910693159335763699560039874558361990664932998233037501529828597054346100735\n",
-      "354901720847464302026037015570314714039863945648104521621821386318671527399120079749116723981329865996466075003059657194108692201471\n",
-      "709803441694928604052074031140629428079727891296209043243642772637343054798240159498233447962659731992932150006119314388217384402943\n",
-      "1419606883389857208104148062281258856159455782592418086487285545274686109596480318996466895925319463985864300012238628776434768805887\n",
-      "2839213766779714416208296124562517712318911565184836172974571090549372219192960637992933791850638927971728600024477257552869537611775\n",
-      "5678427533559428832416592249125035424637823130369672345949142181098744438385921275985867583701277855943457200048954515105739075223551\n",
-      "11356855067118857664833184498250070849275646260739344691898284362197488876771842551971735167402555711886914400097909030211478150447103\n",
-      "22713710134237715329666368996500141698551292521478689383796568724394977753543685103943470334805111423773828800195818060422956300894207\n",
-      "45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788415\n",
-      "90854840536950861318665475986000566794205170085914757535186274897579911014174740415773881339220445695095315200783272241691825203576831\n",
-      "181709681073901722637330951972001133588410340171829515070372549795159822028349480831547762678440891390190630401566544483383650407153663\n",
-      "363419362147803445274661903944002267176820680343659030140745099590319644056698961663095525356881782780381260803133088966767300814307327\n",
-      "726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614655\n",
-      "1453677448591213781098647615776009068707282721374636120562980398361278576226795846652382101427527131121525043212532355867069203257229311\n",
-      "2907354897182427562197295231552018137414565442749272241125960796722557152453591693304764202855054262243050086425064711734138406514458623\n",
-      "5814709794364855124394590463104036274829130885498544482251921593445114304907183386609528405710108524486100172850129423468276813028917247\n",
-      "11629419588729710248789180926208072549658261770997088964503843186890228609814366773219056811420217048972200345700258846936553626057834495\n",
-      "23258839177459420497578361852416145099316523541994177929007686373780457219628733546438113622840434097944400691400517693873107252115668991\n",
-      "46517678354918840995156723704832290198633047083988355858015372747560914439257467092876227245680868195888801382801035387746214504231337983\n",
-      "93035356709837681990313447409664580397266094167976711716030745495121828878514934185752454491361736391777602765602070775492429008462675967\n",
-      "186070713419675363980626894819329160794532188335953423432061490990243657757029868371504908982723472783555205531204141550984858016925351935\n",
-      "372141426839350727961253789638658321589064376671906846864122981980487315514059736743009817965446945567110411062408283101969716033850703871\n",
-      "744282853678701455922507579277316643178128753343813693728245963960974631028119473486019635930893891134220822124816566203939432067701407743\n",
-      "1488565707357402911845015158554633286356257506687627387456491927921949262056238946972039271861787782268441644249633132407878864135402815487\n",
-      "2977131414714805823690030317109266572712515013375254774912983855843898524112477893944078543723575564536883288499266264815757728270805630975\n",
-      "5954262829429611647380060634218533145425030026750509549825967711687797048224955787888157087447151129073766576998532529631515456541611261951\n",
-      "11908525658859223294760121268437066290850060053501019099651935423375594096449911575776314174894302258147533153997065059263030913083222523903\n",
-      "23817051317718446589520242536874132581700120107002038199303870846751188192899823151552628349788604516295066307994130118526061826166445047807\n",
-      "47634102635436893179040485073748265163400240214004076398607741693502376385799646303105256699577209032590132615988260237052123652332890095615\n",
-      "95268205270873786358080970147496530326800480428008152797215483387004752771599292606210513399154418065180265231976520474104247304665780191231\n",
-      "190536410541747572716161940294993060653600960856016305594430966774009505543198585212421026798308836130360530463953040948208494609331560382463\n",
-      "381072821083495145432323880589986121307201921712032611188861933548019011086397170424842053596617672260721060927906081896416989218663120764927\n",
-      "762145642166990290864647761179972242614403843424065222377723867096038022172794340849684107193235344521442121855812163792833978437326241529855\n",
-      "1524291284333980581729295522359944485228807686848130444755447734192076044345588681699368214386470689042884243711624327585667956874652483059711\n",
-      "3048582568667961163458591044719888970457615373696260889510895468384152088691177363398736428772941378085768487423248655171335913749304966119423\n",
-      "6097165137335922326917182089439777940915230747392521779021790936768304177382354726797472857545882756171536974846497310342671827498609932238847\n",
-      "12194330274671844653834364178879555881830461494785043558043581873536608354764709453594945715091765512343073949692994620685343654997219864477695\n",
-      "24388660549343689307668728357759111763660922989570087116087163747073216709529418907189891430183531024686147899385989241370687309994439728955391\n",
-      "48777321098687378615337456715518223527321845979140174232174327494146433419058837814379782860367062049372295798771978482741374619988879457910783\n",
-      "97554642197374757230674913431036447054643691958280348464348654988292866838117675628759565720734124098744591597543956965482749239977758915821567\n",
-      "195109284394749514461349826862072894109287383916560696928697309976585733676235351257519131441468248197489183195087913930965498479955517831643135\n",
-      "390218568789499028922699653724145788218574767833121393857394619953171467352470702515038262882936496394978366390175827861930996959911035663286271\n",
-      "780437137578998057845399307448291576437149535666242787714789239906342934704941405030076525765872992789956732780351655723861993919822071326572543\n",
-      "1560874275157996115690798614896583152874299071332485575429578479812685869409882810060153051531745985579913465560703311447723987839644142653145087\n",
-      "3121748550315992231381597229793166305748598142664971150859156959625371738819765620120306103063491971159826931121406622895447975679288285306290175\n",
-      "6243497100631984462763194459586332611497196285329942301718313919250743477639531240240612206126983942319653862242813245790895951358576570612580351\n",
-      "12486994201263968925526388919172665222994392570659884603436627838501486955279062480481224412253967884639307724485626491581791902717153141225160703\n",
-      "24973988402527937851052777838345330445988785141319769206873255677002973910558124960962448824507935769278615448971252983163583805434306282450321407\n",
-      "49947976805055875702105555676690660891977570282639538413746511354005947821116249921924897649015871538557230897942505966327167610868612564900642815\n",
-      "99895953610111751404211111353381321783955140565279076827493022708011895642232499843849795298031743077114461795885011932654335221737225129801285631\n",
-      "199791907220223502808422222706762643567910281130558153654986045416023791284464999687699590596063486154228923591770023865308670443474450259602571263\n",
-      "399583814440447005616844445413525287135820562261116307309972090832047582568929999375399181192126972308457847183540047730617340886948900519205142527\n",
-      "799167628880894011233688890827050574271641124522232614619944181664095165137859998750798362384253944616915694367080095461234681773897801038410285055\n",
-      "1598335257761788022467377781654101148543282249044465229239888363328190330275719997501596724768507889233831388734160190922469363547795602076820570111\n",
-      "3196670515523576044934755563308202297086564498088930458479776726656380660551439995003193449537015778467662777468320381844938727095591204153641140223\n",
-      "6393341031047152089869511126616404594173128996177860916959553453312761321102879990006386899074031556935325554936640763689877454191182408307282280447\n",
-      "12786682062094304179739022253232809188346257992355721833919106906625522642205759980012773798148063113870651109873281527379754908382364816614564560895\n",
-      "25573364124188608359478044506465618376692515984711443667838213813251045284411519960025547596296126227741302219746563054759509816764729633229129121791\n",
-      "51146728248377216718956089012931236753385031969422887335676427626502090568823039920051095192592252455482604439493126109519019633529459266458258243583\n",
-      "102293456496754433437912178025862473506770063938845774671352855253004181137646079840102190385184504910965208878986252219038039267058918532916516487167\n",
-      "204586912993508866875824356051724947013540127877691549342705710506008362275292159680204380770369009821930417757972504438076078534117837065833032974335\n",
-      "409173825987017733751648712103449894027080255755383098685411421012016724550584319360408761540738019643860835515945008876152157068235674131666065948671\n",
-      "818347651974035467503297424206899788054160511510766197370822842024033449101168638720817523081476039287721671031890017752304314136471348263332131897343\n",
-      "1636695303948070935006594848413799576108321023021532394741645684048066898202337277441635046162952078575443342063780035504608628272942696526664263794687\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for i in range(500):\n",
     "    print(2**i - 1)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Typesetting Equations.ipynb

@@ -1,271 +1,271 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The Markdown parser included in IPython is MathJax-aware.  This means that you can freely mix in mathematical expressions using the [MathJax subset of Tex and LaTeX](http://docs.mathjax.org/en/latest/tex.html#tex-support).  [Some examples from the MathJax site](http://www.mathjax.org/demos/tex-samples/) are reproduced below, as well as the Markdown+TeX source."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Motivating Examples\n",
     "\n",
     "---\n",
     "\n",
     "## The Lorenz Equations\n",
     "### Source\n",
     "```\\begin{align}\n",
     "\\dot{x} & = \\sigma(y-x) \\\\\n",
     "\\dot{y} & = \\rho x - y - xz \\\\\n",
     "\\dot{z} & = -\\beta z + xy\n",
     "\\end{align}\n",
     "```\n",
     "### Display\n",
     "\\begin{align}\n",
     "\\dot{x} & = \\sigma(y-x) \\\\\n",
     "\\dot{y} & = \\rho x - y - xz \\\\\n",
     "\\dot{z} & = -\\beta z + xy\n",
     "\\end{align}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## The Cauchy-Schwarz Inequality\n",
     "### Source\n",
     "```\\begin{equation*}\n",
     "\\left( \\sum_{k=1}^n a_k b_k \\right)^2 \\leq \\left( \\sum_{k=1}^n a_k^2 \\right) \\left( \\sum_{k=1}^n b_k^2 \\right)\n",
     "\\end{equation*}\n",
     "```\n",
     "### Display\n",
     "\\begin{equation*}\n",
     "\\left( \\sum_{k=1}^n a_k b_k \\right)^2 \\leq \\left( \\sum_{k=1}^n a_k^2 \\right) \\left( \\sum_{k=1}^n b_k^2 \\right)\n",
     "\\end{equation*}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## A Cross Product Formula\n",
     "### Source\n",
     "```\\begin{equation*}\n",
     "\\mathbf{V}_1 \\times \\mathbf{V}_2 =  \\begin{vmatrix}\n",
     "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n",
     "\\frac{\\partial X}{\\partial u} &  \\frac{\\partial Y}{\\partial u} & 0 \\\\\n",
     "\\frac{\\partial X}{\\partial v} &  \\frac{\\partial Y}{\\partial v} & 0\n",
     "\\end{vmatrix}  \n",
     "\\end{equation*}\n",
     "```\n",
     "### Display\n",
     "\\begin{equation*}\n",
     "\\mathbf{V}_1 \\times \\mathbf{V}_2 =  \\begin{vmatrix}\n",
     "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n",
     "\\frac{\\partial X}{\\partial u} &  \\frac{\\partial Y}{\\partial u} & 0 \\\\\n",
     "\\frac{\\partial X}{\\partial v} &  \\frac{\\partial Y}{\\partial v} & 0\n",
     "\\end{vmatrix}  \n",
     "\\end{equation*}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## The probability of getting \\(k\\) heads when flipping \\(n\\) coins is\n",
     "### Source\n",
     "```\\begin{equation*}\n",
     "P(E)   = {n \\choose k} p^k (1-p)^{ n-k} \n",
     "\\end{equation*}\n",
     "```\n",
     "### Display\n",
     "\\begin{equation*}\n",
     "P(E)   = {n \\choose k} p^k (1-p)^{ n-k} \n",
     "\\end{equation*}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## An Identity of Ramanujan\n",
     "### Source\n",
     "```\\begin{equation*}\n",
     "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n",
     "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n",
     "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n",
     "\\end{equation*}\n",
     "```\n",
     "### Display\n",
     "\\begin{equation*}\n",
     "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n",
     "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n",
     "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n",
     "\\end{equation*}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## A Rogers-Ramanujan Identity\n",
     "### Source\n",
     "```\\begin{equation*}\n",
     "1 +  \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n",
     "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n",
     "\\quad\\quad \\text{for $|q|<1$}. \n",
     "\\end{equation*}\n",
     "```\n",
     "### Display\n",
     "\\begin{equation*}\n",
     "1 + \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n",
     "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n",
     "\\quad\\quad \\text{for $|q|<1$}. \n",
     "\\end{equation*}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Maxwell's Equations\n",
     "### Source\n",
     "```\\begin{align}\n",
     "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\   \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n",
     "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n",
     "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n",
     "\\end{align}\n",
     "```\n",
     "### Display\n",
     "\\begin{align}\n",
     "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\   \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n",
     "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n",
     "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n",
     "\\end{align}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Equation Numbering and References\n",
     "\n",
     "---\n",
     "\n",
     "Equation numbering and referencing will be available in a future version of IPython."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Inline Typesetting (Mixing Markdown and TeX)\n",
     "\n",
     "---\n",
     "\n",
     "While display equations look good for a page of samples, the ability to mix math and *formatted* **text** in a paragraph is also important.\n",
     "\n",
     "## Source\n",
     "``` This expression $\\sqrt{3x-1}+(1+x)^2$ is an example of a TeX inline equation in a **[Markdown-formatted](http://daringfireball.net/projects/markdown/)** sentence.  \n",
     "```\n",
     "## Display\n",
     "This expression $\\sqrt{3x-1}+(1+x)^2$ is an example of a TeX inline equation in a **[Markdown-formatted](http://daringfireball.net/projects/markdown/)** sentence.  "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Other Syntax\n",
     "\n",
     "---\n",
     "\n",
     "You will notice in other places on the web that `$$` are needed explicitly to begin and end MathJax typesetting.  This is **not** required if you will be using TeX environments, but the IPython notebook will accept this syntax on legacy notebooks.  \n",
     "\n",
     "### Source\n",
     "```\n",
     "$$\n",
     "\\begin{array}{c}\n",
     "y_1 \\\\\\\n",
     "y_2 \\mathtt{t}_i \\\\\\\n",
     "z_{3,4}\n",
     "\\end{array}\n",
     "$$\n",
     "```\n",
     "\n",
     "```\n",
     "$$\n",
     "\\begin{array}{c}\n",
     "y_1 \\cr\n",
     "y_2 \\mathtt{t}_i \\cr\n",
     "y_{3}\n",
     "\\end{array}\n",
     "$$\n",
     "```\n",
     "\n",
     "```\n",
     "$$\\begin{eqnarray} \n",
     "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n",
     "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n",
     "\\end{eqnarray}$$\n",
     "```\n",
     "\n",
     "```\n",
     "$$\n",
     "x=4\n",
     "$$\n",
     "```\n",
     "\n",
     "### Display\n",
     "$$\n",
     "\\begin{array}{c}\n",
     "y_1 \\\\\\\n",
     "y_2 \\mathtt{t}_i \\\\\\\n",
     "z_{3,4}\n",
     "\\end{array}\n",
     "$$\n",
     "\n",
     "$$\n",
     "\\begin{array}{c}\n",
     "y_1 \\cr\n",
     "y_2 \\mathtt{t}_i \\cr\n",
     "y_{3}\n",
     "\\end{array}\n",
     "$$\n",
     "\n",
     "$$\\begin{eqnarray} \n",
     "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n",
     "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n",
     "\\end{eqnarray}$$\n",
     "\n",
     "$$\n",
     "x=4\n",
     "$$"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Using nbconvert as a Library.ipynb

@@ -1,1449 +1,619 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# NbConvert, Python library"
+    "# Using nbconvert as a Library"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this Notebook, I will introduce you to the programatic API of nbconvert to show you how to use it in various context. \n",
+    "In this Notebook, you will be introduced to the programatic API of nbconvert and how it can be used in various contexts. \n",
     "\n",
-    "For this I will use one of [@jakevdp](https://github.com/jakevdp) great [blog post](http://jakevdp.github.io/blog/2013/04/15/code-golf-in-python-sudoku/).\n",
-    "I've explicitely chosen a post with no javascript tricks as Jake seem to be found of right now, for the reason that the becommings of embeding javascript in nbviewer, which is based on nbconvert is not fully decided yet. \n",
-    "\n",
-    "\n",
-    "This will not focus on using the command line tool to convert file. The attentive reader will point-out that no data are read from, or written to disk during the conversion process. Indeed, nbconvert as been though as much as\n",
-    "possible to avoid IO operation and work as well in a database, or web-based environement."
+    "One of [@jakevdp](https://github.com/jakevdp)'s great [blog posts](http://jakevdp.github.io/blog/2013/04/15/code-golf-in-python-sudoku/) will be used to demonstrate.  This notebook will not focus on using the command line tool. The attentive reader will point-out that no data is read from or written to disk during the conversion process. Nbconvert has been designed to work in memory so that it works well in a database or web-based environement too."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Quick overview"
+    "## Quick overview"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Credit, Jonathan Freder (@jdfreder on github)\n",
+    "Credit, Jonathan Frederic (@jdfreder on github)\n",
     "\n",
     "<center>\n",
     " ![nbca](images/nbconvert_arch.png)\n",
     "</center>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The main principle of nbconvert is to instanciate a `Exporter` that controle\n",
-    "a pipeline through which each notebook you want to export with go through."
+    "The main principle of nbconvert is to instantiate an `Exporter` that controls\n",
+    "the pipeline through which notebooks are converted."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's start by importing what we need from the API, and download @jakevdp's notebook."
+    "First, download @jakevdp's notebook."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'{\\n \"metadata\": {\\n  \"name\": \"XKCD_plots\"\\n },\\n \"nbformat\": 3,\\n...'"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import requests\n",
     "response = requests.get('http://jakevdp.github.com/downloads/notebooks/XKCD_plots.ipynb')\n",
     "response.text[0:60]+'...'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you do not have request install downlad by hand, and read the file as usual."
+    "If you do not have `requests`, install it by running `pip install requests` (or if you don't have pip installed, you can find it on PYPI)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We read the response into a slightly more convenient format which represent IPython notebook. \n",
-    "There are not real advantages for now, except some convenient methods, but with time this structure should be able to\n",
-    "guarantee that the notebook structure is valid. Note also that the in-memory format and on disk format can be slightly different. In particual, on disk, multiline strings might be spitted into list of string to be more version control friendly."
+    "The response is a JSON string which represents an IPython notebook. Next, read the response using nbformat.\n",
+    "\n",
+    "Doing this will guarantee that the notebook structure is valid. Note that the in-memory format and on disk format are slightly different. In particual, on disk, multiline strings might be splitted into a list of strings."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'cell_type': 'markdown',\n",
-       " 'metadata': {},\n",
-       " 'source': '# XKCD plots in Matplotlib'}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython import nbformat\n",
     "jake_notebook = nbformat.reads(response.text, as_version=4)\n",
     "jake_notebook.cells[0]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So we have here Jake's notebook in a convenient form, which is mainly a Super-Powered dict and list nested.\n",
-    "You don't need to worry about the exact structure."
+    "The nbformat API returns a special dict.  You don't need to worry about the details of the structure."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The nbconvert API exposes some basic exporter for common format and default options. We will start\n",
-    "by using one of them. First we import it, instanciate an instance with most of the default parameters and fed it\n",
-    "the downloaded notebook. "
+    "The nbconvert API exposes some basic exporters for common formats and defaults. You will start\n",
+    "by using one of them. First you will import it, then instantiate it using most of the defaults, and finally you will process notebook downloaded early."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "from IPython.config import Config\n",
     "from IPython.nbconvert import HTMLExporter\n",
     "\n",
-    "## I use `basic` here to have less boilerplate and headers in the HTML.\n",
-    "## we'll see later how to pass config to exporters.\n",
+    "# The `basic` template is used here.\n",
+    "# Later you'll learn how to configure the exporter.\n",
     "html_exporter = HTMLExporter(config=Config({'HTMLExporter':{'default_template':'basic'}}))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "(body, resources) = html_exporter.from_notebook_node(jake_notebook)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The exporter returns a tuple containing the body of the converted notebook, here raw HTML, as well as a resources dict.\n",
-    "The resource dict contains (among many things) the extracted PNG, JPG [...etc] from the notebook when applicable.\n",
-    "The basic HTML exporter does keep them as embeded base64 into the notebook, but one can do ask the figures to be extracted. Cf advance use. So for now the resource dict **should** be mostly empty, except for 1 key containing some css, and 2 others whose content will be obvious.\n",
+    "The exporter returns a tuple containing the body of the converted notebook, raw HTML in this case, as well as a resources dict.  The resource dict contains (among many things) the extracted PNG, JPG [...etc] from the notebook when applicable.  The basic HTML exporter leaves the figures as embeded base64, but you can configure it to extract the figures.  So for now, the resource dict **should** be mostly empty, except for a key containing CSS and a few others whose content will be obvious.\n",
     "\n",
-    "Exporter are stateless, you won't be able to extract any usefull information (except their configuration) from them.\n",
-    "You can directly re-use the instance to convert another notebook. Each exporter expose for convenience a `from_file` and `from_filename` methods if you need."
+    "`Exporter`s are stateless, so you won't be able to extract any usefull information beyond their configuration from them.  You can re-use an exporter instance to convert another notebook. Each exporter exposes, for convenience, a `from_file` and `from_filename` method."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['raw_mimetypes', 'inlining', 'metadata', 'output_extension']\n",
-      "defaultdict(None, {'name': 'Notebook'})\n",
-      ".html\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print([key for key in resources ])\n",
     "print(resources['metadata'])\n",
     "print(resources['output_extension'])\n",
-    "# print resources['inlining'] # too lng to be shown"
+    "# print resources['inlining'] # Too long to be shown"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<!DOCTYPE html>\n",
-      "<html>\n",
-      "<head>\n",
-      "\n",
-      "<meta charset=\"utf-8\" />\n",
-      "<title>Notebook</title>\n",
-      "\n",
-      "<script src=\"https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js\"></script>\n",
-      "<script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.min.js\"></script>\n",
-      "\n",
-      "<style type=\"text/css\">\n",
-      "    /*!\n",
-      "*\n",
-      "* Twitter Bootstrap\n",
-      "*\n",
-      "*/\n",
-      "/*! normalize.css v3.0.2 | MIT License | git.io/normalize */\n",
-      "html {\n",
-      "  fon...\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Part of the body, here the first Heading\n",
     "start = body.index('<h1 id', )\n",
     "print(body[:400]+'...')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can directly write the body into an HTML file if you wish, as you see it does not contains any body tag, or style declaration, but thoses are included in the default HtmlExporter if you do not pass it a config object as I did."
+    "If you understand HTML, you'll notice that some common tags are ommited, like the `body` tag.  Those tags are included in the default `HtmlExporter`, which is what would have been constructed if no Config object was passed into it."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Extracting Figures"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When exporting one might want to extract the base64 encoded figures to separate files, this is by default what does the RstExporter does, let see how to use it. "
+    "When exporting you may want to extract the base64 encoded figures as files, this is by default what the `RstExporter` does (as seen below)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "from IPython.nbconvert import RSTExporter\n",
     "\n",
     "rst_exporter = RSTExporter()\n",
     "\n",
     "(body,resources) = rst_exporter.from_notebook_node(jake_notebook)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "XKCD plots in Matplotlib\n",
-      "========================\n",
-      "\n",
-      "This notebook originally appeared as a blog post at `Pythonic\n",
-      "Perambulations <http://jakevdp.github.com/blog/2012/10/07/xkcd-style-plots-in-matplotlib/>`__\n",
-      "by Jake Vanderplas.\n",
-      "\n",
-      ".. raw:: html\n",
-      "\n",
-      "   <!-- PELICAN_BEGIN_SUMMARY -->\n",
-      "\n",
-      "*Update: the matplotlib pull request has been merged! See* `*This\n",
-      "post* <http://jakevdp.github.io/blog/2013/07/10/XKCD-plots-in-matplotlib/>`__\n",
-      "*for a description of the XKCD functionality now built-in to\n",
-      "matplotlib!*\n",
-      "\n",
-      "One of the problems I've had with typical matplotlib figures is that\n",
-      "everything in them is so precise, so perfect. For an example of what I\n",
-      "mean, take a look at this figure:\n",
-      "\n",
-      ".. code:: python\n",
-      "\n",
-      "    from IPython.display import Image\n",
-      "    Image('http://jakevdp.github.com/figures/xkcd_version.png')\n",
-      "\n",
-      "\n",
-      "\n",
-      ".. image:: output_3_0.png\n",
-      "\n",
-      "\n",
-      "\n",
-      "Sometimes when showing schematic plots, this is the type of figure I\n",
-      "want to display. But drawing it by hand is a pain: I'd rather just use\n",
-      "matpl...\n",
-      "[.....]\n",
-      "mage:: output_3_0.png\n",
-      "\n",
-      "\n",
-      "\n",
-      "Sometimes when showing schematic plots, this is the type of figure I\n",
-      "want to display. But drawing it by hand is a pain: I'd rather just use\n",
-      "matplotlib. The problem is, matplotlib is a bit too precise. Attempting\n",
-      "to duplicate this figure in matplotlib leads to something like this:\n",
-      "\n",
-      ".. code:: python\n",
-      "\n",
-      "    Image('http://jakevdp.github.com/figures/mpl_version.png')\n",
-      "\n",
-      "\n",
-      "\n",
-      ".. image:...\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(body[:970]+'...')\n",
     "print('[.....]')\n",
     "print(body[800:1200]+'...')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we see that base64 images are not embeded, but we get what look like file name. Actually those are (Configurable) keys to get back the binary data from the resources dict we havent inspected earlier.\n"
+    "Notice that base64 images are not embeded, but instead there are file name like strings.  The strings actually are (configurable) keys that map to the binary data in the resources dict.\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So when writing a Rst Plugin for any blogengine, Sphinx or anything else, you will be responsible for writing all those data to disk, in the right place. \n",
-    "Of course to help you in this task all those naming are configurable in the right place."
+    "Note, if you write an RST Plugin, you are responsible for writing all the files to the disk (or uploading, etc...) in the right location.  Of course, the naming scheme is configurable."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "let's try to see how to get one of these images"
+    "As an exercise, this notebook will show you how to get one of those images."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['output_5_0.png',\n",
-       " 'output_16_0.png',\n",
-       " 'output_13_1.png',\n",
-       " 'output_18_1.png',\n",
-       " 'output_3_0.png']"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "list(resources['outputs'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We have extracted 5 binary figures, here `png`s, but they could have been svg, and then wouldn't appear in the binary sub dict.\n",
-    "keep in mind that a object having multiple _repr_ will store all it's repr in the notebook. \n",
+    "There are 5 extracted binary figures, all `png`s, but they could have been `svg`s which then wouldn't appear in the binary sub dict.  Keep in mind that objects with multiple reprs will have every repr stored in the notebook avaliable for conversion. \n",
     "\n",
-    "Hence if you provide `_repr_javascript_`,`_repr_latex_` and `_repr_png_`to an object, you will be able to determine at conversion time which representaition is the more appropriate. You could even decide to show all the representaition of an object, it's up to you. But this will require beeing a little more involve and write a few line of Jinja template. This will probably be the subject of another tutorial.\n",
+    "Hence if the object provides `_repr_javascript_`, `_repr_latex_`, and `_repr_png_`, you will be able to determine, at conversion time, which representaition is most appropriate. You could even show all of the representaitions of an object in a single export, it's up to you. Doing so would require a little more involvement on your part and a custom Jinja template.\n",
     "\n",
-    "Back to our images,\n",
-    "\n"
+    "Back to the task of extracting an image, the Image display object can be used to display one of the images (as seen below)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": [
-       "iVBORw0KGgoAAAANSUhEUgAAAbAAAAEgCAYAAADVKCZpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
-       "AAALEgAACxIB0t1+/AAAIABJREFUeJzsnXd4FGXXxu/ZTYP0RkvoJKH3IvAivQsiINIEgUAsgPIJ\n",
-       "Cq8IAgroqxRRUJpSpCO9ifQSpEgNvYYSCJDek93z/XEyuwkkIWV3Zjd5fte11yxbZu5ZsnvPc57z\n",
-       "nAMSCCyApUuXUqlSpUiSJKpfvz4dPnzY8Fy1atUoLCwsy/edPXuWiIjS0tLo008/JVtbW5Ik6aVb\n",
-       "mTJlKDEx0fA++fX29vak1Wqpe/fu9ODBAyIiWrFiBbm5udHx48fzfT6ffPIJOTo60u3bt/O9j5zY\n",
-       "vn07VaxY0XB+JUuWpBs3brzyfSdOnCAfHx+Kjo7O8zHv379PDg4O5OTkRFFRUfmRLRCYFBsIBCoz\n",
-       "e/ZsfPrppyhZsiSmTp2K5ORkrFmzBi1atAAAJCYmIiUlJcv3NmnSBMnJydi4cSNmzZoFLy8vTJky\n",
-       "Bfb29ple16hRIzg4OAAAUlNT0b9/f2zcuBG1atVCUFAQjhw5giNHjqBv3764efMmoqOjsWnTJjRt\n",
-       "2hSjR4/G77//jlu3bsHb2ztX57R//34kJibi/v378PT0REJCQo6v9/DwgJ2dXa72/ejRI/Tq1Qup\n",
-       "qamYNWsWrl69it9++w0dO3bE8ePHUbJkScNrY2Nj4ezsbPi3JEl49OgRlixZgjFjxgAAYmJicqXP\n",
-       "19cX77zzDpYvX47z58/j9ddfz5VegcBsqO2ggqLNypUrSZIk8vPzo9DQ0Jeef/78Obm6umb5HBGR\n",
-       "JElERBQeHk6SJNHSpUtfeczAwECSJIm6d+9OKSkpLz0/efJkkiSJ/vrrL7py5QppNBoqX758lq/N\n",
-       "js8++4wkSaKDBw9Sv379SJIk0mg0ZG9vn+UI8fvvv8/1vtu2bUtubm40d+5cw2ObNm0iOzs7atGi\n",
-       "heGxzZs3k1arpdOnT2d6f5MmTahcuXKG8+nbt2+u9cmfzaFDh3KtVyAwF8LABKrx6NEjcnNzI3d3\n",
-       "d3r8+HGWrzlw4ABVq1aN9Hp9ls/LBpaYmEiSJNHYsWMpLCzMcHsxVLZjxw6SJIlatGhBaWlpWe5T\n",
-       "/pGeMWMG1alTh3x8fOjWrVt5Ojd/f/9MP/SnTp2iq1ev0v3790mSJOrRowft2bOH9uzZQydOnMj1\n",
-       "fo8dO0aSJNG2bdteek6+GDh//jwREU2ZMiXL1x46dIgkSaL58+cbHsutvh9++IE0Go0hdCsQqIkw\n",
-       "MIFqTJ8+nSRJom+//Tbb1xw4cCDTqCI2NpbCwsLozp07NGbMGJIkiR48eEDR0dEkSRLZ29uTg4MD\n",
-       "SZJEtra21Llz50zm16FDB9JoNPTPP/9ke0zZwOTb4MGD83xu5cuXz/aHXpIkWrZsWZ73SUTUvn17\n",
-       "GjhwYJbP6fV6qly5Mk2ePJmIiJo2bUqurq4UHx+f6XUpKSnk5eVFNjY2dPfu3TzpS0lJoa1bt+ZL\n",
-       "u0BgasQcmEA1kpOTodFoMHjw4Bxfd+7cOVy+fBlubm5o06YNrl+/bnhOkiT4+Phg5cqVAIC///4b\n",
-       "tWrVwsmTJ1GzZk2ULl36pWNWrVoVjRs3zrXOVatWoWzZspg2bVoezg4oW7Ys6tatm6f35MSDBw+w\n",
-       "f/9+XLlyJcvnJUmCk5MTQkJCEB0djQsXLqBXr14oXrx4ptfZ2tqiTZs2WL9+PaKjo/OkwdbWFt26\n",
-       "dcv3OQgEpkSjtgBB0aVChQrQ6/XYu3dvjq+Li4tDzZo14evri+vXr6Nt27bYvXs3Bg4caHhNWloa\n",
-       "AOA///kPXF1d0b59+5fMSz7mtWvXcO/evVfqGz9+PHbs2AF7e3t88803GDduXK7OKyUlBbGxsdBo\n",
-       "TPv1WrduHd544w34+fll+fyWLVtw5coVjBo1CpGRkUhISIBWq83ytRcvXkSJEiVQuXJlk2oUCJRE\n",
-       "GJhANfr374/y5ctj1KhRePLkSabnTp06halTp0KSJGi1Wnz88cfYvXs3du/ejRUrVqBDhw5o3bo1\n",
-       "iAgAcOPGDQBAREQEEhMT8fjxY8MtJibGsN/x48eDiDBw4EDodLpMx1y6dCk2bdqEevXqAeDRWufO\n",
-       "nbF79244Ozvjhx9+wKZNm155XpcvX0ZkZGSBPpus2LFjB9zd3V96PCkpCd9//z369OmDb7755pXZ\n",
-       "gRcuXMC1a9cwd+5cODo65kkDEeH69esvfXYCgRoIAxOohp2dHdavXw+NRoMGDRpgxowZCAkJwcyZ\n",
-       "M9G8eXNDWnmzZs0we/ZsdOjQAR06dECpUqUAcMhMJiQkBABQpUoVlC1bFmXKlDHc3n//fcPrqlat\n",
-       "il9//RXHjx9H48aNsWjRIly9ehWDBw9GYGAgSpcuje7du2PkyJEoX748AKB58+ZYtGgRAGDjxo2v\n",
-       "PK/jx48D4HCbKfH398fmzZsxbtw4LF68GIsXL8b06dNRqVIlzJw5E7Nnz8bYsWMBwDDy0uv1L+0n\n",
-       "KCgI9erVwzvvvJNnDXPmzEHVqlXh7++PO3fuFOyEBIICIubABKrSsGFDnDp1CtOnT8eXX36JL774\n",
-       "Ara2thg5ciQ+++wzHD58ONtQXKNGjVCnTh0AgJ+fHypUqIBWrVoB4B/wLl26wNnZ+aURSWBgIKpW\n",
-       "rYovv/wSQUFBAAAvLy8sWrQIr732GgDgxx9/zPSePn36IDk5GQEBAa88p/DwcAC8Ru1F7t+//8r3\n",
-       "Z8fMmTPh7e2NX3/9FU+fPoWtrS2CgoIwf/589OjRI9Nry5Yti5o1a2Lbtm1ITExEsWLFALABnTp1\n",
-       "CpcuXcryGK/S5+7uDkmSYGdnBycnp3yfi0BgElROIilSJCcnZ5sOLsiaI0eO0Mcff6y2jDwhZzEO\n",
-       "HTr0peeOHTtGTk5OdOfOHbPrWL58OUmSREFBQbRo0SKaNGkS2djY0PLly7N9j5L6BIKCIhGlTyII\n",
-       "zMr9+/fRsGFDhIeHY968eRg5cqTakgRmYubMmZg5cyZ27tyJZs2aqarlrbfewpYtWwBwKHb69Omi\n",
-       "goag0CAMzMzo9XosWLAA48ePR1xcHAAOw5w+fRqVKlVSWZ1AIBBYLyKJw0Q8ffoUqampmR67fPky\n",
-       "WrRogZEjRyIuLg5ubm4AgMjISHTq1AnPnj1TQ6pAIBAUCoSBmYCIiAh8/PHHOHfuHABeBzR16lTU\n",
-       "q1cPx48fR+nSpbFx40aULVsWABAQEIAbN26ge/fuSExMVFO6QCAQWC3CwEzA/v37sWbNGsTGxiIt\n",
-       "LQ1NmjTB5MmTkZKSguHDh+Py5cvo2bOnoaL6okWLUK5cOQQHB6N///5ZpjoLBAKBIGeEgb2ClJSU\n",
-       "TAthdToddDodiOtIAuBFt9WqVUPNmjVhY2ODbt26wc/PDwcOHMDChQsNoUPZwHx9fbFr1y54eHig\n",
-       "VatWJq/YIBAIBEUBkcTxClavXo2tW7fivffeQ9u2bWFjY1w6p9frodFo0Lp1azx//hybNm1C5cqV\n",
-       "kZycDL1eb1h7I+Pr64uHDx/i/v378PX1RWRkZJaVFQQCgUDwasSlfw7o9Xrcvn0ba9euxVtvvYXX\n",
-       "X38ds2fPxvHjxxEdHW0YOV27dg16vd5gRvb29i+ZF2CsHCGX4RHmJRAIBPlHVOLIAY1Gg+HDh+Pu\n",
-       "3bv4448/cOLECZw4cQIAULNmTQQGBuKff/4x1Nzz8PDIcX9y5YL4+HizaxcIBILCjggh5pLIyEic\n",
-       "PXsW27Ztw/79+3H16lUQkaEKepcuXbB9+3bodLpsK4A3bNgQZ86cwcmTJ9GoUSMl5QsEAkGhQ4zA\n",
-       "skGe31qzZg2aN2+OsmXLok2bNmjTpg0ePXqEQ4cOYdOmTXjy5AkaNmyIYcOGAUCOCRnyCCw2NlaR\n",
-       "cxAIBILCjDCwbJCNqH///pg/fz6CgoKg1+uh1WpRpkwZ9OvXz7AYuUqVKob5rYwV0l9E7k/16NEj\n",
-       "85+AQCAQFHKEgeVAWFgYAMDT09PQlwrgnkiSJMHd3T1PiRjyQuaCVCQXCAQCASOyELNAnhY8evQo\n",
-       "ihcvbugLdfbsWaxZs8YwygoJCclTm3lhYAKBQGA6hIFlgWxg+/fvR5UqVVCiRAkAwMKFC7FmzRrD\n",
-       "67Zv346lS5cit3kwsoGFhoaaWLFAIBAUPYSB5cDx48dRq1YtQ5jw1KlTKFmypMGw/vnnH1SuXBnR\n",
-       "0dG52p8YgQkEAoHpEAaWBXICx9WrV2FrawsXFxcAwN27d9G1a1dDCPHff/81tL3PDcLABAKBwHSI\n",
-       "JI5siIiIgK+vL37//Xc4OTkhOjoaKSkpaNeuHQBOs9fpdChevHiuW6t7eXnBxsYGkZGRSEpKgoOD\n",
-       "gzlPQSAQCAo1YgSWDW5ubhgzZgy8vLxw4MAB/PXXX0hJSUFgYCD++usv/P7774iIiECjRo0y1UfM\n",
-       "CY1Gg1KlSgEAHj9+bE75AoFAUOgRI7Bs0Gg0GDlypKEZ5ZUrV7BlyxasXLkS69atA8CjsOTkZADG\n",
-       "1PpXUapUKTx48ABhYWGoUKGCOU9BIBAICjViBJYFcpLGhQsXMGPGDKSlpaFRo0b4+uuvcffuXZw7\n",
-       "dw6ff/453njjDTRo0CBP+/b29gYAPH/+3OS6BQKBoCghRmDZsG7dOowaNQpPnz5Fq1at0LRpU9y+\n",
-       "fRvR0dGoW7cuvvrqK8TExBh6feVm9AXAkPSRmppqNu0CgUBQFBAGlgVnzpxBYGAgunbtioCAACxc\n",
-       "uBAxMTGYMGEC7t69Cy8vL+zevRuVKlXK875tbW0BGJtbCgQCgSB/iBBiBvR6PQBgx44d8Pb2xs8/\n",
-       "/4y33noLmzdvxldffYXmzZvj9u3baN26NYKCggAg14uYZWQDEyMwgUAgKBjCwLJg3759aNiwIezt\n",
-       "7VGnTh1UrFgRvr6++N///gc3Nzf4+flh37592LVrV65DhzKJiYkAIFLoBQKBoIAIA8uAvIC5ePHi\n",
-       "uHLlisFsEhISUL16dYNZyYkYcgWOvIzCIiMjAYhuzAKBQFBQhIFlwYgRI2BrawsvLy8QEVasWIHB\n",
-       "gwcb1nvJC5ebNm0KIPcJHIDRwF7VvVkgEAgEOSOSODIgN7GsUqUK/P39ER0dDVdX15e6J1+9ejVT\n",
-       "lfq8IEZgAoFAYBqEgWVAHkmFhYUhODgYHh4esLW1hZ+fH1q2bIlu3bohICAAly5dQq1atQAAOp3O\n",
-       "0CcsN4gRmEAgEJgGifKaRlcECA8PR1JSEsqVK4cHDx5g9+7dOHDgAE6cOIFHjx4hOTkZn3zyCWbN\n",
-       "mmUYteWG1NRU2NnZQavVIjU1Nc8JIAKBQCAwIgwsAxnLQSUlJUGSJNjb27/0utDQUJQsWTLL53Ii\n",
-       "PDwcJUuWhKenJ549e2YSzQKBQFBUESHEDEiShAMHDuDo0aO4du0aQkNDkZqaiqpVq8Le3h4pKSlw\n",
-       "c3NDjRo1ULZsWbRt2zZP4cO4uDgAgLOzs7lOQSAQCIoMwsDSOXDgACZMmIDr168jKioK5cuXR8WK\n",
-       "FSFJEpYtWwZnZ2fY29sjOjoaNWvWxLBhw9ChQ4c8HSMtLQ2AcTGzQCAQCPKPMLB01q1bh5MnT2LU\n",
-       "qFEYNGgQ/Pz84OLigpEjR+LBgwdYunQp6tati+TkZMTFxeW6B1hG5OobwsAEAoGg4AgDS0euKu/v\n",
-       "75+pwny7du1w5MgRlCpVCq6urgCAEiVK5OsY8ggst/3DBAKBQJA9YiFzOoGBgXj//fcxfvx4fPbZ\n",
-       "Zzh79iwAoEePHrh48aKhAaVer89z/UMZMQITCAQC0yGGAhmYOHEibG1tsWLFCnz//fdo3bo17O3t\n",
-       "4eDggPv37xtS5vV6fb5S4IWBCQQCgekQBpaBMmXKYO7cuRgwYAB+++03rF+/HhEREQCAmTNnQqfT\n",
-       "YcCAAfkOAYoQokAgEJgOEULMgBwabNy4MRYsWIBr165h+/btGDduHJycnPDhhx/Czs4O3377bb72\n",
-       "L0ZgAoFAYDrEUCADclhQDhF6enqiS5cu6NKlCwAgJiYGixcvRv369fO1f5FGLxAIBKZDGFgWyKWh\n",
-       "iAg6nQ4Az4/17NkTH3/8ca5LR72IPAITIUSBQCAoOCKEmE5WmYWSJMHGxgaXLl3Cd999h5s3b0Kr\n",
-       "1ea7hqEIIQoEAoHpKPJDAb1eD8A46pLDh5IkGWojnj59Gt7e3mjWrFmBjiWSOF6BXg8cPgxs3Aic\n",
-       "Pg08fMiPV6gANG4M9O0LNGgAiCLIAoEAYgSG4OBgTJgwAYcOHQLARiaPsOTw4YkTJ6DVag2tUPKL\n",
-       "GIFlAxGwaRNQqxbQujXw00/AiRPA/ft8O3IE+OEHoFEjoGVLNjeBQFDkKfIGdvToUcyZMwcDBw7E\n",
-       "wIEDsWXLFjxMv/KXR0oXL16Eg4MD3NzcCnSslJQUAMLAMhERAfTsybfLlwFfX+C//wX+/hu4cwe4\n",
-       "dQvYtQv4+GPA3Z3N7LXXgGnT2PgEAkGRpcjHsoYOHYozZ85gw4YNWLVqFVatWgVbW1s0adIEo0aN\n",
-       "ws2bN3H58mXEx8cX2MDi4+MBAI6OjqaQbv1cuQJ07w7cvAk4OwPTpwMjRgB2dplfV6kS0KkTMGUK\n",
-       "3+bMASZNYnNbtAgQFwQCQZGkyBuYt7c3Vq9ejYkTJ+LQoUPYu3cvgoODcfToUVy4cAExMTEAgPLl\n",
-       "y8Pd3b1AxxIGloFjx4AuXYCYGKBuXWDzZqB8+Zzf4+oKzJoFtGsHvP02sGwZ8OwZ8OefL5ueQCAo\n",
-       "9BT5ECIAaLVa1K5dG6NGjcLWrVtx6NAh/Pzzz6hXrx4CAgLQvn17/PzzzwCMSR/5QRhYOidPAp07\n",
-       "s3n17AkcPfpq88pIly7A/v2ApyewYwcQGCjCiQJBEaTIj8Bk9Ho99Ho9bGxsUL16dfj7+6NDhw54\n",
-       "+vQpqlataggf5ncNGABDF+aCjuSsmqtXgY4dgdhYzipcuRLIQ1NQA02aAHv2cFLHihUcZvzqK5PL\n",
-       "FQgElosYgaWj0Wgypbfb2NigcuXKeO211wo89yUjJ4f4+PiYZH9WR0QE0K0bEBXFc1/Ll+fPvGQa\n",
-       "NADWrQM0Gp4b273bdFoFAoHFIwwsB4go361TsuLRo0cAiqiB6fVA//6csFG3LrBqlWmSL7p0AaZO\n",
-       "5fvvvgukf8YCgaDwIwwsB+QFzaZCHoGVKVPGZPu0GmbP5pCfpyewZQtgynnACROA9u05oeP998V8\n",
-       "mEBQRJDIlEMMQbbodDrY29tDp9MhOTkZdkUpa+7sWZ6zSk1l8+re3fTHePgQqF6dE0PWrgX69DH9\n",
-       "MQQCgUUhRmAoWJfl3PLkyRPodDp4e3sXLfNKSuLQYWoq8MEH5jEvAPDxAb77ju+PGgU8f26e4wgE\n",
-       "AotBGBiM5aMKkiL/KuT5ryIXPvzmG848rFoV+P578x5r+HDg9deB8HDgiy/MeyyBQKA6RdrA4uLi\n",
-       "MGfOHPzwww+Ij48vUIr8qyiSGYiXLgEzZ/L9RYuA4sXNezyNBvjlF85sXLQICAkx7/EEAoGqFGkD\n",
-       "c3R0RPHixfH1119j+PDhCA0NBWDMPjRHBmKRGYHp9VwWKi0NCAoC/vMfZY5brRofT68Hxo5V5pgC\n",
-       "gUAVirSBAcCIESPwv//9D0ePHsXEiRPx+PFjQ/ahKTMQw8PDAQClSpUy2T4tml9/BYKDgVKljKMw\n",
-       "pfjqK8DFhdeF7d2r7LEFAoFiFFkDk3t9AUBgYCCWLl2KlStXomHDhli4cCFCQkLw+PFjJCQkmOR4\n",
-       "soGVKFHCJPuzaJ4944ryAPDjj4CJFoLnGm9vYPx4vj9likirFwgKKUXWwCRJMvTnunDhgsFgwsLC\n",
-       "8MEHH6Bjx44YMmQIJk2aZCjoWxCKlIFNmsTVNtq1A3r3VkfDyJHcfuXYMSC915tAIChcFMlaiBER\n",
-       "Edi1axfWrl2LkJAQxMTEoGTJkmjbti26dOmCcuXK4dixY9ixYwdOnDgBHx8fjBkzpkDHjI6OBgCT\n",
-       "laWyWC5c4PChVsttT9TqnuzsDHzyCTB5MvcOa9VKHR0CgcBsFEkDO3HiBKZNmwZJktC2bVvUqFED\n",
-       "LVq0QP369Q2v6d69O4YMGYLk5GQEBAQU+JjJyckAAHt7+wLvy2Ih4saTej2vxapRQ109o0dz6v7+\n",
-       "/cD580CdOurqEQgEJqVIGljLli0RHBwMFxcX6PV6Q4dknU4HbXpxWVtbW9SqVctkxywSBvbnn8DB\n",
-       "g1wuasoUtdXw3NvgwcBPP/GocP58tRUJBAITUiTnwBwdHeHu7g6tVmswLwAG8wJMX8hXnm/LWPG+\n",
-       "UJGSAowbx/enTeP5J0sgKIi3K1ZwCxeBQFBoKJIGlhtMnUYvN7GUm1oWOhYvBu7c4XqEw4errcZI\n",
-       "zZq8Bi0ujmskCgSCQoMwMIWQkzciIyNVVmIGEhKAr7/m+1OnApY2ynzvPd6uW6eqDIFAYFqEgSmE\n",
-       "3IW5UBrY/PlAWBhQrx7Qs6faal6mRw821f37eY2aQCAoFAgDUwjZwKKiolRWYmJiY42VNr7+Wr20\n",
-       "+Zzw9ATatgV0OmDzZrXVCAQCEyEMTCEK7Qhs8WJuXdK0KdC5s9pqskdeUL1li7o6BAKByRAGphCF\n",
-       "0sDS0oC5c/n+559b5uhLpmtX3v79N8/ZCQQCq0cYmEIUyiSOTZuAe/eAKlWAN95QW03OlC4NNGzI\n",
-       "DTb371dbjUAgMAEWli5WeCmUI7BZs3g7ZgyXjrJ0unUDTp8Gtm+3fMMt5EREALt2ccOCe/d4KtXF\n",
-       "BahY0RiNdnVVW6XA0hEGphCFLokjOBg4cYIXLA8erLaa3PHGG1wbcft2LntlySHPQsrFi9yke9Mm\n",
-       "XvueFT/+CNjZ8bTlZ5+JCmCC7BEGphCFbgT2ww+8ff99IH2RtsVTrx5Qpgzw8CFw7hz/W6AIkZE8\n",
-       "TbpoEf9bo+HE0LZtuQepiws3MLhyhacpDx0CVq0CVq/mvqjTpwMeHuqeg8DykMiU9ZIE2fLw4UP4\n",
-       "+vqiZMmSePz4sdpyCsbdu0Dlyhw2vHuXTcFaCAoCFi7kWo2TJqmtpkhw+jSPpu7dA2xt+Zpn3Dig\n",
-       "bNns33PvHkeo58/nXCFPT0547dFDOd0Cy0ckcShEoRqB/fQTV5x/5x3rMi+A58EADiMKzM6iRUDz\n",
-       "5mxIjRpxU4Aff8zZvACgfHlOcD1/njvhPH8OvPUWMHYskF5WVCAQIzClICLY2tpCp9MhKSnJeqvS\n",
-       "x8YCvr5ATAxfWjdooLaivJGQwJfzSUnAo0ecnSgwCzNmGBtzf/ghj6jy82dPxGY2bhyPxtq04cYH\n",
-       "IslDIEZgCiFJElxcXAAAsdZcFf3339m8/vMf6zMvAChenDtFA8DOnepqKcRMmsTmJUncyebnn/Nn\n",
-       "XgDv45NPeF6sVCleBfH66zyVKSjaCANTEGdnZwBWbGA6nXHhcgE7VKuKnEK/bZu6OgopP/7IHXW0\n",
-       "Wu5iM2KEafbbrBlw/Djg78+Nv1u2FCZW1BEGpiBWb2AbNwK3bgEVKgBvvqm2mvwjV+X46y9usyIw\n",
-       "GZs28WgJAJYuBQYMMO3+K1ZkE6tfn/8UW7fmSLCgaCIMTEGs2sD0er6sBoDx461j4XJ2+Pry5Xxi\n",
-       "IrB1q9pqCg3XrgGDBvGc1ddf831z4OkJ7N0L1K0L3LjBc2LWntgryB/CwBTEqg1syxbg0iX+8Zf7\n",
-       "a1kz/fvzdtUqdXUUEhITgbff5gHtO+8YkzfMhYcHrxerXZuNs2tX0XC7KCIMTEHs7OwAAKnWlgdM\n",
-       "ZBx9ff55/mfjLYm33+ZR5J49okeYCZg0iats+Ptz6rwSRU48PdnEqlQB/v0X6NNHpNgXNYSBKYg2\n",
-       "Peym0+lUVpJHduwAzp7llPPAQLXVmIYSJYD27Tkve8MGtdVYNf/+yynyGg2wciWQHmhQBG9vrqno\n",
-       "5QXs3g188AFfbwmKBsLAFESj4Y9br9errCQPEAFTp/L9zz4DHBzU1WNK5DDi6tXq6rBi0tL4mkav\n",
-       "B0aP5sXKSlOlCieUFisGLFkCzJunvAaBOggDUxCrHIH99Rdw6hSPWEyVD20p9OjBhnz4MHD/vtpq\n",
-       "rJIFC3hwXr68McqsBq+9xksUAeDTT/m/VFD4EQamIJYwAiPiYhSRkbys65V88w1vP/2UFwEXJpyd\n",
-       "ge7d+f6aNepqsUJiYoyD89mzAScndfX06cOlptLSeIpTrBEr/AgDU5DExEQAQLFixRQ7JhEPoP77\n",
-       "X84cd3Xl4vEeHtyywt+fu6Fs3gwkJ7/w5iNH+ObuzpMLhZF+/XgrshHzzA8/cP5Ls2aWU2R3xgxO\n",
-       "qw8PB3r1yuJvWlCoEAamIAnpreyLKzCSSUjgousNGgCNG/MXOziYU43t7bl9hV7P62iWL+dCqQ0a\n",
-       "vJDFNX06b0ePVnZmXknkzonnzgGXL6utxmoIDzd21PnuO8tprWZjw4PpcuWAf/7hEZmg8CIMTEHi\n",
-       "4+MBAI5m7J+l0/FEtr8/dw45e5bTjUeP5myt8HCuYxsdzVenZ84AM2cCNWvyYMTWNn1H//7LaV2O\n",
-       "jsCoUWbTqzr29tzrAxDJHHnghx+A+HiuytW8udpqMuPtzYmldnbcOGHtWrUVCcwGCRSjZs2aBIDO\n",
-       "nz9vlv2fOEFUqxYRBw6J6tYlWrmSKDHx1e/V64lSUjI80KsX72TsWLNotSj27eNzrVSJPwhBjjx9\n",
-       "SuToyB/ZqVNqq8men35ijU5ORFevqq1GYA7ECExBzBVCTEriVhPNmvFi0goVgD/+4NHVgAG5y3yX\n",
-       "pAyjrytXuF+FnR3wf/9nUq0WScuWvMbt9m3g5Em11Vg8s2fz6KtLF6BhQ7XVZM+HHwJ9+3J1kN69\n",
-       "OawuKFwIA1MQc4QQb94EmjYFvv+e/z1uHE/l9O/PC0vzxcyZPIgbOtTQLyspyTR6LRKtln/pAJHM\n",
-       "8QoiIozrrL78Ul0tr0KSeB44IICroH34oVjkXNgQBqYgsoGZagT255+ceHHuHFC5MidpfPcdL+jM\n",
-       "N3fv8vBNq+WFy+l88QWwfn2BJVsu8qLmtWs5D1uQJXPnciJQ+/a89srScXbm+bBixYBly7hCvqDw\n",
-       "IAxMIYjIZCFEvZ5LEvbqxWtxevbkcGHjxiYQ+t13nAnSvz/3rgCHYH75hYu0/vGHCY5hiTRoAPj5\n",
-       "AU+eAAdPcYCBAAAgAElEQVQOqK3GIomKMraDmzRJXS15oWZN/vsFgI8+4gs+QeFAGJhCpKSkQK/X\n",
-       "w9bWFraGyaa8k5DAizS/+45ThmfP5itMk7RXDwvjS1RJAiZMMDzs6MgdVIh4zdj27SY4lqUhSaJC\n",
-       "/SuYN4+zV1u14obc1sSgQVzyKjmZ58Oio9VWJDAJameRFBUiIiIIALm5ueV7H48fEzVuzJlVrq6c\n",
-       "PGdSxo7lnffsmeXT48fz0w4OnPFY6Lh6lU/Q2ZkoIUFtNRZFbCyRhwd/PPv3q60mfyQkcGau/Ccu\n",
-       "Ek6tHzECU4iCzn9dvsxzDidPcpbh8eNcccBkRERwYTsg22ZO06cDw4dzQkfPnjxgK1QEBHAoMTYW\n",
-       "2LlTbTUWxW+/8Z/Ia6/xCMwaKVaM53FdXHj+WA6HCqwXYWAKUZD5r2PHeLHo3bs8z3XiBFC9uokF\n",
-       "zpvHudEdO/KPeBZIEvDzz8Drr3Mb9969C2G+gxxGFLURDeh0HKoGOMvVUqpu5IcqVdiMAT6X4GB1\n",
-       "9QgKhjAwhcivge3YAbRrxxPoPXpwfkHJkiYWFxtrvBx9RStdW1u+ivXx4VGgXG2q0CBX5di5kw1d\n",
-       "gE2bgDt3ONP1zTfVVlNwevYExozhi68+fUQ/U2tGGJhCyBXo5ZYquWHFCv7BSEriCegNG8xUEP7X\n",
-       "X7k8ffPmQIsWr3x5iRJcPxHgauSnTplBk1qUKwc0acLZMrt3q63GIpBrHn7yCa+uKAx8+y2vn3zw\n",
-       "ABg4kDN7BdaHMDCFyGsrldmzOXNKp+OEwIULzfTjkZRk/IX64otcx4fatOGrWJ2OC9VbU4uzVyKP\n",
-       "wkSnZpw5wyFrd3dgyBC11ZgOW1te8ufpCezZY+waJLAuhIEpRG4NjIijeHIFp1mzOExntnmHpUuB\n",
-       "x4+BevWATp3y9NapUwFfX/6RW7jQTPrUoFcv3m7fDqS3wCmqyAt/Bw3i5RSFibJleV2jJAGTJwN/\n",
-       "/622IkFeEQamEFK6A1EOtWzS0rjp8YwZPNpatoxHOWYjKck4iZWH0ZeMkxMwZw7f/+9/gadPTaxP\n",
-       "LSpW5ESWuDi+PC+iJCYaF64PHaquFnPRsSMwcSJfOPbvL5pgWhvCwBTiVSOw1FT+Ai1ezMV3N2/m\n",
-       "q16zsmgRf2Pr1OGGYPmgZ0+gQwdOMilUCR1vv83bIhxG3LyZF/w2bAjUrq22GvMxeTLQti1fgL3z\n",
-       "DpCSorYiQW4RBqYQORmYXB1AXqOydy/3WTIrCQlGx5kyJd+VfyWJq4IAwPz5QGioifSpjRxG3Lq1\n",
-       "yLb1lb373XfV1WFutFouvlKmDC9ZCQwURX+tBWFgCiEbWMX0+oIyiYmcabh1K0+U79unUJmeX37h\n",
-       "ua8GDYDu3Qu0qzp1uJh7SgowbZqJ9KlNlSpA3bq8xGDvXrXVKE5iojEJM5+Dc6uiRAlg2zbO8l2x\n",
-       "ohD9HRdyhIEphEajQZ06dbBy5UrDY3FxQNeuPM3i7c1rvBTpr/TsGfD113x/yhSTZIhMncpXsr/9\n",
-       "Bly/XuDdWQZyNmKhLsOfNX/9xYP0hg052aEoUL8+m9jAgWxkha7STCFEGJhCFCtWDAcOHICHhwcA\n",
-       "nlvo1IlNq3Rp4OBBHskowoQJvO6rfXvuSmgC/Px4ol+nA776yiS7VB95HmzLliI3MfLnn7zt2VNd\n",
-       "HUrTpg2PwMaONbTCE1gwEuWUFicwGXq93hBGjIhg8zp1iq9u9+1jA1CEf/7hFZw2Nty+OSDAZLsO\n",
-       "DeXIm07HtRtNuGv1qF2bP6edO4HOndVWowipqVztJTKSm3NXraq2IguAiMPJAA/PbGzU1SMAIEZg\n",
-       "iiGb19OnfJV36hRnax8+rKB56XTcEImIF5qZ2GHKlePFrnp9IcpILIKLmg8fZvOqWrUImldcHE9I\n",
-       "T5nCw8+AAF7tbGPDPYtcXXkVtK0tT5w1aQL068ftqbdtK0RrSawDMQJTkLAwrmt4+TLg788jL19f\n",
-       "BQX8+ivw/vt80CtXeCGXibl7lw2ZCLh6lUdkVs3ly0CNGoCHBye9FKCXm7UwciQXbf7vf4tIhYq0\n",
-       "NI6ZrlkD7NrF6yOzwtGR54sTEnKuPeXnx6H5bt248nUR+JtRC2FgChEaymtNbt7k38O//wZKlVJQ\n",
-       "wPPn7JoREcC6dcb5HTMwbBhXcBg6FFiyxGyHUY4aNdjI9uzhRW+FGL2ew9qPHnGUQJGkIrXQ6Th/\n",
-       "fto04MYN4+NNm3Jd0Lp1OYRcurRx5AXw1VlqKo+27tzhW0gIh+dPnmSDk3Fz4wWew4ZxtRtrLuVv\n",
-       "iajYi6zIcPMmUbly3EivXj2ip09VEDFiBAto29bsnfxu3iTSaolsbIhu3zbroZRh0iT+7IYPV1uJ\n",
-       "2Tlxgk+1bNlC3vDx8mWiRo34ZAGiKlWI5swhevCgYPtNTSU6fpxowgSiGjWM+weI6tQhmjuXKCrK\n",
-       "NOcgIGFgZubyZaLSpfnv97XXiCIjVRBx8iSRJLGjXL6syCEHDeJzHjFCkcOZl7Nn+WRKly7kv+pE\n",
-       "n3/OpzpqlNpKzIReT/Tjj0T29kan/v13Np5XEBfHnal1ujwc7/x5oo8/Nrazljt+jx1LFBqa//MQ\n",
-       "EJEwMLNy+jSRtzf/zbZsSRQTo4IInc54pfnZZ4od9upVIo2GyNaW6N49xQ5rHvR6Ih8f/gzPnFFb\n",
-       "jdnQ64n8/Pg0DxxQW40ZSEnhUbRsJMOGEUVH5/rthw4ZfW/GjDweOymJaN06/iGQj29jQzRwIF8g\n",
-       "CfKFMDAzsWsXkaMj/5127EgUH6+SkIULWYSPD18+Kkj//nzoDz9U9LDmQQ7BTp2qthKzcekSn6Kn\n",
-       "Z64GJNZFQgJRhw58gg4ORGvW5Gs3GzZwMAMgWrIkn1pOnSLq25fj7LKZtW9PtG9foR/hmxphYGbg\n",
-       "t9+Mf5sDBxIlJxufe1DQGHteePbMGLrI5xe2IISE8Jfdzo4oLEzxw5uWLVv4c2zcWG0lZmPaND7F\n",
-       "IUPUVmJiEhKI2rXjkytRguiffwq0u59/5l1ptUTbtxdgR3fvEo0ZQ+TkZDSyxo2J/vwzj3HKoosw\n",
-       "MBOi1xt/BACi8eMzX1Ddvn2bateurZygoCAW0qaNald2PXuyhC++UOXwpiMujuNHkkT05InaasxC\n",
-       "vXr8f7Vtm9pKTEhCAo9uZPMy0RzwF1/wLosV48SXAhERQfT118b5BoAoIIBo6dLMV7+ClxAGZiIS\n",
-       "EowhM0kimjcv8/NpaWlUpkwZcnZ2VkbQqVPGxI2QEGWOmQXHjvFn4u7OHmDVdOrEJ/P772orMTl3\n",
-       "7vCpOTkRJSaqrcZEpKURdetmNC8Tfg/0eqKhQ40h16tXTbDT+Hiin34iKl/eaGS+vkSzZike/rcW\n",
-       "hIGZgNBQovr1jT8Amza9/JrY2FgCQI6OjuYXpNNxKALgbCeVee01lvLTT2orKSDz5vGJ9O6tthKT\n",
-       "M3s2n9rbb6utxISMHs0n5eHBE3wmJiWFqEsXPkT58kQPH5pwxytWZE7D9/AgmjxZpTU4loswsALy\n",
-       "9998cQcQVapEdPFi1q+Lj48nAFSsWDHzi1q0iAWVKaNS6mNmNmwwfj5paWqrKQC3b/OJuLgUutDO\n",
-       "66/zqa1apbYSEzF3Lp+QnR3R4cNmO0xcnPFasU4dEy/x0uk4ntusmdHIihfntHyrT+01DcLA8klq\n",
-       "KtHEicaMpLZtOWciOxITEwkA2dvbm1fY8+cc0wCIVq8277FySVoaUcWKLKlAk96WQPXqfCL79qmt\n",
-       "xGQ8eWJMtslDVrnlsnu38Yu5cqXZD/f0KZG/v3G6OSnJDAc5fNg43JNT8N97T7F1nZaKKOabD0JD\n",
-       "uSDv119zZZivvuIqQ56e2b9HSi8hQ+au3PXf/3LZqNatuT+6BaDVcglGgPtoWjVdu/J21y51dZiQ\n",
-       "rVv5V7FtW+4IbtXcvw8MGMAnNHky3zczXl7c/LNUKWD/fmDw4JxLJeaLFi2AHTuAc+e4NJVeD/z+\n",
-       "O1C9OnfEPXy4aLaRVttBrQm9nuiXX3ghvVyYIbcLPlNSUggA2djYmE/ggQMszNbWLDH/ghAezrI0\n",
-       "GiuPfvz9N3/GSmaTmpmOHfmUFi5UW0kBSU42Trh27qx4KvrZs8bfhv79zRxlvnWL6IMPjCurAZ7I\n",
-       "LGIIA8slt29zeED+W+nZk3+Uc0taWhoBII1GYx6B8fFElSuzuK++Ms8xCki/fizvyy/VVlIAkpI4\n",
-       "dxogevRIbTUF5skTY93KnELgVsH//Z+xPJRKJ3PwoHFZV6dOCmTePn7MX6jSpYnu3zfzwSwPYWCv\n",
-       "ID6ek3/k3ywvL6K1a/O+rEqv1xMAMtug95NPWGCtWhabYHDwoHHkatWVHjp35hNZtkxtJQXmp5/4\n",
-       "VLp2VVtJATl0yDg3VOCFWQXj1Cn+nZDrnyqyiN+qv1D5R8yBZQMRsHo1N/SbMgVITAT69uWuGn36\n",
-       "5L0rgpThDWTqWPWWLcCcOTzZtGQJYGdn2v2biNdf51ZJYWHcTsZq6diRt3v2qKvDBKxaxdv+/dXV\n",
-       "USDi47mTKsBzwE2aqCqnYUPg2DFu8HriBNCgARAcbOaDFtUO0Wo76Itcu3aNBgwYQI9UCs/o9Vw1\n",
-       "qGFDY7iwXj2+wCsoGo2GAFCqKa+Wbt0icnVlod9/b7r9mompU41zBFbL5ct8Et7eVl3yR168XLy4\n",
-       "la+THTXKmMduQdGHsDCiFi2M09ILFohSh6bGYgzswYMHNGLECNJqtQSARo4cqejx09K4WHTt2kbj\n",
-       "KlGCaPFi06xdyhhC1JnqRy8hgahBAxb75ptW8e2Ql1IVK2YRS9Tyh17P8ywA0b//qq0m38yYwafQ\n",
-       "t6/aSgrA2bPGijMWWNU9JYWXbeV37twSiI2NpfsWOr+m+rgzIiICM2fOxLx585CUlASNRoPAwEB8\n",
-       "9tlnihz/6VPuHvzrr9xYFQDKlAE++wwYPhwoXtz4Wr1ej7t37+Lu3bvQaDSwtbWFjY0NbG1tUbx4\n",
-       "cTg7O8PFxQWOjo7QaDJHZ/XpebWSJL30XL7Q6ThF+MwZoEIF4LffrKLba8WKwH/+Axw9yl3cBw9W\n",
-       "W1E+kCTuzLxkCbBvH3faBZCWloakpCTo9XoQkWGb8X5+n0tNTc10S0lJMdxPS0uDVquFnZ0dbG1t\n",
-       "M20dHBxQvHhxFCtWzPA3KoezrT58SAR8/DFvR43iDsoWhq0tR/cbNQI++ID/5o8eBRYu5Ox3a2Dr\n",
-       "1q0YMGAA6tWrh27duqFbt26oX7++aX7HCohEpM7igbi4OMydOxf/+9//EB0dDQDo2bMnJk2aBH9/\n",
-       "/0xf4he/zNn9OyUlBQkJCUhMTERCQgISEhKQnJyMzp07wyZDjDgxkZfx/PEHsH07kJLCj1eowMY1\n",
-       "ZAjg4JBZ77Zt2/Dpp5/iRsbW49kgSRKcnJwMhiab2oEDBwwG7ejoCCcnJzg6Ohpu9vb20Gq1Wd5q\n",
-       "1aoFHx8f40HGjOFvhqsrB9xr1AAA6HQ6pKSkwMHBIdO8myWxcCEQFMTrjtScC0tNTUVUVBQiIyMz\n",
-       "3eTHoqOjERMTg+joaERHR6Nz584YOXIkv/n33/kPpVcvYMMGAMD+/fvRtm1b9U7oFfTt2xerV68G\n",
-       "AFy6BNSqBbi7A48fG6dNhwwZgpiYGIPhZTS/rB6T79vZ2UGSJMMFmnxfvmX1vc3KqOX7kiTBwcHh\n",
-       "pZubmxu0Wi2LXbeO1zp6ewPXrwNubip9srnj7l3+kzl4kP89YADw/fe8fiw/xMXF4dGjRwgLC8Oj\n",
-       "R4/w+PFjREdHIz4+HnFxcYiPj0diYiIAZPq/sLGxgb29PRwcHLLdZry/c+dOrFy5EklJSYZjlyhR\n",
-       "Au3atUOnTp3Qvn17lChRQhVDU8XALl68iNq1ayt2vPXr16N3794A+G9+6FCe9wX4YrpLF7466tSJ\n",
-       "8yAycuHCBcyfPx+XLl2Ck5MTNBrNS1fDqampSExMRExMDGJjYxEXF2dS/b/88guCgoKMD8ydC3zy\n",
-       "CV/e7dnDi5YBJCcno0WLFjh16hQ0Go3BRJ2cnF66n91NNlYnJyfY2dlBq9XCxsbmpZtWq830owTg\n",
-       "pQuOjI/b29ujXLlyAIDISKB0ab5wePCAR7wAcOvWLcTFxeW4vxcvUvK6TUhIQExMDCIjI/P8/9Ss\n",
-       "WTMcO3aM/3H1KlCtGuDjwycB/kEpXbo0AGT6EZfvv7jN7XOSJMHW1tZwk0dY8n0bGxukpaVlGpml\n",
-       "pKQgJSUFSUlJhvP/7bff0KVLFwDAF18A06dzlGHhQj6l4OBgNGvWLE+fiZK0bNkSB+Vf/9RUzrC6\n",
-       "fZvDJyNGAOC/oZ49e4KIoNVqodPpoNPpkJaWluVWp9NlebEs3yRJQrFixV66ZYy4ZLd1dXVFzZo1\n",
-       "UaJECcM56PXAvHnA+PFAUhIvHJ8yBfjoI/46ZyQqKgohISE4c+YMQkNDM5lVWFgYYmNjFfrkX835\n",
-       "8+cV/U2XUSWEmJ1Ty19aGxubl67iXvVv+Uvu6Oj40lXiw4cPDceoVo3Nq1Ejzibs149/g7Kjdu3a\n",
-       "+CWP5SN0Oh3i4uIQGxtrMLXHjx+jR48esLe3x5w5cwxXSBlvycnJhi+V/MUKDAxE9+7djTtfvJjN\n",
-       "C+DYZ7p5AcD//d//4fbt27C3t0dycjJiYmIQExOTJ+3m5Pr16/Dz84O7O18sbNkCbNrEX14A2Llz\n",
-       "J0aPHq2YHo1GAzc3N7i7u2e6yY+5uroabi4uLnB3dzf8qMHfn6/4Hz5kA/P1hZOTk0X9qGSHnGEL\n",
-       "ZA4fenl5YceOHZnM/lX35W1KSkq2kRH5M8uNUcv39Xo9kpOTkZSUZLhNnz7dKHbZMjavgABg2DDD\n",
-       "wyNHjsSFCxdM+nnFy1e7+aR3795YsGABvLy8oNFw1PONN3i7YwcHU+bNA6ZO5Uxn+SLazc0NzZs3\n",
-       "R+3atbFp0ybcvXsX58+fR2RkJADAwcEBpUuXRpkyZVCmTBmUKlUK7u7umaI7xYoVA5D5YjAtLc3w\n",
-       "2eZn++zZMzx8+BA6nQ4Af4/s7e0L9BnlF1VGYEQEnU6H4OBgbNu2Ddu2bcPVq1cNz2u1WkybNg0T\n",
-       "Jkwww7G52kz6YEAxIiMj4eHhAVdXV0RFReVvJ8uWcQyCCJg1i//ysyE1NRVxcXGGmzwyjI2NRWxs\n",
-       "rME0M75GNlX5vjy/It/kK1f59uIFBICXHsv4+JgxY/Dhhx8CAFauBN59F2jVCjhwgDWHh4ejffv2\n",
-       "htdntT87O7tsw1mv2sr3XVxc4ObmBmdn54KFPTp14hHwunXA22/nfz8Kc+IE0LQpX7jdu/dy1MHi\n",
-       "SUnh9RihoezEffsCABISEvDgwQPDaFSn0xkiCFlt5VtWF8PyTa/XIykpCYmJiZluCQkJhu+SfKGY\n",
-       "1X15a29vj5kzZxpGwDLbtgHjxgHXrvG/q1UDPv2Uw4svTmMA/Nsp5wrIYVulOHXqFCZMmIB9+/YB\n",
-       "AEqVKoVJkyZh2LBhsFNr6U5BMkBMyY0bN2jWrFnUunVrsrGxoXXr1qktyaQ8ffqUAJCHh0f+drBq\n",
-       "FddhAohmzjStOBWIijKWlnr8WG01+WTiRP7/mDBBbSV5Qs46/7//U1tJPlmwgE+gRg2ra2+Qlpb2\n",
-       "UhZyair3rixXLnMG9IQJllGr98qVK9SrVy9DFrWrqyvNmDGD4iygwZ/FGFhGIiMjKbHQdNVjwsLC\n",
-       "CACVKFEi729euNBYXXvqVNOLU4muXfmUfvlFbSX5ZM0aPoHu3dVWkmtSU43tf06fVltNPkhM5CaP\n",
-       "ANH69WqrMSnJydwGrG5do5EB3GtwyhSi4GDzFNzQ6/Wk0+leMtbo6GgaP348DRw4kACQg4MDff75\n",
-       "5/T8+XPTi8gnFmlghZHQ0FACQD4+Prl/k15vXKxTyMyLiOi33/i02rVTW0k+uXiRT6ByZbWV5Jq/\n",
-       "/mLJ/v5WsWzwZWbNMi5atuJF5Dmh13P3lMBAY40C+ebqStS6NdGYMTxq27ePu0HnZSG6Xq+ntGxG\n",
-       "rjqdjmLSF2jOnj2bJEmi0aNH0wcffEAPTdax03QIA1OIW7duEQCqUKFC7t6g03E3ZYBHX/Pnm1eg\n",
-       "Cjx/zutPtVorbTSbnMwnIElcNNMKeO89/pOaPFltJfkgJsZYZHDHDrXVKEJiItHmzUQffkhUpUpm\n",
-       "M3vx9vPPL79fp9ORPocrlevXr9OSJUtowIAB5OfnR5Ik0S/pIZFx48aRJEn0VXpxcJNWEDIRqi9k\n",
-       "LiqkpqYCAGxfzJXNirg4znDYvJlrnK1YYZioLkx4ePBasD17OCMxQzKZdWBnx8kEV67wrUEDtRXl\n",
-       "SFISL6QFOPvW6pg9G3j2DGjeHOjcWW01iuDgwAue5UXPDx4A589zW7DLl/nfciJsyZIvvz+rJKVn\n",
-       "z55h8uTJWLRoEdLS0uDq6oqAgAC0bNkSkydPRq9evQBwkgbASxOy25faCANTiFwb2PXrQO/ewMWL\n",
-       "nKa9bh2QnplXGOnd25jIZ3UGBvAC8itXgJAQizewnTuBmBiWGRCgtpo88uwZr/oFgBkzrKLqjDnw\n",
-       "9eWb3FdVhghIS9NDr2ejSUlJQXBwMPbt24eIiAgMGDAATZs2BcBFGRYsWICAgADMnj0b3t7eKFmy\n",
-       "JNzc3ODo6GjIbKxSpQoAGFLkLdHALE+RudHpuG1quqEoRVpaGgBe25ElRLyuq149Nq+AAOCffwq1\n",
-       "eQFAjx6cxr1vHzeStjrSK6AgJERdHbkgvWCIpTTqzhszZwKxsbx0oUULtdWoAqWveHr48CEOHjyI\n",
-       "x48fA0B65RLA1lYDjUaD06dPo1KlSmjbti02bNiAvXv34u2338aoUaOQnJwMR0dHAMDnn3+OTp06\n",
-       "oUGDBvBNX8eYMS1froYSGhqKiIiITBosBrVjmIpz7JhxNvSdd4j++IMoIsLsh719+zZt2bKFkrOq\n",
-       "ln3jhjElD+DOj1FRZtdkKXTowKe9eLHaSvLB+vVk6ABswSQmGhst3r6ttpo8cv++sfPwmTNqq1EF\n",
-       "OUPwxo0bZG9vT5Ik0bvvvpvp+X///ZfWr19P1atXpxo1atC2bdsoOjqaIiMjqV27dqTVaunIkSNE\n",
-       "ROTh4UFBQUH077//0ooVK2jQoEHUsWNHunbtmmGfu3fvJh8fH6pfvz7dvHmTiHgZQE5zakpT9Axs\n",
-       "925eP5Jx9lOrJWrVijOc0v+jFOHJE6Lx44ns7FiHiwvR8uVWmh6WfxYv5tPv0EFtJfng+nUWn5fs\n",
-       "UhXYutWYkm11jBjB4t9+W20lqtOnTx9ycXGhLl26kCRJ9NFHHxmSKz799FNq06YN7d27N9N7li9f\n",
-       "Tj169KD9+/cbHnvjjTdIkiRyc3OjUqVKUevWrWnNmjWUnJxsyFA8fPgwOTs7U8eOHenZCx2uIyMj\n",
-       "KSQkRHUzK3oGJnPrFtGcOURt2rCBZTQ0Pz/+0qxebfpVtno9X0UGBRE5OBiPOXiwQq1bLY9nz6w4\n",
-       "GzEtjRtqAaq1sc8NgwezxG++UVtJHrlxg/8wNBrOFy+k3Lhxg4YNG2YY6WTFtWvXyNHR0ZAlOGLE\n",
-       "CJIkiZYvX05ERMePH6dWrVrRsWPHiIgzDL/88kuSJIlGjBhBqampBsPp27cv1a1blxITEykhIYFi\n",
-       "s8jDv3TpEjk7O5OzszMFBQXRhg0b6L333qPq1auTJEnk7OxMoaGhpv4o8kTRNbCMRERwpYu+fV9e\n",
-       "eAEQVa1KNGgQ0dy5REeOcEOfvFx5PHzIubCffkpUsWLmfXfvrnoLdEugUyf+OBYuVFtJPmjShMVn\n",
-       "uMK1JFJTidzdWaLVeUC/fix86FC1lZiVQYMGGVLYXxzVyP/eu3cveXt70x9//EFERCEhIdSoUSOq\n",
-       "X78+XU4v2TFy5EiaPn06ERF988035O7uTm+++Sa1bduW6tatSxcvXiSdTkdDhw4lPz+/l3To9Xp6\n",
-       "mn4VmZSURE2aNCFJkgw3T09PevPNN2n16tX0559/UpTKUx0iCxHgnhL9+vEtNZV7bB04wLejR7ny\n",
-       "+NWrwPLlxve4ugKVKgElSgCenrwPSeJy06mpQHg48OgRF15Mn2w1UKoUt+EYOZIragvQpw+wezdn\n",
-       "Iw4frraaPFKnDifcnD+fqbiypXD6NHcA8POzsuzD8+e51qGdHTB5stpq8gSl13vVarU51iuUXyMX\n",
-       "6PX09IQkSYbH5X1JkoT4+HhERkYiLCwMAFC9enVMmzYN77//Pg4ePIhq1aqhYsWKOHfuHADgww8/\n",
-       "xLvvvgs3Nzc8efIE3377LaZMmYL169ejSpUqWL58OaKjo3Hv3j3s2LEDBw4cwJkzZ9C4cWOsW7cO\n",
-       "zs7OWLFiBcaNG4fDhw+jfv36GDt2LBo0aAAvLy+LaNckDOxFbG2B117j24QJXDj07Fk2tdOngQsX\n",
-       "gBs3gOhofjw3uLgADRtyCfyuXYFmzaywgqp56dGDe4Tt389NRr291VaUB+Q2Eiaugm4q/vqLtx06\n",
-       "qKsjz0ycyNsPP1S++nYBkftuvQqtVovU1FSULVsWAHLsNyhnMLu4uAAAjhw5gokTJyI8PByHDx/G\n",
-       "Bx98gGrVqmH79u2G18vvcXZ2RunSpZGUlGQoCAwA5cuXN7SDatWqFcaOHYv33nsPzs7OSEtLg5+f\n",
-       "H1atWoXiGTv7WhDCwF6FnR3QpAnfZIh4hHX3Lud+P38OyBXmNRq+lSjBTa/KlOEvnwWuobAk3N2B\n",
-       "du240eiff7KZWQ116vD2/Hl1dWSDVRrYsWPcbdbRkS8krYyoqCisXbsWOp0OgYGBOVZr12q1qJoe\n",
-       "icnYokRGvm9nZwedTodNmzbB19cXEyZMQEBAgOFYM2fOROXKlSFJEu7du4fy5csjNjYWFy9exC+/\n",
-       "/IKVK1di48aNkCQJpUqVgouLC/z9/fHGG2+gTJkyaN26NcqVKweNRgMigo2NDYjIYF46nc5Qud9i\n",
-       "UDWAKRBkQK6N2Lq12krySFQUC7e3N0+11QIQFcU5EDY2RNHRaqvJJXo90euv82f65Zdqq3klGZMj\n",
-       "5H9/9dVXhkSHyMjIHN+v1+tp3rx5htT4F4vqyvu+dOkS+fj4kCRJVLx4cerWrRtFR0fT2rVrqVix\n",
-       "Yt33RU8AACAASURBVPTll1/SvXv3qHfv3jRu3DhasmQJjRgxgsqVK0eSJNHYsWMN+wwPD6fz589T\n",
-       "vJWUQMsOYWAKkZiYSAsWLKBx48apLcViiYw0tlh58kRtNXmkfHn+wbWE/hcZ2LSJZbVoobaSPLB3\n",
-       "L4t2d7f49ZCRkZE0depUWrZsGRHxOqnjx48bkh6CgoJyrCEom9Py5cupePHi1LNnT4PhvWhkz549\n",
-       "oxYtWlDNmjUNmYZERPfv36fWrVtT48aN6fbt2/T++++TJElkb29P1apVo2HDhtHGjRuzzDR8UYe1\n",
-       "IQxMIR48eEAAqHTp0mpLsWi6dOHfrgUL1FaSR7p3Z+Fr1qitJBMffMCypk1TW0ku0euJmjdn0TNm\n",
-       "qK3mlYSHhxvMavPmzURE1LRpU5IkiVq3bk23bt3K8f2ySS1fvtyQ7p7RaJKSkuj8+fMUHBxMaWlp\n",
-       "NGTIEGrSpAkRsVnKa7b+/PNP8vLyosuXL9OdO3fo3Llz5jhdi0NMzCiEHEdOSEhQWYll06cPb9ev\n",
-       "V1dHnrHQRA6rm//at4/nvzw9gY8+UlvNK/H29kZQUBC0Wi3ee+89tG7dGmfPnoWtrS2++OILVKpU\n",
-       "Kcf3U3ppJg8PD0iShPXr12P8+PGYOXMmWrRogTJlyqBu3br46KOPEBMTg8qVK2d6v5yp2KVLF4wY\n",
-       "MQKOjo6oUKEC6qTPy+r1euj1essrAWUiRBKHQsj1x+Lj41VWYtm8+SYngh48yHkyJUqorSiXWKCB\n",
-       "3brFN3d3i68zbGTqVN6OHQs4O6urJZf89NNPKF68OGbPno1Dhw4BAPr27Yu2bdtCr9fnWARXfq5W\n",
-       "rVqoXr06QkJCMH/+fABA7dq1MWjQILz11lvQaDRwdHREVFQUwsPDkZSUBAcHB8N+7O3t8c0332S7\n",
-       "/0KL2kPAooJeryetVksAKCUlRW05Fo1cFtKqwohXr7LocuXUVmJgwQIrq8B06hQLdnPj3l9WxJMn\n",
-       "T2j06NGGcGLVqlUpODiYiCjb5pEvcvv2berYsSPVqlWLPv74Y7p06RIlJCS89JrHpq4OZMUUcnu2\n",
-       "HCRJEqOwXPL227y1qjBilSrcvCk01LikQmWsLnw4dy5vAwOtZvQl4+rqisTERMO/r127hoEDB+KP\n",
-       "P/4whPlygohQsWJF7Ny5ExcuXMCcOXNQo0YNFCtW7KXXlMyq8VcRRRiYgjg5OQEA4uLiVFZi2bwY\n",
-       "RrQKtFqgZk2+bwFhxLQ0nk4CrKQjT1gYsHYtr5e0grmvF9m/fz8WL14MHx8fnD9/Ht26dcPt27fx\n",
-       "7rvv4vvvv0dMTAyA7NuRSJIEIjKswdLr9Vm+RpAZYWAK4unpCYA7ogqyx82NRw16vbGDsFVgQfNg\n",
-       "J09y80p/f6B8ebXV5IKVK7kEW/fuQIUKaqvJMxPTq4ZMnDgRtWrVwpYtWzA5vfzVrFmzcqywISMb\n",
-       "lCRJhX/uykSIJA4F8fLyAgA8ffpUZSWWT+/ewI4dwNatwPvvq60ml8gVOdJr0amJ1YUP167l7aBB\n",
-       "6urIB4mJiahevTpq1KiBgQMHGh7/4osvUL9+fSQlJaFatWoAxCjK1AgDUxDv9AJ/wsBeTefOvD1w\n",
-       "AEhIACy0FFtm6tfn7Zkz6uqAlRnYzZv8mTk5Gf/jrYhixYphyZIl0Ov1cHBwMBTftbGxQbdu3dSW\n",
-       "V6gR41QFEQaWe0qW5PrHSUk8F2YV1K3LHQkuXWLhKhEVxcXxbWyAVq1Uk5F75GydN9/kRBgrxM7O\n",
-       "zpDWLkZZyiEMTEGEgeWNLl14u3OnujpyjZMTUK0aZ1CoOA+2fz/PHzZrZiXJfHL48J131NUhsDqE\n",
-       "gSmIMLC8kdHArKaQgLxi+PRp1SQcOMDbdu1Uk5B7rl3jKv6urlYS7xRYEsLAFEQkceSNhg25otCd\n",
-       "O8D162qrySWvvcbbw4dVkyAfumVL1STkHnn09dZbgL29uloEVocwMAUpkV4XSRhY7tBqgU6d+P6O\n",
-       "HepqyTVt2/J23z6O4ylMRARw8SK3sWvcWPHD551163grF8EUCPKAMDAFkQ0s3GpW56qPHEZMbzJr\n",
-       "+fj7A2XLAs+eqdLg8tgxDrc2aWIF+RAhIXzz8LCSeKfA0hAGpiDCwPJO5848Ejt8GIiMVFtNLpAk\n",
-       "Y+mLXbsUP/yRI7x9/XXFD5135PBhz55cekUgyCPCwBTEw8MDWq0WUVFRSElJUVuOVeDuzj/GOh2w\n",
-       "e7faanLJm2/ydsMGxQ8tL0GTp+IsFiJg1Sq+L7IPBflEGJiCaDQaQyaiKCeVe+S1oFu3qqsj13To\n",
-       "ALi4AGfP8iJdhSAyFgGpW1exw+aPQ4e414uvL9C6tdpqBFaKMDCFEWHEvNO9O2937eJyeRaPg4Nx\n",
-       "FCYnKSjAgwecxOHlBfj4KHbY/LF4MW+HDOEYsUCQD4SBKYwwsLxTuTJQvToQHa1qdnrekMNiK1Yo\n",
-       "tojt7FneygVBLJaoKGDjRr4/ZIi6WgRWjTAwhXF3dwcARFlIzyhroUcP3q5Zo66OXNOxI1C6NHD1\n",
-       "KnD8uCKHtJrw4apVXGqrXTugYkW11QisGGFgCiP3BIuNjVVZiXUxYABvN2wAkpPV1ZIrbGyAwYP5\n",
-       "/pIlihxSHoHVq6fI4fKPHD4cNkxdHQKrRxiYwjinF6cTTS3zRvXqPLKIirKi2ohDh/J23TpAgQuW\n",
-       "jCFEi+Xff1moh4dxWC0Q5BNhYAojRmD5Rx6F/fGHujpyjZ8frwGIjzeueTITz58D9+5x25mAALMe\n",
-       "qmDIo9GBA61gpbXA0hEGpjDCwPJPv36cnLB9Oyd0WAVymMzMYUR5/Vfduhac1JeYaLz6EOFDgQkQ\n",
-       "BqYwNjbcQ1SvQp08a8fHh/tbJScbk9gsnt69uafJiRPAlStmO4xsYHIxfIvkzz/5yqNRI6B2bbXV\n",
-       "CAoBwsAEVoXcsX3lSnV15JrixY0p9cuWme0wcveWhg3NdoiCI5I3BCZGGJjAqujVi6dODh4E7t9X\n",
-       "W00ukdc6rVjBNbFMDBEQHMz3LdbAbt7k/7RixYC+fdVWIygkCAMTWBWurlyZI2MpPYunaVNO6Hj0\n",
-       "CPjrL5Pv/soVICwMKFmSG0JbJEuX8rZPH/5PFAhMgDAwhZHnviSLLpVg2chhRAWLXBQMSQLee4/v\n",
-       "//67yXf/99+8bdfOQitwpKUZz1uEDwUmRBiYwkSm9wRxc3NTWYn10qkTd2oOCTFWn7B4ZNfdvh1I\n",
-       "SDDprvfs4a3cxcXi2L2bh4j+/sB//qO2GkEhQhiYwshV6L28vFRWYr3Y2hqnUawmmaNcOW6RnJBg\n",
-       "dBwT8Pw5sHcvoNEYu1dbHBmTNyxyiCiwVoSBKYxsYHJbFUH+ePdd3q5axREqq6BXL96asE/Y+vVc\n",
-       "ob99e54DszgeP+ZRp1YLDBqkthpBIUMYmMKIEZhpaNyY8yIePwb27VNbTS6RDWz7dpMVdJRHoHKV\n",
-       "Eotj+XLOvHzjDaBUKbXVCAoZwsAURhiYaZAk44/2+vXqask1lSsDdeoAMTEmcd07d4Bjx3ip2Vtv\n",
-       "mUCfqSEyViAJDFRXi6BQIgxMYYSBmY6ePXm7ZYtZlleZB9lpTNBeWl5G8OabQHqFMsvi6FHg+nVu\n",
-       "K2OxE3QCa0YYmILodDpERERAkiRDXzBB/qlZE6hSBXj2jH8rrYJu3Xi7fXuB1gAQGcOHcoKjxZGx\n",
-       "63J6CTWBwJQIA1OQyMhIEBHc3d0NNREF+UeSjAOaTZvU1ZJr6tXjoo4PHxr7n+SDs2e5V6aXl4Wm\n",
-       "z0dHG2O7clsZgcDECANTEBE+ND0ZDcxqFjXLo7AChBHlou7vvMPLCiyONWu4+nyrVjz3JxCYAWFg\n",
-       "CiIMzPQ0acJTLKGh3CvRKpANbNu2fL1dpwNWr+b7Fh8+FMkbAjMiDExBhIGZHo3G2Nh382Z1teSa\n",
-       "Nm04dfDff4EHD/L89sOHubBFpUps4BbH+fNcHt/V1ZhpIxCYAWFgCiIMzDxY3TyYgwPQoQPf3749\n",
-       "z2+Xp5b69LHQwhZy6vyAAVx9XiAwE8LAFOTp06cAhIGZmpYt+WI/JAS4cUNtNbkkn2FEnY77QgLA\n",
-       "22+bWJMpSEzkKsuACB8KzI4wMAURIzDzYGfHhR4AKxqFde3Kw6d9+4D4+Fy/7ehR4MkTDh/Wq2dG\n",
-       "ffll40YgKoobk1mkQEFhQhiYgggDMx9yGNFq5sFKluQJrORkrsabS+Qyir17W2j4cNEi3g4frq4O\n",
-       "QZFAGJiCCAMzH5068dRScDAnOFgF+Qgj7tjBW4vMjbh6lTNMHB2Bfv3UViMoAggDUxBRid58ODoa\n",
-       "F/Ru2aKullyTsSpHeqPTnLh1i+sfurtzhM7ikFPn+/UDnJ3V1SIoEggDUxAxAjMvVhdGrFkTqFAB\n",
-       "CA8HTp585cvlzstt2nB3EosiORlYtozvi/ChQCGEgSmIMDDz0q0brwvbv58rGVk8eazKIU+VWWTp\n",
-       "qC1buChl7dpAo0ZqqxEUEYSBKURKSgpiYmKg1Wrh6uqqtpxCiZcX8Prr3ODRBMXelSGX82A6HRsz\n",
-       "YKEGtnAhb0eMsNDsEkFhRBiYQkRERAAAPDw8IIkvuNno04e3a9eqqyPXtGzJ80WXLvEEVzacOQNE\n",
-       "RnL6fKVKCurLDbdu8XKAYsUsuLOmoDAiDEwhnj9/DgDw9PRUWUnhplcvDiPu2QOkXzNYNnZ2xl5Z\n",
-       "OYzC5Pmvdu0U0JRXfvyRt337Am5u6mr5//bOPS7Kauvjv/0MV+UqIDZeEgVN8M4RMAWviaNg2pt5\n",
-       "T+3NUsvrqY9ancC3TLDQMLWL4iW1g2bmDdTykimK+cpLmsqBBPWAiiIEKDdh1vvHdh4YAUGF5xkO\n",
-       "+/v5zGce5tmz99qjzI+199prCRoVQsAUoqIHJqg/mjfnQQ6lpQ3oUHMtlhENBZwHDVLAnschNxdY\n",
-       "v55fz5mjri2CRocQMIUwCJjwwOqfsWP5c4NZRhw2jLuNx45VGX1SWAjExfHrgQMVtq0moqKAu3e5\n",
-       "Yd26qW2NoJEhBEwhDEuIwgOrf0aN4gWADx/mEeomj5MT0KcPjz45eLDS7ZMneZR69+48UMVkKC0t\n",
-       "Xz6cN09dWwSNEiFgCiGWEJWjWTOe7F2v56n5GgSPWEY07H+Z3PLhtm3A1auAhwf3IgUChRECphD5\n",
-       "+fkAAFuRoUARDMuI0dHq2lFrRozgzzEx3LOpgOH8l0kJWGkpsHgxv160iC+BCgQKI/7XKURJSQkA\n",
-       "wNLSUmVLGgcvvghYWgLHjwPXr6ttTS3o2JF7Mjk5fM3wAXfu8BD6Jk14xL3JsHUrr13Tvj0waZLa\n",
-       "1ggaKULAFEIImLLY2QE6HUBUXgDS5KliGTEnhz8PG8ZFzCS4fx/4n//h1yEhfMNRIFABIWAKYRAw\n",
-       "CwsLlS1pPDTYZcQKaURatuSepElln9+0CUhN5V7j+PFqWyNoxAgBUwiDgJmbm6tsSeMhKIh7LfHx\n",
-       "wJUraltTC/r04anmk5OBf/0LAE9u8cILJhQjUVICfPQRvw4NNcGswoLGhBAwhZAebHLra1E2Q1A3\n",
-       "NG1aXql5+3Z1bakVZmZ83RMwWkacMwcwmfSZ69YB164Bnp7A6NFqWyNo5AgBU4gmDzYwCgoKVLak\n",
-       "cdHgDjUblhErCJi/v0q2PExBQbn39dFHwvsSqI4QMIUwCFhhYaHKljQudDqeKzchgQfNmTxDh3JP\n",
-       "7MQJIDMTAN8DMwlWrwZu3gS8vcuLrwkEKiIETCGsra0BCA9MaayseEg90EAONdvbcxHT603LbczL\n",
-       "A8LC+PWSJaJkisAkEAKmEMIDUw/DqtyBA+raUWsmTuTPW7aoa0dFVqzg6f39/XmaE4HABBACphDC\n",
-       "A1OPwYN5ooi4OO5ImDwjRvCDbGfOAJcuqW0NP00dEcGvhfclMCGEgCmECOJQD0dHwM+PZz8yVDU2\n",
-       "aayty6NP1qxR1xYACA8H8vOBwEATiigRCISAKYbBAxNLiOpgqBnZYJYR336bP2/cWGWJFcXIzARW\n",
-       "reLXH3+snh0CQRUIAVMI4YGpS0UBI1LXluq4fZs7OgCALl2AAQN4ra0NG9QzKjycFyR78UXgb39T\n",
-       "zw6BoAqEgCmEIQdicXGxypY0Try9eS2tq1d5ogtTZNUq7nDJGCocf/opFxGluXED+PJLfh0aqvz4\n",
-       "AkENCAFTCCFg6iJJ5cFzpriMWFICfP11+WodAJ7ct3t3nk7fICRKEhYGFBXxM1/duys/vkBQA0LA\n",
-       "FEIImPqY8j7YDz/w7SYLiwpLnJJUvu+0dClfTlSKjAyuqIDwvgQmixAwhRACpj4GD+yXX9RZkXsU\n",
-       "q1fz57feeihKfdgwHkKZlcVFTClCQ4HiYuDll4GuXZUbVyB4DISAKYQQMPVxdQV69uSrYocPq21N\n",
-       "Ob//zs+o2dmVn2GWYQxYvpxff/qpMufCzp4FoqJ4SisReSgwYYSAKYQQMNPgv/6LP2/erK4dFTF4\n",
-       "X5MnAzY2VTTo3RuYNo0Xkpwxo37DKIl48IjhuWPH+htLIHhKGJGpBhX/Z3Hjxg1otVq4urri5s2b\n",
-       "apvTaPn3v4FnnwXMzXleWkdHde3JyeFFKwsLuXP13HPVNMzO5mKSlQWsXQu8/nr9GLRhA/Daa0Dz\n",
-       "5jxc02TquAgElREemEIID8w0aN2aF4gsKQG++05ta3jYfGEhT3dVrXgBQLNmwOef8+s5c+SCl3XK\n",
-       "1avlofsREUK8BCaPEDCFMAiYoTKzQD1ee40/r1mj7qFmvb48U9Rbb9XiDePH80dBAU81VZeH4u/f\n",
-       "ByZN4iepR40CJkyou74FgnpCLCEqRGlpKczNzaHRaFBaWqq2OY2a+/eBtm358aqffuIemRocPMhD\n",
-       "+1u3BlJTecxEjeTm8kiU1FReETk6mofbPy1z5gArVwLPPAMkJvIlRIHAxBEemEJoNBowxlBWVoay\n",
-       "sjK1zWnUmJuXezyGVTk1MBxanjGjluIF8GW9vXt5yOL33wMLFz69G/nll1y8zM35gTQhXoIGgvDA\n",
-       "FMTKygrFxcUoLCyElZWV2uY0arKyuOdTVAQkJSkfbJeWBrRvzzUjPR1wcXnMDvbv55k6ysqA+fOB\n",
-       "zz57sjInmzYBU6bw6/oMDhEI6gHhgSmIhYUFABHIYQo4O/MtH4DXalSar77ijtMrrzyBeAGATsc9\n",
-       "MHNzfk7sv/+bq3FtIeIHo6dO5T9/+mmjEC+9Xo/x48dDkiS8Xov5ZmZm4oUXXkBKSooC1tUNCQkJ\n",
-       "WLx4MTaomQRaKUigGM7OzgSAbt26pbYpAiK6dImIMSILC6L0dOXGLSggcnIiAoji45+ys337iKys\n",
-       "eGedOxOdOFHze27dInrpJf4egCgs7CmNUJedO3eSk5MTMcbkR9euXenPP/+s1HbmzJnEGCN7e3ti\n",
-       "jNGRI0fke9u3b6d33nlH/lmv11Pfvn2JMUaffPIJERF5eHgYjWN4TJgwgdLS0oiIKDk5mZ5//vkq\n",
-       "2zHGaO7cuURElJGRQf7+/kb3LC0tacuWLU/0ORQVFdG4ceNIkiTS6XSUmJhIREQJCQkkSRKFhYXR\n",
-       "/fv3ydzcnN57771K7w8JCSHGGH377bdERLR+/Xpq3rx5lXPQaDSUkJDwRHbWJULAFESr1RIA+ve/\n",
-       "/622KYIHjB7Nv8MffKcowvr1fExvbyK9vg46/L//I3J3LxekgQOJNm4kysgoH6C4mOjMGaJ33yWy\n",
-       "t+ft7OyI9uypAwPU48yZM2RpaUmtWrWi2bNnU1RUFC1atIjs7e3Jzs6OLl26JLeNj48nxhhFRkbS\n",
-       "7du3yc3NjTw9PUn/4DOaM2cOMcZowYIFRET0xRdfkIWFBWk0GvL29iYiIsYYSZJEY8eOpaioKIqK\n",
-       "iqJp06YRY4z8/PyIiEin0xFjjIYOHSq3MTw2bNhA9+7do9LSUvL19SUzMzMaMWIErV27llavXk1d\n",
-       "unQhxhgtWbLksT6HwsJC8vLyIltbW1q7dq08JyKi5cuXE2OMpk6dSkVFRcQYoyZNmtCJh/7YMQjY\n",
-       "sWPH6ObNm8QYIzMzMwoNDa00j4MHDz7+P1Y9IARMQdq2bUsA6PLly2qbInhAYiL/Lre2JsrMrP/x\n",
-       "9Hqibt34mBs21GHHBQVEH3xAZGtbLmQAUdOmRI6ORGZmxq8HBhIlJ9ehAepw8eJFsrS0pMWLFxu9\n",
-       "np2dTS4uLhQUFCS/tmLFCrK0tKScnBwi4gLFGKPY2FgiKhcwV1dXSkhIIK1WS8uXL6ewsDBijBER\n",
-       "FzCdTlfJDk9PT3J1dSUiomXLlpG5uTkVFxc/0vaAgAByc3Mzek2v19O0adPIwcGhSg+yKoqKikin\n",
-       "05GFhQWlpqZWun/x4sVKAsYYo86dOxu1MwjYb7/9RkREnTt3pldffbVWNqiF2ANTEMNZsKLH2asQ\n",
-       "1CvduvFYiMJCZfbCfv2V5z5s3hwYN64OO7a2Bj76CLh2jeemGjKEH36+d4+n+ygt5ZEq06YBp07x\n",
-       "lPweHnVoAIeI5wDOyOBJk7dtA37+uf6KSnfq1AmzZs0CPRSL5ujoiE2bNiEmJga5DwaPiYmBjY0N\n",
-       "HBwcAABBQUFwdHTE3r17AQBt2rQBANy6dQve3t5o0aIFpk+fjhYtWoBVCJAJDg42Gmv//v24dOkS\n",
-       "/v73vwMAbG1tUVZWhsTERNy8eVN+PHx8Zs2aNZXsZoxh1apVsLW1le2qidWrV+PAgQOYP38+3Nzc\n",
-       "Kt3ftWuXfF3RhgsXLhjtk5WWlqJly5bo1asXAKBp06ZIS0vD9evX5TlkZWXVyibFUFtBGxPdu3cn\n",
-       "AHT27Fm1TRFUID6eOyU2NkR37tTvWCNH8rFCQup3HJmcHKKsLKLCwnobIi/P2Lmr6mFmRjRoEN+y\n",
-       "q2tCQ0MpNDS0ynstWrSg6OhoKigoIK1WS6+88op8Lzs7m4KDg6l///5ERHT06FF5j8rKykr2RFJS\n",
-       "Uow8sI4dO1J8fDxdv36dIiMjycrKivz9/eV+IyMjiTFGtra2JEmSfL3hIZc7LS2N2rZtW6XdCxcu\n",
-       "pMDAwFrN//Tp09S6dWtijNGwYcMo+SHP2uBZzZkzh/75z38SY4zi4+Np6NCh1KJFC8rIyCAiok6d\n",
-       "Ohl5hD169CCNRkM2Njay19axY0e5vSkgPDAFMYTOF5paLY9Gjq8vP8x89y6wbFn9jZOaCuzezWt+\n",
-       "TZ9ef+MY4eAAODkBCh7bMDPjHmbv3rwaS+/eXMYOHwbu3Kn78fR6fbX3fH190aZNG2RmZuLGjRtI\n",
-       "SkpCRkYGli1bBhcXF+zbt6+SVzFv3jzExcXJnoj00EHx5ORk9O7dGy1btsTcuXPh4+OD2NhY+f6e\n",
-       "PXvg7u6OvLw8nDt3DocOHcJff/2FKYbjCg+gR5xg8vHxkT3CmvDx8cG1a9dw+PBh3LlzB15eXthc\n",
-       "RbbqkSNHyqs/vr6++OKLL1BQUIDAwED88ccfuHPnjuxppqenIzExEaGhocjLy8OhQ4dw/vx5JCUl\n",
-       "QavV1souJajt8UlBHWBtbQ1ACJgpsmQJX+qKjOSHnFu3rvsxwsL4F/m4cUCLFnXfv1rY2tZ8lvrO\n",
-       "HeDQIWDAgLof/6effoJOp6v0ekFBAfbv34/NmzfjzgPlPH/+PFq3bg0bGxts374dK1asQFxcHG7d\n",
-       "umX03p49e8rXx48fN7onSRLeeustDB8+HJIkwd/fX94eAPhSXN++fQEAXl5e8PLyqtbu6tixYwf8\n",
-       "/PxqmLkxAwYMwMmTJ7Fu3TrMnDkTXl5e6Nmzpzz3h4XY3d0de/fuhU6nQ9cHNd9GjBghzwEAAgIC\n",
-       "wBjDwIEDH8sWpRAemIIYBEzsgZkevXrxM1lFRfVTgPjKFZ7oXZKARYvqvn9Tx8kJGDOmfpJ8NK+m\n",
-       "0127dsHX1xe2trbya6+++iqOHDmC3NxcvPTSS3jzzTcBACdPnqy2/4c9pcDAQERGRmLIkCEYPHiw\n",
-       "kXiVlZUhNTUVOTk5ICJkZ2cb7YPdv39fbutSzQHAkpIS7Nu3r0pRrglJkjBx4kSYm5vjm2++AVBZ\n",
-       "gCsSEBCAhQsXAuD7b6NHjwYA+dxbVlYWysrKjOZw+/btx7arvhAemIIID8y0+fhjYOdOLjQzZgB/\n",
-       "+1vd9b10KY+jmDhRlNiqa3r27FlJZAoLCxEREYGlD1WxnjJlCvr37y//3KFDBwDAtWvXqgyAMFDR\n",
-       "exk1alS17fLz85Geno709HR4eHggNTVVvscYQ2xsLAIDA2W7q2L58uUYPnw43N3dqx3HQEZGBvbv\n",
-       "34/AwEAcP34cd+/exZo1a5CXl4fg4GBkZ2cjKSkJjDGYm5tX2cf777+P9PR0ODk5YciDsuUXLlwA\n",
-       "AIwZMwatW7fGlStX5PbPPvssUlJSYFbr/Gf1h/oWNCKEgJk2Hh48p21EBN+jOn0a0Gievt+LF3mB\n",
-       "Y0kCPvjg6fsTGENERlGC+fn5eOONN+Dg4CB/IScnJ8PKygq9e/c2eq+Pj4/swXXr1g3u7u7y76kB\n",
-       "Pz8/oz0lQ0adqmjSpAm0Wi08PT3RqlUrBAQE4JlnnkG/fv3g7OxcrWgBPEPPgQMHEBYWhri4uFrN\n",
-       "/ejRo3jjjTcgSZK8F+jn54djx46hT58+uHLlCkpKSsAYg6+vL/5VRRkeSZLw9ddfG73Wvn172NjY\n",
-       "YNSoUdA8+CV4/vnn0aZNG3Tr1s0kxAsQAqYoQsBMn9BQHvp99ixPL7hgwdP1RwTMns1TFs6YIbyv\n",
-       "uqaoqAh79uyBq6sr1q1bh5iYGOzevRu9evXCkSNH5HaXL1+GtbW10XKfgenTp8sBE8nJyZXuP/fc\n",
-       "c3juQbG2KVOmwNfXt1p7LCwskJ6eXivbt23bhpycHKxbtw6pqan46quvUFxcjNjY2Gr3zR6mb9++\n",
-       "sLS0RElJCXQ6HWJiYqptK0mSkdA/iuDgYOTl5dWqraqoGgPZyJg1axYBoBUrVqhtiuARxMaWh36f\n",
-       "Pv10fUVF8b6aNePR7IK6JTEx0SjFkY2NDYWGhlJeXp7aptVI9+7dZbsN6Z/OnTtXp2NkZGSQJEk0\n",
-       "f/58IiJKTU2lnj171ukYaiI8MAURHljDQKfjS4mRkTwM/ORJoFWrx+/nzz+59wXwsi1OTnVrSCc+\n",
-       "OgAADbxJREFUpwBwc3PD4sWLERAQgH79+qltzmMxf/585Obm4u233663MbRarVH5Jjc3N5w9e7be\n",
-       "xlMaIWAKYthEFQUtTZ/wcODMGS5eQ4cCx48Djo61f//t28Dw4TwRxpgxPHhDUPfY2dnhH//4h9pm\n",
-       "PBGTDOUQBE+MCKNXEMP6M4kSbCaPpSWvG9mpE3DhAtCvH8/SVBtycoBhw4DkZJ6q6uuvn6xUl0Ag\n",
-       "eDRCwBRECFjDolkz4OBBHnhx/jzQvTsPsX9UQe3TpwE/P+B//xdo146nHLS3V85mgaAxIQRMQQxn\n",
-       "SYSANRxatwbi4vhyYE4O8NprQIcOPFrx5595iHxCArBxI08K3Ls397y6dgWOHv3PyrghEJgaYg9M\n",
-       "QQwe2KNytwlMDycnvpz43Xf8HFdqKrB4cdVtLSyAuXOBkBCgSRNl7RQIGhtCwBRELCE2XBgDJkzg\n",
-       "ARmHDwN79vCyKFlZXLQ6dAD69OHBGtVkCBIIBHWMWEJUECFgDR8zMyAwkJfcOnECSEoCzp0DduwA\n",
-       "5s0T4mXq6PV6jB8/HpIk4fXXX6+xfWZmJl544QU5N2Bj5ejRowgNDcWPP/6otilGCAFTELEHJhDU\n",
-       "PT/++COcnZ0hSZL86NatGy5fvlyp7axZsxAdHQ07OzusX78eR48ele99//33ePfdd+WfiQgvv/wy\n",
-       "Dh8+jB07dgDguRMrjmN4TJw4Uc4XmJKSgj59+lTZTpIkzJs3DwBw/fp1BAQEGN2zsrLC1q1bn+hz\n",
-       "2LdvH9q3bw9JkvDcc89h586dldro9Xq88847sLCwkMccPXp0td9JOTk5GDJkCAYNGoSUlBR0794d\n",
-       "ALB7925IkoTo6GikpaVBo9HIyYMrMmXKFEiSJCcUDg8Ph52dXZWfi42NDa5fv/54k1bvDHXjY8mS\n",
-       "JQSAFi5cqLYpAsF/BGfOnCFLS0tq1aoVzZ49m6KiomjRokVkb29PdnZ2dOnSJbltfHw8McYoMjKS\n",
-       "bt++TW5ubuTp6Ul6vZ6IiObMmUOMMVqwYAEREX3xxRdkYWFBGo2GvL29iYjkrBljx46lqKgoioqK\n",
-       "omnTphFjjPz8/IiISKfTEWOMhg4dKrcxPDZs2ED37t2j0tJS8vX1JTMzMxoxYgStXbuWVq9eTV26\n",
-       "dCHGGC1ZsuSxPoft27eTmZkZOTg40MKFCyk8PJxGjhxZqV1ERAQxxqhr1670zTffkI+PDzHGaObM\n",
-       "mZXaXr9+nVq1akUuLi60e/duo3uzZ88mxhgtXryYkpKSiDFGLi4ulJSUZNRu8uTJxBijq1ev0unT\n",
-       "p4kxRk2bNqWIiIhKn01cXNxjzZmISAiYgnzyyScEQP4FEQgET8fFixfJ0tKSFi9ebPR6dnY2ubi4\n",
-       "UFBQkPzaihUryNLSknJycoiICxRjjGJjY4moXMBcXV0pISGBtFotLV++nMLCwowqMut0ukp2eHp6\n",
-       "kqurKxERLVu2jMzNzam4uPiRtgcEBBhVQCYi0uv1NG3aNHJwcKA///yzVp/BsWPHSKPRkKurK/3+\n",
-       "++/VtktNTSUzMzPq0qUL/fHHH0REVFZWRmPHjiXGGEVFRclts7Ozydvbm5ycnCg3N7dSX7GxsZUE\n",
-       "zFARuiKTJ08mjUZDmZmZVFJSQg4ODvThhx/Wal61QQRxKIjYAxP8R1JczOvFADx7sV7Po14YA/Lz\n",
-       "gYICwNmZh3MOHgx06VJnQ3fq1AmzZs2q9Dvl6OiITZs2Yfjw4cjNzYW9vT1iYmJgY2MDBwcHAEBQ\n",
-       "UBBCQkLkoo6GhL63bt2Ct7c3evTogenTp2P79u1GSXCDg4ONxtq/fz8uXbqE8PBwAICtrS3KysqQ\n",
-       "mJhoVFXZ2dnZKIv7mjVrEBQUZNQXYwyrVq3CgQMHsHfvXsydO/eR8y8uLsakSZPAGMORI0fg6elZ\n",
-       "bdulS5eiefPmOHv2rJwVSJIkbN26FTk5OVi1ahVee+01AEBISAgSEhLw5Zdfws7OrlJfu3btkq8r\n",
-       "1jg7cOAADh8+jEGDBgHgWYeef/55OeO/lZUVkpOTcfPmTfk9lpaWcHycNDcVqTMpFNRIeHg4AaB3\n",
-       "331XbVMEgrojL49nLK7N45tv6nz40NBQCg0NrfJeixYtKDo6mgoKCkir1dIrr7wi38vOzqbg4GDq\n",
-       "378/EREdPXqUGGM0d+5csrKyot9++42IiFJSUow8sI4dO1J8fDxdv36dIiMjycrKivz9/eV+IyMj\n",
-       "iTFGtra2JEmSfL1hwwYj29LS0qht27ZV2r1w4UIKDAysce7fffcdMcZoxowZj2yXlpZGFhYWdOjQ\n",
-       "oSrvG7y4y5cvExHR3r17ycnJiTQaDU2cOJEyMjKM2huWBlesWEFLly4lOzs7OnfuHPXo0YO8vLwo\n",
-       "Pz+fiIisra1pwIABRMS9y2bNmpG5uTk1adKEGGOk0WioV69edPfu3RrnWhXCA6tniAh//fUXHB0d\n",
-       "H3kOLDc3F3Z2drUudyAQmAwWFvzgmwFJKvfEbG35gbjMTCA3t069LwN6vd6o4GRFfH190aZNG2Rm\n",
-       "ZuLGjRtISkpCRkYGtm7divfeew96vb5S6ZJ58+Zh0qRJcu2uh/tOTk42qivm7+9vVMZkz549cHd3\n",
-       "R3JyMi5cuIDMzEz079+/Uj/0iJUYHx8f3Llzp8a5FxcXAwCmTp36yHZbtmyBr6+v7Bk9jJ2dHfR6\n",
-       "PS5duoR27dohKCgIWVlZ2LlzJ95//305KGTw4MFG7xs5ciQ2btyIZs2aoUuXLli5ciUGDhyIF198\n",
-       "EStXrkRRUZH8nRYXF4ecnBx8++23GD16NI4fP4527dqhXbt2Nc6zWp5I9gS1orS0lGbMmEEeHh50\n",
-       "+/Zt+vTTTwmAXNqAiP9VsnXrVnJ2dqZt27apaK1A0DDx8/OrtAdGRHTv3j2ysLCgvLw8SktLMyq7\n",
-       "YmtrSz/88AP17duXGGOUmZkpe2BXr1416mfjxo1GHphGo6HZs2fTwYMH6eeff6aioiKj9v369aOp\n",
-       "U6fWaPdXX31VrQc2fvx4WrlyZY19GGz+6KOPHtmua9eu9OOPP1Z5r7S0lMaNG0cdOnSg0tLSSvdL\n",
-       "Skrogw8+IK1WS2lpaUREFBQURJIk0ZUrVygkJMRoHtHR0aTRaOTP+uOPPzay9eHP92kQYfT1SGFh\n",
-       "IU6dOoWUlBQEBwfLa8X04C+vq1evYvjw4ZgwYQKysrJM7oyFQNAQMOyvPMyuXbvg6+sLW1tb+bVX\n",
-       "X30VR44cQW5uLl566SW8+eabAICTJ09W2z895CkFBgYiMjISQ4YMweDBg42KZJaVlSE1NRU5OTkg\n",
-       "ImRnZ+PmzZvyo+J+kUs1hwZLSkqwb98+6HS6Gufev39/+Pn5ITQ0FBcvXjS6d+XKFcyaNQvp6ek4\n",
-       "f/58lftMKSkpGDVqFI4cOYJdu3bJ1ZcrYm5ujrfeegs3btxAdHQ0AMhh8VUxZswYTJ48GQDf03v5\n",
-       "5ZflsQAgKysLJSUlRp9LdnZ2jXOtCrGEWI/Y2NggJiYGvXv3Rnx8PO7evQuA/ydfuXIl3nvvPdy7\n",
-       "dw8ODg5Yvnw5pkyZoq7BAkEDpGfPnpVEprCwEBEREVhqCC55wJQpU9C/f3/55w4dOgAArl27Bjc3\n",
-       "t2rHqLj8N2rUqGrb5efnIz09Henp6fDw8EBqaqp8jzGG2NhYBAYGynZXxfLlyzF8+HC4u7tXO05F\n",
-       "tmzZgkGDBsHf3x8zZ87EqFGjkJCQgLlz52LixIlwcHCAi4sL5s+fj/Hjx8P+QXbpU6dO4dtvv0WP\n",
-       "Hj1w6NAhdOrUCQCQlJSEkydPYtiwYThw4AAKCwsRHh4OKysrBAYG4uLFi8jLywNjTA4GeZhVq1Yh\n",
-       "Ly8PAQEB6PigDPmFCxcA8CVXR0dHozNffn5+j/wjojqEgNUzWq0W+/fvR58+ffDHH38AALZv3y5H\n",
-       "4YwePRorV65EC5H1VSB4IojIaO84Pz8fb7zxBhwcHDBkyBAAfN/KysrKaO8K4HtNBg+uW7ducHd3\n",
-       "lwvPGvDz88PmzZvlny0sLKq1pUmTJtBqtfD09ESrVq0QEBCAZ555Bv369YOzs3O1ogXw/awDBw4g\n",
-       "LCwMcXFxtZ5/u3btcOrUKUREROCzzz7DkiVLwBjD+PHjERERgaZNmyImJgbLli3DggULoNfr0aFD\n",
-       "B4wePRrJycmVhHvHjh348MMPIUmSvF8/dOhQxMTEwMvLC7/88gsAoGXLltBqtVXaZG1tje+//97o\n",
-       "NQ8PD7i4uGD48OEAuKAPGjQILi4u8PX1rfV8jaizxUjBI/n1119Jo9EQAAJAWq2Wdu3apbZZAkGD\n",
-       "prCwkHr06EFDhw6ltWvX0siRI4kxRj4+PkaRbWvWrKFmzZpV2UdISEi1+0MPM3Xq1EqHdZ+UsLAw\n",
-       "sre3p7Vr19KiRYvI0dGRmjRpQr/88kud9P+knDhxgjQaDUmSVGV0o2Evq127dkTEo0Cr28urb4SA\n",
-       "KcjUqVMJAHXu3Jn++usvtc0RCBo8iYmJRsEZNjY2FBoaSnl5eWqbViPdu3eX7ZYkiXQ6HZ07d05t\n",
-       "s2rk5MmTpNFo6PPPPyciotOnT9cq5L8+YETiVK1S0ENLHQKB4OnIy8tDZGQkAgIC0K9fP7XNeSw2\n",
-       "b96M3NxcvP3222qb0mARAiYQCASCBokIoxcIBAJBg0QImEAgEAgaJELABAKBQNAgEQImEAgEggaJ\n",
-       "EDCBQCAQNEiEgAkEAoGgQSIETCAQCAQNEiFgAoFAIGiQCAETCAQCQYPk/wEPvRJNIO9OCwAAAABJ\n",
-       "RU5ErkJggg==\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython.display import Image\n",
     "Image(data=resources['outputs']['output_3_0.png'],format='png')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Yep, this is indeed the image we were expecting, and I was able to see it without ever writing or reading it from disk. I don't think I'll have to show to you what to do with those data, as if you are here you are most probably familiar with IO."
+    "This image is being rendered without reading or writing to the disk."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Extracting figures with HTML Exporter ?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Use case:\n",
     "\n",
-    "> I write an [awesome blog](http://jakevdp.github.io/) in HTML, and I want all but having base64 embeded images. \n",
-    "Having one html file with all inside is nice to send to coworker, but I definitively want resources to be cached !\n",
-    "So I need an HTML exporter, and I want it to extract the figures !"
+    "> I write an [awesome blog](http://jakevdp.github.io/) using IPython notebooks converted to HTML, and I want the images to be cached.  Having one html file with all of the images base64 encoded inside it is nice when sharing with a coworker, but for a website, not so much.  I need an HTML exporter, and I want it to extract the figures!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Some theory"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The process of converting a notebook to a another format with the nbconvert Exporters happend in a few steps:\n",
+    "The process of converting a notebook to a another format with happens in a few steps:\n",
     "\n",
-    "  - Get the notebook data and other required files. (you are responsible for that)\n",
-    "  - Feed them to the exporter that will\n",
-    "      - sequentially feed the data to a number of `Preprocessors`. Preprocessor only act on the **structure**\n",
-    "      of the notebook, and have access to it all. \n",
-    "      - feed the notebook through the jinja templating engine\n",
-    "          - the use templates are configurable.\n",
-    "          - templates make use of configurable macros called filters.\n",
-    "  - The exporter return the converted notebook as well as other relevant resources as a tuple.\n",
-    "  - Write what you need to disk, or elsewhere. (You are responsible for it)"
+    "  - Retrieve the notebook and it's accompanying resource (you are responsible for this).\n",
+    "  - Feed them into the exporter, which:\n",
+    "      - Sequentially feeds them into an array of `Preprocessors`.  Preprocessors only act on the **structure** of the notebook, and have unrestricted access to it. \n",
+    "      - Feeds the notebook into the Jinja templating engine.\n",
+    "          - The template is configured (you can change which one is used).\n",
+    "          - Templates make use of configurable macros called `filters`.\n",
+    "  - The exporter returns the converted notebook and other relevant resources as a tuple.\n",
+    "  - You write the data to the disk, or elsewhere (you are responsible for this too)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we'll be interested in the `Preprocessors`. Each `Preprocessor` is applied successively and in order on the notebook before going through the conversion process.\n",
-    "\n",
-    "We provide some preprocessor that do some modification on the notebook structure by default.\n",
-    "One of them, the `ExtractOutputPreprocessor` is responsible for crawling notebook,\n",
-    "finding all the figures, and put them into the resources directory, as well as choosing the key\n",
-    "(`filename_xx_y.extension`) that can replace the figure in the template.\n",
-    "\n",
+    "You can use `Preprocessors` to accomplish the task at hand.  IPython has preprocessors built in which you can use.  One of them, the `ExtractOutputPreprocessor` is responsible for crawling the notebook, finding all of the figures, and putting them into the resources directory, as well as choosing the key (i.e. `filename_xx_y.extension`) that can replace the figure inside the template.\n",
     "\n",
-    "The `ExtractOutputPreprocessor` is special in the fact that it **should** be availlable on all `Exporter`s, but is just inactive by default on some exporter."
+    "The `ExtractOutputPreprocessor` is special because it's available in all of the `Exporter`s, and is just disabled in some by default."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<function IPython.nbconvert.preprocessors.coalescestreams.cell_preprocessor.<locals>.wrappedfunc>,\n",
-       " <IPython.nbconvert.preprocessors.svg2pdf.SVG2PDFPreprocessor at 0x107d1a630>,\n",
-       " <IPython.nbconvert.preprocessors.extractoutput.ExtractOutputPreprocessor at 0x107d1a748>,\n",
-       " <IPython.nbconvert.preprocessors.csshtmlheader.CSSHTMLHeaderPreprocessor at 0x107d1aba8>,\n",
-       " <IPython.nbconvert.preprocessors.revealhelp.RevealHelpPreprocessor at 0x107d1a710>,\n",
-       " <IPython.nbconvert.preprocessors.latex.LatexPreprocessor at 0x107daa860>,\n",
-       " <IPython.nbconvert.preprocessors.clearoutput.ClearOutputPreprocessor at 0x107db7080>,\n",
-       " <IPython.nbconvert.preprocessors.execute.ExecutePreprocessor at 0x107db7160>,\n",
-       " <IPython.nbconvert.preprocessors.highlightmagics.HighlightMagicsPreprocessor at 0x107db7048>]"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# 3rd one should be <ExtractOutputPreprocessor>\n",
     "html_exporter._preprocessors"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To enable it we will use IPython configuration/Traitlets system. If you are have already set some IPython configuration options, \n",
-    "this will look pretty familiar to you. Configuration option are always of the form:\n",
+    "Use the IPython configuration/Traitlets system to enable it. If you have already set IPython configuration options, this system is familiar to you. Configuration options will always of the form:\n",
     "\n",
     "    ClassName.attribute_name = value\n",
     "   \n",
-    "A few ways exist to create such config, like reading a config file in your profile, but you can also do it programatically usign a dictionary. Let's create such a config object, and see the difference if we pass it to our `HTMLExporter`"
+    "You can create a configuration object a couple of different ways.  Everytime you launch IPython, configuration objects are created from reading config files in your profile directory.  Instead of writing a config file, you can also do it programatically using a dictionary.  The following creates a config object, that enables the figure extracter, and passes it to an `HTMLExporter`.  The output is compared to an `HTMLExporter` without the config object."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "resources without the \"figures\" key :\n",
-      "['raw_mimetypes', 'inlining', 'metadata', 'output_extension']\n",
-      "\n",
-      "Here we have one more field\n",
-      "['outputs', 'raw_mimetypes', 'inlining', 'metadata', 'output_extension']\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "['output_5_0.png',\n",
-       " 'output_16_0.png',\n",
-       " 'output_13_1.png',\n",
-       " 'output_18_1.png',\n",
-       " 'output_3_0.png']"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython.config import Config\n",
     "\n",
     "c =  Config({\n",
     "            'ExtractOutputPreprocessor':{'enabled':True}\n",
     "            })\n",
     "\n",
     "exportHTML = HTMLExporter()\n",
     "exportHTML_and_figs = HTMLExporter(config=c)\n",
     "\n",
     "(_, resources)          = exportHTML.from_notebook_node(jake_notebook)\n",
     "(_, resources_with_fig) = exportHTML_and_figs.from_notebook_node(jake_notebook)\n",
     "\n",
-    "print('resources without the \"figures\" key :')\n",
+    "print('resources without the \"figures\" key:')\n",
     "print(list(resources))\n",
     "\n",
     "print('')\n",
-    "print('Here we have one more field')\n",
+    "print('ditto, notice that there\\'s one more field:')\n",
     "print(list(resources_with_fig))\n",
     "list(resources_with_fig['outputs'])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So now you can loop through the dict and write all those figures to disk in the right place... "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "#### Custom Preprocessor"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Of course you can imagine many transformation that you would like to apply to a notebook. This is one of the reason we provide a way to register your own preprocessors that will be applied to the notebook after the default ones.\n",
+    "There are an endless number of transformations that you may want to apply to a notebook.  This is why we provide a way to register your own preprocessors that will be applied to the notebook after the default ones.\n",
     "\n",
-    "To do so you'll have to pass an ordered list of `Preprocessor`s to the Exporter constructor. \n",
+    "To do so, you'll have to pass an ordered list of `Preprocessor`s to the `Exporter`'s constructor. \n",
     "\n",
-    "But what is an preprocessor ? Preprocessor can be either *decorated function* for dead-simple `Preprocessor`s that apply\n",
-    "independently to each cell, for more advance transformation that support configurability You have to inherit from\n",
-    "`Preprocessor` and define a `call` method as we'll see below.\n",
+    "For simple cell-by-cell transformations, `Preprocessor` can be created using a decorator.  For more complex operations, you need to subclass `Preprocessor` and define a `call` method (as seen below).\n",
     "\n",
-    "All transforers have a magic attribute that allows it to be activated/disactivate from the config dict."
+    "All transforers have a flag that allows you to enable and disable them via a configuration object."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Four relevant docstring\n",
-      "=============================\n",
-      " A configurable preprocessor\n",
-      "\n",
-      "    Inherit from this class if you wish to have configurability for your\n",
-      "    preprocessor.\n",
-      "\n",
-      "    Any configurable traitlets this class exposed will be configurable in\n",
-      "    profiles using c.SubClassName.attribute = value\n",
-      "\n",
-      "    you can overwrite :meth:`preprocess_cell` to apply a transformation\n",
-      "    independently on each cell or :meth:`preprocess` if you prefer your own\n",
-      "    logic. See corresponding docstring for informations.\n",
-      "\n",
-      "    Disabled by default and can be enabled via the config by\n",
-      "        'c.YourPreprocessorName.enabled = True'\n",
-      "    \n",
-      "=============================\n",
-      "\n",
-      "        Preprocessing to apply on each notebook.\n",
-      "        \n",
-      "        Must return modified nb, resources.\n",
-      "        \n",
-      "        If you wish to apply your preprocessing to each cell, you might want\n",
-      "        to override preprocess_cell method instead.\n",
-      "        \n",
-      "        Parameters\n",
-      "        ----------\n",
-      "        nb : NotebookNode\n",
-      "            Notebook being converted\n",
-      "        resources : dictionary\n",
-      "            Additional resources used in the conversion process.  Allows\n",
-      "            preprocessors to pass variables into the Jinja engine.\n",
-      "        \n",
-      "=============================\n",
-      "\n",
-      "        Override if you want to apply some preprocessing to each cell.\n",
-      "        Must return modified cell and resource dictionary.\n",
-      "        \n",
-      "        Parameters\n",
-      "        ----------\n",
-      "        cell : NotebookNode cell\n",
-      "            Notebook cell being processed\n",
-      "        resources : dictionary\n",
-      "            Additional resources used in the conversion process.  Allows\n",
-      "            preprocessors to pass variables into the Jinja engine.\n",
-      "        index : int\n",
-      "            Index of the cell being processed\n",
-      "        \n",
-      "=============================\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from IPython.nbconvert.preprocessors import Preprocessor\n",
     "import IPython.config\n",
     "print(\"Four relevant docstring\")\n",
     "print('=============================')\n",
     "print(Preprocessor.__doc__)\n",
     "print('=============================')\n",
     "print(Preprocessor.preprocess.__doc__)\n",
     "print('=============================')\n",
     "print(Preprocessor.preprocess_cell.__doc__)\n",
     "print('=============================')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "***\n",
-    "We don't provide convenient method to be aplied on each worksheet as the **data structure** for worksheet will be removed. (not the worksheet functionality, which is still on it's way)\n",
-    "***"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "### Example"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "I'll now demonstrate a specific example [requested](https://github.com/ipython/nbconvert/pull/137#issuecomment-18658235) while nbconvert 2 was being developed. The ability to exclude cell from the conversion process based on their index. \n",
+    "The following demonstration was requested in [an IPython GitHub issue](https://github.com/ipython/nbconvert/pull/137#issuecomment-18658235), the ability to exclude a cell by index. \n",
     "\n",
-    "I'll let you imagin how to inject cell, if what you just want is to happend static content at the beginning/end of a notebook, plese refer to templating section, it will be much easier and cleaner."
+    "Inject cells is similar, and won't be covered here.  If you want to inject static content at the beginning/end of a notebook, use a custom template."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "from IPython.utils.traitlets import Integer"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "class PelicanSubCell(Preprocessor):\n",
-    "    \"\"\"A Pelican specific preprocessor to remove somme of the cells of a notebook\"\"\"\n",
+    "    \"\"\"A Pelican specific preprocessor to remove some of the cells of a notebook\"\"\"\n",
     "    \n",
     "    # I could also read the cells from nbc.metadata.pelican is someone wrote a JS extension\n",
     "    # But I'll stay with configurable value. \n",
     "    start = Integer(0, config=True, help=\"first cell of notebook to be converted\")\n",
     "    end   = Integer(-1, config=True, help=\"last cell of notebook to be converted\")\n",
     "    \n",
     "    def preprocess(self, nb, resources):\n",
     "\n",
     "        #nbc = deepcopy(nb)\n",
     "        nbc = nb\n",
     "        # don't print in real preprocessor !!!\n",
     "        print(\"I'll keep only cells from \", self.start, \"to \", self.end, \"\\n\\n\")\n",
     "        nbc.cells = nb.cells[self.start:self.end]                    \n",
     "        return nbc, resources"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "# I create this on the fly, but this could be loaded from a DB, and config object support merging...\n",
     "c =  Config()\n",
     "c.PelicanSubCell.enabled = True\n",
     "c.PelicanSubCell.start = 4\n",
     "c.PelicanSubCell.end = 6"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "I'm creating a pelican exporter that take `PelicanSubCell` extra preprocessors and a `config` object as parameter. This might seem redundant, but with configuration system you'll see that one can register an inactive preprocessor on all exporters and activate it at will form its config files and command line. "
+    "Here a Pelican exporter is created that takes `PelicanSubCell` preprocessors and a `config` object as parameters.  This may seem redundant, but with the configuration system you can register an inactive preprocessor on all of the exporters and activate it from config files or the command line. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "pelican = RSTExporter(preprocessors=[PelicanSubCell], config=c)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "I'll keep only cells from  4 to  6 \n",
-      "\n",
-      "\n",
-      "\n",
-      "Sometimes when showing schematic plots, this is the type of figure I\n",
-      "want to display. But drawing it by hand is a pain: I'd rather just use\n",
-      "matplotlib. The problem is, matplotlib is a bit too precise. Attempting\n",
-      "to duplicate this figure in matplotlib leads to something like this:\n",
-      "\n",
-      ".. code:: python\n",
-      "\n",
-      "    Image('http://jakevdp.github.com/figures/mpl_version.png')\n",
-      "\n",
-      "\n",
-      "\n",
-      ".. image:: output_5_0.png\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(pelican.from_notebook_node(jake_notebook)[0])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Programatically make templates"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "</div>\n",
-      "</div>\n",
-      "FOOOOOOOOTEEEEER\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from jinja2 import DictLoader\n",
     "\n",
     "dl = DictLoader({'full.tpl': \n",
     "\"\"\"\n",
     "{%- extends 'basic.tpl' -%} \n",
     "\n",
     "{% block footer %}\n",
     "FOOOOOOOOTEEEEER\n",
     "{% endblock footer %}\n",
     "\"\"\"})\n",
     "\n",
     "\n",
     "exportHTML = HTMLExporter(extra_loaders=[dl])\n",
     "(body,resources) = exportHTML.from_notebook_node(jake_notebook)\n",
     "for l in body.split('\\n')[-4:]:\n",
     "    print(l)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Real World Use"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "@jakevdp use Pelican and IPython Notebook to blog. Pelican [Will use](https://github.com/getpelican/pelican-plugins/pull/21) nbconvert programatically to generate blog post. Have a look a [Pythonic Preambulations](http://jakevdp.github.io/) for Jake blog post."
+    "@jakevdp uses Pelican and IPython Notebook to blog. Pelican [will use](https://github.com/getpelican/pelican-plugins/pull/21) nbconvert programatically to generate blog post. Have a look a [Pythonic Preambulations](http://jakevdp.github.io/) for Jake's blog post."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "@damianavila Wrote a Nicholas Plugin to [Write blog post as Notebook](http://www.damian.oquanta.info/posts/one-line-deployment-of-your-site-to-gh-pages.html) and is developping a js-extension to publish notebooks in one click from the web app."
+    "@damianavila wrote the Nicholas Plugin to [write blog post as Notebooks](http://www.damian.oquanta.info/posts/one-line-deployment-of-your-site-to-gh-pages.html) and is developping a js-extension to publish notebooks via one click from the web app."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<center>\n",
     "<blockquote class=\"twitter-tweet\"><p>As <a href=\"https://twitter.com/Mbussonn\">@Mbussonn</a> requested... easieeeeer! Deploy your Nikola site with just a click in the IPython notebook! <a href=\"http://t.co/860sJunZvj\">http://t.co/860sJunZvj</a> cc <a href=\"https://twitter.com/ralsina\">@ralsina</a></p>&mdash; Damián Avila (@damian_avila) <a href=\"https://twitter.com/damian_avila/statuses/370306057828335616\">August 21, 2013</a></blockquote>\n",
     "</center>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And finaly,  what you just did, is replicate what [nbviewer](http://nbviewer.ipython.org) does. WHich to fetch a notebook from url, convert it and send in back to you as a static html."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "##### A few gotchas"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Jinja blocks use `{% %}`by default which does not play nicely with $\\LaTeX$, hence thoses are replaced by `((* *))` in latex templates."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/What is the IPython Notebook.ipynb

@@ -1,184 +1,183 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
    "source": [
     "# What is the IPython Notebook?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Introduction"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The IPython Notebook is an **interactive computing environment** that enables users to author notebook documents that include: \n",
     "- Live code\n",
     "- Interactive widgets\n",
     "- Plots\n",
     "- Narrative text\n",
     "- Equations\n",
     "- Images\n",
     "- Video\n",
     "\n",
     "These documents provide a **complete and self-contained record of a computation** that can be converted to various formats and shared with others using email, [Dropbox](http://dropbox.com), version control systems (like git/[GitHub](http://github.com)) or [nbviewer.ipython.org](http://nbviewer.ipython.org)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
    "source": [
     "### Components"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The IPython Notebook combines three components:\n",
     "\n",
     "* **The notebook web application**: An interactive web application for writing and running code interactively and authoring notebook documents.\n",
     "* **Kernels**: Separate processes started by the notebook web application that runs users' code in a given language and returns output back to the notebook web application. The kernel also handles things like computations for interactive widgets, tab completion and introspection. \n",
     "* **Notebook documents**: Self-contained documents that contain a representation of all content visible in the notebook web application, including inputs and outputs of the computations, narrative\n",
     "text, equations, images, and rich media representations of objects. Each notebook document has its own kernel."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
    "source": [
     "## Notebook web application"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The notebook web application enables users to:\n",
     "\n",
     "* **Edit code in the browser**, with automatic syntax highlighting, indentation, and tab completion/introspection.\n",
     "* **Run code from the browser**, with the results of computations attached to the code which generated them.\n",
     "* See the results of computations with **rich media representations**, such as HTML, LaTeX, PNG, SVG, PDF, etc.\n",
     "* Create and use **interactive JavaScript wigets**, which bind interactive user interface controls and visualizations to reactive kernel side computations.\n",
     "* Author **narrative text** using the [Markdown](https://daringfireball.net/projects/markdown/) markup language.\n",
     "* Build **hierarchical documents** that are organized into sections with different levels of headings.\n",
     "* Include mathematical equations using **LaTeX syntax in Markdown**, which are rendered in-browser by [MathJax](http://www.mathjax.org/).\n",
     "* Start **parallel computing** clusters that work with IPython's interactive parallel computing libraries `IPython.parallel`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
    "source": [
     "## Kernels"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Through IPython's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages.  For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in the following languages:\n",
     "\n",
     "* Python(https://github.com/ipython/ipython)\n",
     "* Julia (https://github.com/JuliaLang/IJulia.jl)\n",
     "* R (https://github.com/takluyver/IRkernel)\n",
     "* Ruby (https://github.com/minrk/iruby)\n",
     "* Haskell (https://github.com/gibiansky/IHaskell)\n",
     "* Scala (https://github.com/Bridgewater/scala-notebook)\n",
     "* node.js (https://gist.github.com/Carreau/4279371)\n",
     "* Go (https://github.com/takluyver/igo)\n",
     "\n",
-    "The default kernel runs Python code. When it is released in the Summer/Fall of 2014, IPython 3.0 will provide a simple way for users to pick which of these kernels is used for a given notebook. \n",
+    "The default kernel runs Python code. IPython 3.0 provides a simple way for users to pick which of these kernels is used for a given notebook. \n",
     "\n",
     "Each of these kernels communicate with the notebook web application and web browser using a JSON over ZeroMQ/WebSockets message protocol that is described [here](http://ipython.org/ipython-doc/dev/development/messaging.html). Most users don't need to know about these details, but it helps to understand that \"kernels run code.\""
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
    "source": [
     "## Notebook documents"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notebook documents contain the **inputs and outputs** of an interactive session as well as **narrative text** that accompanies the code but is not meant for execution. **Rich output** generated by running code, including HTML, images, video, and plots, is embeddeed in the notebook, which makes it a complete and self-contained record of a computation. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When you run the notebook web application on your computer, notebook documents are just **files on your local filesystem with a `.ipynb` extension**. This allows you to use familiar workflows for organizing your notebooks into folders and sharing them with others using email, Dropbox and version control systems."
+    "When you run the notebook web application on your computer, notebook documents are just **files on your local filesystem with a `.ipynb` extension**. This allows you to use familiar workflows for organizing your notebooks into folders and sharing them with others."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notebooks consist of a **linear sequence of cells**. There are four basic cell types:\n",
     "\n",
     "* **Code cells:** Input and output of live code that is run in the kernel\n",
     "* **Markdown cells:** Narrative text with embedded LaTeX equations\n",
     "* **Heading cells:** 6 levels of hierarchical organization and formatting\n",
     "* **Raw cells:** Unformatted text that is included, without modification, when notebooks are converted to different formats using nbconvert\n",
     "\n",
     "Internally, notebook documents are **[JSON](http://en.wikipedia.org/wiki/JSON) data** with **binary values [base64](http://en.wikipedia.org/wiki/Base64)** encoded. This allows them to be **read and manipulated programmatically** by any programming language. Because JSON is a text format, notebook documents are version control friendly.\n",
     "\n",
     "**Notebooks can be exported** to different static formats including HTML, reStructeredText, LaTeX, PDF, and slide shows ([reveal.js](http://lab.hakim.se/reveal-js/#/)) using IPython's `nbconvert` utility.\n",
     "\n",
     "Furthermore, any notebook document available from a **public URL on or GitHub can be shared** via [nbviewer](http://nbviewer.ipython.org). This service loads the notebook document from the URL and renders it as a static web page. The resulting web page may thus be shared with others **without their needing to install IPython**."
    ]
   }
  ],
  "metadata": {
-  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

examples/Notebook/Working With Markdown Cells.ipynb

@@ -1,320 +1,320 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Markdown Cells"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Text can be added to IPython Notebooks using Markdown cells.  Markdown is a popular markup language that is a superset of HTML. Its specification can be found here:\n",
     "\n",
     "<http://daringfireball.net/projects/markdown/>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Markdown basics"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can make text *italic* or **bold**."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can build nested itemized or enumerated lists:\n",
     "\n",
     "* One\n",
     "    - Sublist\n",
     "        - This\n",
     "  - Sublist\n",
     "        - That\n",
     "        - The other thing\n",
     "* Two\n",
     "  - Sublist\n",
     "* Three\n",
     "  - Sublist\n",
     "\n",
     "Now another list:\n",
     "\n",
     "1. Here we go\n",
     "    1. Sublist\n",
     "    2. Sublist\n",
     "2. There we go\n",
     "3. Now this"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can add horizontal rules:\n",
     "\n",
     "---"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Here is a blockquote:\n",
     "\n",
     "> Beautiful is better than ugly.\n",
     "> Explicit is better than implicit.\n",
     "> Simple is better than complex.\n",
     "> Complex is better than complicated.\n",
     "> Flat is better than nested.\n",
     "> Sparse is better than dense.\n",
     "> Readability counts.\n",
     "> Special cases aren't special enough to break the rules.\n",
     "> Although practicality beats purity.\n",
     "> Errors should never pass silently.\n",
     "> Unless explicitly silenced.\n",
     "> In the face of ambiguity, refuse the temptation to guess.\n",
     "> There should be one-- and preferably only one --obvious way to do it.\n",
     "> Although that way may not be obvious at first unless you're Dutch.\n",
     "> Now is better than never.\n",
     "> Although never is often better than *right* now.\n",
     "> If the implementation is hard to explain, it's a bad idea.\n",
     "> If the implementation is easy to explain, it may be a good idea.\n",
     "> Namespaces are one honking great idea -- let's do more of those!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "And shorthand for links:\n",
     "\n",
     "[IPython's website](http://ipython.org)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Headings"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you want, you can add headings using Markdown's syntax:\n",
     "\n",
     "# Heading 1\n",
     "# Heading 2\n",
     "## Heading 2.1\n",
     "## Heading 2.2"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**BUT most of the time you should use the Notebook's Heading Cells to organize your Notebook content**, as they provide meaningful structure that can be interpreted by other tools, not just large bold fonts."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Embedded code"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can embed code meant for illustration instead of execution in Python:\n",
     "\n",
     "    def f(x):\n",
     "        \"\"\"a docstring\"\"\"\n",
     "        return x**2\n",
     "\n",
     "or other languages:\n",
     "\n",
     "    if (i=0; i<n; i++) {\n",
     "      printf(\"hello %d\\n\", i);\n",
     "      x += 4;\n",
     "    }"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## LaTeX equations"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Courtesy of MathJax, you can include mathematical expressions both inline: \n",
     "$e^{i\\pi} + 1 = 0$  and displayed:\n",
     "\n",
     "$$e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Github flavored markdown (GFM)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The Notebook webapp support Github flavored markdown meaning that you can use triple backticks for code blocks \n",
     "<pre>\n",
     "```python\n",
     "print \"Hello World\"\n",
     "```\n",
     "\n",
     "```javascript\n",
     "console.log(\"Hello World\")\n",
     "```\n",
     "</pre>\n",
     "\n",
     "Gives \n",
     "```python\n",
     "print \"Hello World\"\n",
     "```\n",
     "\n",
     "```javascript\n",
     "console.log(\"Hello World\")\n",
     "```\n",
     "\n",
     "And a table like this : \n",
     "\n",
     "<pre>\n",
     "| This | is   |\n",
     "|------|------|\n",
     "|   a  | table| \n",
     "</pre>\n",
     "\n",
     "A nice Html Table\n",
     "\n",
     "| This | is   |\n",
     "|------|------|\n",
     "|   a  | table| "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## General HTML"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Because Markdown is a superset of HTML you can even add things like HTML tables:\n",
     "\n",
     "<table>\n",
     "<tr>\n",
     "<th>Header 1</th>\n",
     "<th>Header 2</th>\n",
     "</tr>\n",
     "<tr>\n",
     "<td>row 1, cell 1</td>\n",
     "<td>row 1, cell 2</td>\n",
     "</tr>\n",
     "<tr>\n",
     "<td>row 2, cell 1</td>\n",
     "<td>row 2, cell 2</td>\n",
     "</tr>\n",
     "</table>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Local files"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "If you have local files in your Notebook directory, you can refer to these files in Markdown cells directly:\n",
     "\n",
     "    [subdirectory/]<filename>\n",
     "\n",
     "For example, in the images folder, we have the Python logo:\n",
     "\n",
     "    <img src=\"../images/python_logo.svg\" />\n",
     "\n",
     "<img src=\"../images/python_logo.svg\" />\n",
     "\n",
     "and a video with the HTML5 video tag:\n",
     "\n",
     "    <video controls src=\"images/animation.m4v\" />\n",
     "\n",
     "<video controls src=\"images/animation.m4v\" />\n",
     "\n",
     "These do not embed the data into the notebook file, and require that the files exist when you are viewing the notebook."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Security of local files"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Note that this means that the IPython notebook server also acts as a generic file server\n",
     "for files inside the same tree as your notebooks.  Access is not granted outside the\n",
     "notebook folder so you have strict control over what files are visible, but for this\n",
     "reason it is highly recommended that you do not run the notebook server with a notebook\n",
     "directory at a high level in your filesystem (e.g. your home directory).\n",
     "\n",
     "When you run the notebook in a password-protected manner, local file access is restricted\n",
     "to authenticated users unless read-only views are active."
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }