diff --git a/ipynb/risk.ipynb b/ipynb/risk.ipynb
index 575d9f7..ff12baa 100644
--- a/ipynb/risk.ipynb
+++ b/ipynb/risk.ipynb
@@ -10,7 +10,7 @@
     "\n",
     "[Keith Devlin](https://web.stanford.edu/~kdevlin/)'s [book](https://www.amazon.com/Unfinished-Game-Pascal-Fermat-Seventeenth-Century/dp/0465018963) [*The Unfinished Game*](https://wordplay.blogs.nytimes.com/2015/12/14/devlin-unfinished-game/) describes how Fermat and Pascal discovered the rules of probability that guide gambling in games. The question they confronted was: what if a gambling game is interrupted, but one player is in the lead by a certain score. How much of the pot should the leader get?\n",
     "\n",
-    "My friends and I faced a similar question when a game of [*Risk*](https://www.ultraboardgames.com/risk/game-rules.php) ran on too long (as they often do) and we were unable to finish. Player **A**  was poised to make a sweeping attack on player **D**, whose territories were arranged in such a way that **A** could attack from one territory to the next without ever having to branch off.  We wrote down the number of **A**'s massed armies, **72**, and the number of armies in **D**'s successive territories: **22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1.** What is the probability that **A** can capture all these territories?\n",
+    "My friends and I faced a similar question when a game of [*Risk*](https://www.ultraboardgames.com/risk/game-rules.php) ran on too long (as they often do). Player **A**  was poised to make a sweeping attack on player **D**, whose territories were arranged in such a way that **A** could attack from one territory to the next without ever having to branch off.  We wrote down the number of **A**'s massed armies, **72**, and the number of armies in **D**'s successive territories: **22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1.** What is the probability that **A** can capture all these territories?\n",
     "\n",
     "![](https://www.ultraboardgames.com/risk/gfx/board.jpg)\n",
     "\n",
@@ -39,9 +39,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing      import List, Iterable\n",
+    "from typing      import List, Iterable, Tuple\n",
     "from collections import Counter\n",
     "from functools   import lru_cache\n",
+    "from dataclasses import dataclass\n",
     "import random\n",
     "import itertools\n",
     "import matplotlib.pyplot as plt"
@@ -53,7 +54,7 @@
    "source": [
     "# Representing the State of a Campaign\n",
     "\n",
-    "I will represent the **state of a campaign** as a tuple where the first element is the number of attacking armies, and subsequent elements are the number of defenders in each successive territory. Thus we can represent the start state of our unfinished campaign as follows:"
+    "I will represent the **state of a campaign** with the class `State`, and the state of the unfinished game as `start`:"
    ]
   },
   {
@@ -62,20 +63,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "State = tuple\n",
-    "\n",
-    "start = State((72, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1))"
+    "@dataclass(frozen=True)\n",
+    "class State:\n",
+    "    A: int # Number of attackers\n",
+    "    D: int # Number of defenders in first territory\n",
+    "    rest: Tuple[int] = () # Tuple of numbers of defenders in subsequent territories  \n",
+    "        \n",
+    "start = State(A=72, D=22, rest=(8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "I'll define the following functions on states: \n",
-    "- `A(state)`: the number of attackers in a state.\n",
-    "- `D(state)`: the number of defenders in the defender's first territory (or `0` if there are no defenders at all).\n",
-    "- `allD(state)`: the tuple of numbers of defenders in each territory.\n",
-    "- `update(state, dead)`: a new state reflecting the aftermath of a battle that leads to  `dead` armies, where `dead` is a two-element tuple of (attackers-who-died, defenders-who-died). The attackers will occupy the first territory if all the defenders in the first territory died.  Note that `dead` is a slightly different usage of `State`, counting the number of deaths rather than the number of living armies."
+    "The function `update` will update a state to reflect the `Deaths` that happened in a battle. We declare `game_over` when there are no defenders or only a single attacker (who can't leave their territory) remaining."
    ]
   },
   {
@@ -84,79 +85,24 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def A(state)    -> int:   \"Attackers\";       return state[0]\n",
-    "def D(state)    -> int:   \"First defenders\"; return state[1] if allD(state) else 0\n",
-    "def allD(state) -> tuple: \"All defenders\";   return state[1:]\n",
-    "\n",
-    "Deaths = State # A kind of state where (A, D) means that A attackers and D defenders died\n",
-    "\n",
-    "def update(state, dead: Deaths) -> State:\n",
+    "@dataclass(frozen=True)\n",
+    "class Deaths:\n",
+    "    \"The number of attackers and defenders who die in a battle.\"\n",
+    "    A: int\n",
+    "    D: int\n",
+    "        \n",
+    "def update(state: State, dead: Deaths) -> State:\n",
     "    \"\"\"Update the `state` of a campaign to reflect the`dead` in a battle.\"\"\"\n",
-    "    a, d, ds = A(state) - A(dead), D(state) - D(dead), allD(state)[1:]\n",
-    "    if d: # Can't occupy first territory if there are defenders there \n",
-    "        return State((a, d, *ds))\n",
-    "    else: # Occupy territory, leaving 1 behind\n",
-    "        return State((a - 1, *ds))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "72"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "A(start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "22"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "D(start)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "allD(start)"
+    "    a = state.A - dead.A  # Attackers remaining\n",
+    "    d = state.D - dead.D  # First territory defenders remaining\n",
+    "    r = state.rest        # Other territories defenders remaining\n",
+    "    return (State(a, d, r) if d            # Defenders still in first territory\n",
+    "       else State(a - 1, r[0], r[1:]) if r # First territory captured\n",
+    "       else State(a - 1, 0))               # All territories captured\n",
+    "\n",
+    "def game_over(state) -> bool: \n",
+    "    \"\"\"Is the game over?\"\"\"\n",
+    "    return state.D == 0 or state.A <= 1"
    ]
   },
   {
@@ -165,12 +111,12 @@
    "source": [
     "# Rolling the Dice and the Outcome of a Single Battle\n",
     "\n",
-    "We'll represent a roll of the dice with a list of integers; for example the attacker might roll `[2, 6, 1]` with three dice. The function `random_roll(n)` gives a random outcome for rolling `n` dice. The function `battle_deaths`, when given the specific sets of dice rolled by attacker and defender in a battle, returns a two-element `State` tuple that gives the number of attackers and defenders who perish in the battle."
+    "We'll represent a roll of the dice with a list of integers; for example the attacker might roll `[2, 6, 1]` with three dice. The function `random_roll(n)` gives a random outcome for rolling `n` dice. The function `battle_deaths`, when given the two lists of dice rolled by attacker and defender, returns  the number of attackers and defenders who perish in the battle."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -186,21 +132,21 @@
     "    dead = Counter('D' if a > d else 'A'\n",
     "                   for a, d in zip(sorted(A_dice, reverse=True), \n",
     "                                   sorted(D_dice, reverse=True)))\n",
-    "    return Deaths((dead['A'], dead['D']))"
+    "    return Deaths(dead['A'], dead['D'])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "([5, 5, 4], [5, 1], (1, 1))"
+       "([6, 1, 6], [6, 4], Deaths(A=1, D=1))"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -218,51 +164,43 @@
    "source": [
     "# Monte Carlo Simulation of a Campaign\n",
     "\n",
-    "A [**Monte Carlo simulation**](https://en.wikipedia.org/wiki/Monte_Carlo_method) makes random choices at every choice point (here, every dice roll), and reports on the outcome. \n",
-    "\n",
-    "The function `simulate_campaign` rolls random dice for a battle until we've reached a terminal state where there can be no more battles (either because the defenders have all been defeated, or because the attackers do not have the two armies necessary to launch an attack)."
+    "A **simulation** makes random choices at every choice point (here, every dice roll), and reports on the outcome. The function `simulate_campaign` rolls random dice for a battle until the game is over:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
     "def simulate_campaign(state) -> State:\n",
     "    \"\"\"Simulate a campaign with random rolls, returning the final state.\"\"\"\n",
-    "    while not terminal(state):\n",
-    "        dead  = battle_deaths(random_roll(min(3, A(state))), \n",
-    "                              random_roll(min(2, D(state))))\n",
+    "    while not game_over(state):\n",
+    "        dead  = battle_deaths(random_roll(min(3, state.A - 1)), \n",
+    "                              random_roll(min(2, state.D)))\n",
     "        state = update(state, dead)\n",
-    "    return state\n",
-    "\n",
-    "def terminal(state) -> bool: \n",
-    "    \"\"\"Is the game over?\"\"\"\n",
-    "    return A(state) < 2 or not D(state)"
+    "    return state"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Finishing the Unfinished Game (Randomly)\n",
-    "\n",
-    "**Let's see who wins!**"
+    "Let's see who wins:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(11,)"
+       "State(A=5, D=0, rest=())"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -275,22 +213,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "That final state says that the attackers won—there are 11 attackers and no defenders left. \n",
+    "That final state says that the attackers won—there are 5 attackers and no defenders left. \n",
     "\n",
-    "# Predicting the Unfinished Game: Estimating Probabilities\n",
+    "But what if we want to know the **probability** that the attackers win? [Monte Carlo simulation](https://en.wikipedia.org/wiki/Monte_Carlo_method) answers that question by repeating a simulation many times and summarizing all the final outcomes. The summary is in the form of a **probability distribution**, a mapping of `{outcome_state: probability}` pairs, which I have implemented as `ProbDist`. \n",
     "\n",
-    "But what if we want to know not just who won that one game, but what is the **probability** that the attackers win? Monte Carlo simulation answers that question by repeating a simulation many times and **summarizing** all the final outcomes. The summary is in the form of a **probability distribution**, a mapping of `{outcome_state: probability}` pairs, which I have implemented as `ProbDist`. I implemented `ProbDist` as a subclass of `Counter`, with the restriction that the values are normalized to sum to 1. (I realize that the name  `Counter` suggests integer counts, but that's not a requirement, and `Counter` has a nicer API than `dict`, including  a default value of 0  and the `most_common` method.)"
+    "*Note*: I have `ProbDist` as a subclass of `Counter`, with the restriction that the values are normalized to sum to 1. I realize that the name  `Counter` suggests integer counts, but that's not a requirement, and `Counter` has a nicer API than `dict`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
     "class ProbDist(Counter): \n",
     "    \"A Probability Distribution.\"\n",
     "    def __init__(self, *args):\n",
+    "        \"Normalize total to 1.\"\n",
     "        Counter.__init__(self, *args)\n",
     "        total = sum(self.values())\n",
     "        for x in self:\n",
@@ -299,28 +238,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "ProbDist({'H': 0.1,\n",
-       "          'E': 0.1,\n",
-       "          'L': 0.3,\n",
-       "          'O': 0.2,\n",
-       "          'W': 0.1,\n",
-       "          'R': 0.1,\n",
-       "          'D': 0.1})"
+       "ProbDist({4: 0.176, 3: 0.168, 2: 0.163, 1: 0.175, 5: 0.16, 6: 0.158})"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "ProbDist('HELLOWORLD') # example probability distribution over 10 letters"
+    "ProbDist(random_roll(1000)) # Probability distribution over 1,000 die rolls"
    ]
   },
   {
@@ -332,12 +265,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
     "def monte_carlo(simulation, start, k=1000) -> ProbDist:\n",
-    "    \"Call simulation(start) repeatedly (k times) and return a ProbDist of outcomes.\"\n",
+    "    \"Call `simulation(start)` repeatedly (`k` times) and return a ProbDist of outcomes.\"\n",
     "    return ProbDist(simulation(start) for _ in range(k))"
    ]
   },
