diff --git a/code/Ch02-Fig01.pdf b/code/Ch02-Fig01.pdf
new file mode 100644
index 00000000..725a1357
Binary files /dev/null and b/code/Ch02-Fig01.pdf differ
diff --git a/code/HIV.ipynb b/code/HIV.ipynb
new file mode 100644
index 00000000..86483a21
--- /dev/null
+++ b/code/HIV.ipynb
@@ -0,0 +1,348 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook \n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>R</th>\n",
+       "      <td>1.000000e+03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>L</th>\n",
+       "      <td>0.000000e+00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>E</th>\n",
+       "      <td>0.000000e+00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>V</th>\n",
+       "      <td>4.000000e-07</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "R    1.000000e+03\n",
+       "L    0.000000e+00\n",
+       "E    0.000000e+00\n",
+       "V    4.000000e-07\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Stocks are stored as State variables\n",
+    "init = State(R = 1000, L = 0, E = 0, V = 4e-7)\n",
+    "#R: Uninfected CD4 lymphocytes (white blood?) cells\n",
+    "#L: Lately infected cells\n",
+    "#E: Actively infected cells\n",
+    "#V: free virons"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>gamma</th>\n",
+       "      <td>1.36000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>tau</th>\n",
+       "      <td>0.20000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mu</th>\n",
+       "      <td>0.00136</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>0.00027</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p</th>\n",
+       "      <td>0.10000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>q</th>\n",
+       "      <td>0.90000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.03600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>delta</th>\n",
+       "      <td>0.33000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>pi</th>\n",
+       "      <td>100.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>sigma</th>\n",
+       "      <td>2.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>dt</th>\n",
+       "      <td>0.10000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "gamma      1.36000\n",
+       "tau        0.20000\n",
+       "mu         0.00136\n",
+       "beta       0.00027\n",
+       "p          0.10000\n",
+       "q          0.90000\n",
+       "alpha      0.03600\n",
+       "delta      0.33000\n",
+       "pi       100.00000\n",
+       "sigma      2.00000\n",
+       "dt         0.10000\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Everything else is stored in System\n",
+    "system = System(gamma = 1.36, #rate at which uninfected CD4 lymphocytes arise\n",
+    "               tau = 0.2, #the proportion of uninfected CD4  lymphocytes are activated\n",
+    "               mu = 0.00136, #death rate of uninfected CD4 lymphocytes \n",
+    "               beta = 0.00027, #infection rate of uninfected CD4 lymphocytes\n",
+    "               p = 0.1, #the proportion of cells that become latenly infected cells\n",
+    "               q = 1- 0.1, #the number of cells that go straight to being annotated\n",
+    "               alpha = 0.036, #activation rate of latently infected cells\n",
+    "               delta = 0.33, #death rate of actively infected CD4 lymphocytes\n",
+    "               pi = 100, #rate of production of virons by an actively infected cell\n",
+    "               sigma = 2, #removal rate of cell free virons\n",
+    "               dt = 0.1) #small time step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#creates function that updates State variables for each dt and returns the new State\n",
+    "def update_func(state, system):\n",
+    "    \n",
+    "    new_state = state\n",
+    "    #equations that affect the change in State variables\n",
+    "    dR = system.gamma * system.tau + system.mu * state.R - system.beta * state.V * state.R\n",
+    "    dL = system.p * system.beta * state.V * state.R - system.mu * state.L - system.alpha * state.L\n",
+    "    dE = system.q * system.beta * state.V * state.R + system.alpha * state.L - system.delta * state.E\n",
+    "    dV = system.pi * state.E - system.sigma * state.V\n",
+    "   \n",
+    "    #applies equations to each state variable\n",
+    "    \n",
+    "    new_state.R += dR * system.dt\n",
+    "    new_state.L += dL * system.dt\n",
+    "    new_state.E += dE * system.dt\n",
+    "    new_state.V += dV * system.dt\n",
+    "    \n",
+    "    return new_state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#runs a simulation of the system and returns a time frame\n",
+    "def run_simulation(system, update_func):\n",
+    "    \n",
+    "    frame = TimeFrame(columns=init.index)\n",
+    "    frame.row[0] = init\n",
+    "    \n",
+    "    for t in linrange(0, 200, system.dt):\n",
+    "        frame.row[t+system.dt] = update_func(frame.row[t], system)\n",
+    "        \n",
+    "    return frame"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x15e54ccc2b0>]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plots R, L and E\n",
+    "results = run_simulation(system, update_func)\n",
+    "plot(results.R)\n",
+    "plot(results.L)\n",
+    "plot(results.E)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x15e54d1b940>]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plots V\n",
+    "results = run_simulation(system, update_func)\n",
+    "plot(results.V)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/Orbit.ipynb b/code/Orbit.ipynb
new file mode 100644
index 00000000..70bef0b1
--- /dev/null
+++ b/code/Orbit.ipynb
@@ -0,0 +1,670 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Starter code for the orbit example\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Earth falling into the sun\n",
+    "\n",
+    "Here's a question from the web site [Ask an Astronomer](http://curious.astro.cornell.edu/about-us/39-our-solar-system/the-earth/other-catastrophes/57-how-long-would-it-take-the-earth-to-fall-into-the-sun-intermediate):\n",
+    "\n",
+    "\"If the Earth suddenly stopped orbiting the Sun, I know eventually it would be pulled in by the Sun's gravity and hit it. How long would it take the Earth to hit the Sun? I imagine it would go slowly at first and then pick up speed.\"\n",
+    "\n",
+    "Here's a solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "meter"
+      ],
+      "text/latex": [
+       "$meter$"
+      ],
+      "text/plain": [
+       "<Unit('meter')>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here are the units we'll need\n",
+    "\n",
+    "s = UNITS.second\n",
+    "N = UNITS.newton\n",
+    "kg = UNITS.kilogram\n",
+    "m = UNITS.meter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>x</th>\n",
+       "      <td>0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>y</th>\n",
+       "      <td>147000000000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>vx</th>\n",
+       "      <td>30330.0 meter / second</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>vy</th>\n",
+       "      <td>0.0 meter / second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "x                    0 meter\n",
+       "y       147000000000.0 meter\n",
+       "vx    30330.0 meter / second\n",
+       "vy        0.0 meter / second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# And an inition condition (with everything in SI units)\n",
+    "\n",
+    "y_0 = 147e9 * m\n",
+    "v_0 = 3.033e4 * m/s \n",
+    "\n",
+    "init = State(x = 0 * m,\n",
+    "             y = y_0,\n",
+    "             vx = v_0,\n",
+    "             vy = 0 * m / s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>init</th>\n",
+       "      <td>x                    0 meter\n",
+       "y       147000000...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>G</th>\n",
+       "      <td>6.674e-11 meter ** 2 * newton / kilogram ** 2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m1</th>\n",
+       "      <td>1.989e+30 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>r_final</th>\n",
+       "      <td>701879000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m2</th>\n",
+       "      <td>5.972e+24 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>0 second</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>31540000.0 second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init       x                    0 meter\n",
+       "y       147000000...\n",
+       "G              6.674e-11 meter ** 2 * newton / kilogram ** 2\n",
+       "m1                                        1.989e+30 kilogram\n",
+       "r_final                                    701879000.0 meter\n",
+       "m2                                        5.972e+24 kilogram\n",
+       "t_0                                                 0 second\n",
+       "t_end                                      31540000.0 second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Making a system object\n",
+    "\n",
+    "r_earth = 6.371e6 * m\n",
+    "r_sun = 695.508e6 * m\n",
+    "\n",
+    "system = System(init=init,\n",
+    "                G=6.674e-11 * N / kg**2 * m**2,\n",
+    "                m1=1.989e30 * kg,\n",
+    "                r_final=r_sun + r_earth,\n",
+    "                m2=5.972e24 * kg,\n",
+    "                t_0=0 * s,\n",
+    "                t_end=3.154e7 * s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's a function that computes the force of gravity\n",
+    "\n",
+    "def universal_gravitation(state, system):\n",
+    "    \"\"\"Computes gravitational force.\n",
+    "    \n",
+    "    state: State object with distance r\n",
+    "    system: System object with m1, m2, and G\n",
+    "    \"\"\"\n",
+    "    x, y, vx, vy = state\n",
+    "    unpack(system)\n",
+    "    \n",
+    "    r = Vector(x, y)\n",
+    "    r_hat = r.hat()\n",
+    "    \n",
+    "    force = G * m1 * m2 / r.mag**2\n",
+    "    \n",
+    "    \n",
+    "    return r_hat * force"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "[0.0000000e+00 3.6686486e+22] newton"
+      ],
+      "text/latex": [
+       "$[0.0000000e+00 3.6686486e+22] newton$"
+      ],
+      "text/plain": [
+       "<Quantity([0.0000000e+00 3.6686486e+22], 'newton')>"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "universal_gravitation(init, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The slope function\n",
+    "\n",
+    "def slope_func(state, t, system):\n",
+    "    \"\"\"Compute derivatives of the state.\n",
+    "    \n",
+    "    state: position, velocity\n",
+    "    t: time\n",
+    "    system: System object containing `g`\n",
+    "    \n",
+    "    returns: derivatives of y and v\n",
+    "    \"\"\"\n",
+    "    x, y, vx, vy = state\n",
+    "    unpack(system)\n",
+    "    \n",
+    "    v = Vector(vx, vy)\n",
+    "\n",
+    "    a = -universal_gravitation(state, system) / m2\n",
+    "\n",
+    "    return v.x, v.y, a.x, a.y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(<Quantity(30330.0, 'meter / second')>,\n",
+       " <Quantity(0.0, 'meter / second')>,\n",
+       " <Quantity(-0.0, 'newton / kilogram')>,\n",
+       " <Quantity(-0.006143082049146188, 'newton / kilogram')>)"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Always test the slope function!\n",
+    "\n",
+    "slope_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's an event function that stops the simulation\n",
+    "# before the collision\n",
+    "\n",
+    "def event_func(state, t, system):\n",
+    "    x, y, vx, vy = state\n",
+    "    v = Vector (x, y)\n",
+    "    return v.mag - system.r_final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "146298121000.0 meter"
+      ],
+      "text/latex": [
+       "$146298121000.0 meter$"
+      ],
+      "text/plain": [
+       "<Quantity(146298121000.0, 'meter')>"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Always test the event function!\n",
+    "\n",
+    "event_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>sol</th>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_events</th>\n",
+       "      <td>[[]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nfev</th>\n",
+       "      <td>152</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>njev</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nlu</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>status</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>message</th>\n",
+       "      <td>The solver successfully reached the end of the...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>success</th>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "sol                                                      None\n",
+       "t_events                                                 [[]]\n",
+       "nfev                                                      152\n",
+       "njev                                                        0\n",
+       "nlu                                                         0\n",
+       "status                                                      0\n",
+       "message     The solver successfully reached the end of the...\n",
+       "success                                                  True\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Finally we can run the simulation\n",
+    "\n",
+    "results, details = run_ode_solver(system, slope_func, events=event_func)\n",
+    "details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "31540000.0 second"
+      ],
+      "text/latex": [
+       "$31540000.0 second$"
+      ],
+      "text/plain": [
+       "<Quantity(31540000.0, 'second')>"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here's how long it takes...\n",
+    "\n",
+    "t_final = get_last_label(results) * s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "365.04629629629625 day"
+      ],
+      "text/latex": [
+       "$365.04629629629625 day$"
+      ],
+      "text/plain": [
+       "<Quantity(365.04629629629625, 'day')>"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# ... expressed in units we understand\n",
+    "\n",
+    "t_final.to(UNITS.day)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before plotting, we run the simulation again with `t_eval`\n",
+    "\n",
+    "ts = linspace(t_0, t_final, 201)\n",
+    "results, details = run_ode_solver(system, slope_func, events=event_func, t_eval=ts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scaling the time steps to days\n",
+    "\n",
+    "results.index /= 60 * 60 * 24 * 360"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scaling the distance to million km\n",
+    "\n",
+    "r = results.x / 1e9;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# And plotting\n",
+    "\n",
+    "plot(results.x, results.y, label='x,y')\n",
+    "\n",
+    "decorate(xlabel='X position (million km)',\n",
+    "         ylabel='Y position (million km)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ts = linspace(t_0, system.t_end, 500)*s\n",
+    "results, details = run_ode_solver(system, slope_func, vectorized = True, events=event_func, t_eval = ts)\n",
+    "#results, details = run_ode_solver(system, slope_func, method='LSODA', min_step=99)\n",
+    "results.index /= 60*60*24\n",
+    "results.x /= 1e9\n",
+    "results.y /= 1e9\n",
+    "details\n",
+    "plot(results.y, results.x, 'go-')\n",
+    "decorate(xlabel = 'X',\n",
+    "        ylabel = 'Y')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results.x.plot()\n",
+    "results.y.plot()\n",
+    "decorate(ylabel = 'Distance [millions of km]',\n",
+    "         xlabel = 'Time [days]')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/Orbit.ipynb.txt b/code/Orbit.ipynb.txt
new file mode 100644
index 00000000..6b226e3a
--- /dev/null
+++ b/code/Orbit.ipynb.txt
@@ -0,0 +1,606 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Starter code for the orbit example\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Earth falling into the sun\n",
+    "\n",
+    "Here's a question from the web site [Ask an Astronomer](http://curious.astro.cornell.edu/about-us/39-our-solar-system/the-earth/other-catastrophes/57-how-long-would-it-take-the-earth-to-fall-into-the-sun-intermediate):\n",
+    "\n",
+    "\"If the Earth suddenly stopped orbiting the Sun, I know eventually it would be pulled in by the Sun's gravity and hit it. How long would it take the Earth to hit the Sun? I imagine it would go slowly at first and then pick up speed.\"\n",
+    "\n",
+    "Here's a solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "meter"
+      ],
+      "text/latex": [
+       "$meter$"
+      ],
+      "text/plain": [
+       "<Unit('meter')>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here are the units we'll need\n",
+    "\n",
+    "s = UNITS.second\n",
+    "N = UNITS.newton\n",
+    "kg = UNITS.kilogram\n",
+    "m = UNITS.meter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>r</th>\n",
+       "      <td>147000000000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>v</th>\n",
+       "      <td>0.0 meter / second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "r    147000000000.0 meter\n",
+       "v      0.0 meter / second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# And an inition condition (with everything in SI units)\n",
+    "\n",
+    "r_0 = 147e9 * m\n",
+    "\n",
+    "init = State(r = r_0,\n",
+    "             v = 0 * m / s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>init</th>\n",
+       "      <td>r    147000000000.0 meter\n",
+       "v      0.0 meter / s...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>G</th>\n",
+       "      <td>6.674e-11 meter ** 2 * newton / kilogram ** 2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m1</th>\n",
+       "      <td>1.989e+30 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>r_final</th>\n",
+       "      <td>701879000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m2</th>\n",
+       "      <td>5.972e+24 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>0 second</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>10000000.0 second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init       r    147000000000.0 meter\n",
+       "v      0.0 meter / s...\n",
+       "G              6.674e-11 meter ** 2 * newton / kilogram ** 2\n",
+       "m1                                        1.989e+30 kilogram\n",
+       "r_final                                    701879000.0 meter\n",
+       "m2                                        5.972e+24 kilogram\n",
+       "t_0                                                 0 second\n",
+       "t_end                                      10000000.0 second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Making a system object\n",
+    "\n",
+    "r_earth = 6.371e6 * m\n",
+    "r_sun = 695.508e6 * m\n",
+    "\n",
+    "system = System(init=init,\n",
+    "                G=6.674e-11 * N / kg**2 * m**2,\n",
+    "                m1=1.989e30 * kg,\n",
+    "                r_final=r_sun + r_earth,\n",
+    "                m2=5.972e24 * kg,\n",
+    "                t_0=0 * s,\n",
+    "                t_end=1e7 * s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's a function that computes the force of gravity\n",
+    "\n",
+    "def universal_gravitation(state, system):\n",
+    "    \"\"\"Computes gravitational force.\n",
+    "    \n",
+    "    state: State object with distance r\n",
+    "    system: System object with m1, m2, and G\n",
+    "    \"\"\"\n",
+    "    r, v = state\n",
+    "    unpack(system)\n",
+    "    \n",
+    "    force = G * m1 * m2 / r**2\n",
+    "    return force"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "3.6686485997501037e+22 newton"
+      ],
+      "text/latex": [
+       "$3.6686485997501037e+22 newton$"
+      ],
+      "text/plain": [
+       "<Quantity(3.6686485997501037e+22, 'newton')>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "universal_gravitation(init, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The slope function\n",
+    "\n",
+    "def slope_func(state, t, system):\n",
+    "    \"\"\"Compute derivatives of the state.\n",
+    "    \n",
+    "    state: position, velocity\n",
+    "    t: time\n",
+    "    system: System object containing `g`\n",
+    "    \n",
+    "    returns: derivatives of y and v\n",
+    "    \"\"\"\n",
+    "    y, v = state\n",
+    "    unpack(system)    \n",
+    "\n",
+    "    force = universal_gravitation(state, system)\n",
+    "    dydt = v\n",
+    "    dvdt = -force / m2\n",
+    "    \n",
+    "    return dydt, dvdt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(<Quantity(0.0, 'meter / second')>,\n",
+       " <Quantity(-0.006143082049146188, 'newton / kilogram')>)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Always test the slope function!\n",
+    "\n",
+    "slope_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here's an event function that stops the simulation\n",
+    "# before the collision\n",
+    "\n",
+    "def event_func(state, t, system):\n",
+    "    r, v = state\n",
+    "    return r - system.r_final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "146298121000.0 meter"
+      ],
+      "text/latex": [
+       "$146298121000.0 meter$"
+      ],
+      "text/plain": [
+       "<Quantity(146298121000.0, 'meter')>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Always test the event function!\n",
+    "\n",
+    "event_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>sol</th>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_events</th>\n",
+       "      <td>[[5432658.401694091]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nfev</th>\n",
+       "      <td>236</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>njev</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nlu</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>status</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>message</th>\n",
+       "      <td>A termination event occurred.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>success</th>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "sol                                  None\n",
+       "t_events            [[5432658.401694091]]\n",
+       "nfev                                  236\n",
+       "njev                                    0\n",
+       "nlu                                     0\n",
+       "status                                  1\n",
+       "message     A termination event occurred.\n",
+       "success                              True\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Finally we can run the simulation\n",
+    "\n",
+    "results, details = run_ode_solver(system, slope_func, events=event_func)\n",
+    "details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "5432658.401694091 second"
+      ],
+      "text/latex": [
+       "$5432658.401694091 second$"
+      ],
+      "text/plain": [
+       "<Quantity(5432658.401694091, 'second')>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Here's how long it takes...\n",
+    "\n",
+    "t_final = get_last_label(results) * s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "62.87799076034826 day"
+      ],
+      "text/latex": [
+       "$62.87799076034826 day$"
+      ],
+      "text/plain": [
+       "<Quantity(62.87799076034826, 'day')>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# ... expressed in units we understand\n",
+    "\n",
+    "t_final.to(UNITS.day)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Before plotting, we run the simulation again with `t_eval`\n",
+    "\n",
+    "ts = linspace(t_0, t_final, 201)\n",
+    "results, details = run_ode_solver(system, slope_func, events=event_func, t_eval=ts)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scaling the time steps to days\n",
+    "\n",
+    "results.index /= 60 * 60 * 24"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scaling the distance to million km\n",
+    "\n",
+    "r = results.r / 1e9;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# And plotting\n",
+    "\n",
+    "plot(r, label='r')\n",
+    "\n",
+    "decorate(xlabel='Time (day)',\n",
+    "         ylabel='Distance from sun (million km)')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
\ No newline at end of file
diff --git a/code/Project 1.ipynb b/code/Project 1.ipynb
new file mode 100644
index 00000000..3b912bde
--- /dev/null
+++ b/code/Project 1.ipynb	
@@ -0,0 +1,813 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Assuming an intervention, what does the birth rate of moose need to be to have a positive trend in Northeastern Minnesotan moose population?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following data collected from the Minnesota DNR."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this model the following assumptions were made:\n",
+    "\n",
+    "    -The birth rate of the moose remains constant"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The parameters we took in for this model/simulation were:\n",
+    "\n",
+    "    -\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "population = [8160, 8840, 6860, 7890, 7840, 5700, 4900, 4230, 2760, 4350, 3450, 4020, 3710, 3030];"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "years = range(2005,2019);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then put the data into the TimeSeries, so it is easier to work with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2005</th>\n",
+       "      <td>8160.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2006</th>\n",
+       "      <td>8840.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2007</th>\n",
+       "      <td>6860.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2008</th>\n",
+       "      <td>7890.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2009</th>\n",
+       "      <td>7840.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2010</th>\n",
+       "      <td>5700.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2011</th>\n",
+       "      <td>4900.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2012</th>\n",
+       "      <td>4230.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013</th>\n",
+       "      <td>2760.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2014</th>\n",
+       "      <td>4350.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2015</th>\n",
+       "      <td>3450.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016</th>\n",
+       "      <td>4020.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017</th>\n",
+       "      <td>3710.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2018</th>\n",
+       "      <td>3030.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "2005    8160.0\n",
+       "2006    8840.0\n",
+       "2007    6860.0\n",
+       "2008    7890.0\n",
+       "2009    7840.0\n",
+       "2010    5700.0\n",
+       "2011    4900.0\n",
+       "2012    4230.0\n",
+       "2013    2760.0\n",
+       "2014    4350.0\n",
+       "2015    3450.0\n",
+       "2016    4020.0\n",
+       "2017    3710.0\n",
+       "2018    3030.0\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "population_series = TimeSeries(population, index = years, dtype = float)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a fucntion to calculate the average birth rate over time.  This was calculated using the assumption of a 25% death rate.  This value is from a New York Times article: https://www.nytimes.com/2013/10/15/science/earth/something-is-killing-off-the-moose.html"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.18782875308272756\n"
+     ]
+    }
+   ],
+   "source": [
+    "def birth_rate(population):\n",
+    "    sum=0\n",
+    "    #print(population[0])\n",
+    "    for i in range(13):\n",
+    "        birth = population[i+1]/population[i]-0.75\n",
+    "        sum = sum + birth\n",
+    "        #print(sum)\n",
+    "    avgbirth = sum/14\n",
+    "    return avgbirth\n",
+    "#print('average birth rate =', birth_rate(population))\n",
+    "avgbirth = birth_rate(population)\n",
+    "print(avgbirth)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a function for the line of best fit to show the trend of the moose population over time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f(years):\n",
+    "    t = TimeSeries()\n",
+    "    for x in (0, 2050):\n",
+    "        y = (-454.286*x) + 919206\n",
+    "        t[x] = y\n",
+    "    return t"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a scatter plot of the past data by year and plot a line of best fit for the data, which shows the overall negative trend."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def population_graph(series):\n",
+    "    plot(series,'*', label='Population Estimates')\n",
+    "    plot(f(years), \"purple\", label='Population Trend')\n",
+    "    decorate(xlabel = 'Year',\n",
+    "           ylabel = 'Estimated Population',\n",
+    "           title = 'Population Estimate by Year')\n",
+    "    plt.ylim([0, 10000]);\n",
+    "    plt.xlim([2005, 2025]);\n",
+    "    \n",
+    "population_graph(population_series)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a SweepSeries for values for change in death rate.  This will allow us to sweep death rates to determine how "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.08  , 0.1225, 0.165 , 0.2075, 0.25  ])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = 0.08\n",
+    "b = 0.25\n",
+    "c = 5\n",
+    "\n",
+    "death_rate_sweep = linspace(a, b, c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then created a linear line of best fit showing the general trend over time.  First we define a function that creates an array of values forming a line of best fit.  Then we plot these values on a plot."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time_initial = 2018;\n",
+    "moose = population_series[time_initial];\n",
+    "birth_rate = avgbirth;\n",
+    "death_rate = death_rate_sweep;\n",
+    "duration = 10;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>time_initial</th>\n",
+       "      <td>2018.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>moose</th>\n",
+       "      <td>3030.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>birth_rate</th>\n",
+       "      <td>0.187829</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>duration</th>\n",
+       "      <td>10.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "time_initial    2018.000000\n",
+       "moose           3030.000000\n",
+       "birth_rate         0.187829\n",
+       "duration          10.000000\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(time_initial=time_initial,\n",
+    "               moose=moose,\n",
+    "               birth_rate=birth_rate,\n",
+    "               #death_rate=death_rate,\n",
+    "               duration=duration)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.08\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(death_rate_sweep[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func(pop, t, system, i, death_rate_sweep):\n",
+    "    #net_growth = (system.birth_rate - death_rate_sweep[i]) * pop\n",
+    "    net_growth = (system.birth_rate - death_rate_sweep[i]) * pop\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func, i):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    #for i in range(c):\n",
+    "    results[i] = TimeSeries()\n",
+    "    results[system.time_initial] = system.moose\n",
+    "    \n",
+    "    for t in linrange(system.time_initial, system.time_initial + system.duration):\n",
+    "        results[t+1] = update_func(results[t], t, system, i, death_rate_sweep)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "IndentationError",
+     "evalue": "unexpected indent (<ipython-input-14-e18ec91a4b85>, line 2)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-14-e18ec91a4b85>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    \"\"\"Simulate the system using any update function.\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
+     ]
+    }
+   ],
+   "source": [
+    "#def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.time_initial] = system.moose\n",
+    "    \n",
+    "    for t in linrange(system.time_initial, system.time_initial + system.duration):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(c):\n",
+    "    results = run_simulation(system, update_func, i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_sim()\n",
+    "    plot run_simulation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simulate the upcoming years assuming no intervention."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = run_simulation(system, update_func1)\n",
+    "plot_results(census, un, results, 'Proportional model, factored')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#plot predition and initial data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#def plot_all_sim(system, update_function, iterations):\n",
+    "   # for i in range(iterations):\n",
+    "        #results = simulation(system, update_function)\n",
+    "        #plot(results, )\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The results of the model are"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "death = linspace(0.08, 0.25, 5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func(pop, t, system, death_rate_sweep, death):\n",
+    "    #net_growth = (system.birth_rate - death_rate_sweep[i]) * pop\n",
+    "    #net_growth = (system.birth_rate - death_rate_sweep[i]) * pop\n",
+    "    net_growth = ((system.birth_rate - death) * pop)\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func, death):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    #for i in range(c):\n",
+    "    results = TimeSeries()\n",
+    "    results[system.time_initial] = system.moose\n",
+    "    \n",
+    "    for t in linrange(system.time_initial, system.time_initial + system.duration):\n",
+    "        results[t+1] = update_func(results[t], t, system, death_rate_sweep, death)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.08\n",
+      "0.1225\n",
+      "0.16499999999999998\n",
+      "0.20750000000000002\n",
+      "0.25\n"
+     ]
+    }
+   ],
+   "source": [
+    "death_rate = linspace(0.08, 0.25, 5)\n",
+    "for death in death_rate:\n",
+    "    print(death)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sweep = SweepSeries()\n",
+    "\n",
+    "for death in death_rate:\n",
+    "    death_rate_sim = run_simulation(system, update_func, death)\n",
+    "    sweep[death] = death_rate_sim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x288088dc240>]"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(sweep[death])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2018    3030.000000\n",
+      "2019    2841.621122\n",
+      "2020    2664.953993\n",
+      "2021    2499.270481\n",
+      "2022    2343.887719\n",
+      "2023    2198.165296\n",
+      "2024    2061.502619\n",
+      "2025    1933.336431\n",
+      "2026    1813.138494\n",
+      "2027    1700.413413\n",
+      "2028    1594.696591\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(sweep[death])\n",
+    "#delete first value in sweep series.\n",
+    "#data type object\n",
+    "#plot year vs population\n",
+    "#sweep-1 only does population values\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-35-32a488080182>, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-35-32a488080182>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def update_mat(pop,system,deathRate)\u001b[0m\n\u001b[1;37m                                        ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "def update_mat(pop,system,death_rate):\n",
+    "    net_growth = (system.birth_rate - death_rate ) * pop\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap04-Mason.ipynb b/code/chap04-Mason.ipynb
new file mode 100644
index 00000000..8f59cfb7
--- /dev/null
+++ b/code/chap04-Mason.ipynb
@@ -0,0 +1,1088 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 4\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim library\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Returning values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a simple function that returns a value:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_five(x):\n",
+    "    return x + 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here's how we call it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y = add_five(3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you run a function on the last line of a cell, Jupyter displays the result:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "add_five(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But that can be a bad habit, because usually if you call a function and don't assign the result in a variable, the result gets discarded.\n",
+    "\n",
+    "In the following example, Jupyter shows the second result, but the first result just disappears."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "add_five(3)\n",
+    "add_five(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When you call a function that returns a variable, it is generally a good idea to assign the result to a variable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8 10\n"
+     ]
+    }
+   ],
+   "source": [
+    "y1 = add_five(3)\n",
+    "y2 = add_five(5)\n",
+    "\n",
+    "print(y1, y2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Write a function called `make_state` that creates a `State` object with the state variables `olin=10` and `wellesley=2`, and then returns the new `State` object.\n",
+    "\n",
+    "Write a line of code that calls `make_state` and assigns the result to a variable named `init`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_state():\n",
+    "    state = State(olin=10,wellesley=2)\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>olin</th>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         10\n",
+       "wellesley     2\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = make_state()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running simulations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's the code from the previous notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def step(state, p1, p2):\n",
+    "    \"\"\"Simulate one minute of time.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    p1: probability of an Olin->Wellesley customer arrival\n",
+    "    p2: probability of a Wellesley->Olin customer arrival\n",
+    "    \"\"\"\n",
+    "    if flip(p1):\n",
+    "        bike_to_wellesley(state)\n",
+    "    \n",
+    "    if flip(p2):\n",
+    "        bike_to_olin(state)\n",
+    "        \n",
+    "def bike_to_wellesley(state):\n",
+    "    \"\"\"Move one bike from Olin to Wellesley.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    \"\"\"\n",
+    "    if state.olin == 0:\n",
+    "        state.olin_empty += 1\n",
+    "        return\n",
+    "    state.olin -= 1\n",
+    "    state.wellesley += 1\n",
+    "    \n",
+    "def bike_to_olin(state):\n",
+    "    \"\"\"Move one bike from Wellesley to Olin.\n",
+    "    \n",
+    "    state: bikeshare State object\n",
+    "    \"\"\"\n",
+    "    if state.wellesley == 0:\n",
+    "        state.wellesley_empty += 1\n",
+    "        return\n",
+    "    state.wellesley -= 1\n",
+    "    state.olin += 1\n",
+    "    \n",
+    "def decorate_bikeshare():\n",
+    "    \"\"\"Add a title and label the axes.\"\"\"\n",
+    "    decorate(title='Olin-Wellesley Bikeshare',\n",
+    "             xlabel='Time step (min)', \n",
+    "             ylabel='Number of bikes')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a modified version of `run_simulation` that creates a `State` object, runs the simulation, and returns the `State` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(p1, p2, num_steps):\n",
+    "    \"\"\"Simulate the given number of time steps.\n",
+    "    \n",
+    "    p1: probability of an Olin->Wellesley customer arrival\n",
+    "    p2: probability of a Wellesley->Olin customer arrival\n",
+    "    num_steps: number of time steps\n",
+    "    \"\"\"\n",
+    "    state = State(olin=10, wellesley=2, \n",
+    "                  olin_empty=0, wellesley_empty=0)\n",
+    "                    \n",
+    "    for i in range(num_steps):\n",
+    "        step(state, p1, p2)\n",
+    "        \n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now `run_simulation` doesn't plot anything:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>olin</th>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>olin_empty</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley_empty</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin               3\n",
+       "wellesley          9\n",
+       "olin_empty         0\n",
+       "wellesley_empty    0\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = run_simulation(0.4, 0.2, 60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But after the simulation, we can read the metrics from the `State` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state.olin_empty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can run simulations with different values for the parameters.  When `p1` is small, we probably don't run out of bikes at Olin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = run_simulation(0.2, 0.2, 60)\n",
+    "state.olin_empty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When `p1` is large, we probably do."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = run_simulation(0.6, 0.2, 60)\n",
+    "state.olin_empty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## More for loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`linspace` creates a NumPy array of equally spaced numbers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p1_array = linspace(0, 1, 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use an array in a `for` loop, like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0\n",
+      "0.25\n",
+      "0.5\n",
+      "0.75\n",
+      "1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "for p1 in p1_array:\n",
+    "    print(p1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This will come in handy in the next section.\n",
+    "\n",
+    "`linspace` is defined in `modsim.py`.  You can get the documentation using `help`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function linspace in module modsim:\n",
+      "\n",
+      "linspace(start, stop, num=50, **options)\n",
+      "    Returns an array of evenly-spaced values in the interval [start, stop].\n",
+      "    \n",
+      "    start: first value\n",
+      "    stop: last value\n",
+      "    num: number of values\n",
+      "    \n",
+      "    Also accepts the same keyword arguments as np.linspace.  See\n",
+      "    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n",
+      "    \n",
+      "    returns: array or Quantity\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(linspace)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`linspace` is based on a NumPy function with the same name.  [Click here](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) to read more about how to use it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** \n",
+    "Use `linspace` to make an array of 10 equally spaced numbers from 1 to 10 (including both)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "linspace(1,10,10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** The `modsim` library provides a related function called `linrange`.  You can view the documentation by running the following cell:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function linrange in module modsim:\n",
+      "\n",
+      "linrange(start=0, stop=None, step=1, **options)\n",
+      "    Returns an array of evenly-spaced values in the interval [start, stop].\n",
+      "    \n",
+      "    This function works best if the space between start and stop\n",
+      "    is divisible by step; otherwise the results might be surprising.\n",
+      "    \n",
+      "    By default, the last value in the array is `stop-step`\n",
+      "    (at least approximately).\n",
+      "    If you provide the keyword argument `endpoint=True`,\n",
+      "    the last value in the array is `stop`.\n",
+      "    \n",
+      "    start: first value\n",
+      "    stop: last value\n",
+      "    step: space between values\n",
+      "    \n",
+      "    Also accepts the same keyword arguments as np.linspace.  See\n",
+      "    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n",
+      "    \n",
+      "    returns: array or Quantity\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(linrange)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Use `linrange` to make an array of numbers from 1 to 11 with a step size of 2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 3., 5., 7., 9.])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "linrange(1,11,2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sweeping parameters"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`p1_array` contains a range of values for `p1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p2 = 0.2\n",
+    "num_steps = 60\n",
+    "p1_array = linspace(0, 1, 11)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following loop runs a simulation for each value of `p1` in `p1_array`; after each simulation, it prints the number of unhappy customers at the Olin station:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 0\n",
+      "0.1 0\n",
+      "0.2 0\n",
+      "0.30000000000000004 0\n",
+      "0.4 4\n",
+      "0.5 8\n",
+      "0.6000000000000001 11\n",
+      "0.7000000000000001 23\n",
+      "0.8 31\n",
+      "0.9 32\n",
+      "1.0 41\n"
+     ]
+    }
+   ],
+   "source": [
+    "for p1 in p1_array:\n",
+    "    state = run_simulation(p1, p2, num_steps)\n",
+    "    print(p1, state.olin_empty)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can do the same thing, but storing the results in a `SweepSeries` instead of printing them.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sweep = SweepSeries()\n",
+    "\n",
+    "for p1 in p1_array:\n",
+    "    state = run_simulation(p1, p2, num_steps)\n",
+    "    sweep[p1] = state.olin_empty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And then we can plot the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap02-fig02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(sweep, label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
+    "         ylabel='Number of unhappy customers')\n",
+    "\n",
+    "savefig('figs/chap02-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Exercise:** Wrap this code in a function named `sweep_p1` that takes an array called `p1_array` as a parameter.  It should create a new `SweepSeries`, run a simulation for each value of `p1` in `p1_array`, store the results in the `SweepSeries`, and return the `SweepSeries`.\n",
+    "\n",
+    "Use your function to plot the number of unhappy customers at Olin as a function of `p1`.  Label the axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "60"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def sweep_p1(p1_array):\n",
+    "    sweep = SweepSeries()\n",
+    "    for p1 in p1_array:\n",
+    "        state = run_simulation(p1,p2,num_steps)\n",
+    "        sweep[p1] = state.olin_empty\n",
+    "    return sweep\n",
+    "p1_array = linspace(0,1,15)\n",
+    "p2 = 0.2\n",
+    "num_steps = 60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap02-fig02.pdf\n",
+      "0.000000     0\n",
+      "0.071429     0\n",
+      "0.142857     0\n",
+      "0.214286     0\n",
+      "0.285714     0\n",
+      "0.357143     0\n",
+      "0.428571     5\n",
+      "0.500000    11\n",
+      "0.571429     9\n",
+      "0.642857    13\n",
+      "0.714286    28\n",
+      "0.785714    23\n",
+      "0.857143    21\n",
+      "0.928571    37\n",
+      "1.000000    35\n",
+      "dtype: int64\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(sweep_p1(p1_array), label='Olin')\n",
+    "\n",
+    "decorate(title='Olin-Wellesley Bikeshare',\n",
+    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
+    "         ylabel='Number of unhappy customers')\n",
+    "\n",
+    "savefig('figs/chap02-fig02.pdf')\n",
+    "print(sweep_p1(p1_array))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Write a function called `sweep_p2` that runs simulations with `p1=0.5` and a range of values for `p2`.  It should store the results in a `SweepSeries` and return the `SweepSeries`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sweep_p2(p2_array):\n",
+    "    sweep2 = SweepSeries()\n",
+    "    for p2 in p2_array:\n",
+    "        state = run_simulation(p1,p2,num_steps)\n",
+    "        sweep2[p2] = state.wellesley_empty\n",
+    "    return sweep2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.000000     0\n",
+      "0.071429     0\n",
+      "0.142857     0\n",
+      "0.214286     0\n",
+      "0.285714     0\n",
+      "0.357143     0\n",
+      "0.428571     3\n",
+      "0.500000     0\n",
+      "0.571429    13\n",
+      "0.642857    11\n",
+      "0.714286    12\n",
+      "0.785714    18\n",
+      "0.857143    23\n",
+      "0.928571    24\n",
+      "1.000000    26\n",
+      "dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "p2_array = linspace(0,1,15)\n",
+    "p1 = 0.5\n",
+    "num_steps = 60\n",
+    "print(sweep_p2(p2_array))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Optional exercises\n",
+    "\n",
+    "The following two exercises are a little more challenging.  If you are comfortable with what you have learned so far, you should give them a try.  If you feel like you have your hands full, you might want to skip them for now.\n",
+    "\n",
+    "**Exercise:** Because our simulations are random, the results vary from one run to another, and the results of a parameter sweep tend to be noisy.  We can get a clearer picture of the relationship between a parameter and a metric by running multiple simulations with the same parameter and taking the average of the results.\n",
+    "\n",
+    "Write a function called `run_multiple_simulations` that takes as parameters `p1`, `p2`, `num_steps`, and `num_runs`.\n",
+    "\n",
+    "`num_runs` specifies how many times it should call `run_simulation`.\n",
+    "\n",
+    "After each run, it should store the total number of unhappy customers (at Olin or Wellesley) in a `TimeSeries`.  At the end, it should return the `TimeSeries`.\n",
+    "\n",
+    "Test your function with parameters\n",
+    "\n",
+    "```\n",
+    "p1 = 0.3\n",
+    "p2 = 0.3\n",
+    "num_steps = 60\n",
+    "num_runs = 10\n",
+    "```\n",
+    "\n",
+    "Display the resulting `TimeSeries` and use the `mean` function provided by the `TimeSeries` object to compute the average number of unhappy customers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  Continuting the previous exercise, use `run_multiple_simulations` to run simulations with a range of values for `p1` and\n",
+    "\n",
+    "```\n",
+    "p2 = 0.3\n",
+    "num_steps = 60\n",
+    "num_runs = 20\n",
+    "```\n",
+    "\n",
+    "Store the results in a `SweepSeries`, then plot the average number of unhappy customers as a function of `p1`.  Label the axes.\n",
+    "\n",
+    "What value of `p1` minimizes the average number of unhappy customers?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap04.ipynb b/code/chap04.ipynb
index 138fc23f..4e8a5863 100644
--- a/code/chap04.ipynb
+++ b/code/chap04.ipynb
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -45,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,9 +62,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "y = add_five(3)"
    ]
