Repository: RUrlus/ModelMetricUncertainty (language: python)

Issue:
[ENH] Add Multivariate-Normal - Possion uncertainty
Add Max's elliptical uncertainty on two metrics.

- [x] Port Python implementation for Recall-Precision to C++
- [x] Python bindings
- [x] Unit tests


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index 632c1c7..bd19351 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -8,12 +8,13 @@ on:
   workflow_dispatch:
   pull_request:
     branches:
-      - main
+      - stable
       - unstable
   push:
     branches:
-      - main
-      - unstable
+      - stable
+  schedule:
+    - cron: '0 23 * * 1'
 
 jobs:
   pre_job:
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index aa9d79d..287ade6 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -8,12 +8,13 @@ on:
   workflow_dispatch:
   pull_request:
     branches:
-      - main
+      - stable
       - unstable
   push:
     branches:
-      - main
-      - unstable
+      - stable
+  schedule:
+    - cron: '0 23 * * 1'
 
 jobs:
   pre_job:
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index cb8ed25..ed3db5c 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -5,6 +5,12 @@ on:
   release:
     types:
       - published
+  pull_request:
+    branches:
+      - stable
+  push:
+    branches:
+      - stable
 
 jobs:
   build_sdist:
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index fadbdbd..a1af744 100644
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -8,12 +8,13 @@ on:
   workflow_dispatch:
   pull_request:
     branches:
-      - main
+      - stable
       - unstable
   push:
     branches:
-      - main
-      - unstable
+      - stable
+  schedule:
+    - cron: '0 23 * * 1'
 
 jobs:
   pre_job:
diff --git a/README.rst b/README.rst
index 7a0b658..aadafbc 100644
--- a/README.rst
+++ b/README.rst
@@ -2,9 +2,25 @@
 Model-Metric-Uncertainty (MMU)
 ==============================
 
-**Model-Metric-Uncertainty (MMU) is a library for the evaluation of model performance and estimation of the uncertainty on these metrics.**
+.. image:: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/macos.yml/badge.svg?branch=stable
+    :target: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/macos.yml
+    :alt: MacOS build
+.. image:: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/linux.yml/badge.svg?branch=stable
+    :target: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/linux.yml
+    :alt: Linux build
+.. image:: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/windows.yml/badge.svg?branch=stable
+    :target: https://github.com/RUrlus/ModelMetricUncertainty/actions/workflows/windows.yml
+    :alt: Windows build
+.. image:: https://readthedocs.org/projects/mmu/badge/?version=latest
+    :target: https://mmu.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation
+.. image:: https://img.shields.io/github/license/RUrlus/modelmetricuncertainty
+    :target: https://github.com/RUrlus/carma/blob/stable/LICENSE
+    :alt: License
+
+`Documentation <https://mmu.readthedocs.io/en/latest/>`_
 
-We currently focus on binary classification models but aim to include support for other types of models and their metrics in the future.
+**Model-Metric-Uncertainty (MMU) is a library for the evaluation of model performance and estimation of the uncertainty on these metrics.**
 
 Functionality
 -------------
@@ -14,6 +30,8 @@ On a high level ``MMU`` provides two types of functionality:
 * **Metrics** - functions to compute confusion matrix(ces) and binary classification metrics over classifier scores or predictions.
 * **Uncertainty estimators** - functionality to compute the joint uncertainty over classification metrics.
 
+We currently focus on binary classification models but aim to include support for other types of models and their metrics in the future.
+
 Confusion Matrix & Metrics
 **************************
 
@@ -77,7 +95,7 @@ Usage
     scores, y, yhat = mmu.generate_data(n_samples=1000)
 
     # Compute the joint uncertainty on precision and recall
-    pr_err = mmu.PrecisionRecallCurveMultinomialUncertainty.from_scores(y, scores, 0.85)
+    pr_err = mmu.PrecisionRecallCurveUncertainty.from_scores(y, scores, 0.85)
     
     # Plot the uncertainty
     pr_err.plot()
diff --git a/docs/source/basics.rst b/docs/source/basics.rst
index c9026ba..89598dd 100644
--- a/docs/source/basics.rst
+++ b/docs/source/basics.rst
@@ -135,7 +135,7 @@ The following class methods are provided:
 - ``from_confusion_matrix``
 - ``from_classifier``
 
-For example ``pr_err = mmu.PRMU.from_scores(y, scores, threshold=0.82)``.
+For example ``pr_err = mmu.PRU.from_scores(y, scores, threshold=0.82)``.
 
 Precision-Recall
 ****************
@@ -158,6 +158,8 @@ The Multinomial approach computes the profile log-likelihoods scores for a grid
 The Multinomial approach is usually robust for relatively low statistics tests.
 Additionally it is valid for the extreme values of precision and recall, which the Bivariate-Normal approach is not. However, the Multinomial approach does not allow the statistical uncertainty of the train set to be incorporated which the Bivariate-Normal does.
 
+The multinomial approach is the default approach.
+
 .. code-block:: python3
 
     import mmu
@@ -166,8 +168,8 @@ Additionally it is valid for the extreme values of precision and recall, which t
     # note that scores and y now have shape (1000, 30)
     scores, yhat, y = mmu.generate_data(n_samples=1000)
 
-    # mmu.PRMU is an alias
-    pr_err = mmu.PrecisionRecallMultinomialUncertainty.from_scores(y, scores, 0.85)
+    # mmu.PRU is an alias
+    pr_err = mmu.PrecisionRecallUncertainty.from_scores(y, scores, 0.85)
 
     # get the confusion matrix as a DataFrame
     pr_err.get_conf_mat()
@@ -187,8 +189,8 @@ we compute them with :func:`mmu.auto_thresholds`.
 
 .. code-block:: python3
 
-    # PRCMU is an alias of PrecisionRecallCurveMultinomialUncertainty
-    pr_err_curve = mmu.PRCMU.from_scores(y, scores)
+    # PRCU is an alias of PrecisionRecallCurveUncertainty
+    pr_err_curve = mmu.PRCU.from_scores(y, scores)
 
     # we add the threshold uncertainty using point_uncertainty argument
     ax = pr_err.plot(point_uncertainty=pr_err)
@@ -197,7 +199,7 @@ we compute them with :func:`mmu.auto_thresholds`.
   :width: 800
   :alt: Uncertainty on the Precision-Recall curve
 
-See :class:`mmu.PrecisionRecallMultinomialUncertainty` and :class:`mmu.PrecisionRecallCurveMultinomialUncertainty` for details.
+See :class:`mmu.PrecisionRecallUncertainty` and :class:`mmu.PrecisionRecallUncertainty` for details.
 
 Bivariate-Normal approach
 +++++++++++++++++++++++++
@@ -209,8 +211,8 @@ The curve uncertainty computes chi2 scores in a similar manner to Multinomial ap
 
 Note that the Bivariate-Normal (Elliptical) approach is only valid for medium to high statistic datasets. A warning is raised when the Normal approximation to the Binomial may not be valid. Additionally, the estimation is not valid for the extremes of precision/recall. However, the train set uncertainty can be added to the test uncertainty.
 
-The bivariate threshold/point uncertainty can be computed using the same API as
-the multinomial uncertainty.
+The bivariate threshold/point uncertainty can be computed using setting
+``method`` to one of: ``'bivariate'``, ``'bvn'`` or , ``'elliptical'``.
 
 .. code-block:: python3
 
@@ -220,10 +222,10 @@ the multinomial uncertainty.
     # note that scores and y now have shape (1000, 30)
     scores, yhat, y = mmu.generate_data(n_samples=1000)
 
-    # mmu.PREU is an alias
-    pr_err = mmu.PrecisionRecallEllipticalUncertainty.from_scores(y, scores, 0.85)
+    # mmu.PRU is an alias
+    pr_err = mmu.PrecisionRecallUncertainty.from_scores(y, scores, 0.85, method='bvn')
 
-    # PRCEU is an alias of PrecisionRecallCurveEllipticalUncertainty
-    pr_err_curve = mmu.PRCEU.from_scores(y, scores, 0.85)
+    # PRCU is an alias of PrecisionRecallCurveUncertainty
+    pr_err_curve = mmu.PRCU.from_scores(y, scores, method='bvn')
 
-See :class:`mmu.PrecisionRecallEllipticalUncertainty` and :class:`mmu.PrecisionRecallCurveMultinomialUncertainty` for details.
+See :class:`mmu.PrecisionRecallUncertainty` and :class:`mmu.PrecisionRecallCurveUncertainty` for details.
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 1b607a8..d15cd67 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -11,6 +11,18 @@
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 import os
 import sys
+import pathlib
+
+readme_path = (
+    pathlib.Path(__file__)
+    .parent.resolve()
+    .parent.resolve()
+    .parent.joinpath("README.rst")
+)
+readme_target = pathlib.Path(__file__).parent.joinpath("readme.rst")
+with readme_target.open("w") as outf:
+    outf.write(readme_path.read_text())
+
 sys.path.insert(0, os.path.abspath('../..'))
 sys.setrecursionlimit(1500)
 
@@ -47,7 +59,6 @@
 # This pattern also affects html_static_path and html_extra_path.
 exclude_patterns = []
 
-
 # -- Options for HTML output -------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
diff --git a/docs/source/contents.rst b/docs/source/contents.rst
index 1ea9c03..11d2fd6 100644
--- a/docs/source/contents.rst
+++ b/docs/source/contents.rst
@@ -26,5 +26,4 @@ Model Metric Uncertainty
     :maxdepth: 2
 
     contributing
-    extconfig
     extension
diff --git a/docs/source/contributing.rst b/docs/source/contributing.rst
index df0794a..2b0dc37 100644
--- a/docs/source/contributing.rst
+++ b/docs/source/contributing.rst
@@ -1,22 +1,36 @@
 Contributing
 ------------
 
-We very much welcome contributions, contributing please make sure to follow the below conventions.
+We very much welcome contributions.
+Before starting work on a big PR it is always good to check if there is interest
+and or how this would fit with existing development activities.
 
 Installation
 ************
 
-In order to contribute to ``mmu`` you
+In order to contribute to ``mmu`` you have to install the package from source.
 The package can be installed for local development with:
 
 .. code-block:: bash
-
+    
+    git clone https://github.com/RUrlus/ModelMetricUncertainty.git
+    cd modelmetricuncertainty
     pip install -e ..
 
 Note that the C++ extension is (re-)compiled during local installation.
 If you don't have a compiler installed and are not working on the extension the best solution is to download the wheels from PyPi.
 Unzip the version for you system and Python version and copy it to ``mmu/lib/``.
 
+Debug build
++++++++++++
+
+By default we create a CMake ``Release`` build, if you need to create a
+``Debug`` build use:
+
+.. code-block:: bash
+
+   CMAKE_ARGS="CMAKE_BUILD_TYPE=Debug" pip install -e .
+
 Manual compilation
 ++++++++++++++++++
 
@@ -40,6 +54,23 @@ This requires that you have the following pip packages installed:
 * pybind11
 * numpy
 
+Extension specific tests
+++++++++++++++++++++++++
+
+The library contains unit tests for the internals of the C++ extension.
+For example, unit tests of the functions in ``include/mmu/numpy.hpp``.
+These are specific tests that have their own extension which can be build using:
+
+.. code-block:: bash
+
+   CMAKE_ARGS="-DMMU_ENABLE_INTERNAL_TESTS=ON" pip install -e .
+
+This will place ``_mmu_core_tests`` extension in ``mmu/lib``.
+You can run the tests with
+
+.. code-block:: bash
+
+   pytest tests/internal
 
 Testing
 *******
@@ -52,13 +83,36 @@ MMU's test suite can than be run with:
    pytest 
 
 This will run both the API tests and the internal tests.
-The internal tests are 
+In order to run the internal tests you need to have compiled the test extension.
+Please see :ref:`Extension Specific Tests` for details.
+
+If you have not build the extension tests, you can test the API tests with:
+
+.. code-block:: bash
+
+   cd tests
+   pytest api
 
+CICD
+++++
+
+There are a number of Github Actions that are triggered on pull requests:
+
+- Windows - Python 3.7 - 3.10
+- Linux - Python 3.7 - 3.10
+- MacOS - Python 3.7 - 3.10
+- Valgrind
+- Asan
+
+A lighter Build & Test pipeline is run on each push, this should help you check
+compatibility across the platforms.
+Valgrind and Asan are only relevant if you have touched the C++ extension and
+can be largely ignored otherwise.
 
 Conventions
 ***********
 
-Carma
+We have a few conventions that we would like you to adhere to.
 
 Pull requests
 +++++++++++++
@@ -74,14 +128,14 @@ Commits
 
 Please prepend your commit messages with:
 
-* ``ENH: `` the commit introduces new functionality
-* ``CHG: `` the commit changes existing functionality
-* ``FIX: `` the commit fixes incorrect behaviour of existing functionality
-* ``STY: `` the commit improves the readability of the code but not the functioning of the code
-* ``DOC: `` the commit only relates to the documentation
-* ``TST: `` the commit only relates to the tests
-* ``BLD: `` changes related to setup files or build instructions (``BLD: [CPP] ...``)
-* ``CICD: `` the commit only relates to the CI/CD templates
+* ``ENH:`` the commit introduces new functionality
+* ``CHG:`` the commit changes existing functionality
+* ``FIX:`` the commit fixes incorrect behaviour of existing functionality
+* ``STY:`` the commit improves the readability of the code but not the functioning of the code
+* ``DOC:`` the commit only relates to the documentation
+* ``TST:`` the commit only relates to the tests
+* ``BLD:`` changes related to setup files or build instructions (``BLD: [CPP] ...``)
+* ``CICD:`` the commit only relates to the CI/CD templates
 
 Additionally use ``[CPP]`` after the prefix when your commit touches C++ code or build instructions.
 
@@ -91,5 +145,12 @@ Clang format
 ++++++++++++
 
 If your contribution touches C++ code, please run clang-format.