@@ -345,29 +278,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we run the campaign \n",
-    "simulation 10 times and see the summary of outcomes:"
+    "Here we simulate the campaign \n",
+    " 10 times and see the summary of outcomes:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "ProbDist({(5,): 0.2,\n",
-       "          (8,): 0.2,\n",
-       "          (22,): 0.1,\n",
-       "          (21,): 0.1,\n",
-       "          (11,): 0.1,\n",
-       "          (0, 5, 1): 0.1,\n",
-       "          (13,): 0.1,\n",
-       "          (1, 1, 1): 0.1})"
+       "ProbDist({State(A=16, D=0, rest=()): 0.1,\n",
+       "          State(A=1, D=5, rest=(1,)): 0.1,\n",
+       "          State(A=11, D=0, rest=()): 0.2,\n",
+       "          State(A=1, D=2, rest=(5, 1)): 0.1,\n",
+       "          State(A=17, D=0, rest=()): 0.1,\n",
+       "          State(A=6, D=0, rest=()): 0.2,\n",
+       "          State(A=1, D=0, rest=()): 0.1,\n",
+       "          State(A=28, D=0, rest=()): 0.1})"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -380,23 +313,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And here we run it 1,000 times and report the probability that the attackers win:"
+    "And here we run 1,000 simulations and report how often the attackers win:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def attacker_win_probability(dist: ProbDist) -> float: \n",
-    "    \"\"\"The probability that the attackers win the campaign.\"\"\"\n",
-    "    return sum(dist[s] for s in dist if not allD(s))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -405,12 +327,16 @@
        "0.8190000000000004"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "def attacker_win_probability(dist: ProbDist) -> float: \n",
+    "    \"\"\"The probability that the attackers win the campaign.\"\"\"\n",
+    "    return sum(dist[s] for s in dist if not s.D)\n",
+    "\n",
     "attacker_win_probability(monte_carlo(simulate_campaign, start, 1000))"
    ]
   },
@@ -418,65 +344,39 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "How accurate is that result? We can run it again and compare:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.8130000000000003"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "attacker_win_probability(monte_carlo(simulate_campaign, start))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Alernatively, we could  do some math: the standard deviation of the expected value of a [binomial variable](https://www.mathsisfun.com/data/binomial-distribution.html) is $\\sqrt{p(1-p)/n}$, where $p$ is the true probability of one of the two outcomes and $n$ is the number of samples. In our case $\\sqrt{0.8(1-0.8)/1000}$ gives a standard deviation of about 1%. So we can be pretty confident (but not certain) \n",
-    "that the true percentage is somewhere between 77% and 86%.\n",
+    "The Monte Carlo simulation says the attackers win about 82% of the time. How accurate is that result?  The standard deviation of the expected value of a [binomial variable](https://www.mathsisfun.com/data/binomial-distribution.html) is $\\sqrt{p(1-p)/n}$, where $p$ is the true probability of one of the two outcomes and $n$ is the number of samples. In our case $\\sqrt{0.8(1-0.8)/1000}$ gives a standard deviation of about 1%. So we can be pretty confident that the true percentage is within 3 standard deviations; that is, between 79% and 85%.\n",
     "\n",
-    "We could get better accuracy at the cost of increased computing time.  It took about half a second to do 1,000 simulations; to get the standard deviation down by a factor of 10 to 0.1% would require 100 times more computing time (because of the square root in the formula), about a minute. To get to 0.01% would require 100 minutes.  \n",
+    "We could get better accuracy at the cost of increased computing time.  To get the standard deviation down by a factor of 10 from 1% to 0.1% would require 100 times more computation (because of the square root in the formula). \n",
     "\n",
-    "# Monte Carlo Simulation versus Exact Probability Calculation\n",
+    "# Monte Carlo versus Exact Probability Calculation\n",
     "\n",
-    "An alternative to the Monte Carlo approach is an approach that explicitly calculates the exact probability distribution of the final state of ther campaign. The differences between the two approaches are:\n",
+    "An alternative to the Monte Carlo approach is to explicitly calculate the exact probability distribution of the final state of the campaign. The differences between the two approaches are:\n",
     "\n",
     "- The **Monte Carlo approach** deals with a **single current state**, using random dice rolls to decide how that state changes. At the end of a simulated campaign we get a single final state, and we repeat the simulation to get an **estimated** probability distribution over final states.\n",
     "\n",
-    "- The **exact probability calculation approach** deals with a **probability distribution over states**, right from the start. At each dice roll, every possible outcome is considered, and the probability distribution is updated to reflect all the outcomes and their probabilities. At the end of the campaign we have an **exact** probability distribution over all possible final states (well, exact at least to the limits of floating point precision; if you need even more precision, use `fractions.Fraction`).\n",
+    "- The **exact probability calculation approach** deals with a **probability distribution over states**, right from the start. At each dice roll, every possible outcome is considered, and the probability distribution is updated to reflect all the possible outcomes and their probabilities. At the end of the campaign we have an **exact** probability distribution over all possible final states (well, exact at least to the limits of floating point precision; if you need more precision, use `fractions.Fraction`).\n",
     "\n",
     "In deciding whether to use the exact calculation approach, there are three considerations:\n",
     "\n",
-    "- **Is it worth the effort?** If I only wanted to know whether the attackers chance of winning is more or less than 50%, then the Monte Carlo approach is the quickest way to answer the question. The code will be simple and straightforward.  If I need 0.0001% precision on the win probability, then exact calculation is called for.\n",
+    "- **Is it worth the effort?** Code for an exact calculation is more complex, and will take more time to write and debug.\n",
     "- **Is it possible?** The exact calculation approach only works for **finite games**. \n",
     "- **Is it feasible?** Computation may take too long if there are too many possible states of the game.\n",
     "\n",
-    "**Worth the effort?** In general, the code for an exact calculation is more complex than for a Monte Carlo simulation, and thus it will take more time to write and debug the code. Monte Carlo code deals with the single current state of the simulation, for example: \n",
+    "Let's examine the three considerations:\n",
     "\n",
-    "     while not terminal(state):\n",
-    "     \n",
+    "**Worth the effort?** If I only wanted to know whether the attackers chance of winning is above or below 50%, then the Monte Carlo approach is the quickest way to answer the question. The code will be simple and straightforward.   Monte Carlo code deals with the single current state of the simulation, for example: \n",
+    "\n",
+    "     while not game_over(state):\n",
+    " \n",
     "But in the exact calculation we need to consider every possible states (referenced in a loop):\n",
     "\n",
-    "    while any(not terminal(state) for state in probdist):\n",
-    "    \n",
-    "Adding all these loops to the code makes it more complex. After the shared basics of representing states and battle outcomes, we need just just 10 non-comment lines of code to implement the Monte Carlo method (in `simulate_campaign`, `monte_carlo`, and `random_roll`), but 22 lines to implement exact calculation (in `campaign_probdist`, `battle_deaths_probdist`, `battle_update_probdist`, and `all_rolls`).\n",
+    "    while any(not game_over(state) for state in probdist):\n",
     "\n",
-    "**Possible?** Imagine a *Risk* rule change where if the attackers roll three 6s and the defneders roll two 6s, then both sides *gain* an army. For the Monte Carlo simulation it would be trivial to add a single `if` statement to handle this rule, and the expected run time of the program would hardly change. But with the exact calculation everything has changed, because we now have an  **infinite** game: no matter how far ahead we look, there will always be some possible states that have not terminated. (To deal with these we would have to make some compromises, such as stopping the calculation when there are still some nonterminal states, as long as they have very low probability in total.)\n",
+    "Putting all these loops into the code makes it more complex. (Less added complexity in Python, which has comprehensions, than in other languages where loops must be statements, not expressions.) After the shared basics of representing states and battle outcomes, we need just 10 non-comment lines of code to implement the Monte Carlo method (in `simulate_campaign`, `monte_carlo`, and `random_roll` above), but twice as much code (22 lines) to implement exact calculation (in `battle_deaths_probdist`,  `all_rolls`, `campaign_probdist`, and `battle_update_probdist` below).\n",
     "\n",
-    "**Feasible?** Imagine a rule change where before each battle, every army independently has the option to take one of ten possible actions (e.g. to move to a safe neighboring territory). Then with 100 armies, the very first move has $10^{100}$ outcomes, meaning that the probability distribution requires more states than the number of atoms in the universe. (To deal with this we would either stick with the Monte Carlo simulation, or a variant of it such as [particle filtering](https://en.wikipedia.org/wiki/Particle_filter) in which we maintain a **sample** of several possible states–more than a single state, but less than the complete state distribution.)\n",
+    "**Possible?** Imagine a *Risk* rule change where if the attackers roll three 6s and the defenders roll two 6s, then both sides *gain* an army. For the Monte Carlo simulation it would be trivial to add a single `if` statement to handle this rule, and the expected run time of the program would hardly change. But with  exact calculation everything has changed, because we now have an  **infinite** game: no matter how many moves ahead we look, there will always be some possible states that have not terminated. (To deal with these we would have to make some compromises, such as stopping the calculation when there are still some nonterminal states, as long as they have sufficiently low total probability. Sometimes a mathematical formula can determine the value of an infinite game.)\n",
+    "\n",
+    "**Feasible?** Imagine a rule change where before each battle, every army independently has the option to take one of ten possible actions (e.g. to move to a safe neighboring territory). Then with just 80 armies, the very first move has $10^{80}$ possible outcomes, meaning that the probability distribution requires as many states as there are [atoms in the universe](http://norvig.com/atoms.html). (To deal with this we would either stick with the Monte Carlo simulation, or a variant of it such as [particle filtering](https://en.wikipedia.org/wiki/Particle_filter) in which we maintain a **sample** of several possible states–more than a single state, but less than the complete state distribution, or we would find a way to abstract over the possible moves.)\n",
     "\n",
     " The *Risk* campaign problem as it stands leads to a very efficient exact probability calculation (possible, feasible, and, IMHO, worth it). If there are $n$ total armies to start, then there are fewer than $n^2$ possible states, and the game can last no more than $n$ moves. With $n$ in the range of a few hundred, computation takes less than a second; much faster and more accurate than doing 100,000 simulations."
    ]
