diff --git a/notebooks/fast_gen_pois.ipynb b/notebooks/fast_gen_pois.ipynb
new file mode 100644
index 0000000..7a3b6d8
--- /dev/null
+++ b/notebooks/fast_gen_pois.ipynb
@@ -0,0 +1,1857 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: warning: libm.so.6, needed by /usr/lib/x86_64-linux-gnu/libblas.so, not found (try using -rpath or -rpath-link)\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabs@GLIBC_2.2.5'\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabsf@GLIBC_2.2.5'\n",
+      "collect2: error: ld returned 1 exit status\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: cannot find -lcblas\n",
+      "collect2: error: ld returned 1 exit status\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: warning: libm.so.6, needed by /usr/lib/x86_64-linux-gnu/libblas.so, not found (try using -rpath or -rpath-link)\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabs@GLIBC_2.2.5'\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabsf@GLIBC_2.2.5'\n",
+      "collect2: error: ld returned 1 exit status\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: cannot find -lcblas\n",
+      "collect2: error: ld returned 1 exit status\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: warning: libm.so.6, needed by /usr/lib/x86_64-linux-gnu/libblas.so, not found (try using -rpath or -rpath-link)\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabs@GLIBC_2.2.5'\n",
+      "/home/ricardo/miniconda3/envs/aeppl/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/libblas.so: undefined reference to `cabsf@GLIBC_2.2.5'\n",
+      "collect2: error: ld returned 1 exit status\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pymc as pm\n",
+    "from matplotlib import pyplot as plt\n",
+    "from scipy.special import gammaln\n",
+    "\n",
+    "\n",
+    "def _logpow(x, m):\n",
+    "    \"\"\"\n",
+    "    Calculates log(x**m) since m*log(x) will fail when m, x = 0.\n",
+    "    \"\"\"\n",
+    "    # return m * log(x)\n",
+    "    return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))\n",
+    "\n",
+    "\n",
+    "def _logprob(x, p, lam):\n",
+    "    p_lam_x = p + lam * x\n",
+    "    return np.where(\n",
+    "        x >= 0,\n",
+    "        np.log(p) + _logpow(p_lam_x, x - 1) - p_lam_x - gammaln(x + 1),\n",
+    "        -np.inf,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def _rejection_region_monotonicity(rng, p, lam, dist_size, idxs_mask=None):\n",
+    "    if idxs_mask is None:\n",
+    "        idxs_mask = np.ones(dist_size, dtype=\"bool\")\n",
+    "    p = np.broadcast_to(p, dist_size)[idxs_mask]\n",
+    "    lam = np.broadcast_to(lam, dist_size)[idxs_mask]\n",
+    "    dist_size = np.sum(idxs_mask)\n",
+    "    p0 = np.exp(-p)\n",
+    "    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)\n",
+    "    x = np.full(dist_size, np.nan)\n",
+    "    inds_to_sample = np.ones(dist_size, dtype=bool)  # dummy boolean mask#u > p0 / (p0 + b)\n",
+    "    counter = -1\n",
+    "    while np.any(inds_to_sample):\n",
+    "        counter += 1\n",
+    "        u = rng.uniform(size=dist_size)\n",
+    "        zero_xs = u <= p0 / (p0 + b)\n",
+    "        x[inds_to_sample & zero_xs] = 0\n",
+    "        inds_to_sample = inds_to_sample & ~zero_xs\n",
+    "\n",
+    "        v = rng.uniform(size=dist_size)\n",
+    "        w = rng.uniform(size=dist_size)\n",
+    "        _x = np.floor(1 / w ** 2)\n",
+    "        accepted = v * b * (1 / np.sqrt(_x) - 1 / np.sqrt(_x + 1)) <= np.exp(_logprob(_x, p, lam))\n",
+    "        x[inds_to_sample & accepted] = _x[inds_to_sample & accepted]\n",
+    "        inds_to_sample = inds_to_sample & ~accepted\n",
+    "    # print(counter)\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def _rejection_region_poisson(rng, p, lam, dist_size, idxs_mask=None):\n",
+    "    if idxs_mask is None:\n",
+    "        idxs_mask = np.ones(dist_size, dtype=\"bool\")\n",
+    "    p = np.broadcast_to(p, dist_size)[idxs_mask]\n",
+    "    lam = np.broadcast_to(lam, dist_size)[idxs_mask]\n",
+    "    dist_size = np.sum(idxs_mask)\n",
+    "\n",
+    "    eps = (1 - lam) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)\n",
+    "    delta = (1 - lam) ** (2 / 5) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)\n",
+    "    mu = (p - lam) / (1 - lam)\n",
+    "    sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)\n",
+    "    psi = (\n",
+    "        p * delta * (2 + delta - 2 * lam)\n",
+    "        + (1 + delta) * (1 - lam) ** 2\n",
+    "        - lam * (1 - lam + delta) ** 2\n",
+    "    ) / (2 * (p - 1 - delta))\n",
+    "    G = (\n",
+    "        (p * (1 - lam - eps) * np.sqrt(1 + delta))\n",
+    "        / ((p - lam) * (1 - lam) * (1 - eps) ** 2)\n",
+    "        * np.exp(psi / (1 + delta))\n",
+    "    )\n",
+    "\n",
+    "    def g(x, G, mu, sigma):\n",
+    "        return G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))\n",
+    "\n",
+    "    def h_r(x, p, lam, eps, mu):\n",
+    "        return (\n",
+    "            (p * (1 - lam - eps) ** 1.5)\n",
+    "            / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)\n",
+    "            * np.exp(\n",
+    "                -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (x - mu)\n",
+    "                + 2 * (1 - lam)\n",
+    "            )\n",
+    "        )\n",
+    "\n",
+    "    t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)\n",
+    "    H_r = (\n",
+    "        (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))\n",
+    "        / (\n",
+    "            np.sqrt(2 * np.pi)\n",
+    "            * (p - lam) ** 1.5\n",
+    "            * (1 - 2 * (1 - lam - eps) / (p - lam))\n",
+    "            * eps\n",
+    "            * (1 - lam)\n",
+    "        )\n",
+    "        * np.exp(-(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu))\n",
+    "    )\n",
+    "\n",
+    "    def h_l(x, p, lam, delta, mu):\n",
+    "        return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+    "\n",
+    "    t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)\n",
+    "    H_l = (\n",
+    "        (2 * p * (1 + delta))\n",
+    "        / (np.sqrt(2 * np.pi) * delta * (1 - lam))\n",
+    "        * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))\n",
+    "    )\n",
+    "\n",
+    "    x = np.zeros(dist_size)\n",
+    "    inds_to_sample = np.arange(dist_size)\n",
+    "    n_to_accept = np.zeros(dist_size)\n",
+    "    counter = -1\n",
+    "    while np.any(inds_to_sample):\n",
+    "        counter += 1\n",
+    "        _dist_size = len(inds_to_sample)\n",
+    "        U = rng.uniform(size=_dist_size)\n",
+    "        N = rng.normal(size=_dist_size)\n",
+    "        V = rng.uniform(size=_dist_size)\n",
+    "        E = rng.exponential(size=_dist_size)\n",
+    "        _G = G[inds_to_sample]\n",
+    "        _H_l = H_l[inds_to_sample]\n",
+    "        _H_r = H_r[inds_to_sample]\n",
+    "        _p = p[inds_to_sample]\n",
+    "        _lam = lam[inds_to_sample]\n",
+    "        _mu = mu[inds_to_sample]\n",
+    "        _sigma = sigma[inds_to_sample]\n",
+    "        _delta = delta[inds_to_sample]\n",
+    "        _eps = eps[inds_to_sample]\n",
+    "        _t_l = t_l[inds_to_sample]\n",
+    "        _t_r = t_r[inds_to_sample]\n",
+    "\n",
+    "        center = U < _G / (_G + _H_l + _H_r)\n",
+    "        left = (U < (_G + _H_l) / (_G + _H_l + _H_r)) & ~center\n",
+    "        raw_center_y = _mu + _sigma * N\n",
+    "        raw_left_y = _t_l - 2 * E * (1 + _delta) / _delta / (1 - _lam)\n",
+    "        raw_right_y = _t_r + 2 * E / ((1 - 2 * (1 - _lam - _eps) / (_p - _lam)) * _eps * (1 - _lam))\n",
+    "        Y = np.where(\n",
+    "            center,\n",
+    "            np.where(\n",
+    "                (raw_center_y >= _t_l) & (raw_center_y < _t_r),\n",
+    "                raw_center_y,\n",
+    "                np.nan,\n",
+    "            ),\n",
+    "            np.where(\n",
+    "                left,\n",
+    "                np.where(\n",
+    "                    raw_left_y >= 0,\n",
+    "                    raw_left_y,\n",
+    "                    np.nan,\n",
+    "                ),\n",
+    "                np.where(\n",
+    "                    raw_right_y >= 0,\n",
+    "                    raw_right_y,\n",
+    "                    np.nan,\n",
+    "                ),\n",
+    "            ),\n",
+    "        )\n",
+    "        X = np.floor(Y)\n",
+    "        accepted = (\n",
+    "            V\n",
+    "            * np.where(\n",
+    "                center,\n",
+    "                g(Y, G=_G, mu=_mu, sigma=_sigma),\n",
+    "                np.where(\n",
+    "                    left,\n",
+    "                    h_l(Y, p=_p, lam=_lam, delta=_delta, mu=_mu),\n",
+    "                    h_r(Y, p=_p, lam=_lam, eps=_eps, mu=_mu),\n",
+    "                ),\n",
+    "            )\n",
+    "            <= np.exp(_logprob(X, _p, _lam))\n",
+    "        )\n",
+    "\n",
+    "        x[inds_to_sample[accepted]] = X[accepted]\n",
+    "        n_to_accept[inds_to_sample[accepted]] = counter\n",
+    "        inds_to_sample = inds_to_sample[~accepted]\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def _rejection_region_abel(rng, p, lam, dist_size, idxs_mask=None):\n",
+    "    if idxs_mask is None:\n",
+    "        idxs_mask = np.ones(dist_size, dtype=\"bool\")\n",
+    "    p = np.broadcast_to(p, dist_size)[idxs_mask]\n",
+    "    lam = np.broadcast_to(lam, dist_size)[idxs_mask]\n",
+    "    dist_size = np.sum(idxs_mask)\n",
+    "\n",
+    "    nu = 2 * (p ** 2 - lam * p - 3 * lam ** 2) / (3 * lam ** 2)\n",
+    "    alpha = 0.2746244084  # Taken from page 259\n",
+    "    t = np.floor(alpha * np.maximum(nu, 0))\n",
+    "    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))\n",
+    "    t[problematic] = 0\n",
+    "    # b = p * np.exp(np.maximum(1 - p, 0)) * np.sqrt(2 / np.pi)\n",
+    "    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)\n",
+    "    q_r = b / np.sqrt(t + 1)\n",
+    "\n",
+    "    rho_t = (  # Taken from page 250\n",
+    "        1\n",
+    "        - p\n",
+    "        + np.log(p)\n",
+    "        - 0.5 * np.log(2 * np.pi)\n",
+    "        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))\n",
+    "        - 1.5 * np.log(t + 1)\n",
+    "        + (1 - lam) * t\n",
+    "    )\n",
+    "#     rho_t_prime = (  # Taken form page 271\n",
+    "#         np.log(lam * t + p) \n",
+    "#         - np.log(t + 1)\n",
+    "#         + 1\n",
+    "#         - lam\n",
+    "#         + 0.5 / (t + 1)\n",
+    "#         - (lam + p) / (lam * t + p)\n",
+    "#     )\n",
+    "    rho_t_prime = (\n",
+    "        np.log(lam * t + p)\n",
+    "        - np.log(t + 1)\n",
+    "        + 1\n",
+    "        - lam\n",
+    "        - (t + 0.5) / (t + 1) ** 2\n",
+    "        - (t - 1) * lam / (lam * t + p)\n",
+    "    )\n",
+    "    q = np.exp(-rho_t_prime)\n",
+    "    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))\n",
+    "\n",
+    "    x = np.zeros(dist_size)\n",
+    "    n_to_accept = np.zeros(dist_size)\n",
+    "    inds_to_sample = np.arange(dist_size)\n",
+    "    counter = -1\n",
+    "    while np.any(inds_to_sample):\n",
+    "        counter += 1\n",
+    "        _dist_size = len(inds_to_sample)\n",
+    "        U = rng.uniform(size=_dist_size)\n",
+    "        V = rng.uniform(size=_dist_size)\n",
+    "        W = rng.uniform(size=_dist_size)\n",
+    "        # E = rng.uniform(size=_dist_size)\n",
+    "        E = rng.exponential(size=_dist_size)\n",
+    "        _p = p[inds_to_sample]\n",
+    "        _lam = lam[inds_to_sample]\n",
+    "        _t = t[inds_to_sample]\n",
+    "        _q = q[inds_to_sample]\n",
+    "        _q_l = q_l[inds_to_sample]\n",
+    "        _q_r = q_r[inds_to_sample]\n",
+    "        _b = b[inds_to_sample]\n",
+    "#         raw_left = np.where(_t == 0, 0, _t - np.floor(-E / np.log(1 - _q)))\n",
+    "#         raw_left = np.where(_t == 0, 0, _t - np.floor(-E / np.log(_q)))\n",
+    "        # raw_left = np.where(_t == 0, 0, _t + np.ceil(np.log(1 - E) / _q))\n",
+    "        raw_left = np.where(_t == 0, 0, _t - np.floor(E / _q))\n",
+    "        raw_right = np.floor((_t + 1) / W ** 2)\n",
+    "        \n",
+    "        left = U <= _q_l / (_q_l + _q_r)\n",
+    "        accepted = np.where(\n",
+    "            left,\n",
+    "            np.where(\n",
+    "                _t == 0,\n",
+    "                True,\n",
+    "                np.where(\n",
+    "                    raw_left < 0,\n",
+    "                    False,\n",
+    "#                     V * _q_l * _q ** (_t - raw_left) * (1 - _q)\n",
+    "                    V * _q_l * _q ** (_t - raw_left) * (1 - _q ** (_t + 1))\n",
+    "                    <= np.exp(_logprob(raw_left, _p, _lam)),\n",
+    "                ),\n",
+    "            ),\n",
+    "            V * _b * (1 / np.sqrt(raw_right) - 1 / np.sqrt(raw_right + 1))\n",
+    "            <= np.exp(_logprob(raw_right, _p, _lam)),\n",
+    "        )\n",
+    "        X = np.where(left, raw_left, raw_right)\n",
+    "\n",
+    "        x[inds_to_sample[accepted]] = X[accepted]\n",
+    "        n_to_accept[inds_to_sample[accepted]] = counter\n",
+    "        inds_to_sample = inds_to_sample[~accepted]\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def _inverse_rng_fn(rng, theta, lam, dist_size):\n",
+    "    log_u = np.log(rng.uniform(size=dist_size))\n",
+    "    pos_lam = lam > 0\n",
+    "    abs_log_lam = np.log(np.abs(lam))\n",
+    "    theta_m_lam = theta - lam\n",
+    "    log_s = -theta\n",
+    "    log_p = log_s.copy()\n",
+    "    x_ = 0\n",
+    "    x = np.zeros(dist_size)\n",
+    "    below_cutpoint = log_s < log_u\n",
+    "    with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n",
+    "        counter = 0\n",
+    "        while np.any(below_cutpoint):\n",
+    "            counter += 1\n",
+    "            x_ += 1\n",
+    "            x[below_cutpoint] += 1\n",
+    "            log_c = np.log(theta_m_lam + lam * x_)\n",
+    "            # Compute log(1 + lam / C)\n",
+    "            log1p_lam_m_C = np.where(\n",
+    "                pos_lam,\n",
+    "                np.log1p(np.exp(abs_log_lam - log_c)),\n",
+    "                pm.math.log1mexp_numpy(abs_log_lam - log_c, negative_input=True),\n",
+    "            )\n",
+    "            log_p = log_c + log1p_lam_m_C * (x_ - 1) + log_p - np.log(x_) - lam\n",
+    "            log_s = np.logaddexp(log_s, log_p)\n",
+    "            below_cutpoint = log_s < log_u\n",
+    "#     print(counter)\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def _branching_rng_fn(rng, theta, lam, dist_size, idxs_mask=None):\n",
+    "    if idxs_mask is None:\n",
+    "        idxs_mask = np.ones(dist_size, dtype=bool)\n",
+    "    lam_ = np.abs(lam)  # This algorithm is only valid for positive lam\n",
+    "    y = rng.poisson(theta, size=dist_size)\n",
+    "    x = y.copy()\n",
+    "    higher_than_zero = y > 0\n",
+    "    while np.any(higher_than_zero[idxs_mask]):\n",
+    "        y = rng.poisson(lam_ * y)\n",
+    "        x[higher_than_zero] = x[higher_than_zero] + y[higher_than_zero]\n",
+    "        higher_than_zero = y > 0\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/1238690607.py:5: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  poisson_idxs = np.broadcast_to(p >= np.maximum(3, 2 * lam / (1 - lam)), dist_size)\n",
+      "/tmp/ipykernel_21224/1238690607.py:7: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam))),\n"
+     ]
+    }
+   ],
+   "source": [
+    "rng = np.random.default_rng(42)\n",
+    "p, lam = np.meshgrid(np.logspace(-2, 4, 50), np.linspace(0, 1, 50))\n",
+    "dist_size = (100, *p.shape)\n",
+    "monotonicity_idxs = np.broadcast_to(p <= np.exp(lam), dist_size)\n",
+    "poisson_idxs = np.broadcast_to(p >= np.maximum(3, 2 * lam / (1 - lam)), dist_size)\n",
+    "abel_idxs = np.broadcast_to(\n",
+    "    (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam))),\n",
+    "    dist_size,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 3.56 s, sys: 108 ms, total: 3.67 s\n",
+      "Wall time: 3.69 s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/2250734458.py:80: RuntimeWarning: overflow encountered in power\n",
+      "  V * _q_l * _q ** (_t - raw_left) * (1 - _q ** (_t + 1))\n",
+      "/tmp/ipykernel_21224/2555885245.py:12: RuntimeWarning: invalid value encountered in log\n",
+      "  return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "samples = np.full(dist_size, np.nan)\n",
+    "samples[monotonicity_idxs] = _rejection_region_monotonicity(\n",
+    "    rng=rng, p=p, lam=lam, dist_size=dist_size, idxs_mask=monotonicity_idxs\n",
+    ")\n",
+    "samples[poisson_idxs] = _rejection_region_poisson(\n",
+    "    rng=rng,\n",
+    "    p=p,\n",
+    "    lam=lam,\n",
+    "    dist_size=dist_size,\n",
+    "    idxs_mask=poisson_idxs,\n",
+    ")\n",
+    "samples[abel_idxs] = _rejection_region_abel(\n",
+    "    rng=rng,\n",
+    "    p=p,\n",
+    "    lam=lam,\n",
+    "    dist_size=dist_size,\n",
+    "    idxs_mask=abel_idxs,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "c = np.zeros_like(p.flatten())\n",
+    "c[monotonicity_idxs[0].flatten()] = 0\n",
+    "c[poisson_idxs[0].flatten()] = 1\n",
+    "c[abel_idxs[0].flatten()] = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/1687800886.py:2: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  (p / (1 - lam)).flatten(),\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Sample mean')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABRlElEQVR4nO39aZgd2X3feX5PRNy4+5b7glywFVAo1IIqFMkqklKRFCVSpiWLoixSy0jTGrNlk27brZ72qO2n3W5PP9aL6e7Hbcl20xKHkmVLlihaJkW6KUpicSnWgtqw70Du+827b7GdfhE3E0gUgAIKBWQC+f/UA4IZd4kTAeB3zz1x4n+U1hohhBAPPmOzGyCEEOLekMAXQohtQgJfCCG2CQl8IYTYJiTwhRBim5DAF0KIbcLa7AbcTE9Pjx4fH9/sZgghxH3jtddeW9Fa917vsS0d+OPj47z66qub3QwhhLhvKKUmb/SYDOkIIcQ2IYEvhBDbhAS+EEJsExL4QgixTUjgCyHENiGBL4QQ24QEvhBCbCG+71MsFu/Ke2/pefhCCLGdlEolpqam8DyPZDKJbdvv6vtL4AshxCbzPI+pqSmKxSLxeJw9e/a862EPEvhCCLGpVldXmZ6exvd9hoaGGBgYQCl1V/YlgS+EEJvAcRympqYol8skk0nGxsaIx+N3dZ8S+EIIcY8tLy8zOzuL1pqRkRF6e3vvWq/+ahL4QghxF+jOf8ZVkyHb7TYTExPUajXS6TRjY2NEo9F71iYJfCGEeJeVKbPKKi4uUaJ0625qizXm5+dRSjE2NkZPT889b5cEvhBCvIsqVFhggTgxoiSpNqt8d+K7ZBtZBnIDjI6OEolENqVtEvhCCHGHPDxatNBollgkTgxTmyzML7C8sAymJrcrx+787k1tpwS+EELcgRo15plHEwCaOebI1fMUJ4q0W23y3Xn6d/SjLb3ZTZXAF0KId8rDY4F5YkQxMQmCgNpsnYtLlxixRxjfM04mm6FFiziJzW6uBL4QQtyugAAfnyYNNBoTk2qlyszkDL7jk+xNMDA8QNJM0qKFj08XXZvdbAl8IYS4HSVKrFLAx6dNi7rfoDBToLRSwo7aHNh3ACflYGPj4REnQRddRLl30y9vRAJfCCFuQZMmM0wzwzQJkuTJE5Tg+NQJ0l6aPQO76R/sRxvhWP04O4mwObNxbkQCXwghbqJNmwIrzDCNi0uSFNrVHJ0+ilk0GY4PYu4xSSVSNGigUPQzsOXCHiTwhRDihipUmGOWChVcXEqUaRfauNMuXuDTNZzm0f6D1FSNAQYwsYgRw9qi0bo1WyWEEJvIx2eFZc5xFgODOg0SToLKZIX5yjwjqWH2ju0miGkcXOIkyJBFcffr4dwJCXwhhOjw8VliiXOcoUoVE4t++llcXuTMzGm66GJwZIBcX279+R4ugwxu+bAHCXwhhADCOfWnOck8c7RoY2Iy15planKSWC2BnYnSPzZAwg5LGLt4DLODQQa3xAycWyGBL4TY9kqUmOAyF7lIhAht3UYtKspzZRpGg0PjT9LVvYc2Lh4BI+xggEESW+BmqtshgS+E2LZWWeUobzDNVKeUsUm+kWd6chrdgP58P2pEQUTTok0P3YyzizTpzW76OyKBL4TYdtaKnH2X7+B2Lro2gwYX5y9iL0bJWVkiuyL05nto0yJHnj76GWd8S063vFX3LPCVUs8B/ww4Cfyh1vr5e7VvIYRYU6HCWc5wgfPUqWMTpVVrUpus47ZcVDfs3DGOZ/m0aRPBZjd76KUXE3Ozm39H7ijwlVJfBD4BLGmtD161/WPAvwBM4Le11r8BaKAGxICZO9mvEELcLgeH13mVYxzFwcWhje3bVOeqrC4Vydk59u/dRyVToUYNE4txdvIQ+0iR2uzmvyvutIf/JeA3gd9b26CUMoHfAj5KGOxHlFJfBb6ntf6OUqof+N+An7/DfQshxC2pUOF7fIdLnYuyWbLMVWaZmpwi6aTp6uuiazhH1IiRRvEQ+9nBCF103RfTLW/VHQW+1vq7Sqnxaza/B7igtb4EoJT6Q+AntdanOo8X4T6ZwySEuK9VKPMmb3KJSxQpYGJS9+qszKzgFFyMmElqX4LeVDcmJk2aPMQ+9vPwfTPV8nbcjTH8YWD6qp9ngPcqpT4J/BiQI/xWcF1Kqc8CnwUYHR29C80TQjzoAgJOcpIX+T5FSmgCXFx0UVOfbuJ7HoODgwwNDNEyWrRx6KWXR3iU3ezesPD4g+SeXbTVWn8F+MotPO8LwBcADh8+vPlLxAgh7istWhzhFV7iRQICTAxsN8bE1ATNUotcIkvPnn7iiRig6aOPp3kPO9m1ZWvgvFvuxtHNAiNX/byjs00IIe4aD4+TnOQFvkeFMj4+ESKsFlZpTjchUCSHk2T7c9gqgk9AkhTP8gHGGHugxupv5G4E/hFgr1JqJ2HQfxr4ubuwHyGEAKBIkT/lPzHHDB4eGo3ruDQnW7gVBzMVYWRsGDfmEiOKTYxHeIRDPHnf3kT1TtzptMw/AJ4DepRSM8A/0Vr/jlLq88A3CadlflFrffKOWyqEENcICHiDN/g2f0GVajj2rqG13KIwu4rCoHe0l2RvHB8fhcEII3yQ5+ijb7Obf8/d6Sydz9xg+zeAb9zJewshxM1MMcV/4c+YZ56AAIWB2/JYnVxF1zTxTIz0WJqYbROgsbF5mAN8iA9jP4AzcG7Fg32FQgjxwAkI+BZ/zsu8iIcHgNaa6kKFxnwdbSpy4xmy3Vl8fBIk6KWPD/MjDDO8Lcbqb0QCXwhx35hhmj/lKyyxtL7NbbiUJkp4TY9YPkbXSBcqovDwiWJzmKd5L+8jRnwTW741SOALIba8OnX+hD/mAufXt+lAU52vUV+sY1gG+d15YrkYGo1CkSfHx/hrPMRDm9jyrUUCXwixpZ3gOF/hy+vDNwBOzaE0UcJv+8R7EmR2pDHM8GapJEme4Cl+iB8iLr36DSTwhRBbSkBAhQrLLPAtvsUCC1ce8wOqs1Uayw0M26RrbxfRzJULsD308Df4aUaRu/SvRwJfCLFlaDQLLPADvs8xjm54rFVuUZ6qEDg+ib4kmeE0yrhyAfYxHuMn+Ski2Pe62fcNCXwhxJYxxwy/x+/RpLG+LfACKjMVmoUmZsyie383dvJKqGfI8dP8NDvZtRlNvq9I4AshNlVAQIsW3+BrHOPYhseaxSblqQra16QGU6QGUyh1pVf/FIf5MT5OjNi9bvZ9SQJfCLFpfHxe5zW+xn/euN31KU9VaJdaWIkIufEskfiVpQWjxPgMP8cudt/rJt/XJPCFEPech4ePz7/jS0wxteGxxkqDykwVrTXpHWmSfckNvfonOcxf5yfu++UGN4MEvhDinvHwWGaZN3iNl3hx42Ntj/JkGafqEEnZ5MazWNErEWUT5f/BLzHK2L1u9gNDAl8Icc/MMsPv83u0aa9v01rTWG5Qma2ilCIzmiHZm9zwuv3s59P8/AO7MMm9IoEvhLhrPDzKlKlS4SVe5BQbC+e6TZfyZBm37hLNRsmOZjHtK0M1Jia/wt9ix4YlNsQ7JYEvhLgrfHxmmaHAKn/Kn2x4TGtNbaFObb6GMhW5nTniXRvvin2YR/iMLKXxrpLAF0K8a2rUKFKkTZsWTX7AC8xsWOIanLpDebIcFjvripMdyWBYG4dqfon/J7vZcy+bvi1I4Ash3hVlyiwwj43NIgt8k/+y4XEdaKpz1bDYWcRcL3Z2tQMc5NNcd5kN8S6QwBdCvGMeHi1aACyzTIIEX+frzDGz4XntapvyZPm6xc7W/B0+zwCD96zt25EEvhDiHalQYZFFIKBFmwtc4A1e2/Ccq4udmVGTroe6iKY3rjb1MAf4DD9/D1u+fUngCyFum4vLIgvEiOHi8Vd8nQKFDc9plVuUJysErk+yP0l6aGOxM4D/hn9ADz33sunbmgS+EOK2NTrFzc5zgef5yw2PBV5AebpCa7WJFbfI795Y7AzgER7jZ/nZe9ZeEZLAF0Lcsna1SrtZYzm2ylfS/5m6qm94vLnapDzdKXY2lCY1sLEsAsA/5NdJkrqXzRYdEvhCiLcV+D5LJ05QnpvhhDrGUXUUduZgVx4sA9/xKU+VaZfbRJIRsmMbi50BPMOzfJy/tjkHIAAJfCHELShMX2J29jRf7/82Hi6QgNkqxCM04tZNi50B/Dr/WJYb3AIk8IUQNxQQUGCFP5/8j5zNn4erKlR6EYPyX13GeaQXOxMlO7ax2BnAj/IxPsAH73GrxY1I4AshNtBo2rQJdMBqdY5/6/9rtDsP0XCIRmtNfbVFdamOqntkx7Ikril2FiPO/5t/SITI9XYhNokEvhBinYPDPHM06kVeeONPmKpeADQsNiBm4o5kKC/UcJseUTcg+/4dmNeE/Y/zCd7HM5tzAOKmJPCF2OYCAlxcNJoJJijrMl9/4zfBC6AvAYBORqh9e4raTAWVjJDrThDfmYP93evv00MPf5e/j0LdYE9is0ngC7GNlSmzzDIObeaCWd5svkKlvgJVdz3snaZLebGBl48R25Uje6AHIxOFrjh0bqT6DD/PwxzYzEMRt0ACX4htqklz/W7ZC0tv8oOT/wlaPtQcWGmgczGqxSb11SZGxCA/liG2vzucitkxzDD/NX9nE49C3A4JfCG2EY2mRYuAgBJFDAy+UfkT5l57GXIxyEQhH6V9Yonydybxd6RJ5GOke+IYhRb0JNbf63P8XfoZ2MSjEbdLAl+IB1iLFk2aKBRRbJZZXg/81/3XOOOfgNlVsE2wTQI/oLLSpNkbxzxTpGt3jmjUgkILxrOQjfIQ+/kFfnGzD028AxL4QjygChQosIKBgUZTYIUUGdJBkv94+d9QuzQNng9zNehN0DIV5YU6gReQ3N1FeiiD2tcNERN645CL8Tn19+inf7MPTbxDEvhCPIBatCiwQpIkCkWLFhVqXOIyZy59H86tQnccLIOg7lD+9gSth3ux8jG6RjJEFBCz4OEeMBQf4AP8KB/f7MMSd0gCX4gHUIMGXuc/H58L+gIvNr6NH3hwqQQ9cTANmuU25ZaPjpikik1SD+VRTQ/cAA4PgKH47/l1UlLs7IEggS/EA6ZFizlmWWEZiwgnKkeYO/pGOPvG8WGijP94H+VSm3bNIRK3yP3ITqy2B9kYxC0YTvOB9Ef5UX5ssw9HvIsk8IV4gPj4zDKDQlGlyhHnRXhlCqIm9CUh0NTfXKT6rcvoAz1k+pMk8jFUoQUHemF3ngRJ/j7/gJgUO3vgSOAL8QBp0GCxOsWxie8yV7oIbR8qbRjL4rU9SvN13J449rlVsokIVjISzsCxDdiR5sf5a7yPZzf7MMRdcs8CXyn1MPD3gB7gL7XW//pe7VuIB51DmzYOM5ULfOvF38G3NCQjMFVGXy5RB6pND6Ugu7+HRF8Kcp0e/K4c+ZFx/m70v8WSYmcPtDsKfKXUF4FPAEta64NXbf8Y8C8Ia6n+ttb6N7TWp4FfVUoZwO8BEvhCvAMeHg0a+PjEiDHPLDNMc2LlCAtf/S4s18Phm9E0bk+c0usLeMeXiD7RT3YghakIL8o+Mwwxi0/xN3mMxzf7sMQ9cKc9/C8Bv0kY4AAopUzgt4CPAjPAEaXUV7XWp5RSPwH8beDf3eF+hdiWGjSYYxZNACiWWWKWWY7Pfx9enodiEwZT6LZH7YVZan0JVF+CXMkhno1C3YWWB/u76Y0N8nn+nhQ720buKPC11t9VSo1fs/k9wAWt9SUApdQfAj8JnNJafxX4qlLq68B/uN57KqU+C3wWYHR09E6aJ8QDJSBgjlnatGnTwsXjhfZ3qJ6+BH81Ab6GchtHQckJ8B2feM0l895hjJoL+ThYCgbT/HLX59jF7s0+JHGP3Y0x/GFg+qqfZ4D3KqWeAz4JRIFv3OjFWusvAF8AOHz4sL4L7RPivtSmTYECDi5L3ixHLz0P37wE1TZUHfSuPJVyi8aLcxgHuukaTRNteGGv/ulB6E9JWYRt7p5dtNVaPw88f6/2J8SDQKNp0qRNmzp1VihwgmPUj52Hy+WwZv2ODO3X5im9OEMwliUxmiIdtzBKDqRtODQA/Sn+Np9jkKHNPiSxie5G4M8CI1f9vKOzTQhxGwICFligQpkGTU7UX+PC6lGYKMPLc5C2CZoelUKTZsLGnK/RHTGwd+Yh36l8+f4dPNH1AT7JT2/24Ygt4G4E/hFgr1JqJ2HQfxr4ubuwHyEeaBXKFFihoFf43tk/xT03B2dXYbUFtTatwRTl1xcJxrMkRzOkc1GUZUC5Ha5E9dQg/03+f6CHns0+FLFF3Om0zD8AngN6lFIzwD/RWv+OUurzwDcJp2V+UWt98o5bKsQ2EBDQpEmlucKpxVc40zzBoj8HZwrQKWjmj2WofH+alhdgjaTpqrSJRE1oezCUhoe6OHTox/kp41ObfThii7nTWTqfucH2b3CTC7NCiLdq02ayeYGps29w6ZXvMpdaJrAV/MUlQEHcohExqaRsdDZKuuaQfLwftdyAhgtdCaz37+LXhv9nkoYUOxNvJaUVhNgCmjQ5Xn6Fyz/4PhOv/oB6tAkFH06ugBvgN1xKWuOgiOztIndoAGumAp4O6+T82G5+eO+n+EjkRzf7UMQWJoEvxCarUuUcZzn2/a8zdfwIzJcgGYXJElQd6r0JKsUWxCwyvk+y2bl5aiwH/Uliuwf5tX2/QZTYJh+J2Ook8IW4xwICKlSoUqFNm7PBKU6de4Hq178VrhlrGhA38VablBoebszEztjk4hZmLAJLdSimYTTLR/d+mg/s/kkUxmYflrgPSOALcQ9pNNNMUaGCgeJI6btc+s634fQKNH1wA3SxTb3QpKpBtTyyUYvEcBpGMuFNVLtypD/3ET6X/AckTBmrF7dOAl+Ie8THZ4IJJrmMg8Mrr30V78vH4OwKKAUNB9cyKKUjeBNlYpZBxiAsdtaXhKgFVYcf/fHP84HMz2z24Yj7kAS+EHdZQECLFrPBNJeqZ5gOLjNVuwC//XJYFiFiooOA6mqbenkJY08X+cEUsd5EOPvm0AB4Pj1+L3/t2V9i56PPbfYhifuUBL4Qd5GHxwwzFKsLvPr6V5mrXcKvt+Bbl+FyCUayOG2HklL4UZN4yyUzmsFAwWO98NQgKMUnmz/F7u5HSfb2YpjmZh+WuE9J4AvxLvBaLerLy3jtNtF8FtWVYIlFzq28yeL0OebfeJ26WYf5OlwswoklAjegmojQWGxg9Cfp2pUlOl8N69/s7YaP7mRf+jF+jl+UEsbiXSGBL8QdahQKzLz8MoZp4pkeS+fmqfcETF04RumVkzSrqwRzlXC5QUNBPk5bQ2m+RpCxSQwkyRigah4YJnxgBPPwCH8/+t+TJbfZhyceIBL4QrxDge+zeuEC5/7sz9BaE+vKU99lEaTjnP2936U+t0A7paHQgIslSNoECioompkYZqxBd6GF3ZcKyyJETfjZx3nq/T/FT/LJzT488QCSwBfiHSqcPcvK2bMYpondk2exOcPi8RlKiTrFhSl0TEEb6I7BOWg2HcqGgS61SI1nSO3Oo7wAsjaYMayffozPP/e/0iXFzsRdIoEvxDvgOw7lqSnsvhzV6ZMUG3MsnzvLyqnT+CtVqLrhE7ui+OkoZdenXfOx8jFyKCJuAOM5SNnw1ADPPvNpPrZbisqKu0sCX4jb4DsOtUKRiYsrHD+2SjPvEMzPUjz+Ao1GGXQASkPDgahJY6VJBdDdMdLTNZIDSVQ+FpZOCDT2rn7+1nP/P/p3PLTZhya2AQl8IW5RZXaWhWMnePNMheJKjeWJ16jqOgvlVXKrHlnfCefN9ybwkg5lwHECIoUGuUwMazQdli/uS8K+bt47/CN89EO/ip1MbvahiW1CAl+IW9CuVlk8dowqMVbaLWruWVZak9QnZ4jETJbbWZLpFmbappGMUAmSUGqTSRkkYxEYy8KuHOzrJndwP7/Y81m6ekcxI5HNPjSxjUjgC/E2NJrZuTOcXXmTo4vLTL45jYpUCVaLoBRKA2WHpu/Tjrm4NYdoyia7J4e5Mwc7MvDsDlhp8tef/TxP5z642YcktikJfCHexuziOV788heZf+N1Vheb1JaiJGmAr8EP0MMpGsqnWK9jWya5iEHcDwuhEbWgP0nPSoqf2fVrDGQPbvbhiG1MAl+Im2jVq7z8lS+xcPJN6tPTxCwLq5ah1QqIpjSu47E82SBqtUiPxMjGIxjZGAynoCcOP7KTT3X/Mg/1HCKazaKU3DErNo8EvhA3UFyd43vf+CIn/uiP8JsNaPuYrsdQq8RKO8tKJEM7HSHjlhmx6iSyefj4Xnh6AAxFz3KSXzn4z0gmc5t9KEIAEvhim9NaUyq1qFYdYjGLRJeiblWZWjzFG1/7I+befIVguQwZGyImRAxINbG8RbqjVRI9SbIxEyOSga44HOwBQ/Fx7+P0GVniUalXL7YOCXyxbfl+wLFjiyws1FAG1Pw6tWgJvXSOV/7smzROTZGprJCttzDcgCBiUK0FNAwDM2HTMxgn2puAoVSn8mWGsfhuPtL6ME6pSteBvRiW/BMTW4f8bRTb1vx8jenJVaLJGiVKTLTO8eafXKT4ygUG3SnMUosVM0fTt8jXl6goTeBBMmaSjhmovd3h3bJRhTmS4yee/TyZYhpiMPDEE6SHhjb7EIXYQAJfbFtnXr/A0pljNGKrLMxfYGFqitVzBqrUQrktzIZDwnZYbBi0sUj2m3QbCvt9Q5COhcM3XsAj6af48KFfoHff/s0+JCFuSgJfbEuzE0t852svcrE6R2X6HKnpy5jKhcUkmIDt0zYDalrj2Qq7rehNRlD5cOYNP7abvJvlF71fJJvpJ5JIbPYhCfG2JPDFttJouLz55jxf+f//JbOXL7CwOE16foainyBpN3CCCNlglbrZxiHANCxSsRR5s47a1wUfGIOffpifMj/FIZ7a7MMR4rZI4Itto9l0+d6Ll3npxEkWmiepepdpz7TQOonttZhvduHrFo3AIOdG6IoGKJ0giktsOAJDaXo/9UP8LfPvESO+2YcjxG2TwBcPtKWlGpcvl2g0XFaaRd70j3KyfYZg4QKR2RKDXgkniOBoTTvQ9EVm8L04TT1KOQajmXkSgwaLux5hbN8n+OD0z+BGDGLpzT4yIW6fBL54YE1NlXjl+bN41XlWg1n+4uIkda9K9PQUreMNEgkHI/CoY1INIKkq9HTbxGtttD1Lra+fyFiWlYGH+NBjP8G+h97LaqHJ4sI0zzwzQiYT3exDFOK2SOCLB5Ln+7z83aPUVy5STJQ4N3ME9eIyhfNJop5HO0izWo+S9KvUlcZQUXZYVeKY0BVBfWQc006THXqajz38HH1DAxiWSTQGlUqbixdXOXRocLMPU4jbIoEvHgheq0W7UkFZJqVci6P1E7w08V2cSIHVb1yifrTGYiFNqZkgaQR0x2YoWTYFJ8dYvEg8YZCyFezOwZ48+Wcf50czf5PAtRkY7dqwr2QyQrHY2pwDFeIOSOCL+17x8mVWzpxBa81M7TJnG+do5SLMvHGRyrkWtUmoNXpo6SixoIxjtVhsxeixW+SzDoOJKq3xFI2xfSQP93A4+Szjgz9MPGHjeQGtlkcsduWfSrPpkU7bm3jEQrwzEvjivtYsFlk+dYpoT55zp07yx197lUsXfWqrdWplg6QPyjdJmA2arkNTtRkMVrCjCfpVEztq4DcVgzub2IceZm/iI+T6RujtS7F/fw/lcovXXpsnn48RjVq0Wh61msOjj/Zv9qELcdsk8MWW1Wy6eF5AMmljGNcvK1xbWCCIGpxeOcvv/vuXODujUV5AfSVCsZWiSpwAl7i1hK998rSJ6yRRU+FEkqi8Se/uGH/j//U/8J4P/jSeFwBgWQYA8XiEJ5+E8+cLVKsNkkmb97xnmK4umZYp7j8S+GLLcRyf48cXWVpqABCLmRw82Edv78a1X13X5/WTi/zla6/z2gtnufiGRSziYzRdrLaDSZQ6HooGUU+RjthoL4FHBe2DkTbZu2cHP/9ffYZ4PYrWej3orzY4mGZgIEUQaEzzrY8Lcb+QwBdbzrFjixSLTfr6wnIF7bbHq6/O8cEPjpFKhWPns4VV/u3vf5vv/OAEi29MU1uxcT0DzzWw2xqLJp5RhSAgoUyU7iGhizQjUeykxhrK8DOffD/P/PCzRGwLw7JuujiJUgrTlMVLxP1NAl9sKY2Gy/JyYz3sAaJRC9N0WFioMj6S4tz5V/lXv/knvPRaFYo11EJApGlRC3JEqeNQpYlPJNB4dJMwapjapxlJYveYHHx2Nz//mZ+hf3gAt9HAqVYZes97NvGohbg3JPDFluJ5AdfraEciJo1ai4mXj/KN7/8JR19cpTmtMKtNFCZpo0k5iNCgjg1ESeCTJmM79OZqWK7H2NMmz3361/jYhx/DW5yitbqKncnQ/773Ee/qeutOhXjA3LPAV0rtAv4RkNVaf+pe7VfcHxzHZ2WlTqPh0my6OI6HbVv4vmZpqcbJU8vk0mUmT/4Rp789SelyL+2WRVPn8DCJsUSUBQwjQTRIoLGJWw6DuRVihsPwIwk+9su/xtjOvfSN9qPGBjb7kIW45+4o8JVSXwQ+ASxprQ9etf1jwL8gLDT721rr39BaXwJ+RSn15TvZp3jwlMstjhyZw/MCDCMc1nnjjUX27Mlz4ewcp988T9O5TOXsS8xO27iVJBUnTltH0LRwqaLRmOQZpMZYzyyRqE80ElCxe9i5ex/v/9TPMr5rD48/PiALiYtt6057+F8CfhP4vbUNSikT+C3go8AMcEQp9VWt9ak73Jd4AGmtOXZskWjUJJeLEgTQ3Z3g4sUip0+d5lt/9B0a7SX0yhJBFWYa/bi+ifbbONSwqKNIoBkkruqkrQZDwzX6PzHI44NPMd7zOMPv+zDJ7q71C75CbFd3FPha6+8qpcav2fwe4EKnR49S6g+BnwRuKfCVUp8FPgswOjp6J80T94FGw6VWc6jVXC5fXiUIND19CY6eOs2rX/8B1WqDekmh2j1YhofjKKCGT4M0dVx6SGCRMFY5kDxHNKnYtz/HE/kPM/rI+xh6/BDxfH6zD1OILeFujOEPA9NX/TwDvFcp1Q38L8AhpdSva63/+fVerLX+AvAFgMOHD+u70D6xSbTWrK42WV5uEIkY9PenME3F0aMLTEyUiUQMUPDS62c49fIJcnqB1moSHEXdj1PFxqCMRmOQxiKPqcCwNLbto8a6efhDD/Nz/+Dv07NjF2YkstmHLMSWcs8u2mqtC8Cv3qv9ia1Fa82JE0tMT1eIRk2CQHPuXIHR0Sznz6/SarkArLiLnHjpPPUVFV6QdQ38wKCJSxsHsDDIAzEcIGk26e+pkNndi+46zO7Hn+HyYpKKV2HHjgzxuIS+EGvuRuDPAiNX/byjs01sY6urTaanK/T3X7lb1nV9nn/+MoHvUVlZZmJxkoXJFrWqhetHcAGLBi4V2thAnAgxTEw0AUQU9MYwBnsZGRoEUnz/9RZmukyl0mJqqswzz4yQSEjoCwF3J/CPAHuVUjsJg/7TwM/dhf2ILc73A1ZXmzSbHnNzlXDIpkNrjVetMHXyAq997wILpQqlsoXvxwlQgKKBj4EDJAjIY2JiKRfDDFAxiyBiM5zP8t4nHiabtYlETEzTYH6+Si4XQ2vNxESJAwd6N+0cCLGV3Om0zD8AngN6lFIzwD/RWv+OUurzwDcJp2V+UWt98o5bKu4rrZbHq6/OUq06NJseR4/OMTtbY9++brJxmH7lFd58Y5pXJkyWamHv/Yo2UAZ8ApJAEjDDqZdWQFePixXNgk6Sj9mk0xGaTQ/LMsnlYiSTEebnq+zf38PiYk0CX4iOO52l85kbbP8G8I07eW9xfzt/vkCr5WPbBkeOLHLuXJFz51Y4c2qO5cklSuUqpVYMxzevelUAVIEGYV+hGzA7/X2NQuNbMVKZfnKZFKurTXr6wqJmunN5v7s7gVLhcFG77clUTCGuIqUVxLsuCDRzc1WSSZuvfe0Mx44tUqs5xG2DqfPzrJabBD64gUEY8gbQIuzVB4Q9+jSgUAREbE0sZxD1DdKJOI5r4bZdPvRMD8mBIbL5JL29ScrlNqYJ1apDf3+SatXhwIG+zTsRQmwxEvjiXddsupw9W+DEiUXOni1gGIp02qYwu0S10qTtajyigCIM+CJh4FtAF3DlIqsyFYlslD37uulNpTgwnsTQHu953w6eeOYhUpkkJ08u4Xk+hUKTiYkS0ahFNhvn4ME+enoS12uiENuSBL64I67rs7hYp1BokE5HyeWi/NEfneSll6Y4d65IodCgWm2BDmhUGjQ9g7BH7wMOUCEM/VTn11rZA41haGLRKIM9eXpTeT7wgRF++IfHqVTaPPPMCLlcDIB8PsbCQo1azeGDHxwln0+QSERuuGiKENuVBL54x1otjx/8YIpm0yeVirCwUOfYsXneeGMexwnr4hiGplZzaLd1J8rXwr5M2Ku3Ccfq1/4qapIpl/7ugF0jaUb3PsLgUJ4nnhhgaChNterQ3R0nm42utyMatRgby93LQxfiviSBL96R2dkKzz9/mYmJMl1dcUZHsyQSEb71rYucPr1MPB5hebmB6wb4XnhFNfzfOuGFWYAs4ewcBQYkMh77n27z6Y/1cXBoJx/42I9hx9OcO1dgbq5KreYyMpJlz54uKYAmxDsggS9u29JSjTffXKBUahOJGJw7V+Cb37xAsdjk5MllarU2Sqkw7P21VzUJe/UOYa8+C1iYyifdbzB4MMlTT+V4ODHM7sEBdCrLS0dWeeyxCI8+2s8jj4QXX2WYRoh3TgL/AddqeZRKLZSCfD6ObZtv/6KOSqVNtdrGdQO6u+NEImFJhJMnl2i3Pd54Y55Ll1aZm6tSKrVYWmquT49c68+Hv9cIL8wqwqAPL6RagB2N8dCePsYH86i5CPv/xp714RnX9Xn99fkNSxsKId45CfwH2OxshePHF9dD2LIMDh0aoKcnedPXBYHmxIlFTp5cZnKyTLPpUiq12LEjg2Fovva1c8zMlCmVnM5iJT6ed713coESYe8+RRj0Vz5w7EiEdDbGwYeGiEYt8vnYhrH48M5ZxcJClT17uu/kVAghkMB/YDUaLseOLdLVFceywpIGYa98gQ99aOf6tmsVCg2OHJnl9dcXaLVcduxIMzvronXA8eMLHD26yOxslXq9jefpGwR9QNirrxFepO0iDPxQxIRcCuLJKIMjXfT3Jzl4sI9isfWWd7IsA9cN7vBsCCEg/NcoHkCFQgPDUBuCPRq18DxNqfTWYAWYni7z0kszXL5cwvM8CoUG588XqVbbZDIx3nhjgfn5OkqB53GDsG8DK4RhHwd6uTrsDQMyaRNlWuS70xw6NMDcXI1qtU1/fwrH8Te8W7Pp0dt7828kQohbIz38B9TNJrFc/ZjWen3h8DNnVujpSbCyEn5YZDIxCoUGMzMVlpfrTEyUaLc9PI+rxurXrJVFqBMO23QBsSv7BCwL4lEY3xEj35ujbzDL8nKDarXN+fNxhoYyLC/XicUimKai3fYZGcmQTEZYXW0SjZokkzKWL8Q7JYH/gOrqShAEYZhfPaRjWYpsNgziiYkib765gOP4WJZBqdTi4MF++vuTzMxUWF1tMjtb5ejRBSqVNrXadbv0XCmL4HOlLMLGL4/RmCKbiTM4mCTfm2R4OE2h0MS2LQ4dGmJoKI1SkE5HGR3N4Tg+PT1xVlaaPP/8BEoptNYMDqY5eLDvhkNSQogbk8B/QCUSER57rJ/jx5eAsCdvmgZPPTWIUvDtb1/kj//4NPG4he9r6nWHUqnN0lKDgwd7sW2Dl16a4fz5As2mf4O9BIRB3yT8q9QNRDc8I5FQ5PMJ9u7tprs7zvBwmqNHl/F9RSwWIZWycRyfVssjn49TqbTp70+STNrMz1e5eHGVvr7k+nTM+fkqsZjF/v09d+nMCfHgksB/gA0PZ+juTlAqtfC8gEQiDNhXXpnl93//BLlcjEqlRaHQYmQkQ7vtc/lykddem2NycpWzZ5dpt2+0yuTavPqryyJc6XUnEgbJpI1lmRw82MfQUIa9e7u4dKnEzp1ZhoYyNJseuVyMYrFJu+0Si1lUKg5BEO5zYqJENhvdMPe+uzvO1FSZhx7qljn5QtwmCfwHnG2brK42mZgoYhgGlUqbubkKtm2STtssLdXo7o6zvNzA83xeeWWG1dUmpVIL173eO15dFiFCOFa/cVzdsmBwMM3hw8PUag779/ewe3cez9MoBQMDaUxT0Wi4mKYiHo/Q3Z2g1fKIxa6M03tegGluDHXDUJ1yyJordXeEELdCAn+L01pTLLZYXKyhlGJgILVeNOzteF7A889P8NJLM6TTNr29iU6xsxpaa+p1F9fVtNstzpxZYXq63Olh3+gdG4RhrwnH6a8udhYyTUilbJ58cpAnnhik2XTYubML01SdgmagtSIetxgdzVIoNDqvU9TrLocPD6333IeHM5w7t0Jv75W/ppVKm97eJKYpY/hC3C4J/C3u3LkCFy8WiUbDG5YuXSqyf38Pu3bl3/a1x48vcuTILMPDaSxLUS63KRTqmKZBteowO1thZaXJwkKN+fkq7faNkt4jDPo2V8oibFwnVimIxQzicYv9+3sZH8/z5JMDvP76PAcO9GKa4UXXdNrmxIklPC/gmWeGWVios7ra4H3vG2F8PLdh0fGRkQxLS3WWlurYtonrBkSjJvv3y01YQrwTEvhbWLXa5tKlIn19ifViYb4fcPbsCgMDSWzbuuFslXrdYW6uQiplr68lm0xGOHeuxcxMhQsXCjhOWEN+eblxk159jY3Fzt46J76rK9pZXjDKzp15Mpkoy8t1Tp9e4dChQSYnS8zMVHAcj76+FP394SpV1arD6GiWD394J+l09C3vG4mYPP30EIVCOMSUSkXo7U0Sidx6eQghxBUS+FtYpdJGKTZUhjQMxdJSnf/yXy6QTEbIZGLs399DV1d8w2vbbR/LMslkYjQaHomExcpKnVbLZXm5itbg+/omYe9ypdhZlLViZ1czDIhGFT09CTKZKO973wjZbJTp6QpPPjnE2FgW3w/42tfOkUxGSCQsLl8u092d4POff5rBwfTbngPTNOjrS5JMRpiYKHH+/CqplM2uXXny+fjbvl4IcYUMhG5BaxclLct4yw1OCws1JiaKJJNhb9f3A15+eYZKpb3heYlEhCDQjI9ncV2flZUG58+vculSiWKxheO4TE2VrhP2mrBHv0wY+jk21qsPGQak0xFSqTi+f2UGULPp0tUV5/HH+/F9zQ9+MM1TTw2wY0eaeDzC0FCKWMxkcbF2y+ejXnf4wQ9mWFioEY2a1GoOL744w9LSrb+HEEJ6+FtKudzi7NkCq6tNbNtkbCxDJGLSaLjrAX7uXIHe3hRdXWHFyUQiguv6TEyUeOyxfrTWNJsepqnYuTPPxYurdHXFefPNBV58cYaJiRL1unODsggOYa/eJbxLNsvVxc7WRCKQzUZJpWxyuTjxeISdO3NA2CPfvTvD8eNLXL5cpFJx2L27i+7uK0sNLi7WmZ2t8sQTg7d0XiYnyyilyeXinf2bWJbBmTMr9PYmpTa+ELdIAn+LqNcdXnpphljMWp9Nc/bsKsPDacrlFktLDVzXo9XyGB/PUSq1yGajWJZBLGZRrbZZXW1y/PgizaYXLisI1GptvvOdSaamwnH7ev16N1FdW+wsT1gHZ6NoFAzDZGAgycBAmoGBJN3dCQwDBgYypFIRLMvAcTQQMDKS5dixRc6fL7B/fy9G5/tku+1dd8z+RgqFxltKKsRiFsvLdTwvkDF9IW6RBP4WMTNTwTTVet33SMSkpyfO4mKdD31onFbL48KFAqdPrzA5WcI0w17ugQO9uK5PT0+CI0dmSaVsGg2HF16Y4eTJJS5dKmIYsLBQvUHYtwl79R5hyGe53khfKmWxY0eaWs1leDjDQw/1kMlEKZfb9PeneeihbkzT4Pz5An19qfXpo9Vqm4mJEr29Sbq64tRqbbSGRx7pveVzk8lE17/1rHFdn2jUkumZQtwGCfwtolxuEYtt/OMwTWO9Ho7va+bn6zz2WB+vvDJHrdam3fY5fnyR3bvzpFI2rZbHnj3dfPvbE8zNVZidrVKphHfZ1mrXhn1AuIB4g+sVO1ujFAwOJsnl4vT1JVhZaZJIROjrS6wXNNuxI82ePV1MT4c3dD3+eN96r/vQoQHqdZdKpUW77ZLJxPjUpw5sGOJ5O+PjOebmqkQiBvF4BMfxWV1t8thj/XK3rRC3QQJ/i+jqinPpUmnDPHTX9YlEDGzb7ISpQbPpEYkYxGLhmP7UVJne3iR9fQkcx+Oll6Y5eXKJ8+cLzM/XCILrVbZ8+2JnEI7V53JR9uzpIhIx8byAhx7q4qmnhvH9gPn5Os89N8JDD/VgWeFsmtOnlykUmgwMhCWRBwbSvOc9w+ze3UUuF6O7O37bFS+z2Rjvec8wZ86ssLxcJxq1ePzxAYaH336WjxDiCgn8LWLHjixTU2WKxSbpdBTH8alU2jzxxACmaaBUOAd/errMwECKWs3ljTcq1GoOFy+uYhga27Z45ZVZvv/9yZuURahwpdhZD9eWRYAw6DOZKL4fXih9+OFeUimbSqVFNGqyd2+4aMmBA72Mj+fWXxePW3R3x5mcLJLPx1BKUSq1GBnJ8uijfXd0cbW7O8H73z+6Xm5BLtQKcfsk8DdRve7QaLjYtrk+j31iosTiYo1EIsLTTw/R1xf2lPv6khw/vsj0dJnJyQqXLxeZm6sQjZpUKk0WF2sUCg1OnVq6QdhfW+wszY1q0cTjEdLpKK2WRzYb47HHBohGDRoNF8cJ+PjH9xCJmHz72xMEgV6/N2BiosTKSoOurjgzM1X6+xPs29fD6Gj2XQtoKYssxDsngb8JgkBz5sxyZ7phOOTS3R3niScGOXCglwMHwguarZZHu+2xstLgwoVVTp9e4VvfuoRSsLLSYHW1CRjUag6+X6FQaOK/5brstcXOurm2LMIaYz1LNe22h2EYPPJIH4ahaLV8BgfTRKNhOeVUymL37jznzhUAOHt2BdNUDA6mOXCgl1Kpxc6deUZHc+vv77o+y8t1Gg2XbDbWmeEjPXUh7hUJ/E2wsFDl8uUS/f1X5pCvrDQ5f77AI4/0Uam0OXFiqTMds06l0uaxx/qoVFrs2JHmlVfmKJVa+L6P70O77eD7XOcmqjrhEA5AhnC8/q0BqxRYlkIpjWVZ2HaESMRkZCTLk08O8vTTQ0BYjK1cbpFIhB8Ye/Z0kUhE+PrXz2OaipGRLIODaWzbpKsrxmuvzVMutzDNsDLnhQurnUVYDBwnoKcnzpNPDkmvXYh7RAJ/E0xOlslmoxuGObq6YszMVNi5M8crr8xiGOFNVeVyC63h4sUip08XKJUaVCoNmk3dqTzJdXr1b1/sbI1lhSWUbdvC8wLS6SjZrM3DD/dy4EAP9bpLq+V1Zvo4jIxkOHt2BdcNGBxMMTiYZu/eMPivDu65uSonT66QTkcxDPjmNxfp6Ylz4EDf+nOWlurMzlYYG8u9OydWCHFTEvibIAj0W8a0w4uymunpMidOLDAzU6PRcJifr7F3bxcTE0VOnFjsTNFUgL5BWYQ6b1fsbE0kEu7XNCEeN8nnU+ze3U0uF+NDHxpjdDRHve5gmuF0yFwuysxMlVjMxDQN5uerDA6m6e1NsrBQXa9tU687XLhQZHQ0Sz4fw/MCDENRLLY7Ne/Dv3aZTJSZGQl8Ie4VCfy7xHV9isUWQaDJZqMbplvu2JHhxIkl4vGwLIJtm8zMVKhW2/yH/3CUH/xgBq01sZiFYSiOH1+g1fLJ52MsLtZwnOtVO3OBUuf36xc7W2OaYNsG0ahJEIQfHrWai9YwMuIzNpZl58489brLs8+O0tOTwHF8vv3ty3R3x9d78qlUuAzho4/2dy4aN0kmI8zNVfE8f73cQvihYuD7AfW6ux74QaDXyz4LIe4+Cfy7oFhs8tpr8zSbLoVCnWKxzb59Xbz3vSN0dyfo60syP1/lzJkVajWHUim86aqnJ8Hzz09QqzkopfC8oFMXxyAaNbAshev61/TsNVdKGBuExc6uf1NTMmkSjVpEIgbNpovvB+RycbSGIAhIJsNevFJQqTgcPjxET0/4XvV6uPTgtePt0ahFs+nx7LMjzMxUKBab7NiRIRq11u8aDiteJjh3rrC+glUQaCqVNk89dWv1dIQQd04C/13m+wGvvz5PJGIwPd2gWnVIJiO8+uoCCwsNnnlmB74f4Lo+XV0JursTuG6Byckyr702R6Ph4nmaZtNFqfBCrO8HOE5AvV69Juwdwl69x42Kna3NAorHDbLZGNGoRaPhAAaxmEEyGcM0w+GVnp44Dz3UzaFDYXXLoaErNzbd6MKq5wXE4xbxeIS9e7vXt33ve5PU6876TVZdXXF6e5M0my6uG6C1Zs+eLvr7U+/OiRdCvC0J/HdZpdLGccJAr9Xa5HJx5uaqzM/X8DyPmZlw7nwkYjA6msF1A44dW6RabXP+/Aq+r/C86y8cfiXsb63YGUA0amCaBiMjGZQK14/t60uytFTDMAwymQi+H04LtW2LINDE4xGazY3lNFMpm+7uOMVii3w+LMHQbLoYhqK398p1giDQlMstensTXL5colIJrwFkMlF+4RceIwg0juOTSEQ2DHMJIe4+Cfy7pFJpY9smxWKDlZUGqVSEaDSs8Pjqq/O4bsD4eI502uaNN2aZm6vRbkM4RHMzbcJevU84dJPhZssaWJZBKmUTjZrk8wn6+sIhpe9/fxqlNIlE2APPZuO02y7xeDjP/tpaN0opHn98gBMnllheDtehTSQsnn56eH1M3vMCXn99jkKhiWWFHzSGAYcPD9LdnZC7Y4XYZPcs8JVSu4B/BGS11p+6V/u91zKZKLYdBrDrhitKrS34sbRU49VXwzn0zabH1FR5veTx9StZXu3aYmfdhBdnbyyZNOnpSZBIREgmbfL5GIlEhIsXi3R3x0mn7c6i5ZpWyyWZtBkYSBOLWYyNZd/yftGoxVNPDdFqeZ1vAtaGEJ+eLlMoNOnru9LjL5VazM5W6em58WwhIcS9cUuBr5T6IvAJYElrffCq7R8D/gVhAv221vo3bvQeWutLwK8opb58Z03e2kzT4MknB3nhhSlKpRaTkyXqdY9SqcHKSpNGw2VsLMfkZBnHcWm1/FsI+1srdgbh3bK2HdbIHxhI0dOT4MCBXmzbIpOxicct9u3roVhsUS43efLJQdptH8fxeOyxfp58coidO/MbhluCQLO62mRlJfzw6u9Prd98dbWZmQrZ7MYPoWw2yvx8jYMHAyllLMQmu9Ue/peA3wR+b22DUsoEfgv4KDADHFFKfZUw/P/5Na//r7TWS3fc2i3McXxKpRZKQS4X46Mf3U2j4XLkyAzT02XK5RalUhvLMjoVH00cx6Nev+7SUx23VuwMwhuoLMskGjWw7QiZjE2z6eG6mnrdZXAww9BQil278mgdjskXCg2y2Rj79vWQy8U21JtfEwSao0cXmJ+vEo1aeF646tbhw8NvWUfXMNRbKnOu1dqR4RwhNt8tBb7W+rtKqfFrNr8HuNDpuaOU+kPgJ7XW/5zw28C2sbhY4+jRRXw/vKq6dpF0ZqbC4cNDOI5Hu+1jGC7lcqszA0fRbF63ylnHrRc7i0TANBW5nE0QBOvz2xOJCH/9r+8llYpy8uQSWge0WuG3CcOAnTvzeF6wYQjmWktLNebnqxtm07RaHseOLfJDPzS2oRbO2FiOY8cWiEavlIwoFluMjmalZo4QW8CdjOEPA9NX/TwDvPdGT1ZKdQP/C3BIKfXrnQ+G6z3vs8BnAUZHR++gefdGq+Xx5psLZLPR9UU/Vleb/Mt/+SIXLhSpVh0WFqqdcXoH19Vo7aMUN1hX9taLnUHYsw+HSgJ8H7Q26OlJMDCQIpWysSyTWMxkcrLEI4/00tUVzrDxfc3p08scPjx00+NbXKy/ZfgmFrOoVMIiaGtz7QGGhtJUKi0mJyud6aCa3t4ke/Z0vd1pFELcA/fsoq3WugD86i087wvAFwAOHz78dlNWNkW97lAsNjEMxepqk2PHFrAsg6GhDIODKV59dZapqSqrqy1WVxuUSg6+H6BUsF5C4a31b+BWi51dTakwgKNRk4GBFM2mRzodobs7jlKKU6eW2Lkzz+7deUBdNcQC9bpHNhul0XApFpsoBV1diQ0rb9m2ie9f+WOo1Rzq9fBmseCa2g6GoThwoI+xsRzNprde9lkIsTXcSeDPAiNX/byjs+2BdvlykTNnVjAMxfR0hS9/+WRnvn0C3w/o70/SbntUq2EdnEqlRavloXU4jGKa4Xq1ruvjOGvv6hFOtXQIx+hz3MofTSYTPiefj2EYBpVK+IbVqkO97rJzZ77zzcJleDjLjh1p5uZqQDjNcnw8Q7vt8Z3vTHSGYDSgOHRoYH0IZ2gozcRECdf1mZmpMDdXpV53SSRsjhyZ4+mnh98S6smkfdurWgkh7r47CfwjwF6l1E7CoP808HPvSqu2IMfxuXhxleefv0wuF8fzAv78zy8AmmjUIpuN0m57HDkyQ63mEomYnSJpYdA7TljVMhzK8bEsRTg+f+vFziD8wNAa+vvj7N7dzcxMGdM0O+u9WuRyMbSGdtun2fTo6UkwNJTi+PFlTBOGh7P09CTIZKIsLdVZWGgwOJhav5PWdX2OHl3gued2YttmZwGUfl58cYaTJ1fI5aIMDYWLlntewNGjC3zgA6NyUVaI+8CtTsv8A+A5oEcpNQP8E6317yilPg98k3Bmzhe11ifvWks3UaPh8vLLM0xNlbh0qUS1urTe400mI9TrLlNTJdptn7m5Ko2GRy4X65RJCDBNk3BsPgxrrcFx1soiXCl2ZhjW+t20hrFWQTP8ee2DwzAUlmVgWWFhtUce6SMaDde3TadtqtU2hUKL8fEMAwMpBgZSLCyElTePHJnj/PkiAwMp9u7t5pFHelhdbW0omxCJhEM44d2y4YfP8HCGPXvy2La5PpcfwuGepaU69frGsXwhxNZ0q7N0PnOD7d8AvvGutmgLOnNmmUKhgeeFBb/6+hJMT5ep1Vwsy6BYbDI8nGZhoY5lmSQSdMojaBwnWA/rMOzDYmeGUSUIrhQ7i0TCsHWccFGTeNwEFM2m1wn6cBjGtk3i8bAswfJyg9278xSLLWKxCDt2ZJierhCJmDzySB/JZIRm08dxfEZGsp2hn/A9crkoXV0JCoXmdY/52h57NGqRTEauM/8+vB4ghNj6pLTC25ifr/J//V8XSCRsVlYaXLpUYHm5TrXqsLpaZ3KyiO9rlpfrNJsevq8xTU0QuFeN0a+5UuwsCOKEF2bDmT2uC1qH3flIhM5iJDaxmNkpdgaxWIR02sZxNFoHRKP2ei0bzws64/JZcrnY+gpY4bKFmiDQdHUliMdNisUWkUg4DARhBc61GUatlkckYpLLxTa0fGAgxaVLRXz/yg1U1WqbbDZ63ZuwhBBbjwT+TTQaLm++uUA+HycWM/E8H1DMzJRJJGzS6SiVShvP89enIYLu9NQDTHNtNk6AadZQqo7vK7TuIqxuuZFSYQnkZDKCbYd3tLZaHktLdTzPZ3Q0RyIRWQ/3tRu3Dh7sYy3UR0ayZDIxXDccXiqVmtRqLg891E0iYV0V2IpUKsqhQwMcPbqwPhMnEjF56qnBt1THzOfjPPxwL2fPrnSOVZFIWDz+eL+M3wtxn5DAv0at5lCttjHN8I7YsD5Mg/n5Kp4X4HlBJ8w9olGDrq44y8sNTNNYv+lprfyvbSuazRaWVcIwNEEQR+srxc7WLsAGAdg2mGZYqTIWizA6miaZjJJIWPT3J5idrWJZBpGI0fndxDBsnnlmBx/84CjRqEU6bRONRshkokQiBmfPrnDkyBxdXS3SaYtazWF5uUFvb4JEIrzAaxiK557bSbncQilFLhe7YSnkXbvyDA6mqFYdLMtYf70Q4v4ggd+hteb8+QIXLxZRSrG4GA7lLCzUqNUcVlaa6zXqm81wFk6jEdbCCS+0XplY77qaq4udeZ5JWMJ44/TFq+fie1447q+UQ7vtU6m0iEbDRVF6e5O02z4LC7XOMI0mmbQZH89x6tQy9brLnj1djI1lOXRocH145uGHe4nFIrz66hwvvDDF6mqTbDZKLBZemHUcn1jMwrbNDSWOb2bt+oEQ4v4jgd9RLLa4cKFIb28Czwv47ncncd2Actkhl4sSBFAogO/72LZFMmlRrbbXL8jClRk4SrUwjBKGAUGQxPfTWJax4c7atQuxa7VnIhFFImGjdThtc+1GqoGBFOVyk0wmyuBgmtHRLMvLDVw3wHE8duzI0NeXYHW1SSplc+lSkX37eoDwwmtYO0ejNXR3hwugxOMWpVKbs2dXePzxgXt8poUQm0XKF3YsLtaIRk0MQ1GptCgUGkQiJrZtdBY18YhEFJ4HiUSkswasXp+hEgRrF12LKLVKJBJB6y6CIIthhGG/tmD41WF/bbExAMMwO8samrRaHtWqS29vorM0YXgHa73eJp+P4Tg+0aiF4/idVbbK1zm2Ojt2pMnn4yQSkc7QTVjFcq3+jxDiwSc9/GusrbVaLrdYWWni+wGJhL0+Nh+LhQt7WJbRmRMfVoj0/RqGUcfzPGw7R3d3b2epQgelDNptrxOuCq01lmWiddCpK293VpwyqdcdTDO8kSuVipFOR2i3fSzLpKsrQX9/klotXI82lYrQanm4bjg2pFRYOqFUauH7Ael09LoVMN+O1ppq1cFxfJJJGcIR4kEhgd8xMJDi1KklTp1a5s0353n55VlqtRaeB9Goie8H1GpO58IsnZCH8MapMuFKVBGghyCIMDdXB9aGeK4erw+79I5zpWplEDh4XvjB4nk+th2QzdrYtoHWGs8LaDRcCoUG/f0JlArXvK1W28RiEY4eXewM/YRlHF58cRqlwvnxBw/2MTqa5dixxQ01corFFsPD6bfUqHccnzffnKdQaKFUOBS0e3eevXu7ZTaOEPc5CfyOXC6G6wacP1/g3LlV+vsTncXDw1o07Xa4fqthGCgF7fZaWYS3FjtbWzjcMMKxece5fg04pcJfth3+MTiOSywW9qhrtXbnm4DBrl35zsVSi+XlFrOzFdJpm2w2iu+H5RDK5XBlqYcf7l1fc9bzwvVyn312hB070szOVtfblsvFeOih7re06ezZFUql8OYyCL/xnD+/SjYbkwXHhbjPSeB3VKsOiUQ4pTGdtsnnw/nstZrD0lKNUqlFIhFF6wDHcSiVFjBNF9NMYNt56vVwDn40GgZzuAh4WC9nLWS1DohEwumba3fTWpbZWXzEIhIx2Lkzy/h4nlgsgu/7jI/nGBvLkc3GaDY9FhdrvPrqPB/5SFjrZm1Mv1RqUatdWWAc6JRgMFhaqvPYYwOMj+dpNNzOnbZvnVLpuj6zsxV6eq6sZ2sYinTaZmamIoEvxH1OAr8jCMLhC9M0iMfDBccty+zUp7Fpt31iMQPXreM4BQzDJxLpIh7PEotZBEELw6BTWiHamYsPvm9gmmtj9+F7+37QGbqJYJqKSMQgk4liWYpcLs7AQIpsNo5SsGdP1/pdr2G7TC5dKpHNxkgmr4yt+35ApdJ+y3EZhlq/qSqTid60XPHaBeRrh24MQ+G6cnFXiPudzNLpSKfDkr69vQkgLF1gmooggETCwjA8TLMAlLHtJIbRh2EkOxdvw5k7WofvA7oTtOFFXqBTxmBtmCccmzfNsBBaOh2l1QpLDofj7OFdrA8/3EO77Xfu4A0ppchk7A31a8LZQor+/iStlrdhe6vl3XRFq6vZdnhh+NoPjkrFYXg4/U5OqxBiC5EefodpGjzxRD/Vant9qb5wrnuAZdUZHGxRqWgsqxvPs4lG27iuxvN8DEMRj1tkMjGiUYPl5SZaB+tTL1MpG8fxse2wOFr4/ChKhYt8u65PEOhObz+scTMykuXpp4e5dKnI1FS58+GjMU2Dn/qphzl3rkC97qz34HfuzDEwkOK11+apVtvr23ftym8Y5nk7jzzSyyuvzLK8XMc0DTwvrPE/NCSBL8T9TunrTQTfIg4fPqxfffXVe7Ivx/GZmiozM1OmUmlRq7VZXi6xvLyAbQfs2TNMpRLl9OkVarU22WyCRMKm3XbJ5aLk8+EQzOxsheXlsAJlJhNB67AcQk9PCq19CoUGQWAwOJjsjMu7eB7kcjbd3UlyuRi5XIzh4Qy5XAzH8ZicLLO4WCOfj7FrVxfxeIR222NlpUG97qzfL9BshmvnFosNlFLs29dDd3fitmfXuK7PykqDZjNcESufj0sJBSHuE0qp17TWh6/7mAQ+XLq0yu/+7lFefXWWlZUmnueSTLZx3QqWZWPbeebmXBoNh3rdw/d94vEIAwMpDhzoo1BosrgYLvYdzqMPb5oyTUU6HWVgIE02a9Pfn2Z4OE2j4dFouICm3Q5794ODKQxD0dWVYO/eLpRSGIaiUGgyMVEiCALi8QiPPtrHs8+OkkqFF1JPnlzi5Mkljh5dolptUy43SaWiHDjQy+Bgik9+8mF27Mje9XMohNgabhb4235Ip1Rq8ad/epbTp5eIRCyyWajVily4UCCZzLFr1xBLS03qdZfV1RaJRIRIJCyBUC63+Ku/ukwqZeN5AVqr9WGQIAg/SMMbrDQrK03K5TbtdjimXq+71GoOvu+za1c35XJ7fWZPo+HS25vkL/7iIr6v2bu3i0jEpFZzuHixSDRq8dhj/Rw/vkir5XH2bIHe3jgTE0XSaZtEwmJ1NVzJ6k//9Cy/8iuH5OYpIYRctJ2eLjM5WURrqNUWcd0lfB8MoxelchSLLSqVcMHusLKlxrIUSinqdY9Wy6VWa3eGZvzOilF0Fi03CALNwkId2zZptwMWF+udgmsB1WoL2zZRKvxASKdt2m2PhYUaS0s1LMukXG53VswKrwW4bsDqapNz5wrYtsnERLFTG6fVWVYxXFO2UGgSiYTTNWdmKm9zFoQQ28G27+E7jk+7XaNancZxWiSTXWgdxbLCkPR9jdaqc8es2lD7RuvgLfVwrh0uD6dm6vXXhj3/sHZ9uN1YnxK6VhohLKAWzhJaK3x2tbDMQ3jxt9321y/ori1Evvb8oLNeYljHXwix3W3rHr7ruvh+AaWKgCKbHcEwssTj0c5drqqzhqvVqZkTYJprhdLCMfVIxCCZjBCJmFiWwvM0phnO+tE6wLIU3d3x9Vk6uVyMSMTq3HAVpd0Ob4TKZGzqdZdYzCKfj9HXl6Ld9jvFzsIED2vqhAuk7NqVp9l02bkzR63mks+Hi56YpsJxwmsMpmlg2wZDQ5nNPdFCiC1h2wZ+oVDg1KlTGIbDj//4U4yO7qXVUiwv15ifr9HbmyCVCqdO9vTECQJNIhHBcQJqtXZnjn1kfSZMImHhebpzMfbqipga2zZQStHdHWVsLNsZHtLEYhFs22Jurra+8EgkYqzPztm5M8f4eJ7p6QozM2UWFmr09iZ5/PEBBgbSjIxkicctenvj69U+y+U2i4s1BgaSFApNPvKRnWSztz4tUwjx4Np2s3Qcx2FqaopyuUwymWR8fJxoNMrCQpUjR2aZmCgRj4c96EzGZna2Qr3uEY9brKw0uHChSL3eprs7zqOP9vPoo/3U6y5vvDHP5curtFoeWiuy2Sj9/eHMG9MM6+EMDYUzdMLhGAMI5/E3Gj6xmMngYArbtmg0XJLJCD09Cep1l4mJIrVaWCJ5ZCRLMmkD4YdJsdhiebnG0lKDcrm1PhSUy8XZt6+bvj4phyDEdiLTMjuWl5eZmZkBYHh4mN7eXqkAKYR4oGz7aZmtVovJyUlqtRqZTIaxsTFs297sZgkhxD31QAe+1prFxUXm5uYwDIPx8XG6u99aElgIIbaDBzbwG40Gk5OTNBoNcrkco6OjRCJy85EQYvt64AJfa83c3ByLi4tYlsWuXbvI5/Ob3SwhhNh0D1zgh3fA1unq6mLHjh1Y1gN3iEII8Y48kGm4d+9emX0jhBDXeCBvvJKwF0KIt3ogA18IIcRbSeALIcQ2IYEvhBDbhAS+EEJsExL4QgixTUjgCyHENiGBL4QQ28SWLo+slFoGJje7HZusB1jZ7EZsYXJ+bk7Oz809iOdnTGvde70HtnTgC1BKvXqj2tZCzs/bkfNzc9vt/MiQjhBCbBMS+EIIsU1I4G99X9jsBmxxcn5uTs7PzW2r8yNj+EIIsU1ID18IIbYJCXwhhNgmJPCFEGKbkMC/Tymldimlfkcp9eXNbstWIefk5pRSDyul/o1S6stKqb+92e3ZapRSzymlvtc5R89tdnvuBgn8TaCU+qJSakkpdeKa7R9TSp1VSl1QSv1/bvYeWutLWutfubst3Xy3c662yzm52m2en9Na618F/ibw/s1o7712m//WNFADYsDMvW7rvSCBvzm+BHzs6g1KKRP4LeDjwAHgM0qpA0qpR5VSf3bNr7573+RN8yVu8Vzd+6ZtCV/iNs6PUuongK8D37i3zdw0X+LWz8/3tNYfB/4h8E/vcTvvCQn8TaC1/i6wes3m9wAXOr1UB/hD4Ce11se11p+45tfSPW/0Jrmdc3XPG7cF3O750Vp/tRNqP39vW7o5bvPfWtB5vAhE72Ez7xkJ/K1jGJi+6ueZzrbrUkp1K6X+DXBIKfXrd7txW8x1z9U2PydXu9H5eU4p9X8opf5Ptk8P/3pudH4+2Tk3/w74zU1p2V1mbXYDxDujtS4Av7rZ7dhK5JzcnNb6eeD5TW7GlqW1/grwlc1ux90kPfytYxYYuernHZ1t4q3kXN2cnJ+b27bnRwJ/6zgC7FVK7VRK2cCnga9ucpu2KjlXNyfn5+a27fmRwN8ESqk/AF4E9imlZpRSv6K19oDPA98ETgN/pLU+uZnt3ArkXN2cnJ+bk/OzkRRPE0KIbUJ6+EIIsU1I4AshxDYhgS+EENuEBL4QQmwTEvhCCLFNSOALIcQ2IYEv7jtKqX+klDqplDqmlHpTKfXeu7y/55VSh+/mPoS4F6SWjrivKKWeAT4BPKm1biulegB7k5slxH1BevjifjMIrGit2wBa6xWt9RyAUup/VEodUUqdUEp9QSmlOtufV0r970qpV5VSp5VSTyulvqKUOq+U+v92njOulDqjlPr3ned8WSmVuHbnSqkfVUq9qJR6XSn1x0qp1HWe87b76zzvF5RSr3S+pfyfnTrtKKX+dee1J5VS//Sq508opf5pZ9/HlVL73+VzKx5wEvjifvPnwIhS6pxS6l8ppX74qsd+U2v9tNb6IBAn/CawxtFaHwb+DfCfgc8BB4FfVkp1d56zD/hXWuuHgQrwd67ecefbxD8GfkRr/STwKvDf3qCdN92fUuph4GeB92utnwB8rtSo/0ed1z4G/LBS6rGr3nels+9/Dfx3b3u2hLiKBL64r2ita8BTwGeBZeA/KqV+ufPwh5RSLyuljgMfBh656qVrxbGOAye11vOdbwmXuFI5cVpr/ULn//8+8IFrdv8+whWSXlBKvQn8EjB2g6a+3f4+0jmOI533+giwq/Oav6mUeh14o3MMV6/mtVa+9zVg/Ab7FuK6ZAxf3He01j5hXffnO+H+S0qpPwT+FXBYaz2tlPqfCNcmXdPu/B5c9f/Xfl77d3BtYalrf1bAt7TWn7mFZr7d/hTwu1rrDQu1KKV2Evbcn9ZaF5VSX7rBcfjIv19xm6SHL+4rSql9Sqm9V216ApjkSiiudMbVP/UO3n60c1EY4OeA71/z+EvA+5VSezptSSqlHnoH+wH4S+BTqrM+sVKqSyk1BmSAOlBWSvUTrrsqxLtCegjifpMC/qVSKgd4wAXgs1rrklLq3wIngAXCmue36yzwOaXUF4FThOPk67TWy53hoz9QSq2tefqPgXO3uyOt9Sml1D8G/lwpZQAu8Dmt9UtKqTeAM4TL8L1ws/cR4nZIeWQhCGfpAH/WueArxANJhnSEEGKbkB6+EEJsE9LDF0KIbUICXwghtgkJfCGE2CYk8IUQYpuQwBdCiG1CAl8IIbaJ/xsZfdvFERVF9AAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(\n",
+    "    (p / (1 - lam)).flatten(),\n",
+    "    np.mean(samples, axis=0).flatten(),\n",
+    "    c=c,\n",
+    "    alpha=0.2,\n",
+    "    cmap=\"jet\",\n",
+    ")\n",
+    "ax = plt.gca()\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "plt.plot(ax.get_xlim(), ax.get_ylim(), \"-k\", alpha=0.2)\n",
+    "plt.xlabel(\"Expected mean\")\n",
+    "plt.xlabel(\"Sample mean\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/816571136.py:2: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  (p / (1 - lam) ** 3).flatten(),\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Sample variance')"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(\n",
+    "    (p / (1 - lam) ** 3).flatten(),\n",
+    "    np.var(samples, axis=0).flatten(),\n",
+    "    c=c,\n",
+    "    alpha=0.2,\n",
+    "    cmap=\"jet\",\n",
+    ")\n",
+    "ax = plt.gca()\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "\n",
+    "ax = plt.gca()\n",
+    "plt.plot(ax.get_xlim(), ax.get_ylim(), \"-k\", alpha=0.2)\n",
+    "plt.xlabel(\"Expected variance\")\n",
+    "plt.xlabel(\"Sample variance\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def normal_approx(x, p, lam):\n",
+    "    mu = p / (1 - lam)\n",
+    "    sigma = np.sqrt(p / (1 - lam) ** 3)\n",
+    "    return 1 / np.sqrt(2 * np.pi) / sigma * np.exp(-0.5 * (x - mu) ** 2 / sigma ** 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def monotonicity_region_envelope(x, p, lam):\n",
+    "    return p * np.exp(\n",
+    "        2\n",
+    "        - lam\n",
+    "        - np.minimum(lam, p) * np.sqrt(2 / np.pi) * ((1 / np.sqrt(x)) - (1 / np.sqrt(x + 1)))\n",
+    "    ) + (x == 0) * np.exp(\n",
+    "        -p\n",
+    "    )  # Extra probability for x==0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def poisson_region_envelope(x, p, lam):\n",
+    "    eps = (1 - lam) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)\n",
+    "    delta = (1 - lam) ** (2 / 5) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)\n",
+    "    mu = (p - lam) / (1 - lam)\n",
+    "    sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)\n",
+    "    psi = (\n",
+    "        p * delta * (2 + delta - 2 * lam)\n",
+    "        + (1 + delta) * (1 - lam) ** 2\n",
+    "        - lam * (1 - lam + delta) ** 2\n",
+    "    ) / (2 * (p - 1 - delta))\n",
+    "    G = (\n",
+    "        (p * (1 - lam - eps) * np.sqrt(1 + delta))\n",
+    "        / ((p - lam) * (1 - lam) * (1 - eps) ** 2)\n",
+    "        * np.exp(psi / (1 + delta))\n",
+    "    )\n",
+    "\n",
+    "    def g(x):\n",
+    "        return G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))\n",
+    "\n",
+    "    h_r_norm = (p * (1 - lam - eps) ** 1.5) / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)\n",
+    "    h_r_exp_A = -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam)\n",
+    "    h_r_exp_B = 2 * (1 - lam)\n",
+    "\n",
+    "    def h_r(x):\n",
+    "        return h_r_norm * np.exp(h_r_exp_A * (x - mu) + h_r_exp_B)\n",
+    "\n",
+    "    t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)\n",
+    "    H_r = (\n",
+    "        (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))\n",
+    "        / (\n",
+    "            np.sqrt(2 * np.pi)\n",
+    "            * (p - lam) ** 1.5\n",
+    "            * (1 - 2 * (1 - lam - eps) / (p - lam))\n",
+    "            * eps\n",
+    "            * (1 - lam)\n",
+    "        )\n",
+    "        * np.exp(-(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu))\n",
+    "    )\n",
+    "\n",
+    "    def h_l(x):\n",
+    "        return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+    "\n",
+    "    t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)\n",
+    "    H_l = (\n",
+    "        (2 * p * (1 + delta))\n",
+    "        / (np.sqrt(2 * np.pi) * delta * (1 - lam))\n",
+    "        * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))\n",
+    "    )\n",
+    "    return np.where(x < t_l, h_l(x), np.where(x < t_r, g(x), h_r(x)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f02979f9ac0>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x = np.linspace(1000, 1700, 1000)\n",
+    "lam = 0.3\n",
+    "p = 1000\n",
+    "y0 = poisson_region_envelope(x, p, lam)\n",
+    "y1 = np.exp(_logprob(np.floor(x), p, lam))\n",
+    "y2 = normal_approx(x, p, lam)\n",
+    "plt.semilogy(x, y0, label=\"Envelope\")\n",
+    "plt.semilogy(x, y1, label=\"PDF\")\n",
+    "plt.plot(x, y2, label=\"Normal approx\")\n",
+    "samples = _rejection_region_poisson(np.random.default_rng(42), p, lam, 100000)\n",
+    "y, edges = np.histogram(samples, bins=20, density=True)\n",
+    "plt.plot(0.5 * (edges[1:] + edges[:-1]), y, label=\"Sampled points\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def abel_rejection_envelope(x, p, lam):\n",
+    "    p = np.asarray(p)\n",
+    "    lam = np.asarray(lam)\n",
+    "    nu = 2 / 3 * (p ** 2 - lam * p - 3 * lam ** 2) / lam ** 2\n",
+    "    alpha = 0.2746244084  # Taken from page 259\n",
+    "    # alpha = 3/7\n",
+    "    t = np.floor(alpha * np.maximum(nu, 0))\n",
+    "    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))\n",
+    "    if t.size == 1:\n",
+    "        if problematic:\n",
+    "            t = 0\n",
+    "    else:\n",
+    "        t[problematic] = 0\n",
+    "    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)\n",
+    "    q_r = b / np.sqrt(t + 1)\n",
+    "\n",
+    "    rho_t = (  # Taken from page 250\n",
+    "        1\n",
+    "        - p\n",
+    "        + np.log(p)\n",
+    "        - 0.5 * np.log(2 * np.pi)\n",
+    "        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))\n",
+    "        - 1.5 * np.log(t + 1)\n",
+    "        + (1 - lam) * t\n",
+    "    )\n",
+    "    rho_t_prime = (\n",
+    "        np.log(lam * t + p)\n",
+    "        - np.log(t + 1)\n",
+    "        + 1\n",
+    "        - lam\n",
+    "        - (t + 0.5) / (t + 1) ** 2\n",
+    "        - (t - 1) * lam / (lam * t + p)\n",
+    "    )\n",
+    "    q = np.where(t == 0, 0, np.exp(-rho_t_prime))\n",
+    "    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))\n",
+    "    return np.where(\n",
+    "        x <= t,\n",
+    "        q_l * q ** (t - x) * (1 - q ** (t + 1)),\n",
+    "        b * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def abel_rejection_proposal_density(x, p, lam):\n",
+    "    p = np.asarray(p)\n",
+    "    lam = np.asarray(lam)\n",
+    "    nu = 2 / 3 * (p ** 2 - lam * p - 3 * lam ** 2) / lam ** 2\n",
+    "    alpha = 0.2746244084  # Taken from page 259\n",
+    "    # alpha = 3/7\n",
+    "    t = np.floor(alpha * np.maximum(nu, 0))\n",
+    "    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))\n",
+    "    if t.size == 1:\n",
+    "        if problematic:\n",
+    "            t = 0\n",
+    "    else:\n",
+    "        t[problematic] = 0\n",
+    "    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)\n",
+    "    q_r = b / np.sqrt(t + 1)\n",
+    "\n",
+    "    rho_t = (  # Taken from page 250\n",
+    "        1\n",
+    "        - p\n",
+    "        + np.log(p)\n",
+    "        - 0.5 * np.log(2 * np.pi)\n",
+    "        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))\n",
+    "        - 1.5 * np.log(t + 1)\n",
+    "        + (1 - lam) * t\n",
+    "    )\n",
+    "    rho_t_prime = (\n",
+    "        np.log(lam * t + p)\n",
+    "        - np.log(t + 1)\n",
+    "        + 1\n",
+    "        - lam\n",
+    "        - (t + 0.5) / (t + 1) ** 2\n",
+    "        - (t - 1) * lam / (lam * t + p)\n",
+    "    )\n",
+    "    q = np.where(t == 0, 0, np.exp(-rho_t_prime))\n",
+    "    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))\n",
+    "    return np.where(\n",
+    "        x <= t,\n",
+    "        q ** (t - x) * (1 - q ** (t + 1)) / (1 - q),\n",
+    "        np.sqrt(t + 1) * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/4290048940.py:39: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  b * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f02979a7160>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p, lam = 2.1209508879201904, 0.5510204081632653\n",
+    "mean = p / (1 - lam)\n",
+    "std = np.sqrt(p / (1 - lam) ** 3)\n",
+    "x = np.linspace(np.maximum(0, mean - 1.2 * std), mean + 15 * std, 1000)\n",
+    "plt.semilogy(x, np.exp(_logprob(x, p, lam)), label=\"PDF\")\n",
+    "plt.plot(x, abel_rejection_envelope(x, p, lam), label=\"Envelope\")\n",
+    "plt.plot(x, abel_rejection_proposal_density(x, p, lam), label=\"Proposal density\")\n",
+    "# samples = _rejection_region_abel(np.random.default_rng(42), p, lam, 100000)\n",
+    "# print(np.mean(samples <= 1), np.sum(np.exp(_logprob(np.array([0, 1]), p, lam))))\n",
+    "y, edges = np.histogram(samples, bins=20, density=True)\n",
+    "# plt.plot(0.5 * (edges[1:] + edges[:-1]), y, label=\"Sampled points\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/2555885245.py:12: RuntimeWarning: invalid value encountered in log\n",
+      "  return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p, lam = 2.1209508879201904, 0.5510204081632653\n",
+    "\n",
+    "mean = p / (1 - lam)\n",
+    "std = np.sqrt(p / (1 - lam) ** 3)\n",
+    "x = np.linspace(0, 10, 1000)\n",
+    "\n",
+    "plt.figure(figsize=(16, 6))\n",
+    "plt.semilogy(x, np.exp(_logprob(np.floor(x), p, lam)), label=\"PMF\")\n",
+    "\n",
+    "# plt.plot(x, abel_rejection_envelope(np.floor(x), p, lam), label=\"Envelope\")\n",
+    "# plt.plot(x, abel_rejection_proposal_density(np.floor(x), p, lam), label=\"Proposal density\")\n",
+    "samples_monot = _rejection_region_monotonicity(np.random.default_rng(), p, lam, 100000)\n",
+    "samples_branch = _branching_rng_fn(np.random.default_rng(), p, lam, 100000)\n",
+    "samples_abel = _rejection_region_abel(np.random.default_rng(), p, lam, 100000)\n",
+    "for samples, algo in zip((samples_monot, samples_branch, samples_abel), (\"monoticity\", \"branch\", \"abel\")):\n",
+    "    u, c = np.unique(samples, return_counts=True)\n",
+    "    edges = np.arange(11)\n",
+    "    y = np.array([np.sum(c[u == e]) for e in edges])\n",
+    "    plt.step(edges, y / samples.size, label=f\"Sampled points ({algo})\", where=\"post\")\n",
+    "    plt.legend(loc=(1, 0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.11991754613423761"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.exp(_logprob(0, p, lam))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/4253790774.py:8: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))\n",
+      "/tmp/ipykernel_21224/4253790774.py:10: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))\n"
+     ]
+    }
+   ],
+   "source": [
+    "p_range = np.logspace(-2, 4, 50)\n",
+    "lam_range = np.linspace(0, 1, 60)\n",
+    "p, lam = np.meshgrid(p_range, lam_range)\n",
+    "dist_size = p.shape\n",
+    "# monotonicity_idxs = p <= (1 + lam)\n",
+    "# monotonicity_idxs = p <= np.exp(lam)\n",
+    "# poisson_idxs = p > np.maximum(1 + lam, 2 * lam / (1 - lam))\n",
+    "poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))\n",
+    "# poisson_idxs = p > np.maximum(np.exp(lam), 2 * lam / (1 - lam))\n",
+    "abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))\n",
+    "# abel_idxs = (lam == 1) | ((p > np.exp(lam)) & (p <= 2 * lam / (1 - lam)))\n",
+    "# abel_idxs = (lam == 1) | ((p >= 3) & (p <= 2 * lam / (1 - lam)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.54,)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "idxs = np.full((lam_range.size, 50), 0, dtype=int)\n",
+    "# idxs[monotonicity_idxs] = 0\n",
+    "idxs[poisson_idxs] = 1\n",
+    "idxs[abel_idxs] = 2\n",
+    "np.mean(idxs == 1),"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/2902846004.py:5: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))\n",
+      "/tmp/ipykernel_21224/2902846004.py:6: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))\n",
+      "/tmp/ipykernel_21224/1720600079.py:5: RuntimeWarning: invalid value encountered in multiply\n",
+      "  - np.minimum(lam, p) * np.sqrt(2 / np.pi) * ((1 / np.sqrt(x)) - (1 / np.sqrt(x + 1)))\n",
+      "/tmp/ipykernel_21224/3405323858.py:41: RuntimeWarning: overflow encountered in exp\n",
+      "  return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+      "/tmp/ipykernel_21224/3405323858.py:41: RuntimeWarning: overflow encountered in multiply\n",
+      "  return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+      "/tmp/ipykernel_21224/4290048940.py:38: RuntimeWarning: overflow encountered in power\n",
+      "  q_l * q ** (t - x) * (1 - q ** (t + 1)),\n",
+      "/tmp/ipykernel_21224/4290048940.py:39: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  b * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),\n",
+      "/tmp/ipykernel_21224/4290048940.py:38: RuntimeWarning: divide by zero encountered in power\n",
+      "  q_l * q ** (t - x) * (1 - q ** (t + 1)),\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.475, xs=[4]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.492, xs=[3 4 5]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.508, xs=[3 4 5]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.525, xs=[3 4 5 6]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.525, xs=[6]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.542, xs=[3 4 5 6]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.542, xs=[6 7]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.559, xs=[3 4 5 6]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.559, xs=[5 6 7 8]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.576, xs=[3 4 5 6 7]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.576, xs=[5 6 7 8]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.593, xs=[3 4 5 6 7]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.593, xs=[5 6 7 8]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.610, xs=[3 4 5 6 7]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.610, xs=[5 6 7 8 9]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.627, xs=[3 4 5 6 7 8]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.627, xs=[5 6 7 8 9]\n",
+      "Poisson envelope is not higher than pmf for p=3.7, lam=0.644, xs=[3 4 5 6 7 8]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.644, xs=[5 6 7 8 9]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.661, xs=[ 5  6  7  8  9 10]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.678, xs=[ 5  6  7  8  9 10]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.695, xs=[ 5  6  7  8  9 10]\n",
+      "Poisson envelope is not higher than pmf for p=4.9, lam=0.712, xs=[ 6  7  8  9 10]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/4290048940.py:38: RuntimeWarning: overflow encountered in multiply\n",
+      "  q_l * q ** (t - x) * (1 - q ** (t + 1)),\n",
+      "/tmp/ipykernel_21224/4290048940.py:38: RuntimeWarning: invalid value encountered in multiply\n",
+      "  q_l * q ** (t - x) * (1 - q ** (t + 1)),\n"
+     ]
+    }
+   ],
+   "source": [
+    "p_range = np.logspace(-2, 4, 50)\n",
+    "lam_range = np.linspace(0, 1, 60)\n",
+    "p, lam = np.meshgrid(p_range, lam_range)\n",
+    "\n",
+    "poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))\n",
+    "abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))\n",
+    "\n",
+    "idxs = np.full((lam_range.size, 50), 0, dtype=int)\n",
+    "# idxs[monotonicity_idxs] = 0\n",
+    "idxs[poisson_idxs] = 1\n",
+    "idxs[abel_idxs] = 2\n",
+    "\n",
+    "xs = np.concatenate([np.arange(10), np.logspace(1, 4.5)]).astype(int)\n",
+    "for i in range(p.shape[0]):\n",
+    "    for j in range(p.shape[1]):\n",
+    "        if idxs[i, j] == 0:\n",
+    "            proposal = monotonicity_region_envelope(xs, p[i, j], lam[i, j])\n",
+    "            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))\n",
+    "            bad_xs = xs[proposal < pmf + 0.00]\n",
+    "            if len(bad_xs):\n",
+    "                print(\n",
+    "                    f\"Monotonicity envelope is not higher than pmf for p={p[i, j]:.1f}, \"\n",
+    "                    f\"lam={lam[i, j]:.3f}, xs={bad_xs}\"\n",
+    "                )\n",
+    "\n",
+    "        elif idxs[i, j] == 1:\n",
+    "            proposal = poisson_region_envelope(xs, p[i, j], lam[i, j])\n",
+    "            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))\n",
+    "            bad_xs = xs[proposal < pmf - 0.03]\n",
+    "            if len(bad_xs):\n",
+    "                print(\n",
+    "                    f\"Poisson envelope is not higher than pmf for p={p[i, j]:.1f}, \"\n",
+    "                    f\"lam={lam[i, j]:.3f}, xs={bad_xs}\"\n",
+    "                )\n",
+    "\n",
+    "        elif idxs[i, j] == 2:\n",
+    "            proposal = abel_rejection_envelope(xs, p[i, j], lam[i, j])\n",
+    "            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))\n",
+    "            bad_xs = xs[proposal < pmf - 0.0 + 0.00]\n",
+    "            if len(bad_xs):\n",
+    "                print(\n",
+    "                    f\"Abel envelope is not higher than pmf for p={p[i, j]:.1f}, \"\n",
+    "                    f\"lam={lam[i, j]:.3f}, xs={bad_xs}\"\n",
+    "                )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = idxs.T\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 7))\n",
+    "\n",
+    "# get discrete colormap\n",
+    "cmap = plt.get_cmap(\"coolwarm\", np.max(data) - np.min(data) + 1)\n",
+    "# set limits .5 outside true range\n",
+    "mat = ax.imshow(\n",
+    "    data,\n",
+    "    cmap=cmap,\n",
+    "    vmin=0,\n",
+    "    vmax=2,\n",
+    "    origin=\"lower\",\n",
+    ")\n",
+    "# tell the colorbar to tick at integers\n",
+    "cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038)\n",
+    "cbar.ax.set_yticklabels([\"monotonicity\", \"poisson\", \"abel\"])\n",
+    "\n",
+    "ax.set_xlabel(\"lam\")\n",
+    "every = 8\n",
+    "plt.xticks(range(0, lam_range.size)[::every], np.round(lam_range[::every], 2))\n",
+    "\n",
+    "ax.set_ylabel(\"p\")\n",
+    "every = 8\n",
+    "plt.yticks(range(0, p_range.size)[::every], np.round(p_range[::every], 2));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Benchmark algorithms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import signal\n",
+    "import time\n",
+    "from functools import reduce"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Handlers.SIG_DFL: 0>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class TimeOutError(RuntimeError):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "def handler(signum, frame):\n",
+    "    raise TimeOutError\n",
+    "\n",
+    "\n",
+    "signal.signal(signal.SIGALRM, handler)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "rng = np.random.default_rng(42)\n",
+    "dist_size = (100, *p.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def benchmark_algorithm(algorithm_fn, draws=100, duration_cutoff=0.05):\n",
+    "    duration = np.full_like(p, np.nan)\n",
+    "    for i in range(p.shape[0]):\n",
+    "        for j in range(p.shape[1]):\n",
+    "            signal.setitimer(signal.ITIMER_REAL, duration_cutoff)\n",
+    "            start = time.time()\n",
+    "            try:\n",
+    "                algorithm_fn(rng, p=p[i, j], lam=lam[i, j], dist_size=draws)\n",
+    "                signal.alarm(0)\n",
+    "            except TimeOutError:\n",
+    "                continue\n",
+    "            end = time.time()\n",
+    "            duration[i, j] = end - start\n",
+    "    signal.alarm(0)\n",
+    "    return duration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def plot_benchmark(duration, title=\"\"):\n",
+    "    fig, ax = plt.subplots(1, 2, figsize=(14, 7), sharey=True)\n",
+    "\n",
+    "    # Region\n",
+    "    data = idxs.T\n",
+    "    cmap = plt.get_cmap(\"coolwarm\", np.max(data) - np.min(data) + 1)\n",
+    "    mat = ax[0].imshow(\n",
+    "        data,\n",
+    "        cmap=cmap,\n",
+    "        vmin=0,\n",
+    "        vmax=2,\n",
+    "        origin=\"lower\",\n",
+    "    )\n",
+    "    cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038, ax=ax[0])\n",
+    "    cbar.ax.set_yticks([0.3, 1, 1.7])\n",
+    "    cbar.ax.set_yticklabels([\"monoticity.\", \"poisson\", \"abel\"], rotation=90, va=\"center\")\n",
+    "\n",
+    "    # Timings\n",
+    "    data = duration.T\n",
+    "    mat = ax[1].imshow(\n",
+    "        data,\n",
+    "        cmap=\"viridis\",\n",
+    "        origin=\"lower\",\n",
+    "    )\n",
+    "    cbar = fig.colorbar(mat, fraction=0.038, ax=ax[1])\n",
+    "\n",
+    "\n",
+    "    for axi in ax:\n",
+    "        axi.set_xlabel(\"lam\")\n",
+    "        every = 8\n",
+    "        axi.set_xticks(range(0, lam_range.size)[::every])\n",
+    "        axi.set_xticklabels(np.round(lam_range[::every], 2))\n",
+    "\n",
+    "        axi.set_ylabel(\"p\")\n",
+    "        every = 8\n",
+    "        axi.set_yticks(range(0, p_range.size)[::every])\n",
+    "        axi.set_yticklabels(np.round(p_range[::every], 2))\n",
+    "\n",
+    "        axi.axhline(20.5, color=\"white\")\n",
+    "\n",
+    "    fig.suptitle(title, y=0.85, fontsize=18)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "duration_monot = benchmark_algorithm(_rejection_region_monotonicity)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/2133065621.py:11: RuntimeWarning: invalid value encountered in sqrt\n",
+      "  sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)\n",
+      "/tmp/ipykernel_21224/2133065621.py:41: RuntimeWarning: invalid value encountered in power\n",
+      "  * (p - lam) ** 1.5\n",
+      "/tmp/ipykernel_21224/2133065621.py:29: RuntimeWarning: invalid value encountered in power\n",
+      "  / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)\n",
+      "/tmp/ipykernel_21224/2133065621.py:50: RuntimeWarning: overflow encountered in exp\n",
+      "  return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+      "/tmp/ipykernel_21224/2133065621.py:10: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  mu = (p - lam) / (1 - lam)\n",
+      "/tmp/ipykernel_21224/2133065621.py:11: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)\n",
+      "/tmp/ipykernel_21224/2133065621.py:18: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  (p * (1 - lam - eps) * np.sqrt(1 + delta))\n",
+      "/tmp/ipykernel_21224/2133065621.py:36: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)\n",
+      "/tmp/ipykernel_21224/2133065621.py:46: RuntimeWarning: invalid value encountered in subtract\n",
+      "  * np.exp(-(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu))\n",
+      "/tmp/ipykernel_21224/2133065621.py:52: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)\n",
+      "/tmp/ipykernel_21224/2133065621.py:54: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  (2 * p * (1 + delta))\n",
+      "/tmp/ipykernel_21224/2133065621.py:56: RuntimeWarning: invalid value encountered in subtract\n",
+      "  * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))\n",
+      "/tmp/ipykernel_21224/2133065621.py:85: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  raw_left_y = _t_l - 2 * E * (1 + _delta) / _delta / (1 - _lam)\n",
+      "/tmp/ipykernel_21224/2133065621.py:86: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  raw_right_y = _t_r + 2 * E / ((1 - 2 * (1 - _lam - _eps) / (_p - _lam)) * _eps * (1 - _lam))\n",
+      "/tmp/ipykernel_21224/2133065621.py:86: RuntimeWarning: invalid value encountered in add\n",
+      "  raw_right_y = _t_r + 2 * E / ((1 - 2 * (1 - _lam - _eps) / (_p - _lam)) * _eps * (1 - _lam))\n",
+      "/tmp/ipykernel_21224/2133065621.py:38: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))\n",
+      "/tmp/ipykernel_21224/2133065621.py:84: RuntimeWarning: invalid value encountered in add\n",
+      "  raw_center_y = _mu + _sigma * N\n",
+      "/tmp/ipykernel_21224/2133065621.py:85: RuntimeWarning: invalid value encountered in subtract\n",
+      "  raw_left_y = _t_l - 2 * E * (1 + _delta) / _delta / (1 - _lam)\n",
+      "/tmp/ipykernel_21224/2133065621.py:24: RuntimeWarning: invalid value encountered in subtract\n",
+      "  return G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))\n",
+      "/tmp/ipykernel_21224/2133065621.py:50: RuntimeWarning: invalid value encountered in subtract\n",
+      "  return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))\n",
+      "/tmp/ipykernel_21224/2133065621.py:31: RuntimeWarning: invalid value encountered in subtract\n",
+      "  -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (x - mu)\n",
+      "/tmp/ipykernel_21224/2555885245.py:19: RuntimeWarning: invalid value encountered in subtract\n",
+      "  np.log(p) + _logpow(p_lam_x, x - 1) - p_lam_x - gammaln(x + 1),\n"
+     ]
+    }
+   ],
+   "source": [
+    "duration_poisson = benchmark_algorithm(_rejection_region_poisson)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/2250734458.py:8: RuntimeWarning: divide by zero encountered in true_divide\n",
+      "  nu = 2 * (p ** 2 - lam * p - 3 * lam ** 2) / (3 * lam ** 2)\n",
+      "/tmp/ipykernel_21224/2555885245.py:12: RuntimeWarning: invalid value encountered in log\n",
+      "  return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))\n",
+      "/tmp/ipykernel_21224/2250734458.py:80: RuntimeWarning: overflow encountered in power\n",
+      "  V * _q_l * _q ** (_t - raw_left) * (1 - _q ** (_t + 1))\n"
+     ]
+    }
+   ],
+   "source": [
+    "duration_abel = benchmark_algorithm(_rejection_region_abel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_21224/1066448282.py:4: RuntimeWarning: divide by zero encountered in log\n",
+      "  abs_log_lam = np.log(np.abs(lam))\n"
+     ]
+    }
+   ],
+   "source": [
+    "duration_inverse = benchmark_algorithm(\n",
+    "    lambda rng, p, lam, dist_size: _inverse_rng_fn(rng, theta=p, lam=lam, dist_size=dist_size)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "duration_branch = benchmark_algorithm(\n",
+    "    lambda rng, p, lam, dist_size: _branching_rng_fn(rng, theta=p, lam=lam, dist_size=dist_size)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark(duration=duration_monot, title=\"Monotonicity algorithm speed\")\n",
+    "plot_benchmark(duration=duration_poisson, title=\"Poisson algorithm speed\")\n",
+    "plot_benchmark(duration=duration_abel, title=\"Abel algorithm speed\")\n",
+    "plot_benchmark(duration=duration_inverse, title=\"Inverse algorithm speed\")\n",
+    "plot_benchmark(duration=duration_branch, title=\"Branching algorithm speed\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "def plot_benchmark_comparison(benchmarks, benchmark_names, threshold=0):\n",
+    "    \n",
+    "    nan_to_inf = lambda x: np.nan_to_num(x, nan=np.inf)\n",
+    "    best_duration = np.full_like(duration_monot, np.nan)\n",
+    "\n",
+    "    for i, reference in enumerate(benchmarks):\n",
+    "        comps = (reference + threshold < nan_to_inf(other) for other in benchmarks if other is not reference)\n",
+    "        best_duration[reduce(lambda x, y: x & y, comps)] = i\n",
+    "    \n",
+    "    \n",
+    "    fig, ax = plt.subplots(1, 2, figsize=(14, 7), sharey=True)\n",
+    "\n",
+    "    # Region\n",
+    "    data = idxs.T\n",
+    "    cmap = plt.get_cmap(\"coolwarm\", np.max(data) - np.min(data) + 1)\n",
+    "    mat = ax[0].imshow(\n",
+    "        data,\n",
+    "        cmap=cmap,\n",
+    "        vmin=0,\n",
+    "        vmax=2,\n",
+    "        origin=\"lower\",\n",
+    "    )\n",
+    "    cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038, ax=ax[0])\n",
+    "    cbar.ax.set_yticks([0.3, 1, 1.7])\n",
+    "    cbar.ax.set_yticklabels([\"monoticity.\", \"poisson\", \"abel\"], rotation=90, va=\"center\")\n",
+    "\n",
+    "    # Timings\n",
+    "    data = best_duration.T\n",
+    "    cmap = plt.get_cmap(\"coolwarm\", np.nanmax(data) - np.nanmin(data) + 1)\n",
+    "    mat = ax[1].imshow(\n",
+    "        data,\n",
+    "        cmap=cmap,\n",
+    "        origin=\"lower\",\n",
+    "    )\n",
+    "    cbar = fig.colorbar(mat, fraction=0.038, ax=ax[1])\n",
+    "    cbar.ax.set_yticks([0.3, 1, 1.7, 2.8, 3.5][:len(benchmarks)])\n",
+    "    cbar.ax.set_yticklabels(benchmark_names, rotation=90, va=\"center\")\n",
+    "\n",
+    "\n",
+    "    for axi in ax:\n",
+    "        axi.set_xlabel(\"lam\")\n",
+    "        every = 8\n",
+    "        axi.set_xticks(range(0, lam_range.size)[::every])\n",
+    "        axi.set_xticklabels(np.round(lam_range[::every], 2))\n",
+    "\n",
+    "        axi.set_ylabel(\"p\")\n",
+    "        every = 8\n",
+    "        axi.set_yticks(range(0, p_range.size)[::every])\n",
+    "        axi.set_yticklabels(np.round(p_range[::every], 2))\n",
+    "\n",
+    "        axi.axhline(20.5, color=\"k\")\n",
+    "\n",
+    "    fig.suptitle(\"Best performance per region\", y=0.85, fontsize=18)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_monot, duration_poisson, duration_abel],\n",
+    "    [\"monot\", \"poisson\", \"abel\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_monot, duration_poisson, duration_abel, duration_inverse, duration_branch],\n",
+    "    [\"monot\", \"poisson\", \"abel\", \"inverse\", \"branch\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_monot, duration_poisson, duration_abel, duration_inverse, duration_branch],\n",
+    "    [\"monot\", \"poisson\", \"abel\", \"inverse\", \"branch\"],\n",
+    "    threshold=0.001\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_monot, duration_branch],\n",
+    "    [\"monot\", \"branch\"],\n",
+    "    threshold=0.0\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_poisson, duration_branch],\n",
+    "    [\"poisson\", \"branch\"],\n",
+    "    threshold=0.0\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x504 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_benchmark_comparison(\n",
+    "    [duration_abel, duration_branch],\n",
+    "    [\"abel\", \"branch\"],\n",
+    "    threshold=0.000\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "hide_input": false,
+  "jupytext": {
+   "formats": "ipynb,py:percent"
+  },
+  "kernelspec": {
+   "display_name": "roche_preclinical_hd_gpu",
+   "language": "python",
+   "name": "roche_preclinical_hd_gpu"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  },
+  "toc-showtags": false
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/fast_gen_pois.py b/notebooks/fast_gen_pois.py
new file mode 100644
index 0000000..61db454
--- /dev/null
+++ b/notebooks/fast_gen_pois.py
@@ -0,0 +1,918 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.4.2
+#   kernelspec:
+#     display_name: roche_preclinical_hd_gpu
+#     language: python
+#     name: roche_preclinical_hd_gpu
+# ---
+
+# %% pycharm={"name": "#%%\n"}
+import numpy as np
+import pymc as pm
+
+from matplotlib import pyplot as plt
+from scipy.special import gammaln
+
+
+def _logpow(x, m):
+    """
+    Calculates log(x**m) since m*log(x) will fail when m, x = 0.
+    """
+    # return m * log(x)
+    return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))
+
+
+def _logprob(x, p, lam):
+    p_lam_x = p + lam * x
+    return np.where(
+        x >= 0,
+        np.log(p) + _logpow(p_lam_x, x - 1) - p_lam_x - gammaln(x + 1),
+        -np.inf,
+    )
+
+
+# %% pycharm={"name": "#%%\n"}
+def _rejection_region_monotonicity(rng, p, lam, dist_size, idxs_mask=None):
+    if idxs_mask is None:
+        idxs_mask = np.ones(dist_size, dtype="bool")
+    p = np.broadcast_to(p, dist_size)[idxs_mask]
+    lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+    dist_size = np.sum(idxs_mask)
+    p0 = np.exp(-p)
+    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+    x = np.full(dist_size, np.nan)
+    inds_to_sample = np.ones(dist_size, dtype=bool)  # dummy boolean mask#u > p0 / (p0 + b)
+    counter = -1
+    while np.any(inds_to_sample):
+        counter += 1
+        u = rng.uniform(size=dist_size)
+        zero_xs = u <= p0 / (p0 + b)
+        x[inds_to_sample & zero_xs] = 0
+        inds_to_sample = inds_to_sample & ~zero_xs
+
+        v = rng.uniform(size=dist_size)
+        w = rng.uniform(size=dist_size)
+        _x = np.floor(1 / w ** 2)
+        accepted = v * b * (1 / np.sqrt(_x) - 1 / np.sqrt(_x + 1)) <= np.exp(_logprob(_x, p, lam))
+        x[inds_to_sample & accepted] = _x[inds_to_sample & accepted]
+        inds_to_sample = inds_to_sample & ~accepted
+    # print(counter)
+    return x
+
+
+# %% pycharm={"name": "#%%\n"}
+def _rejection_region_poisson(rng, p, lam, dist_size, idxs_mask=None):
+    if idxs_mask is None:
+        idxs_mask = np.ones(dist_size, dtype="bool")
+    p = np.broadcast_to(p, dist_size)[idxs_mask]
+    lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+    dist_size = np.sum(idxs_mask)
+
+    eps = (1 - lam) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+    delta = (1 - lam) ** (2 / 5) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+    mu = (p - lam) / (1 - lam)
+    sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)
+    psi = (
+        p * delta * (2 + delta - 2 * lam)
+        + (1 + delta) * (1 - lam) ** 2
+        - lam * (1 - lam + delta) ** 2
+    ) / (2 * (p - 1 - delta))
+    G = (
+        (p * (1 - lam - eps) * np.sqrt(1 + delta))
+        / ((p - lam) * (1 - lam) * (1 - eps) ** 2)
+        * np.exp(psi / (1 + delta))
+    )
+
+    def g(x, G, mu, sigma):
+        return G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))
+
+    def h_r(x, p, lam, eps, mu):
+        return (
+            (p * (1 - lam - eps) ** 1.5)
+            / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)
+            * np.exp(
+                -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (x - mu)
+                + 2 * (1 - lam)
+            )
+        )
+
+    t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)
+    H_r = (
+        (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))
+        / (
+            np.sqrt(2 * np.pi)
+            * (p - lam) ** 1.5
+            * (1 - 2 * (1 - lam - eps) / (p - lam))
+            * eps
+            * (1 - lam)
+        )
+        * np.exp(-(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu))
+    )
+
+    def h_l(x, p, lam, delta, mu):
+        return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))
+
+    t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)
+    H_l = (
+        (2 * p * (1 + delta))
+        / (np.sqrt(2 * np.pi) * delta * (1 - lam))
+        * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))
+    )
+
+    x = np.zeros(dist_size)
+    inds_to_sample = np.arange(dist_size)
+    n_to_accept = np.zeros(dist_size)
+    counter = -1
+    while np.any(inds_to_sample):
+        counter += 1
+        _dist_size = len(inds_to_sample)
+        U = rng.uniform(size=_dist_size)
+        N = rng.normal(size=_dist_size)
+        V = rng.uniform(size=_dist_size)
+        E = rng.exponential(size=_dist_size)
+        _G = G[inds_to_sample]
+        _H_l = H_l[inds_to_sample]
+        _H_r = H_r[inds_to_sample]
+        _p = p[inds_to_sample]
+        _lam = lam[inds_to_sample]
+        _mu = mu[inds_to_sample]
+        _sigma = sigma[inds_to_sample]
+        _delta = delta[inds_to_sample]
+        _eps = eps[inds_to_sample]
+        _t_l = t_l[inds_to_sample]
+        _t_r = t_r[inds_to_sample]
+
+        center = U < _G / (_G + _H_l + _H_r)
+        left = (U < (_G + _H_l) / (_G + _H_l + _H_r)) & ~center
+        raw_center_y = _mu + _sigma * N
+        raw_left_y = _t_l - 2 * E * (1 + _delta) / _delta / (1 - _lam)
+        raw_right_y = _t_r + 2 * E / ((1 - 2 * (1 - _lam - _eps) / (_p - _lam)) * _eps * (1 - _lam))
+        Y = np.where(
+            center,
+            np.where(
+                (raw_center_y >= _t_l) & (raw_center_y < _t_r),
+                raw_center_y,
+                np.nan,
+            ),
+            np.where(
+                left,
+                np.where(
+                    raw_left_y >= 0,
+                    raw_left_y,
+                    np.nan,
+                ),
+                np.where(
+                    raw_right_y >= 0,
+                    raw_right_y,
+                    np.nan,
+                ),
+            ),
+        )
+        X = np.floor(Y)
+        accepted = (
+            V
+            * np.where(
+                center,
+                g(Y, G=_G, mu=_mu, sigma=_sigma),
+                np.where(
+                    left,
+                    h_l(Y, p=_p, lam=_lam, delta=_delta, mu=_mu),
+                    h_r(Y, p=_p, lam=_lam, eps=_eps, mu=_mu),
+                ),
+            )
+            <= np.exp(_logprob(X, _p, _lam))
+        )
+
+        x[inds_to_sample[accepted]] = X[accepted]
+        n_to_accept[inds_to_sample[accepted]] = counter
+        inds_to_sample = inds_to_sample[~accepted]
+    return x
+
+
+# %% pycharm={"name": "#%%\n"}
+def _rejection_region_abel(rng, p, lam, dist_size, idxs_mask=None):
+    if idxs_mask is None:
+        idxs_mask = np.ones(dist_size, dtype="bool")
+    p = np.broadcast_to(p, dist_size)[idxs_mask]
+    lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+    dist_size = np.sum(idxs_mask)
+
+    nu = 2 * (p ** 2 - lam * p - 3 * lam ** 2) / (3 * lam ** 2)
+    alpha = 0.2746244084  # Taken from page 259
+    t = np.floor(alpha * np.maximum(nu, 0))
+    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))
+    t[problematic] = 0
+    # b = p * np.exp(np.maximum(1 - p, 0)) * np.sqrt(2 / np.pi)
+    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+    q_r = b / np.sqrt(t + 1)
+
+    rho_t = (  # Taken from page 250
+        1
+        - p
+        + np.log(p)
+        - 0.5 * np.log(2 * np.pi)
+        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))
+        - 1.5 * np.log(t + 1)
+        + (1 - lam) * t
+    )
+    #     rho_t_prime = (  # Taken form page 271
+    #         np.log(lam * t + p)
+    #         - np.log(t + 1)
+    #         + 1
+    #         - lam
+    #         + 0.5 / (t + 1)
+    #         - (lam + p) / (lam * t + p)
+    #     )
+    rho_t_prime = (
+        np.log(lam * t + p)
+        - np.log(t + 1)
+        + 1
+        - lam
+        - (t + 0.5) / (t + 1) ** 2
+        - (t - 1) * lam / (lam * t + p)
+    )
+    q = np.exp(-rho_t_prime)
+    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))
+
+    x = np.zeros(dist_size)
+    n_to_accept = np.zeros(dist_size)
+    inds_to_sample = np.arange(dist_size)
+    counter = -1
+    while np.any(inds_to_sample):
+        counter += 1
+        _dist_size = len(inds_to_sample)
+        U = rng.uniform(size=_dist_size)
+        V = rng.uniform(size=_dist_size)
+        W = rng.uniform(size=_dist_size)
+        # E = rng.uniform(size=_dist_size)
+        E = rng.exponential(size=_dist_size)
+        _p = p[inds_to_sample]
+        _lam = lam[inds_to_sample]
+        _t = t[inds_to_sample]
+        _q = q[inds_to_sample]
+        _q_l = q_l[inds_to_sample]
+        _q_r = q_r[inds_to_sample]
+        _b = b[inds_to_sample]
+        #         raw_left = np.where(_t == 0, 0, _t - np.floor(-E / np.log(1 - _q)))
+        #         raw_left = np.where(_t == 0, 0, _t - np.floor(-E / np.log(_q)))
+        # raw_left = np.where(_t == 0, 0, _t + np.ceil(np.log(1 - E) / _q))
+        raw_left = np.where(_t == 0, 0, _t - np.floor(E / _q))
+        raw_right = np.floor((_t + 1) / W ** 2)
+
+        left = U <= _q_l / (_q_l + _q_r)
+        accepted = np.where(
+            left,
+            np.where(
+                _t == 0,
+                True,
+                np.where(
+                    raw_left < 0,
+                    False,
+                    #                     V * _q_l * _q ** (_t - raw_left) * (1 - _q)
+                    V * _q_l * _q ** (_t - raw_left) * (1 - _q ** (_t + 1))
+                    <= np.exp(_logprob(raw_left, _p, _lam)),
+                ),
+            ),
+            V * _b * (1 / np.sqrt(raw_right) - 1 / np.sqrt(raw_right + 1))
+            <= np.exp(_logprob(raw_right, _p, _lam)),
+        )
+        X = np.where(left, raw_left, raw_right)
+
+        x[inds_to_sample[accepted]] = X[accepted]
+        n_to_accept[inds_to_sample[accepted]] = counter
+        inds_to_sample = inds_to_sample[~accepted]
+    return x
+
+
+# %% pycharm={"name": "#%%\n"}
+def _inverse_rng_fn(rng, theta, lam, dist_size):
+    log_u = np.log(rng.uniform(size=dist_size))
+    pos_lam = lam > 0
+    abs_log_lam = np.log(np.abs(lam))
+    theta_m_lam = theta - lam
+    log_s = -theta
+    log_p = log_s.copy()
+    x_ = 0
+    x = np.zeros(dist_size)
+    below_cutpoint = log_s < log_u
+    with np.errstate(divide="ignore", invalid="ignore"):
+        counter = 0
+        while np.any(below_cutpoint):
+            counter += 1
+            x_ += 1
+            x[below_cutpoint] += 1
+            log_c = np.log(theta_m_lam + lam * x_)
+            # Compute log(1 + lam / C)
+            log1p_lam_m_C = np.where(
+                pos_lam,
+                np.log1p(np.exp(abs_log_lam - log_c)),
+                pm.math.log1mexp_numpy(abs_log_lam - log_c, negative_input=True),
+            )
+            log_p = log_c + log1p_lam_m_C * (x_ - 1) + log_p - np.log(x_) - lam
+            log_s = np.logaddexp(log_s, log_p)
+            below_cutpoint = log_s < log_u
+    #     print(counter)
+    return x
+
+
+# %%
+def _branching_rng_fn(rng, theta, lam, dist_size, idxs_mask=None):
+    if idxs_mask is None:
+        idxs_mask = np.ones(dist_size, dtype=bool)
+    lam_ = np.abs(lam)  # This algorithm is only valid for positive lam
+    y = rng.poisson(theta, size=dist_size)
+    x = y.copy()
+    higher_than_zero = y > 0
+    while np.any(higher_than_zero[idxs_mask]):
+        y = rng.poisson(lam_ * y)
+        x[higher_than_zero] = x[higher_than_zero] + y[higher_than_zero]
+        higher_than_zero = y > 0
+    return x
+
+
+# %% pycharm={"name": "#%%\n"}
+rng = np.random.default_rng(42)
+p, lam = np.meshgrid(np.logspace(-2, 4, 50), np.linspace(0, 1, 50))
+dist_size = (100, *p.shape)
+monotonicity_idxs = np.broadcast_to(p <= np.exp(lam), dist_size)
+poisson_idxs = np.broadcast_to(p >= np.maximum(3, 2 * lam / (1 - lam)), dist_size)
+abel_idxs = np.broadcast_to(
+    (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam))),
+    dist_size,
+)
+
+# %% pycharm={"name": "#%%\n"}
+# %%time
+samples = np.full(dist_size, np.nan)
+samples[monotonicity_idxs] = _rejection_region_monotonicity(
+    rng=rng, p=p, lam=lam, dist_size=dist_size, idxs_mask=monotonicity_idxs
+)
+samples[poisson_idxs] = _rejection_region_poisson(
+    rng=rng,
+    p=p,
+    lam=lam,
+    dist_size=dist_size,
+    idxs_mask=poisson_idxs,
+)
+samples[abel_idxs] = _rejection_region_abel(
+    rng=rng,
+    p=p,
+    lam=lam,
+    dist_size=dist_size,
+    idxs_mask=abel_idxs,
+)
+
+# %% pycharm={"name": "#%%\n"}
+c = np.zeros_like(p.flatten())
+c[monotonicity_idxs[0].flatten()] = 0
+c[poisson_idxs[0].flatten()] = 1
+c[abel_idxs[0].flatten()] = 2
+
+# %% pycharm={"name": "#%%\n"}
+plt.scatter(
+    (p / (1 - lam)).flatten(),
+    np.mean(samples, axis=0).flatten(),
+    c=c,
+    alpha=0.2,
+    cmap="jet",
+)
+ax = plt.gca()
+ax.set_xscale("log")
+ax.set_yscale("log")
+plt.plot(ax.get_xlim(), ax.get_ylim(), "-k", alpha=0.2)
+plt.xlabel("Expected mean")
+plt.xlabel("Sample mean")
+
+# %% pycharm={"name": "#%%\n"}
+plt.scatter(
+    (p / (1 - lam) ** 3).flatten(),
+    np.var(samples, axis=0).flatten(),
+    c=c,
+    alpha=0.2,
+    cmap="jet",
+)
+ax = plt.gca()
+ax.set_xscale("log")
+ax.set_yscale("log")
+
+ax = plt.gca()
+plt.plot(ax.get_xlim(), ax.get_ylim(), "-k", alpha=0.2)
+plt.xlabel("Expected variance")
+plt.xlabel("Sample variance")
+
+
+# %% pycharm={"name": "#%%\n"}
+def normal_approx(x, p, lam):
+    mu = p / (1 - lam)
+    sigma = np.sqrt(p / (1 - lam) ** 3)
+    return 1 / np.sqrt(2 * np.pi) / sigma * np.exp(-0.5 * (x - mu) ** 2 / sigma ** 2)
+
+
+# %% pycharm={"name": "#%%\n"}
+def monotonicity_region_envelope(x, p, lam):
+    return p * np.exp(
+        2
+        - lam
+        - np.minimum(lam, p) * np.sqrt(2 / np.pi) * ((1 / np.sqrt(x)) - (1 / np.sqrt(x + 1)))
+    ) + (x == 0) * np.exp(
+        -p
+    )  # Extra probability for x==0
+
+
+# %% pycharm={"name": "#%%\n"}
+def poisson_region_envelope(x, p, lam):
+    eps = (1 - lam) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+    delta = (1 - lam) ** (2 / 5) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+    mu = (p - lam) / (1 - lam)
+    sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)
+    psi = (
+        p * delta * (2 + delta - 2 * lam)
+        + (1 + delta) * (1 - lam) ** 2
+        - lam * (1 - lam + delta) ** 2
+    ) / (2 * (p - 1 - delta))
+    G = (
+        (p * (1 - lam - eps) * np.sqrt(1 + delta))
+        / ((p - lam) * (1 - lam) * (1 - eps) ** 2)
+        * np.exp(psi / (1 + delta))
+    )
+
+    def g(x):
+        return G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))
+
+    h_r_norm = (p * (1 - lam - eps) ** 1.5) / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)
+    h_r_exp_A = -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam)
+    h_r_exp_B = 2 * (1 - lam)
+
+    def h_r(x):
+        return h_r_norm * np.exp(h_r_exp_A * (x - mu) + h_r_exp_B)
+
+    t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)
+    H_r = (
+        (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))
+        / (
+            np.sqrt(2 * np.pi)
+            * (p - lam) ** 1.5
+            * (1 - 2 * (1 - lam - eps) / (p - lam))
+            * eps
+            * (1 - lam)
+        )
+        * np.exp(-(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu))
+    )
+
+    def h_l(x):
+        return p / np.sqrt(2 * np.pi) * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))
+
+    t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)
+    H_l = (
+        (2 * p * (1 + delta))
+        / (np.sqrt(2 * np.pi) * delta * (1 - lam))
+        * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))
+    )
+    return np.where(x < t_l, h_l(x), np.where(x < t_r, g(x), h_r(x)))
+
+
+# %% pycharm={"name": "#%%\n"}
+x = np.linspace(1000, 1700, 1000)
+lam = 0.3
+p = 1000
+y0 = poisson_region_envelope(x, p, lam)
+y1 = np.exp(_logprob(np.floor(x), p, lam))
+y2 = normal_approx(x, p, lam)
+plt.semilogy(x, y0, label="Envelope")
+plt.semilogy(x, y1, label="PDF")
+plt.plot(x, y2, label="Normal approx")
+samples = _rejection_region_poisson(np.random.default_rng(42), p, lam, 100000)
+y, edges = np.histogram(samples, bins=20, density=True)
+plt.plot(0.5 * (edges[1:] + edges[:-1]), y, label="Sampled points")
+plt.legend()
+
+
+# %% pycharm={"name": "#%%\n"}
+def abel_rejection_envelope(x, p, lam):
+    p = np.asarray(p)
+    lam = np.asarray(lam)
+    nu = 2 / 3 * (p ** 2 - lam * p - 3 * lam ** 2) / lam ** 2
+    alpha = 0.2746244084  # Taken from page 259
+    # alpha = 3/7
+    t = np.floor(alpha * np.maximum(nu, 0))
+    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))
+    if t.size == 1:
+        if problematic:
+            t = 0
+    else:
+        t[problematic] = 0
+    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+    q_r = b / np.sqrt(t + 1)
+
+    rho_t = (  # Taken from page 250
+        1
+        - p
+        + np.log(p)
+        - 0.5 * np.log(2 * np.pi)
+        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))
+        - 1.5 * np.log(t + 1)
+        + (1 - lam) * t
+    )
+    rho_t_prime = (
+        np.log(lam * t + p)
+        - np.log(t + 1)
+        + 1
+        - lam
+        - (t + 0.5) / (t + 1) ** 2
+        - (t - 1) * lam / (lam * t + p)
+    )
+    q = np.where(t == 0, 0, np.exp(-rho_t_prime))
+    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))
+    return np.where(
+        x <= t,
+        q_l * q ** (t - x) * (1 - q ** (t + 1)),
+        b * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),
+    )
+
+
+# %% pycharm={"name": "#%%\n"}
+def abel_rejection_proposal_density(x, p, lam):
+    p = np.asarray(p)
+    lam = np.asarray(lam)
+    nu = 2 / 3 * (p ** 2 - lam * p - 3 * lam ** 2) / lam ** 2
+    alpha = 0.2746244084  # Taken from page 259
+    # alpha = 3/7
+    t = np.floor(alpha * np.maximum(nu, 0))
+    problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))
+    if t.size == 1:
+        if problematic:
+            t = 0
+    else:
+        t[problematic] = 0
+    b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+    q_r = b / np.sqrt(t + 1)
+
+    rho_t = (  # Taken from page 250
+        1
+        - p
+        + np.log(p)
+        - 0.5 * np.log(2 * np.pi)
+        + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))
+        - 1.5 * np.log(t + 1)
+        + (1 - lam) * t
+    )
+    rho_t_prime = (
+        np.log(lam * t + p)
+        - np.log(t + 1)
+        + 1
+        - lam
+        - (t + 0.5) / (t + 1) ** 2
+        - (t - 1) * lam / (lam * t + p)
+    )
+    q = np.where(t == 0, 0, np.exp(-rho_t_prime))
+    q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - q))
+    return np.where(
+        x <= t,
+        q ** (t - x) * (1 - q ** (t + 1)) / (1 - q),
+        np.sqrt(t + 1) * (1 / np.sqrt(x) - 1 / np.sqrt(x + 1)),
+    )
+
+
+# %% pycharm={"name": "#%%\n"}
+p, lam = 2.1209508879201904, 0.5510204081632653
+mean = p / (1 - lam)
+std = np.sqrt(p / (1 - lam) ** 3)
+x = np.linspace(np.maximum(0, mean - 1.2 * std), mean + 15 * std, 1000)
+plt.semilogy(x, np.exp(_logprob(x, p, lam)), label="PDF")
+plt.plot(x, abel_rejection_envelope(x, p, lam), label="Envelope")
+plt.plot(x, abel_rejection_proposal_density(x, p, lam), label="Proposal density")
+# samples = _rejection_region_abel(np.random.default_rng(42), p, lam, 100000)
+# print(np.mean(samples <= 1), np.sum(np.exp(_logprob(np.array([0, 1]), p, lam))))
+y, edges = np.histogram(samples, bins=20, density=True)
+# plt.plot(0.5 * (edges[1:] + edges[:-1]), y, label="Sampled points")
+plt.legend()
+
+# %% pycharm={"name": "#%%\n"}
+p, lam = 2.1209508879201904, 0.5510204081632653
+
+mean = p / (1 - lam)
+std = np.sqrt(p / (1 - lam) ** 3)
+x = np.linspace(0, 10, 1000)
+
+plt.figure(figsize=(16, 6))
+plt.semilogy(x, np.exp(_logprob(np.floor(x), p, lam)), label="PMF")
+
+# plt.plot(x, abel_rejection_envelope(np.floor(x), p, lam), label="Envelope")
+# plt.plot(x, abel_rejection_proposal_density(np.floor(x), p, lam), label="Proposal density")
+samples_monot = _rejection_region_monotonicity(np.random.default_rng(), p, lam, 100000)
+samples_branch = _branching_rng_fn(np.random.default_rng(), p, lam, 100000)
+samples_abel = _rejection_region_abel(np.random.default_rng(), p, lam, 100000)
+for samples, algo in zip(
+    (samples_monot, samples_branch, samples_abel), ("monoticity", "branch", "abel")
+):
+    u, c = np.unique(samples, return_counts=True)
+    edges = np.arange(11)
+    y = np.array([np.sum(c[u == e]) for e in edges])
+    plt.step(edges, y / samples.size, label=f"Sampled points ({algo})", where="post")
+    plt.legend(loc=(1, 0))
+
+# %% pycharm={"name": "#%%\n"}
+np.exp(_logprob(0, p, lam))
+
+# %% pycharm={"name": "#%%\n"}
+p_range = np.logspace(-2, 4, 50)
+lam_range = np.linspace(0, 1, 60)
+p, lam = np.meshgrid(p_range, lam_range)
+dist_size = p.shape
+# monotonicity_idxs = p <= (1 + lam)
+# monotonicity_idxs = p <= np.exp(lam)
+# poisson_idxs = p > np.maximum(1 + lam, 2 * lam / (1 - lam))
+poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))
+# poisson_idxs = p > np.maximum(np.exp(lam), 2 * lam / (1 - lam))
+abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))
+# abel_idxs = (lam == 1) | ((p > np.exp(lam)) & (p <= 2 * lam / (1 - lam)))
+# abel_idxs = (lam == 1) | ((p >= 3) & (p <= 2 * lam / (1 - lam)))
+
+# %% pycharm={"name": "#%%\n"}
+idxs = np.full((lam_range.size, 50), 0, dtype=int)
+# idxs[monotonicity_idxs] = 0
+idxs[poisson_idxs] = 1
+idxs[abel_idxs] = 2
+np.mean(idxs == 1),
+
+# %% pycharm={"name": "#%%\n"}
+p_range = np.logspace(-2, 4, 50)
+lam_range = np.linspace(0, 1, 60)
+p, lam = np.meshgrid(p_range, lam_range)
+
+poisson_idxs = p >= np.maximum(3, 2 * lam / (1 - lam))
+abel_idxs = (lam == 1) | ((p >= 1 + lam) & (p <= 2 * lam / (1 - lam)))
+
+idxs = np.full((lam_range.size, 50), 0, dtype=int)
+# idxs[monotonicity_idxs] = 0
+idxs[poisson_idxs] = 1
+idxs[abel_idxs] = 2
+
+xs = np.concatenate([np.arange(10), np.logspace(1, 4.5)]).astype(int)
+for i in range(p.shape[0]):
+    for j in range(p.shape[1]):
+        if idxs[i, j] == 0:
+            proposal = monotonicity_region_envelope(xs, p[i, j], lam[i, j])
+            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))
+            bad_xs = xs[proposal < pmf + 0.00]
+            if len(bad_xs):
+                print(
+                    f"Monotonicity envelope is not higher than pmf for p={p[i, j]:.1f}, "
+                    f"lam={lam[i, j]:.3f}, xs={bad_xs}"
+                )
+
+        elif idxs[i, j] == 1:
+            proposal = poisson_region_envelope(xs, p[i, j], lam[i, j])
+            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))
+            bad_xs = xs[proposal < pmf - 0.03]
+            if len(bad_xs):
+                print(
+                    f"Poisson envelope is not higher than pmf for p={p[i, j]:.1f}, "
+                    f"lam={lam[i, j]:.3f}, xs={bad_xs}"
+                )
+
+        elif idxs[i, j] == 2:
+            proposal = abel_rejection_envelope(xs, p[i, j], lam[i, j])
+            pmf = np.exp(_logprob(xs, p[i, j], lam[i, j]))
+            bad_xs = xs[proposal < pmf - 0.0 + 0.00]
+            if len(bad_xs):
+                print(
+                    f"Abel envelope is not higher than pmf for p={p[i, j]:.1f}, "
+                    f"lam={lam[i, j]:.3f}, xs={bad_xs}"
+                )
+
+# %% pycharm={"name": "#%%\n"}
+data = idxs.T
+
+fig, ax = plt.subplots(figsize=(7, 7))
+
+# get discrete colormap
+cmap = plt.get_cmap("coolwarm", np.max(data) - np.min(data) + 1)
+# set limits .5 outside true range
+mat = ax.imshow(
+    data,
+    cmap=cmap,
+    vmin=0,
+    vmax=2,
+    origin="lower",
+)
+# tell the colorbar to tick at integers
+cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038)
+cbar.ax.set_yticklabels(["monotonicity", "poisson", "abel"])
+
+ax.set_xlabel("lam")
+every = 8
+plt.xticks(range(0, lam_range.size)[::every], np.round(lam_range[::every], 2))
+
+ax.set_ylabel("p")
+every = 8
+plt.yticks(range(0, p_range.size)[::every], np.round(p_range[::every], 2))
+
+# %% [markdown]
+# ## Benchmark algorithms
+
+# %% pycharm={"name": "#%%\n"}
+import signal
+import time
+
+from functools import reduce
+
+
+# %% pycharm={"name": "#%%\n"}
+class TimeOutError(RuntimeError):
+    pass
+
+
+def handler(signum, frame):
+    raise TimeOutError
+
+
+signal.signal(signal.SIGALRM, handler)
+
+# %% pycharm={"name": "#%%\n"}
+rng = np.random.default_rng(42)
+dist_size = (100, *p.shape)
+
+
+# %%
+def benchmark_algorithm(algorithm_fn, draws=100, duration_cutoff=0.05):
+    duration = np.full_like(p, np.nan)
+    for i in range(p.shape[0]):
+        for j in range(p.shape[1]):
+            signal.setitimer(signal.ITIMER_REAL, duration_cutoff)
+            start = time.time()
+            try:
+                algorithm_fn(rng, p=p[i, j], lam=lam[i, j], dist_size=draws)
+                signal.alarm(0)
+            except TimeOutError:
+                continue
+            end = time.time()
+            duration[i, j] = end - start
+    signal.alarm(0)
+    return duration
+
+
+# %%
+def plot_benchmark(duration, title=""):
+    fig, ax = plt.subplots(1, 2, figsize=(14, 7), sharey=True)
+
+    # Region
+    data = idxs.T
+    cmap = plt.get_cmap("coolwarm", np.max(data) - np.min(data) + 1)
+    mat = ax[0].imshow(
+        data,
+        cmap=cmap,
+        vmin=0,
+        vmax=2,
+        origin="lower",
+    )
+    cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038, ax=ax[0])
+    cbar.ax.set_yticks([0.3, 1, 1.7])
+    cbar.ax.set_yticklabels(["monoticity.", "poisson", "abel"], rotation=90, va="center")
+
+    # Timings
+    data = duration.T
+    mat = ax[1].imshow(
+        data,
+        cmap="viridis",
+        origin="lower",
+    )
+    cbar = fig.colorbar(mat, fraction=0.038, ax=ax[1])
+
+    for axi in ax:
+        axi.set_xlabel("lam")
+        every = 8
+        axi.set_xticks(range(0, lam_range.size)[::every])
+        axi.set_xticklabels(np.round(lam_range[::every], 2))
+
+        axi.set_ylabel("p")
+        every = 8
+        axi.set_yticks(range(0, p_range.size)[::every])
+        axi.set_yticklabels(np.round(p_range[::every], 2))
+
+        axi.axhline(20.5, color="white")
+
+    fig.suptitle(title, y=0.85, fontsize=18)
+
+
+# %%
+duration_monot = benchmark_algorithm(_rejection_region_monotonicity)
+
+# %%
+duration_poisson = benchmark_algorithm(_rejection_region_poisson)
+
+# %%
+duration_abel = benchmark_algorithm(_rejection_region_abel)
+
+# %%
+duration_inverse = benchmark_algorithm(
+    lambda rng, p, lam, dist_size: _inverse_rng_fn(rng, theta=p, lam=lam, dist_size=dist_size)
+)
+
+# %%
+duration_branch = benchmark_algorithm(
+    lambda rng, p, lam, dist_size: _branching_rng_fn(rng, theta=p, lam=lam, dist_size=dist_size)
+)
+
+# %%
+plot_benchmark(duration=duration_monot, title="Monotonicity algorithm speed")
+plot_benchmark(duration=duration_poisson, title="Poisson algorithm speed")
+plot_benchmark(duration=duration_abel, title="Abel algorithm speed")
+plot_benchmark(duration=duration_inverse, title="Inverse algorithm speed")
+plot_benchmark(duration=duration_branch, title="Branching algorithm speed")
+
+
+# %% pycharm={"name": "#%%\n"}
+def plot_benchmark_comparison(benchmarks, benchmark_names, threshold=0):
+
+    nan_to_inf = lambda x: np.nan_to_num(x, nan=np.inf)
+    best_duration = np.full_like(duration_monot, np.nan)
+
+    for i, reference in enumerate(benchmarks):
+        comps = (
+            reference + threshold < nan_to_inf(other)
+            for other in benchmarks
+            if other is not reference
+        )
+        best_duration[reduce(lambda x, y: x & y, comps)] = i
+
+    fig, ax = plt.subplots(1, 2, figsize=(14, 7), sharey=True)
+
+    # Region
+    data = idxs.T
+    cmap = plt.get_cmap("coolwarm", np.max(data) - np.min(data) + 1)
+    mat = ax[0].imshow(
+        data,
+        cmap=cmap,
+        vmin=0,
+        vmax=2,
+        origin="lower",
+    )
+    cbar = fig.colorbar(mat, ticks=[0, 1, 2], fraction=0.038, ax=ax[0])
+    cbar.ax.set_yticks([0.3, 1, 1.7])
+    cbar.ax.set_yticklabels(["monoticity.", "poisson", "abel"], rotation=90, va="center")
+
+    # Timings
+    data = best_duration.T
+    cmap = plt.get_cmap("coolwarm", np.nanmax(data) - np.nanmin(data) + 1)
+    mat = ax[1].imshow(
+        data,
+        cmap=cmap,
+        origin="lower",
+    )
+    cbar = fig.colorbar(mat, fraction=0.038, ax=ax[1])
+    cbar.ax.set_yticks([0.3, 1, 1.7, 2.8, 3.5][: len(benchmarks)])
+    cbar.ax.set_yticklabels(benchmark_names, rotation=90, va="center")
+
+    for axi in ax:
+        axi.set_xlabel("lam")
+        every = 8
+        axi.set_xticks(range(0, lam_range.size)[::every])
+        axi.set_xticklabels(np.round(lam_range[::every], 2))
+
+        axi.set_ylabel("p")
+        every = 8
+        axi.set_yticks(range(0, p_range.size)[::every])
+        axi.set_yticklabels(np.round(p_range[::every], 2))
+
+        axi.axhline(20.5, color="k")
+
+    fig.suptitle("Best performance per region", y=0.85, fontsize=18)
+
+
+# %%
+plot_benchmark_comparison(
+    [duration_monot, duration_poisson, duration_abel],
+    ["monot", "poisson", "abel"],
+)
+
+# %%
+plot_benchmark_comparison(
+    [duration_monot, duration_poisson, duration_abel, duration_inverse, duration_branch],
+    ["monot", "poisson", "abel", "inverse", "branch"],
+)
+
+# %%
+plot_benchmark_comparison(
+    [duration_monot, duration_poisson, duration_abel, duration_inverse, duration_branch],
+    ["monot", "poisson", "abel", "inverse", "branch"],
+    threshold=0.001,
+)
+
+# %%
+plot_benchmark_comparison([duration_monot, duration_branch], ["monot", "branch"], threshold=0.0)
+
+# %%
+plot_benchmark_comparison([duration_poisson, duration_branch], ["poisson", "branch"], threshold=0.0)
+
+# %%
+plot_benchmark_comparison([duration_abel, duration_branch], ["abel", "branch"], threshold=0.000)
+
+# %%
diff --git a/preclinpack/blocks/distributions.py b/preclinpack/blocks/distributions.py
index 16671a4..06685fc 100644
--- a/preclinpack/blocks/distributions.py
+++ b/preclinpack/blocks/distributions.py
@@ -32,6 +32,7 @@
     from pymc.distributions.distribution import _moment
     from pymc.distributions.shape_utils import rv_size_is_none
     from pymc.distributions.transforms import _default_transform
