{ "cells": [ { "cell_type": "markdown", "id": "2a113e8a", "metadata": {}, "source": [ "# Grama: Model Building\n", "\n", "*Purpose*: Grama provides tools to work with models, but in order to use these tools we need to be able to buidl models in grama! This exercise will introduce fundamental concepts for building and sanity-checking models. We'll build on these skills in future exercises.\n" ] }, { "cell_type": "markdown", "id": "067569a6", "metadata": {}, "source": [ "## Setup\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "5b289c69", "metadata": { "collapsed": false }, "outputs": [], "source": [ "import grama as gr\n", "import pandas as pd\n", "DF = gr.Intention()\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "id": "012c4621", "metadata": {}, "source": [ "# Composition\n", "\n", "Recall that there are four classes of verb in grama; *composition* verbs take a model as an input and produce a new model as an output. Using compositions we can add information to a model, such as input metadata and functions.\n" ] }, { "cell_type": "markdown", "id": "8f4ada0b", "metadata": {}, "source": [ "\n", "![Grama verb class diagram](./images/verb-classes.png)\n" ] }, { "cell_type": "markdown", "id": "14f502c6", "metadata": {}, "source": [ "# Useful Programming Tools\n", "\n", "To build grama models, we'll need to use a few simple programming tools.\n" ] }, { "cell_type": "markdown", "id": "64e04f54", "metadata": {}, "source": [ "## Lambda functions\n", "\n", "In an earlier exercise, we learned how to define Python functions using the `def` keyword:\n", "\n", "```python\n", "def fcn(x):\n", " return x ** 2\n", "```\n", "\n", "However, we can define the same function with `lambda` syntax:\n", "\n", "```python\n", "fcn = lambda x: x ** 2\n", "```\n", "\n", "A `lambda` function starts with the keyword `lambda`, and is followed by its arguments. The example above has just one argument `x`. After the arguments comes a colon `:`, which signals that what follows is the output of the function.\n", "\n", "The advantage of this `lambda` syntax is that it is more compact, and can be incorporated with a grama model building pipeline. Let's get some practice defining lambda functions.\n" ] }, { "cell_type": "markdown", "id": "c5a56de8", "metadata": {}, "source": [ "### __q1__ Implement a `lambda` function\n", "\n", "Use the `lambda` syntax to implement the following function:\n", "\n", "$$f(x) = x + 1$$\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "f6435619", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# TASK: Create a lambda function to implement the function above\n", "\n", "fcn = lambda x: x + 1\n", "# Use the following to check your work\n", "assert \\\n", " fcn(1) == 2, \\\n", " \"Incorrect value\"\n", "\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "id": "0176dd11", "metadata": {}, "source": [ "## Working with DataFrames\n", "\n", "Grama uses DataFrames to represent data and to interface with models. The constructor `gr.df_make()` is a convenient way to make a simple DataFrame:\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "d339625c", "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xyz
01arecycled value
12brecycled value
23crecycled value
\n", "
" ], "text/plain": [ " x y z\n", "0 1 a recycled value\n", "1 2 b recycled value\n", "2 3 c recycled value" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NOTE: No need to edit; recall that gr.df_make(...)\n", "# helps us construct DataFrames\n", "gr.df_make(\n", " x=[1, 2, 3],\n", " y=[\"a\", \"b\", \"c\"],\n", " z=\"recycled value\",\n", ")" ] }, { "cell_type": "markdown", "id": "eba03a86", "metadata": {}, "source": [ "We can *combine* this DataFrame constructor with a `lambda` function to take a DataFrame as an input, and return a DataFrame as an output. For instance, the following is a DataFrame version of the previous `lambda` function:\n", "\n", "```python\n", "fcn_df = lambda df: gr.df_make(y=df.x ** 2)\n", "```\n", "\n", "Note that this `lambda` function takes in a DataFrame, uses specific columns from that input `df`, and returns a DataFrame.\n" ] }, { "cell_type": "markdown", "id": "c9586f21", "metadata": {}, "source": [ "### __q2__ Functions on DataFrames\n", "\n", "Use the `lambda` syntax to implement the following function:\n", "\n", "$$y(x) = x + 1$$\n", "\n", "Make sure your lambda function takes a DataFrame as an argument, and returns a DataFrame as an output." ] }, { "cell_type": "code", "execution_count": 4, "id": "8a7ae65d", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# TASK: Create a lambda function based on DataFrames\n", "\n", "fcn_df = lambda df: gr.df_make(y=df.x + 1)\n", "# NOTE: Use the following to check your work\n", "df_res = fcn_df(gr.df_make(x=[0, 1]))\n", "df_out = gr.df_make(y=[1, 2])\n", "\n", "assert \\\n", " isinstance(df_res, pd.DataFrame), \\\n", " \"Output must be DataFrame\"\n", "\n", "assert \\\n", " gr.df_equal(df_res, df_out), \\\n", " \"Incorrect output\"\n", "\n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "id": "000ea6e9", "metadata": {}, "source": [ "# Constructing Grama Models\n", "\n", "Remember that *composition* verbs take in a grama model and return a new model. We use compositions primarily to construct grama models. We can start a blank model with `gr.Model()`, but then we need to add functionality to that model!\n" ] }, { "cell_type": "markdown", "id": "5ff1c1ff", "metadata": { "tags": [] }, "source": [ "## Add a function\n", "\n", "One of the most core parts of a model is its set of *functions*; these map from inputs to outputs. For functions defined by simple mathematical expressions, the composition `gr.cp_vec_function()` is the appropriate tool for the job.\n" ] }, { "cell_type": "markdown", "id": "ff424b78", "metadata": {}, "source": [ "### __q3__ Add a function to a model\n", "\n", "Add a function to `md_basic` that provides the output `y = x + 1`.\n", "\n", "*Hint 1*: Consult the documentation for `gr.cp_vec_function()` to see what arguments it requires. Remember that you can use `help(gr.cp_vec_function)` or use `Shift + Tab` to bring up the documentation at your cursor.\n", "\n", "*Hint 2*: Use a DataFrame-based lambda function, as you did for q2 above.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "fa076f73", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# TASK: Finish implementing the model\n", "md_basic = (\n", " gr.Model(\"Basic model\")\n", " >> gr.cp_vec_function(\n", " fun=lambda df: gr.df_make(\n", " y=df.x + 1\n", " ),\n", " var=[\"x\"],\n", " out=[\"y\"],\n", " )\n", ")\n", "\n", "# NOTE: Use the following to check your work\n", "df_res = (\n", " md_basic\n", " >> gr.ev_df(gr.df_make(x=0))\n", ")\n", "df_out = gr.df_make(x=0, y=1)\n", "\n", "assert \\\n", " set(md_basic.var) == {\"x\"}, \\\n", " \"md_basic has wrong variables\"\n", " \n", "assert \\\n", " set(md_basic.out) == {\"y\"}, \\\n", " \"md_basic has wrong outputs\"\n", "\n", "assert \\\n", " gr.df_equal(df_res, df_out), \\\n", " \"md_basic function incorrect\"\n", " \n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "id": "aba3eebb", "metadata": {}, "source": [ "## Add bounds\n", "\n", "Once your model has a function, it is useful to define bounds for the inputs. This does not *force* the model to reject values outside the bounds, but rather serves as useful *metadata* about the model. Bounds are used by other verbs like exploratory tools (e.g. for parameter sweeps) and optimization.\n", "\n", "The verb `gr.cp_bounds()` allows you to add bounds for inputs.\n" ] }, { "cell_type": "markdown", "id": "fa35ba7e", "metadata": {}, "source": [ "### __q4__ Add bounds to a model\n", "\n", "For the following model, add bounds $0 \\leq x_1 \\leq 1$ and $0 \\leq x_2 \\leq 1$.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "87dfea8e", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Success!\n" ] } ], "source": [ "# TASK: Finish implementing the model\n", "md_bounded = (\n", " gr.Model(\"Bounded input\")\n", " >> gr.cp_vec_function(\n", " fun=lambda df: gr.df_make(\n", " y=gr.sin(df.x1) + gr.sin(df.x2)**2\n", " ),\n", " var=[\"x1\", \"x2\"],\n", " out=[\"y\"],\n", " )\n", " >> gr.cp_bounds(\n", " x1=(0, 1),\n", " x2=(0, 1),\n", " )\n", ")\n", "\n", "# NOTE: Use the following to check your work\n", "assert \\\n", " (md_bounded.domain.bounds[\"x1\"][0] == 0) and \\\n", " (md_bounded.domain.bounds[\"x1\"][1] == 1) and \\\n", " (md_bounded.domain.bounds[\"x2\"][0] == 0) and \\\n", " (md_bounded.domain.bounds[\"x2\"][1] == 1), \\\n", " \"md_bounded bounds incorrect\"\n", " \n", "print(\"Success!\")" ] }, { "cell_type": "markdown", "id": "541e0f24", "metadata": {}, "source": [ "A model with functions and bounds already has a lot of useful information! There is a lot more information that a grama model can have, but that's enough model building for this exercise.\n" ] }, { "cell_type": "markdown", "id": "cd1834ab", "metadata": {}, "source": [ "## Composition: Quick Reference\n", "\n", "As a quick-reference, here is a list of the most important grama composition verbs. Note that some of these are covered later in the exercise sequence; most notably, the verbs related to quantifying uncertainties (marginals and copulas).\n", "\n", "| Verb | Description |\n", "|---|---|\n", "| `gr.Model()` | Start a new grama model |\n", "| `gr.cp_vec_function()` | Add a *vectorized* (DataFrame-based) function |\n", "| `gr.cp_function()` | Add a *non-vectorized* (array-based) function |\n", "| `gr.cp_bounds()` | Add bounds for inputs |\n", "| `gr.cp_marginals()` | Add marginal distributions for inputs |\n", "| `gr.cp_copula_independence()` | Assume random inputs are independent |\n", "| `gr.cp_copula_gaussian()` | Assume random inputs are correlated |\n" ] }, { "cell_type": "markdown", "id": "7a52352b", "metadata": {}, "source": [ "# Checking models\n", "\n", "Once you've built a grama model, you can use a variety of tools to work with the model. These are useful for making sense of model behavior.\n", "\n", "One of the most key studies you can do with a model is a parameter sweep. There are a variety of grama tools to help do parameter sweeps.\n" ] }, { "cell_type": "markdown", "id": "2be8866d", "metadata": { "tags": [] }, "source": [ "### __q5__ Create a grid of values\n", "\n", "The verb `gr.df_grid()` is a helper function that creates a \"grid\" of points. Modify the code below to see how this function operates.\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "daf71558", "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# TASK: Modify the code, note the changes\n", "(\n", " # TODO: Try modifying the following code; see how\n", " # the results change\n", " gr.df_grid(\n", " x1=[0.0, 0.5, 1.0],\n", " x2=gr.linspace(0, 1, 25),\n", " )\n", " \n", " # NOTE: No need to edit the following\n", " >> gr.ggplot(gr.aes(\"x1\", \"x2\"))\n", " + gr.geom_point()\n", ")" ] }, { "cell_type": "markdown", "id": "67ac9b2d", "metadata": {}, "source": [ "Once you've created a grid of points, you can evaluate the model on that grid to perform a parameter sweep.\n" ] }, { "cell_type": "markdown", "id": "60bf9dbb", "metadata": {}, "source": [ "### __q6__ Evaluate a grid of values\n", "\n", "Create a grid of points in `x1` and `x2` to evaluate the model.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "c9fcffed", "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# TASK: Create a grid of points\n", "(\n", " md_bounded\n", " >> gr.ev_df(\n", "\n", " gr.df_grid(\n", " x1=gr.linspace(0, 1, 25),\n", " x2=gr.linspace(0, 1, 25),\n", " )\n", " )\n", " \n", " >> gr.ggplot(gr.aes(\"x1\", \"x2\", fill=\"y\"))\n", " + gr.geom_tile()\n", ")" ] }, { "cell_type": "markdown", "id": "6e62f9a2", "metadata": {}, "source": [ "## Model sanity checks\n", "\n", "Parameter sweeps are particularly useful when checking that you implemented a model *correctly*. For example, let's suppose someone implemented the following function in a model\n", "\n", "$$\\begin{aligned}f(x, y) &= x + y^2 \\,|\\, x < 1/2 \\\\ & = 1 - x + y^2 \\,|\\, x \\geq 1/2 \\end{aligned}$$\n", "\n", "The following code *attempts* to implement the function as a grama model.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "5c4ffc94", "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "model: Error example\n", "\n", " inputs:\n", " var_det:\n", " y: [0, 1]\n", " x: [0, 1]\n", "\n", " var_rand:\n", "\n", " copula:\n", " None\n", "\n", " functions:\n", " f0: ['x', 'y'] -> ['f']" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NOTE: No need to edit; you'll explore this model in the next task\n", "md_error = (\n", " gr.Model(\"Error example\")\n", " >> gr.cp_vec_function(\n", " fun=lambda df: gr.df_make(\n", " f=(df.x + df.y**2) * (df.x < 0.5)\n", " +(1 + df.x + df.y**2) * (df.x >= 0.5)\n", " ),\n", " var=[\"x\", \"y\"],\n", " out=[\"f\"],\n", " )\n", " >> gr.cp_bounds(\n", " x=(0, 1),\n", " y=(0, 1),\n", " )\n", ")\n", "md_error" ] }, { "cell_type": "markdown", "id": "9a27e88f", "metadata": {}, "source": [ "However, the model implementation above is in error. Up next, you'll use a parameter sweep to help find the error.\n" ] }, { "cell_type": "markdown", "id": "750c6972", "metadata": { "tags": [] }, "source": [ "### __q7__ Find the error\n", "\n", "Construct a sinew plot to inspect the model behavior and find the implementation error. Answer the questions under *observations* below.\n", "\n", "Make sure to sweep over all the deterministic variables in the model. Remember that the effect of `x` should switch from positive to negative at the midpoint of its domain.\n", "\n", "*Hint*: We learned about sinew plots in the previous grama exercise `e-grama01-basics`.\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "28ebc7e4", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calling plot_sinew_outputs....\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnsAAAHPCAYAAAArhxxpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAABoCUlEQVR4nO3dd5wdVfnH8c9sdlNJg0AgS2dAIMnSpUhTAalDEzyA4AHpoIioFBFCrwJKERVhRMrQBAYbYkFRBPmJ9OZBEUnoJCFAyiY7vz/OBJbN9r1355bv+/XaV/bOvXfm2dw9d597ynOCLMsQERERkdrUUHQAIiIiIlI+SvZEREREapiSPREREZEapmRPREREpIYp2RMRERGpYUr2RERERGqYkj0RERGRGqZkT0RERKSGKdkTERERqWFK9kRERERqmJI9ERERkRqmZE9ERESkhinZExEREalhSvZEREREapiSPREREZEapmRPpADNzc2rNjc3v9Pc3LxVfntMc3Pzf5qbm79YdGwiUlrNzc0nNDc3/6rDsRObm5t/UVRMUl+U7IkUYPr06S8BXwV+1tzcPBa4Evjb9OnTbyg0MBEphxuATzc3N09sd+xAIC4mHKk3SvZECpIndg8CDwBbAUcVG5GIlMP06dNfB34LHADQ3Ny8ETAJuKfIuKR+KNkTKdbVwFTgR9OnT59ddDAiUjbXAQfl3x8EJNOnT59fYDxSR4Isy4qOQaQuNTc3Dwf+ATwE7AFslA/vikiNaW5ubgKmAzsCvwF2mz59+sPFRiX1Qj17IsW5GHgZOBS4Crihubl5SLEhiUg5TJ8+vRU/d+864G0lejKYlOyJFKC5uXknYB/ATp8+PQPOAJqAUwoNTETK6TqgBfhp0YFIfdEwroiIyCBobm5eGngVWGP69OmvFB2P1I/GogMAiKLoR8AuwGjgHeBHaZqe28Vjt8GXqVgdeBo4NE3Tx0sczzjgR8BOwBzgwjRNL2t3/xTgGvwntJeAY9M0/UMpYxARkdrR3NwcAF8DfqNETwZbpQzjXgaEaZqOwZeg+GIURft2fFAURcsAdwMXAuOBm4E0iqJhfb1gFEXToiia1sXdVwDDgGbgc8ApURTtlD+vCb9cPs1jOAO4M4qi5foag4iI1L7m5uZh+I6D/YBvFRyO1KGK6NlL0/SZDofagLCTh+4FuDRNrweIouhS4HhgO+CXURQF+e0jgQn4VY6Hp2na609RURSNws+l2ihN03eBJ6Mo+jFwCPBrYFtgJHB+mqZtwC1RFH01f86Vvb2OiIjUh7zEylJFxyH1q1J69oii6Lwoit7Hr04chV+11NEU4LHFN9I0zYAn8uMAx+KLVu4ATAQeBZI+hrIW0JCm6VPtjj3W7hpTgCfzRK+z+0VEREQqRsUke2manoz/5PNJ4CZgZicPWwqY1eHYLPxcP/A7EJyapulLaZq2AtOATaIoWrkPoSwFdCxu2/4aPcUgIiIiUjEqYhh3sbyn7pEoinbEz4X7eoeHvAeM7XBsLH4uBMCq+GHV9r1ubcCKwMtRFD0BLE78hgNEUfS1/PZf0jTdNb/GmG6u0VMMIiIiIhWjopK9dhqBNTo5/hRw+OIb+Ry9FuAH+aGXgSPTNL2/s5OmadrS7rnT8mPTOjzsBSCLomhymqZP58fWz6+9OIYToyhqaDeUuz5+sUhJzZgx435gm1KfV0SKMWnSpKCr+2bMmKE6WCI1oru2XoTCk70oisYDu+JX2b4HbI4fjj2rk4f/HLgoiqIvArcCR+fHf5f/+wPgnCiKDkrT9MX83NunaXprb+NJ0/T9KIpuz89zILAKfoeDg/OH3A/MBb6VLxCJ8Hub7tXba/TBNvheybroNRw3btx6Q4YM+fOiRYu2njVrVknL6VS40cAr6LWudb2Z6qHfgdqmtl4fKm5aV+HJHpDhE6nv4+OZDnwXX/6EKIreA3ZK0/SBNE3fjqJoj/y+H+N72aI0TRdvJn05ftj2F1EUNePn0t2HTwz74pj8/K/iG+T5aZr+GiBN09YoiiJ8nb3T8XX29krT9I0+/+S9M2fSpEnvluncFaW1tfV9gIaGhvfr5WcGmDFjxuJv9VrXsHavc3f0O1DD1Nbr42fuZVsfVNpBo4Llwzpj66WBtLa2bgj8A9ioqanp0aLjGSwzZswYg18UpNe6hs2YMWNMd6+v2nvtU1uvn9e50l7filmNKyIiIiKlp2RPREREpIYp2RMRERGpYUr2RERERGqYkj0RERGRGqZkT0RERKSGKdkTERERqWFK9kRERERqmJI9ERERkRqmZE9ERESkhinZExEREalhSvZERPrJODui6BhERHqiZE9EpI+Ms6sbZ28F/micDYqOR0SkO41FByAiUi2Ms+OBbwNfAf4GHJOEcVZsVCIi3VOyJyLSA+NsE3AUcDrwFrAvkCrRE5FqoGRPRKQL+RDt7sCFwNLANODqJIxbi4xLRKQvlOyJiHTCOLsx8F1gM+D7wDlJGM8qNCgRkX5Qsici0o5xdiXgXOAA4DZg7SSM/1NsVCIi/adkT0QEMM6OBk4Cvg48BnwqCeO/FRqUiEgJKNkTkbpmnG0EvgycCbwPfAm4TYsvRKRWKNkTkbqUL77YEbgYaAbOBi5Pwnh+oYGJSEUxzg4BrgFuScL4N0XH0x9K9kSk7hhnW/BJ3qeBHwBnJmH8VrFRiUilMc42AD8EdsO/Z1QlJXsiUjeMsysAZwEHA/cAk5MwfqHYqESkEuW9/5cA+wCfScL46YJD6jcleyJS84yzo4ATgG8Bz+PfuP9UbFQiUuHOAA4HdkjC+B9FBzMQSvZEpGblc20OBM4B2vC7YNyYhHFboYGJSEUzzn4TOBHYLQnjvxQdz0Ap2RORmmSc/Qy+KHIInA9cmoTxB8VGJSKVzjh7FL7W5j5JGP+26HhKQcmeiNQU4+w6+O3NdsavoNsxCePXi41KRKqBcfZA4HLgS0kY31VwOCWjZE9EaoJxdjn83rWHA78FWqp5QrWIDC7j7J7AdcAxSRjfWHQ8paRkT0SqmnF2OPA14BTgJWCnJIzvKzImEakuxtnPAbcAJyVh/MOi4yk1JXsiUpXy+lcGOA8YChwPxEkYLyo0MBGpKsbZrYE7gfOSMK7aWnrdUbInIlXHOLslvv7VFOAi4KIkjN8rNioRqTbG2Y2BXwBX46eB1CQleyJSNYyzIXABsCfwU2DPJIynFxuViFQj4+wU4F788O0JtbwftpI9Eal4xtmlge8AxwAPABsmYfxYoUGJSNUyzq4J3IdP9o6s5UQPlOyJSAUzzg7FJ3jfAV7H9+j9qtbfmEWkfIyzKwO/A/6OL7FS8/N8leyJSMXJ96TcCz9kOwb4NnBNEsathQYmIlXNODsRn+j9C/hCvbynKNkTkYpinN0Uv/PFxsClwPlJGM8uNioRqXb5dJD7gDeB3ZMwnldwSINGyZ6IVATj7Cr4MioGuBk4IAnj/xYblYjUAuPsaODXwEJglySM3y84pEGlZE9ECmWcHQucjC+M/AiwWRLGfy80KBGpGcbZkcA9wGhgmySMZxUb0eBTsicihViYLeSs1y7cF/gyMAvYH7hTiy9EpFTyRV63AysDWyVh/GbBIRVCyZ6IDCrjbLDhiPW3eq31NV5b+MZRwOnAVUkYLyg6NhGpHcbZRuBGoAWf6NVtTU4leyIyaIyzGwDffXTuY1vtOHo7DhgxefeNxmxwf9FxiUhtybdTvAbYFp/o/Wcg57PGBXESVu2oQ0PRAYhI7TPONhtnY+AfwDv7j99n7wOW/gItI6a8W3BoIlJj8tJN3wP2AHZIwvi5gZzPGjcU+Lk1bo+BR1cM9eyJSNkYZ5cCvgV8A3gC/wn7r62trRsWG9nAWeMmAS1xEv6m6FhE5GPOAQ4Gtk/C+J8DOZE1bgjwM2BT/PtYVVKyJyIlZ5wdgn+zPRuYBxwC3FILiy+scaOAb+ZfD1rj7q3m4R2RWmKcPRn4OrBzEsZ/G8i5rHENwI+BzwDbxEn4YglCLISSPREpKePs54CL8avfzgG+XwvFS/NP+F/CJ7ALgcOBm5XoiVQG4+xXgDOBvZIw/sNAzmWNC/BF3fcGPh0n4TMlCLEwSvZEpCSMs1PwSd52wNXAGbVS5sAatx1+V4/V8IWfL4uTcG6xUYnIYsZZi0/OvpiE8T0lOOVZwKHADnESPlqC8xVKyZ6IDIhxdnn8p+kvA78Epgx0QnSlsMatC1wEfA74EbB9nIRvFBuViLRnnD0E3z6PSMI4Gej5rHEn4qdp7BIn4V8Her5KoGRPRPolr0r/deBE/Kbi2yVh/MdioyoNa9xEYBpwGPAb/EKMqh7GEalFxtkTgAuAw5Iwvm6g57PGHY2fqvH5OAl/N9DzVQoleyLSJ3n9qi/i5+MFwLHAz5Iwbis0sBKwxo0AjgdOAv4N7FhLb/gitSIvr3I2foXsPkkY3znQc1rjDgK+DxwUJ+HdAz1fJVGyJyK9ZpzdFj937RP4T9PfTcL4g0KDKoF81d3+wLn498XjgOvjJFxUaGAisoT8A+cVwEH4Vbe/H+g5rXF7A9cCR8dJeNNAz1dplOyJSI+Ms58ALgR2BX4C7JqE8avFRlUa1rit8Qnsuvif8eI4Cd8vNioR6Yxxtgn4KbAj8NkkjB8e6DmtcTsCNwPfipPwRwM9XyVSsiciXTLOLovfu/ZI4HfA+kkYP1lsVKVhjVsTn9xFQAzsHifhjEKDEpEu5fOEbwM2ALZOwvipgZ4z/7B3J3BOnISXDPR8lUrJnogswTg7HPgq8G3gZWCXJIzvLTaq0rDGLQOcBhwN3A9sGCfh44UGJSLdMs6OA+4BJgGfGuhetwDWuE2AXwBX4SsK1CwleyLyoXzS8xfwteRG4Cc/X5eE8cJCAysBa9ww/GKSU4FXgd2BX6soskhlM85OxK+KHwJsWYopJNa4qcC9+OHbb9T6+4CSPREBwDi7BXAJ0IKfw3ZhEsZzio1q4PJK+J8HzgdGAycD18RJWPUJrEitM86uAtwHvI0fYXhnoOfMp3DcB/wavyCjphM9ULInUveMs2vgE6G98Rt+fz4J41eKjao0rHGb4RPXDfHV9c+Pk/DdYqMSkd4wzq6NT8qeBfZMwnjAC6escSsDvwceAmy9rLhXsidSp4yz4/FDml8B/gpsnIRx1W8LBGCNW7yt2b7ATcB+cRK+XGxUItJbxtmN8EO39+O3QJs/0HNa45bHJ3rPAyZOwtaBnrNaKNkTqTPG2aHAUfhFCm/hhzjvScK46ocyrHHjgFPwdfIeBjaNk/CRQoMSkT7J63mmwK34LdAG3PtmjVsa30v4OrBHnITzBnrOaqJkT6RO5Isv9sCXGxmPL6nywySMq/7TrTWuCV8e5nRgJn6Ryd31MBdHpJYYZ3fDl1e5HPhWKT6EWuPG4HsJF+D3u627OppK9kTqgHF2E/zctU2By4BzkzCeXWhQJZAvvojwCewE4Azg6jgJFxQamIj0mXH2i8B1+FGH80uU6I3El2wZBWwTJ2HVv+/1h5I9kRpmnF0ZP3dtP+AW4BNJGL9UaFAlYo3bCLgY2ALfC3BOnIQzi41KRPrDOHss/oPosUkYX12Kc1rjhgJ3ACsCW8VJ+FYpzluNlOyJ1CDj7Bh8iZHjgX8Am5diW6FKYI1bCTgH+CJwO7BOnIT/LjYqEemPfHrJqcB3gAOSML6lFOe1xjXiF2dNBbas991xlOyJ1BDjbCNwGH44cw4+IbqjRhZfjAZOBE4AHsO/gT9YaFAi0m/G2Qb89JIjgN2TMP51Kc5rjWvA7+G9NbB1nIQvleK81UzJnkgNyD8d7wxcBKwAnAVcWYpyBUXLP6Efgt/OaC5ggVu1+EKkeuUfTK/BLxrbIQnjv5TivPk83svxc3k/HSfhc6U4b7VTsidS5Yyz6+E/HW8DXAmclYTx28VGVRrWuB3x8/JWBM4Grqi3kgkitSbfezsBNge2TcL4sRKe/lzgS8B2cRKW8rxVTcmeSJUyzk7CJ0AWuAtYNwnjfxUZU6nk+1ZeDHwG+AFwZj1PrhapFcbZ0cDdwBrAVkkYv1Cqc1vjTsHPU945TsKHSnXeWqBkT6TKGGdHAd/Mv57BfzL+c7FRlYY1bgX8cO0h+HIJU+IkfL7YqESkFIyzy+D3ox0NfKqU2zJa476Kn6u8Z5yEfyjVeWuFkj2R6vMj/MTjw4GbkzBuKzieAbPGjcIvvPgWfiujz8ZJeH+hQYlIyfz5vb8ui997ey6+R69kPfXWuK/hRwIOiJPwF6U6by1RsidSfbYATkvC+MaiAxmo+fPbgsMOdBZfSqUNv43bjXESVn0CKyLe661vcN3bN1wHvABESRi/W4rz5osxzgBOwu91e3spzluLlOyJVBHj7FhgVeCJgkMZsGefnssVl755I9AMnA9cGifhBwWHJSIl9MO3rt3o8blPMrxh+L/ea3tvpySM55bivHl5le8DB+O3QLuvFOetVUr2RKrLFHwP2DNFB9Jf1ri1l1qq4bL3329j/PghT78zf9E2cRK+XnRcIlI6eTmoY4BLdxqzA7uN2ekbSw8fX6pErwmI8eWmtouT8G+lOG8tU7InUl1agH+V6tPxYLLGLQtMA47IMh4+/ZwVaF5p6DlNTU1K9ERqSF5a5Upg/3WHr33G/uP3OQtYVIpzW+NGALcBG+ELJj9ZivPWOiV7ItWlhSobwrXGDQeOA04B/gvsfNnVK72F38ZNRGpIXhLq58AkYMuTJ56Q4Yu8D5g1biyQAivhd9B5sRTnrQdK9kSqy1TgN0UH0Rv55GkDnAcMA74OxHESLmptbd2w0OBEpOSMs5vjE70XgI2TMH6jVG09Hxn4Df69pO73uu0rJXsiVSKfA9MCXFh0LD2xxm2J39VjKn4Lt4viJHyv2KhEpFyMs4cCV+FLQx2fhHFrqc5tjVsZ+C0wG9ghTsKa2CFoMCnZE6keq+CLkVbsMK41LgQuAPYEfgrsFSfh9GKjEpFyMc4OBS4FDgWOTsL4mlKe3xr3CeA+fG/hHvrQ2D9K9kSqRwswBz/vraJY45YGvoNfffcAsFGchP8sNioRKSfj7HLA7UCI38mnpKtirXEb4oduHwD2j5NwfinPX0+U7IlUjxbgiSSMs6IDWcwaNxSf4H0HeB3YC/hlnIQVE6OIlJ5xdiP8ntzT8fPzSjqHzhq3NX7LxDuAw+MkXFjK89cbJXsi1aMFqIgyA/nii73wQ7ZjgVOBH8dJWLJ5OiJSmYyzBwDXADfhh25L2uNmjdsF32N4FfANfXgcOCV7ItVjKr5ifKGscZ/EL77YBLgMOC9OwtmFBiUiZWecbcR/wPsq8DXgqlKPNFjj9sfP950GnKtErzSU7IlUAePsCGAtClycYY1bBV9GxQAJcGCchC8VFY+IDB7j7DL4dr8+sF0Sxn8q9TWscUfjP9B+NU7Cq0p9/nqmZE+kOqwLNABPDfaF80KmJ+M/yf8fsHmchA8PdhwiUgzjbAt+ft4s/Py8ki4Sy6eFfBs4HTgoTsKbSnl+UbInUi1agJeSMB604dJ8/8nD8cMps4EDgJ9rWEWkfhhnP48fVr0bODQJ4w9Kef480bsYOBpfWuWXpTy/eEr2RKrDoG2Tlr/57oov3jwRv9XRVSp7IFI/jLMN+LZ/Yv51SRnm5zXiizDvDXwuTsI/l/L88hEleyLVoQUoaQ2rzljjNsAvvtgKuAI4K07Cd8p9XRGpHMbZscCNwBbAzkkY/7bU17DGDcOv5t0K2FZ1OctLyZ5IhWu3TdoPy3UNa1wzcA5wEHAnsE6chK5c1xORymScXRs/ZNsKbJKE8YulvoY1bjT+fWYt/D63L5T6GvJxSvZEKt9EYAJlGMa1xi0FfAv4Bn7xxzZxEj5Q6uuISOUzzu6G79G7D7BJGM8p9TWsccsAv8LX5/xUnIT/K/U1ZElK9ipYQ0MDY8eOXa+1tfX9omMZJGsv/re1tX5q844fP37UnDlzGD16dKev9aYjN97s7x/8Y/6VK14yurW1dcNSXHPuB20N3//uG9GQIRwVBCxc8xPDzz7m+GXvHTasISvVNXpQd6/1+PHjR+G3fepUY2Njl78DNaoufwe6a+tFmd82P5j22rmHAEes2DTph9OWP+XaYQ3D1izR6/Lh6/znP86cMHRocFUQsODLR044eoONRy7b2tq6bCkuUkl6autFCLJMC+sq1axZs7JRo0YVHYYU7Jez7+XhDx7hzBVOLcn5nn5yLrfdPJN33lrITtFYttthDE1Dg5KcW7rX1NTU5X90a2ur3oxl0M1rm8cP376Op+Y+w1ETDmXDkeuV5TpvvN7KJee/zjLLNHLsCcsxYkRDWa5TKbpr60VQz14FmzdvHsOGDdu6sbGxYj4Bltna+CGEA4DnCo5l0CxcuHDUnDlz/jx69OhOX+vfzLnvzIBgEXDGQK5z9x2zVv/jfXOOf//9tk2XmTDkjoMPn/DDDTYeOWsg5xyAunutFy5cOKqpqanL+2fOnElXvwM1qi5/B7pr64Ptmrd/uv6D7z10BkGwKBqz89c3HLneS2W4zNqv/G/Bjeee/tqsYcOCJ794yDInjhjRUNMr+3tq60VQslfB2tramDlz5uOTJk16t+hYBkO7IYPnmpqaHi0ylsH05ptvjgG6fK1nLZq9IhD39//EGjcROBM4FD9XZup3r1jt2QGEPGD1+Fq/+eabY0aMGNHl/QsXLlR7r3E9tfXBYpwdjn9POAH4ERnf3GfZPd8rx7Uuu3D6Vs89M4+RoxoenD1r0R4rrzKy5sfse2rrRVCyJ1LBjLNN+N0znuzrc61xI4HjgZMAB2wfJ+EfShuhiFQT4+yGwPXAOHxZlXvLcR1rXANwCjBt973Hsv1OY05baqlhNZ/oVSoleyKVbS2giT6sxM3fZA8AzsVvsfYV4GdxEi4qS4QiUvHyD44nA98BbgaOS8J4ZjmulZdWiYHt199wxAm77jHuMkBzUgukZE+ksrUAryVh/GZvHmyN2wZfFHlt4ALgkjgJC58bJCLFMc6ug+/NWwX4QhLGPy/Xtaxxa+Dr9DUBnzzm+OVGluta0ntK9kQqW6+2SbPGrYXf3mw34FpgtzgJXy1zbCJSwfItz76G7+X/NbBLEsZvlOt61rjtgVvwu/0cECfhrEEq5SQ9ULInUtm6TfascROA04CjgD8AG8RJOCh76IpI5TLOroYfSl0POAy4odR72y6W76d9AnB+/nW6po1UFiV7IpWtBUg6Hsz3lfwKcCrwCr4n7zeDHJuIVJh8e8XDgEuAB4GpSRiXbZeKfCHYj4E9ABMn4e3lupb0n5I9kQplnF0aWJEOK3Gtcdvih2pH4bc6uzZOwoWDHqCIVBTj7CTgGmAb/BaIV5erNw/AGrcKfo/bccDmGlWoXEr2RCrXVGAR0LEm3tnAI8ChcRKWfO9KEakueW/efsAVwDPAekkYu3JeM18MdjvwOL6s09vlvJ4MjJI9kco1FXguCeMPq83nc2OmAhcp0SuWs2YosHoYJ3Wx+4NUJuPsBOAHQISf1nFJEsZlmy+XvwcdDVwGfB84USMLlU/Jnkjl6mxxxsrAmE6OyyBx1gTAnvjSNu86azYO40Q1xGTQGWd3w8+XmwFslITxU+W8Xj5X+Cpgf+DgOAlvKOf1pHSU7IlUrhbgrk6OzQH+O+jRCM6aTfB1DDfF92ycq0RPBptxdiz+9+9AfFmVs5MwXlDOa1rjJgE/B5qBLeMk/Ec5ryelpWRPpALl9bGm4vevbK8FeDJOwrbBj6p+OWtWwf9R3Q9fR+wTYZy8VGhQUpeMs58BrgM+ADZPwviRcl/TGrcZPtFzwMZxEr5e7mtKaSnZE6lMqwMjWXK4tldFlqU0nDVj8XsLHw/8A9g8jJOHi41K6pFxdiS+ht0x+F69U5Mwnlvu61rjvowfur0GOD5OwrL2IEp5KNkTqUwtwCxgeifHLx/0aOqMs6YRX6vsDPyw+ReBOzRkK0Uwzm4O/BS/BdlnkjD+U7mvaY1rwieVhwFHx0l4TbmvKeWjZE+kMk0FnmhfI8saNwJYC/XslU2++GIX4CJgefww+lVhnMzv9okiZWCcHYHfIeebwE+AbyRhXPZV+Na45YDb8O8328ZJ+GC5rynlpWRPpDJ1Nly7DtBAhyLLUhrOmvXxiy+2Aq4Ezgrj5J1Cg5K6lM/Z3R8/T7QBiJIw/tVgXNsatxG+UPKr+Pl5HUcXpAop2ROpTC1Ax+3PWoD/xkk4u4B4apazphlfqPpL+D9y64ZxUtaCtCJdMc5ujf/QsQ5wIfDdJIzfH4xrW+MOwM/Nuxk/dDtvMK4r5adkT6TCGGeXAtZAizPKylmzFH547BvA08A2YZw8UGxUUq+Ms2vhazdG+O0QoySMXx2Ma1vjGvGLP47DL0a6Mk5CzU+tIUr2RCrP5PzfpzscbwEeGuRYao6zZghggbOAVvwE9CSME5WzkUFnnF0GPy/vaOCPwAZJGA/ahzpr3DL4nrwN8Nue3T9Y15bBo2RPpPK0AC8mYfze4gP5FkXr4avlSz85a7YHLgZWw8+H+l4YJ2UvXyHSkXF2GPAV/BZn0/E9er9pvyir3KxxO+EXfryGn5+nYu01SsmeSOVpYclFGBOBCWgYt1+cNZPxK2x3AH4EbB/GyRvFRiX1KMsyps09f0/gdGAUcCLwkySMB21/WWvcaPy8wEPw8wLPiJNQK85rmJI9kcozFbi/k2PzgX8NejRVzFkzEV8r7zDgV8DUME6eLTYqqVfnz710k5HBCOYw52p8snXBYJRSac8atw0Q46cwbBUn4d8G8/pSDCV7IhXEOBvge/a+3+GuFuDpOAkH7dN/NXPWjMBPND8ZeBHYIYyT3xcbldQr4+xq+AUQ+2zUsD4jG0ZueNrqJw3qh468Tuc5+EUYVwEnxUk4KKt8pXhK9kQqSzMwHq3E7RdnTQNwAB/VJ/sqcH0YJ4sKDUzqknF2HPBt/O/hQysEEz99wLB972fJnXHKyhq3CXA9fth4hzgJ9cGnzijZE6ksLfgNzv/dyfHrBz+c6uGs2YaP6pNdAHw3jBP1XMigM842AUfi5+W9A+wLpN8ccdzowYzDGjcUvwDkFOBnwNdUp7M+KdkTqSwtwJNJGH9YBiTfo3Jd1LPXKWdN+/pk1wG7hXEyKPXJRNrLp2Hsjl/0sDR+vujVSRi3AsyYMWPQYrHGTcF/QJwE7BUnYTpoF5eKo2RPpLJ0thJ3LWBoJ8frmrNmGXzPyVHk9cnCOFFCLIUwzm6E71neHD/n9pwkjGcNdhzWuCHACfg6kil+2PatwY5DKouSPZHKMhVfGqS9FuD1OAlVKgRw1nRanyyME1X8l0FnnF0JP0f0AOA2YJ0kjDtOwxgU1rgQv9J2XXzh8EQ7YQgo2ROpGP9c+MRQYG2WHK6d2smxuuOsCYB98KsaP6xPFsaJVijLoDPOTsIvvDgOeAz4VBLGhZQxyYuuH4kvGP5nYEqchIM3ZiwVT8meSIX4Q+uf18K3yY7DtXW/EtdZszl+iGwD4BLggjBO3i02KqlHxtlP4hO8fYEX8D1otw7mzhftWeNWwu+CsQW+3NCP1ZsnHSnZE6kQs7PZk4FXkjB+p8NdLcCtBYRUOGfNh/XJgBuBL4Rx8r9io5J6k6+u3Ruf5G0G/ALYCfh9gUleAByInx/4ONASJ2Ehw8dS+ZTsiVSIBSyYQocePGvceGCljsdrnbNmHO3qkwGfDOPk/woNSuqOcXYZ4HDgGGAsfrX3QUkYF7qTjTVuOeCH+ITzZOB7cRK2df8sqWdK9kQqxEIWTQYe6XB4KrAIqIstvpw1ndYn0+ILGUzG2Sn4XrwvAjPwc+GuS8K48Bp11rg98Ynef4EN4iSsi/cGGRgleyIVoo22KcC1HQ63AM/X+ibl+eKLJeqThXHSWmhgUjeMsw3ALsDXgM8AfwC+APwyCePCd2Cxxo0DLgcMcCZwfpyEah/SK0r2RCrAe9l7ABOpw5W4zpol6pOFcTKr0KCkbhhnxwAH48v5NOPnhq6XhHHFtDtr3A74D4KzgE3jJHy02Iik2ijZE6kAr7a9DtAKPN/hrhZ8YdSas/Cdt3nt3Gln4ecd3QasHcbJfwoOS+qEcTbEJ3gHA3OAK4EfJWFcMQWI8968c4Ej8B+ITouTcF6hQUlVUrInUgFmtL1GQPDczeF1Hw7LWOMa8D17ZxcXWek5a0Y3Tlz+mEXvvA1DhqwIfCqMk0Lqk0l9ybcz+wx+Pt6uwMP4BRh3LN7SrBLkWyQeAUzDz13dJk7CvxQalFQ1JXsiFeDVttcYwpCnOxxeDV88uGKGkwbCWdMIfBk4c+Hbb7VOOORIRm6w0cFDR4zQkJSUlXF2BH6xxVfxhctvAzZPwvjhQgPrIC+nsht+7uqy+Ll5P4iTcEGhgUnVU7InUgFmZK/RSONTHQ634OfovDL4EZVOvvhiR/yKxmbgrOazLvxL44RlHyo2Mql1xtkVgaPxvWRt+FWsOyZhPL3QwDphjdsQP1T7KfK5q3ESziw2KqkV/Ur2giCYDHwH2ARYEdg8y7JHgyA4B/hLlmW/LmGMIjVtRttrDa+1vc7oYKlnOtzVAjxZzdXwnTUt+CTv08BVwJlhnLzd2tq6YbGRSa0yzi6H7x3bHdgZeBr4JnBzEsZzi4ytM/kOGOfgex5vB9ZWcWQptT4ne0EQbA/8EvgHftXSqe3ubsV/ilKyJ9JLdyy4e/WFLGTlhhU769mryiFcZ80KwFn4ye8pMDmMkxeKjUpqlXF2TWAPfIK3BfAa/vduO+BPRe1y0R1r3Gj8/s4n4PfW3TJOwgcLDUpqVn969s4DkizLDgqCoJGPJ3v/BA4tSWQideLttnemjGIk+wzd8/UOd00F7i0ipv5y1ozC//H6FvAc8JkwTv5UbFRSa/KaeJvgk7s9gHXwhcfvwv/+PZKEcUXuKLFoUcZ5p8+1wCnAXPK9dau5B18qX3+SvSn47VkAOv5yzgImDCQgkXozn/mTV25YkZHBiA+PWeNGASFV0rPnrBkCHIRfObwIvwvGTWGcVOQfXKk+xtlh+JW0uwMRsDzwIL7+3N1Fb2HWGxeeNXe7ocPggw84Ez90e7lKqchg6E+y9w4wqYv71gJe7X84IvVnIYumrNCwQsfDk4EA6Di0W3GcNZ/FTyxfA9/zf2kYJxU3N0qqj3F2HH7e3R74eoyNwH34OeO/SMK4Y294RbLGTcXPXf3sZls2svIq2frHHr/aSwWHJXWkP8neXcAZQRA8BLj8WBYEwfLAN4A7ShSbSF1oo23ypIblOx5uAV6Mk/C9AkLqFWfNOsBF+D/CPwY+F8ZJVfzxlcplnF0Z33O3B7AN8C7wC3zP8W+TMH6/uOj6xhq3PH7u6iHAL1ZZreGT0V5D/4HvNBEZNP1J9k7Gz5V4AngyP3YtsDq++v+0kkQmUgeMs2OBVVboPNl7cslnFM9Zsxy+nR8O/BZoCeOkY41AkV5ZmC3kQHfYenw0/24D4D/A3fhE6a9JGC8sLsK+s8aNxM8dPBH/d/GzcRLeP2PGjDHFRib1qs/JXpZls4Mg2AK/THx7/CeUd/BbzVyfZZmKP4r03hSgbWKwXEOH4y1ARS1scNaMwO88cAr+j/FOYZzcV2xUUo2MsyM/NWqzjZdqGMXv5/zpHvzUoEeBO/ELFp6sxBW0Pcl3vTkQv8VZhq9OcUOchJq7KoXqV529LMtagevyLxHpv6kBwYtDg6Y1Fx/Iq+hPBS4vLqyPOGsaAIOfj9cEfA34aRgni4qMSypfvj3Z8sB6wPr513rAWn99/6G2ycPXYeWhK/7s3wteuioJ45eLi3TgrHGfwc9dXZN87mqchB8UG5WIpx00RIrV0kDDU/g/EItNApamAlbiOmu2wv8Bm4Kfn3dRGCcVO49QimOcbQQ+wUeJ3eJ/l8OXGHkSX0/ucuCxM5f/drDasFX/Atza1NRUtYmeNW5tfNvYGbgG2ClOwteKjUrk4/pTVLmNJUuufEyWZUP6HZFIfWlppPGPwJ7tjwEfAIVV0XfWrAlcgJ9DFQN7hnFScVtMSTGMs2Pwv6fr81FiNwUYji9o/Bi+7up1+ff/SsL4Yz3B1b6LijVuLeDr+Nqy9wHrxUlY8avnpT71p2fv6yyZ7I0HdsD3SFw2wJhE6kI+xNUyPBjWcbi2BXgqTsJBHyZ11iwNnIafa/RnYMMwTh4b7DikMuS/oyvx8aRuffyCvDZ84ezHgduAbwOPV0s5lP7Ip1hsj5+7ujO+zt8ucRJWVfFzqT/9WaBxWRd3TQuC4Hr88JOI9GwVYPTywcSOK1kHfZs0Z80w4Bh8/bJX8T2NvwrjpOomyUv38uHWMcC4br6WAdbFJ3bjgDn438nH8NthPg48VYl7zZZDvrr2QHySFwK3Ap+Mk/CRQgMT6aVSz9m7AfgZvmdARLrXAsw5cJjpOF+pBV+3ruycNQGwN37IdjR+pe2PwzipqlIX9STvbVuGJRO0sZ0c6+xrqQ6nbMXvftTx6wHgCnyC959K3X6snKxxK+M/BB0GLASuBn4QJ6E2D5CqUupk7xNAxxISItK5qcCTHbZJGwqszSD07DlrNsUvvtgYuBQ4P4yT2eW+rgzYGODNdrcXADNZMlmbDczo5Hj7+2cBc6uxzEm55EO1n8L34u2JX1jydSDR1mZSrfqzQOPrnRweit+Ieh/gpoEGJVInOhuuXRvfLstWUNlZsyq+NMQXgJuBA8I4+W+5riclNwf/ezIbmJWEsRKQErDGDQP2xSd5G+CLOn8GeCBOQiXDUtX607N3cSfH5gOvAN/DVzwXkZ61AN/v5Nj0OAnfLvXFnDVj8cO0xwGPAJuFcfL3Ul9HyisfTn2+6DhqhTVuInAkcBR+NfE1wOfjJHypyLhESqk/CzQ0TCsyQMbZEcBaLNmzV/LFGc6aJvzWZtPww3b7AXdp8YXUM2vchvgPPgZ4CTgTuL6S96MW6S8VVRYpxrr4+a0d63K14CfED1i++GI34EJ8YdszgB+EcaItDaUuWeMa8XvwHgdsBdyLryV5r7Y0k1rWq2QvCIK9+nLSLMt+3r9wROpGC/BSEsazO2yO3oJf0T4gzpoN8VMutsTvWHB2GCczB3pekWpkjRuPL358LDAB+ClwRJyEzxYamMgg6W3P3u19OGcGaAcNke610GERxs9vmb80sAIDGMZ11qwInIOvCXYHsE4YJy8OIE6RqpVvZfZV4EvAW/hSMtfESagPPlJXepvsrVbWKETqz1TgofYH/u3aJuNrnvV58r2zZjTwLeAEfLK4VRgnfy1BnCJVxRoX4odqd8cP1T4AHATcHSeh6kdKXepVspdlmcoyiJRIXhR3PeBH7Y9/8EE2GXg2TsJez6lz1gwBDsGvgp+Xf3+LFl9IvbDGNQAb4efe7Q5Mxm/jdjdwXJyE/ywuOpHKMKAFGkEQjMQvVf+YLMveGch5RWrcRPy8oY8N1y5sZUrHY91x1nwOPy9vZfzQ7ffDOFHNNal5efHxT/NRD94KwN+A6/E9eCpNI9JOf4oqB8CpwBH4BtYZzdkT6VoLvhfOtT+4aBGTgaSnJztr1sQvutgOv33TGWGcvNn9s0SqmzVuLLAzPrnbGV/M/3fA6cA9cRK+XmB4IhWtPz17x+O3jrkQ35twNrAIX6toaH5MRLrWAjydhPGH84fa2jKyjHXpXc/eFcAoYEoYJ8+VKUaRwlnjVuSj3rttgfeAXwAH48ulqCaeSC/0J9n7Mv6T1JX4xO6uLMseDYLgLCAFwhLGJ1KLlliJ+/ZbGfgpEb3ZJm194KtK9KTW5PvSTsEnd3vg5+L9Fz//7jzgL3ESthYWoEiV6k+ytyrwWJZli4IgaAXGAWRZ1hYEwVX4rWZOKVmEIrVnKn5u0Ydem9EG8A7wandPdNZMxBdILukuGyJFeW/OoiHHH/3fbfioB2914J/4BO9Q4HHtTSsyMP1J9t4Glsq/fxnYEPhDfnsCMLIEcYnUJONsEyw5XPvaq200NPDUtTf1+EetBb8X9b/KFKJI2VnjJk5df8Snl1qqgYcffP+3wGjgT8BlQBonoSpAiJRQf5K9vwKbAL8CbgKmBUGwPL4+2GHA70sXnkjNWQs/t7VDspcxZAhP9+L5LcAzYZyoXphUPGvcEPzv/Hr46Qfr598v/9Tjc+duuPFI1lp7+Hefe2beVXESqoqDSJn0dru0kVmWfZDfnAY059+fix/G3Q8YAdwHfKW0IYrUlBbgtSSMP7Z69rUZbTQNXWKf3K6eryFcqTjWuNH438/Fid16+CkLI4A38Hs+P4afwvDYJVeuOGqp0UP+DvyqqalJiZ5IGfW2Z++NIAjuwvfk3Ztl2fMAWZbNx28ofVx5whOpOUska/f9esHome9kTFwh6E3P3lTghrJEJtIL+SKKFVmyty4E2oAX8EndnfjFfI/FSfhax/O0trZuOCgBi0ivk70fAvsC+wNvBUFwK3BTlmUPli0ykdq0RLL31OOL1gkC2GSzxm5X1zprGvG7A6hnTwZFXrx4bT6e1K0PLA28Dzyef12ET/CeipPwgyXPJCJF6u12aScEQfANYBv8kK0BjgqC4GXgRuDmLMt60yshUu9agFvaH3jvvWzKMhMCttiqaW4Pz+10vp9Ib1njGoEx+Ok33X0tg19INBloAl7BJ3V/A36Qf/9inIRtgxS6iAxArxdoZFmWAfcD9wdBcAywIz7xOw44OQiCJ/HDS0mWZa+UIVaRqmacHY8f/uq4Tdq6y09q6M0pWoDXwzh5owzhSZXIFz2sxpIJ2thOjnX8WlxJYbFWYFYXXz8j77mLk/CtEv4IIjLI+rU3bpZlC/FVzH8RBMEIIAIOAM7HF75sKlmEIrVjKn63mWfbH1y0iCnLr9DrZE+9ejKKj0rvzKfrZG1GN/fNAmYDc1XDTqT29SvZ62AN/B+hKUADvg6fiCypBXguCeP5iw/kk90nLz8p6O3ze7PDhtS2OcDywOw4CecVHYyIVL5+JXtBEKyKH8LdDz+n4wP8VmlfAe4tVXAiNaaznrmVgTF96Nm7rdRBSXXJe+JeLzoOEakevU72giBYDvgCPsHbFD8c9Vv80O1d7erwiUjnWoC7Ojk2Z9z4YHR3T3TWjANWQsO4IiLSR73qTgiC4Lf41ViX4ZO8Y4EVsizbNcuym5ToiXTPONuAn+rQcRi2paGBZxsaehzG7XS+n4iISE9627O3PHAavrbey2WMR6RWrYafWN+xZ66lYQhPAZ/s4fktwPNhnGiOloiI9Elv6+y1lDsQkRrXgl8B2bEs0dSmJq7p5fM1hCsiIn3Wq2FcERmwFuCJJIw/LHNhjRsOfGLUqKC3e+JqJa6IiPSZkj2RwdFZz9y6QMO6U4c8090TnTUN+Dl76tkTEZE+U7InMjg6S/ZagP/uuOvQd3t47qp0Pt9PRESkR0r2RMrMOLsUvvh4Z8leb4ZmW/C7HfyvxKGJiEgd6HOyFwTBtUEQrNbFfasEQXDtwMMSqSmTgQB4usPx3i66aAGeCONE21qJiEif9adnzwLLdnHfBOBL/Y5GpDZNBV5Mwvi9To73OtkreVQiIlIX+juM21UPw5pob1yRjpZI1qxxE4HlOh7v7fNFRER6q1d19oIgOAo4Kr+ZATcFQTC3w8OG4yeSa+/O0ho9Y8aMomMYFOPGjRs1ZMgQFi1aNOrNN98cU3Q8pdJAwwZNNP5lxowZH/5M45cONpv5Tjb/iK8Oew1YvFXaEq916wN/HAmEwbLLvdj++dWuVl/rHowGelqMo/Ze27ps67Wqjl/nntp6l5qbm6+fPn36QSWMp9c7aMwA/pF/PwV4Hnizw2MW4Ldy+klpQpNcxyK8NWvWrFmLv/1zgWGUVJZlDGMYXxi655bASYuPb7ZlI48/upBVVh3yTruHL/FaN6y6OgDDj/7a78oe7CCqxde6l3raF0/tvT7oda59Pe6B2dzcfF0Xd5nm5ub5wH+AH02fPv2tgQbT2x007gbuBgiCAOCsLMv+PdCLS6+sCMwpOojBMG7cuPWGDBny50WLFm09a9asx4uOpxSuXXDDpLnMffaBhX/boKVxyodt5r5ftV4NtAFH4z8FvkInr/X8n15zIEFwQjBs+PqDGHbZ1eJr3Quje36I2nuN67Kt16o6fp1749Uujmf4DrVNge2BTw80oN727H0UQZYdPNCLSp/MmTRpUr+7g6tJa2vr+wANDQ3v18rP/LR7dkvggxfb/vPEpEmT2hYfX7jQrQP8bNKkSe+2G85Z4rV2H7y/FvB4rfx/LFaLr3VPejlsp/Zew7pr67Wqzl/nbk2fPv2Uzo43Nzcfu/i+5ubmWaWIqc/JXm9Kq2RZdkj/whGpOVOBp5Iw/jDRs8Y14XfP6O3ijHob/hARqWftq5rcWooT9jnZAzbo5Nh4YCXgLWD6gCISqS2draRdExjayfGPcdYE+fOvKE9oIiJSaaZPn35nu+8PL8U5+zOM21myRxAE6wA3AycMNCiRGtIC/KiTY6/HSfhGD8+dBCxN73bZEBER6VTJtkvLsuxZ4ALg0lKdU6SaGWeHAWvT+TZpvR3CnQu8WOLQRESkjpR6b9zZQFjic4pUq7Xxvecde+Z6m+xNBZ4K42RRqQMTEZH60Z8FGkt3cngosA5wLvDUQIMSqREtwCtJGL/TyfHeFB/XzhkiIjJg/Vmg8Radb5cWAP8D9hhIQCI1pIUOvXrWuMWLmXo7jHtNGeISEZE60p9k7xCWTPbm4QtFPpxl2cIBRyVSG6YCj3U4NgVYhN9tpkvOmsW95erZExEpmLNmPDArjJPOOrsqXn9W48ZliEOkFrUA13dy7Pk4Cef18Nyu5vuJiMggctYsDzwAfBe4uuBw+qU/PXsABEGwFvBJYAX8lh+PZFn2fKkCE6lmxtll8W1jICtxZ4Rx8napYxMRkd5x1iwD3Ae8Dvys4HD6rT8LNJbC1w3bF7+adx4wHGgLguA24LAsy94raZQi1Wcq0Ap0/ADUAqS9eL4WZ4iIFMhZMwb4NbAA2CWMk/cLDqnf+lN65XJgV+AwYGyWZSOBscDhwC75/SL1rgV4Jgnj1sUHrHEN+CSwt2VXlOyJiBTAWTMSuAcYBXwujJPZBYc0IP1J9vYGTsyy7Losy+YAZFk2J8uya4GTgL1KGaBIleqsZ241/BtHb+bhqWdPRKQAzpphwB3AisD2YZy8VXBIA9afZG8e8J8u7vs3fuhKpN5NZcmkbiq+8Pj/unuis2YCfqs0JXsiIoPIWdMI3IR/v/5sGCczCg6pJPqT7F0HHBUEQdD+YH776Px+kbplnB2CL7HS6eKMOAl7Wrrf1Xw/EREpE2dNA/ATYCtguzBOXio2otLpz2rcd4ANgX8FQXAP8AawHLAbMAz4SxAEX88fm2VZpr1ypd6E+EVLA1mJ+1wYJwtKHZiIiCzJWRPg1xxEwLZhnDxXcEgl1Z9k77x23x/Xyf3nt/s+A5TsSb1pwe8081onx3/by+drCFdEZBDkid55wJfwPXqPFxxSyfWnqHJ/hn5F6kkL8EQSxh8O11rjRuF7/Hq7Evf2MsUmIiIfdwrwNWDnME4eKjiWsuhz4hYEwdZ5rb3O7hsVBMHWAw9LpKp11jM3Gb9/9NPdPdFZ09V8PxERKTFnzVeBacDeYZz8oeBwyqY/vXR/BNbt4r618/tF6lkLS67EbQH+HSfhnB6euwYwAiV7IiJl5aw5BLgEOCCMk18WHU859SfZC7q5bxQwt5+xiFQ94+wYYFWWTNZ6WyS5BXgbvwWhiIiUgbNmX/xuYIeHcXJr0fGUW6/m7AVBsBmwRbtD+wdBsGWHhw0HdgeeLVFsItVoCtAGPNPheAvw5148vwV4IoyTnsqziIhIPzhrdgVuBL4exsm1RcczGHq7QONzwOn59xnw1U4e04pP9I4uQVwiVcU4GwB7ABcA/0jC+IPF91njAnwSd0UvTtXZELCIiJSAs+bT+AVw08I4+X7R8QyWXg3jZll2RpZlDflK3ADYbPHtdl/DsixbP8uyB8sbskhlMc5uDNwPJMBdwA4dHjIJWJreD+Nqvp6ISIk5azbD73d7GXBusdEMLpVeEekn4+zK+DeM/YFbgbWTMO5sK8EW4AP8doJdav39vUvh989VsiciUkLOmvWBXwM/BU6ut6kyfU72elNaJcuy3sxNEqlK+SKMk4DjgUeBLZIw7q42UwvwdJyEi7o778In/rkOfppEt+VZRESk95w1a+ML2qfAV+ot0YP+7aBxP/4PUvtVuR3/44b0NyCRSmWcbQQOBc4A3gMOBO5oXzy5C71aiZu9/94U4F9hnHzQ02NFRKRnzppVgd/hF8h9OYyTtmIjKkZ/kr0NOjk2Hr+IY2/giAFFJFJh8sUXOwMXASsAZwFXJmE8v5enaAGu6fFRra2T0RCuiEhJOGsmAb/HL3rbP4yThQWHVJj+zNnras+4+4Mg+ACf7KmwstQE4+x6wHeBbYArgbOSMH67t8+3xg0F1qE3SdyiRVOA3/QvUhERWcxZMwG4D3gFvzvGgoJDKlR/eva68yDwzRKfU2TQGWcnAWfjN8a+G1g3CeN/9eNUa+PbWbflVLIsg7a2dYEL+3ENERHJOWvGAvcC7wO7aWpM6ZO9PYB3SnxOkUFjnB2F/8DyTXxh5E8nYTyQBUctwPQ4CbvtDcxmzwIYi4ZxRUT6zVkzCvglMBTYNoyTdwsOqSL0ZzVu2snhocAngJWBbw00KJHBZpwdgu/FOxtYCBwO3JyE8UAn8/aqSHL22gzwiz5eGuD1RETqkrNmOHAnsBywdRgnvZ5yU+v607M3hiVX387Dr3a5PcuyewcclcggMs5uh5+XtxpwHnBZEsal2uO5BehqnuuH2l57FRoangmvvakuV4qJiAyEs6YJX9h+bWDLME5eKzikitKfBRrbliEOkUFnnF0Xv8L2c/gNsbdPwviNEl9mKvCznh7U9uoMaBjyVImvLSJS85w1Q4AY2AzYKoyTl4uNqPL0a85eEAQNwDL5zbezLFNvhFQN4+xEYBpwGH71a0sSxs+U+jrWuAn4rdJ6nIfX9tqr0NSkYsoiIn3grBkG3AB8Gvh0GCf9WUhX8/qU7AVBsAvwNWALYHh+eF4QBH8FLsuy7FelDU+kdIyzI/C/vyfjty7bMQnj35XxklOBVuD57h608NFHhmVvvUGw9AQleyIivZQvxvg5sC6+R+/ZgkOqWL1O9oIg+B7wFWAmfn+5xd2kKwPbAvcEQXB5lmVfK3GMIgNinG3A7197Lv53/jjg+iSMu92+rARagGfjJOy2vlPrX/60NlnGkHXWLXnvoohILXLWjMevup2An6P334JDqmi9SvaCIPgicCxwJnBRlmXvd7h/JPAN4LQgCP6eZdlNJY9UpB+Ms1vjF18srmF3cRLG73f/rJJpoTfbpM15d91g3HiG7rz77EGISUSkqjlrVsDX0VuE79F7veCQKl5ve/aOBq7JsmxaZ3dmWfYBcGYQBM3AMYCSPSmUcXZNfHIX4Sfu7p6E8YxBDqMFuK3HRy1YMCVYaeXyRyMiUuWcNavhd8Z4FV8weVaxEVWH3iZ7U4HTe/G424H9+h+OyMAYZ5cBTsN/QLkf2DAJ4x5Ln5SaNW4IMBn4To8PXrRwcsPyk8oek4hINXPWTMYneo8Bn9fOGL3X22QvA4JyBiIyEMbZYfipBqfiP/HtDvw6CeOONSEHyxrACHqzI0Zb25SG5Vcoe0AiItXKWbMp8Cvgt8CX6n2v277qbbL3JLA3/j+5O/ug7Z5kEBlnA+DzwPnAaPxK22uSMF5YaGB+CPdtfOLZJWfNRGDZholK9kREOuOs+Sx+j/KfAceGcVLuxXU1p7fJ3lXA9UEQvAJ8N5+j96EgCEYAJwCHAAeWNkSRzhlnN8MvvtgQuBQ4PwnjStkHsQV4Ik7CnnoWW4AFwYRlhw5CTCIiVcVZsyd+Z4yLgVPDOClqtKaq9SrZy7LsxiAINgPOAI4LguCPLFl6ZWngyizLbi5HoCKLGWcXb2u2L34x0H5JGFdaxfRercQFphIEzwZDhqxX7oBERKqJs+Zg4MfASWGcXFx0PNWs13X2siz7ShAE9+GL0u4KDMvvmg88iC+qfE/JIxTJGWfHAafg6+Q9DGyahPEjhQbVtRagN+2hhSFDngaU7ImI5Jw1x+O3szwijJOfFB1PtevTDhpZlqVAGgTBEHwhQ4C3sizT+LmUjXG2CTgCv8XZTMAAdxW4+KJb1rjRwGr0rmevhcamnsuziIjUAWdNgK/peyJgwji5veCQakK/9sbNkzsVMZSyyhdf7Iavl7cs/g3gB0kYV/oqrCn4Fezdbn/mrGkEJgcjRkwbjKBERCqZs6YB+D5wMLBLGCf3FRxSzehXsidSbsbZDfGLLz6Fb/znJGE8s9ioeq0F+FechD3VgFoLGNqw6upPDUJMIiIVy1nThC+AvzOwXRgnfys2otqiZE8qytsL32Haa+eeiW/wtwNrJ2H874LD6qveLs5oAd4Yts/+b5U5HhGRiuWsGYHfbWgjYOswTp4sOKSao2RPKoJxdvQKjcsf9daitxnCkJWBLZMwfrDouPqphZ5rUoLfmUZ1KUWkbjlrxgIpsBKwZRgnLxYcUk1SsieFMs424usznvnmwrfaDp9wMJuM3NCOGDri0aJj6w9rXIBP9npTJqC3PYAiIjXHWbMs8Bt8dY8twzgZ7P3L60ZD0QFI/TLO7ojf4/BC4LvnTTpjr81HfZLGoKo/g6wMjMHvOtMTJXsiUpecNSsDDwALgW2U6JVXVf9VlepknJ2K7/n6LPAD4IwkjN9qbW3dsNjISmIn4D3gpe4e5KwZh08MleyJSF1x1nwCuA94AdgjjJP3Cg6p5inZk0FjnF0eOAs/bPsLYHISxs8XG1VpWOMm4xPY7YEz4yRs6+EpU4FFwLOAtkoTkbrgrNkQP3T7ALB/GCfzCw6pLijZk7Izzo7E7518IvA8sF0Sxn8sNqrSsMZNxNf/OxT4FTA1TsJne/HUFuCFME7mzZgxQ8meiNQ8Z83W+J2F7gAOD+NkYcEh1Q0le1I2xtkG4EDgnPzQ0cANSRj31OtV8axxI4CvAycBLwI7xEn4+z6cQvP1RKRuvHHV97YELgCuAr4RxklF7oBUq5TsSVkYZz+NL4q8FnA+cEkSxj0VGa541rgG4ADgXPwCp68AP4uTsK9bBk7FD2WLiNS09x76K3P/+X/fxW95ea4SvcGnZE9Kyji7Nn517S7AT4CdkzB+rdioSsMatw0+gV0H/wn1u3ESvt/X8+RbAk3FJ4wiIjXJWTOkceLyxy588w2GrrbGxSuffs45PT9LykHJnpSEcXZZ/Ke2I/CrrNZLwrgmtgGzxq2FT2B3A64DdouT8NUBnHJVYCk0jCsiNSqvOHDTwjff2GK5477JiHWn3FZ0TPVMyZ4MiHF2OHAccArwMr4nrze7R1Q8a9wE4DTgKOCPwAZxEpYiQWsBZgP/K8G5REQqirNmXeAuYN74z+934Ih1p6QFh1T3lOxJvxhnA8AA5+Grn58AXJeEcV/nrlUca9ww/Fy8U4HpQAT8Jk7CUs0zaQGe0LwVEak1zprdgZ8B9wIHj9l+x7UKDklQsif9YJz9FHAJft7ZxcCFSRhXfVHMfKuzffALSkbhS8X8JE7CUpcHaKF3O2yIiFSFfC7yqfjRkNOA88I4yVpbW4sNTAAle9IHxtk18AsT9gKuB/ZOwviVYqMqDWvc5vjFFxvgE9kL4iR8t0yXm4qf1ygiUvWcNaPxfxM+A+wexskvCw5JOlCyJz0yzi6N/8R2LPAXYKMkjP9ZbFSlYY1bHT8UvQ9wI/CFOAnLNpfOWTMSWBMtzhCRGuCsCYG7gSHAJ8M4qYldkWqNkj3pknF2KL4Q8mnAG8DewC+SMK76uWbWuHH4BPYrwEPAJ+Mk/L9BuPRkIABqYqWyiNQvZ82OwM34rc8ODONkdsEhSReU7MkS8sUXe+KHbMcB3wF+lIRx1U++sMY14VfXng68DewLpCVcfNGTFuDfYZzMGaTriYiUlLMmAL6JrxV6HnB6GCdVvzNSLVOyJx9jnN0EP2dtE+B7wLlJGFf9p7V88UWEr5e3DL4m4NVxEg52Aqtt0kSkauVTUX6Crzv6hTBO7ig4JOkFJXsCgHF2FfyntP2AW4ADkzB+qdCgSsQatzF+1fDmwOXA2XESzioonBb8kIeISFVx1qwK3AmMATYL40TTUaqEkr06Z5wdC5wMfA34P2DzJIwfLjSoErHGrYRPYA8AbgPWiZPw30XFkw99tABXFhWDiEh/OGu2xb+P/hP4bBgn7xQbkfSFkr06ZZxtBA7HD2e+i0+Ifl4jiy9GAycBXwceAz4VJ+HfCg3KWwFYGg3jikiVyD+kHouf3nMZcHIYJ6WuPSplpmSvzuSLL3YBLgImAmcBVyZhvKDQwErAGtcIfBk4E3gf+BJw2yAuvuhJCzAXeLHoQEREeuKsGQ78AL9bkg3j5MaCQ5J+UrJXR4yz6+MLB2+FH0o8Kwnjqu+Kzxdf7Iifl9cMnA1cHifh/EIDW1IL8FQYJ1W/pZyI1DZnTTPwc/yIxKfCOHm04JBkAJTs1QHj7OIE6Ev4ybXrJmHsio2qNKxxLfgEdlvgKuCsOAnfKjSormklrohUPGfNFvhE73lg4zBO3ig4JBkgJXs1zDi7FL4W0jeAp4FtkjCuiZWg1rhJ+OHag4EUmBwn4QvFRtWjFuCaooMQEemKs+Yw/MjPD4Gvh3FS9fVVRcleTTLODgEsvjdvAXAocEsSxlVf9NIaNwqfvH4LeBb4TJyEfyo2qp45a4YC6wBPFh2LiEhH+XvUZfh5z0eGcXJtsRFJKSnZqzHG2e3xc9dWxZcd+V4SxvMKDaoErHFDgIPwCWwbcARwU5yE1ZLAfgLf3pTsiUhFcdZMBG4H1gC2CePkoYJDkhJTslcjjLOT8Une9vju9+2SMH6z2KhKwxr3Wfy8vDXwW/NcGifh3GKj6rMWYEYYJ5U6n1BE6pCzZjN8/bxX8PPzZhQckpSBkr3acRywEJiahPGzRQdTCta4dfAlYnYCfgx8Lk7C14uNqt+0OENEKkY+bHs6cCJ+LvFxYZxUWgUDKREle7XjmCSMa2Ii7T8eeX/81d9/6yp80effAi1xEj5dcFgDpWRPRCqCs6YFuB5fa3X3ME5+WXBIUmZK9mpELSR6r85oHfbP//uAu26fdTe+8PBOcRLeV3RcJdIC3FB0ECJSv5w1jfgFbmfiS6t8NoyTt4uNSgaDkj0pnDWuAdivsZGLRy01hHCtYRf/6/n5Z8VJWBPFh501E4BJaHGGiBTEWbMW8FNgLeDAME5uKTgkGURK9qRQ1rit8IsvJi+7XNMNp5yx/OHDhzekTU1NNZHo5abi51M+V3QgIlJfnDUNwDHABcAfgClhnLxabFQy2JTsSSGscWvi33z2AGJgzzMvmDQRP0+v1kwFng3jpOr3HxaR6uGsWRm4Dvgk8BXg2jBOKmWvcBlESvZkUFnjlgZOw3/S/BOwYZyEjwG0trZOLDC0ctLiDBEZNM6aAL895veAR4GpYZy8VGhQUiglezIorHHD8Aned4BX8T16v4qTsB4+ZbbgC5aKiJSVs2Z5fK3VHfBlVa4I46Rais9LmSjZk7KyxgXA3vgh29HAKcCP4yRcWGhgg8RZMwSYgu/NFBEpG2fN54Gr8dUM1g/j5PmCQ5IKoWRPysYatyl+8cXGwKXAeXESvltsVINuDWAEGsYVkTJx1iwNXA7sA5wBXBDGSV18oJbeUbInJWeNWxU4H9gXuAk4IE7C/xYaVHFagHfwQ9ciIiXlrNkJvwPG28Anwzh5rNiIpBIp2ZOSscaNww/THgc8DGwaJ+EjhQZVvKnAE1oBJyKl5KwZjd8P/cv4bSWnabsz6YqSvQrW0NDA2LFj12ttbX2/6Fi6M3vWosYrLn1jr4YGjmgYwpx1Jo845ejjlv1jY2NAa2vrhn041dqL/21trfoNQQBoWGr0Vg3Dh7/a3f/D+PHjR82ZM4fRo0dX/GtdQjX3Wvdk/Pjxo4AHurq/sbFRvwM1rlRt/a3rfrQBjY1nBEGwaNTmW315mQMPfhKYXKH/j3X5OtNNWy9CkGXqcKhUs2bNykaNGlV0GF3KsozH/zmXO5KZvPtuG7vtOZZtPzuaxsag6NAqxvRTTmDMTrsxeqttiw5FKkBTU1OXjaO1tVVvxtKttgULmHXnbcz5/b2M3nY7xu29Lw3DhhcdlnSiu7ZeBPXsVbB58+YxbNiwrRsbGyvuk/6tN76z9l/+/N7xcz/I1l92ucbkiGMnXLPulBFzBnjatYEbgQOogd0m5v/bjVz45hsPtL7y8oHAM109buHChaPmzJnz59GjR1fka10mNfVa98bChQtHNTU1dXn/zJkz0e9AbRtIW38n+dk67/35/rOytrYRoz652bSl9z+oWqbI1OXr3F1bL4KSvQrW1tbGzJkzH580aVLFrGC1xq0InAMcCNwBmIu+v+qLpTh3uy7+55qamh4txTmL9N/zztgcyOb84b6fTzzoyx909bg333xzDFBxr3U51dpr3RtvvvnmmBEjRnR5/8KFC/U7UOP609adNU3AqcC3gZ8BX1vhqONmly/K0qrX17m7tl4EJXvSK9a4pfAFOk/AlxHZKk7CvxYbVcVrAVwYJ10meiIiXXHWbAZcCawI7BXGSVpwSFKllOxJt6xxQ4BDgLOAefn3t9TJzhcDpW3SRKTPnDWrAefhy1fdAOwYxsmbxUYl1UzJnnTJGvc5/NL+lfFDt9+Pk3BesVFVlanA74oOQkSqg7NmHB+Vr3oIXzfv/woNSmqCkj1ZgjVuCj7J2w6/9c4ZcRLqU2Uf5BuRtwCXFB2LiFS2fF7ekcDp+CLsXwDuVn1OKRUle/Iha9zywJn4Ip2/BKbESVgXq6fKYCVgLBrGFZEu5B8KI+BCYAJ+q7OrwzhZUGhgUnOU7AnWuJHA1/ELMP4FbBcn4R+LjarqtQDvAS8VHIeIVCBnzUb4EZQt8PvanhPGycxio5JapWSvjlnjGoAvAufmh44BboiTsK24qGpGC/BkGCf6vxSRD7XNmsm8S877IX6o9jZgnTBO/l1wWFLjlOzVKWvctsB3gU8AFwDfjZNQJUJKpwV4suggRKQyOGtGM3ToqbS1QVvbGsCWYZw8WHRcUh+U7NUZa9wn8PNDdgV+AuwaJ+GrxUZVk6YCVxUdhIgUy1nTiC9ZdSatrXOHfuFAhqy51nbNa4R1UTxbKoOSvTphjZuAX+l1JPB7YP04CdXzVAbOmuH4HlMtzhCpY86aHfHz8lYEzh76hS/GjS3rq7KBDDolezXOGjcc+Ap+q53/4Xvy7i02qpq3DjAEDeOK1CVnzVR8kvcZ4AfAmWGcvDVjxowxxUYm9UrJXo2yxgX46uvnAyOAbwLXxUm4sNDA6kML8HIYJ7OKDkREBo+zZgV8+apDgHuAKWGcPF9sVCJK9mqSNW4L/OKL9fJ/L4yTcE6xUdUVbZMmUkecNaPw+4Z/C3ge+GwYJ/cXGpRIO0r2aog1bnV8T97ngZ8B+8RJ+EqxUdWlFuCRooMQkfJy1jQAB+G3k2wDjgJuVMklqTRK9mqENe4kfPX1B4GN4yR8tOCQ6lkLfqWziNSgfBGWwRejXw3/IfvSME5UvkoqkpK92vE8sA9wT5yE2k+xIM6aicByaBhXpObkc/KOwlc1aAR+jE/yXis0MJEeKNmrEXES3ll0DALAJsAC4IWiAxGR0nDWbAIch1/05oDvADeEcfJ+oYGJ9JKSPZEScNaMBU4GvgbcEcaJVj2LVLG8GPJe+CRvC+BX+GL094VxotETqSpK9kQGwFnTBBwOTANmAwcAPy8yJhHpP2fNMsBh+L3CxwPXAQeHcaLeeqlaSvZE+sFZE+A/5V8ITATOAq4M42RBoYGJSL84ayYDXwUOBF4HLgGuDeNkdqGBiZSAkj2RPnLWbICvX7glcAVwdhgn7xQblYj0VV46ZWf8UO12wP3A/sA9YZwsKjA0kZJSsifSS86aZnw9rYPwQ7XrhnHiio1KRPrKWTMaOBi/leRKwI3A+mGcPF5oYCJlomRPpAfOmqXwlfG/gd/vduswTv5SbFQi0lfOmtXxCd4hwPvAlcCPwjh5s9DARMpMyZ5IF5w1Q/Cf/s8C5gNfBm5RdXyR6pHPr/00fqh2N/zuNkcBt2uOrdQLJXsinXDW7ABcDKwCnAt8L4yTecVGJSK95awZCeyHT/LWAW4Htgjj5KFCAxMpgJI9kXbyFXkXA9sDP8RvaK4hHpEq4KyZAOwC7AHsAMzFt+OdwjiZXmBoIoVSsifCh9ucnQkcii+eOjWMk2eLjUpEepLPw9sdn+BtCbwFpMAXgN+pR15EyZ7UuXyo53jgJPw2SNuHcfKHYqMSka7kc/A2wid4uwNT8dsT3o3fxeZhlU0R+Tgle1KX8vpaB+Dn4zXgV+j9TH8kRCqPs2YosA2+9y4CVgQeAm4C7grj5LniohOpfEr2pO44a7bFF0X+BHABcIk2NBepLM6aMcBO+N67XYDhwO/xq+PvCePk1QLDE6kqSvakbjhrFid3uwHXArvqD4ZI5cgLl0f4BO8z+Fp4v8SXPbo3jJM5BYYnUrWU7EnNy1fonQ4cCfwR2CCMkyeKjUpEsixjdvrz1Wf/4q7FPXibAP8D7gIuAv4cxklrgSGK1AQle1KznDXD8XPxvg28AuwWxslvio1KpH7lc2VXA9ZvXHa5PQAWvvnGbcDj+AUWRwCPhXGSFRakSA1Ssic1J1+tty9wPjASv9XZtWGcLCw0MJE64qwZAUwB1gfWa/fvUsDMtvffe2HsbntBwG7L7LjrLwoLVKQOKNmTmuKs2QK/+GL9/N8LNM9HpLzyOpXr81FStz5+AVQD8CK+5+5e/JzZx4H/rfS9H24A/AOYMegBi9QZJXtSE/LCqucDnwduAPYN4+R/xUYlUlvy/aLXYsnEbiIwD3gKeAy4Ep/UPRHGybudnau1VVPxRAaLkj2pas6a8fg5eV8B/gZsEsbJP4qNSqT6OWtGAy18PLGbAowA3sAndY8B1+f/vqCpEiKVScmeVKW8yOpRwGn47ZH2BVJN7Bb5SL4gYjQwrt3X2A63O/taBlgZaMPvTvEY8HN8e3ssjJPXyh68iJSMkj2pKvniiz2AC4Hx+JIqP1R5BqkXzpphwH4smaB1lsSNBYJ2T28DZuVfs9t9Pwt4qcPt54Cnwjj5oNQ/g4gMLiV7UjWcNRvjF11sBnwPODeMk1mFBiUy+Ibgpy50TNZe7HC74/2zgPfU+y1Sf5TsScVz1qyM38N2f+BWYO0wTv5TbFQixch72tYsOg4RqR5K9qRi5XtjngQcD/wT2CKMk4eKjUpERKS6NBQdgEhHi96bM8RZcyTgAAMcBHxKiZ6IiEjfqWdPKka2cCFzn3mKt66+/Bb84ouzgSvCOJlfcGgiIiJVS8meVARnzXoNI0de1TZ/Po3jl/7bwrfe/GoYJ28XHZeIiEi1U7InhXLWTML34H2JIUP+NGnaeTQtv8J3m5qalOiJiIiUgJI9KYSzZhTwzfzrGeDTK11y1Xv4vTJFRESkRJTsyaDK99b8Er43byFwOHBzGCdtra2tGxYanIiISA1SsieDxlmzHb4o8mrAecBlYZzMLTYqERGR2qZkT8rOWbMucBHwOeDHwPZhnLxRbFQiIiL1QcmelI2zZjngDOAw4F6gJYyTZ4qNSkREpL4o2ZOSc9aMAL4GnAz8B9gxjJPfFRqUiIhInVKyJyXjrGnA7197Lv536zjg+jBOFhUamIiISB1Tsicl4azZGr/4Yl3gQuDiME7eLzYqERERUbInA+KsWROf3EVADOwexsmMQoMSERGRDynZk35x1iwDnAYcDdwPbBjGyeOFBiUiIiJLULInfeKsGQYcC5wKvArsDvw6jJOs0MBERESkU0r2pFecNQHweeB8YDR+pe01YZwsLDQwERER6ZaSPemRs2Yz/OKLDYFLgfPDOHm32KhERESkN5TsSZecNYu3NdsXuAnYL4yTl4uNSkRERPpCyZ4swVkzDjgFXyfvYWDTME4eKTQoERER6Rcle/IhZ00TcCRwOjAT+AJwtxZfiIiIVC8le7J48UWEr5c3Ab+f7dVhnCwoNDAREREZMCV7dc5ZsyF+8cWngO8D54RxMrPYqERERKRUlOzVKWfNSsA5wBeB24G1wzj5d7FRiYiISKkp2aszzprRwInACcBjwJZhnDxYaFAiIiJSNkr26oSzphE4BDgTmAtY4FYtvhAREaltSvbqgLNmR+BiYEXgbOCKME7mFRuViIiIDAYlezXMWTMVn+R9BvgBcGYYJ28VG5WIiIgMJiV7NchZszxwFn7Y9h5gShgnzxcblYiIiBRByV4NcdaMxC+8OBF4HvhsGCf3FxqUiIiIFErJXo1w1hj8kG0GHAXcGMZJW7FRiYiISNGU7NWOFfDz8i4N4+SDooMRERGRyqBkr0aEcXJp0TGIiIhI5WkoOgARERERKR8leyIiIiI1TMmeiIiISA1TsiciIiJSw5TsiYiIiNQwJXsiIiIiNUzJnoiIiEgNU7InIiIiUsOU7ImIiIjUMCV7IiIiIjWs4rdLi6JoAvAc4NI03ayLx2wDXAmsDjwNHJqm6eMDuOaxwMnAWODe/Hwz8/suAnbH70X7OnBlmqbaqkxEREQqUjX07F0EPNPVnVEULQPcDVwIjAduBtIoiob152JRFG0PnAHshk/oFgFXt3vIPGBPfCK4O3BCFEVf6M+1RERERMqtonv28h67NYGfAEd08bC98L1+1+fPuRQ4HtgO+GUURUF++0hgAvAQcHiapq90cT4LXJem6aP5+b4NPBNF0dg0TWenafqddo99OoqiFNgSuKX/P6mIiIhIeVRsz14URUOBK4BjgKybh04BHlt8I03TDHgiPw5wLHAAsAMwEXgUSPpwvn8BC4C1O4mxAdgKeKqHH0dERESkEJXcs3cS8Ls0TR+PomiDbh63FDCzw7FZwOj8+6OAE9I0fQkgiqJpwPtRFK2cpunLXZxvVjfna+8ioBWIu4lvoEbPmDGjjKevHOPGjRs1ZMgQFi1aNOrNN98cU3Q8g2jx75Ze69o2Gni3p8fod6Cmqa3Xh9609UFVkcleFEUhfjh1/V48/D38/Ln2xgJz8u9XBW6Joqit3f1twIpRFH0ROCU/9kCapjv14nyLYzwV2BXYJk3T+b2Is88mTZoUlOO8FewBIAAYOXJkwaEMqnfJf+46Uo+vdbdv/mrvdUFtvT5UVKIHFZrs4efALQ+8EEURwAhgRBRFrwFrpWna/j/yKeDwxTfyOXotwA/yQy8DR6Zpen8n13kQOLfDsafwSeaN+flCYBh+RfDia5yET0a3SdP0tf78gCIiIiKDoVLn7N2CL6Oyfv51GvBk/v2cDo/9ObBmFEVfzOf5HZcf/13+7w+Ac6IoWgMgiqLxURTt2821Y+DgKIo2iKJoKeBs4Odpms7On/8t/GKPz6ZpOn0AP6OIiIhI2QVZ1t3ah8oQRZHF985tlt9+D9gpTdMH8tvb4hdzrIHvmTssTdPH8vsa8Is8jgaa8fPv7kvT9MvdXO9Y/PDuGOC3wJfb1dnL8As2Wts95YY0TY8szU8rIiIiUjpVkeyJiIiISP9U6jCuiIiIiJSAkj0RERGRGqZkT0RERKSGKdkTERERqWFK9kRERERqmJI9ERERkRqmZE9ERESkhinZExEREalhSvZEREREapiSPREREZEapmRPREREpIYp2RMRERGpYUr2RERERGqYkj0RERGRGqZkT0RERKSGKdkTERERqWGNRQdQK6IoWhX4D/B+u8M3pGl6ZDfPOQs4EhgK3AYck6bp/H5efxzwI2AnYA5wYZqml+X3rQVcCGwODAMeB05I0/T/+nMtkVoURdGxgAWmAnemaWq6eNxQ4C58WwOYByyixO29hzY9DkiA7YEAeAPYP03TP6i9i3Svj239JmBjYBVgpzRNf1OGeMbRRVvP758CXAO0AC8Bx6Zp+oe+XEM9e6U3IU3TpfKv7t74DwUOADYFVgfWBs4cwHWvwL+xNwOfA06JomjxH6NxwK+AycAywO3Ar6MoGjWA64nUmhnA2cCPe/HYxYnTK8Ce/W3vURRNi6JoWhdP665NXwlslce7MTACuCeKouVQexfpSV/a+l+AA/Ftvd/629ajKGoC7gFSYDxwBnBn3tZ7TT17xTkYuCRN038DRFF0BnAjcGJ+e3nge8C2wALgJ8CZaZq2dTxR/ia+D7BRmqbvAk9GUfRj4BDg12ma/h34e7unXB5F0QX4Pzj/KM+PJ1Jd0jT9OUAUResDE7p53IIoiq4FvgN01h4D4Hh8L94E4CFgWTpv71fltzu29+vpok1HUfTn/L53gTPSNG2LougK4AhgnzRNr0TtXaRLfWnrwGX5Yxd1vL+Ltn54mqa9Tgx7+vuNf08YCZyf//2/JYqir+bPubK311HPXum5KIpmRFGURFG0UjePmwI81u72Y8CyURRNjKKoAZ/FO3zX8abA7sCXuzjXWkBDmqZPdTjflM4eHEXRJvjX3vX404hId5qBGzu092PxvXg7ABOBR4EN6KS9A6Pww7Ad2/vewJAu2vRawBDgsXYf/h7Dt+kl2rzau0jZdNbWkz6eo6e/31OAJzt09LS/v1eU7JXOW8AmwKr4cfX38cMqQ7p4/FLArHa3F38/Gj8ssxJwapqm89I0nQFcAuzXzblmdzg2Kz/Xx0RRtAxwA3BamqYdnyMivbO4vb8CHMXH2/tR+Lb7UpqmrcA0fHI2vN3zZ+X/DgMmsWR7v40lew1n4dv0Uvh5grM63NdIhzav9i5SVp219U2iKFq5D+fo6e93x1yh4/29omHcfoqi6ADgh/nN/6ZpOpmP5vG8FUXR0fiJlmsCz3VyiveAse1uL/5+DrAh/lP/zCiKFt/fAPwvv/bT+B4A8EM3zwBjOpx/bH6u9jGPBe4FfpOm6YW9+kFFpMv2nrfPd4H27X1V/FBLx2RtDeB3URQ9wUft93B8224C2qIoWohPHBvzr/btfQjwDv69YxhLvn8spF2bV3sXKbtVWbKttwErAi/nbX1x4jccIIqir+W3/5Km6a749tzd3++OuULH+3tFyV4/pWl6I37OTVey/Cvo4v6ngPWBv+a31wfeTNP09SiKXgZeSdN01S6uPbn97XzMP4uiaHKapk+3O99T7R6z+I3/kTRNj+smbhHpoI/t/WXgyDRN7198ZxRFfyV/v03TtCWKou3wq/yuwv9h2K59e8/b9Dt5m56cHzsb+ATwAv4PygZRFDXkwzvr58eeyh+r9i5Sfku09fbSNG1Z/P3ixRlpmk7r8LAX6P7v91PAie3a+uL7b+5LoEGWZX15vHQhiqJN8Z/wn8dn6RcCnwJa0jTtbGLnYfjFGNvju3DvAv6WpumJ+VDQQ/h5PJcAc/G9ApPSNP1TF9e/ET//50B8L8DvgIPTNP11FEVj8G/8zwJfTtNUL7pIB1EULe5NOxU/j+YgYFE+PNPxsVviP1mnfNSON8NP4TgW2Bc4KE3TF6MoGg+cD3yWDu0d37YDYGeWbO9X4Xv5OmvTN+Hn8V6AX6n3B3xJl9XwQ7xq7yJd6GNbH4Zvo8/j2/Z9wIJ8YdRxLNnWt0/T9NZOzjMNOk32evr73YRPCH8IXApE+DIsa6Zp+kZvf2bN2Sud1YFf4v8APAcsDey6ONGLouiAfDhmsWvwEzkfwdfn+xdwGkD+nN3wQ0L/AmYCtwIrdHP9Y4BW4FX8L+P5aZr+Or9vT/wfoi8Ac6Ioei//2mqgP7RIDTkVn2h9G7/SbS55aYZO2sud+EnSK+M/YR8CnJW33cvxiyGeiaLoXXydu0a6aO/4HsHO2vvNdN2mj8aXhDgdPyl8PhDlb/5q7yLd60tbfz6/f2X8B7K5wNb5fZfj2/Uv2rX1z/Ujni7/fucJaIRv17PwJdr26kuiB+rZExEREalp6tkTERERqWFK9kRERERqmJI9ERERkRqmZE9ERESkhinZExEREalhSvZEREREapiSPREREZEapmRPREREpIYp2RORqhIEwbQgCN4rOIZxeRzr9vC4vYMgyIIg2LKL+5cOgmBBEARn9vK6cRAET/X8SBGRjyjZExHpu3H4rcq6TfbwWyi+C+zXxf2fB5qAG0sWmYhIB0r2RETKJMuyecAdwD5BEDR28pD9gUezLHt+cCMTkXqiZE9EqloQBKvmQ6VfDILgiiAIZgZB8GoQBBe3T7AWD/8GQbBJEAR/D4JgXhAEzwZBsGuH870UBMEVHY7tkV9j1SAIVgX+k991W348y4935iZgWWC7DudsBrYi79ULguCEIAgeCYJgdhAEbwRB8IsgCNbq4WfvdEg7CIJZQRBM63BslyAIHg6CYG4QBG8GQfCDIAhGdXd+EakNSvZEpFacA7QB+wJXAycAh3Z4TBNwC/BTYC/AAXcGQTC1D9d5NX8uwCnA5vnXq108/g/Aa/hevPZM/m+S/7sicAWwex53A/BgEARL9yG2TgVB8HkgBZ4E9gS+lf8MPxnouUWk8nU2rCAiUo0ezrLsq/n39wVB8Gn8nLir2z1mKHB2lmXXAgRBcC/wL3zS1tW8uo/Jsmx+EAT/zG/+K8uyh3p4fFsQBAnw5SAIhudDu+TXuz/Lshn5445f/JwgCIYA9wFv5D/Dj3oTW2eCIAiAi4Fbsiw7tN3xV4FfBUFwVpZlT/f3/CJS+dSzJyK14rcdbj+D7y3r6M7F32RZtgi4C9i0fGEBfih3NLArQBAEawIb0W5hRhAEmwVBcF8QBG8DC4EPgKWAbodye2EtYBXg1iAIGhd/AX/C94RuPMDzi0iFU7InIrViVofbC4DhHY61Zlk2s8Ox14EVyhUUQJZlj+B7EBcP5e4PzMcv3iAIgpXxyeoQ4AjgU8Am+J69jj9DX03I/70TaG339UF+vZUGeH4RqXAaxhWRetIUBMH4DgnfRD4+324efri3vfEluPZNwElBEIzFD+H+Msuy2fl9O+J78fbKsmwWQN771tN8vXn4eYgfCoKgKT/XYu/k/x4LPNzJOWb04WcQkSqknj0RqTd7Lv4mnxu3Bx9Pgl4B1unwnB063F6Q/9uXXrebgGHA2cAn+HhtvRFAhu9xW2xfev5A/gowNAiCNdod+wy+x26x5/LHrZ5l2f918qVkT6TGqWdPROrJAuDUIAiG48unHI0fxtyj3WNuB34QBMHpwIPAzvjVtu29hh823i8Igv/gh2SfyLJsAV3IsuyFIAj+ARwDzMYXXF7sD/m/1wVB8ENgMn418awefp5fA+8DPw6C4AL8HMXj8D1+i6+bBUHwdeCmvNTKL/PnrALsApySZdkLPVxHRKqYevZEpJ604odQD8EvzFgT2DvLsifaPeYa/OrVo4Db8L1uJ7c/SZZlbcDBwGrA74FHgEm9uP6NQADckWXZ/HbnexKw+EUbv8hj/Dw+KexSlmVvA3sDy+U/z6HAQfjks/3jbsMnrWsDN+PLsJwAvISfsygiNSzIsqzoGEREyi4vMvyNLMuW6umxIiK1RD17IiIiIjVMyZ6IiIhIDdMwroiIiEgNU8+eiIiISA1TsiciIiJSw5TsiYiIiNQwJXsiIiIiNUzJnoiIiEgNU7InIiIiUsOU7ImIiIjUMCV7IiIiIjVMyZ6IiIhIDft/rIMZ4Na7LfMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# TASK: Explore the model's behavior to find the implementation error\n", "(\n", " md_error\n", "\n", " >> gr.ev_sinews(df_det=\"swp\")\n", " # NOTE: No need to edit; use this to visualize your results\n", " >> gr.pt_auto()\n", ")" ] }, { "cell_type": "markdown", "id": "abda48a5", "metadata": {}, "source": [ "*Observations*\n", "\n", "- Do there appear to be any \"jumps\" in the output? Which variable seems to cause the jump?\n", " - Yes, there's a jump in `x` around the middle of its domain.\n", "- What is the error in the implementation?\n", " - The sign of `x` in the second part of the piecewise function is wrong; it should be negative.\n", "" ] }, { "cell_type": "markdown", "id": "472527f0", "metadata": {}, "source": [ "# Payoff: Rapid model exploration\n", "\n", "One of the big payoffs from these model building tools is the ability to rapidly explore models. Since a grama model includes a lot of information (functions and bounds), the tools for evaluating and visualizing models are extremely simple.\n", "\n", "For instance, we can re-build the model to fix the sign error on `x`, and quickly construct a sinew plot to verify that we've fixed the issue:\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "7ac6d63e", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calling plot_sinew_outputs....\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NOTE: No need to edit; this fixes the model\n", "(\n", " # Build the model\n", " gr.Model(\"Fixed model\")\n", " >> gr.cp_vec_function(\n", " fun=lambda df: gr.df_make(\n", " f=(df.x + df.y**2) * (df.x < 0.5)\n", " +(1 - df.x + df.y**2) * (df.x >= 0.5)\n", " ),\n", " var=[\"x\", \"y\"],\n", " out=[\"f\"],\n", " )\n", " >> gr.cp_bounds(x=(0, 1), y=(0, 1))\n", " \n", " # Evaluate\n", " >> gr.ev_sinews(df_det=\"swp\")\n", " \n", " # Plot\n", " >> gr.pt_auto()\n", ")" ] }, { "cell_type": "markdown", "id": "50ce52a3", "metadata": {}, "source": [ "We'll see in the next grama exercise how to generate and visualize contour data. Once we've implemented a model, the syntax for generating a contour plot is quite simple:\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "bba7b0ae", "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calling plot_contour....\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NOTE: No need to edit; this generates a contour plot\n", "(\n", " # Select the model\n", " md_error\n", " # Evaluate\n", " >> gr.ev_contour(\n", " var=[\"x\", \"y\"],\n", " out=[\"f\"],\n", " )\n", " # Plot\n", " >> gr.pt_auto()\n", ")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" } }, "nbformat": 4, "nbformat_minor": 5 }