{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ruff: noqa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quick Start\n",
    "\n",
    "See the [API](https://xskillscore.readthedocs.io/en/stable/api.html) for more detailed information, examples, formulas, and references for each function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import xarray as xr\n",
    "\n",
    "import xskillscore as xs\n",
    "\n",
    "np.random.seed(seed=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we generate some sample gridded data. Our data has three time steps, and a 4x5 latitude/longitude grid. `obs` denotes some verification data (sometimes termed `y`) and `fct` some forecast data (e.g. from a statistical or dynamical model; sometimes termed `yhat`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = xr.DataArray(\n",
    "    np.random.rand(3, 4, 5),\n",
    "    coords=[\n",
    "        xr.cftime_range(\"2000-01-01\", \"2000-01-03\", freq=\"D\"),\n",
    "        np.arange(4),\n",
    "        np.arange(5),\n",
    "    ],\n",
    "    dims=[\"time\", \"lat\", \"lon\"],\n",
    "    name=\"var\",\n",
    ")\n",
    "fct = obs.copy()\n",
    "fct.values = np.random.rand(3, 4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deterministic Metrics\n",
    "\n",
    "`xskillscore` offers a suite of correlation-based and distance-based deterministic metrics:\n",
    "\n",
    "### Correlation-Based \n",
    "\n",
    "* Effective Sample Size (`effective_sample_size`)\n",
    "* Pearson Correlation (`pearson_r`)\n",
    "* Pearson Correlation effective p value (`pearson_r_eff_p_value`)\n",
    "* Pearson Correlation p value (`pearson_r_p_value`)\n",
    "* Slope of Linear Fit (`linslope`)\n",
    "* Spearman Correlation (`spearman_r`)\n",
    "* Spearman Correlation effective p value (`spearman_r_eff_p_value`)\n",
    "* Spearman Correlation p value (`spearman_r_p_value`)\n",
    "\n",
    "### Distance-Based\n",
    "\n",
    "* Coefficient of Determination (`r2`)\n",
    "* Mean Absolute Error (`mae`)\n",
    "* Mean Absolute Percentage Error (`mape`)\n",
    "* Mean Error (`me`)\n",
    "* Mean Squared Error (`mse`)\n",
    "* Median Absolute Error (`median_absolute_error`)\n",
    "* Root Mean Squared Error (`rmse`)\n",
    "* Symmetric Mean Absolute Percentage Error (`smape`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the functions is very straight-forward. All deterministic functions take the form `func(a, b, dim=None, **kwargs)`. **Notice that the original dataset is reduced by the dimension passed.** I.e., since we passed `time` as the dimension here, we are returned an object with dimensions `(lat, lon)`. For correlation metrics `dim` cannot be `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[ 0.99509676, -0.88499394,  0.94083077,  0.96521259, -0.13696899],\n",
      "       [-0.90613709,  0.51585291,  0.72875703,  0.19331043,  0.79754067],\n",
      "       [-0.80112059, -0.95632624, -0.23640403, -0.57684283,  0.43389289],\n",
      "       [ 0.00230351, -0.58970109, -0.87332763, -0.99992557, -0.31404248]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "r = xs.pearson_r(obs, fct, dim=\"time\")\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.06306879, 0.30832471, 0.22009394, 0.1684121 , 0.91252786],\n",
      "       [0.2780348 , 0.6549502 , 0.48019675, 0.87615511, 0.41226788],\n",
      "       [0.40847506, 0.1888421 , 0.84806222, 0.60856901, 0.71427925],\n",
      "       [0.99853354, 0.59849112, 0.32391484, 0.00776728, 0.79663312]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "p = xs.pearson_r_p_value(obs, fct, dim=\"time\")\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify multiple axes for deterministic metrics. Here, we apply it over the latitude and longitude dimension (a pattern correlation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (time: 3)> Size: 24B\n",
      "array([-0.16920304, -0.06326809,  0.18040449])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "r = xs.pearson_r(obs, fct, dim=[\"lat\", \"lon\"])\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All deterministic metrics except for `effective_sample_size`, `pearson_r_eff_p_value` and `spearman_r_eff_p_value` can take the kwarg `weights=...`. `weights` should be a DataArray of the size of the reduced dimension (e.g., if time is being reduced it should be of length 3 in our example).\n",
    "\n",
    "Weighting is a common practice when working with observations and model simulations of the Earth system. When working with rectilinear grids, one can weight the data by the cosine of the latitude, which is maximum at the equator and minimum at the poles (as in the below example). More complicated model grids tend to be accompanied by a cell area varaible, which could also be passed into this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs2 = xr.DataArray(\n",
    "    np.random.rand(3, 180, 360),\n",
    "    coords=[\n",
    "        xr.cftime_range(\"2000-01-01\", \"2000-01-03\", freq=\"D\"),\n",
    "        np.linspace(-89.5, 89.5, 180),\n",
    "        np.linspace(-179.5, 179.5, 360),\n",
    "    ],\n",
    "    dims=[\"time\", \"lat\", \"lon\"],\n",
    ")\n",
    "fct2 = obs2.copy()\n",
    "fct2.values = np.random.rand(3, 180, 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make weights as cosine of the latitude and broadcast\n",
    "weights = np.cos(np.deg2rad(obs2.lat))\n",
    "_, weights = xr.broadcast(obs2, weights)\n",
    "\n",
    "# Remove the time dimension from weights\n",
    "weights = weights.isel(time=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (time: 3)> Size: 24B\n",
      "array([-0.0020303 , -0.00498588, -0.00401522])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "r_weighted = xs.pearson_r(obs2, fct2, dim=[\"lat\", \"lon\"], weights=weights)\n",
    "print(r_weighted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (time: 3)> Size: 24B\n",
      "array([ 5.72646719e-05, -4.32380560e-03,  4.17909845e-05])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "r_unweighted = xs.pearson_r(obs2, fct2, dim=[\"lat\", \"lon\"], weights=None)\n",
    "print(r_unweighted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also pass the optional boolean kwarg `skipna`. If `True`, ignore any NaNs (pairwise) in `obs` and `fct` when computing the result. If `False`, return NaNs anywhere there are pairwise NaNs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (time: 3, lat: 4, lon: 5)> Size: 480B\n",
      "array([[[       nan,        nan,        nan,        nan,        nan],\n",
      "        [       nan,        nan,        nan,        nan,        nan],\n",
      "        [0.02058449, 0.96990985, 0.83244264, 0.21233911, 0.18182497],\n",
      "        [0.18340451, 0.30424224, 0.52475643, 0.43194502, 0.29122914]],\n",
      "\n",
      "       [[       nan,        nan,        nan,        nan,        nan],\n",
      "        [       nan,        nan,        nan,        nan,        nan],\n",
      "        [0.60754485, 0.17052412, 0.06505159, 0.94888554, 0.96563203],\n",
      "        [0.80839735, 0.30461377, 0.09767211, 0.68423303, 0.44015249]],\n",
      "\n",
      "       [[       nan,        nan,        nan,        nan,        nan],\n",
      "        [       nan,        nan,        nan,        nan,        nan],\n",
      "        [0.96958463, 0.77513282, 0.93949894, 0.89482735, 0.59789998],\n",
      "        [0.92187424, 0.0884925 , 0.19598286, 0.04522729, 0.32533033]]])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "obs_with_nans = obs.where(obs.lat > 1)\n",
    "fct_with_nans = fct.where(fct.lat > 1)\n",
    "print(obs_with_nans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (time: 3)> Size: 24B\n",
      "array([0.51901116, 0.41623426, 0.32621064])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "mae_with_skipna = xs.mae(obs_with_nans, fct_with_nans, dim=[\"lat\", \"lon\"], skipna=True)\n",
    "print(mae_with_skipna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (time: 3)> Size: 24B\n",
      "array([nan, nan, nan])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "mae_without_skipna = xs.mae(obs_with_nans, fct_with_nans, dim=[\"lat\", \"lon\"], skipna=False)\n",
    "print(mae_without_skipna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probabilistic Metrics\n",
    "\n",
    "`xskillscore` offers a suite of probabilistic metrics:\n",
    "\n",
    "* Brier Score (`brier_score`)\n",
    "* Brier scores of an ensemble for exceeding given thresholds (`threshold_brier_score`)\n",
    "* Continuous Ranked Probability Score with a gaussian distribution (`crps_gaussian`)\n",
    "* Continuous Ranked Probability Score with numerical integration of the normal distribution (`crps_quadrature`)\n",
    "* Continuous Ranked Probability Score with the ensemble distribution (`crps_ensemble`)\n",
    "* Discrimination (`discrimination`)\n",
    "* Rank Histogram (`rank_histogram`)\n",
    "* Ranked Probability Score (`rps`)\n",
    "* Receiver Operating Characteristic (`roc`)\n",
    "* Reliability (`reliability`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create some data with an ensemble member dimension. In this case, we envision an ensemble forecast with multiple members to validate against our theoretical observations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs3 = xr.DataArray(\n",
    "    np.random.rand(4, 5),\n",
    "    coords=[np.arange(4), np.arange(5)],\n",
    "    dims=[\"lat\", \"lon\"],\n",
    "    name=\"var\",\n",
    ")\n",
    "fct3 = xr.DataArray(\n",
    "    np.random.rand(3, 4, 5),\n",
    "    coords=[np.arange(3), np.arange(4), np.arange(5)],\n",
    "    dims=[\"member\", \"lat\", \"lon\"],\n",
    "    name=\"var\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Continuous Ranked Probability Score with the ensemble distribution. Pass `dim=[]` to get the same behaviour as `properscoring.crps_ensemble` without any averaging over `dim`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.19918258, 0.10670612, 0.11858151, 0.15974459, 0.26841063],\n",
      "       [0.08038415, 0.13237479, 0.23778382, 0.18009214, 0.08326884],\n",
      "       [0.08589149, 0.11666573, 0.21579228, 0.09646599, 0.12855359],\n",
      "       [0.19891371, 0.10470738, 0.05289158, 0.107965  , 0.11143681]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "crps_ensemble = xs.crps_ensemble(obs3, fct3, dim=[])\n",
    "print(crps_ensemble)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The CRPS with a Gaussian distribution requires two parameters: $\\mu$ and $\\sigma$ from the forecast distribution. Here, we just use the ensemble mean and ensemble spread."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.19821619, 0.11640329, 0.14219455, 0.15912935, 0.28104703],\n",
      "       [0.08953392, 0.11758925, 0.25156378, 0.095484  , 0.10679842],\n",
      "       [0.05069082, 0.07081479, 0.24529056, 0.08700853, 0.09535839],\n",
      "       [0.1931706 , 0.11233935, 0.0783092 , 0.09593862, 0.11037143]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "crps_gaussian = xs.crps_gaussian(obs3, fct3.mean(\"member\"), fct3.std(\"member\"), dim=[])\n",
    "print(crps_gaussian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The CRPS quadrature metric requires a callable distribution function. Here we use `norm` from `scipy.stats`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.52852898, 0.58042038, 0.46945497, 0.25013942, 0.23370234],\n",
      "       [0.39109762, 0.24071855, 0.25557803, 0.28994381, 0.23764056],\n",
      "       [0.40236669, 0.33477031, 0.24063375, 0.45538915, 0.48236113],\n",
      "       [0.42011508, 0.4174865 , 0.24837346, 0.43954946, 0.44689198]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import norm\n",
    "\n",
    "crps_quadrature = xs.crps_quadrature(obs3, norm, dim=[])\n",
    "print(crps_quadrature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use a threshold Brier Score, to score hits over a certain threshold. Ranked Probability Score for two categories yields the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' ()> Size: 8B\n",
      "array(0.15555556)\n",
      "Coordinates:\n",
      "    threshold  float64 8B 0.5\n"
     ]
    }
   ],
   "source": [
    "threshold_brier_score = xs.threshold_brier_score(obs3, fct3, 0.5, dim=None)\n",
    "print(threshold_brier_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' ()> Size: 8B\n",
      "array(0.15555556)\n"
     ]
    }
   ],
   "source": [
    "brier_score = xs.brier_score(obs3 > 0.5, (fct3 > 0.5).mean(\"member\"))\n",
    "print(brier_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray ()> Size: 8B\n",
      "array(0.15555556)\n"
     ]
    }
   ],
   "source": [
    "rps = xs.rps(obs3 > 0.5, fct3 > 0.5, category_edges=np.array([0.5]))\n",
    "print(rps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_rank' (rank: 4)> Size: 32B\n",
      "array([3, 8, 6, 3])\n",
      "Coordinates:\n",
      "  * rank     (rank) float64 32B 1.0 2.0 3.0 4.0\n"
     ]
    }
   ],
   "source": [
    "rank_histogram = xs.rank_histogram(obs3, fct3)\n",
    "print(rank_histogram)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (event: 2, forecast_probability: 5)> Size: 80B\n",
      "array([[0.        , 0.08333333, 0.        , 0.66666667, 0.25      ],\n",
      "       [0.125     , 0.5       , 0.        , 0.375     , 0.        ]])\n",
      "Coordinates:\n",
      "  * forecast_probability  (forecast_probability) float64 40B 0.1 0.3 0.5 0.7 0.9\n",
      "  * event                 (event) bool 2B True False\n"
     ]
    }
   ],
   "source": [
    "disc = xs.discrimination(obs3 > 0.5, (fct3 > 0.5).mean(\"member\"))\n",
    "print(disc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (forecast_probability: 5)> Size: 40B\n",
      "array([0.        , 0.2       ,        nan, 0.72727273, 1.        ])\n",
      "Coordinates:\n",
      "  * forecast_probability  (forecast_probability) float64 40B 0.1 0.3 0.5 0.7 0.9\n",
      "    samples               (forecast_probability) float64 40B 1.0 5.0 ... 3.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ray/Documents/PYTHON_dev/xskillscore/xskillscore/core/np_probabilistic.py:40: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  r[..., i] = N_o_f_in_bin / N_f_in_bin\n"
     ]
    }
   ],
   "source": [
    "rel = xs.reliability(obs3 > 0.5, (fct3 > 0.5).mean(\"member\"))\n",
    "print(rel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n",
      "  np.histogram_bin_edges(\n",
      "/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n",
      "  np.histogram_bin_edges(\n",
      "/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n",
      "  np.histogram_bin_edges(\n",
      "/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n",
      "  np.histogram_bin_edges(\n",
      "/Users/ray/miniforge3/envs/xskillscore-dev/lib/python3.11/site-packages/xhistogram/core.py:384: RuntimeWarning: Converting input from bool to <class 'numpy.uint8'> for compatibility.\n",
      "  np.histogram_bin_edges(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8229166666666666"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ROC for probabilistic forecasts and bin_edges='continuous' default\n",
    "roc = xs.roc(obs3 > 0.5, (fct3 > 0.5).mean(\"member\"), return_results=\"all_as_metric_dim\")\n",
    "\n",
    "plt.figure(figsize=(4, 4))\n",
    "plt.plot([0, 1], [0, 1], \"k:\")\n",
    "roc.to_dataset(dim=\"metric\").plot.scatter(y=\"true positive rate\", x=\"false positive rate\")\n",
    "roc.sel(metric=\"area under curve\").values[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contingency-Based\n",
    "\n",
    "To work with contingency-based scoring, first instantiate a `Contingency` object by passing in your observations, forecast, and observation/forecast bin edges. See https://www.cawcr.gov.au/projects/verification/#Contingency_table for more information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3,\n",
      "                                                      observations_category: 2,\n",
      "                                                      forecasts_category: 2)> Size: 96B\n",
      "array([[[5, 6],\n",
      "        [6, 3]],\n",
      "\n",
      "       [[6, 5],\n",
      "        [4, 5]],\n",
      "\n",
      "       [[5, 5],\n",
      "        [4, 6]]])\n",
      "Coordinates:\n",
      "  * time                          (time) object 24B 2000-01-01 00:00:00 ... 2...\n",
      "    observations_category_bounds  (observations_category) <U10 80B '[0.0, 0.5...\n",
      "    forecasts_category_bounds     (forecasts_category) <U10 80B '[0.0, 0.5)' ...\n",
      "  * observations_category         (observations_category) int64 16B 1 2\n",
      "  * forecasts_category            (forecasts_category) int64 16B 1 2\n"
     ]
    }
   ],
   "source": [
    "dichotomous_category_edges = np.array([0, 0.5, 1])  # \"dichotomous\" mean two-category\n",
    "dichotomous_contingency = xs.Contingency(\n",
    "    obs, fct, dichotomous_category_edges, dichotomous_category_edges, dim=[\"lat\", \"lon\"]\n",
    ")\n",
    "dichotomous_contingency_table = dichotomous_contingency.table\n",
    "print(dichotomous_contingency_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                             histogram_observations_forecasts  \\\n",
      "observations_category                                                       1   \n",
      "observations_category_bounds                                       [0.0, 0.5)   \n",
      "forecasts_category forecasts_category_bounds                                    \n",
      "1                  [0.0, 0.5)                                            5.33   \n",
      "2                  [0.5, 1.0]                                            5.33   \n",
      "\n",
      "                                                         \n",
      "observations_category                                 2  \n",
      "observations_category_bounds                 [0.5, 1.0]  \n",
      "forecasts_category forecasts_category_bounds             \n",
      "1                  [0.0, 0.5)                      4.67  \n",
      "2                  [0.5, 1.0]                      4.67  \n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    dichotomous_contingency_table.to_dataframe()\n",
    "    .pivot_table(\n",
    "        index=[\"forecasts_category\", \"forecasts_category_bounds\"],\n",
    "        columns=[\"observations_category\", \"observations_category_bounds\"],\n",
    "    )\n",
    "    .round(2)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scores based on the constructed contingency table can be called via class methods. The available methods are:\n",
    "\n",
    "* Accuracy (`accuracy`)\n",
    "* Bias Score (`bias_score`)\n",
    "* Equitable Threat Score (`equit_threat_score`)\n",
    "* False Alarms / False Positives (`false_alarms`)\n",
    "* False Alarm Ratio / False Discovery Rate (`false_alarm_ratio`)\n",
    "* False Alarm Rate / False Positive Rate / Fall-out (`false_alarm_rate`)\n",
    "* Gerrity Score (`gerrity_score`)\n",
    "* Heidke Score / Cohen's Kappa (`heidke_score`)\n",
    "* Hit Rate / Recall / Sensitivity / True Positive Rate (`hit_rate`)\n",
    "* Hits / True Positives (`hits`)\n",
    "* Misses / False Negatives (`misses`)\n",
    "* Odds Ratio (`odds_ratio`)\n",
    "* Odds Ratio Skill Score (`odds_ratio_skill_score`)\n",
    "* Peirce Score (`peirce_score`)\n",
    "* Receiver Operating Characteristic (`roc`)\n",
    "* Success Ratio / Precision / Positive Predictive Value (`success_ratio`)\n",
    "* Threat Score / Critical Success Index (`threat_score`)\n",
    "\n",
    "Below, we share a few examples of these in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([1.        , 1.11111111, 1.1       ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(dichotomous_contingency.bias_score())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([0.33333333, 0.55555556, 0.6       ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(dichotomous_contingency.hit_rate())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([0.54545455, 0.45454545, 0.5       ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(dichotomous_contingency.false_alarm_rate())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([-0.41176471,  0.2       ,  0.2       ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(dichotomous_contingency.odds_ratio_skill_score())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can leverage multi-category edges to make use of some scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "multi_category_edges = np.array([0, 0.25, 0.75, 1])\n",
    "multicategory_contingency = xs.Contingency(\n",
    "    obs, fct, multi_category_edges, multi_category_edges, dim=[\"lat\", \"lon\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([0.25, 0.25, 0.5 ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(multicategory_contingency.accuracy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([-0.14503817, -0.25      ,  0.2481203 ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(multicategory_contingency.heidke_score())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([-0.1496063 , -0.24193548,  0.25      ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(multicategory_contingency.peirce_score())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'histogram_observations_forecasts' (time: 3)> Size: 24B\n",
      "array([-0.15212912, -0.11160714,  0.25      ])\n",
      "Coordinates:\n",
      "  * time     (time) object 24B 2000-01-01 00:00:00 ... 2000-01-03 00:00:00\n"
     ]
    }
   ],
   "source": [
    "print(multicategory_contingency.gerrity_score())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5035528250988777"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ROC for deterministic forecasts and bin_edges\n",
    "roc = xs.roc(obs, fct, np.linspace(0, 1, 11), return_results=\"all_as_metric_dim\")\n",
    "\n",
    "plt.figure(figsize=(4, 4))\n",
    "plt.plot([0, 1], [0, 1], \"k:\")\n",
    "roc.to_dataset(dim=\"metric\").plot.scatter(y=\"true positive rate\", x=\"false positive rate\")\n",
    "roc.sel(metric=\"area under curve\").values[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparative\n",
    "\n",
    "Tests to compare whether one forecast is significantly better than another one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sign test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "length = 100\n",
    "obs_1d = xr.DataArray(\n",
    "    np.random.rand(length),\n",
    "    coords=[\n",
    "        np.arange(length),\n",
    "    ],\n",
    "    dims=[\"time\"],\n",
    "    name=\"var\",\n",
    ")\n",
    "fct_1d = obs_1d.copy()\n",
    "fct_1d.values = np.random.rand(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# given you want to test whether one forecast is better than another forecast\n",
    "significantly_different, walk, confidence = xs.sign_test(\n",
    "    fct_1d, fct_1d + 0.2, obs_1d, time_dim=\"time\", metric=\"mae\", orientation=\"negative\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x160310d10>]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "walk.plot()\n",
    "confidence.plot(c=\"gray\")\n",
    "(-1 * confidence).plot(c=\"gray\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Half-width Confidence Interval test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a worse forecast with high but different to perfect correlation and choose RMSE as the distance metric\n",
    "fct_1d_worse = fct_1d.copy()\n",
    "step = 3\n",
    "fct_1d_worse[::step] = fct_1d[::step].values + 0.1\n",
    "metric = \"rmse\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' ()> Size: 8B\n",
      "array(0.00734139)\n",
      "<xarray.DataArray 'var' ()> Size: 8B\n",
      "array(0.01108879)\n",
      "RMSEs significantly different at level 0.05 : False\n"
     ]
    }
   ],
   "source": [
    "# half-with of the confidence interval at level alpha is larger than the RMSE differences,\n",
    "# therefore not significant\n",
    "alpha = 0.05\n",
    "significantly_different, diff, hwci = xs.halfwidth_ci_test(\n",
    "    fct_1d, fct_1d_worse, obs_1d, metric, time_dim=\"time\", dim=[], alpha=alpha\n",
    ")\n",
    "print(diff)\n",
    "print(hwci)\n",
    "print(f\"RMSEs significantly different at level {alpha} : {bool(significantly_different)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistical tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple tests\n",
    "\n",
    "A statistical test is applied multiple times on a spatial grid. `multipletests` helps controlling the false discovery rate (FDR) of p values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.06306879, 0.30832471, 0.22009394, 0.1684121 , 0.91252786],\n",
      "       [0.2780348 , 0.6549502 , 0.48019675, 0.87615511, 0.41226788],\n",
      "       [0.40847506, 0.1888421 , 0.84806222, 0.60856901, 0.71427925],\n",
      "       [0.99853354, 0.59849112, 0.32391484, 0.00776728, 0.79663312]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "p = xs.pearson_r_p_value(fct, obs, \"time\")\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray 'var' (lat: 4, lon: 5)> Size: 160B\n",
      "array([[0.06306879, 0.30832471, 0.22009394, 0.1684121 , 0.91252786],\n",
      "       [0.2780348 , 0.6549502 , 0.48019675, 0.87615511, 0.41226788],\n",
      "       [0.40847506, 0.1888421 , 0.84806222, 0.60856901, 0.71427925],\n",
      "       [0.99853354, 0.59849112, 0.32391484, 0.00776728, 0.79663312]])\n",
      "Coordinates:\n",
      "  * lat                   (lat) int64 32B 0 1 2 3\n",
      "  * lon                   (lon) int64 40B 0 1 2 3 4\n",
      "    multipletests_method  <U6 24B 'fdr_bh'\n",
      "    multipletests_alpha   float64 8B 0.5\n",
      "    result                <U15 60B 'pvals_corrected'\n"
     ]
    }
   ],
   "source": [
    "p_corrected = xs.multipletests(p, alpha=0.5, method=\"fdr_bh\", return_results=\"pvals_corrected\")\n",
    "print(p_corrected)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert not p_corrected.equals(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessors\n",
    "\n",
    "You can also use `xskillscore` as a method of your `xarray` Dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = xr.Dataset()\n",
    "ds[\"obs_var\"] = obs\n",
    "ds[\"fct_var\"] = fct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the case that your Dataset contains both your observation and forecast variable, just pass them as strings into the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (lat: 4, lon: 5)> Size: 160B\n",
      "array([[ 0.99509676, -0.88499394,  0.94083077,  0.96521259, -0.13696899],\n",
      "       [-0.90613709,  0.51585291,  0.72875703,  0.19331043,  0.79754067],\n",
      "       [-0.80112059, -0.95632624, -0.23640403, -0.57684283,  0.43389289],\n",
      "       [ 0.00230351, -0.58970109, -0.87332763, -0.99992557, -0.31404248]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "print(ds.xs.pearson_r(\"obs_var\", \"fct_var\", dim=\"time\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also pass in a separate Dataset that contains your observations or forecast variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<xarray.DataArray (lat: 4, lon: 5)> Size: 160B\n",
      "array([[ 0.99509676, -0.88499394,  0.94083077,  0.96521259, -0.13696899],\n",
      "       [-0.90613709,  0.51585291,  0.72875703,  0.19331043,  0.79754067],\n",
      "       [-0.80112059, -0.95632624, -0.23640403, -0.57684283,  0.43389289],\n",
      "       [ 0.00230351, -0.58970109, -0.87332763, -0.99992557, -0.31404248]])\n",
      "Coordinates:\n",
      "  * lat      (lat) int64 32B 0 1 2 3\n",
      "  * lon      (lon) int64 40B 0 1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "ds = ds.drop_vars(\"fct_var\")\n",
    "print(ds.xs.pearson_r(\"obs_var\", fct, dim=\"time\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resampling\n",
    "-   randomly resample the `time` dimension and then take mean over `time` to get resample threshold\n",
    "-   resample over `member` dimension to get uncertainty due to member sampling in hindcasts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create large one-dimensional array\n",
    "s = 1000\n",
    "f = xr.DataArray(\n",
    "    np.random.normal(size=s), dims=\"member\", coords={\"member\": np.arange(s)}, name=\"var\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "109 ms ± 18.2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "1.54 ms ± 161 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# resample with replacement in that one dimension\n",
    "iterations = 100\n",
    "%timeit f_r = xs.resampling.resample_iterations(f, iterations, 'member', replace=True)\n",
    "# resample_iterations_idx is much (50x) faster because it involves no loops\n",
    "%timeit f_r = xs.resampling.resample_iterations_idx(f, iterations, 'member', replace=True)\n",
    "# but both do the same resampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- use `resample_iterations` for very large data, because very robust, chunksize stays contants and only more tasks are added\n",
    "- use `resample_iterations_idx` for small data always and very large data only, when chunked to small chunks in the other dimensions, because the function increases the input chunksize by factor `iterations`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1602dc0d0>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f_r = xs.resampling.resample_iterations_idx(f, iterations, \"member\", replace=True)\n",
    "f.plot.hist(label=\"distribution\")\n",
    "f_r.mean(\"iteration\").plot.hist(label=\"resampled mean distribution\")\n",
    "plt.axvline(x=f.mean(\"member\"), c=\"k\", label=\"distribution mean\")\n",
    "plt.title(\"Gaussian distribution mean\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1603b8c10>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGxCAYAAABIjE2TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABHsklEQVR4nO3dd1QUZ/828GulLlWKNGnWWMASjQIaEWn2xBJrFEXzaGwhaKxJQI2SkFgSjaZYsEvsUfNTMSpqbOijidhNIGKEYAVBOvf7h+/O47qLgII74PU5Z85xZ+6Z+U6RvfaemV2FEEKAiIiISEZq6LoAIiIioqcxoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgVEMxMTFQKBTSoK+vD0dHRwwYMADXrl3TaN+xY0coFArUrVsX2r5Y+PDhw9KyYmJi1KadPHkSvXr1gqurK4yMjGBvbw9vb29MnDhR6zq0De7u7s/cnuTkZCgUCnz11Vfl3hcluXXrFiIjI3Hu3LkKWyZVPHd3dwwbNkzXZUgOHToEhUKBQ4cOSeOGDRtW6jn8tOc9/7StS6FQYNy4ceVaTmmWLFmi8X8d+N//RW3TqpPynHcbN25EixYtYGxsDCcnJ4SFhSErK6tyC3xF6Ou6AKo8K1euRKNGjZCbm4vffvsNc+bMwcGDB3H58mVYWVmptTU3N0dSUhIOHDgAf39/tWkrVqyAhYUFMjMz1cbv3r0bPXv2RMeOHREdHQ1HR0ekpqbi9OnT2LhxI+bNm6fWvm7duli3bp1GnUZGRhW0xWV369YtzJw5E+7u7mjRosVLXz+VzbZt22BhYaHrMp7pk08+wQcffFCueZ73/HuedT2PJUuWwNbWVuNN2tHREcePH0e9evUqvYaqYN26dXj33XcxcuRILFiwAFevXsWUKVNw8eJF7Nu3T9flVXkMKNWYh4cHWrduDeBxD0ZRUREiIiKwfft2DB8+XK2tq6srzM3NsWLFCrWA8vDhQ2zatAmDBw/Gjz/+qDZPdHQ06tSpg71790Jf/3+n0oABAxAdHa1Rj1KphJeXV0VuIlVzLVu21HUJpXoZb9aPHj2CiYmJzoOBkZER/w//f0VFRfjoo48QFBQk/W308/ODubk5Bg8ejP/7v/9Dly5ddFxl1cZLPK8QVVj5999/tU4PDQ3F1q1b8eDBA2ncxo0bATwOHU+7e/cubG1t1cKJSo0aFX9qFRcXY86cOXB1dYWxsTFat26NX3/9VaPdtWvXMGjQINjZ2cHIyAiNGzfGt99+K00/dOgQ3njjDQDA8OHDpUtNkZGR2L17NxQKBRISEqT2W7ZsgUKhQLdu3dTW06xZM/Tp00d6LYTAkiVL0KJFCyiVSlhZWaFv377466+/NGrcv38//P39YWFhARMTE7Rr105jWyIjI6FQKHDhwgUMHDgQlpaWsLe3R2hoKDIyMkrdX0IIzJ07F25ubtL+iouLQ8eOHdGxY0epXW5uLiZOnIgWLVrA0tIS1tbW8Pb2xo4dO9SW96zufdX+U7l9+zb+85//wMXFBUZGRqhVqxbatWuH/fv3S23Onj2L7t27S8fJyckJ3bp1w82bN6U2T3e1l7VWVU3jxo3DmjVr0LhxY5iYmKB58+bYtWtXqfsOAC5fvozOnTvDxMQEtra2GD16NB4+fKjRTttll02bNqFt27awtLSEiYkJ6tati9DQUADPPv9UyzMzM8P58+cRFBQEc3Nz6UPDsy4nff/992jYsCGMjIzQpEkT6f+uiup8eprqknBycjKAx/v8woULiI+P17gMW9I5cPToUfj7+8Pc3BwmJibw8fHB7t27ta7n4MGDeP/992FrawsbGxv07t0bt27d0rpNTzp9+jQGDBgAd3d3KJVKuLu7Y+DAgfj777+fez0FBQWYPHkyHBwcYGJigvbt2+PUqVOl1gIAJ06cQGpqqsaHvXfeeQdmZmbYtm1bmZZDJWNAeYUkJSUBABo2bKh1+oABA6Cnp4cNGzZI45YvX46+fftq7Wb39vbGyZMnMWHCBJw8eRIFBQWl1lBYWKgxFBcXl6n+xYsXY8+ePVi4cCHWrl2LGjVqoEuXLjh+/LjU5uLFi3jjjTeQmJiIefPmYdeuXejWrRsmTJiAmTNnAgBef/11rFy5EgDw8ccf4/jx4zh+/DhGjhwJX19fGBgYqL2R7t+/H0qlEvHx8dI2pqenIzExEQEBAVK7UaNGISwsDAEBAdi+fTuWLFmCCxcuwMfHRy0Url27FkFBQbCwsMCqVavw008/wdraGsHBwVoDV58+fdCwYUNs2bIFU6dOxfr16/Hhhx+Wur9mzJiBGTNmoHPnztixYwdGjx6NkSNH4urVq2rt8vLycO/ePUyaNAnbt2/Hhg0b0L59e/Tu3RurV68uy6HRMGTIEGzfvh2ffvop9u3bh2XLliEgIAB3794FAGRnZyMwMBD//vsvvv32W8TFxWHhwoVwdXXVGgKet9bdu3dj8eLFmDVrFrZs2QJra2v06tVLa2h80r///gtfX18kJiZiyZIlWLNmDbKyssp0r8fx48fRv39/1K1bFxs3bsTu3bvx6aeforCwEMCzzz+V/Px89OzZE506dcKOHTukc7ckP//8M7755hvMmjULmzdvhpubGwYOHIjNmzeXWu/Ttm3bhrp166Jly5ZSbc96s42Pj0enTp2QkZGB5cuXY8OGDTA3N0ePHj0QGxur0X7kyJEwMDDA+vXrER0djUOHDuHdd98tta7k5GS89tprWLhwIfbu3YsvvvgCqampeOONN3Dnzp3nWs97772Hr776CkOHDsWOHTvQp08f9O7dG/fv3y+1nsTERACPP6g8ycDAAI0aNZKm0wsQVO2sXLlSABAnTpwQBQUF4uHDh2LPnj3CwcFBdOjQQRQUFKi19/X1FU2bNhVCCBESEiJat24thBDiwoULAoA4dOiQSEhIEADEypUrpfnu3Lkj2rdvLwAIAMLAwED4+PiIqKgo8fDhQ411qNo9PYwYMeKZ25OUlCQACCcnJ5GTkyONz8zMFNbW1iIgIEAaFxwcLJydnUVGRobaMsaNGyeMjY3FvXv3hBBC6/aotG/fXnTq1El6Xb9+ffHRRx+JGjVqiPj4eCGEEOvWrRMAxNWrV4UQQhw/flwAEPPmzVNbVkpKilAqlWLy5MlCCCGys7OFtbW16NGjh1q7oqIi0bx5c9GmTRtpXEREhAAgoqOj1dqOGTNGGBsbi+Li4hL32b1794SRkZHo37+/2nhVnb6+viXOW1hYKAoKCsSIESNEy5YtpfGq46BtnwEQERER0mszMzMRFhZW4jpOnz4tAIjt27eX2EYIIdzc3ERISEi5a1XVZG9vLzIzM6VxaWlpokaNGiIqKuqZ650yZYpQKBTi3LlzauMDAwMFAHHw4EFpXEhIiHBzc5Nef/XVVwKAePDgQYnLf9b5FxISIgCIFStWaJ325LpU26lUKkVaWpo0rrCwUDRq1EjUr19fGqc6n56m+nuRlJQkjWvatKnWc0TbOeDl5SXs7OzU/s8XFhYKDw8P4ezsLJ2nqvWMGTNGbZnR0dECgEhNTdVY37MUFhaKrKwsYWpqKr7++muN7SltPZcuXRIAxIcffqjWTvV/+1nnnRBCzJkzp8S6g4KCRMOGDcu1PaSJPSjVmJeXFwwMDGBubo7OnTvDysoKO3bs0HpJRiU0NBSnT5/G+fPnsXz5ctSrVw8dOnTQ2tbGxgZHjhxBQkICPv/8c7z11lu4evUqpk2bBk9PT41PNfXq1UNCQoLG8Mknn5Rpe3r37g1jY2PptepT2uHDh1FUVITc3Fz8+uuv6NWrF0xMTNR6abp27Yrc3FycOHGi1PX4+/vjt99+Q05ODv7++29cv34dAwYMQIsWLRAXFwfgca+Kq6srGjRoAADYtWsXFAoF3n33XbX1Ojg4oHnz5tJTH8eOHcO9e/cQEhKi0YvUuXNnJCQkIDs7W62enj17qr1u1qwZcnNzkZ6eXuI2nDhxAnl5eejXr5/aeC8vL62XCDZt2oR27drBzMwM+vr6MDAwwPLly3Hp0qVS95c2bdq0QUxMDD777DOcOHFCo3etfv36sLKywpQpU/Ddd9/h4sWLZV52eWpV3ROgYm9vDzs7O43LAk87ePAgmjZtiubNm6uNHzRoUKn1qS7f9OvXDz/99BP++eefsmyWhicvH5bG398f9vb20ms9PT30798f169fV7tkVtGys7Nx8uRJ9O3bF2ZmZmrrHzJkCG7evIkrV66ozaPtfAZQ6jHJysrClClTUL9+fejr60NfXx9mZmbIzs7WeuxLW8/BgwcBAIMHD1Zr169fv2f+jXyatstmzxpPZceAUo2tXr0aCQkJOHDgAEaNGoVLly5h4MCBz5ynQ4cOaNCgAb7//nusWbMGoaGhpf5Ha926NaZMmYJNmzbh1q1b+PDDD5GcnKxxo6zqPoinBzc3tzJtj4ODg9Zx+fn5yMrKwt27d1FYWIhFixbBwMBAbejatSsAaO0KflpAQADy8vJw9OhRxMXFwdbWFi1btkRAQIB06efXX39Vu7zz77//QggBe3t7jXWfOHFCWq/qUk/fvn012n3xxRcQQuDevXtq9djY2Ki9Vj31lJOTU+I2qC6lPPmmpfL0uK1bt6Jfv36oXbs21q5di+PHjyMhIQGhoaHIzc0tdX9pExsbi5CQECxbtgze3t6wtrbG0KFDkZaWBgCwtLREfHw8WrRogenTp6Np06ZwcnJCRETEMy8VlrfWp/cd8Hj/PWvfAY/3X0nnW2k6dOiA7du3o7CwEEOHDoWzszM8PDzULp2WxsTEpFxPLz2rVtW5UBnu378PIQQcHR01pjk5OWld//Ocz8DjcLh48WKMHDkSe/fuxalTp5CQkIBatWppnbe09ajqenrf6evraz1vSlq+tv177949WFtbl7oMejY+xVONNW7cWLox1s/PD0VFRVi2bBk2b96Mvn37ljjf8OHD8fHHH0OhUCAkJKRc6zQwMEBERAQWLFhQ4ddgVW9uT48zNDSEmZkZDAwMpE9uY8eO1bqMOnXqlLqetm3bwszMDPv370dycjL8/f2hUCjg7++PefPmISEhATdu3FALKLa2tlAoFDhy5IjWx6ZV42xtbQEAixYtKvFpCG2horxUfzy13RCdlpam1ouydu1a1KlTB7GxsWphNC8vT20+Ve/V0+O1/YG2tbXFwoULsXDhQty4cQM///wzpk6divT0dOzZswcA4OnpiY0bN0IIgT/++AMxMTGYNWsWlEolpk6dqnW7ylrri7KxsSnxfCuLt956C2+99Rby8vJw4sQJREVFYdCgQXB3d4e3t3ep85f30/ezalWdC08evyfP0bKE9pJYWVmhRo0aSE1N1ZimuiFVdc6/iIyMDOzatQsRERFq54bqnqTnodovaWlpqF27tjS+sLCwTKHO09MTAHD+/Hk0adJEbf7Lly+X+mGQSscelFdIdHQ0rKys8Omnnz7zxtSQkBD06NEDH330kdp/3Kdp+6MEQOpuVX2Cqihbt25V+5T88OFD7Ny5E2+++Sb09PRgYmICPz8/nD17Fs2aNdPaW6P6o/SsT20GBgbo0KED4uLicODAAQQGBgIA3nzzTejr60vh7cnHsbt37w4hBP755x+t61X9MWvXrh1q1qyJixcvam3XunVrGBoavvC+atu2LYyMjDRuUjxx4oRGV7pCoYChoaHam2JaWprGkzH29vYwNjbGH3/8oTZe2xM0T3J1dcW4ceMQGBiI//73vxrTFQoFmjdvjgULFqBmzZpa25S31hfl5+eHCxcu4Pfff1cbv379+nItx8jICL6+vvjiiy8APH5ySTUeKL3XoKx+/fVXtTBaVFSE2NhY1KtXD87OzgAghdKnj9/OnTu11l2W2kxNTdG2bVts3bpVrX1xcTHWrl0LZ2fnEm/KLw+FQgEhhEb4X7ZsGYqKip5rmaon2Z7+bqaffvpJuqH5Wdq2bQtHR0eNJ5o2b96MrKws9O7d+7nqov9hD8orxMrKCtOmTcPkyZOxfv36Eu+cd3Jywvbt20tdXnBwMJydndGjRw80atQIxcXFOHfuHObNmwczMzONL5TKyckp8R6Qsny3gp6eHgIDAxEeHo7i4mJ88cUXyMzMVHvC4euvv0b79u3x5ptv4v3334e7uzsePnyI69evY+fOnThw4ACAx/fDKJVKrFu3Do0bN4aZmRmcnJykUOXv7y99G66qp0SpVMLHxwf79u1Ds2bNYGdnJ623Xbt2+M9//oPhw4fj9OnT6NChA0xNTZGamoqjR4/C09MT77//PszMzLBo0SKEhITg3r176Nu3L+zs7HD79m38/vvvuH37NpYuXVrqviiNtbU1wsPDERUVBSsrK/Tq1Qs3b97EzJkz4ejoqPYYePfu3bF161aMGTMGffv2RUpKCmbPng1HR0e1bx5W3WOzYsUK1KtXD82bN8epU6c03rQzMjLg5+eHQYMGoVGjRjA3N0dCQgL27Nkj/dHetWsXlixZgrffflv6BmPVI+6qQKhNWWt9UWFhYVixYgW6deuGzz77DPb29li3bh0uX75c6ryffvopbt68CX9/fzg7O+PBgwf4+uuvYWBgAF9fXwCln3/lZWtri06dOuGTTz6BqakplixZgsuXL6s9aty1a1dYW1tjxIgRmDVrFvT19RETE4OUlBSN5al6t2JjY1G3bl0YGxtLIftpUVFRCAwMhJ+fHyZNmgRDQ0MsWbIEiYmJ2LBhQ4Xci2FhYYEOHTrgyy+/hK2tLdzd3REfH4/ly5ejZs2az7XMxo0b491338XChQthYGCAgIAAJCYm4quvvirT5TU9PT1ER0djyJAhGDVqFAYOHIhr165h8uTJCAwMROfOnZ+rLnqCDm/QpUqiuos9ISFBY1pOTo5wdXUVDRo0EIWFhUII9ad4SqLtqYPY2FgxaNAg0aBBA2FmZiYMDAyEq6urGDJkiLh48aLa/M96igeAxpNFT1I9OfDFF1+ImTNnCmdnZ2FoaChatmwp9u7dq7V9aGioqF27tjAwMBC1atUSPj4+4rPPPlNrt2HDBtGoUSNhYGCg8RTK77//LgCIBg0aqM2junM/PDxca60rVqwQbdu2FaampkKpVIp69eqJoUOHitOnT6u1i4+PF926dRPW1tbCwMBA1K5dW3Tr1k1s2rRJaqN66uL27dtq82p76kKb4uJi8dlnn0n7q1mzZmLXrl2iefPmolevXmptP//8c+Hu7i6MjIxE48aNxY8//qj1qY+MjAwxcuRIYW9vL0xNTUWPHj1EcnKy2v7Lzc0Vo0ePFs2aNRMWFhZCqVSK1157TURERIjs7GwhhBCXL18WAwcOFPXq1RNKpVJYWlqKNm3aiJiYGLX1aXuKp6y1AhBjx47V2C+lPRmkcvHiRREYGCiMjY2FtbW1GDFihNixY0epT/Hs2rVLdOnSRdSuXVsYGhoKOzs70bVrV3HkyBG15Zd0/oWEhAhTU1OtNZX0FM/YsWPFkiVLRL169YSBgYFo1KiRWLduncb8p06dEj4+PsLU1FTUrl1bREREiGXLlmmcT8nJySIoKEiYm5sLANI6S3qS68iRI6JTp07See/l5SV27typ1qakv0sHDx7U2Kfa3Lx5U/Tp00dYWVkJc3Nz0blzZ5GYmKhxPMuznry8PDFx4kRhZ2cnjI2NhZeXlzh+/HiZzxEhhFi/fr1o1qyZMDQ0FA4ODmLChAkaTzHS81EIoeXHV4ioWkpKSkKjRo0QERGB6dOn67ocIqISMaAQVVO///47NmzYAB8fH1hYWODKlSuIjo5GZmYmEhMTK+RmXCKiysJ7UIiqKVNTU5w+fRrLly/HgwcPYGlpiY4dO2LOnDkMJ0Qke+xBISIiItnhY8ZEREQkOwwoREREJDsMKERERCQ7VfIm2eLiYty6dQvm5ub8QSYiIqIqQgiBhw8fwsnJSe0LI7WpkgHl1q1bcHFx0XUZRERE9BxSUlKkn2EoSZUMKKqfT09JSSnXL34S0YvJzs6Wvo791q1bMDU11XFFRFSVZGZmwsXFRXoff5YqGVBUl3UsLCwYUIheIj09PenfFhYWDChE9FzKcnsGb5IlIiIi2WFAISIiItlhQCEiIiLZqZL3oBBR1SaEQGFhIYqKinRdChFVMAMDA7X71Z4XAwoRvVT5+flITU3Fo0ePdF0KEVUChUIBZ2dnmJmZvdByGFCI6KUpLi5GUlIS9PT04OTkBENDQ37ZIlE1IoTA7du3cfPmTTRo0OCFelIYUIjopcnPz0dxcTFcXFxgYmKi63KIqBLUqlULycnJKCgoeKGAwptkieilK+0rromo6qqoXlH+lSAiIiLZYUAhIiIi2eE9KESkc+5Td7/U9SV/3u2lrk9uhg0bhgcPHmD79u3PvYxDhw7Bz88P9+/fR82aNSusNjmJiYlBWFgYHjx4AACIjIzE9u3bce7cuQpdz9P78un1Vua65Iw9KEREVCnc3d2hUCigUCigVCrRqFEjfPnllxBCSG2Sk5OhUCigr6+Pf/75R23+1NRU6OvrQ6FQIDk5WRq/ZcsWtG3bFpaWljA3N0fTpk0xceJEaXpMTIy03icHY2PjF9qeSZMm4ddffy1T28jISLRo0aJMbX18fJCamgpLS8sXqE5Tx44dERYW9lLWVRkYUIiIyik/P1/XJVQZs2bNQmpqKi5duoRJkyZh+vTp+OGHHzTaOTk5YfXq1WrjVq1ahdq1a6uN279/PwYMGIC+ffvi1KlTOHPmDObMmaNxTCwsLJCamqo2/P333y+0LWZmZrCxsXmhZTytoKAAhoaGcHBweCmP3L/Mdb0oBhQiolJ07NgR48aNQ3h4OGxtbREYGAgAuHjxIrp27QozMzPY29tjyJAhuHPnjjTf5s2b4enpCaVSCRsbGwQEBCA7OxsAkJCQgMDAQNja2sLS0hK+vr7473//q7ZehUKB77//Ht27d4eJiQkaN26M48eP4/r16+jYsSNMTU3h7e2NP//8U5pH9cn9+++/lx7nfuedd555uUAIgejoaNStWxdKpRLNmzfH5s2b1dr88ssvaNiwIZRKJfz8/NR6NJ7F3NwcDg4OcHd3x8iRI9GsWTPs27dPo11ISAhWrlypNi4mJgYhISFq43bt2oX27dvjo48+wmuvvYaGDRvi7bffxqJFizT2nYODg9pgb2//zFpjYmLg6uoKExMT9OrVC3fv3lWb/nSvyKFDh9CmTRuYmpqiZs2aaNeuHf7++2/ExMRg5syZ+P3336Xem5iYGKmu7777Dm+99RZMTU3x2Wef4dChQ1AoFBrHaPv27WjYsCGMjY0RGBiIlJQUadqwYcPw9ttvq7UPCwtDx44dpenx8fH4+uuvpRqSk5O1rmvLli1o2rQpjIyM4O7ujnnz5qkt193dHXPnzkVoaCjMzc3h6uqqNWRWNN6DQlTNVeT9HcX5udK/G3+yBzUMy9dlXttcD5F+dshXZkKhn1v6DDKyatUqvP/++/jtt98ghEBqaip8fX3x3nvvYf78+cjJycGUKVPQr18/HDhwAKmpqRg4cCCio6PRq1cvPHz4EEeOHJEubzx8+BAhISH45ptvAADz5s1D165dce3aNZibm0vrnT17NubPn4/58+djypQpGDRoEOrWrYtp06bB1dUVoaGhGDduHP7v//5Pmuf69ev46aefsHPnTmRmZmLEiBEYO3Ys1q1bp3XbPv74Y2zduhVLly5FgwYNcPjwYbz77ruoVasWfH19kZKSgt69e2P06NF4//33cfr0abVLKmUhhEB8fDwuXbqEBg0aaEzv2bMnvvvuOxw9ehTt27fH0aNHce/ePfTo0QOzZ8+W2jk4OGD9+vVITEyEh4dHuWp4lpMnTyI0NBRz585F7969sWfPHkRERJTYvrCwEG+//Tbee+89bNiwAfn5+Th16hQUCgX69++PxMRE7NmzB/v37wcAtUsqERERiIqKwoIFC6Cnp4ekpCSN5T969Ahz5szBqlWrYGhoiDFjxmDAgAH47bffyrQ9X3/9Na5evQoPDw/MmjULwP++n+RJZ86cQb9+/RAZGYn+/fvj2LFjGDNmDGxsbDBs2DCp3bx58zB79mxMnz4dmzdvxvvvv48OHTqgUaNGZarneTCgEBGVQf369REdHS29/vTTT/H6669j7ty50rgVK1bAxcUFV69eRVZWFgoLC9G7d2+4ubkBADw9PaW2nTp1Ulv+999/DysrK8THx6N79+7S+OHDh6Nfv34AgClTpsDb2xuffPIJgoODAQAffPABhg8frras3NxcrFq1Cs7OzgCARYsWoVu3bpg3bx4cHBzU2mZnZ2P+/Pk4cOAAvL29AQB169bF0aNH8f3338PX1xdLly5F3bp1sWDBAigUCrz22ms4f/48vvjii1L325QpU/Dxxx8jPz8fBQUFMDY2xoQJEzTaGRgY4N1338WKFSvQvn17rFixAu+++y4MDAzU2o0fPx5HjhyBp6cn3Nzc4OXlhaCgIAwePBhGRkZSu4yMDI2vWvfx8dHaewM8fkMPDg7G1KlTAQANGzbEsWPHsGfPHq3tMzMzkZGRge7du6NevXoAgMaNG0vTzczMoK+vr7G/AWDQoEEIDQ2VXmsLKAUFBVi8eDHatm0L4HFAbty4MU6dOoU2bdporelJlpaWMDQ0hImJidYaVObPnw9/f3988skn0nZfvHgRX375pVpA6dq1K8aMGQPg8TFdsGABDh06VKkBhZd4iIjKoHXr1mqvz5w5g4MHD8LMzEwaVH+s//zzTzRv3hz+/v7w9PTEO++8gx9//BH379+X5k9PT8fo0aPRsGFDWFpawtLSEllZWbhx44baepo1ayb9W3WJ4smgY29vj9zcXGRmZkrjXF1dpXACAN7e3iguLsaVK1c0tuvixYvIzc1FYGCg2rasXr1aunR06dIleHl5qd23oAozpfnoo49w7tw5xMfHw8/PDzNmzICPj4/WtiNGjMCmTZuQlpaGTZs2qb2Jq5iammL37t24fv06Pv74Y5iZmWHixIlo06aN2u87mZub49y5c2rD05eQnnTp0iWNbXrWNlpbW2PYsGEIDg5Gjx498PXXXyM1NbW03QFA81zSRl9fX61do0aNULNmTVy6dKlM6yirS5cuoV27dmrj2rVrh2vXrqn9mOeT56Hq8ll6enqF1vI09qAQEZWBqamp2uvi4mL06NFDay+Co6Mj9PT0EBcXh2PHjmHfvn1YtGgRZsyYgZMnT6JOnToYNmwYbt++jYULF8LNzQ1GRkbw9vbWuNnzyR4EVUDQNq64uLjE2lVttN0YqZpv9+7dGjekqnoknnzqprxsbW1Rv3591K9fH1u2bEH9+vXh5eWFgIAAjbYeHh5o1KgRBg4ciMaNG8PDw6PER3rr1auHevXqYeTIkZgxYwYaNmyI2NhYqTepRo0aqF+/fpnrfJ5tXLlyJSZMmIA9e/YgNjYWH3/8MeLi4uDl5fXM+Z4+l0qi7XipxtWoUUOj5oKCgjJW/j9CCI31aNsXT/dkKRSKZ55zFYE9KEREz+H111/HhQsX4O7uLr0BqwbVG5BCoUC7du0wc+ZMnD17FoaGhti2bRsA4MiRI5gwYQK6du0q3aD45A22L+LGjRu4deuW9Pr48eOoUaMGGjZsqNG2SZMmMDIywo0bNzS2w8XFRWpz4sQJtfmefl0WVlZWGD9+PCZNmlRiIAgNDcWhQ4e09p6UxN3dHSYmJtINyM/jebexZcuWmDZtGo4dOwYPDw+sX78ewOOnZZ7sgSivwsJCnD59Wnp95coVPHjwQOqlq1WrlkaPzdNhriw1NGnSBEePHlUbd+zYMTRs2PCFfkenIjCgEBE9h7Fjx+LevXsYOHAgTp06hb/++gv79u1DaGgoioqKcPLkScydOxenT5/GjRs3sHXrVty+fVu6T6F+/fpYs2YNLl26hJMnT2Lw4MFQKpUVUpuxsTFCQkLw+++/S0GoX79+Wu9FMDc3x6RJk/Dhhx9i1apV+PPPP3H27Fl8++23WLVqFQBg9OjR+PPPPxEeHo4rV65g/fr10lMp5TV27FhcuXIFW7Zs0Tr9vffew+3btzFy5Eit0yMjIzF58mQcOnQISUlJOHv2LEJDQ1FQUCA9XQU87gVIS0vTGEr61K/qCYmOjsbVq1exePHiEu8/AR7fNzJt2jQcP34cf//9N/bt24erV69Kx9fd3R1JSUk4d+4c7ty5g7y8vLLuIgCPeyzGjx+PkydP4r///S+GDx8OLy8v6f6TTp064fTp01i9ejWuXbuGiIgIJCYmqi3D3d0dJ0+eRHJyMu7cuaN12ydOnIhff/0Vs2fPxtWrV7Fq1SosXrwYkyZNKle9lYGXeIhI534ep34NvJlzTd0UUg5OTk747bffMGXKFAQHByMvLw9ubm7o3LkzatSoAQsLCxw+fBgLFy5EZmYm3NzcMG/ePHTp0gXA4xtq//Of/6Bly5ZwdXXF3LlzK+xNoX79+ujduze6du2Ke/fuoWvXrliyZEmJ7WfPng07OztERUXhr7/+Qs2aNfH6669j+vTpAB7f07JlyxZ8+OGHWLJkCdq0aSM9dlpetWrVwpAhQxAZGYnevXtrTNfX14etrW2J8/v6+uLbb7/F0KFD8e+//8LKygotW7bEvn378Nprr0ntMjMz4ejoqDF/amqq1qDm5eWFZcuWISIiApGRkQgICMDHH3+s9gTRk0xMTHD58mWsWrUKd+/ehaOjI8aNG4dRo0YBAPr06YOtW7fCz88PDx48wMqVK9VuOi2NiYmJ9NTWzZs3pRuHVYKDg/HJJ59g8uTJyM3NRWhoKIYOHYrz589LbSZNmoSQkBA0adIEOTk5Wm/Gff311/HTTz/h008/xezZs+Ho6IhZs2aVq9bKohAvcnFRRzIzM2FpaYmMjAxYWFjouhwiWavox4xTFvQFALh8uPm5HzO2c3KGQt+wxHZVIaDIVWV9HTtRWeXm5iIpKQl16tTR+Pbe8rx/8xIPERERyQ4DChEREckOAwoRUTUSGRnJyztULTCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBARlcGwYcOgUCigUCigr68PV1dXvP/++7h//77Uxt3dHQqFAhs3btSYv2nTplAoFGo/snf27Fl0794ddnZ2MDY2hru7O/r37y/9qnFycrK0zqeH5/k1YaKqhAGFiKiMOnfujNTUVCQnJ2PZsmXYuXMnxowZo9bGxcUFK1euVBt34sQJpKWlwdTUVBqXnp6OgIAA2NraYu/evbh06RJWrFgBR0dHPHr0SG3+/fv3IzU1VW1o1apV5W0okQzw14yJSGeEEMjJeaQxPjvboNLXbWJiAoVCUa55jIyMpF/CdXZ2Rv/+/dV6RABg8ODBWLBgAVJSUuDi4gLg8S8XDx48GKtXr5baHTt2DJmZmVi2bBn09R//Ka5Tpw46deqksV4bGxutv8BLVJ2VqwclKioKb7zxBszNzWFnZ4e3334bV65cUWvzZDeoavDy8lJrk5eXh/Hjx8PW1hampqbo2bMnbt68+eJbQ0RVSk7OI3i/5qwxmJmZVfrwdC9Fef3111/Ys2cPDAzUw5S9vT2Cg4OxatUqAMCjR48QGxuL0NBQtXYODg4oLCzEtm3bUAV/VJ6o0pUroMTHx2Ps2LE4ceIE4uLiUFhYiKCgIGRnZ6u1U3WDqoZffvlFbXpYWBi2bduGjRs34ujRo8jKykL37t1RVFT04ltERFRJdu3aBTMzMyiVStSrVw8XL17ElClTNNqFhoYiJiYGQghs3rwZ9erVQ4sWLdTaeHl5Yfr06Rg0aBBsbW3RpUsXfPnll/j33381lufj46MRsPj3kqq7cl3i2bNnj9rrlStXws7ODmfOnEGHDh2k8U92gz4tIyMDy5cvx5o1axAQEAAAWLt2LVxcXLB//34EBweXdxuIqIpSKk1w/Ipm76ln7ZqVvm4TE5Nyz+Pn54elS5fi0aNHWLZsGa5evYrx48drtOvWrRtGjRqFw4cPY8WKFRq9Jypz5sxBeHg4Dhw4gBMnTuC7777D3LlzcfjwYXh6ekrtYmNj0bhxY7V59fT0yl0/UVXyQvegZGRkAACsra3Vxh86dAh2dnaoWbMmfH19MWfOHNjZ2QEAzpw5g4KCAgQFBUntnZyc4OHhgWPHjmkNKHl5ecjLy5NeZ2ZmvkjZRCQTCoUCJiamGuOfvJlUTkxNTVG/fn0AwDfffAM/Pz/MnDkTs2fPVmunr6+PIUOGICIiAidPnsS2bdtKXKaNjQ3eeecdvPPOO4iKikLLli3x1VdfSZeIgMc33qrWS/SqeO6neIQQCA8PR/v27eHh4SGN79KlC9atW4cDBw5g3rx5SEhIQKdOnaSAkZaWBkNDQ1hZWaktz97eHmlpaVrXFRUVBUtLS2lQ3XhGRKRLERER+Oqrr3Dr1i2NaaGhoYiPj8dbb72l8feuJIaGhqhXr57GZXOiV9Fz96CMGzcOf/zxB44ePao2vn///tK/PTw80Lp1a7i5uWH37t3o3bt3icsTQpR4R/20adMQHh4uvc7MzGRIISKd69ixI5o2bYq5c+di8eLFatMaN26MO3fulHgpadeuXdi4cSMGDBiAhg0bQgiBnTt34pdfftF4TPnu3bsaH+Bq1qwJY2Pjit0gIhl5roAyfvx4/Pzzzzh8+DCcnZ2f2dbR0RFubm64du0agMd3rufn5+P+/ftqnyrS09Ph4+OjdRlGRkYwMjJ6nlKJiCpVeHg4hg8frvVmWRsbmxLna9KkCUxMTDBx4kSkpKTAyMgIDRo0wLJlyzBkyBC1tqr79Z60YcMGDBgw4MU3gEimyhVQhBAYP348tm3bhkOHDqFOnTqlznP37l2kpKTA0dERANCqVSsYGBggLi4O/fr1AwCkpqYiMTER0dHRz7EJRESV7+nvO1EZNGgQBg0aBODxN78+y4MHD6R/161bFz/88MMz27u7u/MRZHpllSugjB07FuvXr8eOHTtgbm4udTlaWlpCqVQiKysLkZGR6NOnDxwdHZGcnIzp06fD1tYWvXr1ktqOGDECEydOhI2NDaytrTFp0iR4enpq/ZRAREREr55yBZSlS5cCeHzd9UkrV67EsGHDoKenh/Pnz2P16tV48OABHB0d4efnh9jYWJibm0vtFyxYAH19ffTr1w85OTnw9/dHTEwMH5sjIiIiAM9xiedZlEol9u7dW+pyjI2NsWjRIixatKg8qyciIqJXBH8skIiIiGSHAYWIXppiAQAC4I2fRNVWRd3YzYBCRC/Ng9xiFBQJiMJ8XZdCRJUkP//x/+8Xva/0hb7qnoioPHIKBX79KwvdDfVgZQ0o9A0BLV/QmJubq4PqiOhFFRcX4/bt2zAxMYG+/otFDAYUInqptl56/DXu/nWLYKCnAKAZUAxzlC+5KiKqKDVq1ICrq2uJ3w5fVgwoRPRSCQBbLmVj97VHsDKugRpa/ob9OrHjyy6LiCqIoaEhatR48TtIGFCISCdyCwVSs4q0TuNvzBARb5IlIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItlhQCEiIiLZYUAhIiIi2WFAISIiItnR13UBRFWJ+9Tdui6BiOiVwB4UIiIikh0GFCIiIpIdXuIhItmpipfSkj/vpusSiKoV9qAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHslCugREVF4Y033oC5uTns7Ozw9ttv48qVK2pthBCIjIyEk5MTlEolOnbsiAsXLqi1ycvLw/jx42FrawtTU1P07NkTN2/efPGtISIiomqhXAElPj4eY8eOxYkTJxAXF4fCwkIEBQUhOztbahMdHY358+dj8eLFSEhIgIODAwIDA/Hw4UOpTVhYGLZt24aNGzfi6NGjyMrKQvfu3VFUVFRxW0ZERERVVrm+qG3Pnj1qr1euXAk7OzucOXMGHTp0gBACCxcuxIwZM9C7d28AwKpVq2Bvb4/169dj1KhRyMjIwPLly7FmzRoEBAQAANauXQsXFxfs378fwcHBFbRpREREVFW90D0oGRkZAABra2sAQFJSEtLS0hAUFCS1MTIygq+vL44dOwYAOHPmDAoKCtTaODk5wcPDQ2rztLy8PGRmZqoNREREVH09d0ARQiA8PBzt27eHh4cHACAtLQ0AYG9vr9bW3t5empaWlgZDQ0NYWVmV2OZpUVFRsLS0lAYXF5fnLZuIiIiqgOcOKOPGjcMff/yBDRs2aExTKBRqr4UQGuOe9qw206ZNQ0ZGhjSkpKQ8b9lERERUBTxXQBk/fjx+/vlnHDx4EM7OztJ4BwcHANDoCUlPT5d6VRwcHJCfn4/79++X2OZpRkZGsLCwUBuIiIio+ipXQBFCYNy4cdi6dSsOHDiAOnXqqE2vU6cOHBwcEBcXJ43Lz89HfHw8fHx8AACtWrWCgYGBWpvU1FQkJiZKbYiIiOjVVq6neMaOHYv169djx44dMDc3l3pKLC0toVQqoVAoEBYWhrlz56JBgwZo0KAB5s6dCxMTEwwaNEhqO2LECEycOBE2NjawtrbGpEmT4OnpKT3VQ0RERK+2cgWUpUuXAgA6duyoNn7lypUYNmwYAGDy5MnIycnBmDFjcP/+fbRt2xb79u2Dubm51H7BggXQ19dHv379kJOTA39/f8TExEBPT+/FtoaIiIiqBYUQQui6iPLKzMyEpaUlMjIyeD8KvVTuU3frugSdKs7PRcqCvgAAlw83o4ahsY4rko/kz7vpugQi2SvP+zd/i4eIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSn3AHl8OHD6NGjB5ycnKBQKLB9+3a16cOGDYNCoVAbvLy81Nrk5eVh/PjxsLW1hampKXr27ImbN2++0IYQERFR9VHugJKdnY3mzZtj8eLFJbbp3LkzUlNTpeGXX35Rmx4WFoZt27Zh48aNOHr0KLKystC9e3cUFRWVfwuIiIio2tEv7wxdunRBly5dntnGyMgIDg4OWqdlZGRg+fLlWLNmDQICAgAAa9euhYuLC/bv34/g4ODylkRERETVTKXcg3Lo0CHY2dmhYcOGeO+995Ceni5NO3PmDAoKChAUFCSNc3JygoeHB44dO6Z1eXl5ecjMzFQbiIiIqPqq8IDSpUsXrFu3DgcOHMC8efOQkJCATp06IS8vDwCQlpYGQ0NDWFlZqc1nb2+PtLQ0rcuMioqCpaWlNLi4uFR02URERCQj5b7EU5r+/ftL//bw8EDr1q3h5uaG3bt3o3fv3iXOJ4SAQqHQOm3atGkIDw+XXmdmZjKkEBERVWOV/pixo6Mj3NzccO3aNQCAg4MD8vPzcf/+fbV26enpsLe317oMIyMjWFhYqA1ERERUfVV6QLl79y5SUlLg6OgIAGjVqhUMDAwQFxcntUlNTUViYiJ8fHwquxwiIiKqAsp9iScrKwvXr1+XXiclJeHcuXOwtraGtbU1IiMj0adPHzg6OiI5ORnTp0+Hra0tevXqBQCwtLTEiBEjMHHiRNjY2MDa2hqTJk2Cp6en9FQPERERvdrKHVBOnz4NPz8/6bXq3pCQkBAsXboU58+fx+rVq/HgwQM4OjrCz88PsbGxMDc3l+ZZsGAB9PX10a9fP+Tk5MDf3x8xMTHQ09OrgE0iIiKiqq7cAaVjx44QQpQ4fe/evaUuw9jYGIsWLcKiRYvKu3oiIiJ6BfC3eIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2GFCIiIhIdhhQiIiISHYYUIiIiEh2yh1QDh8+jB49esDJyQkKhQLbt29Xmy6EQGRkJJycnKBUKtGxY0dcuHBBrU1eXh7Gjx8PW1tbmJqaomfPnrh58+YLbQgRERFVH+UOKNnZ2WjevDkWL16sdXp0dDTmz5+PxYsXIyEhAQ4ODggMDMTDhw+lNmFhYdi2bRs2btyIo0ePIisrC927d0dRUdHzbwkRERFVG/rlnaFLly7o0qWL1mlCCCxcuBAzZsxA7969AQCrVq2Cvb091q9fj1GjRiEjIwPLly/HmjVrEBAQAABYu3YtXFxcsH//fgQHB2ssNy8vD3l5edLrzMzM8pZNREREVUiF3oOSlJSEtLQ0BAUFSeOMjIzg6+uLY8eOAQDOnDmDgoICtTZOTk7w8PCQ2jwtKioKlpaW0uDi4lKRZRMREZHMVGhASUtLAwDY29urjbe3t5empaWlwdDQEFZWViW2edq0adOQkZEhDSkpKRVZNhEREclMuS/xlIVCoVB7LYTQGPe0Z7UxMjKCkZFRhdVHRERE8lahAcXBwQHA414SR0dHaXx6errUq+Lg4ID8/Hzcv39frRclPT0dPj4+FVkOyZz71N26LoGIiGSqQgNKnTp14ODggLi4OLRs2RIAkJ+fj/j4eHzxxRcAgFatWsHAwABxcXHo168fACA1NRWJiYmIjo6uyHKIiF6aqhq4kz/vpusSiLQqd0DJysrC9evXpddJSUk4d+4crK2t4erqirCwMMydOxcNGjRAgwYNMHfuXJiYmGDQoEEAAEtLS4wYMQITJ06EjY0NrK2tMWnSJHh6ekpP9RAREdGrrdwB5fTp0/Dz85Neh4eHAwBCQkIQExODyZMnIycnB2PGjMH9+/fRtm1b7Nu3D+bm5tI8CxYsgL6+Pvr164ecnBz4+/sjJiYGenp6FbBJREREVNUphBBC10WUV2ZmJiwtLZGRkQELCwtdl0PPqap2ib/KivNzkbKgLwDA5cPNqGForOOK6EXxEg+9TOV5/+Zv8RAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkewwoBAREZHsMKAQERGR7DCgEBERkezoV/QCIyMjMXPmTLVx9vb2SEtLAwAIITBz5kz88MMPuH//Ptq2bYtvv/0WTZs2rehSXinuU3frugQiIqIKUyk9KE2bNkVqaqo0nD9/XpoWHR2N+fPnY/HixUhISICDgwMCAwPx8OHDyiiFiIiIqqBKCSj6+vpwcHCQhlq1agF43HuycOFCzJgxA71794aHhwdWrVqFR48eYf369ZVRChEREVVBlRJQrl27BicnJ9SpUwcDBgzAX3/9BQBISkpCWloagoKCpLZGRkbw9fXFsWPHSlxeXl4eMjMz1QYiIiKqvio8oLRt2xarV6/G3r178eOPPyItLQ0+Pj64e/eudB+Kvb292jxP3qOiTVRUFCwtLaXBxcWlossmIiIiGanwgNKlSxf06dMHnp6eCAgIwO7dj2/eXLVqldRGoVCozSOE0Bj3pGnTpiEjI0MaUlJSKrpsIiIikpFKf8zY1NQUnp6euHbtGhwcHABAo7ckPT1do1flSUZGRrCwsFAbiIiIqPqq9ICSl5eHS5cuwdHREXXq1IGDgwPi4uKk6fn5+YiPj4ePj09ll0JERERVRIV/D8qkSZPQo0cPuLq6Ij09HZ999hkyMzMREhIChUKBsLAwzJ07Fw0aNECDBg0wd+5cmJiYYNCgQRVdChEREVVRFR5Qbt68iYEDB+LOnTuoVasWvLy8cOLECbi5uQEAJk+ejJycHIwZM0b6orZ9+/bB3Ny8okshIiKiKqrCA8rGjRufOV2hUCAyMhKRkZEVvWoiIiKqJvhbPERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7+rougIiIdMd96m5dl1BuyZ9303UJ9BKwB4WIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkhwGFiIiIZIcBhYiIiGSHAYWIiIhkR1/XBciR+9Tdui6BiIjolcYeFCIiIpIdBhQiIiKSHV7iISKiKqUqXoZP/rybrkuoctiDQkRERLLDgEJERESyw4BCREREssOAQkRERLLDgEJERESyw4BCREREssOAQkRERLLDgEJERESyw4BCREREssOAQkRERLLDgEJERESyw4BCREREssOAQkRERLLDgEJERESyo9OAsmTJEtSpUwfGxsZo1aoVjhw5ostyiIiISCZ0FlBiY2MRFhaGGTNm4OzZs3jzzTfRpUsX3LhxQ1clERERkUzoLKDMnz8fI0aMwMiRI9G4cWMsXLgQLi4uWLp0qa5KIiIiIpnQ18VK8/PzcebMGUydOlVtfFBQEI4dO6bRPi8vD3l5edLrjIwMAEBmZmal1Fec96hSlktU1RXn5/7v33mPAFGsw2qIqg7XDzfpuoRyS5wZXOHLVL1vCyFKbauTgHLnzh0UFRXB3t5ebby9vT3S0tI02kdFRWHmzJka411cXCqtRiJ6tn+WDNV1CURUiSwXVt6yHz58CEtLy2e20UlAUVEoFGqvhRAa4wBg2rRpCA8Pl14XFxfj3r17sLGx0dpejjIzM+Hi4oKUlBRYWFjoupxXDve/bnH/6x6PgW5x/z8mhMDDhw/h5ORUaludBBRbW1vo6elp9Jakp6dr9KoAgJGREYyMjNTG1axZszJLrDQWFhav9Mmpa9z/usX9r3s8BrrF/Y9Se05UdHKTrKGhIVq1aoW4uDi18XFxcfDx8dFFSURERCQjOrvEEx4ejiFDhqB169bw9vbGDz/8gBs3bmD06NG6KomIiIhkQmcBpX///rh79y5mzZqF1NRUeHh44JdffoGbm5uuSqpURkZGiIiI0LhURS8H979ucf/rHo+BbnH/l59ClOVZHyIiIqKXiL/FQ0RERLLDgEJERESyw4BCREREssOAQkRERLLDgEJERESyw4BSQZYsWYI6derA2NgYrVq1wpEjR57Zft26dWjevDlMTEzg6OiI4cOH4+7duy+p2uqpvMfg22+/RePGjaFUKvHaa69h9erVL6nS6ufw4cPo0aMHnJycoFAosH379lLniY+PR6tWrWBsbIy6deviu+++q/xCq6ny7v/U1FQMGjQIr732GmrUqIGwsLCXUmd1Vt5jsHXrVgQGBqJWrVqwsLCAt7c39u7d+3KKrSIYUCpAbGwswsLCMGPGDJw9exZvvvkmunTpghs3bmhtf/ToUQwdOhQjRozAhQsXsGnTJiQkJGDkyJEvufLqo7zHYOnSpZg2bRoiIyNx4cIFzJw5E2PHjsXOnTtfcuXVQ3Z2Npo3b47FixeXqX1SUhK6du2KN998E2fPnsX06dMxYcIEbNmypZIrrZ7Ku//z8vJQq1YtzJgxA82bN6/k6l4N5T0Ghw8fRmBgIH755RecOXMGfn5+6NGjB86ePVvJlVYhgl5YmzZtxOjRo9XGNWrUSEydOlVr+y+//FLUrVtXbdw333wjnJ2dK63G6q68x8Db21tMmjRJbdwHH3wg2rVrV2k1vioAiG3btj2zzeTJk0WjRo3Uxo0aNUp4eXlVYmWvhrLs/yf5+vqKDz74oNLqeRWV9xioNGnSRMycObPiC6qi2IPygvLz83HmzBkEBQWpjQ8KCsKxY8e0zuPj44ObN2/il19+gRAC//77LzZv3oxu3bq9jJKrnec5Bnl5eTA2NlYbp1QqcerUKRQUFFRarfTY8ePHNY5XcHAwTp8+zf1Pr6Ti4mI8fPgQ1tbWui5FNhhQXtCdO3dQVFSk8SvM9vb2Gr/WrOLj44N169ahf//+MDQ0hIODA2rWrIlFixa9jJKrnec5BsHBwVi2bBnOnDkDIQROnz6NFStWoKCgAHfu3HkZZb/S0tLStB6vwsJC7n96Jc2bNw/Z2dno16+frkuRDQaUCqJQKNReCyE0xqlcvHgREyZMwKeffoozZ85gz549SEpK4g8lvqDyHINPPvkEXbp0gZeXFwwMDPDWW29h2LBhAAA9Pb3KLpWg/XhpG09U3W3YsAGRkZGIjY2FnZ2drsuRDQaUF2Rraws9PT2NT+rp6ekanxBVoqKi0K5dO3z00Udo1qwZgoODsWTJEqxYsQKpqakvo+xq5XmOgVKpxIoVK/Do0SMkJyfjxo0bcHd3h7m5OWxtbV9G2a80BwcHrcdLX18fNjY2OqqK6OWLjY3FiBEj8NNPPyEgIEDX5cgKA8oLMjQ0RKtWrRAXF6c2Pi4uDj4+PlrnefToEWrUUN/1qk/tgr/dWG7PcwxUDAwM4OzsDD09PWzcuBHdu3fXODZU8by9vTWO1759+9C6dWsYGBjoqCqil2vDhg0YNmwY1q9fz3sQtdDXdQHVQXh4OIYMGYLWrVvD29sbP/zwA27cuCFdspk2bRr++ecf6Xs2evTogffeew9Lly5FcHAwUlNTERYWhjZt2sDJyUmXm1JllfcYXL16FadOnULbtm1x//59zJ8/H4mJiVi1apUuN6PKysrKwvXr16XXSUlJOHfuHKytreHq6qqx/0ePHo3FixcjPDwc7733Ho4fP47ly5djw4YNutqEKq28+x8Azp07J817+/ZtnDt3DoaGhmjSpMnLLr9aKO8x2LBhA4YOHYqvv/4aXl5eUo+iUqmEpaWlTrZBdnT5CFF18u233wo3NzdhaGgoXn/9dREfHy9NCwkJEb6+vmrtv/nmG9GkSROhVCqFo6OjGDx4sLh58+ZLrrp6Kc8xuHjxomjRooVQKpXCwsJCvPXWW+Ly5cs6qLp6OHjwoACgMYSEhAghtP8fOHTokGjZsqUwNDQU7u7uYunSpS+/8Griefa/tvZubm4vvfbqorzHwNfX95ntSQiFELymQERERPLCi+1EREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDsMKERERCQ7DChEREQkOwwoREREJDv/DxdZ6XiuGN3iAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we can calculate the distribution of the RMSE of 0 and f resampled over member\n",
    "xs.rmse(f_r, xr.zeros_like(f_r), dim=\"iteration\").plot.hist(label=\"resampled RMSE distribution\")\n",
    "# the gaussian distribution should have an RMSE with 0 of one\n",
    "plt.axvline(x=xs.rmse(f, xr.zeros_like(f)), c=\"k\", label=\"RMSE\")\n",
    "plt.title(\"RMSE between gaussian distribution and 0\")\n",
    "plt.legend()"
   ]
  }
 ],
 "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}