+    from scipy.special import gammaln
 
     try:
         from aesara.link.jax.dispatch import jax_funcify
@@ -195,6 +196,13 @@ def logp(op, value_var_list, rng, size, dtype, dim, alpha, **kwargs):
             dim > 1,
         )
 
+    def _logpow(x, m):
+        """
+        Calculates log(x**m) since m*log(x) will fail when m, x = 0.
+        """
+        # return m * log(x)
+        return np.where(x == 0, np.where(m == 0, 0.0, -np.inf), m * np.log(x))
+
     class GeneralizedPoissonRV(RandomVariable):
         name = "generalized_poisson"
         ndim_supp = 0
@@ -213,21 +221,285 @@ def rng_fn(cls, rng, theta, lam, size):
             else:
                 dist_size = np.broadcast_shapes(theta.shape, lam.shape)
 
-            # A mix of 2 algorithms described by Famoye (1997) is used depending on
-            # parameter values
+            # A mix of 4 algorithms described by Devroye (1989) and Famoye (1997) is used
+            # depending on parameter values
             # 0: Inverse method, computed on the log scale. Used when lam <= 0.
-            # 1: Branching method. Used when lambda > 0.
+            # 1: Poisson rejection region. Used when theta > max(3, 2 * lam / (1 - lam))
+            # 2: Abel rejection region. Used when lam == 1 or (p >= 1 + lam and p <= 2*lam / (1-lam))
+            # 3: Universal bound (AKA monotonicity region). Used when lam > 0 and not in regions 1 or 2
+
+            poisson_idxs = np.broadcast_to(theta >= np.maximum(3, 2 * lam / (1 - lam)), dist_size)
+            abel_idxs = np.broadcast_to(
+                (lam == 1) | ((theta >= 1 + lam) & (theta <= 2 * lam / (1 - lam))),
+                dist_size,
+            )
+            monotonicity_idxs = (lam > 0) & (~poisson_idxs) & (~abel_idxs)
+            inverse_method_idxs = np.broadcast_to(lam < 0, dist_size)
+
             x = np.empty(dist_size)