@@ -489,48 +389,48 @@
     "\n",
     "The function `battle_deaths` was defined above to return the specific death counts for a specific dice roll. \n",
     "\n",
-    "Now we'll define `battle_deaths_probdist` to give a probability distribution over all possible battle outcomes, corresponding to all possible dice rolls. The input to `battle_deaths_probdist` is a state giving the number of attacking and defending armies for just this one battle (*not* the total number of attacking and defending armies in the current state). Thus, the attackers will always be 3, 2, or 1, and the defenders will always be 2 or 1. I define it this way so that I can **cache** the results and reuse them in subsequent battles, for efficiency."
+    "Now we'll define `battle_deaths_probdist` to give a probability distribution over all possible battle outcomes, corresponding to all possible dice rolls. The input to `battle_deaths_probdist` is   the number of attacking and defending armies for just this one battle (*not* the total number of attacking and defending armies in the current state). Thus, the attackers will always be 3, 2, or 1, and the defenders will always be 2 or 1. I define it this way so that I can **cache** the results and reuse them in subsequent battles, for efficiency."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
     "@lru_cache()\n",
-    "def battle_deaths_probdist(state) -> ProbDist:\n",
-    "    \"\"\"A probability distribution of deaths in a battle.\n",
-    "    State is (A, D) where 1 <= A <= 3 and 1 <= D <= 2.\"\"\"\n",
+    "def battle_deaths_probdist(battlers: State) -> ProbDist:\n",
+    "    \"\"\"A probability distribution of deaths in a single battle.\n",
+    "    Requires 1 <= battlers.A <= 3 and 1 <= battlers.D <= 2.\"\"\"\n",
     "    return ProbDist(battle_deaths(A_dice, D_dice)\n",
-    "                    for A_dice in all_rolls(A(state))\n",
-    "                    for D_dice in all_rolls(D(state)))\n",
+    "                    for A_dice in all_rolls(battlers.A)\n",
+    "                    for D_dice in all_rolls(battlers.D))\n",
     "\n",
     "def all_rolls(n) -> Iterable[Dice]: \n",
     "    \"\"\"All possible rolls of `n` dice.\"\"\"\n",
