diff --git a/README.md b/README.md
index e2bb7b3..87241fe 100644
--- a/README.md
+++ b/README.md
@@ -23,4 +23,7 @@ git clone git@github.com:LSSTDESC/BPD.git
 cd BPD
 pip install -e .
 pip install -e ".[dev]"
+
+# Might be necessary
+conda install -c nvidia cuda-nvcc
 ```
diff --git a/bpd/draw.py b/bpd/draw.py
index f0fdc87..7a4961d 100644
--- a/bpd/draw.py
+++ b/bpd/draw.py
@@ -17,6 +17,8 @@ def draw_gaussian(
     fft_size: int,  # rule of thumb: at least 4 times `slen`
     psf_hlr: float = 0.7,
     pixel_scale: float = 0.2,
+    dx=0.0,  # additional offset from true centroid
+    dy=0.0,
 ):
     gsparams = GSParams(minimum_fft_size=fft_size, maximum_fft_size=fft_size)
 
@@ -27,7 +29,9 @@ def draw_gaussian(
 
     psf = xgalsim.Gaussian(flux=1.0, half_light_radius=psf_hlr)
     gal_conv = xgalsim.Convolve([gal, psf]).withGSParams(gsparams)
-    image = gal_conv.drawImage(nx=slen, ny=slen, scale=pixel_scale, offset=(x, y))
+    image = gal_conv.drawImage(
+        nx=slen, ny=slen, scale=pixel_scale, offset=(x + dx, y + dy)
+    )
     return image.array
 
 
diff --git a/bpd/pipelines/image_samples.py b/bpd/pipelines/image_samples.py
index 56f3aae..5882424 100644
--- a/bpd/pipelines/image_samples.py
+++ b/bpd/pipelines/image_samples.py
@@ -51,21 +51,21 @@ def logprior(
     sigma_x: float = 0.5,  # pixels
     flux_bds: tuple = (-1.0, 9.0),
     hlr_bds: tuple = (0.01, 5.0),
-    all_free: bool = True,
+    free_flux_hlr: bool = True,
+    free_dxdy: bool = True,
 ) -> Array:
     prior = jnp.array(0.0)
 
-    if all_free:
+    if free_flux_hlr:
         f1, f2 = flux_bds
         prior += stats.uniform.logpdf(params["lf"], f1, f2 - f1)
 
         h1, h2 = hlr_bds
         prior += stats.uniform.logpdf(params["hlr"], h1, h2 - h1)
 
-        # NOTE: hard-coded assumption that galaxy is in center-pixel within odd-size image.
-        # sigma_x in units of pixels.
-        prior += stats.norm.logpdf(params["x"], loc=0.0, scale=sigma_x)
-        prior += stats.norm.logpdf(params["y"], loc=0.0, scale=sigma_x)
+    if free_dxdy:
+        prior += stats.norm.logpdf(params["dx"], loc=0.0, scale=sigma_x)
+        prior += stats.norm.logpdf(params["dy"], loc=0.0, scale=sigma_x)
 
     e1e2 = jnp.stack((params["e1"], params["e2"]), axis=-1)
     prior += jnp.log(ellip_prior_e1e2(e1e2, sigma=sigma_e))
diff --git a/experiments/exp2/run_inference_galaxy_images.py b/experiments/exp2/run_inference_galaxy_images.py
index c260a83..b731bdf 100755
--- a/experiments/exp2/run_inference_galaxy_images.py
+++ b/experiments/exp2/run_inference_galaxy_images.py
@@ -6,8 +6,9 @@
 
 import jax.numpy as jnp
 import typer
-from jax import jit, random, vmap
+from jax import Array, jit, random, vmap
 from jax._src.prng import PRNGKeyArray
+from jax.scipy import stats
 
 from bpd import DATA_DIR
 from bpd.chains import run_sampling_nuts, run_warmup_nuts
@@ -17,10 +18,35 @@
     get_target_images,
     get_true_params_from_galaxy_params,
     loglikelihood,
-    logprior,
     logtarget,
     sample_target_galaxy_params_simple,
 )
+from bpd.prior import ellip_prior_e1e2
+
+
+def logprior(
+    params: dict[str, Array],
+    *,
+    sigma_e: float,
+    sigma_x: float = 0.5,  # pixels
+    flux_bds: tuple = (-1.0, 9.0),
+    hlr_bds: tuple = (0.01, 5.0),
+) -> Array:
+    prior = jnp.array(0.0)
+
+    f1, f2 = flux_bds
+    prior += stats.uniform.logpdf(params["lf"], f1, f2 - f1)
+
+    h1, h2 = hlr_bds
+    prior += stats.uniform.logpdf(params["hlr"], h1, h2 - h1)
+
+    prior += stats.norm.logpdf(params["x"], loc=0.0, scale=sigma_x)
+    prior += stats.norm.logpdf(params["y"], loc=0.0, scale=sigma_x)
+
+    e1e2 = jnp.stack((params["e1"], params["e2"]), axis=-1)
+    prior += jnp.log(ellip_prior_e1e2(e1e2, sigma=sigma_e))
+
+    return prior
 
 
 def sample_prior(
diff --git a/experiments/exp3/get_image_interim_samples_fixed.py b/experiments/exp3/get_image_interim_samples_fixed.py
index e551172..6f68e3e 100755
--- a/experiments/exp3/get_image_interim_samples_fixed.py
+++ b/experiments/exp3/get_image_interim_samples_fixed.py
@@ -69,7 +69,9 @@ def main(
     extra_params = {"x": x, "y": y, **extra_params}
 
     # more setup
-    _logprior = partial(logprior, sigma_e=sigma_e_int, all_free=False)
+    _logprior = partial(
+        logprior, sigma_e=sigma_e_int, free_flux_hlr=False, free_dxdy=False
+    )
 
     # prepare pipelines
     gkeys = random.split(gkey, n_gals)
diff --git a/experiments/exp4/README.md b/experiments/exp4/README.md
new file mode 100644
index 0000000..2f85725
--- /dev/null
+++ b/experiments/exp4/README.md
@@ -0,0 +1,8 @@
+# Experiment 4 
+
+Same as experiment 3 but we let deviations from true centroid `(dx, dy)` be free parameters in 
+the fit.
+
+
+For now we assume that the true and interim prior on the deviation is the same, so it does not get
+accounted for in the shear inference.
diff --git a/experiments/exp4/figs/contours.pdf b/experiments/exp4/figs/contours.pdf
new file mode 100644
index 0000000..851bca1
Binary files /dev/null and b/experiments/exp4/figs/contours.pdf differ
diff --git a/experiments/exp4/figs/hists.pdf b/experiments/exp4/figs/hists.pdf
new file mode 100644
index 0000000..97726ff
Binary files /dev/null and b/experiments/exp4/figs/hists.pdf differ
diff --git a/experiments/exp4/figs/scatter_dxdy.pdf b/experiments/exp4/figs/scatter_dxdy.pdf
new file mode 100644
index 0000000..811e67f
Binary files /dev/null and b/experiments/exp4/figs/scatter_dxdy.pdf differ
diff --git a/experiments/exp4/figs/scatter_shapes.pdf b/experiments/exp4/figs/scatter_shapes.pdf
new file mode 100644
index 0000000..1698cb3
Binary files /dev/null and b/experiments/exp4/figs/scatter_shapes.pdf differ
diff --git a/experiments/exp4/figs/traces.pdf b/experiments/exp4/figs/traces.pdf
new file mode 100644
index 0000000..1a2c2bf
Binary files /dev/null and b/experiments/exp4/figs/traces.pdf differ
diff --git a/experiments/exp4/get_interim_samples.py b/experiments/exp4/get_interim_samples.py
new file mode 100755
index 0000000..ed98dea
--- /dev/null
+++ b/experiments/exp4/get_interim_samples.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+from functools import partial
+
+import jax.numpy as jnp
+import typer
+from jax import jit, random, vmap
+
+from bpd import DATA_DIR
+from bpd.draw import draw_gaussian
+from bpd.initialization import init_with_truth
+from bpd.io import save_dataset
+from bpd.pipelines.image_samples import (
+    get_target_images,
+    get_true_params_from_galaxy_params,
+    logprior,
+    pipeline_interim_samples_one_galaxy,
+    sample_target_galaxy_params_simple,
+)
+
+
+def main(
+    seed: int,
+    n_gals: int = 1000,  # technically, in this file it means 'noise realizations'
+    n_samples_per_gal: int = 100,
+    g1: float = 0.02,
+    g2: float = 0.0,
+    lf: float = 6.0,  # ~ SNR = 1000
+    hlr: float = 1.0,
+    shape_noise: float = 1e-4,
+    sigma_e_int: float = 4e-2,
+    slen: int = 53,
+    fft_size: int = 256,
+    background: float = 1.0,
+    initial_step_size: float = 1e-3,
+):
+    rng_key = random.key(seed)
+    pkey, nkey, gkey = random.split(rng_key, 3)
+
+    # directory structure
+    dirpath = DATA_DIR / "cache_chains" / f"exp4_{seed}"
+    if not dirpath.exists():
+        dirpath.mkdir(exist_ok=True)
+
+    # galaxy parameters from prior
+    pkeys = random.split(pkey, n_gals)
+    _get_galaxy_params = partial(
+        sample_target_galaxy_params_simple, g1=g1, g2=g2, shape_noise=shape_noise
+    )
+    galaxy_params = vmap(_get_galaxy_params)(pkeys)
+    assert galaxy_params["x"].shape == (n_gals,)
+    assert galaxy_params["e1"].shape == (n_gals,)
+    assert "lf" not in galaxy_params
+    extra_params = {"f": 10 ** jnp.full((n_gals,), lf), "hlr": jnp.full((n_gals,), hlr)}
+
+    # now get corresponding target images
+    draw_params = {**galaxy_params, **extra_params}
+    target_images = get_target_images(
+        nkey, draw_params, background=background, slen=slen
+    )
+    assert target_images.shape == (n_gals, slen, slen)
+
+    # interim samples are on 'sheared ellipticity'
+    true_params = vmap(get_true_params_from_galaxy_params)(galaxy_params)
+
+    # we pass in x,y as fixed parameters for drawing
+    # and initialize the function with deviations (dx, dy) = (0, 0)
+    x = true_params.pop("x")
+    y = true_params.pop("y")
+    true_params["dx"] = jnp.zeros_like(x)
+    true_params["dy"] = jnp.zeros_like(y)
+    extra_params = {"x": x, "y": y, **extra_params}
+
+    # more setup
+    _logprior = partial(
+        logprior, sigma_e=sigma_e_int, free_flux_hlr=False, free_dxdy=True
+    )
+
+    # prepare pipelines
+    gkeys = random.split(gkey, n_gals)
+    _draw_fnc = partial(draw_gaussian, slen=slen, fft_size=fft_size)
+    pipe = partial(
+        pipeline_interim_samples_one_galaxy,
+        initialization_fnc=init_with_truth,
+        draw_fnc=_draw_fnc,
+        logprior=_logprior,
+        n_samples=n_samples_per_gal,
+        initial_step_size=initial_step_size,
+        background=background,
+        free_flux=False,
+    )
+    vpipe = vmap(jit(pipe))
+
+    # compilation on single target image
+    _ = vpipe(
+        gkeys[0, None],
+        {k: v[0, None] for k, v in true_params.items()},
+        target_images[0, None],
+        {k: v[0, None] for k, v in extra_params.items()},
+    )
+
+    samples = vpipe(gkeys, true_params, target_images, extra_params)
+    e_post = jnp.stack([samples["e1"], samples["e2"]], axis=-1)
+    fpath = dirpath / f"e_post_{seed}.npz"
+
+    save_dataset(
+        {
+            "e_post": e_post,
+            "true_g": jnp.array([g1, g2]),
+            "dx": samples["dx"],
+            "dy": samples["dy"],
+            "sigma_e": shape_noise,
+            "sigma_e_int": sigma_e_int,
+            "e1": draw_params["e1"],
+            "e2": draw_params["e2"],
+        },
+        fpath,
+        overwrite=True,
+    )
+
+
+if __name__ == "__main__":
+    typer.run(main)
diff --git a/experiments/exp4/get_posteriors.sh b/experiments/exp4/get_posteriors.sh
new file mode 100755
index 0000000..fcfebf9
--- /dev/null
+++ b/experiments/exp4/get_posteriors.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+export CUDA_VISIBLE_DEVICES="0"
+export JAX_ENABLE_X64="True"
+SEED="43"
+ 
+./get_interim_samples.py $SEED
+../../scripts/get_shear_from_interim_samples.py $SEED exp4_$SEED "e_post_${SEED}.npz" --overwrite
diff --git a/experiments/exp4/make_figures.py b/experiments/exp4/make_figures.py
new file mode 100755
index 0000000..8aed6b7
--- /dev/null
+++ b/experiments/exp4/make_figures.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["JAX_PLATFORMS"] = "cpu"
+os.environ["JAX_ENABLE_X64"] = "True"
+
+
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+import typer
+from jax import Array
+from matplotlib.backends.backend_pdf import PdfPages
+
+from bpd import DATA_DIR
+from bpd.diagnostics import get_contour_plot
+from bpd.io import load_dataset
+
+
+def make_trace_plots(g_samples: Array) -> None:
+    """Make trace plots of g1, g2."""
+    fname = "figs/traces.pdf"
+    with PdfPages(fname) as pdf:
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 5))
+        g1 = g_samples[:, 0]
+        g2 = g_samples[:, 1]
+
+        ax1.plot(g1)
+        ax2.plot(g2)
+
+        pdf.savefig(fig)
+        plt.close(fig)
+
+
+def make_contour_plots(g_samples: Array, n_examples=10) -> None:
+    """Make figure of contour plot on g1, g2."""
+    fname = "figs/contours.pdf"
+    with PdfPages(fname) as pdf:
+        truth = {"g1": 0.02, "g2": 0.0}
+        g_dict = {"g1": g_samples[:, 0], "g2": g_samples[:, 1]}
+        fig = get_contour_plot([g_dict], ["post"], truth)
+        pdf.savefig(fig)
+        plt.close(fig)
+
+
+def make_scatter_shape_plots(e_post: Array, n_examples: int = 10) -> None:
+    """Show example scatter plots of interim posterior ellipticitites."""
+    # make two types, assuming gaussianity and one not assuming gaussianity.
+    fname = "figs/scatter_shapes.pdf"
+
+    n_gals, _, _ = e_post.shape
+
+    with PdfPages(fname) as pdf:
+        # individual
+        for _ in range(n_examples):
+            idx = np.random.choice(np.arange(0, n_gals))
+            e1, e2 = e_post[idx, :, 0], e_post[idx, :, 1]
+            fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+            ax.scatter(e1, e2, marker="x")
+            ax.set_title(f"Samples ellipticity index: {idx}")
+            ax.set_xlabel("e1", fontsize=14)
+            ax.set_ylabel("e2", fontsize=14)
+            pdf.savefig(fig)
+            plt.close(fig)
+
+        # clusters
+        n_clusters = 50
+        fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+        ax.set_xlabel("e1", fontsize=14)
+        ax.set_ylabel("e2", fontsize=14)
+        fig.suptitle(f"{n_clusters} galaxies plotted")
+        for _ in range(n_clusters):
+            idx = np.random.choice(np.arange(0, n_gals))
+            e1, e2 = e_post[idx, :, 0], e_post[idx, :, 1]
+            ax.scatter(e1, e2, marker="x")
+        pdf.savefig(fig)
+        plt.close(fig)
+
+
+def make_scatter_dxdy_plots(dx: Array, dy: Array, n_examples: int = 10) -> None:
+    """Show example scatter plots of interim posterior ellipticitites."""
+    # make two types, assuming gaussianity and one not assuming gaussianity.
+    fname = "figs/scatter_dxdy.pdf"
+
+    n_gals, _ = dx.shape
+
+    with PdfPages(fname) as pdf:
+        # individual
+        for _ in range(n_examples):
+            idx = np.random.choice(np.arange(0, n_gals))
+            dx1, dy1 = dx[idx, :], dy[idx, :]
+            fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+            ax.scatter(dx1, dy1, marker="x")
+            ax.set_title(f"Samples ellipticity index: {idx}")
+            ax.set_xlabel("dx", fontsize=14)
+            ax.set_ylabel("dy", fontsize=14)
+            pdf.savefig(fig)
+            plt.close(fig)
+
+        # clusters
+        n_clusters = 50
+        fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+        ax.set_xlabel("dx", fontsize=14)
+        ax.set_ylabel("dy", fontsize=14)
+        fig.suptitle(f"{n_clusters} galaxies plotted")
+        for _ in range(n_clusters):
+            idx = np.random.choice(np.arange(0, n_gals))
+            dx1, dy1 = dx[idx, :], dy[idx, :]
+            ax.scatter(dx1, dy1, marker="x")
+        pdf.savefig(fig)
+        plt.close(fig)
+
+
+def make_hists(g_samples: Array, e1_samples: Array) -> None:
+    """Make histograms of g1 along with std and expected std."""
+    fname = "figs/hists.pdf"
+    with PdfPages(fname) as pdf:
+        fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+
+        g1 = g_samples[:, 0]
+        e1_std = e1_samples.std()
+        g1_exp_std = e1_std / jnp.sqrt(len(e1_samples))
+
+        ax.hist(g1, bins=25, histtype="step")
+        ax.axvline(g1.mean(), linestyle="--", color="k")
+        ax.set_title(f"Std g1: {g1.std():.4g}; Expected g1 std: {g1_exp_std:.4g}")
+
+        pdf.savefig(fig)
+        plt.close(fig)
+
+
+def main(seed: int = 43):
+    # load data
+    pdir = DATA_DIR / "cache_chains" / f"exp4_{seed}"
+    e_post_dict = load_dataset(pdir / f"e_post_{seed}.npz")
+    e_post_samples = e_post_dict["e_post"]
+    g_samples = jnp.load(pdir / f"g_samples_{seed}_{seed}.npy")
+
+    e1_samples = e_post_dict["e1"]
+    dx = e_post_dict["dx"]
+    dy = e_post_dict["dy"]
+
+    # make plots
+    make_scatter_shape_plots(e_post_samples)
+    make_scatter_dxdy_plots(dx, dy)
+    make_trace_plots(g_samples)
+    make_contour_plots(g_samples)
+    make_hists(g_samples, e1_samples)
+
+
+if __name__ == "__main__":
+    typer.run(main)
diff --git a/notebooks/exp4_check1.ipynb b/notebooks/exp4_check1.ipynb
new file mode 100644
index 0000000..08096b2
--- /dev/null
+++ b/notebooks/exp4_check1.ipynb
@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4a213c34-b49c-41ce-86e2-442af71fff46",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/pscratch/sd/i/imendoza/miniconda3/envs/bpd_gpu3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
+    "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n",
+    "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n",
+    "\n",
+    "import jax.numpy as jnp\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import typer\n",
+    "from jax import Array\n",
+    "from matplotlib.backends.backend_pdf import PdfPages\n",
+    "\n",
+    "from bpd import DATA_DIR\n",
+    "from bpd.diagnostics import get_contour_plot\n",
+    "from bpd.io import load_dataset\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "edea5496-4787-4e10-bb0e-f0c1369b589c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "data_dict = load_dataset(\"/pscratch/sd/i/imendoza/data/cache_chains/exp4_42/e_post_42.npz\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "889c5a4c-4625-4919-80a0-6b231c0d42e5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['e_post', 'true_g', 'dx', 'dy', 'sigma_e', 'sigma_e_int', 'e1', 'e2'])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_dict.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2a50e56d-2151-469c-8cf9-158c20824e9f",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dx = data_dict['dx']\n",
+    "dy = data_dict['dy']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "09d935ac-795d-4fad-935b-7f6021341eed",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((1000, 100), (1000, 100))"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dx.shape, dy.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c6a91f9e-a7b9-4d68-b36b-69c820456cd8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7fc2ecf75c70>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGdCAYAAAAGx+eQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANrJJREFUeJzt3X9wFGWe+PFPhpCQGCYBIRnRoFCwsPw4QZDsAK7nmSLBlCtK1bK5rAssyqK4dygHC3cm5HQ9OHX39vRYf9x9JVbdKpqqU1eEeDnCjzOJASJRIZHSFQSECSfZZAIL5Md8vn/Mps1AJ0wymR89835VdQ3T/XTneTpD+jNPf56n41RVBQAAAD5s4a4AAABAJCJIAgAAMEGQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAAACYIkgAAAEzEh7sCVubxeOTUqVMydOhQiYuLC3d1AACAH1RVWltbZdSoUWKz9dxfRJAUgFOnTklmZma4qwEAAPrhxIkTcsMNN/S4nSApAEOHDhUR70m22+1hrg0AAPCH2+2WzMxM4zreE4KkAHTdYrPb7QRJAABYzNVSZUjcBgAAMEGQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAAACYIkgAAAEwQJAEAAJggSAIAADBBkAQAAGCCIAkAAMAEQRKsz+MRKSoSqaryvno84a4RACAK8IBbWF9xsciTT3qXLk88EbbqAACiAz1JsL7c3N7fAwDQDwRJsL6yst7fAwDQD9xug/UVF3tfc3O9AVLX+4Hg8XiP1/3YNr5bAEAsiFNVDXclrMrtdktqaqq0tLSI3W4Pd3UQDEVFvrlOhYXkOwGAxfl7/eYrMdAb8p0AIGYRJAG9Id8JAGIWOUlAb4KZ7wQAiGjkJAWAnCQAAKyHnCQAAIAAECQBAACYIEhCbOJ5bwCAqyBxG7GJ570BAK6CniTEJuY/QiygxxQICD1JiE1m8x/Nnh2eugDBQo8pEBCCJMQm5j9CLMjN9Q2Q6DEF+oQgCbHJZvv2GzU9SIhW9JgCASFIAoBoRY8pEBBm3A4AM24DAGA9zLgNAAAQAIIkAAAAEwRJAAAAJgiSAAAATBAkAQAAmCBIAgAAMEGQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAAACYIkgAAAEwQJAEAAJggSAIAADBBkAQAAGCCIAkAAMBE0IOkzZs3y0033SRDhgyRrKws2bdvX6/lS0tLZeLEiTJkyBCZOnWqbN++3We7qkpRUZFcd911kpSUJNnZ2fL555/7lGlqapKCggKx2+2SlpYmy5Ytk3PnzhnbL168KEuWLJGpU6dKfHy8LFiwYMDaCwAAokNQg6Q33nhDHnvsMdmwYYN89NFHcvPNN0tOTo6cOXPGtHxVVZXk5+fLsmXL5ODBg7JgwQJZsGCBHDp0yCjz9NNPy3PPPScvvvii1NTUyDXXXCM5OTly8eJFo0xBQYEcPnxYysvLZdu2bbJ3715Zvny5sb2zs1OSkpLkb/7mbyQ7Ozt4JwAAAFhWnKpqsA6elZUlt956q/zbv/2biIh4PB7JzMyUn//857Ju3boryi9atEjOnz8v27ZtM9Z973vfk2nTpsmLL74oqiqjRo2S1atXy9/93d+JiEhLS4tkZGRISUmJ/OhHP5KGhgaZNGmS7N+/X2bOnCkiImVlZXLXXXfJyZMnZdSoUT4/c8mSJdLc3Cxvv/12n9vndrslNTVVWlpaxG6393l/AAAQev5ev4PWk9TW1ia1tbU+PTU2m02ys7OlurradJ/q6uorenZycnKM8kePHhWXy+VTJjU1VbKysowy1dXVkpaWZgRIIiLZ2dlis9mkpqYmoDZdunRJ3G63zwIAAKJT0IKkb775Rjo7OyUjI8NnfUZGhrhcLtN9XC5Xr+W7Xq9WJj093Wd7fHy8DB8+vMef66+NGzdKamqqsWRmZgZ0PAAAELkY3dYH69evl5aWFmM5ceJEuKsEAACCJGhB0ogRI2TQoEHS2Njos76xsVEcDofpPg6Ho9fyXa9XK3N5YnhHR4c0NTX1+HP9lZiYKHa73WcBEIU8HpGiIpGqKu+rxxPuGgEIg6AFSQkJCTJjxgzZuXOnsc7j8cjOnTvF6XSa7uN0On3Ki4iUl5cb5ceMGSMOh8OnjNvtlpqaGqOM0+mU5uZmqa2tNcpUVFSIx+ORrKysAWsfgChWXCzy5JMic+Z4X4uLw10jAGEQH8yDP/bYY7J48WKZOXOmzJo1S37zm9/I+fPnZenSpSIi8pOf/ESuv/562bhxo4iI/O3f/q3cfvvt8qtf/Ury8vJk69atcuDAAXn55ZdFRCQuLk5WrVolv/zlL2X8+PEyZswYKSwslFGjRhlzHX33u9+V3NxcefDBB+XFF1+U9vZ2eeSRR+RHP/qRz8i2+vp6aWtrk6amJmltbZW6ujoREZk2bVowTwkAK8jN9QZH3d8DiDlBDZIWLVok//d//ydFRUXicrlk2rRpUlZWZiReHz9+XGy2bzuzZs+eLa+99po8/vjj8vd///cyfvx4efvtt2XKlClGmbVr18r58+dl+fLl0tzcLHPnzpWysjIZMmSIUeZ3v/udPPLII3LnnXeKzWaThQsXynPPPedTt7vuuku++uor4/306dNFxDtZJYAYV1Z25fvZs8NTFwBhE9R5kqId8yQBUcrj8d5iy831BkjFxSI2xrkA0cLf6zdBUgAIkgAAsJ6wTyYJAABgZQRJAAAAJgiSAAAATBAkAQAAmCBIAgAAMEGQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAAACYIkgAAAEwQJAEAAJggSAIAADBBkAQAAGCCIAmAtXg8IkVFIlVV3lePJ9w1AhCl4sNdAQDok+JikSef9C5dnngibNUBEL3oSQJgLbm5vb8HgAFCkATAWsrKen8PAAOE220ArKW42Puam+sNkLreA8AAi1NVDXclrMrtdktqaqq0tLSI3W4Pd3UAAIAf/L1+c7sNAADABEESAAQTUxYAlkVOEgAEE1MWAJZFTxIABBNTFgCWRZAEAMHElAWAZXG7DegPj8d7G6X7MHQb3zlggikLAMtiCoAAMAVADCsq8s0xKSwkzwQALIIpAIBgIs8EAKIeQRLQH+SZAEDUIycJ6A/yTAAg6pGTFABykgAAsB5ykgAAAAJAkAQAAGCCIAkAAMAEQRIAAIAJgiQAGGgej3fC0aoq76vHE+4aAegHpgAAgIFWXOydkb37rOzMyA5YDj1JADDQmJEdiAoESQAw0JiRHYgK3G4DAH95PN5bad1nWreZfNdkRnYgKjDjdgBiesZtfy8WQDQpKvLNMyosJNcIsCBm3EZwdSWmzpnjfeWbMmIBuUZATCFIQv9wsUAsItcIiCnkJKF/zC4Ws2eHpy5AqJBrBMQUcpICQE5SMTlJAADL8ff6TZAUgJgOkgAAsCgStwEAAAJAkAQAAGCCIAkAAMAEQRIAAIAJgiQAAAATBEkAAAAmQhIkbd68WW666SYZMmSIZGVlyb59+3otX1paKhMnTpQhQ4bI1KlTZfv27T7bVVWKiorkuuuuk6SkJMnOzpbPP//cp0xTU5MUFBSI3W6XtLQ0WbZsmZw7d86nzCeffCK33XabDBkyRDIzM+Xpp58emAYDAADLC3qQ9MYbb8hjjz0mGzZskI8++khuvvlmycnJkTNnzpiWr6qqkvz8fFm2bJkcPHhQFixYIAsWLJBDhw4ZZZ5++ml57rnn5MUXX5Samhq55pprJCcnRy5evGiUKSgokMOHD0t5ebls27ZN9u7dK8uXLze2u91umTdvntx4441SW1srzzzzjBQXF8vLL78cvJMBAACsQ4Ns1qxZunLlSuN9Z2enjho1Sjdu3Gha/oc//KHm5eX5rMvKytKf/exnqqrq8XjU4XDoM888Y2xvbm7WxMREff3111VVtb6+XkVE9+/fb5TZsWOHxsXF6ddff62qqr/97W912LBheunSJaPML37xC50wYYLfbWtpaVER0ZaWFr/3AQAA4eXv9TuoPUltbW1SW1sr2dnZxjqbzSbZ2dlSXV1tuk91dbVPeRGRnJwco/zRo0fF5XL5lElNTZWsrCyjTHV1taSlpcnMmTONMtnZ2WKz2aSmpsYo8/3vf18SEhJ8fs6RI0fkj3/8o2ndLl26JG6322cBAADRKahB0jfffCOdnZ2SkZHhsz4jI0NcLpfpPi6Xq9fyXa9XK5Oenu6zPT4+XoYPH+5TxuwY3X/G5TZu3CipqanGkpmZad5wAABgeYxu64P169dLS0uLsZw4cSLcVQIAAEES1CBpxIgRMmjQIGlsbPRZ39jYKA6Hw3Qfh8PRa/mu16uVuTwxvKOjQ5qamnzKmB2j+8+4XGJiotjtdp8FAABEp6AGSQkJCTJjxgzZuXOnsc7j8cjOnTvF6XSa7uN0On3Ki4iUl5cb5ceMGSMOh8OnjNvtlpqaGqOM0+mU5uZmqa2tNcpUVFSIx+ORrKwso8zevXulvb3d5+dMmDBBhg0bFmDLAQCA5QU7g3zr1q2amJioJSUlWl9fr8uXL9e0tDR1uVyqqnr//ffrunXrjPKVlZUaHx+vzz77rDY0NOiGDRt08ODB+umnnxplNm3apGlpafrOO+/oJ598ovfcc4+OGTNGL1y4YJTJzc3V6dOna01NjX7wwQc6fvx4zc/PN7Y3NzdrRkaG3n///Xro0CHdunWrJicn60svveR32xjdBsvq7FQtLFStrPS+dnaGu0YAEDL+Xr+DHiSpqj7//PM6evRoTUhI0FmzZumHH35obLv99tt18eLFPuXffPNN/c53vqMJCQk6efJkfe+993y2ezweLSws1IyMDE1MTNQ777xTjxw54lPm7Nmzmp+frykpKWq323Xp0qXa2trqU+bjjz/WuXPnamJiol5//fW6adOmPrWLIAmWVVioKvLtUlgY7hoBQMj4e/2OU1UNb1+WdbndbklNTZWWlhbyk2AtVVUic+Z8+76yUmT27PDVBwBCyN/rN6PbgFhUVtb7ewCAxIe7AgDCoLjY+5qb6w2Qut4DAAzcbgsAt9sAC/F4vMFg98DQRmc6EIu43QbECo9HpKjIm2dUVOR9jysVF4s8+aQ3F+vJJ+k9A3BVBEmA1XHx909ubu/vAeAyBEmA1XHx9w/J6gD6iMRtwOrMLv4M578SyeoA+ojE7QCQuI2IQEIyAPSJv9dvgqQAECQBAGA9jG4DAAAIAEESAACACYIkAAAAEwRJAAAAJgiSAAAATBAkAQAAmCBIAjAweIYcgChDkASEQiwEEDxDDkCUIUgCQmHDBt8AYsOGcNdo4PEMOQBRhiAJCIWTJ3t/Hw14gCyAKMMDbgH0rC/PheMBsgCiDEESEAo33ND7+0jVlWf05JPfrnviCfOyNtu322bPDnrVACDYuN0WaWIhwTcW/eM/ihQWilRWel//8R/DXSP/kGcEIIbRkxRp+vLNHdZh1V4WszwjK9UfAAJAT1Kk4Zs7IklxsW8PmNXzjOipBdAH9CRFGr65R5a+JC5HI6v2gPWEnloAfUCQFGkYIRRZuKhGl9xc398lPbUAehFDX4ktouub++zZ3ler9lpEy22NUN7+7O85G+hzHS2/OzPM5QSgD+hJQnBESw9MKG9/9vecDfS5jpbfnRl6agH0gUW7KRDxoiUBPZSJy/09ZwN9rqPld2cmWnpqAYQEfyEQHNFyWyOUF9X+nrOBPtfR8rsDgABxuw3BwW2NvuvvORvoc83vDgBERCROVTXclbAqt9stqamp0tLSIna7feB/QKwPP480/D4AICr4e/2mJymSRXMCrRXx+wCAmMLX4EgWzQm0VsTvAwBiCkFSJCOBNrLw+4hu0Tw/FIB+4XZbJIuVBFqr5PrEyu8jVnE7FcBlSNwOQNATt2NFUZHvhamwkIsTQq+qSmTOnG/fL1ki8v/+X2QG7AAC4u/1m//9CD9yfRAJLr99WlJCbyEQ4wiSEH7k+iASFBd7e4+6I2AHYho5SQg/cn0QCWw2kcxM33XBfFYfgIhHTlIAyEkCooxVBhEA0S7I/xf9vX4TJAWAIAmIMQRRQGgEeUAPidsAMNC6pgmYM8f7yq1hIDgiZEAPQRIA+CtC/nADUS9CBvSQuA0A/jL7w01iNzDwImRADzlJASAn6c/I00Cs4LMORAUSt0OAIOnPmDEbQCgQpGKAkLiN0CFPA0AokDiPECNIQuAiJMEOQJTjCxlCjMRtBC5CEuwARDkS560him6LkpMUAHKSACCEoujiG9UskKdK4nYIECQBAHCZqipv3liXysqI6/ELe+J2U1OTFBQUiN1ul7S0NFm2bJmcO3eu130uXrwoK1eulGuvvVZSUlJk4cKF0tjY6FPm+PHjkpeXJ8nJyZKeni5r1qyRjo4OnzK7d++WW265RRITE2XcuHFSUlLis33v3r1y9913y6hRoyQuLk7efvvtgWgyAACIojzVoAVJBQUFcvjwYSkvL5dt27bJ3r17Zfny5b3u8+ijj8q7774rpaWlsmfPHjl16pTcd999xvbOzk7Jy8uTtrY2qaqqkldffVVKSkqkqKjIKHP06FHJy8uTO+64Q+rq6mTVqlXywAMPyPvvv2+UOX/+vNx8882yefPmgW84AACxrLjYe4utstL7auU8VQ2C+vp6FRHdv3+/sW7Hjh0aFxenX3/9tek+zc3NOnjwYC0tLTXWNTQ0qIhodXW1qqpu375dbTabulwuo8wLL7ygdrtdL126pKqqa9eu1cmTJ/sce9GiRZqTk2P6c0VE33rrrX61s6WlRUVEW1pa+rV/1OrsVC0sVK2s9L52dkbGsQAAUP+v30HpSaqurpa0tDSZOXOmsS47O1tsNpvU1NSY7lNbWyvt7e2SnZ1trJs4caKMHj1aqqurjeNOnTpVMjIyjDI5OTnidrvl8OHDRpnux+gq03WMQFy6dEncbrfPAhMDOZcJ86IAAMIkKEGSy+WS9PR0n3Xx8fEyfPhwcblcPe6TkJAgaWlpPuszMjKMfVwul0+A1LW9a1tvZdxut1y4cKHfbRIR2bhxo6SmphpLZmZmQMeLWgM5lwnzogAAwqRPQdK6deskLi6u1+Wzzz4LVl3Dbv369dLS0mIsJ06cCHeVItNAJu1FUQIgAMBa+jSZ5OrVq2XJkiW9lhk7dqw4HA45c+aMz/qOjg5pamoSh8Nhup/D4ZC2tjZpbm726U1qbGw09nE4HLJv3z6f/bpGv3Uvc/mIuMbGRrHb7ZKUlHTVNvYmMTFREhMTAzpGTBjIySWZqBIAECZ9CpJGjhwpI0eOvGo5p9Mpzc3NUltbKzNmzBARkYqKCvF4PJKVlWW6z4wZM2Tw4MGyc+dOWbhwoYiIHDlyRI4fPy5Op9M47lNPPSVnzpwxbueVl5eL3W6XSZMmGWW2b9/uc+zy8nLjGAgBm+3bicMCnRtjII+FgcOkfgBiQbAyx3Nzc3X69OlaU1OjH3zwgY4fP17z8/ON7SdPntQJEyZoTU2NsW7FihU6evRoraio0AMHDqjT6VSn02ls7+jo0ClTpui8efO0rq5Oy8rKdOTIkbp+/XqjzJdffqnJycm6Zs0abWho0M2bN+ugQYO0rKzMKNPa2qoHDx7UgwcPqojor3/9az148KB+9dVXfWojo9sQswoLVUW+XQoLw10jAPCbv9fvoAVJZ8+e1fz8fE1JSVG73a5Lly7V1tZWY/vRo0dVRHTXrl3GugsXLujDDz+sw4YN0+TkZL333nv19OnTPsc9duyYzp8/X5OSknTEiBG6evVqbW9v9ymza9cunTZtmiYkJOjYsWN1y5YtV2wXkSuWxYsX96mNBEmIWZWVvkFSZWW4awQAfvP3+s1jSQLAY0kQVfpyC80Cz2YCgJ74e/3uU04SgCjWNSdV9+Cnp8CHhHoAMYCepADQk4SoYoGHUgLAQAj7A24BWAxzUgGAD4IkeHk83jyTqirvq8cT7hoh1ML9UEo+gwAiDLfbAhBVt9tIxEW48RkEECLcbkPf8Iw0XC7UPTt8BgFEGIIkeJGPgst1jXabM8f7Guzbb3wGAUQYpgCAF0O6cbncXN/bX8Hu2eEzGLl4DA1iFEESvHhGGi5n1rMTzM9GJH4GrRIcBLuefZlDC4giBEkAzNGzY53gINj1DHWvIhAhIvArEYCI0NWzM3u29zUSe1CCzSrJ5MGuJ/liiFEx+FcPAPwUjuCgP6MKg13PcM+hBYQJ8yQFIKrmSQJwpXDkJPVnviir5E4BEcLf6zdBUgAIkgAMOJ6hBwQdk0kCgBWR/wNEDEa3AUAkiYZRhdz+Q5TgdlsAuN0GACZ4Dh8iHLfbAADhYZWpE4CrIEgCAAws8qoQJchJAhB65KxEt2jIqwKEnKSAkJME9BM5KwDCiJwkAJGLnBUAFkCQBCD0yFkBYAHkJAEIPXJWAFgAOUkBICcJAADrIScJAAAgAARJAAAAJgiSAAAATBAkwVo8Hu8cO1VV3lePJ9w1AgBEKUa3wVqKi72TEHafiJBJCAEAQUBPEqyFSQgBL3pVEUx8vkSEniRYjdkkhLNnh6cuQDjRq4pg4vMlIvQkwWqKi73P+aqs9L4yCSFiFb2qCCY+XyJCTxKsxmb79tsMPUiIZfSqIpj4fIkIQRIAWBOPdkEw8fkSER5LEhAeSwIAgPXwWBIAAIAAECQBAACYIEgCAAAwQZAEAABggiAJQN8wE685zgsQdZgCAEDfMBOvuWg+Lx6Pt33dh4Pb+I6N6MenHNbFN/fwYCZecz2dl2j4nHYFgHPmeF9jdM4cxB6CJFgXf7jDw2wm3kgVygClp/MSDZ9TAmPEKG63wbpyc31vbfCHOzSsNBNvKG+B9XReouFzumPHle9j8BEViD0ESbAuni0UHlZ6fl4oA5SezgufU8CyCJJgXVbq0cC3QpkEHAkBSnGxiKrIyZPe96rec2ClxOf580V++Uvf90AMIEiCdVmpRwPfioRbYP3VnwDPZhOJixMpKfl2XVyctUa+RUKwCYQBD7gNAA+4BfqhqsqbxNylstI6F9yiIt/grrDQv2AnUtrc3148pgBAlOEBt4g80TAUGoGz0ui4y/V3lFektLm/I+26em1nz/a+EiCFHn8/w4LbbQidaJ5sD/6zci5Zf287RUqbo2GkXazi72dYECQhdPgDDRFr55L1N9iJlDaTW2Rd/P0MC4IkhA5/oGF1kRLs9Fek9Gih7/j7GRZBvbHc1NQkBQUFYrfbJS0tTZYtWybnzp3rdZ+LFy/KypUr5dprr5WUlBRZuHChNDY2+pQ5fvy45OXlSXJysqSnp8uaNWuko6PDp8zu3bvllltukcTERBk3bpyUdB9ZIiIbN26UW2+9VYYOHSrp6emyYMECOXLkyIC0Gz0oLvYmulZWel/5Aw2EFrlF1sXfz7AI6v+QgoICOXz4sJSXl8u2bdtk7969snz58l73efTRR+Xdd9+V0tJS2bNnj5w6dUruu+8+Y3tnZ6fk5eVJW1ubVFVVyauvviolJSVSVFRklDl69Kjk5eXJHXfcIXV1dbJq1Sp54IEH5P333zfK7NmzR1auXCkffvihlJeXS3t7u8ybN0/Onz8/8CcCXvyBhlWQJItIw9/P8NAgqa+vVxHR/fv3G+t27NihcXFx+vXXX5vu09zcrIMHD9bS0lJjXUNDg4qIVldXq6rq9u3b1WazqcvlMsq88MILarfb9dKlS6qqunbtWp08ebLPsRctWqQ5OTk91vfMmTMqIrpnzx6/29jS0qIioi0tLX7vg37q7FQtLFStrPS+dnaGu0aIZoWFqt5pH71LYWG4awRgAPl7/Q5aKFpdXS1paWkyc+ZMY112drbYbDapqakx3ae2tlba29slOzvbWDdx4kQZPXq0VFdXG8edOnWqZGRkGGVycnLE7XbL4cOHjTLdj9FVpusYZlpaWkREZPjw4T2WuXTpkrjdbp8FIRINDwmFdfBAVwASxNttLpdL0tPTfdbFx8fL8OHDxeVy9bhPQkKCpKWl+azPyMgw9nG5XD4BUtf2rm29lXG73XLhwoUrfq7H45FVq1bJnDlzZMqUKT22aePGjZKammosmZmZPZbFAOOihVCKlHmNAIRVn4OkdevWSVxcXK/LZ599Foy6Bs3KlSvl0KFDsnXr1l7LrV+/XlpaWozlxIkTIaohuGghpEiSBSD9mAJg9erVsmTJkl7LjB07VhwOh5w5c8ZnfUdHhzQ1NYnD4TDdz+FwSFtbmzQ3N/v0JjU2Nhr7OBwO2bdvn89+XaPfupe5fERcY2Oj2O12SUpK8ln/yCOPGEnlN9xwQ6/tSkxMlMTExF7LIEgYuoxQsvpQfwADos9B0siRI2XkyJFXLed0OqW5uVlqa2tlxowZIiJSUVEhHo9HsrKyTPeZMWOGDB48WHbu3CkLFy4UEZEjR47I8ePHxel0Gsd96qmn5MyZM8btvPLycrHb7TJp0iSjzPbt232OXV5ebhxDRERV5ec//7m89dZbsnv3bhkzZkwfzwRCiotWbOAZYQAiSTCzx3Nzc3X69OlaU1OjH3zwgY4fP17z8/ON7SdPntQJEyZoTU2NsW7FihU6evRoraio0AMHDqjT6VSn02ls7+jo0ClTpui8efO0rq5Oy8rKdOTIkbp+/XqjzJdffqnJycm6Zs0abWho0M2bN+ugQYO0rKzMKPPQQw9pamqq7t69W0+fPm0sf/rTn/xuH6PbgAHGqDIAIeDv9TuoQdLZs2c1Pz9fU1JS1G6369KlS7W1tdXYfvToURUR3bVrl7HuwoUL+vDDD+uwYcM0OTlZ7733Xj19+rTPcY8dO6bz58/XpKQkHTFihK5evVrb29t9yuzatUunTZumCQkJOnbsWN2yZYvPdhExXS4v1xuCJGCAVVb6BkmVleGuke/0E48/7l2YiqL/mM4DEcDf63ecqmqYOrEsz+12S2pqqrS0tIjdbg93dQDrKyryfT5VYWH4H+J5eZ26C2f9rHprMhJ/x4g5/l6/LfA/CjGLWY9jTySOKuttuolwTkVh1bnDmM4DFkKQhMhl1YsA+m+gH70wEIF2b9NNhHMqCqsGG0znAQvp8+g2IGRyc3275a1yEUDk6Aq0u3+O+nprp/v0Ezt2eP89f374p6Kw6lPhmc4DFkKQhMhl1YsAIsdABNo9TT8R7s+iVYMNpvOAhRAkIXJZ9SKA/glGInJ/A20rJEUTbABBx+i2ADC6LYZZ4SIaSfw5X8EY9dTf3xMjsICoxug2IJhIKu8bf85XMBKR+5sIbtWk6EjEKFVYGEES0B+xehHt7wXPn/MVSaOeIqkuVscXClgYOUlAf8RqUnl/R4v5c74iKQetL3Xh1mvvGKUKCyNIAvojki7oodTfC54/5yuSEpH7UpeBmGYgmsXqFwpEBYIkoD8i6YIeSv294EXz+aKnpHex+oUCUYEgCYD/uOBdiZ6S3kVzgIyoxxQAAWAKAADkJAHW4+/1myApAARJAICIRyB/BX+v39xuAwAgmjG4oN9iO5QEACDaxeq8bgOAIAkAgGjG5Kj9xu02AACiGaNS+43E7QCQuA0AgPXwgFsAAIAAECQBAACYIEgCetLfJ94DsCb+z+MyJG4DPWFukcjGBHkYaPyfx2X4iwL0hLlFIlvXBW3OHO8rI3YQKP7P4zIESUBPmFsksnFBw0Dj/zwuw+02oCfMLRLZzC5oPGUefdX9tq2qyOOPi8yfz/95iAjzJAWEeZKAMCInCQOhqMg3B6mwkDykGODv9ZsgKQAESQBgcVVV3ry2LpWV9EjGACaTBADgashDQi/ISQIAxC5yD9ELbrcFgNttAABYD7fbAAAAAkCQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAQTB6Pd1bnqirvq8cT7hoB8BPzJAFAMBUXex970f3RFzz2ArAEepIAIJhyc3t/DyBiESQBQDDx2AvAsrjdBgDBxGMvAMvisSQB4LEkAABYD48lAQAACABBEgAAgAmCJCDWMG8PAPiFxG0g1jBvDwD4hZ4koLtQ97KEo1eHeXsAwC/0JAHdhbqXJRy9Ombz9syeHdyfCQAWRE8S0F2oe1nC0atTXCxSWChSWel9Zd4eADBFTxLQXah7WcLRq2OzfdtbRQ8SAPSIIAnoLtSzIzMbMwBELGbcDgAzbgMAYD3MuA0AABCAoAZJTU1NUlBQIHa7XdLS0mTZsmVy7ty5Xve5ePGirFy5Uq699lpJSUmRhQsXSmNjo0+Z48ePS15eniQnJ0t6erqsWbNGOjo6fMrs3r1bbrnlFklMTJRx48ZJSUmJz/YXXnhB/uIv/kLsdrvY7XZxOp2yY8eOAWk3AACwvqAGSQUFBXL48GEpLy+Xbdu2yd69e2X58uW97vPoo4/Ku+++K6WlpbJnzx45deqU3Hfffcb2zs5OycvLk7a2NqmqqpJXX31VSkpKpKioyChz9OhRycvLkzvuuEPq6upk1apV8sADD8j7779vlLnhhhtk06ZNUltbKwcOHJC/+qu/knvuuUcOHz488CcCAABYjwZJfX29ioju37/fWLdjxw6Ni4vTr7/+2nSf5uZmHTx4sJaWlhrrGhoaVES0urpaVVW3b9+uNptNXS6XUeaFF15Qu92uly5dUlXVtWvX6uTJk32OvWjRIs3Jyem1zsOGDdP/+I//8LuNLS0tKiLa0tLi9z4AACC8/L1+B60nqbq6WtLS0mTmzJnGuuzsbLHZbFJTU2O6T21trbS3t0t2draxbuLEiTJ69Giprq42jjt16lTJyMgwyuTk5Ijb7TZ6gaqrq32O0VWm6xiX6+zslK1bt8r58+fF6XT22KZLly6J2+32WQAAQHQKWpDkcrkkPT3dZ118fLwMHz5cXC5Xj/skJCRIWlqaz/qMjAxjH5fL5RMgdW3v2tZbGbfbLRcuXDDWffrpp5KSkiKJiYmyYsUKeeutt2TSpEk9tmnjxo2SmppqLJmZmb2cAQw4HswKAAihPgdJ69atk7i4uF6Xzz77LBh1HXATJkyQuro6qampkYceekgWL14s9fX1PZZfv369tLS0GMuJEydCWFsYj/CYM8f7ypxC0YuAGEAE6PNkkqtXr5YlS5b0Wmbs2LHicDjkzJkzPus7OjqkqalJHA6H6X4Oh0Pa2tqkubnZpzepsbHR2MfhcMi+fft89usa/da9zOUj4hobG8Vut0tSUpKxLiEhQcaNGyciIjNmzJD9+/fLv/7rv8pLL71kWr/ExERJTEzste0Iotxc32ec8WDW6BWOZ9oBwGX63JM0cuRImThxYq9LQkKCOJ1OaW5ultraWmPfiooK8Xg8kpWVZXrsGTNmyODBg2Xnzp3GuiNHjsjx48eNXCGn0ymffvqpTwBWXl4udrvduFXmdDp9jtFVprd8IxERj8cjly5d6tsJQeiYPcIjUtETEphwPNMOAC4XzOzx3NxcnT59utbU1OgHH3yg48eP1/z8fGP7yZMndcKECVpTU2OsW7FihY4ePVorKir0wIED6nQ61el0Gts7Ojp0ypQpOm/ePK2rq9OysjIdOXKkrl+/3ijz5ZdfanJysq5Zs0YbGhp08+bNOmjQIC0rKzPKrFu3Tvfs2aNHjx7VTz75RNetW6dxcXH63//93363j9FtIdbZqVpYqFpZ6X3t7Ax3jXpWWKgq8u1SWBjuGlkL5w9AEPl7/Q5qkHT27FnNz8/XlJQUtdvtunTpUm1tbTW2Hz16VEVEd+3aZay7cOGCPvzwwzps2DBNTk7We++9V0+fPu1z3GPHjun8+fM1KSlJR4wYoatXr9b29nafMrt27dJp06ZpQkKCjh07Vrds2eKz/ac//aneeOONmpCQoCNHjtQ777yzTwGSaoiDJCsFCPD+nrpf5Csrw10ja+HzDiCI/L1+8+y2AIT02W1FRb75GYWF5GhEMn5fABCxeHZbtCFHw1qKi72BUWWl97W3kXjkLwFAROrz6DaEiVnS8uzZ4akLrs5m+7bn6Gq/J0ZyAUBEIkiyiq6eiNxcb4DEHEHRg6kNACAiESRZRV96JmAt9BICQEQiSALCjV5CRCOPx/tZ7v65tpEGC2thdFsAQjq6DQCshBGeiGCMbgMAhA8jchEFCJIAAAPPSo8RAnpAThIAYOCRa4coQE5SAMhJAgDAeshJAgAACABBEgAAgAmCJCCceG4bAEQsEreBcOK5bQAQsehJAsKJuWQAIGIRJAHhxFwyABCxuN0GhBNzyQBAxGKepAAwTxIAANbDPEkAcDlGEwLoA263AYgdjCYE0Af0JAGIHYwmBNAHBEkAYgejCQH0AbfbAMQORhMC6ANGtwWA0W0AAFgPo9sAAAACQJAEAABggiAJAADABEESAACACYIkAAAAEwRJAAAAJgiSACDS8cw5ICwIkgAg0nU9c27OHO9rXybBJMAC+o0gCQAiXSDPnAskwAJiHEESAES6QJ45x0N9gX7j2W0AEOmKi0VURU6e9L5X9d42s/nxPdcswJo9e8CrCEQjgiQAiHQ2m0hcnEhJybfr4uJEnnji6vvyUF+g33jAbQB4wC2AkKmq8uYVdamspEcI6CcecAsA0SSQvCQA/cLtNgCwAm6bASHH7bYAcLsNAADr4XYbAABAAAiSAAAATBAkAQAAmCBIAgAAMEGQBAAAYIIgCQAAwARBEgAAgAmCJAAAABMESQAAACYIkgAAAEwQJAEAAJggSAIAADARH+4KWFnXs4HdbneYawIAAPzVdd3uuo73hCApAK2trSIikpmZGeaaAACAvmptbZXU1NQet8fp1cIo9Mjj8cipU6dk6NChEhcXF+7q9MrtdktmZqacOHFC7HZ7uKsTVLQ1OsVKW2OlnSK0NVpZoa2qKq2trTJq1Cix2XrOPKInKQA2m01uuOGGcFejT+x2e8R+aAcabY1OsdLWWGmnCG2NVpHe1t56kLqQuA0AAGCCIAkAAMAEQVKMSExMlA0bNkhiYmK4qxJ0tDU6xUpbY6WdIrQ1WkVTW0ncBgAAMEFPEgAAgAmCJAAAABMESQAAACYIkgAAAEwQJFlEU1OTFBQUiN1ul7S0NFm2bJmcO3eu130uXrwoK1eulGuvvVZSUlJk4cKF0tjY6FPm+PHjkpeXJ8nJyZKeni5r1qyRjo4OnzK7d++WW265RRITE2XcuHFSUlLis33jxo1y6623ytChQyU9PV0WLFggR44cicq27t27V+6++24ZNWqUxMXFydtvv92ntm3evFluuukmGTJkiGRlZcm+fft6LV9aWioTJ06UIUOGyNSpU2X79u0+21VVioqK5LrrrpOkpCTJzs6Wzz//3KeMP+fzk08+kdtuu02GDBkimZmZ8vTTT/epXVZo58WLF2XJkiUydepUiY+PlwULFgTUxkhu6+7du+Wee+6R6667Tq655hqZNm2a/O53v4vKth45ckTuuOMOycjIkCFDhsjYsWPl8ccfl/b29qhra3dffPGFDB06VNLS0gJqp0hktvXYsWMSFxd3xfLhhx8G3N4+UVhCbm6u3nzzzfrhhx/q//7v/+q4ceM0Pz+/131WrFihmZmZunPnTj1w4IB+73vf09mzZxvbOzo6dMqUKZqdna0HDx7U7du364gRI3T9+vVGmS+//FKTk5P1scce0/r6en3++ed10KBBWlZWZpTJycnRLVu26KFDh7Surk7vuusuHT16tJ47dy7q2rp9+3b9h3/4B/2v//ovFRF96623/G7X1q1bNSEhQV955RU9fPiwPvjgg5qWlqaNjY2m5SsrK3XQoEH69NNPa319vT7++OM6ePBg/fTTT40ymzZt0tTUVH377bf1448/1h/84Ac6ZswYvXDhgt/ns6WlRTMyMrSgoEAPHTqkr7/+uiYlJelLL73kd9us0M5z587pihUr9OWXX9acnBy95557+tU+K7T1qaee0scff1wrKyv1iy++0N/85jdqs9n03Xffjbq2/uEPf9BXXnlF6+rq9NixY/rOO+9oenq6z//taGlrl7a2Np05c6bOnz9fU1NT+93OSG7r0aNHVUT0f/7nf/T06dPG0tbWFlB7+4ogyQLq6+tVRHT//v3Guh07dmhcXJx+/fXXpvs0Nzfr4MGDtbS01FjX0NCgIqLV1dWq6r3g22w2dblcRpkXXnhB7Xa7Xrp0SVVV165dq5MnT/Y59qJFizQnJ6fH+p45c0ZFRPfs2RPVbe1rkDRr1ixduXKl8b6zs1NHjRqlGzduNC3/wx/+UPPy8nzWZWVl6c9+9jNVVfV4POpwOPSZZ54xtjc3N2tiYqK+/vrrqurf+fztb3+rw4YNM86DquovfvELnTBhgt9ts0I7u1u8ePGABElWaGuXu+66S5cuXdr3Rv6Zldr66KOP6ty5c/veyD+L9LauXbtWf/zjH+uWLVsCDpIita1dQdLBgwcDal+guN1mAdXV1ZKWliYzZ8401mVnZ4vNZpOamhrTfWpra6W9vV2ys7ONdRMnTpTRo0dLdXW1cdypU6dKRkaGUSYnJ0fcbrccPnzYKNP9GF1luo5hpqWlRUREhg8f3seWWq+t/mpra5Pa2lqf49tsNsnOzu7x+Ferz9GjR8XlcvmUSU1NlaysLJ92X+18VldXy/e//31JSEjw+TlHjhyRP/7xj1HTzoFmtba2tLT06/+kiLXa+sUXX0hZWZncfvvtUdnWiooKKS0tlc2bN/erfVZqq4jID37wA0lPT5e5c+fK73//+8Aa3A8ESRbgcrkkPT3dZ118fLwMHz5cXC5Xj/skJCRccb86IyPD2MflcvkEDV3bu7b1VsbtdsuFCxeu+Lkej0dWrVolc+bMkSlTpvjfyG71tkpb++Kbb76Rzs5O0+P31q7eyne9Xq3M1c6nP+fGX5HczoFmpba++eabsn//flm6dKmfrfNlhbbOnj1bhgwZIuPHj5fbbrtNnnjiiT620iuS23r27FlZsmSJlJSUDMiDYyO5rSkpKfKrX/1KSktL5b333pO5c+fKggULQh4oESSF0bp160wT07ovn332Wbir2ScrV66UQ4cOydatW33WR2NbASvYtWuXLF26VP793/9dJk+eHO7qBM0bb7whH330kbz22mvy3nvvybPPPhvuKg24Bx98UP76r/9avv/974e7KkE3YsQIeeyxxyQrK0tuvfVW2bRpk/z4xz+WZ555JqT1iA/pT4OP1atXy5IlS3otM3bsWHE4HHLmzBmf9R0dHdLU1CQOh8N0P4fDIW1tbdLc3OzTw9LY2Gjs43A4rhjF0DUirHuZy0eJNTY2it1ul6SkJJ/1jzzyiGzbtk327t0rN9xwQ1S3ta9GjBghgwYNMj1+b+3qrXzXa2Njo1x33XU+ZaZNm2aUudr57OnndP8Z/orkdg40K7R1z549cvfdd8u//Mu/yE9+8pO+N/LPrNDWzMxMERGZNGmSdHZ2yvLly2X16tUyaNCgqGlrRUWF/P73vzcCQFUVj8cj8fHx8vLLL8tPf/rTqGmrmaysLCkvL/evcQOEnqQwGjlypEycOLHXJSEhQZxOpzQ3N0ttba2xb0VFhXg8HsnKyjI99owZM2Tw4MGyc+dOY92RI0fk+PHj4nQ6RUTE6XTKp59+6vNhLS8vF7vdLpMmTTLKdD9GV5muY4h4/6M+8sgj8tZbb0lFRYWMGTMmatvaXwkJCTJjxgyf43s8Htm5c2ePx79afcaMGSMOh8OnjNvtlpqaGp92X+18Op1O2bt3r8+Q6fLycpkwYYIMGzYsato50CK9rbt375a8vDz553/+Z1m+fHlUt/VyHo9H2tvbxePxRFVbq6urpa6uzlieeOIJGTp0qNTV1cm9994bVW01U1dX5xN4hURY08bht9zcXJ0+fbrW1NToBx98oOPHj/cZLnny5EmdMGGC1tTUGOtWrFiho0eP1oqKCj1w4IA6nU51Op3G9q5h8fPmzdO6ujotKyvTkSNHmg6LX7NmjTY0NOjmzZuvGBb/0EMPaWpqqu7evdtnqOaf/vSnqGtra2urHjx4UA8ePKgior/+9a/14MGD+tVXX121XVu3btXExEQtKSnR+vp6Xb58uaalpRkj7u6//35dt26dUb6yslLj4+P12Wef1YaGBt2wYYPpUNu0tDR955139JNPPtF77rnHdKhtb+ezublZMzIy9P7779dDhw7p1q1bNTk5OaApACKxnaqqhw8f1oMHD+rdd9+tf/mXf2n8LvsrUttaUVGhycnJun79ep//k2fPno26tv7nf/6nvvHGG1pfX69/+MMf9I033tBRo0ZpQUFB1LX1cgMxui1S21pSUqKvvfaaNjQ0aENDgz711FNqs9n0lVdeCai9fUWQZBFnz57V/Px8TUlJUbvdrkuXLtXW1lZje9dwyV27dhnrLly4oA8//LAOGzZMk5OT9d5779XTp0/7HPfYsWM6f/58TUpK0hEjRujq1au1vb3dp8yuXbt02rRpmpCQoGPHjtUtW7b4bBcR0+XyctHQ1l27dpm2dfHixX617fnnn9fRo0drQkKCzpo1Sz/88ENj2+23337Fcd588039zne+owkJCTp58mR97733fLZ7PB4tLCzUjIwMTUxM1DvvvFOPHDnSp/Opqvrxxx/r3LlzNTExUa+//nrdtGmTX+2xWjtvvPFG099ftLV18eLFpu28/fbbo66tW7du1VtuuUVTUlL0mmuu0UmTJuk//dM/+VyQo6WtlxuIIClS21pSUqLf/e53NTk5We12u86aNctnmpdQiVNVDV2/FQAAgDWQkwQAAGCCIAkAAMAEQRIAAIAJgiQAAAATBEkAAAAmCJIAAABMECQBAACYIEgCAAAwQZAEAABggiAJAADABEESAACACYIkAAAAE/8f/5g+jFW2FlkAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(dx[3, :], dy[3, :], marker='x', color='r', s=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21fe7d36-3f21-419c-a609-3c387fa70dd4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bpd_gpu3",
+   "language": "python",
+   "name": "bpd_gpu3"
+  },
+  "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.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/flux-hlr-prior.ipynb b/notebooks/flux-hlr-prior.ipynb
new file mode 100644
index 0000000..9eeedf5
--- /dev/null
+++ b/notebooks/flux-hlr-prior.ipynb
@@ -0,0 +1,203 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
+    "os.environ[\"JAX_PLATFORMS\"] = \"cpu\"\n",
+    "os.environ[\"JAX_ENABLE_X64\"] = \"True\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax\n",
+    "import jax.numpy as jnp\n",
+    "import jax.scipy as jsp\n",
+    "from jax import random\n",
+    "\n",
+    "import matplotlib.pyplot as plt "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_log_hlr_flux = jnp.array([-0.72972787,  0.67149507]) # log pixels, log inst flux\n",
+    "# mu =jnp.array([0.5,  2.0])\n",
+    "inv_cov_hlrFlux = jnp.array([[ 3.26319582, -1.15157345],\n",
+    "       [-1.15157345,  1.73425812]])\n",
+    "cov = jnp.linalg.inv(inv_cov_hlrFlux)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Array([[0.40023474, 0.26576188],\n",
+       "       [0.26576188, 0.75308532]], dtype=float64)"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cov"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "k = random.key(42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "samples = jax.random.multivariate_normal(k, mean=mu, cov=cov, shape=(10000,))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7f713c3ed000>"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(samples[:, 0], samples[:, 1], s=3, marker='o')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Log-HLR')"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(samples[:, 0])\n",
+    "plt.xlabel(\"Log-HLR\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, 'Log-Flux')"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(samples[:, 1])\n",
+    "plt.xlabel(\"Log-Flux\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bpd_gpu2",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pyproject.toml b/pyproject.toml
index 6223e86..0387b97 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,7 +22,7 @@ dependencies = [
 
 
 [project.optional-dependencies]
-dev = ["pytest", "typer", "ruff", "ChainConsumer", "ipython"]
+dev = ["pytest", "typer", "ruff", "ChainConsumer", "ipython", "ipykernel"]
 
 
 [project.urls]