-            idxs_mask = np.broadcast_to(lam < 0, dist_size)
-            if np.any(idxs_mask):
-                x[idxs_mask] = cls._inverse_rng_fn(rng, theta, lam, dist_size, idxs_mask=idxs_mask)[
-                    idxs_mask
-                ]
-            idxs_mask = ~idxs_mask
-            if np.any(idxs_mask):
-                x[idxs_mask] = cls._branching_rng_fn(
-                    rng, theta, lam, dist_size, idxs_mask=idxs_mask
-                )[idxs_mask]
+            if np.any(inverse_method_idxs):
+                x[inverse_method_idxs] = cls._inverse_rng_fn(
+                    rng, theta, lam, dist_size, idxs_mask=inverse_method_idxs
+                )[inverse_method_idxs]
+            if np.any(monotonicity_idxs):
+                x[monotonicity_idxs] = cls._rejection_region_monotonicity(
+                    rng, theta, lam, dist_size, idxs_mask=monotonicity_idxs
+                )
+            if np.any(poisson_idxs):
+                x[poisson_idxs] = cls._rejection_region_poisson(
+                    rng, theta, lam, dist_size, idxs_mask=poisson_idxs
+                )
+            if np.any(abel_idxs):
+                x[abel_idxs] = cls._rejection_region_abel(
+                    rng, theta, lam, dist_size, idxs_mask=abel_idxs
+                )
+            return x
+
+        @staticmethod
+        def _logprob(x, theta, lam):
+            theta_lam_x = theta + lam * x
+            return np.log(theta) + _logpow(theta_lam_x, x - 1) - theta_lam_x - gammaln(x + 1)
+
+        @classmethod
+        def _rejection_region_monotonicity(cls, rng, p, lam, dist_size, idxs_mask=None):
+            if idxs_mask is None:
+                idxs_mask = np.ones(dist_size, dtype="bool")
+            p = np.broadcast_to(p, dist_size)[idxs_mask]
+            lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+            dist_size = np.sum(idxs_mask)
+            p0 = np.exp(-p)
+            b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+            u = rng.uniform(size=dist_size)
+            x = np.zeros(dist_size)
+            inds_to_sample = u > p0 / (p0 + b)
+            counter = 0
+            while np.any(inds_to_sample):
+                counter += 1
+                v = rng.uniform(size=dist_size)
+                w = rng.uniform(size=dist_size)
+                _x = np.floor(1 / w ** 2)
+                accepted = v * b * (1 / np.sqrt(_x) - 1 / np.sqrt(_x + 1)) <= np.exp(
+                    cls._logprob(_x, p, lam)
+                )
+                x[inds_to_sample & accepted] = _x[inds_to_sample & accepted]
+                inds_to_sample = inds_to_sample & ~accepted
+            return x
+
+        @classmethod
+        def _rejection_region_poisson(cls, rng, p, lam, dist_size, idxs_mask=None):
+            if idxs_mask is None:
+                idxs_mask = np.ones(dist_size, dtype="bool")
+            p = np.broadcast_to(p, dist_size)[idxs_mask]
+            lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+            dist_size = np.sum(idxs_mask)
+
+            eps = (1 - lam) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+            delta = (1 - lam) ** (2 / 5) / (2 + (p - lam) * (1 - lam)) ** (1 / 3)
+            mu = (p - lam) / (1 - lam)
+            sigma = np.sqrt((1 + delta) * (p - lam) / (1 - lam - eps) / (1 - lam) ** 2)
+            psi = (
+                p * delta * (2 + delta - 2 * lam)
+                + (1 + delta) * (1 - lam) ** 2
+                - lam * (1 - lam + delta) ** 2
+            ) / (2 * (p - 1 - delta))
+            G = (
+                (p * (1 - lam - eps) * np.sqrt(1 + delta))
+                / ((p - lam) * (1 - lam) * (1 - eps) ** 2)
+                * np.exp(psi / (1 + delta))
+            )
+
+            def g(x, G, mu, sigma):
+                return (
+                    G / (np.sqrt(2 * np.pi) * sigma) * np.exp(-((x - mu) ** 2) / (2 * sigma ** 2))
+                )
+
+            def h_r(x, p, lam, eps, mu):
+                return (
+                    (p * (1 - lam - eps) ** 1.5)
+                    / (np.sqrt(2 * np.pi) * (p - lam) ** 1.5)
+                    * np.exp(
+                        -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (x - mu)
+                        + 2 * (1 - lam)
+                    )
+                )
+
+            t_r = np.ceil((p - lam) / (1 - lam - eps) - 1)
+            H_r = (
+                (2 * p * (1 - lam - eps) ** 1.5 * np.exp(2 * (1 - lam)))
+                / (
+                    np.sqrt(2 * np.pi)
+                    * (p - lam) ** 1.5
+                    * (1 - 2 * (1 - lam - eps) / (p - lam))
+                    * eps
+                    * (1 - lam)
+                )
+                * np.exp(
+                    -(1 - 2 * (1 - lam - eps) / (p - lam)) * (eps / 2) * (1 - lam) * (t_r - mu)
+                )
+            )
+
+            def h_l(x, p, lam, delta, mu):
+                return (
+                    p
+                    / np.sqrt(2 * np.pi)
+                    * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (x + 1 - mu))
+                )
+
+            t_l = np.ceil((p - lam) / (1 - lam + delta) - 1)
+            H_l = (
+                (2 * p * (1 + delta))
+                / (np.sqrt(2 * np.pi) * delta * (1 - lam))
+                * np.exp(delta * (1 - lam) / (2 * (1 + delta)) * (t_l + 1 - mu))
+            )
+
+            x = np.zeros(dist_size)
+            inds_to_sample = np.arange(dist_size)
+            n_to_accept = np.zeros(dist_size)
+            counter = -1
+            while np.any(inds_to_sample):
+                counter += 1
+                _dist_size = len(inds_to_sample)
+                U = rng.uniform(size=_dist_size)
+                N = rng.normal(size=_dist_size)
+                V = rng.uniform(size=_dist_size)
+                E = rng.exponential(size=_dist_size)
+                _G = G[inds_to_sample]
+                _H_l = H_l[inds_to_sample]
+                _H_r = H_r[inds_to_sample]
+                _p = p[inds_to_sample]
+                _lam = lam[inds_to_sample]
+                _mu = mu[inds_to_sample]
+                _sigma = sigma[inds_to_sample]
+                _delta = delta[inds_to_sample]
+                _eps = eps[inds_to_sample]
+                _t_l = t_l[inds_to_sample]
+                _t_r = t_r[inds_to_sample]
+
+                center = U < _G / (_G + _H_l + _H_r)
+                left = (U < (_G + _H_l) / (_G + _H_l + _H_r)) & ~center
+                raw_center_y = _mu + _sigma * N
+                raw_left_y = _t_l - 2 * E * (1 + _delta) / _delta / (1 - _lam)
+                raw_right_y = _t_r + 2 * E / (
+                    (1 - 2 * (1 - _lam - _eps) / (_p - _lam)) * _eps * (1 - _lam)
+                )
+                Y = np.where(
+                    center,
+                    np.where(
+                        (raw_center_y >= _t_l) & (raw_center_y < _t_r),
+                        raw_center_y,
+                        np.nan,
+                    ),
+                    np.where(
+                        left,
+                        np.where(
+                            raw_left_y >= 0,
+                            raw_left_y,
+                            np.nan,
+                        ),
+                        np.where(
+                            raw_right_y >= 0,
+                            raw_right_y,
+                            np.nan,
+                        ),
+                    ),
+                )
+                X = np.floor(Y)
+                accepted = (
+                    V
+                    * np.where(
+                        center,
+                        g(Y, G=_G, mu=_mu, sigma=_sigma),
+                        np.where(
+                            left,
+                            h_l(Y, p=_p, lam=_lam, delta=_delta, mu=_mu),
+                            h_r(Y, p=_p, lam=_lam, eps=_eps, mu=_mu),
+                        ),
+                    )
+                    <= np.exp(cls._logprob(X, _p, _lam))
+                )
+
+                x[inds_to_sample[accepted]] = X[accepted]
+                n_to_accept[inds_to_sample[accepted]] = counter
+                inds_to_sample = inds_to_sample[~accepted]
+            return x
+
+        @classmethod
+        def _rejection_region_abel(cls, rng, p, lam, dist_size, idxs_mask=None):
+            if idxs_mask is None:
+                idxs_mask = np.ones(dist_size, dtype="bool")
+            p = np.broadcast_to(p, dist_size)[idxs_mask]
+            lam = np.broadcast_to(lam, dist_size)[idxs_mask]
+            dist_size = np.sum(idxs_mask)
+
+            nu = 2 * (p ** 2 - lam * p - 3 * lam ** 2) / (3 * lam ** 2)
+            alpha = 0.2746244084  # Taken from page 259
+            t = np.floor(alpha * np.maximum(nu, 0))
+            problematic = (p < 1 + lam) | ((p * (1 - lam)) > (2 * lam))
+            t[problematic] = 0
+            b = p * np.exp(2 - lam - np.minimum(lam, p)) * np.sqrt(2 / np.pi)
+            q_r = b / np.sqrt(t + 1)
+
+            rho_t = (  # Taken from page 250
+                1
+                - p
+                + np.log(p)
+                - 0.5 * np.log(2 * np.pi)
+                + (t - 1) * (np.log(lam * t + p) - np.log(t + 1))
+                - 1.5 * np.log(t + 1)
+                + (1 - lam) * t
+            )
+            rho_t_prime = (
+                np.log(lam * t + p)
+                - np.log(t + 1)
+                + 1
+                - lam
+                + 1.5 / (t + 1)
+                - (lam + p) / (lam * t + p)
+            )
+            q = np.exp(-rho_t_prime)
+            q_l = np.where(t == 0, np.exp(-p), np.exp(rho_t) / (1 - np.exp(-rho_t_prime)))
+
+            x = np.zeros(dist_size)
+            n_to_accept = np.zeros(dist_size)
+            inds_to_sample = np.arange(dist_size)
+            counter = -1
+            while np.any(inds_to_sample):
+                counter += 1
+                _dist_size = len(inds_to_sample)
+                U = rng.uniform(size=_dist_size)
+                V = rng.uniform(size=_dist_size)
+                W = rng.uniform(size=_dist_size)
+                E = rng.exponential(size=_dist_size)
+                _p = p[inds_to_sample]
+                _lam = lam[inds_to_sample]
+                _t = t[inds_to_sample]
+                _q = q[inds_to_sample]
+                _q_l = q_l[inds_to_sample]
+                _q_r = q_r[inds_to_sample]
+                _b = b[inds_to_sample]
+                raw_left = np.where(_t == 0, 0, _t - np.floor(-E / np.log(1 - _q)))
+                raw_right = np.floor((_t + 1) / W ** 2)
+                left = U <= _q_l / (_q_l + _q_r)
+                accepted = np.where(
+                    left,
+                    np.where(
+                        _t == 0,
+                        True,
+                        np.where(
+                            raw_left > 0,
+                            False,
+                            V * _q_l * _q ** (_t - raw_left) * (1 - _q)
+                            <= np.exp(cls._logprob(raw_left, _p, _lam)),
+                        ),
+                    ),
+                    V * _b * (1 / np.sqrt(raw_right) - 1 / np.sqrt(raw_right + 1))
+                    <= np.exp(cls._logprob(raw_right, _p, _lam)),
+                )
+                X = np.where(left, raw_left, raw_right)
+
+                x[inds_to_sample[accepted]] = X[accepted]
+                n_to_accept[inds_to_sample[accepted]] = counter
+                inds_to_sample = inds_to_sample[~accepted]
             return x
 
         @classmethod
@@ -257,18 +529,6 @@ def _inverse_rng_fn(cls, rng, theta, lam, dist_size, idxs_mask):
                     below_cutpoint = log_s < log_u
             return x
 
-        @classmethod
-        def _branching_rng_fn(cls, rng, theta, lam, dist_size, idxs_mask):
-            lam_ = np.abs(lam)  # This algorithm is only valid for positive lam
-            y = rng.poisson(theta, size=dist_size)
-            x = y.copy()
-            higher_than_zero = y > 0
-            while np.any(higher_than_zero[idxs_mask]):
-                y = rng.poisson(lam_ * y)
-                x[higher_than_zero] = x[higher_than_zero] + y[higher_than_zero]
-                higher_than_zero = y > 0
-            return x
-
     generalized_poisson = GeneralizedPoissonRV()
 
     class GeneralizedPoisson(pm.distributions.Discrete):