-The format is specified by the ``.clang-format`` file at the root of the repo.
-It should be picked up automatically.
+The format is specified by the ``.clang-format`` file at the root of the repo, it should be picked up automatically.
+For example:
+
+.. code-block::
+
+   clang-format -i include/mmu/core/*.hpp
+
+.. _pybind11: https://pybind11.readthedocs.io/en/stable/#
+.. _scikit-build: https://scikit-build.readthedocs.io/en/latest/index.html
diff --git a/docs/source/estimators.rst b/docs/source/estimators.rst
index 712d875..52f82ac 100644
--- a/docs/source/estimators.rst
+++ b/docs/source/estimators.rst
@@ -13,7 +13,6 @@ The Multinomial approach computes the profile log-likelihoods scores for a grid
 The Multinomial approach is usually robust for relatively low statistics tests.
 Additionally it is valid for the extreme values of precision and recall, which the Bivariate-Normal approach is not. However, the Multinomial approach does not allow the statistical uncertainty of the train set to be incorporated which the Bivariate-Normal does.
 
-
 **Bivariate-Normal approach**
 
 The statistical/sampling uncertainty over the Precision and Recall are modelled
@@ -34,45 +33,21 @@ To help with this the curve methods provide functionality to overlay threshold u
 Threshold
 +++++++++
 
-**Multinomial uncertainty**
-
-.. autoclass:: mmu.PRMU
-    :members:
-    :inherited-members:
-
-.. autoclass:: mmu.PrecisionRecallMultinomialUncertainty
-    :members:
-    :inherited-members:
-
-**Elliptical uncertainty**
-
-.. autoclass:: mmu.PREU
+.. autoclass:: mmu.PRU
     :members:
     :inherited-members:
 
-.. autoclass:: mmu.PrecisionRecallEllipticalUncertainty
+.. autoclass:: mmu.PrecisionRecallUncertainty
     :members:
     :inherited-members:
 
 Curve
 +++++
 
-**Multinomial uncertainty**
-
-.. autoclass:: mmu.PRCMU
-    :members:
-    :inherited-members:
-
-.. autoclass:: mmu.PrecisionRecallCurveMultinomialUncertainty
-    :members:
-    :inherited-members:
-
-**Elliptical uncertainty**
-
-.. autoclass:: mmu.PRCEU
+.. autoclass:: mmu.PRCU
     :members:
     :inherited-members:
 
-.. autoclass:: mmu.PrecisionRecallCurveEllipticalUncertainty
+.. autoclass:: mmu.PrecisionRecallCurveUncertainty
     :members:
     :inherited-members:
diff --git a/docs/source/extconfig.rst b/docs/source/extconfig.rst
deleted file mode 100644
index 39220c0..0000000
--- a/docs/source/extconfig.rst
+++ /dev/null
@@ -1,69 +0,0 @@
-.. role:: bash(code)
-   :language: bash
-
-`MMU` relies on a C++ extension for the computationally intensive routines or
-those that will be called over many items.
-
-Build configuration
--------------------
-
-The extension is wrapped using Pybind11_ and requires a compiler with support for C++14.
-The compilation of the extension is triggered by the ``setup.py`` using Scikit-Build_.
-We provide wheels for all major OS's, architectures and CPython versions, hence building from source should be uncommon for users.
-If you encounter an issue please rerun the installation with verbose mode on,
-``pip install mmu -v``, and create an `issue <https://github.com/RUrlus/ModelMetricUncertainty/issues>`_ with the output.
-
-Debug build
-+++++++++++
-
-By default we create a CMake ``Release`` build, if you need to create a
-``Debug`` build use:
-
-.. code-block:: bash
-
-   CMAKE_ARGS="CMAKE_BUILD_TYPE=Debug" pip install -e .
-
-Independent build
-+++++++++++++++++
-
-When you are working on the extension, it can be beneficial to compile the
-extension directly rather than through ``setup.py``.
-Unfortunately building through the ``setup.py`` does not allow for incremental
-builds.
-
-If you have not installed the package in develop/editable mode, you should do so
-first. Also make sure you have all the build requirements installed in your virtual
-environment, these can be found in ``pyproject.toml`` file.
-
-.. code-block:: bash
-
-    cmake -S . -G Ninja -B mbuild \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DMMU_ENABLE_INTERNAL_TESTS=ON \
-        -DMMU_DEV_MODE=ON \
-        -DPython3_EXECUTABLE=$(python3 -c 'import sys; print(sys.executable)') \
-        -Dpybind11_DIR=$(python3 -c 'import pybind11; print(pybind11.get_cmake_dir())') \
-        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON
-    
-    cmake --build mbuild --target install --config Release -j 4
-
-Extension specific tests
-++++++++++++++++++++++++
-
-The library contains unit tests for the internals of the C++ extension.
-For example, unit tests of the functions in ``include/mmu/numpy.hpp``.
-These are specific tests that have their own extension which can be build using:
-
-.. code-block:: bash
-
-   CMAKE_ARGS="-DMMU_ENABLE_INTERNAL_TESTS=ON" pip install -e .
-
-This will place ``_mmu_core_tests`` extension in ``mmu/lib``.
-You can run the tests with
-
-.. code-block:: bash
-
-   pytest tests/internal
-
-.. _pybind11: https://pybind11.readthedocs.io/en/stable/#
-.. _scikit-build: https://scikit-build.readthedocs.io/en/latest/index.html
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 40dc85a..e34f99c 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -6,4 +6,6 @@ MMU - Model Metric Uncertainty
   :width: 1000
   :alt: Uncertainty on the Precision-Recall curve
 
-.. include:: ../../readme.rst
+.. only:: latex
+
+.. include:: readme.rst
diff --git a/mmu/__init__.py b/mmu/__init__.py
index 571d5a2..bccb237 100644
--- a/mmu/__init__.py
+++ b/mmu/__init__.py
@@ -39,14 +39,10 @@
 
 pr_curve = precision_recall_curve
 
-from mmu.methods import PREU
-from mmu.methods import PRMU
-from mmu.methods import PRCMU
-from mmu.methods import PRCEU
-from mmu.methods import PrecisionRecallEllipticalUncertainty
-from mmu.methods import PrecisionRecallMultinomialUncertainty
-from mmu.methods import PrecisionRecallCurveMultinomialUncertainty
-from mmu.methods import PrecisionRecallCurveEllipticalUncertainty
+from mmu.methods import PRU
+from mmu.methods import PRCU
+from mmu.methods import PrecisionRecallUncertainty
+from mmu.methods import PrecisionRecallCurveUncertainty
 
 from mmu.commons.utils import generate_data
 
@@ -72,14 +68,10 @@
     'pr_curve',
     'precision_recall_curve',
     # classes
-    'PREU',
-    'PRMU',
-    'PRCMU',
-    'PRCEU',
-    'PrecisionRecallEllipticalUncertainty',
-    'PrecisionRecallMultinomialUncertainty',
-    'PrecisionRecallCurveMultinomialUncertainty',
-    'PrecisionRecallCurveEllipticalUncertainty',
+    'PRU',
+    'PRCU',
+    'PrecisionRecallUncertainty',
+    'PrecisionRecallCurveUncertainty',
     # modules
     'metrics',
     'methods',
diff --git a/mmu/methods/__init__.py b/mmu/methods/__init__.py
index 00f34ac..53fa0b0 100644
--- a/mmu/methods/__init__.py
+++ b/mmu/methods/__init__.py
@@ -1,19 +1,12 @@
-from mmu.methods.prpoint import PrecisionRecallEllipticalUncertainty
-from mmu.methods.prpoint import PrecisionRecallMultinomialUncertainty
-from mmu.methods.prcurve import PrecisionRecallCurveMultinomialUncertainty
-from mmu.methods.prcurve import PrecisionRecallCurveEllipticalUncertainty
+from mmu.methods.prpoint import PrecisionRecallUncertainty
+from mmu.methods.prcurve import PrecisionRecallCurveUncertainty
 
-PREU = PrecisionRecallEllipticalUncertainty
-PRMU = PrecisionRecallMultinomialUncertainty
-PRCMU = PrecisionRecallCurveMultinomialUncertainty
-PRCEU = PrecisionRecallCurveEllipticalUncertainty
+PRU = PrecisionRecallUncertainty
+PRCU = PrecisionRecallCurveUncertainty
 
 __all__ = [
-    'PREU',
-    'PRMU',
-    'PRCMU',
-    'PRCEU',
-    'PrecisionRecallEllipticalUncertainty',
-    'PrecisionRecallMultinomialUncertainty',
-    'PrecisionRecallCurveMultinomialUncertainty',
+    'PRU',
+    'PRCU',
+    'PrecisionRecallUncertainty',
+    'PrecisionRecallCurveUncertainty',
 ]
diff --git a/mmu/methods/prcurve.py b/mmu/methods/prcurve.py
index 7379601..05ac9d3 100644
--- a/mmu/methods/prcurve.py
+++ b/mmu/methods/prcurve.py
@@ -13,7 +13,7 @@
 from mmu.metrics.confmat import confusion_matrices_to_dataframe
 from mmu.viz.contours import _plot_pr_curve_contours
 from mmu.lib import MMU_MT_SUPPORT as _MMU_MT_SUPPORT
-from mmu.methods.prpoint import PointUncertainty
+from mmu.methods.prpoint import PrecisionRecallUncertainty
 
 import mmu.lib._mmu_core as _core
 from mmu.lib._mmu_core import (
@@ -26,15 +26,171 @@
         mvn_uncertainty_over_grid_thresholds_mt as mvn_error_grid_thresh_mt,
     )
 
-class _PrecisionRecallCurveBase:
+class PrecisionRecallCurveUncertainty:
+    """Compute joint uncertainty Precision-Recall curve.
+
+    The joint statistical uncertainty can be computed using:
+
+    Multinomial method:
+
+    Model's the uncertainty using profile log-likelihoods between
+    the observed and most conservative confusion matrix for that
+    precision recall. Unlike the Bivariate-Normal/Elliptical approach,
+    this approach is valid for relatively low statistic samples and
+    at the edges of the curve. However, it does not allow one to
+    add the training sample uncertainty to it.
+
+    Bivariate Normal / Elliptical method:
+
+    Model's the linearly propogated errors of the confusion matrix as a
+    bivariate Normal distribution. Note that this method is not valid
+    for low statistic sets or for precision/recall close to 1.0/0.0.
+    In these scenarios the Multinomial method should be used.
+
+    Attributes
+    ----------
+    conf_mat : np.ndarray[int64]
+        the confusion_matrices over the thresholds with columns [TN, FP, FN, TP].
+        A DataFrame can be obtained by calling `get_conf_mat`.
+    cov_mats : np.ndarray[float64], optional
+        flattened covariance matrices for each threshold. Not computed when the
+        multinomial approach is used
+    precision : np.ndarray[float64]
+        the Positive Predictive Values aka positive precisions
+    recall : np.ndarray[float64]
+        True Positive Rate aka Sensitivity aka positive recall
+    chi2_scores : np.ndarray[float64]
+        the sum of squared z scores which follow a chi2 distribution with
+        two degrees of freedom. Has shape (`n_bins`, `n_bins`) with bounds
+        `precision_bounds` on the y-axis and `recall_bounds` on the x-axis.
+    thresholds : np.ndarray[float64], Optional
+        the inclusive classification/discrimination thresholds used to compute
+        the confusion matrices. Is None when the class is instantiated with
+        `from_confusion_matrices`.
+    rec_grid : np.ndarray[float64]
+        the recall values that where evaluated.
+    prec_grid : np.ndarray[float64]
+        the precision values that where evaluated.
+    n_sigmas : int, float
+        the number of marginal standard deviations used to determine the
+        bounds of the grid which is evaluated for each observed precision and
+        recall.
+    epsilon : float
+        the value used to prevent the bounds from reaching precision/recall
+        1.0/0.0 which would result in NaNs.
+
+    """
+
     def __init__(self):
         self.n_conf_mats = None
         self.conf_mats = None
-        self.chi2_scores = None
         self.precision = None
         self.recall = None
-        self._doc_pref = " "
+        self.chi2_scores = None
+        self.prec_grid = None
+        self.rec_grid = None
+        self.n_sigmas = None
+        self.epsilon = None
         self.thresholds = None
+        self._has_cov = False
+        self._moptions = {
+            'mult': {'mult', 'multinomial'},
+            'bvn': {'bvn', 'bivariate', 'elliptical'}
+        }
+
+    def _compute_bvn_scores(self, n_sigmas, epsilon, n_threads):
+        n_threads = _check_n_threads(n_threads)
+
+        # -- validate n_sigmas arg
+        self._parse_n_sigmas(n_sigmas)
+
+        # -- validate epsilon arg
+        self._parse_epsilon(epsilon)
+
+        # compute precision and recall
+        mtr = _core.pr_curve_mvn_cov(self.conf_mats)
+        self.precision = mtr[:, 0]
+        self.recall = mtr[:, 1]
+        self.cov_mats = mtr[:, 2:]
+
+        # compute scores
+        if _MMU_MT_SUPPORT and n_threads > 1:
+            self.chi2_scores = mvn_error_grid_thresh_mt(
+                n_conf_mats=self.n_conf_mats,
+                precs_grid=self.prec_grid,
+                recs_grid=self.rec_grid,
+                conf_mat=self.conf_mats,
+                n_sigmas=self.n_sigmas,
+                epsilon=self.epsilon,
+                n_threads=n_threads,
+            )
+        elif (n_threads > 1):
+            warnings.warn(
+                "mmu was not compiled with multi-threading enabled,"
+                " ignoring `n_threads`"
+            )
+        else:
+            self.chi2_scores = mvn_error_grid_thresh(
+                n_conf_mats=self.n_conf_mats,
+                precs_grid=self.prec_grid,
+                recs_grid=self.rec_grid,
+                conf_mat=self.conf_mats,
+                n_sigmas=self.n_sigmas,
+                epsilon=self.epsilon,
+            )
+
+    def _compute_multn_scores(self, n_sigmas, epsilon, n_threads):
+        n_threads = _check_n_threads(n_threads)
+
+        # -- validate n_sigmas arg
+        self._parse_n_sigmas(n_sigmas)
+
+        # -- validate epsilon arg
+        self._parse_epsilon(epsilon)
+
+        # compute precision and recall
+        mtr = _core.precision_recall_2d(self.conf_mats)
+        self.precision = mtr[:, 0].copy()
+        self.recall = mtr[:, 1].copy()
+        # compute scores
+        if _MMU_MT_SUPPORT and n_threads > 1:
+            self.chi2_scores = mult_error_grid_thresh_mt(
+                n_conf_mats=self.n_conf_mats,
+                precs_grid=self.prec_grid,
+                recs_grid=self.rec_grid,
+                conf_mat=self.conf_mats,
+                n_sigmas=self.n_sigmas,
+                epsilon=self.epsilon,
+                n_threads=n_threads,
+            )
+        elif (n_threads > 1):
+            warnings.warn(
+                "mmu was not compiled with multi-threading enabled,"
+                " ignoring `n_threads`"
+            )
+        else:
+            self.chi2_scores = mult_error_grid_thresh(
+                n_conf_mats=self.n_conf_mats,
+                precs_grid=self.prec_grid,
+                recs_grid=self.rec_grid,
+                conf_mat=self.conf_mats,
+                n_sigmas=self.n_sigmas,
+                epsilon=self.epsilon,
+            )
+
+    def _parse_method(self, method):
+        if method in self._moptions['mult']:
+            self.method = method
+            self._compute_scores = self._compute_multn_scores
+        elif method in self._moptions['bvn']:
+            self._has_cov = True
+            self.method = method
+            self._compute_scores = self._compute_bvn_scores
+        else:
+            raise ValueError(
+                "``method`` must be one of 'multinomial', 'mult', 'elliptical'"
+                ", 'bivariate', 'bvn'"
+            )
 
     def _parse_thresholds(self, thresholds, scores, max_steps, seed):
         if thresholds is None:
@@ -98,14 +254,12 @@ def _parse_epsilon(self, epsilon):
             raise ValueError("`epsilon` must be  in [1e-15, 0.1]")
         self.epsilon = epsilon
 
-    def _compute_scores(self, *args, **kwargs):
-        raise NotImplementedError
-
     @classmethod
     def from_scores(cls,
         y : np.ndarray,
         scores : np.ndarray,
         thresholds : Optional[np.ndarray] = None,
+        method : str = 'multinomial',
         n_bins : Union[int, Tuple[int], List[int], np.ndarray, None] = 1000,
         n_sigmas : Union[int, float] = 6.0,
         epsilon : float = 1e-12,
@@ -128,6 +282,10 @@ def from_scores(cls,
             determined such that each thresholds results in a different
             confusion matrix. Note that the maximum number of thresholds can
             be set using `max_steps`.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
         n_bins : int, array-like[int], default=1000
             the number of bins in the precision/recall grid for which the
             uncertainty is computed. If an int the `chi2_scores` will be a
@@ -154,6 +312,7 @@ def from_scores(cls,
 
         """
         self = cls()
+        self._parse_method(method)
         self._parse_thresholds(thresholds, scores, auto_max_steps, auto_seed)
         self._parse_nbins(n_bins)
         self.conf_mats = confusion_matrices_thresholds(
@@ -166,6 +325,7 @@ def from_scores(cls,
     @classmethod
     def from_confusion_matrices(cls,
         conf_mats : np.ndarray,
+        method : str = 'multinomial',
         n_bins : Union[int, Tuple[int], List[int], np.ndarray, None] = 1000,
         n_sigmas : Union[int, float] = 6.0,
         epsilon : float = 1e-12,
@@ -180,6 +340,10 @@ def from_confusion_matrices(cls,
             confusion matrix as returned by mmu.confusion_matrix, i.e.
             with layout [0, 0] = TN, [0, 1] = FP, [1, 0] = FN, [1, 1] = TP or
             the flattened equivalent.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
         n_bins : int, array-like[int], default=1000
             the number of bins in the precision/recall grid for which the
             uncertainty is computed. If an int the `chi2_scores` will be a
@@ -200,6 +364,7 @@ def from_confusion_matrices(cls,
 
         """
         self = cls()
+        self._parse_method(method)
         self.conf_mats = check_array(
             conf_mats,
             min_dim=2,
@@ -220,6 +385,7 @@ def from_classifier(cls,
         X : np.ndarray,
         y : np.ndarray,
         thresholds : Optional[np.ndarray] = None,
+        method : str = 'multinomial',
         n_bins : Union[int, Tuple[int], List[int], np.ndarray, None] = 1000,
         n_sigmas : Union[int, float] = 6.0,
         epsilon : float = 1e-12,
@@ -241,6 +407,10 @@ def from_classifier(cls,
         threshold : float, default=0.5
             the classification threshold to which the classifier score is evaluated,
             is inclusive.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
         n_bins : int, array-like[int], default=1000
             the number of bins in the precision/recall grid for which the
             uncertainty is computed. If an int the `chi2_scores` will be a
@@ -267,13 +437,14 @@ def from_classifier(cls,
 
         """
         self = cls()
+        self._parse_method(method)
         if not hasattr(clf, 'predict_proba'):
             raise TypeError("`clf` must have a method `predict_proba`")
         score = clf.predict_proba(X)[:, 1]
         self._parse_thresholds(thresholds, score, auto_max_steps, auto_seed)
         self._parse_nbins(n_bins)
         self.conf_mats = confusion_matrices_thresholds(
-            y=y, score=score, thresholds=self.thresholds
+            y=y, scores=score, thresholds=self.thresholds
         )
         self.n_conf_mats = self.conf_mats.shape[0]
         self._compute_scores(n_sigmas, epsilon, n_threads)
@@ -289,6 +460,33 @@ def get_conf_mats(self) -> pd.DataFrame:
         """
         return confusion_matrices_to_dataframe(self.conf_mats)
 
+    def get_cov_mats(self):
+        """Get the covariance matrices over the thresholds.
+
+        Returns
+        -------
+        cov_df = pd.DataFrame
+            the flattened covariance matrix and the thresholds
+
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
+
+        """
+        if not self._has_cov:
+            raise NotImplementedError(
+                "`cov_mats` are not computed when method is not"
+                " Bivariate-Normal/Elliptical."
+            )
+        cov_df = pd.DataFrame(
+            self.cov_mats,
+            columns=['var_prec', 'cov', 'cov', 'var_rec']
+        )
+        cov_df['thresholds'] = self.thresholds
+        return cov_df
+
+
     def _get_critical_values_std(self, n_std):
         """Compute the critical values for a chi2 with 2df using the continuity
         correction."""
@@ -302,6 +500,10 @@ def _get_critical_values_alpha(self, alphas):
         return sts.chi2.ppf(alphas, 2)
 
     def _add_point_to_plot(self, point, point_kwargs):
+        if not isinstance(point, PrecisionRecallUncertainty):
+            raise TypeError(
+                "``point`` must be PrecisionRecallUncertainty isinstance."
+            )
         if isinstance(point_kwargs, dict):
             if 'cmap' not in point_kwargs:
                 point_kwargs['cmap'] = 'Reds'
@@ -316,7 +518,7 @@ def _add_point_to_plot(self, point, point_kwargs):
         self._ax.legend(handles=self._handles, loc='lower center', fontsize=12)  # type: ignore
 
     def _add_points_to_plot(self, point, point_kwargs):
-        if issubclass(type(point), PointUncertainty):
+        if isinstance(point, PrecisionRecallUncertainty):
             self._add_point_to_plot(point, point_kwargs)
         elif isinstance(point, (list, tuple)):
             if point_kwargs is None:
@@ -327,8 +529,8 @@ def _add_points_to_plot(self, point, point_kwargs):
                 self._add_point_to_plot(p, k)
         else:
             raise TypeError(
-                "`point_uncertainty` must be a subclass of PointUncertainty"
-                " or a list of PointUncertainty's"
+                "``point_uncertainty`` must be a PrecisionRecallUncertainty"
+                " isinstance or a list of PrecisionRecallUncertainty's."
             )
 
     def plot(
@@ -338,8 +540,9 @@ def plot(
         cmap : str = 'Blues',
         equal_aspect : bool = False,
         limit_axis : bool = True,
+        legend_loc : Optional[str] = None,
         alpha : float = 0.8,
-        point_uncertainty : Union[PointUncertainty, List[PointUncertainty], None] = None,
+        point_uncertainty : Union[PrecisionRecallUncertainty, List[PrecisionRecallUncertainty], None] = None,
         point_kwargs : Union[Dict, List[Dict], None] = None
     ):
         """Plot confidence interval(s) for precision and recall
@@ -360,10 +563,11 @@ def plot(
             enforce square axis
         limit_axis : bool, default=True
             allow ax to be limited for optimal CI plot
+        legend_loc : str, default=None
+            location of the legend, default is `lower center`
         alpha : float, defualt=0.8
             opacity value of the contours
-        point_uncertainty : PrecisionRecallMultinomialUncertainty,
-        PrecisionRecallEllipticalUncertainty, List, default=None
+        point_uncertainty : PrecisionRecallUncertainty, List, default=None
             Add a point uncertainty(ies) plot to the curve plot, by default the
             `Reds` cmap is used for the point plot(s).
         point_kwargs : dict, list[dict], default=None
@@ -414,226 +618,25 @@ def plot(
                 "`levels` must be a int, float, array-like or None"
             )
 
+        self.critical_values_plot = levels
+
         self._ax, self._handles = _plot_pr_curve_contours(
-            self.precision,
-            self.recall,
-            self.chi2_scores,
-            self.prec_grid,
-            self.rec_grid,
-            levels,
-            labels,
+            precision=self.precision,
+            recall=self.recall,
+            scores=self.chi2_scores,
+            prec_grid=self.prec_grid,
+            rec_grid=self.rec_grid,
+            levels=levels,
+            labels=labels,
             cmap=cmap,
             ax=ax,
             alpha=alpha,
             equal_aspect=equal_aspect,
             limit_axis=limit_axis,
+            legend_loc=legend_loc
         )
 
         if point_uncertainty is not None:
             self._add_points_to_plot(point_uncertainty, point_kwargs)
 
         return self._ax
-
-
-class PrecisionRecallCurveMultinomialUncertainty(_PrecisionRecallCurveBase):
-    """Precision-Recall curve uncertainty modelled as a Multinomial.
-
-    Model's the uncertainty using profile log-likelihoods between
-    the observed and most conservative confusion matrix for that
-    precision recall. Unlike the PrecisionRecallEllipticalUncertainty
-    this approach is valid for relatively low statistic samples and
-    at the edges of the curve. However, it does not allow one to
-    add the training sample uncertainty to it.
-
-    Attributes
-    ----------
-    conf_mat : np.ndarray[int64]
-        the confusion_matrices over the thresholds with columns [TN, FP, FN, TP].
-        A DataFrame can be obtained by calling `get_conf_mat`.
-    cov_mats : np.ndarray[float64]
-        flattened covariance matrices for each threshold.
-    precision : np.ndarray[float64]
-        the Positive Predictive Values aka positive precisions
-    recall : np.ndarray[float64]
-        True Positive Rate aka Sensitivity aka positive recall
-    chi2_scores : np.ndarray[float64]
-        The profile loglikelihood scores which follow a chi2 distribution with 2DF.
-        Has shape (`n_bins`, `n_bins`) with bounds precision_bounds on the
-        y-axis and recall_bounds on the x-axis
-    thresholds : np.ndarray[float64]
-        the inclusive classification/discrimination thresholds used to compute
-        the confusion matrices
-    rec_grid : np.ndarray[float64]
-        the recall values that where evaluated.
-    prec_grid : np.ndarray[float64]
-        the precision values that where evaluated.
-    n_sigmas : int, float, default=6.0
-        the number of marginal standard deviations used to determine the
-        bounds of the grid which is evaluated for each observed precision and
-        recall.
-    epsilon : float, default=1e-12
-        the value used to prevent the bounds from reaching precision/recall
-        1.0/0.0 which would result in NaNs.
-
-    """
-    def __init__(self):
-        self.n_conf_mats = None
-        self.conf_mats = None
-        self.precision = None
-        self.recall = None
-        self.chi2_scores = None
-        self.prec_grid = None
-        self.rec_grid = None
-        self.n_sigmas = None
-        self.epsilon = None
-        self.thresholds = None
-
-    def _compute_scores(self, n_sigmas, epsilon, n_threads):
-        n_threads = _check_n_threads(n_threads)
-
-        # -- validate n_sigmas arg
-        self._parse_n_sigmas(n_sigmas)
-
-        # -- validate epsilon arg
-        self._parse_epsilon(epsilon)
-
-        # compute precision and recall
-        mtr = _core.precision_recall_2d(self.conf_mats)
-        self.precision = mtr[:, 0].copy()
-        self.recall = mtr[:, 1].copy()
-        # compute scores
-        if _MMU_MT_SUPPORT and n_threads > 1:
-            self.chi2_scores = mult_error_grid_thresh_mt(
-                n_conf_mats=self.n_conf_mats,
-                precs_grid=self.prec_grid,
-                recs_grid=self.rec_grid,
-                conf_mat=self.conf_mats,
-                n_sigmas=self.n_sigmas,
-                epsilon=self.epsilon,
-                n_threads=n_threads,
-            )
-        elif (n_threads > 1):
-            warnings.warn(
-                "mmu was not compiled with multi-threading enabled,"
-                " ignoring `n_threads`"
-            )
-        else:
-            self.chi2_scores = mult_error_grid_thresh(
-                n_conf_mats=self.n_conf_mats,
-                precs_grid=self.prec_grid,
-                recs_grid=self.rec_grid,
-                conf_mat=self.conf_mats,
-                n_sigmas=self.n_sigmas,
-                epsilon=self.epsilon,
-            )
-
-
-class PrecisionRecallCurveEllipticalUncertainty(_PrecisionRecallCurveBase):
-    """Precision-Recall Curve uncertainty modelled as a Bivariate Normal.
-
-    Model's the linearly propogated errors of the confusion matrix as a
-    bivariate Normal distribution. Note that this method is not valid
-    for low statistic sets or for precision/recall close to 1.0/0.0.
-    In these scenarios the `PrecisionRecallCurveMultinomialUncertainty` class
-    should be used.
-
-    Attributes
-    ----------
-    conf_mat : np.ndarray[int64]
-        the confusion_matrices over the thresholds with columns [TN, FP, FN, TP].
-        A DataFrame can be obtained by calling `get_conf_mat`.
-    cov_mats : np.ndarray[float64]
-        flattened covariance matrices for each threshold.
-    precision : np.ndarray[float64]
-        the Positive Predictive Values aka positive precisions
-    recall : np.ndarray[float64]
-        True Positive Rate aka Sensitivity aka positive recall
-    chi2_scores : np.ndarray[float64]
-        the sum of squared z scores which follow a chi2 distribution with
-        two degrees of freedom. Has shape (`n_bins`, `n_bins`) with bounds
-        `precision_bounds` on the y-axis and `recall_bounds` on the x-axis.
-    thresholds : np.ndarray[float64], Optional
-        the inclusive classification/discrimination thresholds used to compute
-        the confusion matrices. Is None when the class is instantiated with
-        `from_confusion_matrices`.
-    rec_grid : np.ndarray[float64]
-        the recall values that where evaluated.
-    prec_grid : np.ndarray[float64]
-        the precision values that where evaluated.
-    n_sigmas : int, float, default=6.0
-        the number of marginal standard deviations used to determine the
-        bounds of the grid which is evaluated for each observed precision and
-        recall.
-    epsilon : float, default=1e-12
-        the value used to prevent the bounds from reaching precision/recall
-        1.0/0.0 which would result in NaNs.
-
-    """
-    def __init__(self):
-        self.n_conf_mats = None
-        self.conf_mats = None
-        self.precision = None
-        self.recall = None
-        self.chi2_scores = None
-        self.prec_grid = None
-        self.rec_grid = None
-        self.n_sigmas = None
-        self.epsilon = None
-        self.thresholds = None
-
-    def get_cov_mats(self):
-        """Get the covariance matrices over the thresholds.
-
-        Returns
-        -------
-        cov_df = pd.DataFrame
-            the flattened covariance matrix and the thresholds
-
-        """
-        cov_df = pd.DataFrame(
-            self.cov_mats,
-            columns=['var_prec', 'cov', 'cov', 'var_rec']
-        )
-        cov_df['thresholds'] = self.thresholds
-        return cov_df
-
-    def _compute_scores(self, n_sigmas, epsilon, n_threads):
-        n_threads = _check_n_threads(n_threads)
-
-        # -- validate n_sigmas arg
-        self._parse_n_sigmas(n_sigmas)
-
-        # -- validate epsilon arg
-        self._parse_epsilon(epsilon)
-
-        # compute precision and recall
-        mtr = _core.pr_curve_mvn_cov(self.conf_mats)
-        self.precision = mtr[:, 0]
-        self.recall = mtr[:, 1]
-        self.cov_mats = mtr[:, 2:]
-
-        # compute scores
-        if _MMU_MT_SUPPORT and n_threads > 1:
-            self.chi2_scores = mvn_error_grid_thresh_mt(
-                n_conf_mats=self.n_conf_mats,
-                precs_grid=self.prec_grid,
-                recs_grid=self.rec_grid,
-                conf_mat=self.conf_mats,
-                n_sigmas=self.n_sigmas,
-                epsilon=self.epsilon,
-                n_threads=n_threads,
-            )
-        elif (n_threads > 1):
-            warnings.warn(
-                "mmu was not compiled with multi-threading enabled,"
-                " ignoring `n_threads`"
-            )
-        else:
-            self.chi2_scores = mvn_error_grid_thresh(
-                n_conf_mats=self.n_conf_mats,
-                precs_grid=self.prec_grid,
-                recs_grid=self.rec_grid,
-                conf_mat=self.conf_mats,
-                n_sigmas=self.n_sigmas,
-                epsilon=self.epsilon,
-            )
diff --git a/mmu/methods/prpoint.py b/mmu/methods/prpoint.py
index 1d95083..b5cd334 100644
--- a/mmu/methods/prpoint.py
+++ b/mmu/methods/prpoint.py
@@ -19,64 +19,26 @@
 import mmu.lib._mmu_core as _core
 
 
-class PointUncertainty:
-    def __init__(self):
-        self.threshold = None
-        self.conf_mat = None
-
-    def _parse_threshold(self, threshold):
-        if not isinstance(threshold, float) or not (0.0 < threshold < 1.0):
-            raise TypeError("`threshold` must be a float in [0, 1]")
-        self.threshold = threshold
-
-    def get_conf_mat(self) -> pd.DataFrame:
-        """Obtain confusion matrix as a DataFrame.
+class PrecisionRecallUncertainty:
+    """Compute joint uncertainty Precision-Recall.
 
-        Returns
-        -------
-        pd.DataFrame
-            the confusion matrix of the test set
-        """
-        return confusion_matrix_to_dataframe(self.conf_mat)
+    The joint statistical uncertainty can be computed using:
 
-    def _add_point_to_plot(self, point, point_kwargs):
-        if isinstance(point_kwargs, dict):
-            if 'cmap' not in point_kwargs:
-                point_kwargs['cmap'] = 'Reds'
-            if 'ax' in point_kwargs:
-                point_kwargs.pop('ax')
-        elif point_kwargs is None:
-            point_kwargs = {'cmap': 'Reds'}
-        else:
-            raise TypeError("`point_kwargs` must be a Dict or None")
-        self._ax = point.plot(ax=self._ax, **point_kwargs)
-        self._handles = self._handles + point._handles
-        self._ax.legend(handles=self._handles, loc='lower left', fontsize=12)  # type: ignore
-    def _add_other_to_plot(self, other, other_kwargs):
-        if issubclass(type(other), PointUncertainty):
-            self._add_point_to_plot(other, other_kwargs)
-        elif isinstance(other, (list, tuple)):
-            if other_kwargs is None:
-                other_kwargs = {}
-            elif isinstance(other_kwargs, dict):
-                other_kwargs = [other_kwargs, ] * len(other)
-            for point, kwargs in zip_longest(other, other_kwargs):
-                self._add_point_to_plot(point, kwargs)
-        else:
-            raise TypeError(
-                "`point_uncertainty` must be a subclass of PointUncertainty"
-                " or a list of PointUncertainty's"
-            )
+    Multinomial method:
 
+    Model's the uncertainty using profile log-likelihoods between
+    the observed and most conservative confusion matrix for that
+    precision-recall. Unlike the Bivariate-Normal/Elliptical approach,
+    this approach is valid for relatively low statistic samples and
+    at the edges of the curve. However, it does not allow one to
+    add the training sample uncertainty to it.
 
-class PrecisionRecallEllipticalUncertainty(PointUncertainty):
-    """Precision-Recall uncertainty modelled as a Bivariate Normal.
+    Bivariate Normal / Elliptical method:
 
     Model's the linearly propogated errors of the confusion matrix as a
     bivariate Normal distribution. Note that this method is not valid
     for low statistic sets or for precision/recall close to 1.0/0.0.
-    In these scenarios the `PrecisionRecallMultinomialUncertainty` class should
-    be used.
+    In these scenarios the Multinomial method should be used.
 
     Attributes
     ----------
@@ -88,27 +50,52 @@ class PrecisionRecallEllipticalUncertainty(PointUncertainty):
         the Positive Predictive Value aka positive precision
     recall : float
         True Positive Rate aka Sensitivity aka positive recall
-    cov_mat : np.ndarray[float64]
-        the covariance matrix of precision and recall with layout
-        [0, 0] = V[P], [0, 1] = COV[P, R], [1, 0] = COV[P, R], [1, 1] = V[R]
-        A DataFrame can be obtained by calling `get_cov_mat`.
     threshold : float, optional
         the inclusive threshold used to determine the confusion matrix.
         Is None when the class is instantiated with `from_predictions` or
         `from_confusion_matrix`.
+    cov_mat : np.ndarray[float64], optional
+        the covariance matrix of precision and recall with layout
+        [0, 0] = V[P], [0, 1] = COV[P, R], [1, 0] = COV[P, R], [1, 1] = V[R]
+        A DataFrame can be obtained by calling `get_cov_mat`.
+        Only set when Elliptical method is used.
     train_conf_mats : np.ndarray, optional
         the confusion matrices from the multiple training runs.
         Only set when `add_train_uncertainty` is called.
         A DataFrame can be obtained by calling `get_train_conf_mats`
+        Only set when Elliptical method is used.
     train_cov_mat : np.ndarray, optional
         the precision, recall covariance matrix from the multiple training runs.
         Only set when `add_train_uncertainty` is called.
         A DataFrame can be obtained by calling `get_train_cov_mat`.
+        Only set when Elliptical method is used.
     total_cov_mat : np.ndarray, optional
         the precision, recall covariance matrix that combines the test and
         training sampling uncertainty.
         Only set when `add_train_uncertainty` is called.
         A DataFrame can be obtained by calling `get_total_cov_mat`.
+        Only set when Elliptical method is used.
+    chi2_scores : np.ndarray[float64], optional
+        the chi2 scores for the grid with shape (`n_bins`, `n_bins`) and
+        bounds precision_bounds on the y-axis, recall_bounds on the x-axis
+        Only set when Multinomial method is used.
+    precision_bounds : np.ndarray[float64], optional
+        the lower and upper bound for which precision was evaluated, equal
+        to precision +- `n_sigmas` * sigma(precision)
+        Only set when Multinomial method is used.
+    recall_bounds : np.ndarray[float64], optional
+        the lower and upper bound for which recall was evaluated, equal
+        to recall +- `n_sigmas` * sigma(recall)
+        Only set when Multinomial method is used.
+    n_sigmas : int, float, optional
+        the number of marginal standard deviations used to determine the
+        bounds of the grid which is evaluated for each observed precision and
+        recall.
+        Only set when Multinomial method is used.
+    epsilon : float, optional
+        the value used to prevent the bounds from reaching precision/recall
+        1.0/0.0 which would result in NaNs.
+        Only set when Multinomial method is used.
 
     """
     def __init__(self):
@@ -119,8 +106,76 @@ def __init__(self):
         self.train_conf_mats = None
         self.train_cov_mat = None
         self.total_cov_mat = None
+        self._bounds = None
+        self.precision_bounds = None
+        self.recall_bounds = None
+        self.chi2_scores = None
+        self.n_bins = None
+        self.n_sigmas = None
+        self.epsilon = None
+        self._has_cov = False
+        self._moptions = {
+            'mult': {'mult', 'multinomial'},
+            'bvn': {'bvn', 'bivariate', 'elliptical'}
+        }
+
+    def _parse_threshold(self, threshold):
+        if not isinstance(threshold, float) or not (0.0 < threshold < 1.0):
+            raise TypeError("`threshold` must be a float in [0, 1]")
+        self.threshold = threshold
+
+    def _parse_method(self, method):
+        if method in self._moptions['mult']:
+            self.method = method
+            self._compute_scores = self._compute_multn_scores
+        elif method in self._moptions['bvn']:
+            self._has_cov = True
+            self.method = method
+            self._compute_scores = self._compute_bvn_scores
+        else:
+            raise ValueError(
+                "``method`` must be one of 'multinomial', 'mult', 'elliptical'"
+                ", 'bivariate', 'bvn'"
+            )
+
+    def _compute_multn_scores(self, n_bins, n_sigmas, epsilon):
+        # -- validate n_bins arg
+        if n_bins is None:
+            self.n_bins = 100
+        elif isinstance(n_bins, int):
+            if n_bins < 1:
+                raise ValueError("`n_bins` must be bigger than 0")
+            self.n_bins = n_bins
+        else:
+            raise TypeError("`n_bins` must be an int")
+
+        # -- validate n_sigmas arg
+        if not isinstance(n_sigmas, (int, float)):
+            raise TypeError("`n_sigmas` must be an int or float.")
+        elif n_sigmas < 1.0:
+            raise ValueError("`n_sigmas` must be greater than 1.")
+        self.n_sigmas = n_sigmas
+
+        # -- validate epsilon arg
+        if not isinstance(epsilon, float):
+            raise TypeError("`epsilon` must be a float")
+        elif not (1e-15 <= epsilon <= 0.1):
+            raise ValueError("`epsilon` must be  in [1e-15, 0.1]")
+        self.epsilon = epsilon
+
+        self.precision, self.recall = _core.precision_recall(self.conf_mat)
+        # compute scores
+        self.chi2_scores, bounds = _core.multinomial_uncertainty(
+            n_bins=self.n_bins,
+            conf_mat=self.conf_mat,
+            n_sigmas=self.n_sigmas,
+            epsilon=self.epsilon
+        )
+        self.precision_bounds = bounds[0, :].copy()
+        self.recall_bounds = bounds[1, :].copy()
+        self._bounds = bounds.flatten()
 
-    def _compute_mvn_cov(self):
+    def _compute_bvn_scores(self, *args, **kwargs):
         out = _core.pr_mvn_cov(self.conf_mat)
         self.precision = out[0]
         if self.precision < 1e-12:
@@ -149,65 +204,106 @@ def _compute_mvn_cov(self):
             )
 
     @classmethod
-    def from_scores(cls, y : np.ndarray, scores : np.ndarray, threshold : float = 0.5):
-        """Compute elliptical uncertainty on precision and recall.
-
-        Model's the linearly propogated errors of the confusion matrix as a
-        bivariate Normal distribution. Note that this method is not valid
-        for low statistic sets or for precision/recall close to 1.0/0.0.
-        In these scenarios the `PrecisionRecallMultinomialUncertainty` class should
-        be used.
+    def from_scores(cls,
+        y : np.ndarray,
+        scores : np.ndarray,
+        threshold : float = 0.5,
+        method : str = 'multinomial',
+        n_bins : int = 100,
+        n_sigmas : Union[int, float] = 6.0,
+        epsilon : float = 1e-12
+    ):
+        """Compute joint-uncertainty on precision and recall.
 
         Parameters
         ----------
-        y : np.ndarray[bool, int32, int64, float32, float64]
-            true labels for the observations
-        scores : np.ndarray[float32, float64], default=None
-            the classifier score to be evaluated against the `threshold`, i.e.
-            `yhat` = `score` >= `threshold`.
+        y : np.ndarray
+            true labels for observations, supported dtypes are [bool, int32,
+            int64, float32, float64]
+        scores : np.ndarray, default=None
+            the classifier scores to be evaluated against the `threshold`, i.e.
+            `yhat` = `scores` >= `threshold`.
+            Supported dtypes are float32 and float64.
         threshold : float, default=0.5
-            the classification threshold to which the classifier score is evaluated,
+            the classification threshold to which the classifier scores are evaluated,
             is inclusive.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
+        n_bins : int, default=100
+            the number of bins in the precision/recall grid for which the
+            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
+            array.
+            Ignored when method is not the Multinomial approach.
+        n_sigmas : int, float, default=6.0
+            the number of marginal standard deviations used to determine the
+            bounds of the grid which is evaluated.
+            Ignored when method is not the Multinomial approach.
+        epsilon : float, default=1e-12
+            the value used to prevent the bounds from reaching precision/recall
+            1.0/0.0 which would result in NaNs.
+            Ignored when method is not the Multinomial approach.
 
         """
         self = cls()
+        self._parse_method(method)
         self._parse_threshold(threshold)
         self.conf_mat = confusion_matrix(y=y, scores=scores, threshold=threshold)
-        self._compute_mvn_cov()
+        self._compute_scores(n_bins, n_sigmas, epsilon)
         return self
 
     @classmethod
-    def from_predictions(cls, y : np.ndarray, yhat : np.ndarray):
-        """Compute elliptical uncertainty on precision and recall.
-
-        Model's the linearly propogated errors of the confusion matrix as a
-        bivariate Normal distribution. Note that this method is not valid
-        for low statistic sets or for precision/recall close to 1.0/0.0.
-        In these scenarios the `PrecisionRecallMultinomialUncertainty` class should
-        be used.
+    def from_predictions(cls,
+        y : np.ndarray,
+        yhat : np.ndarray,
+        method : str = 'multinomial',
+        n_bins : int = 100,
+        n_sigmas : Union[int, float] = 6.0,
+        epsilon : float = 1e-12
+    ):
+        """Compute joint-uncertainty on precision and recall.
 
         Parameters
         ----------
         y : np.ndarray[bool, int32, int64, float32, float64]
-            true labels for the observations
-        yhat : np.ndarray[bool, int32, int64, float32, float64], default=None
+            true labels for observations, supported dtypes are
+        yhat : yhat : np.ndarray[bool, int32, int64, float32, float64], default=None
             the predicted labels, the same dtypes are supported as y.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
+        n_bins : int, default=100
+            the number of bins in the precision/recall grid for which the
+            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
+            array.
+            Ignored when method is not the Multinomial approach.
+        n_sigmas : int, float, default=6.0
+            the number of marginal standard deviations used to determine the
+            bounds of the grid which is evaluated.
+            Ignored when method is not the Multinomial approach.
+        epsilon : float, default=1e-12
+            the value used to prevent the bounds from reaching precision/recall
+            1.0/0.0 which would result in NaNs.
+            Ignored when method is not the Multinomial approach.
 
         """
         self = cls()
+        self._parse_method(method)
         self.conf_mat = confusion_matrix(y=y, yhat=yhat)
-        self._compute_mvn_cov()
+        self._compute_scores(n_bins, n_sigmas, epsilon)
         return self
 
     @classmethod
-    def from_confusion_matrix(cls, conf_mat : np.ndarray):
-        """Compute elliptical uncertainty on precision and recall.
-
-        Model's the linearly propogated errors of the confusion matrix as a
-        bivariate Normal distribution. Note that this method is not valid
-        for low statistic sets or for precision/recall close to 1.0/0.0.
-        In these scenarios the `PrecisionRecallMultinomialUncertainty` class should
-        be used.
+    def from_confusion_matrix(cls,
+        conf_mat : np.ndarray,
+        method : str = 'multinomial',
+        n_bins : int = 100,
+        n_sigmas : Union[int, float] = 6.0,
+        epsilon : float = 1e-12
+    ):
+        """Compute joint-uncertainty on precision and recall.
 
         Parameters
         ----------
@@ -215,13 +311,31 @@ def from_confusion_matrix(cls, conf_mat : np.ndarray):
             confusion matrix as returned by mmu.confusion_matrix, i.e.
             with layout [0, 0] = TN, [0, 1] = FP, [1, 0] = FN, [1, 1] = TP or
             the flattened equivalent. Supported dtypes are int32, int64
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
+        n_bins : int, default=100
+            the number of bins in the precision/recall grid for which the
+            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
+            array.
+            Ignored when method is not the Multinomial approach.
+        n_sigmas : int, float, default=6.0
+            the number of marginal standard deviations used to determine the
+            bounds of the grid which is evaluated.
+            Ignored when method is not the Multinomial approach.
+        epsilon : float, default=1e-12
+            the value used to prevent the bounds from reaching precision/recall
+            1.0/0.0 which would result in NaNs.
+            Ignored when method is not the Multinomial approach.
 
         """
         self = cls()
+        self._parse_method(method)
         if conf_mat.shape == (2, 2):
             conf_mat = conf_mat.ravel()
         self.conf_mat = check_array(conf_mat, max_dim=1, dtype_check=_convert_to_int)
-        self._compute_mvn_cov()
+        self._compute_scores(n_bins, n_sigmas, epsilon)
         return self
 
     @classmethod
@@ -229,15 +343,13 @@ def from_classifier(cls,
         clf,
         X : np.ndarray,
         y : np.ndarray,
-        threshold : float = 0.5
+        threshold : float = 0.5,
+        method : str = 'multinomial',
+        n_bins : int = 100,
+        n_sigmas : Union[int, float] = 6.0,
+        epsilon : float = 1e-12
     ):
-        """Compute elliptical uncertainty on precision and recall.
-
-        Model's the linearly propogated errors of the confusion matrix as a
-        bivariate Normal distribution. Note that this method is not valid
-        for low statistic sets or for precision/recall close to 1.0/0.0.
-        In these scenarios the `PrecisionRecallMultinomialUncertainty` class should
-        be used.
+        """Compute joint-uncertainty on precision and recall.
 
         Parameters
         ----------
@@ -247,31 +359,72 @@ def from_classifier(cls,
         X : np.ndarray
             the feature array to be used to compute the classifier scores
         y : np.ndarray[bool, int32, int64, float32, float64]
-            true labels for the observations
+            true labels for observations
         threshold : float, default=0.5
             the classification threshold to which the classifier score is evaluated,
             is inclusive.
+        method : str, default='multinomial',
+            which method to use, options are the Multinomial approach
+            {'multinomial', 'mult'} or the bivariate-normal/elliptical approach
+            {'bvn', 'bivariate', 'elliptical'}. Default is 'multinomial'.
+        n_bins : int, default=100
+            the number of bins in the precision/recall grid for which the
+            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
+            array.
+            Ignored when method is not the Multinomial approach.
+        n_sigmas : int, float, default=6.0
+            the number of marginal standard deviations used to determine the
+            bounds of the grid which is evaluated.
+            Ignored when method is not the Multinomial approach.
+        epsilon : float, default=1e-12
+            the value used to prevent the bounds from reaching precision/recall
+            1.0/0.0 which would result in NaNs.
+            Ignored when method is not the Multinomial approach.
 
         """
         self = cls()
+        self._parse_method(method)
         self._parse_threshold(threshold)
         if not hasattr(clf, 'predict_proba'):
             raise TypeError("`clf` must have a method `predict_proba`")
         scores = clf.predict_proba(X)[:, 1]
         self.conf_mat = confusion_matrix(y=y, scores=scores, threshold=threshold)
-        self._compute_mvn_cov()
+        self._compute_scores(n_bins, n_sigmas, epsilon)
         return self
 
+    def _get_scaling_factor_alpha(self, alphas):
+        """Compute critical value given a number alphas."""
+        # Get the scale for 2 degrees of freedom confidence interval
+        # We use chi2 because the equation of an ellipse is a sum of squared variable,
+        return np.sqrt(sts.chi2.ppf(alphas, 2))
+
+    def _get_scaling_factor_std(self, stds):
+        alphas = 2. * (sts.norm.cdf(stds) - 0.5)
+        return np.sqrt(sts.chi2.ppf(alphas, 2))
+
+    def _get_critical_values_std(self, n_std):
+        """Compute the critical values for a chi2 with 2df using the continuity correction"""
+        alphas = 2. * (sts.norm.cdf(n_std) - 0.5)
+        # confidence limits in two dimensions
+        return sts.chi2.ppf(alphas, 2)
+
+    def _get_critical_values_alpha(self, alphas):
+        """Compute the critical values for a chi2 with 2df."""
+        # confidence limits in two dimensions
+        return sts.chi2.ppf(alphas, 2)
+
     def add_train_uncertainty(
         self,
         y : np.ndarray,
         yhat : Optional[np.ndarray] = None,
         scores : Optional[np.ndarray] = None,
-        threshold : float = 0.5,
+        threshold : Optional[float] = None,
         obs_axis : int = 0,
     ):
         """Incorporate the sampling uncertainty of the train set.
 
+        Can only be used when ``method`` is the bivariate-normal/elliptical.
+
         Parameters
         ----------
         y : np.ndarray[bool, int32, int64, float32, float64]
@@ -283,27 +436,39 @@ def add_train_uncertainty(
             the classifier scores to be evaluated against the `threshold`, i.e.
             `yhat` = `scores` >= `threshold`. Can be `None` if `yhat` is not `None`,
             if both are provided, this parameter is ignored.
-        threshold : float, default=0.5
+        threshold : float, default=None
             the classification threshold to which the classifier scores are evaluated,
-            is inclusive.
+            is inclusive. Must be set when class was instantiated with
+            ``from_classifier`` or ``from_predictions`` and ``yhat`` is None, otherwhise ignored.
         obs_axis : int, default=0
             the axis containing the observations for a single run, e.g. 0 when the
             labels and scores are stored as columns
 
-        """
-        self.train_conf_mats = confusion_matrices(
-            y, yhat, scores, threshold, obs_axis
-        )
-        out = _core.precision_recall_2d(self.train_conf_mats)
-        self.train_precisions = out[:, 0]
-        self.train_recalls = out[:, 1]
-        self.train_cov_mat = np.cov(out, rowvar=False)
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
 
+        """
+        if not self._has_cov:
+            raise NotImplementedError(
+                "``add_train_uncertainty`` cannot be called when method is not"
+                " Bivariate-Normal/Elliptical."
+            )
         if self.cov_mat is None:
             raise RuntimeError(
                 "the class needs to be initialised with from_*"
                 " before adding train uncertainty."
             )
+
+        threshold = threshold or self.threshold
+        self.train_conf_mats = confusion_matrices(
+            y, yhat, scores, threshold, obs_axis
+        )
+        out = _core.pr_mvn_error_runs(self.train_conf_mats)
+        self.train_precision = out[:, 0]
+        self.train_recall = out[:, 1]
+        self.train_cov_mat = np.cov(out[:, 2:], rowvar=False)
         self.total_cov_mat = self.cov_mat + self.train_cov_mat
 
     def get_train_conf_mats(self) -> pd.DataFrame:
@@ -313,10 +478,26 @@ def get_train_conf_mats(self) -> pd.DataFrame:
         -------
         pd.DataFrame
             the confusion matrices of the training sets
+
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
+
         """
+        if not self._has_cov:
+            raise NotImplementedError(
+                "`train_conf_mats` are not computed when method is not"
+                " Bivariate-Normal/Elliptical."
+            )
         return confusion_matrices_to_dataframe(self.train_conf_mats)
 
     def _get_cov_mat(self, cov_mat):
+        if not self._has_cov:
+            raise NotImplementedError(
+                "`cov_mat` is not computed when method is not"
+                " Bivariate-Normal/Elliptical."
+            )
         cov_cols = ['precision', 'recall']
         return pd.DataFrame(cov_mat, index=cov_cols, columns=cov_cols)
 
@@ -327,6 +508,12 @@ def get_cov_mat(self) -> pd.DataFrame:
         -------
         pd.DataFrame
             the covariance matrix
+
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
+
         """
         return self._get_cov_mat(self.cov_mat)
 
@@ -337,6 +524,12 @@ def get_train_cov_mat(self) -> pd.DataFrame:
         -------
         pd.DataFrame
             the covariance matrix
+
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
+
         """
         return self._get_cov_mat(self.train_cov_mat)
 
@@ -347,75 +540,69 @@ def get_total_cov_mat(self) -> pd.DataFrame:
         -------
         pd.DataFrame
             the covariance matrix
+
+        Raises
+        ------
+        NotImplementedError
+            when method is not Bivariate-Normal/Elliptical
+
         """
         return self._get_cov_mat(self.total_cov_mat)
 
+    def get_conf_mat(self) -> pd.DataFrame:
+        """Obtain confusion matrix as a DataFrame.
 
-    def _get_scaling_factor_alpha(self, alphas):
-        """Compute critical value given a number alphas."""
-        # Get the scale for 2 degrees of freedom confidence interval
-        # We use chi2 because the equation of an ellipse is a sum of squared variable,
-        return np.sqrt(sts.chi2.ppf(alphas, 2))
+        Returns
+        -------
+        pd.DataFrame
+            the confusion matrix of the test set
+        """
+        return confusion_matrix_to_dataframe(self.conf_mat)
 
-    def _get_scaling_factor_std(self, stds):
-        alphas = 2. * (sts.norm.cdf(stds) - 0.5)
-        return np.sqrt(sts.chi2.ppf(alphas, 2))
+    def _add_point_to_plot(self, point, point_kwargs):
+        if isinstance(point_kwargs, dict):
+            if 'cmap' not in point_kwargs:
+                point_kwargs['cmap'] = 'Reds'
+            if 'ax' in point_kwargs:
+                point_kwargs.pop('ax')
+        elif point_kwargs is None:
+            point_kwargs = {'cmap': 'Reds'}
+        else:
+            raise TypeError("`point_kwargs` must be a Dict or None")
+        self._ax = point.plot(ax=self._ax, **point_kwargs)
+        self._handles = self._handles + point._handles
+        self._ax.legend(handles=self._handles, loc='lower left', fontsize=12)  # type: ignore
 
-    def plot(
+    def _add_other_to_plot(self, other, other_kwargs):
+        if isinstance(other, PrecisionRecallUncertainty):
+            self._add_point_to_plot(other, other_kwargs)
+        elif isinstance(other, (list, tuple)):
+            if other_kwargs is None:
+                other_kwargs = {}
+            elif isinstance(other_kwargs, dict):
+                other_kwargs = [other_kwargs, ] * len(other)
+            for point, kwargs in zip_longest(other, other_kwargs):
+                self._add_point_to_plot(point, kwargs)
+        else:
+            raise TypeError(
+                "`point_uncertainty` must be a subclass of PointUncertainty"
+                " or a list of PointUncertainty's"
+            )
+
+    def _plot_ellipse(
         self,
-        levels : Union[int, float, np.ndarray, None] = None,
-        uncertainties : str = 'test',
-        ax=None,
-        cmap : str = 'Blues',
-        equal_aspect : bool = False,
-        limit_axis : bool = True,
-        alpha : float = 0.6,
-        other : Union[PointUncertainty, List[PointUncertainty], None] = None,
-        other_kwargs : Union[Dict, List[Dict], None] = None
+        levels,
+        uncertainties,
+        ax,
+        cmap,
+        equal_aspect,
+        limit_axis,
+        legend_loc,
+        alpha,
+        other,
+        other_kwargs
     ):
-        """Plot elliptical confidence interval(s) for precision and recall
-
-        Parameters
-        ----------
-        levels : int, float np.ndarray, default=np.array((1, 2, 3,))
-            if int(s) levels is treated as the number of standard deviations
-            for the confidence interval. Note that the continuity correction
-            is applied when determining the corresponding quantiles of the chi2.
-            If float(s) it is taken to be the density to be contained in the
-            confidence interval, no continuity correction is applied.
-            By default we plot 1, 2 and 3 std deviations
-        uncertainties : str, default='test'
-            which uncertainty to plot, 'test' indicates only the sampling
-            uncertainty of the test set. 'train' only plots the sampling
-            uncertainty of the train set. 'all' plots to toal uncertainty over
-            both the train and test sets. Note that 'train' and 'all' require
-            that `add_train_uncertainty` has been called.
-        ax : matplotlib.axes.Axes, default=None
-            Pre-existing axes for the plot
-        cmap : str, default='Blues'
-            matplotlib cmap name to use for CIs
-        equal_aspect : bool, default=False
-            enforce square axis
-        limit_axis : bool, default=True
-            allow ax to be limited for optimal CI plot
-        alpha : float, defualt=0.8
-            opacity value of the ellipses
-        other : PrecisionRecallMultinomialUncertainty,
-        PrecisionRecallEllipticalUncertainty, List, default=None
-            Add other point uncertainty(ies) plot to the plot, by default the
-            `Reds` cmap is used for the `other` plot(s).
-        other_kwargs : dict, list[dict], default=None
-            Keyword arguments passed to `other.plot()`, ignored if
-            `other` is None. If `other` is a list and
-            `other_kwargs` is a dict, the kwargs are used for all point
-            others.
-
-        Returns
-        -------
-        ax : matplotlib.axes.Axes
-            the axis with the ellipse added to it
-
-        """
+        """Plot elliptical confidence interval(s) for precision and recall."""
         if self.cov_mat is None:
             raise RuntimeError("the class needs to be initialised with from_*")
 
@@ -475,295 +662,110 @@ def plot(
                 "`levels` must be a int, float, array-like or None"
             )
 
+        self.critical_values_plot = levels
+
         self._ax, self._handles = _plot_pr_ellipse(
-            self.precision,
-            self.recall,
-            cov_mat,
-            scales,
-            labels,
+            precision=self.precision,
+            recall=self.recall,
+            cov_mat=cov_mat,
+            scales=scales,
+            labels=labels,
             cmap=cmap,
             ax=ax,
             alpha=alpha,
             equal_aspect=equal_aspect,
             limit_axis=limit_axis,
+            legend_loc=legend_loc
         )
         if other is not None:
             self._add_other_to_plot(other, other_kwargs)
         return self._ax
 
+    def _plot_contour(
+        self,
+        levels,
+        ax,
+        cmap,
+        equal_aspect,
+        limit_axis,
+        legend_loc,
+        alpha,
+        other,
+        other_kwargs
+    ):
+        """Plot confidence interval(s) for precision and recall."""
+        if self.chi2_scores is None:
+            raise RuntimeError("the class needs to be initialised with from_*")
 
-class PrecisionRecallMultinomialUncertainty(PointUncertainty):
-    """Precision-Recall uncertainty modelled as a Multinomial.
-
-    Model's the uncertainty using profile log-likelihoods between
-    the observed and most conservative confusion matrix for that
-    precision recall. Unlike the PrecisionRecallEllipticalUncertainty
-    this approach is valid for relatively low statistic samples and
-    at the edges of the curve. However, it does not allow one to
-    add the training sample uncertainty to it.
-
-    Attributes
-    ----------
-    conf_mat : np.ndarray[int64]
-        the confusion_matrix with layout
-        [0, 0] = TN, [0, 1] = FP, [1, 0] = FN, [1, 1] = TP
-        A DataFrame can be obtained by calling `get_conf_mat`.
-    precision : float
-        the Positive Predictive Value aka positive precision
-    recall : float
-        True Positive Rate aka Sensitivity aka positive recall
-    chi2_scores : np.ndarray[float64]
-        the chi2 scores for the grid with shape (`n_bins`, `n_bins`) and
-        bounds precision_bounds on the y-axis, recall_bounds on the x-axis
-    precision_bounds : np.ndarray[float64]
-        the lower and upper bound for which precision was evaluated, equal
-        to precision +- `n_sigmas` * sigma(precision)
-    recall_bounds : np.ndarray[float64]
-        the lower and upper bound for which recall was evaluated, equal
-        to recall +- `n_sigmas` * sigma(recall)
-
-    """
-    def __init__(self):
-        self.conf_mat = None
-        self.precision = None
-        self.recall = None
-        self._bounds = None
-        self.precision_bounds = None
-        self.recall_bounds = None
-        self.chi2_scores = None
-        self.n_bins = None
-        self.n_sigmas = None
-        self.epsilon = None
+        # quick catch for list and tuples
+        if isinstance(levels, (list, tuple)):
+            levels = np.asarray(levels)
 
-    def _compute_loglike_scores(self, n_bins, n_sigmas, epsilon):
-        # -- validate n_bins arg
-        if n_bins is None:
-            self.n_bins = 100
-        elif isinstance(n_bins, int):
-            if n_bins < 1:
-                raise ValueError("`n_bins` must be bigger than 0")
-            self.n_bins = n_bins
+        # transform levels into scaling factors for the ellipse
+        if levels is None:
+            levels = self._get_critical_values_std(np.array((1, 2, 3)))
+            labels = [r'$1\sigma$ CI', r'$2\sigma$ CI', r'$3\sigma$ CI']
+        elif isinstance(levels, int):
+            labels = [f'{levels}' + r'$\sigma$ CI']
+            levels = self._get_critical_values_std(np.array((levels,)))
+        elif (
+            isinstance(levels, np.ndarray)
+            and np.issubdtype(levels.dtype, np.integer)
+        ):
+            levels = np.sort(np.unique(levels))
+            labels = [f'{l}' + r'$\sigma$ CI' for l in levels]
+            levels = self._get_critical_values_std(levels)
+        elif isinstance(levels, float):
+            labels = [f'{round(levels * 100, 3)}% CI']
+            levels = self._get_critical_values_alpha(np.array((levels,)))
+        elif (
+            isinstance(levels, np.ndarray)
+            and np.issubdtype(levels.dtype, np.floating)
+        ):
+            levels = np.sort(np.unique(levels))
+            labels = [f'{round(l * 100, 3)}% CI' for l in levels]
+            levels = self._get_critical_values_alpha(levels)
         else:
-            raise TypeError("`n_bins` must be an int")
+            raise TypeError(
+                "`levels` must be a int, float, array-like or None"
+            )
 
-        # -- validate n_sigmas arg
-        if not isinstance(n_sigmas, (int, float)):
-            raise TypeError("`n_sigmas` must be an int or float.")
-        elif n_sigmas < 1.0:
-            raise ValueError("`n_sigmas` must be greater than 1.")
-        self.n_sigmas = n_sigmas
+        self.critical_values_plot = levels
 
-        # -- validate epsilon arg
-        if not isinstance(epsilon, float):
-            raise TypeError("`epsilon` must be a float")
-        elif not (1e-15 <= epsilon <= 0.1):
-            raise ValueError("`epsilon` must be  in [1e-15, 0.1]")
-        self.epsilon = epsilon
-
-        self.precision, self.recall = _core.precision_recall(self.conf_mat)
-        # compute scores
-        self.chi2_scores, bounds = _core.multinomial_uncertainty(
+        self._ax, self._handles = _plot_pr_contours(
             n_bins=self.n_bins,
-            conf_mat=self.conf_mat,
-            n_sigmas=self.n_sigmas,
-            epsilon=self.epsilon
+            precision=self.precision,
+            recall=self.recall,
+            scores=self.chi2_scores,
+            bounds=self._bounds,
+            levels=levels,
+            labels=labels,
+            cmap=cmap,
+            ax=ax,
+            alpha=alpha,
+            equal_aspect=equal_aspect,
+            limit_axis=limit_axis,
+            legend_loc=legend_loc
         )
-        self.precision_bounds = bounds[0, :].copy()
-        self.recall_bounds = bounds[1, :].copy()
-        self._bounds = bounds.flatten()
-
-    @classmethod
-    def from_scores(cls,
-        y : np.ndarray,
-        scores : np.ndarray,
-        threshold : float = 0.5,
-        n_bins : int = 100,
-        n_sigmas : Union[int, float] = 6.0,
-        epsilon : float = 1e-12
-    ):
-        """Compute Multinomial uncertainty on precision and recall.
-
-        Model's the uncertainty using profile log-likelihoods between
-        the observed and most conservative confusion matrix for that
-        precision recall.
 
-        Parameters
-        ----------
-        y : np.ndarray
-            true labels for observations, supported dtypes are [bool, int32,
-            int64, float32, float64]
-        scores : np.ndarray, default=None
-            the classifier scores to be evaluated against the `threshold`, i.e.
-            `yhat` = `scores` >= `threshold`.
-            Supported dtypes are float32 and float64.
-        threshold : float, default=0.5
-            the classification threshold to which the classifier scores are evaluated,
-            is inclusive.
-        n_bins : int, default=100
-            the number of bins in the precision/recall grid for which the
-            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
-            array.
-        n_sigmas : int, float, default=6.0
-            the number of marginal standard deviations used to determine the
-            bounds of the grid which is evaluated.
-        epsilon : float, default=1e-12
-            the value used to prevent the bounds from reaching precision/recall
-            1.0/0.0 which would result in NaNs.
-
-        """
-        self = cls()
-        self._parse_threshold(threshold)
-        self.conf_mat = confusion_matrix(y=y, scores=scores, threshold=threshold)
-        self._compute_loglike_scores(n_bins, n_sigmas, epsilon)
-        return self
-
-    @classmethod
-    def from_predictions(cls,
-        y : np.ndarray,
-        yhat : np.ndarray,
-        n_bins : int = 100,
-        n_sigmas : Union[int, float] = 6.0,
-        epsilon : float = 1e-12
-    ):
-        """Compute Multinomial uncertainty on precision and recall.
-
-        Model's the uncertainty using profile log-likelihoods between
-        the observed and most conservative confusion matrix for that
-        precision recall.
-
-        Parameters
-        ----------
-        y : np.ndarray[bool, int32, int64, float32, float64]
-            true labels for observations, supported dtypes are
-        yhat : yhat : np.ndarray[bool, int32, int64, float32, float64], default=None
-            the predicted labels, the same dtypes are supported as y.
-        n_bins : int, default=100
-            the number of bins in the precision/recall grid for which the
-            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
-            array.
-        n_sigmas : int, float, default=6.0
-            the number of marginal standard deviations used to determine the
-            bounds of the grid which is evaluated.
-        epsilon : float, default=1e-12
-            the value used to prevent the bounds from reaching precision/recall
-            1.0/0.0 which would result in NaNs.
-
-        """
-        self = cls()
-        self.conf_mat = confusion_matrix(y=y, yhat=yhat)
-        self._compute_loglike_scores(n_bins, n_sigmas, epsilon)
-        return self
-
-    @classmethod
-    def from_confusion_matrix(cls,
-        conf_mat : np.ndarray,
-        n_bins : int = 100,
-        n_sigmas : Union[int, float] = 6.0,
-        epsilon : float = 1e-12
-    ):
-        """Compute Multinomial uncertainty on precision and recall.
-
-        Model's the uncertainty using profile log-likelihoods between
-        the observed and most conservative confusion matrix for that
-        precision recall.
-
-        Parameters
-        ----------
-        conf_mat : np.ndarray[int64],
-            confusion matrix as returned by mmu.confusion_matrix, i.e.
-            with layout [0, 0] = TN, [0, 1] = FP, [1, 0] = FN, [1, 1] = TP or
-            the flattened equivalent. Supported dtypes are int32, int64
-        n_bins : int, default=100
-            the number of bins in the precision/recall grid for which the
-            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
-            array.
-        n_sigmas : int, float, default=6.0
-            the number of marginal standard deviations used to determine the
-            bounds of the grid which is evaluated.
-        epsilon : float, default=1e-12
-            the value used to prevent the bounds from reaching precision/recall
-            1.0/0.0 which would result in NaNs.
-
-        """
-        self = cls()
-        if conf_mat.shape == (2, 2):
-            conf_mat = conf_mat.ravel()
-        self.conf_mat = check_array(conf_mat, max_dim=1, dtype_check=_convert_to_int)
-        self._compute_loglike_scores(n_bins, n_sigmas, epsilon)
-        return self
-
-    @classmethod
-    def from_classifier(cls,
-        clf,
-        X : np.ndarray,
-        y : np.ndarray,
-        threshold : float = 0.5,
-        n_bins : int = 100,
-        n_sigmas : Union[int, float] = 6.0,
-        epsilon : float = 1e-12
-    ):
-        """Compute Multinomial uncertainty on precision and recall.
-
-        Model's the uncertainty using profile log-likelihoods between
-        the observed and most conservative confusion matrix for that
-        precision recall.
-
-        Parameters
-        ----------
-        clf : sklearn.Predictor
-            a trained model with method `predict_proba`, used to compute
-            the classifier scores
-        X : np.ndarray
-            the feature array to be used to compute the classifier scores
-        y : np.ndarray[bool, int32, int64, float32, float64]
-            true labels for observations
-        threshold : float, default=0.5
-            the classification threshold to which the classifier score is evaluated,
-            is inclusive.
-        n_bins : int, default=100
-            the number of bins in the precision/recall grid for which the
-            uncertainty is computed. `scores` will be a `n_bins` by `n_bins`
-            array.
-        n_sigmas : int, float, default=6.0
-            the number of marginal standard deviations used to determine the
-            bounds of the grid which is evaluated.
-        epsilon : float, default=1e-12
-            the value used to prevent the bounds from reaching precision/recall
-            1.0/0.0 which would result in NaNs.
-
-        """
-        self = cls()
-        self._parse_threshold(threshold)
-        if not hasattr(clf, 'predict_proba'):
-            raise TypeError("`clf` must have a method `predict_proba`")
-        scores = clf.predict_proba(X)[:, 1]
-        self.conf_mat = confusion_matrix(y=y, scores=scores, threshold=threshold)
-        self._compute_loglike_scores(n_bins, n_sigmas, epsilon)
-        return self
-
-    def _get_critical_values_std(self, n_std):
-        """Compute the critical values for a chi2 with 2df using the continuity correction"""
-        alphas = 2. * (sts.norm.cdf(n_std) - 0.5)
-        # confidence limits in two dimensions
-        return sts.chi2.ppf(alphas, 2)
-
-    def _get_critical_values_alpha(self, alphas):
-        """Compute the critical values for a chi2 with 2df."""
-        # confidence limits in two dimensions
-        return sts.chi2.ppf(alphas, 2)
+        if other is not None:
+            self._add_other_to_plot(other, other_kwargs)
+        return self._ax
 
     def plot(
         self,
         levels : Union[int, float, np.ndarray, None] = None,
+        uncertainties = 'test',
         ax=None,
         cmap : str = 'Blues',
         equal_aspect : bool = False,
         limit_axis : bool = True,
+        legend_loc : Optional[str] = None,
         alpha : float = 0.8,
-        other : Union[PointUncertainty, List[PointUncertainty], None] = None,
+        other : Union['PrecisionRecallUncertainty', List['PrecisionRecallUncertainty'], None] = None,
         other_kwargs : Union[Dict, List[Dict], None] = None
     ):
-        """Plot confidence interval(s) for precision and recall
+        """Plot confidence interval(s) for precision and recall.
 
         Parameters
         ----------
@@ -773,6 +775,13 @@ def plot(
             If float(s) it is taken to be the density to be contained in the
             confidence interval
             By default we plot 1, 2 and 3 std deviations
+        uncertainties : str, default='test'
+            which uncertainty to plot, ignored when method is not
+            Bivariate-Normal / Elliptical. 'test' indicates only the sampling
+            uncertainty of the test set. 'train' only plots the sampling
+            uncertainty of the train set. 'all' plots to toal uncertainty over
+            both the train and test sets. Note that 'train' and 'all' require
+            that `add_train_uncertainty` has been called.
         ax : matplotlib.axes.Axes, default=None
             Pre-existing axes for the plot
         cmap : str, default='Blues'
@@ -781,6 +790,8 @@ def plot(
             enforce square axis
         limit_axis : bool, default=True
             allow ax to be limited for optimal CI plot
+        legend_loc : str, default=None
+            location of the legend, default is `lower left`
         alpha : float, defualt=0.8
             opacity value of the contours
         other : PrecisionRecallMultinomialUncertainty,
@@ -799,57 +810,28 @@ def plot(
             the axis with the ellipse added to it
 
         """
-        if self.chi2_scores is None:
-            raise RuntimeError("the class needs to be initialised with from_*")
-
-        # quick catch for list and tuples
-        if isinstance(levels, (list, tuple)):
-            levels = np.asarray(levels)
-
-        # transform levels into scaling factors for the ellipse
-        if levels is None:
-            levels = self._get_critical_values_std(np.array((1, 2, 3)))
-            labels = [r'$1\sigma$ CI', r'$2\sigma$ CI', r'$3\sigma$ CI']
-        elif isinstance(levels, int):
-            labels = [f'{levels}' + r'$\sigma$ CI']
-            levels = self._get_critical_values_std(np.array((levels,)))
-        elif (
-            isinstance(levels, np.ndarray)
-            and np.issubdtype(levels.dtype, np.integer)
-        ):
-            levels = np.sort(np.unique(levels))
-            labels = [f'{l}' + r'$\sigma$ CI' for l in levels]
-            levels = self._get_critical_values_std(levels)
-        elif isinstance(levels, float):
-            labels = [f'{round(levels * 100, 3)}% CI']
-            levels = self._get_critical_values_alpha(np.array((levels,)))
-        elif (
-            isinstance(levels, np.ndarray)
-            and np.issubdtype(levels.dtype, np.floating)
-        ):
-            levels = np.sort(np.unique(levels))
-            labels = [f'{round(l * 100, 3)}% CI' for l in levels]
-            levels = self._get_critical_values_alpha(levels)
+        if self._has_cov is True:
+            return self._plot_ellipse(
+                levels=levels,
+                uncertainties=uncertainties,
+                ax=ax,
+                cmap=cmap,
+                equal_aspect=equal_aspect,
+                limit_axis=limit_axis,
+                legend_loc=legend_loc,
+                alpha=alpha,
+                other=other,
+                other_kwargs=other_kwargs
+            )
         else:
-            raise TypeError(
-                "`levels` must be a int, float, array-like or None"
+            return self._plot_contour(
+                levels=levels,
+                ax=ax,
+                cmap=cmap,
+                equal_aspect=equal_aspect,
+                limit_axis=limit_axis,
+                legend_loc=legend_loc,
+                alpha=alpha,
+                other=other,
+                other_kwargs=other_kwargs
             )
-
-        self._ax, self._handles = _plot_pr_contours(
-            self.n_bins,
-            self.precision,
-            self.recall,
-            self.chi2_scores,
-            self._bounds,
-            levels,
-            labels,
-            cmap=cmap,
-            ax=ax,
-            alpha=alpha,
-            equal_aspect=equal_aspect,
-            limit_axis=limit_axis,
-        )
-
-        if other is not None:
-            self._add_other_to_plot(other, other_kwargs)
-        return self._ax
diff --git a/mmu/metrics/metrics.py b/mmu/metrics/metrics.py
index 483efb7..9855918 100644
--- a/mmu/metrics/metrics.py
+++ b/mmu/metrics/metrics.py
@@ -664,7 +664,7 @@ def precision_recall(y, yhat=None, scores=None, threshold=None, fill=0.0, return
     if return_df:
         return (
             confusion_matrix_to_dataframe(conf_mat),
-            pd.DataFrame(prec_rec, columns=['precision', 'recall'])
+            pd.DataFrame(prec_rec, index=['precision', 'recall']).T
         )
     return conf_mat, prec_rec
 
diff --git a/mmu/viz/contours.py b/mmu/viz/contours.py
index 13d4011..b9bd9c6 100644
--- a/mmu/viz/contours.py
+++ b/mmu/viz/contours.py
@@ -14,12 +14,12 @@ def _plot_pr_curve_contours(
     rec_grid,
     levels,
     labels,
-    cmap=None,
-    ax=None,
-    alpha=0.8,
-    legend_loc=None,
-    equal_aspect=False,
-    limit_axis=True
+    cmap,
+    ax,
+    alpha,
+    legend_loc,
+    equal_aspect,
+    limit_axis
 ):
     if cmap is None:
         cmap = 'Blues'
@@ -34,7 +34,7 @@ def _plot_pr_curve_contours(
 
     # create meshgrid for plotting
     RX, PY = np.meshgrid(rec_grid, prec_grid)
-    colors = _get_color_hexes(cmap, n_colors=len(labels))
+    colors = _get_color_hexes(cmap, n_colors=len(labels), keep_alpha=True)
 
     levels = [0.0] + levels.tolist()
     # create contours
@@ -71,12 +71,12 @@ def _plot_pr_contours(
     bounds,
     levels,
     labels,
-    cmap=None,
-    ax=None,
-    alpha=0.8,
-    legend_loc=None,
-    equal_aspect=True,
-    limit_axis=True,
+    cmap,
+    ax,
+    alpha,
+    legend_loc,
+    equal_aspect,
+    limit_axis,
 ):
     if cmap is None:
         cmap = 'Blues'
@@ -94,7 +94,7 @@ def _plot_pr_contours(
     rec_grid = np.linspace(bounds[2], bounds[3], num=n_bins)
     RX, PY = np.meshgrid(rec_grid, prec_grid)
     colors, c_marker = _get_color_hexes(
-        cmap, n_colors=len(labels), return_marker=True
+        cmap, n_colors=len(labels), return_marker=True, keep_alpha=True
     )
 
     # add zero level to contours
diff --git a/mmu/viz/ellipse.py b/mmu/viz/ellipse.py
index 576bc03..e39b62c 100644
--- a/mmu/viz/ellipse.py
+++ b/mmu/viz/ellipse.py
@@ -38,12 +38,12 @@ def _plot_pr_ellipse(
     cov_mat,
     scales,
     labels,
-    ax=None,
-    alpha=0.5,
-    cmap=None,
-    legend_loc=None,
-    equal_aspect=True,
-    limit_axis=True
+    ax,
+    alpha,
+    cmap,
+    legend_loc,
+    equal_aspect,
+    limit_axis
 ):
     if cmap is None:
         cmap = 'Blues'
@@ -57,7 +57,7 @@ def _plot_pr_ellipse(
         fig = ax.get_figure()
 
     colors, c_marker = _get_color_hexes(
-        cmap, n_colors=len(labels), return_marker=True
+        cmap, n_colors=len(labels), return_marker=True, keep_alpha=False
     )
 
     # we multiply the radius by 2 because width and height are diameters
diff --git a/mmu/viz/utils.py b/mmu/viz/utils.py
index 0e218f1..875929f 100644
--- a/mmu/viz/utils.py
+++ b/mmu/viz/utils.py
@@ -12,13 +12,13 @@ def _set_plot_style(get_colors=False):
         return [i['color'] for i in plt.rcParams['axes.prop_cycle']]  # type: ignore
 
 
-def _get_color_hexes(cmap, n_colors=3, n_offset=3, return_marker=False):
+def _get_color_hexes(cmap, n_colors=3, n_offset=3, return_marker=False, keep_alpha=True):
     if not isinstance(cmap, str):
         raise TypeError('`cmap` must be a str')
 
     t_colors = n_colors + 2 * n_offset + 1
     cmap = plt_cm.get_cmap(cmap, t_colors)
-    hexes = [rgb2hex(cmap(i), keep_alpha=True) for i in range(cmap.N)]
+    hexes = [rgb2hex(cmap(i), keep_alpha=keep_alpha) for i in range(cmap.N)]
     if return_marker:
         return hexes[n_offset:n_offset + n_colors][::-1], hexes[-3]
     return hexes[n_offset:n_offset + n_colors][::-1]
diff --git a/notebooks/metrics_tutorial.ipynb b/notebooks/metrics_tutorial.ipynb
index 411f767..e78bda0 100644
--- a/notebooks/metrics_tutorial.ipynb
+++ b/notebooks/metrics_tutorial.ipynb
@@ -5,7 +5,7 @@
    "id": "bea5e9f1",
    "metadata": {},
    "source": [
-    "# MMU metrics walkthrough\n",
+    "# MMU Confusion matrix & Metrics walkthrough\n",
     "\n",
     "This notebook briefly demonstrates the various capabilities of the package on the computation of confusion matrix/matrices and binary classification metrics."
    ]
@@ -31,7 +31,7 @@
     "### Data generation\n",
     "\n",
     "We generate predictions and true labels where:\n",
-    "* `score`: classifier scores\n",
+    "* `scores`: classifier scores\n",
     "* `yhat`: estimated labels\n",
     "* `y`: true labels"
    ]
@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "score, yhat, y = mmu.generate_data(n_samples=10000)"
+    "scores, yhat, y = mmu.generate_data(n_samples=10000)"
    ]
   },
   {
@@ -67,8 +67,8 @@
     {
      "data": {
       "text/plain": [
-       "array([[ 830, 2863],\n",
-       "       [1452, 4855]])"
+       "array([[1347, 2380],\n",
+       "       [ 926, 5347]])"
       ]
      },
      "execution_count": 3,
@@ -98,8 +98,8 @@
     {
      "data": {
       "text/plain": [
-       "array([[ 830, 2863],\n",
-       "       [1452, 4855]])"
+       "array([[1347, 2380],\n",
+       "       [ 926, 5347]])"
       ]
      },
      "execution_count": 4,
@@ -108,7 +108,54 @@
     }
    ],
    "source": [
-    "mmu.confusion_matrix(y, score=score, threshold=0.5)"
+    "mmu.confusion_matrix(y, scores=scores, threshold=0.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2c2df1c",
+   "metadata": {},
+   "source": [
+    "## Precision-Recall\n",
+    "\n",
+    "mmu has a specialised function for the positive precision and recall"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "120c1300",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm, prec_rec = mmu.precision_recall(y, scores=scores, threshold=0.5, return_df=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09ae171b",
+   "metadata": {},
+   "source": [
+    "Next to the point precision and recall there is also a function to compute the precision recall curve.\n",
+    "\n",
+    "`precision_recall_curve` also available under alias `pr_curve` requires you to pass the discrimination/classification thresholds.\n",
+    "\n",
+    "## Auto thresholds\n",
+    "\n",
+    "mmu provides an utility function `auto_thresholds` that returns the all the thresholds that result in a different confusion matrix.\n",
+    "\n",
+    "For large test sets this can be a bit much. `auto_thresholds` has an optional parameter `max_steps` that limits the number of thresholds.\n",
+    "This is done by weighted sampling where the scaled inverse proximity to the next score is used as a weight. In practice this means that the extremes of the scores are oversampled. `auto_thresholds` always ensures that the lowest and highest score are included."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5e0d0eac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thresholds = mmu.auto_thresholds(scores)"
    ]
   },
   {
@@ -137,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "id": "513f7482",
    "metadata": {},
    "outputs": [
@@ -169,7 +216,7 @@
        " 'mcc': 9}"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -189,7 +236,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "id": "a726f5a2",
    "metadata": {},
    "outputs": [],
@@ -199,18 +246,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "id": "c75da16c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 830, 2863],\n",
-       "       [1452, 4855]])"
+       "array([[1347, 2380],\n",
+       "       [ 926, 5347]])"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -220,117 +267,50 @@
     "cm"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "78577630",
-   "metadata": {},
-   "source": [
-    "We can create a dataframe from the confusion matrix using:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "3586a08a",
+   "execution_count": 10,
+   "id": "961e44ba",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead tr th {\n",
-       "        text-align: left;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th colspan=\"2\" halign=\"left\">estimated</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "      <th>negative</th>\n",
-       "      <th>positive</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th rowspan=\"2\" valign=\"top\">observed</th>\n",
-       "      <th>negative</th>\n",
-       "      <td>830</td>\n",
-       "      <td>2863</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>positive</th>\n",
-       "      <td>1452</td>\n",
-       "      <td>4855</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
       "text/plain": [
-       "                  estimated         \n",
-       "                   negative positive\n",
-       "observed negative       830     2863\n",
-       "         positive      1452     4855"
+       "array([0.59260889, 0.69198913, 0.36141669, 0.85238323, 0.449     ,\n",
+       "       0.76385714, 0.63858331, 0.14761677, 0.6694    , 0.24667191])"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mmu.confusion_matrix_to_dataframe(cm)"
+    "metrics"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "1e7917d6",
+   "cell_type": "markdown",
+   "id": "78577630",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([ 0.36371604,  0.62904898,  0.22474953,  0.76977961,  0.27782427,\n",
-       "        0.69233512,  0.77525047,  0.23022039,  0.5685    , -0.00629139])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "metrics"
+    "We can also request dataframes back:"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "c43dd390",
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d45d2836",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "We can create a dataframe from the metrics using:"
+    "cm, metrics = mmu.binary_metrics(y, yhat, return_df=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "79dfc709",
+   "execution_count": 12,
+   "id": "05d07e9f",
    "metadata": {},
    "outputs": [
     {
@@ -369,36 +349,36 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.363716</td>\n",
-       "      <td>0.629049</td>\n",
-       "      <td>0.22475</td>\n",
-       "      <td>0.76978</td>\n",
-       "      <td>0.277824</td>\n",
-       "      <td>0.692335</td>\n",
-       "      <td>0.77525</td>\n",
-       "      <td>0.23022</td>\n",
-       "      <td>0.5685</td>\n",
-       "      <td>-0.006291</td>\n",
+       "      <td>0.592609</td>\n",
+       "      <td>0.691989</td>\n",
+       "      <td>0.361417</td>\n",
+       "      <td>0.852383</td>\n",
+       "      <td>0.449</td>\n",
+       "      <td>0.763857</td>\n",
+       "      <td>0.638583</td>\n",
+       "      <td>0.147617</td>\n",
+       "      <td>0.6694</td>\n",
+       "      <td>0.246672</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "   neg.precision  pos.precision  neg.recall  pos.recall    neg.f1    pos.f1  \\\n",
-       "0       0.363716       0.629049     0.22475     0.76978  0.277824  0.692335   \n",
+       "   neg.precision  pos.precision  neg.recall  pos.recall  neg.f1    pos.f1  \\\n",
+       "0       0.592609       0.691989    0.361417    0.852383   0.449  0.763857   \n",
        "\n",
-       "       fpr      fnr     acc       mcc  \n",
-       "0  0.77525  0.23022  0.5685 -0.006291  "
+       "        fpr       fnr     acc       mcc  \n",
+       "0  0.638583  0.147617  0.6694  0.246672  "
       ]
      },
-     "execution_count": 10,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mmu.metrics_to_dataframe(metrics)"
+    "metrics"
    ]
   },
   {
@@ -411,18 +391,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "id": "90d7accb",
    "metadata": {},
    "outputs": [],
    "source": [
-    "cm, metrics = mmu.binary_metrics(y, score=score, threshold=0.5)"
+    "cm, metrics = mmu.binary_metrics(y, scores=scores, threshold=0.5, return_df=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "02e66be7",
+   "execution_count": 14,
+   "id": "69d997ef",
    "metadata": {},
    "outputs": [
     {
@@ -460,13 +440,13 @@
        "    <tr>\n",
        "      <th rowspan=\"2\" valign=\"top\">observed</th>\n",
        "      <th>negative</th>\n",
-       "      <td>830</td>\n",
-       "      <td>2863</td>\n",
+       "      <td>1347</td>\n",
+       "      <td>2380</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>positive</th>\n",
-       "      <td>1452</td>\n",
-       "      <td>4855</td>\n",
+       "      <td>926</td>\n",
+       "      <td>5347</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -475,23 +455,23 @@
       "text/plain": [
        "                  estimated         \n",
        "                   negative positive\n",
-       "observed negative       830     2863\n",
-       "         positive      1452     4855"
+       "observed negative      1347     2380\n",
+       "         positive       926     5347"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mmu.confusion_matrix_to_dataframe(cm)"
+    "cm"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "4fe2e389",
+   "execution_count": 15,
+   "id": "62c3e3c9",
    "metadata": {},
    "outputs": [
     {
@@ -530,36 +510,36 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.363716</td>\n",
-       "      <td>0.629049</td>\n",
-       "      <td>0.22475</td>\n",
-       "      <td>0.76978</td>\n",
-       "      <td>0.277824</td>\n",
-       "      <td>0.692335</td>\n",
-       "      <td>0.77525</td>\n",
-       "      <td>0.23022</td>\n",
-       "      <td>0.5685</td>\n",
-       "      <td>-0.006291</td>\n",
+       "      <td>0.592609</td>\n",
+       "      <td>0.691989</td>\n",
+       "      <td>0.361417</td>\n",
+       "      <td>0.852383</td>\n",
+       "      <td>0.449</td>\n",
+       "      <td>0.763857</td>\n",
+       "      <td>0.638583</td>\n",
+       "      <td>0.147617</td>\n",
+       "      <td>0.6694</td>\n",
+       "      <td>0.246672</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "   neg.precision  pos.precision  neg.recall  pos.recall    neg.f1    pos.f1  \\\n",
-       "0       0.363716       0.629049     0.22475     0.76978  0.277824  0.692335   \n",
+       "   neg.precision  pos.precision  neg.recall  pos.recall  neg.f1    pos.f1  \\\n",
+       "0       0.592609       0.691989    0.361417    0.852383   0.449  0.763857   \n",
        "\n",
-       "       fpr      fnr     acc       mcc  \n",
-       "0  0.77525  0.23022  0.5685 -0.006291  "
+       "        fpr       fnr     acc       mcc  \n",
+       "0  0.638583  0.147617  0.6694  0.246672  "
       ]
      },
-     "execution_count": 13,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mmu.metrics_to_dataframe(metrics)"
+    "metrics"
    ]
   },
   {
@@ -574,25 +554,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "id": "748a86d4",
    "metadata": {},
    "outputs": [],
    "source": [
-    "thresholds = np.linspace(1e-5, 1.0, 1000)"
+    "thresholds = mmu.auto_thresholds(scores)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 17,
    "id": "97987cd5",
    "metadata": {},
    "outputs": [],
    "source": [
     "cm, metrics = mmu.binary_metrics_thresholds(\n",
     "    y=y,\n",
-    "    score=score,\n",
+    "    scores=scores,\n",
     "    thresholds=thresholds,\n",
+    "    return_df=True\n",
     ")"
    ]
   },
@@ -606,23 +587,138 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "id": "78d3591e",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>TN</th>\n",
+       "      <th>FP</th>\n",
+       "      <th>FN</th>\n",
+       "      <th>TP</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6273</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>3727</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6272</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1</td>\n",
+       "      <td>3726</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6272</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>3725</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6272</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>3</td>\n",
+       "      <td>3724</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6272</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9995</th>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6268</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9996</th>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6269</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9997</th>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6270</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9998</th>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6271</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9999</th>\n",
+       "      <td>3727</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6272</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>10000 rows × 4 columns</p>\n",
+       "</div>"
+      ],
       "text/plain": [
-       "array([[   0, 3693,    0, 6307],\n",
-       "       [   0, 3693,    0, 6307],\n",
-       "       [   0, 3693,    0, 6307],\n",
-       "       ...,\n",
-       "       [3693,    0, 6307,    0],\n",
-       "       [3693,    0, 6307,    0],\n",
-       "       [3693,    0, 6307,    0]])"
+       "        TN    FP    FN    TP\n",
+       "0        0  3727     0  6273\n",
+       "1        0  3727     1  6272\n",
+       "2        1  3726     1  6272\n",
+       "3        2  3725     1  6272\n",
+       "4        3  3724     1  6272\n",
+       "...    ...   ...   ...   ...\n",
+       "9995  3727     0  6268     5\n",
+       "9996  3727     0  6269     4\n",
+       "9997  3727     0  6270     3\n",
+       "9998  3727     0  6271     2\n",
+       "9999  3727     0  6272     1\n",
+       "\n",
+       "[10000 rows x 4 columns]"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -641,7 +737,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "id": "0e49d03a",
    "metadata": {},
    "outputs": [
@@ -681,68 +777,68 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.773533</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.627300</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.770970</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.6273</td>\n",
+       "      <td>0.000000</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.773533</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.627263</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.999841</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.770895</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000159</td>\n",
+       "      <td>0.6272</td>\n",
+       "      <td>-0.007708</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.773533</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.627325</td>\n",
+       "      <td>0.000268</td>\n",
+       "      <td>0.999841</td>\n",
+       "      <td>0.000536</td>\n",
+       "      <td>0.770942</td>\n",
+       "      <td>0.999732</td>\n",
+       "      <td>0.000159</td>\n",
+       "      <td>0.6273</td>\n",
+       "      <td>0.003724</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.773533</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.666667</td>\n",
+       "      <td>0.627388</td>\n",
+       "      <td>0.000537</td>\n",
+       "      <td>0.999841</td>\n",
+       "      <td>0.001072</td>\n",
+       "      <td>0.770990</td>\n",
+       "      <td>0.999463</td>\n",
+       "      <td>0.000159</td>\n",
+       "      <td>0.6274</td>\n",
+       "      <td>0.010532</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>0.773533</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.6307</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.750000</td>\n",
+       "      <td>0.627451</td>\n",
+       "      <td>0.000805</td>\n",
+       "      <td>0.999841</td>\n",
+       "      <td>0.001608</td>\n",
+       "      <td>0.771037</td>\n",
+       "      <td>0.999195</td>\n",
+       "      <td>0.000159</td>\n",
+       "      <td>0.6275</td>\n",
+       "      <td>0.015609</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -758,112 +854,112 @@
        "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>995</th>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.5394</td>\n",
+       "      <th>9995</th>\n",
+       "      <td>0.372886</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000797</td>\n",
+       "      <td>0.543215</td>\n",
+       "      <td>0.001593</td>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.999203</td>\n",
+       "      <td>0.3732</td>\n",
+       "      <td>0.017240</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>996</th>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.5394</td>\n",
+       "      <th>9996</th>\n",
+       "      <td>0.372849</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000638</td>\n",
+       "      <td>0.543176</td>\n",
+       "      <td>0.001274</td>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.999362</td>\n",
+       "      <td>0.3731</td>\n",
+       "      <td>0.015419</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>997</th>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.5394</td>\n",
+       "      <th>9997</th>\n",
+       "      <td>0.372812</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000478</td>\n",
+       "      <td>0.543136</td>\n",
+       "      <td>0.000956</td>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.999522</td>\n",
+       "      <td>0.3730</td>\n",
+       "      <td>0.013353</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>998</th>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.5394</td>\n",
+       "      <th>9998</th>\n",
+       "      <td>0.372775</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000319</td>\n",
+       "      <td>0.543097</td>\n",
+       "      <td>0.000637</td>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.999681</td>\n",
+       "      <td>0.3729</td>\n",
+       "      <td>0.010902</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>999</th>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0000</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.5394</td>\n",
+       "      <th>9999</th>\n",
+       "      <td>0.372737</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000159</td>\n",
+       "      <td>0.543057</td>\n",
+       "      <td>0.000319</td>\n",
        "      <td>0.000000</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.3693</td>\n",
-       "      <td>0.0</td>\n",
+       "      <td>0.999841</td>\n",
+       "      <td>0.3728</td>\n",
+       "      <td>0.007708</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "<p>1000 rows × 10 columns</p>\n",
+       "<p>10000 rows × 10 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
-       "     neg.precision  pos.precision  neg.recall  pos.recall  neg.f1    pos.f1  \\\n",
-       "0           0.0000         0.6307         0.0         1.0  0.0000  0.773533   \n",
-       "1           0.0000         0.6307         0.0         1.0  0.0000  0.773533   \n",
-       "2           0.0000         0.6307         0.0         1.0  0.0000  0.773533   \n",
-       "3           0.0000         0.6307         0.0         1.0  0.0000  0.773533   \n",
-       "4           0.0000         0.6307         0.0         1.0  0.0000  0.773533   \n",
-       "..             ...            ...         ...         ...     ...       ...   \n",
-       "995         0.3693         0.0000         1.0         0.0  0.5394  0.000000   \n",
-       "996         0.3693         0.0000         1.0         0.0  0.5394  0.000000   \n",
-       "997         0.3693         0.0000         1.0         0.0  0.5394  0.000000   \n",
-       "998         0.3693         0.0000         1.0         0.0  0.5394  0.000000   \n",
-       "999         0.3693         0.0000         1.0         0.0  0.5394  0.000000   \n",
+       "      neg.precision  pos.precision  neg.recall  pos.recall    neg.f1  \\\n",
+       "0          0.000000       0.627300    0.000000    1.000000  0.000000   \n",
+       "1          0.000000       0.627263    0.000000    0.999841  0.000000   \n",
+       "2          0.500000       0.627325    0.000268    0.999841  0.000536   \n",
+       "3          0.666667       0.627388    0.000537    0.999841  0.001072   \n",
+       "4          0.750000       0.627451    0.000805    0.999841  0.001608   \n",
+       "...             ...            ...         ...         ...       ...   \n",
+       "9995       0.372886       1.000000    1.000000    0.000797  0.543215   \n",
+       "9996       0.372849       1.000000    1.000000    0.000638  0.543176   \n",
+       "9997       0.372812       1.000000    1.000000    0.000478  0.543136   \n",
+       "9998       0.372775       1.000000    1.000000    0.000319  0.543097   \n",
+       "9999       0.372737       1.000000    1.000000    0.000159  0.543057   \n",
        "\n",
-       "     fpr  fnr     acc  mcc  \n",
-       "0    1.0  0.0  0.6307  0.0  \n",
-       "1    1.0  0.0  0.6307  0.0  \n",
-       "2    1.0  0.0  0.6307  0.0  \n",
-       "3    1.0  0.0  0.6307  0.0  \n",
-       "4    1.0  0.0  0.6307  0.0  \n",
-       "..   ...  ...     ...  ...  \n",
-       "995  0.0  1.0  0.3693  0.0  \n",
-       "996  0.0  1.0  0.3693  0.0  \n",
-       "997  0.0  1.0  0.3693  0.0  \n",
-       "998  0.0  1.0  0.3693  0.0  \n",
-       "999  0.0  1.0  0.3693  0.0  \n",
+       "        pos.f1       fpr       fnr     acc       mcc  \n",
+       "0     0.770970  1.000000  0.000000  0.6273  0.000000  \n",
+       "1     0.770895  1.000000  0.000159  0.6272 -0.007708  \n",
+       "2     0.770942  0.999732  0.000159  0.6273  0.003724  \n",
+       "3     0.770990  0.999463  0.000159  0.6274  0.010532  \n",
+       "4     0.771037  0.999195  0.000159  0.6275  0.015609  \n",
+       "...        ...       ...       ...     ...       ...  \n",
+       "9995  0.001593  0.000000  0.999203  0.3732  0.017240  \n",
+       "9996  0.001274  0.000000  0.999362  0.3731  0.015419  \n",
+       "9997  0.000956  0.000000  0.999522  0.3730  0.013353  \n",
+       "9998  0.000637  0.000000  0.999681  0.3729  0.010902  \n",
+       "9999  0.000319  0.000000  0.999841  0.3728  0.007708  \n",
        "\n",
-       "[1000 rows x 10 columns]"
+       "[10000 rows x 10 columns]"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mmu.metrics_to_dataframe(metrics)"
+    "metrics"
    ]
   },
   {
@@ -876,12 +972,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 20,
    "id": "8b7c84c6",
    "metadata": {},
    "outputs": [],
    "source": [
-    "score, yhat, y = mmu.generate_data(n_samples=10000, n_sets=100)"
+    "scores, yhat, y = mmu.generate_data(n_samples=10000, n_sets=100)"
    ]
   },
   {
@@ -898,35 +994,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "id": "f74e5e36",
    "metadata": {},
    "outputs": [],
    "source": [
     "cm, metrics = mmu.binary_metrics_runs(\n",
     "    y=y,\n",
-    "    score=score,\n",
+    "    scores=scores,\n",
     "    threshold=0.5,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 22,
    "id": "3e338096",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 878, 2871, 1386, 4865],\n",
-       "       [ 823, 2929, 1408, 4840],\n",
-       "       [ 856, 2922, 1420, 4802],\n",
-       "       [ 870, 2786, 1423, 4921],\n",
-       "       [ 882, 2961, 1357, 4800]])"
+       "array([[1432, 2400,  906, 5262],\n",
+       "       [1428, 2379,  914, 5279],\n",
+       "       [1387, 2368,  890, 5355],\n",
+       "       [1362, 2405,  876, 5357],\n",
+       "       [1352, 2370,  906, 5372]])"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -947,14 +1043,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 23,
    "id": "b90e1d33",
    "metadata": {},
    "outputs": [],
    "source": [
     "cm, metrics = mmu.binary_metrics_runs_thresholds(\n",
     "    y=y,\n",
-    "    score=score,\n",
+    "    scores=scores,\n",
     "    thresholds=thresholds,\n",
     "    fill=1.0\n",
     ")"
@@ -986,7 +1082,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 24,
    "id": "05912c5d",
    "metadata": {},
    "outputs": [
@@ -994,7 +1090,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "shape confusion matrix:  (1000, 4, 100)\n",
+      "shape confusion matrix:  (10000, 4, 100)\n",
       "strides confusion matrix:  (3200, 8, 32)\n"
      ]
     }
@@ -1006,7 +1102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 25,
    "id": "8bdd9df2",
    "metadata": {},
    "outputs": [
@@ -1014,8 +1110,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "shape metrics:  (1000, 10, 100)\n",
-      "strides metrics:  (800, 800000, 8)\n"
+      "shape metrics:  (10000, 10, 100)\n",
+      "strides metrics:  (800, 8000000, 8)\n"
      ]
     }
    ],
@@ -1026,7 +1122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 26,
    "id": "4194a61f",
    "metadata": {},
    "outputs": [],
@@ -1047,7 +1143,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 27,
    "id": "49f4a20f",
    "metadata": {},
    "outputs": [],
@@ -1055,14 +1151,14 @@
     "# We use confusion_matrices to create confusion matrices based on some output\n",
     "cm = mmu.confusion_matrices(\n",
     "    y=y,\n",
-    "    score=score,\n",
+    "    scores=scores,\n",
     "    threshold=0.5,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 28,
    "id": "c8e2e53d",
    "metadata": {},
    "outputs": [],
@@ -1072,7 +1168,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 29,
    "id": "c03c77e0",
    "metadata": {},
    "outputs": [
@@ -1112,68 +1208,68 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>0.387809</td>\n",
-       "      <td>0.628878</td>\n",
-       "      <td>0.234196</td>\n",
-       "      <td>0.778275</td>\n",
-       "      <td>0.292034</td>\n",
-       "      <td>0.695646</td>\n",
-       "      <td>0.765804</td>\n",
-       "      <td>0.221725</td>\n",
-       "      <td>0.5743</td>\n",
-       "      <td>0.014426</td>\n",
+       "      <td>0.612489</td>\n",
+       "      <td>0.686766</td>\n",
+       "      <td>0.373695</td>\n",
+       "      <td>0.853113</td>\n",
+       "      <td>0.464182</td>\n",
+       "      <td>0.760954</td>\n",
+       "      <td>0.626305</td>\n",
+       "      <td>0.146887</td>\n",
+       "      <td>0.6694</td>\n",
+       "      <td>0.260525</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>0.368893</td>\n",
-       "      <td>0.622989</td>\n",
-       "      <td>0.219350</td>\n",
-       "      <td>0.774648</td>\n",
-       "      <td>0.275113</td>\n",
-       "      <td>0.690590</td>\n",
-       "      <td>0.780650</td>\n",
-       "      <td>0.225352</td>\n",
-       "      <td>0.5663</td>\n",
-       "      <td>-0.006981</td>\n",
+       "      <td>0.609735</td>\n",
+       "      <td>0.689344</td>\n",
+       "      <td>0.375099</td>\n",
+       "      <td>0.852414</td>\n",
+       "      <td>0.464466</td>\n",
+       "      <td>0.762255</td>\n",
+       "      <td>0.624901</td>\n",
+       "      <td>0.147586</td>\n",
+       "      <td>0.6707</td>\n",
+       "      <td>0.260853</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>0.376098</td>\n",
-       "      <td>0.621699</td>\n",
-       "      <td>0.226575</td>\n",
-       "      <td>0.771778</td>\n",
-       "      <td>0.282788</td>\n",
-       "      <td>0.688656</td>\n",
-       "      <td>0.773425</td>\n",
-       "      <td>0.228222</td>\n",
-       "      <td>0.5658</td>\n",
-       "      <td>-0.001905</td>\n",
+       "      <td>0.609135</td>\n",
+       "      <td>0.693383</td>\n",
+       "      <td>0.369374</td>\n",
+       "      <td>0.857486</td>\n",
+       "      <td>0.459881</td>\n",
+       "      <td>0.766753</td>\n",
+       "      <td>0.630626</td>\n",
+       "      <td>0.142514</td>\n",
+       "      <td>0.6742</td>\n",
+       "      <td>0.261972</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>0.379416</td>\n",
-       "      <td>0.638510</td>\n",
-       "      <td>0.237965</td>\n",
-       "      <td>0.775694</td>\n",
-       "      <td>0.292486</td>\n",
-       "      <td>0.700448</td>\n",
-       "      <td>0.762035</td>\n",
-       "      <td>0.224306</td>\n",
-       "      <td>0.5791</td>\n",
-       "      <td>0.015647</td>\n",
+       "      <td>0.608579</td>\n",
+       "      <td>0.690157</td>\n",
+       "      <td>0.361561</td>\n",
+       "      <td>0.859458</td>\n",
+       "      <td>0.453622</td>\n",
+       "      <td>0.765559</td>\n",
+       "      <td>0.638439</td>\n",
+       "      <td>0.140542</td>\n",
+       "      <td>0.6719</td>\n",
+       "      <td>0.256956</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>0.393926</td>\n",
-       "      <td>0.618477</td>\n",
-       "      <td>0.229508</td>\n",
-       "      <td>0.779600</td>\n",
-       "      <td>0.290036</td>\n",
-       "      <td>0.689754</td>\n",
-       "      <td>0.770492</td>\n",
-       "      <td>0.220400</td>\n",
-       "      <td>0.5682</td>\n",
-       "      <td>0.010629</td>\n",
+       "      <td>0.598760</td>\n",
+       "      <td>0.693878</td>\n",
+       "      <td>0.363246</td>\n",
+       "      <td>0.855687</td>\n",
+       "      <td>0.452174</td>\n",
+       "      <td>0.766334</td>\n",
+       "      <td>0.636754</td>\n",
+       "      <td>0.144313</td>\n",
+       "      <td>0.6724</td>\n",
+       "      <td>0.253116</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -1190,68 +1286,68 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>95</th>\n",
-       "      <td>0.378191</td>\n",
-       "      <td>0.622838</td>\n",
-       "      <td>0.231585</td>\n",
-       "      <td>0.769194</td>\n",
-       "      <td>0.287264</td>\n",
-       "      <td>0.688322</td>\n",
-       "      <td>0.768415</td>\n",
-       "      <td>0.230806</td>\n",
-       "      <td>0.5663</td>\n",
-       "      <td>0.000895</td>\n",
+       "      <td>0.594898</td>\n",
+       "      <td>0.684662</td>\n",
+       "      <td>0.362105</td>\n",
+       "      <td>0.848871</td>\n",
+       "      <td>0.450188</td>\n",
+       "      <td>0.757975</td>\n",
+       "      <td>0.637895</td>\n",
+       "      <td>0.151129</td>\n",
+       "      <td>0.6639</td>\n",
+       "      <td>0.242859</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>96</th>\n",
-       "      <td>0.382051</td>\n",
-       "      <td>0.618799</td>\n",
-       "      <td>0.234400</td>\n",
-       "      <td>0.766246</td>\n",
-       "      <td>0.290543</td>\n",
-       "      <td>0.684674</td>\n",
-       "      <td>0.765600</td>\n",
-       "      <td>0.233754</td>\n",
-       "      <td>0.5634</td>\n",
-       "      <td>0.000741</td>\n",
+       "      <td>0.603006</td>\n",
+       "      <td>0.698889</td>\n",
+       "      <td>0.369247</td>\n",
+       "      <td>0.857596</td>\n",
+       "      <td>0.458026</td>\n",
+       "      <td>0.770151</td>\n",
+       "      <td>0.630753</td>\n",
+       "      <td>0.142404</td>\n",
+       "      <td>0.6772</td>\n",
+       "      <td>0.261692</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>97</th>\n",
-       "      <td>0.361099</td>\n",
-       "      <td>0.623978</td>\n",
-       "      <td>0.222222</td>\n",
-       "      <td>0.766497</td>\n",
-       "      <td>0.275129</td>\n",
-       "      <td>0.687934</td>\n",
-       "      <td>0.777778</td>\n",
-       "      <td>0.233503</td>\n",
-       "      <td>0.5637</td>\n",
-       "      <td>-0.012975</td>\n",
+       "      <td>0.610512</td>\n",
+       "      <td>0.687548</td>\n",
+       "      <td>0.358765</td>\n",
+       "      <td>0.860431</td>\n",
+       "      <td>0.451945</td>\n",
+       "      <td>0.764336</td>\n",
+       "      <td>0.641235</td>\n",
+       "      <td>0.139569</td>\n",
+       "      <td>0.6704</td>\n",
+       "      <td>0.255604</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>98</th>\n",
-       "      <td>0.374890</td>\n",
-       "      <td>0.625227</td>\n",
-       "      <td>0.227855</td>\n",
-       "      <td>0.772233</td>\n",
-       "      <td>0.283438</td>\n",
-       "      <td>0.690998</td>\n",
-       "      <td>0.772145</td>\n",
-       "      <td>0.227767</td>\n",
-       "      <td>0.5682</td>\n",
-       "      <td>0.000101</td>\n",
+       "      <td>0.588184</td>\n",
+       "      <td>0.690992</td>\n",
+       "      <td>0.360515</td>\n",
+       "      <td>0.849968</td>\n",
+       "      <td>0.447031</td>\n",
+       "      <td>0.762279</td>\n",
+       "      <td>0.639485</td>\n",
+       "      <td>0.150032</td>\n",
+       "      <td>0.6675</td>\n",
+       "      <td>0.242408</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>99</th>\n",
-       "      <td>0.370674</td>\n",
-       "      <td>0.629036</td>\n",
-       "      <td>0.219466</td>\n",
-       "      <td>0.780321</td>\n",
-       "      <td>0.275699</td>\n",
-       "      <td>0.696559</td>\n",
-       "      <td>0.780534</td>\n",
-       "      <td>0.219679</td>\n",
-       "      <td>0.5723</td>\n",
-       "      <td>-0.000248</td>\n",
+       "      <td>0.599203</td>\n",
+       "      <td>0.691294</td>\n",
+       "      <td>0.361475</td>\n",
+       "      <td>0.855362</td>\n",
+       "      <td>0.450925</td>\n",
+       "      <td>0.764626</td>\n",
+       "      <td>0.638525</td>\n",
+       "      <td>0.144638</td>\n",
+       "      <td>0.6705</td>\n",
+       "      <td>0.250979</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1260,35 +1356,35 @@
       ],
       "text/plain": [
        "    neg.precision  pos.precision  neg.recall  pos.recall    neg.f1    pos.f1  \\\n",
-       "0        0.387809       0.628878    0.234196    0.778275  0.292034  0.695646   \n",
-       "1        0.368893       0.622989    0.219350    0.774648  0.275113  0.690590   \n",
-       "2        0.376098       0.621699    0.226575    0.771778  0.282788  0.688656   \n",
-       "3        0.379416       0.638510    0.237965    0.775694  0.292486  0.700448   \n",
-       "4        0.393926       0.618477    0.229508    0.779600  0.290036  0.689754   \n",
+       "0        0.612489       0.686766    0.373695    0.853113  0.464182  0.760954   \n",
+       "1        0.609735       0.689344    0.375099    0.852414  0.464466  0.762255   \n",
+       "2        0.609135       0.693383    0.369374    0.857486  0.459881  0.766753   \n",
+       "3        0.608579       0.690157    0.361561    0.859458  0.453622  0.765559   \n",
+       "4        0.598760       0.693878    0.363246    0.855687  0.452174  0.766334   \n",
        "..            ...            ...         ...         ...       ...       ...   \n",
-       "95       0.378191       0.622838    0.231585    0.769194  0.287264  0.688322   \n",
-       "96       0.382051       0.618799    0.234400    0.766246  0.290543  0.684674   \n",
-       "97       0.361099       0.623978    0.222222    0.766497  0.275129  0.687934   \n",
-       "98       0.374890       0.625227    0.227855    0.772233  0.283438  0.690998   \n",
-       "99       0.370674       0.629036    0.219466    0.780321  0.275699  0.696559   \n",
+       "95       0.594898       0.684662    0.362105    0.848871  0.450188  0.757975   \n",
+       "96       0.603006       0.698889    0.369247    0.857596  0.458026  0.770151   \n",
+       "97       0.610512       0.687548    0.358765    0.860431  0.451945  0.764336   \n",
+       "98       0.588184       0.690992    0.360515    0.849968  0.447031  0.762279   \n",
+       "99       0.599203       0.691294    0.361475    0.855362  0.450925  0.764626   \n",
        "\n",
        "         fpr       fnr     acc       mcc  \n",
-       "0   0.765804  0.221725  0.5743  0.014426  \n",
-       "1   0.780650  0.225352  0.5663 -0.006981  \n",
-       "2   0.773425  0.228222  0.5658 -0.001905  \n",
-       "3   0.762035  0.224306  0.5791  0.015647  \n",
-       "4   0.770492  0.220400  0.5682  0.010629  \n",
+       "0   0.626305  0.146887  0.6694  0.260525  \n",
+       "1   0.624901  0.147586  0.6707  0.260853  \n",
+       "2   0.630626  0.142514  0.6742  0.261972  \n",
+       "3   0.638439  0.140542  0.6719  0.256956  \n",
+       "4   0.636754  0.144313  0.6724  0.253116  \n",
        "..       ...       ...     ...       ...  \n",
-       "95  0.768415  0.230806  0.5663  0.000895  \n",
-       "96  0.765600  0.233754  0.5634  0.000741  \n",
-       "97  0.777778  0.233503  0.5637 -0.012975  \n",
-       "98  0.772145  0.227767  0.5682  0.000101  \n",
-       "99  0.780534  0.219679  0.5723 -0.000248  \n",
+       "95  0.637895  0.151129  0.6639  0.242859  \n",
+       "96  0.630753  0.142404  0.6772  0.261692  \n",
+       "97  0.641235  0.139569  0.6704  0.255604  \n",
+       "98  0.639485  0.150032  0.6675  0.242408  \n",
+       "99  0.638525  0.144638  0.6705  0.250979  \n",
        "\n",
        "[100 rows x 10 columns]"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/notebooks/precision_recall_uncertainty_tutorial.ipynb b/notebooks/precision_recall_uncertainty_tutorial.ipynb
new file mode 100644
index 0000000..a23fd0e
--- /dev/null
+++ b/notebooks/precision_recall_uncertainty_tutorial.ipynb
@@ -0,0 +1,680 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c6b4537d",
+   "metadata": {},
+   "source": [
+    "# Precision-Recall joint uncertainty\n",
+    "\n",
+    "MMU provides two methods for modelling the joint uncertainty on precision and recall.\n",
+    "\n",
+    "## Multinomial approach\n",
+    "\n",
+    "The Multinomial approach computes the profile log-likelihoods scores for a grid around the precision and recall. The bounds of the grid are determined by ``n_sigmas`` times the standard deviation of the marginals. The scores are chi2 distributed with 2 degrees of freedom.\n",
+    "\n",
+    "The Multinomial approach is usually robust for relatively low statistics tests.\n",
+    "Additionally it is valid for the extreme values of precision and recall, which the Bivariate-Normal approach is not. However, the Multinomial approach does not allow the statistical uncertainty of the train set to be incorporated which the Bivariate-Normal does.\n",
+    "\n",
+    "\n",
+    "## Bivariate-Normal approach\n",
+    "\n",
+    "The statistical/sampling uncertainty over the Precision and Recall are modelled\n",
+    "as a Bivariate-Normal over the linearly propagated errors of the confusion\n",
+    "matrix. For a threshold/confusion matrix a covariance matrix is computed which is used to determine the elliptical uncertainty.\n",
+    "The curve uncertainty computes chi2 scores in a similar manner to Multinomial approach.\n",
+    "\n",
+    "Note that the Bivariate-Normal (Elliptical) approach is only valid for medium to high statistic datasets. A warning is raised when the Normal approximation to the Binomial may not be valid. Additionally, the estimation is not valid for the extremes of precision/recall. However, the train set uncertainty can be added to the test uncertainty.\n",
+    "\n",
+    "## Threshold vs curve uncertainty\n",
+    "\n",
+    "Both methods can be applied for a specific threshold or over the precision recall curve. The curve uncertainty represents a conservative view on the uncertainty.\n",
+    "The precision-recall grid is divided into, by default, 1000 bins per axis.\n",
+    "For each bin in the two dimensional grid we retain the minimum score, highest probability, over the thresholds. This means that for any threshold, the curve's CI will never be smaller than the CI of the corresponding threshold.\n",
+    "Hence, the curve uncertainty can slightly over-cover the true confidence interval.\n",
+    "To help with this the curve methods provide functionality to overlay threshold uncertainty(ies) on the curve. \n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4b679c9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1eba6d38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import make_classification\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.model_selection import train_test_split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "044c3daa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import mmu\n",
+    "from mmu.viz.utils import _set_plot_style"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "88bab561",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "_ = _set_plot_style()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1d84bfc",
+   "metadata": {},
+   "source": [
+    "### Generate data\n",
+    "\n",
+    "Here we use scikit's make_classifaction to generate a toy data set that we fit with Logistic regression.\n",
+    "We use 500 points for the train set and 500 for the test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "64a584f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate seeds to be used by sklearn\n",
+    "# do not use this in real scenarios,\n",
+    "# it's a convenience only used in the tutorial notebooks\n",
+    "seeds = mmu.commons.utils.SeedGenerator(234)\n",
+    "\n",
+    "# generate 2 class dataset\n",
+    "X, y = make_classification(\n",
+    "    n_samples=1000, n_classes=2, random_state=seeds()\n",
+    ")\n",
+    "\n",
+    "# split into train/test sets\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=0.5, random_state=seeds()\n",
+    ")\n",
+    "# fit a model\n",
+    "model = LogisticRegression(solver='lbfgs')\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "# predict probabilities, for the positive outcome only\n",
+    "y_score = model.predict_proba(X_test)[:, 1]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73817c70",
+   "metadata": {},
+   "source": [
+    "## Multinomial uncertainty\n",
+    "\n",
+    "### Threshold uncertainty\n",
+    "\n",
+    "If you have selected an classification/discrimination threshold you may want to evaluate the test-set sampling uncertainty of this classifier. MMU provides a simple way to achieve this.\n",
+    "\n",
+    "`mmu.PrecisionRecallUncertainty` also available under the alias `PRU` is an estimator for the joint precision-recall uncertainty at a specific threshold\n",
+    "\n",
+    "We instantiate the class by calling the `from_scores` method, this follows the sklearn API for e.g. ConfusionMatrixDisplay\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "251c9e25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pr_err = mmu.PRU.from_scores(y_test, y_score, threshold=0.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fae02191",
+   "metadata": {},
+   "source": [
+    "Alternatively we could have instantiated the uncertainty estimator with:\n",
+    "\n",
+    "**Predictions**\n",
+    "```python\n",
+    "y_pred = model.predict(X_test)\n",
+    "PRMU.from_predictions(y_test, y_pred)\n",
+    "```\n",
+    "\n",
+    "**Confusion matrix**\n",
+    "```python\n",
+    "PRMU.from_confusion_matrix(conf_mat)\n",
+    "```\n",
+    "\n",
+    "**Trained classifier**\n",
+    "```python\n",
+    "PRMU.from_classifier(model, X_test, y_test)\n",
+    "```\n",
+    "Note that the last option requires the classifier to have the methods `predict_proba`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "873913b5",
+   "metadata": {},
+   "source": [
+    "### Attributes\n",
+    "\n",
+    "A number of attributes are set during instantiation, most importantly:\n",
+    "* **conf_mat** : np.ndarray[int64]\n",
+    "    * the confusion_matrix with layout\n",
+    "| | |\n",
+    "|---------------|----------------|\n",
+    "| True Negative | False Positive |\n",
+    "| False Negative | True Positive |\n",
+    "    \n",
+    "* **precision** : float\n",
+    "    * the Positive Predictive Value aka positive precision\n",
+    "* **recall** : float\n",
+    "    * True Positive Rate aka Sensitivity aka positive recall\n",
+    "* **chi2_scores** : np.ndarray[float64]\n",
+    "    * the profile log-likelihoods scores with are distributed accoring to a\n",
+    "    chi2 distribution with 2DF\n",
+    "\n",
+    "The attributes that are Numpy arrays can be retrieved as a DataFrame using the \n",
+    "`get_<attribute_name>` methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "799317c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"2\" halign=\"left\">estimated</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th>negative</th>\n",
+       "      <th>positive</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"2\" valign=\"top\">observed</th>\n",
+       "      <th>negative</th>\n",
+       "      <td>201</td>\n",
+       "      <td>55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>positive</th>\n",
+       "      <td>41</td>\n",
+       "      <td>203</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  estimated         \n",
+       "                   negative positive\n",
+       "observed negative       201       55\n",
+       "         positive        41      203"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pr_err.get_conf_mat()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66087fb6",
+   "metadata": {},
+   "source": [
+    "### Plotting\n",
+    "\n",
+    "The `PrecisionRecallUncertainty` class provides a plot method which will plot the precision and recall given the threshold and a settable confidence interval.\n",
+    "\n",
+    "By default three confidence intervals are plotted, respectively 1, 2, and 3 standard deviations. Which are approximate the 68%, 95% and 99% CIs.\n",
+    "\n",
+    "Alternative, we can specify the alpha's of the confidence interval(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b2fd8cd6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAI4CAYAAAB3HEhGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABQ0ElEQVR4nO3de3xU9Z3/8fckk2SYJBAgggkk4aYBuWnLBh5CETVSoVu71gtWrK4gXbZq2l+1D+vtsXarCSK4ogs8BApVql20itothW4oAt4pVUEINBRIxYTEiCHkMkkmmd8fNGOGZJKZ5MztnNfz8fAhc3LmzPeEL2fOez7f73dsHo/HIwAAAABAn8VFugEAAAAAYBYELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMIg90g0It/Ly8oi9dnp6uqqrqyP2+oh+9BEEgn6CQNBP0BP6CAJBP/EvMzOzy+1UsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCAELAAAAAAxCwAIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADCIPZwvVldXp9WrV2vfvn1KTU3VzTffrBkzZnTar76+Xhs2bNBHH30kSZo9e7ZuvPFG78+rqqq0evVqlZaWKj09XQsWLNCkSZPCdRoAAAAA0KWwVrDWrVsnu92utWvXqqCgQGvXrtWnn37aab/nnntOzc3NWrlypQoLC7V7927t2LHD+/MVK1ZoxIgRWr9+vW666SY9+eSTqq2tDeepAAAAAEAnYQtYLpdL77//vubNmyeHw6GxY8dqypQp2rVrV6d99+7dq2uuuUZJSUkaMmSILr/8cm/AKi8v17Fjx3TjjTcqMTFR06ZNU3Z2tt57771wnQoAAAAAdClsAauiokLx8fHKzMz0bsvJyemygtWV9v1OnDihoUOHql+/fj7HOXHihLENBgAAAIAghW0Olsvl8glFkuR0OuVyuTrtO3nyZL322mu68847dfr0ae3YsUNNTU3e4zidzk7HOXXqVJevW1xcrOLiYknSkiVLlJ6ebsTp9Irdbo/o6yP60UcQCPoJAkE/QU/oIwgE/SR4YQtYDodDjY2NPtsaGxvlcDg67btgwQKtX79eBQUFSk1N1fTp0/X22297j9PQ0NDpOOeGt3b5+fnKz8/3Pq6uru7rqfRaenp6RF8f0Y8+gkDQTxAI+gl6Qh9BIOgn/nUcmddR2AJWRkaGWltbVVFRoYyMDElSWVmZsrKyOu2bkpKigoIC7+MXX3xRo0ePliQNHz5cVVVVPqGqrKxM06dPD8NZAAAAAIB/YZuD5XA4NHXqVG3atEkul0uHDh3Snj17NHPmzE77njx5UmfOnFFbW5s+/PBDbd++Xdddd52ks0lxxIgRevnll9Xc3KwPPvhAZWVlmjZtWrhOBQAAAAC6FNbvwbrjjju0atUqLVq0SCkpKVq0aJGysrJUUlKiwsJCbdy4UZJ09OhRPffcc6qvr1dGRobuvvtun0rXj370I61atUq333670tPT9ZOf/ET9+/cP56kAAAAAQCc2j8fjiXQjwqm8vDxir80YVvSEPoJA0E8QCPoJekIfQSDoJ/75m4MV1i8aBgAAAAAzI2ABAAAAgEEIWAAAAABgEAIWAAAAABiEgAUAAAAABiFgAQAAAIBBCFgAAAAAYBACFgAAAAAYhIAFAAAAAAYhYAEAAACAQQhYAAAAAGAQAhYAAAAAGISABQAAAAAGIWABAAAAgEEIWAAAAABgEAIWAAAAABiEgAUAAAAABiFgAQAAAIBBCFgAAAAAYBACFgAAAAAYhIAFAAAAAAYhYAEAAACAQQhYAAAAAGAQAhYAAAAAGISABQAAAAAGIWABAAAAgEEIWAAAAABgEAIWAAAAABiEgAUAAAAABiFgAQAAAIBBCFgAAAAAYBACFgAAAAAYhIAFAAAAAAYhYAEAAACAQQhYAAAAAGAQAhYAAAAAGISABQAAAAAGIWABAAAAgEEIWAAAAABgEAIWAAAAABiEgAUAAAAABiFgAQAAAIBBCFgAAAAAYBACFgAAAAAYhIAFAAAAAAYhYAEAAACAQQhYAAAAAGAQAhYAAAAAGISABQAAAAAGIWABAAAAgEEIWAAAAABgEAIWAAAAABjEHukGAABgJh9/GekWnGU/UyO3+6vHkwdGri0AYCUELAAAzhEtIclIvT0nghkABIeABQCwDDMGp1AL5HdGCAOArxCwAACmQHiKnO5+94QvAFZDwAIAxAQCVGzy9/dG8AJgVgQsAEBUIUhZQ1d/z4QuAGZAwAIARARBCucidAEwAwIWACCkCFLoi3P7D4ELQLQjYAEADEOYQqgRuABEOwIWAKBXCFOIBgQuANGGgAUA6BFhCrGiY18lbAGIBAIWAKATAhXMgLAFIBIIWAAAAhVMj7AFIFwIWABgMYQpWB1hC0AoEbAAwOQIVIB/hC0ARiNgAYAJEaqA4LX/uyFoAegLAhYAmACBCjAOVS0AfUHAAoAYRKACwoOqFoBgEbAAIEa03+jZz9REtB2AFRG0AASKgAUAUYxKFRBdCFoAekLAAoAoQqACYgNBC4A/BCwAiDBCFRC7CFoAzkXAAoAIIFQB5kLQAtAurAGrrq5Oq1ev1r59+5Samqqbb75ZM2bM6LRfS0uLNmzYoD179sjtdis3N1c/+MEPNGjQIEnSI488otLSUsXFxUmSBg0apBUrVoTzVAAgaIQqwPwIWgDCGrDWrVsnu92utWvX6vjx4yoqKlJOTo6ysrJ89tuyZYtKS0v1xBNPyOl0as2aNVq/fr3uvfde7z4LFizQlVdeGc7mA0DQCFWANRG0AOuKC9cLuVwuvf/++5o3b54cDofGjh2rKVOmaNeuXZ32raqq0uTJk5WWlqbExERdeuml+vTTT8PVVADok4+//Oo/ANbGdQCwnrBVsCoqKhQfH6/MzEzvtpycHB08eLDTvldccYV+9atf6dSpU0pOTtbu3bt1ySWX+Ozz4osv6sUXX1RmZqZuuukmjR8/vsvXLS4uVnFxsSRpyZIlSk9PN/CsgmO32yP6+oh+9JHYtfNYjffP9hBfWW02m+yhfhHEPPpJ9Dhw5uz/LxuZFtF2nIv3HASCfhK8sF15XS6X+vXr57PN6XTK5XJ12jcjI0ODBw/W4sWLFRcXp+zsbC1cuND78/nz52v48OGy2+16++239fjjj2vp0qU6//zzOx0rPz9f+fn53sfV1dUGnlVw0tPTI/r6iH70kdgTiU+n7Xa73G53+F8YMYV+En22l1ZH1ZBB3nMQCPqJfx0LRx2FbYigw+FQY2Ojz7bGxkY5HI5O+65bt04tLS1av369Nm7cqLy8PBUWFnp/fsEFF6hfv35KSEjQrFmzlJubqw8//DDk5wAAEkMAAfQe1w7A/MIWsDIyMtTa2qqKigrvtrKysk4LXLRvnzVrllJSUpSQkKA5c+boyJEjqq2t7fLYNptNHo8nZG0HAEIVACNxPQHMK6wVrKlTp2rTpk1yuVw6dOiQ9uzZo5kzZ3bad/To0dq5c6caGhrkdru1bds2DRw4UP3791d9fb0++ugjNTc3q7W1Vbt371ZJSYkuvvjicJ0KAAvhJghAKHF9AczH5glj6aeurk6rVq3S/v37lZKSovnz52vGjBkqKSlRYWGhNm7cKEk6c+aMNmzYoH379sntdisrK0u33XabxowZo9raWhUVFemzzz5TXFychg0bpnnz5mnSpEkBtaG8vDyUp9gtxrCiJ/SR6BDtNzzMrUEg6CexJRJzs3jPQSDoJ/75m4MV1oAVDQhYiGb0kciK9mDVjhtnBIJ+EpvCGbR4z0Eg6Cf++QtYrN8KwPJiJVghttQ0GfP5ZVqSzZDjIDZ8/CVfTgzEOgIWAEsiVKEnfQ1INfVNBrUkqVfPsjW1aADhLCYRsoDYRsACYCkEKwQanIwLSH3T23bY7XZ5FN/jflTIohMhC4hdBCwAlkCwspaeQlS0hKdQ6+k805KT/P6uCF6RR8gCYhMBC4BpEarMz184sEqA6it/vyd/wYvQFX7t1zGCFhA7CFgATIdgZT4EqfDq6vdK6IosqllA7CBgATANgpU5dHUTT5CKvEBCF2ErtAhZQGwgYAGIeQSr2EWYim2d/658VzwkcBmPkAVEPwIWgJhFsIo9BCpzI3CFByELiG4ELAAxh2AVO84NVIQpa+n4991xOCFBq+8IWUD0ImABiBkEq+hHoII/vn3hq8oWYav3CFlAdCJgAYh6BKvoRaBCbxC2jEPIAqIPAQtA1CJYRR/mUMFo7f2HFQkBmAUBC0DUIVhFF6pUCAfma/UeVSwguhCwAEQNglX0IFQhkrqqahG0ukfIAqIHAQtAxBGsokPHUEWgQjQgaAWHkAVEBwIWgIghWEUeoQqxgKAVOEIWEHkELAARQbiKHEIVYhVBKzCELCCyCFgAwopgFRmEKpgJQQtANCNgAQgLglX4sVAFzO7coEXI+gpVLCByCFgAQo5wFV5Uq2A1X/Xzs19aTNA6i5AFRAYBC0DIEKzCh1AFnO37DBsEEGkELACGI1iFD8EK8MWwQV9UsYDwI2ABMBThKvS+qG9Re6wiVAFdo5r1FUIWEF4ELACGIFiFXvuNok0EKyAQVLMARAIBC0CfEKxCq6shgHY7l24gGB2rWVYNWVSxgPDhXRpArxGuQoe5VYCxGDIIIFwIWACCRrAKHYIVEDpWHzJIFQsIj7hINwBAbCFchUZNk8cbrmrqmwhXQAi1//s698u4rYBrOBB6VLAABIQ35dCgYgVEBvOyAIQKFSwAPSJcGY+KFRB5Vq1kcU0HQosKFgC/eBM2HhUrILpQyQJgNCpYALpEuDIWFSsgelmxksU1HggdAhaATnjjNQ7BCogNVgxZAEKDIYIAvAhWxmEoIBB7rDZccOexGo1PjXQrAPOhggVAEuHKKFSsgNhGJQtAXxGwABCuDEKwAszBSiGL6z9gPIYIAhbGG6sxOgYrmE9lvTssrzM0mbfkaGK14YIAjMPVHLAowlXfMc8q9gUSnhpczWFoiVQZwD6EsPAiZAHoDa7UgAURrvqOqlXs6C5EhSs8BaKntjgdiX7PheAVOu0hy8w+/lKaPDDSrQDMgysyYDGEq74hWEU3fwEkmoJUb/k7h3ODF2HLeGf/vSdRxQIQEK7CgEUQrPqG4YDRqatAZYYwFYxzz7d9qKHN1iqPx0PgMpCZhwpSxQKMw1UXsADCVd9QtYoe5wYqq4WpQLT/Tux2u9xut8/cLsJW7zEfC0CguNICJke46j2qVpFHoOq7jr8zwlbfWGE+FoC+4+oKmBjhqveoWkUGgSq0CFvGMGsVi2GCgDG4ogImRbjqHapW4Ueoioz233PHRTIIWj1jqCCAnnAlBUyGYNV7VK3Ch1AVPbqqahG0usdQQQDd4QoKmAjhqvcIV6FHqIp+7X8nBK3AUMUC0BWunIBJEK56h2AVeh2DFaEqNhC0embWKhbzsIC+44oJmADhqncIV6FDqDIHglbPqGIBOBdXSiDGEa6Cx0IWoUOwMqcGVzOLYXTBrFUsAH3DFRKIYYSr4FG1Mh6hyhrOXXWQkPUVqlgAOoqLdAMA9A7hKniEK2NV1ru94arB1Uy4sgjvsMEOf/9WZsbrCe8vQN8QsIAYxJtf8AhXxiFYoePfOyHrrI5DjwFYG/V9IMYQroJDsDIOQwFxro5zs6w8ZJC5WAA6ooIFxBDCVXAIV8agYoXuUMkCAF8ELCBGEK6CQ7jqO4IVAkXIOnutMdMwQd5zgN6zbj0fiCG80QWHcNU3DAVEb3T8ziwrDxcEACpYQJQjXAWHcNU3VKzQVw2uZmtXskxUxQLQO3zEBEQxwlVwCFe91zFYAX3V4Gq2ZCWLxS4ASAQsIGoRroJT0+QhWPUCwwERKlYNWQDAEEEgChGugkO46h2GAyLUrDpckGGCgLURsADENMJV8NpXByRYIVysFLLMdD3iwz6gdwhYQJThDS1whKvgMdcK4cYS7gCshoHRQBTZeawm0k2IGYSr4BCsEEkNrmY5HYmRbgYAhAUVLCBKULkKHOEqOIQrRAsrVbGYhwVYFwELiAKEq8ARrgLXPtdKIlwh8qw0VJBrFGBtBCwgwghXgSNcBY4VAhGN6IsArICABSAmMNwmcFStEO2sUMUCYF0ELCCCqF4Fpj1cUb3qGeEK0Y6+CcDsWEUQiBDCVWAIV4EhWCHWVNa7NTTZvLchZ69ZSUpLskW6KQDCjAoWEAGEq8AQrgJDuEKsoa8CMDMCFhBmhKvAEK4CQ7hCLGMuFgAzCro2X1paqv3796u2tlZtbW0+P1uwYIFhDQMAwlX3CFeIZXz5MACzCipgvfHGG3rhhRd0/vnna+DAgbLZghtXXFdXp9WrV2vfvn1KTU3VzTffrBkzZnTar6WlRRs2bNCePXvkdruVm5urH/zgBxo0aFBQxwGiDdWrwLAce88IVwAARKegAtYf/vAH3X777br66qt79WLr1q2T3W7X2rVrdfz4cRUVFSknJ0dZWVk++23ZskWlpaV64okn5HQ6tWbNGq1fv1733ntvUMcBognhKjAsx96z8tqz4ZNwBTMw+2IXAKwnqDlYDQ0NuuSSS3r1Qi6XS++//77mzZsnh8OhsWPHasqUKdq1a1enfauqqjR58mSlpaUpMTFRl156qT799NOgjwMgtjDvqmdUrmAm9GMAZhTUR0bTp0/XRx99pG9+85tBv1BFRYXi4+OVmZnp3ZaTk6ODBw922veKK67Qr371K506dUrJycnavXu3N9gFcxxJKi4uVnFxsSRpyZIlSk9PD7rtRrHb7RF9fUTOzmM1sgfwr81ms8keyI4m9EV9i2ySzjS1WvZ30JPy2ibZbDY1u9v4HaFHsXI9iZV29oZNiupzC+R3n56eFp7GIGpx/xq8oP7Vp6en66WXXtLhw4eVnZ3d6R/lP//zP/t9rsvlUr9+/Xy2OZ1OuVyuTvtmZGRo8ODBWrx4seLi4pSdna2FCxcGfRxJys/PV35+vvdxdXV19ycZQunp6RF9fURGMEMD7Xa73G5rrqrlEZWr7nSsXFm5nyBwsdJPEu1xMdHO3vAkxUf1uQXSR7hvAfev/nUs+HQUVMDavn27HA6HDh8+rMOHD/v8zGazdRuwHA6HGhsbfbY1NjbK4XB02nfdunVqaWnR+vXrlZSUpNdff12FhYUqLCwM6jgAYgPzrrrHsECYWYOrWZUS87AAmEZQV7OVK1f2+oUyMjLU2tqqiooKZWRkSJLKysq6XJiirKxMN910k1JSUiRJc+bM0UsvvaTa2tqgjgNEGgtb9Ix5V90jXAEAEFt6/UXDLpfL77C8rjgcDk2dOlWbNm2Sy+XSoUOHtGfPHs2cObPTvqNHj9bOnTvV0NAgt9utbdu2aeDAgerfv39QxwEiiXAVOMJV9whXQGyqqW+iQg9YkM3j8QT1L3/r1q16/fXXderUKUnS4MGD9Z3vfCeghS/q6uq0atUq7d+/XykpKZo/f75mzJihkpISFRYWauPGjZKkM2fOaMOGDdq3b5/cbreysrJ02223acyYMd0eJxDl5eXBnK6hGMNqLb0JWLEyZ8IofN9V9yrr3V2GK6v1E/ROLPUTpyPRlEME05KTlJYU3HeGhlMgfWTywDA1BlGL+1f//M3BCipgvfrqq3rttdf07W9/W2PHjpUklZSU6Pe//72uvfZa/cu//IshjQ0lAhbCobfVq1i6IeorhgZ2r7uhgVbqJ+i9WOonBKzIIGAhENy/+mfIIhf/93//px/84Ac+1aKJEycqIyNDv/nNb2IiYAGIHoSrrjHvCgCA2BXUHKza2lrvML2OxowZo9OnTxvWKCCWMfeqZ8xJ6BnhCgCA2BRUwMrIyNBbb73Vaftbb73lt0QGAF2hetW19uoVYDX0fQBmEdQQwRtuuEH/9V//pZKSEuXm5kqSDh8+rIMHD+r//b//F5IGArGE6lXPWNjCP4YGwqoaXM1yOhIj3QwAMERQFaypU6eqsLBQAwYM0N69e7V3714NGDBAhYWFysvLC1UbgZhAuOoZQwN7RriCFZl1kQsA1hT01WzUqFEqKCgIRVsAWADVq64xPAoAAHPoMWDV1dUpJSXF++futO8HWA3Vq55RvfKPoYEAAJhHjwFr4cKFWrNmjQYMGKCFCxd2u++mTZsMaxgA86F65R/hCgAAc+gxYP3Hf/yHtzL1H//xHyFvEBBrqF71jOqVfwwNBBCt+JJhoHd6DFgXXXRRl38GgGBQvfKP6hUAAOYR1CIXJ06cUFxcnPc7r/bt26c333xTWVlZ+s53vqO4uKAWJQRgAVSvAFhRWnJSpJsAIEKCSkSrV6/WsWPHJEnV1dVaunSp6uvrtW3bNv3P//xPSBoIRDOGBwaG6lXXKuvdVK8AE0tLskW6CQAiIKiA9dlnn2nkyJGSpPfee08XXHCB7r//ft111116++23Q9JAAABCyePx6OCxL+Vq9p0P52p26+CxL+XxUIUFAAQuqIDV1tYmu/3sqMJPPvlEl1xyiSTp/PPPV01NjeGNA6IZ1aue1TR5qF75QfUqepQcr9FHR77Q9j+Xe0OWq9mt7X8u10dHvlDJ8ZrINhAAEFOCClhZWVn64x//qJKSEu3fv18XX3yxJOnUqVPq379/KNoHAEBIjRqWqgHJiTpd36ztfy5XTV2Ttv+5XKfrmzUgOVGjhqVGuomm5nQkamhyUFPCASCqBRWw5s+fr+3bt+uRRx7R9OnTlZ2dLUn685//rNGjR4ekgUA0onrVMxa3QKxwJNp15ZRMb8ja8u6n3nB15ZRMORK5+Yf1sEQ70HtBvWtcdNFF+uUvf6mGhgbvd2NJUn5+vpKSWC0HgC+GB3aN4YHRx5Fo1/RJQ7Xl3U+926ZPGkq4Qq+kJSexwAVgYUGvqx4XF+cTriRpyJAhGjBggGGNAgAgnFzNbr29r9Jn29v7KjstfAEAQE96/Gju8ccf19133y2n06nHH3+8233vu+8+wxoGRCuGB/aM4YGIJe0LWrQPC5w+aaje3lfpnZPFMMHQcToSI90EADBcj+8Yqampstls3j8DQCAYHti1ynoqItHm6GdnOs25unJKpjd0Hf3sjC4ayYSUUGGBCwBmY/NY7As+ysvLI/ba6enpqq6ujtjrwxihrGDZ7Xa53bF/A87y7P4ZMf/KLP0kWng8HpUcr9GoYak+lSpXs1tHPzujcSPSvB80xpJY6CdmXEEwluZf+esjLHCBjrh/9S8zM7PL7UFd1WpqatTa2qrBgwf7bP/iiy8UHx+vtLS0XjcQiAUMDwTMx2azdVmhciTaqVyFEMMDAZhVUItcPPPMM/rwww87bf/444/13//934Y1CkDsonoFIFBmq14BgBRkwPrb3/6miy66qNP2sWPH6m9/+5thjQIAAOZl1upVWjJfWQMgyIDV2tqqlpaWTttbWlqifpw30FcMDwQA45i1ehUr86/8Yf4V0HdBBawLLrhAf/zjHztt37Ztm0aPHm1YowAAAAAgFgX18dFNN92k//zP/9Tf//53jR8/XpJ04MABHTt2TA8//HBIGgggdvD9V90zYgVBINaZceVAieGBAL4S1BXuwgsv1KOPPqo33nhDH3zwgSRpxIgRWrhwoUaMGBGK9gGIMSxwAcCqYn14IABjBP0R0ogRI1RQUBCKtgBRi/lXANB3Zq1emQXzrwBjBDUHSzr7XVhvvPGG1q1bp9raWknSoUOHVFVVZXjjAAAAoh3DAwF0FFTAOnr0qH784x/rrbfe0vbt29XY2ChJ2rdvn37zm9+EpIEAACD2mb16xfBAAO2CClgbN27U3LlztXTpUiUkJHi3X3zxxTp8+LDhjQMAALHPrN97BQBdCbqCddlll3XanpaWptOnTxvWKCCaMP8KRuJGE1Zl1uqVWYYHMv8KME5QASsxMVH19fWdtpeXl6t///6GNQpA7Klp8rCCYA/MeoMJdMcKHyowPBBAR0EFrClTpujll19WS0uLJMlms6mqqkovvPCCpk6dGpIGAgCA2GbWDxfMUr0CYKygAtb3v/991dXV6Y477lBTU5MefvhhFRQUyOl06qabbgpVGwEAQAyiehUbGB4IGCuoj5Ti4+P1yCOPqKSkREePHpXH49HIkSM1adKkULUPAADEoPZwRfUKgNUEfNVra2vTv/7rv+qJJ57QhAkTNGHChFC2CwAAxDizhqt2ZqheATBewEME4+LilJ6eLrfbHcr2AFGFFQQRClYYNgVrM/t3XpkJwwMB4wU1B+u6667TCy+8oNra2lC1BwBMjZtOmJ0VPkBIS06iegXAr6De6X/3u9+pqqpKixcv1uDBg5WU5Dv+eNmyZYY2DgAAxA6zz7uSmHsFoGdBXQGnTZsmm80mj8cTqvYAgCU4HYlqcDVHuhmAYawQrtqZpXp12cg0VVdXR7oZgOkEdBVsamrSxo0btWfPHrW2tmrChAlasGABXy4MAL0wNNmuynrms8J8zB6uqF4BCERAc7Beeukl7dy5U1/72tc0ffp07d+/X+vWrQt12wAAQAyw0qIWZqlesbgFEDoBXQ0/+OADLV68WNOnT5ckfeMb39DDDz+strY2xcUFtU4GAOAfGCYIM7DCohYS1SsAgQsoHVVXV2vcuHHex2PGjFFcXJxOnToVsoYBiC1pSTZuQIJglU/7YW5Wmnclmad6BSC0AgpYbW1tstt9L57x8fFqa2sLSaMAwCqs8uk/zMdK4cpsHx4xPBAIrYCvis8884xPyGppadGzzz6rxMSvbg7uu+8+Y1sHACbGYheIVVYKV+2oXgEIVEBXxssuu6zTtm984xuGNwYArIi5WIglVgtXVK8ABCugq+MPf/jDULcDACyJKhZiiVXDFdUrAMFgCUAAiALMxUK0s1q4amemcEX1CggPAhYAQ5ltOE04tN+wErIQrawYrriWAegtAhYAw5jpk95ws9KNK2KLlcMV1zQAvWGdqyUARLmhyXZVSix4gahgxWDVkdnCFcMDgfChggUAUYahgog0K4crhgYC6CsCFgDDcYPSe8zHQqQRrqheAegbAhYAQ5ntxiQSCFmIFCuHq3ZcwwD0lXWvoAAQxfh+LIQTwcq8lXeqV0D4UcECgCg1NNlOFQshR7gy79BAAJFBwAJguLQkm2k/DQ43QhZCiXD1FTOGK6pXQGRwRQWAKNe+fLvEEu4wBsHqK2nJSaYMVwAihwoWgJChimUcFr6AEZyORMJVB2a+RlG9AiKHgAV0gzeo3uMTYeO13xAnJcRHuCWIRR2DFeHK3POueO8CIouABQAxhEoWgkXVqjMzhysAkUfAAhBSZh6CEymZ/c/+TglZ6AlVq87MHq6oXgGRR8ACEDJmvYGJBh0rWQQtnMvpSFRSQjzByg+uTQBCiYAFIOSoYoVGx5tnQhYk38DdXunEV8y+YiDVKyA6ELAAhJSZb2aiBdUsnDvPiqpVZ3zQAyBcCFhAD/hE0Bjc3IQW1SxrIlgFxuzzriTeq4BowpUYQMilJdlU0+SJdDMsof0Gmy8mNreOIZpQ1T3CFYBwo4IFIGyoYoUPwwbNiYpVcKwQrgBEH67MAMKCKlb4eatZ9W7vTTkVrdhExSp4VglXVK+A6MNVGgjA5IHSx19GuhWx7+yNTpJq6psi3RRLIWjFJkJV71klXAGITlyxAYRdWjIhKxIIWtHv3OGcBKvgWSlcUb0CohNXbgBhxVDByCNoRR+qVcYgXAGIBmG9itfV1Wn16tXat2+fUlNTdfPNN2vGjBmd9issLFRJSYn3sdvtVmZmppYvXy5JuvPOO1VTU6O4uLNrdOTm5uqhhx4Kz0kAMARVrMjreCNf2WE7YSs8qFYZy0rhCkB0C+vVfN26dbLb7Vq7dq2OHz+uoqIi5eTkKCsry2e/Bx54wOfxI488ogkTJvhsu++++zRp0qSQtxloxzws47RXsQhZ0aOrqpZE2DIaoSo0rBauqF4B0S1sy7S7XC69//77mjdvnhwOh8aOHaspU6Zo165d3T6vqqpKJSUlmjlzZphaCiAcrHIjFGval/4+d5l3lnrvnY6/P6cj0ef3S7gyBuEKQLQJ29W9oqJC8fHxyszM9G7LycnRwYMHu33erl27NG7cOA0ZMsRn+zPPPKO2tjaNHDlSt9xyi0aMGNHl84uLi1VcXCxJWrJkidLT0/t2In1gt9sj+vroO/uZmpAe32azyW63zk2XralFA5OTdKapNdJNiS02haWfDBvw1WuU1zYpud9X32PW1MLfWVeSEuI7bcvsH6HvfwtTP4mk1KSzv+/ByQkRbkl4XDYyzdDjcV+CQNBPghe2K6/L5VK/fv18tjmdTrlcrm6ft3PnTl133XU+2+6++26NGjVKHo9HW7Zs0WOPPaannnpKycnJnZ6fn5+v/Px87+Pq6uo+nEXfpKenR/T10XfjU0M7TNBut8vtdofuBaLMgH8MFUxJimeoYBAi0U+GOH2DQ2W970IlVh1KeG5lz+PxdKpMRerftNmvJ2nJSfLobOXKzOfZkdH3ENyXIBD0E/86Fo46ClvAcjgcamxs9NnW2Ngoh8Ph9zmHDh1STU2Npk2b5rN97Nix3j9fe+212rlzp0pKSjRlyhRjGw0g5FhVMDb5LJBxzrytdmYLXf6GSTLUL/ysNixQYmggEEvC9q6QkZGh1tZWVVRUKCMjQ5JUVlbWaYGLjt58801NnTq12xAmnR1WBYQLi10Yjy8gjm1dBQx/oUuK/uDV3XwzwlTkEa4ARLuwVrCmTp2qTZs2afHixTp+/Lj27NmjRx99tMv9m5ub9e677+qnP/2pz/bq6mpVV1drzJgxamtr09atW1VbW6vc3NxwnAaAECFkmYu/INJd8GoXygAW6GIdBKnoY8VgBSA2hfUd5I477tCqVau0aNEipaSkaNGiRcrKylJJSYkKCwu1ceNG774ffPCBkpOTNX78eJ9jNDY2at26daqsrFRCQoJGjBihBx54QKmpqeE8FQAhwtLt5hZIcKnscY/Qvj6ij5XDFdUrIPbYPB6PpSY/lJeXR+y1mSRoLqEYJmj2SemBaJ+PRcjyj36CQJilnxCuQof7EgSCfuKfv0UuwvY9WAAQiPabqPabKgDWRbgCEIsIWEAv8eYXOoQsAFYOVwBiGwELQFQiZAHWlJacdPa/JJtlwxUf4AGxjYAF9AFvgqFFyAKshaoV7yuAGRCwAEQ1QhZgDYQrwhVgFgQsoI94Qww9QhZgXgwJPIv3EsA8CFgAYgIhCzAfqlYAzIiABRiATx7Dg5AFmEN71UoiXEm8hwBmQ8ACEFMIWUBs6xisCFeEK8CMCFiAQXiTDB9CFhB7qFp1xvsGYE72SDcAAHrjqxu0szdsNfVNkWsMgG4RrDojXAHmRQULMBBvmOFHNQuIXlStusZ7BWBuBCwAMY+QBUQf5lp1jXAFmB8BCzAYb56R0TFkEbSAyOF7rfzj/QGwBgIWEAK8iUZGxxs6QhYQXgwH7B7vC4B1ELAAmA4hCwgvhgN2j3AFWAurCAIhMnmg9PGXkW6FdbHKIBB6HT/EIFgBwFlUsIAQ4lPLyKOaBRjv3OGAhCv/eB8ArIcKFgDTo5oFGIOKVXAIV4A1UcECQow32OjBSoNA71CxCh7XfsC6CFhAGPBGGz1YaRAIDsEqeFzzAWtjiCAQJix6EV3SkmyqafJ4bx4ZNgh8haGAvUe4AkDAAmBZ7TeOBC3gLIJV3xCuAEgELCCsqGJFJ4IWrI5g1TcEKwAdMQcLCDPeiKPXufOzmKMFs2Pxir7jmg7gXAQsIAJ4Q45uBC2YHcHKGFzLAXSFIYJAhDBcMPoxdBBmwjBAYxGuAPhDwAKAHhC0EMsIVsYjXAHoDgELiCCqWLGFoIVYkZacJJskT1L82ccEK8MQrgD0hIAFRBghK/YQtBCtOlarBicnyO12R7A15kO4AhAIAhYQBQhZscm3KvDVjS1hC+F07iIsVKtCg3AFIFAELCBKTB4oHTgT6Vagt6hqIZwIVeFFuAIQDAIWEEUuG5mm7aXVkW4G+oCqFkKFUBV+BCsAvUHAAqIMwwXNo6uqlkTYQuAIVZFDuALQWwQsIAoRssyl400xYQs9IVRFHuEKQF8QsIAoRcgyp843y4QtEKqiCeEKQF8RsIAoRsgyP39ztiQCl5kRqKIPwQqAUQhYQJQjZFlHd0MJJQJXLCNQRTfCFQAjEbCAGEDIsp5zb8A7Bi6bJE9SPIErSp0bprzbCVVRiXAFwGgELCBGELKsrePNud1uV3V9CxWuKNFVoCJMRT+CFYBQIWABMYSQhXZd38B3vtEndBmHypR5EK4AhBIBC4gx7TcGBC2cK9DQJRG8uuMvSEmEKTMgXAEINQIWEKOoZiEQ/gOB/xBhhfDVXYiSCFJmRLACEC4ELCCGEbLQW90HiO7DR7toDGI9BSeffQlRlkG4AhBOBCwgxhGyYLTAg0fgYSZcCE3oiGAFIBIIWIAJELIQCYQZRDPCFYBIIWABJsHiFwBAsAIQeXGRbgAAY3FzAcCquP4BiAYELMCEuMkAYCWTB3LdAxA9CFiASXHDAcAKuM4BiDYELMDkuPkAYEZ8iAQgWrHIBWABLIABwCwIVQCiHRUswEK4MQEQy7iGAYgFVLAAi6GaBSDWEKwAxBIqWIBFccMCINoxzwpALCJgARbGzQuAaMW1CUCsImAB4EYGQNTggx8AsY45WAAkMTcLQGQRqgCYBQELgA+CFoBwIlgBMBuGCALoEjc9AEKJoYAAzIoKFgC/qGYBMBqhCoDZEbAA9IigBaCvCFYArIKABSBgBC0AwSJYAbAaAhaAoBG0APSEYAXAqghYAHqNoAXgXAQrAFZHwALQZwQtAAQrADiLgAXAMAQtwHoIVgDgi4AFwHAELcDcCFUA4B8BC0DIELQAcyFYAUDPCFgAQo6gBcQ2ghUABI6ABSBsOt6kEbaA6EaoAoDeIWABiAiqWkB0IlgBQN8QsABEFFUtIPIIVQBgHAIWgKhBVQsIH0IVAIRGWANWXV2dVq9erX379ik1NVU333yzZsyY0Wm/wsJClZSUeB+73W5lZmZq+fLlkqSqqiqtXr1apaWlSk9P14IFCzRp0qSwnQeA0KKqBYQOwQoAQiusAWvdunWy2+1au3atjh8/rqKiIuXk5CgrK8tnvwceeMDn8SOPPKIJEyZ4H69YsUIXXnih7r//fv3lL3/Rk08+qaefflr9+/cPy3kACB+qWkDfEaoAIHziwvVCLpdL77//vubNmyeHw6GxY8dqypQp2rVrV7fPq6qqUklJiWbOnClJKi8v17Fjx3TjjTcqMTFR06ZNU3Z2tt57771wnAaACJk88Kv/APTsspFp/JsBgAgIWwWroqJC8fHxyszM9G7LycnRwYMHu33erl27NG7cOA0ZMkSSdOLECQ0dOlT9+vXzOc6JEye6fH5xcbGKi4slSUuWLFF6enpfT6XX7HZ7RF8f0Y8+EpgrO/yKdh6riVg7IsVms8luZwotOrtsZJr3z1xP0BP6CAJBPwle2N6hXS6XTyiSJKfTKZfL1e3zdu7cqeuuu87nOE6ns9NxTp061eXz8/PzlZ+f731cXV0dbNMNk56eHtHXR/SjjwRvfOpXf7bKMEK73S632x3pZiAKnFud6nj94HqCntBHEAj6iX8dC0cdhS1gORwONTY2+mxrbGyUw+Hw+5xDhw6ppqZG06ZN8zlOQ0NDp+OcG94AWM+5N5tWCVywFob8AUB0C9scrIyMDLW2tqqiosK7raysrNMCFx29+eabmjp1qk8IGz58uKqqqnzCWllZmYYPHx6ahgOIWczbglnQlwEgdoQtYDkcDk2dOlWbNm2Sy+XSoUOHtGfPHu/iFedqbm7Wu+++q1mzZvlsz8zM1IgRI/Tyyy+rublZH3zwgcrKynyqXABwro43qNykItrRXwEgdoUtYEnSHXfcoebmZi1atEgrVqzQokWLlJWVpZKSEn3/+9/32feDDz5QcnKyxo8f3+k4P/rRj3T06FHdfvvteuGFF/STn/yEJdoBBIWbV0QTAhUAmIfN4/F4It2IcCovL4/YazNJED2hj0SHaJ+7xSIXsS8cIYrrCXpCH0Eg6Cf+RXyRCwCIFSyWAaNRlQIA6yBgAUAPuro5JnTBH8IUAFgbAQsAeoHQBYkwBQDojIAFAAYhdJkXQQoAECgCFgCEkL8bc4JXdCJIAQD6ioAFABHQ3Y084Su0CFEAgFAiYAFAlOkpAKSnp2l7KUvm+kOAAgBEEgELAGJQMCEi1itiBCYAQCwhYAGAyRFQAAAIn7hINwAAAAAAzIKABQAAAAAGIWABAAAAgEEIWAAAAABgEBa5+AeXy6XW1lbZbLaQvUZlZaWamppCdnxEJ4/Ho/j4eDkcjkg3BQAAACFGwJLU0tIiSUpOTg7p69jtdsXHx4f0NRCdXC6XWlpalJCQEOmmAAAAIIQYIiipublZSUlJkW4GTCwpKUnNzc2RbgYAAABCjID1D6EcGgjQvwAAAKyBgCVufhEe9DMAAADzI2ABAAAAgEEIWAAAAABgEAJWDNm+fbu2b98e6WaEhZXOFQAAAObBMu0x4tSpU1q6dKkk6ZJLLtGgQYMi3KLQsdK5AgAAwFyoYMWIZcuW6cEHH9T999+vZcuWRbo5IWWlcwUAAIC52DwejyfSjQin8vLyTtsaGhrkdDpD/tp2u11utzvkr4PoFEg/S09PV3V1dZhahFhFP0Eg6CfoCX0EgaCf+JeZmdnldipYAAAAAGAQAlYf/LWyQecWAD0ej/5a2RChFgEAAACIJAJWL+3+65d6ZW+lfr+/2huyPB6Pfr+/Wq/srdTuv35p2GvV1NRo2LBhuuCCCzR69Gh97Wtf09q1a4M6xpdffqmFCxdqzJgxysvL0+bNm7vc74ILLvD5LysrSw899JD3559++qm+//3v66KLLtLFF1+sBx980GfYY0/PD+Y88/Ly9Jvf/Cao8wzmXAM5n7vvvluXXHKJcnNzNWPGDL344ovenzU1Nemee+5RXl6eLrzwQl111VX605/+FHR7AQAAYB6sItgLf61s0FtHaiRJ+0/USZLmTkzXlv3V3sdvHanR0AFJunBo3+d2HThwQIMHD9a+ffskSdu2bdOCBQv0rW99y+/Yz3M9+OCDSkhI0Mcff6wDBw7o1ltv1UUXXaTc3Fyf/UpLS71/rq+v18UXX6x//ud/9m574IEHNHjwYP3lL39RbW2tvve97+m5557TwoULA3p+T+c5aNAg7d+/X5K0efNm/ehHP9I3v/nNoFYSDPRcAzmfu+66S8uWLVNSUpKOHDmi66+/XhMmTNCkSZPU2tqqzMxMvfLKKxo2bJi2b9+uxYsXa/v27crKygq4vQAAADAPKli9cMGQfpo4PMX7eP+JOj3+h+PecCVJE4en6IIh/Qx5vQMHDmjy5Mnex5dccokkqaWlJaDnNzQ0aMuWLfrpT3+q5ORk5eXl6aqrrtIrr7zS7fN+//vfKz09XVOnTvVu+/vf/65vf/vbcjgcGjJkiGbNmqXDhw8H/PzuHDhwQBMnTvQ+njZtmlpbW1VTUxPQ86Xgz7Wn88nNzVVSUpL3sc1m0/HjxyVJTqdT99xzj7KyshQXF6errrpK2dnZ3iAMAAAA66GC1Qs2m03fmpguST6hqt3E4Sn61sR02Ww2Q17vk08+8Yaq06dP6/HHH9ekSZOUnZ2tW2+9VXv27Onyef/0T/+k559/XkePHlV8fLxGjx7t/dn48eP17rvvdvu6L7/8sq6//nqf87jjjjv0+uuv69JLL1VNTY127Nihn/70pwE/v6fzbA9Yp0+fVlFRkSZNmqSRI0dKUkjONZDzuf/++/XSSy/J5XJpwoQJuvLKK7s81ueff66jR492WSkDAACANRCweslms2nuxPQuA9ZcA8OVJB08eFB/+MMf9Mtf/lIDBgzQpZdeql/96ley2Wx6/vnne3x+fX29UlNTfbalpqaqvr7e73NOnDih9957T8uXL/fZPm3aNL3wwgvKzc1Va2urbrjhBl199dUBP787Bw8e1JYtW/SrX/1KdXV1mjVrll544QXv7zIU5xrI+RQVFenRRx/V3r179c477ygxMbHTcVpaWnTXXXfp+uuv15gxYwI9ZQAAAJgMQwR7yePxaMv+rr8TYEuHhS/6qqmpSaWlpdq5c6cOHDigd955R8uWLdPQoUMDPkZycrLOnDnjs+3MmTNKTk72+5zf/va3ysvLU3Z2tndbW1ub5s+frzlz5qi0tFT79+/X6dOn9dhjjwX0/O60n2dxcbEOHz6sNWvW6C9/+Yvs9uA+AwjmXIM5n/j4eOXl5amioqJT0Gtra1NBQYESExO7fC4AAACsg4DVC+2rBXZVvZLODhv8vUEh6/Dhw3I6nX4Xs7jllls6rdzX/t8tt9wiSRo1apRaW1t19OhR7/MOHjzY7VC23/72t7rhhht8ttXU1Oizzz7T7bffrqSkJA0aNEjz5s3rcuW8rp7f03kmJSUpJydHkvStb31Lw4YN05YtW0J2rsGcT7vW1laVlZV5H3s8Ht1zzz36/PPPtWbNGiUkJAR8zgAAADAfhgj2QmlVY6cFLc5dRXD/iTpdODS5z6sIfvLJJ7rwwgv9/vzXv/51j8dwOp2aM2eOli1bpmXLlunAgQP64x//qNdff73L/ffs2aOTJ092Wv1v0KBBys7O1vPPP6/Fixervr5eL7/8ssaNGxfQ83/84x9Lkp566im/59lxaOUVV1yhP/7xj7rppptCcq49nU91dbXefvtt5efny+FwaPfu3Xrttde0atUq7zF+9rOfqbS0VJs2bVK/fsYsagIAAIDYRQWrFy4c6tSMMWmSvlrQIu4fC1+0ry44Y0yaYUu0G7FoQmFhoVwulyZNmqQf/vCHKioq8h73lltu0dNPP+3d9+WXX9acOXOUkpLS6Thr167Vm2++qUmTJmn69Omy2+165JFHfPbx9/zy8nL90z/9U5ftO3DggC666CKfbbNmzdKuXbvkcrkMO9dzz7e782mf4zZlyhRddNFF+sUvfqGf//znmj17tqSz88x+/etf6+DBg7r44ou91bRXX301qPYCAADAPGweoyYLxYjy8vJO2xoaGuR0Bh+G/lrZoAuG9POpung8HpVWNXYZrux2u8+X2FpJc3OzrrrqKhUXF1t2GF0g/Sw9PV3V1V3P7QPa0U8QCPoJekIfQSDoJ/75m8LDEME+6CpE2Ww2QypXZpOYmKidO3dGuhkAAABASDFEEAAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAAAAAwCAELAAAAAAwCF807MfLJbX6vMFt6DFtNps8Ho8k6TynXTeM6x/Q8zZs2KCXXnpJhw4d0ne+8x099dRTfWrH5s2btWbNGh05ckQpKSkaP368CgoKlJeXp6lTp+qJJ57QzJkz+/QaAAAAgBURsPz4vMGtozXGBqzeGjp0qH70ox/pzTfflMvl6tOxnn32Wa1cuVJLlizRrFmzlJCQoB07dmjbtm3Ky8szqMUAAACANRGwYsDcuXMlSR9//LEqKip8ftbS0qLly5dr8+bNOnnypNzus6Fw3LhxKi4u9tm3trZWy5Yt05NPPuk9piTNnj1bs2fPDvFZAAAAAOZHwIpxS5cu1bvvvqtXX31VAwcO1O23367U1FQ9/PDDnfbdu3evmpqaNGfOnAi0FAAAADA/FrmIYXV1dVq/fr2efvppDRs2TE6nU3PnzlVNTY1ycnI67f/ll19q0KBBstvJ1QAAAEAoELBi2Hvvvafs7GyNGjXKu+306dM677zzutx/4MCBOnXqlHcYIQAAAABjEbBi2BdffKEBAwZ4H3s8Hm3dulX5+fld7v/1r39diYmJ2rp1a7iaCAAAAFgKASsGuN1uuVwutbW1qbW1VS6XS263W2PHjtX+/fv1ySefqLGxUUVFRbLZbLrmmmu6PE7//v1177336sEHH9TWrVvV2NiolpYW/elPf9Kjjz4a5rMCAAAAzIfJOH6c5zT+V3Pu92AFasWKFXryySe9j1999VX95Cc/0T333KOCggLdeuut8ng8uuyyy7Rx40YlJCT4PdbixYs1ZMgQrVixQnfddZdSUlI0ceJEFRQU9P7EAAAAAEiSbJ72O36LKC8v77StoaFBTqcz5K9tt9uZ/2RhgfSz9PR0VVdXh6lFiFX0EwSCfoKe0EcQCPqJf5mZmV1uZ4ggAAAAABiEgAUAAAAABiFgAQAAAIBBCFgAAAAAYBACFgAAAAAYhIAFAAAAAAYhYAEAAACAQQhYAAAAAGAQAhYAAAAAGMQe6QZEq7c+a9Lp5jZDj2mz2eTxeCRJAxLjNGNYUo/PaWpq0gMPPKDdu3erpqZGOTk5uv/++3XFFVf0uh2bN2/WmjVrdOTIEaWkpGj8+PEqKChQXl6epk6dqieeeEIzZ87s9fEBAAAAqyJg+XG6uU0nGzwGH7Xj8QILb62trcrMzNQrr7yiYcOGafv27Vq8eLG2b9+urKysoFvw7LPPauXKlVqyZIlmzZqlhIQE7dixQ9u2bVNeXl7QxwMAAADwFQJWlHM6nbrnnnu8j6+66iplZ2dr3759ysrKUktLi5YvX67Nmzfr5MmTcrvdkqRx48apuLjY51i1tbVatmyZnnzySc2dO9e7ffbs2Zo9e3Z4TggAAAAwMQJWjPn888919OhR5ebmSpKWLl2qd999V6+++qoGDhyo22+/XampqXr44Yc7PXfv3r1qamrSnDlzwt1sAAAAwBJY5CKGtLS06K677tL111+vMWPGqK6uTuvXr9fTTz+tYcOGyel0au7cud65Wuf68ssvNWjQINnt5GoAAAAgFAhYMaKtrU0FBQVKTEzUY489Jkl67733lJ2drVGjRnn3O336tM4777wujzFw4ECdOnXKO4wQAAAAgLEIWDHA4/Honnvu0eeff641a9YoISFBkvTFF19owIABPvtt3bpV+fn5XR7n61//uhITE7V169awtBsAAACwGgJWDPjZz36m0tJSPffcc+rXr593+9ixY7V//3598sknamxsVFFRkWw2m6655pouj9O/f3/de++9evDBB7V161Y1NjaqpaVFf/rTn/Too4+G63QAAAAA02Iyjh8DEuMU6FLqgTr3e7ACceLECf36179WUlKSLr74Yu/2xx9/XN/97ndVUFCgW2+9VR6PR5dddpk2btzorXB1ZfHixRoyZIhWrFihu+66SykpKZo4caIKCgr6dG4AAAAAJJun/Y7fIsrLyztta2hokNPpDPlr2+125j9ZWCD9LD09XdXV1WFqEWIV/QSBoJ+gJ/QRBIJ+4l9mZmaX28Nawaqrq9Pq1au1b98+paam6uabb9aMGTO63Pfo0aN67rnndPToUTkcDl177bXe72668847VVNTo7i4s1Wg3NxcPfTQQ2E7DwAAAADoSlgD1rp162S327V27VodP35cRUVFysnJUVZWls9+tbW1Kiws1G233aZp06bJ7Xbriy++8Nnnvvvu06RJk8LZfAAAAADoVtgWuXC5XHr//fc1b948ORwOjR07VlOmTNGuXbs67fu///u/mjx5sr7xjW8oISFB/fr10/Dhw8PVVAAAAADolbBVsCoqKhQfH+8zVjEnJ0cHDx7stG9paamys7P10EMP6eTJkxozZozuuOMOpaene/d55pln1NbWppEjR+qWW27RiBEjwnEaAAAAAOBX2AKWy+XyWWJckpxOp1wuV6d9T506pWPHjumhhx5Sdna2fv3rX2vFihX6xS9+IUm6++67NWrUKHk8Hm3ZskWPPfaYnnrqKSUnJ3c6VnFxsYqLiyVJS5Ys8Qlp7SorK2W3h+dXEa7XQfRJSkrqsv91ZLfbe9wHoJ8gEPQT9IQ+gkDQT4IXtrt9h8OhxsZGn22NjY1yOByd9k1MTFReXp7GjBkjSbrhhhu0cOFC7ypsY8eO9e577bXXaufOnSopKdGUKVM6HSs/P9/ni3e7WgWlqalJ8fHxvT63QLGKoLU1NTX1uAoPK/UgEPQTBIJ+gp7QRxAI+ol//lYRDNscrIyMDLW2tqqiosK7raysrNMCF5KUnZ3t89hms3V77J5+DgAAAADhELaA5XA4NHXqVG3atEkul0uHDh3Snj17NHPmzE77Xn755dqzZ4+OHz8ut9ut3/72txo7dqycTqeqq6t16NAhud1uNTc364033lBtba1yc3PDdSoAAAAA0KWwTgi64447tGrVKi1atEgpKSlatGiRsrKyVFJSosLCQm3cuFGSNGHCBH3ve99TUVGRmpublZubq4KCAklnhxWuW7dOlZWVSkhI0IgRI/TAAw8oNTU1nKcCAAAAAJ3YPB6PJ9KNCKfy8vJO29rndnV0pFZqbDX2tW02m9p/3f3ipTH9A3ve3XffrbfeeksNDQ0677zz9MMf/lA333xzr9uxefNmrVmzRkeOHFFKSorGjx+vgoIC5eXlaerUqXriiSe6rCyib7rqZ+dinDMCQT9BIOgn6Al9BIGgn/jnbw4WS9r50dgqnXGHYm5X+zEDz7V33XWXli1bpqSkJB05ckTXX3+9JkyY0KsvWn722We1cuVKLVmyRLNmzVJCQoJ27Nihbdu2KS8vL+jjAQAAAPgKASsGnDu/zGaz6fjx45o0aZJaWlq0fPlybd68WSdPnvSuUjhu3Djv8vTtamtrtWzZMj355JOaO3eud/vs2bM1e/bs0J8IAAAAYHIErBhx//3366WXXpLL5dKECRN05ZVXSpKWLl2qd999V6+++qoGDhyo22+/XampqXr44Yc7HWPv3r1qamrSnDlzwt18AAAAwBLCtoog+qaoqEh//etftXnzZs2ZM0eJiYmqq6vT+vXr9fTTT2vYsGFyOp2aO3euampqlJOT0+kYX375pQYNGsSXHQMAAAAhQsCKIfHx8crLy1NFRYWef/55vffee8rOztaoUaO8+5w+fVrnnXdel88fOHCgTp06xZcdAwAAACFCwIpBra2tKisr0xdffKEBAwZ4t3s8Hm3dulX5+fldPu/rX/+6EhMTtXXr1nA1FQAAALAUAlaUq66u1uuvv676+nq1trbqzTff1GuvvaYZM2Zo7Nix2r9/vz755BM1NjaqqKhINptN11xzTZfH6t+/v+699149+OCD2rp1qxobG9XS0qI//elPevTRR8N8ZgAAAID5MBnHj37xUjBLqQfi3O/BCvQ5zz//vH72s5+pra1Nw4cP189//nPvqn8FBQW69dZb5fF4dNlll2njxo1KSEjwe7zFixdryJAhWrFihe666y6lpKRo4sSJ3i9yBgAAANB7fNGwAvsCWCPY7XbmP1kYXzQMo9BPEAj6CXpCH0Eg6Cf++fuiYYYIAgAAAIBBCFgAAAAAYBACFgAAAAAYhIAlyWLT0BAh9DMAAADzI2D9Aze/CCX6FwAAgDUQsCQlJiaqqakp0s2AiTU1NSkxMTHSzQAAAECI8T1YkhISEtTa2qr6+nrZbLaQvU5SUhJBzoI8Ho/i4+O7/X4yAAAAmAMB6x8cDkfIX4PvEQAAAADMjSGCAAAAAGAQAhYAAAAAGISABQAAAAAGIWABAAAAgEFsHr6gBwAAAAAMQQUrjH72s59FugmIcvQRBIJ+gkDQT9AT+ggCQT8JHgELAAAAAAxCwAIAAAAAgxCwwig/Pz/STUCUo48gEPQTBIJ+gp7QRxAI+knwWOQCAAAAAAxCBQsAAAAADELAAgAAAACDELAAAAAAwCD2SDcgltXV1Wn16tXat2+fUlNTdfPNN2vGjBmd9issLFRJSYn3sdvtVmZmppYvXy5Jqqqq0urVq1VaWqr09HQtWLBAkyZNCtt5ILSM6id33nmnampqFBd39nOR3NxcPfTQQ+E5CYRcoP2kpaVFGzZs0J49e+R2u5Wbm6sf/OAHGjRoUFDHQewxqo888sgjKi0t9V5LBg0apBUrVoT1XBA6gfaT+vp6bdiwQR999JEkafbs2brxxhu9P+fexNyM6ifcm3SNgNUH69atk91u19q1a3X8+HEVFRUpJydHWVlZPvs98MADPo8feeQRTZgwwft4xYoVuvDCC3X//ffrL3/5i5588kk9/fTT6t+/f1jOA6FlVD+RpPvuu483OJMKtJ9s2bJFpaWleuKJJ+R0OrVmzRqtX79e9957b1DHQewxqo9I0oIFC3TllVeG+xQQBoH2k+eee07Nzc1auXKlTp8+rV/84hc677zzdPnll0vi3sTsjOonEvcmXWGIYC+5XC69//77mjdvnhwOh8aOHaspU6Zo165d3T6vqqpKJSUlmjlzpiSpvLxcx44d04033qjExERNmzZN2dnZeu+998JxGggxo/oJzC2YflJVVaXJkycrLS1NiYmJuvTSS/Xpp58GfRzEFqP6CMwtmH6yd+9eXXPNNUpKStKQIUN0+eWXa8eOHZK4NzE7o/oJ/CNg9VJFRYXi4+OVmZnp3ZaTk9Pjm9iuXbs0btw4DRkyRJJ04sQJDR06VP369fM5zokTJ0LTcISVUf2k3TPPPKOFCxfq0Ucf1fHjx0PRZERAMP3kiiuu0OHDh3Xq1Ck1NTVp9+7duuSSS4I+DmKLUX2k3YsvvqiFCxfq4Ycf1oEDB0LefoRHX68B7ftxb2JuRvWTdtybdMYQwV5yuVw+Fx5Jcjqdcrlc3T5v586duu6663yO43Q6Ox3n1KlTxjUWEWNUP5Gku+++W6NGjZLH49GWLVv02GOP6amnnlJycrLh7UZ4BdNPMjIyNHjwYC1evFhxcXHKzs7WwoULgz4OYotRfUSS5s+fr+HDh8tut+vtt9/W448/rqVLl+r8888P+XkgtILpJ5MnT9Zrr72mO++8U6dPn9aOHTvU1NTkPQ73JuZlVD+RuDfxhwpWLzkcDjU2Nvpsa2xslMPh8PucQ4cOqaamRtOmTfM5TkNDQ6fjnNvxEZuM6ieSNHbsWCUmJiopKUnXXnutkpOTfRbFQOwKpp+sW7dOLS0tWr9+vTZu3Ki8vDwVFhYGfRzEFqP6iCRdcMEF6tevnxISEjRr1izl5ubqww8/DPk5IPSC6ScLFixQYmKiCgoKtHTpUk2fPl2DBw/2Hod7E/Myqp9I3Jv4Q8DqpYyMDLW2tqqiosK7raysrNuJ5G+++aamTp3q04GHDx+uqqoqn45eVlam4cOHh6bhCCuj+klXbDabYe1EZAXTT8rKyjRr1iylpKQoISFBc+bM0ZEjR1RbW9ur/obYYFQf6YrNZpPH4wlZ2xE+wfSTlJQUFRQUaO3atXryySfV1tam0aNHS+LexOyM6idd4d7kLAJWLzkcDk2dOlWbNm2Sy+XSoUOHtGfPHr+LEjQ3N+vdd9/VrFmzfLZnZmZqxIgRevnll9Xc3KwPPvhAZWVlnaoXiE1G9ZPq6modOnRIbrdbzc3NeuONN1RbW6vc3NwwnAVCLZh+Mnr0aO3cuVMNDQ1yu93atm2bBg4cqP79+wfd3xA7jOoj9fX1+uijj9Tc3KzW1lbt3r1bJSUluvjii8N/UjBcMP3k5MmTOnPmjNra2vThhx9q+/bt3qHp3JuYm1H9hHsT/2wePrbqtbq6Oq1atUr79+9XSkqK5s+frxkzZqikpESFhYXauHGjd9+33npLL774olauXNkp3VdVVWnVqlXe75pYuHAhy12aiBH95NNPP9WKFStUWVmphIQEjRgxQvPnz+/2UyTElkD7yZkzZ7Rhwwbt27dPbrdbWVlZuu222zRmzJhuj4PYZ0Qfqa2tVVFRkT777DPFxcVp2LBhmjdvHu85JhJoP3nnnXf03HPPqb6+XhkZGZo/f75P0ObexNyM6Cfcm/hHwAIAAAAAgzBEEAAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADELAAgAAAACDELAAADDAypUrtWTJEr+PAQDWYI90AwAA6KuVK1dq586dkqS4uDgNHDhQX/va1/S9731PKSkpEW4dAMBKCFgAAFOYOHGi7r77brW2turEiRNavXq16uvr9eMf/zjSTQMAWAgBCwBgCgkJCUpLS5MkDR48WJdeeqnefPNN78937NihN954Q1VVVUpPT9dVV12luXPnKi7u7Gj5hoYGvfDCC9qzZ4/q6+s1ZMgQ3XDDDbr00kt15swZ/fKXv9ShQ4d05swZDR06VN/+9rd1+eWXR+BMAQDRjIAFADCdyspKffTRR4qPj5ckFRcX66WXXtKCBQs0atQo/f3vf9ezzz4ru92uq6++Wh6PR0VFRaqrq9MPf/hDZWRkqLy8XC0tLZKklpYWjRo1Sv/yL/+ifv36af/+/VqzZo3S09M1ceLESJ4qACDKELAAAKbw0Ucf6fvf/77a2tq8wejWW2+VJL3yyiu65ZZbNG3aNEnSkCFDVFlZqW3btunqq6/W/v379de//lXLly/X8OHDJUlDhw71HnvQoEG65pprvI+HDh2qTz75RG+//TYBCwDgg4AFADCFcePG6d/+7d/U3Nys4uJiVVZWau7cuaqtrdUXX3yhNWvWaO3atd7929ra5PF4JEnHjh1TWlqaN1ydq62tTa+99preeecdnTp1Si0tLXK73Ro/fnxYzg0AEDsIWAAAU0hKStL5558vSVqwYIF+/vOf67e//a1mz54tSVq0aJFyc3N7dew33nhDv/vd73T77bcrOztbDodDL774ompraw1rPwDAHPgeLACAKV1//fV6/fXX1dbWpoEDB6qyslLnn39+p/8kaeTIkaqpqdGJEye6PNahQ4f09a9/XTNnztSIESM0dOhQVVRUhPN0AAAxggoWAMCUxo8fr+HDh+vVV1/VjTfeqPXr18vpdOprX/ua3G63jh07plOnTunaa6/VhAkTNGbMGC1fvly33XabMjMzdfLkSblcLuXl5SkzM1PvvPOODh06pNTUVP3hD39QVVWVRo4cGenTBABEGQIWAMC0vv3tb2vVqlVasWKF/v3f/12/+93v9Jvf/EaJiYkaPny4rr76aklnv5z4gQce0MaNG/XMM8/I5XJ5l2mXpO9+97uqqqpSYWGhEhMTNWvWLH3jG9/wW/ECAFiXzdM+wxcAAAAA0CfMwQIAAAAAgxCwAAAAAMAgBCwAAAAAMAgBCwAAAAAMQsACAAAAAIMQsAAAAADAIAQsAAAAADAIAQsAAAAADPL/Aa1DIk4UQug3AAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = pr_err.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a64db9d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# we can set any arbitraty number of levels\n",
+    "ax = pr_err.plot(levels=np.linspace(0.01, 0.99, 7), equal_aspect=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b9efd4a",
+   "metadata": {},
+   "source": [
+    "The specifc discrimination threshold can easily be added to a precision recall plot\n",
+    "\n",
+    "Here we use `mmu.auto_thresholds`, a utility function that computes all the thresholds that result in a different confusion matrix, much like sklearn's `precision_recall_curve` does. \n",
+    "\n",
+    "Although optimial, for large test sets it can become inconvenient to have so many thresholds. `mmu.auto_thresholds` takes the optional `max_steps` parameter which limits the number points in the thresholds. It does so by performing weighted sampling where points close to each other increase the probability of being selected."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7faf3b2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thresholds = mmu.auto_thresholds(y_score)\n",
+    "prec, rec = mmu.precision_recall_curve(y_test, y_score, thresholds)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "5adfb2f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax.plot(rec, prec, zorder=4)\n",
+    "ax = pr_err.plot(ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5414f9ca",
+   "metadata": {},
+   "source": [
+    "**Combining threshold plots**\n",
+    "\n",
+    "To compare two thresholds or compare the uncertainties of two model you can plot them together quite easily."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "0de18a8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pr_err_alt = mmu.PRU.from_scores(y_test, y_score, threshold=0.53)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "ax = pr_err.plot(ax=ax, other=pr_err_alt, other_kwargs={'alpha': 0.6})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e0e4cf5",
+   "metadata": {},
+   "source": [
+    "Configuration\n",
+    "\n",
+    "The most import setting when it comes to the computation of the uncertainty is the number standard deviations (`n_sigmas`) from the precision, recall that determine the boundaries of the grid. By default `n_sigmas` is 7, this can often be made smaller.\n",
+    "\n",
+    "A too small value for `n_sigmas` can be recognised by straight cuts in the uncertainty contour. Here we artificially set the `n_sigmas` too low to demonstrate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "3b3455a0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.65, 0.875)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2AAAAI9CAYAAABc9Rs5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABqUUlEQVR4nO3de3xU9Z3/8fckk2TIBRJIAwkkQcByB61AWMtNG21lq67rBQXRCsJSRNqu9tF6a21XAwrYIgUqIKhU/KH1gnWtdIMSwAtSq3ILFBcTxcSEiLlnkkwyvz/YjJlMSDLJzJk5M6/n48FD58yZM9+Tb+bMeefzPd9jcTqdTgEAAAAA/C4i0A0AAAAAgHBBAAMAAAAAgxDAAAAAAMAgBDAAAAAAMAgBDAAAAAAMQgADAAAAAIMQwAAAAADAIFYj36y6ulrr16/XwYMHlZCQoNmzZ2vKlCke6zU2NmrLli06cOCAHA6Hhg8froULF6pv376SpLlz57qt39DQoO9///uaN2+eSktLtWTJEsXExLiev/rqq3Xdddf5d+cAAAAAoBOGBrBNmzbJarVq48aNKigo0LJly5SZman09HS39V5//XWdOHFCK1asUGxsrDZs2KDNmzfr7rvvliRt3brVta7dbteCBQs0efJkt2089dRTioyM9P9OAQAAAEAXGTYE0W63a//+/Zo1a5ZsNptGjBihCRMmaM+ePR7rlpaWavz48UpMTFR0dLQuvvhiff755+1u97333lOfPn00cuRIf+8CAAAAAPSIYRWw4uJiRUZGKi0tzbUsMzNTR48e9Vj30ksv1VNPPaUzZ84oLi5Oe/fu1YUXXtjudvPy8jRt2jRZLBa35YsXL5bFYtG4ceN08803q3fv3h6vzc3NVW5uriRp+fLlPdk9AAAAAOiUYQHMbrerV69ebstiY2Nlt9s91k1NTVW/fv20aNEiRUREKCMjQ/Pnz/dY7/Tp0zp69Kh+/OMfu5b17t1by5Yt0+DBg1VVVaUnn3xSa9as0X333efx+uzsbGVnZ7seFxUV9WQXEQDJyckqKysLdDPgJfrNnOg3c6LfzIc+Myf6zZz81W+ti05tGTYE0Wazqa6uzm1ZXV2dbDabx7qbNm1SY2OjNm/erK1bt2rSpEnKycnxWG/Pnj0aMWKEUlJS3N5n6NChioyMVGJioubPn6+PP/7Y470BAAAAwGiGBbDU1FQ1NTWpuLjYtaywsNBjAo6W5TNmzFB8fLyioqJ0xRVX6JNPPlFlZaXbenv27NH06dO79P5Op7NnOwAAAAAAPWRoBSwrK0vbt2+X3W7XsWPHdODAAU2bNs1j3aFDhyovL0+1tbVyOBzauXOnkpKS3K7jOn78uM6cOaN/+Zd/cXvtiRMnVFRUpObmZlVVVWnLli0aPXq0YmNj/b6PAAAAANARQ6ehv/3227Vu3TotWLBA8fHxWrBggdLT05Wfn6+cnBzX9PJz587Vli1btHTpUjkcDqWnp+vnP/+527by8vI0adIkj+vKSkpK9Nxzz6myslK9evXSuHHj9JOf/MSwfQQAAACAc7E4GZvnwiQc5sMFr+ZEv5kT/WZO9Jv50GfmRL+ZU0hPwgEAAAAA4Y4ABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABiEAAYAAAAABiGAAQAAAIBBCGAAAAAAYBACGAAAAAAYhAAGAAAAAAYhgAEAAACAQQhgAAAAAGAQAhgAAAAAGIQABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABiEAAYAAAAABiGAAQAAAIBBCGAAAAAAYBBroBsAADCHvE/L5XAEuhXwlrUqdPttfFKgWwAA3iOAAQAkSR9/3fHzVr4xEGQ6+p0lnAEIVnydAkCY6CxgAaGEcAYgWBHAACBEELCArjnXZ4VgBsAIBDAAMBFCFuA/7X2+CGUAfI0ABgBBhpAFBA9CGQBfI4ABQIAQtABzIpQB6AkCGAD4GUELCH1tP+cEMgDnQgADAB8haAFoQSADcC4EMADoBsIWAG8QyAC0IIABQAcIWgD8gUAGhC8CGAD8H8IWgEBpffyxVpVrdELg2gLAvwhgAMISYQtAMGt9jKI6BoQWAhiAkEfYAmBmDFcEQgsBDEDIIXABCGVUxwBzI4ABMDXCFoBwRhgDzIcABsBUCFwA0D7CGGAOBDAAQYuwBQDdQxgDghcBDEDQIHABgO8RxoDgQgADEDAELgAwVstxlyAGBA4BDIBhWr74rVXlcjgC2xYACGdUxYDAIYAB8BsqXAAQ/KiKAcYigAHwGQIXAJgXVTHAGAQwAN1G4AKA0ERVDPAfAhiALiNwAUB4IYgBvkcAA9AhQhcAgOGJgO8QwAC4IXABADpCVQzoGQIYAEIXAMBrBDGgewwNYNXV1Vq/fr0OHjyohIQEzZ49W1OmTPFYr7GxUVu2bNGBAwfkcDg0fPhwLVy4UH379pUkPfjggzpx4oQiIiIkSX379tXq1atdr9+3b5+2bdumqqoqjR07VosXL1Z8fLwxOwmYAIELAOArBDHAO4YGsE2bNslqtWrjxo0qKCjQsmXLlJmZqfT0dLf1Xn/9dZ04cUIrVqxQbGysNmzYoM2bN+vuu+92rTNv3jx973vf83iPzz//XBs2bNAvf/lLDRkyRE888YQ2bdqkn/70p/7ePSCoEboAAP5EEAO6JsKoN7Lb7dq/f79mzZolm82mESNGaMKECdqzZ4/HuqWlpRo/frwSExMVHR2tiy++WJ9//nmX3mfv3r266KKLNGrUKNlsNs2aNUv79+9XXV2dr3cJCGoff+3+DwAAI/C9A3TMsApYcXGxIiMjlZaW5lqWmZmpo0ePeqx76aWX6qmnntKZM2cUFxenvXv36sILL3RbZ9u2bdq2bZvS0tJ04403avTo0ZKkU6dO6dvf/rZrvQEDBshqtaq4uFhDhgxx20Zubq5yc3MlScuXL1dycrLP9hfGsFqt9FsreZ+Wu/7fGsRXeFosFlmDuYFoF/1mTvSb+YRKnx2pOvvf6eclBrQdRuGcxJwC0W+Gfbrtdrt69erltiw2NlZ2u91j3dTUVPXr10+LFi1SRESEMjIyNH/+fNfzc+bM0aBBg2S1WvX222/rkUce0aOPPqoBAwbIbrcrNjbW433aq4BlZ2crOzvb9bisrKynuwmDJScnh32/mfGvjFarVQ6HI9DNgJfoN3Oi38wn1Pps14mysBiWyDmJOfmr31oXndoybAiizWbzCEF1dXWy2Wwe627atEmNjY3avHmztm7dqkmTJiknJ8f1/Pnnn69evXopKipKM2bM0PDhw/Xhhx92+D5twx9gZgwtBACYCd9ZwDcMC2CpqalqampScXGxa1lhYaHHBBwty2fMmKH4+HhFRUXpiiuu0CeffKLKysp2t22xWOR0OiVJgwYNUmFhoeu5kpISNTY2KjU11cd7BBiL0AUAMDu+xwCDK2BZWVnavn277Ha7jh07pgMHDmjatGke6w4dOlR5eXmqra2Vw+HQzp07lZSUpN69e6umpkYfffSRGhoa1NTUpL179yo/P18XXHCBJGnq1Kn64IMPlJ+fL7vdru3btysrK4sKGEyJ0AUACEV8tyGcWZwtpSMDVFdXa926dTp06JDi4+M1Z84cTZkyRfn5+crJydHWrVslSVVVVdqyZYsOHjwoh8Oh9PR03XrrrRo2bJgqKyu1bNkyffHFF4qIiNDAgQM1a9YsjRs3zvU++/bt07PPPqvq6mqv7gNWVFTkt32Hf4TieOtw+EIKtesbwgX9Zk70m/mEW5+FyvVhoXhOEg4CcQ2YoQEs2BHAzCdUDnbhELpaC7eTi1BBv5kT/WY+4dpnZg9ioXJOEm4CEcDMP8cpYFLhFroAAOgIN3JGuCCAAQYidAEA0LGPvyaEIbQRwAA/I3QBAOAdqmEIZQQwwA8IXUBwKq8392XPiTGWQDcBMBTVMIQiAhjgI4QuwP98EaDKa+p90JJAifH6FZb6RjlFeIN5UQ1DqCGAAT1E8AJ6xptQZe7w1HPd2X+r1ar4mMgu/5wJaghWVMMQKghgQDcQuoDOdfWEP9xDlRG6+jNOjIvptN8IaAgkQhhCAQEM6CJCF+CuKwGLcGUunfVXZwGNcAYjMCQRZkcAAzpB8EI4a32y3XItkdvzBKyw0lF/dxTOCGbwB6phMCsCGNAOQhfCSUcVjdYn3FarVQ6Hw4gmwYTOFc7OFcwIZfAFQhjMiAAGtELwQijratACfOncv1ueMzoSytAdDEmE2RDAEPYIXQg15wpahCwEk/Z/Hwll6D6qYTALAhjCFsELZkfQQqhp+7vb3vBFAhk6QgiDGRDAEFYIXTArwhbCEYEM3UEIQ7AjgCEsELxgJoQtoH0EMnQVIQzBjACGkEXoghkQtoDu6yyQEcbCGyEMwYoAhpBD8EIway9wEbYA3/D8LLlP6kEgCz/MkIhgRABDyCB4IdgQtoDAav15ozoW3qiGIZgQwGBqeZ+Wi/vCIlgQuIDgRRgDIQzBggAGU2qpdln5DUYAEbgAcyKMhS9CGIIBp68wFYYZIpAIXEDoOVcYI4iFLkIYAo0ABlMgeCEQCFxAeHH/fH8zgQdhLPQQwhBIBDAELUIXjEbgAtCi5bPPEMXQRQhDoBDAEHQIXjBS29BF4ALQGkMUQxshDIFAAEPQIHjBCAQuAN3VXlWMIGZ+hDAYjQCGgCN4wd8IXQB8iWvFQg8hDEYigCFgCF7wFwIXAKNQFQPgLQIYDEfwgj8QugAEEkHM/KiCwSgEMBiG4AVfI3QBCDYEMXMjhMEIBDD4HcELvtQ6dBG4AAQrgph5EcLgbwQw+A3BC75C6AJgVgQxcyKEwZ8IYPA5ghd8gdAFIJQQxMyHEAZ/IYDBZwhe6ClCF4BQ1zaIEcKA8EMAQ48RvNAThC4A4eib493Z+4gRxIITVTD4AwEM3UbwQnd9VdOolthF6AIQzspr6hmWGOQIYfA1Ahi8RvBCd7SudFlE8AKAFm2HJSZzdhZ0CGHwJT7i6DKCF7qjvSGGViuHHgBoq+UYaZHkFNUwIFRxFoQuIXzBG1zXBQDdV1XfpPiYSIYlBhmqYPAVAhg6RPBCV7UOXRLBCwB6gtkSgxMhDL5AAEO7CF7oKqpdAOA/TNIBhB4CGNwQvNAVhC4AMA7VsOBCFQw9FRHoBiB4EL7QmfJ6pyt8ldfUE74AwEAtx9y2Q75hPM6Z0BNUwMBBBB2i2gUAwYMhiYD5EcDCGMELHSF4AUBwYkhicGAoIrqLIYhh6OOvCV84N4YZAoA5MCQx8DifQndQAQszHCjQHqpdAGBOrYckUgkDzIEAFiYIXmgPwQsAzO+b43eMJK4LMxpDEeEtQwNYdXW11q9fr4MHDyohIUGzZ8/WlClTPNZrbGzUli1bdODAATkcDg0fPlwLFy5U37591djYqE2bNunQoUOqrq5W//79NXv2bF144YWSpNLSUi1ZskQxMTGu7V199dW67rrrDNvPYELwQnsIXgAQeqiGAeZgaADbtGmTrFarNm7cqIKCAi1btkyZmZlKT093W+/111/XiRMntGLFCsXGxmrDhg3avHmz7r77bjU1Nalfv3568MEHlZycrA8//FC/+93vtHLlSqWkpLi28dRTTykyMtLI3Qs6hC+0RfACgNBGCAuMj7+Wvpcc6FbALAybhMNut2v//v2aNWuWbDabRowYoQkTJmjPnj0e65aWlmr8+PFKTExUdHS0Lr74Yn3++eeSJJvNphtuuEEpKSmKiIjQRRddpJSUFJ08edKoXQl6TLKB1lom1Sivd7om1SB8AUDoYnIOILgZVgErLi5WZGSk0tLSXMsyMzN19OhRj3UvvfRSPfXUUzpz5ozi4uK0d+9e1xDDtsrLy1VcXOxRRVu8eLEsFovGjRunm2++Wb179/Z4bW5urnJzcyVJy5cvV3Ky+f90kfdpuaxhdGWfxWKRNZx22Atf1TRKkiySquqbJCl4flaWIGoLuo5+Myf6zXx80GfV9U1KiIlURb1T/eKifNQwdGRPQYWmDTb/uWS4sVqthmcAw47IdrtdvXr1clsWGxsru93usW5qaqr69eunRYsWKSIiQhkZGZo/f77Heg6HQ2vWrNH06dM1cOBASVLv3r21bNkyDR48WFVVVXryySe1Zs0a3XfffR6vz87OVnZ2tutxWVlZT3czYMK14mW1WuVwOALdjKBihmGG9Js50W/mRL+Zj6/67GuHQ4lxMSqraWQ4ogGsVqt2nShjQg6TSU5O9ksGaF10asuwIYg2m011dXVuy+rq6mSz2TzW3bRpkxobG7V582Zt3bpVkyZNUk5Ojts6zc3N+sMf/iCr1ap58+a5vc/QoUMVGRmpxMREzZ8/Xx9//LHHe4eScA1fcMf9uwAAbTEcEQg+hlXAUlNT1dTUpOLiYqWmpkqSCgsLPYYOtiy/8cYbFR8fL0m64oor9Pzzz6uyslK9e/eW0+nUH//4R1VUVOiee+7pUpne6Qy9Aw/BC5I5Kl6AP5TUmKuq0z+OYYAIDCbmMBbT0qMzhn0b2Gw2ZWVlafv27Vq0aJEKCgp04MABPfTQQx7rDh06VHl5eRo9erSio6O1c+dOJSUlua7j2rhxo7744gs98MADio6OdnvtiRMnFBcXpwEDBqimpkZbtmzR6NGjFRsba8h+GoXwBYIXQpE3oarW3uDHlvhWrC26S/tGSIO/EMKA4GFxGlgaqq6u1rp163To0CHFx8drzpw5mjJlivLz85WTk6OtW7dKkqqqqrRlyxYdPHhQDodD6enpuvXWWzVs2DCdPn1ad9xxh6KiohQR8c0IyoULF2rq1Knat2+fnnvuOVVWVqpXr16uSTgSExM7bV9RUZG/dt3nCGBnheO1DaEQvMKx30KBL/qtsxBiplDlD7G26A6f705A4/NmPv7ss8Q4btbsL637jQqYeQTiGjBDA1iwI4CZTzidWIRC8GoRTv0WSrrabx2FrHAPWD3RUTjrKJjxeTMff/cZIcw/2vYbIcwcAhHAGOsABLlQCl4ILecKWoQs/zjXz/VcwxsZzohzYTgiEFgcnYEg1npWQyBQWk7uLZYmtwmNCFrBob1+aB3KWvqNQIbWWkIY/IfJOHAuHI2BIETwQqB0VNViKJt5tA5lVqtV0dYIj74lkOHsd0wMVTDAYBx9gSBC8IKRGEIYPtr2aXvDFglk4YuhiP5DFQzt4WgLBAGu84IR2gtchK3w1FkgI4yFD64HA4zHERYIIIIX/InAha5q/XtBGAs/hDDAWBxVgQBhuCF8jcAFXyCMhScm5fAfhiGiLY6kgMEIXvCltqGLwAVfIoyFFyblAIzB0RMwCMMN4QsELgTKucIYQSz0MBTR96iCoTWOmoABqHqhJwhdCDYtv4NUxUIPQxEB/+NICfgRwQvdQeCCWVAVC00MRQT8iyMk4AcMN4S3CF0wu/aqYgQxc2Moom8xDBEtODICPkbVC11F6EIoIoiFBoYiAv7DERHwEYIXuqp18CJ0IVQRxMyPoYiAf3AkBHyA8IXOELoQrghi5sdQRMC3OAICPUDwQkcIXcA32gYxQpg5MBTRt7gODBIBDOg2whfaw3VdQMdaPhMl//eYIGYOVMEA3+GoB3iJ4IX2UO0CvFNrb2BYoklQBQN8KyLQDQDMhPCF1kpqHK5/0tkTSsIX0HWtPzNtq8cIPq1vsYLu+/jrQLcAgcafm4AuIHihNapdgG9RDQt+VMEA36ECBnSC8IUWVLsA/6EaZg5UwYCe409MwDm0/pIhfIUvJtUAjNW6GkYlLLhQBQN8gyMb0A6qXmCYIRA4zJQY3JgRseeYjj68MQQRaIPwFd4YZggED4YkBh++G4GeI4AB/6e83kn4CmMELyA4EcKCE9eCAd1HAAPkXvUifIUXghcQ/AhhwYXvSaBnCGAIe1S9whPBCzAXQhiAUEEAQ1gjfIUfghdgXoSw4MIwRKB7CGAISy3XezHkMHwQvIDQQAgLDnx39tzHXwe6BQgUAhjCDlWv8ELwAkIPIQyAmRHAEFYIX+GF4AWELkJYcGAYIuA9AhjCBuErfLRUvQheQGgjhAUW36dA93BreYQ8glf4aH0SRvACwkOtvUGxtmiV1DjUP47TGgDBjwoYQhrhK3ww3BAIX1TCAothiIB3+FMRQhbhKzy0Dl4AwldLJQzGKq+pV2JcTKCbAZgKFTCEJMJX6Gs7uyEA1NobqILBVJiKPjwRwBByCF+hj+GGADpCCAMQzBiCiJBC+AptVLwAdIahiMY7+50bo8QYS6CbApgCFTCEDMJXaCN8AegqhiICCGYEMIQEwlfo4lovAN1FCAMQjAhgMD3CV+jiWi8A3cUxA0CwIoDB1L6qaZRE+Ao1VL0A+ApVMADBhgAG06LyFZqoegHwFY4hximvqeeGzEAXEcBgSi0H+ar6pgC3BL5E1QuArzEhB4BgQwCD6VD5Ck2ELwAAEA64DxhMhfAVegheAIxQUuNQ/zhOewAEHhUwmAbhK/QQvgAYgWMMgGBi6J+CqqurtX79eh08eFAJCQmaPXu2pkyZ4rFeY2OjtmzZogMHDsjhcGj48OFauHCh+vbt26Xt7Nu3T9u2bVNVVZXGjh2rxYsXKz4+3rD9hO8RvkIP4QuA0aiCAQgGhlbANm3aJKvVqo0bN2rp0qXauHGjPv/8c4/1Xn/9dZ04cUIrVqzQE088ofj4eG3evLlL2/n888+1YcMGLVmyRBs3blRMTIw2bdpk2D7C9whfoaeo8mxfEr4AGIXjDYBgYVgAs9vt2r9/v2bNmiWbzaYRI0ZowoQJ2rNnj8e6paWlGj9+vBITExUdHa2LL77YFbA6287evXt10UUXadSoUbLZbJo1a5b279+vuro6o3YVPkT4Cj0lNQ7VNzZxMgQAAMKSYQGsuLhYkZGRSktLcy3LzMxstwJ26aWX6vjx4zpz5ozq6+u1d+9eXXjhhV3azqlTp5SZmel6bsCAAbJarSouLvbXrsFPCF+hpeXmygQvAIHElPT+w73AgK4xbCC03W5Xr1693JbFxsbKbrd7rJuamqp+/fpp0aJFioiIUEZGhubPn9+l7djtdsXGxno8314FLDc3V7m5uZKk5cuXKzk5ufs7aDBrVXmgm+BXX9U0yqKz9/myWjv4NbWo4+cRFIoq62WxWFTfeLY/LRYL/WZC9Js50W/faHA0KyYqMvh/Hib+brPIvG3vqe5+1pKTE33fGHSZ1Wo1PAMY9gmx2WweIaiurk42m81j3U2bNqmxsVGbN29WTEyMduzYoZycHOXk5HS6nXM93za0SVJ2drays7Ndj8vKyrq9f0ZzhPgf8JzqWuXLarXKEeo/DJNrb7IN+s2c6Ddzot/cRVsjgv7nYeY+c8ZEmrbtPdXdfjPT+WcoSk5O9ksftB6t15ZhQxBTU1PV1NTkNhSwsLBQ6enpHusWFhZqxowZio+PV1RUlK644gp98sknqqys7HQ7gwYNUmFhoeu5kpISNTY2KjU11Y97B18qr3cy7DBEMNMhAACAO8MCmM1mU1ZWlrZv3y673a5jx47pwIEDmjZtmse6Q4cOVV5enmpra+VwOLRz504lJSWpd+/enW5n6tSp+uCDD5Sfny+73a7t27crKyur3QoYgg9jx0MH4QtAMKq1N3AdGICAsjidTsPOeKurq7Vu3TodOnRI8fHxmjNnjqZMmaL8/Hzl5ORo69atkqSqqipt2bJFBw8elMPhUHp6um699VYNGzasw+202Ldvn5599llVV1d7dR+woqIi/+y4H3z8daBb4HvdmXTDzMM0Qlln4Yt+Myf6zZzoN0+xtuigvh+YmfssMS5GiTGWQDcjILrbb+OT/NAYdFkghiAaGsCCHQEscLo746GZv6RCVVcqX/SbOdFv5kS/eSKA+Q8BjABmNiF9DRjQGa77Mj+GHQIAAHSMAIaAY9KN0ED4AgAA6BwBDAHFpBuhhfAFwCyYiANAoBDAEDDdve4LwaekxkH4AmAaHK8ABBIBDAFF+DI//ooMAADQdQQwBARDD0MD130BAAB4hwAGwzH0MDQQvgAAALxHAENAEL7MjfAFAADQPQQwGIqhh6GD8AUAaC2cb8IMeIMABsMw9DA0MOkGAAC+MT4p0C1AIBDAYCjCl7kx9BAAAKBnCGAwBEMPQwfhCwAAoPsIYDAM1S9zY+ghAABAzxHA4Hfl9U7Cl8kx9BAAAMA3CGDwK4Yehg7CFwAAQM8RwOB3VL/MjaGHAEJNrC1a/eOsgW5GSEmMiwl0EwDTIIDBb6h+hQ6qXwCAznAPMO8wBX34IoDBr6h+mRvVLwAAAN8igMEvqH6FDqpfAAAAvkMAg99Q/TK3khoH4QsAAMDHCGDwOapfAHrC6XTq6Kdfy97gPgTW3uDQ0U+/ltPJMQbdF2uLDnQTAIQ5Ahj8guqXuXHtFwIpv6BcH33ylXb9vcgVwuwNDu36e5E++uQr5ReUB7aBMD1mQPStxLgYJuAAvEAAg09R/QodDD9EoAwZmKA+cdGqqGnQrr8Xqby6Xrv+XqSKmgb1iYvWkIEJgW4iAPQIMyCGNwIYfI7ql7lR/UKg2aKt+t6ENFcIe/3dz13h63sT0mSLpnoBADAvAhgAD1S/EGi2aKu+O66/27LvjutP+EKPcP0XgGBAAIPPMPwQgK/YGxx6+2CJ27K3D5Z4TMwBeIvrv3wrMS4m0E0ATIcABp9i+KG5MfwQwaBlwo2WYYcz/yXd7ZowQhgQXJiAwztc/wUCGHyC6lfoYPghAu3kF1Vu13wlxse4XRN28ouqQDcRJsTwQwDBgjo8fIbqFwBfGDk4UdLZ2RBbrvlqmZjj5BdVrucBbzH80LcYfgh0D0ciAJIYfojgYbFYNOo8zzE6tmhru8sBBA7DDwHvMQQRPcbww9DB8EMAoSjWFk31C0DQIIDBJxh+CAAA0DEm4IBEAAMAACGMyTf8IzEuhuGHQDcRwNAjDD8EAAQ7hh8CCCYEMPQYww/Nr6TGwfVfAEIO1S//YPbD7mH4IVoQwAAAQMii+uUfDD8Euo8ABgAAQg7VLwDBigCGbuP6LwBAMKP65XsMPwR6jgCGHuH6LwBAsKH65V8MP/Qe13+hNQIYAAAIOVS/AAQrAhgAAAgZVL/8h3t/Ab5BAEO3cP0XACBYUf1CMGH4IdoigKHbuP4LABBMYm3RhC8/YfINwHcIYAAAwPQYeuh/DD8EfIMABgAAQgLVL/+g+tV9DD9EewhgAADA1Kh++R/VL8B3CGAAAMC0WsIX1S//oPoF+B4BDAAAmBrhy7+ofnUPww9xLoYesaqrq7V+/XodPHhQCQkJmj17tqZMmeKxXk5OjvLz812PHQ6H0tLStGrVKpWVlelnP/uZ2/r19fWaO3eurrzySh05ckS//e1vFR39zXCE+fPna8aMGX7bLwAAYDxmPfQvql+Afxh61Nq0aZOsVqs2btyogoICLVu2TJmZmUpPT3db795773V7/OCDD2rMmDGSpOTkZG3dutX1XGlpqe68805lZWW5liUlJemPf/yjH/ckvJXXO5mCHgAQUFz3ZQyqX91D9QsdMWwIot1u1/79+zVr1izZbDaNGDFCEyZM0J49ezp8XWlpqfLz8zVt2rR2n8/Ly9OoUaOUkpLij2YDYYOTGQBmwXVf/kf1C/Afw45cxcXFioyMVFpammtZZmamjh492uHr9uzZo5EjR7YbsJxOp/bs2aNrr73WbXlFRYUWLFig6OhoTZw4UTfeeKNsNpvH63Nzc5WbmytJWr58uZKTk7uzawFhrSoP2Htb6htltQbJl55FwdMWExvYx6qiynrDfpYWi4V+MyH6zZxCrd9ioiIlSWm9QzggBMF3m0VSv7iogLbBbFp/1pKTEwPbGHSZ1Wo1PAMY9um22+3q1auX27LY2FjZ7fYOX5eXl+cRsFocO3ZM5eXlmjx5smvZwIEDtWLFCqWlpamsrExr167VM888o4ULF3q8Pjs7W9nZ2a7HZWVl3uxSQDkcgXtvp85elxcMrFZr0LTF7JxOp2E/S/rNnOg3cwq1fou2Rqh/XGjtU1uB7rPEuJig+q43i5Z+G59krnPKcJecnOyX/mpddGrL6wB24sQJHTp0SJWVlWpubnZ7bt68eed8nc1mU11dnduyurq6ditTLdoLWK3l5eUpKyvLbRuJiYlKTEyUJKWkpGjOnDl65JFH2g1gAADAPBgqbRyu/QL8x6sA9uqrr+rZZ5/VgAEDlJSUJIul6x/O1NRUNTU1qbi4WKmpqZKkwsJCjwk4Wtu9e7dHwGrR0NCgd999Vz//+c87fF+LxeIRFAG0L9YWrVp7Q6CbAQAeuO7LGFz71TNMvoGu8Ooo9te//lW33XabfvCDH3j9RjabTVlZWdq+fbsWLVqkgoICHThwQA899FC763cWsN5//33Fx8dr9OjRbssPHz6s/v37Kzk5WV999ZW2bdumiRMnet1eINz0j7OqpIbhJgCCD+HLWFS/AP/y6khWW1urCy+8sNtvdvvtt2vdunVasGCB4uPjtWDBAqWnpys/P185OTlu08u///77iouL8whYLfLy8jR16lSPKlxBQYHWrFmjmpoaJSQkaOLEibrpppu63WYAABA4hC/jUP0CjGFxOp3Orq68YcMGZWZm6vvf/74/2xQwRUVFgW5Cl338deDeO5juAxboC5VDTUsFzN/DEOk3c6LfzMnM/Rau4StQfZYYF0P1qwe+d75/JnOAfwX9JBzJycl6/vnndfz4cWVkZHhMkfrDH/6wey0EEBQYhgggWIRr+AoUwhdgHK+Oart27ZLNZtPx48d1/Phxt+csFgsBDAAA9Bjhy1gMPew5Jt+AN7w6sq1du9Zf7QAQRJgNEUCgEL4Cg+oXYJyI7r7Qbrd3ehNlAObDSQ+AQCF8GY/qV89R/YK3vD7CvfHGG9qxY4fOnDkjSerXr5+uvvrqkJ2YA+1LjIsJmok44B9UwQAYifBlvJbwRfULMJZXR7mXXnpJr7zyiq688kqNGDFCkpSfn69t27aprq5O//Zv/+aPNiLIJMZYVF7f5ckzYUJMxgHASISvwCF89QzVL3SHV0e6//mf/9HChQs1ZcoU17KxY8cqNTVVzz33HAEMCDFUwQD4G+ErMBh6CASOV9eAVVZWatiwYR7Lhw0bpoqKCp81CkDgcTIEwN8IX4HB0EPfoPqF7vIqgKWmpmrfvn0ey/ft29fhzcYAmFP/OKvrBAkAfInwFViELyBwvDrqXX/99frd736n/Px8DR8+XJJ0/PhxHT16VD/72c/80kAAgcdQRAC+RPgKHIYe+gbVL/SEVxWwrKws5eTkqE+fPvrggw/0wQcfqE+fPsrJydGkSZP81UYAAcQJEgBfInwFDkMPgeDg9dFvyJAhWrp0qT/aApNhKvrwQhUMQE8QvIID4avnqH6hpzo9ClZXVys+Pt71/x1pWQ+hj6now0vLtPSEMADdQfgKvMS4GMIXECQ6PRLOnz9fGzZsUJ8+fTR//vwO192+fbvPGgYguHBvMADdQfgKPK778h2qX/CFTo+Gv/71r12VrV//+td+bxCA4NU/zqoSiSoYgC4hfAUe130BwafTI+KoUaPa/X8A4YuhiAA6QvAKLoQv36D6BV/xahbEU6dOqaioyPX44MGDevzxx/Xyyy+rubnZ541DcEuMsTCsIQy1nFBxfzAA7SF8BQ+u+wKCk1cBbP369fr0008lSWVlZXr00UdVU1OjnTt36v/9v//nlwYCCD6EMADtIXwFD/5A6ltUv+BLXgWwL774Quedd54k6b333tP555+ve+65R0uWLNHbb7/tlwYCCE6EMAAtYm3RirVFq3+clfAVBLjuCwhuXgWw5uZmWa1nD6yHDx/WhRdeKEkaMGCAysvLfd44mAN/ZQtfhDAAVL2CC+HL96h+wde8CmDp6en629/+pvz8fB06dEgXXHCBJOnMmTPq3bu3P9qHIMcBHoQwIDxR9QpefDcDwc2rADZnzhzt2rVLDz74oL773e8qIyNDkvT3v/9dQ4cO9UsDAQQ/QhgQXqh6BScm3fA9ql/wB6+OnKNGjdKTTz6p2tpa173BJCk7O1sxMQxDC2eJcTEqr6kPdDMQQC03amaKeiB0EbyCF5cD+B7hC/7iVQVMkiIiItzClySlpKSoT58+PmsUzIW/tqEFlTAgNLUMN5QIX8GI674Ac+n0KPrII4/ozjvvVGxsrB555JEO1/3FL37hs4YBMCcqYUBoIXgFN8KXf1D9gj91ejRNSEiQxWJx/T/QnrMHfoYh4ixCGGB+rSvZhK/gRPgCzMnidDqdgW5EsCgqKgp0E7rs468D3QJP5fVOwwOY1WqVw+Ew9D3RdSU1Z/umbQij38yJfjMnb/uN4BV4Xekzwpf/dLf6lZycrLKyMt82Bn7nr35LS0s753NeHVnLy8vV1NSkfv36uS3/6quvFBkZqcTExG41EKGDyTjQWsvJW8n/PaYaBgQ3hhuaA+HLfxh6CCN4NQnHmjVr9OGHH3os//jjj/WHP/zBZ42COfFFgHNhcg4guHFPL/PhOxcwL68C2P/+7/9q1KhRHstHjBih//3f//VZo2BuTIWL9hDCgODD7Ibmw72+/IfqF4zi1dG2qalJjY2NHssbGxu5LgCSzv5FrryeywrRvpYTvNLaJkVbIxiSCAQI13mZE+HLfwhfMJJXFbDzzz9ff/vb3zyW79y5U0OHDvVZo2B+VMHQkbTeZ38/qIYBxmpb8SJ8mQffq0Do8OrIe+ONN+q3v/2tPvvsM40ePVqSdOTIEX366ad64IEH/NJAmA9VMHRF66nqJSboAPyJipe5MemGf1H9gtG8noa+oKBAr776qgoKCiRJgwcP1lVXXaXBgwf7oXnGYhp632kJYP6eEZFpsc2pbb+da7p6BBc+b+YTa4uWxWKR0+kkeJlI688a4cu/fBm+mIbenIJ+GnrpbOBaunRpjxqE0EcVDN5gunrAt1pXvNJ6xxCcTYrwBYQmr64Bk87eC+zVV1/Vpk2bVFlZKUk6duyYSktLfd44mB9j1uGN1jMlcn0Y4D2u8QodhC//Y+ghAsWrAHby5En99Kc/1b59+7Rr1y7V1dVJkg4ePKjnnnvOLw2EefGlge5ofdJIEAO6huAVWhJiIpUYY+F71I8IXwgkrwLY1q1bNXPmTD366KOKiopyLb/gggt0/PhxnzcOoYEqGLqjbRAD4K4ldLW+gTLBy/wS42LULy6q8xUBmJbXFbDp06d7LE9MTFRFRYXPGoXQwV/v0FMtJ5VUw4CzqHaFLu7zZQyqXwg0r47a0dHRqqmp8VheVFSk3r17+6xRCC1nv0xi/D4jIkIbE3UgnLX94wOhK7RwvZdxCF8IBl5VwCZMmKAXXnhBjY2NkiSLxaLS0lI9++yzysrK8ksDEToYighfaFsRoyqGUNZetYvwFVoIX8YhfCFYeBXA5s6dq+rqat1+++2qr6/XAw88oKVLlyo2NlY33nijv9qIEMAXC3yNyToQqtr+cYHQFboIX0B48uqIHhkZqQcffFD5+fk6efKknE6nzjvvPI0bN85f7UMIYSgi/ME1NLHG4TphZXgizIYhhuGH8GUsql8IJl0+wjc3N+tHP/qRVqxYoTFjxmjMmDH+bBdCWGIcIQy+114QkwhjCG6tf1cJXeGD8GUswheCTZeP9hEREUpOTpbD4fBnexDiEmMsKq93EsLgN61PYqmKIRgRusIb4ctYhC8EI6+uAbv22mv17LPPqrKy0l/tQRjgSwdGae86Ma4Vg9Fa/+5xz67wRvgCIHl5Ddhf/vIXlZaWatGiRerXr59iYtxntVu5cqVPG4fQRhUMRjlXVUyiMgb/4JoutEbwCgyqXwhWXn0jTJ48WRaLRU6ns1tvVl1drfXr1+vgwYNKSEjQ7NmzNWXKFI/1cnJylJ+f73rscDiUlpamVatWSZLuuOMOlZeXKyLibAFv+PDhuv/++13rv/baa9qxY4caGhqUlZWlBQsWKCqKu8oHE4YiIlAIY/AXQhfaQ/gKDMIXglmXvh3q6+u1detWHThwQE1NTRozZozmzZvn9c2XN23aJKvVqo0bN6qgoEDLli1TZmam0tPT3da799573R4/+OCDHpN+/OIXv2h39sWPPvpIO3bs0K9+9SslJSVp5cqVev755zVnzhyv2gr/I4Qh0Ahj6AkCFzpD+AoMwheCXZeuAXv++eeVl5en73znO/rud7+rQ4cOadOmTV69kd1u1/79+zVr1izZbDaNGDFCEyZM0J49ezp8XWlpqfLz8zVt2rQuvU9eXp4uueQSpaenKz4+Xtdee612797tVVthHL6UECzaXpfDNWNoq+21XBI3R8a5Eb4AnEuXvjHef/99LVq0SN/97nclSVOnTtUDDzyg5uZm1zDAzhQXFysyMlJpaWmuZZmZmTp69GiHr9uzZ49GjhyplJQUt+Vr1qxRc3OzzjvvPN18880aPHiwJOnUqVOaOHGi23tUVFSoqqpKCQkJbtvIzc1Vbm6uJGn58uVKTk7u0r4EA2tVeaCb4DPJVskiqaq+yfsXWySrlRMf0wnyfhvYx71tRRb3E6j6xm78roYAi8US1P3mazFRkR7L0nrHtLNmkAvyz1soSog5+7vTL657lz+E22fNl6aflxiw97ZaraY6l8RZgei3Ln26y8rKNHLkSNfjYcOGKSIiQmfOnOlyg+12u3r16uW2LDY2Vna7vcPX5eXl6dprr3Vbduedd2rIkCFyOp16/fXX9fDDD+v3v/+94uLiZLfbFRsb6/YeklRXV+cRwLKzs5Wdne22n2YRancD6BNjkVORXg9FtFqt3BrBhMzWbymx35yIl9Q4FG11/8NTuAxXNFu/eatttdPpdHpUtsy4/6Heb8GkperV5/+qXt39udNn3TM+KbDncsnJyaY6l8RZ/uq31kWntroUwJqbmz3+EhMZGanm5uYuN8Jms6murs5tWV1dnWw22zlfc+zYMZWXl2vy5Mluy0eMGOH6/2uuuUZ5eXnKz8/XhAkTZLPZVFtb6/YekjzCH4IT14Mh2LU31KyknfXCJZSZVXtDSxlGiJ5gyGFgcd0XzKTL3zZr1qxxC2GNjY164oknFB39zZfYL37xi3O+PjU1VU1NTSouLlZqaqokqbCw0GMCjtZ2796trKysDkOadLZU32LQoEEqLCzUxRdf7HqPPn36eFS/EHyYlANm1fbEve2EHi0IZcY71zV8hC34EuErsAhfMJsuXcA1ffp0JSUlKSEhwfVv6tSp6tevn9uyjthsNmVlZWn79u2y2+06duyYDhw4cM7JNRoaGvTuu+9qxowZbsvLysp07NgxORwONTQ06NVXX1VlZaWGDx/uauubb76pU6dOqaamRi+++KLHNhC8Wr68Wr7MADNqPTHDuSb2YIIP32rvZ9veRBlMmAFfSoyLOfsvxkL4ChDCF8yoS99Cixcv9smb3X777Vq3bp0WLFig+Ph4LViwQOnp6crPz1dOTo62bt3qWvf9999XXFycRo8e7baNuro6bdq0SSUlJYqKitLgwYN17733ugLgBRdcoKuvvlq/+c1vXPcBu+GGG3zSfhiDShhC0blO+tsbvtiCipm7zgIrwQpGouoFoLsszu7eVTkEFRUVBboJXfbx14Fugf+V15/91ewohHGhsjnRb50rqenaz8fIkObPfutKNZCA1T183nzP3+GLPuuaYKt+MQmHOQXtJBxAIFAJQzjratjoqILWGV+Gt54OpyRcwQyoegWPYAtfgDf4xkNQI4QBHetJcPE2vFksFo8p+H3RDsAMCF/Bg/AFs+MbE0GPEAb4h7ehiWFRCEetJ4UifAUe4QuhoEuzIAKBxuyIAACjta56Eb4Cj/CFUEEAg2kQwgAARmiZXl6i6hUsCF8IJQQwmAohDADgT1S9gg/hC6GGAAbTIYQBAHyNqldwInwhFBHAYEotX44JMZEBbgkAwOyoegUnwhdCFbMgwrQSYyyyWq1quZM4MyQCALzBDIcAAoEKGEyPIYkAAG9R9QpuVL8QyghgCAmEMABAV3CtV/AjfCHUEcAQMghhAICOUPUKfoQvhAOuAUNI+eYL9eyXLNeFAQCoeJkD4QvhggoYQhLVMAAAww3Ng/CFcEIAQ8gihAFAeGobvAhfwY3whXBDAENIax3CCGIAEPoIXuZC+EI44howhLyWL+DyeqcS42K4LgwAQhBDDc2H8IVwRQBD2EiMsbhCmMQEHQAQCriZsjkRvhDOCGAIK1TDACA0ELzMi/CFcEcAQ1hqXQ0jhAGAeRC8zIvgBZxFAEPY4p5hAGAuXOdlXoQv4BsEMIQ9rg0DgOBG8DI3whfgjgAGiGvDACAYEbzMj/AFeCKAAa1QDQOAwCN4hQbCF9A+AhjQRttqmEQQAwAjMMFG6CB8AedGAAPOgWGJAGAMKl6hhfAFdIwABnSC2RIBwD8IXqGH8AV0jgAGdBHXhwFAzzHMMHQRvoCuIYABXuD6MADoHoJX6CJ4Ad4hgAHdQBADgK4heIU2whfgPQIY0AMEMQBoH8Er9BG+gO4hgAE+QBADAPfQJRG8QhnhC+g+AhjgQwQxAOGIald4IXwBPUMAA/yAIAYgHBC8wgvBC/ANAhjgRwQxAKGG0BWeCF+A7xDAAAMQxACYHcErfBG+AN8igAEGIogBMBNCFwhfgO8RwIAAcD+R+eYEhzAGIBgQvEDwAvyHAAYEGFUxAMGA0IUWhC/AvwhgQJBoL4hJhDEA/sN9u9AW4QvwPwIYEGRanwBRFQPga4QunAvhCzAGAQwIYlTFAPgCoQsdIXgBxiKAASZAVQyAt1qOExZJThG60D7CF2A8AhhgMsygCOBc2qt0Wa1WORyOALUIwYzwBQQGAQwwMYYoAmB4IbxF8AICiwAGhIBzDVGUCGNAKCJ0obsIX0DgEcCAEEMYA0IPgQs9RfACgoehAay6ulrr16/XwYMHlZCQoNmzZ2vKlCke6+Xk5Cg/P9/12OFwKC0tTatWrVJFRYW2bNmi/Px82e12ZWRk6JZbbtH5558vSTpy5Ih++9vfKjo62vX6+fPna8aMGX7fPyDYEMYA8yJ0wVcIX0BwMTSAbdq0SVarVRs3blRBQYGWLVumzMxMpaenu6137733uj1+8MEHNWbMGEmS3W7XsGHDdOutt6pPnz568803tXz5cq1du1Y2m02SlJSUpD/+8Y/G7BRgEp4nb+4ndwQyILDaBi6J0IWeI3wBwSfCqDey2+3av3+/Zs2aJZvNphEjRmjChAnas2dPh68rLS1Vfn6+pk2bJknq37+/fvjDHyopKUkRERHKzs6Ww+FQUVGREbsBhIzEGIvrn3T25K/lHwBjtP3ctf5cEr7QE+OTCF9AsDKsAlZcXKzIyEilpaW5lmVmZuro0aMdvm7Pnj0aOXKkUlJS2n2+oKBADodDAwYMcC2rqKjQggULFB0drYkTJ+rGG290VccAeKI6BhiDYYUwAsELCG6GBTC73a5evXq5LYuNjZXdbu/wdXl5ebr22mvbfa62tlZr1qzRddddp9jYWEnSwIEDtWLFCqWlpamsrExr167VM888o4ULF3q8Pjc3V7m5uZKk5cuXKzk5uTu7FhDWqvJANyEoWCxn73ED30pu9SP9qqZRSW1OGqvqm3r2BhbRb2ZEv3ktISbS7XG/uCjD28Bx0ny622fTz0v0fWPQZVar1VTnkjgrEP1m2BHZZrOprq7ObVldXV2Hlaljx46pvLxckydP9niuoaFBjzzyiM4//3xdc801ruWJiYlKTEyUJKWkpGjOnDl65JFH2g1g2dnZys7Odj0uKyvzdrcChntqnsUNRv2vT5u/0JfXOxXf5qTS2woZ/WZO9FvH2hu+2/bzE4ifH/1mPt3ps/FJ5jqPCUXJycn0gQn5q99aj/pry7AAlpqaqqamJhUXFys1NVWSVFhY6DEBR2u7d+9WVlaWR0hrbGzUihUr1K9fv3aDVWsWi0XNzc093wEAkjyHTLWdXVFiyCLCA5NmIBgw3BAwH8Mm4bDZbMrKytL27dtlt9t17NgxHThwwDW5RlsNDQ169913PaaPdzgcWrVqlaKionTHHXcoIsJ9Fw4fPqzTp0/L6XSqrKxM27Zt08SJE/21W0DYa2/SgNYTCzCpB0JB29/pxLgYj999wheMRvgCzMnQQeG333671q1bpwULFig+Pl4LFixQenq68vPzlZOTo61bt7rWff/99xUXF6fRo0e7beOf//yn/vGPfyg6Olo/+tGPXMvvvfdejRw5UgUFBVqzZo1qamqUkJCgiRMn6qabbjJqF4Gw1/5JqHsIs0j6miFRCFLn+qMBAQvBguAFmJvF6XQ6A92IYGGmqew//jrQLQgOXNtgTlarVWU1jR7LGboY3ELx8xYOYSsU+y3UddRnhK/gxTVg5hTS14ABQGtdqZS1IJihp8IhaCG0EbyA0EEAAxA02jsZbm+SD9dzBDO00tH1hgQtmBXBCwg9BDAAQe1cJ84dBTOJcBaqOpvUhaCFUEL4AkITAQyAKXV0ot1ZOJMIaMGqK7NmErIQ6qafl8i1REAII4ABCDmdnaB3JaBJhDRf6+otCQhYCFdUvIDwQAADEHa6coLf1ZDm9powC2ze/nwIVsC5Eb6A8EEAA4B2eBsWuhPYzMYiyRkT6XpMoAJ6juAFhB8CGAD4QDiEEe4nBfgOwQsIXxGBbgAAAEA4IXwB4Y0KGAAAgAEIXgAkAhgAAIBfEbwAtEYAAwAA8AOCF4D2EMAAAAB8iOAFoCNMwgEAAOAjhC8AnaECBgAA0EMELwBdRQADAADoJoIXAG8RwAAAALxE8ALQXQQwAACALiJ4AegpAhgAAEAnCF4AfIUABgAAcA4ELwC+xjT0JsUXAgAA/jM+ie9aAP5BBczEWr4YPv46sO0AACBUELoA+BsBLAQQxAAA6BmCFwCjEMBCCEEMAADvELwAGI0AFoIIYgAAnBuhC0AgEcBCGEEMAIBvELwABAMCWBggiAEAwhnBC0AwIYCFEYIYACCcELwABCMCWBgKpS+k5ORElZWVBboZ8BL9Zk70mznRbwAQXLgRMwAAAAAYhAAGAAAAAAYhgAEAAACAQQhgAAAAAGAQAhgAAAAAGIQABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABiEAAYAAAAABiGAAQAAAIBBCGAAAAAAYBACGAAAAAAYhAAGAAAAAAYhgAEAAACAQQhgAAAAAGAQAhgAAAAAGIQABgAAAAAGIYABAAAAgEGsRr5ZdXW11q9fr4MHDyohIUGzZ8/WlClTPNbLyclRfn6+67HD4VBaWppWrVolSSotLdX69et14sQJJScna968eRo3bpxr/ddee007duxQQ0ODsrKytGDBAkVFRfl/BwEAAACgA4YGsE2bNslqtWrjxo0qKCjQsmXLlJmZqfT0dLf17r33XrfHDz74oMaMGeN6vHr1an3729/WPffco3/84x967LHH9Pjjj6t379766KOPtGPHDv3qV79SUlKSVq5cqeeff15z5swxZB8BAAAA4FwMG4Jot9u1f/9+zZo1SzabTSNGjNCECRO0Z8+eDl9XWlqq/Px8TZs2TZJUVFSkTz/9VDfccIOio6M1efJkZWRk6L333pMk5eXl6ZJLLlF6erri4+N17bXXavfu3f7ePQAAAADolGEVsOLiYkVGRiotLc21LDMzU0ePHu3wdXv27NHIkSOVkpIiSTp16pT69++vXr16uW3n1KlTrucnTpzo9lxFRYWqqqqUkJDgtu3c3Fzl5uZKkpYvX67k5OSe7SQMZ7Va6TcTot/MiX4zJ/rNfOgzc6LfzCkQ/WZYALPb7W6hSZJiY2Nlt9s7fF1eXp6uvfZat+3ExsZ6bOfMmTPtPt/y/3V1dR4BLDs7W9nZ2a7HZWVlXuwRgkFycjL9ZkL0mznRb+ZEv5kPfWZO9Js5+avfWhed2jJsCKLNZlNdXZ3bsrq6OtlstnO+5tixYyovL9fkyZPdtlNbW+uxnZZw1/b5lvdsG/4AAAAAwGiGBbDU1FQ1NTWpuLjYtaywsNBjAo7Wdu/eraysLLeQNmjQIJWWlrqFucLCQg0aNMj1fGFhodtzffr08ah+AQAAAIDRDK2AZWVlafv27bLb7Tp27JgOHDjgmlyjrYaGBr377ruaMWOG2/K0tDQNHjxYL7zwghoaGvT++++rsLDQVSWbPn263nzzTZ06dUo1NTV68cUXPbYBAAAAAIFg6I2Yb7/9djU0NGjBggVavXq1FixYoPT0dOXn52vu3Llu677//vuKi4vT6NGjPbbzk5/8RCdPntRtt92mZ599Vv/5n/+p3r17S5IuuOACXX311frNb36jxYsX61vf+pZuuOEGQ/YPAAAAADpicTqdzkA3IlgUFRUFugnwEhe8mhP9Zk70mznRb+ZDn5kT/WZOIT0JBwAAAACEOwIYAAAAABiEAAYAAAAABiGAAQAAAIBBCGAAAAAAYBACGAAAAAAYhAAGAAAAAAYhgAEAAACAQQhgAAAAAGAQAhgAAAAAGIQABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABiEAAYAAAAABiGAAQAAAIBBrIFugBk0NTXJbrdLkiwWS4Bbg9ZKSkpUX18f6Gb0iNPpVGRkpGw2W6CbAgAAAD8jgHWiqalJdXV1iouLI3wFIavVqsjIyEA3o8fsdrsaGxsVFRUV6KYAAADAjxiC2Am73U74gt/FxMSooaEh0M0AAACAnxHAuoDwBX/jdwwAACA8EMA6wYkxjMLvGgAAQOgjgAEAAACAQQhgAAAAAGAQAlgI2bVrl3bt2hXoZhginPYVAAAAoYNp6EPEmTNn9Oijj0qSLrzwQvXt2zfALfKf1vs6ceJE9e7dO8AtAgAAALqGCliIWLlype677z7dc889WrlyZaCb41et97UliAEAAABmYHE6nc5ANyJYFBUVeSyrra1VbGxsAFqDrrBarXI4HIFuhk+E0+9acnKyysrKAt0MeIl+Myf6zXzoM3Oi38zJX/2WlpZ2zueogAEAAACAQQhgfvLPklq1LS46nU79s6Q2QC0CAAAAEGgEMD/Y+8+v9eIHJfrvQ2WuEOZ0OvXfh8r04gcl2vvPr336fuXl5Ro4cKDOP/98DR06VN/5zne0ceNGr7bx9ddfa/78+Ro2bJgmTZqkl19+ud31zj//fLd/6enpuv/++13Pf/7555o7d65GjRqlCy64QPfdd5/bEMHOXu/Nfk6aNEnPPvusV/vpzb52ZX/uvPNOXXjhhRo+fLimTJmibdu2uZ6rr6/XXXfdpUmTJunb3/62LrvsMr355ptetxcAAAChg1kQfeyfJbXa90m5JOnQqWpJ0syxyXr9UJnr8b5PytW/T4y+3d831/scOXJE/fr108GDByVJO3fu1Lx58/Sv//qvHY4/be2+++5TVFSUPv74Yx05ckS33HKLRo0apeHDh7utd+LECdf/19TU6IILLtAPf/hD17J7771X/fr10z/+8Q9VVlbqpptu0tNPP6358+d36fWd7Wffvn116NAhSdLLL7+sn/zkJ7rsssu8mvWxq/valf1ZsmSJVq5cqZiYGH3yySe67rrrNGbMGI0bN05NTU1KS0vTiy++qIEDB2rXrl1atGiRdu3apfT09C63FwAAAKGDCpiPnZ/SS2MHxbseHzpVrUf+WuAKX5I0dlC8zk/p5bP3PHLkiMaPH+96fOGFF0qSGhsbu/T62tpavf766/r5z3+uuLg4TZo0SZdddplefPHFDl/33//930pOTlZWVpZr2WeffaYrr7xSNptNKSkpmjFjho4fP97l13fkyJEjGjt2rOvx5MmT1dTUpPLy8i69XvJ+Xzvbn+HDhysmJsb12GKxqKCgQJIUGxuru+66S+np6YqIiNBll12mjIwMV1AGAABA+KEC5mMWi0X/OjZZktxCV4uxg+L1r2OTZbFYfPaehw8fdoWuiooKPfLIIxo3bpwyMjJ0yy236MCBA+2+buLEiXrmmWd08uRJRUZGaujQoa7nRo8erXfffbfD933hhRd03XXXue3L7bffrh07dujiiy9WeXm53nrrLf385z/v8us728+WAFZRUaFly5Zp/PjxOu+88yTJL/valf2555579Pzzz8tut2vMmDH63ve+1+62Tp8+rZMnT7ZbaQMAAEB4IID5gcVi0cyxye0GsJk+Dl+SdPToUf31r3/Vk08+qT59+ujiiy/WU089JYvFomeeeabT19fU1CghIcFtWUJCgmpqas75mlOnTum9997TqlWr3JZPnjxZzz77rIYPH66mpiZdf/31+sEPftDl13fk6NGjev311/XUU0+purpaM2bM0HPPPef6efpjX7uyP8uWLdNDDz2kDz74QO+8846io6M9ttPY2KglS5bouuuu07Bhw7q6ywAAAAgxDEH0A6fTqdcPtX8/gddbTczhC/X19Tpx4oTy8vJ05MgRvfPOO1q5cqX69+/f5W3ExcWpqqrKbVlVVZXi4uLO+Zo///nPmjRpkjIyMlzLmpubNWfOHF1xxRU6ceKEDh06pIqKCj388MNden1HWvYzNzdXx48f14YNG/SPf/xDUVFRXdzLs7zZV2/2JzIyUpMmTVJxcbFHEGxubtbSpUsVHR3d7msBAAAQPghgPtYy22F71S/p7LDE//ZhCDt+/LhiY2PPOdnGzTff7DHzYMu/m2++WZI0ZMgQNTU16eTJk67XHT16tMOhcn/+8591/fXXuy0rLy/XF198odtuu00xMTHq27evZs2a1e7Mf+29vrP9jImJUWZmpiTpX//1XzVw4EC99tprfttXb/anRVNTkwoLC12PnU6n7rrrLp0+fVobNmzwOjACAAAgtDAE0cdOlNZ5TLjRdhbEQ6eq9e3+cT6ZBfHw4cP69re/fc7n//SnP3W6jdjYWF1xxRVauXKlVq5cqSNHjuhvf/ubduzY0e76Bw4c0Jdffukxe2Hfvn2VkZGhZ555RosWLVJNTY1eeOEFjRw5skuv/+lPfypJ+v3vf3/O/Ww9fPPSSy/Vzp07dcMNN/hlXzvbn7KyMr399tvKzs6WzWbT3r179corr2jdunWubfzyl7/UiRMntH37dvXq5buJVwAAAGBOVMB87Nv9YzVlWKKkbybciPi/iTlaZkecMizRp1PQ+2JSh5ycHNntdo0bN06LFy/WsmXLXNu9+eab9fjjj7vWfeGFF3TFFVcoPj7eYzsbN27U7t27NW7cOH33u9+V1WrVgw8+6LbOuV5fVFSkiRMnttu+I0eOaNSoUW7LZsyYoby8PNntdp/ta9v97Wh/Wq6xmzBhgkaNGqX/+q//0m9+8xtdfvnlks5e5/anP/1JR48e1QUXXOCqxr300ktetRcAAAChw+L05QVJJldUVOSxrLa2VrGx3oelf5bU6vyUXm4VG6fTqROldT4LX6GkoaFBl112mXJzc70apme1Wt1ujGxm3f1dM6Pk5GSVlbV/nSSCF/1mTvSb+dBn5kS/mZO/+q2je/EyBNFP2gtZFouF8HUO0dHRysvLC3QzAAAAAL9iCCIAAAAAGIQABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABiEAAYAAAAABiGAAQAAAIBBDL0PWHV1tdavX6+DBw8qISFBs2fP1pQpU9pd9+TJk3r66ad18uRJ2Ww2XXPNNZo5c6bKysr0s5/9zG3d+vp6zZ07V1deeaWOHDmi3/72t4qOjnY9P3/+fM2YMcOfuwYAAAAAnTI0gG3atElWq1UbN25UQUGBli1bpszMTKWnp7utV1lZqZycHN16662aPHmyHA6HvvrqK0ln71a9detW17qlpaW68847lZWV5VqWlJSkP/7xj37bjxfyK3W61uG37X8r1qrrR/bu8vpbtmzR888/r2PHjunqq6/W73//+x69/8svv6wNGzbok08+UXx8vEaPHq2lS5dq0qRJysrK0ooVKzRt2rQevQcAAAAQjgwLYHa7Xfv379eqVatks9k0YsQITZgwQXv27NGcOXPc1n3ttdc0fvx4TZ06VZIUFRWlQYMGtbvdvLw8jRo1SikpKX7fhxanax06We6/AOat/v376yc/+Yl2794tu93eo2098cQTWrt2rZYvX64ZM2YoKipKb731lnbu3KlJkyb5qMUAAABAeDIsgBUXFysyMlJpaWmuZZmZmTp69KjHuidOnFBGRobuv/9+ffnllxo2bJhuv/12JScnu63ndDq1Z88eXXvttW7LKyoqtGDBAkVHR2vixIm68cYbZbPZPN4nNzdXubm5kqTly5d7bF+SSkpKZLW6/5gsFkvXd7wbLBaLx3t25KqrrpIkHTp0SMXFxW6vbWxs1IoVK/TSSy+puLhYDsfZ4Dhy5Ejt3r3bbTuVlZVauXKlVq9e7dqmJM2cOVMzZ850tS0yMtKr9vlbMLWlJ2JiYtr9HQxFVqs1bPY1lNBv5kS/mQ99Zk70mzkFot8MrYD16tXLbVlsbGy7FZszZ87o008/1f3336+MjAz96U9/0urVq/Vf//VfbusdO3ZM5eXlmjx5smvZwIEDtWLFCqWlpamsrExr167VM888o4ULF3q8T3Z2trKzs12Py8rKPNapr69XZGSk2zKn09m1ne4mp9PpCkreaG5uVnNzs9trc3Jy9O677+rFF19UUlKSbrvtNiUkJOiBBx7weI/9+/ervr5el19++Tnf3+l0qqmpqVvt8wer1Ro0bemp+vr6dn8HQ1FycnLY7Gsood/MiX4zH/rMnOg3c/JXv7UuOrVl2CyINptNdXV1bsvq6urarUxFR0dr0qRJGjZsmKKjo3X99dfr+PHjqq2tdVsvLy9PWVlZbttITEzUoEGDFBERoZSUFM2ZM0f79+/3z04Fuerqam3evFmPP/64Bg4cqNjYWM2cOVPl5eXKzMz0WP/rr79W3759Q6aiBAAAAAQbwwJYamqqmpqaVFxc7FpWWFjoMQGHJGVkZLg9bm/IX0NDg959991OZze0WCxqbm7uXqNN7r333lNGRoaGDBniWlZRUaFvfetb7a6flJSkM2fOhExFCQAAAAg2hlbAsrKytH37dtntdh07dkwHDhxodza9Sy65RAcOHFBBQYEcDof+/Oc/a8SIEYqNjXWt8/7777tm6Gvt8OHDOn36tJxOp8rKyrRt2zZNnDjR7/sXjL766iv16dPH9djpdOqNN95wG3bZ2kUXXaTo6Gi98cYbRjURAAAACCuGjjW7/fbbtW7dOi1YsEDx8fFasGCB0tPTlZ+fr5ycHNf08mPGjNFNN92kZcuWqaGhQcOHD9fSpUvdtpWXl6epU6d6VMcKCgq0Zs0a1dTUKCEhQRMnTtRNN91k2D4GgsPhkMPhUHNzs5qammS322W1WjVixAgdOnRIhw8f1tChQ/W73/1OFovFbYKN1nr37q27775b9913n6xWq6ZPny6r1aq9e/fqnXfe0f3332/wngEAAAChxeL094wSJlJUVOSxrLa21q3yJgXffcBWrVqlxx57zG3Zf/7nf+quu+7S6tWr9fTTT8vpdGr69On61a9+pb59+3a4vZdeekkbN27UiRMnFB8fr7Fjx2rp0qWaOHFi0N0HLJQm4Wjvdy1UcaGyOdFv5kS/mQ99Zk70mzkFYhIOAlgrXQ1gCB4EMHPiS8qc6Ddzot/Mhz4zJ/rNnEJ6FkQAAAAACHcEMAAAAAAwCAEMAAAAAAxCAAMAAAAAgxDAAAAAAMAgBDAAAAAAMAgBDAAAAAAMQgADAAAAAIMQwAAAAADAINZAN8CM9n1Rr4qGZr9tv090hKYMjOnSuvX19br33nu1d+9elZeXKzMzU/fcc48uvfTSbr//yy+/rA0bNuiTTz5RfHy8Ro8eraVLl2rSpEnKysrSihUrNG3atG5vHwAAAAhXBLBuqGho1pe1Tj++Q9fDXVNTk9LS0vTiiy9q4MCB2rVrlxYtWqRdu3YpPT3d63d+4okntHbtWi1fvlwzZsxQVFSU3nrrLe3cuVOTJk3yensAAAAAvkEAM7nY2FjdddddrseXXXaZMjIydPDgQaWnp6uxsVGrVq3Syy+/rC+//FIOh0OSNHLkSOXm5rptq7KyUitXrtRjjz2mmTNnupZffvnluvzyy43ZIQAAACCEEcBCzOnTp3Xy5EkNHz5ckvToo4/q3Xff1UsvvaSkpCTddtttSkhI0AMPPODx2g8++ED19fW64oorjG42AAAAEBaYhCOENDY2asmSJbruuus0bNgwVVdXa/PmzXr88cc1cOBAxcbGaubMma5rxdr6+uuv1bdvX1mt5HIAAADAHwhgIaK5uVlLly5VdHS0Hn74YUnSe++9p4yMDA0ZMsS1XkVFhb71rW+1u42kpCSdOXPGNUwRAAAAgG8RwEKA0+nUXXfdpdOnT2vDhg2KioqSJH311Vfq06eP23pvvPGGsrOz293ORRddpOjoaL3xxhuGtBsAAAAINwSwEPDLX/5SJ06c0NNPP61evXq5lo8YMUKHDh3S4cOHVVdXp2XLlsliseiqq65qdzu9e/fW3Xffrfvuu09vvPGG6urq1NjYqDfffFMPPfSQUbsDAAAAhCwu9umGPtER8maq+O5tv2tOnTqlP/3pT4qJidEFF1zgWv7II4/o3//937V06VLdcsstcjqdmj59urZu3eqqkLVn0aJFSklJ0erVq7VkyRLFx8dr7NixWrp0aU92CQAAAIAki9Pp9OcNrUylqKjIY1ltba1iY2MD0Bp0hdVqDZlr1sLpdy05OVllZWWBbga8RL+ZE/1mPvSZOdFv5uSvfktLSzvncwxBBAAAAACDEMAAAAAAwCAEMAAAAAAwCAEMAAAAAAxCAAMAAAAAgxDAAAAAAMAgBDAAAAAAMAgBDAAAAAAMQgADAAAAAINYA90AM/qkUqpr8t/2e0VKw3p3ff0777xT+/btU21trb71rW9p8eLFmj17drff/+WXX9aGDRv0ySefKD4+XqNHj9bSpUs1adIkZWVlacWKFZo2bVq3tw8AAACEKwJYN9Q1SVUOix/fwenV2kuWLNHKlSsVExOjTz75RNddd53GjBmjcePGef3OTzzxhNauXavly5drxowZioqK0ltvvaWdO3dq0qRJXm8PAAAAwDcIYCFg+PDhbo8tFosKCgo0btw4NTY2atWqVXr55Zf15ZdfyuFwSJJGjhyp3Nxct9dVVlZq5cqVeuyxxzRz5kzX8ssvv1yXX365/3cEAAAACHEEsBBxzz336Pnnn5fdbteYMWP0ve99T5L06KOP6t1339VLL72kpKQk3XbbbUpISNADDzzgsY0PPvhA9fX1uuKKK4xuPgAAABAWmIQjRCxbtkz//Oc/9fLLL+uKK65QdHS0qqurtXnzZj3++OMaOHCgYmNjNXPmTJWXlyszM9NjG19//bX69u0rq5VcDgAAAPgDASyEREZGatKkSSouLtYzzzyj9957TxkZGRoyZIhrnYqKCn3rW99q9/VJSUk6c+aMa5giAAAAAN8igIWgpqYmFRYW6quvvlKfPn1cy51Op9544w1lZ2e3+7qLLrpI0dHReuONN4xqKgAAABBWCGAmV1ZWph07dqimpkZNTU3avXu3XnnlFU2ZMkUjRozQoUOHdPjwYdXV1WnZsmWyWCy66qqr2t1W7969dffdd+u+++7TG2+8obq6OjU2NurNN9/UQw89ZPCeAQAAAKGHi326oVek5O1U8d5vv2ssFoueeeYZ/fKXv1Rzc7MGDRqk3/zmN65ZC5cuXapbbrlFTqdT06dP19atWxUVFXXO7S1atEgpKSlavXq1lixZovj4eI0dO1ZLly7t6W4BAAAAYc/idDr9lyRMpqioyGNZbW2tYmNjA9AadIXVag2Za9bC6XctOTlZZWVlgW4GvES/mRP9Zj70mTnRb+bkr35LS0s753MMQQQAAAAAgxDAAAAAAMAgBDAAAAAAMAgBrBNcIgej8LsGAAAQ+ghgXcCJMfyN3zEAAIDwQADrhM1mU01NDSfI8Kv6+npFR0cHuhkAAADwM+4D1onIyEj16tVLtbW1ks7edwvBIyYmRvX19YFuRo84nU5FRkZ2eH82AAAAhAYCWBdERkYqLi4u0M1AO7jnBgAAAMyEIYgAAAAAYBBDK2DV1dVav369Dh48qISEBM2ePVtTpkxpd92TJ0/q6aef1smTJ2Wz2XTNNddo5syZkqQ77rhD5eXliog4mx+HDx+u+++/3/Xa1157TTt27FBDQ4OysrK0YMEChncBAAAACDhDA9imTZtktVq1ceNGFRQUaNmyZcrMzFR6errbepWVlcrJydGtt96qyZMny+Fw6KuvvnJb5xe/+IXGjRvn8R4fffSRduzYoV/96ldKSkrSypUr9fzzz2vOnDl+3TcAAAAA6IxhQxDtdrv279+vWbNmyWazacSIEZowYYL27Nnjse5rr72m8ePHa+rUqYqKilKvXr00aNCgLr1PXl6eLrnkEqWnpys+Pl7XXnutdu/e7eO9AQAAAADvGVYBKy4uVmRkpNLS0lzLMjMzdfToUY91T5w4oYyMDN1///368ssvNWzYMN1+++1KTk52rbNmzRo1NzfrvPPO080336zBgwdLkk6dOqWJEye6vUdFRYWqqqqUkJDg9j65ubnKzc2VJC1fvtytbTAP+s2c6Ddzot/MiX4zH/rMnOg3czK63wytgPXq1cttWWxsrOx2u8e6Z86cUV5enn70ox9p3bp1SklJ0erVq13P33nnnVq7dq3WrVun0aNH6+GHH1ZNTY3rfWJjY93eQ5Lq6uo83ic7O1vLly/X8uXL9ctf/tIn+wlj0W/mRL+ZE/1mTvSb+dBn5kS/mVMg+s2wAGaz2TxCUF1dnWw2m8e60dHRmjRpkoYNG6bo6Ghdf/31On78uOteXCNGjFB0dLRiYmJ0zTXXKC4uTvn5+a73aVmv5T0keYQ/AAAAADCaYQEsNTVVTU1NKi4udi0rLCz0mIBDkjIyMtwed3bz49bPDxo0SIWFhW7v0adPH4/hhwAAAABgNEMrYFlZWdq+fbvsdruOHTumAwcOaNq0aR7rXnLJJTpw4IAKCgrkcDj05z//WSNGjFBsbKzKysp07NgxORwONTQ06NVXX1VlZaWGDx8uSZo+fbrefPNNnTp1SjU1NXrxxRc1Y8aMTtuXnZ3t612GAeg3c6LfzIl+Myf6zXzoM3Oi38wpEP1mcTqdTqPerLq6WuvWrdOhQ4cUHx+vOXPmaMqUKcrPz1dOTo62bt3qWvdvf/ubXnzxRTU0NGj48OGuSTg+//xzrV69WiUlJYqKitLgwYM1Z84cDR061PVa7gMGAAAAIBgZGsAAAAAAIJwZNgQRAAAAAMIdAQwAAAAADGLYjZiNUF1drfXr1+vgwYNKSEjQ7NmzNWXKFI/1cnJyXNPWS5LD4VBaWppWrVolSbrjjjtUXl6uiIiz+XT48OG6//77XetzjZlv+aLfysrK9LOf/cxt/fr6es2dO1dXXnmljhw5ot/+9reKjo52PT9//vwuTdCC9nW13xobG7VlyxYdOHBADodDw4cP18KFC9W3b98ubWffvn3atm2bqqqqNHbsWC1evFjx8fGG7Weo8UW/NTY2atOmTTp06JCqq6vVv39/zZ49WxdeeKEkqbS0VEuWLFFMTIxre1dffbWuu+46w/YzlPjqs/bggw/qxIkTru+2vn37ut1jk8+ab/mq3+bOneu2fkNDg77//e9r3rx5fNb8oKv9VlNToy1btuijjz6SJF1++eW64YYbXM+XlpZq/fr1OnHihJKTkzVv3jyNGzfO9Tznkr7li36rqKjQli1blJ+fL7vdroyMDN1yyy06//zzJcm355LOEPK73/3O+dhjjznr6uqc+fn5zltuucX52Wefdfq6X//6184XXnjB9Xjx4sXOjz/+uN11P/zwQ+ftt9/u/Oyzz5xVVVXOX//6184//elPPtuHcOSrfmutpKTEecMNNzhLSkqcTqfTefjwYed//Md/+LTd4a6r/fbKK6847777bufXX3/trK+vd65Zs8a5YsWKLm3ns88+c86dO9d55MgRZ11dnfP3v/+983e/+51RuxiSfNFvdXV1zu3btztLSkqcTU1Nzr///e/OuXPnuj5vJSUlzuuvv97pcDgM3bdQ5avP2q9//Wtnbm5uu+/BZ833fNVvrdXV1Tlvvvlm55EjR5xOJ581f+hqv61du9a5atUqp91ud5aUlDiXLFnifPPNN13P33vvvc6nnnrKWV9f73z33Xedt956q7OiosLpdHIu6Q++6Lcvv/zS+Ze//MV55swZZ1NTk/N//ud/nPPmzXPW1dU5nU7fnkuGzBBEu92u/fv3a9asWbLZbBoxYoQmTJigPXv2dPi60tJS5efntzsdfnvy8vJ0ySWXKD09XfHx8br22mu1e/duH+xBePJXv+Xl5WnUqFFKSUnxR7PDnjf9VlpaqvHjxysxMVHR0dG6+OKL9fnnn3dpO3v37tVFF12kUaNGyWazadasWdq/f7/HTd3RNb7qN5vNphtuuEEpKSmKiIjQRRddpJSUFJ08edLoXQp5vuqzzvBZ8y1/9dt7772nPn36aOTIkf7ehbDkTb998MEHuuqqqxQTE6OUlBRdcskleuuttyRJRUVF+vTTT3XDDTcoOjpakydPVkZGht577z1JnEv6mq/6rX///vrhD3+opKQkRUREKDs7Ww6HQ0VFRT5vc8gEsOLiYkVGRiotLc21LDMzs9Mvnz179mjkyJEeJ+pr1qzR/Pnz9dBDD6mgoMC1/NSpUxo8eLDbe1RUVKiqqson+xFufN1vkuR0OrVnzx5Nnz7dbXlFRYUWLFigO+64Q0899ZTsdrtvdiIMedNvl156qY4fP64zZ86ovr5ee/fudQ1V62w7p06dUmZmpuu5AQMGyGq1ut3QHV3nq35rq7y8XMXFxUpPT3dbvnjxYi1atEjr1q1TZWWlb3cmTPi6z7Zt26b58+frgQce0JEjR1zL+az5lr8+a3l5eZo2bZosFovbcj5rvtHdc5IWrb+7+vfvr169erlt59SpU67nOZf0HV/1W1st9yMeMGCAa5mvziVD5howu93u9osuSbGxsZ3+YPLy8nTttde6Lbvzzjs1ZMgQOZ1Ovf7663r44Yf1+9//XnFxcbLb7YqNjXV7D0mqq6tTQkKCj/YmfPiy31ocO3ZM5eXlmjx5smvZwIEDtWLFCqWlpamsrExr167VM888o4ULF/Z8J8KQN/2Wmpqqfv36adGiRYqIiFBGRobmz5/fpe20/by1PM9f5bvHV/3WmsPh0Jo1azR9+nQNHDhQktS7d28tW7ZMgwcPVlVVlZ588kmtWbNG9913n392LIT5ss/mzJmjQYMGyWq16u2339YjjzyiRx99VAMGDOCz5mP++KydPn1aR48e1Y9//GPXMj5rvuVNv40fP16vvPKK7rjjDlVUVOitt95SfX29azvtfZ7OnDnT7vOcS/aMr/qttdraWq1Zs0bXXXedq398eS4ZMhUwm83m8UVRV1cnm812zte0d6IuSSNGjFB0dLRiYmJ0zTXXKC4uzjX5g81mU21trdt7SPLoeHSNL/utRV5enrKysty2kZiYqEGDBikiIkIpKSmaM2eO9u/f75udCEPe9NumTZvU2NiozZs3a+vWrZo0aZJycnK6tJ1zPc/nrXt81W8tmpub9Yc//EFWq1Xz5s1ze5+hQ4cqMjJSiYmJmj9/vj7++GNO5rvBl312/vnnq1evXoqKitKMGTM0fPhwffjhhx2+D5+17vH1Z006O/JjxIgRbiM/+Kz5ljf9Nm/ePEVHR2vp0qV69NFH9d3vflf9+vVzbaf1uWLLdlo+T5xL+pav+q1FQ0ODHnnkEZ1//vm65pprXMt9eS4ZMgEsNTVVTU1NbsMlCgsLPYbEtLZ7926PE/X2tC71Dxo0SIWFhW7v0adPH/5i0U2+7reGhga9++67nc5IY7FY1Nzc3O12hztv+q2wsFAzZsxQfHy8oqKidMUVV+iTTz5RZWVlp9tp+3krKSlRY2OjUlNT/bh3octX/SadHer7xz/+URUVFbrrrrtktXY+oMLpdPpuZ8KEL/usLYvF4uoTPmu+5Y9+a29o/bnwWeseb/otPj5eS5cu1caNG/XYY4+publZQ4cOlXT281RaWuoWCgoLCzVo0CDX85xL+o6v+k06OyvpihUr1K9fv04rWz05lwyZAGaz2ZSVlaXt27fLbrfr2LFjOnDgwDknaTjXiXpZWZmOHTsmh8OhhoYGvfrqq6qsrNTw4cMlSdOnT9ebb76pU6dOqaamRi+++CJTmfeAr/qtxfvvv6/4+HiNHj3abfnhw4d1+vRpOZ1OlZWVadu2bZo4caKvdydseNNvQ4cOVV5enmpra+VwOLRz504lJSWpd+/enW5n6tSp+uCDD1xTwm7fvl1ZWVn8lbCbfNVvkrRx40Z98cUX+sUvfuE2Ja8knThxQkVFRWpublZVVZW2bNmi0aNHewzJQed81Wc1NTX66KOP1NDQoKamJu3du1f5+fm64IILJPFZ8zVfftYkua4R+5d/+Re31/JZ8y1v+u3LL79UVVWVmpub9eGHH2rXrl2uSyPS0tI0ePBgvfDCC2poaND777+vwsJC18gdziV9y1f95nA4tGrVKkVFRemOO+5w3bKjhS/PJS3OEPozSXV1tdatW6dDhw4pPj5ec+bM0ZQpU5Sfn6+cnBxt3brVtW7L/U7Wrl3rVuH6/PPPtXr1apWUlCgqKkqDBw/WnDlz3NIx927wLV/0W4uHH35YQ4cO1Y033ui2/LXXXtNf/vIX1dTUKCEhQRMnTtRNN93EyUUPdLXfWk4KDh48KIfDofT0dN16660aNmxYh9tpsW/fPj377LOqrq7m3kQ+4It+O336tO644w5FRUW5fUEtXLhQU6dO1b59+/Tcc8+psrJSvXr10rhx43TzzTcrMTExQHttbr7os8rKSi1btkxffPGFIiIiNHDgQM2aNcvtvkR81nzLV8dISdqwYYPq6+t15513ur0HnzXf62q/vfPOO3r66adVU1Oj1NRUzZkzx/UHDens7Jbr1q1z3Qds/vz53AfMj3zRb0ePHtWDDz6o6Ohot3PMe++9VyNHjvTpuWRIBTAAAAAACGYhMwQRAAAAAIIdAQwAAAAADEIAAwAAAACDEMAAAAAAwCAEMAAAAAAwCAEMAAAAAAxCAAMAwM/Wrl2r5cuXn/MxACB8WAPdAAAA/Gnt2rXKy8uTJEVERCgpKUnf+c53dNNNN3GjYQCA4QhgAICQN3bsWN15551qamrSqVOntH79etXU1OinP/1poJsGAAgzBDAAQMiLiopSYmKiJKlfv366+OKLtXv3btfzb731ll599VWVlpYqOTlZl112mWbOnKmIiLMj9Wtra/Xss8/qwIEDqqmpUUpKiq6//npdfPHFqqqq0pNPPqljx46pqqpK/fv315VXXqlLLrkkAHsKAAh2BDAAQFgpKSnRRx99pMjISElSbm6unn/+ec2bN09DhgzRZ599pieeeEJWq1U/+MEP5HQ6tWzZMlVXV2vx4sVKTU1VUVGRGhsbJUmNjY0aMmSI/u3f/k29evXSoUOHtGHDBiUnJ2vs2LGB3FUAQBAigAEAQt5HH32kuXPnqrm52RWcbrnlFknSiy++qJtvvlmTJ0+WJKWkpKikpEQ7d+7UD37wAx06dEj//Oc/tWrVKg0aNEiS1L9/f9e2+/btq6uuusr1uH///jp8+LDefvttAhgAwAMBDAAQ8kaOHKn/+I//UENDg3Jzc1VSUqKZM2eqsrJSX331lTZs2KCNGze61m9ubpbT6ZQkffrpp0pMTHSFr7aam5v1yiuv6J133tGZM2fU2Ngoh8Oh0aNHG7JvAABzIYABAEJeTEyMBgwYIEmaN2+efvOb3+jPf/6zLr/8cknSggULNHz48G5t+9VXX9Vf/vIX3XbbbcrIyJDNZtO2bdtUWVnps/YDAEIH9wEDAISd6667Tjt27FBzc7OSkpJUUlKiAQMGePyTpPPOO0/l5eU6depUu9s6duyYLrroIk2bNk2DBw9W//79VVxcbOTuAABMhAoYACDsjB49WoMGDdJLL72kG264QZs3b1ZsbKy+853vyOFw6NNPP9WZM2d0zTXXaMyYMRo2bJhWrVqlW2+9VWlpafryyy9lt9s1adIkpaWl6Z133tGxY8eUkJCgv/71ryotLdV5550X6N0EAAQhAhgAICxdeeWVWrdunVavXq0f//jH+stf/qLnnntO0dHRGjRokH7wgx9IOnvz5nvvvVdbt27VmjVrZLfbXdPQS9K///u/q7S0VDk5OYqOjtaMGTM0derUc1bMAADhzeJsucoYAAAAAOBXXAMGAAAAAAYhgAEAAACAQQhgAAAAAGAQAhgAAAAAGIQABgAAAAAGIYABAAAAgEEIYAAAAABgEAIYAAAAABjk/wMAJON5g0zPwQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 8))\n",
+    "mmu.PRU.from_scores(y_test, y_score, n_sigmas=3.).plot(ax=ax)\n",
+    "ax.set_xlim((0.75, 0.93))\n",
+    "ax.set_ylim((0.65, 0.875))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38c7301e",
+   "metadata": {},
+   "source": [
+    "## Precision-Recall curve uncertainty\n",
+    "\n",
+    "If you want to plot the uncertainty for the entire PR curve the most correct thing would be to plot the contour for each classification threshold. Unfortunately this becomes fairly slow and hard to read.\n",
+    "\n",
+    "Hence we provide a conservative alternative.\n",
+    "\n",
+    "`PrecisionRecallCurveUncertainty (PRCU)` models the uncertainty in the same way as the method for a single classification threshold. However, rather than drawing multiple countours we draw a countour(s) over the precision-recall grid.\n",
+    "For each bin in the grid we compute the profile log-likelihood (PLL) and store the minimum PLL over the thresholds. In other words, we show the region that contains the highest p-values for any threshold.\n",
+    "\n",
+    "This by nature is a conservative approach that should not be used for inference.\n",
+    "It does allow us to visualise the uncertainty over the entire curve in a reasonable time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e9e89dff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pr_curve_err = mmu.PRCU.from_scores(y_test, y_score)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17006448",
+   "metadata": {},
+   "source": [
+    "Note that we don't specify the thresholds, when thresholds is None we use ``mmu.auto_thresholds`` which determines all the threhsolds that result in a different confusion matrix.\n",
+    "\n",
+    "### Attributes\n",
+    "\n",
+    "A number of attributes are set during instantiation, most importantly:\n",
+    "* **conf_mat** : np.ndarray[int64]\n",
+    "    * the confusion_matrix with layout (N, 4)\n",
+    "| | | | |\n",
+    "|---------------|----------------|---------------|----------------|\n",
+    "| True Negative | False Positive | False Negative | True Positive |\n",
+    "    \n",
+    "* **precision** : np.ndarray[float64]\n",
+    "    * the Positive Predictive Value aka positive precision\n",
+    "* **recall** : np.ndarray[float64]\n",
+    "    * True Positive Rate aka Sensitivity aka positive recall\n",
+    "* **chi2_scores** : np.ndarray[float64]\n",
+    "    * the profile log-likelihoods scores with are distributed accoring to a\n",
+    "    chi2 distribution with 2DF\n",
+    "\n",
+    "The attributes that are Numpy arrays can be retrieved as a DataFrame using the \n",
+    "`get_<attribute_name>` methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8a3d3747",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='Recall', ylabel='Precision'>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pr_curve_err.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a5865b4",
+   "metadata": {},
+   "source": [
+    "As before we can easily add point uncertainties to the curve plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "19921b06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pr_err_95 = mmu.PRU.from_scores(y_test, y_score, threshold=0.95, n_sigmas=8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "98780e5f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "ax = pr_curve_err.plot(\n",
+    "    ax=ax,\n",
+    "    cmap='Blues',\n",
+    "    point_uncertainty=[pr_err, pr_err_95],\n",
+    "    point_kwargs=[{'cmap': 'Reds'}, {'cmap': 'Greens', 'alpha':0.95}]\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e8a04e7",
+   "metadata": {},
+   "source": [
+    "## Elliptical uncertainty\n",
+    "\n",
+    "The bivariate-normal (elliptical) approach has can be selected by setting ``method`` to one of ``bivariate``, ``bvn`` or ``eliptical``\n",
+    "\n",
+    "### Attributes\n",
+    "\n",
+    "A number of attributes are set during instantiation, most importantly:\n",
+    "* **conf_mat** : np.ndarray[int64]\n",
+    "    * the confusion_matrix with layout\n",
+    "| | |\n",
+    "|---------------|----------------|\n",
+    "| True Negative | False Positive |\n",
+    "| False Negative | True Positive |\n",
+    "    \n",
+    "* **precision** : float\n",
+    "    * the Positive Predictive Value aka positive precision\n",
+    "* **recall** : float\n",
+    "    * True Positive Rate aka Sensitivity aka positive recall\n",
+    "* **cov_mat** : np.ndarray[float64]\n",
+    "    * the covariance matrix of precision and recall with layout\n",
+    "| | |\n",
+    "| --------------- | --------------- |\n",
+    "| $\\sigma_{P}^{2}$ | $\\sigma_{P, R}$ |\n",
+    "| $\\sigma_{P, R}$ | $\\sigma_{R}^{2}$ |\n",
+    "\n",
+    "The attributes that are Numpy arrays can be retrieved as a DataFrame using the \n",
+    "`get_<attribute_name>` methods."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9671d363",
+   "metadata": {},
+   "source": [
+    "To reiterate, the elliptical approach is not valid for edge cases as can be seen in the plot below"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "99ff8740",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pr_curve_err_alt = mmu.PRCU.from_scores(y_test, y_score, method='bvn')\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "ax = pr_curve_err.plot(ax=ax)\n",
+    "ax = pr_curve_err_alt.plot(ax=ax, alpha=0.4, cmap='Reds')\n",
+    "ax.set_title('Elliptical uncertainty (red) vs Multinomial (blue)');"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}


Test patch:
diff --git a/tests/api/test_prcurve.py b/tests/api/test_prcurve.py
new file mode 100644
index 0000000..967557e
--- /dev/null
+++ b/tests/api/test_prcurve.py
@@ -0,0 +1,202 @@
+import numpy as np
+import sklearn.metrics as skm
+from sklearn.datasets import make_classification
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+
+
+import mmu
+from mmu.commons._testing import generate_test_labels
+from mmu.commons._testing import greater_equal_tol
+
+
+def test_PRCMU_from_scores():
+    """Test PRMU.from_scores"""
+    np.random.seed(412)
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    proba, _, y = generate_test_labels(N=500)
+    yhat = greater_equal_tol(proba, thresholds[100])
+
+    sk_conf_mat = skm.confusion_matrix(y, yhat)
+    pr_err = mmu.PRCU.from_scores(y=y, scores=proba, thresholds=thresholds)
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
+
+
+def test_PRCMU_from_confusion_matrices():
+    """Test PRMU.from_scores"""
+    np.random.seed(412)
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    proba, _, y = generate_test_labels(N=500)
+    yhat = greater_equal_tol(proba, thresholds[100])
+
+    sk_conf_mat = skm.confusion_matrix(y, yhat)
+    conf_mats = mmu.confusion_matrices_thresholds(y, proba, thresholds)
+    pr_err = mmu.PRCU.from_confusion_matrices(conf_mats=conf_mats)
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
+
+
+def test_PRCMU_from_classifier():
+    """Test PREU.from_classifier"""
+    # generate seeds to be used by sklearn
+    # do not use this in real scenarios,
+    # it's a convenience only used in the tutorial notebooks
+    seeds = mmu.commons.utils.SeedGenerator(234)
+
+    # generate 2 class dataset
+    X, y = make_classification(
+        n_samples=1000, n_classes=2, random_state=seeds()
+    )
+
+    # split into train/test sets
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.5, random_state=seeds()
+    )
+    # fit a model
+    model = LogisticRegression(solver='lbfgs')
+    model.fit(X_train, y_train)
+
+    # predict probabilities, for the positive outcome only
+    y_scores = model.predict_proba(X_test)[:, 1]
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    yhat = greater_equal_tol(y_scores, thresholds[100])
+    sk_conf_mat = skm.confusion_matrix(y_test, yhat)
+    pr_err = mmu.PRCU.from_classifier(
+        clf=model, X=X_test, y=y_test, thresholds=thresholds
+    )
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y_test, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
+
+
+def test_PRCEU_from_scores():
+    """Test PRMU.from_scores"""
+    np.random.seed(412)
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    proba, _, y = generate_test_labels(N=500)
+    yhat = greater_equal_tol(proba, thresholds[100])
+
+    sk_conf_mat = skm.confusion_matrix(y, yhat)
+    pr_err = mmu.PRCU.from_scores(
+        y=y, scores=proba, thresholds=thresholds, method='bvn'
+    )
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
+
+
+def test_PRCEU_from_confusion_matrices():
+    """Test PRMU.from_scores"""
+    np.random.seed(412)
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    proba, _, y = generate_test_labels(N=500)
+    yhat = greater_equal_tol(proba, thresholds[100])
+
+    sk_conf_mat = skm.confusion_matrix(y, yhat)
+    conf_mats = mmu.confusion_matrices_thresholds(y, proba, thresholds)
+    pr_err = mmu.PRCU.from_confusion_matrices(conf_mats=conf_mats, method='bvn')
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
+
+
+def test_PRCEU_from_classifier():
+    """Test PREU.from_classifier"""
+    # generate seeds to be used by sklearn
+    # do not use this in real scenarios,
+    # it's a convenience only used in the tutorial notebooks
+    seeds = mmu.commons.utils.SeedGenerator(234)
+
+    # generate 2 class dataset
+    X, y = make_classification(
+        n_samples=1000, n_classes=2, random_state=seeds()
+    )
+
+    # split into train/test sets
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.5, random_state=seeds()
+    )
+    # fit a model
+    model = LogisticRegression(solver='lbfgs')
+    model.fit(X_train, y_train)
+
+    # predict probabilities, for the positive outcome only
+    y_scores = model.predict_proba(X_test)[:, 1]
+    thresholds = np.linspace(1e-12, 1 - 1e-12, 200)
+    yhat = greater_equal_tol(y_scores, thresholds[100])
+    sk_conf_mat = skm.confusion_matrix(y_test, yhat)
+    pr_err = mmu.PRCU.from_classifier(
+        clf=model, X=X_test, y=y_test, thresholds=thresholds, method='bvn'
+    )
+    assert pr_err.conf_mats is not None
+    assert pr_err.conf_mats.dtype == np.dtype(np.int64)
+
+    prec, rec, _, _ = skm.precision_recall_fscore_support(
+        y_test, yhat, zero_division=0.0  # type: ignore
+    )
+
+    assert pr_err.chi2_scores.shape == (
+        pr_err.rec_grid.size,
+        pr_err.rec_grid.size
+    )
+    assert np.isclose(pr_err.precision[100], prec[1])
+    assert np.isclose(pr_err.recall[100], rec[1])
+    assert np.array_equal(pr_err.conf_mats[100], sk_conf_mat.flatten())
diff --git a/tests/api/test_prpoint.py b/tests/api/test_prpoint.py
index 73835d6..b57a9d3 100644
--- a/tests/api/test_prpoint.py
+++ b/tests/api/test_prpoint.py
@@ -55,7 +55,7 @@ def test_PRMU_from_scores():
         yhat = greater_equal_tol(proba, threshold)
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PRMU.from_scores(y=y, scores=proba, threshold=threshold)
+        pr_err = mmu.PRU.from_scores(y=y, scores=proba, threshold=threshold)
         assert pr_err.conf_mat is not None
         assert pr_err.conf_mat.dtype == np.dtype(np.int64)
 
@@ -82,7 +82,7 @@ def test_PRMU_from_predictions():
         )
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PRMU.from_predictions(y=y, yhat=yhat)
+        pr_err = mmu.PRU.from_predictions(y=y, yhat=yhat)
         assert pr_err.conf_mat is not None
         assert pr_err.conf_mat.dtype == np.dtype(np.int64)
 
@@ -108,7 +108,7 @@ def test_PRMU_from_confusion_matrix():
         )
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PRMU.from_confusion_matrix(sk_conf_mat)
+        pr_err = mmu.PRU.from_confusion_matrix(sk_conf_mat)
         prec, rec, _, _ = skm.precision_recall_fscore_support(
             y, yhat, zero_division=0.0  # type: ignore
         )
@@ -150,7 +150,7 @@ def test_PRMU_from_classifier():
         yhat = greater_equal_tol(y_scores, threshold)
         sk_conf_mat = skm.confusion_matrix(y_test, yhat)
 
-        pr_err = mmu.PRMU.from_classifier(
+        pr_err = mmu.PRU.from_classifier(
             model, X_test, y_test, threshold=threshold
         )
         prec, rec, _, _ = skm.precision_recall_fscore_support(
@@ -170,7 +170,7 @@ def test_PRMU_exceptions():
     proba, _, y = generate_test_labels(N=1000,)
     yhat = greater_equal_tol(proba, 0.5)
 
-    pr_err = mmu.PRMU.from_scores(
+    pr_err = mmu.PRU.from_scores(
         y=y, scores=proba, threshold=0.5, n_bins=40
     )
     assert pr_err.n_bins == 40
@@ -178,28 +178,28 @@ def test_PRMU_exceptions():
 
     # n_bins >= 1
     with pytest.raises(ValueError):
-        pr_err = mmu.PRMU.from_scores(
+        pr_err = mmu.PRU.from_scores(
             y=y, scores=proba, threshold=0.5, n_bins=-20
         )
 
     # n_bins >= 1
     with pytest.raises(ValueError):
-        pr_err = mmu.PRMU.from_scores(
+        pr_err = mmu.PRU.from_scores(
             y=y, scores=proba, threshold=0.5, n_bins=0
         )
 
     # n_bins must be an int
     with pytest.raises(TypeError):
-        pr_err = mmu.PRMU.from_scores(
+        pr_err = mmu.PRU.from_scores(
             y=y, scores=proba, threshold=0.5, n_bins=20.
         )
 
-    pr_err = mmu.PRMU.from_scores(
+    pr_err = mmu.PRU.from_scores(
         y=y, scores=proba, threshold=0.5, n_sigmas=1.
     )
 
     with pytest.raises(TypeError):
-        pr_err = mmu.PRMU.from_scores(
+        pr_err = mmu.PRU.from_scores(
             y=y, scores=proba, threshold=0.5, n_sigmas=[1., ]
         )
 
@@ -218,7 +218,9 @@ def test_PREU_from_scores():
         yhat = greater_equal_tol(proba, threshold)
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PREU.from_scores(y=y, scores=proba, threshold=threshold)
+        pr_err = mmu.PRU.from_scores(
+            y=y, scores=proba, threshold=threshold, method='bvn'
+        )
         assert pr_err.conf_mat is not None
         assert pr_err.conf_mat.dtype == np.dtype(np.int64)
         assert pr_err.cov_mat.shape == (2, 2)
@@ -244,7 +246,7 @@ def test_PREU_from_predictions():
         )
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PREU.from_predictions(y=y, yhat=yhat)
+        pr_err = mmu.PRU.from_predictions(y=y, yhat=yhat, method='bvn')
         assert pr_err.conf_mat is not None
         assert pr_err.conf_mat.dtype == np.dtype(np.int64)
 
@@ -270,7 +272,7 @@ def test_PREU_from_confusion_matrix():
         )
         sk_conf_mat = skm.confusion_matrix(y, yhat)
 
-        pr_err = mmu.PREU.from_confusion_matrix(sk_conf_mat)
+        pr_err = mmu.PRU.from_confusion_matrix(sk_conf_mat, method='bvn')
         prec, rec, _, _ = skm.precision_recall_fscore_support(
             y, yhat, zero_division=0.0  # type: ignore
         )
@@ -310,8 +312,8 @@ def test_PREU_from_classifier():
         yhat = greater_equal_tol(y_scores, threshold)
         sk_conf_mat = skm.confusion_matrix(y_test, yhat)
 
-        pr_err = mmu.PREU.from_classifier(
-            model, X_test, y_test, threshold=threshold
+        pr_err = mmu.PRU.from_classifier(
+            model, X_test, y_test, threshold=threshold, method='bvn'
         )
         prec, rec, _, _ = skm.precision_recall_fscore_support(
             y_test, yhat, zero_division=0.0  # type: ignore