\n",
" \n",
"# The Diamond Game: A Probability Puzzle\n",
"\n",
"Puzzle master [**Wei-Hwa Huang**](https://en.wikipedia.org/wiki/Wei-Hwa_Huang) poses this problem (reworded by me): \n",
" \n",
"*You are playing a game where a merchant has a stockpile of bags for sale. Each bag contains an unknown number of diamonds. You can **buy** a randomly selected bag for 12 coins, look in the bag to see how many diamonds there are, and immediately decide whether to **keep it**, or **sell it back** for 11 coins. You can also (as many times as you want and at no cost) **peek** at a random bag and count the diamonds, without the option to buy. What is a good **strategy** for **maximizing** the number of diamonds in the bags you keep?*\n",
" \n",
"In this notebook I solve the problem and along the way demonstrate three things:\n",
"- How to reason with probability.\n",
"- How to compute the optimal strategy for a game like this.\n",
"- How to use data visualizations to better understand the results.\n",
" \n",
"# The main concepts\n",
" \n",
"- **Strategy**: In general, a **strategy** for a game is a policy for choosing an **action**, in each possible **situation**. \n",
"- **Actions**: The actions are to **peek** at or **buy** a bag, and after buying to **keep** the bag or **sell** it back, and finally to **stop** the game. \n",
"- **Situations**: A situation consists of:\n",
" 1) The number of coins you have.\n",
" 2) The number of diamonds in the bag you just bought. \n",
" 3) What you have learned about the distribution of diamonds from peeking. \n",
" - The situation does **not** include the number of diamonds you have already bought, because that information is irrelevant to what your best strategy should be; you are always trying to get more diamonds, regardless of how many you already have.\n",
"- **Stockpile**: By default, I'll say a stockpile is 1,000 bags with mean 100 diamonds per bag.\n",
"- **Peeks**: By default, a player peeks at 100 bags. (That should be plenty, but I'll test to make sure.)\n",
"- **Probability distribution**: A collection of bags can be represented as a dict of integer diamond counts: which counts are possible, and how often did each occur. \n",
" \n",
"# Good Strategy\n",
"\n",
"Here's what I think a good strategy should do:\n",
"- **Use the coins**: The goal is to maximize diamonds, not coins, so don't **stop** if you have enough coins to buy a bag. Also, don't **sell** a bag back if that would leave you with not enough coins to buy another bag.\n",
"- **Peek first**: If you're going to do a certain number of **peeks** eventually, it is always better to do all the peeks before any buys, so they can inform your future keep/sell choices. This is because peeks are free. If peeks had a cost, a good strategy would consider peeks that are contingent on the result of previous peeks and buys. \n",
"- **Keep or sell**: Once we accept the \"use the coins\" and \"peek first\" ideas, the remaining action choices are just **keep** or **sell**.\n",
"- **Maximize expected value of diamonds**: With 13 coins, buy a bag. Suppose it has *d* diamonds. Keep it if you think *d* is more than what you'd expect to get from selling it back and buying a different bag. With 14 or more you have to think ahead, considering the value of keeping or selling on this turn as well as on subsequent turns. No strategy can *guarantee* a maximal number of diamonds, because the number you get depends in part on random luck of the draw. Instead of a guarantee, we can evaluate a strategy by its [**expected value**](https://en.wikipedia.org/wiki/Expected_value): the expected value of the number of diamonds obtained, starting from a given situation, averaged over all possible random selections of bags from the stockpile.\n",
"- **Expected value is expected number**: We will assume that the expected *value* of the diamonds is the expected *number* of the diamonds. (This isn't necessarily so. Suppose that later in the game there was an important thing you could do if you have 100 diamonds, but not if you have less. Then the value of 100 diamonds is, say, twice the value of 99 diamonds, not 1% more. But we aren't given any threshold values like 100, so we will assume that each additional diamond is equally valuable.)\n",
"\n",
" \n",
"# Preliminaries\n",
" \n",
"Let's get these out of the way first: imports of necessary modules, and some constants: "
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "87ae23c0-9145-4271-be91-c1cd032fba9f",
"metadata": {},
"outputs": [],
"source": [
"import functools\n",
"import matplotlib.pyplot as plt\n",
"import random\n",
"from typing import *\n",
"from statistics import mean, stdev\n",
"\n",
"BUY = 12 # How many coins a bag costs\n",
"SELL = 11 # How many coins you get from selling a bag back\n",
"MEAN = 100 # Average number of diamonds in a bag\n",
"BAGS = 1000 # Default number of bags in the merchant's stockpile\n",
"PEEKS = 100 # Default number of peeks at the stockpile\n",
"\n",
"cache = functools.lru_cache(None) # Decorator\n",
"\n",
"random.seed(42) # For reproducability"
]
},
{
"cell_type": "markdown",
"id": "a0827ec9-3ee5-48ab-8e83-27dbd37120af",
"metadata": {},
"source": [
"# Discrete probability distributions\n",
"\n",
"There are two different collections of bags that we need to represent:\n",
"- The merchant's stockpile of bags.\n",
"- The bags that the player has peeked at.\n",
"\n",
"In both cases we need to know the number of diamonds in each bag–we want to represent a collection of integers, and how often each of those integers appears. This is called a [**discrete probability distribution**](https://en.wikipedia.org/wiki/Probability_distribution#Discrete_probability_distribution). I implement this with the class `ProbDist`, a subclass of Python's `Counter` class, that works as follows:\n",
"- `P = ProbDist([[108, 92, 108, 100, 92])` makes a distribution `P` with 5 samples.\n",
"- `P = ProbDist({108: 2, 92: 2, 100: 1})` makes the same distribution in a different way.\n",
"- `P(d)` gives the *probability* of `d` diamonds (e.g. `P(108) == 2/5`).\n",
"- `P[d]` gives the *count* of `d` diamonds (e.g. `P[108] == 2`).\n",
"- `P` is *hashable*, so that it can be passed to functions with a `cache` decorator. Caching is crucial for efficiency.\n",
"- The attributes `P.n, P.μ, P.σ` give the total count, mean, and standard deviation of the values in `P`, respectively.\n",
"- The `__str__` method gives an informative description of the distribution, including a descriptive `name`.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "4a5d3d85-57ec-45d7-853d-85e58113cc5c",
"metadata": {},
"outputs": [],
"source": [
"class Hashable:\n",
" \"\"\"A mixin that hashes objects based on their identity, `id(self)`.\"\"\"\n",
" def __hash__(self): return id(self)\n",
" def __eq__(self, other): return self is other\n",
"\n",
"class ProbDist(Hashable, Counter):\n",
" \"\"\"A discrete probability distribution, mapping values to frequencies.\"\"\"\n",
" def __init__(self, samples: Union[Iterable, Mapping], name='ProbDist'):\n",
" \"`samples` can be either an iterable of values, or a {value: count} mapping.\"\n",
" super().__init__(samples)\n",
" values = list(self.elements())\n",
" self.μ = mean(values)\n",
" self.σ = stdev(values)\n",
" self.n = len(values)\n",
" self.name = name\n",
" def __call__(self, d) -> float: return self[d] / self.n\n",
" def __str__(self) -> str: return f'{self.name}[μ={self.μ:.1f}, σ={self.σ:.1f}, n={self.n:,d}]'"
]
},
{
"cell_type": "markdown",
"id": "26f30076-ad7b-45b7-b374-de7fbf584131",
"metadata": {},
"source": [
"Here's an example of building a probability distribution, `P`, from five values, and making some assertions about it:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "04519783-37b6-4835-b314-0cf0d0bd82bd",
"metadata": {},
"outputs": [],
"source": [
"P = ProbDist([108, 92, 108, 100, 92])\n",
"\n",
"assert P[108] == 2 # number of times 108 occurs\n",
"assert P(108) == 2/5 # probability of 108\n",
"assert P.n == 5 # total number of samples in the distribution\n",
"assert P.μ == 100 # mean of the samples\n",
"assert P.σ == 8 # standard deviation of the samples\n",
"assert dict(P) == {108: 2, 92: 2, 100: 1} \n",
"assert repr(P) == 'ProbDist({108: 2, 92: 2, 100: 1})'\n",
"assert str(P) == 'ProbDist[μ=100.0, σ=8.0, n=5]'"
]
},
{
"cell_type": "markdown",
"id": "bc29b4d5",
"metadata": {},
"source": [
"I will define the function `normal` to create a stockpile of bags that will have a roughly normal (Gaussian) distribution. Then I will define `peek` to peek at some of the bags in a stockpile:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "28786f50-8834-4b40-9faf-54dada711091",
"metadata": {},
"outputs": [],
"source": [
"def normal(σ, μ=MEAN, n=BAGS) -> ProbDist:\n",
" \"\"\"A ProbDist of `n` integers sampled from a Normal distribution with mean `μ` and standard deviation `σ`.\"\"\"\n",
" values = [max(0, round(random.gauss(μ, σ))) for _ in range(n)]\n",
" return ProbDist(values, 'normal')\n",
"\n",
"def peek(stockpile: ProbDist, peeks=PEEKS) -> ProbDist:\n",
" \"\"\"A ProbDist formed by peeking at `peeks` values sampled randomly from stockpile.\"\"\"\n",
" values = random.choices(list(stockpile), list(stockpile.values()), k=peeks)\n",
" return ProbDist(values, stockpile.name + '_peek')"
]
},
{
"cell_type": "markdown",
"id": "07b5c3b6-b3e2-444e-b6cb-5dee7e6e2fd8",
"metadata": {},
"source": [
"We see that a `peek` at 100 bags does a good job of capturing the statistics of a stockpile:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "e864cd55-5c9c-46a5-b006-10de35f25d6e",
"metadata": {},
"outputs": [],
"source": [
"stock1 = normal(σ=1)\n",
"peek1 = peek(stock1, peeks=100)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "5bb94ae2-8c73-43b4-8431-036572b6a3d7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"normal[μ=100.0, σ=1.1, n=1,000]\n"
]
}
],
"source": [
"print(stock1)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5259d068-a6b1-4277-a8e6-eed5c3239186",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"normal_peek[μ=100.0, σ=1.0, n=100]\n"
]
}
],
"source": [
"print(peek1)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "1fddb469-ed3f-4258-a545-b937bd00d204",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(100, 373),\n",
" (99, 252),\n",
" (101, 233),\n",
" (102, 67),\n",
" (98, 64),\n",
" (97, 7),\n",
" (103, 3),\n",
" (104, 1)]"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stock1.most_common() # Most common outcomes and their counts"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "ce79bb5f-4067-4556-a157-c3c4893b4a6a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(100, 40), (101, 26), (99, 24), (98, 5), (102, 4), (97, 1)]"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"peek1.most_common()"
]
},
{
"cell_type": "markdown",
"id": "1a4641c9-1b67-4a3d-a093-88fe1c9bca04",
"metadata": {},
"source": [
"We see that 100 is the most common outcome; then 99 and 101; then 98 and 102; and so on."
]
},
{
"cell_type": "markdown",
"id": "3193d3bd-eaf7-4b9f-acc7-5102af1a313b",
"metadata": {},
"source": [
"# Strategies\n",
"\n",
"We previously explained that it best to do all the peeks first, and to continue buying bags until the coins are exhausted. So we'll assume that all strategies do that, and we're left with the task of making **keep**/**sell** choices. I will use two conventions:\n",
"- A **strategy** is a function, `strategy(c, d)`, that returns `'keep'` if a player who just bought a bag with `d` diamonds and has `c` coins remaining should keep the bag, and otherwise returns `'sell'`. \n",
"- A **strategy maker** is a function that is passed a distribution of peeked-at bags and returns a strategy function.\n",
"\n",
"For example, `cutoff_strategy` is a strategy maker such that `cutoff_strategy(peeks, 0.95)` returns a strategy function that keeps all bags with at least 95% of the mean number of diamonds in `peeks`. (Also, if it started with exactly BUY coins, it keeps the bag, because selling it back would not yield enough coins to buy another bag.)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "5970413b-5752-4033-8168-c2cbbac6f3a1",
"metadata": {},
"outputs": [],
"source": [
"Action = Literal['keep', 'sell'] # The two possible actions\n",
"Strategy = Callable[[int, int], Action] # strategy(coins, diamonds) -> 'keep' | 'sell'\n",
"\n",
"def cutoff_strategy(peeks: ProbDist, ratio=1.0) -> Strategy:\n",
" \"\"\"Strategy to keep all bags with `ratio * P.μ` or more diamonds. \n",
" Also keep a bag if selling it back would not yield enough coins to buy another bag.\"\"\"\n",
" cutoff = ratio * peeks.μ\n",
" def strategy(c: int, d: int) -> Action: \n",
" return 'keep' if (c == BUY or d >= cutoff) else 'sell'\n",
" strategy.__name__ = f'cutoff_{cutoff:.0f}' # Give the strategy a descriptive name\n",
" return strategy"
]
},
{
"cell_type": "markdown",
"id": "b23e0fe4-5d9e-4edd-be37-097e447ed436",
"metadata": {},
"source": [
"Here are some examples of a cutoff strategy deciding what action to take:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "2023f0ce-4bf4-442f-87bf-a3bee5c6a4bc",
"metadata": {},
"outputs": [],
"source": [
"strategy = cutoff_strategy(peek1, 0.95) # A strategy to keep bags at least 95% of the mean of peek1\n",
"\n",
"assert strategy(42, 92) == 'sell' # 92 is below the cutoff; sell it back\n",
"assert strategy(42, 103) == 'keep' # 103 is above the cutoff; keep it"
]
},
{
"cell_type": "markdown",
"id": "961d5ed9-dc05-46d3-84e6-f6c0f7d56264",
"metadata": {},
"source": [
"# Expected value\n",
"\n",
"I'll define $E(P, \\textit{strategy}, c)$ to be the expected number of diamonds that can be bought with $c$ coins, from a stockpile with distribution $P$, when the player follows the given $\\textit{strategy}$. The expected value is 0 if we don't have enough coins to buy any bags, and otherwise is the probability-weighted average, over all possible bags, of the expected value of the result of either keeping or selling back the bag, depending on what the strategy says to do. When the cost of a bag is 12 this can be written as:\n",
"\n",
"\n",
"$$E(P, \\textit{strategy}, c) = \\sum_{d \\in P} P(d) \\left\\{ \\begin{array}{ l l }\n",
" 0 & \\textbf{if } c < 12 \\\\\n",
" E(P, \\textit{strategy}, c - 12) + d & \\textbf{if } \\textit{strategy}(c, d) = \\textit{keep} \\\\\n",
" E(P, \\textit{strategy}, c - 12 + 11) & \\textbf{if } \\textit{strategy}(c, d) = \\textit{sell}\n",
" \\end{array}\\right.$$\n",
" \n",
"Our game is small enough that it is computationally feasible to do an exact expected value calculation, as long as we cache results:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "cac11aac-5f3a-4db0-87ec-095434692202",
"metadata": {},
"outputs": [],
"source": [
"@cache\n",
"def E(P: ProbDist, strategy: Strategy, c: int) -> float:\n",
" \"\"\"The expected number of diamonds that can be bought with `c` coins using `strategy`,\n",
" when the stockpile of bags has distribution `P`.\"\"\" \n",
" return (0 if c < BUY else\n",
" sum(P(d) * (E(P, strategy, c - BUY) + d if strategy(c, d) == 'keep' else \n",
" E(P, strategy, c - BUY + SELL)) \n",
" for d in P))"
]
},
{
"cell_type": "markdown",
"id": "e93ec7ef-1cdf-45a2-b3f7-6a646588cfbc",
"metadata": {},
"source": [
"This function always terminates because each recursive call reduces the number of coins, and when we get down to fewer than 12 coins, the expected value is always zero. If this was not the case (say, if you could have a negative balance of coins and still continue the game) then this computation of $E$ would lead to an infinite loop.\n",
"\n",
"# Optimal strategy\n",
"\n",
"For any game, the optimal strategy is to *take the action that leads to the highest expected value*. That may sound trivial or circular: \"the best strategy is to choose the best action.\" But it is actually neither trivial nor circular, and can be implemented with the strategy maker `optimal_strategy`: "
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "1f696165-19f9-4d6e-911f-cbc2d9f41e3a",
"metadata": {},
"outputs": [],
"source": [
"def optimal_strategy(peeks: ProbDist) -> Strategy:\n",
" \"\"\"Strategy to take the action (keep or sell) that leads to the highest expected value.\"\"\"\n",
" def optimal(c: int, d: int) -> Action:\n",
" return 'keep' if E(peeks, optimal, c - BUY) + d > E(peeks, optimal, c - BUY + SELL) else 'sell'\n",
" return optimal"
]
},
{
"cell_type": "markdown",
"id": "b91acd05",
"metadata": {},
"source": [
"One subtle but important point: if we want to know the *true* expected value of a situation, we would call `E(c, stockpile, strategy)`. That's easy enough for us to do as outside observers of the game. But a player *in* the game does not have access to the stockpile; all they have is an *estimate* of the stockpile distribution, gained from peeks. We will see that usually the estimate is quite good."
]
},
{
"cell_type": "markdown",
"id": "e2ff0dc8-ed00-4548-a054-cc4004aeab5f",
"metadata": {},
"source": [
"Here we see the optimal strategy in action:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "fa73f557-2ae4-42ac-9fc4-5d9f35a80768",
"metadata": {},
"outputs": [],
"source": [
"stock10 = normal(σ=10) # A stockpile with standard deviation 10 (and mean 100)\n",
"peek10 = peek(stock10) # A probability distribution formed by peeking at some bags\n",
"optimal = optimal_strategy(peek10) # The optimal strategy with respect to peek10\n",
"\n",
"assert 99 < peek10.μ < 101 # The mean of peek10 should be somewhere around 100\n",
"assert 9 < peek10.σ < 11 # The standard deviation of peek10 should be somewhere around 10\n",
"assert optimal(13, 98) == 'sell' # sell back because we expect about 100 on the next buy\n",
"assert optimal(13, 103) == 'keep' # keep because we expect about 100 on the next buy\n",
"assert optimal(15, 103) == 'sell' # 103 is an above average bag, but we have 3 chances to do better; sell it\n",
"assert optimal(23, 110) == 'sell' # 110 is a very good bag, but we have 11 chances to do better; sell it\n",
"assert optimal(23, 116) == 'keep' # Even with 11 more chances, it is tough to beat a bag with 116 diamonds\n",
"assert optimal(12, 50) == 'keep' # keep because if we sold we couldn't buy another bag"
]
},
{
"cell_type": "markdown",
"id": "cc49d59a-9a0c-4a68-8515-c868b892e1f9",
"metadata": {},
"source": [
"We can use the strategy to play a random instance of the game:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "c95654f3-c583-4a47-9be3-c0e7da3b2606",
"metadata": {},
"outputs": [],
"source": [
"def play(strategy, coins: int, stockpile: ProbDist, verbose=True) -> List[int]:\n",
" \"\"\"Play a game using `strategy` and return the list of bags kept. Optionally print each action.\"\"\"\n",
" bags = list(stockpile.elements())\n",
" kept = [] # List of bags kept\n",
" while coins >= BUY: # While you have enough coins to buy a bag:\n",
" coins -= BUY # Buy a bag\n",
" bag = random.choice(bags) # Count the diamonds in the bag\n",
" action = strategy(coins, bag) # Decide whether to keep it or sell it back\n",
" if action == 'keep':\n",
" kept.append(bag)\n",
" else:\n",
" coins += SELL\n",
" if verbose: \n",
" print(f'{bag:3d} diamond bag: {action} it (total: {sum(kept):3d} diamonds and {coins:3d} coins.')\n",
" return kept"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "562696b4-9786-4b64-ab89-9147aeb163b0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 88 diamond bag: sell it (total: 0 diamonds and 94 coins.\n",
" 96 diamond bag: sell it (total: 0 diamonds and 93 coins.\n",
" 98 diamond bag: sell it (total: 0 diamonds and 92 coins.\n",
"102 diamond bag: sell it (total: 0 diamonds and 91 coins.\n",
" 97 diamond bag: sell it (total: 0 diamonds and 90 coins.\n",
" 88 diamond bag: sell it (total: 0 diamonds and 89 coins.\n",
" 87 diamond bag: sell it (total: 0 diamonds and 88 coins.\n",
"117 diamond bag: keep it (total: 117 diamonds and 76 coins.\n",
" 92 diamond bag: sell it (total: 117 diamonds and 75 coins.\n",
" 89 diamond bag: sell it (total: 117 diamonds and 74 coins.\n",
"109 diamond bag: keep it (total: 226 diamonds and 62 coins.\n",
" 79 diamond bag: sell it (total: 226 diamonds and 61 coins.\n",
"113 diamond bag: keep it (total: 339 diamonds and 49 coins.\n",
"106 diamond bag: keep it (total: 445 diamonds and 37 coins.\n",
" 95 diamond bag: sell it (total: 445 diamonds and 36 coins.\n",
"108 diamond bag: keep it (total: 553 diamonds and 24 coins.\n",
"103 diamond bag: keep it (total: 656 diamonds and 12 coins.\n",
"108 diamond bag: keep it (total: 764 diamonds and 0 coins.\n"
]
},
{
"data": {
"text/plain": [
"[117, 109, 113, 106, 108, 103, 108]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(optimal_strategy(peek10), 95, stock10)"
]
},
{
"cell_type": "markdown",
"id": "b4d4c4e4-4924-4fe3-88b5-3ef62e8fbda4",
"metadata": {},
"source": [
"**We've solved the problem!** \n",
"\n",
"We could stop here, but I have some remaining questions! \n",
"\n",
"___\n",
"\n",
"# Visualizing a Strategy\n",
"\n",
"\n",
"\n",
"We have *defined* the optimal strategy, but do we *understand* it? In exactly which situations should we keep a bag and when should we sell it back? What's a concise intuitive explanation for these results? Here's some code that might lead to some understanding:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "f8d70f31-7fd3-47f2-9d7e-642c0e80b605",
"metadata": {},
"outputs": [],
"source": [
"plt.rcParams[\"figure.figsize\"] = (14, 6)\n",
"\n",
"COINS = range(12, 121) # Range of coin values to examine\n",
"\n",
"def plot_strategy(P: ProbDist, strategy):\n",
" \"\"\"Plot (coins, diamonds) points for which strategy(c, d) == 'sell'.\"\"\"\n",
" points = [(c, d) for c in COINS for d in range(min(P), max(P) + 1) \n",
" if strategy(c, d) == 'sell']\n",
" plt.scatter(*transpose(points), marker='.', label=strategy.__name__)\n",
" decorate(title=f'When to sell back with {strategy.__name__} strategy on {P}')\n",
" \n",
"def decorate(title, xticks=COINS[::BUY], xlabel='coins', ylabel='diamonds'):\n",
" \"\"\"Decorate the plot with title, grid lines, ticks, and labels.\"\"\"\n",
" plt.grid(True); plt.xticks(xticks)\n",
" plt.title(title); plt.xlabel(xlabel); plt.ylabel(ylabel)\n",
" \n",
"def transpose(matrix): return zip(*matrix)"
]
},
{
"cell_type": "markdown",
"id": "6b454a23-6c5b-4882-8c3c-b2c17c6caac2",
"metadata": {},
"source": [
"The plot below looks at situations where the x-axis lists the number of coins you have before you buy a bag, and the y-axis lists the number of diamonds in the bag you bought. A blue dot at position (x, y) means that the optimal strategy is to sell the bag back in that situation. This is the *true* optimal strategy for `stock10`, obtained by having exact knowledge of the stockpile, something that a player could never obtain exactly."
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "ea737adf-801a-4eb2-96db-e84abd46c994",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABIgAAAIhCAYAAAAl74HfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC77UlEQVR4nOzde3hcZdU+/ntnmrZJ2wxtB9oUKAkIiDRgxYICQrG0QMrJqFSLchYUfJGDgq0cUoQG6stBCyIqAoLFKgZ4wbxyElAsaKCALSJ+qQ3lEMChMFOaaUmb5/dHf5m3Q5JmTfJ0z1p735/r6qWdru59Z629H5Kncwiccw5ERERERERERBRbZaUOQEREREREREREpcUNIiIiIiIiIiKimOMGERERERERERFRzHGDiIiIiIiIiIgo5rhBREREREREREQUc9wgIiIiIiIiIiKKOW4QERERERERERHFHDeIiIiIiIiIiIhijhtEREREREREREQxxw0iItrq7rrrLgRBgMWLF/f4s7333htBEOCBBx7o8We77LILPvGJT+R/HwQBvvnNb27VrMVYsmQJGhsb8d5775U6Sp9uvfVWBEGAtra2/GMnnXQSampq+v27U6dOxaRJk7ZeOEXnDYIAjY2N+d//4x//QGNjY0HfupWqL31544030NjYiOeee67HnzU2NiIIgvBDAXjssccQBAEee+yxQR+rpaWlYD6+/fjHP8att9661Y5POnx47Wtra0MQBPlfd911V6h51qxZg7PPPhvbb789hg0bht122w0LFizAxo0be9T+7W9/w2GHHYZRo0Zh5MiROOSQQ/CXv/xFfK5HH30U06dPx3bbbYeRI0dir732wo9+9KNez6XF/fffjxNOOAF1dXUoLy/f4lrW2dmJefPmoaamBsOGDcNHP/pRLFy4UHSeP/7xjzjllFPw0Y9+FCNGjMD222+PY445Bs8884yvL2WreOKJJ3Daaadhn332wbBhw3r8t15i6dKlOPTQQzFy5Ehss802aGhowL///e9eaxcuXIiPfvSjGDZsGGprazFv3jx0dnb2qHv77bdx0kknIZVKobKyEp/+9KfxyCOP9Kj7+Mc/nr/3jjzyyKJyE9HWww0iItrqpk6diiAI8OijjxY8vnr1aixbtgwjRozo8WevvfYa/v3vf+OQQw4JM2pRlixZgnnz5qneICKZJ598Eqeddlr+9//4xz8wb968or/ZLoU33ngD8+bN63WD6LTTTsOTTz4ZfijPWlpaMG/evK12fG4QxdtFF12EJ598Ep/97GdDO+eGDRswffp03HHHHZg7dy7uv/9+HHXUUfjud7+Lc889t6C2tbUVBx10EHK5HG6//XbcfvvtWLduHaZNmya6vx9++GEceuih2LBhA372s5/hnnvuwdSpU/Gtb30L55133tb6Egft7rvvxlNPPYWPfexj2HvvvbdYe+aZZ6KpqQlnnXUWHnjgAXzuc5/Dt771LcyfP7/f89x4441oa2vDt771LbS0tOCHP/wh3n77bXzqU5/CH//4R19fjnePPPIIHn74YUycOBH7779/0X//n//8J6ZOnYoPPvgAv/nNb/CLX/wC//rXv/CZz3wG//nPfwpqr7jiCnzrW99CQ0MDHnjgAZx55pmYP38+zjrrrIK69evXY9q0aXjkkUfwwx/+EPfeey/GjRuHww8/HI8//nhB7e23344nn3wS48ePL/6LJ6KtxxERhaCurs7tvvvuBY81Nze78vJyd/bZZ7t999234M9++ctfOgDuvvvuyz8GwJ111lmh5JX4wQ9+4AC4lStXljpKn2655ZYeGU888US300479ft3Dz74YLfnnntuvXDKzru53/72tw6Ae/TRR3v8mYZ8m2ttbXUA3C233FLqKAUeffTRPntYrLPOOstJv2Xp6upyHR0dRR1/zz33dAcffPAAktFgFDunwfrw2rdy5cqS3Tt33nmnA+B+97vfFTx++umnu7KyMvfPf/4z/9hhhx3mxo0b59auXZt/LJvNulQq5fbff/9+z3X88ce7YcOGuffff7/g8RkzZriqqqpBfiVbz8aNG/P/f0trwPLly10QBG7+/PkFj3/ta19zFRUV7p133tnied56660ej61Zs8aNGzfOTZs2bQDJw7F5fwby/cgXv/hFl0qlXCaTyT/W1tbmysvL3QUXXJB/LJ1Ou+HDh7vTTz+94O9fccUVLggC98ILL+Qfu+GGGxwAt2TJkvxjnZ2d7mMf+1iP7/O67bTTTm7mzJni3ES0dfEZREQUikMOOQQvvfQS2tvb84899thjmDJlCurr6/HMM89gzZo1BX+WSCTwmc98psexbr/9duyxxx6orKzE3nvvjfvvv79Hzf/7f/8Ps2fPxnbbbYdhw4Zhjz32wA033FBQ0/0SmDvvvBPf+973MGHCBFRVVeHQQw/FSy+9tMWvp7GxEd/5zncAALW1tfmnSXe/nKarqwsLFizIPx17u+22wwknnIDXXnut31795z//wemnn44dd9wRw4YNw7bbbosDDjgADz/8cEHdww8/jGnTpqGqqgqVlZU44IADen0a92D9+c9/xqc+9SlUVFRg++23x8UXX9zjZQnz5s3DfvvthzFjxqCqqgqf+MQncPPNN8M51+N4ixYtwqc//WmMHDkSI0eOxMc//nHcfPPNW8xw9913o7KyEqeddho2bNjQa80NN9yAsrIyvP322/nHrr76agRBUPCvnF1dXRg9ejTOP//8/GObv8Ts1ltvxRe/+EUAm67b7tl++Bkmra2t+MxnPoPKykrsvPPOuPLKK9HV1bXFrwMA1q1bhzlz5qC2thZDhw7F9ttvj7POOqvHM9Fqampw5JFH4u6778Zee+2F4cOHY+edd8aPfvSjfE33PQQAJ598cj5r99fS20vMuo97//33Y/LkyaioqMAee+yRv49uvfVW7LHHHhgxYgT23XdfPP300wV//+mnn8aXvvQl1NTUoKKiAjU1Nfjyl7+MV155pd+vvTcdHR349re/jdraWgwfPhxjxozBJz/5Sdx5550ANr0sqPve3fzlQN3P7up+6elPfvIT7LHHHhg2bBhuu+02ALLrsqamBi+88AIef/zx/LE3fxlSNpvN5+ue1znnnIO1a9cWfB3vvfceTj31VIwZMwYjR47EzJkz8e9//7tgHn/+85/za86H/fKXv0QQBGhtbd1iv5YvX45jjjkGo0ePxvDhw/Hxj388//V2G8zaBvzfdfPCCy/gy1/+MpLJJMaNG4dTTjkFmUymoLbY67m5uRmTJ0/G8OHDMW/evHzWRYsW4cILL0R1dTVGjhyJo446Cm+99RbWrFmD008/HalUCqlUCieffDLef//9gmPfcMMNOOigg7DddtthxIgRqKurw4IFC3p9+YtUXy/F9fWyzb/85S8IggBHHHFEweNHHnkkurq6cPfddxfUTp06FZWVlfnHRo0ahYMOOghLliwp+O9qb8rLyzF06FBUVFQUPL7NNttg+PDhA/4aWlpacOCBB2LUqFEF9+aH79GBKiuT/Zhyzz33wDmHk08+ueDxk08+GblcDn/4wx+2+Pe32267Ho+NHDkSH/vYx/Dqq6/KA29msPeghLQ/vdmwYQPuv/9+fP7zn0dVVVX+8Z122gmHHHJIwfX3hz/8AevWreu1v8453HPPPfnH7r77buy+++749Kc/nX9syJAh+MpXvoK//e1veP311wecmYjCMaTUAYgoHg455BD86Ec/wmOPPYYvf/nLADa9J8KRRx6JAw44AEEQ4M9//jPq6+vzf/aJT3wCyWSy4Di///3v0draissuuwwjR47EggUL8LnPfQ4vvfQSdt55ZwCbXh60//77Y+LEibj66qsxfvx4PPDAAzj77LORTqdx6aWXFhxz7ty5OOCAA/Dzn/8c2WwWF154IY466ii8+OKLSCQSvX49p512GlavXo2FCxeiubkZ1dXVAICPfexjAIBvfOMb+OlPf4pvfvObOPLII9HW1oaLL74Yjz32GJYuXYpUKtVnr7761a9i6dKluOKKK7Dbbrvhvffew9KlS/HOO+/ka+644w6ccMIJOOaYY3DbbbehvLwcN910Ew477DA88MADmDZtWjHj6dObb76JL33pS/jud7+Lyy67DL///e9x+eWX491338X111+fr2tra8MZZ5yBiRMnAgCeeuop/Nd//Rdef/11XHLJJfm6Sy65BN///vfR0NCA888/H8lkEsuXL9/i5sK1116L73znO2hsbMRFF13UZ92hhx4K5xweeeSR/DX28MMPo6KiAg899FC+7umnn8Z7772HQw89tNfjzJw5E/Pnz8fcuXNxww035N8Ha5dddinoy/HHH4/zzz8fl156Ke6++27MmTMHEyZMwAknnNBnRuccjj32WDzyyCOYM2cOPvOZz+Dvf/87Lr30Ujz55JN48sknMWzYsHz9c889h3POOQeNjY0YP348fvWrX+Fb3/oWPvjgA3z729/GJz7xCdxyyy04+eSTcdFFF2HmzJkAgB122KHPDADw/PPPY86cOfje976HZDKJefPmoaGhAXPmzMEjjzyC+fPnIwgCXHjhhTjyyCOxcuXK/A+XbW1t2H333fGlL30JY8aMQXt7O2688UZMmTIF//jHP7Z4bffmvPPOw+23347LL78ckydPxtq1a7F8+fL89X7xxRdj7dq1uOuuuwpeTtN9zwGbfkD885//jEsuuQTjx4/P/8AnuS7vvvtufOELX0AymcSPf/xjAMjPoKOjAwcffDBee+01zJ07F3vttRdeeOEFXHLJJVi2bBkefvhhBEGArq4uHHXUUXj66afR2NiIT3ziE3jyySdx+OGHF3ytn/nMZzB58mTccMMN+Wu02/XXX48pU6bkN/x689JLL2H//ffHdttthx/96EcYO3Ys7rjjDpx00kl46623cMEFFxTUD2Rt29znP/95zJo1C6eeeiqWLVuGOXPmAAB+8YtfACj+el66dClefPFFXHTRRaitrcWIESPyG21z587FIYccgltvvRVtbW349re/jS9/+csYMmQI9t57b9x555149tlnMXfuXIwaNapgo3TFihWYPXt2fpPq+eefxxVXXIF//vOf+axb08aNG3vdDP+wsrKy/A/1H3zwAcrKylBeXl5Q092vv//97/nHPvjgg4I+frh22bJlBffDh33961/HnXfeibPPPhtz585FZWUl7rvvPtx9991oamrq/wvsxZ///GccddRR2G233XDTTTdh9OjR+O1vf4tbbrkFe++9N4488khss802ADZtyks2z4MgEF2XH7Z8+XJsu+22PV6qtNdee+X/vFiZTAZLly4d9MsOJffg1u5Pb1asWIFcLpfv0eb22msvPPTQQ1i3bh2GDx+e719dXV1BXXV1NVKpVEF/ly9f3us/7HWf54UXXsD222/v5Wsgoq2kdE9eIqI4Wb16tSsrK8s/RTmdTrsgCNwf/vAH55xz++67r/v2t7/tnHNu1apVDkDBU5yd2/QSs3HjxrlsNpt/7M0333RlZWWuqakp/9hhhx3mdthhh4KnTTvn3De/+U03fPhwt3r1aufc/70Epr6+vqDuN7/5jQPgnnzyyS1+TX09pfvFF190ANyZZ55Z8Phf//pXB8DNnTt3i8cdOXKkO+ecc/r887Vr17oxY8a4o446quDxjRs3ur333rvgadyDfYkZAHfvvfcWPP61r33NlZWVuVdeeaXXv7dx40bX2dnpLrvsMjd27FjX1dXlnHPu3//+t0skEu7444/v97x77rmn27hxo/vmN7/phg4d6u64445+8zrn3A477OBOOeUU55xz69evdyNGjHAXXnihA5DPe8UVV7jy8vKCl1sAcJdeemn+9/29xAyA++tf/1rw+Mc+9jF32GGHbTHfH/7wBwfALViwoODxxYsXOwDupz/9af6xnXbayQVB4J577rmC2unTp7uqqqr8y0229BKzSy+9tMfLMnbaaSdXUVHhXnvttfxjzz33nAPgqqurC17Gcs899zgA7n/+53/6/Jo2bNjg3n//fTdixAj3wx/+MP+49CVmkyZNcscee+wWa7b08hIALplM5u/rvvR1XTrX90vMmpqaXFlZmWttbS14/K677nIAXEtLi3POud///vcOgLvxxht7/P0PX1vd9+Szzz6bf+xvf/ubA+Buu+22LX4NX/rSl9ywYcPcqlWrCh4/4ogjXGVlpXvvvfecc4Nf27qvmw9fp2eeeaYbPnx4vnfFXs+JRMK99NJLBbXdWT+8np1zzjkOgDv77LMLHj/22GPdmDFj+szePedf/vKXLpFIFFwXxbzErK91srd7qntN6O/XiSeemP871113nQPg/vznPxcc6+KLL3YA3IwZM/KPffzjH3e77bZbwUuKOjs73c477+wAuEWLFvXZj25/+ctf3IQJE/JZEolEj7kV44gjjnAVFRXujTfeKHj86KOPdmPGjHFr1qzJP3biiSeK+rOll3luaQ2YPn16j5ewdxs6dGiPl0ZJHH/88W7IkCHu6aefLvrvOlfcPdh9TfX3a0v/3S72JWZ/+ctfHAB355139viz+fPnOwD52X7ta19zw4YN6/U4u+22W8G1Wl5e7s4444wedUuWLOnzWuVLzIh04UvMiCgUo0ePxt57751/Cdbjjz+ORCKBAw44AABw8MEH59+ouvt/e3uD6kMOOQSjRo3K/37cuHHYbrvt8s9AWbduHR555BF87nOfQ2VlJTZs2JD/VV9fj3Xr1uGpp54qOObRRx9d8Pvuf+ka6EtmuvOfdNJJBY/vu+++2GOPPfp9Gdi+++6LW2+9FZdffjmeeuqpHi+TWLJkCVavXo0TTzyx4Ovr6urC4YcfjtbW1h4vfxmoUaNG9ejP7Nmz0dXVhT/96U/5x/74xz/i0EMPRTKZRCKRQHl5OS655BK88847+Zd8PfTQQ9i4cWOPN7Xszbp163DsscfiV7/6FR588EEcf/zxorzTpk3LvxRvyZIl6OjowHnnnYdUKpV/FtHDDz+MT3/60xgxYoTomL0ZP3489t1334LH9tprr36vme43PP3wtfHFL34RI0aM6HFt7Lnnnj3enHX27NnIZrNYunTpANNv+vSYzf8Vd4899gCAHi9j6X5886/r/fffx4UXXoiPfOQjGDJkCIYMGYKRI0di7dq1ePHFF4vOsu++++J///d/8d3vfhePPfYYcrlc0cf47Gc/i9GjR/d4XHJdbsn999+PSZMm4eMf/3jBvXbYYYcVvKS0+81XjzvuuIK//+FnCXU/tt122xW85HXhwoXYdtttMWvWrC3m+eMf/4hp06Zhxx13LHj8pJNOQkdHR483LB7s2tbb31+3bl2+d8Vez3vttRd22223Xs/14U8x6r72up8Vt/njq1evLniZ2bPPPoujjz4aY8eOzc/5hBNOwMaNG/Gvf/1L9LUOxk033YTW1tZ+f23+SXzHH388xowZg9NPPx1//etf8d577+HOO+/MPzNq85cP/dd//Rf+9a9/4Zvf/CZef/11vPrqq/j617+en2N/LzV65pln8LnPfQ777LMP7rvvPvzxj3/EnDlzcNFFF+H73//+gL7mp556CtOmTevxzKWvfOUrWL16dcH61NjYKOrPTTfdNKAsALb4sr9iXxJ48cUX41e/+hWuvfZa7LPPPgPOBMjuwdNPP13Un/vuu29QWXoj7Vsx/fU5CyIKH19iRkShOeSQQ3DNNdfgjTfewKOPPop99tkHI0eOBLBpg+jqq69GJpPBo48+iiFDhuDAAw/scYyxY8f2eGzYsGH5HyrfeecdbNiwAQsXLuzzI27T6fQWj9n9tP2B/KDanQFAr0/5nzBhQr8/nC1evBiXX345fv7zn+Piiy/GyJEj8bnPfQ4LFizA+PHj8dZbbwEAvvCFL/R5jNWrVw9qA6TbuHHjejzW/TT+7q/zb3/7G2bMmIGpU6fiZz/7GXbYYQcMHToU99xzD6644op8H7s/FaW/lz8Bmz4m99VXX8Whhx5a1KezHHroobjtttvw//7f/8PDDz+MyZMnY7vttsNnP/tZPPzww5g9ezaWLFmC733ve+Jj9qa/67Av77zzDoYMGYJtt9224PEgCDB+/PiClxEC6PXTXT7c/4EYM2ZMwe+HDh26xcfXrVuXf2z27Nl45JFHcPHFF2PKlCmoqqpCEASor68f0D3zox/9CDvssAMWL16Mq666CsOHD8dhhx2GH/zgB9h1111Fx+jtXpNel1vy1ltv4eWXX+7xMqBu3WtJ91w/3L/e7p9hw4bhjDPOwNVXX40f/OAH6OzsxG9+8xucd955vb6MaHPvvPNOn+tK959vbrBrW39/v9jreUsvgxrINTly5EisWrUKn/nMZ7D77rvjhz/8IWpqajB8+HD87W9/w1lnnTXgdbwYH/nIR8QvMeuWSqXwhz/8ASeeeCI+9alPAdjU72uuuQannnpqwQbuKaecgv/85z+4/PLLceONNwIAPv3pT+Pb3/42rrrqqn5fsnPWWWdh3LhxuPvuu/MvUTrkkENQVlaGxsZGHH/88fmXaEutWbOm1/Wpe8abv9fMxIkTRev+QDcPxo4d2+unOK5duxYffPBBj2toS+bNm4fLL78cV1xxBb75zW8OKM+Hs22ut3tw85fFbonPzZXuXL39d2T16tUIgiD/EsGxY8di3bp16OjoKPgHhO7azTfRxo4d2+cxgZ73MxHpw2cQEVFoup8R9Nhjj+Gxxx7DwQcfnP+z7s2gP/3pT/k33u3ePCrG6NGjkUgkcNJJJ/X5r3Dd73O0tXR/49XbG4e+8cYb/b5HSyqVwnXXXYe2tja88soraGpqQnNzc/5f6bv//sKFC/v8Gnv7wXQgujejNvfmm28C+L+v89e//jXKy8tx//3347jjjsP++++PT37ykz3+XvcPkZI36p44cSLuu+8+PPbYY2hoaCjYoNiS7vdeevjhh/HQQw9h+vTp+ccfeeQR/OlPf8L69ev7fP+hrW3s2LHYsGFDj48Qds7hzTff7HFtdPe6t8d626Ta2jKZDO6//35ccMEF+O53v4tp06ZhypQpqKury/8AUKwRI0Zg3rx5+Oc//4k333wTN954I5566ikcddRR4mP09oOT9LrcklQqhbq6uj7vs4svvhjA/831wz3obX7Apvco6+zsxC9+8Qv87Gc/w4YNG/D1r3+93zxjx47tc13pzhumYq/nrfHsgXvuuQdr165Fc3MzvvKVr+DAAw/EJz/5yfxG0mD09ob4H36DbGDT+lJeXt7vr1NOOaXg73W/b9fKlSuxfPlyvPHGG/lnTh100EEFtRdeeCHS6TSWLVuGtrY2LFmyBO+++y5GjBjR77NcnnvuOeyzzz493r9mypQp6OrqGtAz/7bbbrte33C4e33ffH065ZRTRP0Z6Hvn1dXV4T//+U+P+23ZsmUAgEmTJomOM2/ePDQ2NqKxsRFz584dUJaBuOyyy0T92fx98AZrl112QUVFRb5Hm1u2bBk+8pGP5N/AvPu9hz5c++abbyKdThf0t66urs9jAvJZEFHp8BlERBSagw46CIlEAnfddRdeeOEFLFiwIP9nyWQy/2k8bW1tmD179oDOUVlZiUMOOQTPPvss9tprLy8/JPSlr3+N735TyzvuuKPgDWdbW1vx4osvFvXslYkTJ+Kb3/wmHnnkEfzlL38BABxwwAHYZptt8I9//MPLv3BuyZo1a/A///M/BU+TX7RoEcrKyvI/wARBgCFDhhT88JHL5XD77bcXHGvGjBlIJBK48cYbCz7hpC8zZszAAw88gJkzZ+LII4/Evffe2++zoqqrq/Gxj30Mv/vd7/DMM89g/vz5AIDp06fjjDPOwDXXXIOqqqotvhEwMPhnkfVl2rRpWLBgAe644w6ce+65+cd/97vfYe3atT1+QHrhhRfw/PPPF7zMbNGiRRg1alT+zbO3VtbeBEEA51yPZ7r8/Oc/7/HJdgMxbtw4nHTSSXj++edx3XXX5f/FevOv8cOfxLSlrJLrEuj72V9HHnkk5s+fj7Fjx6K2trbPcx188MFYsGABFi9ejG984xv5x3/961/3Wl9dXY0vfvGL+PGPf4wPPvgARx11VP6NtLdk2rRpuPvuu/HGG2/knzUEbPoEtMrKyvwzUcJS7PW8NXRvOm1+TTrn8LOf/WzQx25vb8fbb79d8OyO7nV4czfddFPBp3D2pa8NvO5PS3PO4eqrr8aECRPyn6S4uWHDhuV/wF61ahUWL16Mr33ta/3eExMmTMDTTz+NjRs3FtwP3S9JlDy758NmzJiBO++8E6+//nrBM5huu+02jBgxouBabGxsFP23avOXjxfjmGOOwUUXXYTbbrsNF154Yf7xW2+9FRUVFT3eLL433//+9/MfhPDhD7LY2k4//fQeL7HsTX/PMCzGkCFDcNRRR6G5uRkLFizI937VqlV49NFHC+7nww8/HMOHD8ett96K/fbbL//4rbfeiiAIcOyxx+Yf+9znPoczzzwTf/3rX/O1GzZswB133IH99tuvYN0iIp24QUREoen+mOl77rkHZWVl+fcf6nbwwQfjuuuuA9D7+w9J/fCHP8SBBx6Iz3zmM/jGN76BmpoarFmzBi+//HL+/Rd86P5XtR/+8Ic48cQTUV5ejt133x277747Tj/9dCxcuBBlZWU44ogj8p9ituOOOxZ84/VhmUwGhxxyCGbPno2PfvSjGDVqFFpbW/GHP/wBDQ0NADZ9/O7ChQtx4oknYvXq1fjCF76A7bbbDv/5z3/w/PPP4z//+U/+ZQiDNXbsWHzjG9/AqlWrsNtuu6GlpQU/+9nP8I1vfCP/A+3MmTNxzTXXYPbs2Tj99NPxzjvv4L//+797fDNbU1ODuXPn4vvf/z5yuVz+47P/8Y9/IJ1OY968eT3Of+CBB+KRRx7B4YcfjhkzZqClpaXHJ9t92LRp07Bw4UJUVFTkr7Ha2lrU1tbiwQcfxNFHH40hQ7b8n7/uH8J++tOfYtSoURg+fDhqa2sH/ayd6dOn47DDDsOFF16IbDaLAw44IP+pT5MnT8ZXv/rVgvoJEybg6KOPRmNjI6qrq3HHHXfgoYcewlVXXZV/qn/3vwT/6le/wh577IGRI0diwoQJW+Ub8aqqKhx00EH4wQ9+gFQqhZqaGjz++OO4+eab8y9HKNZ+++2HI488EnvttRdGjx6NF198Ebfffjs+/elP57/G7nvtqquuwhFHHIFEItHvBrD0uuw+/q9//WssXrwYO++8M4YPH466ujqcc845+N3vfoeDDjoI5557Lvbaay90dXVh1apVePDBB3H++edjv/32w+GHH44DDjgA559/PrLZLPbZZx88+eST+OUvfwmg9/eI+da3vpX/AeqWW24R9erSSy/F/fffj0MOOQSXXHIJxowZg1/96lf4/e9/jwULFvR7b/hW7PW8tTIMHToUX/7yl3HBBRdg3bp1uPHGG/Huu+8O+tjdP/xeeOGFGDZsGH7961/n31vnjjvuwMyZMzF69GjsvvvuAzr+9773PdTV1aG6uhqrVq3CL37xC/z1r3/F73//+4JNn+XLl+N3v/sdPvnJT2LYsGF4/vnnceWVV2LXXXft8R5Cp556Km677TasWLECO+20EwDg3HPPxdlnn42jjjoKZ5xxBiorK/HII4/g6quvxqGHHlqwAd3Y2Ih58+bh0UcfxdSpU/vMfskll+Dee+/F1KlTcemll2Ls2LG4/fbb8Yc//AELFiwo+Oj0mpqa/CZYMV555RW0trYC2PSpWwBw11135Y/Z/YzAPffcE6eeeiouvfRSJBIJTJkyBQ8++CB++tOf4vLLLy94WdNll12Gyy67DI888kj+WcxXX301LrnkEhx++OGYOXNmj/cp3Hyz69Zbb8XJJ5+MW265pcd7bw3UQNfr//znP/n3P+t+hs7//u//Ytttt8W2225b8CztqVOn4vHHHy94KeS8efMwZcoUHHnkkfjud7+LdevW4ZJLLkEqlcL555+frxszZgwuuugiXHzxxRgzZgxmzJiRf0+t0047Lf/prcCmZ4vdcMMN+OIXv4grr7wS2223HX784x/jpZdeyr8/IBEpV8I3yCaiGLrgggscAPfJT36yx591f2LS0KFDCz5JqRsAd9ZZZ/V4fKeddir4dBjnNn06zSmnnOK23357V15e7rbddlu3//77u8svvzxf0/0pI7/97W97/F308ck2HzZnzhw3YcIEV1ZWVvCJTRs3bnRXXXWV22233Vx5eblLpVLuK1/5inv11Ve3eLx169a5r3/9626vvfZyVVVVrqKiwu2+++7u0ksv7dGTxx9/3M2cOdONGTPGlZeXu+23397NnDmz4OsZ7KeY7bnnnu6xxx5zn/zkJ92wYcNcdXW1mzt3ruvs7Cyo/cUvfuF23313N2zYMLfzzju7pqYmd/PNN/f6qSq//OUv3ZQpU9zw4cPdyJEj3eTJkwt63X3ezS1fvtyNHz/efeITn3D/+c9/tpj73nvvdQDc9OnTCx7/2te+5gC4H/3oRz3+Dj70SVPObfqUodraWpdIJAquh97yOSfvay6XcxdeeKHbaaedXHl5uauurnbf+MY33LvvvltQ1/3JLnfddZfbc8893dChQ11NTY275pprehzzzjvvdB/96EddeXl5wdfS16eY9faJMb3dX933wg9+8IP8Y6+99pr7/Oc/70aPHu1GjRrlDj/8cLd8+fIe96H0U8y++93vuk9+8pNu9OjR+evn3HPPdel0Ol+zfv16d9ppp7ltt93WBUFQcF31tS44J78u29ra3IwZM9yoUaN6fFrQ+++/7y666CK3++67u6FDh7pkMunq6urcueee695888183erVq93JJ5/sttlmG1dZWemmT5/unnrqKQeg4NPdNldTU+P22GOPLfbnw5YtW+aOOuool0wm3dChQ93ee+/dY60a7NrWfd18+F7rbT0p9nr+sL6ydp/rw58g11u2++67z+29995u+PDhbvvtt3ff+c533P/+7//2uP4G8ilmV111lRs3bpwbPny4O/LII90TTzzhJkyY4LbffvuCTwIciG984xtu4sSJbujQoS6VSrnPf/7z7u9//3uPupdeeskddNBBbsyYMW7o0KHuIx/5iLvooosKPolx89y9rbu/+93v3IEHHuhSqZQbMWKE23PPPd33v//9Hsc4//zzXRAE7sUXX+w3/4svvuiOPfbYgmvx1ltvLa4JW9B9DfT268P/zf/ggw/cpZdemu/nbrvt1uta3339bH5d9PcpdJtbuHChA5D/BNa++Pj+oj/d5+jt14c/EW6fffZx48eP73GMp59+2k2bNs1VVla6qqoqd+yxx7qXX3651/P98Ic/dLvttpsbOnSomzhxorv00kvdBx980KPuzTffdCeccIIbM2aMGz58uPvUpz7lHnrooT6/Dn6KGZEugXOCd9UjIiKiUNXU1GDSpEm4//77Sx2FBmjRokU4/vjj8Ze//KXHm63//e9/x957740bbrgBZ555ZokSxltbWxtqa2tx880344QTTkAikci/ZO2kk07CY489hra2ttKGDNm+++6LnXbaCb/97W9LHUWl4447DitXrsw/s8mCNWvWYMyYMbjuuutEnyIalo0bN8I5h4985CP8bx2RInyJGREREdEgdb8fS11dHcrKyvDUU0/hBz/4AQ466KCCzaEVK1bglVdewdy5c1FdXe3tZSo0cKeeeipOPfVU/Pa3v93ip0NGXTabxfPPP4/bbrut1FFUcs7hsccewx133FHqKEX505/+hO233x5f+9rXSh2lwD777IPnn38eAN+8mkgTbhARERERDdKoUaPw61//GpdffjnWrl2b3/y5/PLLC+q+//3v4/bbb8cee+yB3/72tz0+NprCM2HChIJngvj8lCiLqqqqsH79+lLHUCsIArz99tuljlG0mTNnYubMmaWO0cOiRYvQ0dEBAAN+Dzsi8o8vMSMiIiIiIiIiirmeH6tBRERERERERESxwg0iIiIiIiIiIqKY4wYREREREREREVHM8U2qAXR1deGNN97AqFGj8h9vSkRERERERERknXMOa9aswYQJE1BW1vfzhLhBBOCNN97AjjvuWOoYRERERERERERbxauvvooddtihzz/nBhE2fTQtsKlZVVVVJU7TU2dnJx588EHMmDED5eXlpY5DReDsbOLc7OLsbOLc7OLs7OLsbOLc7OLs7IrC7LLZLHbcccf83kdfuEEE5F9WVlVVpXaDqLKyElVVVWYvyLji7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyK0uz6e0sdvkk1EREREREREVHMcYOIiIiIiIiIiCjmuEFERERERERERBRz3CAiIiIiIiIiIoo5bhAREREREREREcUcN4iIiIiIiIiIiGKOG0RERERERERERDHHDSIiIiIiIiIiopjjBhERERERERERUcxxg4iIiIiIiIiIKOa4QUREREREREREFHPcICIiIiIiIiIiijluEBERERERERERxRw3iIiIiIiIiIiIYo4bREREREREREREMccNIqIBaM/ksGRFGu2ZXKmjEBEREREREQ3akFIHILJmcesqzGlehi4HlAVAU0MdZk2ZWOpYRERERERERAPGZxARFaE9k8tvDgFAlwPmNi/nM4mIiIiIiIjING4QERVhZXptfnOo20bn0JbuKE0gIiIiIiIiIg+4QURUhNrUCJQFhY8lggA1qcrSBCIiIiIiIiLygBtEREWoTlagqaEOiWDTLlEiCDC/YRKqkxUlTkZEREREREQ0cHyTaqIizZoyEQftti3a0h2oSVVyc4iIiIiIiIjM4wYR0QBUJyu4MURERERERESRwZeYERERERERERHFHDeIKFbaMzksWZHe4sfS+6ohIiIiIiIisoIvMaPYWNy6CnOal6HLAWUB0NRQh1lTJm6VGiIiIiIiIiJL+AwiioX2TC6/qQMAXQ6Y27y84BlAvmqIiIiIiIiIrOEGEcXCyvTa/KZOt43OoS3d4b2GiIiIiIiIyBpuEFEs1KZGoCwofCwRBKhJVXqvISIiIiIiIrKGG0QUC9XJCjQ11CERbNrdSQQB5jdMKvioel81RERERERERNbwTaopNmZNmYiDdtsWbekO1KQqe93U8VVDREREREREZAk3iChWqpMV/W7o+KohIiIiIiIisoIvMSMiIiIiIiIiijluEJEJ7ZkclqxIb/Hj5LXVEBEREREREVnBl5iReotbV2FO8zJ0OaAsAJoa6jBrykTVNURERERERESW8BlEpFp7JpffjAGALgfMbV5e8MwdbTVERERERERE1nCDiFRbmV6b34zpttE5tKU71NYQERERERERWcMNIlKtNjUCZUHhY4kgQE2qUm0NERERERERkTXcICLVqpMVaGqoQyLYtCuTCALMb5hU8BHz2mqIiIiIiIiIrOGbVJN6s6ZMxEG7bYu2dAdqUpW9bsZoqyEiIiIiIiKyhBtEZEJ1sqLfjRhtNURERERERERW8CVmREREREREREQxV9INoj/96U846qijMGHCBARBgHvuuafgz5ubm3HYYYchlUohCAI899xzPY6xfv16/Nd//RdSqRRGjBiBo48+Gq+99lo4XwARERERERERUQSUdINo7dq12HvvvXH99df3+ecHHHAArrzyyj6Pcc455+Duu+/Gr3/9azzxxBN4//33ceSRR2Ljxo1bKzZ51J7JYcmKNNozuUHXaashIiIiIiIisqKk70F0xBFH4Igjjujzz7/61a8CANra2nr980wmg5tvvhm33347Dj30UADAHXfcgR133BEPP/wwDjvsMO+ZyZ/Fraswp3kZuhxQFgBNDXWYNWXigOq01RARERERERFZYvpNqp955hl0dnZixowZ+ccmTJiASZMmYcmSJX1uEK1fvx7r16/P/z6bzQIAOjs70dnZuXVDD0B3Jo3ZBuqt7Do03vt3lG/2HLZ59y7DATuPxriq4UXVaavZXBRnFwecm12cnU2cm12cnV2cnU2cm12cnV1RmJ00e+Ccc1s5i0gQBLj77rtx7LHH9viztrY21NbW4tlnn8XHP/7x/OOLFi3CySefXLDZAwAzZsxAbW0tbrrppl7P1djYiHnz5vV4fNGiRaisrBzU10FEREREREREpEVHRwdmz56NTCaDqqqqPutMP4OoL845BEHQ55/PmTMH5513Xv732WwWO+64I2bMmLHFZpVKZ2cnHnroIUyfPh3l5eWljuPFW9l1mH7t4+jabHsyEQR48NyDejyDqL86bTWbi+Ls4oBzs4uzs4lzs4uzs4uzs4lzs4uzsysKs+t+1VR/TG8QjR8/Hh988AHeffddjB49Ov/422+/jf3337/Pvzds2DAMGzasx+Pl5eWqB649XzF2GFuOxmP2wtzm5djoHBJBgMsaJmGHsaOKrtNW05sozS5OODe7ODubODe7ODu7ODubODe7ODu7LM9Omtv0BtE+++yD8vJyPPTQQzjuuOMAAO3t7Vi+fDkWLFhQ4nTUn1lTJuKg3bZFW7oDNalKVCcrBlynrYaIiIiIiIjIkpJuEL3//vt4+eWX879fuXIlnnvuOYwZMwYTJ07E6tWrsWrVKrzxxhsAgJdeegnApmcOjR8/HslkEqeeeirOP/98jB07FmPGjMG3v/1t1NXV5T/VjHSrTlaINlgkddpqiIiIiIiIiKwo679k63n66acxefJkTJ48GQBw3nnnYfLkybjkkksAAP/zP/+DyZMnY+bMmQCAL33pS5g8eTJ+8pOf5I9x7bXX4thjj8Vxxx2HAw44AJWVlbjvvvuQSCTC/4KIiIiIiIiIiAwq6TOIpk6dii19iNpJJ52Ek046aYvHGD58OBYuXIiFCxd6TkeD1Z7JYWV6LWpTI/p8to2kxuexwqyh8HF2REREREREA2P6PYhIr8WtqzCneRm6HFAWAE0NdZg1ZWLRNT6PFWYNhY+zIyIiIiIiGriSvsSMoqk9k8v/EA4AXQ6Y27wc7ZlcUTU+jxVmDYWPsyMiIiIiIhocbhCRdyvTa/M/hHfb6Bza0h1F1fg8Vpg1FD7OjoiIiIiIaHC4QUTe1aZGoCwofCwRBKhJVRZV4/NYYdZQ+Dg7IiIiIiKiweEGEXlXnaxAU0MdEsGmn8YTQYD5DZMK3hBYUuPzWGHWUPg4OyIiIiIiosHhm1TTVjFrykQctNu2aEt3oCZV2esP4ZIan8cKs4bCx9kRERERERENHDeIaKupTlb0+wO4pMbnscKsofBxdkRERERERAPDl5gREREREREREcUcN4hoq2nP5LBkRXqLHyMuqfF5rDBrSEbjNUBERERERBQ3fIkZbRWLW1dhTvMydDmgLACaGuowa8rEomt8HivMGpLReA0QERERERHFEZ9BRN61Z3L5H8IBoMsBc5uXFzxjQ1Lj81hh1pCMxmuAiIiIiIgorrhBRN6tTK/N/xDebaNzaEt3FFXj81hh1pCMxmuAiIiIiIgorrhBRN7VpkagLCh8LBEEqElVFlXj81hh1pCMxmuAiIiIiIgorrhBRN5VJyvQ1FCHRLDpp/FEEGB+w6SCjxaX1Pg8Vpg1JKPxGiAiIiIiIoorvkk1bRWzpkzEQbtti7Z0B2pSlb3+EC6p8XmsMGtIRuM1QEREREREFEfcIKKtpjpZ0e8P4JIan8cKs4ZkNF4DREREREREccOXmBERERERERERxRw3iIiIiIiIiIiIYo4bRDQg7ZkclqxIoz2T2+o1YZ/PZ+64s3oNULh8XgNERERERDQwfA8iKtri1lWY07wMXQ4oC4CmhjrMmjJxq9SEfT6fuePO6jVA4fJ5DRARERER0cDxGURUlPZMLv9DGgB0OWBu8/KCf9H3VRP2+Xzmjjur1wCFy+c1QEREREREg8MNIirKyvTa/A9p3TY6h7Z0h/easM/nM3fcWb0GKFw+rwEiIiIiIhocbhBRUWpTI1AWFD6WCALUpCq914R9Pp+5487qNUDh8nkNEBERERHR4HCDiIpSnaxAU0MdEsGmn9YSQYD5DZNQnazwXhP2+Xzmjjur1wCFy+c1QEREREREg8M3qaaizZoyEQftti3a0h2oSVX2+kOar5qwz+czd9xZvQYoXD6vASIiIiIiGjhuENGAVCcr+v0BzVdN2OfzmTvurF4DFC6f1wAREREREQ0MX2JGRERERERERBRz3CCiHtozOSxZkd7iR0iHWaMxkzR3lEX5GiB/wr4GSB/OjYiIiMgGvsSMCixuXYU5zcvQ5YCyAGhqqMOsKRNLVqMxkzR3lEX5GiB/wr4GSB/OjYiIiMgOPoOI8tozufw38gDQ5YC5zcsL/tU3zBqNmaS5oyzK1wD5E/Y1QPpwbkRERES2cIOI8lam1+a/ke+20Tm0pTtKUqMxkzR3lEX5GiB/wr4GSB/OjYiIiMgWbhBRXm1qBMqCwscSQYCaVGVJajRmkuaOsihfA+RP2NcA6cO5EREREdnCDSLKq05WoKmhDolg03f0iSDA/IZJBR8rHWaNxkzS3FEW5WuA/An7GiB9ODciIiIiW/gm1VRg1pSJOGi3bdGW7kBNqrLXb+TDrNGYSZo7yqJ8DZA/YV8DpA/nRkRERGQHN4ioh+pkRb/fxIdZozGTNHeURfkaIH/CvgZIH86NiIiIyAa+xIyIiIiIiIiIKOa4QUQ9tGdyWLIivcWPIg6zRmMmaW6rNPaSswuX1WuAwsV7joiIiCg6+BIzKrC4dRXmNC9DlwPKAqCpoQ6zpkwsWY3GTNLcVmnsJWcXLqvXAIWL9xwRERFRtPAZRJTXnsnlv5EHgC4HzG1eXvCvvmHWaMwkzW2Vxl5yduGyeg1QuHjPEREREUUPN4gob2V6bf4b+W4bnUNbuqMkNRozSXNbpbGXnF24rF4DFC7ec0RERETRww0iyqtNjUBZUPhYIghQk6osSY3GTNLcVmnsJWcXLqvXAIWL9xwRERFR9HCDiPKqkxVoaqhDItj0HX0iCDC/YVLBxxOHWaMxkzS3VRp7ydmFy+o1QOHiPUdEREQUPYFzzvVfFm3ZbBbJZBKZTAZVVVWljtNDZ2cnWlpaUF9fj/Ly8q1+vvZMDm3pDtSkKvv8Rj7MGo2ZpLnDnp0vGnsZ5vmszs0nq9cAZxcu3nPE2dnF2dnEudnF2dkVhdlJ9zz4KWbUQ3Wyot9/4Q2zRmMmaW6rNPaSswuX1WuAwsV7joiIiCg6+BIzIiIiIiIiIqKY4wYREREREREREVHMcYOIemjP5LBkRRrtmZyKGo2ZpLm1sdrvUpwvyrTN1+c1QDIa50vh4uyIiIjow/geRFRgcesqzGlehi4HlAVAU0MdZk2ZWLIajZmkubWx2u9SnC/KtM3X5zVAMhrnS+Hi7IiIiKg3fAYR5bVncvlvBgGgywFzm5cX/MthmDUaM0lza2O136U4X5Rpm6/Pa4BkNM6XwsXZERERUV+4QUR5K9Nr898MdtvoHNrSHSWp0ZhJmlsbq/0uxfmiTNt8fV4DJKNxvhQuzo6IiIj6wg0iyqtNjUBZUPhYIghQk6osSY3GTNLc2ljtdynOF2Xa5uvzGiAZjfOlcHF2RERE1BduEFFedbICTQ11SASbvitMBAHmN0xCdbKiJDUaM0lza2O136U4X5Rpm6/Pa4BkNM6XwsXZERERUV8C55zrvyzastkskskkMpkMqqqqSh2nh87OTrS0tKC+vh7l5eVb/XztmRza0h2oSVX2+c1gmDUaM0lzhz27/ljtd9jn0zY337TN1+c1EPXZ+aJtvpxb+Dg74uxs4tzs4uzsisLspHse/BQz6qE6WdHvvxKGWaMxkzS3Nlb7XYrzRZm2+fq8BkhG43wpXJwdERERfRhfYkZEREREREREFHPcIIqR9kwOS1ak+/2YWkldmDUaM0lza2O136U4X5Rpm6/PayDuNN5PnFu4wr4GKFxcL4mIaGviS8xiYnHrKsxpXoYuB5QFQFNDHWZNmTigujBrNGaS5tbGar9Lcb4o0zZfn9dA3Gm8nzi3cIV9DVC4uF4SEdHWxmcQxUB7Jpf/RgEAuhwwt3l5j39VktSFWaMxkzS3Nlb7XYrzRZm2+fq8BuJO4/3EuYUr7GuAwsX1koiIwsANohhYmV6b/0ah20bn0JbuKLouzBqNmaS5tbHa71KcL8q0zdfnNRB3Gu8nzi1cYV8DFC6ul0REFAZuEMVAbWoEyoLCxxJBgJpUZdF1YdZozCTNrY3VfpfifFGmbb4+r4G403g/cW7hCvsaoHBxvSQiojBwgygGqpMVaGqoQyLY9B1DIggwv2FSj4+uldSFWaMxkzS3Nlb7XYrzRZm2+fq8BuJO4/3EuYUr7GuAwsX1koiIwhA451z/ZdGWzWaRTCaRyWRQVVVV6jg9dHZ2oqWlBfX19SgvLx/wcdozObSlO1CTqtziNwqSujBrNGaS5vY1O1+s9jvs82mbm2/a5uvzGoj67Pqj8X7i3MIV9jXA2YWL6yVxbnZxdnZFYXbSPQ9+ilmMVCcrRP+CJKkLs0ZjJmlubaz2uxTnizJt8/V5DcSdxvuJcwtX2NcAhYvrJRERbU18iRkRERERERERUcxxgyhG2jM5LFmR7vejTiV1YdZozCTNHaYo97sU57NIYy/DvgaizOr9FPe5+aTxGiB/uF5GG+85IrKALzGLicWtqzCneRm6HFAWAE0NdZg1ZeKA6sKs0ZhJmjtMUe53Kc5nkcZehn0NRJnV+ynuc/NJ4zVA/nC9jDbec0RkBZ9BFAPtmVz+PzgA0OWAuc3Le/zrhKQuzBqNmaS5wxTlfpfifBZp7GXY10CUWb2f4j43nzReA+QP18to4z1HRJZwgygGVqbX5v+D022jc2hLdxRdF2aNxkzS3GGKcr9LcT6LNPYy7GsgyqzeT3Gfm08arwHyh+tltPGeIyJLuEEUA7WpESgLCh9LBAFqUpVF14VZozGTNHeYotzvUpzPIo29DPsaiDKr91Pc5+aTxmuA/OF6GW2854jIEm4QxUB1sgJNDXVIBJv+y5MIAsxvmNTj408ldWHWaMwkzR2mKPe7FOezSGMvw74Goszq/RT3ufmk8Rogf7heRhvvOSKyJHDOuf7Loi2bzSKZTCKTyaCqqqrUcXro7OxES0sL6uvrUV5ePuDjtGdyaEt3oCZVucX/4EjqwqzRmEma29fsJKLc77DPF+bcfNLYy7CvAauzk7B6P8V9bj5pvAY4O3+4XkYb7zni7OyKwuykex78FLMYqU5WiP4lQlIXZo3GTNLcYYpyv0txPos09jLsayDKrN5PcZ+bTxqvAfKH62W08Z4jIgv4EjMiIiIiIiIiopjjBhERERERERERUcxxgyhG2jM5LFmRRnsmN+i6MGs0ZpLmDlOU+12K82ljtZdh57ZKYy/jfs+Fzeo1QDIa50v+cL2MNs4uuji3nvgeRDGxuHUV5jQvQ5cDygKgqaEOs6ZMHFBdmDUaM0lzhynK/S7F+bSx2suwc1ulsZdxv+fCZvUaIBmN8yV/uF5GG2cXXZxb7/gMohhoz+TyFz8AdDlgbvPyHjulkrowazRmkuYOU5T7XYrzaWO1l2HntkpjL+N+z4XN6jVAMhrnS/5wvYw2zi66OLe+cYMoBlam1+Yv/m4bnUNbuqPoujBrNGaS5g5TlPtdivNpY7WXYee2SmMv437Phc3qNUAyGudL/nC9jDbOLro4t75xgygGalMjUBYUPpYIAtSkKouuC7NGYyZp7jBFud+lOJ82VnsZdm6rNPYy7vdc2KxeAySjcb7kD9fLaOPsootz6xs3iGKgOlmBpoY6JIJNd0EiCDC/YRKqkxVF14VZozGTNHeYotzvUpxPG6u9DDu3VRp7Gfd7LmxWrwGS0Thf8ofrZbRxdtHFufUtcM65/suiLZvNIplMIpPJoKqqqtRxeujs7ERLSwvq6+tRXl4+4OO0Z3JoS3egJlW5xYtfUhdmjcZM0ty+ZicR5X6Hfb4w5yZltZdh59Y4OwmNvYz7PRc2q9cAZyejcb6cnT9cL6ONs4sujT/TbS3SPQ9+ilmMVCcrRLuikrowazRmkuYOU5T7XYrzaWO1l2HntkpjL+N+z4XN6jVAMhrnS/5wvYw2zi66OLeeSvoSsz/96U846qijMGHCBARBgHvuuafgz51zaGxsxIQJE1BRUYGpU6fihRdeKKhZv349/uu//gupVAojRozA0Ucfjddeey3Er4KIiIiIiIiIyLaSbhCtXbsWe++9N66//vpe/3zBggW45pprcP3116O1tRXjx4/H9OnTsWbNmnzNOeecg7vvvhu//vWv8cQTT+D999/HkUceiY0bN4b1ZZjRnslhyYp0vx/fJ6kLs0ZjJmnuMEW536U4nzZWexl2bqs09jLu95xPGvvN2fljdb7UP41rKvnD9TLaOLeBKelLzI444ggcccQRvf6Zcw7XXXcdvve976GhoQEAcNttt2HcuHFYtGgRzjjjDGQyGdx88824/fbbceihhwIA7rjjDuy44454+OGHcdhhh4X2tWi3uHUV5jQvQ5cDygKgqaEOs6ZMHFBdmDUaM0lzhynK/S7F+bSx2suwc1ulsZdxv+d80thvzs4fq/Ol/mlcU8kfrpfRxrkNnJo3qQ6CAHfffTeOPfZYAMC///1v7LLLLli6dCkmT56crzvmmGOwzTbb4LbbbsMf//hHTJs2DatXr8bo0aPzNXvvvTeOPfZYzJs3r9dzrV+/HuvXr8//PpvNYscdd0Q6nVb7JtUPPfQQpk+fPqA3xXoruw7Tr30cXZtNOhEEePDcgzCuanhRdWHWaMwkzd1tsLOTiHK/S3E+IJy5SVntZdi5u2manYTGXsb9nvNJY785O3+szrdbnGfXH41rajfObfC4Xkab1Z/ptrZsNotUKtXvm1Sr3SBasmQJDjjgALz++uuYMGFCvu7000/HK6+8ggceeACLFi3CySefXLDZAwAzZsxAbW0tbrrppl7P1djY2Ovm0aJFi1BZWenviyIiIiIiIiIiKqGOjg7Mnj3b/qeYBUFQ8HvnXI/HPqy/mjlz5uC8887L/777GUQzZszgM4gM/kuYtprN8RlEtjJ10/SvBFZ7yX8Rl9HYy7jfcz5p7Ddn54/V+XaL8+z6o3FN7ca5DR7Xy2iz+jPd1pbNZkV1JX2T6i0ZP348AODNN98sePztt9/GuHHj8jUffPAB3n333T5rejNs2DBUVVUV/AKA8vJytb8Gk2+HsaPQeMxe2NBVhvUbA2zoKsOlx9Rhh7Gjiq4Ls0ZjJmluX7PzNV+r/S7l7LSsCVZ7GXZujbMLc75WrwGrc9M437CvgajPLsrz5ez8zLYU8+XcbM6Xs9M3X40/04XxS0LtS8ycc5gwYQLOPfdcXHDBBQCADz74ANtttx2uuuqq/JtUb7vttrjjjjtw3HHHAQDa29uxww47oKWlRfwm1dlsFslkst+nW5VKZ2cnWlpaUF9fLx5sb9ozObSlO1CTqkR1smJQdWHWaMwkze1rdhJR7nfY5wtzblJWexl2bo2zk9DYy7jfcz5p67fPY0V9dhJW58vZ9U/jmsq5+cP1Mtqs/ky3tUj3PEr6ErP3338fL7/8cv73K1euxHPPPYcxY8Zg4sSJOOecczB//nzsuuuu2HXXXTF//nxUVlZi9uzZAIBkMolTTz0V559/PsaOHYsxY8bg29/+Nurq6vKfakb/pzpZscULv5i6MGs0ZpLmDlOU+12K82ljtZdh57ZKYy/jfs/5pLHfnJ0/VudL/dO4ppI/XC+jjXMbmJJuED399NM45JBD8r/vfl+gE088EbfeeisuuOAC5HI5nHnmmXj33Xex33774cEHH8SoUaPyf+faa6/FkCFDcNxxxyGXy2HatGm49dZbkUgkQv96iIiIiIiIiIgsKul7EE2dOhXOuR6/br31VgCbXnbW2NiI9vZ2rFu3Do8//jgmTZpUcIzhw4dj4cKFeOedd9DR0YH77rsPO+64Ywm+mtJqz+SwZEUa7ZncoGp8HivKmaS5fYl7v0txvjBFuZdh59bIai+jfM/5pK2XYV8DUWb5for77CQ03k+cmz8a50v+8J7betR/ihn1b3HrKsxpXoYuB5QFQFNDHWZNmVh0jc9jRTmTNLcvce93Kc4Xpij3MuzcGlntZZTvOZ+09TLsayDKLN9PcZ+dhMb7iXPzR+N8yR/ec1uX2k8xI5n2TC5/YQNAlwPmNi8v2AWV1Pg8VpQzSXP7Evd+l+J8YYpyL8POrZHVXkb5nvNJWy/DvgaizPL9FPfZSWi8nzg3fzTOl/zhPbf1cYPIuJXptfkLu9tG59CW7iiqxuexopxJmtuXuPe7FOcLU5R7GXZujaz2Msr3nE/aehn2NRBllu+nuM9OQuP9xLn5o3G+5A/vua2PG0TG1aZGoCwofCwRBKhJVRZV4/NYUc4kze1L3PtdivOFKcq9DDu3RlZ7GeV7zidtvQz7Gogyy/dT3GcnofF+4tz80Thf8of33NbHDSLjqpMVaGqoQyLYdIUnggDzGyYVfFyfpMbnsaKcSZrbl7j3uxTnC1OUexl2bo2s9jLK95xP2noZ9jUQZZbvp7jPTkLj/cS5+aNxvuQP77mtL3DOuf7Loi2bzSKZTCKTyaCqqqrUcXro7OxES0sL6uvrUV5e3mtNeyaHtnQHalKVfV7Ykhqfx4pyJmluyewk4t7vsM/na25SUe5l2LnDnp2E1V5G+Z7zSVsvw74GLM+uP1bvJ2ldlGcnofF+4tz80Thfzs4fqz/TlZJ0z4MbRIjGBhHpxNnZxLnZxdnZxLnZxdnZxdnZxLnZxdnZFYXZSfc8+BIzIiIiIiIiIqKY4wYREREREREREVHMcYMoItozOSxZkUZ7JjeoGp/HinImaW5f4t7vUpwvTFHuZdi5NbLayyjfcxJWexl2bqs09pLrpT8a+x33e84nq/ONO433E+fW05BSB6DBW9y6CnOal6HLAWUB0NRQh1lTJhZd4/NYUc4kze1L3PtdivOFKcq9DDu3RlZ7GeV7TsJqL8PObZXGXnK99Edjv+N+z/lkdb5xp/F+4tx6x2cQGdeeyeUvbADocsDc5uUFu6CSGp/HinImaW5f4t7vUpwvTFHuZdi5NbLayyjfcxJWexl2bqs09pLrpT8a+x33e84nq/ONO433E+fWN24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXP7Evd+l+J8YYpyL8POrZHVXkb5npOw2suwc1ulsZdcL/3R2O+433M+WZ1v3Gm8nzi3vnGDyLja1AiUBYWPJYIANanKomp8HivKmaS5fYl7v0txvjBFuZdh59bIai+jfM9JWO1l2Lmt0thLrpf+aOx33O85n6zON+403k+cW9+4QWRcdbICTQ11SASbrvBEEGB+wyRUJyuKqvF5rChnkub2Je79LsX5whTlXoadWyOrvYzyPSdhtZdh57ZKYy+5Xvqjsd9xv+d8sjrfuNN4P3FufQucc67/smjLZrNIJpPIZDKoqqoqdZweOjs70dLSgvr6epSXl/da057JoS3dgZpUZZ8XtqTG57GinEmaWzI7ibj3O+zz+ZqbVJR7GXbusGcnYbWXUb7nJKz2MuzcGmcnobGXXC/90djvuN9zPlmdb9xnp/F+CvtnulKS7nlwgwjR2CAinTg7mzg3uzg7mzg3uzg7uzg7mzg3uzg7u6IwO+meB19iRkREREREREQUc9wgioj2TA5LVqS3+NF8khqfx4pyJmluX+Le71Kcz5e49zLs3GHT1ier14BGVnsZdm6NrPYy6uulL1b7HeV7zqcozzfKNPabcxuYIaUOQIO3uHUV5jQvQ5cDygKgqaEOs6ZMLLrG57GinEma25e497sU5/Ml7r0MO3fYtPXJ6jWgkdVehp1bI6u9jPp66YvVfkf5nvMpyvONMo395twGjs8gMq49k8tf2ADQ5YC5zcsLdkElNT6PFeVM0ty+xL3fpTifL3HvZdi5w6atT1avAY2s9jLs3BpZ7WXU10tfrPY7yvecT1Geb5Rp7DfnNjjcIDJuZXpt/sLuttE5tKU7iqrxeawoZ5Lm9iXu/S7F+XyJey/Dzh02bX2yeg1oZLWXYefWyGovo75e+mK131G+53yK8nyjTGO/ObfB4QaRcbWpESgLCh9LBAFqUpVF1fg8VpQzSXP7Evd+l+J8vsS9l2HnDpu2Plm9BjSy2suwc2tktZdRXy99sdrvKN9zPkV5vlGmsd+c2+Bwg8i46mQFmhrqkAg2XeGJIMD8hkmoTlYUVePzWFHOJM3tS9z7XYrz+RL3XoadO2za+mT1GtDIai/Dzq2R1V5Gfb30xWq/o3zP+RTl+UaZxn5zboMTOOdc/2XRls1mkUwmkclkUFVVVeo4PXR2dqKlpQX19fUoLy/vtaY9k0NbugM1qco+L2xJjc9jRTmTNLdkdhJx73fY5/M1t7Bza+xl2Ll9zk5CW5+sXgNhz03Cai/Dzm11dhp7GfX10her/Y7yPedTlOcb5dlp7LfGn+lKSbrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxgygi2jM5LFmR3uJH80lqfB4rypmkuX2Je79LcT5f4t7LsHOHTVufrF4DYYtyL8POrZHVXkZ9vZTQ1kuN14BVGnvJ9VLGar/jPreBGlLqADR4i1tXYU7zMnQ5oCwAmhrqMGvKxKJrfB4rypmkuX2Je79LcT5f4t7LsHOHTVufrF4DYYtyL8POrZHVXkZ9vZTQ1kuN14BVGnvJ9VLGar/jPrfB4DOIjGvP5PIXNgB0OWBu8/KCXVBJjc9jRTmTNLcvce93Kc7nS9x7GXbusGnrk9VrIGxR7mXYuTWy2suor5cS2nqp8RqwSmMvuV7KWO133Oc2WNwgMm5lem3+wu620Tm0pTuKqvF5rChnkub2Je79LsX5fIl7L8POHTZtfbJ6DYQtyr0MO7dGVnsZ9fVSQlsvNV4DVmnsJddLGav9jvvcBosbRMbVpkagLCh8LBEEqElVFlXj81hRziTN7Uvc+12K8/kS916GnTts2vpk9RoIW5R7GXZujaz2MurrpYS2Xmq8BqzS2EuulzJW+x33uQ0WN4iMq05WoKmhDolg0xWeCALMb5iE6mRFUTU+jxXlTNLcvsS936U4ny9x72XYucOmrU9Wr4GwRbmXYefWyGovo75eSmjrpcZrwCqNveR6KWO133Gf22AFzjnXf1m0ZbNZJJNJZDIZVFVVlTpOD52dnWhpaUF9fT3Ky8t7rWnP5NCW7kBNqrLPC1tS4/NYUc4kzS2ZnUTc+x32+XzNLezcGnsZdm6fs5PQ1ier14DVufk8ltVrIOzZSVjtZdTXSwltvdR4DWicm4TGXnK9lLHab40/05WSdM+DG0SIxgYR6cTZ2cS52cXZ2cS52cXZ2cXZ2cS52cXZ2RWF2Un3PPgSMyIiIiIiIiKimOMGERERERERERFRzHGDKCLaMzksWZFGeyY3qBqfx4pyJmluCY25457Jp7j3MuzcvrCXdu85iSj3MuzcYYtyL62ulz5p66XGa0Ajq72M+nrpi9V+x31uAzWk1AFo8Ba3rsKc5mXockBZADQ11GHWlIlF1/g8VpQzSXNLaMwd90w+xb2XYef2hb20e89JRLmXYecOW5R7aXW99ElbLzVeAxpZ7WXU10tfrPY77nMbDD6DyLj2TC5/YQNAlwPmNi8v2AWV1Pg8VpQzSXNLaMwd90w+xb2XYef2hb20e89JRLmXYecOW5R7aXW99ElbLzVeAxpZ7WXU10tfrPY77nMbLG4QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90w+xb2XYef2hb20e89JRLmXYecOW5R7aXW99ElbLzVeAxpZ7WXU10tfrPY77nMbLG4QGVebGoGyoPCxRBCgJlVZVI3PY0U5kzS3hMbccc/kU9x7GXZuX9hLu/ecRJR7GXbusEW5l1bXS5+09VLjNaCR1V5Gfb30xWq/4z63weIGkXHVyQo0NdQhEWy6whNBgPkNk1CdrCiqxuexopxJmltCY+64Z/Ip7r0MO7cv7KXde04iyr0MO3fYotxLq+ulT9p6qfEa0MhqL6O+Xvpitd9xn9tgBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wzyeZm1Tcexl2bl+zYy/t3nMSUe5l2Lmtzk5jL62ulz5p66XGayDKc/N5LI2ZNM5Owmq/w/6ZTjvpngc3iBCNDSLSibOziXOzi7OziXOzi7Ozi7OziXOzi7OzKwqzk+558CVmREREREREREQxxw2iiGjP5LBkRXqLH80nqfF5rChnkuaW0Jg77pl8insvw87tC3vJe85qL8POHbYo99LqeilhtZcac2tktZdRXy8lotzvKM9taxpS6gA0eItbV2FO8zJ0OaAsAJoa6jBrysSia3weK8qZpLklNOaOeyaf4t7LsHP7wl7ynrPay7Bzhy3KvbS6XkpY7aXG3BpZ7WXU10uJKPc7ynPb2vgMIuPaM7n8hQ0AXQ6Y27y8YBdUUuPzWFHOJM0toTF33DP5FPdehp3bF/aS95zVXoadO2xR7qXV9VLCai815tbIai+jvl5KRLnfUZ5bGLhBZNzK9Nr8hd1to3NoS3cUVePzWFHOJM0toTF33DP5FPdehp3bF/aS95zVXoadO2xR7qXV9VLCai815tbIai+jvl5KRLnfUZ5bGAa0QZTL5dDR8X/Ne+WVV3DdddfhwQcf9BaMZGpTI1AWFD6WCALUpCqLqvF5rChnkuaW0Jg77pl8insvw87tC3vJe85qL8POHbYo99LqeilhtZcac2tktZdRXy8lotzvKM8tDAPaIDrmmGPwy1/+EgDw3nvvYb/99sPVV1+NY445BjfeeKPXgLRl1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGfyKe69DDu3L+wl7zmrvQw7d9ii3Eur66WE1V5qzK2R1V5Gfb2UiHK/ozy3MATOOdd/WaFUKoXHH38ce+65J37+859j4cKFePbZZ/G73/0Ol1xyCV588cWtkXWryWazSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532GfTzI3qbj3MuzcvmbHXvKes9rLsHP7nJ1ElHtpdb2UsNpLjbnDvuckrPYy6uulRJT7HfbPdNpJ9zwGtEFUWVmJf/7zn5g4cSKOO+447Lnnnrj00kvx6quvYvfddy94+ZkFUdggIp04O5s4N7s4O5s4N7s4O7s4O5s4N7s4O7uiMDvpnseAXmL2kY98BPfccw9effVVPPDAA5gxYwYA4O2331a5wUJERERERERERH0b0AbRJZdcgm9/+9uoqanBfvvth09/+tMAgAcffBCTJ0/2GpBk2jM5LFmR3uJH80lqfB4rypmkuSU05o57JgmNua1m8pnbF/ZS3z0nFfdehp3bJ219snoNFFMXFqu91Jg7bFHupeX1UkJbLy1fA3EyZCB/6Qtf+AIOPPBAtLe3Y++9984/Pm3aNHzuc5/zFo5kFreuwpzmZehyQFkANDXUYdaUiUXX+DxWlDNJc0tozB33TBIac1vN5DO3L+ylvntOKu69DDu3T9r6ZPUaKKYuLFZ7qTF32KLcS8vrpYS2Xlq+BuJmQM8gAoDx48dj8uTJKCv7v0Psu++++OhHP+olGMm0Z3L5CxsAuhwwt3l5wS6opMbnsaKcSZpbQmPuuGeS0JjbaiafuX1hL/Xdc1Jx72XYuX3S1ier10AxdWGx2kuNucMW5V5aXi8ltPXS8jUQR+INooaGBvEvCs/K9Nr8hd1to3NoS3cUVePzWFHOJM0toTF33DNJaMxtNZPP3L6wl/ruOam49zLs3D5p65PVa6CYurBY7aXG3GGLci8tr5cS2npp+RqII/EGUTKZzP+qqqrCI488gqeffjr/58888wweeeQRJJPJrRKUelebGoGyoPCxRBCgJlVZVI3PY0U5kzS3hMbccc8koTG31Uw+c/vCXuq756Ti3suwc/ukrU9Wr4Fi6sJitZcac4ctyr20vF5KaOul5WsgjsQbRLfcckv+17hx43Dcccdh5cqVaG5uRnNzM/7973/jS1/6ElKp1NbMSx9SnaxAU0MdEsGmKzwRBJjfMAnVyYqianweK8qZpLklNOaOeyYJjbmtZvKZ2xf2Ut89JxX3Xoad2ydtfbJ6DRRTFxarvdSYO2xR7qXl9VJCWy8tXwNxFDjnXP9lhbbddls88cQT2H333Qsef+mll7D//vvjnXfe8RYwDNlsFslkEplMBlVVVaWO00NnZydaWlpQX1+P8vLyXmvaMzm0pTtQk6rs88KW1Pg8VpQzSXOHObso9zvs8/maW9i5rWbymVsyOwn2Ut89JxX3Xoad2+rsNPbS6nopYbWXGnOHOTdpJqu9tLxeSmjrpeVrIOzZbQ3SPY8BbRCNHj0at9xyC4499tiCx++55x6cfPLJePfdd4sOXEpR2CAinTg7mzg3uzg7mzg3uzg7uzg7mzg3uzg7u6IwO+mex4A+5v7kk0/GKaecgpdffhmf+tSnAABPPfUUrrzySpx88skDS0xERERERERERCUxoA2i//7v/8b48eNx7bXXor29HQBQXV2NCy64AOeff77XgEREREREREREtHWJ36S64C+VleGCCy7A66+/jvfeew/vvfceXn/9dVxwwQVIJBK+M5JAeyaHJSvSaM/kBlXj81hRziTNLaExd9wzSWjMbTWTz9y+sJf67jmpuPcy7Nw+aeuT1WugmDofotxLjbnDFuVeWl4vJbT10vI1ECcDegbR5jS+Z0/cLG5dhTnNy9DlgLIAaGqow6wpE4uu8XmsKGeS5pbQmDvumSQ05raayWduX9hLffecVNx7GXZun7T1yeo1UEydD1HupcbcYYtyLy2vlxLaemn5GoibAT2D6K233sJXv/pVTJgwAUOGDEEikSj4ReFpz+TyFzYAdDlgbvPygl1QSY3PY0U5kzS3hMbccc8koTG31Uw+c/vCXuq756Ti3suwc/ukrU9Wr4Fi6nyIci815g5blHtpeb2U0NZLy9dAHA1og+ikk07C0qVLcfHFF+Ouu+5Cc3NzwS8Kz8r02vyF3W2jc2hLdxRV4/NYUc4kzS2hMXfcM0lozG01k8/cvrCX+u45qbj3MuzcPmnrk9VroJg6H6LcS425wxblXlpeLyW09dLyNRBHA3qJ2RNPPIE///nP+PjHP+45DhWrNjUCZQEKLvBEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5z+8Je6rvnpOLey7Bz+6StT1avgWLqfIhyLzXmDluUe2l5vZTQ1kvL10AcDegZRDvuuCOcc/0X0lZXnaxAU0MdEkEAYNOFPb9hEqqTFUXV+DxWlDNJc0tozB33TBIac1vN5DO3L+ylvntOKu69DDu3T9r6ZPUaKKbOhyj3UmPusEW5l5bXSwltvbR8DcRR4Aaw0/Pggw/i6quvxk033YSampqtECtc2WwWyWQSmUxG5Ztud3Z2oqWlBfX19SgvL++1pj2TQ1u6AzWpyj4vbEmNz2NFOZM0d5izi3K/wz6fr7mFndtqJp+5JbOTYC/13XNSce9l2Lmtzk5jL6O8XlrtpcbcPu85iSj30vJ6KaGtl5avgbBntzVI9zwGtEE0evRodHR0YMOGDaisrOzRpNWrVxefuISisEFEOnF2NnFudnF2NnFudnF2dnF2NnFudnF2dkVhdtI9jwG9B9F111030FxERERERERERKTMgDaITjzxRN85aJDaMzmsTK9FbWrEFp9C11+Nz2NFOZM0t4TG3HHPJKExt9VMPnNLsJc6M/kS916GndsnbX2yeg0UU+dDlHupMbdPce+l5fVSQlsvLV8DcTKgDSIA2LhxI+655x68+OKLCIIAH/vYx3D00UcjkUj4zEcCi1tXYU7zMnQ5oCwAmhrqMGvKxKJrfB4rypmkuSU05o57JgmNua1m8plbgr3UmcmXuPcy7Nw+aeuT1WugmDofotxLjbl9insvLa+XEtp6afkaiJsBfYrZyy+/jD322AMnnHACmpubcdddd+ErX/kK9txzT6xYscJ3RtqC9kwuf2EDmz6qb27zcrRnckXV+DxWlDNJc0tozB33TBIac1vN5DO3BHupM5Mvce9l2Ll90tYnq9dAMXU+RLmXGnP7FPdeWl4vJbT10vI1EEcD2iA6++yzscsuu+DVV1/F0qVL8eyzz2LVqlWora3F2Wef7TsjbcHK9Nr8hd1to3NoS3cUVePzWFHOJM0toTF33DNJaMxtNZPP3BLspc5MvsS9l2Hn9klbn6xeA8XU+RDlXmrM7VPce2l5vZTQ1kvL10AcDWiD6PHHH8eCBQswZsyY/GNjx47FlVdeiccff9xbOOpfbWoEyoLCxxJBgJpUZVE1Po8V5UzS3BIac8c9k4TG3FYz+cwtwV7qzORL3HsZdm6ftPXJ6jVQTJ0PUe6lxtw+xb2XltdLCW29tHwNxNGANoiGDRuGNWvW9Hj8/fffx9ChQwcdiuSqkxVoaqhDIth0hSeCAPMbJhW8yZakxuexopxJmltCY+64Z5LQmNtqJp+5JdhLnZl8iXsvw87tk7Y+Wb0GiqnzIcq91Jjbp7j30vJ6KaGtl5avgTgKnHOu/7JCJ5xwApYuXYqbb74Z++67LwDgr3/9K772ta9hn332wa233uo751aVzWaRTCaRyWRQVVVV6jg9dHZ2oqWlBfX19SgvL++1pj2TQ1u6AzWpyj4vbEmNz2NFOZM0d5izi3K/wz6fr7mFndtqJp+5475eWs0tmZtU3HsZdm6rs9PYS43rpUSUe6kxd5Tvuahn8jk7CW29tHwNhD27rUG65zGgDaL33nsPJ554Iu677758gzZs2ICjjz4at956K5LJ5MCTl0AUNohIJ87OJs7NLs7OJs7NLs7OLs7OJs7NLs7OrijMTrrnMaCXmG2zzTa499578dJLL+Guu+7Cb3/7W7z00ku4++67vW8OrVmzBueccw522mknVFRUYP/990dra2v+z51zaGxsxIQJE1BRUYGpU6fihRde8JqBiIiIiIiIiCjKBrRB1G3XXXfFUUcdhaOPPhof+chHfGUqcNppp+Ghhx7C7bffjmXLlmHGjBk49NBD8frrrwMAFixYgGuuuQbXX389WltbMX78eEyfPr3X90iKsvZMDktWpLf40XySGp/HinImaW4JjbnjnklCY26rmXzmlmAvdWaS0JhbW6awc/ukrU9Wr4Fi6nyIci815vYp7r20ul5a7aXV3HEzZCB/yTmHu+66C48++ijefvttdHV1Ffx5c3Ozl3C5XA6/+93vcO+99+Kggw4CADQ2NuKee+7BjTfeiO9///u47rrr8L3vfQ8NDQ0AgNtuuw3jxo3DokWLcMYZZ3jJod3i1lWY07wMXQ4oC4CmhjrMmjKx6Bqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHP7pK1PVq+BYup8iHIvNeb2Ke69tLpeWu2l1dxxNKD3IDr77LPx05/+FIcccgjGjRuH4P9/9+9ut9xyi5dwa9asQVVVFR5++GFMmzYt//inP/1pDBs2DL/4xS+wyy67YOnSpZg8eXL+z4855hhss802uO2223o97vr167F+/fr877PZLHbccUek02m170H00EMPYfr06T1e8/hWdh2mX/s4ujabYiII8OC5B2Fc1XBxjc9jRTmTNHe3MGYX5X6X4nzA4OfGXoafu1tc10urubttaW5ac2vLFHbubv3NTkJbn6xeA8XUAYOfXZR7qTF3tyjec1HP1C2Me85nbqv9DvtnOiuy2SxSqdTWeZPqMWPG4I477kB9ff2gQkrsv//+GDp0KBYtWoRx48bhzjvvxAknnIBdd90Vt9xyCw444AC8/vrrmDBhQv7vnH766XjllVfwwAMP9HrMxsZGzJs3r8fjixYtQmVl5Vb7WoiIiIiIiIiIwtTR0YHZs2f3u0E0oJeYJZNJ7LzzzgMOV4zbb78dp5xyCrbffnskEgl84hOfwOzZs7F06dJ8zYefweSc6/HY5ubMmYPzzjsv//vuZxDNmDGDzyBStmurLROfQRTtTN34DCI9NcXUAfFdL63m7sZnENnL3S2Kz2aweg0UUwfwGUTWcneL4j0X9Uzd+AwiW7k3F5VnEEkM6E2qu5+Bk8tt/Tdz2mWXXfD444/j/fffx6uvvoq//e1v6OzsRG1tLcaPHw8AePPNNwv+zttvv41x48b1ecxhw4ahqqqq4BcAlJeXq/3VV74dxo5C4zF7YUNXGdZvDLChqwyXHlOHHcaOKqrG57GinEmaO8zZRbnfpZzdYObGXoafO+7rpdXckrlpza0tU9i5pbOT/NLWJ6vXQNizi3IvNeaO8j0X9Uxh3nMae2k1t+/7TsMviQG9xKyjowMNDQ34y1/+gpqamh4n2/zZPb69++67qK2txYIFC/C1r30NEyZMwLnnnosLLrgAAPDBBx9gu+22w1VXXSV+k+psNotkMtnv061KpbOzEy0tLaivr+9zsO2ZHNrSHahJVaI6WTHgGp/HinImae4wZxflfod9Pl9zCzu31Uw+c8d9vbSaWzI3jbk1Zgo7t3R2Etr6ZPUakNb5ml2Ue6kxd5TvuahnCvOe85nbar/D/plOO+mex4A2iI477jg8+uij+MIXvtDrm1RfeumlxSfuwwMPPADnHHbffXe8/PLL+M53voNhw4bhiSeeQHl5Oa666io0NTXhlltuwa677or58+fjsccew0svvYRRo0aJzhGFDSLSibOziXOzi7OziXOzi7Ozi7OziXOzi7OzKwqzk+55DOg9iH7/+9/jgQcewIEHHjjggFKZTAZz5szBa6+9hjFjxuDzn/88rrjiivxgLrjgAuRyOZx55pl49913sd9+++HBBx8Ubw4REREREREREcXdgDaIdtxxx9CeaXPcccfhuOOO6/PPgyBAY2MjGhsbQ8lDRERERERERBQ1A3qT6quvvhoXXHAB2traPMehgWrP5LBkRRrtmb7fOFxS4/NYUc4kzS2hMXfcM0lozG01k8/cEuylzkwSGnNryxR2bgn2UmcmX6LcS425fYp7LzWulxJWe2k1d9wM6BlEX/nKV9DR0YFddtkFlZWVPV6Ht3r1ai/hSGZx6yrMaV6GLgeUBUBTQx1mTZlYdI3PY0U5kzS3hMbccc8koTG31Uw+c0uwlzozSWjMrS1T2Lkl2EudmXyJci815vYp7r3UuF5KWO2l1dxxNKBnEF133XX46U9/il/84he4/vrrce211xb8ovC0Z3L5CxsAuhwwt3l5wS6opMbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTL5EuZcac/sU915qXC8lrPbSau64GtAG0YknnrjFXxSelem1+Qu720bn0JbuKKrG57GinEmaW0Jj7rhnktCY22omn7kl2EudmSQ05taWKezcEuylzky+RLmXGnP7FPdealwvJaz20mruuBrQBtHmcrkcstlswS8KT21qBMqCwscSQYCaVGVRNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3Vm8iXKvdSY26e491LjeilhtZdWc8fVgDaI1q5di29+85vYbrvtMHLkSIwePbrgF4WnOlmBpoY6JIJNV3giCDC/YRKqkxVF1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZyZco91Jjbp/i3kuN66WE1V5azR1XgXPO9V9W6KyzzsKjjz6Kyy67DCeccAJuuOEGvP7667jppptw5ZVX4vjjj98aWbeabDaLZDKJTCaDqqqqUsfpobOzEy0tLaivr+/xhuDd2jM5tKU7UJOq7PPCltT4PFaUM0lzhzm7KPc77PP5mlvYua1m8pk77uul1dySuWnMrTFT2LmjvF5azS2tk953/YlyLzXm9jW3sHNr7KXG9VLCai+t5gb83nelIt3zGNAG0cSJE/HLX/4SU6dORVVVFZYuXYqPfOQjuP3223HnnXeipaVlUOHDFoUNItKJs7OJc7OLs7OJc7OLs7OLs7OJc7OLs7MrCrOT7nkM6CVmq1evRm1tLQCgqqoq/7H2Bx54IP70pz8N5JBERERERERERFQiA9og2nnnndHW1gYA+NjHPobf/OY3AID77rsP22yzja9sVIT2TA5LVqS3+NF8khqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ4291LheSljtpdXccTNkIH/p5JNPxvPPP4+DDz4Yc+bMwcyZM7Fw4UJs2LAB11xzje+M1I/Fraswp3kZuhxQFgBNDXWYNWVi0TU+jxXlTNLcEhpzxz2ThMbcVjP5zC3BXurMJKExt7ZMYeeWYC91ZpLQmFtbTSnOJ6GtTxp7qXG9lLDaS6u542hAzyA699xzcfbZZwMADjnkEPzzn//EnXfeiaVLl+Jb3/qW14C0Ze2ZXP7CBoAuB8xtXl6wCyqp8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2EuN66WE1V5azR1XA9og+rCJEyeioaEBe++9t4/DURFWptfmL+xuG51DW7qjqBqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ4291LheSljtpdXccSV+idmPfvQjnH766Rg+fDh+9KMfbbG2+9lFtPXVpkagLEDBBZ4IAtSkKouq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2EuN66WE1V5azR1X4mcQXXvttVi7dm3+//f167rrrttaWakX1ckKNDXUIREEADZd2PMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5qXC8lrPbSau64Cpxzrv+yaMtms0gmk8hkMqiqqip1nB46OzvR0tKC+vp6lJeX91rTnsmhLd2BmlRlnxe2pMbnsaKcSZo7zNlFud9hn8/X3MLObTWTz9xxXy+t5pbMTWNujZnCzh3l9dJqbmmdtu9Rwj6f1dxW10uNvdS4XkpY7aXV3IC/2ZWSdM9DvEF03nnniU4cBAGuvvpqWUolorBBRDpxdjZxbnZxdjZxbnZxdnZxdjZxbnZxdnZFYXbSPQ/xexA9++yzBb9/5plnsHHjRuy+++4AgH/9619IJBLYZ599BhiZiIiIiIiIiIhKQfweRI8++mj+11FHHYWpU6fitddew9KlS7F06VK8+uqrOOSQQzBz5sytmZf60J7JYcmK9BY/mk9S4/NYUc4kzS2hMXfcM0lozG01k8/cEuylzkwSGnNryxR2bgn2UmcmCY25tdWU4nwS2vqksZdW10urvbSaO27EzyDa3NVXX40HH3wQo0ePzj82evRoXH755ZgxYwbOP/98bwGpf4tbV2FO8zJ0OaAsAJoa6jBrysSia3weK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWc8eR+BlEm8tms3jrrbd6PP72229jzZo1gw5Fcu2ZXP7CBjZ9VN/c5uUFu6CSGp/HinImaW4JjbnjnklCY26rmXzmlmAvdWaS0JhbW6awc0uwlzozSWjMra2mFOeT0NYnjb20ul5a7aXV3HE1oA2iz33uczj55JNx11134bXXXsNrr72Gu+66C6eeeioaGhp8Z6QtWJlem7+wu210Dm3pjqJqfB4rypmkuSU05o57JgmNua1m8plbgr3UmUlCY25tmcLOLcFe6swkoTG3tppSnE9CW5809tLqemm1l1Zzx9WANoh+8pOfYObMmfjKV76CnXbaCTvttBOOP/54HHHEEfjxj3/sOyNtQW1qBMqCwscSQYCaVGVRNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNqQBtElZWV+PGPf4x33nkHzz77LJYuXYrVq1fjxz/+MUaMGOE7I21BdbICTQ11SASbrvBEEGB+wyRUJyuKqvF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1XgXPO9V8WbdlsFslkEplMBlVVVaWO00NnZydaWlpQX1+P8vLyXmvaMzm0pTtQk6rs88KW1Pg8VpQzSXOHObso9zvs8/maW9i5rWbymTvu66XV3JK5acytMVPYuaO8XlrNLa3T9j1K2Oezmtvqeqmxl1bXS6u9tJobkN93mkn3PLhBhGhsEJFOnJ1NnJtdnJ1NnJtdnJ1dnJ1NnJtdnJ1dUZiddM9jQC8xIyIiIiIiIiKi6OAGERERERERERFRzHGDKCLaMzksWZFGeyY3qBqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dxxM6TUAWjwFreuwpzmZehyQFkANDXUYdaUiUXX+DxWlDNJc0tozB33TBIac1vN5DO3BHupM5OExtzaMoWdW4K91JlJQmNubTWlOJ+Etj5p7KXV9dJqL63mjiM+g8i49kwuf2EDQJcD5jYvL9gFldT4PFaUM0lzS2jMHfdMEhpzW83kM7cEe6kzk4TG3NoyhZ1bgr3UmUlCY25tNaU4n4S2PmnspdX10movreaOK24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZSUJjbm01pTifhLY+aeyl1fXSai+t5o4rbhAZV5sagbKg8LFEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rjiBpFx1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdcBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpuQH7faSbd8+AGEaKxQUQ6cXY2cW52cXY2cW52cXZ2cXY2cW52cXZ2RWF20j0PvsSMiIiIiIiIiCjmuEEUEe2ZHJasSG/xo/kkNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNmSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs0dR3wGkXHtmVz+wgaALgfMbV5esAsqqfF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1X3CAybmV6bf7C7rbRObSlO4qq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2Eur66XVXlrNHVfcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcccUNIuOqkxVoaqhDIth0hSeCAPMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rgKnHOu/7Joy2azSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532Gfz9fcws5tNZPP3HFfL63mlsxNY26NmcLOHeX10mpuaZ2271HCPp/V3FbXS429tLpeWu2l1dyA/L7TTLrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxgygi2jM5LFmR3uJH80lqfB4rypmkuSU05o57JgmNua1m8plbgr3UmUlCY25tmcLOLcFe6swkoTG3tppSnE9CW5809tLqemm1l1Zzx82QUgegwVvcugpzmpehywFlAdDUUIdZUyYWXePzWFHOJM0toTF33DNJaMxtNZPP3BLspc5MEhpza8sUdm4J9lJnJgmNubXVlOJ8Etr6pLGXVtdLq720mjuO+Awi49ozufyFDQBdDpjbvLxgF1RS4/NYUc4kzS2hMXfcM0lozG01k8/cEuylzkwSGnNryxR2bgn2UmcmCY25tdWU4nwS2vqksZdW10urvbSaO664QWTcyvTa/IXdbaNzaEt3FFXj81hRziTNLaExd9wzSWjMbTWTz9wS7KXOTBIac2vLFHZuCfZSZyYJjbm11ZTifBLa+qSxl1bXS6u9tJo7rrhBZFxtagTKgsLHEkGAmlRlUTU+jxXlTNLcEhpzxz2ThMbcVjP5zC3BXurMJKExt7ZMYeeWYC91ZpLQmFtbTSnOJ6GtTxp7aXW9tNpLq7njihtExlUnK9DUUIdEsOkKTwQB5jdMQnWyoqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXccRU451z/ZdGWzWaRTCaRyWRQVVVV6jg9dHZ2oqWlBfX19SgvL++1pj2TQ1u6AzWpyj4vbEmNz2NFOZM0d5izi3K/wz6fr7mFndtqJp+5475eWs0tmZvG3BozhZ07yuul1dzSOm3fo4R9Pqu5ra6XGntpdb202kuruQH5faeZdM+DG0SIxgYR6cTZ2cS52cXZ2cS52cXZ2cXZ2cS52cXZ2RWF2Un3PPgSMyIiIiIiIiKimOMGERERERERERFRzHGDKCLaMzksWZFGeyY3qBqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dxxM6TUAWjwFreuwpzmZehyQFkANDXUYdaUiUXX+DxWlDNJc0tozB33TBIac1vN5DO3BHupM5OExtzaMoWdW4K91JlJQmNubTWlOJ+Etj5p7KXV9dJqL63mjiM+g8i49kwuf2EDQJcD5jYvL9gFldT4PFaUM0lzS2jMHfdMEhpzW83kM7cEe6kzk4TG3NoyhZ1bgr3UmUlCY25tNaU4n4S2PmnspdX10movreaOK24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZSUJjbm01pTifhLY+aeyl1fXSai+t5o4rbhAZV5sagbKg8LFEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rjiBpFx1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdcBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpuQH7faSbd8+AGEaKxQUQ6cXY2cW52cXY2cW52cXZ2cXY2cW52cXZ2RWF20j0PvsSMiIiIiIiIiCjmuEEUEe2ZHJasSG/xo/kkNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNmSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs0dR3wGkXHtmVz+wgaALgfMbV5esAsqqfF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1X3CAybmV6bf7C7rbRObSlO4qq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2Eur66XVXlrNHVfcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcccUNIuOqkxVoaqhDIth0hSeCAPMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rgKnHOu/7Joy2azSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532Gfz9fcws5tNZPP3HFfL63mlsxNY26NmcLOHeX10mpuaZ2271HCPp/V3FbXS429tLpeWu2l1dyA/L7TTLrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxgygi2jM5LFmR3uJH80lqfB4rypmkuSU05o57JgmNua1m8plbgr3UmUlCY25tmcLOLcFe6swkoTG3tppSnE9CW5809tLqemm1l1Zzx82QUgegwVvcugpzmpehywFlAdDUUIdZUyYWXePzWFHOJM0toTF33DNJaMxtNZPP3BLspc5MEhpza8sUdm4J9lJnJgmNubXVlOJ8Etr6pLGXVtdLq720mjuO+Awi49ozufyFDQBdDpjbvLxgF1RS4/NYUc4kzS2hMXfcM0lozG01k8/cEuylzkwSGnNryxR2bgn2UmcmCY25tdWU4nwS2vqksZdW10urvbSaO664QWTcyvTa/IXdbaNzaEt3FFXj81hRziTNLaExd9wzSWjMbTWTz9wS7KXOTBIac2vLFHZuCfZSZyYJjbm11ZTifBLa+qSxl1bXS6u9tJo7rrhBZFxtagTKgsLHEkGAmlRlUTU+jxXlTNLcEhpzxz2ThMbcVjP5zC3BXurMJKExt7ZMYeeWYC91ZpLQmFtbTSnOJ6GtTxp7aXW9tNpLq7njihtExlUnK9DUUIdEsOkKTwQB5jdMQnWyoqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXccRU451z/ZdGWzWaRTCaRyWRQVVVV6jg9dHZ2oqWlBfX19SgvL++1pj2TQ1u6AzWpyj4vbEmNz2NFOZM0d5izi3K/wz6fr7mFndtqJp+5475eWs0tmZvG3BozhZ07yuul1dzSOm3fo4R9Pqu5ra6XGntpdb202kuruQH5faeZdM+DG0SIxgYR6cTZ2cS52cXZ2cS52cXZ2cXZ2cS52cXZ2RWF2Un3PPgSMyIiIiIiIiKimFO9QbRhwwZcdNFFqK2tRUVFBXbeeWdcdtll6Orqytc459DY2IgJEyagoqICU6dOxQsvvFDC1EREREREREREtqjeILrqqqvwk5/8BNdffz1efPFFLFiwAD/4wQ+wcOHCfM2CBQtwzTXX4Prrr0drayvGjx+P6dOnY82aNSVMHr72TA5LVqTRnskNqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXfcDCl1gC158sknccwxx2DmzJkAgJqaGtx55514+umnAWx69tB1112H733ve2hoaAAA3HbbbRg3bhwWLVqEM844o2TZw7S4dRXmNC9DlwPKAqCpoQ6zpkwsusbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXccqX6T6iuvvBI/+clP8OCDD2K33XbD888/jxkzZuC6667Dl7/8Zfz73//GLrvsgqVLl2Ly5Mn5v3fMMcdgm222wW233dbrcdevX4/169fnf5/NZrHjjjsinU6rfZPqhx56CNOnT+/xplhvZddh+rWPo2uzKSaCAA+eexDGVQ0X1/g8VpQzSXN3C2N2Ue53Kc4HDH5u7GX4ubvFdb20mrvbluamNbe2TGHn7hbF9dJq7mLqAD3fo2jspcbc3aytlxp7aXW9tNpLq7k31999Z0E2m0UqlbL9KWbOOcydOxdXXXUVEokENm7ciCuuuAJz5swBACxZsgQHHHAAXn/9dUyYMCH/904//XS88soreOCBB3o9bmNjI+bNm9fj8UWLFqGysnLrfDFERERERERERCHr6OjA7Nmz+90gUv0Ss8WLF+OOO+7AokWLsOeee+K5557DOeecgwkTJuDEE0/M1wVBUPD3nHM9HtvcnDlzcN555+V/3/0MohkzZvAZRMp2bbVl4jOIop2pWxT/RVxjJqv/Iq6xT1Zzd7P2L+IaM1n9F3GNfbKau5g6QM/3KBp7qTF3N2vrpcZeWl0vrfbSau7NReUZRBKq36T6O9/5Dr773e/iS1/6Eurq6vDVr34V5557LpqamgAA48ePBwC8+eabBX/v7bffxrhx4/o87rBhw1BVVVXwCwDKy8vV/uor3w5jR6HxmL2woasM6zcG2NBVhkuPqcMOY0cVVePzWFHOJM0d5uyi3O9Szm4wc2Mvw88d9/XSam7J3LTm1pYp7NxRXi+t5ta4XlrtpcbcVtdLjb20ul5a7aXV3MXcd1Z+iTjFxowZ43784x8XPDZ//ny36667Ouec6+rqcuPHj3dXXXVV/s/Xr1/vksmk+8lPfiI+TyaTcQBcJpPxE9yzDz74wN1zzz3ugw8+6LPmjfc63JKX0+6N9zoGVePzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpu5+T3nWbSPQ/V70F00kkn4eGHH8ZNN92EPffcE88++yxOP/10nHLKKbjqqqsAAFdddRWamppwyy23YNddd8X8+fPx2GOP4aWXXsKoUaNE58lms0gmk/2+Hq9UOjs70dLSgvr6evnOH6nA2dnEudnF2dnEudnF2dnF2dnEudnF2dkVhdlJ9zxUvwfRwoULcfHFF+PMM8/E22+/jQkTJuCMM87AJZdckq+54IILkMvlcOaZZ+Ldd9/FfvvthwcffFC8OUREREREREREFHeq34No1KhRuO666/DKK68gl8thxYoVuPzyyzF06NB8TRAEaGxsRHt7O9atW4fHH38ckyZNKmHq0mjP5LBkRRrtmdyganweK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWc8eN6mcQkczi1lWY07wMXQ4oC4CmhjrMmjKx6Bqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dxxpPoZRNS/9kwuf2EDQJcD5jYvL9gFldT4PFaUM0lzS2jMHfdMEhpzW83kM7cEe6kzk4TG3NoyhZ1bgr3UmUlCY25tNaU4n4S2PmnspdX10movreaOK24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZSUJjbm01pTifhLY+aeyl1fXSai+t5o4rbhAZV5sagbKg8LFEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rjiBpFx1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdcBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpuQH7faSbd8+AGEaKxQUQ6cXY2cW52cXY2cW52cXZ2cXY2cW52cXZ2RWF20j0PvsSMiIiIiIiIiCjmuEEUEe2ZHJasSG/xo/kkNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNmSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs0dR3wGkXHtmVz+wgaALgfMbV5esAsqqfF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1X3CAybmV6bf7C7rbRObSlO4qq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2Eur66XVXlrNHVfcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcccUNIuOqkxVoaqhDIth0hSeCAPMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rgKnHOu/7Joy2azSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532Gfz9fcws5tNZPP3HFfL63mlsxNY26NmcLOHeX10mpuaZ2271HCPp/V3FbXS429tLpeWu2l1dyA/L7TTLrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxg4iIiIiIiIiIKOa4QRQR7ZkclqxIoz2TG1SNz2NFOZM0t4TG3HHPJKExt9VMPnNLsJc6M0lozK0tU9i5JdhLnZkkNObWVlOK80lo65PGXlpdL6320mruuBlS6gA0eItbV2FO8zJ0OaAsAJoa6jBrysSia3weK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWc8cRn0FkXHsml7+wAaDLAXOblxfsgkpqfB4rypmkuSU05o57JgmNua1m8plbgr3UmUlCY25tmcLOLcFe6swkoTG3tppSnE9CW5809tLqemm1l1ZzxxU3iIxbmV6bv7C7bXQObemOomp8HivKmaS5JTTmjnsmCY25rWbymVuCvdSZSUJjbm2Zws4twV7qzCShMbe2mlKcT0JbnzT20up6abWXVnPHFTeIjKtNjUBZUPhYIghQk6osqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdccYPIuOpkBZoa6pAINl3hiSDA/IZJqE5WFFXj81hRziTNLaExd9wzSWjMbTWTz9wS7KXOTBIac2vLFHZuCfZSZyYJjbm11ZTifBLa+qSxl1bXS6u9tJo7rgLnnOu/LNqy2SySySQymQyqqqpKHaeHzs5OtLS0oL6+HuXl5b3WtGdyaEt3oCZV2eeFLanxeawoZ5LmDnN2Ue532OfzNbewc1vN5DN33NdLq7klc9OYW2OmsHNHeb20mltap+17lLDPZzW31fVSYy+trpdWe2k1NyC/7zST7nlwgwjR2CAinTg7mzg3uzg7mzg3uzg7uzg7mzg3uzg7u6IwO+meB19iRkREREREREQUc9wgioj2TA5LVqS3+NF8khqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dxxM6TUAWjwFreuwpzmZehyQFkANDXUYdaUiUXX+DxWlDNJc0tozB33TBIac1vN5DO3BHupM5OExtzaMoWdW4K91JlJQmNubTWlOJ+Etj5p7KXV9dJqL63mjiM+g8i49kwuf2EDQJcD5jYvL9gFldT4PFaUM0lzS2jMHfdMEhpzW83kM7cEe6kzk4TG3NoyhZ1bgr3UmUlCY25tNaU4n4S2PmnspdX10movreaOK24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZSUJjbm01pTifhLY+aeyl1fXSai+t5o4rbhAZV5sagbKg8LFEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rjiBpFx1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdcBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpuQH7faSbd8+AGEaKxQUQ6cXY2cW52cXY2cW52cXZ2cXY2cW52cXZ2RWF20j0PvsSMiIiIiIiIiCjmuEEUEe2ZHJasSG/xo/kkNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNmSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs0dR3wGkXHtmVz+wgaALgfMbV5esAsqqfF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1X3CAybmV6bf7C7rbRObSlO4qq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2Eur66XVXlrNHVfcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcccUNIuOqkxVoaqhDIth0hSeCAPMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rgKnHOu/7Joy2azSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532Gfz9fcws5tNZPP3HFfL63mlsxNY26NmcLOHeX10mpuaZ2271HCPp/V3FbXS429tLpeWu2l1dyA/L7TTLrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxg4iIiIiIiIiIKOa4QRQR7ZkclqxIoz2TG1SNz2NFOZM0t4TG3HHPJKExt9VMPnNLsJc6M0lozK0tU9i5JdhLnZkkNObWVlOK80lo65PGXlpdL6320mruuBlS6gA0eItbV2FO8zJ0OaAsAJoa6jBrysSia3weK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWc8cRn0FkXHsml7+wAaDLAXOblxfsgkpqfB4rypmkuSU05o57JgmNua1m8plbgr3UmUlCY25tmcLOLcFe6swkoTG3tppSnE9CW5809tLqemm1l1ZzxxU3iIxbmV6bv7C7bXQObemOomp8HivKmaS5JTTmjnsmCY25rWbymVuCvdSZSUJjbm2Zws4twV7qzCShMbe2mlKcT0JbnzT20up6abWXVnPHFTeIjKtNjUBZUPhYIghQk6osqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdccYPIuOpkBZoa6pAINl3hiSDA/IZJqE5WFFXj81hRziTNLaExd9wzSWjMbTWTz9wS7KXOTBIac2vLFHZuCfZSZyYJjbm11ZTifBLa+qSxl1bXS6u9tJo7rgLnnOu/LNqy2SySySQymQyqqqpKHaeHzs5OtLS0oL6+HuXl5b3WtGdyaEt3oCZV2eeFLanxeawoZ5LmDnN2Ue532OfzNbewc1vN5DN33NdLq7klc9OYW2OmsHNHeb20mltap+17lLDPZzW31fVSYy+trpdWe2k1NyC/7zST7nlwgwjR2CAinTg7mzg3uzg7mzg3uzg7uzg7mzg3uzg7u6IwO+meB19iRkREREREREQUc9wgioj2TA5LVqS3+NF8khqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dxxM6TUAWjwFreuwpzmZehyQFkANDXUYdaUiUXX+DxWlDNJc0tozB33TBIac1vN5DO3BHupM5OExtzaMoWdW4K91JlJQmNubTWlOJ+Etj5p7KXV9dJqL63mjiM+g8i49kwuf2EDQJcD5jYvL9gFldT4PFaUM0lzS2jMHfdMEhpzW83kM7cEe6kzk4TG3NoyhZ1bgr3UmUlCY25tNaU4n4S2PmnspdX10movreaOK24QGbcyvTZ/YXfb6Bza0h1F1fg8VpQzSXNLaMwd90wSGnNbzeQztwR7qTOThMbc2jKFnVuCvdSZSUJjbm01pTifhLY+aeyl1fXSai+t5o4rbhAZV5sagbKg8LFEEKAmVVlUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rjiBpFx1ckKNDXUIRFsusITQYD5DZNQnawoqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXdcBc45139ZtGWzWSSTSWQyGVRVVZU6Tg+dnZ1oaWlBfX09ysvLe61pz+TQlu5ATaqyzwtbUuPzWFHOJM0d5uyi3O+wz+drbmHntprJZ+64r5dWc0vmpjG3xkxh547yemk1t7RO2/coYZ/Pam6r66XGXlpdL6320mpuQH7faSbd8+AGEaKxQUQ6cXY2cW52cXY2cW52cXZ2cXY2cW52cXZ2RWF20j0PvsSMiIiIiIiIiCjmuEEUEe2ZHJasSG/xo/kkNT6PFeVM0twSGnPHPZOExtxWM/nMLcFe6swkoTG3tkxh55ZgL3VmktCYW1tNKc4noa1PGntpdb202kurueNmSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs0dR3wGkXHtmVz+wgaALgfMbV5esAsqqfF5rChnkuaW0Jg77pkkNOa2mslnbgn2UmcmCY25tWUKO7cEe6kzk4TG3NpqSnE+CW190thLq+ul1V5azR1X3CAybmV6bf7C7rbRObSlO4qq8XmsKGeS5pbQmDvumSQ05raayWduCfZSZyYJjbm1ZQo7twR7qTOThMbc2mpKcT4JbX3S2Eur66XVXlrNHVfcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcccUNIuOqkxVoaqhDIth0hSeCAPMbJqE6WVFUjc9jRTmTNLeExtxxzyShMbfVTD5zS7CXOjNJaMytLVPYuSXYS52ZJDTm1lZTivNJaOuTxl5aXS+t9tJq7rgKnHOu/7Joy2azSCaTyGQyqKqqKnWcHjo7O9HS0oL6+nqUl5f3WtOeyaEt3YGaVGWfF7akxuexopxJmjvM2UW532Gfz9fcws5tNZPP3HFfL63mlsxNY26NmcLOHeX10mpuaZ2271HCPp/V3FbXS429tLpeWu2l1dyA/L7TTLrnwQ0iRGODiHTi7Gzi3Ozi7Gzi3Ozi7Ozi7Gzi3Ozi7OyKwuykex58iRkRERERERERUcxxg4iIiIiIiIiIKOa4QRQR7ZkclqxIoz2TG1SNz2NFOZM0t4TG3HHPJKExt9VMPnNLsJc6M0lozK0tU9i5JdhLnZkkNObWVlOK80lo65PGXlpdL6320mpuAHgru67gf6NsSKkD0OAtbl2FOc3L0OWAsgBoaqjDrCkTi67xeawoZ5LmltCYO+6ZJDTmtprJZ24J9lJnJgmNubVlCju3BHupM5OExtzaakpxPgltfdLYS6vrpdVeWs3dXdd4799x5RRg+rWPo/GYvQZ8b1rAZxAZ157J5S9sAOhywNzm5QW7oJIan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcxdRFCTeIjFuZXpu/YLttdA5t6Y6ianweK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWcxdTFyXcIDKuNjUCZUHhY4kgQE2qsqgan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcxdRFCTeIjKtOVqCpoQ6JYNOVmwgCzG+YhOpkRVE1Po8V5UzS3BIac8c9k4TG3FYz+cwtwV7qzCShMbe2TGHnlmAvdWaS0JhbW00pziehrU8ae2l1vbTaS6u5i6mLksA55/ovi7ZsNotkMolMJoOqqqpSx+mhs7MTLS0tqK+vR3l5ea817Zkc2tIdqElV9nnBSmp8HivKmaS5w5xdlPsd9vl8zS3s3FYz+cwd9/XSam7J3DTm1pgp7NxRXi+t5pbWafseJezzWc1tdb3U2Eur66XVXlrNDQCvvbMGzzzxR+xz4Gexw9hRfdZpJt3z4AYRorFBRDpxdjZxbnZxdjZxbnZxdnZxdjZxbnZxdnZFYXbSPQ/1LzGrqalBEAQ9fp111lkAAOccGhsbMWHCBFRUVGDq1Kl44YUXSpyaiIiIiIiIiMgO9RtEra2taG9vz/966KGHAABf/OIXAQALFizANddcg+uvvx6tra0YP348pk+fjjVr1pQydujaMzksWZHe4kfuSWp8HivKmaS5JTTmjnsmCY25rWbymVuCvdSZSUJjbm2Zws4twV7qzCShMbe2mlKcT0JbnzT20up6abWXVnMDwFvZdQX/G2VDSh2gP9tuu23B76+88krssssuOPjgg+Gcw3XXXYfvfe97aGhoAADcdtttGDduHBYtWoQzzjijFJFDt7h1FeY0L0OXA8oCoKmhDrOmTCy6xuexopxJmltCY+64Z5LQmNtqJp+5JdhLnZkkNObWlins3BLspc5MEhpza6spxfkktPVJYy+trpdWe2k1d3dd471/x5VTgOnXPo7GY/Ya8L1pgan3IPrggw8wYcIEnHfeeZg7dy7+/e9/Y5dddsHSpUsxefLkfN0xxxyDbbbZBrfddluvx1m/fj3Wr1+f/302m8WOO+6IdDqt9j2IHnroIUyfPr3Hax7fyq7D9GsfR9dmU0wEAR489yCMqxourvF5rChnkubuFsbsotzvUpwPGPzc2Mvwc3eL63ppNXe3Lc1Na25tmcLO3S2K66XV3MXUAXq+R9HYS425u1lbLzX20up6abWXVnNvXlceOHz/k124+OkybHBlff7sp1k2m0UqlYrWm1T/5je/wezZs7Fq1SpMmDABS5YswQEHHIDXX38dEyZMyNedfvrpeOWVV/DAAw/0epzGxkbMmzevx+OLFi1CZWXlVstPRERERERERBSmjo4OzJ49u98NIvUvMdvczTffjCOOOKJgMwgAgiAo+L1zrsdjm5szZw7OO++8/O+7n0E0Y8YMPoNI6a6tlkx8BlG0M3WL4r+Ia8xk9V/ENfbJau5u1v5FXGMmq/8irrFPVnMXUwfo+R5FYy815u5mbb3U2Eur66XVXlrNvXldVJ5BJKH+Taq7vfLKK3j44Ydx2mmn5R8bP348AODNN98sqH377bcxbty4Po81bNgwVFVVFfwCgPLycrW/+sq3w9hRaDxmL2zoKsP6jQE2dJXh0mPqsMPYUUXV+DxWlDNJc4c5uyj3u5SzG8zc2Mvwc8d9vbSaWzI3rbm1ZQo7d5TXS6u5Na6XVnupMbfV9VJjL62ul1Z7aTV3QZ3btG2ywfX/s5/mXxJmXmLW2NiIm266Ca+++iqGDNn0xCfnHCZMmIBzzz0XF1xwAYBN71O03Xbb4aqrrhK/SXU2m0Uymez36Val0tnZiZaWFtTX1/c52PZMDm3pDtSkKlGdrBhwjc9jRTmTNHeYs4tyv8M+n6+5hZ3baiafueO+XlrNLZmbxtwaM4WdO8rrpdXc0jpt36OEfT6rua2ulxp7aXW9tNpLq7kB4LV31uCZJ/6IfQ78LHYYO6rPOs2kex4mNoi6urpQW1uLL3/5y7jyyisL/uyqq65CU1MTbrnlFuy6666YP38+HnvsMbz00ksYNUo2vChsEJFOnJ1NnJtdnJ1NnJtdnJ1dnJ1NnJtdnJ1dUZiddM/DxHsQPfzww1i1ahVOOeWUHn92wQUXIJfL4cwzz8S7776L/fbbDw8++KB4c4iIiIiIiIiIKO5MvAfRjBkz4JzDbrvt1uPPgiBAY2Mj2tvbsW7dOjz++OOYNGlSCVKWVnsmhyUr0mjP5AZV4/NYUc4kzS2hMXfcM0lozG01k8/cEuylzkwSGnNryxR2bgn2UmcmCY25tdWU4nwS2vqksZdW10urvbSaG9j0ZtWb/2+UmXgGEW3Z4tZVmNO8DF0OKAuApoY6zJoysegan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXc3XWN9/4dV04Bpl/7OBqP2WvA96YFJp5BRH1rz+TyFzYAdDlgbvPygl1QSY3PY0U5kzS3hMbccc8koTG31Uw+c0uwlzozSWjMrS1T2Lkl2EudmSQ05tZWU4rzSWjrk8ZeWl0vrfbSau5i6qKEG0TGrUyvzV+w3TY6h7Z0R1E1Po8V5UzS3BIac8c9k4TG3FYz+cwtwV7qzCShMbe2TGHnlmAvdWaS0JhbW00pziehrU8ae2l1vbTaS6u5i6mLEm4QGVebGoGyoPCxRBCgJlVZVI3PY0U5kzS3hMbccc8koTG31Uw+c0uwlzozSWjMrS1T2Lkl2EudmSQ05tZWU4rzSWjrk8ZeWl0vrfbSau5i6qKEG0TGVScr0NRQh0Sw6cpNBAHmN0xCdbKiqBqfx4pyJmluCY25455JQmNuq5l85pZgL3VmktCYW1umsHNLsJc6M0lozK2tphTnk9DWJ429tLpeWu2l1dzF1EVJ4Jxz/ZdFWzabRTKZRCaTQVVVVanj9NDZ2YmWlhbU19ejvLy815r2TA5t6Q7UpCr7vGAlNT6PFeVM0txhzi7K/Q77fL7mFnZuq5l85o77emk1t2RuGnNrzBR27iivl1ZzS+u0fY8S9vms5ra6XmrspdX10movreYGgNfeWYNnnvgj9jnws9hh7Kg+6zST7nlwgwjR2CAinTg7mzg3uzg7mzg3uzg7uzg7mzg3uzg7u6IwO+meB19iRkREREREREQUc9wgIiIiIiIiIiKKOW4QRUR7JoclK9Joz+QGVePzWFHOJM0toTF33DNJaMxtNZPP3BLspc5MEhpza8sUdm4J9lJnJgmNubXVlOJ8Etr6pLGXVtdLq720mhsA3squK/jfKBtS6gA0eItbV2FO8zJ0OaAsAJoa6jBrysSia3weK8qZpLklNOaOeyYJjbmtZvKZW4K91JlJQmNubZnCzi3BXurMJKExt7aaUpxPQlufNPbS6npptZdWc3fXNd77d1w5BZh+7eNoPGavAd+bFvAZRMa1Z3L5CxsAuhwwt3l5wS6opMbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXcxdVHCDSLjVqbX5i/YbhudQ1u6o6gan8eKciZpbgmNueOeSUJjbquZfOaWYC91ZpLQmFtbprBzS7CXOjNJaMytraYU55PQ1ieNvbS6XlrtpdXcxdRFCTeIjKtNjUBZUPhYIghQk6osqsbnsaKcSZpbQmPuuGeS0JjbaiafuSXYS52ZJDTm1pYp7NwS7KXOTBIac2urKcX5JLT1SWMvra6XVntpNXcxdVHCDSLjqpMVaGqoQyLYdOUmggDzGyahOllRVI3PY0U5kzS3hMbccc8koTG31Uw+c0uwlzozSWjMrS1T2Lkl2EudmSQ05tZWU4rzSWjrk8ZeWl0vrfbSau5i6qIkcM65/suiLZvNIplMIpPJoKqqqtRxeujs7ERLSwvq6+tRXl7ea017Joe2dAdqUpV9XrCSGp/HinImae4wZxflfod9Pl9zCzu31Uw+c8d9vbSaWzI3jbk1Zgo7d5TXS6u5pXXavkcJ+3xWc1tdLzX20up6abWXVnMDwGvvrMEzT/wR+xz4WewwdlSfdZpJ9zy4QYRobBCRTpydTZybXZydTZybXZydXZydTZybXZydXVGYnXTPgy8xIyIiIiIiIiKKOW4QERERERERERHFHDeIiIiIiIiIiIhijhtEREREREREREQxxw0iIiIiIiIiIqKY4wYREREREREREVHMcYOIiIiIiIiIiCjmuEFERERERERERBRz3CAiIiIiIiIiIoo5bhAREREREREREcUcN4iIiIiIiIiIiGKOG0RERERERERERDHHDSIiIiIiIiIiopjjBhERERERERERUcxxg4iIiIiIiIiIKOaGlDqABs45AEA2my1xkt51dnaio6MD2WwW5eXlpY5DReDsbOLc7OLsbOLc7OLs7Pr/2rv/sCrr+4/jr6P8OjBEweBwQsgfhKlAGq6pXOq0mc3U5maWRTjmplegQI1opdPLXSm6ouUozdbc1MsLr7UgdEvEpqRrKUkUmhdU8zITvei6JsaPIuB8vn/47Xw7IqZ9jXPOzvNxXecP7s/nnPO+rzfwed/vc5/7Jnfeibx5L3Lnvf4bcvdlr+PL3kdPaBBJam5uliQNGjTIzZEAAAAAAABce83NzQoLC+tx3GK+roXkAxwOhxoaGhQaGiqLxeLucLr59NNPNWjQIJ06dUr9+vVzdzi4CuTOO5E370XuvBN5817kznuRO+9E3rwXufNe/w25M8aoublZdrtdffr0fKUhziCS1KdPH8XExLg7jK/Vr18/r/2F9HXkzjuRN+9F7rwTefNe5M57kTvvRN68F7nzXt6eu8udOfQlLlINAAAAAADg42gQAQAAAAAA+DgaRF4gMDBQK1asUGBgoLtDwVUid96JvHkvcuedyJv3Infei9x5J/Lmvcid9/Kl3HGRagAAAAAAAB/HGUQAAAAAAAA+jgYRAAAAAACAj6NBBAAAAAAA4ONoEAEAAAAAAPg4GkQe5PXXX9fMmTNlt9tlsVhUWlrqHOvo6FB+fr4SExMVEhIiu92uBx54QA0NDe4LGJKkNWvWaOzYsQoNDVVkZKTuuusu1dXV9Th/0aJFslgs+t3vftd7QaKbDRs2KCkpSf369VO/fv00btw4vfrqqy5zjh8/rlmzZiksLEyhoaH63ve+p48++shNEaMna9askcViUU5OjnNbS0uLsrKyFBMTI6vVqptuukkbNmxwX5BwOn36tO6//35FREQoODhYN998s44cOeIcN8Zo5cqVstvtslqtmjx5so4dO+bGiHHDDTfIYrF0e2RmZlKfeLjOzk4tW7ZMgwcPltVq1ZAhQ7Rq1So5HI5LzqdG8RzNzc3KyclRXFycrFarxo8fr6qqKpc51Cnud7njN+nK1rSzZ88qLS1NNptNISEhGjNmjF566aVe3AvfdC2Ovdvb27VkyRINHDhQISEhmjVrlj7++ONe3pNriwaRB2ltbVVycrKKioq6jbW1tam6ulrLly9XdXW1Xn75ZdXX12vWrFluiBRfVVlZqczMTL355puqqKhQZ2enpk2bptbW1m5zS0tLdejQIdntdjdEiq+KiYlRQUGB3nrrLb311luaMmWKZs+e7Vy0P/zwQ6Wmpmr48OHav3+/3nnnHS1fvlxBQUFujhxfVVVVpU2bNikpKclle25urnbv3q1t27bp+PHjys3N1ZIlS/TKK6+4KVJI0rlz5zRhwgT5+/vr1Vdf1XvvvaennnpK/fv3d85Zt26dCgsLVVRUpKqqKtlsNv3gBz9Qc3Oz+wL3cVVVVTpz5ozzUVFRIUmaO3cu9YmHW7t2rTZu3KiioiIdP35c69at029/+1v9/ve/7zaXGsWzLFy4UBUVFdq6datqa2s1bdo03XbbbTp9+rQk6hRPcbnjN+nK1rS0tDTV1dWprKxMtbW1mjNnjubNm6e33367t3bDJ12LY++cnByVlJSouLhYBw8eVEtLi+688051dXX11m5cewYeSZIpKSm57JzDhw8bSebkyZO9ExSuSGNjo5FkKisrXbZ//PHH5vrrrzdHjx41cXFx5umnn3ZPgOjRgAEDzB/+8AdjjDHz5s0z999/v5sjwuU0Nzeb+Ph4U1FRYSZNmmSys7OdYyNHjjSrVq1ymT9mzBizbNmyXo4SX5Wfn29SU1N7HHc4HMZms5mCggLnts8//9yEhYWZjRs39kaIuALZ2dlm6NChxuFwXHKc+sRzzJgxw2RkZLhsmzNnTrf1jRrFs7S1tZm+ffuaXbt2uWxPTk42jz/+uDGGOsUTXXz8dqVrWkhIiNmyZYvLa4WHhztrUnz7vsmxd1NTk/H39zfFxcXOOadPnzZ9+vQxu3fv/jbD/VZxBpEXO3/+vCwWi8snr3C/8+fPS5LCw8Od2xwOh9LS0pSXl6eRI0e6KzT0oKurS8XFxWptbdW4cePkcDj0t7/9TTfeeKNuv/12RUZG6tZbb+122jDcKzMzUzNmzNBtt93WbSw1NVVlZWU6ffq0jDHat2+f6uvrdfvtt7shUnyprKxMKSkpmjt3riIjIzV69Gi98MILzvETJ07o7NmzmjZtmnNbYGCgJk2apDfeeMMdIeMiX3zxhbZt26aMjAxZLJZLzqE+8Rypqal67bXXVF9fL0l65513dPDgQf3whz90zqFG8TydnZ3q6urqdjaQ1WrVwYMHqVO8xJWuaampqdqxY4f+85//yOFwqLi4WO3t7Zo8ebIbokZPLl7bjhw5oo6ODpf82u12jRo1yqtrFhpEXurzzz/Xo48+qvnz56tfv37uDgf/yxijhx56SKmpqRo1apRz+9q1a+Xn56elS5e6MTpcrLa2Vt/5zncUGBioxYsXq6SkRCNGjFBjY6NaWlpUUFCg6dOna8+ePfrRj36kOXPmqLKy0t1hQ1JxcbGqq6u1Zs2aS46vX79eI0aMUExMjAICAjR9+nQ999xzSk1N7eVI8VX//ve/tWHDBsXHx6u8vFyLFy/W0qVLtWXLFkkXrsMgSVFRUS7Pi4qKco7BvUpLS9XU1KQFCxZccpz6xLPk5+fr3nvv1fDhw+Xv76/Ro0crJydH9957r3MONYrnCQ0N1bhx4/Sb3/xGDQ0N6urq0rZt23To0CGdOXOGOsVLXOmatmPHDnV2dioiIkKBgYFatGiRSkpKNHTo0F6NFz271Np29uxZBQQEaMCAAS5zvb1m8XN3ALh6HR0duueee+RwOPTcc8+5Oxx8RVZWlt59910dPHjQue3IkSN65plnVF1d3eOnrXCPhIQE1dTUqKmpSX/961+Vnp6uyspK5ycDs2fPVm5uriTp5ptv1htvvKGNGzdq0qRJbowap06dUnZ2tvbs2dPjtRbWr1+vN998U2VlZYqLi9Prr7+uBx98UNHR0Zc84wi9w+FwKCUlRatXr5YkjR49WseOHdOGDRv0wAMPOOdd/L/SGMP/Tw/x4osv6o477rjkdWqoTzzPjh07tG3bNm3fvl0jR45UTU2NcnJyZLfblZ6eTo3iwbZu3aqMjAxdf/316tu3r8aMGaP58+erurraeZFx6hTv8HVr2rJly3Tu3Dnt3btXAwcOVGlpqebOnasDBw4oMTGxt8PFRa52bfP2moUziLxMR0eH7r77bp04cUIVFRV8OudBlixZorKyMu3bt08xMTHO7QcOHFBjY6NiY2Pl5+cnPz8/nTx5Ug8//LBuuOEG9wUMBQQEaNiwYUpJSdGaNWuUnJysZ555RgMHDpSfn59GjBjhMv+mm27i7iAe4MiRI2psbNQtt9zi/JuqrKzU+vXr5efnp9bWVj322GMqLCzUzJkzlZSUpKysLM2bN09PPvmku8P3adHR0Zf9u7LZbJLU7ZO3xsbGbp/AovedPHlSe/fu1cKFC7uNUZ94pry8PD366KO65557lJiYqLS0NOXm5jrPvqRG8VxDhw5VZWWlWlpadOrUKR0+fFgdHR0aPHgwdYqXuJI17cMPP1RRUZH++Mc/aurUqUpOTtaKFSuUkpKiZ599ttdjhqvLrW02m01ffPGFzp075/Icb69ZaBB5kS9/Qd9//33t3btXERER7g4JutAlzsrK0ssvv6x//OMfGjx4sMt4Wlqa3n33XdXU1DgfdrtdeXl5Ki8vd1PUuBRjjNrb2xUQEKCxY8eqrq7OZby+vl5xcXFuig5fmjp1qmpra13+plJSUnTfffeppqZGXV1d6ujoUJ8+rktc3759e7y1M3rHhAkTLvt3NXjwYNlsNuddsqQL17yprKzU+PHjezVWdLd582ZFRkZqxowZLtupTzxXW1vbZf8XUqN4vpCQEEVHR+vcuXMqLy/X7NmzqVO8xJWsaW1tbZJEzeKBvm5tu+WWW+Tv7++S3zNnzujo0aNeXbPwFTMP0tLSog8++MD584kTJ1RTU6Pw8HDZ7Xb95Cc/UXV1tXbt2qWuri5nNzo8PFwBAQHuCtvnZWZmavv27XrllVcUGhrqzEtYWJisVqsiIiK6/UPx9/eXzWZTQkKCO0KGpMcee0x33HGHBg0apObmZhUXF2v//v3avXu3pAufus6bN08TJ07U97//fe3evVs7d+7U/v373Rs4FBoa6nKNL+lCAR0REeHcPmnSJOXl5clqtSouLk6VlZXasmWLCgsL3REy/ldubq7Gjx+v1atX6+6779bhw4e1adMmbdq0SdKF0/BzcnK0evVqxcfHKz4+XqtXr1ZwcLDmz5/v5uh9m8Ph0ObNm5Weni4/v/8rHzs7O6lPPNjMmTP1xBNPKDY2ViNHjtTbb7+twsJCZWRkSBI1igcrLy+XMUYJCQn64IMPlJeXp4SEBP30pz+VRJ3iKS53/BYbG/u1a9rw4cM1bNgwLVq0SE8++aQiIiJUWlqqiooK7dq1y1275RP+v8feYWFh+tnPfqaHH35YERERCg8P1y9/+UslJiZ69+UM3HcDNVxs3759RlK3R3p6ujlx4sQlxySZffv2uTt0n9ZTXjZv3tzjc7iFrPtlZGSYuLg4ExAQYK677jozdepUs2fPHpc5L774ohk2bJgJCgoyycnJprS01E3R4utcfJv7M2fOmAULFhi73W6CgoJMQkKCeeqpp3q8LTd6z86dO82oUaNMYGCgGT58uNm0aZPLuMPhMCtWrDA2m80EBgaaiRMnmtraWjdFiy+Vl5cbSaaurs5lO/WJZ/v0009Ndna2iY2NNUFBQWbIkCHm8ccfN+3t7T0+hxrFM+zYscMMGTLEBAQEGJvNZjIzM01TU5PLHOoU97vc8ZsxV7am1dfXmzlz5pjIyEgTHBxskpKSut32HtfetTj2/uyzz0xWVpYJDw83VqvV3Hnnneajjz5y305dAxZjjPn22k8AAAAAAADwdFyDCAAAAAAAwMfRIAIAAAAAAPBxNIgAAAAAAAB8HA0iAAAAAAAAH0eDCAAAAAAAwMfRIAIAAAAAAPBxNIgAAAAAAAB8HA0iAAAAAAAAH0eDCAAAoBctWLBAd911l7vDAAAAcGExxhh3BwEAAOArzp8/L2OM+vfv7+5QAAAAnGgQAQAAAAAA+Di+YgYAAHCVHA6H1q5dq2HDhikwMFCxsbF64oknJEm1tbWaMmWKrFarIiIi9Itf/EItLS3O5178FbPJkydr6dKleuSRRxQeHi6bzaaVK1e6vN/KlSsVGxurwMBA2e12LV26tDd2EwAA+BAaRAAAAFfpV7/6ldauXavly5frvffe0/bt2xUVFaW2tjZNnz5dAwYMUFVVlf7yl79o7969ysrKuuzr/fnPf1ZISIgOHTqkdevWadWqVaqoqJAkvfTSS3r66af1/PPP6/3331dpaakSExN7YzcBAIAP4StmAAAAV6G5uVnXXXedioqKtHDhQpexF154Qfn5+Tp16pRCQkIkSX//+981c+ZMNTQ0KCoqSgsWLFBTU5NKS0slXTiDqKurSwcOHHC+zne/+11NmTJFBQUFKiws1PPPP6+jR4/K39+/1/YTAAD4Fs4gAgAAuArHjx9Xe3u7pk6desmx5ORkZ3NIkiZMmCCHw6G6uroeXzMpKcnl5+joaDU2NkqS5s6dq88++0xDhgzRz3/+c5WUlKizs/Ma7Q0AAMAFNIgAAACugtVq7XHMGCOLxXLJsZ62S+p2ZpDFYpHD4ZAkDRo0SHV1dXr22WdltVr14IMPauLEiero6PgG0QMAAFwaDSIAAICrEB8fL6vVqtdee63b2IgRI1RTU6PW1lbntn/+85/q06ePbrzxxm/8nlarVbNmzdL69eu1f/9+/etf/1Jtbe03fj0AAICL+bk7AAAAAG8SFBSk/Px8PfLIIwoICNCECRP0ySef6NixY7rvvvu0YsUKpaena+XKlfrkk0+0ZMkSpaWlKSoq6hu935/+9Cd1dXXp1ltvVXBwsLZu3Sqr1aq4uLhrvGcAAMCX0SACAAC4SsuXL5efn59+/etfq6GhQdHR0Vq8eLGCg4NVXl6u7OxsjR07VsHBwfrxj3+swsLCb/xe/fv3V0FBgR566CF1dXUpMTFRO3fuVERExDXcIwAA4Ou4ixkAAAAAAICP4xpEAAAAAAAAPo4GEQAAAAAAgI+jQQQAAAAAAODjaBABAAAAAAD4OBpEAAAAAAAAPo4GEQAAAAAAgI+jQQQAAAAAAODjaBABAAAAAAD4OBpEAAAAAAAAPo4GEQAAAAAAgI+jQQQAAAAAAODj/gdOZB6fiRuJzwAAAABJRU5ErkJggg==\n",
"text/plain": [
"