@@ -78,9 +89,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "add_five(5)"
    ]
@@ -96,9 +118,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "add_five(3)\n",
     "add_five(5)"
@@ -113,9 +146,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8 10\n"
+     ]
+    }
+   ],
    "source": [
     "y1 = add_five(3)\n",
     "y2 = add_five(5)\n",
@@ -134,20 +175,70 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Solution goes here"
+    "def make_state():\n",
+    "    state = State(olin=10,wellesley=2)\n",
+    "    return state"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Solution goes here"
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>olin</th>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>wellesley</th>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "olin         10\n",
+       "wellesley     2\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = make_state()"
    ]
   },
   {
@@ -166,7 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -669,7 +760,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap05-Mason.ipynb b/code/chap05-Mason.ipynb
new file mode 100644
index 00000000..567e6b06
--- /dev/null
+++ b/code/chap05-Mason.ipynb
@@ -0,0 +1,1688 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 5\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading data\n",
+    "\n",
+    "Pandas is a library that provides tools for reading and processing data.  `read_html` reads a web page from a file or the Internet and creates one `DataFrame` for each table on the page."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The data directory contains a downloaded copy of https://en.wikipedia.org/wiki/World_population_estimates\n",
+    "\n",
+    "The arguments of `read_html` specify the file to read and how to interpret the tables in the file.  The result, `tables`, is a sequence of `DataFrame` objects; `len(tables)` reports the length of the sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "len(tables)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can select the `DataFrame` we want using the bracket operator.  The tables are numbered from 0, so `tables[2]` is actually the third table on the page.\n",
+    "\n",
+    "`head` selects the header and the first five rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>United States Census Bureau (2017)[28]</th>\n",
+       "      <th>Population Reference Bureau (1973–2016)[15]</th>\n",
+       "      <th>United Nations Department of Economic and Social Affairs (2015)[16]</th>\n",
+       "      <th>Maddison (2008)[17]</th>\n",
+       "      <th>HYDE (2007)[24]</th>\n",
+       "      <th>Tanton (1994)[18]</th>\n",
+       "      <th>Biraben (1980)[19]</th>\n",
+       "      <th>McEvedy &amp; Jones (1978)[20]</th>\n",
+       "      <th>Thomlinson (1975)[21]</th>\n",
+       "      <th>Durand (1974)[22]</th>\n",
+       "      <th>Clark (1967)[23]</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1950</th>\n",
+       "      <td>2557628654</td>\n",
+       "      <td>2.516000e+09</td>\n",
+       "      <td>2.525149e+09</td>\n",
+       "      <td>2.544000e+09</td>\n",
+       "      <td>2.527960e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>2.527000e+09</td>\n",
+       "      <td>2.500000e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.486000e+09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1951</th>\n",
+       "      <td>2594939877</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.572851e+09</td>\n",
+       "      <td>2.571663e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1952</th>\n",
+       "      <td>2636772306</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.619292e+09</td>\n",
+       "      <td>2.617949e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1953</th>\n",
+       "      <td>2682053389</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.665865e+09</td>\n",
+       "      <td>2.665959e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1954</th>\n",
+       "      <td>2730228104</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.713172e+09</td>\n",
+       "      <td>2.716927e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      United States Census Bureau (2017)[28]  \\\n",
+       "Year                                           \n",
+       "1950                              2557628654   \n",
+       "1951                              2594939877   \n",
+       "1952                              2636772306   \n",
+       "1953                              2682053389   \n",
+       "1954                              2730228104   \n",
+       "\n",
+       "      Population Reference Bureau (1973–2016)[15]  \\\n",
+       "Year                                                \n",
+       "1950                                 2.516000e+09   \n",
+       "1951                                          NaN   \n",
+       "1952                                          NaN   \n",
+       "1953                                          NaN   \n",
+       "1954                                          NaN   \n",
+       "\n",
+       "      United Nations Department of Economic and Social Affairs (2015)[16]  \\\n",
+       "Year                                                                        \n",
+       "1950                                       2.525149e+09                     \n",
+       "1951                                       2.572851e+09                     \n",
+       "1952                                       2.619292e+09                     \n",
+       "1953                                       2.665865e+09                     \n",
+       "1954                                       2.713172e+09                     \n",
+       "\n",
+       "      Maddison (2008)[17]  HYDE (2007)[24]  Tanton (1994)[18]  \\\n",
+       "Year                                                            \n",
+       "1950         2.544000e+09     2.527960e+09       2.400000e+09   \n",
+       "1951         2.571663e+09              NaN                NaN   \n",
+       "1952         2.617949e+09              NaN                NaN   \n",
+       "1953         2.665959e+09              NaN                NaN   \n",
+       "1954         2.716927e+09              NaN                NaN   \n",
+       "\n",
+       "      Biraben (1980)[19]  McEvedy & Jones (1978)[20]  Thomlinson (1975)[21]  \\\n",
+       "Year                                                                          \n",
+       "1950        2.527000e+09                2.500000e+09           2.400000e+09   \n",
+       "1951                 NaN                         NaN                    NaN   \n",
+       "1952                 NaN                         NaN                    NaN   \n",
+       "1953                 NaN                         NaN                    NaN   \n",
+       "1954                 NaN                         NaN                    NaN   \n",
+       "\n",
+       "     Durand (1974)[22]  Clark (1967)[23]  \n",
+       "Year                                      \n",
+       "1950               NaN      2.486000e+09  \n",
+       "1951               NaN               NaN  \n",
+       "1952               NaN               NaN  \n",
+       "1953               NaN               NaN  \n",
+       "1954               NaN               NaN  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2 = tables[2]\n",
+    "table2.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`tail` selects the last five rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>United States Census Bureau (2017)[28]</th>\n",
+       "      <th>Population Reference Bureau (1973–2016)[15]</th>\n",
+       "      <th>United Nations Department of Economic and Social Affairs (2015)[16]</th>\n",
+       "      <th>Maddison (2008)[17]</th>\n",
+       "      <th>HYDE (2007)[24]</th>\n",
+       "      <th>Tanton (1994)[18]</th>\n",
+       "      <th>Biraben (1980)[19]</th>\n",
+       "      <th>McEvedy &amp; Jones (1978)[20]</th>\n",
+       "      <th>Thomlinson (1975)[21]</th>\n",
+       "      <th>Durand (1974)[22]</th>\n",
+       "      <th>Clark (1967)[23]</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2012</th>\n",
+       "      <td>7013871313</td>\n",
+       "      <td>7.057075e+09</td>\n",
+       "      <td>7.080072e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013</th>\n",
+       "      <td>7092128094</td>\n",
+       "      <td>7.136796e+09</td>\n",
+       "      <td>7.162119e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2014</th>\n",
+       "      <td>7169968185</td>\n",
+       "      <td>7.238184e+09</td>\n",
+       "      <td>7.243784e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2015</th>\n",
+       "      <td>7247892788</td>\n",
+       "      <td>7.336435e+09</td>\n",
+       "      <td>7.349472e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016</th>\n",
+       "      <td>7325996709</td>\n",
+       "      <td>7.418152e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      United States Census Bureau (2017)[28]  \\\n",
+       "Year                                           \n",
+       "2012                              7013871313   \n",
+       "2013                              7092128094   \n",
+       "2014                              7169968185   \n",
+       "2015                              7247892788   \n",
+       "2016                              7325996709   \n",
+       "\n",
+       "      Population Reference Bureau (1973–2016)[15]  \\\n",
+       "Year                                                \n",
+       "2012                                 7.057075e+09   \n",
+       "2013                                 7.136796e+09   \n",
+       "2014                                 7.238184e+09   \n",
+       "2015                                 7.336435e+09   \n",
+       "2016                                 7.418152e+09   \n",
+       "\n",
+       "      United Nations Department of Economic and Social Affairs (2015)[16]  \\\n",
+       "Year                                                                        \n",
+       "2012                                       7.080072e+09                     \n",
+       "2013                                       7.162119e+09                     \n",
+       "2014                                       7.243784e+09                     \n",
+       "2015                                       7.349472e+09                     \n",
+       "2016                                                NaN                     \n",
+       "\n",
+       "      Maddison (2008)[17]  HYDE (2007)[24]  Tanton (1994)[18]  \\\n",
+       "Year                                                            \n",
+       "2012                  NaN              NaN                NaN   \n",
+       "2013                  NaN              NaN                NaN   \n",
+       "2014                  NaN              NaN                NaN   \n",
+       "2015                  NaN              NaN                NaN   \n",
+       "2016                  NaN              NaN                NaN   \n",
+       "\n",
+       "      Biraben (1980)[19]  McEvedy & Jones (1978)[20]  Thomlinson (1975)[21]  \\\n",
+       "Year                                                                          \n",
+       "2012                 NaN                         NaN                    NaN   \n",
+       "2013                 NaN                         NaN                    NaN   \n",
+       "2014                 NaN                         NaN                    NaN   \n",
+       "2015                 NaN                         NaN                    NaN   \n",
+       "2016                 NaN                         NaN                    NaN   \n",
+       "\n",
+       "     Durand (1974)[22]  Clark (1967)[23]  \n",
+       "Year                                      \n",
+       "2012               NaN               NaN  \n",
+       "2013               NaN               NaN  \n",
+       "2014               NaN               NaN  \n",
+       "2015               NaN               NaN  \n",
+       "2016               NaN               NaN  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2.tail()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Long column names are awkard to work with, but we can replace them with abbreviated names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what the DataFrame looks like now.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>census</th>\n",
+       "      <th>prb</th>\n",
+       "      <th>un</th>\n",
+       "      <th>maddison</th>\n",
+       "      <th>hyde</th>\n",
+       "      <th>tanton</th>\n",
+       "      <th>biraben</th>\n",
+       "      <th>mj</th>\n",
+       "      <th>thomlinson</th>\n",
+       "      <th>durand</th>\n",
+       "      <th>clark</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Year</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1950</th>\n",
+       "      <td>2557628654</td>\n",
+       "      <td>2.516000e+09</td>\n",
+       "      <td>2.525149e+09</td>\n",
+       "      <td>2.544000e+09</td>\n",
+       "      <td>2.527960e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>2.527000e+09</td>\n",
+       "      <td>2.500000e+09</td>\n",
+       "      <td>2.400000e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.486000e+09</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1951</th>\n",
+       "      <td>2594939877</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.572851e+09</td>\n",
+       "      <td>2.571663e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1952</th>\n",
+       "      <td>2636772306</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.619292e+09</td>\n",
+       "      <td>2.617949e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1953</th>\n",
+       "      <td>2682053389</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.665865e+09</td>\n",
+       "      <td>2.665959e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1954</th>\n",
+       "      <td>2730228104</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2.713172e+09</td>\n",
+       "      <td>2.716927e+09</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          census           prb            un      maddison          hyde  \\\n",
+       "Year                                                                       \n",
+       "1950  2557628654  2.516000e+09  2.525149e+09  2.544000e+09  2.527960e+09   \n",
+       "1951  2594939877           NaN  2.572851e+09  2.571663e+09           NaN   \n",
+       "1952  2636772306           NaN  2.619292e+09  2.617949e+09           NaN   \n",
+       "1953  2682053389           NaN  2.665865e+09  2.665959e+09           NaN   \n",
+       "1954  2730228104           NaN  2.713172e+09  2.716927e+09           NaN   \n",
+       "\n",
+       "            tanton       biraben            mj    thomlinson durand  \\\n",
+       "Year                                                                  \n",
+       "1950  2.400000e+09  2.527000e+09  2.500000e+09  2.400000e+09    NaN   \n",
+       "1951           NaN           NaN           NaN           NaN    NaN   \n",
+       "1952           NaN           NaN           NaN           NaN    NaN   \n",
+       "1953           NaN           NaN           NaN           NaN    NaN   \n",
+       "1954           NaN           NaN           NaN           NaN    NaN   \n",
+       "\n",
+       "             clark  \n",
+       "Year                \n",
+       "1950  2.486000e+09  \n",
+       "1951           NaN  \n",
+       "1952           NaN  \n",
+       "1953           NaN  \n",
+       "1954           NaN  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table2.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first column, which is labeled `Year`, is special.  It is the **index** for this `DataFrame`, which means it contains the labels for the rows.\n",
+    "\n",
+    "Some of the values use scientific notation; for example, `2.544000e+09` is shorthand for $2.544 \\cdot 10^9$ or 2.544 billion.\n",
+    "\n",
+    "`NaN` is a special value that indicates missing data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Series\n",
+    "\n",
+    "We can use dot notation to select a column from a `DataFrame`.  The result is a `Series`, which is like a `DataFrame` with a single column."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2557628654\n",
+       "1951    2594939877\n",
+       "1952    2636772306\n",
+       "1953    2682053389\n",
+       "1954    2730228104\n",
+       "Name: census, dtype: int64"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "2012    7013871313\n",
+       "2013    7092128094\n",
+       "2014    7169968185\n",
+       "2015    7247892788\n",
+       "2016    7325996709\n",
+       "Name: census, dtype: int64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census.tail()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Like a `DataFrame`, a `Series` contains an index, which labels the rows.\n",
+    "\n",
+    "`1e9` is scientific notation for $1 \\cdot 10^9$ or 1 billion."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From here on, we will work in units of billions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what these estimates look like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap03-fig01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(census, ':', label='US Census')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "    \n",
+    "decorate(xlabel='Year',\n",
+    "         ylabel='World population (billion)')\n",
+    "savefig('figs/chap03-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following expression computes the elementwise differences between the two series, then divides through by the UN value to produce [relative errors](https://en.wikipedia.org/wiki/Approximation_error), then finds the largest element.\n",
+    "\n",
+    "So the largest relative error between the estimates is about 1.3%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.3821293828998855"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "max(abs(census - un) / un) * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** Break down that expression into smaller steps and display the intermediate results, to make sure you understand how it works.\n",
+    "\n",
+    "1.  Compute the elementwise differences, `census - un`\n",
+    "2.  Compute the absolute differences, `abs(census - un)`\n",
+    "3.  Compute the relative differences, `abs(census - un) / un`\n",
+    "4.  Compute the percent differences, `abs(census - un) / un * 100`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.032480\n",
+       "1951    0.022089\n",
+       "1952    0.017480\n",
+       "1953    0.016188\n",
+       "1954    0.017056\n",
+       "1955    0.020448\n",
+       "1956    0.023728\n",
+       "1957    0.028307\n",
+       "1958    0.032107\n",
+       "1959    0.030321\n",
+       "1960    0.016999\n",
+       "1961    0.001137\n",
+       "1962   -0.000978\n",
+       "1963    0.008650\n",
+       "1964    0.017462\n",
+       "1965    0.021303\n",
+       "1966    0.023203\n",
+       "1967    0.021812\n",
+       "1968    0.020639\n",
+       "1969    0.021050\n",
+       "1970    0.021525\n",
+       "1971    0.023573\n",
+       "1972    0.023695\n",
+       "1973    0.022914\n",
+       "1974    0.021304\n",
+       "1975    0.018063\n",
+       "1976    0.014049\n",
+       "1977    0.011268\n",
+       "1978    0.008441\n",
+       "1979    0.007486\n",
+       "          ...   \n",
+       "1987   -0.018115\n",
+       "1988   -0.023658\n",
+       "1989   -0.028560\n",
+       "1990   -0.031861\n",
+       "1991   -0.037323\n",
+       "1992   -0.038763\n",
+       "1993   -0.040597\n",
+       "1994   -0.042404\n",
+       "1995   -0.042619\n",
+       "1996   -0.041576\n",
+       "1997   -0.040716\n",
+       "1998   -0.040090\n",
+       "1999   -0.039403\n",
+       "2000   -0.039129\n",
+       "2001   -0.038928\n",
+       "2002   -0.038837\n",
+       "2003   -0.039401\n",
+       "2004   -0.040006\n",
+       "2005   -0.041050\n",
+       "2006   -0.041964\n",
+       "2007   -0.043192\n",
+       "2008   -0.044599\n",
+       "2009   -0.046508\n",
+       "2010   -0.057599\n",
+       "2011   -0.061999\n",
+       "2012   -0.066201\n",
+       "2013   -0.069991\n",
+       "2014   -0.073816\n",
+       "2015   -0.101579\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census - un"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.032480\n",
+       "1951    0.022089\n",
+       "1952    0.017480\n",
+       "1953    0.016188\n",
+       "1954    0.017056\n",
+       "1955    0.020448\n",
+       "1956    0.023728\n",
+       "1957    0.028307\n",
+       "1958    0.032107\n",
+       "1959    0.030321\n",
+       "1960    0.016999\n",
+       "1961    0.001137\n",
+       "1962    0.000978\n",
+       "1963    0.008650\n",
+       "1964    0.017462\n",
+       "1965    0.021303\n",
+       "1966    0.023203\n",
+       "1967    0.021812\n",
+       "1968    0.020639\n",
+       "1969    0.021050\n",
+       "1970    0.021525\n",
+       "1971    0.023573\n",
+       "1972    0.023695\n",
+       "1973    0.022914\n",
+       "1974    0.021304\n",
+       "1975    0.018063\n",
+       "1976    0.014049\n",
+       "1977    0.011268\n",
+       "1978    0.008441\n",
+       "1979    0.007486\n",
+       "          ...   \n",
+       "1987    0.018115\n",
+       "1988    0.023658\n",
+       "1989    0.028560\n",
+       "1990    0.031861\n",
+       "1991    0.037323\n",
+       "1992    0.038763\n",
+       "1993    0.040597\n",
+       "1994    0.042404\n",
+       "1995    0.042619\n",
+       "1996    0.041576\n",
+       "1997    0.040716\n",
+       "1998    0.040090\n",
+       "1999    0.039403\n",
+       "2000    0.039129\n",
+       "2001    0.038928\n",
+       "2002    0.038837\n",
+       "2003    0.039401\n",
+       "2004    0.040006\n",
+       "2005    0.041050\n",
+       "2006    0.041964\n",
+       "2007    0.043192\n",
+       "2008    0.044599\n",
+       "2009    0.046508\n",
+       "2010    0.057599\n",
+       "2011    0.061999\n",
+       "2012    0.066201\n",
+       "2013    0.069991\n",
+       "2014    0.073816\n",
+       "2015    0.101579\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census - un)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    0.012862\n",
+       "1951    0.008585\n",
+       "1952    0.006674\n",
+       "1953    0.006072\n",
+       "1954    0.006286\n",
+       "1955    0.007404\n",
+       "1956    0.008439\n",
+       "1957    0.009887\n",
+       "1958    0.011011\n",
+       "1959    0.010208\n",
+       "1960    0.005617\n",
+       "1961    0.000369\n",
+       "1962    0.000311\n",
+       "1963    0.002702\n",
+       "1964    0.005350\n",
+       "1965    0.006399\n",
+       "1966    0.006829\n",
+       "1967    0.006289\n",
+       "1968    0.005827\n",
+       "1969    0.005821\n",
+       "1970    0.005832\n",
+       "1971    0.006258\n",
+       "1972    0.006166\n",
+       "1973    0.005847\n",
+       "1974    0.005332\n",
+       "1975    0.004437\n",
+       "1976    0.003388\n",
+       "1977    0.002670\n",
+       "1978    0.001965\n",
+       "1979    0.001712\n",
+       "          ...   \n",
+       "1987    0.003591\n",
+       "1988    0.004604\n",
+       "1989    0.005461\n",
+       "1990    0.005988\n",
+       "1991    0.006900\n",
+       "1992    0.007054\n",
+       "1993    0.007277\n",
+       "1994    0.007490\n",
+       "1995    0.007423\n",
+       "1996    0.007142\n",
+       "1997    0.006903\n",
+       "1998    0.006709\n",
+       "1999    0.006511\n",
+       "2000    0.006386\n",
+       "2001    0.006274\n",
+       "2002    0.006183\n",
+       "2003    0.006197\n",
+       "2004    0.006216\n",
+       "2005    0.006302\n",
+       "2006    0.006365\n",
+       "2007    0.006473\n",
+       "2008    0.006604\n",
+       "2009    0.006805\n",
+       "2010    0.008328\n",
+       "2011    0.008860\n",
+       "2012    0.009350\n",
+       "2013    0.009772\n",
+       "2014    0.010190\n",
+       "2015    0.013821\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census - un) / un"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    1.286247\n",
+       "1951    0.858540\n",
+       "1952    0.667365\n",
+       "1953    0.607232\n",
+       "1954    0.628640\n",
+       "1955    0.740425\n",
+       "1956    0.843928\n",
+       "1957    0.988701\n",
+       "1958    1.101054\n",
+       "1959    1.020766\n",
+       "1960    0.561750\n",
+       "1961    0.036871\n",
+       "1962    0.031146\n",
+       "1963    0.270201\n",
+       "1964    0.535045\n",
+       "1965    0.639908\n",
+       "1966    0.682939\n",
+       "1967    0.628856\n",
+       "1968    0.582745\n",
+       "1969    0.582126\n",
+       "1970    0.583151\n",
+       "1971    0.625807\n",
+       "1972    0.616597\n",
+       "1973    0.584666\n",
+       "1974    0.533223\n",
+       "1975    0.443692\n",
+       "1976    0.338849\n",
+       "1977    0.266959\n",
+       "1978    0.196499\n",
+       "1979    0.171246\n",
+       "          ...   \n",
+       "1987    0.359053\n",
+       "1988    0.460423\n",
+       "1989    0.546078\n",
+       "1990    0.598794\n",
+       "1991    0.690025\n",
+       "1992    0.705441\n",
+       "1993    0.727689\n",
+       "1994    0.749047\n",
+       "1995    0.742263\n",
+       "1996    0.714242\n",
+       "1997    0.690252\n",
+       "1998    0.670935\n",
+       "1999    0.651132\n",
+       "2000    0.638560\n",
+       "2001    0.627448\n",
+       "2002    0.618347\n",
+       "2003    0.619705\n",
+       "2004    0.621627\n",
+       "2005    0.630170\n",
+       "2006    0.636478\n",
+       "2007    0.647257\n",
+       "2008    0.660376\n",
+       "2009    0.680460\n",
+       "2010    0.832811\n",
+       "2011    0.885957\n",
+       "2012    0.935034\n",
+       "2013    0.977243\n",
+       "2014    1.019023\n",
+       "2015    1.382129\n",
+       "2016         NaN\n",
+       "Length: 67, dtype: float64"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "abs(census - un) / un * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`max` and `abs` are built-in functions provided by Python, but NumPy also provides version that are a little more general.  When you import `modsim`, you get the NumPy versions of these functions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Constant growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can select a value from a `Series` using bracket notation.  Here's the first element:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census[1950]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And the last value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7.325996709"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census[2016]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But rather than \"hard code\" those dates, we can get the first and last labels from the `Series`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1950"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2016"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_end = get_last_label(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "66"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "elapsed_time = t_end - t_0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can get the first and last values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p_0 = get_first_value(census)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7.325996709"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p_end = get_last_value(census)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then we can compute the average annual growth in billions of people per year."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.768368055"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total_growth = p_end - p_0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.07224800083333333"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "annual_growth = total_growth / elapsed_time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### TimeSeries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's create a `TimeSeries` to contain values generated by a linear growth model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "Series([], dtype: float64)"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = TimeSeries()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initially the `TimeSeries` is empty, but we can initialize it so the starting value, in 1950, is the 1950 population estimated by the US Census."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1950</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "1950    2.557629\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[t_0] = census[t_0]\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After that, the population in the model grows by a constant amount each year."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for t in linrange(t_0, t_end):\n",
+    "    results[t+1] = results[t] + annual_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what the results looks like, compared to the actual data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap03-fig02.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(census, ':', label='US Census')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "plot(results, color='purple', label='model')\n",
+    "\n",
+    "decorate(xlabel='Year', \n",
+    "         ylabel='World population (billion)',\n",
+    "         title='Constant growth')\n",
+    "savefig('figs/chap03-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model fits the data pretty well after 1990, but not so well before."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Optional Exercise:**  Try fitting the model using data from 1970 to the present, and see if that does a better job.\n",
+    "\n",
+    "Hint: \n",
+    "\n",
+    "1. Copy the code from above and make a few changes.  Test your code after each small change.\n",
+    "\n",
+    "2. Make sure your `TimeSeries` starts in 1950, even though the estimated annual growth is based on later data.\n",
+    "\n",
+    "3. You might want to add a constant to the starting value to match the data better."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap05.ipynb b/code/chap05.ipynb
index 72f2db30..cddc89b2 100644
--- a/code/chap05.ipynb
+++ b/code/chap05.ipynb
@@ -568,7 +568,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap06-Mason.ipynb b/code/chap06-Mason.ipynb
new file mode 100644
index 00000000..a8968175
--- /dev/null
+++ b/code/chap06-Mason.ipynb
@@ -0,0 +1,652 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 6\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code from the previous chapter\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.07224800083333333"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "elapsed_time = t_end - t_0\n",
+    "\n",
+    "p_0 = get_first_value(census)\n",
+    "p_end = get_last_value(census)\n",
+    "total_growth = p_end - p_0\n",
+    "\n",
+    "annual_growth = total_growth / elapsed_time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### System objects"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can rewrite the code from the previous chapter using system objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>annual_growth</th>\n",
+       "      <td>0.072248</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0              1950.000000\n",
+       "t_end            2016.000000\n",
+       "p_0                 2.557629\n",
+       "annual_growth       0.072248\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                annual_growth=annual_growth)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can encapsulate the code that runs the model in a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation1(system):\n",
+    "    \"\"\"Runs the constant growth model.\n",
+    "    \n",
+    "    system: System object\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        results[t+1] = results[t] + system.annual_growth\n",
+    "    \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also encapsulate the code that plots the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', color='yellow', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='purple', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation1(system)\n",
+    "plot_results(census, un, results, 'Constant growth model')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Proportional growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a more realistic model where the number of births and deaths is proportional to the current population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation2(system):\n",
+    "    \"\"\"Run a model with proportional birth and death.\n",
+    "    \n",
+    "    system: System object\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        births = system.birth_rate * results[t]\n",
+    "        deaths = system.death_rate * results[t]\n",
+    "        results[t+1] = results[t] + births - deaths\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I picked a death rate that seemed reasonable and then adjusted the birth rate to fit the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system.death_rate = 0.01\n",
+    "system.birth_rate = 0.027"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = run_simulation2(system)\n",
+    "plot_results(census, un, results, 'Proportional model')\n",
+    "savefig('figs/chap03-fig03.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The model fits the data pretty well for the first 20 years, but not so well after that."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Factoring out the update function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`run_simulation1` and `run_simulation2` are nearly identical except the body of the loop.  So we can factor that part out into a function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def update_func1(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    births = system.birth_rate * pop\n",
+    "    deaths = system.death_rate * pop\n",
+    "    return pop + births - deaths"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The name `update_func` refers to a function object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "update_func1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Which we can confirm by checking its type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(update_func1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`run_simulation` takes the update function as a parameter and calls it just like any other function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we use it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                birth_rate=0.027,\n",
+    "                death_rate=0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "results = run_simulation(system, update_func1)\n",
+    "plot_results(census, un, results, 'Proportional model, factored')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Remember not to put parentheses after `update_func1`.  What happens if you try?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** When you run `run_simulation`, it runs `update_func1` once for each year between `t_0` and `t_end`.  To see that for yourself, add a print statement at the beginning of `update_func1` that prints the values of `t` and `pop`, then run `run_simulation` again."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Combining birth and death"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since births and deaths get added up, we don't have to compute them separately.  We can combine the birth and death rates into a single net growth rate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def update_func2(pop, t, system):\n",
+    "    \"\"\"Compute the population next year.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha  * pop\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how it works:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system.alpha = system.birth_rate - system.death_rate\n",
+    "\n",
+    "results = run_simulation(system, update_func2)\n",
+    "plot_results(census, un, results, 'Proportional model, combined birth and death')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Exercise:** Maybe the reason the proportional model doesn't work very well is that the growth rate, `alpha`, is changing over time.  So let's try a model with different growth rates before and after 1980 (as an arbitrary choice).\n",
+    "\n",
+    "Write an update function that takes `pop`, `t`, and `system` as parameters.  The system object, `system`, should contain two parameters: the growth rate before 1980, `alpha1`, and the growth rate after 1980, `alpha2`.  It should use `t` to determine which growth rate to use.  Note: Don't forget the `return` statement.\n",
+    "\n",
+    "Test your function by calling it directly, then pass it to `run_simulation`.  Plot the results.  Adjust the parameters `alpha1` and `alpha2` to fit the data as well as you can.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "collapsed": true,
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap06.ipynb b/code/chap06.ipynb
index 20ac99f5..af54b72d 100644
--- a/code/chap06.ipynb
+++ b/code/chap06.ipynb
@@ -528,7 +528,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap07-Mason.ipynb b/code/chap07-Mason.ipynb
new file mode 100644
index 00000000..1a7fc413
--- /dev/null
+++ b/code/chap07-Mason.ipynb
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 7\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code from the previous chapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.525149\n",
+       "1951    2.572851\n",
+       "1952    2.619292\n",
+       "1953    2.665865\n",
+       "1954    2.713172\n",
+       "Name: un, dtype: float64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "un.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Year\n",
+       "1950    2.557629\n",
+       "1951    2.594940\n",
+       "1952    2.636772\n",
+       "1953    2.682053\n",
+       "1954    2.730228\n",
+       "Name: census, dtype: float64"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "census = table2.census / 1e9\n",
+    "census.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Quadratic growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's the implementation of the quadratic growth model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad(pop, t, system):\n",
+    "    \"\"\"Compute the population next year with a quadratic model.\n",
+    "    \n",
+    "    pop: current population\n",
+    "    t: current year\n",
+    "    system: system object containing parameters of the model\n",
+    "    \n",
+    "    returns: population next year\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha * pop + system.beta * pop**2\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's a `System` object with the parameters `alpha` and `beta`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here are the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap03-fig04.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "plot_results(census, un, results, 'Quadratic model')\n",
+    "savefig('figs/chap03-fig04.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  Can you find values for the parameters that make the model fit better?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Equilibrium\n",
+    "\n",
+    "To understand the quadratic model better, let's plot net growth as a function of population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pop_array = linspace(0, 15, 100)\n",
+    "net_growth_array = system.alpha * pop_array + system.beta * pop_array**2\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap03-fig05.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set_style('whitegrid')\n",
+    "\n",
+    "plot(pop_array, net_growth_array)\n",
+    "decorate(xlabel='Population (billions)',\n",
+    "         ylabel='Net growth (billions)')\n",
+    "savefig('figs/chap03-fig05.pdf')\n",
+    "\n",
+    "sns.set_style('white')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's what it looks like.  Remember that the x axis is population now, not time."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It looks like the growth rate passes through 0 when the population is a little less than 14 billion.\n",
+    "\n",
+    "In the book we found that the net growth is 0 when the population is $-\\alpha/\\beta$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.88888888888889"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "-system.alpha / system.beta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is the equilibrium the population tends toward."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`sns` is a library called Seaborn which provides functions that control the appearance of plots.  In this case I want a grid to make it easier to estimate the population where the growth rate crosses through 0."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dysfunctions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When people first learn about functions, there are a few things they often find confusing.  In this section I present and explain some common problems with functions.\n",
+    "\n",
+    "As an example, suppose you want a function that takes a `System` object, with variables `alpha` and `beta`, as a parameter and computes the carrying capacity, `-alpha/beta`.  Here's a good solution:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's see all the ways that can go wrong.\n",
+    "\n",
+    "**Dysfunction #1:** Not using parameters.  In the following version, the function doesn't take any parameters; when `sys1` appears inside the function, it refers to the object we created outside the function.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity():\n",
+    "    K = -sys1.alpha / sys1.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity()\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This version actually works, but it is not as versatile as it could be.  If there are several `System` objects, this function can only work with one of them, and only if it is named `system`.\n",
+    "\n",
+    "**Dysfunction #2:** Clobbering the parameters.  When people first learn about parameters, they often write functions like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    system = System(alpha=0.025, beta=-0.0018)\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, we have a `System` object named `sys1` that gets passed as an argument to `carrying_capacity`.  But when the function runs, it ignores the argument and immediately replaces it with a new `System` object.  As a result, this function always returns the same value, no matter what argument is passed.\n",
+    "\n",
+    "When you write a function, you generally don't know what the values of the parameters will be.  Your job is to write a function that works for any valid values.  If you assign your own values to the parameters, you defeat the whole purpose of functions.\n",
+    "\n",
+    "\n",
+    "**Dysfunction #3:** No return value.  Here's a version that computes the value of `K` but doesn't return it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    \n",
+    "sys1 = System(alpha=0.025, beta=-0.0018)\n",
+    "pop = carrying_capacity(sys1)\n",
+    "print(pop)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A function that doesn't have a return statement always returns a special value called `None`, so in this example the value of `pop` is `None`.  If you are debugging a program and find that the value of a variable is `None` when it shouldn't be, a function without a return statement is a likely cause.\n",
+    "\n",
+    "**Dysfunction #4:** Ignoring the return value.  Finally, here's a version where the function is correct, but the way it's used is not."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.88888888888889"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def carrying_capacity(system):\n",
+    "    K = -system.alpha / system.beta\n",
+    "    return K\n",
+    "    \n",
+    "sys2 = System(alpha=0.025, beta=-0.0018)\n",
+    "carrying_capacity(sys2)\n",
+    "\n",
+    "# print(K)     This line won't work because K only exists inside the function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, `carrying_capacity` runs and returns `K`, but the return value is dropped.\n",
+    "\n",
+    "When you call a function that returns a value, you should do something with the result.  Often you assign it to a variable, as in the previous examples, but you can also use it as part of an expression.\n",
+    "\n",
+    "For example, you could eliminate the temporary variable `pop` like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "13.88888888888889\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(carrying_capacity(sys1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or if you had more than one system, you could compute the total carrying capacity like this:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "27.77777777777778"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "total = carrying_capacity(sys1) + carrying_capacity(sys2)\n",
+    "total"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Exercise:** In the book, I present a different way to parameterize the quadratic model:\n",
+    "\n",
+    "$ \\Delta p = r p (1 - p / K) $\n",
+    "\n",
+    "where $r=\\alpha$ and $K=-\\alpha/\\beta$.  Write a version of `update_func` that implements this version of the model.  Test it by computing the values of `r` and `K` that correspond to `alpha=0.025, beta=-0.0018`, and confirm that you get the same results. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad2(pop, system):\n",
+    "    r = system.alpha\n",
+    "    k = -(system.alpha/system.beta)\n",
+    "    net_growth = r*pop*(1 - pop/k)\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = census[t_0]\n",
+    "\n",
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'numpy.float64' object is not callable",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-43-6995dac8fde2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrun_simulation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msystem\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate_func_quad2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mp_0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msystem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mplot_results\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcensus\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mun\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Quadratic model'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0msavefig\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'figs/chap07-fig05.pdf'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32m<ipython-input-6-34aa70955afe>\u001b[0m in \u001b[0;36mrun_simulation\u001b[1;34m(system, update_func)\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mlinrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msystem\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt_0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msystem\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt_end\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m         \u001b[0mresults\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mupdate_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresults\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msystem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mTypeError\u001b[0m: 'numpy.float64' object is not callable"
+     ]
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad2(p_0,system))\n",
+    "plot_results(census, un, results, 'Quadratic model')\n",
+    "savefig('figs/chap07-fig05.pdf')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap07.ipynb b/code/chap07.ipynb
index 5beafe79..dd13aadc 100644
--- a/code/chap07.ipynb
+++ b/code/chap07.ipynb
@@ -526,7 +526,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap08-MINE.ipynb b/code/chap08-MINE.ipynb
new file mode 100644
index 00000000..05dfbcbd
--- /dev/null
+++ b/code/chap08-MINE.ipynb
@@ -0,0 +1,720 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 8\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *\n",
+    "\n",
+    "from pandas import read_html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Functions from the previous chapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    results[system.t_0] = system.p_0\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        results[t+1] = update_func(results[t], t, system)\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Reading the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'table2' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-1-e371cf8c64a3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mun\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtable2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mun\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m1e9\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mcensus\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtable2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcensus\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m1e9\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcensus\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m':'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'US Census'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mun\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'--'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'UN DESA'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'table2' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "census = table2.census / 1e9\n",
+    "plot(census, ':', label='US Census')\n",
+    "plot(un, '--', label='UN DESA')\n",
+    "    \n",
+    "decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title='Estimated world population')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Running the quadratic model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's the update function for the quadratic growth model with parameters `alpha` and `beta`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func_quad(pop, t, system):\n",
+    "    \"\"\"Update population based on a quadratic model.\n",
+    "    \n",
+    "    pop: current population in billions\n",
+    "    t: what year it is\n",
+    "    system: system object with model parameters\n",
+    "    \"\"\"\n",
+    "    net_growth = system.alpha * pop + system.beta * pop**2\n",
+    "    return pop + net_growth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Extract the starting time and population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.557628654"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_0 = get_first_label(census)\n",
+    "t_end = get_last_label(census)\n",
+    "p_0 = get_first_value(census)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initialize the system object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>1950.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>p_0</th>\n",
+       "      <td>2.557629</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>alpha</th>\n",
+       "      <td>0.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>beta</th>\n",
+       "      <td>-0.001800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "t_0      1950.000000\n",
+       "t_end    2016.000000\n",
+       "p_0         2.557629\n",
+       "alpha       0.025000\n",
+       "beta       -0.001800\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=t_end,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the model and plot results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl81dWZ+PHPXbPvOwkkBMghAYLsILhT60LV2to61VJbF35qrV2sU2u1OrUzVWvr1N3WqtNpRxhH26m1raN1wQ1QEUiAkw1CQhKykT13//7++N6EJIRwgex53q9XXtz7XZ8Ech/O+Z5zHothGAghhBDjjXWsAxBCCCEGIwlKCCHEuCQJSgghxLgkCUoIIcS4JAlKCCHEuCQJSgghxLgkCUoIIcS4ZB/rAIQ4FUqpOOCfgSuALOAQ8L/Av2mta0fwvtFAO3CO1vqtk7xGIZCktX4z+N4APqe1fmXYAh0mSqmPgFe01veEcOxzQLTW+osjHZeY3KQFJSYspVQK8CFwNnAzMBf4evDPj5RSc8YuupD8CZjX530G8H9jFIsQ4460oMRE9kvMVszZWmtPcFulUuod4K/AM8CZYxVcCCx932it68YqECHGI0lQYkJSSiUCXwK+2Cc5AaC19iulfgy8r5Sap7UuVkrtB36utX40eH4OsA9YoLUuUkqlAb8AzgfigCrMbsLfBI+PBH6F2ZXYDvxoQDz7gU3AlZiJpxCYDfwMWIH5u7YT+LbW+n2l1FtANvCIUuqLWuuz+3bxKaUigH8F/gmIAN4CbtJaHxzkZ/Ec0AZEA18GDgPfBXzAg0Aq8ArwtZ6flVLqK8APgDnAAeBftdbP97nm94DvALHB77tfMlVKrQ/+DLKAvcBdWuu/DIxNiFMhXXxioloCOID3jrH/Q6AbOD3E6/0H5gf5eUAB5nOsJ5RS6cH9jwNnABcBX8D88B7oeuCLwOcBL2Yr7lNgIbASM7E9FTz2cqAa+GHw9UBPApcCVwfPDQc2DhH/BqAcWAD8HbP1+H3MhHpln2uhlLoKeBZ4AjORPgL8Wil1cXD/NcC9wG3Be88CFvfcSCn1WcykdXfwfk8BLyqlVg0RnxAnTFpQYqJKDv7ZPthOrbWhlDrc57jj+QvmIIAKAKXUfcC3gTlKqS7gK8DntdbvBfdvAD4YcI2NWuutwf2pwAPAL7TWvuC2xzFbWWitm5VSfqBda93c9yLBgR9fwWwdvh7c9v+ADUop58AWY1CZ1vqnwWOfAr6B2ar5JLhtK0eed30H+LXW+ong+1Kl1DzMZPkX4EbgCa31C8Fzr8VsWfb4IfBgz36gXCm1BPgeZoIWYlhIghITVVPwzyygYuBOpZQFs6uuNcTrPQFcoZT6LpAHLAputwEKs7X2SZ/jPwICA65R3vNCa12vlPoNcLNSamGfa4bSa5GH+bu5rc/19mF2yR1LWZ/XXcE/+/5cXEBY8PU8zOd3fb2L2Z0IMB94uM+9u5RSxX2OnQesUErd0WebAygZIj4hTpgkKDFRfYzZjbaMQRIUZpdUFLA1+H5gXZnef/vBZPZ3YBrwAvAGUAzoAef0fQ7jD3711d3nmhnBGPdgdvX9AbML8fdDf1sA9LSQTqQWjneQbQMTaI/uQbZZOJI8DQY8c+oTE5g/uzuAP4cQgxAnTZ5BiQlJa92E2V32Y6VUGIBSao1SapdS6nPAT4BPtNYfBU/xYLaoeuT2eV0AnANcpLW+R2v9MhAf3GfBHATgwRzs0GMBZqvhWC4PnrNWa/3zYFddVjDOng//YyWgCszk1/e5T7ZSqlkplTnEPUO1Bxj4vOh0zO8TYBd9vlellBOzVdX3/GytdVnPF+aAlX9CiGEkLSgxkX0beAd4Uyl1D+aovE8xBzhA/w/hbZjPcF4FnMB9HEkQLZgJ4Uql1O8xu9h+FdwXprVuD3bX/SL4XKsNc9DEUC2cJiANuFgpVYQ5V6tn5F8YZpdbB5CvlErVWtf3nDjgfu1AI/AQsHOwUXwn4WeYgxqKgdcxB4Zci/ncCszRjP+hlPoEc7DJ94GUPuc/APyXUmov5rytczEHVXx1GGITope0oMSEpbVuxExCbwGPYf7P/1zgd8BLwEal1CXBw+/EfEbyAeaIvXsIdoEFP/RvCH7txUxOj2MOC18SPP87mInvJczuwOfp3+010Cbg18BzwetswBzlZ/S55r9jfqj/fZDzvwe8CbwMvI85GOTLQ/5AQqS1/jNwE+ZQ9CLgFuB6rfXvg/v/G7gVM+l8gvlz+kef818OnvNdYDdmArupz6AJIYaFRUq+i8lKKXUB4NVavzHWsQghTpwkKCGEEOOSdPEJIYQYlybEIIngKK1lQC1HD+0VQggx/tkwF0TeprV2h3LChEhQmMlp81gHIYQQ4pSdgTkx/LgmSoKqBfj9739Penr68Y4VQggxztTV1XHVVVdB8PM8FBMlQfkB0tPTycrKGutYhBBCnLyQH9PIIAkhhBDjkiQoIYQQ45IkKCGEEOOSJCghhBDj0kQZJDGkQCBAdXU1nZ2dYx2KOAkOh4PU1FRiY2PHOhQhxDgyKRJUY2MjFosFpRRWqzQKJxLDMOju7ubgQXORbklSQowvbreb2tpaoqOjSU4OtUD18JgUCaqlpYWcnBxJThOQxWIhMjKSzMxMampqJEEJMU4YhkFNTQ1FRUV4PObC/eeddx6RkZGjFsOkSFB+vx+HY6jacWK8i4iIwOuVgqxCjAcul4udO3dy6NCh3m02mw2LZWCh5ZE1KRIUMOo/ODG85O9PiLFnGAZVVVUUFxfj8/l6t0dERLBw4UIiIiJGNZ5Jk6CEEEKcvK6uLnbu3ElDQ0O/7Tk5OeTn52O3j366kIc2o0wpxZ49e47afumll/LSSy/1vv/zn//MpZdeyqJFi1i2bBnXX389xcXFQ1578+bNXHPNNaxYsYLly5fz1a9+la1btw779yCEmDwMw2Dfvn289dZb/ZJTVFQUp59+OgsWLBiT5ASSoMalrVu3ct9993H33Xfz8ccfs3nzZhYvXszXvvY1mpubBz3nxRdf5Pbbb+fqq69m8+bNvPvuu1xyySXccMMNfPTRR6P8HQghJoKOjg7ef/99ioqK8PvNJfIsFguzZs3irLPOIikpiS6XF69vbKocSYIah3bs2EFOTg5LlizBarUSHh7OjTfeyMUXXzxoguru7uZnP/sZP/nJT1i7di1OpxOn08kVV1zBhg0b2LdvH2AOJnnyySc577zzWLFiBbfeemvv9bZs2cLFF1/MAw88wIoVKzjzzDN55JFHeu/xP//zP6xdu5Zly5bxhS98gXfeeaf3vKVLl/aL59xzz+X1118f8jwhxNgxDIPy8nLeeeedfp8pMTExrFmzhoKCAmw2G0Xljfz+b3vZtvvQEFcbOZP2GdTW4jq27q4DYHlBOsvn9S/T8e6Og3xaYjZnVxdOY5FK7bf/zY+rKK5oAuCcJdOZl5vUb//fP6yktOrwoNc+VWeffTaPP/4469evZ+3atSxZsoS5c+dy7733Dnr89u3b8Xg8nHXWWUftu/HGG3tf/8d//Af/+7//y7PPPktqair3338/3/nOd3j++ecBKCsrY+3atbz77rts2bKF6667josuuoiEhATuuusu/vSnPzFnzhz++7//m/vuu4+///3vQ34fzc3NxzxPBkUIMTba2trYsWMHLS0tAPjaGrFHxJA3bwFz5szpN13H5fHj9vr5tLSB/JmJJMSEj2qs0oIah+bMmcMf//hH5s6dy8aNG7n88stZvXo1TzzxBIZhHHV8c3MzcXFxxx1qv2nTJr75zW8yY8YMwsPD+f73v8+2bdvYv38/YDbtb7rpJhwOB2vWrCElJYXKykqcTid2u50XX3yRXbt2cfnll4eUZE72PCHE8AsEApSUlLB582YzOQUCeBqrCO9uYmFkB3NmzjhqLumivBTiosOIjXTi9ox+N58kqFHmdDr7Dd/s4ff7CQsL632fnZ3ND3/4Q/7yl7/wwQcf8O1vf5unn36ajRs3HnVuSkoKLS0tg84jam9v751kV1NTw5133snSpUtZunQpZ555Jna7vXcVh+jo6H4xOBwOAoEA0dHRPP/881RWVrJ+/XrWrFnDU089NWiy7OtkzxNCDK+WlhY2b96M1ppAIECgqw3voXKyw7wszogi3N9N8bubcXv7JyGbzcq6NTP5p/MV6UlRox73pO3iWz5v6K63NQszWbMw85j7z1kynXOWTD/m/s+uzOazK7NPOK709HRqampYsGBB7zafz0dNTU1vteCvfOUrnH/++VxzzTUAJCYmcuWVV7Jr1y601kddc9GiRYSHh/P222+zdu3afvsefPBBKisref7550lNTeXuu+/mjDPO6N1fUlJCTk4O27dvP2bMra2tvc+vvF4v7733HrfccgtLly7FZrP1S4yGYdDa2nrc8wY+txJCDD+/309paSllZWUYhoHh8+A9XEe04UKlhhPltNHZ7aXYnc6+zhTadh9i9cJp/a4x2t16fUkLapRdfPHFPProo5SXlwPm/2weeOABUlJSKCwsBODCCy/kySef5PXXX8fj8eDxeNiyZQtvv/0255133lHXdDqd3Hbbbdx999288cYb+Hw+urq6ePbZZ/njH//IzTffDMBll13GY489Rm1tLX6/n6effpqrrroKl8s1ZMzNzc1ce+21bN26FYfDQVpaGhaLhbi4OGbMmIHH4+HVV1/F7/fz/PPP9y7aO9R5QoiRdfjwYd555x1KS0sxjAC+tkZ8hyrIjfSxKD2SKKcNa1gEnllnss8xBywWdpQ2cLh96M+D0TRpW1Dj1c0334zNZmPDhg00NTURFhbGypUree6553qfIX31q18lPDycxx9/nNtvvx3DMJg1axZ33303a9asGfS6X/7yl4mJieGpp57ijjvuwDAMCgoKeOaZZ1i2bBkAN9xwAz6fj6uuuoqWlhby8vJ45plnjrv+3cyZM7n33nu56667qK+vJyEhgR/96EfMmTMHgB/96Ec8+OCD/PjHP+bSSy9l8eLFIZ0nhBh+fr+fvXv3sm/fPgzDIODuwttcS5zdj8qIIsJhBSxEZM8jMm8ZiXYnRYfLaWrrZuW8DOKiwo57j9FimQjPA5RSOcC+N954g6ysrKP279mzh/z8/FGPSwwv+XsU4tQ0NTWxY8eOI6WHjAC+2jJy4x1kRDlo7fQQnZJO8uJzcMQfGbnc2uHG6bARETZybZbq6uqeHqCZWuv9oZwjLSghhJjgfD4fu3fvprKyst/21LR05uRn01X8Lvvqu6iw5RIfVsiF8f2n1cRFj59WU1+SoIQQYgKrr69n586ddHd3Q8APVhsOh4N58+b19jh1tbaz3eXAZwunqaadqkPtTE+LGePIj2/UEpRS6irgqQGbI4A3tNbnj1YcQggxGXi9XoqLi6mqqgLDwNfWgK+9mekFSzhtxemEhx8ZfZe19AxmBw5QUnWYhXNSSEscvZpOp2LUEpTW+vfA73veK6UWAa8B3x+tGIQQYjKoq6tj586duN1uAq4OvM112A0fBcnhxLhqae3yET5gdPjphRksmZtKQuzYDRs/UWPSxaeUcmAmq3u01jvGIgYhhJho3G43xcXF5uR6vw9vyyH8XW2kRtnJiYvgcEs3Rc2tdBrlfOH8QqzWI6u2RIY7iAyfWIVdQ0pQSikbsARYCqQCfqAO2Ka1/vQk7nsz0A08fhLnCiHElGIYBrW1tRQVFeF2u/F3NONtacBpNZibEkFKlAMvdvbac2iMzIR2gz37m49aQ3SiGTJBKaUSgG8BNwJJQAXQBNiAZCBbKVULPAk8prVuOd4NlVJOzG69/6e1Hv9j3IUQYgy5XC6Kioqora3F8LjwHq4l4HGRHu1gVkI4DpuF8Mw8kuauIre8lcbiOmZlxk2IQRDHc8wEpZRaD/wL8AZwLfC61to94JhY4AzgKqBIKXWn1vr549zzAiAA/OVUAhdCiMnMMAyqq6spLi7G6/Xi7ziM93AdYTYLMxPDiHFYCY+NJ3reGTiTzdF6i1UYGUlRkyI5wdAtqGXAMq11w7EO0Fq3YSaavyilMoA7geMlqEuBTVrrwIkGK4QQU0F3dzc7d+6kvr6+d5s1LIr0aAdxBGhq6mJfguKCVetwOp29x9ht1kmTnGCItfi01rcMlZwGOb5Wa/3NEA5dCbwX6nUnm1BKvj/yyCMUFhZSVlbW75jBigP2eOmll8jPz2fRokUsWrSIhQsXcuGFF/LMM8/0Wz383HPPpbCwsPe4nq/PfvazvcdUVlZy8803s2zZMhYtWsS6dev4z//8z0Hve9FFF3HmmWcOupK6EOLEGIZBZWUlb731Vr/kFBkZyelnnkXh0pXU+WIpSTyTA45cPtZNYxjtyAt5FJ9SKhUoBBxAv4I+WutXT+CeOUDNCRw/Jbndbm677TY2bdrU739IQ8nLy+NPf/oTYP5D3759O7fddhttbW185zvf6T3uF7/4xVGrnvcIBAJcf/31rFu3jp///OeEh4fz6aefcvPNN+N0OvnSl77Ue2zPIrApKSm89tprXHzxxafwHQsxtXV1dbFjxw4aGxvwtTVhsVixxyaRk5PD3LlzsdvtGIkJzIjMo2RbFWmJkcycNvQ6mhNdqKP4rsUccTfYGEUDc9BESLTWo19UZAJatWoVNTU1PPzww9x+++0nfL7FYmHx4sXcd9993HDDDVx77bXHXRQWzBWQKysrWbduHREREYBZzuP222/vrSvVY+PGjXzmM58hKSmJ3/3ud5KghDgJhmGwb98+9u7di7ezDe/hOgyfB4fVQsrsxcyfP7/3WIvVhspOxOmwM3Na7KQv/hlqC+r7wK+BO7TW7SMYz7DpLNlGV9nHIR0bPj2fmAX9y6W373obV9XRXXEDRc5eQlTespOKccjrRkbywAMPcPXVV3PWWWexYsWKk7rOqlWrsFqtbN++fdCS8AMlJSWxfPlyvv71r3PJJZf0dvNddtll/Y5rbm7mjTfe4K9//SsxMTE88MAD7Nq1q1+dKyHE0Do6OtixYwfNjfV4D5tzmgzDIIoAEV4/B4uL6JiviI480otisVjIzZwaJWtCrQc1Hfj3iZKcJovTTjuNDRs28IMf/IC2traTukZP/aWOjo7ebbfddltv0cCer0cffbR3/zPPPMP111/Pzp07ueWWW1i5ciU33XQTdXV1vce8/PLLrFq1ioyMDKKjo7nkkkuO+ZxKCNGfYRiUlZXx9ttv03CgHFdNOf6uNqIcVhZnRJMQ5qAudj41UXPZurvu+BecpEJtQb0GnAeUjmAsU0KoJd973HTTTbz77rvce++9/Z7/hMrv99PW1kZGRkbvtp///OfHfAbVE+PVV1/N1Vdfjcfj4eOPP+bhhx/m1ltvZePGjRiGwaZNm6ivr2f16tWA+czM7XZz++23k5Q0sScHCjGS2trazFZTfR2+5loCXhcWIDs+jBlxTiKmzSFiRSHbP6hlTlY8i1XaWIc8ZkJNUDuAXyilLgFKgH4PI7TWJ/6QZIRF5S07pa63mAVnHdXtNxxCKfnel81m48EHH+TSSy8lMvLEF3jcunUrhmGQl5cX0vEbN27khRde4OWXXwbMZLVq1SocDgfXXXcdAB9++CEtLS387W9/w2o90gjfsGEDL7zwQm8FXyHEEYFAgLKyMkr0XjyHD+HvOEwgYOCwGCzKjCEuPpHo+eacpljg6gvixm0ZjNESahffWcAWzNXHFxKcIxX8GnzcsxhUKCXfB5oxYwY//OEP2bRpU8j3CQQCbN26lbvuuosNGzYQHR0d0nlnnXUWBw4c4P7776epqQnDMKiqquLZZ5/tLTe/ceNGLrjgAtLS0khJSen9+vznP88LL7wgQ86FGKClpYXNmzejtcYwINDdgdvjw+H1EG8EcM44jYQzruidcAvjt0bTaAqpBaW1PmekA5kqQin5PpgrrriCt99+mw8//PCYx5SUlLBo0SIA7HY7mZmZXHfddVx55ZX9jvvud7+LzXb0wMu//e1vpKen84c//IFHHnmEdevW0d3dTUJCAhdccAHf+ta3aGpq4vXXX+e555476vx169Zx//338/e//51169aF+BMRYvLy+/2UlJRQXl5+ZD6ixUJKTh72A0U0G8mUxcyj6XAKX7SGPBh6ygi55LtSKg34JjAPs+W1B/i11rpi5MLrvXcOUvJ90pO/RzGZNDc38+n2T2irr8EWnQCYXfZz585l5syZHK6pYuMHzSTFR3LW4qwJU6PpZI1YyXel1HLg/4Aq4H3MibrrgFuUUmdrrT86qYiFEGKS8fl87Nmzh4rdO/G2HCLg8+J2+ZmlFAsXLiQqypwKmpg5gy+cm0xyfES/shjiiFAHSTwE/BdwY98VyJVSjwIPAtIFKISY8hoaGvj0oy201ewn4O7C4/XjdvuI9daTknFxb3LqkTrJW02nKtQEtRS4bpDyGI8Aoc2GFUKIScrr9VK0ayf7i7fja2/u3R5phYTIcJri5vFeUT0505Nw2OVZU6hCTVC1mGvo6QHbcwGZvCuEmLLq6ur49IN36KivxvCbcxztVguzk8LJVAv5U0UMAauD0+dPw24LdeC0gNAT1O+Ap5VS3wZ6hpGtAn4Z3CeEEFOKx+Nh50dbqNyzg4CrC4/Pj9NuJTnKQcHsmSQtPAt7TCIXZnYSHxNGuDPktblFUKg/sZ8C04BNmCP4LIAXs4vvzpEJTQghxp++5dc7avfj7eqgy+XDCATIyUhgydoLCcuY1buQa3qSrI99skKdB+UBrldK3QYooBso01p3j2RwQggxnrhcLnbt2tW7LqUjPpXOlsNEWMCWlMvuqAIWJmQTPslXGR8tQ5V8vwj4P621N/h6oOlKKeCE60EJIcSEYhgG+/bsQO+rxhc4MlYsIiqahWs/w9YKH/WeME6bk0KYQ54zDZehWlCvAOlAffD1sZxQPSghhJhIOlqa+Pgfr1JfV4vPGUNESiY2q4Xs7GwKCgqw2+2EZ3ThcFhJiAkf63AnlWMmKK21dbDXYnx65JFH2LNnD48//viQx/XM5t62bVtIBQyFmKoCfh8lW99i984deL0+utw+vG0NuB0JrLt4LcnJyb3HynymkSHDSoQQYoDmyr18/M4btLR3AuD3B/B6/YRFJuAKm45hk4EPo2GoZ1ANmN13x6W1Th22iCa56upqLrvsMm699VaefPJJvF4vt9xyC1arlSeffBKPx8ONN97INddcw/vvv89DDz3Evn37yMzM5Oabb+aCCy7ovc6dd97Jzp07yc3NJTc3t999Nm3axDPPPENzczOFhYXcc889TJ8+fSy+ZSEmDG/7YYo3/43yyir6PGoiIS6aqOwCqrxJzM1OIDJc/m8/Gob6KX+fEBPUeFNeXk5JScmghQGHm91uJy8vj1mzZoV8Tnt7O0VFRbz55pu8/vrr3HbbbVx66aW88cYbbN68mVtuuYUFCxawYcMG7r//fs4//3y2bdvGTTfdREpKCkuWLOHWW2+loKCAX//612itufbaa1m61Kx88tprr/GrX/2Kp556ijlz5vDss89y/fXX88orQz1KFGLqMnxe6na+x47tn3C4y4PFYsFmtWCxWsnLn8+81efR3h3A5fHJsPFRNNQzqOdGMY5hVVFRMSrJCcyFISsqKk4oQYFZKbenGKDf72f9+vU4nU7OOecc/H4/v/3tb1mxYgUXXWQOoFy1ahWf+9znePnll0lNTaWoqIjf/OY3OJ1OFixYwKWXXsrBgwcBs/W0fv165s2bB8ANN9zA7373O7Zs2UJ2dvbw/gCEmOD8fj+7t73Hnk+20O3y4fb6sdutzMieztKzLyA+xaxoGx8DIDWaRtNQXXwhV8fTWp94LfIRlJubO6otqIHda6GIj48H6K3LFBMTA9BbodblcpGZmdnvnKysLLZs2UJDQwNhYWEkJCT029eToGpqanj88cd5+umne/d7vV5qamokQQnRR3NzMzt27KCjowPDHoHb24LfFoY3bg65p59LfEr8WIc4pQ3Vxdc5alEMs1mzZp1wi2a0WY4zkW/p0qV89FH/KiZVVVUkJyeTlpaG2+2mqamJpKQkAA4dOtR7XGpqKuvXr+9XqLC8vJxp06bR1NQ0jN+FEBNPwNWJp6ud0oMN7N+/v3d7RMo0/OFJNDpmkTsjlYRYGTI+1obq4vv6aAYi+luzZg1PPvkkr776Kp/97GfZunUrf/7zn3n00UfJzMxk+fLl3H///dx7771UVlby0ksvsXjxYgAuu+wynnjiCZYtW0Zubi6vvPIKd9xxB6+88gp2uzzcFVOTEfDTvW8nVTu3sKfJjSduBhHBwQ52u52CwkJS0qbRcLib7AyZgjEeDNXF9wBwr9a6M/j6WAyt9T8Pf2hTm91u5/HHH+ehhx7izjvvJC0tjXvvvZc1a9YA8Mtf/pI777yT008/nWnTprF27Vqam81l/i+77DLa2tq46aabqK+vZ8aMGTz22GPk5ORQXV09lt+WEKPOMAw89ZW0FL3L3qp69je7cHt8eDtrmJ47g/S0NBYsWEBERAQA2RmOMY5Y9Bjqv9PLAEef18cyIUf6jZWsrCy0PlK1JDY2tt97oN/71atXD3qd5ORknnrqqWPeZ/369axfv/649xdiMvO1N9Ox+z0OHthPaZMLtz+Ax+vHb3HgNpzEJs9k2bJ5x+1yF2NjqC6+cwZ7LYQQ413A46Kr9CNaKnZR2tRNY5c5YMpqs+NMTKQ1kMKMmXkUzM2R5DSOhfxAQikVBVwJzAM8QDGwMbjSuRBCjDnDCOCqLKajZBsHGtsob3ZhCY6MtUcnEJU2ndULFtIdiCA3M06S0zgXUoJSSi0A3sJMTDsxa0J9HfgXpdSFWuu9IV4nA3gCOAdwAU9rre86ibiFEOIoAVcXh3a+y/YDrTR2egAL8UkJhCWmkzM7r3dxVzExhLoI7K+BPwIztNaf1Vp/BrME/PvAsR+EHO1PmOXj04CVwNeUUl85gfOFEGJQgUCAfQfr+LQ9nKYuLz7stDmS6YqazuqzzqGwsFCS0wQT6t/WQmC91trbs0Fr3a2U+gmwPZQLKKVWALnA6uB19imlzsYsfnjKDMOQ5vqb25OoAAAgAElEQVQEFggExjoEMcEEvG58h+twpmbT2trKjh07aG1txRaTSESyn6Z2O4lp0zn37KUkJcWNdbjiJISaoD4BzgBKBmxfCuwO8RpLgF3APUqpazC7+B7XWj8U4vnHFB4e3jtpVZLUxGIYBl6vl0OHDhEVJWucieMzjADu6hI69RZcXV2URM+ns6sVwwgOKLZYmT47jwWpM5mfl4XVKp8JE9VQ86Bu6vN2K/CoUmop8CHgBwqBG4H7Q7xXImaSexuzJTUX+JtSqlZr/YeTiL1XVlYW1dXVNDQ0nMplxBix2+3ExcX1q68jxGC8zbV07H4Pb2sj+xs72V3fRScfkj4rD6fDis1m6128Wf6zOvEdbzXzvuqAC4JfPRqBbwD3hXAvN9Cmtb4n+H6HUuo3wOXAKSUoh8PBzJkzT+USQohxzN/dTufeLbhry/D6DcqbXZTUd+MNWHE7oqhr6mTx/JkUFhZKS3wSGWoe1HB/4u8FIpVSzj5D0+WJpRDimAy/j66KT+ku307A76Oxy0dpswtPAKKT09jfZscZFsaSJaexYlG+tJommaG6+L6mtX4+1AsppSzA17XWvz3GIf8HNAAPKaW+ByjgWsxuQiGE6GUYBp5D++jc8wHezjYa213Uuw0au3zYImMJi0vFYndw2ox41qxcQlSUlFyfjIZqwSwKJpIngZe11rWDHaSUSgW+AtwAvH6si2mtXUqps4BHMIeau4AHtNb/c7LBCyEmK4Ou0o9prm9kb10HdS4/UbExRKZmYw2LJDw8nPnz55ORkTHWgYoRNFQX37eDgyLuBh5WSu3GXD2iEbAAKZjDz/OAvwLXaK23DnUzrXUFcPEwxS6EmKQsFivkLOKTT0o57DLosifSQRyzwiLJzs4mPz8fh0MWdZ3shnwGpLX+CLhEKTUTuBBzWPlsIIA5aOJXwKta6wMjHagQYnLqWW3cmZqNxWIhEAhQWlpKWVkZtuQs2pr8WKw2ZqQnsWrVchntOYWENEhBa70PeHyEYxFCTDG+tiY6ijfjba6jM2sFMVkz2LVrF+3t7QA4YxOY4fRRkJ9HQf7c3grUYmqQUXRCiFEX8LrpKv2I7v1FuD0+qhvaqdB/w5+WS3zskQEPCQkJnFVYSGysFBCciiRBCSFGjWEYuGvL6dzzHgG3ucrZ/sYudLOXTlsMnuZuYqIjCHM6mDt3Ljk5Ug5jKpMEJYQYFb6OFrM7r+kgAG5fgNJmF02WCNoiE/EYdhJjw0lLTeW00xb2VrgVU5ckKCHEiDL8PrrKPqG74lPcHi92m4XaDh/72v1YY9MIi4wlw+UlMiKcpYtPIyMjQ1pNAjixgoWLMBd8dWAOM++ltZYBFEKIQXWVfkxn+Sc0tHRzsKmLdqsda1wy9rQUsJgVfwrUbBk6Lo4SasHCO4GfAM1A+4DdBjLCTwhxDBG5C6kq2s6eQ53U+5x0OROZGW0mp+joaAoLC0lKShrrMMU4FGoL6jrgLq31T0cyGCHExGYYBvh9WOxHWkLNbR0ccKZQ7zBos0UQEWZ+7OTl5TF79mwZOi6OKdQElQRsGslAhBATm6+9mY5db2OJiiei4EyMgI/du3dTXV0NFicpGelEuX3Myp7GwoWFxMTEjHXIYpwLNUG9CFwF3DNyoQghJqKeQRBdFdvp6vZwsH4vjft9hIUH8Hg8vcfFREewfFk+M2bMkEEQIiShJqhu4A6l1BVAKeDpu1Nr/aXhDkwIMf55mmro2PU2/q5WXG4furqVQ26Dxk7NtBmZRIabHzHTpk1j3rx5hIeHj3HEYiIJNUFFcopFBYUQk0fA66Zz7we4qvaa7w2Dum4/BwMRNDpiMWxOvD4/kZGxLFiwgNTU1DGOWExEoa7F9/WRDkQIMTG4D+2no3gzge5OsECLy0dJswdvVDJx2XG4mrtIT4pC5c0mLy8Pu12mW4qTcyLzoBYAtwPzACtmhdxfaa3fH6HYhBDjiOH30r7zLVw15TS2dNPe7cHjcNIQCMeePBObzY4NmJ+XRWFhIXFxcWMdspjgrKEcpJS6EPgEczTfi8B/AzHA20qp80cuPCHEuGG143d1UV59mNL6TnY2+6gMJOBIzsJis2O325k/fz5r1qyR5CSGRagtqJ8C92mt7+27USn1I8wJvK8Nd2BCiPHFYrFgnbWMmo/3UuNz0hWWQJTPQRyQkZHB/PnzZRCEGFahJqh8YLCRei8APxy+cIQQ40FvEcGU6VisNvx+P2VlZZSVlWHPnI2vrou0mHAy0xIoLFxAWlraWIcsJqFQE9QBYBFQNmD7EqB+WCMSQoypgLuLjqJ36DhYQXX4bLIXLqS4uJjOzk4ArHYnc6aHkZubK4MgxIgK9V/WY8CTSqks4MPgtlXAncADIxGYEGL0uWsr6Ch6m6amVqobO6lzbaX4YD3JyUeeKSUkJFAoRQTFKAh1mPmvlFIxwB1AcnBzDfBjrfWjIxWcEGJ0BLxuOorfxV1TimEY1HX6qOj0022LxtXuJT4hQER4GHPnziU7O1tWghCjIuS2eXCh2J8qpVKBbq31wFXNhRATkKehivZdbxFwddLu9lPS5KLdb8UVnYHPGs6M5GhysmdQUFBAWFjYWIcrppBjJiil1E3Ab7XWruDrgft7X0s9KCEmHsPnpVN/SEvpDrBaOdDq4WC7B1tUHOEp6WQGIDY2moULF5KcnHz8CwoxzIZqQX0f2Ai4gq+PRepBCTHB+Dtbadn2KnXVtVQ0dtFmWAmLCMOZnIU1Igar1cq8OXOYNWuWlMMQY+aYCUprPXOw1wMppaQzWogJxhoexaGWbrbXdtLlN/DYwkiKm05YRAQpKSksWLCAqKiosQ5TTHGhVtStAJZqrZsHbJ8GfArISpBCTBDmnKZyyo1YvNZDdNpisUbGER0Tw5LFC8nIyJBBEGJcGOoZ1CXAmuDbHOBflFJdAw6bPUJxCSGGiWEYeBursCVm0dTUyK5du+jq6gJ7GPG5c7F2+Vi0YC4FBfkyp0mMK0P9a9wBfBvo+a/UIvrXgTKADuBrIxOaEOJUBdxdtH76JhV79rLbSCc+uf/cpeTkZM6VhV3FODXUM6hK4FwApdSzwK1a67bRCkwIcWrch/bTsuNNtu6tpa7bR4B9YJ9FfHw0DoeD/HypbivGt5DrQSml7EqpTKBnSI8FCAOWaK3/K5TrKKW+ATwFuPtsvllr/fwJxCyEGILh89Kx531qS3ZR2uyi2WdgGOC2R+F3B1gwfTr5+fkyp0mMe6EOklgHPAskDrL7MBBSggIWAw9prX8Q4vFCiBPgPVxH48f/R8nBRuo7vQBERkbQ7owhIyuLc89YTlJS0hhHKURoQn0i+m+YJTV+AbwBXAKkA78EvncC91sC/PuJBCiEOD4j4Kd1z1a2f/Auh70GfsPcbouIITxlOhfm55ObmyvdeWJCCTVBzQG+qLXWSqlPgCit9SallBf4EWbZjSEppWxAIfBVpdQvgC7gN8D9Wmvj5MIXQvi72ih+7SV2lFXT7QsQHmYnItyJIzGd6bPzmTdvntRpEhNSqAmqGwgEX5cAC4G/Ah8DeSFeIwX4CHgeuByzxtSfgDZkJQohTorb7aZ4916KKw/R7TN/RTt8dlJmFLBsxXJZokhMaKEmqHeAu5RS38JMMtcrpR4CzsZMMMelta4Dzuqz6VOl1CPAF5AEJcQJCQQC7N+/H601Pp+PmIwZeCor6HLEU7h8NWtWLJAlisSEF2qC+h7wZ+AbwJOY86PaACdmTajjUkrNA76ktf5xn81OzLX+hBAhMAyDfXuKqKhtoLurs3e7LSKavBVnMK/wNBLjpU6TmBxCHWZeBuQrpSK01t1KqeXAOUCj1npLiPdqAb6nlKoGnsGc+Pst4JsnEbcQU057UwPv/Pklag4dgvgs0qelABAdHc38+fNJSUkZ4wiFGF5DLXUUeZztb/a811oPXALpKFrrg8Hlkx7AHP3XCPxEa/3iCUctxBTi9/vRW99m1ycf0dpudjgEWmrpTkxg8aIF5ObmYrVaxzhKIYbfUC2oDszljEIRUme31vofwNIQrynElFd3YD/b3/k7HW2tWC3gcNjwev1ExqawYuVqsqfLOs1i8hoqQZ0zalEIIfrp6Ohg++Y3qNtfCkagd3tKQgwxM5ey5syV2GzSahKT21Br8b09moEIIczuvO3btrHjw3exeF3ERDrBAjaLBVWQz9zTz8fmcI51mEKMilCXOtrGEN19WuvlwxaREFOQYRjU1dWx/YPNVJdqMMxfN4/PT056IgvPvpjotKwxjlKI0RXqMPNXBjkvF7gYuGc4AxJiqmlvb6eoqIjGxkYMq50wpx2320uY1ULOrAJOv2gdFqvMaRJTT6jDzO8dbHtwdfJLgIeHMyghpgKv18uePXs5cKASI9histgcJE6bjqOzjUWfuYS06dJqElPXqZbP/AfwyHAEIsRUYRgGFfv28d5bm+lo7yBr5gwsFrBYLOTk5JCXl4fDYcdikUEQYmoL9RnUYHOi4jAXiq0d1oiEmMSamprY9ekn6J07sbg7sWGhqSmWuXNnM2/ePGJjZRUIIXqE2oI61pwoF/D14QtHiMmpq6uLPbuLOVBSjK+1kSiLly7AYTVIxc2KFStksq0QA4SaoAbOiTIAD1CstW4f3pCEmDz8fj9lZWWUFu/E3VRDwGsWk45w2kiww8y5C1BnrpXkJMQgQh0k8TaAUioaUIDf3Ky7RzA2ISYswzCoqalh69aPqa+sIN7hxhosFpgaZScvK4OkRWfjTMwY40iFGL9CfQYVhlkS4yrMFcgBupVSvwa+p7X2j1B8Qkw4LS0tFBUVUVK8B2/LISxGgG6/jbS4MOakxDBtwUoicubL0HEhjiPULr5fYdZ++jKwFbACK4CfA27gn0ciOCEmEpfLxZ49e6iurgYgPNCBzwhgs0Ci3WDp/AISF56JLSJ6jCMVYmIINUF9Cfic1vrdPtteUko1A5uQBCWmML/fT0VFBWVlZfh8vt7tMenTiQ2UkRIbgzr7QuKn545hlEJMPCdS8t07yPbWYYxFiAml5zlTUXExNZVVxCQlEuYwf6XS09MpKCjA2lZPeOp0LLZTnXIoxNQT6m/NHcBvlFIbgA+11gGl1HzM51I/7TtPKpTaUEJMdC0tLRQXF3Ng3z5aa6ux+j00uD3kz89n/vz5JCcnmwdGzRzbQIWYwEJNUA8D0cBmwK+UCgAOwAIsB37R51h58ismre7ubvbu3UtV5X58LYewdLRi9XuwWSDZ10LWDHUkOQkhTkmoCeqyEY1CiHHO5/NRVlZGRXkZ7pYGfG2NYBjYrRamx4URaYGMwpXkzpDkJMRwOdF5UBHAHMxRfOUySVdMdoZhUFVVxc5dxdRUVRPta8VhNQsIJkfamZUQTkzmbKLyV+KMkmWKhBhOoc6DsgH/CtzKka49j1LqOeCbWmvfEKcLMSE1NDSwe/duaqoP0lJThc3vpstqITMhgtlJ4SSnpBE9bzWOxGljHaoQk1KoXXw/Ba4G1gPvYiao1ZjzoO4OfgkxKbS3t7N7927q6+sBcPq7sQeCz5kcFvKSY5i25AzCp8+VFceFGEGhJqj1wHVa61f7bNuklGoHnkYSlJgE3G43WmsqKw/Qd23kiKQ0cv0dRHhdTF+4nMzFp2N1hI1doEJMEaEmqGigbJDtFYA8FRYTWs9E2x279lBfU0tkTDRJibFYLBamT5+OUgpL+2nYIqKxR8ePdbhCTBmhJqhtwM2Yz6D6+ibw8bBGJMQoMQyD6upq9u7dS8OhelpqqrAHPHS52pk1ayYLC+cfqc8ULpVthRhtoSaofwbeUkqdDXwY3LYSyAEuGP6whBhZPQMgWpub8LXW4+hsw4kXuxUyHS6mJSZK8UAhxliow8w/UkotBm4ACjCXPvoz8JjWWirqigmjtbWVXUXFNNYfwuhoxtfRDIaB025hXmokTgOmL1pOcp6smyfEWAt5gTCtdQlwm1IqCfBrrVtGLiwhhld3dze7d++haG85rQ31xBrtRIVZsVlgenwY02OdRGbOJkqtwBYpLSchxoOQE5RS6i7gRiAt+L4KeFhr/fAIxSbEKfN6vZSWlrJv3z7aWlroOniA8IAXD5ATH8XspAiiktKJLjgdR0L6WIcrhOgj1Im6P8Xs3ruP/vWgfqSUcmitHxy5EIU4cX6/n/3791NaWorXay7EH+m0023xE2a3kBFhY2ZKAsmL1hA2bQ6WYLVbIcT4EWoL6jrgawPmQb2nlCoDHgNCTlBKqXhgJ3C31vq5UM8TIhQ9I/M+3VGMx+PC6TiydnFi+jRmx1qxtdSRedpKomefhsXmGMNohRBDCTVB2YGqQbaXATEneM8ngcwTPEeIIRmGQX19PTt3FVNeeYju1iYiwsPInJ5OVFQUc+fOJSMjg4CrEywWbOFRYx2yEOI4Qk1QDwKPK6W+orWuAlBKJQI/w1zuKCRKqa8BscCuEw1UiGM5fPgwe/bsoampie72NoymA0QFvFh8NlIzVrBs8XysVnNJIim3LsTEEWqC+jKQD1QEB0f4gBmAE1iplPpWz4Fa69TBLqCUmgn8GDgd+NupBC0EmGvm7d27l7q6OgyfB29LPZbudqLsASKxMCPOTk6Yqzc5CSEmlhMpWHjSgquh/ydwm9a6Til1KpcTU1x3dzdaa/aW7sNiBHC6W/B1NGMxDDJjnEzLiMRisZMyfxkRMxeOdbhCiJMU6kTd50/xPneZl9EvneJ1xBTmdrspKyujtKyCg/VteNpbiA60ER9hIzXazsz4cCIcVsIz84hUK+Q5kxATXMjzoE7RlcA0pdTlwfcxmM+0lmutbxqlGMQE5fP5qKiooLy8HJ/PR8DjwtpSRZTfQ4TNwuzYMLKSInHEpxFVsBpH/KC9zEKICWZUEpTWem7f90qpTzEn+T43GvcXE1PPXKaysjI8Hk/vdofTQVqUjXCvlWlx4aSnJhIzfzVh02bLfCYhJpHRakEJEbJAIEBVVRUlJSU0HW4nYBjERDoBiImJYe7cuUR15tJS9B6J+UuJzD0Ni13mMwkx2YxJgtJanzYW9xXjm2EYHDx4kJKSElrb2qlt7MTV1oLT4iN5fj4F+flkZmZisVgwjFQip83EFnGi0/CEEBPFMROUUuq3oV5Ea/2N4QlHTEWGYVBXV4fWmvb2dgAsPjfWlmri/C6SnBZiotPIyjpSk8lisUpyEmKSG6oF1fe33wl8DtiLWbzQAywGFgJ/GLHoxKRmGAYNDQ3s3buX1tZWc6Pfh7e1Hkt3GwWJVnydVhJjwphGFVA4pvEKIUbXMROU1vqKntdKqacxBzV8t+8xSqn7gLkDzxXieBobG9Fa09zcjMvjw+X2EW10YHQ0kxVtIyszGofVgssXSYJaROTsJWMdshBilIX6DOqfMFtMAz0PfDp84YjJrrm5mb1799LU1ETAgLqmDjpbDhPlbSE3LYKcaRE4bebKD87UHBLzV2GLihvjqIUQYyHUBFUHnAuUDti+Dqgc1ojEpNTS0oLWmvr6+t5tFiOAteUgWYFuEsMtRAZ8OG0R2KMTiSo4HWdy1hBXFEJMdqEmqH8BnlFKnQt8Algw60FdBFwx1IliamtpaaGkpIRDhw71226xWJiRk0N+uIuDpWVERzhITUsgev4qwqfnY7HI+nlCTHWhLnX0O6VUNbAB+Gpw807gTK31lpEKTkxcra2tlJSUUFdXB4Db46e920tKfASZmZnk5eURFRWFb2YW4a5mEvIWEjl7CVZH2BhHLoQYL0KeB6W1fhN4cwRjEZNAW1sbJSUl1NbW9m6rbeyg8/BhEiwu8s/4J2ZlZ/Tus8cmkXnhNVidEWMRrhBiHBtqHtQDoV5Ea3378IQjJqrBEhNAwNNNoquebHs7YVYL5R9/wqzsi/sdI8lJCDGYoVpQy0K8hjEcgYiJ6ViJyfB5STA6yLK145xmp6zaQlS4g4yoJgwjIM+YhBDHNdQ8qHN6Xiulvgr8VWvdOCpRiXFv4DMmgC6Xj5a2LuanOsi0NhPlALABMHt6EnF5pxE5e7EkJyFESEJ9BvUrYCUgCWqKO9aovKpDbVi6u8k2mkjrDicq+shgh7CM2SSqFdgiZWkiIUToQk1QW4DPAz8bwVjEOHb48GFKSkr6zWPqkZGRQWpnHd2uerBAw+Fu4qLCcCSkEZW/CkdC+hhELISY6EJNUAHgX5VSPwL2Ad19d2qtlw93YGJ8aGpqoqSkhMbG/o1ni8VCRkYGc+bMITY2lpYY2PWP14iJcJKemUbs/NNxpudKfSYhxEk7kRaUzHeaIgzDoLGxkdLSUpqamnq3BwIGja0uvH4HX7rsHBIT4nv3xc0+jbl1FUTNUERkz8ditY1F6EKISSTUibr39rxWSsUCVq11y4hFJcaEYRgcOnSI0tJSWlr6//VaLBbqWwLEu9pJ9h5i//6CfgnKYrOTfOYV0mISQgybkCfqKqVuBH4ITAu+rwf+XWstz6UmOMMwqKmpoaysjLa2tn77LBYLmempZFrbaekspiZYr6ljzxaM0/L6JSRJTkKI4RRSglJK3QbcBfwUeBdzLb7VwA+UUt1a638fuRDFSAkEAlRXV1NWVkZnZ2e/fV6fweycTDKsHVhqd2AE/MRHO2nrcBAXHUZqbjIE/GAbk6LMQogpINRPl5uB/6e1/q8+295TSlUC9wGSoCYQn8/HgQMHqKiooLu733gXuj0B2t1hxLgPk1LzCVj8vTOxLRaYXZBHZN5ynEnTRj9wIcSUEmqCSsGspDvQx4DURJggvF4v+/fvp6KiAo/H02+fw+EgOzub/Tt2k3x4D1bDT31jGNNSogGwxyYTlbccR8p06coTQoyKUBNUEWZZjX8bsP3LmGXgxTjmcrmoqKigsrISn8/Xb19YWBi5ubnk5ORgt9sJP1hMZaMfiwVsNiu26ASi8pbhTJspiUkIMapCTVB3A39RSq0CPghuWwVcAFw+EoGJU9fZ2Ul5eTlVVVUEAoF++2yOMCKikzlz1UJstiNDwjMXr8bdUEV8ahrx+csJy8iVpYmEEGMi1GHmrymlzgNuwawH1Q3sAZZprXeMYHziJLS0tFBWVkZdXR2G0X8t3+joaLo9DjzV5dg9RTTl55GaFN2735mYQe5nrsCRlCktJiHEmBqq3MYFwGatdSeA1vod4J3RCkycGMMwaGhooLy8/KhVHwASEhLISUsgpq2ash0f0d5tPoPa+f6HrP3c2n7HSql1IcR4MFQL6i+ATyn1EfCP4Nf7Wmv3qEQmQhIIBKipqaG8vPyoOUwAKSkpZCdEEN5Uga+0CA+QlhhJe5eHiDA7GQmeoy8qhBDjwFAJKhlzrtMqYA3wHcCqlPqQIwlri9baP+JRiqMMNVTcYrGQnpaGtasTf/mn2OPB16e3LsxpY3bhfFLnL8eZmIEQQoxHQ9WDOgy8EvxCKWUDFmMmrFXAN4BkpdRmrfXFx7qOGF4ul4t9+/ZRWVmJ1+vtt89mszFjxgyyEmMofvV/8LrMxNXujCEmygkWC+HT5hAxcyH22KSxCF8IIUIW8jIAWmu/UqoaqAXqgQNAKpA7QrGJPtra2qioqODgwYNHjcgLCwsjJyeHnJwcnE4nhs9LbKSDpmCCamz3kbZgOeHZ87FFRA92eSGEGHeGTFBKqWjgbGAt8BlgLlAFvAk8A3xFa10zwjFOWT2ripeXl9PQ0DBgH/ix4/AHiExKJy8vr3efxe4gfd4imrZ+THzeaeQvX05YRMRohy+EEKdkqFF8m4HlwGHgLczljP6htS472ZsppdYB/wrMxGyFPaC1fupkrzdZ+f3+3oEP7cHFWftKiIshNuCmrngXTsNNa0s9/pULsFmPPGhKnreCMxeswiplL4QQE9RQLajVQDXwW8wBER9orb1DHD8kpVQG8CLwea31X5VSizHX89umtf7kZK/7/9u79+i4quuAw7/RSDMjybJelixZWLYF9sYGDMG8kialiUvSEBMoAdIGSCC8ktK0ISXpAodAEgivlgWlJSSE0lBKWSQUtzgpjwWF8GizeAQHYtgBrNHoYVvGYHs0kmakmekf58oej21hyZLmjrS/tbQs3TP3ztmembvnnHvuOdNJMpmko6ODaDRKMukGSw6nM/T1D1FTFWFuzSyaS/sp3/4W2XSaeMkQQ2moSGyku2szra27Vq4NlJZhdzEZY4rZaAmqDde1txL4KlApIs8BT+IS1iuqmh1l/92o6kYRaVDVuIiUAPXAMLBnE2GGicfjbNiwga6urt2uL3X19hHvH6IqGOD4miS18S4AN3lrAGpnRxguCVF7yBE0N84uTOWNMWaSjDaKLwr8xPtBRI4EPoFLWFcBQyLyNPCkqt6xP0/mJacKYLv33Deq6lsHEkCxymaz9Pb20t7evsf1JYBIJMJB5X2EBjcRzgyR3BqB+sqd5aXVDbQdeQTh5oNt9VpjzLQ0llF864B1InIbsAI4Hzft0WnAfiUozyBQCSwHfikib6nq3WPYv6gNDw/T1dVFe3s7fX19ACQGhshmYVZFGTU1NbS1tdHc3Ez3s4/wzntDVIRLiYRKCZQECTW1Ub7gMEpr5tpURMaYae0DE5SIHAQcD5zg/Xs0rmvuBdxaUE+P5QlVNQOkgJdE5MfAqbgRgdNaf38/7e3txGKxnTOKJ1NpunrjpJJD1FZV8Mk/PpG6urqdiadx6Yco2dZFpGo25a3LiMxfSkm4opBhGGPMlBltFN9DuITUjLtO9DzwCHA58PJYZ5AQkROBW1R1Rc7mMLBtrJUuFtlslq1bt9Le3s7mzZv3mLg1TIr69A7mlmwjOFhGIlVCfU6rKNQwn4YPr/LWYLIZxY0xM8toLagwcCuuhfSK1/I5EK8CLSLyDdyQ9eOBC4A/PcDj+s5IN140Gt05TLxvYIhIKEiQDJH0AE0lCRrCw7w7e5D341BTFaQi0QPU7jxOIBAg1LigQOd/Tl4AAA02SURBVFEYY0xhjTZIYtVEPpGqbheRk4F/AK7G3fB7oao+M5HPU0iJRIJoNEpnZ+fOaYh2JFL0vpcgk0zQVh1gSfUwdZGg140XYE5tOQ11FUTqm6motpF4xhgzYr8HSUwE736nj07lc062kdF40WiU3t7ePcpLBncwd3Azc0qHqUwGqYvUMtKLFygLU7VwCZH5SymtqpvimhtjjL9NaYKaTlKpFJ2dnUSjUfr7+0lnsiQGhphdGQKgsrKSRYsWUZeJ89vH15LNljB7VohMNkukvoXI/EMJNy0iECwrcCTGGONPlqDGIJvNsn37dqLRKD09PaTTbpxId2+c/h07KE0P0HLccSw7dDENDQ0EAgEyQ0kWND9PpKKcytalROYfSrCyusCRGGOM/1mC2g/pdJru7m46OjrYtm3XoMPsUJJ0YjvlO7ZQnxmiJhSgIlRFY2PjzseUlIWZ9/EzCFbV2Q21xhgzBpagRhGPx4nFYnR2dpJMptiRSBEkTTkDZBLbqQgMsbAqRHlLOd29aSLhILWDXbh7kHcprW4oTADGGFPELEHlyWQybNy4kY6ODrZu3QpAX3+SzT2bKRtOUBFIMb+xknlzQlSFQgQCAbJZiCyaRW3bUiItUuAIjDFmerAE5UkkEsRiMWKxGKlUareyUGoH1UNbqS4NUF0WoK06RKgs6KYemruISMsSyhoOsptpjTFmAs3oBJXJZNi0aRMdHR20x3qIJ1L09/WxsLWR0mAJgUCApqYm5h91OLHHHmQ4k6WmKkJ4zkHMWiCEmtooKQ0VOgxjjJmWZmSC6uvrIxaL0dXVRTKZJJMaJL55I9mBOJXZNIODtaw4ejmtra1EIhEAwsccS2h2PeF5hxCMVH7AMxhjjDlQMyZBDQ0Ns16jrP/922RSCarCkE5sJ92/nezwEJWZNIFghurSEqoqyndbQh2g5qhPFKjmxhgzM82IBBWPx1n76P8Q69lCaLif2SWDhMJu4tZwMEBzTZg5kSCJ/hTVNdXULZ1X4BobY4yZEQmqu7ub0sH3qBnoIUCWTADqayqZVxWirryUkrIQ4aY2WuYtpqx+ng12MMYYH5gRCaqlpYWuDfWktnTRUF7G/NoI9bPLicxdQHjeEkKNrQSCM+K/whhjisaMOCtXVVWx8tOreL8iTkm4gnDLYsJNB1MSihS6asYYY/ZhRiQocGsr1X70TAKlNjmrMcYUgxl1scWSkzHGFI8ZlaCMMcYUD0tQxhhjfMkSlDHGGF+yBGWMMcaXLEEZY4zxpWIZZh4E2LRpU6HrYYwxZhxyzt/7vbR4sSSoZoCzzz670PUwxhhzYJqBd/bngcWSoF4EPgZsBNIFrosxxpixC+KS04v7u0Mgm81OXnWMMcaYcbJBEsYYY3zJEpQxxhhfsgRljDHGlyxBGWOM8SVLUMYYY3zJEpQxxhhfsgRljDHGlyxBGWOM8aVimUlin0TkOGCtqjZ6fzcAtwGfApLAPwNXq2raK78XOAsYzjnMclXdICKtwN3ACUAv8DVV/aWPY/mIV74U6AGuVNWfe2UFi2UscYjIncA5eYeoBFar6g+K8DU5H/g2MAd4E/gbVX3OKyu2WL4GXAbUAy8Al6rqhkLGIiInATcAi73nvVlVfyQiNcBPgJOAPuDbqnqPt08A+D5wMRAC7gG+qarDXvlZwA9wsxw8A5ynqr1+jCVn3xLgIeAZVb01Z/vHca/pwcA64FxV3a9phfyoaFtQIhIQkQuBx3FvuhE/BRpxJ+3DgeOA7+WUHw2cpqqzcn42eGUPAL/FfSAvAh4QkbZJDmVcsYhIM/AL4B+BKuBS4D7vxFGQWMYTh6p+Jfe1AL4JrPfiKkgc441FRJYDtwCnAjXAfcAa72RSbLGcBVwHnO/V97+AJ0QkUqhYRGQ+7qR8Le7/98+B60XkU8APcdOgNQOfAW4QkRO9XS8GTsd99hcDxwJXesdchku053mxvOXFNqkOIBZEZCHwCHBa3jHnAGuA73rHfBh4LOf9V3SKtuK4F+GruBcYABGpAP4EuExVe1X1PeAq4CLvQ1oOHAq8mn8wEVkCHAN8R1VTqvoU7kN5weSHMvZYgC8Cv1LVn6pqVlWfwJ1g3i9gLOOJg5zHHgzcBHxBVXcU4WuymF2fqQDuJDPg7VtssXwOuEtVn1HVYVX9IZACVhYwloXA/ar6sKpmVPVF4GlgJXAGcJWq9qvqq8BduMQE8CXgVlXtUtUtwDXAJV7ZOcAjqvqcqg4CVwB/ICKL/RiLiMwCXsa1jl7IO+bpwO9U9SFVHVLVm4Gwd8yiVMwJ6k5VXQG8lLNtJJ5EzrY00ID7RnEUrmvvLhHZIiKviMgq73HLgJiq5u77JnDEpNR+d+OJZQUQFZEHRORdEfkN0KSqcQoXy3jiyPX3uJPiOu/vYntNHgNeB17DncxvBD6vqhmKL5aSvLKR8iUUKBZVfVZVvzLyt4jUsWsS6Syu9bO3+izDtcpzy+Z5++9Wpqr9QCf+jWUQWKqqVwJDeYfNjxNAmZr32KQo2gSlqj172daH68a4SUTqRKQe+I5XXI7rCnsW941yHq4L40ERORKYBfTnHbIfqJicCHar93hiqcN1rdyH6wq4HnjYa4UUJJZxxgGAiByO63O/MWf3YntNIrgTwgm462h/i+via6L4YnkIuFhEjhGRMhG5CNf7UE4BYxkhItW4VtuvcS2KQVXNnfk6tz759R35vWIvZfn7TrqxxOK1Zvd1fazgsUy0ok1QozgX9+31DdwFzzXe9m2q+riqnqSqL3lN4IeAp4DP4r4tlucdqwJ3kbJQ9hkL7qL2o6q61ovlQeAV4NP4L5bR4hjxZWCNqm7O2ea3OGD0WK4BNqnqr1U1qap3AFHgTIosFlV9APel5wFci+Jw4AngfQoci9fF+H/AZlx3WByI5HUZ59Ynv74jJ+y+vZTl7zupxhHLaPz4Hjsg0zFBNQOXqOpcVT0c6AbeUNV+ETlFRL6U9/gQrtm8Hmj1rlONOJQ9m8xTaZ+x4Jr9tXmPHxmV6bdYRotjxKnseXHab3HA6LHMx/X55xrGdcUUVSzeIJxHVPUQVW0CvoFLUi9TwFhE5A9xLY01wBnedaO3cNf8Fu2jPusBySvbqKrb8su8a3Ot+DeW0eTHOZZ9fanoh5nvxS3A6yJyOe6NdiO7RoQFgdtE5A3cB+3zwEeAC1U1JiLrgOtE5Apv+6nAh6c6gByjxXIv8Jcicg5wP+5b+nLgLFXt9Fkso8UxMty5DXg+dydVVZ/FAaPHshbXZfYgblG2s4HDgF/48DWB0WNZCVwtIh8DduC6/3qAF1U1W4hYvO7rtbhbEG4f2a6qfSLyMG4U3AW4IdYX4UbmAfwrcLmIPIlrZVzjbQP32XlORP4I+F9cq/E3qvp7n8Yymodx77+zvN//GsjgBl8UpemYoC7CjXp5D9ftcrvX1YKqrhGR1cC/A024VsgqVY15+34O+DHunoR3gQtU9fUprn+u0WJZJyIn404qdwAx4HRV7fT29VMs+4zDsxBIeiPJ8vkpDhj9NbnLu55wP+4+qPXAyT59TWD01+XfcBfX1+F6GZ4EPptzbaQQsVyKu458vYhcn7P9n3Cj8u4AOnA9Itep6n975XcCc3Gj3iqAn+Fdb1PV10Tky95jWnAtmjMnOQ4Yfyz7pKq9InIK7j6ou4HfAaeoamqiKz9VbEVdY4wxvjQdr0EZY4yZBixBGWOM8SVLUMYYY3zJEpQxxhhfsgRljDHGlyxBGWOM8SVLUMZMIG/y3i3e5J/5ZatFpM9bLsEY8wEsQRkzsb6OuwE+9+ZLRGQRsBo3c0C0APUypuhYgjJmAqnqJtyaQheKyPE5Rbfj1iG7fa87GmP2YDNJGDPBvJmon8dNEXQsbrb8B4EPqep67zHn41Z1bcHNJr5aVR/1ykpxS5R/AbcszFbc9FyXq2paRO7DzbG2FDdX2+mq+vSUBWjMFLEWlDETzJuv7mLc5L3nA38HXJuTnD6Dm6h1tfeYu3FreR3nHeIK3BLg5+JW6b0C+CtgVc7TnIObc20lbrkGY6ad6ThZrDEFp6qvi8gtwI9wLaQbcoqvBG7w1vACeFtEjsEtafFnuBV5z1PVX3nl94jIt3Arpv6nt229qt432XEYU0iWoIyZPN/Frar7fVXNXZ57GbBCRK7K2VaGt26PN+v+ShG5GbfE+nLcjO/BnMe/M5kVN8YPrIvPmEmiqgPerwN5RaXAN4Gjcn4Ow62phIhci1sSosT795NA/lIW+cc0ZtqxFpQxU+9NYIGqvj2ywWtNDQI3A38BfF1V7/XKynELCgb2cixjpi1LUMZMvZuAe0VEgaeAk4CrcdefwC0guEpEXgCqcV2Fs9lzOXljpjXr4jNmiqnqz4DLgG/hrjtdBlyiqj/3HvJF3Oi914D/AN4G/gVYMeWVNaaA7D4oY4wxvmQtKGOMMb5kCcoYY4wvWYIyxhjjS5agjDHG+JIlKGOMMb5kCcoYY4wvWYIyxhjjS5agjDHG+NL/Ayaqs/yaqgOLAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "plot_results(census, un, results, 'Quadratic model')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating projections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To generate projections, all we have to do is change `t_end`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap04-fig01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8VNX5+PHPZF8hCSEBEnbCwyJLWAK44VZXVLTa+q2K1o2qpbb9UVtFUaq24tLaqqgF9y5CXavVqkWlLiRhVVA8CEjYt4QQQvbJ/P64d8bJNkzITGaSPO/Xa16ZuetzZzL3mXPPuec4XC4XSimlVLiJCHUASimlVHM0QSmllApLmqCUUkqFJU1QSimlwpImKKWUUmFJE5RSSqmwpAlKHTMR+beIvNZo2kARcYnIp42mp4lIvYice4z7+khEHvIx/2URee5Yth1sInKK/Z4k+bn8ABG50Ov1VhH5afAiDKyjfVat2I5DRK4XkTj79dUicqDtEaqOQhOUaouPgEmNpp0B7ADyRKSb1/TjASfwcfuE1qE9C5zk9Xoi8EyIYjkWFwPzArCdk4G/AFH268XAiABsV3UQmqBUW3wE9BaRfl7TTsc6wR4ETvGafjyw0hhzuN2i67gc3i+MMfuNMRWhCqa1jDElAfqcG78PlcaYfQHYruogoo6+iFItWg2UYZWitomIAzgNeBIQrNLUv+xljwc+cK8oImcC9wDHAQeAx4CHjDEuEbnb3mYEMBn4WeMdi8iVwF1Ab+DvQExLQYrI1cDPsX6B/wqrJLcQuMMYU28vMwF4AKu0Ug68YM+vFZFTgNftbfweiAeWALcYYyrt+R8CycaYcnt7dwPTjDETmoknB3gYq4QQD3wD3G6M+Zd9mXIqMFVELjHGDBCRrfZ785j9Hs8Cfgr0A762133b3vZzQIW93UuAYmCRMebeFt6b54BqIAm4CNgF3GmM+YfX/Cggx378AKsUfDsww37/VwL/zxhTYK/zEdaPkdn26xnAHUC2He+dxph/e8VwI/ALe/564JdYpfAP7UUOi8iP7ecPGWPSvd7Hh+z3sR54FfilMeawiAwAvgUuxfo/6wusAH5ijDHNvRcq/GgJSh0zY4wT+BQriQCMxjrRLcdKRt8DEJEorBP/B/brk4G3gTeBXKyT3Z3ATV6bPxv4n73tt733KyKnYl3y+gMwDiuhnH+UcIcD07AS6I+BG+x9IiJDgWXAV3ac1wNXAr/zWj8JK7l9H7gAK/kuOMo+m7ATzJvAYfvYxgLrgGdFJAa4Bev9e8KOpbHbsS6fzcV6v18H/iUiY7yWuQ7rBD8BWATcIyLjfYR1NdYPjXFYPxT+aiddt8vteE4DPrOXuQa4Gevz+xJ4X0R6N3O8ZwF/tuMdBTwFvCwiU+z5P8ZK1vfbx/Mh8G/7/fm+vZnBWD8uvLebBnwC1GJdDr0YOJGml0LvBmYCp2Il0zbXjan2oyUo1VYfYZ2wwbq894kxplpEPgCeFJEsoA8QiXVyA6tE9B+vX/UbRSQb6+T7uD2tEvi9VwnHe58/AV43xiyw5/0SK6H5EgVcbozZCqwVkXuB34jIb7GS1RZgljHGBXwtIr8AXrRLQtjx/8QY85nXPpeIyC1+vEfe4rGSxjPGmBJ7Ww8BlwGZxpjtIlIDVBhj9nuvaCe3nwP3GWNesiffLSKTgFuxEgnAZmPMnfbze+1jGQ+saiGmIuBm+73+2k5ON2J9tgDGGPOcHUMKVoK/zKvUdiNWcvgpMKfRtm8HHvSKd7OdLP8fVgnvJuApY8wz9rZ+Yy+XCpTYz/fZJVXv7f4I6wf2lcaYSnvdq4F8+wdHjfv4jTH/s+cvAH6D6jC0BKXaahkwzi4lnQ4sBTDGfANsxzpxHQ/ku08kwEisUoK3T4A+9gkQ4Ft3cmrGcViXF7H35cK6fOPLdjs5uRUCmUC6HU++vR3veKKxLmuBdVlweaP1o7EuZfrNrkt6Avi+iDwlIh/y3aXPyKOsnmHH29x7N9Lr9TeN5h+2Y23JZ43e60Ks99hts9dzseP0xGCv+1mjGNxGAneKSLn7AVzFd+/bCLw+O2OMyxjza2PMJh/xure71ut/Cns7NTRsSLHR63kZvt8HFWa0BKXaahVQh3V56GSsSypuHwAnYJ1YP/Ca7n1ScXNXiEf4WKa55d1q8P3/XNfotXs/Tj/jqbcfza3f3JAAzcYiIolAgb3P17Dq6Mr5rrTiS0vviYOGPzZrWlimJc29N84W9utvDG5RwG1YlzW91dp/a2j+/TuaY30vfL0PKsxoCUq1iTGmDqse6sdYJ7rVXrM/AMZg1bV4J6gNwJRGmzoe2IfV+u9ovqBp8/ZxR1mnn4ike73OwypVldjxTLYvoXnHU8t3pYdoGpYq8oAqwPDdSbC71/xBLcRxClap7CRjzO/sxgKZ9jz3/ps9YRtjyrAaMTT33n3dwv780fi9ywM+b2HZTVjviycG+32b3EIMG4D+xphN7gdWQ4v/s+dvbLx/EflSRL6P78S1ARgjIvFe0yZgfU5teS9UGNESlAqEZVittN63G064LcW6nOXCKjW4PQisFJE7sCq/x2H9yna34jva/v4EfGzXA72F1ZpsDFbiakk08JyI/Bqr0n0O3zWCeByrXuxREXkMGIhVcf+8MeaQVzwL7fqWbvb8RcaYIyLyJdYv+ntE5B6sCvnzaHqpDaxWdTHAD+3WbuOAR+x5sfbfcmCIiGQZY3Y2Wv9+4LcisgOr9PpD4CwaNulvrVy7Tu4FrIYk52CVfJswxlSIyKPAH0WkAqvu7qdYCXlhM6s8APxDRL4G3sdqaDEPqxEKwB+BRSKyFsjHauCRidVAxn37wngRaVx/9jesRi7uesJUrEYr/zXGfGW34lMdnJagVCB8BCTSsJSEfXLdgdVwotZr+lqsVleXYjUr/h1WU2DvVnMtMsbk2+tej/VLfwTwj6OsVoxVt/IZVtJ8EKsVIMaYXViNLMbZ21uEdbK+udE2XgLeBV4GXsFqDu0u2VyDlSS+AqbTwo2qduxzsBLNV1it22ZjlRzdLe2ewEoQn4tI4+/oY1gn/QewWv9diNWcvS03QL+HVar73D6Oi4wxhT6Wvw3rh8WzWCXmUcCpdr1jA8aY17Caxf8S63h/BdzkbjRh/70DuM8+npOBc+wGIuuwfoC8h9WQxXu7FVifWTesuqdXseriLm794atw5dARdVVnZ7fu8tw/cwzrn0Kj+5w6C/s+pyRjzCUB3OYnwP+MMbcHapuqa9JLfEqpgLDrg0YBQ7FunlaqTfQSn1IqUMZjlTQ30ujGWqWOhV7iU0opFZY6/CU+EYnF6hJmNw3v3VBKKRU+IrG6m1phjKn2Z4UOn6CwkpMO4aCUUh3DSVgtLo+qMySo3QB/+9vf6NWrV6hjUUop1Yw9e/Zw+eWXg33O9kdnSFBOgF69epGdnR3qWJRSSvnmd1WMtuJTSikVlkKSoEQkT0SaHRlTRB61u4BRSinVhbXrJT67U8lraWHQMBE5B2scGr8q0JRSSnVe7V2CmoeVgJoMPy0iPYFHsfohU0op1cW1dyOJJ40xcxsNJ+32DFYHmklY3aUETFlZGfv27aO2tvboC6uwk5iYSHZ2NhERWmWqVFfSrgnK7jW6CRG5Cag3xiwSkZ8Hcp9lZWXs3buXrKws4uPjcTh0vLKOpL6+np07d3LgwAEyMjJCHY5SIedyuaivr2/x4XK5PMu4nzd+3XieP8snJSWRnZ1NZOTRBn4OnJA3MxeR4Vhd8OcFY/v79u0jKyuLhISEYGxeBVlERASZmZkUFRVpglJhx+VyUVdXR11dHU6n85gfvhJOcwkoVOrq6hg8eHC77S/kCQpr/JYM4Bt7YLhYIFpESo0xKW3deG1tLfHx8UdfUIWt6Oho6uoaj0quVNu4XC5qamqora2ltra2wXN30vF+NDfd6exavatFRbVvygh5gjLG3Ic1WBkA9iW+6caYUwK1D72s17Hp56eOxuVy4XQ6qa6ubvJwJ57GfztynXRERAQRERFERkbicDiaPHc4HJ6H92tf8462fHJyMj179mzX4wx5glJKKV+cTidVVVVUVlZ6/lZWVjZJRKEozTgcDqKiooiMjGzTw51w/Hm4E0ZXEJIEZYz5CGj28p0x5hHgkXYNKEyICK+//jrDhw9vMP3CCy/kqquu4uKLrdGs33zzTRYtWsS2bduIiopi7Nix/PznP2fkyJEtbvvjjz/m6aefZsOGDbhcLkSEWbNmkZcXlKo/pfxWV1dHRUUFR44coaKigoqKigaJqKamJij7dSeXmJgYoqOjPX+jo6OJioryPBq/9n64Sy0qOLQE1cEUFhZy7733smDBAnJzc6mpqeHZZ5/lqquu4r333iMtLa3JOi+//DIPP/ww99xzDyeffDIAb7zxBjfccAOLFi1iwoQJ7X0YqotxOp2Ul5dTXl7uSUbuhFRVVRWQfURGRhIbG9vk4Z2AvJNQdHS0Jpcwpwmqg/n8888ZMGAA48ePByAuLo4bb7yRPXv2UFJS0iRBVVZWcv/993P//fdzxhlneKZfeumlHDhwgG+//ZYJEybgdDpZuHAh//znPykvL2fy5MncddddpKWlUVBQwG9/+1umTp3KK6+8QmxsLJdeeimzZs0C4JVXXuGJJ57g0KFD9OvXj1tuuYWTTz6ZgoICbr75ZlauXOnZ72mnncbtt9/OGWec0eJ6quOqq6vzJKLDhw97HpWVlcfc+szhcBAXF0d8fDzx8fGe53FxcQ0SkZZmOp8umaAKv9xD4Vd7AMgb0Yu8kQ2H6fjk852s3bgfgBNG9yFXGjZv/nDVdr7cUgzAqeP7MnJQjwbz380v4pvtBwE4c1J/hvZLDVjsp5xyCgsWLGDGjBmcccYZjB8/nmHDhjFv3rxml1+zZg01NTVMnTq1ybwbb7zR8/yFF17gX//6F88++ywZGRnMnz+fX/ziFzz//PMAbNq0iTPOOINPPvmEgoICrrvuOs4991xSU1O58847eeONN8jJyeGf//wn9957L++++67P4ygpKWlxPT3JdAy1tbUcOnSowePIkSOtTkQOh4OEhAQSExNJTEwkISGhQUKKjY3V/4kuqksmqI4sJyeH119/nb/97W8sXryY++67j9TUVK666ip+8pOfNPkil5SU0L17d6Kjo31ud8mSJcyaNYt+/foB8Ktf/YoJEyawdetWwDqJ3HTTTURHR3PiiSfSs2dPioqKyMzMJCoqipdffplp06Zx8cUXc8kllxz1hBITE3NM66nQcDqdlJaWUlJS4klGFRUVfq/vcDhITEwkKSmpQSJKTEzUG+hVizRBhZGYmJhm7/dxOp3ExsZ6Xvfv35/bb78dsBLQe++9x/z580lNTeWyyy5rsG7Pnj0pLS2ltra2SZI6fPiw5xr9rl27mDNnDnPnzvXMj4qKYufOnURFRZGUlNQghujoaM/d5c8//zxPPfUUM2bMIC4ujquuuoqZM2f6PFZf6+nJKvQqKys5ePAgJSUlHDx4kEOHDvlVMnInouTkZJKSkkhOTiY5OZnExMR27YFAdQ5dMkHljWx6Wc/biWOyOHFMVovzTx3fl1PH921x/lmT+3PW5P6tjqtXr17s2rWLUaO+64qwrq6OXbt2eUYL/tGPfsSZZ57J1VdfDUBaWhqXXXYZ69atwxjTZJu5ubnExcWxbNmyBnVQAA8++CBFRUU8//zzZGRkMHfuXE466STP/I0bNzJgwADWrFnTYsyHDh3C6XTy5JNPUltby6effsqsWbOYMGECkZGRDe41cblcHDp06KjraaON9lddXc2BAwc8D39KRxEREXTr1o3u3bt7HsnJyZqIVMB0yQQVrs477zwee+wxhgwZwuDBgyktLWXBggX07NmT0aNHA3DOOefw+OOPk52d7WlQsGbNGpYtW8b999/fZJsxMTHMnj2buXPn4nA4mDp1KjU1NSxevJjXX3+dRYsWATB9+nQef/xxhgwZQkZGBk8//TQLFy5k6dKlPmMuKSnh2muvZeHCheTl5ZGZmYnD4fCcsGpqanj77bc566yzePHFFzly5MhR11PBV1dX1yAhHT58+KjrJCcnk5aWRkpKiicZaQe+Kpg0QYWRm2++mcjISGbOnElxcTGxsbFMnjyZ5557znN57sorryQuLo4FCxZw66234nK5GDx4MHPnzuXEE09sdrs//OEPSU5O5qmnnuK2227D5XIxYsQInn76aSZOnAjADTfcQF1dHZdffjmlpaUMHTqUp59+mm7duvmMeeDAgcybN48777yTffv2kZqayh133EFOTg4Ad9xxBw8++CB33XUXF154IePGjfNrPRV4FRUV7N27l3379nHgwAHq6+tbXDYqKoqUlBTS0tJITU0lNTX1qPWYSgWaI5QdDwaCiAwAvl26dCnZ2dlN5m/YsKHJja+q49HPsfVcLhelpaXs2bOHvXv3+iwlRUREkJqaSnp6Ounp6aSkpGjpSAXUjh07OP300wEGGmO2+rOOlqCU6kTcSWnXrl3s3r2bysrKFpft1q0bGRkZpKenk5aWpnVHKuxoglKqEygrK2PHjh3s3r27xQYOERERpKenk5mZSWZmpvbyr8KeJiilOqiamhp27tzJ9u3bPa0jG4uJiaFXr15kZmaSnp7e7sMlKNUW+t+qVAficrnYt28f27dvZ+/evc02dIiOjqZ379707t2b9PR0rUtSHZYmKKU6gOrqarZt20ZRUVGz9UqRkZH06tWL7OxsTUqq0/ArQYlIJDAemIA1+q0T2AOsMMasDV54SnVd7gYPW7duZdeuXc2WltLS0sjOzqZPnz7aDFx1Oj4TlIikAj8DbgR6AFuAYiASSAf6i8hu4EngcWNMaXDDVarzc7lc7Nmzh82bN3Pw4MEm82NiYujXrx99+/YlKSkpBBEq1T5aTFAiMgP4LbAUuBb4rzGmutEy3YCTgMuB9SIyxxjzfBDjVarTqq+vZ8eOHWzevJny8vIm81NTUxkwYAC9e/fWJuGqS/BVgpoITDTG7G9pAWNMGfBv4N8i0huYA2iCUqoV6urq2Lp1K1u2bKG6usFvQCIiIsjKymLAgAGkpDQ7CLVSnVaLCcoYM6s1GzLG7AZ+2uaIujB/hnx/9NFHWbhwIa+++ipDhgzxLNPc4IBur776KnPmzCEuLg6wfqn36dOHSy65hGuuucbTe/hpp53GgQMHmvw6z8jI8IzvVFRUxAMPPEBhYSF1dXVkZWVx2WWXccUVVzTZ77nnnkt5eTlLly7V+pFmOJ1OioqK2LRpU5PEFB0dTf/+/Rk4cKDnc1Oqq/G7FZ+IZACjgWigwXgIxpi3AxyX8qG6uprZs2ezZMkSYmJi/Fpn6NChvPHGG4BVx7FmzRpmz55NWVkZv/jFLzzL/eEPf2jS67lbfX09119/PdOmTeOhhx4iLi6OtWvXcvPNNxMTE8MPfvADz7KFhYVER0fTs2dP3nvvPc4777w2HHHnUl9f70lMjYc7j4uLY9CgQfTv31/vWVJdnr+t+K4FFmAlp8ZcWI0mVDuZMmUKu3bt4pFHHuHWW29t9foOh4Nx48Zx7733csMNN3DttdcetVNYgIMHD1JUVMS0adM8vRDk5uZy6623UlNT02DZxYsX873vfY8ePXrw4osvaoLC+mGwY8cOjDFNmorHx8eTk5ND3759tYm4UjZ/f6L9ClgI3GaMOXq//GHuyMYVVGxa5deycX2Hkzyq4XDph9cto2r7Br/WTxgynsShE1sdo89tJiTwwAMPcMUVVzB16lQmTZp0TNuZMmUKERERrFmzptkh4Rvr0aMHeXl5/PjHP+aCCy5g4sSJ5ObmMn369AbLlZSUsHTpUt555x2Sk5N54IEHWLduXYNxrrqa4uJivvzyyyY9PsTFxZGTk0O/fv00MSnViL8Jqi/wp86QnDqLsWPHMnPmTH7zm994Lt21lnv8Je8WY7Nnz25yaenqq6/mpz+1qheffvpplixZwvvvv88LL7xAXV0dU6dOZe7cuZ5BFV977TWmTJlC7969Abjgggv461//yvz5848pzo7syJEjfPXVV+zZs6fB9NjYWIYMGUL//v21RZ5SLfA3Qb0HnA58E8RYujx/h3x3u+mmm/jkk0+YN29eg/offzmdTsrKyjyJBOChhx5qsQ7KHeMVV1zBFVdcQU1NDatWreKRRx7hlltuYfHixbhcLpYsWcK+ffs44YQTAKvOrLq6mltvvZUePXq0Os6OqK6uDmMM3377bYOh0iMjIxk8eDCDBw/WOialjsLfb8jnwB9E5AJgI9CgwsEY06qKEBHJA94yxmTYrzOAP2ElQQfwDnCLMabpXYoBkDh0YpsuuyWPmtrksl8g+DPku7fIyEgefPBBLrzwQhISElq9v8LCQlwuF0OHDvVr+cWLF/PSSy/x2muvAVaymjJlCtHR0Vx33XUA5OfnU1payn/+858Gl6xmzpzJSy+9xM0339zqODsS902269evb9IAIjs7m2HDhmkv4kr5yd+L3lOBAiAeGIN9j5T9mODvzkTEISLXYZXIvJufLQLqgIFADpAKPO7vdjsL95DvmzdvBqC0tJQHHnigwZDvjfXr14/bb7+dJUuW+L2f+vp6CgsLufPOO5k5c6bfvRFMnTqVbdu2MX/+fIqLi3G5XGzfvp1nn33WPRAZixcv5uyzzyYzM5OePXt6HhdddBEvvfQStbW1fsfZ0VRUVFBYWMjKlSsbJKcePXpw0kknkZubq8lJqVbwqwRljDk1QPubB5wH3AvcASAiEUA9MM8Yc8SethB4LED77DD8GfK9OZdeeinLli0jPz+/xWU2btxIbm4uYA3nnZWVxXXXXcdll13WYLlf/vKXzdaJ/Oc//6FXr178/e9/59FHH2XatGlUVlaSmprK2Wefzc9+9jOKi4v573//y3PPPddk/WnTpjF//nzeffddpk2b5uc70jHU19ezZcsWNm7ciNPp9EyPjY1l5MiR9OnTx3OvmVLKf34P+S4imVg34o7EKnltABYaY7b4uzMR6WOM2SUipwCvG2OavTVeRJ4BehhjLvRjmwPQId87vXD9HMvKyli7dm2D1nkOh4P+/fszbNgwvUFZKVvQhny364zeB7YDn2HVE00DZonIKcaYpt0XNMMYs8uPfc0GpgPH+7NNpULB5XKxadMmNm7c2KCX8e7duzNq1ChSU1NDGJ1SnYO/jSQeBv4B3GiM8RS5ROQx4EGgzZcARSQaeBQ4HzjNGPN1W7epVDCUl5ezZs0aSku/67w/MjISEWHQoEF6OU+pAPE3QU0ArvNOTrZHAf/uePVBRJKBN4FkIM8Ys7Ot21Qq0FwuF99++y1ff/11g7qmlJQUcnNzdegLpQLM3wS1GxgAmEbTBwGBuHn3Jax6rZOMMRUB2J5SAVVdXc3atWvZt2+fZ1pERARDhw5lyJAhWmpSKgj8TVAvAn8RkZ8D7qZiU4A/2vOOmYiMBs4FqoF9IuKeVWqMadrqQal2VlxczOrVqxs0He/evTtjx471qw9DpdSx8TdB3Qf0AZZglXQcQC3WJb45rd2pMeYjIMV+/gWNekdXKhy4XC42btzIN99806A3iMGDBzNs2DDtO0+pIPP3Pqga4Hq7hZ0AlcAmY0yl7zWV6piqqqpYvXo1xcXFnmkxMTHk5uaSkZERwsiU6jp8Dfl+LvC+MabWft5YX/flOB0PSnUmJSUlrFy5ssEggj169GDcuHE6eKBS7chXCeotoBewz37eEh0PSnUaRUVFrF+/3nNvk8PhYOjQoeTk5GhDCKXama8h3yOae646nkcffZQNGzawYMECn8u57/ResWJFl6v8r6+vZ/369RQVFXmmxcTEMH78eNLT00MYmVJdl/b3r7q8qqoqVq5cycGD33We3717dyZMmHBMvcQrpQLDVx3UfqzLd0flHjZDtc2OHTuYPn06t9xyC08++SS1tbXMmjWLiIgInnzySWpqarjxxhu5+uqr+eyzz3j44Yf59ttvycrK4uabb+bss8/2bGfOnDl88cUXDBo0iEGDBjXYz5IlS3j66acpKSlh9OjR3H333fTt2zcUhxxyhw4dorCwsEET8qysLMaMGaMDCSoVYr5KUL/CzwTVkWzevJmNGzc2OzBgMERFRTF06FAGDx7s1/KHDx9m/fr1fPjhh/z3v/9l9uzZXHjhhSxdupSPP/6YWbNmMWrUKGbOnMn8+fM588wzWbFiBTfddBM9e/Zk/Pjx3HLLLYwYMYKFCxdijOHaa69lwgRrVJT33nuPP//5zzz11FPk5OTw7LPPcv311/PWW76qGTunvXv3snr1as//gsPhYMSIEQwcOFDrm5QKA77qoJ5rxzjazZYtW9otOYE14OCWLVv8TlBgjZTrHgzQ6XQyY8YMYmJiOPXUU3E6nTzzzDNMmjSJc8+1GldOmTKF888/n9dee42MjAzWr1/PokWLiImJYdSoUVx44YXs3Gn1HrVkyRJmzJjByJEjAbjhhht48cUXKSgooH///oF/A8LU1q1bWb9+vef+pujoaMaPH0/Pnj1DHJlSys3XJT6/R8AzxrR+vPEQGTRoULuXoBpfYjualBRrFBL3Jabk5GQAz42hVVVVZGVlNVgnOzubgoIC9u/fT2xsbIPetLOzsz0JateuXSxYsIC//OUvnvm1tbXs2rWrSyQol8vFV199xZYt340Sk5CQQF5enud9VkqFB1+X+I60WxTtaPDgwa0qzYTC0S4vTZgwgZUrG45wsn37dtLT08nMzKS6upri4mJ69OgBWJey3DIyMpgxY0aDgQo3b95Mnz59GtyU2hk5nU7WrFnD7t27PdNSUlLIy8sjNjY2hJEppZrj6xLfj9szEOW/E088kSeffJK3336bs846i8LCQt58800ee+wxsrKyyMvLY/78+cybN4+ioiJeffVVxo0bB8D06dN54oknmDhxIoMGDeKtt97itttu46233iIqqvM26qytraWwsJCSkhLPtN69e5Obm6uNIZQKU74u8T2APQy7/bwlLmPMrwMfmmpJVFQUCxYs4OGHH2bOnDlkZmYyb948TjzxRAD++Mc/MmfOHI4//nj69OnDGWec4TnRXgbiAAAgAElEQVQxT58+nbKyMm666Sb27dtHv379ePzxxxkwYAA7duwI5WEFTXV1Nfn5+ZSVlXmmDRo0iBEjRmhjCKXCmK+fzBOBaK/nLel0Lf1CJTs7G2O+G9GkW7duDV4DDV6fcMIJzW4nPT2dp556qsX9zJgxgxkzZhx1/51BRUUF+fn5HDny3RXrkSNHtrpeUCnV/nxd4ju1uedKdRSHDx8mPz/fc4+Tw+FgzJgxXfaeL6U6Gr8rHUQkEbgMGAnUAF8Ci+2ezpUKK6WlpRQUFFBTY/17RkREMH78eHr16hXiyJRS/vKrjz0RGQVsA+7FSlDjgYcAIyLDgheeUq1XUlLC8uXLPckpKiqKSZMmaXJSqoPxtxPYhcDrQD9jzFnGmO9hDQH/GdByZYdS7aykpISCggLPfW7uG561w1elOh5/E9QYYL4xptY9wR6s8B4gLxiBBZJ76ATVMXmPZutLcXFxg+QUGxvL8ccf77nxWSnVsfiboFYDJzUzfQLwVeDCCbzExER27txJTU2N3yc6FT5cLhfFxcVHHSiwuLiYwsLCBslpypQp2juEUh2Yr/ugbvJ6WQg8JiITgHzACYwGbgTmBzXCNsrOzubAgQMUFRW1ax98KnDi4uLIzs5ucb675OR0OoHvSk5JSUntFaJSKgiO1pu5tz3A2fbD7QBwDVbjibAUERFBRkYGGRk6Ikhn1Dg5xcXFMWXKFE1OSnUCvu6DGtiegSjVWgcPHqSwsFCTk1KdVIt1UCJyVWs2JCIOEbmm7SEpdXRlZWUNGkTExcXpZT2lOhlfl/hyReT/AU8Crxljdje3kIhkAD8CbgD+689ORSQPeMs9Eq+IxACPAZdg1W/9wRjze7+PQnUp5eXl5OfnU1trNSqNiYlh8uTJJCYmhjgypVQg+brE93O7UcRc4BER+Qqr94gDgAPoidX8fCjwDnC1MabQ185ExAFci3WTr7d5gACDge7Af0RkpzHmhWM6KtVpufvWq66uBqyBBidPnqyt9ZTqhHx2dWSMWQlcICIDgXOwmpUPAeqxGk38GXjbGLPNz/3NA87DalRxh9f0q7AS3EHgoIg8BMwENEEpj6qqKvLz86msrASsAR3z8vLo3r17iCNTSgWDX33xGWO+BRYEYH9PGmPmisgp7gkikgL0puH9VF8DowKwP9VJ1NbWNuiVPCIigokTJ5KWlhbiyJRSweLvjboBYYzZ1cxkd612hde0CiAh+BGpjsDpdFJYWMjhw4cBq1fy8ePH07NnzxBHppQKpnZNUC1wD9QT7zUtASgPQSwqzLhcLlavXt1gJNyxY8dqx69KdQEhT1B2vdMerEYSbsMI8y6UVPC5XC7WrVvHnj17PNNGjhzps1cJpVTn4fd4UEH2InCXiHyBdclvNvCn0IakQu2bb76hqKjI83rw4ME6Eq5SXUhrBizMxRoHKhqrmbmHMaatDSjmAg9jNWOPAP6Cdf+V6qK2bdvWYPj5rKwshg8fHsKIlFLtza8EJSJzsIbWKAEON5rtopUt/IwxHwEpXq+rgJvth+ri9u7dyxdffOF53bNnT8aOHYvD4fCxllKqs/G3BHUdcKcx5r5gBqPUoUOHWL16tWdolO7duzNhwgQiIkJeXaqUamf+fut7AEuCGYhSVVVVDcZ0SkhIYNKkSURFhUtVqVKqPfmboF4GLg9mIKprq6uro7CwkKqqKsDqwigvL4/Y2NgQR6aUChV/f5pWAreJyKXAN0CN90xjzA8CHZjqOlwuF2vWrOHQoUPAdzfiav96SnVt/iaoBODvwQxEdV0bNmxocK/TqFGjtJcIpZTfffH9ONiBqK6pqKiIzZs3e14PHjyY/v37hzAipVS4aM19UKOAW4GRWHVXXwN/NsZ8FqTYVCe3f/9+1q1b53ndq1cvvddJKeXhVyMJETkHWI3Vmu9l4J9AMrBMRM4MXniqszp8+DArV670NCdPSUkhNzdX73VSSnn4W4K6D7jXGDPPe6KI3IF1A+97gQ5MdV61tbWsWLHC05w8Pj6eiRMnanNypVQD/jYzHw78rZnpL6HjNqlWcPdO7h7XKTIykokTJxIXFxfiyJRS4cbfBLUNyG1m+nhgX+DCUZ3dhg0b2Lfvu3+ZsWPH6oi4Sqlm+XtN5XHgSRHJBvLtaVOAOcADwQhMdT47duxo0GIvJyeHPn36hDAipVQ487eZ+Z9FJBm4DUi3J+8C7jLGPBas4FTnUVpa2qAD2MzMTETExxpKqa7O71ppu6PY+0QkA6g0xjTu1VypZlVXV7NixQqcTicAycnJjBs3TlvsKaV8ajFBichNwDPGmCr7eeP5nucBGA9KdVL19fWsXLmyQR972mJPKeUPX2eJXwGLgSr7eUtaPR6U6jrWr19PSUkJ8F0fe4mJiSGOSinVEbSYoIwxA5t73piI6HUa1axt27Y1GLJ9xIgR2seeUspv/vYksUVE0pqZ3gfYG/CoVIdXWlraoBuj7OxsBg5s8XeOUko14asO6gLgRPvlAOC3IlLRaLEhQYpLdWA1NTWsXLmS+vp6ALp168bo0aO1UYRSqlV81UF9DvwccJ9Vcmk4DpQLKAeuCk5oqiNy9xRRWVkJWI0iJkyYQGRkZIgjU0p1NL7qoIqA0wBE5FngFmNMWXsFpjomYwz79+/3vM7NzdVGEUqpY+L3eFAiEiUiWYD7p7ADiAXGG2P+EawAVcexZ88evvnmG8/roUOHkpmZGcKIlFIdmV8JSkSmAc8CTRpKAAcBTVBdXHl5OWvWrPG8zsjIYOjQoSGMSCnV0fnbWezvsYbUyAMOA6cC/wfsAX4anNBUR1FXV8fKlSs9w2ckJCTo2E5KqTbzN0HlAL81xqzCGrgw0RizBCs5+bqJ128iMllECkXkkIhsEpHrArFdFVwul4vPP/+cw4etnq8iIyOZMGECMTExIY5MKdXR+ZugKoF6+/lGYIz9fBXQ5us4IhIBvIE1hHx3rNLZYyIyxveaKtS2bt3Krl27PK9HjRqlw2copQLC3wT1P+BOEUkBVgIXiUg0cAoQiJZ9qUAG4LB7pnABdTRs1q7CTGlpKV999ZXndf/+/enbt28II1JKdSb+Jqj/B0wErgH+DiRiJaZngUfbGoQxphh4DHgeqAVWALcbYza0ddsqOGpqali1apXnZtyUlBSOO+64EEellOpM/EpQxphNxpjhwBPGmAqsxhKXAMcbY+5vaxD2Jb4q4EdAPFbJ7C4RObOt21aB53K5WLt2LRUVVsci0dHRjB8/nogIf3/vKKXU0fnq6ijhKNM/dL+2k1ZbXAycYIxxN7hYJiJPAzOxWg+qMLJlyxb27v2uC8axY8eSkNDsv4tSSh0zX/dBlWPVBfmjrf3Y9MW66ddbHdblPhVGSkpK2LDhuyuvgwYNolevXiGMSCnVWflKUKe2WxRWKen3InIDsBAYB1wPaFPzMFJdXc2qVatwuazfLampqQwfPjzEUSmlOitfffEta68gjDFfisjFwD3Ag1g3AP/GGPNGe8WgfHO5XKxZs8YzMm5MTIzWOymlgsrfro5W4ONynzEmr62BGGPeBt5u63ZUcGzatKlJJ7Dx8fEhjEgp1dn5laCAt5pZbxBwHnB3IANS4efAgQMYYzyvc3JyyMjICGFESqmuwN/ezOc1N11ErgEuAB4JZFAqfFRVVbF69WpPvVOPHj0QkRBHpZTqCtpagfAB8L1ABKLCj3vwwerqagBiY2MZN26cdgKrlGoX/tZBNXeTS3fgDmB3QCNSYcMYQ3FxMQAOh4Nx48YRFxcX4qiUUl2Fv3VQLd0TVQX8OHDhqHCxb9++JoMPpqenhzAipVRX42+CanxPlAurI9cvjTGHAxuSCrXKykpW5X9KbU090bEx9OzZk5ycnFCHpZTqYvxtJLEMQESSAAGc1mRTGcTYVAjU19ezsmA5ZTs2U1ZeRUxKJqedeqrWOyml2p1fjSREJNbuG+8AVk/jq4EDIvKIiLS1myMVRr7+6iv2fLOO8vJKXPX1pFUd5JM120MdllKqC/K3Fd+fsXoY/yGQhdV33pVYTcx/F5TIVLvbvXs3X6/6FGqqiIyMoEdMBCU9JzBquI7xpJRqf/7WQf0AON8Y84nXtFdFpARYAvw64JGpdlVRUcGqTz7AeeQQOBz0S4unx6AJxPY/jj7pSaEOTynVBfmboCppvmfxQwGMRYVIfX09Kz75iMr9OwGIjXQwdvQoUsedpHVPSqmQ8TdB3QYsEpGZQL4xpl5EjgMWAPd53ycVgLGhVDtbv3Y1+zZbQ2g4gNGDskgdqw0jlFKh5W+CegRIAj4GnCJSD0Rjnc/ygD94LauNJjqQXTu281XhpxwuqyAuNorjslLoe+L5OCL9/ddQSqng8PcsND2oUaiQKC8vJ3/pOxw+VIbL5SKiro7a7MlExieHOjSllGr1fVDxQA5W67/NepNux+V0Olm1ahX1kdFERDiIcLmIzjiOQcOHhTo0pZQC/O+LLxKrOfktfHdpr0ZEngN+aoypC1qEKii+/PJLysrKiO2eTs+4BJIdEQw+4XTSU3SMJ6VUePD3Et99wBXADOATrAR1AvAQMNd+qA5i586dFBUVeV6PnjCJAQMGhC4gpZRqhr8JagZwnT3qrdsSETkM/AVNUB1GWWkJa9es8bzOysqif//+IYxIKaWa529PEknApmambwG0i+sOoq6ulmVv/JMdX39JeXklSUlJjB49WpuTK6XCkr8JagVwczPTfwqsClw4Kpjy33mNvXv24airpmz7Jrr3yCYqSpuTK6XCk79np18DH4nIKUC+PW0yMAA4O/BhqUDbtPITdmzd4nmdmNKbAQO0jz2lVPjyqwRljFkJjAPex+ooNh14ExhmjFkevPBUIBQXbeTzFcuJjIwgOTGGbt3TOGHaRaR109FxlVLhy+/rO8aYjcBsEekBOI0xpcELSwVKVekB8v/7b+pd1oDI3bolc/qlVxMTn3CUNZVSKrT8rYNCRO4UkV3APqBYRLaKyM+DF5pqK2d1BSve/icV1VY/v5FR0Uw552JNTkqpDsHfG3XvA24A7gUKsRLbJOAOEYk2xjzY1kBEpDfwBNbw8lXAX4wxd7Z1u12Vq97JqreWsHHHAZISYoiIjGDcyWeQ0rNXqENTSim/+HuJ7zrgqkb3QX0qIpuAx4E2JyjgDawWgZlAb2CZiGwwxvw9ANvuUlwuF5uXvcUXm7ZT73JRdqSGoWMmMGDYqFCHppRSfvM3QUUBzY37vQloc8+iIjIJGAScYIypBb61WwxWtnXbXVFtVSWfb95OPVa9kzMhgzEnnBLaoJRSqpX8rYN6EFggIp52ySKSBtyP1d1RW40H1gF3i8hOEdkMXGSM2R2AbXcpLpeLtevWE5PZj2490qmP68ZZ0y8iJVn72FNKdSz+lqB+CAwHtojIdqAO6AfEAJNF5GfuBY0xGccQRxpwErAMqyQ1DPiPiOzWS3yts2nTJvbu3Qs4SMzsywln59I3+1g+EqWUCq3WDFgYTNVAmTHmbvv15yKyCLgY0ATlB1e9k/0HijHGeKYNHjyYvtnZIYxKKaWOnb/jQT0f5Di+BhJEJMYYU2NP0z54/OSqq8W88w8+3V5JelZvIiIc9OjRg+HDh4c6NKWUOmZ+3wcVZO8D+4GHRSRGREYB1wL/CG1Y4c/lcrG74D1WmCKcZXvZtWULjshoxo8fr53AKqU6tLBIUMaYKmAqVv3TbuA/wAPGmFdCGlgHULllLevWf0llndVir84RQ25uLrGxsSGOTCml2iZsLqMZY7YA54U6jo6k5sAONq/6hDInJMZHU1oXzwmnnkpW78xQh6aUUm0WNglKtY6zspzd+e+wsdi6VSwuKYkJx00id/SwEEemlFKB0WKCEpFn/N2IMeaawISj/OGqd1Ky8l3W7TpEvQsckVGk9R/G+PHjtN5JKdVp+KqDSvZ69ACuxhoDKhJwAmOwhoLXUlg727f2Yz77YhOVtfUAxGf0Y+LkKTr4oFKqU2nxjGaMudT9XET+AjxijPml9zIici/WTbWqnRzZtYWCTz5lb4WT6KgIuvXKInfS8SQlJYU6NKWUCih/f3L/H9aAhY09D6wNXDjKF5ezjjXvv8WeCicAFa5Yhg0dS58+fUIcmVJKBZ6/zcz3AKc1M30aUBS4cJQvh49UUNoti9j4OOodkWQNG83kiWNDHZZSSgWFvyWo3wJPi8hpwGrAgTUe1LnApb5WVIFRU1PDihUrcEXFkDZQoN7F2Wefpo0ilFKdll8lKGPMi8BZgAu4ErgCayiMk40x/wpeeAqs3iJWr15NRUUFAFHRMZxy+ulER0eHODKllAoev5t9GWM+BD4MYiyqGS5nHQWFq9h/YL9n2tixY0lObvMwXEopFdZ83Qf1gL8bMcbcGphwVGPL//0G6zZsICqtNz17ZSBDh9K7d+9Qh6WUUkHnqwQ10c9tuAIRiGpq0xdr+HLDlzhc4CzeSW33VIYOHRrqsJRSql34ug/qVPdzEbkSeMcYc6BdolIcOVTC+vwPiYqMoLaunqj4ZM45/1xtFKGU6jL8bWb+Z6zeJFQ7qK2t4dN/v0xtXR1J8TEkJsbxvYt+QEJ8XKhDU0qpduNvgioALgpmIMricrkoePcNDpWWAuBwwGlnn0vfflkhjkwppdqXv6346oHficgdwLdYTcw9jDF5gQ6sq1r72TJ2b/vW83rUmDH0zjkuhBEppVRo+JugCuyHCqLP13zOik8/JTE2gpjoSAZm9Wbo8d8LdVhKKRUSfiUoY8w893MR6QZEGGNKgxZVF7R923YKlr4D9U6OVDpJjosl96zv43CExaDHSinV7vw++4nIjSKyHTgIFIvIbhH5TfBC6zqOHDnCquWfEllfC0BsZAQTz7qIyLiEEEemlFKh41eCEpHZwP3Ao8BJwMnAH4FbReSW4IXX+dXU1FBQUEBkQiJp/QcRHxtN3smn03vAwFCHppRSIeVvHdTNwE+MMf/wmvapiBQB9wJ/CnhkXYDT6aSwsJAjR44AEJOUwrk/OpUemTp8hlJK+ZugegIrmpm+CsgOXDhdh8vlYsXKVRw8eBAAh8PBuHHj6JGp3RgppRT4Xwe1nuaH1fgh8HXgwukaXC4Xyz78H2s++R8VFVUAjBw5UvvYU0opL/6WoOYC/xaRKcBye9oU4Gzg4mAE1pmtWrUWs/IzIutrOVj0Db3zTmLgQK1zUkopb/6OB/UecDpQjTUe1CVAGTDRGPNWIAMSkRQR2SYiVwdyu+Fix7YiNq38HxGuOgBSouC4HE1OSinVmK/hNs4GPjbGHAEwxvwP+F87xPQk0Cn79dm7dw8rPniHyPpquiXG4Kqp45Tzp5OWpdV4SinVmK9LfP8G6kRkJfCB/fjMGFMdrGBE5CqgG7AuWPsIlZKSEvL/+zZ1FWUAJMdGcsLZZ9J9yIgQR6aUUuHJV4JKB07Aqms6EfgFECEi+XyXsAqMMc5ABCIiA4G7gOOB/wRim+HiYOkhPn3/HWoOWaOVxEY6yMubSPchuSGOTCmlwpev8aAOAm/ZD0QkEhiHlbCmANcA6SLysTHmvLYEYW/7r8BsY8weEWnL5sJKeXk5r7/yBvUl20iKjyY2KoKJo4bRY/RJoQ5NKaXCmt9dHdklpR3AbmAfsM1ef1AA4rjT2oV5NQDbChtVVVX861/vUHNgG05nPUcqahg1MItek87WPvaUUuoofDYzF5Ek4BTgDOB7wDBgO/Ah8DTwI2PMrgDEcRnQR0TcTdaTgQUikmeMuSkA2293NTU15OfnU1+2B4erHgcwuGd3Bky9EEdkdKjDU0qpsOerFd/HQB5W57AfYXVn9IExZlOggzDGDGu077XAI8aY5wK9r/ZQW1tLfn4+hw8fpnuf/kRFRpDpqmTyRf9HZFxiqMNTSqkOwVcJ6gSsS3rPYDWIWG6MqW2XqDowd3I6dOgQAI6ICE4850J6pSQSlZQa4uiUUqrj8JWgBmFd2jsduBFIFJFPgKVYCWu1McYVjKCMMWODsd1gq6ur47PlyymzkxPA6NGjyc7W+5yUUqq1fLXi2wossh+IyBjgNKyEdSdQKyIfAUuNMQuCHmmYq6urY/nyfDZ88SURDsjsm8XYMWPo169fqENTSqkOqTWt+D43xvwRuAArSS0GzsQaI6pLq6uro6CggA3rNxBRvh8O76eu+CBZWZ2yQwyllGoXR+0sVkSygUnAZPvvOKAO+AxrLKiPghhf2Kurq6OwsJADu7YTV3WAKqBnrIOctEgiHaGOTimlOi5frfhewUpIvYHDwKfAm8BsYFWgepDoyGpraykoKKB47y5qDuwgPjaSfslRpCSnMPzs7+OI9LezeKWUUo35OoPGAo9glZBWG2Pq2yWiDqK6upqCggIO7t9Lzb5t4KpnUGosAzLT6D55OpGx8aEOUSmlOjRfjSSmtWcgHUlVVRXLly/nwN49cHAnuOrJSYujb3p3uudNIyohOdQhKqVUh6fXoFqpoqKC5cuXs2fnLsp3F5EQE8GYPklkpSVbyUnvdVJKqYDQBNUK5eXl5OfnU7J3N+W7t+JwuUhxQJQjmu6TLiCqW49Qh6iUUp2GJig/lZSUsGLFCmpqaoiNiyM2KpL0yHq6JyXR97Tva3JSSqkA0y61/bBnzx7y8/OpqakBICYhidOnnU9mZiajL7qS5PSMEEeolFKdj5agjmLr1q0UrlxDfKz1VsXGxpKXl0dKSgrZQ0fqsBlKKRUkmqBa4HK52LDhaz7LX0nNgZ0kZ2aT1bcPkyZNIjHR6pFck5NSSgWPnmGbUV9fz9q1a1mRX4BzfxFR9TU4929jwIAcT3JSSikVXFqCaqS6upoVK1awf6shvvIAdREu4nCQ0yOGzPi6UIenlFJdhiYoL4cOHaJw+aeU7dxCfXUFDoeDIT0TSYuPR878PjGp2hhCKaXaiyYoW9H2HXz24QdEVeyHequbwcGpsQwaNIhuY88gQrsuUkqpdtXlE5TL5eKjj1ewYeWnRNUcJjkhhtjoCEZmJNB3zBTiB4/D4dBuyZVSqr11+QRVVLSVrWuWEVVTCUBtdS3H52TTZ/I5RKf2CnF0SinVdXX5Vnzl5Ufolp6BwwFJ0RHkjR1F3zN+pMlJKaVCrMuXoIYMGYLL5eJIchwjRo0iecBwvaSnlFJhoMsnqLi4OEaNGgWjRoU6FKWUUl66/CU+pZRS4UkTlFJKqbCkCUoppVRYCps6KBH5HnA/kAPsAx40xjwV2qiUUkqFSliUoESkL/AKcC+QAvwf8HsROSukgSmllAqZcClBDQD+box5zX69QkQ+Ak4A3g1VUEoppUInLBKUMeZj4GP3axFJA04CXvRj9UiwRr1VSikVnrzO0ZH+rhMWCcqbiHQH/gUUAG/4sUpvgMsvvzyYYSmllAqM3sBmfxYMqwQlIkOxktJXwOXGmHo/VluBVdraDTiDGJ5SSqljF4mVnFb4u4LD5XIFL5xWEJGTsZLTk8DtxpjwCEwppVRIhEWCEpHBwBpgjjHm0VDHo5RSKvTCJUH9AfgFcKTRrMeNMb8OQUhKKaVCLCwSlFJKKdVYWNyoq5RSSjWmCUoppVRY0gSllFIqLGmCUkopFZY0QSmllApLYdWTRKCJSB7wljEmw37dE/gTcBZQDTwD3GWMcdrzXwB+ANR5bWa0MWaLiPQDngYmYw0HMssY83a7HYytpWFJRCQFWAR8DygH7jDGPGuv4wDuAW4AYoBngV8ZY+rs+T8Afod1l/cy4GpjzL5wPy57vW1AD8DdHHWnMUbseadifd6Dgc+BK40xfnWxEkhHG0pGRHpg3V1/sTFmrdf0WcCvge5YN7HPNMYcsed19GP7HzCRhr2/dDfGOEVkDNYN+6OBLcA1xhi/ex8IFB//k4OBR7HOBdXAEuBWY0x1R/iu2XG0+tjs9dr1+9YpS1Ai4hCR64D3sP5J3J4HMoDhwHFAHvBbr/njgOnGmCSvxxZ73kvAF1gfzvXASyIyKMiH0sBRhiV5AuvL3hs4D7hfRKbaq94AXIx1fDlYJ4bb7W2OwEq8V2Md2zdYx9pujvW4RCQdyAIyvD4v8Zr3OjDP3uZrwLsi0q7/80cbSsbuQeVTYGCj9c4C5mD9mOoNxGGdODrDsTmAsUBuo++aU0RisJLxYnub9wHviUi39jouO0Zfx/YasA7ohfWdmgzcZa8a1t81O45jOrZQfN86ZYLCepNuxPoAABCRBOBs4BfGmH3GmBLgTuB6O6HFA8OAtY03ZvcROAGYa4ypMcZ8gNWh7bXBP5QGBmAPS2KMqbd/VX4EnA5cAtxpjKmwf6kuxPqyAFwFPGKM2WGM2Q/cDcy0510BvGmM+cQYUwXcBpwgIjntdVAc+3GNB75xlyoauRj40hjzijGm1hjzIBBrb7M9DaD5YztBRE7HOkHd08x6VwHPGGO+NMaUA78BfiQiSXT8YxuK1S/bxmbmnQJEG2MesY/tJeBL4IdBiN+XATR/bNOw+v28xz4X7Ab+Bpxorxfu3zU49mNr9+9bZ73E96QxZq6InOI1zZ2Mvd9cJ9ATK+MPw7q0t1BEJgPbsRLSW8AIYFujD+ZrrBJYu/ExLMnHWEXubxrFd4H9fARWB7ze8/rY648AVnrto0JEtgOjGm0vaNpwXOOACBEpxPqVvhr4uTFmA02PGcBgHdf7QTiMZh1lKJm1wED70tBfG606AvC+hLwZ6394KB3/2MYBh4GlInIcVuy/MsYsxzq2DY2W/xrr2NqNj2O7wRgzy2u6A7gQq6s2CPPvmr3fYz22dv++dcoSlDFmVzPTyrEu+T0gImn2tfG59ux4IBnrQ5sH9MG6tLDEvh6eBFQ02mQFkBCcIzi6RsOSrAKqGnWw6x1f4/jdzxOamdd43XbVyuNyAoVYv976Y32R3rFLy2F1XNB0KBljTLH72n4zGsRvvwdVhOFnBq0+tmh7uZ8A2VglrXdEpBU4aTsAAAWiSURBVA8d4Ni8pjv4rs7lPntyh/muQauPrd2/b521BNWSK7He9A3AfuAPwPlAqTHmPawE5vaKiPwY69f6eqwk5i0Bq9K+3TUelgSrTi1ORBxeJ3Pv+I7QMH73P015M/Mar9tuWntcxpgHGq1/G3AT1qWIIzT9coTNZ2aOPpRMg8/FPmHE8d1n1mGPzRjzAvCC16THROQnWJeDwub/EVo+NhFJxiopDgWmejV06BDfNWj9sYXi+9YpS1A+9MZqCZVpjDkO2AlssIva54vIVY2Wj8H61foV0M+up3IbRtMi7f9v7/5CrKqiOI5/bZSgqMiXCMEmevhRQQUWofQmFZFGZP+QlEyth6DGmCwboj+jaFlCWFKBFBUVKtpDpA/9I8oKgqgRczETqC9F/zAylILoYe2J48XJ1O655zq/D8iMd9+re925e9Y5++yzV9uVC8+fkxckbyxz2cPABA69GF3t305ALW3fRcS+1rZyNDSVmmM7lrgk9Um6otLWQx50jf7MqjEf8to6jRHbkbT2/zzyvRg+TBt0UWyS5ku6ruXh6lhrdGySzga2k8lmekTsqbys8WOt/N9HHVsnxtt4O4NaA+yQ1E9+MJ4Ani1tPcAzkr4hp5ZuAWYAiyJir6SvgBXlqGEGOTc7vc7OlyWgb9NSliQi9kvaQq7EWUj+MltMrhaCPBrql/QeeaTzaHkM4HXg43K97lNgJfBlRBzuAnZbHEdcvcA8SbOAfeTPc5icG99DTufeTK4ouhf4i7wYXJuxYvsPXgXWS9pELrVeBWyOiN/Le9LNsU0GBstY201WMjgN2EYubZ4gaQk5NueQy823/I9dP6KxYpM0CdhK/uKdG+UWlYpGjzU4rth6qXm8jbcEtZhcBfYL+QavjYh1ABHxlqQB4A1yieUuYFZE7C2vnQO8SN4z8BOwMCJ21Nz/u8mBvFLSysrjz5ErhdaRH5SDwIqI2FranwfOIo+MTgE2Uq6/RcSQpDvKc6aQR1U3tT+UQxxrXA8CT5Nz4aeS95XMLgPrB0mzySnd9eRKsNkR8UcN8VSNGVv8SymZiHhH0iA5BTMZeJeyGiwiujo2st9nAh+Ur18AV0fEbwCSriE/j4+TCez6siKuTmPFNgxcTE5//Sr9c9LwdUTMoPljDY49ttrHm8ttmJlZI423a1BmZtYlnKDMzKyRnKDMzKyRnKDMzKyRnKDMzKyRnKDMzKyRnKDM2kTSm5J+LJtxtrYNSNovqbcDXTPrCk5QZu3TR94MX70ZEknnkrWeBiJidwf6ZdYVnKDM2iQividr/iySdHmlaS1ZjuJotgcyG3e8k4RZG5VdyD8hN0O9jNwdfwNZTXZ009sFZNXVKeRO+wMRsa20TSSL/s0ly8D8TG7H1R9ZgfY1cs+z88m9Cm+IiA9rC9CsjXwGZdZGpUzIneSGpwuAp4DlleR0LbmJ8UB5znpgi6TRYpjLyJLc88gS4suAe8jqp6NuI/dAmwl81uaQzGoz3jaLNatdROyQtAZ4gTxDWlVpfghYFREbyt9HJF0K3AfcCgwBt0fER6X9JUlLyQqmowXmdkZEa9Vas67nBGVWj8eAB4DBiPiz8vgFwDRJD1cem0Spo1N22Z8paTW5y/RFZNmDnsrzv21nx806xVN8ZjWIiAPl2wMtTROB+4FLKn8uJOuNIWk5WbLhpPL1KrLCc1Xrv2l2QvAZlFln7QLOiYiR0QfK2dRBYDVZUruvlEmnVHWeSlbXNTuhOUGZddaTwCuSAngfuBJ4hLz+BFlcc5ak7cAZ5FTh6cDJHeirWa08xWfWQRGxkSx5vpS87rQEuCsiNpWnzCdX7w0Bm4ER4GVgWu2dNauZ74MyM7NG8hmUmZk1khOUmZk1khOUmZk1khOUmZk1khOUmZk1khOUmZk1khOUmZk1khOUmZk10t8QnHlvpzUN3wAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "system.t_end = 2250\n",
+    "results = run_simulation(system, update_func_quad)\n",
+    "plot_results(census, un, results, 'World population projection')\n",
+    "savefig('figs/chap04-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The population in the model converges on the equilibrium population, `-alpha/beta`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.856665141368708"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results[system.t_end]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "13.88888888888889"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "-system.alpha / system.beta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:**  What happens if we start with an initial population above the carrying capacity, like 20 billion?  Run the model with initial populations between 1 and 20 billion, and plot the results on the same axes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p0_array = linspace(1,20,9)\n",
+    "system.t_end = 2250\n",
+    "\n",
+    "for system.p_0 in p0_array:\n",
+    "    results = run_simulation(system, update_func_quad)\n",
+    "    plot(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Comparing projections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can compare the projection from our model with projections produced by people who know what they are doing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "table3 = tables[3]\n",
+    "table3.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`NaN` is a special value that represents missing data, in this case because some agencies did not publish projections for some years."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "table3.columns = ['census', 'prb', 'un']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function plots projections from the UN DESA and U.S. Census.  It uses `dropna` to remove the `NaN` values from each series before plotting it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def plot_projections(table):\n",
+    "    \"\"\"Plot world population projections.\n",
+    "    \n",
+    "    table: DataFrame with columns 'un' and 'census'\n",
+    "    \"\"\"\n",
+    "    census_proj = table.census / 1e9\n",
+    "    un_proj = table.un / 1e9\n",
+    "    \n",
+    "    plot(census_proj.dropna(), 'b:', label='US Census')\n",
+    "    plot(un_proj.dropna(), 'g--', label='UN DESA')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the model until 2100, which is as far as the other projections go."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system = System(t_0=t_0, \n",
+    "                t_end=2100,\n",
+    "                p_0=p_0,\n",
+    "                alpha=0.025,\n",
+    "                beta=-0.0018)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = run_simulation(system, update_func_quad)\n",
+    "\n",
+    "plot_results(census, un, results, 'World population projections')\n",
+    "plot_projections(table3)\n",
+    "savefig('figs/chap04-fig02.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "People who know what they are doing expect the growth rate to decline more sharply than our model projects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Exercises\n",
+    "\n",
+    "**Optional exercise:** The net growth rate of world population has been declining for several decades.  That observation suggests one more way to generate projections, by extrapolating observed changes in growth rate.\n",
+    "\n",
+    "The `modsim` library provides a function, `compute_rel_diff`, that computes relative differences of the elements in a sequence.  It is a wrapper for the NumPy function `ediff1d`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%psource compute_rel_diff"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's how we can use it to compute the relative differences in the `census` and `un` estimates:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alpha_census = compute_rel_diff(census)\n",
+    "plot(alpha_census)\n",
+    "\n",
+    "alpha_un = compute_rel_diff(un)\n",
+    "plot(alpha_un)\n",
+    "\n",
+    "decorate(xlabel='Year', label='Net growth rate')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Other than a bump around 1990, net growth rate has been declining roughly linearly since 1965.  As an exercise, you can use this data to make a projection of world population until 2100.\n",
+    "\n",
+    "1. Define a function, `alpha_func`, that takes `t` as a parameter and returns an estimate of the net growth rate at time `t`, based on a linear function `alpha = intercept + slope * t`.  Choose values of `slope` and `intercept` to fit the observed net growth rates since 1965.\n",
+    "\n",
+    "2. Call your function with a range of `ts` from 1960 to 2020 and plot the results.\n",
+    "\n",
+    "3. Create a `System` object that includes `alpha_func` as a system variable.\n",
+    "\n",
+    "4. Define an update function that uses `alpha_func` to compute the net growth rate at the given time `t`.\n",
+    "\n",
+    "5. Test your update function with `t_0 = 1960` and `p_0 = census[t_0]`.\n",
+    "\n",
+    "6. Run a simulation from 1960 to 2100 with your update function, and plot the results.\n",
+    "\n",
+    "7. Compare your projections with those from the US Census and UN."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Solution goes here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Related viewing:** You might be interested in this [video by Hans Rosling about the demographic changes we expect in this century](https://www.youtube.com/watch?v=ezVk1ahRF78)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap08.ipynb b/code/chap08.ipynb
index 0f16233f..c8e00803 100644
--- a/code/chap08.ipynb
+++ b/code/chap08.ipynb
@@ -563,7 +563,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap14.ipynb b/code/chap14.ipynb
index 95fd99e7..d67fbed0 100644
--- a/code/chap14.ipynb
+++ b/code/chap14.ipynb
@@ -517,7 +517,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/chap20-MINE.ipynb b/code/chap20-MINE.ipynb
new file mode 100644
index 00000000..184b4371
--- /dev/null
+++ b/code/chap20-MINE.ipynb
@@ -0,0 +1,2012 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Chapter 20\n",
+    "\n",
+    "Copyright 2017 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim.py module\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dropping pennies\n",
+    "\n",
+    "I'll start by getting the units we need from Pint."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "second"
+      ],
+      "text/latex": [
+       "$second$"
+      ],
+      "text/plain": [
+       "<Unit('second')>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = UNITS.meter\n",
+    "s = UNITS.second"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And defining the initial state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>y</th>\n",
+       "      <td>381 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>v</th>\n",
+       "      <td>0.0 meter / second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "y             381 meter\n",
+       "v    0.0 meter / second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = State(y=381 * m, \n",
+    "             v=0 * m/s)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Acceleration due to gravity is about 9.8 m / s$^2$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "9.8 meter/second<sup>2</sup>"
+      ],
+      "text/latex": [
+       "$9.8 \\frac{meter}{second^{2}}$"
+      ],
+      "text/plain": [
+       "<Quantity(9.8, 'meter / second ** 2')>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g = 9.8 * m/s**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we call `odeint`, we need an array of timestamps where we want to compute the solution.\n",
+    "\n",
+    "I'll start with a duration of 10 seconds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "10 second"
+      ],
+      "text/latex": [
+       "$10 second$"
+      ],
+      "text/plain": [
+       "<Quantity(10, 'second')>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_end = 10 * s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we make a `System` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>init</th>\n",
+       "      <td>y             381 meter\n",
+       "v    0.0 meter / secon...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>g</th>\n",
+       "      <td>9.8 meter / second ** 2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>10 second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init     y             381 meter\n",
+       "v    0.0 meter / secon...\n",
+       "g                                  9.8 meter / second ** 2\n",
+       "t_end                                            10 second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(init=init, g=g, t_end=t_end)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And define the slope function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def slope_func(state, t, system):\n",
+    "    \"\"\"Compute derivatives of the state.\n",
+    "    \n",
+    "    state: position, velocity\n",
+    "    t: time\n",
+    "    system: System object containing `g`\n",
+    "    \n",
+    "    returns: derivatives of y and v\n",
+    "    \"\"\"\n",
+    "    y, v = state\n",
+    "    unpack(system)    \n",
+    "\n",
+    "    dydt = v\n",
+    "    dvdt = -g\n",
+    "    \n",
+    "    return dydt, dvdt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It's always a good idea to test the slope function with the initial conditions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 meter / second\n",
+      "-9.8 meter / second ** 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "dydt, dvdt = slope_func(init, 0, system)\n",
+    "print(dydt)\n",
+    "print(dvdt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we're ready to call `run_ode_solver`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The solver successfully reached the end of the integration interval.'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results, details = run_ode_solver(system, slope_func, max_step=0.5*s)\n",
+    "details.message"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here are the results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>y</th>\n",
+       "      <th>v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0.000000</th>\n",
+       "      <td>381.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.000102</th>\n",
+       "      <td>381.000000</td>\n",
+       "      <td>-0.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.001122</th>\n",
+       "      <td>380.999994</td>\n",
+       "      <td>-0.011000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.011327</th>\n",
+       "      <td>380.999371</td>\n",
+       "      <td>-0.111000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.113367</th>\n",
+       "      <td>380.937025</td>\n",
+       "      <td>-1.110997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.613367</th>\n",
+       "      <td>379.156526</td>\n",
+       "      <td>-6.010997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1.113367</th>\n",
+       "      <td>374.926028</td>\n",
+       "      <td>-10.910997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1.613367</th>\n",
+       "      <td>368.245529</td>\n",
+       "      <td>-15.810997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2.113367</th>\n",
+       "      <td>359.115031</td>\n",
+       "      <td>-20.710997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2.613367</th>\n",
+       "      <td>347.534532</td>\n",
+       "      <td>-25.610997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3.113367</th>\n",
+       "      <td>333.504034</td>\n",
+       "      <td>-30.510997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3.613367</th>\n",
+       "      <td>317.023535</td>\n",
+       "      <td>-35.410997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4.113367</th>\n",
+       "      <td>298.093036</td>\n",
+       "      <td>-40.310997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4.613367</th>\n",
+       "      <td>276.712538</td>\n",
+       "      <td>-45.210997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.113367</th>\n",
+       "      <td>252.882039</td>\n",
+       "      <td>-50.110997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.613367</th>\n",
+       "      <td>226.601541</td>\n",
+       "      <td>-55.010997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6.113367</th>\n",
+       "      <td>197.871042</td>\n",
+       "      <td>-59.910997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6.613367</th>\n",
+       "      <td>166.690544</td>\n",
+       "      <td>-64.810997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7.113367</th>\n",
+       "      <td>133.060045</td>\n",
+       "      <td>-69.710997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7.613367</th>\n",
+       "      <td>96.979547</td>\n",
+       "      <td>-74.610997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.113367</th>\n",
+       "      <td>58.449048</td>\n",
+       "      <td>-79.510997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.613367</th>\n",
+       "      <td>17.468550</td>\n",
+       "      <td>-84.410997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9.113367</th>\n",
+       "      <td>-25.961949</td>\n",
+       "      <td>-89.310997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9.613367</th>\n",
+       "      <td>-71.842448</td>\n",
+       "      <td>-94.210997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10.000000</th>\n",
+       "      <td>-109.000000</td>\n",
+       "      <td>-98.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                    y          v\n",
+       "0.000000   381.000000   0.000000\n",
+       "0.000102   381.000000  -0.001000\n",
+       "0.001122   380.999994  -0.011000\n",
+       "0.011327   380.999371  -0.111000\n",
+       "0.113367   380.937025  -1.110997\n",
+       "0.613367   379.156526  -6.010997\n",
+       "1.113367   374.926028 -10.910997\n",
+       "1.613367   368.245529 -15.810997\n",
+       "2.113367   359.115031 -20.710997\n",
+       "2.613367   347.534532 -25.610997\n",
+       "3.113367   333.504034 -30.510997\n",
+       "3.613367   317.023535 -35.410997\n",
+       "4.113367   298.093036 -40.310997\n",
+       "4.613367   276.712538 -45.210997\n",
+       "5.113367   252.882039 -50.110997\n",
+       "5.613367   226.601541 -55.010997\n",
+       "6.113367   197.871042 -59.910997\n",
+       "6.613367   166.690544 -64.810997\n",
+       "7.113367   133.060045 -69.710997\n",
+       "7.613367    96.979547 -74.610997\n",
+       "8.113367    58.449048 -79.510997\n",
+       "8.613367    17.468550 -84.410997\n",
+       "9.113367   -25.961949 -89.310997\n",
+       "9.613367   -71.842448 -94.210997\n",
+       "10.000000 -109.000000 -98.000000"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here's position as a function of time:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving figure to file figs/chap09-fig01.pdf\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_position(results):\n",
+    "    plot(results.y, label='y')\n",
+    "    decorate(xlabel='Time (s)',\n",
+    "             ylabel='Position (m)')\n",
+    "\n",
+    "plot_position(results)\n",
+    "savefig('figs/chap09-fig01.pdf')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Onto the sidewalk\n",
+    "\n",
+    "To figure out when the penny hit the sidewalk, we can use `crossings`, which finds the times where a `Series` passes through a given value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([8.81788535])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_crossings = crossings(results.y, 0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this example there should be just one crossing, the time when the penny hits the sidewalk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "8.817885349720552 second"
+      ],
+      "text/latex": [
+       "$8.817885349720552 second$"
+      ],
+      "text/plain": [
+       "<Quantity(8.817885349720552, 'second')>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_sidewalk = t_crossings[0] * s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can compare that to the exact result.  Without air resistance, we have\n",
+    "\n",
+    "$v = -g t$\n",
+    "\n",
+    "and\n",
+    "\n",
+    "$y = 381 - g t^2 / 2$\n",
+    "\n",
+    "Setting $y=0$ and solving for $t$ yields\n",
+    "\n",
+    "$t = \\sqrt{\\frac{2 y_{init}}{g}}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "8.817885349720552 second"
+      ],
+      "text/latex": [
+       "$8.817885349720552 second$"
+      ],
+      "text/plain": [
+       "<Quantity(8.817885349720552, 'second')>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sqrt(2 * init.y / g)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The estimate is accurate to about 10 decimal places."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Events\n",
+    "\n",
+    "Instead of running the simulation until the penny goes through the sidewalk, it would be better to detect the point where the penny hits the sidewalk and stop.  `run_ode_solver` provides exactly the tool we need, **event functions**.\n",
+    "\n",
+    "Here's an event function that returns the height of the penny above the sidewalk:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def event_func(state, t, system):\n",
+    "    \"\"\"Return the height of the penny above the sidewalk.\n",
+    "    \"\"\"\n",
+    "    y, v = state\n",
+    "    return y"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And here's how we pass it to `run_ode_solver`.  The solver should run until the event function returns 0, and then terminate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>sol</th>\n",
+       "      <td>None</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_events</th>\n",
+       "      <td>[[8.81788534972056]]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nfev</th>\n",
+       "      <td>38</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>njev</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>nlu</th>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>status</th>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>message</th>\n",
+       "      <td>A termination event occurred.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>success</th>\n",
+       "      <td>True</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "sol                                  None\n",
+       "t_events             [[8.81788534972056]]\n",
+       "nfev                                   38\n",
+       "njev                                    0\n",
+       "nlu                                     0\n",
+       "status                                  1\n",
+       "message     A termination event occurred.\n",
+       "success                              True\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results, details = run_ode_solver(system, slope_func, events=event_func)\n",
+    "details"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The message from the solver indicates the solver stopped because the event we wanted to detect happened.\n",
+    "\n",
+    "Here are the results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>y</th>\n",
+       "      <th>v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0.000000</th>\n",
+       "      <td>3.810000e+02</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.000102</th>\n",
+       "      <td>3.810000e+02</td>\n",
+       "      <td>-0.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.001122</th>\n",
+       "      <td>3.810000e+02</td>\n",
+       "      <td>-0.011000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.011327</th>\n",
+       "      <td>3.809994e+02</td>\n",
+       "      <td>-0.111000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.113367</th>\n",
+       "      <td>3.809370e+02</td>\n",
+       "      <td>-1.110997</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1.133773</th>\n",
+       "      <td>3.747013e+02</td>\n",
+       "      <td>-11.110971</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.817885</th>\n",
+       "      <td>5.684342e-14</td>\n",
+       "      <td>-86.415276</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     y          v\n",
+       "0.000000  3.810000e+02   0.000000\n",
+       "0.000102  3.810000e+02  -0.001000\n",
+       "0.001122  3.810000e+02  -0.011000\n",
+       "0.011327  3.809994e+02  -0.111000\n",
+       "0.113367  3.809370e+02  -1.110997\n",
+       "1.133773  3.747013e+02 -11.110971\n",
+       "8.817885  5.684342e-14 -86.415276"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With the `events` option, the solver returns the actual time steps it computed, which are not necessarily equally spaced. \n",
+    "\n",
+    "The last time step is when the event occurred:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "8.81788534972056 second"
+      ],
+      "text/latex": [
+       "$8.81788534972056 second$"
+      ],
+      "text/plain": [
+       "<Quantity(8.81788534972056, 'second')>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "t_sidewalk = get_last_label(results) * s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Unfortunately, `run_ode_solver` does not carry the units through the computation, so we have to put them back at the end.\n",
+    "\n",
+    "We could also get the time of the event from `details`, but it's a minor nuisance because it comes packed in an array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "8.81788534972056 second"
+      ],
+      "text/latex": [
+       "$8.81788534972056 second$"
+      ],
+      "text/plain": [
+       "<Quantity(8.81788534972056, 'second')>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "details.t_events[0][0] * s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result is accurate to about 15 decimal places.\n",
+    "\n",
+    "We can also check the velocity of the penny when it hits the sidewalk:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "-86.41527642726152 meter/second"
+      ],
+      "text/latex": [
+       "$-86.41527642726152 \\frac{meter}{second}$"
+      ],
+      "text/plain": [
+       "<Quantity(-86.41527642726152, 'meter / second')>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "v_sidewalk = get_last_value(results.v) * m / s"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And convert to kilometers per hour."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "-311.0949951381415 kilometer/hour"
+      ],
+      "text/latex": [
+       "$-311.0949951381415 \\frac{kilometer}{hour}$"
+      ],
+      "text/plain": [
+       "<Quantity(-311.0949951381415, 'kilometer / hour')>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "km = UNITS.kilometer\n",
+    "h = UNITS.hour\n",
+    "v_sidewalk.to(km / h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If there were no air resistance, the penny would hit the sidewalk (or someone's head) at more than 300 km/h.\n",
+    "\n",
+    "So it's a good thing there is air resistance."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Under the hood\n",
+    "\n",
+    "Here is the source code for `crossings` so you can see what's happening under the hood:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%psource crossings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The [documentation of InterpolatedUnivariateSpline is here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.InterpolatedUnivariateSpline.html).\n",
+    "\n",
+    "And you can read the [documentation of `scipy.integrate.solve_ivp`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html) to learn more about how `run_ode_solver` works."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercises\n",
+    "\n",
+    "**Exercise:** Here's a question from the web site [Ask an Astronomer](http://curious.astro.cornell.edu/about-us/39-our-solar-system/the-earth/other-catastrophes/57-how-long-would-it-take-the-earth-to-fall-into-the-sun-intermediate):\n",
+    "\n",
+    "\"If the Earth suddenly stopped orbiting the Sun, I know eventually it would be pulled in by the Sun's gravity and hit it. How long would it take the Earth to hit the Sun? I imagine it would go slowly at first and then pick up speed.\"\n",
+    "\n",
+    "Use `run_ode_solver` to answer this question.\n",
+    "\n",
+    "Here are some suggestions about how to proceed:\n",
+    "\n",
+    "1.  Look up the Law of Universal Gravitation and any constants you need.  I suggest you work entirely in SI units: meters, kilograms, and Newtons.\n",
+    "\n",
+    "2.  When the distance between the Earth and the Sun gets small, this system behaves badly, so you should use an event function to stop when the surface of Earth reaches the surface of the Sun.\n",
+    "\n",
+    "3. Express your answer in days, and plot the results as millions of kilometers versus days.\n",
+    "\n",
+    "If you read the reply by Dave Rothstein, you will see other ways to solve the problem, and a good discussion of the modeling decisions behind them.\n",
+    "\n",
+    "You might also be interested to know that [it's actually not that easy to get to the Sun](https://www.theatlantic.com/science/archive/2018/08/parker-solar-probe-launch-nasa/567197/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "astronomical_unit"
+      ],
+      "text/latex": [
+       "$astronomical_unit$"
+      ],
+      "text/plain": [
+       "<Unit('astronomical_unit')>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m = UNITS.meters\n",
+    "kg = UNITS.kilograms\n",
+    "N = UNITS.newtons\n",
+    "s = UNITS.seconds\n",
+    "AU = UNITS.astronomical_unit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>r</th>\n",
+       "      <td>149600000000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>v</th>\n",
+       "      <td>0.0 meter / second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "r    149600000000.0 meter\n",
+       "v      0.0 meter / second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = State(r=1.496 * 10 ** 11 * m, \n",
+    "             v=0 * m/s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>r</th>\n",
+       "      <td>149597870691.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>v</th>\n",
+       "      <td>0.0 meter / second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "r    149597870691.0 meter\n",
+       "v      0.0 meter / second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r_0 = (1 * AU).to_base_units()\n",
+    "v_0 = 0 * m / s\n",
+    "init = State(r=r_0, \n",
+    "             v=v_0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "695508000.0 meter"
+      ],
+      "text/latex": [
+       "$695508000.0 meter$"
+      ],
+      "text/plain": [
+       "<Quantity(695508000.0, 'meter')>"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r_earth = 6.371e6 * m\n",
+    "r_sun = 695.508e6 * m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def universal_gravitation(state, system):\n",
+    "    \"\"\"Computes gravitational force.\n",
+    "    \n",
+    "    state: State object with position and velocity\n",
+    "    system: System object with m1, m2, and G\n",
+    "    \"\"\"\n",
+    "    r, v = state\n",
+    "    unpack(system)\n",
+    "    \n",
+    "    force = G * m1 * m2 / r**2\n",
+    "    return force"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>init</th>\n",
+       "      <td>r    149597870691.0 meter\n",
+       "v      0.0 meter / s...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>G</th>\n",
+       "      <td>6.674e-11 meter ** 2 * newton / kilogram ** 2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m1</th>\n",
+       "      <td>1.989e+30 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>r_final</th>\n",
+       "      <td>701879000.0 meter</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>m2</th>\n",
+       "      <td>5.972e+24 kilogram</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>10000000.0 second</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "init       r    149597870691.0 meter\n",
+       "v      0.0 meter / s...\n",
+       "G              6.674e-11 meter ** 2 * newton / kilogram ** 2\n",
+       "m1                                        1.989e+30 kilogram\n",
+       "r_final                                    701879000.0 meter\n",
+       "m2                                        5.972e+24 kilogram\n",
+       "t_end                                      10000000.0 second\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(init=init,\n",
+    "                G=6.674e-11 * N / kg**2 * m**2,\n",
+    "                m1=1.989e30 * kg,\n",
+    "                r_final=r_sun + r_earth,\n",
+    "                m2=5.972e24 * kg,\n",
+    "                t_end=1e7 * s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def slope_func(state, t, system):\n",
+    "    \"\"\"Compute derivatives of the state.\"\"\"\n",
+    "    y, v = state\n",
+    "    unpack(system)\n",
+    "    \n",
+    "    force = universal_gravitation(state, system)\n",
+    "    dydt = v\n",
+    "    dvdt = -force / m2\n",
+    "    \n",
+    "    return dydt, dvdt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0 meter / second\n",
+      "-0.005931576848287442 newton / kilogram\n"
+     ]
+    }
+   ],
+   "source": [
+    "drdt, dvdt = slope_func(init, 0, system)\n",
+    "print(dydt)\n",
+    "print(dvdt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def event_func(state, t, system):\n",
+    "    \"\"\"Return the height of the penny above the sidewalk.\n",
+    "    \"\"\"\n",
+    "    r, v = state\n",
+    "    return r - system.r_final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results, details = run_ode_solver(system, slope_func,events=event_func)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>r</th>\n",
+       "      <th>v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0.000000e+00</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7.507044e-02</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.000445</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.257749e-01</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.004898</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.332819e+00</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.049427</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.340326e+01</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.494713</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341077e+02</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-4.947574</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341152e+03</th>\n",
+       "      <td>1.495977e+11</td>\n",
+       "      <td>-49.476228</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341159e+04</th>\n",
+       "      <td>1.495772e+11</td>\n",
+       "      <td>-494.807776</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341160e+05</th>\n",
+       "      <td>1.475248e+11</td>\n",
+       "      <td>-4993.821408</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3.521325e+06</th>\n",
+       "      <td>1.090879e+11</td>\n",
+       "      <td>-25666.538318</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4.749549e+06</th>\n",
+       "      <td>6.658091e+10</td>\n",
+       "      <td>-47064.540012</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.171397e+06</th>\n",
+       "      <td>4.329751e+10</td>\n",
+       "      <td>-66031.087220</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.424508e+06</th>\n",
+       "      <td>2.336962e+10</td>\n",
+       "      <td>-97997.504717</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.474343e+06</th>\n",
+       "      <td>1.813194e+10</td>\n",
+       "      <td>-113512.953200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.527604e+06</th>\n",
+       "      <td>1.132776e+10</td>\n",
+       "      <td>-147253.741576</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.562071e+06</th>\n",
+       "      <td>5.317318e+09</td>\n",
+       "      <td>-219976.380723</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.568047e+06</th>\n",
+       "      <td>3.901148e+09</td>\n",
+       "      <td>-257905.245627</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.573491e+06</th>\n",
+       "      <td>2.321078e+09</td>\n",
+       "      <td>-335967.737325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.575974e+06</th>\n",
+       "      <td>1.383932e+09</td>\n",
+       "      <td>-436325.656332</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.577122e+06</th>\n",
+       "      <td>8.207009e+08</td>\n",
+       "      <td>-567561.307137</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.577323e+06</th>\n",
+       "      <td>7.018790e+08</td>\n",
+       "      <td>-613949.168347</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                         r              v\n",
+       "0.000000e+00  1.495979e+11       0.000000\n",
+       "7.507044e-02  1.495979e+11      -0.000445\n",
+       "8.257749e-01  1.495979e+11      -0.004898\n",
+       "8.332819e+00  1.495979e+11      -0.049427\n",
+       "8.340326e+01  1.495979e+11      -0.494713\n",
+       "8.341077e+02  1.495979e+11      -4.947574\n",
+       "8.341152e+03  1.495977e+11     -49.476228\n",
+       "8.341159e+04  1.495772e+11    -494.807776\n",
+       "8.341160e+05  1.475248e+11   -4993.821408\n",
+       "3.521325e+06  1.090879e+11  -25666.538318\n",
+       "4.749549e+06  6.658091e+10  -47064.540012\n",
+       "5.171397e+06  4.329751e+10  -66031.087220\n",
+       "5.424508e+06  2.336962e+10  -97997.504717\n",
+       "5.474343e+06  1.813194e+10 -113512.953200\n",
+       "5.527604e+06  1.132776e+10 -147253.741576\n",
+       "5.562071e+06  5.317318e+09 -219976.380723\n",
+       "5.568047e+06  3.901148e+09 -257905.245627\n",
+       "5.573491e+06  2.321078e+09 -335967.737325\n",
+       "5.575974e+06  1.383932e+09 -436325.656332\n",
+       "5.577122e+06  8.207009e+08 -567561.307137\n",
+       "5.577323e+06  7.018790e+08 -613949.168347"
+      ]
+     },
+     "execution_count": 70,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x24f2c533198>]"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(results.r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results.index /= 60 * 60 * 24\n",
+    "results.r /= 1e9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(results.r, label='r')\n",
+    "\n",
+    "decorate(xlabel='Time (day)', \n",
+    "         ylabel='Distance from sun (million km)')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def event_func(state, t, system):\n",
+    "    r, v = state\n",
+    "    return r - system.r_final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "148895991691.0 meter"
+      ],
+      "text/latex": [
+       "$148895991691.0 meter$"
+      ],
+      "text/plain": [
+       "<Quantity(148895991691.0, 'meter')>"
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "event_func(init, 0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results, details = run_ode_solver(system, slope_func,events=event_func)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>r</th>\n",
+       "      <th>v</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0.000000e+00</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7.507044e-02</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.000445</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.257749e-01</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.004898</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.332819e+00</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.049427</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.340326e+01</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-0.494713</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341077e+02</th>\n",
+       "      <td>1.495979e+11</td>\n",
+       "      <td>-4.947574</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341152e+03</th>\n",
+       "      <td>1.495977e+11</td>\n",
+       "      <td>-49.476228</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341159e+04</th>\n",
+       "      <td>1.495772e+11</td>\n",
+       "      <td>-494.807776</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8.341160e+05</th>\n",
+       "      <td>1.475248e+11</td>\n",
+       "      <td>-4993.821408</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3.521325e+06</th>\n",
+       "      <td>1.090879e+11</td>\n",
+       "      <td>-25666.538318</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4.749549e+06</th>\n",
+       "      <td>6.658091e+10</td>\n",
+       "      <td>-47064.540012</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.171397e+06</th>\n",
+       "      <td>4.329751e+10</td>\n",
+       "      <td>-66031.087220</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.424508e+06</th>\n",
+       "      <td>2.336962e+10</td>\n",
+       "      <td>-97997.504717</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.474343e+06</th>\n",
+       "      <td>1.813194e+10</td>\n",
+       "      <td>-113512.953200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.527604e+06</th>\n",
+       "      <td>1.132776e+10</td>\n",
+       "      <td>-147253.741576</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.562071e+06</th>\n",
+       "      <td>5.317318e+09</td>\n",
+       "      <td>-219976.380723</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.568047e+06</th>\n",
+       "      <td>3.901148e+09</td>\n",
+       "      <td>-257905.245627</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.573491e+06</th>\n",
+       "      <td>2.321078e+09</td>\n",
+       "      <td>-335967.737325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.575974e+06</th>\n",
+       "      <td>1.383932e+09</td>\n",
+       "      <td>-436325.656332</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.577122e+06</th>\n",
+       "      <td>8.207009e+08</td>\n",
+       "      <td>-567561.307137</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5.577323e+06</th>\n",
+       "      <td>7.018790e+08</td>\n",
+       "      <td>-613949.168347</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                         r              v\n",
+       "0.000000e+00  1.495979e+11       0.000000\n",
+       "7.507044e-02  1.495979e+11      -0.000445\n",
+       "8.257749e-01  1.495979e+11      -0.004898\n",
+       "8.332819e+00  1.495979e+11      -0.049427\n",
+       "8.340326e+01  1.495979e+11      -0.494713\n",
+       "8.341077e+02  1.495979e+11      -4.947574\n",
+       "8.341152e+03  1.495977e+11     -49.476228\n",
+       "8.341159e+04  1.495772e+11    -494.807776\n",
+       "8.341160e+05  1.475248e+11   -4993.821408\n",
+       "3.521325e+06  1.090879e+11  -25666.538318\n",
+       "4.749549e+06  6.658091e+10  -47064.540012\n",
+       "5.171397e+06  4.329751e+10  -66031.087220\n",
+       "5.424508e+06  2.336962e+10  -97997.504717\n",
+       "5.474343e+06  1.813194e+10 -113512.953200\n",
+       "5.527604e+06  1.132776e+10 -147253.741576\n",
+       "5.562071e+06  5.317318e+09 -219976.380723\n",
+       "5.568047e+06  3.901148e+09 -257905.245627\n",
+       "5.573491e+06  2.321078e+09 -335967.737325\n",
+       "5.575974e+06  1.383932e+09 -436325.656332\n",
+       "5.577122e+06  8.207009e+08 -567561.307137\n",
+       "5.577323e+06  7.018790e+08 -613949.168347"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x24f2c5cf550>]"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot(results.r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/chap20.ipynb b/code/chap20.ipynb
index eccfea85..cc466991 100644
--- a/code/chap20.ipynb
+++ b/code/chap20.ipynb
@@ -668,7 +668,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/code/duringTheBreak.ipynb b/code/duringTheBreak.ipynb
new file mode 100644
index 00000000..39b06df2
--- /dev/null
+++ b/code/duringTheBreak.ipynb
@@ -0,0 +1,495 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Project 1 example\n",
+    "\n",
+    "Copyright 2018 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim library\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pandas import read_html\n",
+    "\n",
+    "filename = 'data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    if len(timeseries):\n",
+    "        plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "census = table2.census / 1e9\n",
+    "empty = TimeSeries()\n",
+    "plot_results(census, un, empty, 'World population estimates')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.278814327"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "half = get_first_value(census) / 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>young</th>\n",
+       "      <td>1.278814</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>old</th>\n",
+       "      <td>1.278814</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "young    1.278814\n",
+       "old      1.278814\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "init = State(young=half, old=half)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>birth_rate1</th>\n",
+       "      <td>0.0555556</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>birth_rate2</th>\n",
+       "      <td>0.0384615</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mature_rate</th>\n",
+       "      <td>0.025</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>death_rate</th>\n",
+       "      <td>0.025</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_0</th>\n",
+       "      <td>1950</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>t_end</th>\n",
+       "      <td>2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>init</th>\n",
+       "      <td>young    1.278814\n",
+       "old      1.278814\n",
+       "dtype: flo...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "birth_rate1                                            0.0555556\n",
+       "birth_rate2                                            0.0384615\n",
+       "mature_rate                                                0.025\n",
+       "death_rate                                                 0.025\n",
+       "t_0                                                         1950\n",
+       "t_end                                                       2016\n",
+       "init           young    1.278814\n",
+       "old      1.278814\n",
+       "dtype: flo...\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = System(birth_rate1 = 1/18,\n",
+    "                birth_rate2 = 1/26,\n",
+    "                mature_rate = 1/40,\n",
+    "                death_rate = 1/40,\n",
+    "                t_0 = 1950,\n",
+    "                t_end = 2016,\n",
+    "                init=init)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func1(state, t, system):\n",
+    "    if t < 1970:\n",
+    "        births = system.birth_rate1 * state.young\n",
+    "    else:\n",
+    "        births = system.birth_rate2 * state.young\n",
+    "    \n",
+    "    maturings = system.mature_rate * state.young\n",
+    "    deaths = system.death_rate * state.old\n",
+    "    \n",
+    "    young = state.young + births - maturings\n",
+    "    old = state.old + maturings - deaths\n",
+    "    \n",
+    "    return State(young=young, old=old)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>young</th>\n",
+       "      <td>1.317889</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>old</th>\n",
+       "      <td>1.278814</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "young    1.317889\n",
+       "old      1.278814\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = update_func1(init, system.t_0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>young</th>\n",
+       "      <td>1.358158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>old</th>\n",
+       "      <td>1.279791</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "young    1.358158\n",
+       "old      1.279791\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "state = update_func1(state, system.t_0, system)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    init: initial State object\n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    \n",
+    "    state = system.init\n",
+    "    results[system.t_0] = state.young + state.old\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        state = update_func(state, t, system)\n",
+    "        results[t+1] = state.young + state.old\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = run_simulation(system, update_func1);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_results(census, un, results, 'World population estimates')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/duringTheBreakFinal.ipynb b/code/duringTheBreakFinal.ipynb
new file mode 100644
index 00000000..840b210b
--- /dev/null
+++ b/code/duringTheBreakFinal.ipynb
@@ -0,0 +1,360 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Modeling and Simulation in Python\n",
+    "\n",
+    "Project 1 example\n",
+    "\n",
+    "Copyright 2018 Allen Downey\n",
+    "\n",
+    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure Jupyter so figures appear in the notebook\n",
+    "%matplotlib inline\n",
+    "\n",
+    "# Configure Jupyter to display the assigned value after an assignment\n",
+    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
+    "\n",
+    "# import functions from the modsim library\n",
+    "from modsim import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "BeautifulSoup4 (bs4) not found, please install it",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-8-96cf40dd9504>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mfilename\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'../data/World_population_estimates.html'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mtables\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mread_html\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mheader\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindex_col\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdecimal\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'M'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0mtable2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtables\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+      "\u001b[1;32mC:\\Miniconda3\\lib\\site-packages\\pandas\\io\\html.py\u001b[0m in \u001b[0;36mread_html\u001b[1;34m(io, match, flavor, header, index_col, skiprows, attrs, parse_dates, tupleize_cols, thousands, encoding, decimal, converters, na_values, keep_default_na, displayed_only)\u001b[0m\n\u001b[0;32m    985\u001b[0m                   \u001b[0mdecimal\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdecimal\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconverters\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mconverters\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mna_values\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mna_values\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    986\u001b[0m                   \u001b[0mkeep_default_na\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mkeep_default_na\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 987\u001b[1;33m                   displayed_only=displayed_only)\n\u001b[0m",
+      "\u001b[1;32mC:\\Miniconda3\\lib\\site-packages\\pandas\\io\\html.py\u001b[0m in \u001b[0;36m_parse\u001b[1;34m(flavor, io, match, attrs, encoding, displayed_only, **kwargs)\u001b[0m\n\u001b[0;32m    791\u001b[0m     \u001b[0mretained\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    792\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mflav\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mflavor\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 793\u001b[1;33m         \u001b[0mparser\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_parser_dispatch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mflav\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    794\u001b[0m         \u001b[0mp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mparser\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mio\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcompiled_match\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdisplayed_only\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    795\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;32mC:\\Miniconda3\\lib\\site-packages\\pandas\\io\\html.py\u001b[0m in \u001b[0;36m_parser_dispatch\u001b[1;34m(flavor)\u001b[0m\n\u001b[0;32m    741\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0m_HAS_BS4\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    742\u001b[0m             raise ImportError(\n\u001b[1;32m--> 743\u001b[1;33m                 \"BeautifulSoup4 (bs4) not found, please install it\")\n\u001b[0m\u001b[0;32m    744\u001b[0m         \u001b[1;32mimport\u001b[0m \u001b[0mbs4\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    745\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mLooseVersion\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbs4\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__version__\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mLooseVersion\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'4.2.0'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mImportError\u001b[0m: BeautifulSoup4 (bs4) not found, please install it"
+     ]
+    }
+   ],
+   "source": [
+    "from pandas import read_html\n",
+    "\n",
+    "filename = '../data/World_population_estimates.html'\n",
+    "tables = read_html(filename, header=0, index_col=0, decimal='M')\n",
+    "table2 = tables[2]\n",
+    "table2.columns = ['census', 'prb', 'un', 'maddison', \n",
+    "                  'hyde', 'tanton', 'biraben', 'mj', \n",
+    "                  'thomlinson', 'durand', 'clark']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(census, un, timeseries, title):\n",
+    "    \"\"\"Plot the estimates and the model.\n",
+    "    \n",
+    "    census: TimeSeries of population estimates\n",
+    "    un: TimeSeries of population estimates\n",
+    "    timeseries: TimeSeries of simulation results\n",
+    "    title: string\n",
+    "    \"\"\"\n",
+    "    plot(census, ':', label='US Census')\n",
+    "    plot(un, '--', label='UN DESA')\n",
+    "    if len(timeseries):\n",
+    "        plot(timeseries, color='gray', label='model')\n",
+    "    \n",
+    "    decorate(xlabel='Year', \n",
+    "             ylabel='World population (billion)',\n",
+    "             title=title)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "un = table2.un / 1e9\n",
+    "census = table2.census / 1e9\n",
+    "empty = TimeSeries()\n",
+    "plot_results(census, un, empty, 'World population estimates')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Why is world population growing linearly?\n",
+    "\n",
+    "Since 1970, world population has been growing approximately linearly, as shown in the previous figure.  During this time, death and birth rates have decreased in most regions, but it is hard to imagine a mechanism that would cause them to decrease in a way that yields constant net growth year after year.  So why is world population growing linearly?\n",
+    "\n",
+    "To explore this question, we will look for a model that reproduces linear growth, and identify the essential features that yield this behavior.\n",
+    "\n",
+    "Specifically, we'll add two new features to the model:\n",
+    "\n",
+    "1.  Age:  The current model does not account for age; we will extend the model by including two age groups, young and old, roughly corresponding to people younger or older than 40.\n",
+    "\n",
+    "2.  The demographic transition:  Birth rates have decreased substantially since 1970.  We model this transition with an abrupt change in 1970 from an initial high level to a lower level."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll use the 1950 world population from the US Census as an initial condition, assuming that half the population is young and half old."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "half = get_first_value(census) / 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init = State(young=half, old=half)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll use a `System` object to store the parameters of the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system = System(birth_rate1 = 1/18,\n",
+    "                birth_rate2 = 1/25,\n",
+    "                transition_year = 1970,\n",
+    "                mature_rate = 1/40,\n",
+    "                death_rate = 1/40,\n",
+    "                t_0 = 1950,\n",
+    "                t_end = 2016,\n",
+    "                init=init)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here's an update function that computes the state of the system during the next year, given the current state and time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_func1(state, t, system):\n",
+    "    if t <= system.transition_year:\n",
+    "        births = system.birth_rate1 * state.young\n",
+    "    else:    \n",
+    "        births = system.birth_rate2 * state.young\n",
+    "        \n",
+    "    maturings = system.mature_rate * state.young\n",
+    "    deaths = system.death_rate * state.old\n",
+    "    \n",
+    "    young = state.young + births - maturings\n",
+    "    old = state.old + maturings - deaths\n",
+    "    \n",
+    "    return State(young=young, old=old)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll test the update function with the initial condition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = update_func1(init, system.t_0, system)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And we can do one more update using the state we just computed:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = update_func1(state, system.t_0, system)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `run_simulation` function is similar to the one in the book; it returns a time series of total population."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_simulation(system, update_func):\n",
+    "    \"\"\"Simulate the system using any update function.\n",
+    "    \n",
+    "    init: initial State object\n",
+    "    system: System object\n",
+    "    update_func: function that computes the population next year\n",
+    "    \n",
+    "    returns: TimeSeries\n",
+    "    \"\"\"\n",
+    "    results = TimeSeries()\n",
+    "    \n",
+    "    state = system.init\n",
+    "    results[system.t_0] = state.young + state.old\n",
+    "    \n",
+    "    for t in linrange(system.t_0, system.t_end):\n",
+    "        state = update_func(state, t, system)\n",
+    "        results[t+1] = state.young + state.old\n",
+    "        \n",
+    "    return results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can run the simulation and plot the results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'system' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-6-1a01b3cbea2b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrun_simulation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msystem\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate_func1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m;\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m: name 'system' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "results = run_simulation(system, update_func1);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'plot_results' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-4-657dc542a5b2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mplot_results\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcensus\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mun\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'World population estimates'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m: name 'plot_results' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "plot_results(census, un, results, 'World population estimates')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This figure shows the results from our model along with world population estimates from the United Nations Department of Economic and Social Affairs (UN DESA) and the US Census Bureau.\n",
+    "\n",
+    "We adjusted the parameters by hand to fit the data as well as possible.  Overall, the model fits the data well.\n",
+    "\n",
+    "Nevertheless, between 1970 and 2016 there is clear curvature in the model that does not appear in the data, and in the most recent years it looks like the model is diverging from the data.\n",
+    "\n",
+    "In particular, the model would predict accelerating growth in the near future, which does not seem consistent with the trend in the data, and it contradicts predictions by experts.\n",
+    "\n",
+    "It seems that this model does not explain why world population is growing linear.  We conclude that adding two age groups to the model is not sufficient to produce linear growth.  Modeling the demographic transition with an abrupt change in birth rate is not sufficient either.\n",
+    "\n",
+    "In future work, we might explore whether a gradual change in birth rate would work better, possibly using a logistic function.  We also might explore the behavior of the model with more than two age groups."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/figs/chap01-fig01.pdf b/code/figs/chap01-fig01.pdf
new file mode 100644
index 00000000..545d39b9
Binary files /dev/null and b/code/figs/chap01-fig01.pdf differ
diff --git a/code/figs/chap02-fig01.pdf b/code/figs/chap02-fig01.pdf
new file mode 100644
index 00000000..9de555de
Binary files /dev/null and b/code/figs/chap02-fig01.pdf differ
diff --git a/code/figs/chap02-fig02.pdf b/code/figs/chap02-fig02.pdf
new file mode 100644
index 00000000..ab36b94e
Binary files /dev/null and b/code/figs/chap02-fig02.pdf differ
diff --git a/code/figs/chap03-fig01.pdf b/code/figs/chap03-fig01.pdf
new file mode 100644
index 00000000..fce45ddb
Binary files /dev/null and b/code/figs/chap03-fig01.pdf differ
diff --git a/code/figs/chap03-fig02.pdf b/code/figs/chap03-fig02.pdf
new file mode 100644
index 00000000..f65b8a21
Binary files /dev/null and b/code/figs/chap03-fig02.pdf differ
diff --git a/code/figs/chap03-fig04.pdf b/code/figs/chap03-fig04.pdf
new file mode 100644
index 00000000..12fd8d4f
Binary files /dev/null and b/code/figs/chap03-fig04.pdf differ
diff --git a/code/figs/chap03-fig05.pdf b/code/figs/chap03-fig05.pdf
new file mode 100644
index 00000000..0fc6d097
Binary files /dev/null and b/code/figs/chap03-fig05.pdf differ
diff --git a/code/figs/chap04-fig01.pdf b/code/figs/chap04-fig01.pdf
new file mode 100644
index 00000000..ade7f59d
Binary files /dev/null and b/code/figs/chap04-fig01.pdf differ
diff --git a/code/figs/chap08-fig02.pdf b/code/figs/chap08-fig02.pdf
new file mode 100644
index 00000000..e65791d8
Binary files /dev/null and b/code/figs/chap08-fig02.pdf differ
diff --git a/code/figs/chap09-fig01.pdf b/code/figs/chap09-fig01.pdf
new file mode 100644
index 00000000..f25042cb
Binary files /dev/null and b/code/figs/chap09-fig01.pdf differ
diff --git a/code/modsim.py b/code/modsim.py
index 4175bb20..a0b411fb 100644
--- a/code/modsim.py
+++ b/code/modsim.py
@@ -155,9 +155,6 @@ def linrange(start=0, stop=None, step=1, **options):
     stop: last value
     step: space between values
 
-    Also accepts the same keyword arguments as np.linspace.  See
-    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html
-
     returns: array or Quantity
     """
     if stop is None:
@@ -177,7 +174,10 @@ def linrange(start=0, stop=None, step=1, **options):
     if options['endpoint']:
         n += 1
 
-    array = np.linspace(start, stop, int(n), **options)
+    array = np.full(int(n), magnitude(step))
+    array[0] = magnitude(start)
+    array = np.cumsum(array)
+
     if units:
         array = array * units
     return array
diff --git a/code/salmon.ipynb b/code/salmon.ipynb
index 3825ca7e..a74e7bbf 100644
--- a/code/salmon.ipynb
+++ b/code/salmon.ipynb
@@ -916,7 +916,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,