Optimization Example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f53bb980-f8ef-4674-9725-68f660dd6fc6",
   "metadata": {},
   "source": [
    "# Sherpa and the Terrible, Horrible, No Good, Very Bad Optimizer\n",
    "\n",
    "Sherpa comes with a set of statistics and optimisers, but it is possible to write your own. For an optimiser, we need to be able to\n",
    "write a function that matches the following signature (note that this is not the actual signature, since we allow the arrays to be sent in as sequences, for instance):\n",
    "\n",
    "    fcn: Callable[[np.ndarray], tuple[float, np.ndarray]]\n",
    "    x0: np.ndarray\n",
    "    xmin: np.ndarray\n",
    "    xmax: np.ndarray\n",
    "\n",
    "The `fcn` argument represents the \"statistic\" value - given an array of values it returns the statistic value and a \"per-data-bin\" statistic value. We don't need to worry about how it is created: the `sherpa.fit.Fit` class constructs the routine given the data and model and we just\n",
    "need to call it. The `x0`, `xmin`, and `xmax` arguments give the initial starting values and their limits (that is, these three arrays are 1D and have the same size). You can provide extra arguments - if your optimiser has optional or tweakable behaviour - as keyword arguments.\n",
    "\n",
    "The retturn value is the tuple\n",
    "\n",
    "    (bool, np.ndarray, float, str, dict[str, Any])\n",
    "\n",
    "where the first value indicates that the optimization converted (or succeeded), the second is the best-fit values, the third\n",
    "is the best-fit statistic, the fourth a string that may be sent to the user, and the fifth is a dictionary that can be used\n",
    "to send back interesting information.\n",
    "\n",
    "One thing to note is that the optimizer does not care about the `Data` or `Model` classes; this is \"hidden away\" in the `fcn` parameter, and all it cares about is the list of parameter values (here `x0`) along with their limits (`xmin` and `xmax`). This lets you use these optimizing functions (or classes) for other cases, such as [function optimization](https://sherpa.readthedocs.io/en/4.16.1/extra/optimize_function.html).\n",
    "\n",
    "## How bad an optimizer can you think of?\n",
    "\n",
    "For this example, I've decided to try an optimizer which, for each iteration\n",
    "\n",
    "- takes the parameter values and adds {-1, 0, 1} to each of them\n",
    "- calculates the statistic\n",
    "- if there's no fit (i.e. lower statistic) then exit\n",
    "- otherwise start from the new best-fit location\n",
    "\n",
    "This really is only useful as an example!\n",
    "\n",
    "Let's start by importing a few useful symbols from Sherpa and NumPy, and ceck what version of Sherpa we are using (as hopefully some things here wil be improved):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ea2ead0b-1caf-470c-a4b1-3e5e8f4cf578",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any, Callable\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from sherpa.optmethods.optfcts import FUNC_MAX\n",
    "\n",
    "# These (or something like then) will hopefully be added to `optfcts` but for 4.16.1\n",
    "# we define them here. Technically Sherpa can accept Sequence[float] but let's just\n",
    "# think about ndarrays.\n",
    "#\n",
    "OptReturn = tuple[bool,            # did the optimiser succeed\n",
    "                  np.ndarray,      # best-values\n",
    "                  float,           # final statistic value\n",
    "                  str,             # message\n",
    "                  dict[str, Any]]  # information to pass back\n",
    "\n",
    "# The routine sent to the optimizer is sent the current valus and returns\n",
    "# the statistic value (the thing we want to minimize) and an array of\n",
    "# per-bin statistic values (which we are going to ignore).\n",
    "#\n",
    "StatCallback = Callable[[np.ndarray], tuple[float, np.ndarray]]\n",
    "\n",
    "\n",
    "def _outside_limits(x: np.ndarray,\n",
    "                    xmin: np.ndarray,\n",
    "                    xmax: np.ndarray\n",
    "                    ) -> bool:\n",
    "    \"\"\"Are any x values outside the xmin/max range?\"\"\"\n",
    "    return bool(np.any(x < xmin) or np.any(x > xmax))\n",
    "\n",
    "\n",
    "class InfinitePotential:\n",
    "    \"\"\"Ensure the parameter values stay within bounds.\n",
    "\n",
    "    The idea is that if sent a value outside the parameter limits we\n",
    "    return \"infinity\" (here defined to be the maximum value we'd\n",
    "    expect rather than inf, to avoid causing problems to the\n",
    "    optimizer).\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    __slots__ = (\"func\", \"minval\", \"maxval\")\n",
    "\n",
    "    def __init__(self,\n",
    "                 func: StatCallback,\n",
    "                 minval: np.ndarray,\n",
    "                 maxval: np.ndarray) -> None:\n",
    "        self.func = func\n",
    "        self.minval = minval\n",
    "        self.maxval = maxval\n",
    "\n",
    "    def __call__(self, pars: np.ndarray) -> float:\n",
    "        if np.isnan(pars).any() or _outside_limits(pars,\n",
    "                                                   self.minval,\n",
    "                                                   self.maxval):\n",
    "            return FUNC_MAX\n",
    "\n",
    "        return self.func(pars)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5ca4efd7-fc14-45cf-afc4-3afc2bf915ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.16.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sherpa\n",
    "sherpa.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaf4147d-9c50-48a2-ad67-0f6c68499e11",
   "metadata": {},
   "source": [
    "We start with the permutation routine: given a set of parameter values, return a list of parameter values where we have\n",
    "permuted each parameter by {-1, 0, 1}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "136fc984-283d-40bf-b190-3ede7d6e6e87",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "def permute_x(x: np.ndarray) -> list[np.ndarray]:\n",
    "    \"\"\"Return -1,0,+1 for each parameter.\n",
    "\n",
    "    We should really drop the all-0 version, as we already\n",
    "    know the value for this case.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    out = []\n",
    "    args = [[-1, 0, 1] for _ in x]\n",
    "    for shifts in itertools.product(*args):\n",
    "        out.append(x + np.asarray(shifts))\n",
    "\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bda29b5a-cf2b-4012-b875-2274bc5f99a3",
   "metadata": {},
   "source": [
    "We can check what happens if we were to give it `[10, 50, 3]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5b86df90-46a2-41ad-9f2f-881a4c7e0668",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([ 9, 49,  2]),\n",
       " array([ 9, 49,  3]),\n",
       " array([ 9, 49,  4]),\n",
       " array([ 9, 50,  2]),\n",
       " array([ 9, 50,  3]),\n",
       " array([ 9, 50,  4]),\n",
       " array([ 9, 51,  2]),\n",
       " array([ 9, 51,  3]),\n",
       " array([ 9, 51,  4]),\n",
       " array([10, 49,  2]),\n",
       " array([10, 49,  3]),\n",
       " array([10, 49,  4]),\n",
       " array([10, 50,  2]),\n",
       " array([10, 50,  3]),\n",
       " array([10, 50,  4]),\n",
       " array([10, 51,  2]),\n",
       " array([10, 51,  3]),\n",
       " array([10, 51,  4]),\n",
       " array([11, 49,  2]),\n",
       " array([11, 49,  3]),\n",
       " array([11, 49,  4]),\n",
       " array([11, 50,  2]),\n",
       " array([11, 50,  3]),\n",
       " array([11, 50,  4]),\n",
       " array([11, 51,  2]),\n",
       " array([11, 51,  3]),\n",
       " array([11, 51,  4])]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "permute_x([10, 50, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a89fb56b-f9da-4e9e-918a-ff84c78ec4bb",
   "metadata": {},
   "source": [
    "As mentioned, this is really not a good strategy, but let's run with it.\n",
    "\n",
    "The implementation is pretty simple:\n",
    "\n",
    "- use the `InfinitePotential` class to handle the fact that we want the optimizer to obey the bounds a user has added for the parameters without having to worry about this in the code; in this case the `cb` function we create will just return \"positive infinity\" if any parameter value exceeds the parameter limits (actually, it returns the maximum float64 value, but we can pretend it's infinite)\n",
    "- check that our starting positional is actually valid, and find the initial statistic value\n",
    "- loop until we hit our maximum number of iterations (this is an optimization-specific feature which is indicated by the fact it's a named keyword)\n",
    "  - use `permute_x` to create the proposed new positions\n",
    "  - for each of these new positions calculate the statistic value\n",
    "    - if this statistic value is lower than any we've seen, we store the parameters\n",
    "  - if there has been no improvement we can exit\n",
    "  - otherwise we replace the best-fit parameters with the stored values and repeat the loop\n",
    "- at this point we have either found our best-fit location, in which case we can send back `True`\n",
    "- otherwise we send back `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "850ff890-72e8-4e2a-bcc5-d3827df62012",
   "metadata": {},
   "outputs": [],
   "source": [
    "def opty(fcn: StatCallback,\n",
    "         x0: np.ndarray,\n",
    "         xmin: np.ndarray,\n",
    "         xmax: np.ndarray,\n",
    "         maxiter: int = 10,\n",
    "         verbose: bool = False\n",
    "         ) -> OptReturn:\n",
    "    \"\"\"Find the best location within +/-1.\n",
    "\n",
    "    This is not a real optimizer and is intended for educational\n",
    "    purposes only. Given x0, calculate all combinations of parameters\n",
    "    which are +/-1 from it and return the \"best fit\". This always\n",
    "    picks the \"best fit\" and uses that as the next iteration, choosing\n",
    "    the first such value if there is a tie. The maxiter argument is\n",
    "    used to bound the number of iterations.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Ensure that we remain bounded within xmin, xmax since this\n",
    "    # optimizer is not going to do so itself.\n",
    "    #\n",
    "    cb = InfinitePotential(fcn, xmin, xmax)\n",
    "\n",
    "    # What is our starting point?\n",
    "    #\n",
    "    # Note: the float conversion here is only to please mypy and is\n",
    "    # something to be improved in the typing rules.\n",
    "    #\n",
    "    cstat = float(cb(x0))\n",
    "    if cstat == FUNC_MAX:\n",
    "        if verbose:\n",
    "            print(\"Oops\")\n",
    "\n",
    "        return (False, x0, cstat, \"Invalid parameters\", {})\n",
    "\n",
    "    ctr = 0\n",
    "    x = np.copy(x0)\n",
    "    success = False\n",
    "    nfev = 0  # track the number of evaluations\n",
    "    store = []\n",
    "    while ctr < maxiter:\n",
    "\n",
    "        # permute values\n",
    "        xbest = None\n",
    "        for xnew in permute_x(x):\n",
    "            nstat = float(cb(xnew))\n",
    "            nfev += 1\n",
    "\n",
    "            # do we have a better fit?\n",
    "            if nstat < cstat:\n",
    "                if verbose:\n",
    "                    print(f\"- {cstat} -> {nstat} at {xnew}\")\n",
    "\n",
    "                xbest = xnew\n",
    "                cstat = nstat\n",
    "                store.append(xnew)\n",
    "\n",
    "        # If we have not found a better fit then exit.\n",
    "        #\n",
    "        if xbest is None:\n",
    "            success = True\n",
    "            break\n",
    "\n",
    "        ctr += 1\n",
    "        x = xbest\n",
    "\n",
    "    msg = \"Success\" if success else \"Hit iteration limit\"\n",
    "    return (success, x, cstat, msg, {\"nfev\": nfev, \"best-fit\": x, \"best-stat\": cstat, \"store\": store})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d745b517-7b5e-40f0-a1ca-16679c1d956e",
   "metadata": {},
   "source": [
    "We can use this to make a Sherpa optimization class (the `OptMethod` class will identify the keyword arguments to `opty` and make fields for them, as we'll see below when we change the `verbose` setting):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a43822a8-29f2-43f3-b9a7-fce5aef5d8a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sherpa.optmethods import OptMethod\n",
    "\n",
    "class Opty(OptMethod):\n",
    "    \"\"\"A Not-An-Optimizer optimizer.\n",
    "\n",
    "    You do not need to name the class the same as the optimization\n",
    "    function, but naming is hard.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, name=\"opty\"):\n",
    "        super().__init__(name=name, optfunc=opty)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f27cfc-1019-446b-a46e-abbad6f4d376",
   "metadata": {},
   "source": [
    "## How can we test this?\n",
    "\n",
    "We could just create `Data` and `Model` instances and pass them, along with a `Opty` instance, to `sherpa.fit.Fit`. However, that's a lot of effort when we can use the UI layer to do much of this for us (although, if you do want to know how, see the end of this notebook, in the \"I really want to do this with objects\" section).\n",
    "\n",
    "The only issue is that, as of Sherpa 4.16.1, there's no-way to \"register\" a new optimizer with the code, so you have to send in an optimization object directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9d0b4c7f-2eb6-4106-a715-0a86ede5f72f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: imaging routines will not be available, \n",
      "failed to import sherpa.image.ds9_backend due to \n",
      "'RuntimeErr: DS9Win unusable: Could not find ds9 on your PATH'\n"
     ]
    }
   ],
   "source": [
    "from sherpa import ui"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89c1416d-60a4-4443-bbf0-0b2c24db8411",
   "metadata": {},
   "source": [
    "For this example I am going to create a fake data set that we can fit a `Box1D` model to to calculate the best\n",
    "starting and ending point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7835b4d4-bccc-4e47-91ea-e6e1995d37cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "ui.load_arrays(1,\n",
    "               [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],\n",
    "               [0, 0, 5, 3, 4, 6, 5, 4, 3, 5, 7, 0, 8, 3, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "69e35aea-f80e-4f64-a9b1-88d5fe874d1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ui.plot_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0f6cd07-c0a1-463f-9a52-817d8b806e9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's just hide the error bars here\n",
    "ui.get_plot_prefs(\"data\")[\"yerrorbars\"] = False\n",
    "ui.get_plot_prefs(\"resid\")[\"yerrorbars\"] = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acff45ae-2cfe-4f0d-9ae5-b3c3838aec05",
   "metadata": {},
   "source": [
    "We create the model expression, where we\n",
    "\n",
    "- freeze the amplitude (as I didn't want to worry about fitting that)\n",
    "- start the box at the range `x=7-8`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "295fdd8d-ab12-4ea1-ba25-f3d28c531335",
   "metadata": {},
   "outputs": [],
   "source": [
    "mdl = ui.create_model_component(\"box1d\", \"mdl\")\n",
    "\n",
    "mdl.ampl = 5\n",
    "mdl.ampl.freeze()\n",
    "\n",
    "mdl.xlow = 7\n",
    "mdl.xhi = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f6ba3b26-cdc6-4da5-9a49-411fd04c25b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "ui.set_source(1, mdl)\n",
    "ui.set_stat(\"leastsq\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3459db4b-6a0e-47c9-9183-e07557434971",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ui.plot_fit_resid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31ee9cba-8c47-42c4-b022-4d8cdc270539",
   "metadata": {},
   "source": [
    "We then create the optimization object and change one of its parameters (the verbose setting), so that we expect to see some extra output during the fit (the Sherpa `OptMethod` class has logic to take the keyword arguments for the optimization function - in this case `opty` - and turn them into fields of the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "05d829ed-8ada-4218-b183-a1f486430c50",
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = Opty()\n",
    "opt.verbose = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7d0d3240-0b81-4d15-a959-dcfaf1d272d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name    = opty\n",
      "maxiter = 10\n",
      "verbose = True\n"
     ]
    }
   ],
   "source": [
    "print(opt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b9db50-02cb-4449-9a2c-5ad335b7fe46",
   "metadata": {},
   "source": [
    "We can then tell Sherpa to use this optimizer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5f162391-1a61-4b60-8f2e-9bbf09a43571",
   "metadata": {},
   "outputs": [],
   "source": [
    "ui.set_method(opt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bdeb1b0-0e84-4f2b-b250-ef313da3a00c",
   "metadata": {},
   "source": [
    "With this set we can see the options (i.e. the named parameters of `opty`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "36d17a07-19fb-4869-9432-ef353930aab6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'maxiter': 10, 'verbose': True}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ui.get_method_opt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc32f66-0330-4a49-82ab-29174598f60c",
   "metadata": {},
   "source": [
    "Let's check the model first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a5ca793c-bc29-49de-9065-06b1029886e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d.mdl\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   mdl.xlow     thawed            7 -3.40282e+38  3.40282e+38           \n",
      "   mdl.xhi      thawed            8 -3.40282e+38  3.40282e+38           \n",
      "   mdl.ampl     frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "print(mdl)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eac2b31c-3376-4ec4-9a10-03ef627f6de7",
   "metadata": {},
   "source": [
    "With this we can try to fit the data. The first lines (beginning ` - `) are from `opty` because `verbose` set. They indicate when we found new best-fit solutions (so we can see the low edge decrease and the high edge increase over time): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a5a672c2-f92e-4985-9991-9ef134ade220",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- 243.0 -> 223.0 at [6. 7.]\n",
      "- 223.0 -> 208.0 at [6. 8.]\n",
      "- 208.0 -> 203.0 at [6. 9.]\n",
      "- 203.0 -> 193.0 at [5. 8.]\n",
      "- 193.0 -> 188.0 at [5. 9.]\n",
      "- 188.0 -> 163.0 at [ 5. 10.]\n",
      "- 163.0 -> 158.0 at [ 4. 10.]\n",
      "- 158.0 -> 113.0 at [ 4. 11.]\n",
      "- 113.0 -> 88.0 at [ 3. 11.]\n",
      "Dataset               = 1\n",
      "Method                = opty\n",
      "Statistic             = leastsq\n",
      "Initial fit statistic = 243\n",
      "Final fit statistic   = 88 at function evaluation 45\n",
      "Data points           = 15\n",
      "Degrees of freedom    = 13\n",
      "Change in statistic   = 155\n",
      "   mdl.xlow       3           \n",
      "   mdl.xhi        11          \n"
     ]
    }
   ],
   "source": [
    "ui.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "40e664ef-6557-4df2-92a7-8228b6fc4363",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d.mdl\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   mdl.xlow     thawed            3 -3.40282e+38  3.40282e+38           \n",
      "   mdl.xhi      thawed           11 -3.40282e+38  3.40282e+38           \n",
      "   mdl.ampl     frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "print(mdl)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27532939-9ed8-4ab9-88bb-1ecbbf7235b0",
   "metadata": {},
   "source": [
    "We can display the new \"best fit\" (after first turning off the error-bar support):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6affe6ab-7a8a-48a4-949b-0cdc8b3a4be1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ui.plot_fit_resid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9fc85b-d8bd-43a9-9dbd-c4096ccb2c83",
   "metadata": {},
   "source": [
    "So, we can see that it's expanded the box to `x=3 - 11`. I had explicitly set `x=12` to have no counts so that the fit was going to stop there, rather than try to expand to include `x=13 - 14`. And it did, so hurray me!\n",
    "\n",
    "We can get at the \"extra\" information provided by `opty` via the `extra_output` field of the fit results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2b4159ef-acc9-424b-a229-28ea23ce6565",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nfev': 45,\n",
       " 'best-fit': array([ 3., 11.]),\n",
       " 'best-stat': 88.0,\n",
       " 'store': [array([6., 7.]),\n",
       "  array([6., 8.]),\n",
       "  array([6., 9.]),\n",
       "  array([5., 8.]),\n",
       "  array([5., 9.]),\n",
       "  array([ 5., 10.]),\n",
       "  array([ 4., 10.]),\n",
       "  array([ 4., 11.]),\n",
       "  array([ 3., 11.])]}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ui.get_fit_results().extra_output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93cebdb5-bd87-4e3c-b386-9af35d10c56d",
   "metadata": {},
   "source": [
    "One potential gotchya is that the fit results have used the `nfev` value we created in the dictionary. It is not required, but the screen output of the fit would be *slightly* different it it wasn't present (it would drop the \"at function evaluation xxx\" suffix when reporting the final fit statistic), and would not set the `nfev` field in the fit results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "eaac3d54-0a0f-4394-ba55-a19b4c1e115f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ui.get_fit_results().nfev"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4929c133-6a90-431c-b40f-2a14b512be63",
   "metadata": {},
   "source": [
    "## Tracking the fit positions\n",
    "\n",
    "We could store the parameter values tried out in the optimization method and return them in the dict, so they could be accessed from the `extra_output` field. The `fit` method already has a way to access this data, as it can write the parameter values it tries to a file during the fit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f4105015-52eb-452e-9a75-e0f3f44c5f7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "statfile = Path('stats.tmp')\n",
    "if statfile.exists():\n",
    "    statfile.unlink()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4dab3010-ef4a-4c57-8f53-e219deba3f2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d.mdl\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   mdl.xlow     thawed            7 -3.40282e+38  3.40282e+38           \n",
      "   mdl.xhi      thawed            8 -3.40282e+38  3.40282e+38           \n",
      "   mdl.ampl     frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "mdl.reset()\n",
    "print(mdl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "49d4cc5d-7e9d-4812-9c49-0ef711b01631",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- 243.0 -> 223.0 at [6. 7.]\n",
      "- 223.0 -> 208.0 at [6. 8.]\n",
      "- 208.0 -> 203.0 at [6. 9.]\n",
      "- 203.0 -> 193.0 at [5. 8.]\n",
      "- 193.0 -> 188.0 at [5. 9.]\n",
      "- 188.0 -> 163.0 at [ 5. 10.]\n",
      "- 163.0 -> 158.0 at [ 4. 10.]\n",
      "- 158.0 -> 113.0 at [ 4. 11.]\n",
      "- 113.0 -> 88.0 at [ 3. 11.]\n",
      "Dataset               = 1\n",
      "Method                = opty\n",
      "Statistic             = leastsq\n",
      "Initial fit statistic = 243\n",
      "Final fit statistic   = 88 at function evaluation 45\n",
      "Data points           = 15\n",
      "Degrees of freedom    = 13\n",
      "Change in statistic   = 155\n",
      "   mdl.xlow       3           \n",
      "   mdl.xhi        11          \n"
     ]
    }
   ],
   "source": [
    "# The outfile parameter does not accept a Path object in 4.16.1\n",
    "ui.fit(outfile=str(statfile))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da00205a-b708-40ab-9d35-6b46d35403a8",
   "metadata": {},
   "source": [
    "The output file can be read in as it's just an ASCII tabular dataset, with columns for the statistic value and the paraneter values. Here we use AstroPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8ea62e46-3a84-4c57-911b-9cb4868eda15",
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy.table import Table\n",
    "\n",
    "stats = Table.read(statfile, format=\"ascii\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "02756d3b-77d8-4fe2-972f-baf1f15d7caa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><i>Table length=47</i>\n",
       "<table id=\"table133640130953104\" class=\"table-striped table-bordered table-condensed\">\n",
       "<thead><tr><th>nfev</th><th>statistic</th><th>mdl.xlow</th><th>mdl.xhi</th></tr></thead>\n",
       "<thead><tr><th>float64</th><th>float64</th><th>float64</th><th>float64</th></tr></thead>\n",
       "<tr><td>0.0</td><td>243.0</td><td>7.0</td><td>8.0</td></tr>\n",
       "<tr><td>1.0</td><td>223.0</td><td>6.0</td><td>7.0</td></tr>\n",
       "<tr><td>2.0</td><td>208.0</td><td>6.0</td><td>8.0</td></tr>\n",
       "<tr><td>3.0</td><td>203.0</td><td>6.0</td><td>9.0</td></tr>\n",
       "<tr><td>4.0</td><td>258.0</td><td>7.0</td><td>7.0</td></tr>\n",
       "<tr><td>5.0</td><td>243.0</td><td>7.0</td><td>8.0</td></tr>\n",
       "<tr><td>6.0</td><td>238.0</td><td>7.0</td><td>9.0</td></tr>\n",
       "<tr><td>7.0</td><td>283.0</td><td>8.0</td><td>7.0</td></tr>\n",
       "<tr><td>8.0</td><td>268.0</td><td>8.0</td><td>8.0</td></tr>\n",
       "<tr><td>...</td><td>...</td><td>...</td><td>...</td></tr>\n",
       "<tr><td>37.0</td><td>158.0</td><td>2.0</td><td>10.0</td></tr>\n",
       "<tr><td>38.0</td><td>113.0</td><td>2.0</td><td>11.0</td></tr>\n",
       "<tr><td>39.0</td><td>138.0</td><td>2.0</td><td>12.0</td></tr>\n",
       "<tr><td>40.0</td><td>133.0</td><td>3.0</td><td>10.0</td></tr>\n",
       "<tr><td>41.0</td><td>88.0</td><td>3.0</td><td>11.0</td></tr>\n",
       "<tr><td>42.0</td><td>113.0</td><td>3.0</td><td>12.0</td></tr>\n",
       "<tr><td>43.0</td><td>158.0</td><td>4.0</td><td>10.0</td></tr>\n",
       "<tr><td>44.0</td><td>113.0</td><td>4.0</td><td>11.0</td></tr>\n",
       "<tr><td>45.0</td><td>138.0</td><td>4.0</td><td>12.0</td></tr>\n",
       "<tr><td>46.0</td><td>88.0</td><td>3.0</td><td>11.0</td></tr>\n",
       "</table></div>"
      ],
      "text/plain": [
       "<Table length=47>\n",
       "  nfev  statistic mdl.xlow mdl.xhi\n",
       "float64  float64  float64  float64\n",
       "------- --------- -------- -------\n",
       "    0.0     243.0      7.0     8.0\n",
       "    1.0     223.0      6.0     7.0\n",
       "    2.0     208.0      6.0     8.0\n",
       "    3.0     203.0      6.0     9.0\n",
       "    4.0     258.0      7.0     7.0\n",
       "    5.0     243.0      7.0     8.0\n",
       "    6.0     238.0      7.0     9.0\n",
       "    7.0     283.0      8.0     7.0\n",
       "    8.0     268.0      8.0     8.0\n",
       "    ...       ...      ...     ...\n",
       "   37.0     158.0      2.0    10.0\n",
       "   38.0     113.0      2.0    11.0\n",
       "   39.0     138.0      2.0    12.0\n",
       "   40.0     133.0      3.0    10.0\n",
       "   41.0      88.0      3.0    11.0\n",
       "   42.0     113.0      3.0    12.0\n",
       "   43.0     158.0      4.0    10.0\n",
       "   44.0     113.0      4.0    11.0\n",
       "   45.0     138.0      4.0    12.0\n",
       "   46.0      88.0      3.0    11.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4bee25a-aaae-466b-95fa-117d255310f7",
   "metadata": {},
   "source": [
    "We can lool at how the statistic changes with the evauation number. Thanks to the way the \"optimizer\" works we do not see a monotonic\n",
    "decrease:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "44465f7d-4eb5-4b55-bbc6-88e8831427ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ui.plot_scatter(stats[\"nfev\"], stats[\"statistic\"], xlabel=\"evalation\", ylabel=\"statistic\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "930052d8-a1e4-4223-90b3-f532884d42ff",
   "metadata": {},
   "source": [
    "We can also look at the search surface and the path we take (this uses the screen output from setting the `verbose` parameter, which is accessed via the `store` element for this plot, almost like I went \"oh, that would make my life easier to have available\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "58c9daa8-a35d-4839-abc5-a2d9e5a79b7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGdCAYAAACciDANAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABS+UlEQVR4nO3deVhUZf8G8PvMsMMAgiKgqKjlvpCaomaYRuLea5lmLumbLaip769Sc0HNcCnbNMsWl8zMSnDJJXPDFVfcRTEUDBA3GEDWmfP7Y2J0AobBWQ4zc3+u61wy5zxz5h4V5svzPOc5giiKIoiIiIgqIJM6ABEREVVvLBaIiIhILxYLREREpBeLBSIiItKLxQIRERHpxWKBiIiI9GKxQERERHqxWCAiIiK9HKQO8G9qtRppaWlQKBQQBEHqOEREVI2JooicnBwEBgZCJjPf778FBQUoKioyybmcnJzg4uJiknNZSrUrFtLS0hAUFCR1DCIisiKpqamoW7euWc5dUFCA4PoeyMhUmeR8/v7+SE5OtqqCodoVCwqFAoDmH97T01PiNEREVJ0plUoEBQVpPzvMoaioCBmZKiSfqA9PhXG9F8ocNYLbXUdRURGLBWOUDj14enqyWCAiIoNYYtjaUyEzuliwVtWuWCAiIqqOVKIaKiNvvagS1aYJY2EsFoiIiAyghgg1jKsWjH2+VFgsEBERGUANNYztFzD+DNKwz8EXIiIiMhh7FoiIiAygEkWoROOGEYx9vlRYLBARERnAnucscBiCiIiI9GLPAhERkQHUEKFiz4LtKFGpEZ9wDVv3nkN8QjJKVNY5+9RQarUam346gk+jYrDqiz+Rq8yXOpJZqdVqbN93Hgu++gNLVu9F5p0cqSOZXfLfd7DtwAXsPJKIe8r7UschskulwxDGboaKjo5Ghw4doFAo4Ofnh4EDByIxMVF7/Nq1axAEodztl19+0bYr7/i6deuq9N6r3LMQFxeHRYsW4cSJE0hPT0dMTAwGDhwIACguLsb06dOxdetW/PXXX/Dy8kLPnj0xf/58BAYGVvWlHsmuQ5fw2Yo9uHMvT7vPx8sNE17tjme7NrNIBkvasPogvvtkB1QPFUQ/fbMXnZ9phumLh5r1xipS2HXoEuZ9sR2FxSXafT9tOo5WTQLxedRgODnaVmdZ+m0l5ny1Hacu3dDuk8tl6NutBSYP7w5nJ9t6v0T0wL59+xAZGYkOHTqgpKQE06ZNQ3h4OC5cuAB3d3cEBQUhPT1d5znLly/HokWLEBERobN/xYoV6NWrl/axt7d3lbJU+ZMkLy8Pbdq0wdKlS8scu3//Pk6ePIkZM2bg5MmT2LBhAxITE9G/f/+qvswj2XM4ETMXb9EpFADgbvZ9RH36O/48cMkiOSxly8/xWP7RNp1CodSh3Rcxa/waCVKZT3xCMmYu3qJTKJQ6m5iGMe/+IEEq87mnvI/XZv+EM5f/1tmvUqmxee85TP1sE0QrnVlNZI1Kr4YwdjPU9u3bMWrUKLRo0QJt2rTBypUrkZKSghMnTgAA5HI5/P39dbaYmBgMHjwYHh4eOufy9vbWaVfV+1JUuViIiIjABx98gOeff77MMS8vL+zcuRODBw9GkyZN0KlTJyxZsgQnTpxASkpKVV+qSlQqNT5buUdvm89X7Sn3g9VafffJDr3Hj+2/jMz0LMuEsYBFX+/Ue/yv1Ds4fua6hdKY3887TuFu9n2o1GV/uKhFEYdOX8PJi6kSJCOyT2oTbYDmBlgPb4WFhZW+fnZ2NgDAx8en3OMnTpxAQkICxowZU+ZYZGQkatasiSeffBLff/99lX/RMHsfdXZ2NgRBqLDLo7CwsMxf2qM4c+lv3LqTq7fNnXt5OHXeNn64nj2ejPz7ld9b/Ycvd1kgjfkpc/KRfqvy/xsrfj1sgTSWsXnfOajLKRRKyWUCft9/wYKJiMhUgoKC4OXlpd2io6P1tler1Zg4cSK6dOmCli1bltvmu+++Q7NmzdC5c2ed/XPmzMH69euxc+dODBo0CG+99Ra++OKLKuU164BnQUEB3nvvPQwdOrTCO0hGR0dj9uzZRr/Wnay8yhtVoV11d+P6HYPa3bn5aMVXdZNx27D3cS/bdib/ZVUykVGlFnH7nm38fyayBioTXA1R+vzU1FSdz0VnZ2e9z4uMjMS5c+dw4MCBco/n5+dj7dq1mDFjRpljD+8LCQlBXl4eFi1ahAkTJhic22w9C8XFxRg8eDBEUcSyZcsqbDd16lRkZ2drt9TUR/vNv2YNj8obAajlY1i76q5+Yz+D2vkFeps3iIUE1PIyqJ1vDXczJ7EcHy/970UuE1Db1zb+PxNZA5Vomg0APD09dTZ9xcK4ceOwZcsW7NmzB3Xr1i23za+//or79+9jxIgRlb6Pjh074saNGwYNfZQyS7FQWihcv34dO3furLBXAdBUU//+S3sUrZvWgX8tT+i7pbmfrwJtmpX/F21tmrepB3cP/ZUoAAx/q4cF0pifwsMFdfy9K203+sXOlbaxFgO6t4JMVvF/aJVaRJ+nWlgwEZF9M+WcBUOIoohx48YhJiYGu3fvRnBwcIVtv/vuO/Tv3x+1atWq9LwJCQmoUaNGpb0ZDzN5sVBaKFy5cgV//vknfH19Tf0S5ZLJBEwao/lgrKhgmDTmGcjltnMp4evv9dF7vGvP5vD1e7Tiqzqa+uZzeo83bVgbIS2CLJTG/F4Mb4vaPgrIyykYBAHo3uExtGlSR4JkRGQJkZGRWLNmDdauXQuFQoGMjAxkZGQgP193LZ2kpCTExcXhv//9b5lzbN68Gd9++y3OnTuHpKQkLFu2DB9++CHGjx9fpSxV/uTMzc1FQkICEhISAADJyclISEhASkoKiouL8cILL+D48eP48ccfoVKptG+uqKjyyXjG6tq+ERZOeR4Bfrpd1gF+Xpj/3kB0e/Ixs2ewpPABT+DtWQPh+K9r7QUB6Nm/LaYvflmiZOYR0iIIH00bBHdXpzLHnmzTAN/MHyZBKvPx8nDFN7OGoFPrBjr7nRzlGNKrHeZG9oagryuNiExKDQEqIzc1DP+eXbZsGbKzsxEWFoaAgADt9vPPP+u0+/7771G3bl2Eh4eXOYejoyOWLl2K0NBQtG3bFl9//TUWL16MWbNmVem9C2IVr5/Yu3cvunfvXmb/yJEjERUVVWE3yZ49exAWFlbp+ZVKJby8vJCdnf3IQxKiKOL85XTcupeLmt7uaPF4oN7uXGunVquxb/tZJF1Mh28tBfoO7gAnl7IfqLbk0MmrOHUuFR7uzng+vC08Fa5SRzKr9NtKJCbfhKODHG2b1IG7m+Hdh0S2zBSfGYa+xvHzteGhMK53OjdHjfYtbpo1rzlUuVgwN0v8wxMRkW1gsWAZXCuWiIjIAKVDCcaewxqxWCAiIjKAPRcLtnNpABEREZkFexaIiIgMoBYFqEXjegaMfb5UWCwQEREZgMMQRERERBVgzwIREZEBVJBBZeTv2CoTZbE0FgtEREQGEE0wZ0HknAUiIiLbxTkLRERERBVgzwIREZEBVKIMKtHIOQvV6gYLhmOxQEREZAA1BKiN7JBXwzqrBQ5DEBERkV7sWSAiIjKAPU9wZLFARERkANPMWeAwBBEREdkg9iwQEREZQDPB0cgbSXEYgoiIyHapTbDcM6+GICIiIpvEngUiIiID2PMERxYLREREBlBDZreLMrFYICIiMoBKFKAy8q6Rxj5fKpyzQERERHqxZ4GIiMgAKhNcDaHiMAQREZHtUosyqI2c4Ki20gmOHIYgIiIivdizQEREZAAOQxAREZFeahh/NYPaNFEsjsMQREREpBd7FoiIiAxgmkWZrPN3dBYLREREBjDNcs/WWSxYZ2oiIiKyGPYsEBERGUANAWoYO8HROpd7ZrFARERkAHsehmCxQEREZADTrLNgncWCdaYmIiKycdHR0ejQoQMUCgX8/PwwcOBAJCYm6rQJCwuDIAg62xtvvKHTJiUlBX369IGbmxv8/PzwzjvvoKSkpEpZ2LNARERkALUoQG3sokxVeP6+ffsQGRmJDh06oKSkBNOmTUN4eDguXLgAd3d3bbvXXnsNc+bM0T52c3PTfq1SqdCnTx/4+/vj0KFDSE9Px4gRI+Do6IgPP/zQ4CwsFoiIiAygNsEwRFXWWdi+fbvO45UrV8LPzw8nTpxAt27dtPvd3Nzg7+9f7jn++OMPXLhwAX/++Sdq166Ntm3bYu7cuXjvvfcQFRUFJycng7JwGIKIiMjClEqlzlZYWFjpc7KzswEAPj4+Ovt//PFH1KxZEy1btsTUqVNx//597bHDhw+jVatWqF27tnbfc889B6VSifPnzxuclz0LREREBjDNLao1zw8KCtLZP2vWLERFRVX8PLUaEydORJcuXdCyZUvt/pdffhn169dHYGAgzpw5g/feew+JiYnYsGEDACAjI0OnUACgfZyRkWFwbhYLREREBlBBgMrIdRJKn5+amgpPT0/tfmdnZ73Pi4yMxLlz53DgwAGd/WPHjtV+3apVKwQEBKBHjx64evUqGjVqZFTWh3EYgoiIyMI8PT11Nn3Fwrhx47Blyxbs2bMHdevW1Xvejh07AgCSkpIAAP7+/rh586ZOm9LHFc1zKA+LBSIiIgOUDkMYuxlKFEWMGzcOMTEx2L17N4KDgyt9TkJCAgAgICAAABAaGoqzZ88iMzNT22bnzp3w9PRE8+bNDc7CYQgiIiIDqAATDEMYLjIyEmvXrsXGjRuhUCi0cwy8vLzg6uqKq1evYu3atejduzd8fX1x5swZTJo0Cd26dUPr1q0BAOHh4WjevDmGDx+OhQsXIiMjA9OnT0dkZGSlQx8PY88CERFRNbRs2TJkZ2cjLCwMAQEB2u3nn38GADg5OeHPP/9EeHg4mjZtiv/9738YNGgQNm/erD2HXC7Hli1bIJfLERoaildeeQUjRozQWZfBEOxZICIiMoApr4YwhCiKeo8HBQVh3759lZ6nfv362Lp1q8GvWx4WC0RERAbgjaSIiIhIL9EEt6gWrfQW1dZZ4hAREZHFsGeBiIjIAByGICIiIr0sfdfJ6sQ6SxwiIiKyGPYsEBERGUBlgltUG/t8qbBYICIiMgCHIYiIiIgqYLM9C1l385B1Jxfevh7w9nGXOo7Z/XX2GhJ2n0PdpnXx5HNtpY5jdmmpd3A0LhG+fp7o/EwzyOVyqSOZVa6yAOdOp8DJ2QGtn2gABwfbrvNLVGqkpWcBAAIDvOEgt+33S9ZBDRnURv6ObezzpWJzxcJflzOw8rM/cPTAZUAEIADtuzyGUeOfReNmgVLHM7l9vxzColeXovB+kXafIBPQZ+yzePvL1yRMZh4XTqdgxlurkZdToLO/U1hTRH3+ikSpzCc76z6mT1yLxAtp2n1yuQxPP9sC70YNgExmnT94KlKiUuOn347i180ncC/7PgCghrcbXuzfHkOf7wA5iwaSkEoUoDJyGMHY50ulyt95cXFx6NevHwIDAyEIAmJjY3WOb9iwAeHh4fD19YUgCNrbZVrC5fN/Y9IrX+P4oSuaQgEARODkoSRMGr4cl86kWiyLJez5+QA+eOkTnUIBAES1iC1f/YE5L3wkUTLzSDybisnDl5cpFADgyN5LGPfSlxKkMp9cZQFGDPhcp1AAAJVKjd3bz2LimBUSJTMPtVrE7EWb8e2a/dpCAQDuZd3HNz/EYe7i36FW618rn4jMo8rFQl5eHtq0aYOlS5dWeLxr165YsGCB0eGqQhRFfBoVg+KiEqhVuj9Q1GoRqhIVPpkVU+mNOazJolHl/xuU2r8hHtl3cyyUxvxmjl+j93jSxTScP3XdQmnM7+MPNiE/v6jC45fO/40Duy9YMJF5HTyahH2HLqO871BRBHbvv4QjJ/6yeC6iUqUTHI3drFGVhyEiIiIQERFR4fHhw4cDAK5du/bIoR5F0sV0/JWYUeFxtVrE9auZuHz+bzRpWdeCyczj9L7zKC4s0dmnElUQodbZ98ErH2Pmz/+zZDSzyFXm486tuzr7RACOct37sX82OxbLY9+2YDLziT9wudI2P3y7H12faW6BNOYXuy0BMplQYe+BXCZg4/YEdO7QyMLJiDREE9x1UuQKjo+msLAQhYWF2sdKpfKRzpOWcsewdtfv2ESxcHxHgs5jURSxBzFl2u3dthEfec62UCrLq6VohCcaDNE+vnPLdnpSSkrUlba5c+vRvl+qo5Qbd/UOM6jUIlJu3K3wOJG5qSBAZeSNoIx9vlQkLxaio6Mxe7bxH2buHs6VNwLgZmC76q5WUE2dx4IgoIHYBNnQ/WHq6uGCx9tb/29ihQXFuHT2hs6+e3nXkX3/ps4+J2fJ/0tblLOLo9QRTEbh4Yybt/S38XCzje9fImsj+U/WqVOnYvLkydrHSqUSQUFBVT5P6w7B8FC4ILecyW+l3Dyc0baj9X9wAkCfsT3xReS3OvsaC63KtJv36/s2cyllnydmQvXQb9s7zs6DIOhW6X1f6mjpWGbToFEtXLuq/9MzLLyFhdKYX89uzXD12u0K5xUJAvBsmG0MuZB1UovGL6pkrXN0JR88cXZ2hqenp872KJycHTHsjWf0tnl5bHeb+U1MLpcjtH97vW0UPu42UygAwKCRXfUed3CQYdjr3S2Uxvze+l8vvcednBww/LWnLZTG/PqGt0YNbzfIZWV/GMtlAnx9PBDRo6UEyYg01P/MWTB2s0bWmboCA18JxYhxPSB3kEEQBDj886fcQYZhb3THoJFdpI5oUnNi30Pz0MfLPebu7YbVV5dYOJF5jX47HE/3Kv/DwtFJjuUbbWNiY6m27YMx6f2+EMr58HR1c8KS1a/BxcVJgmTm4alwxRfRQ1EnsAYAzXoSpesq1A2sgc/nDYHCw0XKiER2q8rDELm5uUhKStI+Tk5ORkJCAnx8fFCvXj3cvXsXKSkpSEvTXBuemJgIAPD394e/v7+JYpdPEAS8PLY7er/wJPZtP4M7t3LgU1OBsF6t4O3rYdbXlspnB+ch9XIaFo1aisyUW3DzdMWrc4fiqUGdpI5mFlMXDsHr7+Rg0fu/YsdZQO4gw7j3+9nU8MPDIgY8gR7Ptcaa7+Jw5tQ1ODjIEd63DcL7tpU6mlkEBdbAD0tH4+SZFJw6mwpBANq2DMITreuVGXIisjQ1BKiNnKBo7POlIohVXHhg79696N69bFfvyJEjsXLlSqxcuRKvvvpqmeOzZs1CVFRUpedXKpXw8vJCdnb2Iw9JkH0QBAF16tTBjRs3Km9MRDbJEp8Zpa/x8u6X4eRhXG9eUW4R1j6z1uo+46rcsxAWFqZ3YaNRo0Zh1KhRxmQiIiKiakTyqyGIiIisgSkmKFrrBEcWC0RERAZQw/jlmq11zoJ1ljhERERkMexZICIiMoBogqshRCvtWWCxQEREZABT3DXSbu46SUREZI/seYKjdaYmIiIii2HPAhERkQE4DEFERER62fNyzxyGICIiIr3Ys0BERGQADkMQERGRXvZcLHAYgoiIiPRizwIREZEB2LNAREREepUWC8ZuhoqOjkaHDh2gUCjg5+eHgQMHIjExUXv87t27GD9+PJo0aQJXV1fUq1cPEyZMQHZ2ts55BEEos61bt65K753FAhERUTW0b98+REZG4siRI9i5cyeKi4sRHh6OvLw8AEBaWhrS0tLw0Ucf4dy5c1i5ciW2b9+OMWPGlDnXihUrkJ6ert0GDhxYpSwchiAiIjKACOPXSRCr0Hb79u06j1euXAk/Pz+cOHEC3bp1Q8uWLfHbb79pjzdq1Ajz5s3DK6+8gpKSEjg4PPiI9/b2hr+//yPnZs8CERGRASw9DPFvpcMLPj4+ett4enrqFAoAEBkZiZo1a+LJJ5/E999/D1GsStnCngUiIiKDmHKCo1Kp1Nnv7OwMZ2fnip+nVmPixIno0qULWrZsWW6b27dvY+7cuRg7dqzO/jlz5uCZZ56Bm5sb/vjjD7z11lvIzc3FhAkTDM7NYoGIiMjCgoKCdB7PmjULUVFRFbaPjIzEuXPncODAgXKPK5VK9OnTB82bNy9znhkzZmi/DgkJQV5eHhYtWsRigYiIyNRM2bOQmpoKT09P7X59vQrjxo3Dli1bEBcXh7p165Y5npOTg169ekGhUCAmJgaOjo56M3Ts2BFz585FYWGh3td9GIsFIiIiA5iyWPD09NQpFsojiiLGjx+PmJgY7N27F8HBwWXaKJVKPPfcc3B2dsamTZvg4uJSaYaEhATUqFHD4EIBYLFARERULUVGRmLt2rXYuHEjFAoFMjIyAABeXl5wdXWFUqlEeHg47t+/jzVr1kCpVGrnQtSqVQtyuRybN2/GzZs30alTJ7i4uGDnzp348MMP8X//939VysJigYiIyACiKEA0smehKs9ftmwZACAsLExn/4oVKzBq1CicPHkS8fHxAIDGjRvrtElOTkaDBg3g6OiIpUuXYtKkSRBFEY0bN8bixYvx2muvVSk3iwUiIiIDqCEYvc5CVZ5f2eWNYWFhlbbp1asXevXqZfBrVoTrLBAREZFe7FkgIiIygD3fSIrFAhERkQEsPWehOuEwBBEREenFngUiIiIDcBiCiIiI9LLnYQgWC0RERAYQTdCzYK3FAucsEBERkV7sWSAiIjKACKCSNZAMOoc1YrFARERkADUECBZcwbE64TAEERER6cWeBSIiIgPwaggiIiLSSy0KEOx0nQUOQxAREZFe7FkgIiIygCia4GoIK70cgsUCERGRAex5zgKHIYiIiEgv9iwQEREZwJ57FlgsEBERGcCer4ZgsUBERGQAe57gyDkLREREpBd7FoiIiAyg6Vkwds6CicJYGIsFIiIiA9jzBEcOQxAREZFe7FkgIiIygPjPZuw5rBGLBSIiIgNwGIKIiIioAuxZICIiMoQdj0OwWCAiIjKECYYhYKXDECwWiIiIDGDPKzjaXLGQnVeAn+JO4bfD53A39z58PFzxfKeWGNotBDU8XKWOZ3JZyvtY8Pl2HDmRDJVKDUEAHmvoh4mv90TLpnWkjmdyuflFeGPZbzh3PQMAkJmVi87vLsHb/bripafaShvODFQqFcat3ISDideg/ueHjLODHKOebo/xvTpLG85Mlh2Kx4qjJ3GvoAAAUMPVFWOefAKvhz4pcTLzOH0vFauvHsKBzMtQiSJaeAdiWHAnPBvQAoJgnb+Fku2p8gTHuLg49OvXD4GBgRAEAbGxsTrHRVHEzJkzERAQAFdXV/Ts2RNXrlwxVV69bmblYshHP+LrHfHIzM5FiUqNzOw8fPPHUQxZtAYZ93IsksNSMm8r8eLor3Hw6FWoVGoAmqr18tVMvPXuWuw9cEnihKaVk5+Pp6ctw9nrGTrDfnmFxfjw1z2Ys26nZNnMQaVSoWvUV9h/6UGhAACFJSp8vSseY77+VbpwZjJq3W9YHHdIWygAwL38fHy07yDGrI+RMJl5bEpNwIgD32B3xkXkq4pRpC7B6bup+L8T6zHv7BaI1vprqI0qvRrC2M0aVblYyMvLQ5s2bbB06dJyjy9cuBCff/45vvrqK8THx8Pd3R3PPfccCh765jeX2et24mZWDtT/+gZTiyJuKfMwa+0fZs9gSe9E/YbCopIKj8/++Heo1WoLJjKvVxb/jBI97+e3w+eQfjfbgonM663vNyKnoKjC4/FJqdh74S8LJjKvnxPO4OC1lAqPx/11DRvOnrdgIvNKu5+FmadjIAJQiQ/+X6v/KYXXXz+GP9MvSJSOyiUKptmsUJWLhYiICHzwwQd4/vnnyxwTRRGffvoppk+fjgEDBqB169ZYvXo10tLSyvRAmNqN21k4ePEaVOryK3GVWsSRyym4nnnPrDks5fadXCSn3NbbRqVS4+fY4xZKZF5FRSpcM+DfbsrqbRZIYxmHr1yvtM28mN0WSGIZyw4drbTNkoNHLJDEMn69flzvzHgZBPyYbDvvl6ybSecsJCcnIyMjAz179tTu8/LyQseOHXH48GEMGTKkzHMKCwtRWFiofaxUKh/ptS+kZhrY7ibq+9V4pNeoTuJPJRvU7sTp6xj6H+sf6z19/e9y9xfnZePM55O1j88AWD1pqIVSWZ6icSvUG/iq9vEtZZ6EaUwrIye30jbpysrbWIuzWTe0vQjlUUPE+azy/9+TNOx5gqNJF2XKyNBMOqtdu7bO/tq1a2uP/Vt0dDS8vLy0W1BQ0CO9tqOD3LB2csPaVXcuTobVeY6OtvF+Fa4uZfa51q4nQRJp5SSd1XlsS/PfZAa8GUPaWAsnmRyVvRsHmW18/9oM0USbFZL8aoipU6di8uQHvxkqlcpHKhjaNaoDRwc5iktUFbZxkMvQ/rG6j5Szuuna6TEIQuVVat9nW1smkJk1resHAbrfZ4+9NLFMu74dmmHeK70sFcus2k39HIUP/X8+/9HkMm2aBNSyZCSzaupXC2czbupt08Lfz0JpzK+r3+M4kFnx5G+5IEM3v8ctmIioYibtWfD39wcA3Lyp+w1/8+ZN7bF/c3Z2hqenp872KDzdXPBC51YVXmokEwT8p1NLeLvbxuWTzk4O6Nyhkd42Xp6u6NKxsYUSmd/TLRpW2mbW4GctkMQyXnnqiUrbLBwWYYEkljHlmW6VtpnavfI21qJf3TbwdHStsLdEFEUMb2Sbl8daK0tfDREdHY0OHTpAoVDAz88PAwcORGJiok6bgoICREZGwtfXFx4eHhg0aFCZz+CUlBT06dMHbm5u8PPzwzvvvIOSkoonx5fHpMVCcHAw/P39sWvXLu0+pVKJ+Ph4hIaGmvKlyjV5wFMIa6n5QJHLBJ0/uzRrgP97/mmzZ7CkuVMGokE933KPuTg74KtFwyycyLw+GzsA9Wp5V3j8o1f7wMnJdrptJ/XuiicbVtwTNjGiC+rVtP75N6WerFcXk5/uUuHxd8OeQkjdQAsmMi8PRxd83WkkPB1cIQDaIQkZBMgFGeaF/ActvW1vrRSrZ8EhiH379iEyMhJHjhzBzp07UVxcjPDwcOTlPZirNGnSJGzevBm//PIL9u3bh7S0NPznP//RHlepVOjTpw+Kiopw6NAhrFq1CitXrsTMmTOrlEUQq3ghb25uLpKSkgAAISEhWLx4Mbp37w4fHx/Uq1cPCxYswPz587Fq1SoEBwdjxowZOHPmDC5cuAAXl7Ljzv+mVCrh5eWF7OzsR+plEEURx5NuYNPRC7iZlQM/Lw/0e7I5nnwsyGYXOPljz3n88Gs87t7Lg6uLI54Na45RQzrD2cB5Ddbml4NnsHTrISjvF0AuExASXAfzR/WGj4eb1NHMYvf5JHwYswe7ZowFAAz+9EcsGNoLDfx8JE5mHkm37+DD3XE4l54BAQJaBtTG+z2eRkNf23y/eSWF2HzjNA5mXkaxWo1W3nUwqH57+Lt6SR3NKhj7mVGV16i3fCZk5cyfqgp1fgFSxs55pLy3bt2Cn58f9u3bh27duiE7Oxu1atXC2rVr8cILLwAALl26hGbNmuHw4cPo1KkTtm3bhr59+yItLU07n/Crr77Ce++9h1u3bsHJycmg165ysbB371507969zP6RI0di5cqVEEURs2bNwvLly5GVlYWuXbviyy+/xOOPGzb2Zol/eCJrVFrscqEeogcsWSwEfT3LJMVC6uuzkZqaqpPX2dkZzs7Oep+blJSExx57DGfPnkXLli2xe/du9OjRA/fu3YO3t7e2Xf369TFx4kRMmjQJM2fOxKZNm5CQkKA9npycjIYNG+LkyZMICQkxKHeVf/UMCwvT+8NKEATMmTMHc+bMqeqpiYiIqi8T3nXy3xP5Z82ahaioqAqfplarMXHiRHTp0gUtW7YEoLkC0cnJSadQAHSvQMzIyCj3CsXSY4ayzX5qIiIik3t4dokx50C5PQv6REZG4ty5czhw4ICRr/9oTDrBkYiIiCr376sA9RUL48aNw5YtW7Bnzx7Urftg0rO/vz+KioqQlZWl0/7hKxD9/f3LvUKx9JihWCwQEREZwsKLMomiiHHjxiEmJga7d+9GcHCwzvF27drB0dFR5wrExMREpKSkaK9ADA0NxdmzZ5GZ+WCV4507d8LT0xPNmzc3OAuHIYiIiAxhwjkLhoiMjMTatWuxceNGKBQK7RwDLy8vuLq6wsvLC2PGjMHkyZPh4+MDT09PjB8/HqGhoejUqRMAIDw8HM2bN8fw4cOxcOFCZGRkYPr06YiMjKx06ONhLBaIiIiqoWXLlgHQXFjwsBUrVmDUqFEAgE8++QQymQyDBg1CYWEhnnvuOXz55ZfatnK5HFu2bMGbb76J0NBQuLu7Y+TIkVW+CIHFAhERkSFMcYvpKjzfkMukXVxcsHTpUixdurTCNvXr18fWrVsNft3ysFggIiIyAO86SURERFQB9iwQEREZwsITHKsTFgtERESGsPCcheqEwxBERESkF3sWiIiIDCCIms3Yc1gjFgtERESG4JwFIiIi0otzFoiIiIjKx54FIiIiQ3AYgoiIiPSy42KBwxBERESkF3sWiIiIDGHHPQssFoiIiAzBqyGIiIiIyseeBSIiIgNwBUciIiLSz47nLHAYgoiIiPRisUBERER6cRiCiIjIAAJMMGfBJEksj8UCERGRIXjpJBEREVH52LNARERkCDu+GoLFAhERkSHsuFjgMAQRERHpxZ4FIiIiA3AFRyIiItKPwxBERERE5WPPAhERkSHsuGeBxQIREZEB7HnOAochiIiISC/2LBARERnCjpd7ZrFARERkCM5ZICIiIn04Z4GIiIioAuxZICIiMoQdD0OwZ4GIiMgQ4oOhiEfdqlosxMXFoV+/fggMDIQgCIiNjdU5LghCuduiRYu0bRo0aFDm+Pz586uUg8UCERFRNZWXl4c2bdpg6dKl5R5PT0/X2b7//nsIgoBBgwbptJszZ45Ou/Hjx1cpB4chiIiIDCHBMERERAQiIiIqPO7v76/zeOPGjejevTsaNmyos1+hUJRpWxXsWSAiIjKEaKINgFKp1NkKCwuNjnfz5k38/vvvGDNmTJlj8+fPh6+vL0JCQrBo0SKUlJRU6dzsWSAiIrKwoKAgncezZs1CVFSUUedctWoVFAoF/vOf/+jsnzBhAp544gn4+Pjg0KFDmDp1KtLT07F48WKDz81igYiIyACmXGchNTUVnp6e2v3Ozs7GnRjA999/j2HDhsHFxUVn/+TJk7Vft27dGk5OTnj99dcRHR1t8OuyWCAiIrIwT09PnWLBWPv370diYiJ+/vnnStt27NgRJSUluHbtGpo0aWLQ+TlngYiIyMp99913aNeuHdq0aVNp24SEBMhkMvj5+Rl8fvYsEBERGUKCqyFyc3ORlJSkfZycnIyEhAT4+PigXr16ADSTJX/55Rd8/PHHZZ5/+PBhxMfHo3v37lAoFDh8+DAmTZqEV155BTVq1DA4B4sFIiIiA0hxb4jjx4+je/fu2sel8w9GjhyJlStXAgDWrVsHURQxdOjQMs93dnbGunXrEBUVhcLCQgQHB2PSpEk68xgMyy2K1WrxSaVSCS8vL2RnZ5t0PIfI2gmC5ta21exblkhSlvjMKH2NxlM+hNzZpfIn6KEqLEDS/GlW9xnHOQtERESkF4chiIiIDGHHN5JisUBW59zNm/jpzBlcvHULHk5O6PXYYxjQrBncnZykjmYWe68n46PDB7SPR2/egBlduyO4CpOTrMnOG5cRdWwHbubnAgD83RT4oEMvhNVpLHEy87hZkI71qWtwNfcKRKhR2zkAA+q8iBZeraWOZhYl6jyk527Czbw/oBLvQ+HUDHUVg+Hp3FzqaJWSYs5CdWGWYiEnJwczZsxATEwMMjMzERISgs8++wwdOnQwx8uRnRBFEZ8cOoSl8fGQCwJUoggBwMGUFCyJj8faF19EAxv7AJ34x+/YePmSzr4915Ox53oyFvQIx+BmrSRKZh6R+zdgW6ru+027r8TofevRp14zfNH1eYmSmcf+W7vxY8oKnX0p+dfwRdIidPTpileDX5comXnkFSfjRPooFKoyAQgAROQUnsffOT+joXckGtUYJ3VEqoBZ5iz897//xc6dO/HDDz/g7NmzCA8PR8+ePfH333+b4+XITmy+dAlL4+MBAKp/JvmVFum38/Lw6oYNUKnVEqUzvVVnTpUpFB723q4/8HeO0oKJzGvDX2fKFAoP+z3lIjZeO2fBROZ1qyCzTKHwsPi7BxB3a5cFE5mXWizBqYyxKFTd+WdP6fewCgDwV9ZSZORukyidgUx4bwhrY/JiIT8/H7/99hsWLlyIbt26oXHjxoiKikLjxo2xbNkyU78c2QlRFPHVsWMQKjiuEkWkZGdjT3KyRXOZ05LjRypt88H+vWbPYSnzTu2uvM3JPy2QxDJ+ufFjpW1+T4s1fxALuX1/D/JLbgD/FAdlyXAt+xtLRqqy0mEIYzdrZPJioaSkBCqVqsza1K6urjhw4ECZ9oWFhWXuvkX0b1kFBUi8fVtvUe4gk+Hg9esWy2Rut+/fr7TN8XTb6a27V6j7fjO/+hW3V23R2Xe7oPK/E2txNfdypW2yS7LMH8RC7uQfhKB35FuNnKKLKFHnWiwTGc7kxYJCoUBoaCjmzp2LtLQ0qFQqrFmzBocPH0Z6enqZ9tHR0fDy8tJu/74TFxHwYNjBVO1shdpG32/m5z8hb/8p5PxxWOooZmSb/3YVEWHYEKEoVu3WyRbFYQjT+uGHHyCKIurUqQNnZ2d8/vnnGDp0KGSysi83depUZGdna7fU1FRzRCIr5+PqikCFQm+bErUaIQEBFkpkfh6OlV/d0bRmLQsksQw3uSMA4N5vu5AXX/7cBA8H27niJdC1bqVt3ORuFkhiGV7ObSFCXyEgwNUhCA4yL4tlqjIWC6bVqFEj7Nu3D7m5uUhNTcXRo0dRXFyMhg0blmnr7OysvfuWqe/CRbZDJggY3a5dhXMWZIIAbxcX9H78cYvmMqdhLSu/Icz7XbpZIIllvNasE3IPJiBrQ8VzF95q0dmCicxrUN2XK20TVqunBZJYhr97BBxknqj4Y0dEPa+R2pVKqXox6wqO7u7uCAgIwL1797Bjxw4MGDDAnC9HNm5E27bo9dhjADTFQSm5IMBZLsfXAwbA2cF2lg55N7QrWtSs+K5wY0Pao3mt2hZMZF7tlAJuffkLACDo83fLHG/uXRtv2FCx0MC9IXr49ar4uFtD9K/zogUTmZdc5oq2fksgE5wgQP7QEc3HUG33CAQphkgTzkD2PMHRLD9Zd+zYAVEU0aRJEyQlJeGdd95B06ZN8eqrr5rj5chOyGUyfN63L7YkJmJNQgIu374NV0dH9G3SBCNCQhDkVY27Lx+BTCbDpsHD8MWxI1h19hSu/bM/2Nsb73R6ChGNbacXJSkpCU899RQA4K01X2K3PEd7zFnmgJGPt8OUJ3pIFc9sXgwahobujyH27/W4VZQJQIS73APP+IWjT6BtrSkBADVcOyC0ziakKn9ARt52qMUCeDg+hiDPl1HbPQKCUM3vQGDHKzia5UZS69evx9SpU3Hjxg34+Phg0KBBmDdvHrwM+GHOG0kRlc9WbyR19+5d+Pr6AgA2bdqEfv36AbDd90umZckbSTV52zQ3kkr8zPpuJGWWnoXBgwdj8ODB5jg1EdmQoqIibaHwySefaAsFIqpebGeAl4isiiiKcHZ2BgCMHTsWEydOlDYQUSV4bwgiIgtzd3cHAHTs2BFff/21xGmIDGDHcxaq+WwSIrJF3bp1Q35+PuRyOY4cqXxZayKSFnsWiMiixo0bh/379wPQzFkgshYchiAisoAlS5Zg6dKlAICCgoJyV3UlqrY4DEFEZF5bt27F+PHjAQC3b9/WTm4kouqPPQtEZHanT59Gnz59AACJiYnayyWJrIod9yywWCAis0pLS0Pbtm0BAHv37sXjNnT/DrIvwj+bseewRhyGICKzycvLQ506dQAAq1atwtNPPy1xIiJ6FOxZICKzUKlU8PDwAABMnz4dI0aMkDgRkZE4DEFEZDqiKMLhnzuADhw4EHPnzpU4EZHxeOkkEZEJNWnSBAAQFBSEmJgYidMQmYgd9yxwzgIRmdRLL72EK1euAACuX78ucRoiMgX2LBCRycyZMwfr168HABQXF2tvM01kM6y0Z8BYLBaIyCTWrl2LWbNmAQCUSqV2zgKRrbDnOQschiAiox08eBDDhg0DAKSmpkKhUEiciIhMiaU/ERnl6tWr6Nq1KwDgxIkTqFu3rsSJiMzEjic4slggokd27949NG7cGACwceNGPPHEExInIjIfDkMQEVVRUVERfHx8AACLFy9G//79JU5ERObCngUiqjJRFLV3jRw7diwmTZokcSIiC+AwBBGR4UonMHbs2BFff/21xGmILIPDEEREBnr66aeRl5cHmUyGI0eOSB2HiCyAPQtEZLDx48cjLi4OgGbRJSK7YsfDEOxZICKDLFmyBEuWLAEA5OfnQybjjw+yM6KJtiqIi4tDv379EBgYCEEQEBsbq3N81KhREARBZ+vVq5dOm7t372LYsGHw9PSEt7c3xowZg9zc3Crl4Hc7EVVq69atGD9+PADg1q1bcHFxkTgRkeWVzlkwdquKvLw8tGnTBkuXLq2wTa9evZCenq7dfvrpJ53jw4YNw/nz57Fz505s2bIFcXFxGDt2bJVycBiCiPQ6ffo0+vTpAwC4dOkSatasKXEiIvsRERGBiIgIvW2cnZ3h7+9f7rGLFy9i+/btOHbsGNq3bw8A+OKLL9C7d2989NFHCAwMNCgHexaIqEJpaWlo27YtAGDPnj3aW08T2SUTDkMolUqdrbCw8JFj7d27F35+fmjSpAnefPNN3LlzR3vs8OHD8Pb21hYKANCzZ0/IZDLEx8cb/BosFoioXHl5eahTpw4AYOXKlQgLC5M2EJHEBFE0yQYAQUFB8PLy0m7R0dGPlKlXr15YvXo1du3ahQULFmDfvn2IiIiASqUCAGRkZMDPz0/nOQ4ODvDx8UFGRobBr8NhCCIqQ6VSwcPDAwAwbdo0jBw5UuJERLYlNTUVnp6e2seli5xV1ZAhQ7Rft2rVCq1bt0ajRo2wd+9e9OjRw+icpdizQEQ6RFHU3l66f//+mDdvnsSJiKoJEw5DeHp66myPWiz8W8OGDVGzZk0kJSUBAPz9/ZGZmanTpqSkBHfv3q1wnkN5WCwQkY7SeQl16tTBxo0bJU5DVH1IcTVEVd24cQN37txBQEAAACA0NBRZWVk4ceKEts3u3buhVqvRsWNHg8/LYQgi0nrppZdw5coVAJpuUiKSVm5urraXAACSk5ORkJAAHx8f+Pj4YPbs2Rg0aBD8/f1x9epVvPvuu2jcuDGee+45AECzZs3Qq1cvvPbaa/jqq69QXFyMcePGYciQIQZfCQGwZ4GI/jFnzhysX78egGZ1RkEQJE5EVM1IsCjT8ePHERISgpCQEADA5MmTERISgpkzZ0Iul+PMmTPo378/Hn/8cYwZMwbt2rXD/v37dYY1fvzxRzRt2hQ9evRA79690bVrVyxfvrxKOdizQERYu3YtZs2aBUBzSVfpnAUiekCKG0mFhYVBFCt+0o4dOyo9h4+PD9auXVu1F/4X9iwQ2bmDBw9i2LBhAICUlBTtHSWJiErx1wciO3b16lV07doVgKa7MygoSOJERNWYHd9IisUCkZ26d+8eGjduDACIjY1Fu3btJE5EVL1JMQxRXbBYILJDRUVF8PHxAQB8/PHHGDBggMSJiKyAHfcscM4CkZ0RRVE7U/q1117D5MmTJU5ERNUdexaI7EzpBMYOHTpU+fIpIntnrcMIxmKxQGRHwsLCkJeXB0EQcPToUanjEBnnn5slWYwoajZjz2GFOAxBZCcmTJiAffv2AdCsDU9k1VatArp2BR66HTOZD3sWiOzAl19+iS+++AIAkJ+fD5mMvyeQFdu+HRgzRtOzsGaNxV7Wnq+G4E8MIhu3bds2REZGAgBu3boFFxcXiRMRGeHYMeCFFzSFwrBhwPjxlnttCZZ7ri5YLBDZsDNnzqB3794AgEuXLqFmzZoSJyIyQlIS0KcPkJcHPPss8P33AHvJLILDEEQ2Kj09HW3atAEA7NmzR3vraSKrlJkJ9OoF3LoFhIQAv/0GODkBBQUWiyCoNZux57BGLBaIbFBeXp729rMrV65EWFiYtIGIjPXqq8DVq0BwMLB1KyDFPUzseFEmFgtENkalUsHDwwMAMG3aNIwcOVLiREQm8NlnmisfVq8G/P2lTmN3WCwQ2RBRFLW3l+7fvz/mzZsncSIiE2ncGDh8GBAEySLwaggisgnNmjUDANSpUwcbN26UOA2RkebM0VwmWUrCQgHAg0WZjN2sEHsWiGzE0KFDkZiYCABITU2VOA2RkZYsAWbNAhwcgEuXgEaNpE7EngUism5z587FunXrAADFxcUQpP4NjMgYv/0GTJig+XrmzGpRKNg79iwQWbmffvoJM2fOBAAolUrtnAUiq7R/v2axJVEEXn8dmD5d6kQP8GoIIrJGBw8exMsvvwwASElJ0d5RksgqnT8P9O8PFBYCAwYAS5dKP0/hIRyGICKrc/XqVXTt2hUAcPz4cQQFBUmciMgIGRmaRZeysoDOnYGffgLkcqlT0T/Ys0BUzRWUlGB78mXt40NpKWjq4oHGjRsDAGJjY9GuXTup4plcQUkJll6K0z5efG43xjXvBieZbf64UqlUiE1bjos5xyGKIgJc6mNI0ER4OHlJHc1s8goTkJW/HWp1PlydmqCG2wDIa9bUFAsHDgCbNwOurlLHLMuOb1Ft8u8+lUqFqKgorFmzBhkZGQgMDMSoUaMwffp0TroiqqIjaal4Y2cssgofLGk7NPZHpEROAwB8/PHHGDBggFTxTO6Pvy/h7fhfoXroB+pXiQfxzeVDWNrpRTwTaFtLVl/MPoFV16N19iXlncUHl8agi29v9KszWqJk5lGizsZft15HbuEhAA4QAIgowY17c1Df9xPUWL5c07NQo4bEScvHYQgTWrBgAZYtW4YlS5bg4sWLWLBgARYuXKi9PS4RGeZq1l2M3PYrlEWFOvtLC4WAZ57CuLffliKaWVxV3sL4I7/oFAqlVKKINw+vx7WcOxIkM4/couwyhcLDDt7ZiuN3d1swkXmJooi/br2G3ML4f/aUQFQVw3dtLtTF95F8+03kFh2vtoWCvTN5sXDo0CEMGDAAffr0QYMGDfDCCy8gPDwcR48eNfVLEdm0b88cQ4laBXU5H55O9evC6aV+2HHtigTJzOOD0zv0ThQXAXxw+g9LxTG7n1I/rbTN72mrzR/EQvIKjyG38AgAlWaHKKLu7CzUn3oPweNvAyKQkV3Nf6nkLapNp3Pnzti1axcuX9aMsZ4+fRoHDhxAREREue0LCwuhVCp1NiICtly9VO5v2QAQMG0CZIKAbX8lWjiV+Ry7nVJpm/hb18wfxEKu5V2stE2+OtcCSSzjXv5WPDzyXXtZDvxW5UIUgHt93ABBDWXBPqjV+dKFrETpMISxmzUy+ZyFKVOmQKlUomnTppDL5VCpVJg3bx6GDRtWbvvo6GjMnj3b1DGIrF6+qkT7tSiKwD8jvPWWzQcAqEURucVF0oQzA5VY+b17DWljLdSwnfdiCLX6vvZrn1/zUGdBNgDgxkxvZPV1++eICLWYDxmq4eRGO2fyYmH9+vX48ccfsXbtWrRo0QIJCQmYOHEiAgMDy7373dSpUzF58mTtY6VSyUvAiAAEe9ZAUtYdiAAEQUC9r+YDoghBpukQlAsCHqvhK21IE/JydMXdovt629RwdtN73Jq4yt1xX5UjdQyLcXFsDEANz735qP/uXQDAzdcVuDX6wdogcpk35LJqfBWIWtRsxp7DCpl8GOKdd97BlClTMGTIELRq1QrDhw/HpEmTEB1d/kQeZ2dneHp66mxEBIxoGaLzWBAEbaEAaCb9DW3axtKxzGZYo/aVthneqIMFkljGM36DKm0T5PqYBZJYhq/7C3A/XYzgN+9AUAF3B7rh7ykPFwYy1PIYDkGoxmsrcM6C6dy/fx8yme5p5XI51Gr76nIjMtZLTVqjc516kEH3kuPSR5Pbd0FjG+pZiGz6FOq5VTwTvoG7D8Y+3tmCicyra62+8HaoWeFxGeQY3fB9CyYyLwe5D/xVIwARUD7lguuLfABZ6f9mOVwdm6C255uSZqyMABPMWZD6TTwikxcL/fr1w7x58/D777/j2rVriImJweLFi/H888+b+qWIbJqTXI7vew3C2+06w9flwRju4zVq4rNn+mDCE7bzwQkAMpkM2597C+GBTSF/aE0WuSCgV51m2Br+ZplfRKzdlOZfoZF7yzL7fRxrY1qzb+Eq95Aglfl4DYzG/V3LkPH9MxCdNP/GMkEBP8V/8XjtXyGX2db7tSWCKJp2OamcnBzMmDEDMTExyMzMRGBgIIYOHYqZM2fCycmp0ucrlUp4eXkhOzubQxJE/yhRq3Hzfi4cZTLUcnW3+QXOStRqOP6z1G+xSgUHGysS/k2lUiH5/nkUqgvQ0KMVXOU2NMEvNxfIzAQaNtTZXaK6C7WYDwd5LciEyj8bKmKJz4zS1+jSIwoODi5GnaukpAAHd0VZ3WecySc4KhQKfPrpp/j0009NfWoiu+Ugk6GOh/X8YDHWw8WBrRcKgGaotrGitdQxTK+4GHjhBeDkSeD334EOD+acOMh9JAz2aOx5BUfbXGydiIikJYrAf/8L7NgBuLkBnLdm1VgsEBGR6b3/PrB6tebOkevXAx07Sp3IeKa4moE9C0RERACWLAFKL5dfvhzo00faPCYiiCIEI6f5Gft8qdj+YCAREVnOhg3AhAmar+fMAUbb1p0zLS0uLg79+vVDYGAgBEFAbGys9lhxcTHee+89tGrVCu7u7ggMDMSIESOQlpamc44GDRpo1ml5aJs/f36VcrBYICIi0xBF4IsvNH++/jowfbrUiUxLbaKtCvLy8tCmTRssXbq0zLH79+/j5MmTmDFjBk6ePIkNGzYgMTER/fv3L9N2zpw5SE9P127jx4+vUg4OQxARkWkIArBli6ZgeOcdzWMbIsUwRERERIU3YvTy8sLOnTt19i1ZsgRPPvkkUlJSUK9ePe1+hUIBf3//qgf+B3sWiIjIOPkP3SnS3R2YMkUzsZEq9O+7LRcWFprkvNnZ2RAEAd7e3jr758+fD19fX4SEhGDRokUoKSkp/wQVYLFARESPLisLePJJICpKM/xgy0x4b4igoCB4eXlpt4run1QVBQUFeO+99zB06FCdBZ8mTJiAdevWYc+ePXj99dfx4Ycf4t13363SuTkMQUREj6agABgwADh3DrhzBxg3DqhZ8f0urJ4oGl8Q/fP81NRUnQ90Z2dno05bXFyMwYMHQxRFLFu2TOfYw3d2bt26NZycnPD6668jOjra4NdlsUBERFWnUgHDhwNxcYCnJ7B9u20XCjDtCo6mvMtyaaFw/fp17N69u9LzduzYESUlJbh27RqaNGli0GuwWCAioqoRRWDiRODXXwEnJyA2Fmhtg8tVW4HSQuHKlSvYs2cPfH0rvxNtQkICZDIZ/Pz8DH4dFgtERFQ1CxZoFl4SBOCHH4Du3aVOZBkmHIYwVG5uLpKSkrSPk5OTkZCQAB8fHwQEBOCFF17AyZMnsWXLFqhUKmRkZAAAfHx84OTkhMOHDyM+Ph7du3eHQqHA4cOHMWnSJLzyyiuoUaPiW8L/G4sFIiIy3LlzwNSpmq8/+QQYPFjaPBYkqDWbseeoiuPHj6P7Q8VY6fyDkSNHIioqCps2bQIAtG3bVud5e/bsQVhYGJydnbFu3TpERUWhsLAQwcHBmDRpks48BkOwWCAiIsO1bAmsWAFcvgy8/bbUaWxeWFgYRD29EfqOAcATTzyBI0eOGJ2DxQIREVXNqFFSJ5CGBMMQ1QXXWSAiIv2uXtXcDCozU+ok0jLhOgvWhsUCERFVLDMTeO45YOtW4K23pE5DEuEwBBERlS83V9OjcPUqEBysuQLCjtnzLapZLBARUVnFxcCLLwLHj2sWW9q+HTDiRkQ2gXMWiIiI/iGKwGuvaQoENzfNnSQff1zqVCQh9iwQEZGu6Ghg1SrNnSPXrwc6dpQ6UfUgAjBynQVOcCQiItswdKimJ+GrrzRzFgjAgzkLxm7WiD0LRESkKzgYOH0acHGROkn1IsIEcxZMksTi2LNARETA/v3AP0sHA2ChQDrYs0BEZO/Onwf69weUSuD334FevaROVD3Z8dUQLBaIiOxZaqqmOMjKAkJDgW7dpE5UfakBCCY4hxXiMAQRkb26dw+IiABu3ACaNgU2b9ZcKkn0L+xZICKyRwUFwMCBmiGIgADNmgq+vlKnqta4giMREdkPlQp45RUgLg7w9AS2bQPq15c6VfVnx3MWOAxBRGSP/PwAR0cgJgZo00bqNFTNsVggIrI3cjmwdClw6hTwzDNSp7EepT0Lxm5WiMUCEZG9OHBAc4MoABAEoEULafNYGxYLRERk03bsALp3B/r1A/LzpU5DVoYTHImIbN2JE8CgQUBJieZ2087OUieyTna8zgKLBSIiW3b1KtC7N5CXB/TsCXz/PSBjp/Kj4KWTRERkezIzNaszZmYCISHAb78BTk5Sp7JevHSSiIhsSm4u0LcvkJSkuYvk1q2aNRWIHgF7FoiIbNHFi5qtZk3N6oz+/lInsn5qERCM7BlQW2fPAosFIiJb1KGDZoXGoiLg8celTmMb7HgYgsUCEZEtuXPnwT0eQkKkzUI2g3MWiIhsxbJlQJMmwOHDUiexUaZYkMk6exZYLBAR2YING4DISE3Pwp49UqexTVzBkYiIrNb+/cDLL2s+iF5/HZg6VepEZGM4Z4GIyJqdPw/07w8UFmr+XLJEc98HMj21CYYReDUEERFZ1I0bmkWXsrKA0FDgp58AB/5YNxtRrdmMPYcV4jAEEZG1mj1bUzA0bQps3gy4uUmdiGwUS1AiImv1+eea+zxMm/bgckkyH66zQEREVkEUH8xJcHUFvv5a2jz2hHMWiIio2hNF4O23AQ8PYN48TmS0NPYsEBFRtbdwIfDFF5qv+/XTTGoksgBOcCQisgY//ABMmaL5evFiFgpSEGGCRZmq9pJxcXHo168fAgMDIQgCYmNjdSOJImbOnImAgAC4urqiZ8+euHLlik6bu3fvYtiwYfD09IS3tzfGjBmD3NzcKuVgsUBEVN3t2AGMHq35+n//AyZNkjaPvZJgBce8vDy0adMGS5cuLff4woUL8fnnn+Orr75CfHw83N3d8dxzz6GgoEDbZtiwYTh//jx27tyJLVu2IC4uDmPHjq1SDg5DEBFVZydOAIMGASUlmlUaFy6UOhFZUEREBCIiIso9JooiPv30U0yfPh0DBgwAAKxevRq1a9dGbGwshgwZgosXL2L79u04duwY2rdvDwD44osv0Lt3b3z00UcIDAw0KAd7FoiIqqucHKBPHyAvD+jZE1ixQnOpJElDrTbNZiLJycnIyMhAz549tfu8vLzQsWNHHP7nZmKHDx+Gt7e3tlAAgJ49e0ImkyE+Pt7g12LPAhFRdaVQAB9/rFlP4bffACcnqRPZNxNeDaFUKnV2Ozs7w9nZuUqnysjIAADUrl1bZ3/t2rW1xzIyMuDn56dz3MHBAT4+Pto2hmCJSkTVTkb+Xe3XNwvuSZjEMgpK7iAlZweu52yFsihZ9+CwYcChQ4CnpzThzEBU50As2A4xPwZi8Xmp40giKCgIXl5e2i06OlrqSHqZvGehQYMGuH79epn9b731VoUTNIiIACC7OA8fXVyPA7fPafcNPTQPXWu1xDtNB0PhaFvLGavUBTh1eyGu5WyBCBUAQCgW0XFxCXynr4ZbvbaahnK5dCFNSBRVEHM/AfJWASh8sN+hOQSvBRAcm0gXzhAm7FlITU2F50MFYFV7FQDA398fAHDz5k0EBARo99+8eRNt27bVtsnMzNR5XklJCe7evat9viFM3rNw7NgxpKena7edO3cCAF588UVTvxQR2ZBCVTEmn1yGQ7cv6OwXIeLgrfOYfOorFKmKJUpneqKoxsGM/0NyzmZtoQBRRPv3ryPom7NQ9XwKhYW3pA1pYqIyCsj7Bg8XCgCAkkSId4dCLCn7i2a1ohZNswHw9PTU2R6lWAgODoa/vz927dql3adUKhEfH4/Qfy6tDQ0NRVZWFk6cOKFts3v3bqjVanTs2NHg1zJ5sVCrVi34+/trty1btqBRo0Z4+umnTf1SRGRDdmacwF956VCj7AQwNdRIyv0buzNPSZDMPG7mx+Nm/mHgoffbcnEaGmy4C7UcOP2OP5LyYqQLaGJiyVUg/2eUv9CAChDzIeYus3Ssai83NxcJCQlISEgAoJnUmJCQgJSUFAiCgIkTJ+KDDz7Apk2bcPbsWYwYMQKBgYEYOHAgAKBZs2bo1asXXnvtNRw9ehQHDx7EuHHjMGTIEIOvhADMPGehqKgIa9aswejRoyFUsCxpYWEhlEqlzkZE9mdb+lEIqHj5YgECtqYdtWAi87qe8zsEPBheaLTmFpotuwkAODmnHtKf8USyMlaidKYn5m8EoG84RQUUbIYoFlkqUpWJotokW1UcP34cISEhCAkJAQBMnjwZISEhmDlzJgDg3Xffxfjx4zF27Fh06NABubm52L59O1xcXLTn+PHHH9G0aVP06NEDvXv3RteuXbF8+fIq5TDr1RCxsbHIysrCqFGjKmwTHR2N2bNnmzMGEVmBO4XZEB/6rdPnyWAI8gfFgwgRdwpt55eJ/JJb2uGHOjvuIWR2KgDg3NsBSH6pJgCgUHW3wudbHfVtAxoVA2IuIPiYPc4jER8MIxh1jioICwuDqOc5giBgzpw5mDNnToVtfHx8sHbt2iq97r+ZtWfhu+++Q0REhN6ujqlTpyI7O1u7paammjMSEVVTtVy8dXoWWs7pjxZR/bSPZRDg5+ItQTLzcHOoDQFy+J7IRcdJ1yCIwNUhNXFx3INJZy4ONSVMaGKy2pW3gTMgeJg9yiOTYAXH6sJsxcL169fx559/4r///a/eds7OzmUmehCR/ekT2FGnZ0HmKIfM4UG3tRoiegcaPiGrumvg2Q8iVLgf4IS8IGf83cMLp6KCHrqTpAwNPZ+XNKMpCa4DgdKJnOWSA64DIAhcS6I6MluxsGLFCvj5+aFPnz7megkisiHP1H4CTRRBkJUzb0EGAc096yPMr40Eycyjlkt7BLo9jfxAZ+z++XHEfxoM0UHz3gXI4e4QiEaetnMVmeBQH3AbWcFROSAoIHi8adFMVVbNVnC0JLMUC2q1GitWrMDIkSPh4MBFIomock4yB3wc8gZ6+D8BufDgR5NckOFZ/3ZY1HYsHGU28vMkKwvC9u0I9V+Ax7yGQlXDDSrX0vcsIMCtK56p8x2c5LbV0yoopkLwmAQI7roHHJ+A4PszBHkdaYIZyo6HIczynffnn38iJSUFo0vvkkZEZAB3BxdMa/4y3mjcDxeyr0MA0NyrPmo4KaSOZjoFBcCAAcD+/ZB9+y3ajv4fWtQYi9sFCVCjBDWcmsLNMaDy81ghQZABHm8C7q8CRccAMR9waAzBoaHU0agSZikWwsPD9c7eJCLSx8dJga61Wkodw/RUKmD4cCAuTrN8c7t2AABHuQIB7k9JHM5yBMEFcLa+9yuq1RAF44YRqnrpZHVhI316RETVnCgCkyYBv/4KODoCMTFAG9uZg2EXRBHlLypV1XNYH95IiojIEhYuBL74QvP16tXAM89Im4eoCtizQERkbj/8AEyZovl68WJgyBBp89CjUYuAYJ89CywWiIjM7cwZzZ//+59mKIKskygC5dy7pOrnsD4sFoiIzG3hQqBbN4DrzpCVYrFARGQOf/8N1KwJODtrVmXs16/y51C1JqpFiEYOQ1jrlYKc4EhEZGqZmUBYmKYngXfStR2i2jSbFWLPAhGRKeXmAn37AklJQEkJkJenWVOBrB57FoiIyHjFxcDgwcCxY4CvL7B9OxBgm6sxkn2pdj0LpVWXkl13RGRNRBF46y1g2zbAxQX4+WdNocCfZWZV+llhid/YS8RCo4cRSlBsojSWVe2KhZycHABAUFCQxEmIiB5RQQHQs6fUKexKTk4OvLy8zHJuJycn+Pv740DGVpOcz9/fH05O1nUrbkGsZgMoarUaaWlpUCgUEISyt6qtCqVSiaCgIKSmpsLTDsYM+X5tG9+vbeP7fTSiKCInJweBgYGQycw3sl5QUICioiKTnMvJyQkuLi4mOZelVLueBZlMhrp165r0nJ6ennbxzVeK79e28f3aNr7fqjNXj8LDXFxcrO4D3pQ4wZGIiIj0YrFAREREetl0seDs7IxZs2bB2dlZ6igWwfdr2/h+bRvfL1Vn1W6CIxEREVUvNt2zQERERMZjsUBERER6sVggIiIivVgsEBERkV42VyxER0ejQ4cOUCgU8PPzw8CBA5GYmCh1LLNZtmwZWrdurV3YJDQ0FNu2bZM6lsXMnz8fgiBg4sSJUkcxm6ioKAiCoLM1bdpU6lhm9ffff+OVV16Br68vXF1d0apVKxw/flzqWGbRoEGDMv++giAgMjJS6mhmoVKpMGPGDAQHB8PV1RWNGjXC3LlzrfZujPai2q3gaKx9+/YhMjISHTp0QElJCaZNm4bw8HBcuHAB7u7uUsczubp162L+/Pl47LHHIIoiVq1ahQEDBuDUqVNo0aKF1PHM6tixY/j666/RunVrqaOYXYsWLfDnn39qHzs42Ny3rta9e/fQpUsXdO/eHdu2bUOtWrVw5coV1KhRQ+poZnHs2DGoVCrt43PnzuHZZ5/Fiy++KGEq81mwYAGWLVuGVatWoUWLFjh+/DheffVVeHl5YcKECVLHowrY/KWTt27dgp+fH/bt24du3bpJHccifHx8sGjRIowZM0bqKGaTm5uLJ554Al9++SU++OADtG3bFp9++qnUscwiKioKsbGxSEhIkDqKRUyZMgUHDx7E/v37pY4iiYkTJ2LLli24cuWK0ffHqY769u2L2rVr47vvvtPuGzRoEFxdXbFmzRoJk5E+NjcM8W/Z2dkANB+gtk6lUmHdunXIy8tDaGio1HHMKjIyEn369EFPO7mz35UrVxAYGIiGDRti2LBhSElJkTqS2WzatAnt27fHiy++CD8/P4SEhOCbb76ROpZFFBUVYc2aNRg9erRNFgoA0LlzZ+zatQuXL18GAJw+fRoHDhxARESExMlIH9vty4TmDpYTJ05Ely5d0LJlS6njmM3Zs2cRGhqKgoICeHh4ICYmBs2bN5c6ltmsW7cOJ0+exLFjx6SOYhEdO3bEypUr0aRJE6Snp2P27Nl46qmncO7cOSgUCqnjmdxff/2FZcuWYfLkyZg2bRqOHTuGCRMmwMnJCSNHjpQ6nlnFxsYiKysLo0aNkjqK2UyZMgVKpRJNmzaFXC6HSqXCvHnzMGzYMKmjkT6iDXvjjTfE+vXri6mpqVJHMavCwkLxypUr4vHjx8UpU6aINWvWFM+fPy91LLNISUkR/fz8xNOnT2v3Pf300+Lbb78tXSgLu3fvnujp6Sl+++23UkcxC0dHRzE0NFRn3/jx48VOnTpJlMhywsPDxb59+0odw6x++uknsW7duuJPP/0knjlzRly9erXo4+Mjrly5UupopIfNFguRkZFi3bp1xb/++kvqKBbXo0cPcezYsVLHMIuYmBgRgCiXy7UbAFEQBFEul4slJSVSR7SI9u3bi1OmTJE6hlnUq1dPHDNmjM6+L7/8UgwMDJQokWVcu3ZNlMlkYmxsrNRRzKpu3brikiVLdPbNnTtXbNKkiUSJyBA2NwwhiiLGjx+PmJgY7N27F8HBwVJHsji1Wo3CwkKpY5hFjx49cPbsWZ19r776Kpo2bYr33nsPcrlcomSWk5ubi6tXr2L48OFSRzGLLl26lLnc+fLly6hfv75EiSxjxYoV8PPzQ58+faSOYlb379+HTKY7XU4ul0OtVkuUiAxhc8VCZGQk1q5di40bN0KhUCAjIwMA4OXlBVdXV4nTmd7UqVMRERGBevXqIScnB2vXrsXevXuxY8cOqaOZhUKhKDP/xN3dHb6+vjY7L+X//u//0K9fP9SvXx9paWmYNWsW5HI5hg4dKnU0s5g0aRI6d+6MDz/8EIMHD8bRo0exfPlyLF++XOpoZqNWq7FixQqMHDnSpi+LBYB+/fph3rx5qFevHlq0aIFTp05h8eLFGD16tNTRSB+puzZMDUC524oVK6SOZhajR48W69evLzo5OYm1atUSe/ToIf7xxx9Sx7IoW5+z8NJLL4kBAQGik5OTWKdOHfGll14Sk5KSpI5lVps3bxZbtmwpOjs7i02bNhWXL18udSSz2rFjhwhATExMlDqK2SmVSvHtt98W69WrJ7q4uIgNGzYU33//fbGwsFDqaKSHza+zQERERMax+XUWiIiIyDgsFoiIiEgvFgtERESkF4sFIiIi0ovFAhEREenFYoGIiIj0YrFAREREerFYICIiIr1YLBAREZFeLBaIiIhILxYLREREpBeLBSIiItLr/wF9o5afH7fG+wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.scatter(stats[\"mdl.xlow\"], stats[\"mdl.xhi\"], c=stats[\"statistic\"])\n",
    "plt.colorbar()\n",
    "\n",
    "# Take the \"best-fit\" locations from the fit output and draw lines connecting them.\n",
    "store = ui.get_fit_results().extra_output[\"store\"]\n",
    "pxlo = None\n",
    "pxhi = None\n",
    "for xlo, xhi in store:\n",
    "    if pxlo is not None:\n",
    "        plt.arrow(pxlo, pxhi, xlo - pxlo, xhi - pxhi)\n",
    "\n",
    "    pxlo, pxhi = xlo, xhi\n",
    "\n",
    "# Let's show the xlow=xhi line, for reasons.\n",
    "ax = plt.gca()\n",
    "ax.set_xlim(auto=False)\n",
    "ax.set_ylim(auto=False)\n",
    "plt.plot([6, 9], [6, 9], '--', c='r');"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "265de28b-e567-4c97-a17d-525106b620bb",
   "metadata": {},
   "source": [
    "Note that we actually have some cases where `xlo > xhi`, which is not really valid (anything on the dotted line, or to it's lower-right, is technically invalid and the model ends up just returning 0's for all bins). We can try to avoid this by setting the `xlow` parameter to have a maximum value and the `xhi` a minimum value to avoid this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "79d6fa85-9c79-4481-a222-ce3505bbc7fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d.mdl\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   mdl.xlow     thawed            7 -3.40282e+38            7           \n",
      "   mdl.xhi      thawed            8            8  3.40282e+38           \n",
      "   mdl.ampl     frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "mdl.reset()\n",
    "\n",
    "mdl.xlow.max = 7\n",
    "mdl.xhi.min = 8\n",
    "\n",
    "print(mdl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a82523ae-2ec1-42cd-88ea-9cb0128b9cb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset               = 1\n",
      "Method                = opty\n",
      "Statistic             = leastsq\n",
      "Initial fit statistic = 243\n",
      "Final fit statistic   = 88 at function evaluation 45\n",
      "Data points           = 15\n",
      "Degrees of freedom    = 13\n",
      "Change in statistic   = 155\n",
      "   mdl.xlow       3           \n",
      "   mdl.xhi        11          \n"
     ]
    }
   ],
   "source": [
    "ui.set_method_opt(\"verbose\", False)\n",
    "\n",
    "ui.fit(outfile=str(statfile), clobber=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a60f5b5-fb26-434f-bb1a-3a95792264c3",
   "metadata": {},
   "source": [
    "So, the end result is the same, but things are slightly different:\n",
    "\n",
    "- the number of function evaluations may be different (in this case it isn't, but with some code changes I've made but not yet turned into a PR it actually does, and now I'm interested why, but that's for another notebook)\n",
    "- the set of points searched is slightly different (which you can't see from above, but we can looking at the output file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "be6a0031-4f09-4db4-b1ff-5ad13d2fec89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAGdCAYAAABQEQrmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABWP0lEQVR4nO3dd3xT5f4H8E/STWlSC3RJCwVkypBpARGkUgsiKA64yBL0igV/UC9KvYwqYAUHyJA6qSy9cBVEdhkFkbIK9bKXQAttWrA06aArOb8/aiOhM+Qk56T5vO/rvK455zkn34Y2+eb7POd5FIIgCCAiIiISkVLqAIiIiKjuYYJBREREomOCQURERKJjgkFERESiY4JBREREomOCQURERKJjgkFERESiY4JBREREonOWOgCxGAwGpKenw8vLCwqFQupwiIhIpgRBQG5uLgIDA6FUWu97dmFhIYqLi0W5lqurK9zd3UW5lq3UmQQjPT0dQUFBUodBRER2Ii0tDY0bN7bKtQsLCxHSpD40WXpRrufv748rV67YVZJRZxIMLy8vAGW/MCqVSuJoiIhIrnQ6HYKCgoyfG9ZQXFwMTZYeV5KbQOVlWZVEl2tASJdrKC4uZoIhhfJuEZVKxQSDiIhqZIvudJWX0uIEw1455k9NRERkA3rBIMpWW7GxsejWrRu8vLzg6+uLoUOH4vz585W2FQQBERERUCgU2Lhxo8mx1NRUDBo0CPXq1YOvry+mTZuG0tJSs352JhhERERWYoAgylZb+/btQ2RkJA4dOoSEhASUlJRgwIAByM/Pr9B20aJFlVZx9Ho9Bg0ahOLiYhw8eBDfffcd4uPjMWvWLLN+9jrTRUJERCQ3BhhQ+/pD1deore3bt5s8jo+Ph6+vL5KTk9GnTx/j/pSUFHzyySc4duwYAgICTM7ZuXMnzpw5g127dsHPzw+dOnXCnDlz8M477yAmJgaurq61ioUVDCIiIjug0+lMtqKiohrP0Wq1AAAfHx/jvoKCAvzjH//AsmXL4O/vX+GcpKQktG/fHn5+fsZ94eHh0Ol0OH36dK3jZYJBRERkJXpBEGUDgKCgIKjVauMWGxtb7XMbDAZMmTIFvXr1wsMPP2zcP3XqVPTs2RNDhgyp9DyNRmOSXAAwPtZoNLX+2dlFQkREZCXmjqGo6hpAxWkY3Nzcqj0vMjISp06dwoEDB4z7Nm3ahD179uDEiRMWxVQbrGAQERHZgfJpGMq36hKMSZMmYfPmzdi7d6/JZGJ79uzB5cuX4e3tDWdnZzg7l9UZhg0bhr59+wIom9QrMzPT5HrljyvrUqkKEwwiIiIrMUCA3sLNnAqIIAiYNGkSNmzYgD179iAkJMTk+PTp0/G///0PKSkpxg0AFi5ciBUrVgAAQkNDcfLkSWRlZRnPS0hIgEqlQtu2bWsdC7tI/iIIAlIu3cD1m1qo6rmjR9smcHfly3O3vTtPIiX5Gup5umLoC93hF+AtdUiycujMNew5fglOTgoM6fUwWgf7Sh2SrGRp85B86Tr0BgEdmgYguJG31CERWZ2YXSS1ERkZibVr1+Lnn3+Gl5eXccyEWq2Gh4cH/P39K61CBAcHG5ORAQMGoG3bthg1ahQWLFgAjUaDGTNmIDIyssZumbuZ/Qm6f/9+fPTRR0hOTkZGRgY2bNiAoUOHAgBKSkowY8YMbN26FX/88QfUajXCwsLw4YcfIjAwsNrrLlu2DB999BE0Gg06duyIJUuWoHv37uaGd1+OnkvD3FUJuH5Ta9xX38MV/xwcihH9H3H4xdMO7j+H2NkbUVRYYtz34/eH0aptID5ZNgau7o6diJ27lok3Fv0EbX6hcd+6vb/jwYYqfPvOS2iori9hdNIrKCrG3P/swbbkczAIf79R9mzdBHNeDkdDlaeE0RHVLcuXLwcAY3dHuRUrVmDs2LG1uoaTkxM2b96MiRMnIjQ0FJ6enhgzZgzef/99s2Ixu4skPz8fHTt2xLJlyyocKygowPHjxzFz5kwcP34cP/30E86fP49nnnmm2mv+5z//QVRUFGbPno3jx4+jY8eOCA8PNynPWMvvl9MRuegn3LilNdmfd6cYn6zbh5U7jlk9Bjn7/fhVxLyz3iS5KHf+TDr+OfoLCaKSj4w/dRgd+71JclHuxi0dhs38DsVmzn5Xl5TqDYiM21ghuQCAwxdSMXbRf5B7p+Zb7YjslZh3kdSGIAiVbtUlF4IgGAsF5Zo0aYKtW7eioKAAN2/exMcff2wcr1FbZicYERERmDt3Lp599tkKx9RqNRISEvDiiy+iVatWePTRR7F06VIkJycjNTW1ymt++umnePXVVzFu3Di0bdsWcXFxqFevHr799ltzwzPbZ//99a9/gMqPx21KQm5BxQ8PR7Howy3VHr+Rlo2kXyufhtYRxK7ZDb2h6j/+vMJifPnLIRtGJC/7Tv2B45dvVEguAEBvEHD9Ty1+OnhSgsiIbMMg0maPrD7IU6vVQqFQwNvbu9LjxcXFSE5ORlhY2N9BKZUICwtDUlJSldctKiqqMOmIudJvafH75fRK3/zKlZTqsfv4JbOvXRcUFhbjRlp2je2+/+43G0QjT4fPVp04l9t0sPYT09Q1m46chrKaLkZBAH5KOmXDiIjIVqyaYBQWFuKdd97BiBEjqlzh9NatW9Dr9ZVO6lHdhB6xsbEmE44EBQWZHd+fuoIa2yiVSvyprTiHuyP481Zerdppc2p+HeuqUn3N3y3y7xTbIBJ5ysrJqzaBB4A/cx3394fqPkvvICnf7JHVEoySkhK8+OKLEATBOOhETNHR0dBqtcYtLS3N7Gs0VNc8uExvMKDRA445SK9Rw9ote/+Aj+MO0nNxqvlPyKte7Udd1zX+D3jBSVl1BUMBwLcWf4dE9koviLPZI6skGOXJxbVr14z3zlalYcOGcHJyqnRSj+om9HBzc6sw6Yi5Ahqo0KVl42pLuG4uznjikRZmX7sucHV3RpOQhjW2Gzmutw2ikafQh5vW2ObZx9pbPxCZGtKjXbVjVABgWE/HfX2o7uMYDBGVJxcXL17Erl270KBBg2rbu7q6okuXLti9e7dxn8FgwO7duxEaGip2eBVMef4xODkpq0wyJj/XG/U9HPcbaNS7g1HdXbpNmzdCt9CHbBeQzLw7sn+1VQy1pzvGR/SwYUTy8li7EIS2Cq7078tJqUCInw+eDX24kjOJyN6ZnWDk5eWZzP515coVpKSkIDU1FSUlJXj++edx7NgxrFmzBnq9HhqNBhqNBsXFf/dD9+/fH0uXLjU+joqKwldffYXvvvsOZ8+excSJE5Gfn49x48ZZ/hPWoG1Tf3z1rxfQ/EHTRMjHywMzRoVhRP9HrB6DnLV5uDFiPxsJz/oVk6yOnZvg8/jXJIhKPhp518cPs0ahkXfFMn/zAB9snDcOzs6OO2Guk1KJRa8OwfO92pskYkqFAk90aIEVU15EPbfaLf1MZI8MUEBv4WaAfc7FpBAEM26wBZCYmIh+/fpV2D9mzBjExMRUmJa03N69e40TfzRt2hRjx45FTEyM8fjSpUuNE2116tQJixcvRo8etf/mp9PpoFarodVq76u7RBAEnE+7iRs3tVB5uqNTi0C4ODuZfZ267Nihy0hJvgoPDxc8/VxXqL3rSR2SrJy5mondxy/A2ckJT4e2RZCvt9QhyYo2vxAn/ii7ZbVdsD/8vB1zbBNJz9LPC3Oe49hpP9T3suxLRl6uAV3bZVo1XmswO8GQK1v8whARkf1jgmEbjj3HMxERkRWVd3NYeg17xASDiIjIShw5wXDc0WdERERkNaxgEBERWYlBUMAgWFaBsPR8qTDBICIishJ2kRARERGJiBUMIiIiK9FDCb2F3+X1IsVia0wwiIiIrEQQYQyGwDEYREREdDeOwSAiIiISESsYREREVqIXlNALFo7BsNMFPZhgEBERWYkBChgs7CwwwD4zDHaREBERkehYwSAiIrISRx7kyQSDiIjISsQZg8EuEiIiIiIArGAQERFZTdkgTwsXO2MXCREREd3NIMJU4byLhIiIiOgvrGAQERFZiSMP8mSCQUREZCUGKB12oi0mGERERFaiFxTQW7gaqqXnS4VjMIiIiEh0rGAQERFZiV6Eu0j07CIhIiKiuxkEJQwWDvI02OkgT3aREBERkehYwSAiIrISR+4iYQWDiIjISgz4+06S+90MZjxfbGwsunXrBi8vL/j6+mLo0KE4f/688Xh2djYmT56MVq1awcPDA8HBwXjzzTeh1WpNrpOamopBgwahXr168PX1xbRp01BaWmrWz84Eg4iIqI7Yt28fIiMjcejQISQkJKCkpAQDBgxAfn4+ACA9PR3p6en4+OOPcerUKcTHx2P79u0YP3688Rp6vR6DBg1CcXExDh48iO+++w7x8fGYNWuWWbEoBMFOR4/cQ6fTQa1WQ6vVQqVSSR0OERHJlC0+L8qfY/nxbvCob9lohDt5pZjY+eh9xXvz5k34+vpi37596NOnT6Vt1q9fj5dffhn5+flwdnbGtm3b8PTTTyM9PR1+fn4AgLi4OLzzzju4efMmXF1da/XcrGAQERFZSflU4ZZu96u868PHx6faNiqVCs7OZYlQUlIS2rdvb0wuACA8PBw6nQ6nT5+u9XObHfX+/fsxePBgBAYGQqFQYOPGjSbHf/rpJwwYMAANGjSAQqFASkpKjdeMj4+HQqEw2dzd3c0NjYiIqM7S6XQmW1FRUbXtDQYDpkyZgl69euHhhx+utM2tW7cwZ84cvPbaa8Z9Go3GJLkAYHys0WhqHa/ZCUZ+fj46duyIZcuWVXm8d+/emD9/vlnXValUyMjIMG7Xrl0zNzQiIiJZMUAhygYAQUFBUKvVxi02Nrba546MjMSpU6fwww8/VHpcp9Nh0KBBaNu2LWJiYsT+0c2/TTUiIgIRERFVHh81ahQA4OrVq2ZdV6FQwN/f39xwiIiIZEuc1VTLzk9LSzMZg+Hm5lblOZMmTcLmzZuxf/9+NG7cuMLx3NxcPPXUU/Dy8sKGDRvg4uJiPObv748jR46YtM/MzDQeqy3ZjMHIy8tDkyZNEBQUhCFDhtTYz1NUVFShXERERCQn5fNgWLoBZZX+u7fKEgxBEDBp0iRs2LABe/bsQUhISIU2Op0OAwYMgKurKzZt2lRhSEJoaChOnjyJrKws476EhASoVCq0bdu21j+7LBKMVq1a4dtvv8XPP/+M1atXw2AwoGfPnrh+/XqV58TGxpqUioKCgmwYMRERkfxERkZi9erVWLt2Lby8vKDRaKDRaHDnzh0AfycX+fn5+Oabb6DT6Yxt9Ho9AGDAgAFo27YtRo0ahd9//x07duzAjBkzEBkZWW3V5F6ymMkzNDQUoaGhxsc9e/ZEmzZt8MUXX2DOnDmVnhMdHY2oqCjjY51OxySDiIhkxSAoYLBwuXVzzl++fDkAoG/fvib7V6xYgbFjx+L48eM4fPgwAKBFixYmba5cuYKmTZvCyckJmzdvxsSJExEaGgpPT0+MGTMG77//vllxyyLBuJeLiwseeeQRXLp0qco2bm5uZmVSREREtmYQYapwgxnn1zS1Vd++fWtsAwBNmjTB1q1ba/28lZFFF8m99Ho9Tp48iYCAAKlDISIiovtgdgUjLy/PpLJw5coVpKSkwMfHB8HBwcjOzkZqairS09MBwDgHur+/v3H06ejRo/Hggw8ab7F5//338eijj6JFixbIycnBRx99hGvXrmHChAkW/4BERERSEWe5dlnWAmpkdoJx7Ngx9OvXz/i4fBzEmDFjEB8fj02bNmHcuHHG48OHDwcAzJ4923ifbWpqKpTKv1+w27dv49VXX4VGo8EDDzyALl264ODBg2aNViUiIpIbPRTQw7IxGJaeLxWuRUJERA7FlmuRzDnyBNwtXIukMK8UM7vvsbvPN1kO8iQiIqoL2EVCREREotPD8i4OvTih2Jx9pkVEREQka6xgEBERWQm7SIiIiEh0Yi52Zm+YYBAREVmJcNdy65Zcwx7ZZ1pEREREssYKBhERkZWwi4SIiIhEZ+vVVOXEPtMiIiIikjVWMIiIiKxEL8Jy7ZaeLxUmGERERFbCLhIiIiIiEbGCQUREZCUGKGGw8Lu8pedLhQkGERGRlegFBfQWdnFYer5U7DMtIiIiIlljBYOIiMhKHHmQJxMMIiIiKxFEWE1V4EyeREREdDc9FNBbuFiZpedLxT7TIiIiIpI1VjCIiIisxCBYPobCIIgUjI0xwSAiIrISgwhjMCw9Xyr2GTURERHJGisYREREVmKAAgYLB2laer5UmGAQERFZCWfyJCIiIhIRKxhERERW4siDPJlgEBERWYkBIkwVbqdjMOwzLSIiIiJZYwWDiIjISgQR7iIR7LSCwQTjL6WlehxNuoSMGzmo7+WO0MdawkvlIXVYslFcXIzP/28Fzhy8APd6bng55kV0D+8kdViysurrffht/zkolUo881xXPPXMI1KHJCtHDl/Gjh3/g14voGevhzBgQHupQ5KVrOxc/Pb7FRQVl6JFUEN0aRMEhcI+P1job468mqpCEASzJiHdv38/PvroIyQnJyMjIwMbNmzA0KFDjcd/+uknxMXFITk5GdnZ2Thx4gQ6depU43XXr1+PmTNn4urVq3jooYcwf/58DBw4sNZx6XQ6qNVqaLVaqFQqc34kJP16HgtjtyDndj4USgUEgwAXFye8NKonXh7/OJRK+/zHFcuKmd9j7byfKuyvp/LAinOfwcf/AQmiko89O09ifsxG3PuX5OysxMIvx6FVm0BpApOJGzdu483JK5GTU2Cy393dBR/EvoiOHYMlikweiopL8dHKPdjy62kYBAEKhQKCIKCxrzfmvDEQbZv5Sx1inWPJ54W5z/Fswji4eLpadK2S/GJseHKFVeO1BrPHYOTn56Njx45YtmxZlcd79+6N+fPn1/qaBw8exIgRIzB+/HicOHECQ4cOxdChQ3Hq1ClzwzPb8SN/IGb6emhz8gEAwl+TvpeU6LH621+x8qtEq8cgZ5uW76g0uQCAAt0djGoWaeOI5OXMyTR8OLticgEApaUGvDn+G+Tl3bF9YDJRUFCMVyd8XSG5AIDCwhK8FbUW19P+lCAy+YiJ22ZMLgCg/Dtf+i0t3ohdj6vp2VKGR3TfzE4wIiIiMHfuXDz77LOVHh81ahRmzZqFsLCwWl/zs88+w1NPPYVp06ahTZs2mDNnDjp37oylS5eaG57Zvlm+BxBQ6QcEAPxn1UFoK3lzdBRfvr2q2uPFhSVYM+9HG0UjP7GzN1R7XBCA2FnVt6nLvvl6L4qKSqs8LggCPvtspw0jkpezf2iw59hFY3JxN4NBQHFJKeJ/OSxBZCSW8i4SS7faio2NRbdu3eDl5QVfX18MHToU58+fN2lTWFiIyMhINGjQAPXr18ewYcOQmZlp0iY1NRWDBg1CvXr14Ovri2nTpqG0tOq/5crIYgxGUlISoqKiTPaFh4dj48aNVZ5TVFSEoqIi42OdTmf286Zfz8bFcxnVtjEYDPh171k8/WwXs69v77TZuSjKLzLZpxFSoYXpN6qYD87gSNZ+W4YmG/uSjpg8NhhK0DSgN+p5NDDuO3H0iq3Dko29e8/V2Ob331NtEIk87Ug6ByelEnqDodLjeoOAhEPnMWP8ADg7O9k4OhKDracK37dvHyIjI9GtWzeUlpbi3XffxYABA3DmzBl4enoCAKZOnYotW7Zg/fr1UKvVmDRpEp577jn89ttvAAC9Xo9BgwbB398fBw8eREZGBkaPHg0XFxd88MEHtY5FFgmGRqOBn5+fyT4/Pz9oNJoqz4mNjcV7771n0fNqtTWXrpVKJXRax6xgaK5kVth3CkcqNiwAFi8+Y4OI7MONrGQ8+ej7xsd6feUfHo6gsLC4xjaO/Prk5N0BUP0wuFK9AXeKSuDFBINqYfv27SaP4+Pj4evri+TkZPTp0wdarRbffPMN1q5diyeeeAIAsGLFCrRp0waHDh3Co48+ip07d+LMmTPYtWsX/Pz80KlTJ8yZMwfvvPMOYmJi4OpauzElskgw7kd0dLRJ1UOn0yEoKMisa/j61jxYRq83wNdfbXZ8dUFwqwcr7OuNgShCocm+B/zVmPPzdFuFJSuTx39j8vjIqS8rtHFxtds/M4upVB64eTO32jauDvz6+DdQ1ZBeAPXcXVDPw7JBgiQdMe8iubdS7+bmBjc3t2rP1Wq1AAAfHx8AQHJyMkpKSkyGMbRu3RrBwcFISkrCo48+iqSkJLRv397ki394eDgmTpyI06dP45FHaneHnCz+sv39/Sv0/2RmZsLfv+rR07V5YWvSoJEXuj7aHMeP/AGDofI/cw8PV/Tu28ai57FXHvU9oG7oBe2tvz8g3BX14I56Ju2mL/o/dO/e3dbhyUKXzim4dKFipeduYeGOezvmM890xjff7Ku2Te/eLW0Ujfw8/Vg7xG+qeoyFk1KBIY+3h5OScyLaKzETjHu/RM+ePRsxMTFVn2cwYMqUKejVqxcefvhhAGU9Bq6urvD29jZpe3evQVW9CuXHaksWv7WhoaHYvXu3yb6EhASEhoZa/blfmxwGNzeXKm9FjXzrKbi7u1g9Drmauf6tao83fNAH/V7qbaNo5Oe9j15CdVMVuLo6Y/LbEbYLSGaGj3gUDRrWr/K4m5sLJr/5pA0jkpfGft4YPbjy5NxJqUBD7/pVHifHk5aWBq1Wa9yio6OrbR8ZGYlTp07hhx9+sFGEpsxOMPLy8pCSkoKUlBQAwJUrV5CSkoLU1LKBWtnZ2UhJScGZM2V98ufPn0dKSopJ1jN69GiTF+b//u//sH37dnzyySc4d+4cYmJicOzYMUyaNMmSn61WmjbzxaKvxqF9J9N78QMbP4AZ84ZhwKCOVo9Bzjo+3g7zNk+HSyVJVrOOTbH66ucSRCUfjXzV+HLt6/CsX7Ga1tBXhfVb34KTk+P2nSuVSqxc+U+0a9e4wrHg4AZYueqfUKnqVXKm45j4fC+89XI/+Nz1OigVCvTp3ALfzB5hsp/sj5h3kahUKpOtuir+pEmTsHnzZuzduxeNG//99+fv74/i4mLk5OSYtL+716CqXoXyY7Vl9kRbiYmJ6NevX4X9Y8aMQXx8POLj4zFu3LgKx+8u5fTt2xdNmzZFfHy88fj69esxY8YM40RbCxYssNlEW+Uy0m9Dk54DlcoDzR7y4yx69zix53/49acjqO/tiRHTh8KjPmc6vdsflzLR/KGyP76szBw08nXMsTtVyckpwL7EsyjVG9Cr10Pw9/eWOiRZKdUbcO5qJoqKS9E0wAcNvD2lDqnOsuVEW09u/acoE20lDPyiVvEKgoDJkydjw4YNSExMxEMPPWRyXKvVolGjRvj+++8xbNgwAGWFgNatWxvHYGzbtg1PP/00MjIy4OvrCwD48ssvMW3aNGRlZdV6eILZCYZc2eIXhqgm5UlpHfmzIqqT6nKC8cYbb2Dt2rX4+eef0apVK+N+tVoND4+yL4UTJ07E1q1bER8fD5VKhcmTJwMom/QSKLtNtVOnTggMDMSCBQug0WgwatQoTJgwwf5uUyUiIqqLBFi+3Lo5X1eWL18OoKyn4G4rVqzA2LFjAQALFy6EUqnEsGHDUFRUhPDwcHz++d/d3U5OTti8eTMmTpyI0NBQeHp6YsyYMXj//fdhDiYYREREVmLrxc5qUz11d3fHsmXLqlzyAwCaNGmCrVu31vp5K8MEg4iIyEoceTVVWdymSkRERHULKxhERERW4sgVDCYYREREVuLICQa7SIiIiEh0rGAQERFZiSAoIFhYgbD0fKkwwSAiIrISAxQWz4Nh6flSYRcJERERiY4VDCIiIitx5EGeTDCIiIisxJHHYLCLhIiIiETHCgYREZGVsIuEiIiIROfIXSRMMIiIiKxEEKGCYa8JBsdgEBERkehYwSAiIrISAYAgWH4Ne8QEg4iIyEoMUEDBmTyJiIiIxMEKBhERkZXwLhIiIiISnUFQQOGg82Cwi4SIiIhExwoGERGRlQiCCHeR2OltJEwwiIiIrMSRx2Cwi4SIiIhExwoGERGRlThyBYMJBhERkZU48l0kTDCIiIisxJEHeXIMBhEREYmOFQwiIiIrKatgWDoGQ6RgbMzsCsb+/fsxePBgBAYGQqFQYOPGjSbHBUHArFmzEBAQAA8PD4SFheHixYvVXjMmJgYKhcJka926tbmhERERyUr5IE9LN3tkdoKRn5+Pjh07YtmyZZUeX7BgARYvXoy4uDgcPnwYnp6eCA8PR2FhYbXXbdeuHTIyMozbgQMHzA2NiIiIZMLsLpKIiAhERERUekwQBCxatAgzZszAkCFDAAArV66En58fNm7ciOHDh1cdiLMz/P39zQ2HiIhItoS/NkuvYY9EHeR55coVaDQahIWFGfep1Wr06NEDSUlJ1Z578eJFBAYGolmzZhg5ciRSU1OrbV9UVASdTmeyERERyQm7SESi0WgAAH5+fib7/fz8jMcq06NHD8THx2P79u1Yvnw5rly5gsceewy5ublVnhMbGwu1Wm3cgoKCxPkhiIiIyGKyuE01IiICL7zwAjp06IDw8HBs3boVOTk5WLduXZXnREdHQ6vVGre0tDQbRkxERFQLgkibHRL1NtXyMRSZmZkICAgw7s/MzESnTp1qfR1vb2+0bNkSly5dqrKNm5sb3Nzc7jtWIiIiqxOji4NdJEBISAj8/f2xe/du4z6dTofDhw8jNDS01tfJy8vD5cuXTZIUIiIie1M+k6elmz0yO8HIy8tDSkoKUlJSAJQN7ExJSUFqaioUCgWmTJmCuXPnYtOmTTh58iRGjx6NwMBADB061HiN/v37Y+nSpcbH//rXv7Bv3z5cvXoVBw8exLPPPgsnJyeMGDHC4h+QiIjIkdQ0X1VeXh4mTZqExo0bw8PDA23btkVcXJxJm8LCQkRGRqJBgwaoX78+hg0bhszMTLPiMLuL5NixY+jXr5/xcVRUFABgzJgxiI+Px9tvv438/Hy89tpryMnJQe/evbF9+3a4u7sbz7l8+TJu3bplfHz9+nWMGDECf/75Jxo1aoTevXvj0KFDaNSokbnhERERyYYUq6mWz1f1yiuv4LnnnqtwPCoqCnv27MHq1avRtGlT7Ny5E2+88QYCAwPxzDPPAACmTp2KLVu2YP369VCr1Zg0aRKee+45/Pbbb7WOQyEI9lp8MaXT6aBWq6HVaqFSqaQOhxyUQlH2RlBH/qyI6iRbfF6UP0fTb2ZCWc+95hOqYSgoxNXxc+4rXoVCgQ0bNpj0Ijz88MN46aWXMHPmTOO+Ll26ICIiAnPnzoVWq0WjRo2wdu1aPP/88wCAc+fOoU2bNkhKSsKjjz5aq+eWxV0kREREVL17534qKiq6r+v07NkTmzZtwo0bNyAIAvbu3YsLFy5gwIABAIDk5GSUlJSYzGnVunVrBAcH1zin1d2YYBAREVmJmIM8g4KCTOZ/io2Nva+YlixZgrZt26Jx48ZwdXXFU089hWXLlqFPnz4Ayua0cnV1hbe3t8l5Nc1pdS+upkpERGQtIs4VnpaWZtJFcr9TNSxZsgSHDh3Cpk2b0KRJE+zfvx+RkZEIDAw0qVpYigkGERGRHVCpVBaPGblz5w7effddbNiwAYMGDQIAdOjQASkpKfj4448RFhYGf39/FBcXIycnx6SKkZmZadaaYewiISIishK5rUVSUlKCkpISKJWmH/9OTk4wGAwAygZ8uri4mMxpdf78eaSmppo1pxUrGERERNZk45vK8vLyTGbCLp+vysfHB8HBwXj88ccxbdo0eHh4oEmTJti3bx9WrlyJTz/9FEDZIqXjx49HVFQUfHx8oFKpMHnyZISGhtb6DhKACQYREVGdUtN8VT/88AOio6MxcuRIZGdno0mTJpg3bx5ef/114zkLFy6EUqnEsGHDUFRUhPDwcHz++edmxcF5MIhExHkwiOTPlvNgBH0xG0oPC+fBuFOItH++Z3efb6xgEBERWYuId5HYGyYYREREVqP4a7P0GvaHd5EQERGR6FjBICIishZ2kRAREZHoHDjBYBcJERERiY4VDCIiImsRFGWbpdewQ0wwiIiIrOTu1VAtuYY9YhcJERERiY4VDCIiImtx4EGeTDCIiIisxYHHYLCLhIiIiETHCgYREZGVKISyzdJr2CMmGERERNbCMRhEREQkOo7BICIiIhIPKxhERETWwi4SIiIiEp0DJxjsIiEiIiLRsYJBRERkLQ5cwWCCQUREZC28i4SIiIhIPKxg/KWguATbz11A2m0t1B7ueKp1S/ir6ksdlmwUFhbjyw1JOPOHBh5uLnhxwCMI7RAidViyUazXY9bWXcbHn+07iP97vKeEEcmLXq/HwoNJ2HL+PAyCgNCgILz/ZBhcnZykDk029l6/jO8uHENhaQk6NgzE/3XojXrOrlKHJRvakls4oz2IQn0eHnD1R1t1T7gq3aUOq0acydMM+/fvx0cffYTk5GRkZGRgw4YNGDp0qPG4IAiYPXs2vvrqK+Tk5KBXr15Yvnw5HnrooWqvu2zZMnz00UfQaDTo2LEjlixZgu7du5v9A92PjSfPIGbbHhSUlMBZqYRBEPDhrv0Y2aUjop98HM5Kxy70rNl6DEv+sx/CXb/kB/93FQ28PbHq/ZFo4O3YiVj84WR8sGu/yb5lBw5j+W+H8fXw59C7WROJIpOHfVeuYMJPG2C4a9/606ex/vRpzOrbF2O6dJYsNjm4WZCHp7d9i6w7+cZ9h7PS8NWZw3i3c39MaGub90G50gt6bM/4GseytwEAFFDCAD22ZnyJQYGvo6N3X2kDrIkDj8Ew+5MzPz8fHTt2xLJlyyo9vmDBAixevBhxcXE4fPgwPD09ER4ejsLCwiqv+Z///AdRUVGYPXs2jh8/jo4dOyI8PBxZWVnmhme23Rcu4+1NO1BQUgIAKDUYYBAEGAQBq4+l4MNd+6weg5ztSDqHxT+YJhfl/szJx4h3V8JgMFQ86CAO/HGtQnJRziAAr3z/E27m5dk4KvnQ5ObilXuSi7u9n5iIg6mpNo1JTgwGAwZs/sokuSgnAJh3fDc2Xztj+8BkZEfGNziavRXCX/8zQA8AKDbcwYbrC3Fed1TiCKkqZicYERERmDt3Lp599tkKxwRBwKJFizBjxgwMGTIEHTp0wMqVK5Geno6NGzdWec1PP/0Ur776KsaNG4e2bdsiLi4O9erVw7fffmtueGYRBAELE39DVcNnBACrj/2OrFzH/YBY8kPlH57ltHmF2LT/lI2ikZ/oX3bU2CZq4zYbRCJPU7ZsrbHNO9trfg3rqu8vpSCnuOovXwDwwbE9NopGfnQlf+JodnW/QwrszlwFobJvQCQ5UcdgXLlyBRqNBmFhYcZ9arUaPXr0QFJSEoYPH17hnOLiYiQnJyM6Otq4T6lUIiwsDElJSVU+V1FREYqKioyPdTqd+fFm38aFm39W20YQBCScv4yRXTuafX17l1dQiJu3a06uftz9Pwzt28EGEclPZl7Fb54AkL7qa+N/b1QoMPg/K20Vkqzs/eMPk+qXUFoCr9BeqN+hvXFfem6uBJHJw+oLx2tsk3EnFwWlxQ45HuOs7lANLQRkFV1DdrEGDdwCbBKTuRQQYQyGKJHYnqgJhkajAQD4+fmZ7Pfz8zMeu9etW7eg1+srPefcuXNVPldsbCzee+89i+LNLSyqsY1SqYCuqOZ2ddHt3Du1aldQWGzlSOyIQgEIAvLPm5a1N587LVFA8nPn4kXU//gTqcOQhfzSklq1u114B/XqO16CUajPgwJKCH91i1TZziDjKrMD36Zqt3eRREdHIyoqyvhYp9MhKCjIrGs8qFZBqVDAUE15TW8QEPyA+r7jtGd+Dbxq1S6glu3qIgVMx181m/kBhBLTDw0PZyckTn7VpnHJxWNffoXC0lLj42sxsyu0sc+3TnE09lQhLS+n2jYKAH71HPNvzMc1wDjmoioKKODt4mujiMgcoiYY/v7+AIDMzEwEBPxdrsrMzESnTp0qPadhw4ZwcnJCZmamyf7MzEzj9Srj5uYGNzc3i+JtWN8TTzzUDHsv/gF9JUmGAoCXuxuebNncouexV67OzmjX3B+nL1defSoX+eJjNopIfjo9GIATNzKMj51c3QBX09/Lkd0fQaNGjWwdmiz8IzQU3504UW2bLg8G2iga+ZnWqS+e21F991mnhoEOeydba9WjcFd6otBQeVekAkq0UnWHp7OMvwTyLhJxhISEwN/fH7t37zbu0+l0OHz4MEJDQys9x9XVFV26dDE5x2AwYPfu3VWeI6bpYX3g5e4GJ4Xp9yjlXw/nDXoSrs52W+ix2JyJA+HsVPWvSc+OIWjTrOpEsK774qUhFX537lbf1QXvPOG4Cdi/H++D+i4uVR53Uijw5ZAhNoxIXh5p9CAeD2xW5XEXpRKf9XrGhhHJi4vSFYMfjERZncL070wBJdydPDHAf5w0wdWWINJmh8xOMPLy8pCSkoKUlBQAZQM7U1JSkJqaCoVCgSlTpmDu3LnYtGkTTp48idGjRyMwMNBkroz+/ftj6dKlxsdRUVH46quv8N133+Hs2bOYOHEi8vPzMW6c9X9xgh/wxn/HjUD/Vs2hvOuD4mF/P3wz4jmEt65+/o667kFfb6z9YDSC/b1N9js7KfFsvw5Y+FbFu4kcibeHB/a/OQGN6ntWONa8gQ8ORU2EkwNPJuXk5ISjkW+ghY9PhWN+np747bVXofbwkCAy+Yh/4iWMaNEJzgrTt+NmqgbY8fQEBHk9IFFk8tBO3QsvN5mNAI+/K8kKKNFa9Shebf4xfFwd9wuO3CkEM+/vSUxMRL9+/SrsHzNmDOLj440TbX355ZfIyclB79698fnnn6Nly5bGtk2bNsXYsWMRExNj3Ld06VLjRFudOnXC4sWL0aNHj1rHpdPpoFarodVqoVKpzPmRjLIL7kCjy4Xawx0Pqu/vGnVZZnYu/ncxHV4ebuj+cDCUDlq2rcrNvDz8fPIc3F2cMbRDW9R3dbxBedXJKy6G11/dmlm5uWhU37EnaLuXwWDAr5oryC0pQpeGjRHgyfege90uzkShPh9ql4ao53z/r48Ynxe1fY6m8+ZB6W7ZjKOGwkJc/fe/rRqvNZidYMiVLX5hiMgyir+qhHXkbYfslE0TjLkiJRgz7C/B4FdQIiIiEp3jjl4kIiKyNt5FQkRERGIrX03V0s0c+/fvx+DBgxEYGAiFQlHpUh1nz57FM888A7VaDU9PT3Tr1g2pd60LVFhYiMjISDRo0AD169fHsGHDKkwnURMmGERERHVITYuSXr58Gb1790br1q2RmJiI//3vf5g5cybc7xorMnXqVPzyyy9Yv3499u3bh/T0dDz33HNmxcEuEiIiImuRYKrwiIgIREREVHn83//+NwYOHIgFCxYY9zVv/vdtwFqtFt988w3Wrl2LJ554AgCwYsUKtGnTBocOHcKjjz5aqzhYwSAiIrIWmU20ZTAYsGXLFrRs2RLh4eHw9fVFjx49TLpRkpOTUVJSYrJwaevWrREcHFztIqT3YoJBRERkJWKOwdDpdCZb0X0sxJmVlYW8vDx8+OGHeOqpp7Bz5048++yzeO6557Bv3z4AZQuXurq6wtvb2+Tc6hYurQwTDCIiIjsQFBQEtVpt3GJjY82+hsFgAAAMGTIEU6dORadOnTB9+nQ8/fTTiIuLEzVejsEgIiKyFhFvU01LSzOZaOt+Fvxs2LAhnJ2d0bZtW5P9bdq0wYEDBwCULVxaXFyMnJwckypGTYuQ3osVDCIiImsRo3vkrwRDpVKZbPeTYLi6uqJbt244f/68yf4LFy6gSZMmAIAuXbrAxcXFZBHS8+fPIzU11axFSFnBICIiqkPy8vJw6dIl4+PyRUl9fHwQHByMadOm4aWXXkKfPn3Qr18/bN++Hb/88gsSExMBAGq1GuPHj0dUVBR8fHygUqkwefJkhIaG1voOEoAJBhERkfVIMJPnsWPHTBYljYqKAvD3oqTPPvss4uLiEBsbizfffBOtWrXCjz/+iN69exvPWbhwIZRKJYYNG4aioiKEh4fj888/NysOLnZGRDbDxc5IDmy52Fmzf38AJwsXO9MXFuKPee/a3ecbx2AQERGR6NhFQkREZCX3s5ZIZdewR6xgEBERkeiYYBAREZHo2EVCRERkLRLcRSIXTDCIiIisxJHHYDDBICIisiY7TRAsxTEYREREJDpWMIiIiKyFYzCIiIhIbI48BoNdJERERCQ6VjCIiIishV0kREREJDZ2kRARERGJiBUMIiIia2EXCREREYnOgRMMdpEQERGR6FjBICIishIO8hRZbm4upkyZgiZNmsDDwwM9e/bE0aNHq2yfmJgIhUJRYdNoNNYIj4iIyDYEkTY7ZJUKxoQJE3Dq1CmsWrUKgYGBWL16NcLCwnDmzBk8+OCDVZ53/vx5qFQq42NfX19rhEdERGQbHIMhnjt37uDHH3/EggUL0KdPH7Ro0QIxMTFo0aIFli9fXu25vr6+8Pf3N25KJYeIEBER2SPRP8FLS0uh1+vh7u5ust/DwwMHDhyo9txOnTohICAATz75JH777bdq2xYVFUGn05lsREREclI+BsPSzR6JnmB4eXkhNDQUc+bMQXp6OvR6PVavXo2kpCRkZGRUek5AQADi4uLw448/4scff0RQUBD69u2L48ePV/k8sbGxUKvVxi0oKEjsH4WIiMgyDjwGQyEIguihX758Ga+88gr2798PJycndO7cGS1btkRycjLOnj1bq2s8/vjjCA4OxqpVqyo9XlRUhKKiIuNjnU6HoKAgaLVak3EcRCQfCoUCAGCFtx2iWtPpdFCr1Vb9vCh/jtaTP4CTm3vNJ1RDX1SIc0vetbvPN6sMcmjevDn27duHvLw8pKWl4ciRIygpKUGzZs1qfY3u3bvj0qVLVR53c3ODSqUy2YiIiOSEXSRW4unpiYCAANy+fRs7duzAkCFDan1uSkoKAgICrBgdERGRlTlwF4lVblPdsWMHBEFAq1atcOnSJUybNg2tW7fGuHHjAADR0dG4ceMGVq5cCQBYtGgRQkJC0K5dOxQWFuLrr7/Gnj17sHPnTmuER0RERFZmlQRDq9UiOjoa169fh4+PD4YNG4Z58+bBxcUFAJCRkYHU1FRj++LiYrz11lu4ceMG6tWrhw4dOmDXrl3o16+fNcIjIiKyDQeeB8MqgzylYItBO0RkGQ7yJDmw5SDPtm+IM8jzzOcc5ElERETExc6IiIisxoG7SJhgEBERWYkjr6bKBIOIiMhaHLiCwTEYREREJDpWMIiIiKzJTisQlmKCQUREZCWOPAaDXSREREQkOiYYRERE1iLBWiT79+/H4MGDERgYCIVCgY0bN1bZ9vXXX4dCocCiRYtM9mdnZ2PkyJFQqVTw9vbG+PHjkZeXZ1YcTDCIiIisRIrVVPPz89GxY0csW7as2nYbNmzAoUOHEBgYWOHYyJEjcfr0aSQkJGDz5s3Yv38/XnvtNbPi4BgMIiKiOiQiIgIRERHVtrlx4wYmT56MHTt2YNCgQSbHzp49i+3bt+Po0aPo2rUrAGDJkiUYOHAgPv7440oTksqwgkFERGQtInaR6HQ6k62oqOi+QjIYDBg1ahSmTZuGdu3aVTielJQEb29vY3IBAGFhYVAqlTh8+HCtn4cJBhERkZWI2UUSFBQEtVpt3GJjY+8rpvnz58PZ2Rlvvvlmpcc1Gg18fX1N9jk7O8PHxwcajabWz8MuEiIiIjuQlpZmspqqm5ub2ddITk7GZ599huPHjxtXN7YWVjCIiIisRcQuEpVKZbLdT4Lx66+/IisrC8HBwXB2doazszOuXbuGt956C02bNgUA+Pv7Iysry+S80tJSZGdnw9/fv9bPxQoGERGRtchsLZJRo0YhLCzMZF94eDhGjRqFcePGAQBCQ0ORk5OD5ORkdOnSBQCwZ88eGAwG9OjRo9bPxQSDiIjISqSYyTMvLw+XLl0yPr5y5QpSUlLg4+OD4OBgNGjQwKS9i4sL/P390apVKwBAmzZt8NRTT+HVV19FXFwcSkpKMGnSJAwfPrzWd5AA7CIhIiKqU44dO4ZHHnkEjzzyCAAgKioKjzzyCGbNmlXra6xZswatW7dG//79MXDgQPTu3RtffvmlWXGwgkFERGQtEnSR9O3bF4JQ+5OuXr1aYZ+Pjw/Wrl1r3hPfgwkGERGRlSgEAQozPuyruoY9YhcJERERiY4VDCIiImuR2V0ktsQEg4iIyEqkuItELthFQkRERKJjBYOIiMha2EVCREREYmMXCREREZGIWMEgIiKyFnaREBERkdgcuYuECQYREZG1sIJBRJYoNuiRcOMcfv/zBpQKBXr5NUMvv2ZQKhRShyYLpYZSfHvpgPHxgtNbMalVf9RzdpMwKvnQ6/VYd/1n7L+VBL2gh7+7L95o/gr8PXylDk02iu7sREFeHAQhF05OwfBUvQtnl+ZSh0XVsMogz9zcXEyZMgVNmjSBh4cHevbsiaNHj1Z7TmJiIjp37gw3Nze0aNEC8fHx1giNSHS/Z99A3y2fYerhn7D68lGsvHQE4w+sxcCdy5GWf1vq8CR39NYfeHTbXCy7sNu4b82VJPTcPg8/px2XMDJ5+CPvKkYffQObMrYjp0SL3NI8XMz7A1N/n4GFF+KkDk9yBoMOf2q6Q3d7HEpLDkNfegbFRdtx+2YfaLNflzq8WinvJrnfzV5ZJcGYMGECEhISsGrVKpw8eRIDBgxAWFgYbty4UWn7K1euYNCgQejXrx9SUlIwZcoUTJgwATt27LBGeESiuZGfg7H7VyO7qAAAUCoYUCoYAADX8rIxat8qFJQWSxmipG4V5uK1Q/EoEfQVjgkQMOv3Dfjf7TQJIpMHvV6PGadiYaiiBn4k+zj+c22DjaOSl9s3n4LBUPlnR3HhL8jVzrZxRGYSBHE2OyR6gnHnzh38+OOPWLBgAfr06YMWLVogJiYGLVq0wPLlyys9Jy4uDiEhIfjkk0/Qpk0bTJo0Cc8//zwWLlwodnhEolp16SgK9SWVfkDoBQHpBVr8knpKgsjk4eMz26v88Cw3/9QWG0UjP/HXvodQw+uzWZNgo2jkp7joMAz6a9W2Kcz/DgaDwUYRkTlETzBKS0uh1+vh7u5ust/DwwMHDhyo9JykpCSEhYWZ7AsPD0dSUlKVz1NUVASdTmeyEdnaluunoa/m24UCwLbrZ2wXkMz8lnWhxjZntOk2iESekv48ZvI480Q6Tn+XYrKvVCiFttgx39/u5H1Ri1YlKCnaa/VY7pel3SP23E0ieoLh5eWF0NBQzJkzB+np6dDr9Vi9ejWSkpKQkZFR6TkajQZ+fn4m+/z8/KDT6XDnzp1Kz4mNjYVarTZuQUFBYv8oRDWqqftDAJBXUmSbYGSo2FCxa6Qs7fpbTRWOukx/V9dRXkYu9r6xBSfjjkJfVGrSTleSa+vQZEEQ8mvVzmDItnIkFhBE2uyQVcZgrFq1CoIg4MEHH4SbmxsWL16MESNGQKkU7+mio6Oh1WqNW1qa4/bjknSaezWEElXfKeKkUKKl2nHvBGjk7lXJXtN3S08nV9sEI0NqFzUAoPROCTY/94Nxv5Ob6Q1+fu6NbBqXXDi7tKtVOxe3LlaOhO6HVRKM5s2bY9++fcjLy0NaWhqOHDmCkpISNGvWrNL2/v7+yMzMNNmXmZkJlUoFDw+PSs9xc3ODSqUy2YhsbWTzrtV+A9cLBgxv5rhvfq+06FNjm6cbd7J+IDI1IWQkBIOA/z4RDwBQOFd8S27o1gCuDpqE1fOKwr0Vr3splY3h7Fz5Z4scKAzibPbIqmuReHp6IiAgALdv38aOHTswZMiQStuFhoZi9+7dJvsSEhIQGhpqzfCILPZ08MPoH9iywltg+ePxLUPRwSfQ1mHJxnPBXdBWXfXP39CtPv7VLsKGEcnLw95tsDF8FQDAr/uDUN6TYCgA/Lv1VAkikwelsj486r9VXQuofL62WTz3hV0k4tqxYwe2b9+OK1euICEhAf369UPr1q0xbtw4AGXdG6NHjza2f/311/HHH3/g7bffxrlz5/D5559j3bp1mDrVcf+wyD44KZRY/OjzeOvhJ9DIvb5xf1OvBvigy2C83b6/hNHJw5pe/8QzjR+Bs+LvtxslFOjd6CFs6TcVrkrHne9v2LBhKMorG6PzxGeDTI55u6jwccf3HX6yrfqqqaivng+F4gGT/U7OLeDdcBtcXNtLFBnVRCEI4t9gu27dOkRHR+P69evw8fHBsGHDMG/ePKjVZf2NY8eOxdWrV5GYmGg8JzExEVOnTsWZM2fQuHFjzJw5E2PHjq31c+p0OqjVami1WnaXkCT0ggFZd3LhpFCikXt9KDiLpwmDwQAnJycAQJG+xKETCwD4+OOPMW3aNABld985OTmhnmc93Cm4g9yiXNR3rV/DFRxPaek1GPRZcHZpAaXygZpPqIItPi/Kn6P7kLlwdnGv+YRqlJYU4sjPM+zu880qCYYUmGAQyV950lVH3nbu286dOxEeHg4AJu9Znp6eKCgocPjXx9psmmA8M0ecBGPTTLv7fHPsrxBERDZ26dIlY3Jx/vx5u/rAIPM58mqqVh3kSUREf8vNzcVDDz0EANi6dStatmwpcURE1sMKBhGRDRgMBmO1IjY2FhERjnv3jEPhcu1ERGRN5csnDB48GNOnT5c4GrIVdpEQEZHVDBw4ECUlJXB3d8emTZukDofIJljBICKyog8++ADbtm0DAOTn125tDapDxFhu3U7vKmKCQURkJVu2bMG///1vAGUDPMVcj4nsA7tIiIhIVOfPn8fTTz8NALh8+TLq1+fEWeRYWMEgIhKZVqtF69atAZStq1TVQo/kAHgXCRERiUGv18Pb2xsA8MknnyAsLEzagEhS7CIhIiJRODuXfW974YUXEBUVJXE0RNJhBYOISCT9+5etnvvAAw9g3bp1EkdDsmAQyjZLr2GHmGAQEYkgJiYGe/bsAQDcunVL4mhINjgGg4iI7tfGjRvx3nvvASib64K3o1I5BUQYgyFKJLbHvwIiIgucOXMGzz77LADg6tWrqFevnsQRkaPbv38/Bg8ejMDAQCgUCmzcuNF4rKSkBO+88w7at28PT09PBAYGYvTo0UhPTze5RnZ2NkaOHAmVSgVvb2+MHz8eeXl5ZsXBBIOI6D7dvn0b7dq1AwAkJiaiSZMmEkdEslM+k6elmxny8/PRsWNHLFu2rMKxgoICHD9+HDNnzsTx48fx008/4fz583jmmWdM2o0cORKnT59GQkICNm/ejP379+O1114zKw52kRAR3YfS0lL4+PgAAJYuXYrHH39c4ohIjqS4TTUiIqLK1XrVajUSEhJM9i1duhTdu3dHamoqgoODcfbsWWzfvh1Hjx5F165dAQBLlizBwIED8fHHHyMwMLBWcbCCQURkJkEQ4OLiAgB4+eWXERkZKXFE5Ah0Op3JVlRUJMp1tVotFAqFcf6WpKQkeHt7G5MLAAgLC4NSqcThw4drfV0mGEREZurVqxcAIDAwEKtWrZI4GpI1QaQNQFBQENRqtXGLjY21OLzCwkK88847GDFiBFQqFQBAo9HA19fXpJ2zszN8fHyg0WhqfW12kRARmWH69OlISkoCAFy/fl3iaEjuFIIAhYWroZafn5aWZkwCAMDNzc2i65aUlODFF1+EIAhYvny5RdeqDBMMIqJaWrduHebPnw+gbLCcQmGvNxCSPVKpVCYJhiXKk4tr165hz549Jtf19/dHVlaWSfvS0lJkZ2fD39+/1s/BLhIiolr4/fff8dJLLwEo+ybp4eEhcURkFwwibSIqTy4uXryIXbt2oUGDBibHQ0NDkZOTg+TkZOO+PXv2wGAwoEePHrV+HlYwiIhqcOvWLXTq1AkAcODAATRu3FjagMhuiNlFUlt5eXm4dOmS8fGVK1eQkpICHx8fBAQE4Pnnn8fx48exefNm6PV647gKHx8fuLq6ok2bNnjqqafw6quvIi4uDiUlJZg0aRKGDx9e6ztIACYYRETVKikpQaNGjQAAX375pXGAJ5FcHTt2DP369TM+Ll90b8yYMYiJicGmTZsAwJg0l9u7dy/69u0LAFizZg0mTZqE/v37Q6lUYtiwYVi8eLFZcTDBICKqgiAIcHV1BQCMHz8er776qsQRkd2RYC2Svn37Qqim6lHdsXI+Pj5Yu3ateU98DyYYRERV6NKlCwAgJCQEX3/9tcTRkF26j5k4K72GHWKCQURUiaioKJw4cQIAcPnyZYmjIXslxUyecsG7SIiI7rFmzRosXLgQQNlERLwdlch8rGAQEd0lOTkZL7/8MgAgPT3d4smMyMGxi4SIiLKysozrLxw+fBgBAQESR0T2TmEo2yy9hj1iFwkREYDi4mL4+fkBAOLj49G9e3eJIyKyb6InGHq9HjNnzkRISAg8PDzQvHlzzJkzp9rbYhITE6FQKCps5iyqQkR0vwRBMHaFREZGYsyYMRJHRHVGeReJpZsdEr2LZP78+Vi+fDm+++47tGvXDseOHcO4ceOgVqvx5ptvVnvu+fPnTeZDv3c1NyIia3j44YcBAG3btsXSpUsljobqFAnmwZAL0ROMgwcPYsiQIRg0aBAAoGnTpvj+++9x5MiRGs/19fU1rkdPRGQLkZGROHPmDADg1KlTEkdDVHeI3kXSs2dP7N69GxcuXABQtkDQgQMHEBERUeO5nTp1QkBAAJ588kn89ttv1bYtKiqCTqcz2YiIzBEfH4/PP/8cQNl7Cm9HJbGVr0Vi6WaPRK9gTJ8+HTqdDq1bt4aTkxP0ej3mzZuHkSNHVnlOQEAA4uLi0LVrVxQVFeHrr79G3759cfjwYXTu3LnSc2JjY/Hee++JHT4ROYgjR45g3LhxAIDMzEzjlOBEouJtquJZt24d1qxZg7Vr16Jdu3ZISUnBlClTEBgYWOXAqVatWqFVq1bGxz179sTly5excOFCrFq1qtJzoqOjjQu4AIBOp0NQUJC4PwwR1UkZGRnGZaeTk5M53ovICkRPMKZNm4bp06dj+PDhAID27dvj2rVriI2NNWtkdvfu3XHgwIEqj7u5uXECHCIyW1FRkXHJ6TVr1lRZJSUShQDA0nks7LOAIX6CUVBQAKXSdGiHk5MTDAbzXuGUlBROckNEohIEAe7u7gDK1hr5xz/+IXFEVNeJMYaCYzD+MnjwYMybNw/BwcFo164dTpw4gU8//RSvvPKKsU10dDRu3LiBlStXAgAWLVqEkJAQtGvXDoWFhfj666+xZ88e7Ny5U+zwiMiBNW/eHEDZKqmffPKJxNGQQxAgwhgMUSKxOdETjCVLlmDmzJl44403kJWVhcDAQPzzn//ErFmzjG0yMjKQmppqfFxcXIy33noLN27cQL169dChQwfs2rUL/fr1Ezs8InJQ48ePx5UrVwAAR48elTgaorpPIVQ3xaYd0el0UKvV0Gq1JpN1EZF8lN8Gauu3nS+++AKvv/46gLIvNC4uLjZ9/try9PREQUGBzV8fR2OLz4vy53ii4ztwdrJsvGCpvgh7fp9vd59vXOyMiOq0AwcOGJOLmzdvyja5oDrKAMDS6VW42BkRkbxcv34djz32GICySf8aNmwocUREjoMVDCKqk+7cuWOcG2f9+vXo0KGDxBGRI+JdJEREdYggCKhXrx6AsrvWnn/+eYkjIoflwDN5souEiOqc8om0evXqhQ8++EDiaIgcEysYRFSnvPzyy9BoNABQ7WzARDbhwBUMJhhEVGcsXboUa9asAQCUlJRIHA0RHDrBYBcJEdUJiYmJmDx5MgAgOzsbzs78/kQkJf4FEpHdu3btmnHm39OnT+OBBx6QOCKivzjwPBhMMIjIruXn56Np06YAgI0bN6Jt27bSBkR0F96mSkRkhwwGA+rXrw8AmD17NoYMGSJxRET34BgMIiL706BBAwBA//79ERMTI20wRGSCFQwisksvvPACcnJyAAC7du2SNhiiqhgEQGFhBcJgnxUMJhhEZHc+/fRT/Pe//wUAlJaWShwNUTXYRUJEZB8SEhLw1ltvAQBycnLg5OQkcUREVBlWMIjIbly+fBkDBgwAAJw7dw5qtVriiIhqIkIFA/ZZwWCCQUR2ITc3Fy1atAAAbNmyBa1atZI4IqJaYBcJEZF8GQwGqFQqAMAHH3yAgQMHShwREdWEFQwikj1PT08AwKBBgxAdHS1xNERmMAiwuIvDTu8iYQWDiGTt6aefRmFhIVxdXbF582apwyEyj2AQZzPD/v37MXjwYAQGBkKhUGDjxo2mIQkCZs2ahYCAAHh4eCAsLAwXL140aZOdnY2RI0dCpVLB29sb48ePR15enllxMMEgItmKjY3Fli1bAAB37tyROBoi+5Cfn4+OHTti2bJllR5fsGABFi9ejLi4OBw+fBienp4IDw9HYWGhsc3IkSNx+vRpJCQkYPPmzdi/fz9ee+01s+JgFwkRydLWrVvx7rvvAgB0Oh2USn4fIjskwSDPiIgIREREVHEpAYsWLcKMGTOMU+uvXLkSfn5+2LhxI4YPH46zZ89i+/btOHr0KLp27QoAWLJkCQYOHIiPP/4YgYGBtYqDf7FEJDsXLlzAoEGDAACXLl2Cl5eXxBER3SeDIM4mkitXrkCj0SAsLMy4T61Wo0ePHkhKSgIAJCUlwdvb25hcAEBYWBiUSiUOHz5c6+diBYOIZEWr1RpvQd25cyeaN28ucUREFhCxgqHT6Ux2u7m5wc3NzaxLaTQaAICfn5/Jfj8/P+MxjUYDX19fk+POzs7w8fExtqkNVjCISDb0ej28vb0BAJ988gmefPJJaQMikpGgoCCo1WrjFhsbK3VI1WIFg4hkw9m57C1p2LBhiIqKkjgaIhEIEKGCUfZ/aWlpxvlgAJhdvQAAf39/AEBmZiYCAgKM+zMzM9GpUydjm6ysLJPzSktLkZ2dbTy/NljBICJZKK9WqNVq40JmRHavvIvE0g2ASqUy2e4nwQgJCYG/vz92795t3KfT6XD48GGEhoYCAEJDQ5GTk4Pk5GRjmz179sBgMKBHjx61fi5WMIhIcu+9955xyfXs7GyJoyGyb3l5ebh06ZLx8ZUrV5CSkgIfHx8EBwdjypQpmDt3Lh566CGEhIRg5syZCAwMxNChQwEAbdq0wVNPPYVXX30VcXFxKCkpwaRJkzB8+PBa30ECMMEgIolt2rQJMTExAMreGHk7KtUpBgMA8ybKqvwatXfs2DH069fP+Li8u3HMmDGIj4/H22+/jfz8fLz22mvIyclB7969sX37dri7uxvPWbNmDSZNmoT+/ftDqVRi2LBhWLx4sVlxKATBTldRuYdOp4NarYZWqzXpoyIi+VAoFADK7sUHgDNnzqBdu3YAyr5lNW3aVKrQZMHT0xMFBQWoI2/LsmWLz4vy5whrNB7OSleLrlVqKMaum9/Y3ecbvyoQkdWVGEqRkJFifLzx+iHcuKkxJhd79+516OSi1FCKbek/oUQoBgAsv/QRMu7ckDgq+TDo9TDo5sOQ2R0GTScYsvrCcGe71GFRDURPMPR6PWbOnImQkBB4eHigefPmmDNnTo0ZeWJiIjp37gw3Nze0aNEC8fHxYodGRBL4I0+DFw7MR8yp7437Fpz6EY19y0awL168GH379pUoOuldL7iKab9PwFbNj39XdnQp+ODs2/jPtW8ljk56htLrwM32QME3gJADoAAwpAPaN2G42V/q8Gom4iBPeyN6gjF//nwsX74cS5cuxdmzZzF//nwsWLAAS5YsqfKcK1euYNCgQejXrx9SUlIwZcoUTJgwATt27BA7PCKyobySO3gz+Sv8WZRrsj8p4mMAgO8T7fDs+H9IEZoslBpK8cn5GJQKJZUeP/DnbuzNdPBv6rciAJRWfkyfBsOtETYNx2wym8nTlkRPMA4ePIghQ4Zg0KBBaNq0KZ5//nkMGDAAR44cqfKcuLg4hISE4JNPPkGbNm0wadIkPP/881i4cKHY4RGRDW3LOI6c4jwYKlmu2uUBT7SKHoz/pv4mQWTykKDZVGVyUW67ZoONopEfQ8GPAIqqb1SaDIO+2CbxkHlETzB69uyJ3bt348KFCwCA33//HQcOHKhy4RWgbN7zu+dFB4Dw8HDjvOiVKSoqgk6nM9mISF72ZZ2qJLUo0/WHN6AXDNibddKmMclJco7pe5yTq1OFNgX6PBSU5tsqJHnJ/7p27QrXWTcOCwiCQZTNHol+m+r06dOh0+nQunVrODk5Qa/XY968eRg5cmSV52g0mkrnRdfpdLhz5w48PDwqnBMbG4v33ntP7PCJSESF93yzdPVVoThLhx6/TDXeUVKkr/4bfF1WajAt/T/1YW+c33q1QrsiQyHqwdNGUclJLSsTgta6YVhCEKGLw07HYIieYKxbtw5r1qzB2rVr0a5dO+OYisDAQIwZM0a054mOjjaZSlin0yEoKEi06xOR5Vp6PYgLuenQ//UNrOvq1yHoDVA4lRVPlVCghVdAdZeo0/zdH8SfxX9PyRzUwx9BPUynYlZAAbXzA7YOTR6c2wP6tJrbuYbV3EYqggBUWccz5xr2R/QEY9q0aZg+fTqGDx8OAGjfvj2uXbuG2NjYKhMMf39/ZGZmmuzLzMyESqWqtHoB3N8qckRkW0ODHsXPN0yXdy5PLgDAAAHPB/WydViy8VzjkTh95kS1bVp5tXfcycdUc4GbW2to5AmlayubhEPmEf23tqCgoMIfg5OTEwzVzEQWGhpqMi86ACQkJBjnRSci+9TSKxCvNh8AoKxaUa78vwYGdMHjvu0kiEwefN0D8FjDqr99uys98ErIZBtGJC9Kp/qARw2Vbx+Z38prMIiz2SHRKxiDBw/GvHnzEBwcjHbt2uHEiRP49NNP8corrxjbREdH48aNG1i5ciUA4PXXX8fSpUvx9ttv45VXXsGePXuwbt06bNmyRezwiMjGxjbrj5D6flhzdR9Oa1MBAE08ffFScG88/WA341gMR/Vi8Dj4uQdgW8ZG5OvLbudVQIHWXh0wNiQSHs71JI5QWkr1v2FwehDIWwjgzl0HfAHv5VC6tpcstlpx4C4S0acKz83NxcyZM7FhwwZkZWUhMDAQI0aMwKxZs+DqWjZd6tixY3H16lUkJiYaz0tMTMTUqVNx5swZNG7cGDNnzsTYsWNr/bycKpxI/or0JdALBtRzZvdmZe6UFqDIUASVs9pxu0WqYdBrAf0twCkISqf7n37bllOF96//DzgrLJwqXCjG7ry1dvf5xrVIiIjIodgywXii3nBREow9BT/Y3ecbV1MlIiKyFgfuImENjoiIiETHCgYREZG1GARA4ZgVDCYYRERE1iIIACy8zdROEwx2kRAREZHoWMEgIiKyEsEgQLCwi8Reb/ZkgkFERGQtggGWd5FwJk8iIiK6iyNXMDgGg4iIiERXZyoY5RmeTqeTOBIiIpKz8s8JW1QGSoUii7s4SlEiUjS2VWcSjNzcskWCgoKCJI6EiIjsQW5uLtRqtVWu7erqCn9/fxzQ1LTcfO34+/sb1/OyF3VmLRKDwYD09HR4eXlZtDqjTqdDUFAQ0tLS7GrOd1vh61M9vj7V4+tTPb4+1RPr9REEAbm5uQgMDLTqonKFhYUoLi4W5Vqurq5wd3cX5Vq2UmcqGEqlEo0bNxbteiqVin/g1eDrUz2+PtXj61M9vj7VE+P1sVbl4m7u7u52lxSIiYM8iYiISHRMMIiIiEh0TDDu4ebmhtmzZ8PNzU3qUGSJr0/1+PpUj69P9fj6VI+vj32pM4M8iYiISD5YwSAiIiLRMcEgIiIi0THBICIiItExwSAiIiLRMcEAEBsbi27dusHLywu+vr4YOnQozp8/L3VYsrF8+XJ06NDBOLlNaGgotm3bJnVYsvXhhx9CoVBgypQpUociGzExMVAoFCZb69atpQ5LVm7cuIGXX34ZDRo0gIeHB9q3b49jx45JHZYsNG3atMLvj0KhQGRkpNShUTXqzEyelti3bx8iIyPRrVs3lJaW4t1338WAAQNw5swZeHp6Sh2e5Bo3bowPP/wQDz30EARBwHfffYchQ4bgxIkTaNeundThycrRo0fxxRdfoEOHDlKHIjvt2rXDrl27jI+dnfn2U+727dvo1asX+vXrh23btqFRo0a4ePEiHnjgAalDk4WjR49Cr9cbH586dQpPPvkkXnjhBQmjoprwNtVK3Lx5E76+vti3bx/69OkjdTiy5OPjg48++gjjx4+XOhTZyMvLQ+fOnfH5559j7ty56NSpExYtWiR1WLIQExODjRs3IiUlRepQZGn69On47bff8Ouvv0odil2YMmUKNm/ejIsXL1q09hRZF7tIKqHVagGUfYiSKb1ejx9++AH5+fkIDQ2VOhxZiYyMxKBBgxAWFiZ1KLJ08eJFBAYGolmzZhg5ciRSU1OlDkk2Nm3ahK5du+KFF16Ar68vHnnkEXz11VdShyVLxcXFWL16NV555RUmFzLHGuU9DAYDpkyZgl69euHhhx+WOhzZOHnyJEJDQ1FYWIj69etjw4YNaNu2rdRhycYPP/yA48eP4+jRo1KHIks9evRAfHw8WrVqhYyMDLz33nt47LHHcOrUKXh5eUkdnuT++OMPLF++HFFRUXj33Xdx9OhRvPnmm3B1dcWYMWOkDk9WNm7ciJycHIwdO1bqUKgG7CK5x8SJE7Ft2zYcOHBA1NVZ7V1xcTFSU1Oh1Wrx3//+F19//TX27dvHJANAWloaunbtioSEBOPYi759+7KLpBo5OTlo0qQJPv30U3azoWwp7q5du+LgwYPGfW+++SaOHj2KpKQkCSOTn/DwcLi6uuKXX36ROhSqAbtI7jJp0iRs3rwZe/fuZXJxD1dXV7Ro0QJdunRBbGwsOnbsiM8++0zqsGQhOTkZWVlZ6Ny5M5ydneHs7Ix9+/Zh8eLFcHZ2NhmcRmW8vb3RsmVLXLp0SepQZCEgIKBCst6mTRt2I93j2rVr2LVrFyZMmCB1KFQL7CIBIAgCJk+ejA0bNiAxMREhISFShyR7BoMBRUVFUochC/3798fJkydN9o0bNw6tW7fGO++8AycnJ4kik6+8vDxcvnwZo0aNkjoUWejVq1eFW+MvXLiAJk2aSBSRPK1YsQK+vr4YNGiQ1KFQLTDBQNngvLVr1+Lnn3+Gl5cXNBoNAECtVsPDw0Pi6KQXHR2NiIgIBAcHIzc3F2vXrkViYiJ27NghdWiy4OXlVWG8jqenJxo0aMBxPH/517/+hcGDB6NJkyZIT0/H7Nmz4eTkhBEjRkgdmixMnToVPXv2xAcffIAXX3wRR44cwZdffokvv/xS6tBkw2AwYMWKFRgzZgxvcbYT/FdC2URSQFm/+d1WrFjBgUQAsrKyMHr0aGRkZECtVqNDhw7YsWMHnnzySalDIztx/fp1jBgxAn/++ScaNWqE3r1749ChQ2jUqJHUoclCt27dsGHDBkRHR+P9999HSEgIFi1ahJEjR0odmmzs2rULqampeOWVV6QOhWqJgzyJiIhIdBzkSURERKJjgkFERESiY4JBREREomOCQURERKJjgkFERESiY4JBREREomOCQURERKJjgkFERESiY4JBREREomOCQURERKJjgkFERESiY4JBREREovt/BmS8pZRNXwAAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stats2 = Table.read(statfile, format=\"ascii\")\n",
    "\n",
    "plt.scatter(stats2[\"mdl.xlow\"], stats2[\"mdl.xhi\"], c=stats2[\"statistic\"])\n",
    "plt.colorbar()\n",
    "\n",
    "store = ui.get_fit_results().extra_output[\"store\"]\n",
    "pxlo = None\n",
    "pxhi = None\n",
    "for xlo, xhi in store:\n",
    "    if pxlo is not None:\n",
    "        plt.arrow(pxlo, pxhi, xlo - pxlo, xhi - pxhi)\n",
    "\n",
    "    pxlo, pxhi = xlo, xhi\n",
    "\n",
    "# There's no points where xlow >= xhi, so don't bother with adding a line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46481778-a3a5-4729-bbbd-3f469b6d2ada",
   "metadata": {},
   "source": [
    "The statistic points also show a slight difference in behaviour. What is most interesting - but only if you are interested in the weeds of the optimization code, which you might just be if you're reading this - is that the number of function evaluations seems to stop at 41, even though we were told there were 45."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8e3c0d85-a33c-48c3-bf09-b9cd2bb475ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ui.plot_scatter(stats[\"nfev\"], stats[\"statistic\"], xlabel=\"evalation\", ylabel=\"statistic\")\n",
    "ui.plot_scatter(stats2[\"nfev\"], stats2[\"statistic\"], overplot=True, alpha=0.5, color=\"orange\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07a42186-8f8c-4dec-a337-d5252ed04b07",
   "metadata": {},
   "source": [
    "Just to check (the first row is labelled 0 as it is likely to represent the input values, as it is in the case of `opty`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1b3ac215-f7d9-4fbb-90ff-2278748cfead",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(stats2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0135adc8-b2b0-4ff6-b747-bedc7ba7ac42",
   "metadata": {},
   "source": [
    "## Actually, come to think of it, just how is this output file created?\n",
    "\n",
    "If we look at `opty`, there's no obvious way for this file to be created (i.e. `opty` has no knowledge of it). This is because the fit code sets up the `fcn` that is sent to the optimiser to append to this file each time it is called. However, we would still expect there to be 45 and not 42 records, because we tracked them. The issue is that in `InfinitePotential` we check whether all the parameters are valid - i.e. within the minimum and maximum ranges - with\n",
    "\n",
    "```python\n",
    "    def __call__(self, pars: np.ndarray) -> SupportsFloat:\n",
    "        if np.isnan(pars).any() or _outside_limits(pars,\n",
    "                                                   self.minval,\n",
    "                                                   self.maxval):\n",
    "            return FUNC_MAX\n",
    "\n",
    "        return self.func(pars)[0]\n",
    "```\n",
    "\n",
    "and this is done before calling the statistic call back function. So, we end up losing a record of any set of parameters which are out-of-bounds. So, there must have been three locations we checked which hit this condition (actually, as we do not encode any sort of \"already seen\" check, it could be the same location checked three times).\n",
    "\n",
    "## Is it worth adding a check for already-seen locations?\n",
    "\n",
    "Now, this is really-not-an-optimizer, so it's not really worth spending time trying to optimize it's performamce. Saying that, we could make some simple additions such as\n",
    "\n",
    "- don't ever evaluate the \"0, 0, ..\" bin since we will already have seen it\n",
    "- track the evaluated locations so we don't bother re-evaluating them (which is a superset of the previous item)\n",
    "\n",
    "However, there are cases when other parts of the Sherpa ecosystem can come into play. We currently support a per-model cache which will avoid model evaluation when it has seen the parameters before (it only stores a small number of values so it can depend on how the optimizer works whether this comes into play). The [`cache_status`](https://sherpa.readthedocs.io/en/4.16.1/model_classes/api/sherpa.models.model.ArithmeticModel.html#sherpa.models.model.ArithmeticModel.cache_status) method shows the current cache data.  Here we can see that the model has been evaluated 44 times and 4 of them were repeat checks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "81ecc346-3205-4aff-8512-bd15b9fefa18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " box1d.mdl                  size:    5  hits:     4  misses:    40  check:    44\n"
     ]
    }
   ],
   "source": [
    "mdl.cache_status()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a5e2b77-f630-4a8e-b92a-c7c76f15bfaf",
   "metadata": {},
   "source": [
    "If we reset the model and the cache we can see what happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "47a5301f-1d7f-4b65-9382-4ebedd9b7443",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d.mdl\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   mdl.xlow     thawed            7 -3.40282e+38            7           \n",
      "   mdl.xhi      thawed            8            8  3.40282e+38           \n",
      "   mdl.ampl     frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "mdl.cache_clear()\n",
    "mdl.reset()\n",
    "print(mdl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2840cbe7-05fc-4bab-bf24-f257aff4c928",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " box1d.mdl                  size:    1  hits:     0  misses:     0  check:     0\n"
     ]
    }
   ],
   "source": [
    "mdl.cache_status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5a27f299-dfce-4893-bbaf-c0159f2a4e82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset               = 1\n",
      "Method                = opty\n",
      "Statistic             = leastsq\n",
      "Initial fit statistic = 243\n",
      "Final fit statistic   = 88 at function evaluation 45\n",
      "Data points           = 15\n",
      "Degrees of freedom    = 13\n",
      "Change in statistic   = 155\n",
      "   mdl.xlow       3           \n",
      "   mdl.xhi        11          \n"
     ]
    }
   ],
   "source": [
    "ui.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7ca251d3-cada-4def-95fe-1575cf4e7a5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " box1d.mdl                  size:    5  hits:     4  misses:    40  check:    44\n"
     ]
    }
   ],
   "source": [
    "mdl.cache_status()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8eda6e-33d5-47de-9535-e2988f4aef24",
   "metadata": {},
   "source": [
    "Note that the putput of line 40 is the same as line 36 even though the former was after two `fit` calls. This is because the `fit` call will internally clear the cache before it starts: this is because the cache is not infallible, as we assume - but can not **guarantee** - that the model evaluation only depends on the parameter values and the data grid (independent axis) - and so it's safest for `fit` to reset it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c38eed3-e7b1-426e-9197-02f96b0a7943",
   "metadata": {},
   "source": [
    "# I really want to do this with objects\n",
    "\n",
    "For those interested in using the more-OO interface, here's how you can re-create the first run through from above.\n",
    "\n",
    "We need to create\n",
    "\n",
    "- data object\n",
    "- model object\n",
    "- stats object\n",
    "- optimizer object\n",
    "\n",
    "and the we can ass that through to a [fit object](https://sherpa.readthedocs.io/en/4.16.1/fit/index.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "42cc00e3-eb8d-4986-9d04-3bf33cc2ce8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/*\n",
       "Copyright (C) 2020  Smithsonian Astrophysical Observatory\n",
       "\n",
       "\n",
       " This program is free software; you can redistribute it and/or modify\n",
       " it under the terms of the GNU General Public License as published by\n",
       " the Free Software Foundation; either version 3 of the License, or\n",
       " (at your option) any later version.\n",
       "\n",
       " This program is distributed in the hope that it will be useful,\n",
       " but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
       " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
       " GNU General Public License for more details.\n",
       "\n",
       " You should have received a copy of the GNU General Public License along\n",
       " with this program; if not, write to the Free Software Foundation, Inc.,\n",
       " 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n",
       "\n",
       "*/\n",
       "\n",
       ":root {\n",
       "  --sherpa-border-color: var(--jp-border-color2, #e0e0e0);\n",
       "  --sherpa-background-color: var(--jp-layout-color0, white);\n",
       "  --sherpa-background-color-row-even: var(--jp-layout-color1, white);\n",
       "  --sherpa-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
       "\n",
       "  /* https://medium.com/ge-design/iot-cool-gray-is-a-great-background-color-for-data-visualization-ebf18c318418 */\n",
       "  --sherpa-background-color-dark1: #EBEFF2;\n",
       "  --sherpa-background-color-dark2: #D8E0E5;\n",
       "}\n",
       "\n",
       "div.sherpa-text-fallback {\n",
       "    display: none;\n",
       "}\n",
       "\n",
       "div.sherpa {\n",
       "    display: block;\n",
       "}\n",
       "\n",
       "div.sherpa details summary {\n",
       "    display: list-item;  /* needed for notebook, not lab */\n",
       "    font-size: larger;\n",
       "}\n",
       "\n",
       "div.sherpa details div.datavals {\n",
       "    display: grid;\n",
       "    grid-template-columns: 1fr 3fr;\n",
       "    column-gap: 0.5em;\n",
       "}\n",
       "\n",
       "div.sherpa div.dataname {\n",
       "    font-weight: bold;\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa div.dataval { }\n",
       "\n",
       "div.sherpa div.datavals div:nth-child(4n + 1) ,\n",
       "div.sherpa div.datavals div:nth-child(4n + 2) {\n",
       "    background: var(--sherpa-background-color-row-odd);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tbody {\n",
       "    border-bottom: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tr.block {\n",
       "    border-top: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd ,\n",
       "div.sherpa table.model th.model-even {\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd {\n",
       "    background: var(--sherpa-background-color-dark1);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-even {\n",
       "    background: var(--sherpa-background-color-dark2);\n",
       "}\n",
       "\n",
       "div.sherpa .failed {\n",
       "    background: orange;\n",
       "    font-size: large;\n",
       "    padding: 1em;\n",
       "}\n",
       "</style><div class=\"sherpa-text-fallback\">&lt;Data1D data set instance &#x27;Alexander&#x27;&gt;</div><div hidden class=\"sherpa\"><style>/*\n",
       "Copyright (C) 2020  Smithsonian Astrophysical Observatory\n",
       "\n",
       "\n",
       " This program is free software; you can redistribute it and/or modify\n",
       " it under the terms of the GNU General Public License as published by\n",
       " the Free Software Foundation; either version 3 of the License, or\n",
       " (at your option) any later version.\n",
       "\n",
       " This program is distributed in the hope that it will be useful,\n",
       " but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
       " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
       " GNU General Public License for more details.\n",
       "\n",
       " You should have received a copy of the GNU General Public License along\n",
       " with this program; if not, write to the Free Software Foundation, Inc.,\n",
       " 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n",
       "\n",
       "*/\n",
       "\n",
       ":root {\n",
       "  --sherpa-border-color: var(--jp-border-color2, #e0e0e0);\n",
       "  --sherpa-background-color: var(--jp-layout-color0, white);\n",
       "  --sherpa-background-color-row-even: var(--jp-layout-color1, white);\n",
       "  --sherpa-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
       "\n",
       "  /* https://medium.com/ge-design/iot-cool-gray-is-a-great-background-color-for-data-visualization-ebf18c318418 */\n",
       "  --sherpa-background-color-dark1: #EBEFF2;\n",
       "  --sherpa-background-color-dark2: #D8E0E5;\n",
       "}\n",
       "\n",
       "div.sherpa-text-fallback {\n",
       "    display: none;\n",
       "}\n",
       "\n",
       "div.sherpa {\n",
       "    display: block;\n",
       "}\n",
       "\n",
       "div.sherpa details summary {\n",
       "    display: list-item;  /* needed for notebook, not lab */\n",
       "    font-size: larger;\n",
       "}\n",
       "\n",
       "div.sherpa details div.datavals {\n",
       "    display: grid;\n",
       "    grid-template-columns: 1fr 3fr;\n",
       "    column-gap: 0.5em;\n",
       "}\n",
       "\n",
       "div.sherpa div.dataname {\n",
       "    font-weight: bold;\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa div.dataval { }\n",
       "\n",
       "div.sherpa div.datavals div:nth-child(4n + 1) ,\n",
       "div.sherpa div.datavals div:nth-child(4n + 2) {\n",
       "    background: var(--sherpa-background-color-row-odd);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tbody {\n",
       "    border-bottom: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tr.block {\n",
       "    border-top: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd ,\n",
       "div.sherpa table.model th.model-even {\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd {\n",
       "    background: var(--sherpa-background-color-dark1);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-even {\n",
       "    background: var(--sherpa-background-color-dark2);\n",
       "}\n",
       "\n",
       "div.sherpa .failed {\n",
       "    background: orange;\n",
       "    font-size: large;\n",
       "    padding: 1em;\n",
       "}\n",
       "</style><div class=\"sherpa-text-fallback\">&lt;sherpa.plot.DataPlot object at 0x798b847ec910&gt;</div><div hidden class=\"sherpa\"><details open><summary>Data1D Plot</summary><svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"460.8pt\" height=\"345.6pt\" viewBox=\"0 0 460.8 345.6\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n",
       " <metadata>\n",
       "  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
       "   <cc:Work>\n",
       "    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n",
       "    <dc:date>2024-05-27T09:55:56.351122</dc:date>\n",
       "    <dc:format>image/svg+xml</dc:format>\n",
       "    <dc:creator>\n",
       "     <cc:Agent>\n",
       "      <dc:title>Matplotlib v3.9.0, https://matplotlib.org/</dc:title>\n",
       "     </cc:Agent>\n",
       "    </dc:creator>\n",
       "   </cc:Work>\n",
       "  </rdf:RDF>\n",
       " </metadata>\n",
       " <defs>\n",
       "  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n",
       " </defs>\n",
       " <g id=\"figure_1\">\n",
       "  <g id=\"patch_1\">\n",
       "   <path d=\"M 0 345.6 \n",
       "L 460.8 345.6 \n",
       "L 460.8 0 \n",
       "L 0 0 \n",
       "z\n",
       "\" style=\"fill: #ffffff\"/>\n",
       "  </g>\n",
       "  <g id=\"axes_1\">\n",
       "   <g id=\"patch_2\">\n",
       "    <path d=\"M 57.6 307.584 \n",
       "L 414.72 307.584 \n",
       "L 414.72 41.472 \n",
       "L 57.6 41.472 \n",
       "z\n",
       "\" style=\"fill: #ffffff\"/>\n",
       "   </g>\n",
       "   <g id=\"matplotlib.axis_1\">\n",
       "    <g id=\"xtick_1\">\n",
       "     <g id=\"line2d_1\">\n",
       "      <defs>\n",
       "       <path id=\"mf4eec48e4f\" d=\"M 0 0 \n",
       "L 0 3.5 \n",
       "\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </defs>\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"97.022338\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_1\">\n",
       "      <!-- 2 -->\n",
       "      <g transform=\"translate(93.841088 322.182437) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \n",
       "L 3431 531 \n",
       "L 3431 0 \n",
       "L 469 0 \n",
       "L 469 531 \n",
       "Q 828 903 1448 1529 \n",
       "Q 2069 2156 2228 2338 \n",
       "Q 2531 2678 2651 2914 \n",
       "Q 2772 3150 2772 3378 \n",
       "Q 2772 3750 2511 3984 \n",
       "Q 2250 4219 1831 4219 \n",
       "Q 1534 4219 1204 4116 \n",
       "Q 875 4013 500 3803 \n",
       "L 500 4441 \n",
       "Q 881 4594 1212 4672 \n",
       "Q 1544 4750 1819 4750 \n",
       "Q 2544 4750 2975 4387 \n",
       "Q 3406 4025 3406 3419 \n",
       "Q 3406 3131 3298 2873 \n",
       "Q 3191 2616 2906 2266 \n",
       "Q 2828 2175 2409 1742 \n",
       "Q 1991 1309 1228 531 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-32\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_2\">\n",
       "     <g id=\"line2d_2\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"143.401558\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_2\">\n",
       "      <!-- 4 -->\n",
       "      <g transform=\"translate(140.220308 322.182437) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \n",
       "L 825 1625 \n",
       "L 2419 1625 \n",
       "L 2419 4116 \n",
       "z\n",
       "M 2253 4666 \n",
       "L 3047 4666 \n",
       "L 3047 1625 \n",
       "L 3713 1625 \n",
       "L 3713 1100 \n",
       "L 3047 1100 \n",
       "L 3047 0 \n",
       "L 2419 0 \n",
       "L 2419 1100 \n",
       "L 313 1100 \n",
       "L 313 1709 \n",
       "L 2253 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-34\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_3\">\n",
       "     <g id=\"line2d_3\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"189.780779\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_3\">\n",
       "      <!-- 6 -->\n",
       "      <g transform=\"translate(186.599529 322.182437) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \n",
       "Q 1688 2584 1439 2293 \n",
       "Q 1191 2003 1191 1497 \n",
       "Q 1191 994 1439 701 \n",
       "Q 1688 409 2113 409 \n",
       "Q 2538 409 2786 701 \n",
       "Q 3034 994 3034 1497 \n",
       "Q 3034 2003 2786 2293 \n",
       "Q 2538 2584 2113 2584 \n",
       "z\n",
       "M 3366 4563 \n",
       "L 3366 3988 \n",
       "Q 3128 4100 2886 4159 \n",
       "Q 2644 4219 2406 4219 \n",
       "Q 1781 4219 1451 3797 \n",
       "Q 1122 3375 1075 2522 \n",
       "Q 1259 2794 1537 2939 \n",
       "Q 1816 3084 2150 3084 \n",
       "Q 2853 3084 3261 2657 \n",
       "Q 3669 2231 3669 1497 \n",
       "Q 3669 778 3244 343 \n",
       "Q 2819 -91 2113 -91 \n",
       "Q 1303 -91 875 529 \n",
       "Q 447 1150 447 2328 \n",
       "Q 447 3434 972 4092 \n",
       "Q 1497 4750 2381 4750 \n",
       "Q 2619 4750 2861 4703 \n",
       "Q 3103 4656 3366 4563 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-36\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_4\">\n",
       "     <g id=\"line2d_4\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"236.16\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_4\">\n",
       "      <!-- 8 -->\n",
       "      <g transform=\"translate(232.97875 322.182437) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-38\" d=\"M 2034 2216 \n",
       "Q 1584 2216 1326 1975 \n",
       "Q 1069 1734 1069 1313 \n",
       "Q 1069 891 1326 650 \n",
       "Q 1584 409 2034 409 \n",
       "Q 2484 409 2743 651 \n",
       "Q 3003 894 3003 1313 \n",
       "Q 3003 1734 2745 1975 \n",
       "Q 2488 2216 2034 2216 \n",
       "z\n",
       "M 1403 2484 \n",
       "Q 997 2584 770 2862 \n",
       "Q 544 3141 544 3541 \n",
       "Q 544 4100 942 4425 \n",
       "Q 1341 4750 2034 4750 \n",
       "Q 2731 4750 3128 4425 \n",
       "Q 3525 4100 3525 3541 \n",
       "Q 3525 3141 3298 2862 \n",
       "Q 3072 2584 2669 2484 \n",
       "Q 3125 2378 3379 2068 \n",
       "Q 3634 1759 3634 1313 \n",
       "Q 3634 634 3220 271 \n",
       "Q 2806 -91 2034 -91 \n",
       "Q 1263 -91 848 271 \n",
       "Q 434 634 434 1313 \n",
       "Q 434 1759 690 2068 \n",
       "Q 947 2378 1403 2484 \n",
       "z\n",
       "M 1172 3481 \n",
       "Q 1172 3119 1398 2916 \n",
       "Q 1625 2713 2034 2713 \n",
       "Q 2441 2713 2670 2916 \n",
       "Q 2900 3119 2900 3481 \n",
       "Q 2900 3844 2670 4047 \n",
       "Q 2441 4250 2034 4250 \n",
       "Q 1625 4250 1398 4047 \n",
       "Q 1172 3844 1172 3481 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-38\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_5\">\n",
       "     <g id=\"line2d_5\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"282.539221\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_5\">\n",
       "      <!-- 10 -->\n",
       "      <g transform=\"translate(276.176721 322.182437) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-31\" d=\"M 794 531 \n",
       "L 1825 531 \n",
       "L 1825 4091 \n",
       "L 703 3866 \n",
       "L 703 4441 \n",
       "L 1819 4666 \n",
       "L 2450 4666 \n",
       "L 2450 531 \n",
       "L 3481 531 \n",
       "L 3481 0 \n",
       "L 794 0 \n",
       "L 794 531 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \n",
       "Q 1547 4250 1301 3770 \n",
       "Q 1056 3291 1056 2328 \n",
       "Q 1056 1369 1301 889 \n",
       "Q 1547 409 2034 409 \n",
       "Q 2525 409 2770 889 \n",
       "Q 3016 1369 3016 2328 \n",
       "Q 3016 3291 2770 3770 \n",
       "Q 2525 4250 2034 4250 \n",
       "z\n",
       "M 2034 4750 \n",
       "Q 2819 4750 3233 4129 \n",
       "Q 3647 3509 3647 2328 \n",
       "Q 3647 1150 3233 529 \n",
       "Q 2819 -91 2034 -91 \n",
       "Q 1250 -91 836 529 \n",
       "Q 422 1150 422 2328 \n",
       "Q 422 3509 836 4129 \n",
       "Q 1250 4750 2034 4750 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "       <use xlink:href=\"#DejaVuSans-30\" x=\"63.623047\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_6\">\n",
       "     <g id=\"line2d_6\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"328.918442\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_6\">\n",
       "      <!-- 12 -->\n",
       "      <g transform=\"translate(322.555942 322.182437) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "       <use xlink:href=\"#DejaVuSans-32\" x=\"63.623047\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"xtick_7\">\n",
       "     <g id=\"line2d_7\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#mf4eec48e4f\" x=\"375.297662\" y=\"307.584\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_7\">\n",
       "      <!-- 14 -->\n",
       "      <g transform=\"translate(368.935162 322.182437) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "       <use xlink:href=\"#DejaVuSans-34\" x=\"63.623047\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"text_8\">\n",
       "     <!-- x -->\n",
       "     <g transform=\"translate(233.200625 335.860562) scale(0.1 -0.1)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-78\" d=\"M 3513 3500 \n",
       "L 2247 1797 \n",
       "L 3578 0 \n",
       "L 2900 0 \n",
       "L 1881 1375 \n",
       "L 863 0 \n",
       "L 184 0 \n",
       "L 1544 1831 \n",
       "L 300 3500 \n",
       "L 978 3500 \n",
       "L 1906 2253 \n",
       "L 2834 3500 \n",
       "L 3513 3500 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-78\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"matplotlib.axis_2\">\n",
       "    <g id=\"ytick_1\">\n",
       "     <g id=\"line2d_8\">\n",
       "      <defs>\n",
       "       <path id=\"m430ddb2900\" d=\"M 0 0 \n",
       "L -3.5 0 \n",
       "\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </defs>\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"295.488\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_9\">\n",
       "      <!-- 0 -->\n",
       "      <g transform=\"translate(44.2375 299.287219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_2\">\n",
       "     <g id=\"line2d_9\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"265.248\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_10\">\n",
       "      <!-- 1 -->\n",
       "      <g transform=\"translate(44.2375 269.047219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_3\">\n",
       "     <g id=\"line2d_10\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"235.008\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_11\">\n",
       "      <!-- 2 -->\n",
       "      <g transform=\"translate(44.2375 238.807219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-32\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_4\">\n",
       "     <g id=\"line2d_11\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"204.768\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_12\">\n",
       "      <!-- 3 -->\n",
       "      <g transform=\"translate(44.2375 208.567219) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \n",
       "Q 3050 2419 3304 2112 \n",
       "Q 3559 1806 3559 1356 \n",
       "Q 3559 666 3084 287 \n",
       "Q 2609 -91 1734 -91 \n",
       "Q 1441 -91 1130 -33 \n",
       "Q 819 25 488 141 \n",
       "L 488 750 \n",
       "Q 750 597 1062 519 \n",
       "Q 1375 441 1716 441 \n",
       "Q 2309 441 2620 675 \n",
       "Q 2931 909 2931 1356 \n",
       "Q 2931 1769 2642 2001 \n",
       "Q 2353 2234 1838 2234 \n",
       "L 1294 2234 \n",
       "L 1294 2753 \n",
       "L 1863 2753 \n",
       "Q 2328 2753 2575 2939 \n",
       "Q 2822 3125 2822 3475 \n",
       "Q 2822 3834 2567 4026 \n",
       "Q 2313 4219 1838 4219 \n",
       "Q 1578 4219 1281 4162 \n",
       "Q 984 4106 628 3988 \n",
       "L 628 4550 \n",
       "Q 988 4650 1302 4700 \n",
       "Q 1616 4750 1894 4750 \n",
       "Q 2613 4750 3031 4423 \n",
       "Q 3450 4097 3450 3541 \n",
       "Q 3450 3153 3228 2886 \n",
       "Q 3006 2619 2597 2516 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-33\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_5\">\n",
       "     <g id=\"line2d_12\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"174.528\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_13\">\n",
       "      <!-- 4 -->\n",
       "      <g transform=\"translate(44.2375 178.327219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-34\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_6\">\n",
       "     <g id=\"line2d_13\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"144.288\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_14\">\n",
       "      <!-- 5 -->\n",
       "      <g transform=\"translate(44.2375 148.087219) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-35\" d=\"M 691 4666 \n",
       "L 3169 4666 \n",
       "L 3169 4134 \n",
       "L 1269 4134 \n",
       "L 1269 2991 \n",
       "Q 1406 3038 1543 3061 \n",
       "Q 1681 3084 1819 3084 \n",
       "Q 2600 3084 3056 2656 \n",
       "Q 3513 2228 3513 1497 \n",
       "Q 3513 744 3044 326 \n",
       "Q 2575 -91 1722 -91 \n",
       "Q 1428 -91 1123 -41 \n",
       "Q 819 9 494 109 \n",
       "L 494 744 \n",
       "Q 775 591 1075 516 \n",
       "Q 1375 441 1709 441 \n",
       "Q 2250 441 2565 725 \n",
       "Q 2881 1009 2881 1497 \n",
       "Q 2881 1984 2565 2268 \n",
       "Q 2250 2553 1709 2553 \n",
       "Q 1456 2553 1204 2497 \n",
       "Q 953 2441 691 2322 \n",
       "L 691 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-35\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_7\">\n",
       "     <g id=\"line2d_14\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"114.048\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_15\">\n",
       "      <!-- 6 -->\n",
       "      <g transform=\"translate(44.2375 117.847219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-36\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_8\">\n",
       "     <g id=\"line2d_15\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"83.808\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_16\">\n",
       "      <!-- 7 -->\n",
       "      <g transform=\"translate(44.2375 87.607219) scale(0.1 -0.1)\">\n",
       "       <defs>\n",
       "        <path id=\"DejaVuSans-37\" d=\"M 525 4666 \n",
       "L 3525 4666 \n",
       "L 3525 4397 \n",
       "L 1831 0 \n",
       "L 1172 0 \n",
       "L 2766 4134 \n",
       "L 525 4134 \n",
       "L 525 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "       </defs>\n",
       "       <use xlink:href=\"#DejaVuSans-37\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"ytick_9\">\n",
       "     <g id=\"line2d_16\">\n",
       "      <g>\n",
       "       <use xlink:href=\"#m430ddb2900\" x=\"57.6\" y=\"53.568\" style=\"stroke: #000000; stroke-width: 0.8\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "     <g id=\"text_17\">\n",
       "      <!-- 8 -->\n",
       "      <g transform=\"translate(44.2375 57.367219) scale(0.1 -0.1)\">\n",
       "       <use xlink:href=\"#DejaVuSans-38\"/>\n",
       "      </g>\n",
       "     </g>\n",
       "    </g>\n",
       "    <g id=\"text_18\">\n",
       "     <!-- y -->\n",
       "     <g transform=\"translate(38.157812 177.487375) rotate(-90) scale(0.1 -0.1)\">\n",
       "      <defs>\n",
       "       <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \n",
       "Q 1816 -950 1584 -1140 \n",
       "Q 1353 -1331 966 -1331 \n",
       "L 506 -1331 \n",
       "L 506 -850 \n",
       "L 844 -850 \n",
       "Q 1081 -850 1212 -737 \n",
       "Q 1344 -625 1503 -206 \n",
       "L 1606 56 \n",
       "L 191 3500 \n",
       "L 800 3500 \n",
       "L 1894 763 \n",
       "L 2988 3500 \n",
       "L 3597 3500 \n",
       "L 2059 -325 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      </defs>\n",
       "      <use xlink:href=\"#DejaVuSans-79\"/>\n",
       "     </g>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"line2d_17\">\n",
       "    <defs>\n",
       "     <path id=\"md3a4bcf5b4\" d=\"M 0 1.5 \n",
       "C 0.397805 1.5 0.77937 1.341951 1.06066 1.06066 \n",
       "C 1.341951 0.77937 1.5 0.397805 1.5 0 \n",
       "C 1.5 -0.397805 1.341951 -0.77937 1.06066 -1.06066 \n",
       "C 0.77937 -1.341951 0.397805 -1.5 0 -1.5 \n",
       "C -0.397805 -1.5 -0.77937 -1.341951 -1.06066 -1.06066 \n",
       "C -1.341951 -0.77937 -1.5 -0.397805 -1.5 0 \n",
       "C -1.5 0.397805 -1.341951 0.77937 -1.06066 1.06066 \n",
       "C -0.77937 1.341951 -0.397805 1.5 0 1.5 \n",
       "z\n",
       "\" style=\"stroke: #1f77b4\"/>\n",
       "    </defs>\n",
       "    <g clip-path=\"url(#paa5f20b9c5)\">\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"73.832727\" y=\"295.488\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"97.022338\" y=\"295.488\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"120.211948\" y=\"144.288\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"143.401558\" y=\"204.768\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"166.591169\" y=\"174.528\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"189.780779\" y=\"114.048\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"212.97039\" y=\"144.288\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"236.16\" y=\"174.528\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"259.34961\" y=\"204.768\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"282.539221\" y=\"144.288\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"305.728831\" y=\"83.808\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"328.918442\" y=\"295.488\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"352.108052\" y=\"53.568\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"375.297662\" y=\"204.768\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "     <use xlink:href=\"#md3a4bcf5b4\" x=\"398.487273\" y=\"295.488\" style=\"fill: #1f77b4; stroke: #1f77b4\"/>\n",
       "    </g>\n",
       "   </g>\n",
       "   <g id=\"patch_3\">\n",
       "    <path d=\"M 57.6 307.584 \n",
       "L 57.6 41.472 \n",
       "\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_4\">\n",
       "    <path d=\"M 414.72 307.584 \n",
       "L 414.72 41.472 \n",
       "\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_5\">\n",
       "    <path d=\"M 57.6 307.584 \n",
       "L 414.72 307.584 \n",
       "\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"patch_6\">\n",
       "    <path d=\"M 57.6 41.472 \n",
       "L 414.72 41.472 \n",
       "\" style=\"fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
       "   </g>\n",
       "   <g id=\"text_19\">\n",
       "    <!-- Alexander -->\n",
       "    <g transform=\"translate(205.80375 35.472) scale(0.12 -0.12)\">\n",
       "     <defs>\n",
       "      <path id=\"DejaVuSans-41\" d=\"M 2188 4044 \n",
       "L 1331 1722 \n",
       "L 3047 1722 \n",
       "L 2188 4044 \n",
       "z\n",
       "M 1831 4666 \n",
       "L 2547 4666 \n",
       "L 4325 0 \n",
       "L 3669 0 \n",
       "L 3244 1197 \n",
       "L 1141 1197 \n",
       "L 716 0 \n",
       "L 50 0 \n",
       "L 1831 4666 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \n",
       "L 1178 4863 \n",
       "L 1178 0 \n",
       "L 603 0 \n",
       "L 603 4863 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \n",
       "L 3597 1613 \n",
       "L 953 1613 \n",
       "Q 991 1019 1311 708 \n",
       "Q 1631 397 2203 397 \n",
       "Q 2534 397 2845 478 \n",
       "Q 3156 559 3463 722 \n",
       "L 3463 178 \n",
       "Q 3153 47 2828 -22 \n",
       "Q 2503 -91 2169 -91 \n",
       "Q 1331 -91 842 396 \n",
       "Q 353 884 353 1716 \n",
       "Q 353 2575 817 3079 \n",
       "Q 1281 3584 2069 3584 \n",
       "Q 2775 3584 3186 3129 \n",
       "Q 3597 2675 3597 1894 \n",
       "z\n",
       "M 3022 2063 \n",
       "Q 3016 2534 2758 2815 \n",
       "Q 2500 3097 2075 3097 \n",
       "Q 1594 3097 1305 2825 \n",
       "Q 1016 2553 972 2059 \n",
       "L 3022 2063 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \n",
       "Q 1497 1759 1228 1600 \n",
       "Q 959 1441 959 1056 \n",
       "Q 959 750 1161 570 \n",
       "Q 1363 391 1709 391 \n",
       "Q 2188 391 2477 730 \n",
       "Q 2766 1069 2766 1631 \n",
       "L 2766 1759 \n",
       "L 2194 1759 \n",
       "z\n",
       "M 3341 1997 \n",
       "L 3341 0 \n",
       "L 2766 0 \n",
       "L 2766 531 \n",
       "Q 2569 213 2275 61 \n",
       "Q 1981 -91 1556 -91 \n",
       "Q 1019 -91 701 211 \n",
       "Q 384 513 384 1019 \n",
       "Q 384 1609 779 1909 \n",
       "Q 1175 2209 1959 2209 \n",
       "L 2766 2209 \n",
       "L 2766 2266 \n",
       "Q 2766 2663 2505 2880 \n",
       "Q 2244 3097 1772 3097 \n",
       "Q 1472 3097 1187 3025 \n",
       "Q 903 2953 641 2809 \n",
       "L 641 3341 \n",
       "Q 956 3463 1253 3523 \n",
       "Q 1550 3584 1831 3584 \n",
       "Q 2591 3584 2966 3190 \n",
       "Q 3341 2797 3341 1997 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \n",
       "L 3513 0 \n",
       "L 2938 0 \n",
       "L 2938 2094 \n",
       "Q 2938 2591 2744 2837 \n",
       "Q 2550 3084 2163 3084 \n",
       "Q 1697 3084 1428 2787 \n",
       "Q 1159 2491 1159 1978 \n",
       "L 1159 0 \n",
       "L 581 0 \n",
       "L 581 3500 \n",
       "L 1159 3500 \n",
       "L 1159 2956 \n",
       "Q 1366 3272 1645 3428 \n",
       "Q 1925 3584 2291 3584 \n",
       "Q 2894 3584 3203 3211 \n",
       "Q 3513 2838 3513 2113 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \n",
       "L 2906 4863 \n",
       "L 3481 4863 \n",
       "L 3481 0 \n",
       "L 2906 0 \n",
       "L 2906 525 \n",
       "Q 2725 213 2448 61 \n",
       "Q 2172 -91 1784 -91 \n",
       "Q 1150 -91 751 415 \n",
       "Q 353 922 353 1747 \n",
       "Q 353 2572 751 3078 \n",
       "Q 1150 3584 1784 3584 \n",
       "Q 2172 3584 2448 3432 \n",
       "Q 2725 3281 2906 2969 \n",
       "z\n",
       "M 947 1747 \n",
       "Q 947 1113 1208 752 \n",
       "Q 1469 391 1925 391 \n",
       "Q 2381 391 2643 752 \n",
       "Q 2906 1113 2906 1747 \n",
       "Q 2906 2381 2643 2742 \n",
       "Q 2381 3103 1925 3103 \n",
       "Q 1469 3103 1208 2742 \n",
       "Q 947 2381 947 1747 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "      <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \n",
       "Q 2534 3019 2420 3045 \n",
       "Q 2306 3072 2169 3072 \n",
       "Q 1681 3072 1420 2755 \n",
       "Q 1159 2438 1159 1844 \n",
       "L 1159 0 \n",
       "L 581 0 \n",
       "L 581 3500 \n",
       "L 1159 3500 \n",
       "L 1159 2956 \n",
       "Q 1341 3275 1631 3429 \n",
       "Q 1922 3584 2338 3584 \n",
       "Q 2397 3584 2469 3576 \n",
       "Q 2541 3569 2628 3553 \n",
       "L 2631 2963 \n",
       "z\n",
       "\" transform=\"scale(0.015625)\"/>\n",
       "     </defs>\n",
       "     <use xlink:href=\"#DejaVuSans-41\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"68.408203\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-65\" x=\"96.191406\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-78\" x=\"155.964844\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-61\" x=\"215.144531\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"276.423828\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-64\" x=\"339.802734\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-65\" x=\"403.279297\"/>\n",
       "     <use xlink:href=\"#DejaVuSans-72\" x=\"464.802734\"/>\n",
       "    </g>\n",
       "   </g>\n",
       "  </g>\n",
       " </g>\n",
       " <defs>\n",
       "  <clipPath id=\"paa5f20b9c5\">\n",
       "   <rect x=\"57.6\" y=\"41.472\" width=\"357.12\" height=\"266.112\"/>\n",
       "  </clipPath>\n",
       " </defs>\n",
       "</svg>\n",
       "</details></div></div>"
      ],
      "text/plain": [
       "<Data1D data set instance 'Alexander'>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sherpa.data import Data1D\n",
    "\n",
    "x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]\n",
    "y = [0, 0, 5, 3, 4, 6, 5, 4, 3, 5, 7, 0, 8, 3, 0]\n",
    "d = Data1D('Alexander', x, y)\n",
    "\n",
    "# Let the magic of Jupyter display the data.\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c6037e08-e3f2-45d8-b986-35d67ed6fe6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/*\n",
       "Copyright (C) 2020  Smithsonian Astrophysical Observatory\n",
       "\n",
       "\n",
       " This program is free software; you can redistribute it and/or modify\n",
       " it under the terms of the GNU General Public License as published by\n",
       " the Free Software Foundation; either version 3 of the License, or\n",
       " (at your option) any later version.\n",
       "\n",
       " This program is distributed in the hope that it will be useful,\n",
       " but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
       " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
       " GNU General Public License for more details.\n",
       "\n",
       " You should have received a copy of the GNU General Public License along\n",
       " with this program; if not, write to the Free Software Foundation, Inc.,\n",
       " 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n",
       "\n",
       "*/\n",
       "\n",
       ":root {\n",
       "  --sherpa-border-color: var(--jp-border-color2, #e0e0e0);\n",
       "  --sherpa-background-color: var(--jp-layout-color0, white);\n",
       "  --sherpa-background-color-row-even: var(--jp-layout-color1, white);\n",
       "  --sherpa-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
       "\n",
       "  /* https://medium.com/ge-design/iot-cool-gray-is-a-great-background-color-for-data-visualization-ebf18c318418 */\n",
       "  --sherpa-background-color-dark1: #EBEFF2;\n",
       "  --sherpa-background-color-dark2: #D8E0E5;\n",
       "}\n",
       "\n",
       "div.sherpa-text-fallback {\n",
       "    display: none;\n",
       "}\n",
       "\n",
       "div.sherpa {\n",
       "    display: block;\n",
       "}\n",
       "\n",
       "div.sherpa details summary {\n",
       "    display: list-item;  /* needed for notebook, not lab */\n",
       "    font-size: larger;\n",
       "}\n",
       "\n",
       "div.sherpa details div.datavals {\n",
       "    display: grid;\n",
       "    grid-template-columns: 1fr 3fr;\n",
       "    column-gap: 0.5em;\n",
       "}\n",
       "\n",
       "div.sherpa div.dataname {\n",
       "    font-weight: bold;\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa div.dataval { }\n",
       "\n",
       "div.sherpa div.datavals div:nth-child(4n + 1) ,\n",
       "div.sherpa div.datavals div:nth-child(4n + 2) {\n",
       "    background: var(--sherpa-background-color-row-odd);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tbody {\n",
       "    border-bottom: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model tr.block {\n",
       "    border-top: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd ,\n",
       "div.sherpa table.model th.model-even {\n",
       "    border-right: 1px solid var(--sherpa-border-color);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-odd {\n",
       "    background: var(--sherpa-background-color-dark1);\n",
       "}\n",
       "\n",
       "div.sherpa table.model th.model-even {\n",
       "    background: var(--sherpa-background-color-dark2);\n",
       "}\n",
       "\n",
       "div.sherpa .failed {\n",
       "    background: orange;\n",
       "    font-size: large;\n",
       "    padding: 1em;\n",
       "}\n",
       "</style><div class=\"sherpa-text-fallback\">&lt;Box1D model instance &#x27;box1d&#x27;&gt;</div><div hidden class=\"sherpa\"><details open><summary>Model</summary><table class=\"model\"><caption>Expression: box1d</caption><thead><tr><th>Component</th><th>Parameter</th><th>Thawed</th><th>Value</th><th>Min</th><th>Max</th><th>Units</th></tr></thead><tbody><tr><th class=\"model-odd\" scope=\"rowgroup\" rowspan=3>box1d</th><td>xlow</td><td><input disabled type=\"checkbox\" checked></input></td><td>7.0</td><td>-MAX</td><td>MAX</td><td></td></tr><tr><td>xhi</td><td><input disabled type=\"checkbox\" checked></input></td><td>8.0</td><td>-MAX</td><td>MAX</td><td></td></tr><tr><td>ampl</td><td><input disabled type=\"checkbox\"></input></td><td>5.0</td><td>-MAX</td><td>MAX</td><td></td></tr></tbody></table></details></div>"
      ],
      "text/plain": [
       "<Box1D model instance 'box1d'>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sherpa.models.basic import Box1D\n",
    "\n",
    "m = Box1D()\n",
    "m.ampl = 5\n",
    "m.ampl.freeze()\n",
    "\n",
    "m.xlow = 7\n",
    "m.xhi = 8\n",
    "\n",
    "# The Jupyter magic here is a bit less visually impressive.\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d0214494-9dfb-4dfb-9016-b18588321fe8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Least Squared Statistic.\n",
       "\n",
       "    The least-square statistic is equivalent to a chi-square\n",
       "    statistic where the error on each point - sigma(i) - is 1.\n",
       "\n",
       "    "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sherpa.stats import LeastSq\n",
    "\n",
    "stat = LeastSq()\n",
    "\n",
    "# Hmmm, not quite as useful!\n",
    "stat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ebf77c36-5fc0-45a2-8590-7438a0620e62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Opty optimization method instance 'not-a-good-optimizer'>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We already have an optimizer object, but let's create a new one\n",
    "\n",
    "opt = Opty(name=\"not-a-good-optimizer\")\n",
    "\n",
    "# It's really hard to get a good visual impression of an optimizing function!\n",
    "opt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4c8f9ee-e4e5-4640-8cfa-d548804229c3",
   "metadata": {},
   "source": [
    "We can now pass these to the `Fit` object (note that, unlike earlier, I am not going to change the verbose flag for the optimizer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4aa8913b-0762-46a2-a9d8-d2cde3c166d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data      = Alexander\n",
      "model     = box1d\n",
      "stat      = LeastSq\n",
      "method    = Opty\n",
      "estmethod = Covariance\n"
     ]
    }
   ],
   "source": [
    "from sherpa.fit import Fit\n",
    "\n",
    "f = Fit(d, m, stat=stat, method=opt)\n",
    "\n",
    "# The Fit object doesn't have a good \"Jupyter\" display, so we stick with print.\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f5823c4-710c-45d6-88eb-6f5235767e07",
   "metadata": {},
   "source": [
    "The [fit](https://sherpa.readthedocs.io/en/4.16.1/fit/api/sherpa.fit.Fit.html#sherpa.fit.Fit.fit) method will call the optimizer (and can be sent an `outfile` parameter to write the per-iteration data values to, matching the `ui.fit` call above). One thing to note is that it's less visually noisy than `ui.fit` (which combines the call to `fit` along with `format` on the returned value):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b4b484b9-ab6a-401f-b9fc-62bc838989cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = f.fit()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89df12b4-78d9-45c7-8e38-3d76192a5e91",
   "metadata": {},
   "source": [
    "We can check whether the optimization succeeded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "5df64129-3856-489c-8378-1b602d18d177",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.succeeded"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7befebdf-fc2e-4aab-abb6-151b123aa765",
   "metadata": {},
   "source": [
    "The fit results can also be displayed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a4f0d7f3-46e9-4a2e-aefe-b02cec105676",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method                = opty\n",
      "Statistic             = leastsq\n",
      "Initial fit statistic = 243\n",
      "Final fit statistic   = 88 at function evaluation 45\n",
      "Data points           = 15\n",
      "Degrees of freedom    = 13\n",
      "Change in statistic   = 155\n",
      "   box1d.xlow     3           \n",
      "   box1d.xhi      11          \n"
     ]
    }
   ],
   "source": [
    "print(res.format())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6755f433-f82c-4987-b44f-d04fb965cdd9",
   "metadata": {},
   "source": [
    "The model will have been updated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6a4ef85b-84ec-4331-b20b-f9243cbf8bfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box1d\n",
      "   Param        Type          Value          Min          Max      Units\n",
      "   -----        ----          -----          ---          ---      -----\n",
      "   box1d.xlow   thawed            3 -3.40282e+38  3.40282e+38           \n",
      "   box1d.xhi    thawed           11 -3.40282e+38  3.40282e+38           \n",
      "   box1d.ampl   frozen            5 -3.40282e+38  3.40282e+38           \n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9122a5a4-a513-4b2a-b5ba-d836e6ad3513",
   "metadata": {},
   "source": [
    "The output of the `fit` call is a [`FitResults`](https://sherpa.readthedocs.io/en/4.16.1/fit/api/sherpa.fit.FitResults.html) structure which provides information on the fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d90811e1-99fa-41d5-b17d-e8e0e18ac415",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sherpa.fit.FitResults"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f50eaa52-acf0-4425-a014-a66e12387794",
   "metadata": {},
   "source": [
    "including the \"extra\" information the optimizer returned (the last element of the `OptReturn` tuple):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "51d05fa5-c5b0-403b-89ed-db15368c92c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nfev': 45,\n",
       " 'best-fit': array([ 3., 11.]),\n",
       " 'best-stat': 88.0,\n",
       " 'store': [array([6., 7.]),\n",
       "  array([6., 8.]),\n",
       "  array([6., 9.]),\n",
       "  array([5., 8.]),\n",
       "  array([5., 9.]),\n",
       "  array([ 5., 10.]),\n",
       "  array([ 4., 10.]),\n",
       "  array([ 4., 11.]),\n",
       "  array([ 3., 11.])]}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.extra_output"
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}