profileLikelihoodRatio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Profile likelihood ratio calculator\n",
    "\n",
    "Copyright (c) 2020, Pietro Vischia pietro.vischia@cern.ch\n",
    "\n",
    "\n",
    "### Implementation of a class for profile likelihood calculations, with and without systematic uncertainties\n",
    "Based on MINOS via iMinuit (Fred James' still rules)\n",
    "\n",
    "Maybe in the future port to tensorflow?\n",
    "\n",
    "##### Features\n",
    "- [x] Profiling\n",
    "- [x] Constraints on nuisance parameters\n",
    "- [ ] Pulls and impacts\n",
    "- [ ] Breakdown of systematic uncertainties\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5.4\n"
     ]
    }
   ],
   "source": [
    "# Check profile likelihood\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import scipy.stats as st\n",
    "from scipy import optimize as op\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import sys\n",
    "\n",
    "import random\n",
    "import inspect\n",
    "from iminuit import Minuit\n",
    "import iminuit\n",
    "print(iminuit.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class profile_likelihood_ratio():\n",
    "    def __init__(self, model, data, ts, minuslogmodel=None, freezelist=None,nsteps=100, migradprecision=None):\n",
    "        self.model = model\n",
    "        self.minuslogmodel = minuslogmodel\n",
    "        self.n_params=len(self.model.__code__.co_varnames)-2\n",
    "        self.data = data\n",
    "        self.ts=ts\n",
    "        self.migradprecision= migradprecision\n",
    "        self.constraints = {}\n",
    "        self.initial_values=[1. for i in range(self.n_params)]\n",
    "        #self.likelihood_realization=lambda params : -2*(self.model(self.ts(self.data), params))\n",
    "        self.likelihood_realization=lambda params : (self.model(self.data, params))\n",
    "        self.minusloglikelihood_realization= lambda params: 2*self.minuslogmodel(self.data, params) #if self.minuslogmodel else -2*np.log(self.model(self.data, params))\n",
    "        # Work with variable names, to exploit <function>.__code__.co_varnames to have arbitrary number of variables\n",
    "        self.pardict = { parname : 1 for parname in self.minuslogmodel.__code__.co_varnames if parname!='data' and parname!='params'} if self.minuslogmodel else { parname : 1 for parname in self.model.__code__.co_varnames if parname!='data' and parname!='params'}\n",
    "        self.freezelist= freezelist if freezelist else { parname : [False, None, False] for parname in self.pardict.keys()}\n",
    "        self.initial_values = [ 1. for i in range(self.n_params)]\n",
    "        self.mles = None\n",
    "        self.mleuncs = None\n",
    "        self.nsteps = nsteps # For plotting\n",
    "    def __call__(self, params):\n",
    "        # I need the class to be callable, in order to call it. Sweet.\n",
    "        return self.minusloglikelihood_realization(params)\n",
    "        \n",
    "    def minimize(self):\n",
    "        # scipy.optimize.minimize is so crappy that I switched to iMinuit, and am happy\n",
    "        #ret = op.minimize(self, self.initial_values, constraints=self.constraints )\n",
    "\n",
    "        # Errordef should be 0.5 for -lnL, and 1 for least_squares, according to iminuit tutorial\n",
    "        # However, I am already multiplying -lnL by 2, so the correct errordef value is 1.\n",
    "\n",
    "        # Instance the minimizer\n",
    "        m = Minuit.from_array_func(plr, self.initial_values, name=self.pardict.keys(), errordef=1) \n",
    "        m.print_level=3\n",
    "        \n",
    "        # Take care of frozen parameters and constrain nuisance parameters\n",
    "        for par, freezestatus in self.freezelist.items():\n",
    "            print('par %s has freezestatus %s'%(par, freezestatus))\n",
    "            \n",
    "            if freezestatus[1] is not None: # Set the input value of parameters that need to be frozen to their input value\n",
    "                m.fitarg[par] = freezestatus[1]\n",
    "                m.values[par] = freezestatus[1]\n",
    "                m.fitarg['error_%s'%par] = 0.\n",
    "                print('I am freezing (conditioning on) parameter %s to %s'%(par, freezestatus[1]))\n",
    "            if freezestatus[2]: # Nuisance parameters that need to be constrained Gaus(0|par,1)\n",
    "                m.fitarg[par] = freezestatus[1]\n",
    "                m.values[par] = freezestatus[1]\n",
    "                m.fitarg['error_%s'%par] = 1 \n",
    "                print('I am settting the initial value of %s to %s and its variance to 1'%(par, 0))\n",
    "            \n",
    "            # Freeze all parameters that need to be frozen\n",
    "            m.fitarg['fix_%s'%par] = freezestatus[0] # Freeze it\n",
    "            m.fixed[par] = freezestatus[0]\n",
    "            print('Minuit model settings:', m.fitarg)\n",
    "            \n",
    "        print('Minimizer will run with the following model settings: ', m.fitarg)\n",
    "        \n",
    "        # Minimize\n",
    "        if self.migradprecision:\n",
    "            m.migrad(precision=self.migradprecision)\n",
    "        else:\n",
    "            m.migrad()\n",
    "        \n",
    "        m.hesse()\n",
    "        \n",
    "        # Covariance matrix\n",
    "        print(m.covariance)\n",
    "        # Correlation matrix\n",
    "        # m.covariance.correlation()\n",
    "        \n",
    "        m.minos(sigma=1) # Compute asymmetric uncertainties (better than m.hesse() ). Fred James rulezzz\n",
    "        print('I have run MINOS')\n",
    "        print(m.params)\n",
    "        \n",
    "        # Minos profile\n",
    "        m.draw_mnprofile(list(self.pardict.keys())[0],subtract_min=True)                                                                                                                                                                                                                  \n",
    "        #m.draw_profile(list(self.pardict.keys())[0],subtract_min=True);\n",
    "                                 \n",
    "        \n",
    "        return [m.values, m.merrors] # when calling m.minos()\n",
    "        #return [m.values, m.errors] # when calling only m.hesse()\n",
    "        \n",
    "    def do_global_fit(self):\n",
    "        \n",
    "        # Main fit\n",
    "        results=self.minimize()\n",
    "        \n",
    "        print('Main fit Results', results)\n",
    "        print('Main fit Best estimates', results[0])\n",
    "        print('Main fit Uncertainties', results[1])\n",
    "        self.mles = { par : results[0][par] for par in self.pardict.keys() }\n",
    "        self.mleuncs = {}\n",
    "        for par in self.pardict.keys():\n",
    "            if self.freezelist[par][0] == False:\n",
    "                self.mleuncs[par, +1] = results[1][par, +1.0]\n",
    "                self.mleuncs[par, -1] = results[1][par, -1.0]\n",
    "\n",
    "        for par, val in self.mles.items():\n",
    "            if self.freezelist[par][0] == False:\n",
    "                print('Parameter %s = %s (+%s/-%s) [fitted]'%(par,val, self.mleuncs[par, +1],self.mleuncs[par, -1]))\n",
    "            else:\n",
    "                print('Parameter %s = %s [frozen]'%(par,val))\n",
    "    \n",
    "    def compute_model_at(self, datapoint, pars):\n",
    "        print(self.model(datapoint, pars))\n",
    "        \n",
    "    def plot_results(self, scan):\n",
    "        pass\n",
    "        \n",
    "    def find_range_around_mle(self, par):\n",
    "        mle = self.mles[par]\n",
    "        # Wild guess, must find a more meaningful way (maybe pre-finding the range in which it's nonzero)\n",
    "        return [mle+5*self.mleuncs[par, -1], mle+5*self.mleuncs[par, +1]] if self.freezelist[par][0] == False else [mle-5*abs(mle), mle+5*abs(mle)]\n",
    "    \n",
    "    def draw_data(self):\n",
    "        fig = plt.figure(figsize=(10,10))\n",
    "        plt.hist(self.data, bins=100)\n",
    "        thepar=list(self.pardict.keys())[0] # Assume the location parameter is kind of the first parameter\n",
    "        plt.axvline(x=self.ts(self.data), ls='--', c='red', label='Test statistic value')\n",
    "        plt.axvline(x=self.mles[thepar], ls='--', c='black', label='Maximum likelihood estimate for location parameter theta')\n",
    "        plt.axvspan(self.mles[thepar]+self.mleuncs[thepar, -1],self.mles[thepar]+self.mleuncs[thepar,+1], alpha=0.5, color='grey', label='68.3% CL interval')\n",
    "\n",
    "        plt.legend(loc='best')\n",
    "        \n",
    "    def draw_likelihood(self, override_range=None):\n",
    "        ret=[]\n",
    "        # Draw the 1D likelihoods\n",
    "        \n",
    "        for par in self.pardict.keys():\n",
    "            print('NOW PLOTTING %s'%par)\n",
    "            par_idx = list(self.pardict.keys()).index(par)\n",
    "            fig = plt.figure(figsize=(10,10))\n",
    "            scanrange = self.find_range_around_mle(par)\n",
    "            if override_range: # I can't remember what is this\n",
    "                if override_range[par]:\n",
    "                    scanrange=override_range[par]\n",
    "\n",
    "            # Pick the MLES for floating parameters, and the input values for the frozen ones\n",
    "            theparams=[ [ j for j in self.initial_values] for i in range(self.nsteps) ]\n",
    "            conditionlist = { conditionedpar : None for conditionedpar in self.pardict.keys() if conditionedpar!= par  }\n",
    "            \n",
    "            for i_params in range(self.nsteps):\n",
    "                for mledpar in self.pardict.keys():\n",
    "                    if mledpar != par:\n",
    "                        mledpar_idx=list(self.pardict.keys()).index(mledpar)\n",
    "                        theparams[i_params][mledpar_idx] = self.mles[mledpar] \n",
    "                        if self.freezelist[mledpar][0]:\n",
    "                            theparams[i_params][mledpar_idx] = self.freezelist[mledpar][1]\n",
    "                        conditionlist[mledpar] = theparams[i_params][mledpar_idx]\n",
    "     \n",
    "            print('Plotting %s in range %s in %s steps'%(par, scanrange, self.nsteps))            \n",
    "            x=np.linspace(scanrange[0], scanrange[1], num=self.nsteps)\n",
    "            \n",
    "            for idx in range(self.nsteps):\n",
    "                #print(idx, x[idx], theparams[idx][par_idx])\n",
    "                theparams[idx][par_idx] = x[idx]\n",
    "                #print('\\t', idx, x[idx], theparams[idx][par_idx])\n",
    "\n",
    "\n",
    "            y= [self(params) for params in theparams ]\n",
    "            #print('Theparams', theparams)\n",
    "            #for my_idx in range(self.nsteps):\n",
    "            #    print(my_idx, theparams[my_idx], y[my_idx])\n",
    "            #print('linspace x', x)\n",
    "            plt.plot(x,y-np.nanmin(y), label='Delta ln(L) scan')\n",
    "            plt.axvline(x=self.mles[par], ls='--', c='red', label='Maximum likelihood estimate')\n",
    "            plt.axhline(y=1, c='blue', ls='--', alpha=0.5, label='68.3% CL')\n",
    "            plt.axhline(y=4, c='blue', ls='--', alpha=0.5, label='95% CL')\n",
    "            #1D: 1, 4; 2D: 2.29, 5.99)\n",
    "            if self.freezelist[par][0] == False:\n",
    "                plt.axvspan(self.mles[par]+self.mleuncs[par, -1],self.mles[par]+self.mleuncs[par,+1], alpha=0.5, color='grey', label='68.3% CL interval')\n",
    "            plt.xlabel('Scan of %s while fixing %s'%(par, [[key, value] for key, value in conditionlist.items()]))\n",
    "            plt.ylabel('Delta ln(L)')\n",
    "            plt.ylim(-1,10)\n",
    "            plt.legend(loc='best')\n",
    "            ret.append(fig)\n",
    "        return ret\n",
    "        \n",
    "    def print_inputs(self, alsoData=False):\n",
    "        if(alsoData):\n",
    "            print('Data:')\n",
    "            print(data)\n",
    "        print('Test statistic: ')\n",
    "        print(self.ts)\n",
    "        print('Test statistic value:')\n",
    "        print(self.ts(self.data))\n",
    "        print('Parameters:')\n",
    "        print(self.model.__code__.co_varnames)\n",
    "        print('Parameters dictionary:')\n",
    "        print(self.pardict)\n",
    "        print('Initial values:')\n",
    "        print(self.initial_values)\n",
    "        print('Model:')\n",
    "        print(inspect.getsource(self.model))\n",
    "        print('Likelihood model (fixed data):')\n",
    "        print(inspect.getsource(self.likelihood_realization))\n",
    "        print('Likelihood model parameters:')\n",
    "        print(self.likelihood_realization.__code__.co_varnames)\n",
    "        print('minus-log-Likelihood model (fixed data):')\n",
    "        print(inspect.getsource(self.minusloglikelihood_realization))\n",
    "        print('minus-log-Likelihood model parameters:')\n",
    "        print(self.minusloglikelihood_realization.__code__.co_varnames)\n",
    "        #print(self.model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test statistic: \n",
      "<function mean at 0x7f07c0081790>\n",
      "Test statistic value:\n",
      "5.0230018551680535\n",
      "Parameters:\n",
      "('data', 'params', 'theta', 'sigma')\n",
      "Parameters dictionary:\n",
      "{'theta': 1, 'sigma': 1}\n",
      "Initial values:\n",
      "[1.0, 1.0]\n",
      "Model:\n",
      "def my_gaussian_likelihood(data, params):\n",
      "    theta=params[0]\n",
      "    sigma=params[1]\n",
      "    return 1./(math.sqrt(2*math.pi)*sigma)*math.exp(-((data-theta)**2/sigma**2).sum())\n",
      "\n",
      "Likelihood model (fixed data):\n",
      "        self.likelihood_realization=lambda params : (self.model(self.data, params))\n",
      "\n",
      "Likelihood model parameters:\n",
      "('params',)\n",
      "minus-log-Likelihood model (fixed data):\n",
      "        self.minusloglikelihood_realization= lambda params: 2*self.minuslogmodel(self.data, params) #if self.minuslogmodel else -2*np.log(self.model(self.data, params))\n",
      "\n",
      "minus-log-Likelihood model parameters:\n",
      "('params',)\n",
      "par theta has freezestatus [False, None, False]\n",
      "Minuit model settings: {'theta': 1.0, 'sigma': 1.0, 'error_theta': 0.01, 'error_sigma': 0.01, 'fix_theta': False, 'fix_sigma': False, 'limit_theta': None, 'limit_sigma': None}\n",
      "par sigma has freezestatus [False, None, False]\n",
      "Minuit model settings: {'theta': 1.0, 'sigma': 1.0, 'error_theta': 0.01, 'error_sigma': 0.01, 'fix_theta': False, 'fix_sigma': False, 'limit_theta': None, 'limit_sigma': None}\n",
      "Minimizer will run with the following model settings:  {'theta': 1.0, 'sigma': 1.0, 'error_theta': 0.01, 'error_sigma': 0.01, 'fix_theta': False, 'fix_sigma': False, 'limit_theta': None, 'limit_sigma': None}\n",
      "┌──────────────────────────────────┬──────────────────────────────────────┐\n",
      "│ FCN = 14.14                      │        Nfcn = 161 (161 total)        │\n",
      "│ EDM = 3.38e-07 (Goal: 0.0002)    │                                      │\n",
      "├───────────────┬──────────────────┼──────────────────────────────────────┤\n",
      "│ Valid Minimum │ Valid Parameters │        No Parameters at limit        │\n",
      "├───────────────┴──────────────────┼──────────────────────────────────────┤\n",
      "│ Below EDM threshold (goal x 10)  │           Below call limit           │\n",
      "├───────────────┬──────────────────┼───────────┬─────────────┬────────────┤\n",
      "│   Hesse ok    │  Has Covariance  │ Accurate  │  Pos. def.  │ Not forced │\n",
      "└───────────────┴──────────────────┴───────────┴─────────────┴────────────┘\n",
      "Main fit Results [<ValueView of Minuit at 3d94c20>\n",
      "  theta: 5.023305901544844\n",
      "  sigma: 284.13946790598084, MErrors([('theta', MError(name='theta', is_valid=True, lower=-2.6349421323155653, upper=2.6343340987127366, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=62, min=5.023305901544844)), ('sigma', MError(name='sigma', is_valid=True, lower=-123.88507433786009, upper=429.63234282593464, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=63, min=284.13946790598084))])]\n",
      "Main fit Best estimates <ValueView of Minuit at 3d94c20>\n",
      "  theta: 5.023305901544844\n",
      "  sigma: 284.13946790598084\n",
      "Main fit Uncertainties ┌──────────┬───────────────────────┬───────────────────────┐\n",
      "│          │         theta         │         sigma         │\n",
      "├──────────┼───────────┬───────────┼───────────┬───────────┤\n",
      "│  Error   │   -2.6    │    2.6    │  -0.12e3  │  0.43e3   │\n",
      "│  Valid   │   True    │   True    │   True    │   True    │\n",
      "│ At Limit │   False   │   False   │   False   │   False   │\n",
      "│ Max FCN  │   False   │   False   │   False   │   False   │\n",
      "│ New Min  │   False   │   False   │   False   │   False   │\n",
      "└──────────┴───────────┴───────────┴───────────┴───────────┘\n",
      "Parameter theta = 5.023305901544844 (+2.6343340987127366/--2.6349421323155653) [fitted]\n",
      "Parameter sigma = 284.13946790598084 (+429.63234282593464/--123.88507433786009) [fitted]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-28-06043d36ca36>:34: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.print_level=3\n",
      "<ipython-input-28-06043d36ca36>:68: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.draw_mnprofile(list(self.pardict.keys())[0],subtract_min=True)\n",
      "<ipython-input-28-06043d36ca36>:86: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, +1] = results[1][par, +1.0]\n",
      "<ipython-input-28-06043d36ca36>:87: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, -1] = results[1][par, -1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First let's start with a gaussian likelihood\n",
    "def my_gaussian_likelihood(data, params):\n",
    "    theta=params[0]\n",
    "    sigma=params[1]\n",
    "    return 1./(math.sqrt(2*math.pi)*sigma)*math.exp(-((data-theta)**2/sigma**2).sum())\n",
    "    #return 1./(math.sqrt(2*math.pi)*sigma)*math.exp(-1*argument)\n",
    "    #return 1./(math.sqrt(2*math.pi)*sigma)*math.exp(-(data-theta)**2/sigma**2)\n",
    "\n",
    "def my_gaussian_minusloglikelihood(data, params):\n",
    "    theta=params[0]\n",
    "    sigma=params[1]\n",
    "    return np.log(math.sqrt(2*math.pi)*sigma) + ((data-theta)**2/sigma**2).sum()\n",
    "    \n",
    "\n",
    "Ntot=10000\n",
    "data = np.array([ random.gauss(5,2) for i in range(Ntot)])\n",
    "debug=True\n",
    "\n",
    "plr = profile_likelihood_ratio(my_gaussian_likelihood, data, np.mean, my_gaussian_minusloglikelihood)\n",
    "\n",
    "if debug:\n",
    "    plr.print_inputs()\n",
    "plr.do_global_fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAI/CAYAAAC1XpeNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABB/klEQVR4nO3de5xO5f7/8fdlchzHUDSUCtEgasgYh3IaoZy2vbVVVMhGOx2IJGlX26Zs2VI/yaFIVMKWcopySqF2OZ9ziJwaY8ZxxvX7Y273d3Avc2ONNcu8no+Hx8y97rXW/Z41xnx8ruu+lrHWCgAAAJcvh9cBAAAArhYUVgAAAC6hsAIAAHAJhRUAAIBLKKwAAABcQmEFAADgkmu8DiBJxYoVs2XKlPE6BpDlHTlyRKmpqV7HyDb2btsmSSpx880eJ8leIiIiVKBAAa9jAI5Wrlx5wFpbPNRzWaKwKlOmjFasWOF1DCDLmzZtmgoXLux1jGzjxebNJUmvjh7tcZLsJSEhQS1btvQ6BuDIGPOr03MMBQIAALgkS3SsACAr+kurVl5HAOAzFFYA4KDy4497HQGAz1BYAZAkGWMUGRmpiIgIr6NkGaknTkiSInLn9jhJ9lKgQAGtW7fO6xiA8uTJo1KlSilnzpxhH0NhBUCSFBkZqeuvv16FChWSMcbrOFnC7k2bJElRZct6nCR7SUlJUZEiRbyOgWzOWquDBw9q165duvki3hnM5HUAktLe4k5RBQBpjDEqWrSojh8/flHHUVgBCKKoAoD/cyn/JlJYAfDcwYMHFRcXp7i4OJUtW1a33XZb8PHJkyczPH7RokVavnx52K/366+/asqUKRnut/u33zTzyy+Dj1etWqVevXqFfd6M9r9cTZs21apVqzLt/AAuHoUVAM8VLVpUS5Ys0ZIlS/TYY4+pe/fuwce5cuXK8PiLLax27NihTz75JMP9dv/2m2Z+9VXw8Z133qkhQ4aEfd6M9gdw9aGwApAl/fjjj7rvvvtUt25dtWzZUnv37pUkvfPOO6pevbpiY2PVsWNH/frrrxozZozefvttxcXFaenSpWedZ/HixcHuV+3atXXkyBENGDBAy5YtU1xcnEaMGKFff/1V8fHxqlOnjurUqRMs0oa/845W/e9/wf0WLVqktm3bhn3e9PsnJSXpb3/7m2rWrKnY2FhNnz79rJxz5sxRhw4dgo8XLVqkP//5z5Kkp59+WvXq1VONGjX02muvhbxeJUuWDH4+bdo0de3aVZJ04MABPfTQQ6pXr57q1aun77777pK/JwAyxrsCAWQ51lr16tVLH3/8sYoVK6bPPvtMr7zyikaOHKl///vf+uWXX5Q7d24lJCSocOHCeuyxx5Q/f379/e9/P+9cw4cP15tvvqmaNWsqKSlJefLk0cCBAzV8+PBgd+no0aOaPn268uTJo82bN+vxxx/XN998o1dee+2s/RYtWnRR502//+DBg1WwYMFgYfPHH3+clbN+/frq2bOnkpOTFRkZqalTp6p169aSpP79++vaa69Vamqq7r//fq1evVqVKlUK61r27t1b3bt3V2xsrHbu3KlWrVpxCzEgE1FYAQgpb9Om521LadVKpzp3lo4eVd4//em850+1b6+U9u1lDh5UnocfPuu5Y7Nmhf3aJ06c0Lp169SiRQtJUmpqqq6//npJUnR0tDp16qRmzZqpeeBefhdSs2ZN9e3bV3/+85/1wAMPKH/+/OfnPnVKzz33nH755RdFRERo8+bNaduTk3U6JeWSz5vewoULNWbMmODjc5cTuOaaa9SwYUN9+eWXatmypWbPnq1XXnlFkvT5559r3LhxSklJ0d69e7V+/fqwC6uFCxdqw4YNwcdHjhzRkSNHuMkxkEkorABkOdZaVahQQfPnzz/vuU8//VRLlizRrFmzNHjwYH3//fcXPNczzzyj+Ph4zZkzRw0aNNCMGTPO2+ftt9/Wddddp6VLl+r06dMqXjztpvWH//hDJwOLhF7Kec/9mjJ6h1Hr1q313nvvqUiRIrrzzjtVoEABbd++XcOHD9fChQtVpEgRde3aVSdCZEp/7vRvDz99+rTmzZunvHnzXvC1AbiDwgpASBfsMOXLd8HnbdGiF9WhOlfu3Ll14MABLV++XHfffbdOnTqlzZs367bbbtOuXbtUt25dxcbG6pNPPlFSUpIKFCigxMTEkOfaunWroqOjFR0dre+//14bN25UVFSUkpKSgvskJiYqKipKOXLk0EcffaTU1FRJaYumJh89esnnTa9+/foaNWqU/vWvf0lKGwo8t2tVp04d9ejRQ+PHjw8OAx45ckSRkZEqVKiQ9u3bp7lz56pOnTrnnb948eLasGGDypUrp5kzZwY7aGde96mnnpIk/fzzz6pSpYrjtQdweZi8DiDLyZEjhz788EMNGDBAtWrVUlxcnJYvX67U1FR17txZNWvWVO3atdW9e3cVLlxYTZo00cyZM0NOXh85cqTuvvtu1apVS3ny5FGjRo1UqVIlXXPNNapVq5ZGjBihTp066aOPPlL9+vW1efNmRUZGSpLKly2rayIigvtd7HnT69WrlxISEoLHpJ9/dUZERITi4+M1d+5cNWnSRJJUuXJlValSRTVq1FC3bt1Us2bNkNds4MCBatu2rZo3bx4cNpWkIUOG6Mcff1RsbKyqV69+1nAkAPcZa63XGRQTE2OZTAlkbNq0aSpcuHCmnLtQoUIqy61bzhK8pU25ch4nyV64pQ2yknXr1qlixYpnbTPGrLTWxoTan44VAACAS5hjBQAOigUmsQNAuCisAMBB7kwadgVw9WIoEAAcnEhI0ImEBK9jAPAROlYA4ODA/v2SpCg6VwDCRMcKAADAJRRWALKMggULqnPnzsHHKSkpuvnmm4M3Mr5Ys2bN0tChQ92Kd9GaNm2qVatWSZLatGmjhIQE/frrr7r77rvDPsfrr7+u4cOHS5JeffVVLViwQJJUqVIlHTx40PXMbpx35syZWr9+ffBx+tyXIyEhQSNHjrzo4z755BNVrFhR99577yW/dka3LLpY06ZN09q1a4OPX3rpJc2bN8/V18hqXn/99cs+x7hx4/Tbb78FH5cpU0YHDhwI+/iffvpJsy5j8eJwUFgByDIiIyO1bt06HTt2TJL09ddf64Ybbrjk8zVt2lTPPPOMW/Euy2effXbZa5C9+OKLl1UcXCnnFlZu5b7Uwur999/XyJEjwy7uUhzuD+mmcwurV155RQ0bNsz0183ImbsOZIZLKazOzXNuYXWxKKwAZDuNGjXS7NmzJaXdF/BP6W72vGLFCjVs2FC1a9dWw4YNtSmwgOeIESPUrVs3SdKaNWt099136+jRoxo5epy6PdlTvyceV4fHO+uJ7k+qWbNmqlKlihYvXqxu3bopJiZGXbt2Db5GyZIlg5/PnjdPfQcMkCR17dpVTz/9dIbHOwnVCdq2bZtq166tlStXauvWrWrVqpXq1q2r+Ph4bdy48bxzdO3aVdOmTQs+fvfdd1WnTh3VrFkzuP+hQ4f04IMPKjY2VvXr19fq1asvuP3gwYNq0aKFateuraeeekpOi0bPnz9fDRo0UJ06dfTII48Eb90zYMAAVa9eXbGxserXr5+WL1+uWbNmqX///oqLi9PWrVvPyl2pUiUNHDhQDRo0UL169fTTTz+pZcuWqlKlit5//31JUlJSkho0aKA777xTlStX1vTp0yVJffr00ZYtW1S1alX16tVLUtrK8tWrV1eVKlU0IPC9Su+VV17R4sWL1bVrV/Xq1UvHjx/Xo48+qsqVK6tatWrBYmvcuHFq27at7r//fjVu3Njx+2itVa9evVSpUiVVrlxZkydPDj43ePBgVa5cWXfccYf69OkjSXrvvfdUvXp13XHHHWrTpo2OHj2qpUuXasaMGerVq5eqVq2qLVu2qGPHjvr000+D17patWqqXLmyHnvsseC9IcuUKaMBAwYEr0v64vWMcePGqUWLFmrSpIluu+02DRw4MPhcy5Ytdddddyk6OlqjRo0Kbs+fP79eeukl3X333Vq2bJleeeUVVa9eXZUqVVKXLl2CfyfuuecePf3006pbt64qVqyoH374Qa1bt1a5cuX04osvBs83YcIE1ahRQ1WrVtUTTzyh1NRU9enTR8eOHVPVqlXVvn17x/1C5Tnj008/1YoVK9S+fXtVrVo1+B+w//znP+ddk+TkZD322GOqXr26qlWrpunTp+vkyZN66aWXNHnyZFWtWlWTJ0/W999/r1q1aqlatWqqVavWWTcsv2TWWs//3HXXXRZAxj7//HO7YMGCTPmzatUqm5iY6OmfyMhIu3TpUtuiRQu7b98+W7lyZfvFF1/Y+Ph4m5iYaHft2mUPHTpkExMT7fTp0+0DDzxgExMTbUJCgq1Vq5adOHGirVatmp0zZ45NTEy0g4YOtw91eMxu2rXPtmr7F9vsgZb28OHDdtKkSbZAgQJ22bJlNiEhwVatWtUuXrw4mOFMnjHvvmvbtW1rExMT7V//+lfbunXrDI9P/6d27dp24cKFNjEx0d54441227Zt9pdffrEVK1a0K1eutFWqVAkeV69eveD3YP78+bZu3bo2MTHR9unTx7766qvBDB988EHwfIMHD7aJiYn2zTfftI888ohNTEy0Xbp0sX379rWJiYn2v//9r61cufIFtz/xxBP2hRdesImJiXbKlClWkt22bdtZX8e2bdtsrVq17J49e2xiYqIdOHCgfeGFF+z27dtt2bJl7eHDh21iYqLdsWPHeTlD5R46dKhNTEy03bp1s9HR0Xb37t1269attlixYjYxMdHu27fPHj582Fpr7f79++2tt95qT58+bbdt22ajo6ODPw+zZ8+2nTt3tqdPn7apqam2WbNm9ptvvjnv56ZevXr2hx9+sNZa+8Ybb9iOHTtaa61dt26dLV26tD127JgdO3asjYqKsgcPHgz5sxcZGWmttfbTTz+1DRs2tCkpKXbv3r22dOnS9rfffrOzZs2ysbGxNjk52Vprg+c5cOBA8Bz9+vWzw4cPt9Za26FDB/vJJ58Enzvz+NixY7ZUqVJ2w4YN1lprH374Yfvvf//bWmvtTTfdFDz+7bffto8//vh5OceOHWtLlChhDxw4YI8ePWqjo6ODX/uZTGe2n8kmyU6ePDl4jvTX4KGHHrIzZswIXsfevXtba60dNmyYLVmypP3tt9/s8ePHbVRUlD1w4IBdu3atbd68uT158qS11tq//e1vdvz48WddQ2vtBfc7N0966b+XF7omffv2tR9++KG11to//vjDlitXziYlJdmxY8fa7t27B48/fPiwPXXqlLXW2rlz59rWrVuf95pr1649b5ukFdahpuFdgQBCatq06XnbWrVqpc6dO+vo0aNndZLOaN++vdq3b6+DBw/q4YcfPuu5cNvvlSpV0o4dO/Tpp5+e1zlITExU165dtWXLFhljdOrUKUlp9xZ85513VKtWLT366KOO99O7t2FjGWN0++23q3jx4oqOjpYkVahQQTt27Djv5sTX5MunHDlzBh/fd999F3W8kwMHDqhdu3aaMGGCKlasqKSkJC1fvlwdOnQI7nOmS3EhDzzwgCSpatWq+u9//ytJ+u677/Thhx9KkurVq6dDhw7p8OHDjtuXLl2qCRMmSJKaNGkScrjy+++/1/r164Pfj5MnT6pGjRoqWLCg8uTJox49eig+Pj54f8OMnPm7FR0dreTkZBUoUEAFChRQnjx5lJCQoNy5c+uFF17Qt99+qxw5cmj37t36/fffzzvPnDlzNGfOHFWrVk1SWqdr06ZNqlu3ruNrL168WE8++aSktO/bTTfdFOz2NWrUSNdee+0Fsy9evFgPPvigIiIidP3116tevXr64Ycf9M033+jRRx9Vvnz5JCl4ntWrV+vFF19UQkKCkpKSFB8ff8Hzb9iwQTfffLPKly8vSerQoYPefvtt9ezZU5KCN+e+6667NHXq1JDnaNSokYoWLRrcf/HixYqJidHw4cP1+eefS5J27typTZs2qWjRooqIiFCbNm2Cxy9YsECDBw/W0aNHdejQIUVHR+v++++X9H9/5ypXrqzo6Ohgh/eWW27Rzp07tXjxYq1cuVLVq1eXJB07dkzXXXfdeRnnz5/vuN+5eTIS6prMmTNHM2bM0BtvvCFJOn78uHbs2HHesYcPH1aHDh20adOms/5NuRwUVgCynPvuu0/9+vXTrFmzdOjQoeD2V199VXXq1NFHH32kX3/9Vc2aNQs+t2XLFkVGRmrPnj2O582VK7ektEIsd+7cwe05cuQIzqsxxgS3Hzl4UKnpCpwzx5x7/IlUqwOJx/R74vHgtusL5nHMUbBgQZUqVUrfffedKlasqNOnT6tQoUJasmSJ80UJ4UyGiIiIYH4bYijPGOO4Pf3HC7n33ns1duzY87YvWLBACxcu1GeffaZRo0Zp5syZYefOkSOHcuXKFdyeI0cOpaam6pNPPtH+/fu1cuVK5cyZU2XKlNHx48fPO4+1Vn379tUTTzyR4WumP8bJmZtvX8rx1tqQ17Fjx46aNm2a7rjjDo0bN04LFy685HxS6O/5uc7NYYzRwoULNW/ePC1btkz58uXTPffcE7ymefLkUUREhKS0AqRbt25asWKFSpcurZdffvmsa+/0M3DmZ8haqw4dOuif//xnhl+n037p84TD6efgs88+02233XbWvsuXLz/rcf/+/XXvvffq888/1/bt23XPPfeE/bpOmGMFIKRZs2ad9+fMO/by5csX8vkzcyeKFi163nMX4+GHH9bzzz8f7AidkZiYGJzMPnHixOD2w4cP6/nnn9eXX36pQ4cOnTUP6WIVL15cGzZs0OnTpzXtv/8Nq3N0sXLlyqWPPvpIkyZN0pQpU1SwYEHddNNNwW6CtVa//PLLJZ27Vq1amjJliiRp0aJFKlq0qAoWLBjW9jlz5ighxIKo1atX1/Lly7VlyxZJ0tGjR7Vp0yYlJSUpMTFR8fHxGjRokH7++WdJaXNkzszBuhSJiYm67rrrlDNnTi1YsEC//vqrJKlAgQI6cuRIcL/4+HiNGTMm+Fq7d+/Wvn37LnjuunXrBv/ubNy4UTt27Djvl29Gx0+ePFmpqanav3+/vv32W9WoUUONGzfWmDFjdPToUUkK/ofgyJEjKlmypE6dOnXW39lzv5YzKlSooO3bt2vz5s2SpA8//FD16tULO58kzZ07V4cOHdKxY8c0bdo0xcXF6fDhwypSpIjy5cun9evX67vvvgt57JkiqlixYkpKSgrO+wpXgwYN9Omnnwa/D4cOHQp+/3LmzBnsCF1ovwtxum7nio+P13/+859gofrjjz+GPP7w4cOKioqSlDY/zQ0UVgCynKioqOBk9PSeeuopvfzyy2rUqNFZ7xbq27evOnXqpHLlyuntt9/WgAEDtD+wuOfFGjhwoNq2bavmzZureLFil/w1ZCQyMlJTpkzR22+/rS+++EKjR4/WBx98oFq1aqlGjRr64osvLum8ffv21Y8//qjY2FgNGDBA77777gW39+nTR0uWLFGdOnX09ddfq3Tp0ueds1ixYnrnnXf02GOPKTY2Vg0aNAgWVm3btlVsbKyaNm0a7D786U9/0ltvvaXatWtr69atF/01tG3bVitWrFBMTIwmTpyoChUqSEor2OPi4lSpUiX16tVLjRs31l//+lfFxsaqcuXK+tOf/pThL91u3bopNTVVlStX1l/+8heNGzfurM5LRlq1aqUqVarojjvuUP369TV48GCVKFFCTZo00QMPPKCYmBhVrVo1OAT1j3/8Q3fffbcaNWoU/DokqV27dhoyZIiqVasWLFiltG7N2LFj1bZtW1WuXFk5cuQI680R6dWuXVsPP/ywqlatqjZt2igmJkZNmjRRSkqKqlSpov79+zsOlxcuXFidO3dW5cqV1bJly+BQXbhuv/12vfrqq2rcuLGqVKmiRo0aBbvIXbp0UZUqVdS+ffsL7nchHTt2VNeuXc+avB5K//79derUKVWpUkWVKlVS//79JaV1XteuXRucvN67d2/17dtXcXFxrr0j0mTUdrwSYmJi7IoVK7yOAWR506ZNu+y37DspVKiQypYtmynn9kr6obkzLjREd67dgXcdRpUrl6mvg7OlpKSoSJEiXsfwpXHjxmnFihUaMWKE11GuGuvWrVPFihXP2maMWWmtjQm1P3OsAOAKoQADrn4UVgAAXCU6duyojh07eh0jW6OwAgAH16VbLBQAwpHh5HVjTB5jzPfGmP8ZY9YYYwYGtl9rjJlrjNkU+Fgk3TF9jTGbjTEbjDEXXrQDALKonPnzK6fL94gDcHUL512BJyTVt9beIamqpCbGmJqS+kiab60tJ2l+4LGMMbdLaicpWlITSSONMeEvSAEAWcTR/ft19BLfXQgge8pwKDCwdPuZBUlyBv5YSS0k3RPYPl7SQknPB7Z/bK09IWmbMWazpBqS/u+GPwDgslATwy/XH4E1nfIVL+76uQFcncJax8oYE2GM+UnSPklzrbXLJV1vrd0jSYGPZ9asj5K0M93huwLbAOCCEhIS9PDDD+uuu+5STExMcJXkn3/+WfXr11dcXJzq1aunUMuznDh+XG2axev+Rvfovvp19NYb/wo+N/i1V9S8YT31eqp7cNukSZM0cuRIxyybNm1Sl7//XfEtWigmJkYdOnTQvn37tGjRIrVt2/aCX8ewIYOCN/d1snzpEq1a8f0F93FDOHkBuCesyevW2lRJVY0xhSV9boypdIHdQ90b4bzFsowxXSR1kaQbb7wxnBgArqAlS5aEtcJxuAoUKKC4uLgL7vP888+rYcOG+vDDD3Xy5MngKtb9+/dXnz591LhxY82ePVsvvfTSeau558qdWx9M+UyRkfl16tQptWt1v+re20Bly5XXjyt/0Mx53+iZHl21Zs0a3XLLLfroo48c77V2/PhxtW3bVs89+aTurVtXUeXK6dtvv9WBAwfC+lp79uqT4TIKy5ctUb7ISN1X3/m+dudKSUnRNdfwniMgK7uon1BrbYIxZqHS5k79bowpaa3dY4wpqbRulpTWoUq/dG8pSb+FONcoSaOktAVCLyE7gEx05MgRFSxY0LXzJSYmZvj80qVLgyuC58qVK3gfOWNMsMhLTExUiRIlzjveGKPIyLSJ5ikpp5SSckrGGJkcOXTy5ClZa3X8+HHlzJlTb731lrp27aqc6W6wnN4nn3yiGjVq6N50N/M9c2PfRYsWZfi19n76SbW6v5latmypSpUq6cEHH9RXX32lY8dPavj/G63cuXNr0oTxisgRoVnTp2rIkCEqX768evbsqZ070xr+//rXv1SzZk29/vrr2rt3r3799VcVLVpU27Zt08iRI4MLFjZt2lSvvfaaUlNT1adPHx0/flx58uTRO++8o3IZLGwKwH3hvCuweKBTJWNMXkkNJa2XNEPSmVuxd5A0PfD5DEntjDG5jTE3SyonKfP73QB8bfv27SpatKj+9re/qXbt2urRo4eSk5MlpRUZ/fv3V8WKFfXiiy/q5ZdfDnmO1NRU3d/4XtW843bF1amnqnfepfz58yu+aTM9EF9fpW+8UQULFtSqVavOuoHzuc7c8sItRYsW1aJFi/TXRzro/XdHqlTpG/XgQx3UsfMTWrJkiWrVqqXevXure/fu+uabbzRhwgT16NEjePxPP/2kjz/+WGPGjFGbNm2Cnba9e/dqz549qlatmsqXL6+vvvpKixcvVr9+/TRw4EDX8gMIXzgdq5KSxgfe2ZdD0hRr7UxjzDJJU4wxj0vaIamtJFlr1xhjpkhaKylFUvfAUCIAOEpJSdH//vc/DRkyRNWrV1fv3r01dOhQ9e/fX6NHj9Y///lPtWjRQlOnTlWPHj00Y8aM884RERGh/85ZoMTDh9WtU0dtXL9O5StUVJduT6pLtyclSf944Tn169dP48eP19dff63o6Gj17t07ZKbrS5Vy5Wt74IEHJEnRle/QnC9D3wNw4cKF2rBhQ/DxkSNHgl26++67T3nz5pUktW7dWi1atFC/fv00depUtWrVSlJaJ69r167asmWLjDHBm90CuLIy7FhZa3+21laz1lax1lay1r4S2H7QWtvAWlsu8PFQumNes9beaq29zVr7ZWZ+AQCuDlFRUYqKigre9LVly5b63//+JyltovmZ4qRVq1ZauXLlBc9VsFAh3R1bS98u/Pqs7WtW/yJJKlu2rCZNmqTx48dr7dq12rx581n7VaxYUT/99JOuyZtX1wQKmstx5ia/ERERSkkJ/f/M06dPa968eVqyZImWLFmiDRs2qECBApLSbth8xg033KBrr71Wq1ev1tSpU9WmTRtJ0quvvqo6depo+fLlmjx5sk6cOHHZuQFcvLDeFQgAme36669XVFSUNgVufLxw4UJVqFBBklSiRAktXrxYkvTNN9/o1ltvPe/4gwcPKPHwYUnS8WPHtHTxt7ql7NlzjIYNGaR+/frp1KlTwTvZ58iRQ8eOHTtrv7Zt22r58uWa/vHHSv79d0nS3LlztWbNGte+3sj8+ZWclBR8XL9+fY0aNSr4+Oeff3Y8tk2bNho2bJgSExMVHR0tKa1jdcMNN0iSJk6c6FpOABeHwgpAljFkyBB16tRJsbGx+uWXX/Tss89Kkv7zn/+oX79+qlWrlgYOHKi33npLkrRnz55gx2b/77/roT+3UvOG9dS6ebxq1amn+g0bB88996tZqnJHVZUsWVKFCxdWjRo1VLNmTRljVLly5bNy5M2bV5988on+39ixurt+fVWvXl0TJ05U8cB6Vt98840qVKgQ/PPjyh8u+mut3yhec7+apbi4OC1dulRDhgzRjz/+qNjYWFWvXl1jxoxxPLZly5b67LPPgsOAkvTUU0/p5ZdfVqNGjYJFI4Arz6St/+mtmJgYG2pdGgBnmzZtmgoXLpwp5y5UqJDKli0bfOzFcguXI9wFQjNaBiG93YHuWVQG764L9dqhXifc/bK7lJQUFSlSJOMdgStg3bp1wXfhnmGMWWmtjQm1PwuiAAgpM4sgALhaMRQIAADgEgorAAAAlzAUCCDIWitjQt2VKnsqcdNNXkcA4KFLmYdOxwqApLRVyw8fPnxJ/5BcrSJy5VJE4LY6ALIXa60OHjyoPHku7g0mdKwASJKSk5P1+++/h32j4awm8Xh4K40fyRP6/oChnAjc3zB3BvdMDPXaoV4n3P2yu9OnTytfvnxexwCUJ08elbrIOzBQWAGQlPa/s6R0C1b6zbB5G8Par2fD8mGf88XmzSVJr86cedGvHep1wt0vu0tISFDLli29jgFcEgorANkKxQ2AzMQcKwAAAJdQWAEAALiEwgoAAMAlzLECAAcvTZjgdQQAPkNhBQAOcmXSDa8BXL0YCgQABwsGDtSCgQO9jgHAR+hYAYCD+T/8IEm61+McAPyDjhUAAIBLKKwAAABcQmEFAADgEgorAAAAlzB5HQAcZHTzZQA4Fx0rAAAAl1BYAYCD2X37anbfvl7HAOAjDAUCgINFv/wiSYr3OAcA/6CwAgAHJ1JOS5KGzdsY3NazYXmv4gDwAYYCAQAAXEJhBQAA4BKGAgHAQa4cEV5HAOAzFFYAsrT085vOuFLznIo/8+YVeR0AVw+GAgEAAFxCYQUADnJOGKqcE4Z6HQOAjzAUCAAOtu/dIUmK8jgHAP+gYwUAAOASCisAAACXUFgBAAC4hDlWAOAgf85cXkcA4DMUVgDgoNBTg72OAMBnGAoEAABwCYUVADgw4wbJjBvkdQwAPsJQIAA42HVgryTWsQIQPjpWAAAALqFjBQAe8vIm0wDcR8cKAADAJXSsAMBB4Tz5vI4AwGcorADAQWSP172OAMBnKKwAZBmh5hsBgJ9QWAGAg9Oj/yFJytGp/0UfS5EIZE8UVgDgYE/CQUmsYwUgfBRWALI9uksA3MJyCwAAAC6hsAIAAHAJQ4EA4KB4/oLnbWPYEMCFUFgBgINcXV/xOgIAn2EoEAAAwCUUVgDg4OS7L+nkuy95HQOAjzAUCAAO9iclSmIdKwDho2MFAADgEgorAAAAl1BYAQAAuIQ5VgDgoGThol5HAOAzFFYA4CBHp/5eRwDgMwwFAgAAuITCCgAcJI94QckjXvA6BgAfYSgQABwkHD8qSYr0OAcA/6BjBQAA4BI6VgB8Z9i8jV5HAICQ6FgBAAC4hI4VADgoVayEJMl6nAOAf1BYAYAD27GP1xEA+AxDgQAAAC6hsAIAB4ff6q3Db/X2OgYAH2EoEAAcJJ06KUkq5HEOAP5BxwoAAMAlGRZWxpjSxpgFxph1xpg1xpinAttfNsbsNsb8FPjTNN0xfY0xm40xG4wx8Zn5BQAAAGQV4QwFpkh61lq7yhhTQNJKY8zcwHP/tta+kX5nY8ztktpJipZ0g6R5xpjy1tpUN4MDAABkNRkWVtbaPZL2BD4/YoxZJynqAoe0kPSxtfaEpG3GmM2Sakha5kJeALhiypS4UZJ0yuMcAPzjoiavG2PKSKomabmkOEk9jDGPSFqhtK7WH0orur5Ld9guXbgQA4As6dRDz3gdAYDPhD153RiTX9JnknpaaxMlvSPpVklVldbRevPMriEOP2/hYmNMF2PMCmPMiv37919sbgAAgCwnrI6VMSan0oqqidbaqZJkrf093fPvSZoZeLhLUul0h5eS9Nu557TWjpI0SpJiYmK4YwSQzfjhRsr7hz4rSSr+zJsZ7Jn5Ql2vng3Le5AEwIWE865AI+l9SeustUPTbS+ZbrdWklYHPp8hqZ0xJrcx5mZJ5SR9715kALgyTp5O1cnTvO8GQPjC6VjFSXpY0i/GmJ8C216Q9KAxpqrShvm2S3pCkqy1a4wxUyStVdo7CrvzjkAAAJAdhPOuwMUKPW9q1gWOeU3Sa5eRCwAAwHdYeR0AAMAl3CsQQKbzw0T1UG4pXVaSdMLjHAD8g8IKAByc+EsPryMA8BkKKwDIYvza4QPAHCsAcLT7jZ7a/UZPr2MA8BEKKwAAAJdQWAEAALiEwgoAAMAlTF4HAJ/i/oFA1kNhBQAOyt4SLUk65nEOAP5BYQUADo617ux1BAA+wxwrAHCQ42iSchxN8joGAB+hYwUADnaOfFGSFPXcMG+DAPANOlYAAAAuobACAABwCYUVAACASyisAAAAXMLkdQBwUL7CnZKkZI9zAPAPCisAcJDc/BGvIwDwGYYCAcBBzoN7lfPgXq9jAPARCisAcLB97CBtHzvI6xgAfITCCgAAwCUUVgAAAC6hsAIAAHAJhRUAAIBLWG4BAByUr1JTEutYAQgfhRUAOEhu3M7rCAB8hqFAAHCQZ/dW5dm91esYAHyEwgoAHGyZNFxbJg33OgYAH6GwAgAAcAmFFQAAgEsorAAAAFxCYQUAAOASllsAAAcVYu6VJB3xOAcA/6CwAgAHR+5p4XUEAD7DUCAAOMi7ZbXyblntdQwAPkJhBQAONn8+Wps/H+11DAA+QmEFAADgEgorAAAAl1BYAQAAuITCCgAAwCUstwAADm6Lu0+SlORxDgD+QWEFAA6SYuO9jgDAZxgKBAAHkWt+UOSaH7yOAcBH6FgBgIONX06UJEVFV/c4CQC/oGMFAADgEgorAAAAlzAUCMBVw+Zt9DoCAHiGjhUAAIBL6FgBgIPb6reWxDpWAMJHYQUADpLurOt1BAA+w1AgADjIv+pb5V/1rdcxAPgIHSsAcLDh66mSpCg6VwDCRMcKAADAJRRWAAAALqGwAgAAcAmFFQAAgEuYvA4ADsrf116SlOxxDgD+QWEFAA6So6t7HQGAzzAUCAAO8i+brfzLZnsdA4CP0LECAAcblnwpSYqKjfc4CQC/oGMFAADgEgorAAAAl1BYAQAAuITCCgAAwCVMXgcAB2VbdZIkHfM4BwD/oLACAAfHbq3kdQQAPkNhBSAsw+ZtPG9bz4blPUhy5RRYOF2SdOSeFh4nAeAXzLECAAfrVyzQ+hULvI4BwEfoWAG4ZKG6WACQnVFYAQAkZc/hXsBtDAUCAAC4hMIKAADAJQwFAoCDWx/8uyTpuMc5APgHhRUAODgedYvXEQD4TIZDgcaY0saYBcaYdcaYNcaYpwLbrzXGzDXGbAp8LJLumL7GmM3GmA3GmPjM/AIAILNEzvlYkXM+9joGAB8JZ45ViqRnrbUVJdWU1N0Yc7ukPpLmW2vLSZofeKzAc+0kRUtqImmkMSYiM8IDQGba+PN32vjzd17HAOAjGRZW1to91tpVgc+PSFonKUpSC0njA7uNl9Qy8HkLSR9ba09Ya7dJ2iyphsu5AQAAspyLelegMaaMpGqSlku63lq7R0orviRdF9gtStLOdIftCmwDAAC4qoVdWBlj8kv6TFJPa23ihXYNsc2GOF8XY8wKY8yK/fv3hxsDAAAgywqrsDLG5FRaUTXRWjs1sPl3Y0zJwPMlJe0LbN8lqXS6w0tJ+u3cc1prR1lrY6y1McWLF7/U/AAAAFlGhsstGGOMpPclrbPWDk331AxJHSQNCnycnm77R8aYoZJukFRO0vduhgaAK6HMo30kSac8zgHAP8JZxypO0sOSfjHG/BTY9oLSCqopxpjHJe2Q1FaSrLVrjDFTJK1V2jsKu1trU90ODgCZ7VTREl5HAOAzGRZW1trFCj1vSpIaOBzzmqTXLiMXAHgucuYHkqTk5o94nASAX3CvQABwsHH9Km1cv8rrGAB8hFvaAMBVZNi8jedt69mwvAdJgOyJjhUAAIBL6FgBwFXucrpYoY69mOOB7IaOFQAAgEvoWAGAg9LdXpUknfY4R2Zw6kQBuDwUVgDg4HS+/F5HAOAzDAUCgIO8U99T3qnveR0DgI/QsQIAB5u3rpEkRXmcA4B/0LECAABwCYUVAACASyisAAAAXEJhBQAA4BImrwM4D2scpYl6bpjXEQD4DB0rAAAAl1BYAYCD3JNHKPfkEV7HAOAjDAUCgIOtOzdLYh0rAOGjYwUAAOASCisAAACXUFgBAAC4hDlWAOAgV44IryMA8BkKKwBwUPyZN72OAMBnGAoEAABwCYUVADjIOWGock4Y6nUMAD7CUCAAONi+d4ck1rECED46VgAAAC6hsAIAAHAJhRUAAIBLmGMFAA7y58zldQQAPkNhBQAOCj012OsIAHyGoUAAAACXUFgBgAMzbpDMuEFexwDgIwwFAoCDXQf2SmIdKwDho2MFAADgEgorAAAAl1BYAQAAuIQ5VgDgoHCefF5HAOAzFFYA4CCyx+teRwDgMwwFAgAAuITCCgAcnB79D50e/Q+vYwDwEYYCAcDBnoSDkljHCkD46FgBAAC4hMIKAADAJRRWAAAALmGOFQA4KJ6/oNcRAPgMhRUAOMjV9RWvIwDwGYYCAQAAXEJhBQAOTr77kk6++5LXMQD4CEOBAOBgf1KiJNaxAhA+OlYAAAAuobACAABwCYUVAACAS5hjBQAOShYu6nUEAD5DYQUADnJ06u91BAA+w1AgAACASyisAMBB8ogXlDziBa9jAPARhgIBwEHC8aOSpEiPcwDwDworIJsYNm9jyO09G5a/wkkA4OpFYQUAuGihCnWKdIA5VgAAAK6hYwVkc05DhJBKFSshSbIe5wDgHxRWAODAduzjdQQAPsNQIAAAgEsorADAweG3euvwW729jgHARxgKBAAHSadOSpIKeZwDgH/QsQIAAHAJhRUAAIBLKKwAAABcwhwrAHBQpsSNkqRTHucA4B8UVgDg4NRDz3gdAYDPMBQIAADgEgorAHCwf+iz2j/0Wa9jAPARhgIBwMHJ06leRwDgM3SsAAAAXEJhBQAA4JIMCytjzBhjzD5jzOp02142xuw2xvwU+NM03XN9jTGbjTEbjDHxmRUcAAAgqwlnjtU4SSMkfXDO9n9ba99Iv8EYc7ukdpKiJd0gaZ4xpry1lokKAHznltJlJUknPM4BwD8yLKystd8aY8qEeb4Wkj621p6QtM0Ys1lSDUnLLj0iAHjjxF96eB0BgM9czhyrHsaYnwNDhUUC26Ik7Uy3z67ANgAAgKvepRZW70i6VVJVSXskvRnYbkLsa0OdwBjTxRizwhizYv/+/ZcYAwAyz+43emr3Gz29jgHARy6psLLW/m6tTbXWnpb0ntKG+6S0DlXpdLuWkvSbwzlGWWtjrLUxxYsXv5QYAAAAWcolFVbGmJLpHraSdOYdgzMktTPG5DbG3CypnKTvLy8iAACAP2Q4ed0YM0nSPZKKGWN2SRog6R5jTFWlDfNtl/SEJFlr1xhjpkhaKylFUnfeEQgAALKLcN4V+GCIze9fYP/XJL12OaEAAAD8iHsFAoCDsrdES5KOeZwDgH9QWAGAg2OtO3sdAYDPcK9AAHCQ42iSchxN8joGAB+hYwUADnaOfFGSFPXcMG+DAPANOlYAAAAuobACAABwCYUVAACASyisAAAAXMLkdQBwUL7CnZKkZI9zAPAPCisAcJDc/BGvIwDwGYYCAcBBzoN7lfPgXq9jAPARCisAcLB97CBtHzvI6xgAfITCCgAAwCXMsQKuQsPmbfQ6AgBkS3SsAAAAXEJhBQAA4BKGAgHAQfkqNSWxjhWA8FFYAYCD5MbtvI4AwGcYCgQAB3l2b1We3Vu9jgHARyisAMDBlknDtWXScK9jAPARCisAAACXUFgBAAC4hMIKAADAJRRWAAAALmG5BQBwUCHmXknSEY9zAPAPCisAcHDknhZeR/CVcO9R2bNh+UxOAniHoUAAcJB3y2rl3bLa6xgAfISOFeBz4XYJcPE2fz5akhT13DBvgwDwDTpWAAAALqGwAgAAcAmFFQAAgEsorAAAAFzC5HUAcHBb3H2SpCSPcwDwDworAHCQFBvvdYSrUqh3srK2Fa4WDAUCgIPINT8ocs0PXscA4CN0rAAf+XTlTiXZfV7HyDY2fjlRkhQVXd3jJAD8go4VAACASyisAAAAXMJQIADAc+kntOc3J9Tzuy+0fVAzDxMBl4aOFQAAgEvoWAGAg9vqt5bEOlYAwkdhBQAOku6s63UEAD7DUCAAOMi/6lvlX/Wt1zEA+AgdKwBwsOHrqZKkKDpXnijT54vztjGhHVkdHSsAAACXUFgBAAC4hMIKAADAJRRWAAAALmHyOgA4KH9fe0lSssc5APgHhRUAOEiOru51BAA+w1AgADjIv2y28i+b7XUMAD5CxwoAHGxY8qUkKSo23uMkAPyCjhUAAIBLKKwAAABcQmEFAADgEgorAAAAlzB5HQAclG3VSZJ0zOMcAPyDwgoAHBy7tZLXEQD4DEOBAOCgwMLpKrBwutcxAPgIhRUAOFi/YoHWr1jgdQwAPkJhBQAA4BIKKwAAAJdQWAEAALiEwgoAAMAlLLcAAA5uffDvkqTjHucA4B8UVgDg4HjULV5HAOAzDAUCgIPIOR8rcs7HXscA4CN0rIAsqkyfL87bVjunB0GysY0/fydJimrczuMkAPyCjhUAAIBLKKwAAABcwlAgAMA3Qg2Rbx/UzIMkQGh0rAAAAFxCxwoAHJR5tI8k6ZTHOQD4B4UVADg4VbSE1xEA+AxDgQDgIHLmB4qc+YHXMQD4SIaFlTFmjDFmnzFmdbpt1xpj5hpjNgU+Fkn3XF9jzGZjzAZjTHxmBQeAzLZx/SptXL/K6xgAfCScjtU4SU3O2dZH0nxrbTlJ8wOPZYy5XVI7SdGBY0YaYyJcSwsAAJCFZTjHylr7rTGmzDmbW0i6J/D5eEkLJT0f2P6xtfaEpG3GmM2Sakha5lJewPd4uzgAXL0udY7V9dbaPZIU+HhdYHuUpJ3p9tsV2AYAAHDVc3vyugmxzYbc0ZguxpgVxpgV+/fvdzkGAADAlXepyy38bowpaa3dY4wpKWlfYPsuSaXT7VdK0m+hTmCtHSVplCTFxMSELL4AwEulu70qSTrtcQ4A/nGpHasZkjoEPu8gaXq67e2MMbmNMTdLKifp+8uLCADeOJ0vv07ny+91DAA+kmHHyhgzSWkT1YsZY3ZJGiBpkKQpxpjHJe2Q1FaSrLVrjDFTJK2VlCKpu7U2NZOyA0Cmyjv1PUnSsdadPU4CwC/CeVfggw5PNXDY/zVJr11OKADICjZvXSOJd+AACB8rrwMAALiEewUCWUCota0AAP5DxwoAAMAlFFYAAAAuYSgQABxEPTfM6wgAfIaOFQAAgEsorADAQe7JI5R78givYwDwEYYCAcDB1p2bJbGOFYDw0bECAABwCYUVAACASyisAAAAXMIcKwBwkCtHhNcRAPgMhRUAOCj+zJteRwDgMxRWQCbiHoAAkL0wxwoAHOScMFQ5Jwz1OgYAH6FjBQAOtu/dIYl1rACEj44VAACASyisAAAAXEJhBQAA4BLmWAGAg/w5c3kdAYDPUFgBgINCTw32OgLCEO6yJtsHNcvkJABDgQAAAK6hsAIAB2bcIJlxg7yOAcBHGAoEAAe7DuyVxDpWAMJHxwoAAMAlFFYAAAAuobACAABwCXOsAMBB4Tz5vI4AwGcorADAQWSP172OAMBnGAoEAABwCYUVADg4PfofOj36H17HAOAjDAUCgIM9CQclsY4VgPBRWAEuCfd+ZQCAqxdDgQAAAC6hsAIAAHAJQ4EA4KB4/oJeRwDgMxRWAOAgV9dXvI4AwGcYCgQAAHAJhRUAODj57ks6+e5LXscA4CMMBQKAg/1JiZJYxwpA+OhYAQAAuITCCgAAwCUUVgAAAC5hjhUAOChZuKjXEeCBULen2j6omQdJ4EcUVgDgIEen/l5HAOAzDAUCAAC4hMIKABwkj3hBySNe8DoGAB9hKBAAHCQcPypJivQ4B9wRau4U4DYKK+AS8A80kL04/cwzqR3nYigQAADAJRRWAAAALmEoEAAclCpWQpJkPc4BwD8orADAge3Yx+sIAHyGoUAAAACXUFgBgIPDb/XW4bd6ex0DgI8wFAgADpJOnZQkFfI4BwD/oGMFAADgEgorAAAAl1BYAQAAuIQ5VgDgoEyJGyVJpzzOAcA/KKwAwMGph57xOgIAn2EoEAAAwCUUVgDgYP/QZ7V/6LNexwDgIwwFAoCDk6dTvY4AwGfoWAEAALiEwgoAAMAlFFYAAAAuYY4VADi4pXRZSdIJj3MA8A8KKwBwcOIvPbyOAMBnGAoEAABwCR0rIANl+nzhdQR4ZPcbPSVJUc8N8zQHAP+gYwUAAOASCisAAACXUFgBAAC4hMIKAADAJZc1ed0Ys13SEUmpklKstTHGmGslTZZURtJ2SX+21v5xeTGByxNqAvr2Qc08SAI/KXtLtCTpmMc5APiHG+8KvNdaeyDd4z6S5ltrBxlj+gQeP+/C6wDAFXWsdWevIwDwmcwYCmwhaXzg8/GSWmbCawBApstxNEk5jiZ5HQOAj1xuYWUlzTHGrDTGdAlsu95au0eSAh+vu8zXAABP7Bz5onaOfNHrGAB85HKHAuOstb8ZY66TNNcYsz7cAwOFWBdJuvHGGy8zBgAAgPcuq7Cy1v4W+LjPGPO5pBqSfjfGlLTW7jHGlJS0z+HYUZJGSVJMTIy9nByAW1hlHQBwOS55KNAYE2mMKXDmc0mNJa2WNENSh8BuHSRNv9yQAAAAfnA5HavrJX1ujDlzno+stV8ZY36QNMUY87ikHZLaXn5MwH10pwAAbrvkwspau1XSHSG2H5TU4HJCAUBWUL7CnZKkZI9zAPAPN9axAoCrUnLzR7yOAMBnuKUNADjIeXCvch7c63UMAD5CYQUADraPHaTtYwd5HQOAj1BYAQAAuITCCgAAwCUUVgAAAC6hsAIAAHAJyy0AgIPyVWpKYh0rOAu10PD2Qc08SIKsgsIKABwkN27ndQQAPsNQIAA4yLN7q/Ls3up1DAA+QmEFAA62TBquLZOGex0DgI9QWAEAALiEwgoAAMAlFFYAAAAuobACAABwCcstAICDCjH3SpKOeJwDgH9QWAGAgyP3tPA6AgCfYSgQABzk3bJaebes9joGAB+hYwUADjZ/PlqSFPXcMG+DwFe4zU32RscKAADAJRRWAAAALqGwAgAAcAmFFQAAgEuYvA7fCjVBFHDTbXH3SZKSPM4BwD8orADAQVJsvNcRAPgMQ4EA4CByzQ+KXPOD1zEA+AgdKwBwsPHLiZKkqOjqHicB4Bd0rAAAAFxCxwoAgEzGauzZBx0rAAAAl1BYAQAAuIShQABwcFv91pJYxwpA+CisAMBB0p11vY4AwGcYCgQAB/lXfav8q771OgYAH6FjBQAONnw9VZIURecKQJgorAAA8ABLMFydGAoEAABwCYUVAACASyisAAAAXMIcKwBwUP6+9pKkZI9zAPAPCisAcJAcXd3rCAB8hqFAAHCQf9ls5V822+sYAHyEjhUAONiw5EtJUlRsvMdJkJ2xLIO/0LECAABwCR0rXDGX87+uUMcCAJDV0LECAABwCYUVAACASxgKBAAHZVt1kiQd8zgHAP+gsAIAB8dureR1BAA+Q2GFLIeJ6sgqCiycLkk6ck8Lj5MA8AsKKwBwsH7FAklSFIUVrpBw/2PJ2lZZF5PXAQAAXEJhBQAA4BIKKwAAAJcwxwqZ4nLmCQAA4FcUVgDg4NYH/y5JOu5xDgD+QWEFAA6OR93idQQAPkNhBQAOIud8LElKbtzO4yRAxsKdWsGyDJmLyesA4GDjz99p48/feR0DgI9QWAEAALiEoUBcNt7ZBwBAGjpWAAAALqFjhYtCdwoA/I37DGYuCisAcFDm0T6SpFMe5wDgHxRWkMT/YIBQThUt4XUEAD7DHCsAcBA58wNFzvzA6xgAfITCCgAcbFy/ShvXr/I6BgAfYSgQAIBsjukg7qFjBQAA4BI6VtkQSyYAADJCF+vSUFhd5S6niKIAAwBkxOl3RXYtwiisAMBB6W6vSpJOe5wDgH9QWGVxtGIB75zOl9/rCECWkhkjGeGe0y+/+5i8DgAO8k59T3mnvud1DAA+QscqC2FOE5C1bN66RpIU5XEOwI+y64hLphVWxpgmkt6SFCFptLV2UGa9Vrjc/iZnpb80FGUAgKzO7d9VWen38BmZMhRojImQ9Lak+yTdLulBY8ztmfFaAAAAWUVmdaxqSNpsrd0qScaYjyW1kLQ2k14vy7gSk/DoTgEAshu//O7LrMnrUZJ2pnu8S0xTAAAAVzljrXX/pMa0lRRvre0UePywpBrW2ifT7dNFUpfAw9skbXA9yJVTTNIBr0NkQVwXZ1wbZ1yb0Lguzrg2oXFdnF3utbnJWls81BOZNRS4S1LpdI9LSfot/Q7W2lGSRmXS619RxpgV1toYr3NkNVwXZ1wbZ1yb0Lguzrg2oXFdnGXmtcmsocAfJJUzxtxsjMklqZ2kGZn0WgAAAFlCpnSsrLUpxpgekmYrbbmFMdbaNZnxWgAAAFlFpq1jZa2dJWlWZp0/i7kqhjQzAdfFGdfGGdcmNK6LM65NaFwXZ5l2bTJl8joAAEB2xL0CAQAAXEJh5QJjzBBjzHpjzM/GmM+NMYW9zuQ1Y0wTY8wGY8xmY0wfr/NkBcaY0saYBcaYdcaYNcaYp7zOlNUYYyKMMT8aY2Z6nSUrMcYUNsZ8Gvh3Zp0xJtbrTFmBMebpwM/SamPMJGNMHq8zecUYM8YYs88YszrdtmuNMXONMZsCH4t4mdErDtcm035vU1i5Y66kStbaKpI2SurrcR5PcUsjRymSnrXWVpRUU1J3rst5npK0zusQWdBbkr6y1laQdIe4RjLGREn6u6QYa20lpb1Rqp23qTw1TlKTc7b1kTTfWltO0vzA4+xonM6/Npn2e5vCygXW2jnW2pTAw++Utm5Xdha8pZG19qSkM7c0ytastXustasCnx9R2i9H7kgQYIwpJamZpNFeZ8lKjDEFJdWV9L4kWWtPWmsTPA2VdVwjKa8x5hpJ+XTOeonZibX2W0mHztncQtL4wOfjJbW8kpmyilDXJjN/b1NYue8xSV96HcJj3NIoA8aYMpKqSVrucZSsZJik3pJOe5wjq7lF0n5JYwPDpKONMZFeh/KatXa3pDck7ZC0R9Jha+0cb1NlOddba/dIaf+xk3Sdx3myKld/b1NYhckYMy8wjn/unxbp9umntOGeid4lzRJMiG28/TTAGJNf0meSelprE73OkxUYY5pL2metXel1lizoGkl3SnrHWltNUrKy75BOUGC+UAtJN0u6QVKkMeYhb1PBbzLj93amrWN1tbHWNrzQ88aYDpKaS2pgWcMiw1saZVfGmJxKK6omWmunep0nC4mT9IAxpqmkPJIKGmMmWGv5RZn287TLWnumu/mpKKwkqaGkbdba/ZJkjJkqqZakCZ6mylp+N8aUtNbuMcaUlLTP60BZSWb93qZj5QJjTBNJz0t6wFp71Os8WQC3NArBGGOUNk9mnbV2qNd5shJrbV9rbSlrbRml/X35mqIqjbV2r6SdxpjbApsaSFrrYaSsYoekmsaYfIGfrQZiUv+5ZkjqEPi8g6TpHmbJUjLz9zYLhLrAGLNZUm5JBwObvrPWdvUwkucCnYdh+r9bGr3mbSLvGWNqS1ok6Rf93zyiFwJ3KUCAMeYeSc9Za5t7HCXLMMZUVdqk/lyStkp61Fr7h6ehsgBjzEBJf1HaUM6PkjpZa094m8obxphJku6RVEzS75IGSJomaYqkG5VWiLa11p47wf2q53Bt+iqTfm9TWAEAALiEoUAAAACXUFgBAAC4hMIKAADAJRRWAAAALqGwAgAAcAmFFQAAgEsorAAAAFxCYQUAAOCS/w96HK9Mqo7RuwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOW PLOTTING theta\n",
      "Plotting theta in range [-8.151404760032982, 18.194976395108526] in 100 steps\n",
      "NOW PLOTTING sigma\n",
      "Plotting sigma in range [-335.28590378331955, 2432.301182035654] in 100 steps\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-29-e9871ba6acec>:12: RuntimeWarning: invalid value encountered in log\n",
      "  return np.log(math.sqrt(2*math.pi)*sigma) + ((data-theta)**2/sigma**2).sum()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figs = plr.draw_data()\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "figs = plr.draw_likelihood({'theta' : None, 'sigma' : None})\n",
    "\n",
    "for fig in figs:\n",
    "    plt.show()\n",
    "\n",
    "#x = np.linspace(0,10)\n",
    "#y = [ my_gaussian_likelihood(data[0], [x_i, 1]) for x_i in x]\n",
    "#plt.plot(x, y)\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First let's have one bin (channel) and check it works\n",
    "def my_poisson_count_model_1bin_nonuisance(data, params):\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    return st.poisson(mu*s+b).pmf(data) \n",
    "    #poisson_part = st.poisson(mu*s+b)\n",
    "    #p_nobs_given_exp =poisson_part.pmf(data) # this is pois(Nobs | mu*s + b)\n",
    "    #ret=p_nobs_given_exp\n",
    "    #return ret\n",
    "\n",
    "def my_poisson_count_model_1bin_nonuisance_minusloglikelihood(data, params): # analytical loglikelihood better computationally (small values)\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    return mu*s+b - data*np.log(mu*s+b)\n",
    "\n",
    "\n",
    "\n",
    "Nobs=20\n",
    "sexp=5\n",
    "bexp=15\n",
    "\n",
    "#print(inspect.getsource(my_marked_poisson_model_1bin_nonuisance))\n",
    "\n",
    "x=np.linspace(0,4, num=200) # scan mu\n",
    "y = [ my_poisson_count_model_1bin_nonuisance( Nobs, [x_i, sexp, bexp] ) for x_i in x  ]\n",
    "\n",
    "plt.plot(x,y, label='L( %s | mu*%s +%s)' %(Nobs, sexp, bexp))\n",
    "plt.xlabel('mu = s/s_exp')\n",
    "plt.ylabel('L(%s | mu*%s + %s)'%(Nobs, sexp, bexp))\n",
    "plt.legend(loc='best')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Expected signal sexp')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "yy = np.linspace(1,10, num=10) # scan sexp\n",
    "xx = np.linspace(0,4, num=10) # scan mu\n",
    "zz = np.zeros( (xx.size, yy.size) )\n",
    "counter_y = 0\n",
    "for X in xx:\n",
    "    counter_x = 0\n",
    "    for Y in xx:\n",
    "        zz[counter_x,counter_y] = my_poisson_count_model_1bin_nonuisance(Nobs, [X, Y, bexp])\n",
    "        counter_x += 1\n",
    "    counter_y += 1\n",
    "#zz=[ [ my_marked_poisson_model_1bin_nonuisance(Nobs, [X, Y, bexp]) for Y in yy ] for X in xx]\n",
    "print(len(xx), len(yy), len(zz))\n",
    "X, Y = np.meshgrid(xx,yy)\n",
    "#zz = my_marked_poisson_model_1bin_nonuisance( Nobs, [X, Y, bexp] ) \n",
    "#mmpm1n = np.vectorize(my_marked_poisson_model_1bin_nonuisance)\n",
    "#zz= mmpm1n( Nobs, [X, Y, bexp])\n",
    "#print(my_marked_poisson_model_1bin_nonuisance( Nobs, [0.88888889, 3, bexp] ) )\n",
    "#zz = [ my_marked_poisson_model_1bin_nonuisance( Nobs, [xx_i, yy_i, bexp] ) for xx_i, yy_i in zip(X, Y) ]\n",
    "ax.plot_wireframe(X, Y, zz )\n",
    "ax.set_xlabel('mu = s/s_exp')\n",
    "ax.set_ylabel('Expected signal sexp')\n",
    "#ax.set_zlim(0, 0.0000001)\n",
    "#Nobs=45\n",
    "#debug=True\n",
    "\n",
    "#plr = profile_likelihood_ratio(my_gaussian_likelihood, data, np.mean, my_gaussian_minusloglikelihood)\n",
    "\n",
    "#if debug:\n",
    "#    plr.print_inputs()\n",
    "#plr.do_global_fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test statistic: \n",
      "<function mean at 0x7f07c0081790>\n",
      "Test statistic value:\n",
      "20.0\n",
      "Parameters:\n",
      "('data', 'params', 'mu', 's', 'b')\n",
      "Parameters dictionary:\n",
      "{'mu': 1, 's': 1, 'b': 1}\n",
      "Initial values:\n",
      "[1.0, 1.0, 1.0]\n",
      "Model:\n",
      "def my_poisson_count_model_1bin_nonuisance(data, params):\n",
      "    mu=params[0] # POI\n",
      "    s=params[1] # We will condition on this\n",
      "    b=params[2] # We will condition on this\n",
      "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
      "    return st.poisson(mu*s+b).pmf(data) \n",
      "\n",
      "Likelihood model (fixed data):\n",
      "        self.likelihood_realization=lambda params : (self.model(self.data, params))\n",
      "\n",
      "Likelihood model parameters:\n",
      "('params',)\n",
      "minus-log-Likelihood model (fixed data):\n",
      "        self.minusloglikelihood_realization= lambda params: 2*self.minuslogmodel(self.data, params) #if self.minuslogmodel else -2*np.log(self.model(self.data, params))\n",
      "\n",
      "minus-log-Likelihood model parameters:\n",
      "('params',)\n",
      "par mu has freezestatus [False, None, False]\n",
      "Minuit model settings: {'mu': 1.0, 's': 1.0, 'b': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': False, 'fix_b': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "par s has freezestatus [True, 5, False]\n",
      "I am freezing (conditioning on) parameter s to 5\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "par b has freezestatus [True, 15, False]\n",
      "I am freezing (conditioning on) parameter b to 15\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 15.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "Minimizer will run with the following model settings:  {'mu': 1.0, 's': 5.0, 'b': 15.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "┌──────────────────────────────────┬──────────────────────────────────────┐\n",
      "│ FCN = -79.83                     │         Nfcn = 13 (13 total)         │\n",
      "│ EDM = 2.52e-20 (Goal: 0.0002)    │                                      │\n",
      "├───────────────┬──────────────────┼──────────────────────────────────────┤\n",
      "│ Valid Minimum │ Valid Parameters │        No Parameters at limit        │\n",
      "├───────────────┴──────────────────┼──────────────────────────────────────┤\n",
      "│ Below EDM threshold (goal x 10)  │           Below call limit           │\n",
      "├───────────────┬──────────────────┼───────────┬─────────────┬────────────┤\n",
      "│   Hesse ok    │  Has Covariance  │ Accurate  │  Pos. def.  │ Not forced │\n",
      "└───────────────┴──────────────────┴───────────┴─────────────┴────────────┘\n",
      "Main fit Results [<ValueView of Minuit at 4095c90>\n",
      "  mu: 1.0\n",
      "  s: 5.0\n",
      "  b: 15.0, MErrors([('mu', MError(name='mu', is_valid=True, lower=-0.8290402911094543, upper=0.9624346307137834, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=5, min=1.0))])]\n",
      "Main fit Best estimates <ValueView of Minuit at 4095c90>\n",
      "  mu: 1.0\n",
      "  s: 5.0\n",
      "  b: 15.0\n",
      "Main fit Uncertainties ┌──────────┬───────────────────────┐\n",
      "│          │          mu           │\n",
      "├──────────┼───────────┬───────────┤\n",
      "│  Error   │   -0.8    │    1.0    │\n",
      "│  Valid   │   True    │   True    │\n",
      "│ At Limit │   False   │   False   │\n",
      "│ Max FCN  │   False   │   False   │\n",
      "│ New Min  │   False   │   False   │\n",
      "└──────────┴───────────┴───────────┘\n",
      "Parameter mu = 1.0 (+0.9624346307137834/--0.8290402911094543) [fitted]\n",
      "Parameter s = 5.0 [frozen]\n",
      "Parameter b = 15.0 [frozen]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-28-06043d36ca36>:34: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.print_level=3\n",
      "<ipython-input-28-06043d36ca36>:68: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.draw_mnprofile(list(self.pardict.keys())[0],subtract_min=True)\n",
      "<ipython-input-28-06043d36ca36>:86: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, +1] = results[1][par, +1.0]\n",
      "<ipython-input-28-06043d36ca36>:87: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, -1] = results[1][par, -1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now try profile likelihood ratio routine with this simple model\n",
    "Ntot=1000\n",
    "data = st.poisson.rvs(20, size=Ntot)\n",
    "data = 20\n",
    "debug=True\n",
    "\n",
    "\n",
    "freezelist = {'mu': [False, None, False],\n",
    "              's': [True, 5, False],\n",
    "              'b': [True, 15, False]}\n",
    "\n",
    "plr = profile_likelihood_ratio(my_poisson_count_model_1bin_nonuisance, data, np.mean, my_poisson_count_model_1bin_nonuisance_minusloglikelihood, freezelist)\n",
    "\n",
    "if debug:\n",
    "    plr.print_inputs()\n",
    "plr.do_global_fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now let's try to add a nuisance parameter.\n",
    "\n",
    "# First let's have one bin (channel) and check it works\n",
    "def my_poisson_count_model_1bin(data, params):\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    bunc=params[3] # We will profile this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    pois_term = st.poisson.pmf(data,mu*s+b*(1.+bunc))\n",
    "    #pois_term= ((mu*s+b*(1.+bunc))**data)*np.exp(-(mu*s+b*(1.+bunc)))/math.factorial(data)\n",
    "    #constraint_term = 1./(math.sqrt(2*math.pi)*bunc)*math.exp(-((data-b)**2/bunc**2))\n",
    "    constraint_term=st.norm.pdf(0, b , 1)\n",
    "    #print(pois_term, constraint_term)\n",
    "    #joint_pdf = np.outer(pois_term, constraint_term)\n",
    "    #print(pois_term)\n",
    "    #print(constraint_term)\n",
    "    return pois_term*constraint_term\n",
    "\n",
    "    #poisson_part = st.poisson(mu*s+b)\n",
    "    #p_nobs_given_exp =poisson_part.pmf(data) # this is pois(Nobs | mu*s + b)\n",
    "    #ret=p_nobs_given_exp\n",
    "    #return ret\n",
    "\n",
    "\n",
    "def my_poisson_count_model_1bin_minusloglikelihood(data, params): # analytical loglikelihood better computationally (small values)\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    bunc=params[3] # We will profile this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    #print(mu*s, b*(1.+bunc), mu*s+b*(1.+bunc),math.sqrt(2*math.pi)*bunc)\n",
    "    #print(mu, s, b, bunc)\n",
    "    return mu*s+b*(1.+bunc) - data*np.log(mu*s+b*(1.+bunc)) + 0.5*np.log(2*math.pi) + 0.5*(bunc**2)\n",
    "\n",
    "\n",
    "Nobs=20\n",
    "sexp=5\n",
    "bexp=15\n",
    "bunc=0.2\n",
    "#print(inspect.getsource(my_marked_poisson_model_1bin_nonuisance))\n",
    "\n",
    "x=np.linspace(0,4, num=200) # scan mu\n",
    "\n",
    "\n",
    "y = [ my_poisson_count_model_1bin_minusloglikelihood( Nobs, [x_i, sexp, bexp, bunc] ) for x_i in x  ]\n",
    "#y = my_poisson_count_model_1bin(Nobs, [x, sexp, bexp, bunc])\n",
    "plt.plot(x,y, label='Pois( %s | mu*%s + %s(1+%s*%s))*Gaus(0|%s,1)' %(Nobs, sexp, bexp, bunc, bexp, bunc))\n",
    "plt.xlabel('mu = s/s_exp')\n",
    "plt.ylabel('L(%s | mu*%s + %s(1+%s*%s))*Gaus(0|%s,1)'%(Nobs, sexp, bexp, bunc, bexp,bunc))\n",
    "#plt.ylim(0,0.12)\n",
    "plt.legend(loc='best')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "y2 = [ my_poisson_count_model_1bin( Nobs, [x_i, sexp, bexp, bunc] ) for x_i in x  ]\n",
    "plt.plot(x,y2, label='Pois( %s | mu*%s + %s)' %(Nobs, sexp, bexp))\n",
    "plt.xlabel('mu = s/s_exp')\n",
    "plt.ylabel('L(%s | mu*%s + %s)'%(Nobs, sexp, bexp))\n",
    "plt.ylim(0,0.12)\n",
    "plt.legend(loc='best')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test statistic: \n",
      "<function mean at 0x7f07c0081790>\n",
      "Test statistic value:\n",
      "50.0\n",
      "Parameters:\n",
      "('data', 'params', 'mu', 's', 'b', 'bunc', 'pois_term', 'constraint_term')\n",
      "Parameters dictionary:\n",
      "{'mu': 1, 's': 1, 'b': 1, 'bunc': 1}\n",
      "Initial values:\n",
      "[1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\n",
      "Model:\n",
      "def my_poisson_count_model_1bin(data, params):\n",
      "    mu=params[0] # POI\n",
      "    s=params[1] # We will condition on this\n",
      "    b=params[2] # We will condition on this\n",
      "    bunc=params[3] # We will profile this\n",
      "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
      "    pois_term = st.poisson.pmf(data,mu*s+b*(1.+bunc))\n",
      "    #pois_term= ((mu*s+b*(1.+bunc))**data)*np.exp(-(mu*s+b*(1.+bunc)))/math.factorial(data)\n",
      "    #constraint_term = 1./(math.sqrt(2*math.pi)*bunc)*math.exp(-((data-b)**2/bunc**2))\n",
      "    constraint_term=st.norm.pdf(0, b , 1)\n",
      "    #print(pois_term, constraint_term)\n",
      "    #joint_pdf = np.outer(pois_term, constraint_term)\n",
      "    #print(pois_term)\n",
      "    #print(constraint_term)\n",
      "    return pois_term*constraint_term\n",
      "\n",
      "Likelihood model (fixed data):\n",
      "        self.likelihood_realization=lambda params : (self.model(self.data, params))\n",
      "\n",
      "Likelihood model parameters:\n",
      "('params',)\n",
      "minus-log-Likelihood model (fixed data):\n",
      "        self.minusloglikelihood_realization= lambda params: 2*self.minuslogmodel(self.data, params) #if self.minuslogmodel else -2*np.log(self.model(self.data, params))\n",
      "\n",
      "minus-log-Likelihood model parameters:\n",
      "('params',)\n",
      "par mu has freezestatus [False, None, False]\n",
      "Minuit model settings: {'mu': 1.0, 's': 1.0, 'b': 1.0, 'bunc': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'error_bunc': 0.01, 'fix_mu': False, 'fix_s': False, 'fix_b': False, 'fix_bunc': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None, 'limit_bunc': None}\n",
      "par s has freezestatus [True, 5, False]\n",
      "I am freezing (conditioning on) parameter s to 5\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 1.0, 'bunc': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'error_bunc': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': False, 'fix_bunc': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None, 'limit_bunc': None}\n",
      "par b has freezestatus [True, 15, False]\n",
      "I am freezing (conditioning on) parameter b to 15\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 15.0, 'bunc': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'error_bunc': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'fix_bunc': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None, 'limit_bunc': None}\n",
      "par bunc has freezestatus [False, 0.0002, True]\n",
      "I am freezing (conditioning on) parameter bunc to 0.0002\n",
      "I am settting the initial value of bunc to 0 and its variance to 1\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 15.0, 'bunc': 0.0002, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'error_bunc': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'fix_bunc': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None, 'limit_bunc': None}\n",
      "Minimizer will run with the following model settings:  {'mu': 1.0, 's': 5.0, 'b': 15.0, 'bunc': 0.0002, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'error_bunc': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'fix_bunc': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None, 'limit_bunc': None}\n",
      "┌──────────────────────────────────┬──────────────────────────────────────┐\n",
      "│ FCN = -289.4                     │         Nfcn = 70 (70 total)         │\n",
      "│ EDM = 4.35e-07 (Goal: 0.0002)    │                                      │\n",
      "├───────────────┬──────────────────┼──────────────────────────────────────┤\n",
      "│ Valid Minimum │ Valid Parameters │        No Parameters at limit        │\n",
      "├───────────────┴──────────────────┼──────────────────────────────────────┤\n",
      "│ Below EDM threshold (goal x 10)  │           Below call limit           │\n",
      "├───────────────┬──────────────────┼───────────┬─────────────┬────────────┤\n",
      "│   Hesse ok    │  Has Covariance  │ Accurate  │  Pos. def.  │ Not forced │\n",
      "└───────────────┴──────────────────┴───────────┴─────────────┴────────────┘\n",
      "{('mu', 'mu'): 10.95570063835448, ('mu', 'bunc'): -2.9865608578160576, ('bunc', 'mu'): -2.9865608578160576, ('bunc', 'bunc'): 0.9959683658419408}\n",
      "I have run MINOS\n",
      "┌───┬──────┬───────────┬───────────┬────────────┬────────────┬─────────┬─────────┬───────┐\n",
      "│   │ Name │   Value   │ Hesse Err │ Minos Err- │ Minos Err+ │ Limit-  │ Limit+  │ Fixed │\n",
      "├───┼──────┼───────────┼───────────┼────────────┼────────────┼─────────┼─────────┼───────┤\n",
      "│ 0 │ mu   │    7.0    │    3.3    │    -3.3    │    3.3     │         │         │       │\n",
      "│ 1 │ s    │   5.00    │   0.01    │            │            │         │         │  yes  │\n",
      "│ 2 │ b    │   15.00   │   0.01    │            │            │         │         │  yes  │\n",
      "│ 3 │ bunc │    -0     │     1     │     -1     │     1      │         │         │       │\n",
      "└───┴──────┴───────────┴───────────┴────────────┴────────────┴─────────┴─────────┴───────┘\n",
      "Main fit Results [<ValueView of Minuit at 3fa9570>\n",
      "  mu: 7.0021044208220955\n",
      "  s: 5.0\n",
      "  b: 15.0\n",
      "  bunc: -0.0006606473900364687, MErrors([('mu', MError(name='mu', is_valid=True, lower=-3.3070413364308844, upper=3.3271182813472127, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=24, min=7.0021044208220955)), ('bunc', MError(name='bunc', is_valid=True, lower=-0.9993386771856773, upper=1.0006626450005722, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=16, min=-0.0006606473900364687))])]\n",
      "Main fit Best estimates <ValueView of Minuit at 3fa9570>\n",
      "  mu: 7.0021044208220955\n",
      "  s: 5.0\n",
      "  b: 15.0\n",
      "  bunc: -0.0006606473900364687\n",
      "Main fit Uncertainties ┌──────────┬───────────────────────┬───────────────────────┐\n",
      "│          │          mu           │         bunc          │\n",
      "├──────────┼───────────┬───────────┼───────────┬───────────┤\n",
      "│  Error   │   -3.3    │    3.3    │    -1     │     1     │\n",
      "│  Valid   │   True    │   True    │   True    │   True    │\n",
      "│ At Limit │   False   │   False   │   False   │   False   │\n",
      "│ Max FCN  │   False   │   False   │   False   │   False   │\n",
      "│ New Min  │   False   │   False   │   False   │   False   │\n",
      "└──────────┴───────────┴───────────┴───────────┴───────────┘\n",
      "Parameter mu = 7.0021044208220955 (+3.3271182813472127/--3.3070413364308844) [fitted]\n",
      "Parameter s = 5.0 [frozen]\n",
      "Parameter b = 15.0 [frozen]\n",
      "Parameter bunc = -0.0006606473900364687 (+1.0006626450005722/--0.9993386771856773) [fitted]\n",
      "NOW PLOTTING mu\n",
      "Plotting mu in range [-9.533102261332324, 23.637695827558158] in 100 steps\n",
      "NOW PLOTTING s\n",
      "Plotting s in range [-20.0, 30.0] in 100 steps\n",
      "NOW PLOTTING b\n",
      "Plotting b in range [-60.0, 90.0] in 100 steps\n",
      "NOW PLOTTING bunc\n",
      "Plotting bunc in range [-4.997354033318423, 5.002652577612825] in 100 steps\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-47-524614743385>:34: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.print_level=3\n",
      "<ipython-input-47-524614743385>:76: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.draw_mnprofile(list(self.pardict.keys())[0],subtract_min=True)\n",
      "<ipython-input-47-524614743385>:95: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, +1] = results[1][par, +1.0]\n",
      "<ipython-input-47-524614743385>:96: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, -1] = results[1][par, -1.0]\n",
      "<ipython-input-34-375448ab449b>:34: RuntimeWarning: invalid value encountered in log\n",
      "  return mu*s+b*(1.+bunc) - data*np.log(mu*s+b*(1.+bunc)) + 0.5*np.log(2*math.pi) + 0.5*(bunc**2)\n",
      "<ipython-input-34-375448ab449b>:34: RuntimeWarning: invalid value encountered in log\n",
      "  return mu*s+b*(1.+bunc) - data*np.log(mu*s+b*(1.+bunc)) + 0.5*np.log(2*math.pi) + 0.5*(bunc**2)\n",
      "<ipython-input-34-375448ab449b>:34: RuntimeWarning: invalid value encountered in log\n",
      "  return mu*s+b*(1.+bunc) - data*np.log(mu*s+b*(1.+bunc)) + 0.5*np.log(2*math.pi) + 0.5*(bunc**2)\n",
      "<ipython-input-34-375448ab449b>:34: RuntimeWarning: invalid value encountered in log\n",
      "  return mu*s+b*(1.+bunc) - data*np.log(mu*s+b*(1.+bunc)) + 0.5*np.log(2*math.pi) + 0.5*(bunc**2)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2PklEQVR4nO3dd3zV5fn/8deV5GSHJEAgkBDC3ksQEARRwb2VilbU1v6oVusoaq1WrfrVr9Vqq0K11C1OcBQVLagoCDICEpAlKyFhBsgge92/P86h3zRmk0/uM67n43EeOeOTc96E5Fzn/txLjDEopZQKXEG2AyillLJLC4FSSgU4LQRKKRXgtBAopVSA00KglFIBTguBUkoFOC0ESikV4LQQqIAgIptEpLDGpVJEPj6B51siIjkiUiAi6SJycQPH3i4iuzzH7hORv4pISI3HHxGRjZ5Mf2pppkbyNpih1rEDRSRNRHI9ly9EZGCNx0/3/PvzRSTDibyqbWkhUAHBGDPIGBNtjIkGYoA9wLwTeMrbgC7GmHbADGCuiHSp59iPgZM8xw4GhgG31nh8B3A38GlzAohIajPeiBvLUNM+4AqgPdARWAC8U+PxIuBl4K7m5FXeSwuBanUikiEid4nIBhEpEpGXRKSziHwmIsc8nzDjPcdOEpHsOr5/soMRJwKdgPdb+gTGmA3GmMrjNwEX0K2eY3caY/I8NwWoBnrXePw1Y8xnwLGW5mlC3gYz1Do2zxiTYdzLDghQVSvvamPMG8Aup/KqtqWFQDnlcmAK0Be4EPgMuBf3J8wg6v802iARuUdE8uq7NPFprgPmG2OKWpKhRpZPRKQUWAV8DaQ1cOzVIlIAHMb9afwfJ/LaLdHcDJ6fZynwHPCY4wGVNXWeI1SqFTxnjDkIICLLgEPGmO89tz8EzmzJkxpjHgceb2koEYnEfdrjopY+R40sF4iIC5gM9DfGVDdw7FvAWyLSB7gWOHiir99czc1gjIkTkSjchTOzDSIqS7RFoJxS802mpI7b0W0b5z8uA44C39R3gOcU1vFO5Z839GTGmArPaZ2zRaTR4mKM2Q5sAv7ezNzHs11do/WzAUip1SpKac0MnlbTC8DrItKpJZmV99MWgbKtCIg8fkNEgoGE+g4WkXtxn2Kqk6czuCHXAa+bBpbdNcac28hz1CUE6OXAsf/l+Kd6cHcWA18bY1Jb8FTNyRCE+/8oCTjUgtdSXk5bBMq2H4FwETnfc5rlj0BYfQcbYx47PvqnrktDLyQiycDpwGsnElhE+ovIuSISISIuEbkGdwd0na0MEfnV8U/TnmGYfwC+rPG4S0TCcf89hohIuKcgtprGMtQ6doqIjBCRYBFpBzwN5AJbPI8HefK63DclXERCWzOvaltaCJRVxph84DfAi8Be3C2E7Aa/qeWmA98ZY3ae4PMI8Cfcn45zcA8lvdIYsw5ARCaISGGN48cDG0WkCFjoudRs1fwT9+myq4D7PNenn2DG2hrM4Jlncfw0WBzwNpAP7MQ9YugcY0yp5/GJnowLgRTP9UWtnFe1IdGNaZRSKrBpi0AppQKcFgKllApwWgiUUirAaSFQSqkA53PzCDp27GhSU1NtxwgYxcXFtiP4jMxM9+Tb7t27W07iOyIjIxs/SLWKtWvXHjbG1DlHx+cKQWpqKmlp9S7polrZ2rVrbUfwGTNmzABgzpw5lpP4jpEjR9qOEDBEpN5lQvTUkFJKBTifaxEo5a1uuOEG2xGUahEtBEq1kjFjxtiOoFSL6KkhpVrJtm3b2LZtm+0YSjWbtgiUaiVPPfUUoJ3Fyvdoi0AppQKcFgKllApwjhcCz5rm34vIJ3U8JiLyrIjs8Gx0fpJTOXYcKuShjzdRXlnvboJKKRWQ2qJFcBueDS3qcC7Qx3OZATzvVIiso8W8sjyDL7a0+VaxSinl1RztLPbsCHU+8CjwuzoOuZj/2zZwpYjEiUgXY8z+1s4ysW8CXWPDeXv1Hs4b0qW1n14pbr75ZtsRlGoRp1sEfwPuBuo7H5MEZNW4ne2577+IyAwRSRORtJycnBYFCQ4Spo7qxrc7DpN1VNfPUa1v2LBhDBs2zHYMpZrNsUIgIhcAh4wxDS1WI3Xc95Mt04wxc4wxo4wxoxIS6t3XvFE/O7kbAryXltXosUo1V3p6Ounp6bZjKNVsTrYIxgMXiUgG8A5whojMrXVMNtCtxu1kYJ9TgZLiIjitbwLvpWVRWaWdxqp1zZ49m9mzZ9uOofzUgfxSnNpa2LFCYIz5gzEm2RiTCkwDvjLGXFPrsAXAtZ7RQ2OBfCf6B2qaNjqFgwVlLNnWslNMSinV1korqjjv2WU8+ml9425OTJvPIxCRG0XkRs/NhcAuYAfwT+A3Tr/+Gf07kRATxjur9zj9Ukop1So++2E/R4vKmdSvkyPP3yZLTBhjvga+9lx/ocb9BmjToRau4CB+NiqZ57/eyf78ErrERrTlyyulVLPNXbmHnh2jGNergyPPH5Azi68clUK1gffWZNuOopRSDdq0L5+1mblcPSaFoKC6xtecuIBcdC6lQySn9u7Ie2lZ3HJGb4Id+uGqwDJz5kzbEZQfmrtyD+GuIKaO7Nb4wS0UkC0CgKtGp7A3r4Sl27XTWLWOfv360a9fP9sxlB8pKK3gX+v3ctGwrsRGuhx7nYAtBFMGdqZDVKh2GqtWs2rVKlatWmU7hvIjH67bS3F5FdeM7e7o6wTkqSGA0JAgLh+ZzMvf7uZQQSmd2oXbjqR83EsvvQToTmWqdRhjeGNlJsOSYxmaHOfoawVsiwBg2sndqKw2zFurncZKKe+yavdRdhwqdLw1AAFeCHomRDOmR3veXZNFdbUzM/aUUqol3liZSWyEiwuHdXX8tQK6EIC703jP0WK+23XEdhSllALgUEEp//7hAFNHJhPuCnb89QK+EJwzOJHYCBdva6exUspLvLsmi8pqw8/b4LQQBHBn8XHhrmAuOymJuSszOVJYRofoMNuRlI+69957bUdQfqCyqpq3Vu9hQp+O9OgY1SavGfAtAnCfHqqoMnywbq/tKMqHpaamkpqaajuG8nFfbT3E/vzSNukkPk4LAdC3cwwju8fz9po9ji3zqvzf0qVLWbp0qe0Yyse9sTKTLrHhnNnfmQXm6qKFwGPayd3YlVPE6t1HbUdRPmru3LnMnVt7yw2lmm734SKWbT/MVaNTCAluu7dnLQQe5w/tQkxYCO+s0d3LlFJ2vLUqk5AgYdrJzq0rVBctBB6RoSFcMiKJTzfuJ6+43HYcpVSAKa2o4r20bM4elNjmKx04uWdxuIisFpF0EdkkIg/VccwkEckXkfWeywNO5WmKaaO7UV5ZzYffa6exUqptfZy+j/ySijbtJD7OyRZBGXCGMWYYMBw4x7MdZW3LjDHDPZeHHczTqEFdYxmaHMs7q7O001gp1abmrtpD707RjO3Zvs1f27F5BJ7dxwo9N12ei9e/u047OYV7P9zI91l5nJQSbzuO8iEPP2z1c4zyYRuy80jPyuNPFw5EpO33R3G0j0BEgkVkPXAIWGyMqWuN3lM8p48+E5FB9TzPDBFJE5G0nBxn9w+4aHhXIkODeWuVzjRWzZOYmEhiYqLtGMoHzV2ZSYQrmMtGJlt5fUcLgTGmyhgzHEgGRovI4FqHrAO6e04fPQd8VM/zzDHGjDLGjEpISHAyMtFhIVw6IokF6fs4WqSdxqrpFi1axKJFi2zHUD4mv7iCBen7uGREEu3Cndt8piFtMmrIGJOHe/P6c2rdX2CMKfRcXwi4RKRjW2RqyHXjUimvrOadNdoqUE03f/585s+fbzuG8jHz12VTWlHNNWNTrGVwctRQgojEea5HAJOBrbWOSRTPCTERGe3JY30Z0L6dYxjXqwNzv8uksqradhyllJ8yxvDmykxOSoljUNdYazmcbBF0AZaIyAZgDe4+gk9E5EYRudFzzBXADyKSDjwLTDNeMlzn+nGp7MsvZfHmg7ajKKX81IqdR9h1uIjpp7T9kNGanBw1tAEYUcf9L9S4PguY5VSGE3HmgM4kx0fw6ooMzh3SxXYcpZQfemX5btpHhXLuYLvvMTqzuB7BQcL0sd1ZtfsoW/YX2I6jlPIzu3IK+WLLIa4Z271NNp9piBaCBlx5cjfCXUG8tiLDdhTlA5544gmeeOIJ2zGUj3hleQahwUFMtzCTuDYtBA2Iiwzl0hFJfLR+r64/pBoVFxdHXFyc7RjKB+QVlzNvbRaXjOhKQoz9zbC0EDTiunGplFZU866uSqoa8fHHH/Pxxx/bjqF8wJur9lBaUc0vT+1hOwqghaBR/RPbMaZHe17/LpOqaq8Y0KS8lBYC1RTlldW8/l0GE/p0pH9iO9txAC0ETfKL8anszSvhiy06lFQpdWI+3biPgwVlXtMaAC0ETTJ5QGe6xoZrp7FS6oQYY3jp29307hTNaX2cXS6nObQQNEFIcBDXnNKdFTuP8OPBY7bjKKV81KrdR/lhbwG/HN+DoKC2X2W0PloImmjaySmEhgTxqrYKlFIt9OKy3cRHurjspCTbUf6LYzOL/U37qFAuGd6VD9ft5fdn9yc20s4qgcp7Pfvss7YjKC+2+3ARX249yG9P7219Allt2iJohuvGpVJSUcW8tTqUVP1UeHg44eFtu9es8h2vLN+NK8h9mtnbaCFohkFdYzk5NZ7XvsvQoaTqJ+bNm8e8efNsx1BeKL+4gnlp2Vw0vCudYrzvw4IWgma6flwPso6WsGTrIdtRlJdZvHgxixcvth1DeaG3Vu+hpKKKX473niGjNWkhaKazBnUmsV04r32XYTuKUsoHVFRV89qKDMb37sDArt4xgaw2LQTN5AoO4pqxKSzbfpgdh3QoqVKqYQs37udAQSk3eNEEstq0ELTAtNEphAYH8dqKTNtRlFJezBjDi8t20zMhikl9O9mOUy8nt6oMF5HVIpIuIptE5KE6jhEReVZEdojIBhE5yak8raljdBgXDuvK++uyKSitsB1HKeWl1mTksnFvPjec6l0TyGpzskVQBpxhjBkGDAfOEZGxtY45F+jjucwAnncwT6u6flwqxeVVzE/Lth1FeYk5c+YwZ84c2zGUF3lx2S7iIl1cNiLZdpQGOVYIjFuh56bLc6k95vJi4HXPsSuBOBHxiX0hhyTHclJKHK9/l0G1DiVVStWScbiIxVsOcs2Y7kSEetcEstoc7SMQkWARWQ8cwr15/apahyQBNWdnZXvuq/08M0QkTUTScnJyHMvbXNeP70HGkWK+1KGkCnjjjTd44403bMdQXuLVFRmEBAnXeuEEstocLQTGmCpjzHAgGRgtIoNrHVLXSbOffLw2xswxxowyxoxKSPCeFfvOG5xIUlwE//hmp+0oygssW7aMZcuW2Y6hvEB+SQXvpWVx4bCudGrnfRPIamuTUUPGmDzga+CcWg9lA91q3E4G9rVFptYQEhzE/5vQg7TMXNIyjtqOo5TyEu+s3kNxeZVXDxmtyclRQwkiEue5HgFMBrbWOmwBcK1n9NBYIN8Ys9+pTE742cndiI908cI3u2xHUUp5gfLKal5dkcEpPTswqGus7ThN4mSLoAuwREQ2AGtw9xF8IiI3isiNnmMWAruAHcA/gd84mMcRkaEhXHtKKl9sOch23atAqYD30fd72Z9fyozTetqO0mSOLUNtjNkAjKjj/hdqXDfAzU5laCvXjUvlH0t3MmfpLp6cOsx2HGWJrjyqqqoNz3+zk8FJ7ZjU13v6Mxuj+xG0gvZRoVw5qhtvrd7D787qS5fYCNuRlAW6H4H6dON+dh8u4vmfn4SI904gq02XmGglv5rQk2oDryzPsB1FKWVBdbXh70t20LtTNGcPSrQdp1m0ELSSbu0juWBoF95atYf8El12IhC9+OKLvPjii7ZjKEu+2nqIrQeO8ZtJvbx6OYm6aCFoRTMm9qSwrJI3V+lidIFo9erVrF692nYMZYExhllLdpAcH8GFw7rajtNsWgha0aCusUzsm8DL32ZQWlFlO45Sqo2s2HmE9Vl53HhaL1zBvve26nuJvdyNE3tyuLCMD7/fazuKUqqNzPpqB51iwrhipHcvLlcfLQSt7JReHRiaHMucpbt0X2OlAsDazFy+23WEGRN7Eu7y7sXl6qOFoJWJCL+e2Ivdh4tYtOmA7TiqDcXGxhIb6xszSVXrmb1kB/GRLq4ek2I7SovpPAIHnDM4ke4dInnhm52cMzjRp8YTq5Z78sknbUdQbWzTvny+2nqImVP6Ehnqu2+n2iJwQHCQ8P8m9CQ9O5+Vu3QxOqX81d+/3kl0WAjXjku1HeWEaCFwyBUjk+kYHco/luoS1YFi1qxZzJo1y3YM1UZ25hSycON+pp/SndgIl+04J0QLgUPCXcFcPy6Vr7flsGV/ge04qg1s2LCBDRs22I6h2sjzX+8kLCTIZ5aabogWAgdNH5tKVGgwc5bqEtVK+ZPs3GI++n4v005OoWN0mO04J0wLgYNiI11cNTqFBen7yM4tth1HKdVK/vHNLkTg1z601HRDtBA47Jen9kCAl77dbTuKUqoVHDpWyrtpWVx+UrLfrDTs5A5l3URkiYhsEZFNInJbHcdMEpF8EVnvuTzgVB5busZFcPHwJN5ZnUVuUbntOMpBnTt3pnPnzrZjKIe9tGw3lVXV3HhaL9tRWo2TA18rgZnGmHUiEgOsFZHFxpjNtY5bZoy5wMEc1v36tJ68vy6b17/L5LbJfWzHUQ555JFHbEdQDssrLmfuykwuHNaV1I5RtuO0GsdaBMaY/caYdZ7rx4AtQJJTr+fN+naOYfKAzry8fDcFpbpEtVK+6pXlGRSVV/GbSb1tR2lVbdJHICKpuLetXFXHw6eISLqIfCYig+r5/hkikiYiaTk5OU5Gdcztk/uQX1LBK99m2I6iHPLUU0/x1FNP2Y6hHFJYVsmrKzKYMrAz/RJjbMdpVY4XAhGJBt4HbjfG1B5Qvw7obowZBjwHfFTXcxhj5hhjRhljRiUk+M4+oDUNTorlrIGdefHbXbpxjZ/atm0b27Ztsx1DOeT17zLIL6ngltP9qzUADhcCEXHhLgJvGmM+qP24MabAGFPoub4QcIlIRycz2XT75L4cK63UEURK+Zj8kgr+8c0uTu+XwLBucbbjtDonRw0J8BKwxRjzdD3HJHqOQ0RGe/IccSqTbQO7tuPcwYm88u1u8op1BJFSvuLFZe6W/J1n97MdxRFOtgjGA9OBM2oMDz1PRG4UkRs9x1wB/CAi6cCzwDRjjF8v4n/75L4Ullfy4jJtFSjlCw4XlvHSt7s5f2gXBnX1z2XGHRs+aoz5Fmhw/WVjzCwgoFbp6pcYw3lDuvDK8t3ccGoP4qNCbUdSraR79+62IygHPP/1TkorqvjdlL62ozjGdxfQ9mG3n9mHhRv3M2fZLn5/Tn/bcVQrue+++2xHUK1sf34Jb6zM5IqRyfRKiLYdxzG6xIQFfTrHcOHQrry2IoMjhWW24yil6vHslzswxnDrmf49EVQLgSW3ntmH0ooqXZnUjzz66KM8+uijtmOoVpJxuIj30rL4+ZjuJMdH2o7jKC0ElvTuFM3Fw5N4/btMco5pq8AfZGZmkpmZaTuGaiV//eJHQoOD+M3p/rOmUH20EFh065l9KK+q5h/f6C5mSnmTrQcKWJC+j1+MT6VTTLjtOI7TQmBRj45RXDI8iTdWZnKooNR2HKWUx1OLfiQ6LIRfT/T/1gBoIbDu1jN7U1lteF5bBUp5he/35LJ480F+PbEnsZG+vRdxU2khsKx7hyguPymJN1ft4aC2Cnxav3796NfPP2eeBpK/LNpGh6hQfjHe9/cibiotBF7gt2f0obra8PclO2xHUSdg5syZzJw503YMdQJW7DjM8h1HuPn03kSFBc40Ky0EXqBb+0imjkrm7dVZ7M8vsR1HqYBkjOHJRdvoEhvO1WNSbMdpU1oIvMTNp/fGYJitrQKfdf/993P//ffbjqFa6Msth/h+Tx63ndmHcFew7ThtqsG2j4g0WBaNMXtaN07gSo6P5GejuvHumixumtSbpDj/2BQ7kBw8eNB2BNVC1dWGvyzaRo+OUVw+Mtl2nDbXWIvgU+ATz9dPa9xeBejyma3s5tN7IwizvtJWgVJt6eMN+9h64Bh3TOmLKzjwTpQ0+C82xgwxxgz1fB0CXAgsBwqB29sgX0DpGhfBtNHdmJeWReaRIttxlAoIFVXV/HXxj/RPjOGCIV1sx7GiSaVPRPqIyKvAZ8BaYKAx5jkngwWqW07vjSs4iCc+1y0PlWoL76/NJuNIMXee1Y+goAZXzvdbDRYCERksIm/j3m7yC2CwMeZFY4xuuuuQTu3C+fVpPfl0437WZh61HUc1w9ChQxk6dKjtGKoZSsqreObL7YxIiePMAZ1sx7GmsYGy6UAW7r6B0cBoz86SABhjbq3vG0WkG/A6kAhUA3OMMc/UOkaAZ4DzgGLgemPMuub/M/zLjIk9eWvVHv7n0y18cNM4av7Mlfe65ZZbbEdQzTRn6S7255fyzLQRAf131lghuAFo6daRlcBMY8w6EYkB1orIYmPM5hrHnAv08VzGAM97vga0yNAQ7jyrH3e/v4FPN+7ngqFdbUdSyu/szy/hhW92cv6QLozu0d52HKsaKwTvADHGmJyad4pIJ6CgoW80xuwH9nuuHxORLUASULMQXAy87tmneKWIxIlIF8/3BrTLRybz8vLd/PnzrUwZ2JmwkMAa1+yL7rrrLgCefPJJy0lUU/z5s61UGcM95+ougY11Fj8LTKjj/inAX5v6IiKSCozAPey0piTcp56Oy/bcV/v7Z4hImoik5eTk1H7YLwUHCfedP4CsoyW8vkLXuPcF+fn55Ofn246hmmDdnlw+Wr+PGRN60q29f2860xSNFYJTjTEf1L7TGPMmMLEpLyAi0bg7m283xtRuRdR1Uu4np6KMMXOMMaOMMaMSEhKa8rJ+YUKfBCb1S+C5r7aTW1RuO45SfqG62vDQx5vpFBPGTZMCY5npxjRWCBrqPWl06KmIuHAXgTfrKii4WwDdatxOBvY19ryB5N7zBlBYVskzX263HUUpv/DR+r2kZ+Vx9zn9A2phuYY09mZ+SERG175TRE4GGjxH4xkR9BKwxRjzdD2HLQCuFbexQL72D/y3vp1juPLkFOauzGT3YZ1kptSJKCqr5M+fb2VYciyXjfjJWeiA1Vg5vAt4zzOZbK3nvlHAtcC0Rr53PDAd2Cgi6z333QukABhjXgAW4h46ugP38NFfNC9+YLhjSh8WrN/L459t4R/TR9mOo+oxevRPPjMpL/PCNzs5WFDG339+UsBOHqtLg4XAGLPa0yK4Gbjec/cmYIwx5lAj3/stDZ9awjNa6OYmpw1QnWLCufG0Xjy1+EdW7TrCmJ4dbEdSdfjVr35lO4JqQHZuMXOW7uKiYV0Z2T2wh4vW1tjM4hRjzCFjzIPGmMs9lwcaKwKq9f1qQk8S24Xz2MItVFe3dGqHUoHr8c+2IoIOF61DY30EHx2/IiLvOxtFNSQiNJg7z+5HenY+H2/Q/nRvdOutt3LrrfVOtlcWrck4yicb9vPrib3oqku8/0RzRg31dDKIatxlI5IY2KUdT3y+jdKKKttxVC2lpaWUluq+096mutrw8MebSfSs46V+qrFCYOq5riwIChL+eP4A9uaV8MryDNtxlPIJ89dls3FvPvec25/IUB0uWpfGCsEwESkQkWPAUM/1AhE5JiINLjGhnDGud0fO7N+Jvy/ZwZHCMttxlPJqhWWVPPnvbYxIiePi4bpmV30a25gm2BjTzhgTY4wJ8Vw/frtdW4VU/+0P5/WnuKKKv32hk8yUasjsJTvIOVbGgxcOCujVRRsTeHuy+YHenWK4anQ33lq9hx2HCm3HUR4TJkxgwoS6luZSNuw5UsxLy3Zz2YgkhneLsx3Hq2kh8FG3T+5LhCuYRz7ZjHs6hrJt+vTpTJ8+3XYM5fHYwi0EBwl3n6PDRRujhcBHdYwO4/bJffjmxxwWbjxgO45SXmXFzsN8vukAN03qRWJsuO04Xk8LgQ+7flwqA7u046GPN1FQqruH2jZjxgxmzJhhO0bAK62o4o8f/kByfAQzJupw0abQQuDDQoKDeOyyIeQUlvH0oh9tx1HKK8xesoNdh4t47NIhhLt0Q6em0ELg44Z3i2P62O689l0GG7LzbMdRyqptB47x/Nc7uXREEhP7Bs7eJSdKC4EfuPPsfnSMDuPeDzdSpesQqQBVVW2454MNxISH8MfzB9iO41O0EPiBduEuHrhgID/sLeD17zJsx1HKirkrM/l+Tx73XzCQDtFhtuP4FJ1v7ScuGNqFeWuzeWrRj5w7uIuOlLBgypQptiMErH15JTzx+VYm9OnIpbrhTLM51iIQkZdF5JCI/FDP45NEJF9E1nsuDziVJRCICI9cPIiKqmoe/mST7TgBaerUqUydOtV2jIBjjOGBf22iyhgevWSIziBuASdPDb0KnNPIMcuMMcM9l4cdzBIQuneI4rdn9GbhxgMs2apbRrQ1XX3Ujs9+OMAXWw7yuyl9SekQaTuOT3KsEBhjlgJHnXp+VbcZE3vRu1M09//rB0rKdanqtqT7EbS9/OIKHlywicFJ7fjl+B624/gs253Fp4hIuoh8JiKD6jtIRGaISJqIpOXk5LRlPp8TGhLEo5cMJju3hGe/0kXplH97/PMtHCks4/HLhhISbPvtzHfZ/MmtA7obY4YBz1FjN7TajDFzjDGjjDGjEhJ0bHBjxvTswBUjk/nn0l1sO3DMdhylHLFy1xHeXp3FDaf2YHBSrO04Ps1aITDGFBhjCj3XFwIuEeloK4+/ufe8AcSEh3Dfhxt1j2Pld0orqrj3g40kx0dwx5S+tuP4PGuFQEQSxdO9LyKjPVmO2Mrjb9pHhfKH8waQlpnLvLVZtuMo1apqLiOhu46dOMd+giLyNjAJ6Cgi2cCDgAvAGPMCcAVwk4hUAiXANKPrKbeqqSOTmZ+Wzf9+tpXJAzrrJBuHXXjhhbYjBARdRqL1OVYIjDFXNfL4LGCWU6+v3HMLHr10MOc9u4xHF27h6Z8Ntx3Jr2khcJ4uI+EM7Wb3c306xzBjYk8+WLeXr7fp3AIn5eXlkZeXZzuGX9NlJJyhhSAA/PaMPvTtHM1d8zdwtKjcdhy/dffdd3P33XfbjuG3Mo8U6TISDtFCEADCXcH87coR5BWXc+8HG3VrS+VzKqqqufWd9QQHCX++fKguI9HKtBAEiIFd2zHzrH58vukA76/bazuOUs3yzBfbSc/K438vG0rXuAjbcfyOFoIA8v8m9GR0j/b8acEmso4W246jVJOs2nWE2V/vYOrIZM4f2sV2HL+khSCABAcJT/9sGAL87r31uomN8nr5xRXc8e56ureP5E8X1bsKjTpBWggCTHJ8JA9dPIg1GbnMWbrLdhy/csUVV3DFFVfYjuE3jDHc+9FGDh0r45lpI4gK04ljTtGfbAC6dEQSX2w5yNOLtzGhT0ddp6WVnHXWWbYj+JX5a7P5dMN+7jq7H8O6xdmO49e0RRCARIRHLxlCfGQod7y7ntIKXa66NRw4cIADBw7YjuEXMg4X8eCCTYzp0Z4bT+tlO47f00IQoOKjQvnL1GFsP1TInz/fajuOX3jggQd44AHdaO9EVVRVc9s73+MKDuKvVw4nOEiHijpNC0EAm9g3gevHpfLK8gyWbdd9HpR3eOaL7aRn5/PYpUN0qGgb0UIQ4O45tz+9EqK4c146ecU661jZpUNF7dBCEODCXcE8M20ERwrL+eNHP+isY2WNDhW1RwuBYnBSLHdM6csnG/bzr/X7bMdRAUiHitqlP20FwI2n9WLJ1kPc/68fOLlHe5L03GyzXXPNNbYj+CwdKmqXtggU4J51/Ncrh1Ndbbj17e8pr6y2HcnnTJw4kYkTJ9qO4XN261BR6xwrBCLysogcEpEf6nlcRORZEdkhIhtE5CSnsqim6dY+kieuGMbazFwe+niT7Tg+JyMjg4yMDNsxfEphWSW/fiON0BAdKmqTk6eGXsW9A9nr9Tx+LtDHcxkDPO/5qiw6f2gXNu7txQvf7GRIUix9gm0n8h2PPfYYAHPmzLGcxDdUG8Md765nZ04Rr/9ytA4VtcixFoExZilwtIFDLgZeN24rgTgR0fFiXuCus/sxoU9HHvjXJn48okNKlTPe3VTI4s0H+eP5Axjfu6PtOAHNZh9BEpBV43a2576fEJEZIpImImk5OTrxyWnBQcJzV40gMTacJ1fkkVuqS1Co1rUiq5T5W4r42ahkrh+XajtOwLNZCOo6GVjnIHZjzBxjzChjzKiEhASHYymAuMhQ/jF9JEUVhr+syKNCl6xWrSQjr4JZa/Lp18HFI5cM1t3GvIDNQpANdKtxOxnQQexeZECXdtx8cju2HqnglfUFtuMoP5BfVs3jy3OJChXuGhdHWIh2QnkDm/MIFgC3iMg7uDuJ840x+y3mUXUY3y2CXbmVfLStiJ7xLib3iLQdyWvdcMMNtiN4tcpqw1Pf5ZJfWs0jp3cgPlyLgLdwrBCIyNvAJKCjiGQDDwIuAGPMC8BC4DxgB1AM/MKpLOrEXD0kmt15FfxzXQEp7ULo2yHUdiSvNGaMDnpryCvrj7Epp4LbRsfSu73LdhxVg2OFwBhzVSOPG+Bmp15ftZ5gEe4YG8fdXxzhyRV5PDFFP83VZdu2bQD069fPchLvs2hXMZ/vLObiflFM7K7DRL2NzixWTRITGsTvx8Vp53EDnnrqKZ566inbMbzO5pxyXlxXwIjEUH4+JNp2HFUHLQSqyVLjXPxmlLvz+NX1x2zHUT4gp7iKJ7/Lo3NUMHeMiSNYRwh5JV10TjXLqSkR7Mqr5F/biugZH8KZ2nms6lFWafjz8lwqqwz3nN6eqFD93Omt9H9GNdvPh0QzrHMoc9YVsPFQme04ygtVG8OsNflk5FVy+9g4kmL0M6c300Kgmu1453GX6BAeX57H9qO6DIX6P8YY/rmugBXZpUwfGsPILmG2I6lGaCFQLRITGsQDE+OJDQvif5blsie/wnYk626++WZuvjmwB8IZY3h9wzEW7Srhsv5RXNwvynYk1QRaCFSLtY8I5oGJ8biChEeW5nKwqNJ2JKuGDRvGsGHDbMewat7mIhb8WMx5vSO5erCOEPIVWgjUCUmMDuGBifGUVxke+iaX3JLAXaAuPT2d9PR02zGsWfBjEe9uLuT01Ah+MTxG1xDyIVoI1AlLiXVx34R48kureXhpLsfKA3N3s9mzZzN79mzbMaxYtKuY19KPcUpyODeNakeQFgGfooVAtYq+HUL5/fg49hVW8uiyXEp0q8uAsTSzhDlrCxjZJYzbxsTqXAEfpIVAtZqhncP43dg4duZW8OfleZRX6exjf7dqbynPrclnUEIoM0+Jw6VbTfokLQSqVY1JCufmUbFsPFTOX1fmUaVLUfit9INlPL0yj97xLu4ZH0dYsBYBX6WFQLW6SakR/HJ4DKv3lfH3tHyqjRYDf7PlcDmPL8+lW7sQ7psQT4RL30p8mU73U444v08UReWGdzcXEhUaxC+G+f8okpkzZ9qO0CZ25lbw2LJcEiKDuX9CPNG6dITP00KgHDN1YBSFFdV8ur0YV5BwzZBovy4GgbD8dEZeBY8sPUp0aBAPTmxPrC5H7hccLeUico6IbBORHSJyTx2PTxKRfBFZ77k84GQe1bZEhOuHxXBWzwg+2lbE7LQCKv24z2DVqlWsWrXKdgzHpB8s449LjhIaLDx4WjwdIrUI+AsndygLBmYDU3DvT7xGRBYYYzbXOnSZMeYCp3Iou4JEmHFSO+LDg3l3cyG5JVXcOS6OiBD/O53w0ksvAf65U9mSjBKeT8snuV0I952qRcDfOPnXOBrYYYzZZYwpB94BLnbw9ZSXEhF+Niiam0a2Y8Ohch78+ih5pYE7A9mXGGOYt7mQWWvyGZgQyiOnt9ci4IecLARJQFaN29me+2o7RUTSReQzERlU1xOJyAwRSRORtJycHCeyqjYwuWckvx8XR1ZBJfd+dZR9xwJ7bSJvV1lteGFtAe9sKmRS93DumxBPlI4O8ktO/q/W1StY+wTxOqC7MWYY8BzwUV1PZIyZY4wZZYwZlZCQ0LopVZsa1TWch05rT0lFNfd9dUSXsPZSJRXVPL48ly92l3DFgChuOTlWJ4v5MScLQTbQrcbtZGBfzQOMMQXGmELP9YWAS0Q6OphJeYG+HUJ59IwOhLuCePDrXNbuL7UdSdWQW1LF/V8fJf1gOTeObMdVg/1/6G+gc3L46Bqgj4j0APYC04Crax4gIonAQWOMEZHRuAvTEQczKS/RNSaE/z2jPY99m8vjy/P49UntmNzTt7e9vPfee21HOGHZBZX8z7KjHCsz/GF8PCfppjIBwbFCYIypFJFbgH8DwcDLxphNInKj5/EXgCuAm0SkEigBphmj01ADRVx4MA9Nas9fVuTx/NoCjpZUM3VglM9++kxNTbUd4YRsyinnz8tzcQUJD5/enl7xLtuRVBtxdEKZ53TPwlr3vVDj+ixglpMZlHeLCAniD6fG83xaPu9uLuRISRW/GtEOlw+uW7N06VIAJk6caDlJ8y3bU8KsNfl0jgrmjxPi6RSlc00Dif5vK+tCgoRbTo6lQ2Qw728pYmduBbePiSO5nW/9es6dOxfwrUJQUlnNq+uP8cXuEgZ0dPH78fHE6JIRAce3/tKU3xIRrh4cQ5/2Lv6+Jp+7Fh/muuHtOLtnhM+eKvJ2Px4p55nV+RwsrOLS/lFcOShaRwYFKC39yquc3DWcp8/qyICEUP65roDHl+eRX6ab3LSmqmrDe5sLuW/JUSqrDQ9Nas81Q2K0CAQwLQTK68RHuM9T/2J4DOsPlvG7fx/m+wNltmP5hQOFldz/9VHe3VTIqd3CeXpKRwYlhNqOpSzTU0PKKwWJcEGfKAYnhPK3Vfn8z7Jczu8TyTVDYgj1wY5k24wxLMko4aX1xwgSuH1MLBNSImzHUl5CC4HyaqlxLv48uQNzNxzj0+3FbDxYzu1jY+ke631DGx9++GHbEep0rKya59fms2pvGYMSQvnt6FgSdL0gVYMWAuX1woKFG0a0Y3hiGLPX5PP7L44wfWgM5/WO9KqO5MTERNsRfiL9YBnPrc7nWFk104fGcGHfSN1cXv2EFgLlM0Z2CeOvZ3Vg1poCXl5/jBVZpUwfGkP/jt5xjnvRokUAnHXWWZaTuPsC3t1UyNI9pSTHBHPfhA70iPO+VpTyDloIlE+JDQ/m3lPj+GJ3Ce9sco98GdUljKuHRFs/XTR//nzAbiHILa1i/uYivthVTJDApf2jmDowWjeWVw3SQqB8jogwpWckE1LC+XR7MR9tLWLmoiOc1j2cKwdFB+Ss2KLyaj7aVsSn24upqDZM7hHBFQOj6RChfQGqcYH3F6P8RnhIEJcPiOasnpF8uK2IhduL+DarlLN7RXJ5/6iA2E+3rNLw2Y4iPtxaRGGFYXy3cKYNiqZrjP5pq6bT3xbl82LCgrh2aAzn947kvc2FfLa9mC93l3BR30gu6htFhB9uplJZbfgqo4R5mwo5WlrNiMRQrh4cQ09dKE61gBYC5Tc6RAZz06hYLuwbxds/HOO9zUV8vqOYSwdEc3r3CGLCfL8glFZWszK7jHlbCjlQWEW/Di5uHxunk8LUCRFfW/V51KhRJi0tzXaMgLF27VrbEVps+9Fy3txYyMZD5YQIDE8MY2L3cEZ1CScspPU7T/Py8gCIi4tr1eetrDZsOFjOsj0lrN5bRmmVIaVdCFcPiWZUlzCvGkLbXCNHjrQdIWCIyFpjzKi6HtMWgfJbfdqH8uDEeDLyK1maWcK3WaWk7S8jPKSAMUlhTEiJYGinUIJbaY2d1iwAxhi2Halg2Z5SVmSXUlBWTZRLODUlnIndIxjQ0UWQDxcA5V20ECi/JiL0iHPRI87FNUNj2JxTzrd7Svkuu5RvMkuJDQtifLdwJqSE06e964Q+XX/88ccAXHjhhS1+jqwCT9HaU8qh4ipCg9z7PE9ICWdEYphP7tOgvJ+jhUBEzgGewb1D2YvGmMdrPS6ex88DioHrjTHrnMykAlewCEM6hTGkUxi/GtGOdQfKWLanhMW7ilm4o5jEqGCGJYaSEuuie2wIKbEhRDWjo7m5haCkspqs/Eoy8yvZk1/J5pxyMvIrCQKGdA7lykHRjE4KI9IPO7uVd3GsEIhIMDAbmIJ7I/s1IrLAGLO5xmHnAn08lzHA856vSjnKFSyMSQpnTFI4RRXVrMou5dusUpbtKaW4ouQ/x3WMDKJ7rIuU2JD/FIeuMSHNWrK5yhgOFFaxJ7+SjLwK9nje/A8WVf3nmPAQoUdcCL8cHsP4buHEBcDQV+U9nGwRjAZ2GGN2AYjIO8DFQM1CcDHwumef4pUiEiciXYwx+x3MpdR/iXIFcUaPSM7oEYkxhiMl1WTmV5KZ/39v2usPlFHlGVcRIpAQFczxszTHh1vsOFoBwG8/z/nPcxsDR4qrKPdsqRAEJMYE0zPexempEf8pLp2igvWcv7LGyUKQBGTVuJ3NTz/t13VMEvBfhUBEZgAzAFJSUlo9qFLHiQgdI4PpGBnMyC5h/7m/otqw71jl/32aL6yi5ng7AXZ4RiKlxrqo+Z4+sksY3eNC6B7rIrldiC73oLyOk4Wgrt/22mNVm3IMxpg5wBxwDx898WhKNY8rSOge66J7rIsJ9Ryz7RX3n9PMU+LaLJdSrcHJQpANdKtxOxnY14JjlPIJzz77rO0ISrWIk8MR1gB9RKSHiIQC04AFtY5ZAFwrbmOBfO0fUL4qPDyc8PBw2zGUajbHWgTGmEoRuQX4N+7hoy8bYzaJyI2ex18AFuIeOroD9/DRXziVRymnzZs3D4CpU6daTqJU8zg6j8AYsxD3m33N+16ocd0ANzuZQam2snjxYkALgfI9OlNFKaUCnBYCpZQKcFoIlFIqwGkhUEqpAOdz+xGISA6QWc/DHYHDbRintWjutqW525Yv5vbFzNBw7u7GmIS6HvC5QtAQEUmrb+MFb6a525bmblu+mNsXM0PLc+upIaWUCnBaCJRSKsD5WyGYYztAC2nutqW525Yv5vbFzNDC3H7VR6CUUqr5/K1FoJRSqpm0ECilVIDzi0IgIueIyDYR2SEi99jO0xQi0k1ElojIFhHZJCK32c7UHCISLCLfi8gntrM0lWcr1PkistXzcz/FdqamEJE7PL8jP4jI2yLilWtdi8jLInJIRH6ocV97EVksIts9X+NtZqxLPbmf9PyebBCRD0UkzmLEOtWVu8Zjd4qIEZGOTXkuny8EIhIMzAbOBQYCV4nIQLupmqQSmGmMGQCMBW72kdzH3QZssR2imZ4BPjfG9AeG4QP5RSQJuBUYZYwZjHtJ92l2U9XrVeCcWvfdA3xpjOkDfOm57W1e5ae5FwODjTFDgR+BP7R1qCZ4lZ/mRkS6AVOAPU19Ip8vBMBoYIcxZpcxphx4B7jYcqZGGWP2G2PWea4fw/2mlGQ3VdOISDJwPvCi7SxNJSLtgInASwDGmHJjTJ7VUE0XAkSISAgQiZfu4meMWQocrXX3xcBrnuuvAZe0ZaamqCu3MWaRMabSc3Ml7t0TvUo9P2+AvwJ3U8e2v/Xxh0KQBGTVuJ2Nj7yhHiciqcAIYJXlKE31N9y/aNWWczRHTyAHeMVzSutFEYmyHaoxxpi9wF9wf7rbj3sXv0V2UzVL5+O7Dnq+drKcpyV+CXxmO0RTiMhFwF5jTHpzvs8fCoHUcZ/PjIkVkWjgfeB2Y0yB7TyNEZELgEPGmLW2szRTCHAS8LwxZgRQhHeepvgvnnPqFwM9gK5AlIhcYzdV4BCR+3Cfxn3TdpbGiEgkcB/wQHO/1x8KQTbQrcbtZLy06VybiLhwF4E3jTEf2M7TROOBi0QkA/dpuDNEZK7dSE2SDWQbY463uubjLgzebjKw2xiTY4ypAD4AxlnO1BwHRaQLgOfrIct5mkxErgMuAH5ufGPCVS/cHxjSPX+fycA6EUls7Bv9oRCsAfqISA8RCcXdkbbAcqZGiYjgPl+9xRjztO08TWWM+YMxJtkYk4r7Z/2VMcbrP6EaYw4AWSLSz3PXmcBmi5Gaag8wVkQiPb8zZ+IDndw1LACu81y/DviXxSxNJiLnAL8HLjLGFNvO0xTGmI3GmE7GmFTP32c2cJLnd79BPl8IPB06twD/xv0H8p4xZpPdVE0yHpiO+xP1es/lPNuh/NxvgTdFZAMwHHjMbpzGeVow84F1wEbcf7NeufyBiLwNfAf0E5FsEbkBeByYIiLbcY9kedxmxrrUk3sWEAMs9vxtvtDgk1hQT+6WPZdvtHiUUko5xedbBEoppU6MFgKllApwWgiUUirAaSFQSqkAp4VAKaUCnBYCpZQKcFoIlFIqwGkhUKoZRCTVs079i579Ad4Ukckistyz5v5oEfmTiNxZ43t+8CwsqJRX0kKgVPP1xr23wVCgP3A1cCpwJ3CvxVxKtYgWAqWab7dnXZdqYBPujVcM7iUgUq0mU6oFtBAo1XxlNa5X17hdjXu560r++2/LK7eWVOo4LQRKtb4MPEtci8hJuJcGVspraSFQqvW9D7QXkfXATbj3vFXKa+nqo0opFeC0RaCUUgFOC4FSSgU4LQRKKRXgtBAopVSA00KglFIBTguBUkoFOC0ESikV4P4/W+LV1b91d6sAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Ntot=1000\n",
    "#data = st.poisson.rvs(20, size=Ntot)\n",
    "\n",
    "debug=True\n",
    "\n",
    "data = 50\n",
    "sexp=5\n",
    "bexp=15\n",
    "bunc=0.0002\n",
    "\n",
    "freezelist = {'mu': [False, None, False],\n",
    "              's': [True, sexp, False],\n",
    "              'b': [True, bexp, False],\n",
    "              'bunc': [False,bunc, True]}\n",
    "\n",
    "plr = profile_likelihood_ratio(my_poisson_count_model_1bin, data, np.mean, minuslogmodel=my_poisson_count_model_1bin_minusloglikelihood, freezelist=freezelist,migradprecision=0.0001)\n",
    "#migradprecision=0.1\n",
    "if debug:\n",
    "    plr.print_inputs()\n",
    "plr.do_global_fit()\n",
    "plr.draw_likelihood()\n",
    "plr.draw_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now try a marked Poisson model\n",
    "\n",
    "# First let's have one bin (channel) and check it works\n",
    "def my_marked_poisson_model_1bin_nonuisance(data, params):\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    poisson_part = st.poisson(mu*s+b)\n",
    "    f_observable = st.poisson(mu*s+b)\n",
    "    p_nobs_given_exp =poisson_part.pmf(len(data)) # this is pois(Nobs | mu*s + b)\n",
    "    prod_p_ev_give_exp = np.array([ f_observable.pmf(d) for d in data]).prod() # this is prod(f(x_i|mu))\n",
    "    #print(mu, s, b, p_nobs_given_exp, prod_p_ev_give_exp, p_nobs_given_exp*prod_p_ev_give_exp)\n",
    "    ret=p_nobs_given_exp*prod_p_ev_give_exp\n",
    "    #print('Returning %s'%ret)\n",
    "    return ret\n",
    "\n",
    "def my_marked_poisson_model_1bin_nonuisance_minusloglikelihood(data, params): # analytical loglikelihood better computationally (small values)\n",
    "    mu=params[0] # POI\n",
    "    s=params[1] # We will condition on this\n",
    "    b=params[2] # We will condition on this\n",
    "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
    "    poisson_part = st.poisson(mu*s+b)\n",
    "    p_nobs_given_exp =poisson_part.pmf(data) # this is pois(Nobs | mu*s + b)\n",
    "    prod_p_ev_give_exp = np.array([ poisson_part.pmf(d) for d in range(data)]).prod() # this is prod(f(x_i|mu))\n",
    "    #print(mu, s, b, p_nobs_given_exp, prod_p_ev_give_exp, p_nobs_given_exp*prod_p_ev_give_exp)\n",
    "    ret=p_nobs_given_exp*prod_p_ev_give_exp\n",
    "    #print('Returning %s'%ret)\n",
    "    return ret\n",
    "\n",
    "\n",
    "Ntot=100\n",
    "#observations = np.array([ random.gauss(5, 1) for i in range(Ntot)])\n",
    "observations = st.poisson.rvs(20, size=Ntot)\n",
    "Nobs=20\n",
    "sexp=5\n",
    "bexp=15\n",
    "\n",
    "#print(inspect.getsource(my_marked_poisson_model_1bin_nonuisance))\n",
    "\n",
    "x=np.linspace(1,2, num=200) # scan mu\n",
    "y = [ my_marked_poisson_model_1bin_nonuisance( observations, [x_i, sexp, bexp] ) for x_i in x  ]\n",
    "\n",
    "plt.plot(x,y, label='L( %s | mu*%s +%s)' %(Nobs, sexp, bexp))\n",
    "plt.xlabel('mu = s/s_exp')\n",
    "plt.ylabel('L(%s | mu*%s + %s)'%(Nobs, sexp, bexp))\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test statistic: \n",
      "<function mean at 0x7f07c0081790>\n",
      "Test statistic value:\n",
      "20.0\n",
      "Parameters:\n",
      "('data', 'params', 'mu', 's', 'b', 'bunc', 'pois_term', 'constraint_term')\n",
      "Parameters dictionary:\n",
      "{'mu': 1, 's': 1, 'b': 1}\n",
      "Initial values:\n",
      "[1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\n",
      "Model:\n",
      "def my_poisson_count_model_1bin(data, params):\n",
      "    mu=params[0] # POI\n",
      "    s=params[1] # We will condition on this\n",
      "    b=params[2] # We will condition on this\n",
      "    bunc=params[3] # We will profile this\n",
      "    # Now mu is the POI, while s and b will be conditioned upon (expected counts)\n",
      "    pois_term = st.poisson.pmf(data,mu*s+b*(1.+bunc))\n",
      "    #pois_term= ((mu*s+b*(1.+bunc))**data)*np.exp(-(mu*s+b*(1.+bunc)))/math.factorial(data)\n",
      "    #constraint_term = 1./(math.sqrt(2*math.pi)*bunc)*math.exp(-((data-b)**2/bunc**2))\n",
      "    constraint_term=st.norm.pdf(0, b , 1)\n",
      "    #print(pois_term, constraint_term)\n",
      "    #joint_pdf = np.outer(pois_term, constraint_term)\n",
      "    #print(pois_term)\n",
      "    #print(constraint_term)\n",
      "    return pois_term*constraint_term\n",
      "\n",
      "Likelihood model (fixed data):\n",
      "        self.likelihood_realization=lambda params : (self.model(self.data, params))\n",
      "\n",
      "Likelihood model parameters:\n",
      "('params',)\n",
      "minus-log-Likelihood model (fixed data):\n",
      "        self.minusloglikelihood_realization= lambda params: 2*self.minuslogmodel(self.data, params) #if self.minuslogmodel else -2*np.log(self.model(self.data, params))\n",
      "\n",
      "minus-log-Likelihood model parameters:\n",
      "('params',)\n",
      "par mu has freezestatus [False, None, False]\n",
      "Minuit model settings: {'mu': 1.0, 's': 1.0, 'b': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': False, 'fix_b': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "par s has freezestatus [True, 5, False]\n",
      "I am freezing (conditioning on) parameter s to 5\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 1.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': False, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "par b has freezestatus [True, 15, False]\n",
      "I am freezing (conditioning on) parameter b to 15\n",
      "Minuit model settings: {'mu': 1.0, 's': 5.0, 'b': 15.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "Minimizer will run with the following model settings:  {'mu': 1.0, 's': 5.0, 'b': 15.0, 'error_mu': 0.01, 'error_s': 0.01, 'error_b': 0.01, 'fix_mu': False, 'fix_s': True, 'fix_b': True, 'limit_mu': None, 'limit_s': None, 'limit_b': None}\n",
      "┌──────────────────────────────────┬──────────────────────────────────────┐\n",
      "│ FCN = -79.83                     │         Nfcn = 13 (13 total)         │\n",
      "│ EDM = 2.52e-20 (Goal: 0.0002)    │                                      │\n",
      "├───────────────┬──────────────────┼──────────────────────────────────────┤\n",
      "│ Valid Minimum │ Valid Parameters │        No Parameters at limit        │\n",
      "├───────────────┴──────────────────┼──────────────────────────────────────┤\n",
      "│ Below EDM threshold (goal x 10)  │           Below call limit           │\n",
      "├───────────────┬──────────────────┼───────────┬─────────────┬────────────┤\n",
      "│   Hesse ok    │  Has Covariance  │ Accurate  │  Pos. def.  │ Not forced │\n",
      "└───────────────┴──────────────────┴───────────┴─────────────┴────────────┘\n",
      "Main fit Results [<ValueView of Minuit at 3d94c20>\n",
      "  mu: 1.0\n",
      "  s: 5.0\n",
      "  b: 15.0, MErrors([('mu', MError(name='mu', is_valid=True, lower=-0.8290402911094543, upper=0.9624346307137834, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=5, min=1.0))])]\n",
      "Main fit Best estimates <ValueView of Minuit at 3d94c20>\n",
      "  mu: 1.0\n",
      "  s: 5.0\n",
      "  b: 15.0\n",
      "Main fit Uncertainties ┌──────────┬───────────────────────┐\n",
      "│          │          mu           │\n",
      "├──────────┼───────────┬───────────┤\n",
      "│  Error   │   -0.8    │    1.0    │\n",
      "│  Valid   │   True    │   True    │\n",
      "│ At Limit │   False   │   False   │\n",
      "│ Max FCN  │   False   │   False   │\n",
      "│ New Min  │   False   │   False   │\n",
      "└──────────┴───────────┴───────────┘\n",
      "Parameter mu = 1.0 (+0.9624346307137834/--0.8290402911094543) [fitted]\n",
      "Parameter s = 5.0 [frozen]\n",
      "Parameter b = 15.0 [frozen]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-28-06043d36ca36>:34: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.print_level=3\n",
      "<ipython-input-28-06043d36ca36>:68: IMinuitWarning: Setting print_level >=3 has the side-effect of setting the level globally for all Minuit instances\n",
      "  m.draw_mnprofile(list(self.pardict.keys())[0],subtract_min=True)\n",
      "<ipython-input-28-06043d36ca36>:86: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, +1] = results[1][par, +1.0]\n",
      "<ipython-input-28-06043d36ca36>:87: DeprecationWarning: `merrors[(name, +-1)]` is deprecated; use `merrors[name]`\n",
      "  self.mleuncs[par, -1] = results[1][par, -1.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Ntot=1000\n",
    "data = st.poisson.rvs(20, size=Ntot)\n",
    "data = 20\n",
    "debug=True\n",
    "\n",
    "\n",
    "freezelist = {'mu': [False, None, False],\n",
    "              's': [True, 5, False],\n",
    "              'b': [True, 15, False]}\n",
    "\n",
    "plr = profile_likelihood_ratio(my_poisson_count_model_1bin, data, np.mean, my_poisson_count_model_1bin_nonuisance_minusloglikelihood, freezelist)\n",
    "\n",
    "if debug:\n",
    "    plr.print_inputs()\n",
    "plr.do_global_fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}