-    "    return itertools.product(die, repeat=n)"
+    "    return tuple(itertools.product(die, repeat=n))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "ProbDist({(2, 0): 0.2925668724279835,\n",
-       "          (1, 1): 0.3357767489711934,\n",
-       "          (0, 2): 0.37165637860082307})"
+       "ProbDist({Deaths(A=2, D=0): 0.2925668724279835,\n",
+       "          Deaths(A=1, D=1): 0.3357767489711934,\n",
+       "          Deaths(A=0, D=2): 0.37165637860082307})"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "battle_deaths_probdist((3, 2)) # Three attacker dice against two defender dice"
+    "battle_deaths_probdist(State(3, 2)) # Three attacker dice against two defender dice"
    ]
   },
   {
@@ -550,14 +450,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "def campaign_probdist(start: State) -> ProbDist:\n",
     "    \"\"\"Probability distribution for all outcomes of a campaign.\"\"\"\n",
     "    probdist = ProbDist({start: 1.0})\n",
-    "    while any(not terminal(state) for state in probdist):\n",
+    "    while any(not game_over(state) for state in probdist):\n",
     "        probdist = battle_update_probdist(probdist)\n",
     "    return probdist\n",
     "\n",
@@ -566,10 +466,10 @@
     "    Combine these all into one updated `outcomes` ProbDist.\"\"\"\n",
     "    outcomes = ProbDist()\n",
     "    for state in probdist:\n",
-    "        if terminal(state): # `state` carries through unchanged to `outcomes`\n",
+    "        if game_over(state): # `state` carries through unchanged to `outcomes`\n",
     "            outcomes[state] += probdist[state] \n",
     "        else: # Replace `state` with all possible outcomes from a battle\n",
-    "            dead_probdist = battle_deaths_probdist((min(3, A(state) - 1), min(2, D(state))))\n",
+    "            dead_probdist = battle_deaths_probdist(Deaths(min(3, state.A - 1), min(2, state.D)))\n",
     "            for dead in dead_probdist:\n",
     "                outcomes[update(state, dead)] += probdist[state] * dead_probdist[dead]\n",
     "    return outcomes"
@@ -586,7 +486,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -595,7 +495,7 @@
        "0.8105485936352178"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -615,35 +515,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[((12,), 0.03824220182706657),\n",
-       " ((11,), 0.0380992150215239),\n",
-       " ((13,), 0.038032667992797725),\n",
-       " ((10,), 0.037618411457469664),\n",
-       " ((14,), 0.03746512036620402),\n",
-       " ((9,), 0.036822601595588304),\n",
-       " ((15,), 0.036544033638847624),\n",
-       " ((8,), 0.035741340182918115),\n",
-       " ((16,), 0.035284184613703425),\n",
-       " ((7,), 0.03440940023374102),\n",
-       " ((17,), 0.03371050842173721),\n",
-       " ((6,), 0.03286517629527088),\n",
-       " ((18,), 0.031857448871758426),\n",
-       " ((5,), 0.031149102741286083),\n",
-       " ((19,), 0.029767807751056283),\n",
-       " ((4,), 0.029302161098148583),\n",
-       " ((20,), 0.027491133463900305),\n",
-       " ((3,), 0.0273645356924103),\n",
-       " ((1, 5, 1), 0.026621109937678585),\n",
-       " ((1, 1), 0.025661022694069335)]"
+       "[(State(A=12, D=0, rest=()), 0.03824220182706657),\n",
+       " (State(A=11, D=0, rest=()), 0.0380992150215239),\n",
+       " (State(A=13, D=0, rest=()), 0.038032667992797725),\n",
+       " (State(A=10, D=0, rest=()), 0.037618411457469664),\n",
+       " (State(A=14, D=0, rest=()), 0.03746512036620402),\n",
+       " (State(A=9, D=0, rest=()), 0.036822601595588304),\n",
+       " (State(A=15, D=0, rest=()), 0.036544033638847624),\n",
+       " (State(A=8, D=0, rest=()), 0.035741340182918115),\n",
+       " (State(A=16, D=0, rest=()), 0.035284184613703425),\n",
+       " (State(A=7, D=0, rest=()), 0.03440940023374102),\n",
+       " (State(A=17, D=0, rest=()), 0.03371050842173721),\n",
+       " (State(A=6, D=0, rest=()), 0.03286517629527088),\n",
+       " (State(A=18, D=0, rest=()), 0.031857448871758426),\n",
+       " (State(A=5, D=0, rest=()), 0.031149102741286083),\n",
+       " (State(A=19, D=0, rest=()), 0.029767807751056283),\n",
+       " (State(A=4, D=0, rest=()), 0.029302161098148583),\n",
+       " (State(A=20, D=0, rest=()), 0.027491133463900305),\n",
+       " (State(A=3, D=0, rest=()), 0.0273645356924103),\n",
+       " (State(A=1, D=5, rest=(1,)), 0.026621109937678585),\n",
+       " (State(A=1, D=1, rest=()), 0.025661022694069335)]"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -665,12 +565,12 @@
    "source": [
     "# Analyzing and Visualizing Campaigns\n",
     "\n",
-    "Let's try to visualize all the possible outcomes. I'll define the **score** of a campaign as the number of attacker armies in the final territory minus the total number of defenders, minus the number of territories that the defenders hold. This score will be positive when the attackers win and negative when they lose. A score cannot be zero (the closest is that there could be one attacker and one defender left, in which case there can be no more attacks, but the score would be -1, because the defenders have one army and one territory). The function `show` plots a histogram of scores probabilities:"
+    "Let's try to visualize all the possible outcomes. I'll define the **score** of a campaign as the number of attacker armies in the final territory minus the total number of defenders, minus the number of territories that the defenders hold. This score will be positive when the attackers win and negative when they lose. A score cannot be zero. The function `show` plots score probabilities, with the attacker's wins in green and the defender's wins in blue:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -685,19 +585,21 @@
     "    plt.title(f'Attacker wins {p:.2%}. Average score: {μ:.2f}.')\n",
     "    plt.xlabel('Score (positive when attacker wins)')\n",
     "    plt.ylabel('Probability of score')\n",
-    "    plt.bar(X, Y, width=3/4)\n",
+    "    plt.bar(X, Y, width=0.7, color=['g' if x > 0 else 'b' for x in X])\n",
     "    \n",
-    "def score(state): return A(state) - sum(allD(state)) - len(allD(state))"
+    "def score(state): \n",
+    "    return (state.A if not state.D else \n",
+    "            state.A - (state.D + sum(state.rest)) - (len(state.rest) + 1))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAFNCAYAAABST1gVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZglVX3/8feHGTZZdRyNAsOg4AJEiY5oEvcV10EFHUIUDIaYhGhWhSSKKOanSdTEiAsKAVEDiNuoKKKIuBBkCCCLYEbEMEAEZBFQ1MHv7486DZc7vdwhc7v7dr9fz1NPV506de6purf7fvucOnVSVUiSJGl222imKyBJkqSpGbRJkiSNAIM2SZKkEWDQJkmSNAIM2iRJkkaAQZskSdIIMGiTRkiSpUkqycIZrsdtSR4yk3WQpPnGoE26l5KcmeSmJJv2pR+X5Mi+tCuTPHN6azg8VbVlVV2xIctMcr8kJyW5oS0fS7J1z/63Jrkoydokb56irCR5R5KftOUfk6RnfyW5vQWftyX5cM++30tybZIfJnlqT/pDk3w7yYJ7cW5vbq+55/oeq3snyQuTXNze328n2XWSvJf0fBZua5+xz7V9D0vy2STXJ7kxyWlJHj59ZyLdzaBNuheSLAWeBBTwohmtzL3QgprZ9vt/JHBf4CHAQ4EHAm/u2b8aeD3whQHKOhjYG3g08CjgBcAf9eV5dAs+t6yqVwO0Fsy3A48B/gx4b0/+9wB/WVV3rs9JtWDxFcCNwAHrc+x6vMaMtrxuaP/X80myC/Ax4DXAtsDngJUTlVtVu419FoCtgP8BPtF2bwusBB5O95n8DvDZ/0v9pHtrtv3RlkbFK4H/BI6j54s4ycHA/sDr23/sn0tyArAE+FxLe33L+4kk/5vkliRnJdmtp5zNk7wzyY/a/m8m2by/Ekle2lrxdm/bT2itCjcnubCvpejMJG9L8i3gZ3TBUW9ZrxprXWjbq5Oc3LN9VZI92nol2bmtH5fkqCRfSHJrknOSPLTtS5J3J7muncd3x+o6jp2Az1TVT6vqFuDTwF3XpKqOr6ovArdO9Kb0OAB4Z1WtqaqrgXcCBw5w3CLg6qq6FvgK7Rol2ael/+cAZfR7EvBg4HXAiiSbtDI3be/TXdcjyeIkP0/ygLb9giQXtHzfTvKonrxXJnlDku8CtydZmOTQJD9o78OlSV7ck39B+0zd0FoRD0lPV3uSbZIc01oZr05y5EStikn2TLIqyU+T/DjJu3r2PbHnM3hVkgN7yv9Ia7H6UZK/H/vHIcmBSb7VPis30oL1JH+Q5HvpWrRPS7LjgNf8OcA3quqbVbUWeAewHfCUAY59MvAA4JMAVfWdqjqmqm6sql8B7wYenmTRgHWRNpyqcnFxWc+FrtXnT4DHAr8CHtiz7zjgyL78VwLP7Ev7A7r/6jcF/gW4oGffUcCZdF80C4DfafmW0rXuLQRe1eqxcztmO+AnwPPo/iF7Vtte3PafSdeCsFs7fuO++jwEuLkd+yDgR3SByti+m4CN2nb1vO5xdK1Ie7ZyPwac2PY9BziPrrUiwCOBB01wTV8AnErX2nZf4Azgz8fJ91HgzVO8P7cAj+/ZXgbc2rNdwDXA/wKfApa29I2A7wPbAy8EzgW2BC4AFt3Lz8oxwMnAxu39eEnPvmOBt/Vs/ynwpbb+GOA64PHtM3BA+xxt2vOZugDYAdi8pe1LFyBuBLwcuH3setO1Ol3azu2+dEFpAQvb/s8AHwS2oAtavgP80QTndDbwira+JfCEtr6ELqjer53vImCPtu8jdC1UW9F9jr8PHNT2HQispWvdXAhsTtdSurp9ZhYCfw98u6cOnwcOnaB+fwac2rO9ALgDeN0A79exwHGT7N8buHam/wa5zM9lxivg4jJqC/BEukDt/m37MuAvevYfxwBBW9/+bdsX6DbtC/fndN13/fmWtnx/PfYF3LPvDcAJfflPAw5o62cCb5ni3K5qwcIK4Oj2xf0IugBxZU++/qDtwz37ngdc1taf3r6cn0AL+CZ57Qe3QOLXbTkd2GScfIMEbXcCj+jZ3qXVOW37ycAm7bq/F7iYu4OXZ9C1on4d2AN4F3AQ8FTga+2a7j7gZ+U+wE+Bvdv2B4HP9ux/JnBFz/a3gFe29fcDb+0r73LgKT2fqT+Y4vUvAJa39TPoCcLaa4/9A/BA4Be04K/t3w/42gTlngUcQfsd6Ek/DPj0OPkXtPJ37Un7I+DMtn4g8D99x3yRFtS17Y3oWoh3HOC6P4IuYH1qe5/f2D5Thw34fj11gv3bA1cD+w3y/ru4bOjF7lFp/R0AfLmqbmjbH2c971VqXVVvb11ZP6X7Aga4f1s2A34wSRF/AxxVVWt60nYE9m3dUjcnuZkuwHxQT56rpqja1+m+6J7c1s+k61J6StueyP/2rP+MrvWFqjqDLig6CvhxkqPTM7igzyfoArytgK3pzv+jU9R3Ire1MsZsDdxWVdXqdVZV/bKqbqbrttyJrkWHqvpqVT2hqp5C90W/jC4wPYEuuHgr8GEG82K6FqRT2/bHgOcmWdy2zwA2T/L41vW3B123MHTv51/1vZ870AW3Y+7xfiZ5ZU936s3A7nSfJ9pxV01w7I50LWPX9hz7QboWt/EcBDwMuCzJuUle0NJ3YPzP7f3pgqcf9aT9iK51eNxzaXX615763EjXWrsdU6iqy+h+J98LXNte/1JgzWTHAS9pr7POZ729Z18G3ldV/zFVHaRhmFM3r0rD1u4rexmwIMlYoLIpsG2SR1fVhXStF/36034PWE7X2nElXQvbTXRfSjfQdeU8FLhwgqo8G/hSkv+tqk+2tKvoWtr+cJJTGK9uvb5O1y24E/APdN2l+wO/zT1vyh9YVb0HeE+7T+tkuoDzjeNkfTTwJ1V1O0CSDwDfvDevCVzSyvtOT9mXTFZNumt/lyShO+fX0n3pL6iqH7X3/VHrFjGuA+gC2P/piiN0wdF+wHuq6tftvsH9gB8Dn6+qsXv2rqLrOn3bFPUeq++OwIfoWgrPrqo7k1zQc17X0rUUjdmhZ/0qupaw+1d3D9ikquq/gf3aPWkvAU5p93hdRddN3u8GutbpHemCJ+i6Uq8e71x66vS2qvrYVPWZoI6nAKcAJNmW7naEc6c47ADgI2PB/Zgk96UL2FZO8X5IQ2VLm7R+9qbretuVrlVkD7oWmm/QDU6A7su3/xlm/Wlb0X1J/oSuS+YfxnZU1a/p7qt5V5IHt1a53849Hy1yCbAXcFSSsdGrHwVemOQ57ZjNkjw1Se8X9VS+DjyNrptsTTuvvejuTTp/PcoBIMnjWivSxnTdVXfQXb/xnAu8Ot0gjM3pRoDeFbQm2TjJZnR/txa285vo8RsfAf4yyXZJHgz8FV1rGUl2S7JHu0Zb0g1SuBr4Xl8ZrwbOr6oL6N6nzdM9NuJpwJSPO0myHV0A9QLu/qw8mu6m+N6W2Y/T3X+2f1sf8yHgNe36JckWSZ6fZKsJXnILusDn+vb6r6JraRtzMvC6dk22petOB6C6gRdfBt6ZZOskG6V7xMm4N+4n+f0ki9tn9eaWfCddS+Izk7ws3cCIRUn2qG7E7cnA25Js1QLMv2TyltQPAIelDdBpAxn2nSR/fx0f297jxXSthp9rLXAT5d+e7r09vi99a7ou8W9V1aGDvr40FDPdP+viMkoL8CW6UYn96S+j6yJcSHf/1AV0X2afafuX0w0CuJnufrQt6W7KvpWum+iV3PM+sc3pBidcTXdT/VktbSn3vHl8GV1A+Ny2/Xi6wOtGui/vLwBL2r4zgVcPcI7XAv/es70K+GJfnv572o7s2fdUYE1bfwbwXbruyhvovtS3nOB1d6J7NMNPWv2/BOzSs/+49rq9y4Ft35Pouj/H8gb4x1bOjW197H62p9PdG3Y73Y3+n+l9nZbn/nT3uW3dk7Z/e4+vBJ7W0pa0c1syzvkcCpw3TvqD6Vqddu9JW93quUlf3r3ogtmb2/vyCWCrtu9K1h3c8rZWzg109+J9few9p/tsvrtd3x8Cf9HqMXZdtqG7j24N3WfufGDFBO/VR9u1u43uH4i9e/Y9CTiH7t6wq7j7nsr7tuOub+lv4u6BLQcC3xzndV4BXNRT1rE9+74I/O0kn+Nv0v1+3UgbYNH3Xl7Sl/8wuhGn/eUc0D5rt7fzHVuWTFSWi8uwlrFfVknSPJLkucAHqmrHma6LpMHYPSpJ80Drdn5e67bcDjicuwc9SBoBtrRJ0jyQ5D503aWPoHukzBfonlv20xmtmKSBDbWlLcleSS5P92T1dW7gTPdE8JPa/nPSTQ3Uu39JuifI//WgZUqS1lVVP6uqx1XVVlX1gKp6lQGbNFqGFrS1UV1HAc+lG2m3X9adsPcg4Kaq2pnuBtl39O1/N93NputTpiRJ0pwzzJa2PYHVVXVFVf0SOJFuBF2v5dw9vPoU4BkZe5hRsjfdsPreZysNUqYkSdKcM8yH627HPZ9wvYbucQTj5qmqtUluARYl+TndM4SeRfd4hPUpcx33v//9a+nSpetbf0mSpGl33nnn3VBVi/vThxm0ZZy0/lEPE+U5Anh3Vd3WGt7Wp8wuY3Iw3cM5WbJkCatWrZqywpIkSTMtyY/GSx9m0LaGe06Tsj1wzQR51iRZSPdwxxvpWs/2SfKPdBM6/zrJHcB5A5QJQFUdTTfhNcuWLXOIrCRJGmnDDNrOBXZJshPdU91X0M232Gsl3dOmzwb2Ac6o7hkkTxrLkOTNdE86f28L7KYqU5Ikac4ZWtDW7lE7hG7OtgV0049ckuQtwKqqWgkcA5yQZGwKlxX3psxhnYMkSdJsMS8errts2bLynjZJkjQKkpxXVcv6053GSpIkaQQYtEmSJI0AgzZJkqQRYNAmSZI0AgzaJEmSRoBBmyRJ0ggwaJMkSRoBw5wRQZI04nLEulM+1+Fz//me0mxk0CZJ89y9DcwM6KTpZfeoJEnSCDBokyRJGgF2j0rSPGBXpjT6DNokSUPRHygaJEr/N3aPSpIkjQCDNkmSpBFg0CZJkjQCDNokSZJGgAMRJGmOcISoNLcZtEmSpp0BprT+7B6VJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI0AgzZJkqQR4OhRSRohjrqU5q+htrQl2SvJ5UlWJzl0nP2bJjmp7T8nydKWvmeSC9pyYZIX9xxzZZKL2r5Vw6y/JEnSbDG0lrYkC4CjgGcBa4Bzk6ysqkt7sh0E3FRVOydZAbwDeDlwMbCsqtYmeRBwYZLPVdXadtzTquqGYdVdkiRpthlm9+iewOqqugIgyYnAcqA3aFsOvLmtnwK8N0mq6mc9eTYDbPuXpHnCLmBpfMPsHt0OuKpne01LGzdPa0W7BVgEkOTxSS4BLgJe09PKVsCXk5yX5OAh1l+SJGnWGGZL27r/Kq3bYjZhnqo6B9gtySOB45N8saruAH63qq5J8gDg9CSXVdVZ67x4F9AdDLBkyZL/y3lIkiTNuGG2tK0BdujZ3h64ZqI8SRYC2wA39maoqu8BtwO7t+1r2s/rgE/TdcOuo6qOrqplVbVs8eLF/+eTkSRJmknDDNrOBXZJslOSTYAVwMq+PCuBA9r6PsAZVVXtmIUASXYEHg5cmWSLJFu19C2AZ9MNWpAkSZrThtY92kZ+HgKcBiwAjq2qS5K8BVhVVSuBY4ATkqyma2Fb0Q5/InBokl8Bvwb+pKpuSPIQ4NNJxur+8ar60rDOQZIkabYY6sN1q+pU4NS+tDf1rN8B7DvOcScAJ4yTfgXw6A1fU0maPRw9KWk8TmMlSZI0AgzaJEmSRoBBmyRJ0ggwaJMkSRoBQx2IIEnShuQgDc1ntrRJkiSNAIM2SZKkEWDQJkmSNAIM2iRJkkaAAxEkaQZ4Q72k9WVLmyRJ0ggwaJMkSRoBBm2SJEkjwKBNkiRpBBi0SZIkjQCDNkmSpBHgIz8kSXOCj1HRXGdLmyRJ0ggwaJMkSRoBBm2SJEkjwKBNkiRpBDgQQZKGxBvjJW1ItrRJkiSNAIM2SZKkEWDQJkmSNAKGGrQl2SvJ5UlWJzl0nP2bJjmp7T8nydKWvmeSC9pyYZIXD1qmJEnSXDS0oC3JAuAo4LnArsB+SXbty3YQcFNV7Qy8G3hHS78YWFZVewB7AR9MsnDAMiVJkuacYba07QmsrqorquqXwInA8r48y4Hj2/opwDOSpKp+VlVrW/pmwNhwq0HKlCRJmnOGGbRtB1zVs72mpY2bpwVptwCLAJI8PsklwEXAa9r+QcqUJEmac4YZtK37gKK7W8ymzFNV51TVbsDjgMOSbDZgmV3BycFJViVZdf31169HtSVJkmafYT5cdw2wQ8/29sA1E+RZk2QhsA1wY2+GqvpektuB3Qcsc+y4o4GjAZYtW+bTLCVpHvNBx5oLhtnSdi6wS5KdkmwCrABW9uVZCRzQ1vcBzqiqascsBEiyI/Bw4MoBy5QkSZpzhtbSVlVrkxwCnAYsAI6tqkuSvAVYVVUrgWOAE5KspmthW9EOfyJwaJJfAb8G/qSqbgAYr8xhnYMkSdJsMdS5R6vqVODUvrQ39azfAew7znEnACcMWqYkzRS73SRNF2dEkCRJGgEGbZIkSSPAoE2SJGkEGLRJkiSNAIM2SZKkEWDQJkmSNAIM2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI2AoU4YL0nSbJcjsk5aHV4zUBNpcgZtkjQFv9QlzQZ2j0qSJI2AgYK2JE9M8qq2vjjJTsOtliRJknpNGbQlORx4A3BYS9oY+OgwKyVJkqR7GqSl7cXAi4DbAarqGmCrYVZKkiRJ9zTIQIRfVlUlKYAkWwy5TpJmQNa9157yXntJmjUGaWk7OckHgW2T/CHwFeBDw62WJEmSek3Z0lZV/5zkWcBPgYcDb6qq04deM0mSJN1l0qAtyQLgtKp6JmCgJkmSNEMm7R6tqjuBnyXZZprqI0mSpHEMMhDhDuCiJKfTRpACVNVrh1YrSZIk3cMgQdsX2iJJM85RrpLmq0EGIhyfZBPgYS3p8qr61SCFJ9kL+FdgAfDhqnp73/5NgY8AjwV+Ary8qq5sAx/eDmwC/BL4m6o6ox1zJvAg4OetmGdX1XWD1EeSJGlUTRm0JXkqcDxwJRBghyQHVNVZUxy3ADgKeBawBjg3ycqqurQn20HATVW1c5IVwDuAlwM3AC+sqmuS7A6cBmzXc9z+VbVqwHOUJEkaeYN0j76TrjXrcoAkDwP+g651bDJ7Aqur6op23InAcqA3aFsOvLmtnwK8N0mq6vyePJcAmyXZtKp+MUB9JUmS5pxBgraNxwI2gKr6fpKNBzhuO+Cqnu01wOMnylNVa5PcAiyia2kb81Lg/L6A7d+T3Al8EjiyyjtaJEkbXo5Y9ybKOtyvHM2MQYK2VUmOAU5o2/sD5w1w3Di3C9P/SZ80T5Ld6LpMn92zf/+qujrJVnRB2yvo7ou7Z8HJwcDBAEuWLBmgupIkSbPXINNY/TFdF+VrgdfRdW++ZoDj1gA79GxvD1wzUZ4kC4FtgBvb9vbAp4FXVtUPxg6oqqvbz1uBj9N1w66jqo6uqmVVtWzx4sUDVFeSJGn2GqSlbSHwr1X1LrhrgMGmAxx3LrBLkp2Aq4EVwO/15VkJHACcDewDnNEmp9+W7jEjh1XVt8Yyt8Bu26q6oXXRvoBuLlRJkqQ5bZCWtq8Cm/dsb84AgVJVrQUOoRv5+T3g5Kq6JMlbkryoZTsGWJRkNfCXwKEt/RBgZ+CNSS5oywPogsXTknwXuIAuGHTyekmSNOcN0tK2WVXdNrZRVbcluc8ghVfVqcCpfWlv6lm/A9h3nOOOBI6coNipRq1KkiTNOYO0tN2e5DFjG0key90PtpUkSdI0GKSl7c+BTyQZG0TwILoH4EqSJGmaDDKN1blJHgE8nO4RHZcNOo2VJEmSNowpu0eT7Et3X9vFdDMYnNTbXSpJkqThG+SetjdW1a1Jngg8h24e0vcPt1qSJEnqNUjQdmf7+Xzg/VX1WWCT4VVJkiRJ/QYJ2q5O8kHgZcCpSTYd8DhJkiRtIIMEXy+je0DuXlV1M3A/4G+GWitJkiTdwyCjR38GfKpn+1rg2mFWSpIkSfdkN6ckSdIImDBoa/euSZIkaRaYrHv0bOAxSU6oqldMV4UkSRoFOSLrpNXhNQM10XwxWdC2SZIDgN9J8pL+nVX1qXGOkSRJ0hBMFrS9Btgf2BZ4Yd++omdwgiSNOltNJM12EwZtVfVN4JtJVlXVMdNYJ0mSJPWZ8pEfwAlJXgs8uW1/HfiAk8ZLkiRNn0GCtvcBG7efAK+gm3v01cOqlCRJku5pkKDtcVX16J7tM5JcOKwKSZIkaV0DTRif5KFjG0kewt2TyEuSJGkaDNLS9jfA15JcAQTYEXjVUGslSZKkexhk7tGvJtkFeDhd0HZZVf1i6DWTJEnSXQZpaaMFad8dcl0kSZI0ASeMlyRJGgEGbZIkSSNgyqAtySeTPD+JAZ4kSdIMGSQQez/we8B/J3l7kkcMWniSvZJcnmR1kkPH2b9pkpPa/nOSLG3pz0pyXpKL2s+n9xzz2Ja+Osl7kqw7YaAkSdIcM2XQVlVfqar9gccAVwKnJ/l2klcl2Xii45IsAI4CngvsCuyXZNe+bAcBN1XVzsC7gXe09BuAF1bVbwIHACf0HPN+4GBgl7bsNeVZSpIkjbiBujyTLAIOpJu66nzgX+mCuNMnOWxPYHVVXVFVvwROBJb35VkOHN/WTwGekSRVdX5VXdPSLwE2a61yDwK2rqqzq6qAjwB7D3IOkiRJo2zKR34k+RTwCLrWrhdW1bVt10lJVk1y6HbAVT3ba4DHT5SnqtYmuQVYRNfSNualwPlV9Ysk27VyesvcboJ6H0zXIseSJUsmqaYkSRtWjlj3zp06vGagJppLBnlO24er6tTehCSbVtUvqmrZJMeNd69Z/yd20jxJdqPrMn32epTZJVYdDRwNsGzZMn9TJEnSSBuke/TIcdLOHuC4NcAOPdvbA9dMlCfJQmAb4Ma2vT3waeCVVfWDnvzbT1GmJEnSnDNhS1uS36Dretw8yW9xdyvX1sB9Bij7XGCXJDsBVwMr6Eah9lpJN9DgbGAf4IyqqiTbAl8ADquqb41lrqprk9ya5AnAOcArgX8boC6SJEkjbbLu0efQDT7YHnhXT/qtwN9OVXC7R+0Q4DRgAXBsVV2S5C3AqqpaCRwDnJBkNV0L24p2+CHAzsAbk7yxpT27qq4D/hg4Dtgc+GJbJEmS5rQJg7aqOh44PslLq+qT96bwdi/cqX1pb+pZvwPYd5zjjmT8blmqahWw+72pjyRJ0qiarHv096vqo8DSJH/Zv7+q3jXOYZJ0l/EefV0OC5Kke2Wy7tEt2s8tp6MikiRJmthk3aMfbD+PmL7qSJIkaTyTdY++Z7IDq+q1G746kkaNXaCSND0m6x49b9pqIUmSpElNNXpUkiRJs8Bk3aP/UlV/nuRzjDNVVFW9aKg1kyRJ0l0m6x49of385+moiCRJkiY2Wffoee3n15NsAjyCrsXt8qr65TTVT5IkSUze0gZAkucDHwB+QDf/6E5J/qiqnD5KkiRpmkwZtAHvBJ5WVasBkjyUbjJ3gzZJkqRpMkjQdt1YwNZcAVw3pPpImoV8Fpu04eSIdX+h6nB/oTS1yUaPvqStXpLkVOBkunva9gXOnYa6SZIkqZmspe2FPes/Bp7S1q8H7ju0GkkCbN2SJN3TZKNHXzWdFZEkSdLEBhk9uhlwELAbsNlYelX9wRDrJUmSpB4bDZDnBOA3gOcAXwe2B24dZqUkSZJ0T4MEbTtX1RuB29t8pM8HfnO41ZIkSVKvQYK2X7WfNyfZHdgGWDq0GkmSJGkdgzyn7egk9wXeCKwEtmzrkiRJmiZTBm1V9eG2+nXgIcOtjiRJksYzZfdokkVJ/i3JfyU5L8m/JFk0HZWTJElSZ5B72k6km7bqpcA+wA3AScOslCRJku5pkHva7ldVb+3ZPjLJ3sOqkCRJktY1SEvb15KsSLJRW14GfGGQwpPsleTyJKuTHDrO/k2TnNT2n5NkaUtflORrSW5L8t6+Y85sZV7QlgcMUhdJkqRRNtmE8bfSTRAf4C+Bj7ZdGwG3AYdPVnCSBcBRwLOANcC5SVZW1aU92Q4CbqqqnZOsAN4BvBy4g26E6u5t6bd/Va2a+vQkSZLmhglb2qpqq6rauv3cqKoWtmWjqtp6gLL3BFZX1RVV9Uu6e+OW9+VZDhzf1k8BnpEkVXV7VX2TLniTJEma9wa5p40kLwKe3DbPrKrPD3DYdsBVPdtrgMdPlKeq1ia5BVhEN9hhMv+e5E7gk8CRVVUD1EeSpFktR2SdtDrcrzh1Bnnkx9uB1wGXtuV1LW3KQ8dJ6//kDZKn3/5V9ZvAk9ryinFfPDk4yaokq66//vopKytJkjSbDTIQ4XnAs6rq2Ko6FtirpU1lDbBDz/b2wDUT5UmykG6KrBsnK7Sqrm4/bwU+TtcNO16+o6tqWVUtW7x48QDVlSRJmr0GCdoAtu1Z32bAY84FdkmyU5JNgBV002D1Wgkc0Nb3Ac6YrKszycIk92/rGwMvAC4esD6SJEkja5B72v4fcH6Sr9F1Zz4ZOGyqg9o9aocApwELgGOr6pIkbwFWVdVK4BjghCSr6VrYVowdn+RKYGtgk/ZcuGcDPwJOawHbAuArwIcGPVlJkqRRNWnQliTAN4EnAI+jC9reUFX/O0jhVXUqcGpf2pt61u8A9p3g2KUTFPvYQV5bkiRpLpk0aKuqSvKZqnos63ZtSpIkaZoMck/bfyZ53NBrIkmSpAkNck/b04DXtHvMbqfrIq2qetQwKyZJkqS7DRK0PXfotZAkSdKkJpt7dDPgNcDOwEXAMVW1droqJkmSpLtNdk/b8cAyuoDtucA7p6VGkiRJWsdk3aO7tumiSHIM8J3pqZIkSZL6TdbS9quxFbtFJUmSZtZkLW2PTvLTth5g87Y9Nnp066HXTpI2oByRe2zX4RPOmidJs86EQVtVLZjOikiSpIn1/9MB/uMx3ww6YbwkSZJmkEGbJEnSCDBokyRJGgEGbZIkSSPAoE2SJBuNjR0AABNESURBVGkEDDL3qKRJZN0BXZQDuiRJG5gtbZIkSSPAoE2SJGkEGLRJkiSNAO9pk0aQ99FJ0vxjS5skSdIIMGiTJEkaAQZtkiRJI8B72iRJGnE5Yt0bXetwb3Sda2xpkyRJGgFDDdqS7JXk8iSrkxw6zv5Nk5zU9p+TZGlLX5Tka0luS/LevmMem+Sidsx7kvHG0UmSJM0tQwvakiwAjgKeC+wK7Jdk175sBwE3VdXOwLuBd7T0O4A3An89TtHvBw4GdmnLXhu+9pIkSbPLMFva9gRWV9UVVfVL4ERgeV+e5cDxbf0U4BlJUlW3V9U36YK3uyR5ELB1VZ1dVQV8BNh7iOcgaUiSdRdJ0sSGGbRtB1zVs72mpY2bp6rWArcAi6Yoc80UZUqSJM05wwzaxvu/uX8oyyB57lX+JAcnWZVk1fXXXz9JkZIkSbPfMIO2NcAOPdvbA9dMlCfJQmAb4MYpytx+ijIBqKqjq2pZVS1bvHjxelZdkiRpdhlm0HYusEuSnZJsAqwAVvblWQkc0Nb3Ac5o96qNq6quBW5N8oQ2avSVwGc3fNUlSZJml6E9XLeq1iY5BDgNWAAcW1WXJHkLsKqqVgLHACckWU3XwrZi7PgkVwJbA5sk2Rt4dlVdCvwxcBywOfDFtkiSJM1pQ50RoapOBU7tS3tTz/odwL4THLt0gvRVwO4brpaSJEmznzMiSJIkjQCDNkmSpBHghPGSJM1xTig/N9jSJkmSNAIM2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI0AgzZJkqQRYNAmSZI0AgzaJEmSRoDTWEmSNI85xdXosKVNkiRpBBi0SZIkjQCDNkmSpBFg0CZJkjQCDNokSZJGgEGbJEnSCDBokyRJGgE+p02aY7LuI5coH7kkSSPPljZJkqQRYEubJEkal7MlzC62tEmSJI2AoQZtSfZKcnmS1UkOHWf/pklOavvPSbK0Z99hLf3yJM/pSb8yyUVJLkiyapj1lyRJmi2G1j2aZAFwFPAsYA1wbpKVVXVpT7aDgJuqauckK4B3AC9PsiuwAtgNeDDwlSQPq6o723FPq6obhlV3SZKk2WaYLW17Aqur6oqq+iVwIrC8L89y4Pi2fgrwjCRp6SdW1S+q6ofA6laeJEnSvDTMoG074Kqe7TUtbdw8VbUWuAVYNMWxBXw5yXlJDh5CvSVJkmadYY4eHedpUfQPOZkoz2TH/m5VXZPkAcDpSS6rqrPWefEuoDsYYMmSJYPXWpIkaRYaZkvbGmCHnu3tgWsmypNkIbANcONkx1bV2M/rgE8zQbdpVR1dVcuqatnixYv/zycjSZI0k4YZtJ0L7JJkpySb0A0sWNmXZyVwQFvfBzijqqqlr2ijS3cCdgG+k2SLJFsBJNkCeDZw8RDPQZIkaVYYWvdoVa1NcghwGrAAOLaqLknyFmBVVa0EjgFOSLKaroVtRTv2kiQnA5cCa4E/rao7kzwQ+HQ3VoGFwMer6kvDOgfNrOmejsnpnyRpcD54d/oNdUaEqjoVOLUv7U0963cA+05w7NuAt/WlXQE8esPXVBoOA0FJ0obijAiSJEkjwKBNkiRpBBi0SZIkjQCDNkmSpBFg0CZJkjQChjp6VJIkzT8+DmQ4bGmTJEkaAba0aST5/DNJ0nxjS5skSdIIMGiTJEkaAQZtkiRJI8B72iRJ0rRxZOm9Z0ubJEnSCDBokyRJGgEGbZIkSSPAoE2SJGkEOBBBkiTNCg5SmJxBm4ZuumcvcLYESdJcZPeoJEnSCLClTZIkzXp2ndrSJkmSNBIM2iRJkkaA3aMamDf4S5Jmo/nSdWpLmyRJ0giwpW0OskVMkqTOXGqFG2pLW5K9klyeZHWSQ8fZv2mSk9r+c5Is7dl3WEu/PMlzBi1zvkjWXSRJ0tw1tJa2JAuAo4BnAWuAc5OsrKpLe7IdBNxUVTsnWQG8A3h5kl2BFcBuwIOBryR5WDtmqjLnjGG1mPWXayucJGk+GrVWuGF2j+4JrK6qKwCSnAgsB3oDrOXAm9v6KcB7k6Sln1hVvwB+mGR1K48BypwRkwVY93afJEmaGbMxoBtm9+h2wFU922ta2rh5qmotcAuwaJJjBylTkiRpzkkNqVknyb7Ac6rq1W37FcCeVfVnPXkuaXnWtO0f0LWovQU4u6o+2tKPAU6lCzInLbOn7IOBg9vmw4HLh3KiG9b9gRtmuhKzkNdlYl6biXltJua1GZ/XZWJem4kN49rsWFWL+xOH2T26BtihZ3t74JoJ8qxJshDYBrhximOnKhOAqjoaOPreVn4mJFlVVctmuh6zjddlYl6biXltJua1GZ/XZWJem4lN57UZZvfoucAuSXZKsgndwIKVfXlWAge09X2AM6pr+lsJrGijS3cCdgG+M2CZkiRJc87QWtqqam2SQ4DTgAXAsVV1SZK3AKuqaiVwDHBCG2hwI10QRst3Mt0Ag7XAn1bVnQDjlTmsc5AkSZothvpw3ao6le5etN60N/Ws3wHsO8GxbwPeNkiZc8hIdedOI6/LxLw2E/PaTMxrMz6vy8S8NhObtmsztIEIkiRJ2nCce1SSJGkEGLTNsCRvTfLdJBck+XKSB7f0JHlPm67ru0keM9N1nW5J/inJZe38P51k2559405zNl8k2TfJJUl+nWRZ3775fm2c6q5JcmyS65Jc3JN2vySnJ/nv9vO+M1nHmZJkhyRfS/K99rv0upY+769Pks2SfCfJhe3aHNHSd2pTTv53m4Jyk5mu60xIsiDJ+Uk+37an7boYtM28f6qqR1XVHsDngbF7/p5LN2p2F7rnzb1/huo3k04Hdq+qRwHfBw4D6JvmbC/gfW3atPnkYuAlwFm9ifP92vRMn/dcYFdgv3ZN5qvj6D4HvQ4FvlpVuwBfbdvz0Vrgr6rqkcATgD9tnxWvD/wCeHpVPRrYA9gryRPoppp8d7s2N9FNRTkfvQ74Xs/2tF0Xg7YZVlU/7dncAhi7yXA58JHq/CewbZIHTXsFZ1BVfbnNlAHwn3TP5YOeac6q6odA7zRn80JVfa+qxntg9Hy/NndNn1dVvwTGprqbl6rqLLqR+b2WA8e39eOBvae1UrNEVV1bVf/V1m+l+xLeDq8P7Xvntra5cVsKeDrdlJMwT69Nku2B5wMfbtthGq+LQdsskORtSa4C9ufuljan7LqnPwC+2Na9NhOb79dmvp//IB5YVddCF7gAD5jh+sy4JEuB3wLOwesD3NUFeAFwHV2vxw+Am3v+kZ6vv1v/Arwe+HXbXsQ0XheDtmmQ5CtJLh5nWQ5QVX9XVTsAHwMOGTtsnKLm3FDfqa5Ny/N3dF0ZHxtLGqeoeXltxjtsnLQ5d20mMd/PX+spyZbAJ4E/7+v5mNeq6s522872dC3Yjxwv2/TWamYleQFwXVWd15s8TtahXZehPqdNnap65oBZPw58ATicwaYBG3lTXZskBwAvAJ5Rdz+fxmszsXlxbSYx389/ED9O8qCqurbdcnHdTFdopiTZmC5g+1hVfaole316VNXNSc6ku+9v2yQLW6vSfPzd+l3gRUmeB2wGbE3X8jZt18WWthmWZJeezRcBl7X1lcAr2yjSJwC3jDXZzxdJ9gLeALyoqn7Ws2uiac7ktXGqu6n1Th94APDZGazLjGn3Ih0DfK+q3tWza95fnySLx0brJ9kceCbdPX9fo5tyEubhtamqw6pq+6paSve35Yyq2p9pvC4+XHeGJfkk8HC6/vEfAa+pqqvbH5T30o38+hnwqqpaNXM1nX7ppjfbFPhJS/rPqnpN2/d3dPe5raXr1vji+KXMTUleDPwbsBi4Gbigqp7T9s33a/M8uv9+x6a6W2dmlfkiyX8ATwXuD/yYrhX/M8DJwBLgf4B9q6p/sMKcl+SJwDeAi7j7/qS/pbuvbV5fnySPoruhfgFd487JVfWWJA+hG9xzP+B84Per6hczV9OZk+SpwF9X1Qum87oYtEmSJI0Au0clSZJGgEGbJEnSCDBokyRJGgEGbZIkSSPAoE2SJGkEGLRJc1SSv0tySZLvJrkgyeOn8bWT5IwkW2/AMl+T5JVt/cAkD+7Z9+HpmBg+yZlJlg37dXpeb+/e8+o/7/Us66lJPr/hajfl65069qyv9TzuBUmOGEadpFFn0CbNQUl+m24micdU1aPoHo551eRHTVnm+syg8jzgwg05LVBVfaCqPtI2DwQe3LPv1VV16YZ6rVlkb6A3GD2QnvOeLuv53gNQVc+rqpvvxct9ge6p8/e5F8dKc5pBmzQ3PQi4YewBj1V1Q1VdA5DkcUm+neTCJN9JslWSzZL8e5KLkpyf5Gkt74FJPpHkc8CXW9rfJDm3teBN1CKyP+2p4EmWJrksyfHtmFPGvpCTPKO93kVJjk2yaUt/e5JLW/5/bmlvTvLXSfYBlgEfay2Im4+1gCX54yT/OFaJVv9/a+u/3873giQfTLKgt8JJ9kzyqba+PMnPk2zSrs0VPVn3beV8P8mTWv4FSf6p57r8UUt/aqvbKe0afKw9OJu+1/7DduyFST6Z5D5JfodulpR/anV+wzjn/aZ23MVJjh4rO8nO6eauvTDJfyV5aN/rPa5d94ck2aJd+3Nb2vKJ3vue41+f5LVt/d1Jzuh5Pz/a1q9Mcv/2/n8vyYfStfx+Od1T9kny2p73+cT2WS3gTLp/OiT1qioXF5c5tgBbAhcA3wfeBzylpW8CXAE8rm1vTTcH8V8B/97SHkH3JPjN6Fp21gD3a/ueDRxNN0nyRsDngSeP8/o/ArZq60vpJlD+3bZ9LPDXrfyrgIe19I8Af073VPHLufvh39u2n2+mewI5dF/qy3pe70y6gGYxsLon/YvAE+kmu/4csHFLfx/wyr46LwR+2Nb/mW5KrN8FngL8R8/rvLOtPw/4Sls/GPj7tr4psArYiW42glvo5iPcCDgbeOI412tRz/qRwJ+19eOAffrPs2f7fj3rJwAvbOvnAC9u65sB92l1+TzwO8B5wJK2/x/onuAOsC3dZ2aL/ve+r75PAD7R1r9BN1XaxnQzLvxRS7+SbiaGpXSzc+zR0k/ueb1rgE173+e2vj/wbzP9e+TiMtsWW9qkOaiqbgMeSxdMXA+clORAuinTrq2qc1u+n1Y3yfET6b70qarL6IKuh7XiTq+7p/F5dlvOB/6LLsDrnT93zP2q6tae7auq6ltt/aPt9R5OFyR9v6UfDzwZ+ClwB/DhJC+hm8Zt0PO+HrgiyROSLGqv8S3gGe16nJvkgrb9kL5j1wKrkzwS2BN4V6vPk+gCkzFjE4ufRxeQQHdNXtnKPgdYxN3X5TtVtaaqfk0XSC9lXbsn+UaSi+gClt0GPOWnJTmnHfd0YLckWwHbVdWn23ndUXfP3ftIuqD7hVX1Pz11P7TV/Uy6IG9J29f73vc6D3hse61f0AWjy1j3Wo35YVVd0HPs0rb+XbqWw9+nC+zGXMcMdANLs91636cgaTRU1Z10X8Jnti/1A+gCrfHmrluny67H7X35/l9VfXCKl1+bZKMWqDDOa9ZEr1lVa5PsSRdYrQAOoQtIBnUS8DLgMuDTVVWt2/D4qjpsimO/ATwX+BXwFbqWrgV0LYNjxuYUvJO7/4aGrnXstN7C0s1P2DsHYe8xvY4D9q6qC1tw/dQp6kmSzehaDJdV1VVJ3kwXcE32Xl7b8vwWXSvXWN1fWlWX95X/eO753t+lqn6V5ErgVcC36YKvpwEPpZtYvF//Ndi8rT+fLjB+EfDGJLu14Hkz4OeTnIc0L9nSJs1BSR6epLcFbA+61rPLgAcneVzLt1W6m8zPomvhIcnD6FpaLmddpwF/kGTLlne7JA8YJ9/l3LMla0m6wREA+wHfbHVZmmTnlv4K4Out7G2q6lS67tI9xin/VmCrCU7/U3Q38O9HF8ABfBXYZ6yuSe6XZMdxjj2rvebZrdVuEV1r4iUTvNaY04A/TrJxK/9hSbaY4pheWwHXtuP370nvP8/e7c3azxvaNdsHutZTYE2SvVtdNs3dN/XfTBco/UMLKMfq/mc998P91oB1PosumD2LLth9DXBBVQ00oXWSjYAdquprwOvpuma3bLsfBlw8YD2kecOgTZqbtgSOH7vJm24E4pur6pfAy4F/S3IhcDrdl//7gAWtRe4k4MBqgxh6VdWXgY8DZ7e8pzB+8PQF7tla9D3ggFaX+wHvr6o76FpqPtHK+jXwgVbe51verwN/MU75xwEfGLshv6+ONwGXAjtW1Xda2qXA3wNfbuWeTjdYo985wAPpAhHoWpC+O0Ag8uH2mv+V5GLgg6xfT8Yb22ufThfMjjkR+Js2QOCh9Jw3XevVh4CLgM/Q3YM35hXAa9u5fhv4jbEdVfVj4IXAUa017a1096N9t9X9rQPW+Rt01/DsVuYdjN81OpEFwEfbe38+8O66e7Tp0+g+Q5J6ZMB/iiRpYEkeBHykqp6VZCnw+arafWZrpVGQ5IHAx6vqGTNdF2m2saVN0gZXVdcCH8oGfLiu5o0ldKOZJfWxpU2SJGkE2NImSZI0AgzaJEmSRoBBmyRJ0ggwaJMkSRoBBm2SJEkjwKBNkiRpBPx/naLMgvImaGwAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 720x360 with 1 Axes>"
       ]
@@ -718,21 +620,21 @@
    "source": [
     "**Interesting!** To the right of 0, we see a nice  bell-shaped curve. But there is a decidely non-normal pattern on the left side. There are gaps—scores for which the probability is zero—and there are spikes that rise above the normal curve. \n",
     "\n",
-    "What's causing the gaps? We know that a campaign score can never be 0. And in this campaign, no score can be -2, because a -2 can only be achieved with the final state `(1, 2)`:  one attacker and two defenders in a single territory; this campaign has only one defender in the final territory, so `(1, 2)` could never occur. Looking at the plot, we see gaps surrounding groups of bars, where the group sizes, reading left to right, are 1, 1, 3, 1, 2, 3, 5, and 1. These are exactly the number of defenders in the final 8 territories, so the gaps are indicating the impossible scores.\n",
+    "What's causing the gaps? We know that a campaign score can never be 0. And in this campaign, no score can be -2, because a -2 can only be achieved with the final state `State(1, 2)`:  one attacker and two defenders in a single territory; this campaign has only one defender in the final territory, so `State(1, 2)` could never occur. Looking at the plot, we see gaps surrounding groups of bars, where the group sizes, reading left to right, are 1, 1, 3, 1, 2, 3, 5, and 1. These are exactly the number of defenders in the final 8 territories, so the gaps are indicating the impossible scores.\n",
     "\n",
     "What's causing the spikes? To some extent they represent probability mass that has shifted over a place from the impossible states to the neighboring possible states. But the spikes are not quite tall enough to fill in the gaps. I admit I don't understand the exact shape of each spike–do you?\n",
     "\n",
-    "In the plot below  all the defenders are in a single territory, and there is no visible gap–the normalish shape is restored. However, there is something going on with odd-versus-even scores. I believe that part of what is happening is that all but the very last few battles will be 3-versus-2 battles, and thus will result in 2 casualties, preserving the parity of the total number of armies. The parity is broken only in the final battles. But I don't think that's the full story—what do you think?"
+    "To help your intuition, here's a campaign where 100 attackers take on 100 defenders, 50 in the first territory and  5  in each of 10 more territories:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x360 with 1 Axes>"
       ]
@@ -744,7 +646,36 @@
     }
    ],
    "source": [
-    "show(campaign_probdist((146, 100)))"
+    "show(campaign_probdist(State(100, 50, 10 * (5,))))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the plot below  all the defenders are in a single territory, and there is no visible gap–the bell shape is restored. However, there is something going on with odd-versus-even scores. I believe that part of what is happening is that all but the very last few battles will be 3-versus-2 battles, and thus will result in 2 casualties, preserving the parity of the total number of armies. The parity is broken only in the final battles. But I don't think that's the full story—what do you think?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "show(campaign_probdist(State(146, 100)))"
    ]
   },
   {
@@ -756,12 +687,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x360 with 1 Axes>"
       ]
@@ -773,7 +704,7 @@
     }
    ],
    "source": [
-    "show(campaign_probdist((146, 93, 1, 1, 1, 1)))"
+    "show(campaign_probdist(State(146, 93, (1, 1, 1, 1))))"
    ]
   },
   {
@@ -789,7 +720,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -800,7 +731,7 @@
     "    plt.xlabel('Number of Defenders'); plt.ylabel('Win Probability for Attackers')\n",
     "    plt.yticks([i / 10 for i in range(11)]); plt.xticks(range(0, 61, 5))\n",
     "    for delta in deltas:\n",
-    "        winprobs = [attacker_win_probability(campaign_probdist((max(0, d + delta), d))) \n",
+    "        winprobs = [attacker_win_probability(campaign_probdist(State(max(0, d + delta), d,)))\n",
     "                    for d in defenders]\n",
     "        plt.plot(defenders, winprobs, 'o-', label=f'Δ = {delta:2}')\n",
     "    plt.legend(shadow=True)"
@@ -808,7 +739,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -832,13 +763,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note that the purple line (fourth from bottom), where the number of attackers exactly equals the number of defenders, gives a low win probability for a small attacking force, but reaches 50% for 12-on-12, and 73% for 60-on-60. The red line, where the attackers have one more army than the defenders, dips from one to two defenders but is over 50% for a 6-on-5 attack. Similarly, the green line, where the attackers have a surplus of two armies, dips sharply from 75% to 66% as the number of defenders goes from 1 to 2, dips slightly more for 3 and 4 defenders, and then starts to rise. So overall, an attacker does not need a big advantage in armies as long as there are many armies on both sides. Even when the attacker is at a disadvantage in numbers (as in the bottom grey line where the attacker has five fewer armies), the attacker still has bettern than 50/50 odds with 45 attackers or more."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "Note that the purple line (fourth from bottom), where the number of attackers exactly equals the number of defenders, gives a low win probability for a small attacking force, but reaches 50% for 12-on-12, and 73% for 60-on-60. The red line, where the attackers have one more army than the defenders, dips from one to two defenders but is over 50% for a 6-on-5 attack. Similarly, the green line, where the attackers have a surplus of two armies, dips sharply from 75% to 66% as the number of defenders goes from 1 to 2, dips slightly more for 3 and 4 defenders, and then starts to rise. So overall, an attacker does not need a big advantage in armies as long as there are many armies on both sides. Even when the attacker is at a disadvantage in numbers (as in the bottom grey line where the attacker has five fewer armies), the attacker still has better than 50/50 odds with 45 attackers or more.\n",
+    "\n",
     "# Tests\n",
     "\n",
     "Here are regression unit tests that also serve as examples of usage."
@@ -846,7 +772,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -855,62 +781,68 @@
        "True"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "# Tests for States\n",
-    "assert A(start)  == 72\n",
-    "assert D(start)  == 22 \n",
-    "assert allD(start) == (22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
-    "assert sum(allD(start)) == 60 \n",
-    "assert len(allD(start)) == 14\n",
+    "assert start.A  == 72\n",
+    "assert start.D  == 22 \n",
+    "assert start.rest == (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
+    "assert sum(start.rest) + start.D == 60 \n",
+    "assert len(start.rest) == 13\n",
     "\n",
     "# Tests for update\n",
-    "small = State((10, 2, 5)) # Small example where 10 attackers battle 2, then 5 dfenders\n",
-    "assert update(small, (0, 2)) == (9, 5)    # 2 defenders dead; occupy the first territory\n",
-    "assert update(small, (1, 1)) == (9, 1, 5) # continue to battle\n",
-    "assert update(small, (2, 0)) == (8, 2, 5) # continue to battle\n",
-    "assert update(start, (1, 1)) == (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
-    "assert update((9, 2), (0, 2)) == (8,) # Attackers occupied the final territory\n",
+    "small = State(10, 2, (3, 4)) # Small example where 10 attackers battle 2 + 3 + 4 defenders\n",
+    "assert update(small, Deaths(0, 2)) == State(9, 3, (4,))    \n",
+    "assert update(small, Deaths(1, 1)) == State(9, 1, (3, 4)) \n",
+    "assert update(small, Deaths(2, 0)) == State(8, 2, (3, 4)) # continue to battle\n",
+    "assert update(State(10, 2, ()), Deaths(0, 2)) == State(9, 0, ())\n",
     "\n",
     "# The 4 sample dice rolls from www.ultraboardgames.com/risk/game-rules.php\n",
-    "assert battle_deaths([1, 1, 6], [3,])   == (0, 1) # Defender loses one\n",
-    "assert battle_deaths([2, 6, 1], [2, 3]) == (1, 1) # Both lose one\n",
-    "assert battle_deaths([3, 3],    [3, 4]) == (2, 0) # Attacker loses two\n",
-    "assert battle_deaths([6,],      [5, 4]) == (0, 1) # Defender loses one\n",
+    "assert battle_deaths([1, 1, 6], [3,])   == Deaths(0, 1) # Defender loses one\n",
+    "assert battle_deaths([2, 6, 1], [2, 3]) == Deaths(1, 1) # Both lose one\n",
+    "assert battle_deaths([3, 3],    [3, 4]) == Deaths(2, 0) # Attacker loses two\n",
+    "assert battle_deaths([6,],      [5, 4]) == Deaths(0, 1) # Defender loses one\n",
     "\n",
     "# All six possible battle dice combinations. The answers match those given at\n",
     "# a Risk data analysis blog: http://datagenetics.com/blog/november22011/\n",
-    "assert battle_deaths_probdist((1, 1)) == ProbDist({(1, 0):   21, (0, 1):   15})\n",
-    "assert battle_deaths_probdist((2, 1)) == ProbDist({(1, 0):   91, (0, 1):  125})\n",
-    "assert battle_deaths_probdist((3, 1)) == ProbDist({(1, 0):  441, (0, 1):  855})\n",
-    "assert battle_deaths_probdist((1, 2)) == ProbDist({(1, 0):  161, (0, 1):   55})\n",
-    "assert battle_deaths_probdist((2, 2)) == ProbDist({(2, 0):  581, (1, 1):  420, (0, 2):  295})\n",
-    "assert battle_deaths_probdist((3, 2)) == ProbDist({(2, 0): 2275, (1, 1): 2611, (0, 2): 2890})\n",
+    "assert battle_deaths_probdist(State(1, 1)) == ProbDist(\n",
+    "    {Deaths(1, 0):   21, Deaths(0, 1):   15})\n",
+    "assert battle_deaths_probdist(State(2, 1)) == ProbDist(\n",
+    "    {Deaths(1, 0):   91, Deaths(0, 1):  125})\n",
+    "assert battle_deaths_probdist(State(3, 1)) == ProbDist(\n",
+    "    {Deaths(1, 0):  441, Deaths(0, 1):  855})\n",
+    "assert battle_deaths_probdist(State(1, 2)) == ProbDist(\n",
+    "    {Deaths(1, 0):  161, Deaths(0, 1):   55})\n",
+    "assert battle_deaths_probdist(State(2, 2)) == ProbDist(\n",
+    "    {Deaths(2, 0):  581, Deaths(1, 1):  420, Deaths(0, 2):  295})\n",
+    "assert battle_deaths_probdist(State(3, 2)) == ProbDist(\n",
+    "    {Deaths(2, 0): 2275, Deaths(1, 1): 2611, Deaths(0, 2): 2890})\n",
     "\n",
-    "assert set(all_rolls(2)) == {(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), \n",
-    "                         (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), \n",
-    "                         (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), \n",
-    "                         (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), \n",
-    "                         (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), \n",
-    "                         (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)}\n",
+    "assert set(all_rolls(2)) == {\n",
+    "    (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), \n",
+    "    (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), \n",
+    "    (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), \n",
+    "    (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), \n",
+    "    (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), \n",
+    "    (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)}\n",
     "\n",
-    "assert attacker_win_probability(campaign_probdist((2, 1))) == 15/36\n",
-    "assert campaign_probdist((2, 1)) == ProbDist({(1, 1): 21/36, (1,): 15/36})\n",
-    "assert campaign_probdist((4, 2, 1)) == ProbDist(\n",
-    "    {(1, 2, 1): 0.21807067805974698,\n",
-    "     (1, 1, 1): 0.12597532213712342,\n",
-    "     (1, 1): 0.294669783648961,\n",
-    "     (1,): 0.14620529335276633,\n",
-    "     (2,): 0.21507892280140226})\n",
+    "assert attacker_win_probability(campaign_probdist(State(2, 1))) == 15/36\n",
+    "assert campaign_probdist(State(2, 1)) == ProbDist({State(1, 1): 21/36, State(1, 0): 15/36})\n",
+    "assert campaign_probdist(State(4, 2, (1,))) == ProbDist(\n",
+    "    {State(1, 2, (1,)): 0.21807067805974698,\n",
+    "     State(1, 1, (1,)): 0.12597532213712342,\n",
+    "     State(1, 1): 0.294669783648961,\n",
+    "     State(1, 0): 0.14620529335276633,\n",
+    "     State(2, 0): 0.21507892280140226})\n",
     "\n",
     "assert battle_update_probdist(ProbDist({start: 1})) == ProbDist(\n",
-    "    {(70, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.2925668724279835,\n",
-    "     (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.3357767489711934,\n",
-    "     (72, 20, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.37165637860082307})\n",
+    "    {State(70, 22, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.2925668724279835,\n",
+    "     State(71, 21, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.3357767489711934,\n",
+    "     State(72, 20, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.37165637860082307})\n",
     "\n",
     "True"
    ]
@@ -932,7 +864,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,