diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6f1eb4b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+*.pickle
+Untitled*
+.ipynb_checkpoints
+*.DS_Store
+
+utils/.*
diff --git a/basic_xcheck.ipynb b/basic_xcheck.ipynb
new file mode 100644
index 0000000..e8e97de
--- /dev/null
+++ b/basic_xcheck.ipynb
@@ -0,0 +1,356 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "import phasespace\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def beta_l(q2, m):\n",
+    "    return ztf.sqrt(1-(4*ztf.square(m))/(q2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def spatial_sp(p1, p2):\n",
+    "    \n",
+    "    val=p1[0]*p2[0]+p1[1]*p2[1]+p1[2]*p2[2]\n",
+    "    \n",
+    "    return val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sp(p1, p2):\n",
+    "    \n",
+    "    val0 = p1[3]*p2[3]\n",
+    "    \n",
+    "    val = spatial_sp(p1, p2)\n",
+    "    \n",
+    "    sp = val0 - val\n",
+    "    \n",
+    "    return sp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_costheta_l(p1, p2):  \n",
+    "    \n",
+    "    num = spatial_sp(p1, p2)\n",
+    "    \n",
+    "    den1= ztf.sqrt(spatial_sp(p1, p1))\n",
+    "    den2= ztf.sqrt(spatial_sp(p2, p2))\n",
+    "    \n",
+    "    costheta_l = num/(den1*den2)\n",
+    "    \n",
+    "    return costheta_l"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from phasespace import Particle\n",
+    "mZ = 80000.00\n",
+    "mmu = 105.3\n",
+    "\n",
+    "\n",
+    "el1 = Particle('l1', mmu)\n",
+    "el2 = Particle('l2', mmu)\n",
+    "Z = Particle('Z', mZ).set_children(el1, el2)\n",
+    "\n",
+    "#weights, particles = B.generate(n_events=10000)\n",
+    "weights_np, particles_np = Z.generate(n_events=10000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "l1_X=particles_np['l1'][:,0];\n",
+    "l1_Y=particles_np['l1'][:,1];\n",
+    "l1_Z=particles_np['l1'][:,2];\n",
+    "l1_E=particles_np['l1'][:,3];\n",
+    "\n",
+    "l2_X=particles_np['l2'][:,0];\n",
+    "l2_Y=particles_np['l2'][:,1];\n",
+    "l2_Z=particles_np['l2'][:,2];\n",
+    "l2_E=particles_np['l2'][:,3];\n",
+    "\n",
+    "plt.hist(l1_X,bins=40, density=True);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 0.0, 0.0, 80000.0)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "((l1_X[:]+l2_X[:]).mean(), (l1_Y[:]+l2_Y[:]).mean(), (l1_Z[:]+l2_Z[:]).mean(), (l1_E[:]+l2_E[:]).mean())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "import zfit\n",
+    "\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GaussianSampleAndWeights():\n",
+    "\n",
+    "        def __call__(self, n_to_produce, limits, dtype):\n",
+    "            \n",
+    "            n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n",
+    "\n",
+    "            weights, phase_space_sample = Z.generate_tensor(n_events=n_to_produce) #check order \n",
+    "            \n",
+    "            phase_space_sample_tensor = tf.concat([phase_space_sample[\"l1\"],phase_space_sample[\"l2\"]], axis=1)\n",
+    "            \n",
+    "            weights_max = None\n",
+    "            \n",
+    "            thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n",
+    "            \n",
+    "            return phase_space_sample_tensor, thresholds, weights, weights_max, n_to_produce\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    #_PARAMS = ['ml']\n",
+    "    _PARAMS = []\n",
+    "    _N_OBS = 8\n",
+    "\n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        #ml = self.params['ml']\n",
+    "        \n",
+    "        p1x, p1y, p1z, p1E, p2x, p2y, p2z, p2E =x.unstack_x()\n",
+    "        \n",
+    "        p1 = [p1x, p1y, p1z, p1E]\n",
+    "        p2 = [p2x, p2y, p2z, p2E]\n",
+    "        z = [0., 0., 1.]\n",
+    "        \n",
+    "        costheta_l= get_costheta_l(p1, z)\n",
+    "        #q2 = sp(p1+p2,p1+p2)\n",
+    "\n",
+    "        pdf = (1+costheta_l+ztf.square(costheta_l))#*beta_l(q2, 0.)\n",
+    "        \n",
+    "        return pdf\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#m_lepton = zfit.Parameter('ml', mmu)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "upper_vec=np.sqrt(np.square(mZ)/4-np.square(mmu))\n",
+    "lower_vec=-np.sqrt(np.square(mZ)/4-np.square(mmu))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower = ((lower_vec, lower_vec,  lower_vec,    0.,  lower_vec,  lower_vec,  lower_vec,   0.,  ),)\n",
+    "upper = ((upper_vec, upper_vec,  upper_vec, mZ/2,   upper_vec,  upper_vec,  upper_vec, mZ/2,  ),)\n",
+    "\n",
+    "obs = zfit.Space([\"p1x\",\"p1y\",\"p1z\",\"p1E\", \"p2x\",\"p2y\", \"p2z\",\"p2E\"], limits=(lower,upper))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs)\n",
+    "#pdf = dGamma(obs=obs, ml = m_lepton)\n",
+    "pdf._sample_and_weights=GaussianSampleAndWeights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = pdf.create_sampler(n=100000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n",
+    "a=sampler.to_pandas()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.hist(a['p1z']/(mZ/2),bins=40);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_0_momenta_map_mu.ipynb b/example_0_momenta_map_mu.ipynb
new file mode 100644
index 0000000..3195932
--- /dev/null
+++ b/example_0_momenta_map_mu.ipynb
@@ -0,0 +1,505 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "import zfit\n",
+    "\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def beta_l(q2, m):\n",
+    "    beta_l = ztf.sqrt(1-4*(ztf.square(m)/q2))\n",
+    "    return beta_l\n",
+    "\n",
+    "def lambda_phase(m1, m2, q2):\n",
+    "    \n",
+    "    lambd = ztf.square(ztf.square(m1)-ztf.square(m2)) -2*q2*(ztf.square(m1)+ztf.square(m2)) + ztf.square(q2)\n",
+    "    \n",
+    "    return lambd\n",
+    "\n",
+    "def beta_l_np(q2, m):\n",
+    "    beta_l = np.sqrt(1-4*(np.square(m)/q2))\n",
+    "    return beta_l\n",
+    "\n",
+    "def lambda_phase_np(m1, m2, q2):\n",
+    "    \n",
+    "    lambd = np.square(np.square(m1)-np.square(m2)) -2*q2*(np.square(m1)+np.square(m2)) + np.square(q2)\n",
+    "    \n",
+    "    return lambd\n",
+    "def scalar_product_3_np(v1,v2):\n",
+    "    \n",
+    "    output = v1[:,1]*v2[:,1]+v1[:,2]*v2[:,2]+v1[:,3]*v2[:,3]\n",
+    "    return output\n",
+    "\n",
+    "def scalar_product_4_np(v1,v2):\n",
+    "    \n",
+    "    scalar_3 = scalar_product_3_np(v1,v2)\n",
+    "    output = v1[:,0]*v2[:,0]- scalar_3\n",
+    "    return output\n",
+    "\n",
+    "\n",
+    "def a(q2, m, m1, m2):\n",
+    "    \n",
+    "    step1=q2*(1+ztf.square(beta_l(q2, m)))+ lambda_phase(m1, m2, q2)/2 + 2*m*(ztf.square(m1)-ztf.square(m2)+q2)+4*ztf.square(m)*ztf.square(m1)\n",
+    "    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "    \n",
+    "    return step1\n",
+    "\n",
+    "def b(q2, m, m1, m2):\n",
+    "    \n",
+    "    step1=2*(q2*(1+ztf.square(beta_l(q2, m)))+ m*(ztf.sqrt(lambda_phase(m1, m2, q2))*beta_l(q2,m)+(ztf.square(m1)-ztf.square(m2)+q2)))\n",
+    "    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "    \n",
+    "    return step1\n",
+    "\n",
+    "def c(q2, m, m1, m2):\n",
+    "    \n",
+    "    step1= q2*(1+ztf.square(beta_l(q2, m)))- lambda_phase(m1, m2, q2)/2 + 2*m*ztf.sqrt(lambda_phase(m1, m2, q2))*beta_l(q2, m)\n",
+    "    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "    \n",
+    "    return step1\n",
+    "\n",
+    "\n",
+    "def matrix_elt(q2, m, m1, m2, cos_theta_l):\n",
+    "    \n",
+    "    out = a(q2, m, m1, m2)+b(q2, m, m1, m2)*cos_theta_l+c(q2, m, m1, m2)*ztf.square(cos_theta_l)\n",
+    "    \n",
+    "    return out               \n",
+    "                      \n",
+    "def phase_space(q2, m, m1, m2):\n",
+    "    \n",
+    "    phase_space_term = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))\n",
+    "    \n",
+    "    return phase_space_term\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmu_mass = 0.105\n",
+    "mB_mass=5.280\n",
+    "mKst_mass=0.892\n",
+    "\n",
+    "lower_q2= 4*mmu_mass*mmu_mass\n",
+    "upper_q2=(mB_mass-mKst_mass)*(mB_mass-mKst_mass)\n",
+    "cutoff=0.01"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml']\n",
+    "    _N_OBS = 2\n",
+    "    VALID_LIMITS={\n",
+    "                  'cos_theta_l':(-1,1),\n",
+    "                  'q2': (lower_q2, upper_q2),\n",
+    "                  #'Eg': (cutoff, 10)\n",
+    "                 }\n",
+    "    \n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        ml = self.params['ml']\n",
+    "        mB = self.params['mB']\n",
+    "        mKst = self.params['mKst']\n",
+    "        \n",
+    "        q2, cos_theta_l = x.unstack_x()\n",
+    "        pdf = matrix_elt(q2, ml, mB, mKst, cos_theta_l)*phase_space(q2, ml, mB, mKst)\n",
+    "        #pdf= phase_space(q2, mB, mKst, ml)\n",
+    "        \n",
+    "        return pdf\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)\n",
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower = ((lower_q2,  -1.),)\n",
+    "upper = ((upper_q2,   1.),)\n",
+    "\n",
+    "obs = zfit.Space([\"q2\",\"cos_theta_l\"], limits=(lower,upper))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_events=100000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = pdf.create_sampler(n=n_events)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=sampler.to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q2vals_MC = np.array([a['q2'][i] for i in range(n_events)])\n",
+    "q2vals = q2vals_MC.reshape(n_events,1)\n",
+    "\n",
+    "cos_theta_vals_MC = np.array([a['cos_theta_l'][i] for i in range(n_events)])\n",
+    "cos_theta_vals = cos_theta_vals_MC.reshape(n_events,1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2vals,bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def momenta_map(q2_, cos_theta_l_, m_l):\n",
+    "    n_events = q2_.shape[0]\n",
+    "    \n",
+    "    q2 = q2_.reshape(n_events,1)\n",
+    "    cos_theta_l = cos_theta_l_.reshape(n_events,1)\n",
+    "\n",
+    "    kin_f = (np.square(mB_mass)+np.square(mKst_mass)-q2)/(2*mB_mass)\n",
+    "\n",
+    "    sin_theta_l = np.sqrt(1-np.square(cos_theta_l))\n",
+    "    \n",
+    "    lambd = lambda_phase_np(mB_mass,mKst_mass,q2)\n",
+    "    \n",
+    "    beta = beta_l_np(q2, m_l) \n",
+    "    \n",
+    "    phi_l = np.random.uniform(low=-pi,high=pi, size=(n_events,1))\n",
+    "    phi_Kst = np.random.uniform(low=-pi,high=pi, size=(n_events,1))\n",
+    "    theta_Kst = np.random.uniform(low=-pi,high=pi, size=(n_events,1))\n",
+    "    \n",
+    "    cos_phi_l = np.cos(phi_l)\n",
+    "    sin_phi_l = np.sin(phi_l)\n",
+    "    \n",
+    "    cos_phi_Kst = np.cos(phi_Kst)\n",
+    "    sin_phi_Kst = np.sin(phi_Kst)\n",
+    "    \n",
+    "    cos_theta_Kst = np.cos(theta_Kst)\n",
+    "    sin_theta_Kst = np.sin(theta_Kst)\n",
+    "\n",
+    "    p1_B_0 = 0.5*(mB_mass-kin_f) - (beta*np.sqrt(lambd)*cos_theta_l)/(4*mB_mass)\n",
+    "    p1_B_1 = 0.5*beta*np.sqrt(q2)*sin_theta_l*cos_phi_l\n",
+    "    p1_B_2 = 0.5*beta*np.sqrt(q2)*sin_theta_l*sin_phi_l\n",
+    "    p1_B_3 = -np.sqrt(lambd)/(4*mB_mass) + 0.5*(mB_mass-kin_f)*beta*cos_theta_l\n",
+    "\n",
+    "    p2_B_0 = 0.5*(mB_mass-kin_f) + (beta*np.sqrt(lambd)*cos_theta_l)/(4*mB_mass)\n",
+    "    p2_B_1 = -0.5*beta*np.sqrt(q2)*sin_theta_l*cos_phi_l\n",
+    "    p2_B_2 = -0.5*beta*np.sqrt(q2)*sin_theta_l*sin_phi_l\n",
+    "    p2_B_3 = -np.sqrt(lambd)/(4*mB_mass) - 0.5*(mB_mass-kin_f)*beta*cos_theta_l\n",
+    "    \n",
+    "    pKst_B_0 = kin_f\n",
+    "    pKst_B_1 = (np.sqrt(lambd)/(2*mB_mass))*(sin_theta_Kst*cos_phi_Kst)\n",
+    "    pKst_B_2 = (np.sqrt(lambd)/(2*mB_mass))*(sin_theta_Kst*sin_phi_Kst)\n",
+    "    pKst_B_3 = (np.sqrt(lambd)/(2*mB_mass))*cos_theta_Kst\n",
+    "\n",
+    "    \n",
+    "    pKst_B = np.concatenate([pKst_B_0,\n",
+    "                             pKst_B_1,\n",
+    "                             pKst_B_2,\n",
+    "                             pKst_B_3], axis =1)\n",
+    "    \n",
+    "    p1_B = np.concatenate([p1_B_0,\n",
+    "                           p1_B_1,\n",
+    "                           p1_B_2,\n",
+    "                           p1_B_3], axis =1)\n",
+    "    \n",
+    "    p2_B = np.concatenate([p2_B_0,\n",
+    "                           p2_B_1,\n",
+    "                           p2_B_2,\n",
+    "                           p2_B_3], axis =1)\n",
+    "    \n",
+    "    return  pKst_B, p1_B, p2_B"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pKst_B, p1_B, p2_B = momenta_map(q2vals_MC, cos_theta_vals_MC, mmu_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0.011025, 0.011025, 0.011025, ..., 0.011025, 0.011025, 0.011025]),\n",
+       " array([0.795664, 0.795664, 0.795664, ..., 0.795664, 0.795664, 0.795664]))"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scalar_product_4_np(p2_B,p2_B),scalar_product_4_np(pKst_B,pKst_B)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(5.280000000000001, -0.00010350998435309136)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(pKst_B+p1_B+p2_B)[:,0].mean(), (pKst_B+p1_B+p2_B)[:,1].mean()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_B[:,2],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(pKst_B[:,2],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_3.ipynb b/example_3.ipynb
new file mode 100644
index 0000000..14146be
--- /dev/null
+++ b/example_3.ipynb
@@ -0,0 +1,478 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "from phasespace import Particle\n",
+    "from phasespace.kinematics import lorentz_vector, lorentz_boost\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_probability as tfp\n",
+    "import zfit\n",
+    "\n",
+    "from utils.kin_utils import *\n",
+    "\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "zfit.run.check_numerics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mmu_mass = 105.0\n",
+    "mB_mass = 5280.0\n",
+    "mKst_mass = 892.0\n",
+    "\n",
+    "minq=2*mmu_mass\n",
+    "maxq=(mB_mass-mKst_mass)\n",
+    "\n",
+    "el1 = Particle('l1', mmu_mass)\n",
+    "el2 = Particle('l2', mmu_mass)\n",
+    "\n",
+    "def modq(min_mass, max_mass, n_events):\n",
+    "    \n",
+    "        min_mass = tf.cast(min_mass, tf.float64)\n",
+    "        max_mass = tf.cast(max_mass, tf.float64)\n",
+    "\n",
+    "        min_mass = tf.broadcast_to(min_mass, shape=(n_events,))\n",
+    "        \n",
+    "        modq_mass = tfp.distributions.Uniform(low=min_mass, high=max_mass).sample()\n",
+    "        \n",
+    "        return modq_mass\n",
+    "    \n",
+    "q=Particle('q', modq).set_children(el1, el2)\n",
+    "Kst = Particle('Kst', mKst_mass)\n",
+    "\n",
+    "B = Particle('B', mB_mass).set_children(Kst, q)\n",
+    "\n",
+    "#weights, particles = B.generate(n_events=10000)\n",
+    "weights_np, particles_np = B.generate(n_events=1000000)\n",
+    "weights, particles = B.generate_tensor(n_events=1000000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105.00049473122846 5279.995436140764\n"
+     ]
+    }
+   ],
+   "source": [
+    "Kst=particles_np['Kst']\n",
+    "l1 =particles_np['l1']\n",
+    "l2 =particles_np['l2']\n",
+    "q_np=particles_np['q']\n",
+    "q2_array=scalar_product_4_np(q_np,q_np)\n",
+    "q2_range=np.arange(q2_array.min(), q2_array.max(),1000)\n",
+    "print(np.sqrt(q2_array.min()/4), np.sqrt(q2_array.max())+mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "val=np.sqrt(lambda_function_np(mB_mass, mKst_mass, q2_range))*np.sqrt(beta_l_np(q2_range, mmu_mass))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(q2_range/1e6, val);\n",
+    "fig=plt.gcf()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.hist(q2_array/1e6, weights=weights_np, bins=100,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GaussianSampleAndWeights():\n",
+    "\n",
+    "        def __call__(self, n_to_produce, limits, dtype):\n",
+    "            \n",
+    "            n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n",
+    "\n",
+    "            weights, phase_space_sample = B.generate_tensor(n_events=n_to_produce) #check order \n",
+    "            \n",
+    "            weights_out = 1/weights\n",
+    "            phase_space_sample_tensor = tf.concat([phase_space_sample[\"Kst\"],phase_space_sample[\"q\"],phase_space_sample[\"l1\"],phase_space_sample[\"l2\"],], axis=1)\n",
+    "            \n",
+    "            weights_max = None\n",
+    "            \n",
+    "            thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n",
+    "            \n",
+    "            return phase_space_sample_tensor, thresholds, weights_out, weights_max, n_to_produce\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml']\n",
+    "    _N_OBS = 16\n",
+    "\n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        ml = self.params['ml']\n",
+    "        mB = self.params['mB']\n",
+    "        mKst = self.params['mKst']\n",
+    "        \n",
+    "        list_ps= x.unstack_x()\n",
+    "        new_list_ps = [tf.expand_dims(ele, axis=1) for ele in list_ps] \n",
+    "        pKstx, pKsty, pKstz, pKstE, qx, qy, qz, qE, p1x, p1y, p1z, p1E, p2x, p2y, p2z, p2E = new_list_ps\n",
+    "        \n",
+    "        pKst = lorentz_vector(tf.concat([pKstx, pKsty, pKstz],axis=-1), pKstE)\n",
+    "        p1 = lorentz_vector(tf.concat([p1x, p1y, p1z],axis=-1), p1E)\n",
+    "        p2 = lorentz_vector(tf.concat([p2x, p2y, p2z],axis=-1), p2E)\n",
+    "        qvec_B = tf.concat([qx, qy, qz],axis=-1)\n",
+    "        q = lorentz_vector(qvec_B, qE)\n",
+    "\n",
+    "        z = tf.cast(tf.expand_dims(tf.stack([0., 0., 1., 0.],         axis=0), axis=0),dtype=tf.float64)\n",
+    "        \n",
+    "        #assert q==p1+p2\n",
+    "        q2=scalar_product_4(q,q)\n",
+    "        modq = ztf.sqrt(q2)\n",
+    "        \n",
+    "        q_in_q_rf = lorentz_vector(tf.zeros_like(qvec_B), modq)\n",
+    "        p1q = lorentz_boost(p1, qvec_B/qE)\n",
+    "        \n",
+    "        costheta_l= tf.expand_dims(get_costheta_l(p1q, z), axis=1)\n",
+    "        \n",
+    "        #pdf=costheta_l*beta_l(q2, ml)\n",
+    "        \n",
+    "        #pdf = 1./(1.-beta_l(q2, ml)*costheta_l)        \n",
+    "        #pdf = (1/(q2))*(1+ztf.square(costheta_l))*(1/(q2+21e6))#*ztf.exp(-ztf.square(q2-9e6))\n",
+    "        #pdf = ztf.sqrt(lambda_function(mB, mKst, q2))*beta_l(q2,ml)\n",
+    "        #pdf = tf.ones_like(q2) \n",
+    "        #pdf = q2/(1.-beta_l(q2, ml)*costheta_l)\n",
+    "        pdf = 1/(1.-costheta_l*beta_l(q2,mmu_mass))\n",
+    "        \n",
+    "        return pdf[:, 0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lepton_min_E = 105\n",
+    "lepton_max_E = 2700\n",
+    "\n",
+    "lepton_min_p = -2700\n",
+    "lepton_max_p = 2700\n",
+    "\n",
+    "Kst_min_E = 892.\n",
+    "Kst_max_E = 2700\n",
+    "\n",
+    "Kst_min_p = -2700\n",
+    "Kst_max_p = 2700\n",
+    "\n",
+    "q_min_E = 2700\n",
+    "q_max_E = 4400\n",
+    "\n",
+    "q_min_p = -2700\n",
+    "q_max_p = 2700"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower =((Kst_min_p,  Kst_min_p,  Kst_min_p,  mKst_mass, q_min_p, q_min_p, q_min_p, q_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E,),)\n",
+    "upper =((Kst_max_p , Kst_max_p , Kst_max_p , Kst_max_E, q_max_p, q_max_p, q_max_p, q_max_E, lepton_max_p,  lepton_max_p , lepton_max_p , lepton_max_E, lepton_max_p , lepton_max_p , lepton_max_p , lepton_max_E,),)\n",
+    "\n",
+    "#lower = ((lower_Kstx, lower_Ksty,  lower_Kstz, lower_KstE, lower_l1x, lower_l1y,  lower_l1z, lower_l1E, lower_l2x, lower_l2y,  lower_l2z, lower_l2E,  ),)\n",
+    "#upper = ((upper_Kstx, upper_Ksty,  upper_Kstz, upper_KstE, upper_l1x, upper_l1y,  upper_l1z, upper_l1E, upper_l2x, upper_l2y,  upper_l2z, upper_l2E,  ),)\n",
+    "\n",
+    "obs = zfit.Space([\"pKstx\",\"pKsty\",\"pKstz\",\"pKstE\", \n",
+    "                  \"qx\", \"qy\", \"qz\", \"qE\",\n",
+    "                  \"p1x\"  ,\"p1y\"  ,\"p1z\"  ,\"p1E\"  , \n",
+    "                  \"p2x\"  ,\"p2y\"  ,\"p2z\"  ,\"p2E\" ],\n",
+    "                 limits=(lower,upper))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)\n",
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par)\n",
+    "#pdf = dGamma(obs=obs, ml = m_lepton)\n",
+    "pdf._sample_and_weights=GaussianSampleAndWeights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = pdf.create_sampler(n=100000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "a=sampler.to_pandas()  \n",
+    "plt.subplot(1,2,1)\n",
+    "plt.hist(l1[:,0],weights=weights_np,bins=60);\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.hist(a['p1x'].values[:],bins=60);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1x=a['p1x'].values[:]\n",
+    "p1y=a['p1y'].values[:]\n",
+    "p1z=a['p1z'].values[:]\n",
+    "p1E=a['p1E'].values[:]\n",
+    "\n",
+    "p2x=a['p2x'].values[:]\n",
+    "p2y=a['p2y'].values[:]\n",
+    "p2z=a['p2z'].values[:]\n",
+    "p2E=a['p2E'].values[:]\n",
+    "\n",
+    "qx =a['qx'].values[:]\n",
+    "qy =a['qy'].values[:]\n",
+    "qz =a['qz'].values[:]\n",
+    "qE =a['qE'].values[:]\n",
+    "\n",
+    "p1=np.array([p1x,p1y,p1z,p1E]).transpose()\n",
+    "p2=np.array([p2x,p2y,p2z,p2E]).transpose()\n",
+    "q = np.array([qx,qy,qz,qE]).transpose()\n",
+    "#q = p1 + p2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q2_from_sample=scalar_product_4_np(q,q)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_from_sample/1e6,bins=70, density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_3_BtoKll.ipynb b/example_3_BtoKll.ipynb
new file mode 100644
index 0000000..2c7e2a1
--- /dev/null
+++ b/example_3_BtoKll.ipynb
@@ -0,0 +1,717 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "from phasespace import Particle\n",
+    "#from phasespace.kinematics import lorentz_vector, lorentz_boost\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_probability as tfp\n",
+    "import zfit\n",
+    "\n",
+    "\n",
+    "from utils.BtoKll_utils import *\n",
+    "#from phasespace.kinematics import lorentz_boost\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mmu_mass = 105.0\n",
+    "mB_mass = 5280.0\n",
+    "mKst_mass = 892.0\n",
+    "\n",
+    "minq=2*mmu_mass\n",
+    "maxq=(mB_mass-mKst_mass)\n",
+    "\n",
+    "el1 = Particle('l1', mmu_mass)\n",
+    "el2 = Particle('l2', mmu_mass)\n",
+    "\n",
+    "def modq(min_mass, max_mass, n_events):\n",
+    "    \n",
+    "        min_mass = tf.cast(min_mass, tf.float64)\n",
+    "        max_mass = tf.cast(max_mass, tf.float64)\n",
+    "\n",
+    "        min_mass = tf.broadcast_to(min_mass, shape=(n_events,))\n",
+    "        \n",
+    "        modq_mass = tfp.distributions.Uniform(low=min_mass, high=max_mass).sample()\n",
+    "        \n",
+    "        return modq_mass\n",
+    "    \n",
+    "q=Particle('q', modq).set_children(el1, el2)\n",
+    "Kst = Particle('Kst', mKst_mass)\n",
+    "\n",
+    "B = Particle('B', mB_mass).set_children(Kst, q)\n",
+    "\n",
+    "#weights, particles = B.generate(n_events=10000)\n",
+    "weights_np, particles_np = B.generate(n_events=1000000)\n",
+    "weights, particles = B.generate_tensor(n_events=1000000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_events=100000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105.0030608127684 5279.998960900106\n"
+     ]
+    }
+   ],
+   "source": [
+    "Kst=particles_np['Kst']\n",
+    "l1 =particles_np['l1']\n",
+    "l2 =particles_np['l2']\n",
+    "q_np=particles_np['q']\n",
+    "q2_array=scalar_product_4_np(q_np,q_np)\n",
+    "q2_range=np.arange(q2_array.min(), q2_array.max(),1000)\n",
+    "print(np.sqrt(q2_array.min()/4), np.sqrt(q2_array.max())+mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "val=dphi2_np(np.sqrt(q2_range),mmu_mass,mmu_mass)*dphi2_np(mB_mass,mKst_mass,np.sqrt(q2_range))\n",
+    "plt.subplot(2,1,1)\n",
+    "plt.plot(q2_range/1e6, val);\n",
+    "fig=plt.gcf()\n",
+    "plt.subplot(2,1,2)\n",
+    "plt.hist(q2_array/1e6, weights=weights_np, bins=100,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,10);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GaussianSampleAndWeights():\n",
+    "\n",
+    "        def __call__(self, n_to_produce, limits, dtype):\n",
+    "            \n",
+    "            n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n",
+    "\n",
+    "            weights, phase_space_sample = B.generate_tensor(n_events=n_to_produce) #check order \n",
+    "            \n",
+    "            weights_out = 1/weights\n",
+    "            phase_space_sample_tensor = tf.concat([phase_space_sample[\"Kst\"],phase_space_sample[\"q\"],phase_space_sample[\"l1\"],phase_space_sample[\"l2\"],], axis=1)\n",
+    "            \n",
+    "            weights_max = None\n",
+    "            \n",
+    "            thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n",
+    "            \n",
+    "            return phase_space_sample_tensor, thresholds, weights_out, weights_max, n_to_produce\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml']\n",
+    "    _N_OBS = 16\n",
+    "\n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        ml = self.params['ml']\n",
+    "        mB = self.params['mB']\n",
+    "        mKst = self.params['mKst']\n",
+    "        \n",
+    "        list_ps= x.unstack_x()\n",
+    "        new_list_ps = [tf.expand_dims(ele, axis=1) for ele in list_ps] \n",
+    "        pKstx, pKsty, pKstz, pKstE, qx, qy, qz, qE, p1x, p1y, p1z, p1E, p2x, p2y, p2z, p2E = new_list_ps\n",
+    "        \n",
+    "        pKst = lorentz_vector(tf.concat([pKstx, pKsty, pKstz],axis=-1), pKstE)\n",
+    "        p1 = lorentz_vector(tf.concat([p1x, p1y, p1z],axis=-1), p1E)\n",
+    "        p2 = lorentz_vector(tf.concat([p2x, p2y, p2z],axis=-1), p2E)\n",
+    "        qvec_B = tf.concat([qx, qy, qz],axis=-1)\n",
+    "        q = lorentz_vector(qvec_B, qE)\n",
+    "    \n",
+    "        z = tf.cast(tf.expand_dims(tf.stack([0., 0., 1., 0.],         axis=0), axis=0),dtype=tf.float64)\n",
+    "        \n",
+    "        #assert q==p1+p2\n",
+    "        q2=scalar_product_4(q,q)\n",
+    "        modq = ztf.sqrt(q2)\n",
+    "        \n",
+    "        #q_in_q_rf = lorentz_vector(tf.zeros_like(qvec_B), modq)\n",
+    "        p1q = lorentz_boost(p1, qvec_B/qE)\n",
+    "        \n",
+    "        costheta_l= tf.expand_dims(get_costheta_l(p1q, z), axis=1)\n",
+    "        \n",
+    "        \n",
+    "        pdf = matrix_elt(q2, ml, mB, mKst, costheta_l)\n",
+    "        #pdf = tf.ones_like(q2, dtype=tf.float64)\n",
+    "        print(pdf)\n",
+    "        return pdf[:, 0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lepton_min_E = 105\n",
+    "lepton_max_E = 2700\n",
+    "\n",
+    "lepton_min_p = -2700\n",
+    "lepton_max_p = 2700\n",
+    "\n",
+    "Kst_min_E = 892.\n",
+    "Kst_max_E = 2700\n",
+    "\n",
+    "Kst_min_p = -2700\n",
+    "Kst_max_p = 2700\n",
+    "\n",
+    "q_min_E = 2700\n",
+    "q_max_E = 4400\n",
+    "\n",
+    "q_min_p = -2700\n",
+    "q_max_p = 2700"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower =((Kst_min_p,  Kst_min_p,  Kst_min_p,  mKst_mass, q_min_p, q_min_p, q_min_p, q_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E,),)\n",
+    "upper =((Kst_max_p , Kst_max_p , Kst_max_p , Kst_max_E, q_max_p, q_max_p, q_max_p, q_max_E, lepton_max_p,  lepton_max_p , lepton_max_p , lepton_max_E, lepton_max_p , lepton_max_p , lepton_max_p , lepton_max_E,),)\n",
+    "\n",
+    "obs = zfit.Space([\"pKstx\",\"pKsty\",\"pKstz\",\"pKstE\", \n",
+    "                  \"qx\", \"qy\", \"qz\", \"qE\",\n",
+    "                  \"p1x\"  ,\"p1y\"  ,\"p1z\"  ,\"p1E\"  , \n",
+    "                  \"p2x\"  ,\"p2y\"  ,\"p2z\"  ,\"p2E\" ],\n",
+    "                 limits=(lower,upper))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)\n",
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par)\n",
+    "#pdf = dGamma(obs=obs, ml = m_lepton)\n",
+    "pdf._sample_and_weights=GaussianSampleAndWeights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n",
+      "Tensor(\"create_sampler/while/unnormalized_pdf/add_21:0\", shape=(?, 1), dtype=float64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = pdf.create_sampler(n=n_events)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "a=sampler.to_pandas()  \n",
+    "plt.subplot(1,2,1)\n",
+    "plt.hist(l1[:,0],weights=weights_np,bins=60);\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.hist(a['p1x'].values[:],bins=60);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1x=a['p1x'].values[:].reshape(-1,1)\n",
+    "p1y=a['p1y'].values[:].reshape(-1,1)\n",
+    "p1z=a['p1z'].values[:].reshape(-1,1)\n",
+    "p1E=a['p1E'].values[:].reshape(-1,1)\n",
+    "\n",
+    "p2x=a['p2x'].values[:].reshape(-1,1)\n",
+    "p2y=a['p2y'].values[:].reshape(-1,1)\n",
+    "p2z=a['p2z'].values[:].reshape(-1,1)\n",
+    "p2E=a['p2E'].values[:].reshape(-1,1)\n",
+    "\n",
+    "qx =a['qx'].values[:].reshape(-1,1)\n",
+    "qy =a['qy'].values[:].reshape(-1,1)\n",
+    "qz =a['qz'].values[:].reshape(-1,1)\n",
+    "qE =a['qE'].values[:].reshape(-1,1)\n",
+    "\n",
+    "pKstx =a['pKstx'].values[:].reshape(-1,1)\n",
+    "pKsty =a['pKsty'].values[:].reshape(-1,1)\n",
+    "pKstz =a['pKstz'].values[:].reshape(-1,1)\n",
+    "pKstE =a['pKstE'].values[:].reshape(-1,1)\n",
+    "\n",
+    "p1=np.concatenate([p1x,p1y,p1z,p1E], axis=1)\n",
+    "p2=np.concatenate([p2x,p2y,p2z,p2E], axis=1)\n",
+    "q = np.concatenate([qx,qy,qz,qE], axis=1)\n",
+    "pKst = np.concatenate([pKstx,pKsty,pKstz,pKstE], axis=1)\n",
+    "#q = p1 + p2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q2_from_sample=scalar_product_4_np(q,q)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_from_sample/1e6,bins=100, density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1[:,3],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1[:,0],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3MAAAEvCAYAAADvmpjfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAW8klEQVR4nO3db4ylV30f8O8v3kCL0sYGL5Su7a6jbKs4qBVoZdymahFOwcY061ZYMv3DCixZkZyGNJHqNbyw1BZpUSogNCmSFTuYiGIoofWqdkocA6J9YYc1IMA41Fvj2hu7eKn/JK0VqJNfX9xnw+x6dmZ37t2ZOTOfj7Sa5znn3HvP9R7fvd855zlPdXcAAAAYyw9tdAcAAAA4c8IcAADAgIQ5AACAAQlzAAAAAxLmAAAABiTMAQAADGjHRndgJeeff37v3r17o7sBAACwIR544IHvdvfO5eo2dZjbvXt3Dh8+vNHdAAAA2BBV9T9PVWeZJQAAwICEOQAAgAEJcwAAAAMS5gAAAAYkzAEAAAxImAMAABiQMAcAADAgYQ4AAGBAwhwAAMCAhDkAAIABCXMAAAAD2rHRHQAA2K52H7hrxfpHD161Tj0BRiTMAaxgpS9avmQBABvJMksAAIABCXMAAAADsswSYBNyHc2Z8d+LrcpSb2AlwhwAf0YoAoBxCHPA8FYLIBv1uoIPbA3+Xwc2K2EOYJvZqPC7mrP5hdlSNQC2ImEO4CwRIACAs0mYA9gAm3V2jBezxG5r8PcIbEXCHAAwhM062y0oAhtFmAMWwpcZAID1JcwBm54libB5+MXNmfMZBpwtwhwAQ/CFmJUYH8B2JMwBwBY0YrgZsc8AG0mYAzYFX+LOzGbdCIITzTOu/T0CsJpVw1xV3ZbkrUme6u7XTGW/nOTvJ/l+kv+R5J3d/exUd1OS65L8SZKf7+7PTuVXJPmVJOck+fXuPrj4twMA68svItgo816/6JdCML7TmZn7aJJfTfKxJWX3JLmpu1+oqvcnuSnJjVV1SZJrk/xkkr+c5Her6q9Oj/m1JH8vydEkX6qqQ939zcW8DQBYm1HD2Gbttw1SNo/NOkaAxfmh1Rp09xeTPH1S2e909wvT6X1JLpiO9yW5o7u/193fTnIkyaXTnyPd/Uh3fz/JHVNbAAAA1mAR18y9K8knp+NdmYW7445OZUny+Enlr1/AawOwiVi2xajMYgEjmivMVdV7k7yQ5OPHi5Zp1ll+BrBP8ZzXJ7k+SS666KJ5ugecIcujtgZfSrcGf48ArGbNYa6q9me2Mcrl3X08mB1NcuGSZhckeWI6PlX5Cbr7liS3JMnevXuXDXzAeHwxBQBYrDWFuWlnyhuT/N3ufn5J1aEk/76qPpDZBih7kvxeZjN2e6rq4iR/kNkmKf9ono4DMBaBHgAW63RuTfCJJG9Icn5VHU1yc2a7V740yT1VlST3dffPdveDVfWpJN/MbPnlDd39J9Pz/FySz2Z2a4LbuvvBs/B+AACYk2X3MIZVw1x3v32Z4ltXaP++JO9bpvzuJHefUe8AAABY1qq3JgAAAGDzWcStCYBNxNIYYDNz7STA4ghzAACcEfeUhM1BmAPgtJlVAYDNwzVzAAAAAxLmAAAABmSZJQAAC2MjLlg/ZuYAAAAGZGYOAIB1Y+YOFkeYA06bnQwBADYPYQ42gN9KAgAwL9fMAQAADMjMHGwzlkoCAGwNwhwAAENwmQKcyDJLAACAAZmZg8FYJgkAQCLMAQCwDViiyVZkmSUAAMCAhDkAAIABCXMAAAADEuYAAAAGZAMU2ITsWAkAwGqEOTgLhDEAWJt5/g317y/bjWWWAAAAAxLmAAAABmSZJayRpRwAAGwkM3MAAAADMjMHAMC2t9qKm0cPXrVOPYHTZ2YOAABgQMIcAADAgIQ5AACAAa0a5qrqtqp6qqq+saTs5VV1T1U9PP08byqvqvpwVR2pqq9V1euWPGb/1P7hqtp/dt4OAADA9nA6M3MfTXLFSWUHktzb3XuS3DudJ8mVSfZMf65P8pFkFv6S3Jzk9UkuTXLz8QAIAADAmVs1zHX3F5M8fVLxviS3T8e3J7l6SfnHeua+JOdW1auTvDnJPd39dHc/k+SevDggAgAAcJrWes3cq7r7ySSZfr5yKt+V5PEl7Y5OZacqBwAAYA0WfZ+5WqasVyh/8RNUXZ/ZEs1cdNFFi+sZLGOle8q4nwwAAJvZWmfmvjMtn8z086mp/GiSC5e0uyDJEyuUv0h339Lde7t7786dO9fYPQAAgK1trWHuUJLjO1LuT3LnkvJ3TLtaXpbkuWkZ5meTvKmqzps2PnnTVAYAAMAarLrMsqo+keQNSc6vqqOZ7Up5MMmnquq6JI8luWZqfneStyQ5kuT5JO9Mku5+uqr+VZIvTe3+ZXefvKkKAAAAp2nVMNfdbz9F1eXLtO0kN5zieW5LctsZ9Q4AAIBlrXWZJQAAABtImAMAABiQMAcAADCgRd9nDraMle5BBwAAG83MHAAAwICEOQAAgAEJcwAAAAMS5gAAAAZkAxQAAFjFShujPXrwqnXsCfyAMAcAAHNYbQdsYY+zxTJLAACAAQlzAAAAA7LMkqFZ1gAAwHZlZg4AAGBAZubY0labuQMAgFGZmQMAABiQMAcAADAgYQ4AAGBAwhwAAMCAhDkAAIAB2c0SAADOopV213ZPXOZhZg4AAGBAZuYAAGCDrHZPXDN3rMTMHAAAwICEOQAAgAEJcwAAAAMS5gAAAAYkzAEAAAzIbpZseqvt8gQAANuRmTkAAIABmZljw5l5AwCAMzfXzFxV/fOqerCqvlFVn6iqP1dVF1fV/VX1cFV9sqpeMrV96XR+ZKrfvYg3AAAAsB2tOcxV1a4kP59kb3e/Jsk5Sa5N8v4kH+zuPUmeSXLd9JDrkjzT3T+e5INTOwAAANZg3mvmdiT581W1I8nLkjyZ5I1JPj3V357k6ul433Seqf7yqqo5Xx8AAGBbWnOY6+4/SPJvkjyWWYh7LskDSZ7t7hemZkeT7JqOdyV5fHrsC1P7V5z8vFV1fVUdrqrDx44dW2v3AAAAtrQ1b4BSVedlNtt2cZJnk/yHJFcu07SPP2SFuh8UdN+S5JYk2bt374vqAQBgu1hto7hHD161Tj1hM5pnmeVPJ/l2dx/r7v+X5DNJ/laSc6dll0lyQZInpuOjSS5Mkqn+R5M8PcfrAwAAbFvzhLnHklxWVS+brn27PMk3k3w+ydumNvuT3DkdH5rOM9V/rrvNvAEAAKzBPNfM3Z/ZRiZfTvL16bluSXJjkl+sqiOZXRN36/SQW5O8Yir/xSQH5ug3AADAtjbXTcO7++YkN59U/EiSS5dp+8dJrpnn9RiXG4MDAMBizXtrAgAAADbAXDNzAADAxllp9ZOdLrc+M3MAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwIGEOAABgQMIcAADAgIQ5AACAAQlzAAAAAxLmAAAABrRjozsAAAAs3u4Dd61Y/+jBq9apJ5wtZuYAAAAGJMwBAAAMyDJLTotpegAA2FzMzAEAAAzIzBwLsdrMHQAAsFhm5gAAAAYkzAEAAAxImAMAABiQMAcAADAgYQ4AAGBAwhwAAMCAhDkAAIABCXMAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwoLnCXFWdW1Wfrqrfr6qHqupvVtXLq+qeqnp4+nne1Laq6sNVdaSqvlZVr1vMWwAAANh+dsz5+F9J8l+6+21V9ZIkL0vyniT3dvfBqjqQ5ECSG5NcmWTP9Of1ST4y/QQAANbZ7gN3rVj/6MGr1qknrNWaZ+aq6i8m+TtJbk2S7v5+dz+bZF+S26dmtye5ejrel+RjPXNfknOr6tVr7jkAAMA2Ns/M3I8lOZbkN6rqbyR5IMm7k7yqu59Mku5+sqpeObXfleTxJY8/OpU9OUcfWKDVfjsDAABsHvNcM7cjyeuSfKS7X5vk/2a2pPJUapmyflGjquur6nBVHT527Ngc3QMAANi65glzR5Mc7e77p/NPZxbuvnN8+eT086kl7S9c8vgLkjxx8pN29y3dvbe79+7cuXOO7gEAAGxdaw5z3f2/kjxeVX9tKro8yTeTHEqyfyrbn+TO6fhQkndMu1peluS548sxAQAAODPz7mb5z5J8fNrJ8pEk78wsIH6qqq5L8liSa6a2dyd5S5IjSZ6f2gIAALAGc4W57v5qkr3LVF2+TNtOcsM8rwcAAKyPlTbHc9uCzWGum4YDAACwMYQ5AACAAQlzAAAAAxLmAAAABiTMAQAADEiYAwAAGJAwBwAAMCBhDgAAYEDCHAAAwICEOQAAgAEJcwAAAAPasdEdAAAAxrL7wF0r1j968Kp16sn2ZmYOAABgQMIcAADAgIQ5AACAAblmbhtZbW0zAAAwDjNzAAAAAxLmAAAABiTMAQAADEiYAwAAGJAwBwAAMCBhDgAAYEDCHAAAwICEOQAAgAEJcwAAAAMS5gAAAAa0Y6M7AAAAbC27D9x1yrpHD161jj3Z2szMAQAADEiYAwAAGJAwBwAAMCBhDgAAYEBzh7mqOqeqvlJV/3k6v7iq7q+qh6vqk1X1kqn8pdP5kal+97yvDQAAsF0tYmbu3UkeWnL+/iQf7O49SZ5Jct1Ufl2SZ7r7x5N8cGoHAADAGswV5qrqgiRXJfn16bySvDHJp6cmtye5ejreN51nqr98ag8AAMAZmvc+cx9K8i+S/IXp/BVJnu3uF6bzo0l2Tce7kjyeJN39QlU9N7X/7px9YImV7ukBAABsHWuemauqtyZ5qrsfWFq8TNM+jbqlz3t9VR2uqsPHjh1ba/cAAAC2tHmWWf5Ukp+pqkeT3JHZ8soPJTm3qo7P+F2Q5Inp+GiSC5Nkqv/RJE+f/KTdfUt37+3uvTt37pyjewAAAFvXmsNcd9/U3Rd09+4k1yb5XHf/4ySfT/K2qdn+JHdOx4em80z1n+vuF83MAQAAsLp5r5lbzo1J7qiqf53kK0luncpvTfKbVXUksxm5a8/Ca295rokDAACSBYW57v5Cki9Mx48kuXSZNn+c5JpFvB4AAMB2t4j7zAEAALDOhDkAAIABnY1r5gAAAJa12h4Qjx68ap16Mj5hDgAA2DSEvdNnmSUAAMCAhDkAAIABCXMAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwIGEOAABgQMIcAADAgHZsdAc40Wp3vAcAAEjMzAEAAAxJmAMAABiQMAcAADAgYQ4AAGBAwhwAAMCAhDkAAIABCXMAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwIGEOAABgQMIcAADAgIQ5AACAAQlzAAAAA9qx0R3YjnYfuGujuwAAAAxOmAMAAIax0sTIowevWseebLw1L7Osqgur6vNV9VBVPVhV757KX15V91TVw9PP86byqqoPV9WRqvpaVb1uUW8CAABgu5nnmrkXkvxSd/9EksuS3FBVlyQ5kOTe7t6T5N7pPEmuTLJn+nN9ko/M8doAAADb2prDXHc/2d1fno7/KMlDSXYl2Zfk9qnZ7Umuno73JflYz9yX5NyqevWaew4AALCNLWQ3y6raneS1Se5P8qrufjKZBb4kr5ya7Ury+JKHHZ3KAAAAOENzh7mq+pEkv5XkF7r7D1dqukxZL/N811fV4ao6fOzYsXm7BwAAsCXNFeaq6oczC3If7+7PTMXfOb58cvr51FR+NMmFSx5+QZInTn7O7r6lu/d2996dO3fO0z0AAIAta57dLCvJrUke6u4PLKk6lGT/dLw/yZ1Lyt8x7Wp5WZLnji/HBAAA4MzMc5+5n0ryT5N8vaq+OpW9J8nBJJ+qquuSPJbkmqnu7iRvSXIkyfNJ3jnHawMAAJxgpXvQJVvvPnRrDnPd/d+y/HVwSXL5Mu07yQ1rfT0AAAB+YCG7WQIAALC+hDkAAIABCXMAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwIGEOAABgQGu+aTinttqd5wEAAOZlZg4AAGBAwhwAAMCAhDkAAIABCXMAAAADEuYAAAAGJMwBAAAMSJgDAAAYkDAHAAAwIGEOAABgQMIcAADAgIQ5AACAAQlzAAAAAxLmAAAABiTMAQAADGjHRncAAABgPew+cNcp6x49eNU69mQxzMwBAAAMSJgDAAAYkDAHAAAwINfMrcFKa20BAADWg5k5AACAAQlzAAAAAxLmAAAABrTuYa6qrqiqb1XVkao6sN6vDwAAsBWsa5irqnOS/FqSK5NckuTtVXXJevYBAABgK1jvmblLkxzp7ke6+/tJ7kiyb537AAAAMLz1DnO7kjy+5PzoVAYAAMAZWO/7zNUyZX1Cg6rrk1w/nf6fqvrWWe8VG+n8JN/d6E6wpRhTLJoxxaIZUyyaMbUA9f6N7sEp/ZVTVax3mDua5MIl5xckeWJpg+6+Jckt69kpNk5VHe7uvRvdD7YOY4pFM6ZYNGOKRTOmtq/1Xmb5pSR7quriqnpJkmuTHFrnPgAAAAxvXWfmuvuFqvq5JJ9Nck6S27r7wfXsAwAAwFaw3sss0913J7l7vV+XTcuSWhbNmGLRjCkWzZhi0Yypbaq6e/VWAAAAbCrrfc0cAAAACyDMcVZV1S9X1e9X1deq6j9W1blL6m6qqiNV9a2qevOS8iumsiNVdWBJ+cVVdX9VPVxVn5w20WGbqaprqurBqvrTqtp7Up0xxUKdauzAyarqtqp6qqq+saTs5VV1z/QZc09VnTeVV1V9eBpXX6uq1y15zP6p/cNVtX8j3gsbr6ourKrPV9VD0795757KjSlOIMxxtt2T5DXd/deT/PckNyVJVV2S2W6mP5nkiiT/rqrOqapzkvxakiuTXJLk7VPbJHl/kg92954kzyS5bl3fCZvFN5L8wyRfXFpoTLFoq4wdONlHM/vsWepAknunz5h7p/NkNqb2TH+uT/KRZPZFPcnNSV6f5NIkNx//ss6280KSX+run0hyWZIbps8fY4oTCHOcVd39O939wnR6X2b3FkySfUnu6O7vdfe3kxzJ7EPm0iRHuvuR7v5+kjuS7KuqSvLGJJ+eHn97kqvX632weXT3Q939rWWqjCkWbdmxs8F9YpPq7i8mefqk4n2ZfbYkJ37G7EvysZ65L8m5VfXqJG9Ock93P93dz2T2C9GTAyLbQHc/2d1fno7/KMlDSXbFmOIkwhzr6V1Jfns63pXk8SV1R6eyU5W/IsmzS4Lh8XI4zphi0U41duB0vaq7n0xmX86TvHIqP9PPK7axqtqd5LVJ7o8xxUnW/dYEbD1V9btJ/tIyVe/t7junNu/NbMnAx48/bJn2neV/wdArtGcLOp0xtdzDlikzppiHMcLZcqqxZcxxgqr6kSS/leQXuvsPZ4tKlm+6TJkxtQ0Ic8ytu396pfrpYtu3Jrm8f3AvjKNJLlzS7IIkT0zHy5V/N7MlAzummZSl7dliVhtTp2BMsWgrjSk4Hd+pqld395PTkrenpvJTja2jSd5wUvkX1qGfbEJV9cOZBbmPd/dnpmJjihNYZslZVVVXJLkxyc909/NLqg4lubaqXlpVF2d2we7vJflSkj3TLoMvyWxDi0NTCPx8krdNj9+f5FQzNGxPxhSLtuzY2eA+MZZDmX22JCd+xhxK8o5pB8LLkjw3LZn7bJI3VdV50yYVb5rK2Gam67pvTfJQd39gSZUxxQncNJyzqqqOJHlpkv89Fd3X3T871b03s+voXshs+cBvT+VvSfKhJOckua273zeV/1hmGxC8PMlXkvyT7v7eOr4dNoGq+gdJ/m2SnUmeTfLV7n7zVGdMsVCnGjtwsqr6RGYzIOcn+U5mOwj+pySfSnJRkseSXNPdT09f1H81s40onk/yzu4+PD3Pu5K8Z3ra93X3b6zn+2BzqKq/neS/Jvl6kj+dit+T2XVzxhR/RpgDAAAYkGWWAAAAAxLmAAAABiTMAQAADEiYAwAAGJAwBwAAMCBhDgAAYEDCHAAAwICEOQAAgAH9f/OH7EyNawBEAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(pKst[:,0],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_q = lorentz_boost_np(p1, -q[:,0:3]/q[:,3:4])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3MAAAEwCAYAAAAdGiiRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAcqElEQVR4nO3df6yl9V0n8PendDrbKFlaoXUcYIfdTBOrcauZgAn+AUVbWo2z3ViXmlWsRDQLUbL+UQY3qatWx6zW4tplMworbGopq3U7UVyk/EgXs7RArbUU284WLAMToFIqpoQt9Lt/nGfay3DPj3vvOeee55zXK5ncc7/Pc+59TvJwuO/z/X4/n2qtBQAAgH55yXZfAAAAABsnzAEAAPSQMAcAANBDwhwAAEAPCXMAAAA9JMwBAAD00NgwV1X/pKo+VlV/XVX3V9V/7MbPqqqPVtXnquoDVfWybnxn9/2R7vieNT/rQDf+map646xeFAAAwLKrcX3mqqqSfFNr7R+rakeSu5L8fJJ/n+SDrbUbq+q/Jvnr1to1VfXvknxXa+1nq+qiJG9prf2bqnptkvcnOTvJtyX5cJLXtNaeH/a7Tz311LZnz54pvEwAAID+ue+++77YWjttvWMvHffkNkh7/9h9u6P715K8PsmPdePXJ/mlJNck2d89TpI/SvK7XSDcn+TG1tqzSR6sqiMZBLv/M+x379mzJ/fee++4SwQAAFhKVfV3w45NtGeuqk6qqk8keTzJrUn+b5KnWmvPdaccTbK7e7w7ycNJ0h3/cpJvWTu+znMAAADYgInCXGvt+dba65KcnsFs2revd1r3tYYcGzb+AlV1aVXdW1X3PvHEE5NcHgAAwMrZUDXL1tpTSe5M8r1JTqmq48s0T0/yaPf4aJIzkqQ7/k+TPLl2fJ3nrP0dh1pr+1pr+047bd2loQAAACtvkmqWp1XVKd3jlyf5/iQPJLkjyY90p12c5EPd48Pd9+mO397tuzuc5KKu2uVZSfYm+di0XggAAMAqGVsAJcmuJNdX1UkZhL+bWmt/WlWfTnJjVf1qkr9Kcm13/rVJ/ntX4OTJJBclSWvt/qq6KcmnkzyX5LJRlSwBAAAYbmxrgu20b9++ppolAACwqqrqvtbavvWObWjPHAAAAItBmAMAAOghYQ4AAKCHhDkAAIAeEuYAAAB6aJLWBACwWu749fXHzz8w3+sAgBGEOQBW07DABgA9YZklAABAD5mZA4CtsiwTgG1gZg4AAKCHhDkAAIAesswSACalaAoAC8TMHAAAQA8JcwAAAD0kzAEAAPSQPXMALDf73ABYUmbmAAAAekiYAwAA6CFhDgAAoIeEOQAAgB4S5gAAAHpImAMAAOghYQ4AAKCHhDkAAIAe0jQcAGZlVMPy8w/M7zoAWEpm5gAAAHrIzBwAy2HULBgALCEzcwAAAD1kZg6AfjEDBwBJzMwBAAD0kjAHAADQQ8IcAABADwlzAAAAPSTMAQAA9JAwBwAA0EPCHAAAQA+N7TNXVWckuSHJtyb5WpJDrbWrq+qXkvx0kie6U69qrd3cPedAkkuSPJ/k51prt3TjFya5OslJSX6/tXZwui8HAHpiWL+88w/M9zoA6K1JmoY/l+QXWmsfr6qTk9xXVbd2x367tfaba0+uqtcmuSjJdyT5tiQfrqrXdIffm+QHkhxNck9VHW6tfXoaLwQAAGCVjA1zrbVjSY51j5+uqgeS7B7xlP1JbmytPZvkwao6kuTs7tiR1trnk6SqbuzOFeYAAAA2aJKZua+rqj1JvjvJR5Ocm+TyqvqJJPdmMHv3pQyC3t1rnnY03wh/D58wfs6mrhqA5WCpIQBs2sRhrqq+OckfJ7mitfYPVXVNkl9J0rqvv5Xkp5LUOk9vWb/YSlvn91ya5NIkOfPMMye9PACWybCQtwoEXAAmNFE1y6rakUGQe19r7YNJ0lp7rLX2fGvta0l+L99YSnk0yRlrnn56kkdHjL9Aa+1Qa21fa23faaedttHXAwAAsBLGhrmqqiTXJnmgtfbuNeO71pz2liSf6h4fTnJRVe2sqrOS7E3ysST3JNlbVWdV1csyKJJyeDovAwAAYLVMsszy3CQ/nuRvquoT3dhVSd5WVa/LYKnkQ0l+Jklaa/dX1U0ZFDZ5LsllrbXnk6SqLk9ySwatCa5rrd0/xdcCAACwMiapZnlX1t8Hd/OI57wrybvWGb951PMAAACYzER75gAAAFgswhwAAEAPCXMAAAA9JMwBAAD00MRNwwGAbaSZOAAnMDMHAADQQ8IcAABADwlzAAAAPSTMAQAA9JACKADQZ8MKoySKowAsOTNzAAAAPSTMAQAA9JAwBwAA0EPCHAAAQA8JcwAAAD0kzAEAAPSQMAcAANBD+swBwAjX3vVgnn72q0OPn7xzRy75vrPmeEUAMCDMATB7oxpbz8GoQDYujD397FdzxQWvGXr8Pbd9dsvXBwCbIcwBsPRGBbJr73pwZCA7eeeOWV3W7A0L0ecfmO91ADATwhwA07HNs2+bZYkkAH0lzAHQe5PsawOAZSPMAdB74/a1AcAy0poAAACgh4Q5AACAHrLMEgBmRI86AGZJmAOAGdGjDoBZsswSAACgh8zMAbAxPe0nBwDLxswcAABAD5mZA4AtOHnnjqF73zQrB2CWhDkA2ALVKAHYLpZZAgAA9JAwBwAA0EPCHAAAQA8JcwAAAD00tgBKVZ2R5IYk35rka0kOtdaurqpXJvlAkj1JHkryo621L1VVJbk6yZuTfCXJT7bWPt79rIuT/IfuR/9qa+366b4cAPrq2rsezNPPfnVTz1U1EoBVNEk1y+eS/EJr7eNVdXKS+6rq1iQ/meS21trBqroyyZVJ3pHkTUn2dv/OSXJNknO68PfOJPuStO7nHG6tfWnaLwqA/nn62a/migtes92XsRqGNX4//8B8rwOALRkb5lprx5Ic6x4/XVUPJNmdZH+S87rTrk9yZwZhbn+SG1prLcndVXVKVe3qzr21tfZkknSB8MIk75/i6wGApTBupvLknTu0RQBYcRvqM1dVe5J8d5KPJnl1F/TSWjtWVa/qTtud5OE1TzvajQ0bBwBOMG6mclijcgBWx8QFUKrqm5P8cZIrWmv/MOrUdcbaiPETf8+lVXVvVd37xBNPTHp5AAAAK2Wimbmq2pFBkHtfa+2D3fBjVbWrm5XbleTxbvxokjPWPP30JI924+edMH7nib+rtXYoyaEk2bdv34vCHgAsi5N37hg6w6aoCwDjTFLNspJcm+SB1tq71xw6nOTiJAe7rx9aM355Vd2YQQGUL3eB75Ykv1ZVr+jOe0MSO60BVsQke8BWjT1vAGzFJDNz5yb58SR/U1Wf6MauyiDE3VRVlyT5QpK3dsduzqAtwZEMWhO8PUlaa09W1a8kuac775ePF0MBYPmpVgkA0zVJNcu7sv5+tyS5YJ3zW5LLhvys65Jct5ELBGCbDCtfDwAshIkLoAAAALA4NtSaAABYDKOKpxw/vuE9eZqJA/SKMAcAPTQuqE21D92oJbeCHsC2EeYAVp29cQDQS/bMAQAA9JAwBwAA0EOWWQIwNaMag69iU3AAmCVhDoCp0Ri8H0aF7mSTlTABmDthDoCJTRICWAyjWhecvHPHyNA91UqYAMyMMAfAxMy89YeZNYDlpwAKAABADwlzAAAAPSTMAQAA9JA9cwDL5I5fX3/8/APzvQ4AYObMzAEAAPSQMAcAANBDllkCAJtnaS/AthHmAFbBsD+4AYDeEuYAVsy1dz2Yp5/96rrHTt65Q7NpcvLOHXnPbZ/d9HPdQwDzIcwBrJinn/1qrrjgNese2+wf8CyXrYQx9xDA/CiAAgAA0ENm5gCWzKhllMlgGdyoY6NmVkY9F15AYRSAmRPmAJbMqGWU49jrBAD9IcwBAFMzbnb3f3z09vzlla+f4xUBLC9hDgCYmnGzu++55Zk5XQnA8lMABQAAoIeEOQAAgB4S5gAAAHpImAMAAOghYQ4AAKCHhDkAAIAe0poAoIfOPXh7HnnqxSXer3jpZ3Pyzh3bcEUwmd2nvDx7rvyzocf0oAOYnDAH0EOPPPVMHjr4gy8+cMcn538xsAGjwtqwkAfA+oQ5gAU0bObtuN2nvHyOVwOLYdR/F2b1gFUkzAEsoKEzb9B3d/z6+uPnHxj71FH/XZjVA1aRMAfQR8P+IAYAVsbYMFdV1yX5oSSPt9a+sxv7pSQ/neSJ7rSrWms3d8cOJLkkyfNJfq61dks3fmGSq5OclOT3W2sHp/tSAIA+G1Uc5fhxAL5hkpm5P0jyu0luOGH8t1trv7l2oKpem+SiJN+R5NuSfLiqXtMdfm+SH0hyNMk9VXW4tfbpLVw7ALBE7HkD2JixYa619pGq2jPhz9uf5MbW2rNJHqyqI0nO7o4daa19Pkmq6sbuXGEOAABgE7bSNPzyqvpkVV1XVa/oxnYneXjNOUe7sWHjL1JVl1bVvVV17xNPPLHeKQAAACtvs2HumiT/IsnrkhxL8lvdeK1zbhsx/uLB1g611va11vaddtppm7w8AACA5bapapattceOP66q30vyp923R5OcsebU05M82j0eNg6wcibuI6dqJati1L0+QdsCgFW0qTBXVbtaa8e6b9+S5FPd48NJ/rCq3p1BAZS9ST6Wwczc3qo6K8kjGRRJ+bGtXDhAn+kjBwBs1SStCd6f5Lwkp1bV0STvTHJeVb0ug6WSDyX5mSRprd1fVTdlUNjkuSSXtdae737O5UluyaA1wXWttfun/moAAABWxCTVLN+2zvC1I85/V5J3rTN+c5KbN3R1AAAArGsr1SwBAADYJsIcAABAD22qAAoA442qWPn1apXAVOw+5eXZc+WfjTz+l1e+fo5XBDB7whzAjKhYCVMyrG3BmpYF44LaqKAH0FeWWQIAAPSQmTmA7aYxOACwCcIcwCaN2hOXrLMvTmgDAKZImAPYJHviAIDtJMwBAEtPtUtgGQlzAMDSU+0SWEbCHLDSJtn35tN6WH6jZu68DwCLSpgDVtq4fW8+rYfVMCqseR8AFpU+cwAAAD1kZg5YahtuHwD0x7B2H+cfmO91AGwTYQ5YatoHAADLyjJLAACAHhLmAAAAesgyS4ARxpUrBxbQsL10if10wFIR5gBG0FsKGPWhzvHj3iuA7SDMAQCMMC6onXvwdmEP2BbCHADAFowLapqOA7MizAFM26j9OsDKGbf31qwdsFnCHACwOrah0fiosGbWDtgKrQkAAAB6yMwcsPDOPXh7HnnqmaHHLVMCAFaRMAcsvEeeeiYPHfzBocdHVZLTCw4AWFbCHNB7ZuUAgFUkzAELYdRSSrNrAAAvJswBC2HcUkqAZTSqbcEkz7UyAVabMAewWfrJAVu0lTCmrQGgNQEAAEAPCXMAAAA9JMwBAAD0kD1zAKPYFwerYdh/6+cfmO91AGyAmTkAAIAeGhvmquq6qnq8qj61ZuyVVXVrVX2u+/qKbryq6neq6khVfbKqvmfNcy7uzv9cVV08m5cDAACwGiaZmfuDJBeeMHZlkttaa3uT3NZ9nyRvSrK3+3dpkmuSQfhL8s4k5yQ5O8k7jwdAAAAANm7snrnW2keqas8Jw/uTnNc9vj7JnUne0Y3f0FprSe6uqlOqald37q2ttSeTpKpuzSAgvn/LrwAAYAWNaziuqTgsv80WQHl1a+1YkrTWjlXVq7rx3UkeXnPe0W5s2DgAAJswLqhpKg7Lb9rVLGudsTZi/MU/oOrSDJZo5swzz5zelQEzde7B2/PIU88MPe4TYgCA6dpsmHusqnZ1s3K7kjzejR9Ncsaa805P8mg3ft4J43eu94Nba4eSHEqSffv2rRv4gO0xKrDtPuXleejgD4587rjlQAAATG6zYe5wkouTHOy+fmjN+OVVdWMGxU6+3AW+W5L82pqiJ29IonEL9MwjTz0zMrCNsvCzcvrJAQA9MzbMVdX7M5hVO7WqjmZQlfJgkpuq6pIkX0jy1u70m5O8OcmRJF9J8vYkaa09WVW/kuSe7rxfPl4MBQCgd0Z9AKTRODAnk1SzfNuQQxesc25LctmQn3Ndkus2dHUAAMzEuKXzC7+iAph6ARQAABbAJK0Lhi2dVwkT+kGYAwAYpsf7ac2swfIT5gAAeAENyaEfhDkAAF5AQ3LoB2EOWC09XjIFALDWS7b7AgAAANg4M3OwYpSiBgBYDsIcrJhHnnpmaCnqcw/ePnbDOwAAi0GYA77OrBwAkxhV7dIqD5gfYQ4AgA0ZFdZUuoT5EeaA5aRqJQCw5FSzBAAA6CEzcwAA0zRsZcD5B+Z7HcDSE+YAAJiaUcVRjh9XIAWmQ5iDJTOqj1yivQAAszUuqCmQAtMjzMGSGdVHDoBtZPklMGXCHAAAc2MZJkyPMAcAwNxYhgnTI8zBAhq1780nlgAAJMIcLKRR+97OPXj72OUpAPSIvXQvMGoZpg804YWEOegZ/xNbY9gfQAD01qj/z1mCCS/0ku2+AAAAADZOmAMAAOghYQ4AAKCH7JkDFp+9ccAqGvXet6LFUYAXEuYAAFgKWvuwaoQ5YHGYgQNghFFtC44fH9baRyVMlpEwB9tg1CeHiV5xALAeM2vwQsIcbINRTcEBAGASwhzMgJk3AFgskyzRNPNH3whzMANm3gBgsYwLavbU0Uf6zAEAAPSQMAcAANBDllnCJo3rZQMAMzOslYtm4ptmTx19JMzBJtkXB8DCEfI2zZ46+kiYY6WNm13zCRwAAItqS2Guqh5K8nSS55M811rbV1WvTPKBJHuSPJTkR1trX6qqSnJ1kjcn+UqSn2ytfXwrvx+2atTsmk/gZmjYJ8cAAExsGjNz57fWvrjm+yuT3NZaO1hVV3bfvyPJm5Ls7f6dk+Sa7isspEnWzjOCwAYAMFOzWGa5P8l53ePrk9yZQZjbn+SG1lpLcndVnVJVu1prx2ZwDbBlllgCALDIttqaoCX5i6q6r6ou7cZefTygdV9f1Y3vTvLwmuce7cYAAADYoK3OzJ3bWnu0ql6V5Naq+tsR59Y6Y+1FJw1C4aVJcuaZZ27x8lh1owqcJJZKToXllACLT5XLLRu1/ULRNLbLlsJca+3R7uvjVfUnSc5O8tjx5ZNVtSvJ493pR5Ocsebppyd5dJ2feSjJoSTZt2/fi8IebIT2AQDANIwKa4qmsV02Heaq6puSvKS19nT3+A1JfjnJ4SQXJznYff1Q95TDSS6vqhszKHzyZfvlAADoOw3H2S5bmZl7dZI/GXQcyEuT/GFr7X9V1T1JbqqqS5J8Iclbu/NvzqAtwZEMWhO8fQu/GwAAFsK4oHbuwdst0WQmNh3mWmufT/Iv1xn/+yQXrDPekly22d8HbDN74wBgUyzRZFZm0ZoAAIA+GPVBneIosPCEOXpNtUoAAFaVMEevqVYJAPSZ4ilshTDHtptkds2bGADMmd50czHubxx76hhFmGPbjZtdG1cBCgBgWZm5YxRhjoXnDWqOVKwEgIVi5o5RhDkAAOipUTN3Zu2WnzAHAAA9pYfdahPmmItRRU7sewMAgI0T5pgLLQQAAGC6hDlYRQqdAAD0njAHAMDk9J+DhSHMMRWTNP4GAJaYkLdw9KhbfsIcU2FP3IKynBIAVpYedctPmAMAYHZGfbBo1g62RJhjIpZRAgDAYhHmmIhllAvOckoAYIPsqes/YQ4AAFbQuKB27sHbh4Y9QW8xCHN83aillJZRAgBTpwLmQhsV1kYFvUTYmxdhjq+zlBIAgEmolLkYhDlYNPa/AbDqzNjBRF6y3RcAAADAxpmZWyHaCwAAMA+jKmXaTzc9wtwKsScOAIB5GBXW7KebHmGuZyaZXfNJBwAALD9hrmfGza6N6wcCANBbmykSpmgKS0yYWzJm5XpE1UoAALZANUsAAIAeMjO3YFSc7CmzbAAAExlV6fL4cavNJiPMLRgVJwEApkgD8oUzLqiNqgGRCHtrCXMAAMDCGBfUtDb4BnvmAAAAesjMHKzHHjgAWG7aHLAEhDkAAKA3RhVQWbX9dMLcNhhVsVK1SgCABaWYykIYFdZWbT+dMLcNVKycM0smAYBZEvLYJnMPc1V1YZKrk5yU5PdbawfnfQ2zplfcNhHaAIBFIuTN3ar1sJtrmKuqk5K8N8kPJDma5J6qOtxa+/Q8r2PWzLzNmNAGAMA6Vq2twbxn5s5OcqS19vkkqaobk+xP0qswZ+ZtToQ2AGAZTfNvHLN8K23eYW53kofXfH80yTlzvoYtM/M2ggAGADA/WixsyLJVwpx3mKt1xtoLTqi6NMml3bf/WFWfmflVbUL9xnZfQW+dmuSL230RLCX3FrPgvmJW3FvMygT31lVzuZC++bsktZg5958NOzDvMHc0yRlrvj89yaNrT2itHUpyaJ4XxfxU1b2ttX3bfR0sH/cWs+C+YlbcW8yKe2u1vGTOv++eJHur6qyqelmSi5IcnvM1AAAA9N5cZ+Zaa89V1eVJbsmgNcF1rbX753kNAAAAy2DufeZaazcnuXnev5eFYQkts+LeYhbcV8yKe4tZcW+tkGqtjT8LAACAhTLvPXMAAABMgTDH1FTVf6qqv62qT1bVn1TVKWuOHaiqI1X1map645rxC7uxI1V15Zrxs6rqo1X1uar6QFcwhxVVVW+tqvur6mtVte+EY+4tZmLYPQTDVNV1VfV4VX1qzdgrq+rW7j3n1qp6RTdeVfU73f31yar6njXPubg7/3NVdfF2vBYWR1WdUVV3VNUD3f8Lf74bd28hzDFVtyb5ztbadyX5bJIDSVJVr82gcul3JLkwyX+pqpOq6qQk703ypiSvTfK27twk+Y0kv91a25vkS0kumesrYdF8Ksm/TvKRtYPuLWZlzD0Ew/xBBu9Fa12Z5LbuPee27vtkcG/t7f5dmuSaZPAHepJ3JjknydlJ3nn8j3RW1nNJfqG19u1JvjfJZd37kXsLYY7paa39RWvtue7buzPoI5gk+5Pc2Fp7trX2YJIjGbyJnJ3kSGvt8621/5fkxiT7q6qSvD7JH3XPvz7Jv5rX62DxtNYeaK19Zp1D7i1mZd17aJuviQXXWvtIkidPGN6fwXtN8sL3nP1JbmgDdyc5pap2JXljkltba0+21r6UwQelJwZEVkhr7Vhr7ePd46eTPJBkd9xbRJhjdn4qyZ93j3cneXjNsaPd2LDxb0ny1JpgeHwcTuTeYlaG3UOwUa9urR1LBn+UJ3lVN77R9y9IVe1J8t1JPhr3FtmG1gT0W1V9OMm3rnPoF1trH+rO+cUMlgS87/jT1jm/Zf0PE9qI81lik9xb6z1tnTH3FtPgXmHWht1j7j3WVVXfnOSPk1zRWvuHwWKT9U9dZ8y9taSEOTaktfb9o453m2l/KMkF7Rt9L44mOWPNaacnebR7vN74FzNYEvDSbgZl7fksqXH31hDuLWZl1L0FG/FYVe1qrR3rlro93o0Pu8eOJjnvhPE753CdLLCq2pFBkHtfa+2D3bB7C8ssmZ6qujDJO5L8cGvtK2sOHU5yUVXtrKqzMtiQ+7Ek9yTZ21UXfFkGhSwOdyHwjiQ/0j3/4iTDZmZYbe4tZmXde2ibr4l+OpzBe03ywvecw0l+oqs8+L1JvtwtlbslyRuq6hVdcYo3dGOsqG6/97VJHmitvXvNIfcWmoYzPVV1JMnOJH/fDd3dWvvZ7tgvZrCP7rkMlgf8eTf+5iTvSXJSkutaa+/qxv95BgUHXpnkr5L829bas3N8OSyQqnpLkv+c5LQkTyX5RGvtjd0x9xYzMewegmGq6v0ZzHycmuSxDCoH/s8kNyU5M8kXkry1tfZk9wf672ZQgOIrSd7eWru3+zk/leSq7se+q7X23+b5OlgsVfV9Sf53kr9J8rVu+KoM9s25t1acMAcAANBDllkCAAD0kDAHAADQQ8IcAABADwlzAAAAPSTMAQAA9JAwBwAA0EPCHAAAQA8JcwAAAD30/wHP8w7zGQbSEgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plt.hist(p1_B[:,0],alpha=0.3,bins=100);\n",
+    "plt.hist(p1[:,0],histtype=\"step\",bins=100);\n",
+    "plt.hist(p1_q[:,0],alpha=0.5,bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "105.0"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(scalar_product_4_np(p1_q,p1_q)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z=np.array([[0.,0.,1.,0] for i in range(n_events)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cos_theta_l_np=get_costheta_l_np(p1_q,z)\n",
+    "plt.hist(cos_theta_l_np,histtype=\"step\", density=True, bins=100);\n",
+    "cos_theta_l_np_B=get_costheta_l_np(p1,z)\n",
+    "plt.hist(cos_theta_l_np_B,alpha=0.5, density=True,bins=100);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.2160899504353184e-15"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1+p2+pKst)[:,0].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.1290421509112535e-15"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1+p2+pKst)[:,1].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-5.32265759245476e-16"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1+p2+pKst)[:,2].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5280.0"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1+p2+pKst)[:,3].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_3_dGamma_weights.ipynb b/example_3_dGamma_weights.ipynb
new file mode 100644
index 0000000..05911cb
--- /dev/null
+++ b/example_3_dGamma_weights.ipynb
@@ -0,0 +1,477 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "from phasespace import Particle\n",
+    "from phasespace.kinematics import lorentz_vector, lorentz_boost\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_probability as tfp\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def scalar_product_4(v1, v2):\n",
+    "    \"\"\"Calculate mass scalar for Lorentz 4-momentum.\n",
+    "    Arguments:\n",
+    "        vector: Input Lorentz momentum vector.\n",
+    "    \"\"\"\n",
+    "    v0 = v1[:,3]*v2[:,3]\n",
+    "    \n",
+    "    vs = scalar_product_3(v1, v2)\n",
+    "    output = (v0-vs)\n",
+    "    \n",
+    "    return output\n",
+    "\n",
+    "def scalar_product_3(v1, v2):\n",
+    "    \"\"\"Calculate scalar product of two 3-vectors.\n",
+    "    Arguments:\n",
+    "        vec1: First vector.\n",
+    "        vec2: Second vector.\n",
+    "    \"\"\"\n",
+    "    output = (v1[:,0]*v2[:,0] + v1[:,1]*v2[:,1] + v1[:,2]*v2[:,2])\n",
+    "    return output\n",
+    "\n",
+    "def get_costheta_l(p1, p2):  \n",
+    "    \n",
+    "    num = scalar_product_3(p1, p2)\n",
+    "\n",
+    "    den1= np.sqrt(scalar_product_3(p1, p1))\n",
+    "    den2= np.sqrt(scalar_product_3(p2, p2))\n",
+    "    \n",
+    "    costheta_l = num/(den1*den2)\n",
+    "    \n",
+    "    return costheta_l\n",
+    "\n",
+    "def beta_l(q2, m):\n",
+    "    \n",
+    "    return 1-4*(np.square(m)/q2)\n",
+    "\n",
+    "\n",
+    "def lambda_function(m1, m2, q2):\n",
+    "    \n",
+    "    return np.square(np.square(m1)-np.square(m2)) -2*q2*(np.square(m1)+np.square(m2)) + np.square(q2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env2/lib/python3.7/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "n_events=1000000\n",
+    "\n",
+    "mmu_mass = 105.0\n",
+    "mB_mass = 5280.0\n",
+    "mKst_mass = 892.0\n",
+    "\n",
+    "minq=2*mmu_mass\n",
+    "maxq=(mB_mass-mKst_mass)\n",
+    "\n",
+    "el1 = Particle('l1', mmu_mass)\n",
+    "el2 = Particle('l2', mmu_mass)\n",
+    "\n",
+    "def modq(min_mass, max_mass, n_events):\n",
+    "    \n",
+    "        min_mass = tf.cast(min_mass, tf.float64)\n",
+    "        max_mass = tf.cast(max_mass, tf.float64)\n",
+    "\n",
+    "        min_mass = tf.broadcast_to(min_mass, shape=(n_events,))\n",
+    "        \n",
+    "        modq_mass = tfp.distributions.Uniform(low=min_mass, high=max_mass).sample()\n",
+    "        \n",
+    "        return modq_mass\n",
+    "    \n",
+    "q=Particle('q', modq).set_children(el1, el2)\n",
+    "Kst = Particle('Kst', mKst_mass)\n",
+    "\n",
+    "B = Particle('B', mB_mass).set_children(Kst, q)\n",
+    "\n",
+    "z=np.array([[0.,0.,1.,0.] for i in range(n_events)])\n",
+    "weights_np, particles_np = B.generate(n_events=n_events)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1000000, 4)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "z.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105.0000404384508 5279.999786972526\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2wAAAE6CAYAAABqJNGSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3jV53n/8c9zlvY+Otp7s8TeGw/sGhMnsWMnduMMO27iJmmSJk3SjGa0PzepM5ukrmMnthM7XvHADhgwe5lhtkBsJECbLbTO+f7+OELIqgABko7G+3VdukDSF7iNAemj+3nu21iWJQAAAABA32MLdAEAAAAAgM4R2AAAAACgjyKwAQAAAEAfRWADAAAAgD6KwAYAAAAAfRSBDQAAAAD6qIAGNmPMU8aYKmPMzi48+zNjzNbWl1JjzKneqBEAAAAAAsUEcg+bMWa6pHOSnrEsa9g1/Lh/lDTKsqxP91hxAAAAABBgAe2wWZa1UlJd+7cZY3KMMQuNMZuNMauMMYWd/ND7JD3fK0UCAAAAQIA4Al1AJ56Q9IhlWfuMMRMk/UbS7IvvNMZkSMqS9G6A6gMAAACAXtGnApsxJlzSZEkvGWMuvjmow2P3SnrZsixvb9YGAAAAAL2tTwU2+Y9onrIsa+QVnrlX0hd6qR4AAAAACJg+Ndbfsqwzkg4ZY+6WJONXfPH9xpgCSTGS1gWoRAAAAADoNYEe6/+8/OGrwBhTboz5jKRPSPqMMWabpF2S5rf7IfdJesEK5GhLAAAAAOglAR3rDwAAAAC4vD51JBIAAAAAcAmBDQAAAAD6qIBNiXS73VZmZmagfnkAAAAACKjNmzfXWJYVf6VnAhbYMjMztWnTpkD98gAAAAAQUMaYI1d7hiORAAAAANBHEdgAAAAAoI8isAEAAABAH0VgAwAAAIA+isAGAAAAAH3UVQObMSbNGLPMGFNijNlljPlSJ8/MNMacNsZsbX35bs+UCwAAAACDR1fG+rdI+qplWVuMMRGSNhtjFluWtbvDc6ssy7qj+0sEAAAAgMHpqh02y7JOWJa1pfX7ZyWVSErp6cIAAAAAYLC7pjtsxphMSaMkbejk3ZOMMduMMX8zxgzthtoAAAAAYFDrypFISZIxJlzSK5K+bFnWmQ7v3iIpw7Ksc8aY2yW9Jimvk5/jYUkPS1J6evp1Fz3QNbZ4VXe+STVnm1R7vlENzV41tvjU1OKT12fJYbfJ5bDJZTdy2m0KD3IoOtSlqBCnokOdCnbaA/2fAAAAAKAbGMuyrv6QMU5JCyQtsizr8S48f1jSWMuyai73zNixY61NmzZdQ6kDj2VZOnbqgjYertO2stPaX3VOB6rP6cTphhv6eYMcNrnDg5QYFazEqGAlRQa3fT81JlSZcaGKDnV1038FAAAAgOthjNlsWdbYKz1z1Q6bMcZI+r2kksuFNWNMoqRKy7IsY8x4+Y9a1l5HzQOeZVnaWnZKb+84oYW7KlRWd0GSFOayK9cTrknZccp0hyk+IkhxYS7FhbsU4nTI5bApyGGT3Wbk9VlqbPGp2evvup1rbNGp+madvtCsUxeadKq+WdVnG1VxukG7j5/R0pJKNTT7PlBHVIhTmXGhyogLa/s2Kz5MeZ5wRQQ7A/FbAwAAAKCDrhyJnCLpAUk7jDFbW9/2LUnpkmRZ1u8kfVTSPxhjWiRdkHSv1ZXW3SDS1OLTa1uP6anVh7Sn4qycdqOpuW59dmq2xmXGqiAxQnab6ZFf27IsnbnQohNnLqis7oKO1J7Xkdp6Ha49r61lp7Rg+3H52v3fSo4KVl5ChPITwlu/jVCeJ1xhQV0+QQsAAACgG3TpSGRPGCxHIi3L0sKdFfqPv+3R0bp6FSZG6MHJmbpteJKiQvpGJ6upxafyk/U6UH1epZVnta/yrEorz2l/9Tk1tVzqzKXGhKgoKVJDkyM1NDlKQ5MjlRQVLH8TFgAAAMC16JYjkbh+teca9Y1XdmhJSaXyE8L19IPjNLMgvs8FHJfDpuz4cGXHh+vmIQltb/f6LB2tq28LcXsqzmr3iTNaUlKpizk/JtSpIe0C3JCkSGXHh/dYtxAAAAAYTAhsPWRr2Sk99Mwmna5v1rdvL9KnpmTKYb+mLQoBZ7cZZbnDlOUO061DE9vefr6xxR/ejp/WruNntPvEGf1h7eG2blyw06ahyVEqTo1WcZr/24y40D4XVAEAAIC+jiORPWDJ7ko9+vwWxUcE6YkHxqooKTLQJfW4Zq9PB6rPaffxM9p57Ix2HDulHcdOtw07iQpxakRqlEamRWtEarSKU6PkiQwOcNUAAABA4HTlSCSBrZutLK3WZ/64UUVJkXrqwXFyhwcFuqSAafH6VFp5TtvLT2lb+SltLTut0sqz8rZOOEmKClZxarRGpPmDXHFqNINNAAAAMGgQ2HrZzmOndffv1inTHaYXHpqoqNC+MVSkL7nQ5NWu46e1rfy0tpWd0vbyUzpcWy9JshmpKClSo9NjNCYjRqPTY5QWG8JRSgAAAAxIBLZedPpCs+b9arWavT698ehUxUcM3s7atTp5vklby0/p/SMntfnoSW09ekrnm7ySJHd4kMZkRLeFuGEpUQp22gNcMQAAAHDjmBLZi/71tZ06fuqC/vK5SYS1axQT5tKsAo9mFXgk+adT7q04qy1HT2pLa4hbtKtSkuS0Gw1NjrrUhcuIVlJUSCDLBwAAAHoMga0bLNtTpTe3HddXbs7XmIyYQJfT79ltRkOSIzUkOVL3T8yQJNWca9SWIye15egpbTlyUn/acERPrTkkyb/oe2xmrMZlxWpcZozyPRGysVYAAAAAAwBHIm9QQ7NXc/5rhUJcdr39xWlyOfrX6P7+qqnFp5ITZ7Tl6EltOnJSmw7XqfJMoyT/RMqxGTEamxmr8VkxGp4Szf8XAAAA9DkciewFz793VMdOXdBzn5lAKOhFLodNxWnRKk6L1qemZMmyLJXVXdDGw3XaeLhO7x2u09I9VZKkoNZnx7d24UanRysimIEwAAAA6PvosN2AC01eTfvPZcrzhOv5hycGuhx0UHuuURsPn2wLcbuOn5HXZ7VNoxyXGet/yYqRJ4KdcAAAAOhddNh62Euby1RzrlG/vX90oEtBJ+LCgzR3WKLmDkuUJJ1vbNH7R0/pvcN12nS4Tn/ZWKY/rD0sScqMC20LcBOyY5UeG8o6AQAAAAQcge06WZalZ9YdUXFqlMZlxga6HHRBWJBDU/PcmprnliQ1e33aeey0Nh0+qfcO12lJSaVe2lwuSUqMDNaE7FhNyIrTxOxYZbnDCHAAAADodQS267TuQK32V53TT+8uDnQpuE5Ou02j0mM0Kj1GD03Pls9n6UD1Oa0/VKcNB2u19kCtXt96XJIUHxGkCVmxmpAdp4lZscr1hBPgAAAA0OMIbNfpxU1ligpx6o4RSYEuBd3EZjPKS4hQXkKEHpiYIcuydKjmvNYfrNOGQ7XacLBOC7afkCS5w10an+XvwE3IjmWVAAAAAHoEge06NDR7tXh3peYVJyvYaQ90Oeghxhhlx4crOz5cH5+QLsuydLSuXusP+sPb+oO1entHhSQpJtT5gQBXlBhJgAMAAMANI7Bdh+V7q3S+yas7RiQHuhT0ImOMMuLClBEXpo+N8we48pMX/AHukD/ALdpVKUmKDHZofOv9twlZcRqSHCk7AQ4AAADXiMB2HRZsP6G4MJcmZjNsZDAzxigtNlRpsaG6e2yaJOnYqQvacLEDd6hWS0r8AS4iyKFxWbGakBWrSTlxGpocRYADAADAVRHYrpHXZ2llabVuHZooh51F2figlOgQfXh0qj48OlWSVHG6QRsO1frvwR2s1buty7wjgh2akBWnSTlxmpQdp8JE7sABAADg/yKwXaPt5ad0pqFF0/PjA10K+oHEqGDNH5mi+SNTJElVZxq07mCt1h2o1bqDlzpwMaFOTcy+FOCYQgkAAACJwHbNVpbWyBhpSq470KWgH/JEfjDAHTt1wR/eDtRq/cFa/W2nf4iJOzyoLbxNzolTRhyLvAEAAAYjAts1Wr2/WsNTohQb5gp0KRgAUqJD9NExqfromNS2KZQXu2/rDtTqzW3+PXBJUcGadLEDlxOn1JjQAFcOAACA3kBguwaNLV5tKz+tT07KCHQpGIDaT6G8d7x/CuWB6vNad7BW6w/UanlptV59/5gkKS02pLX75taknDglRAYHuHoAAAD0BALbNdh9/IyaWnwanR4T6FIwCBhjlOsJV64nXA9MzJDPZ6m06qzWHajV2gO1WrizQi9uKpckZbvD2rpvE7Pj5A4PCnD1AAAA6A4Etmvw/tFTkqRRBDYEgM1mVJgYqcLESH1qSpa8PkslJ860Brgavb71uP604agkqSAhoi28TcyOVXQoR3gBAAD6IwLbNXi/7JSSo4KVGMXxMwSe3WY0LCVKw1Ki9ND0bLV4fdpx7HTb/bcXNh7VH9YeljHSkKRITcl1a3JOnMZnxSrUxV99AACA/oDP2q7B1rKTGpkeHegygE457DaNSo/RqPQYfX5mrppafNpWfkpr9/s7cE+vOaQnVh6U0240Ki1Gk3PjNCXXrZFp0XKyUxAAAKBPIrB10dmGZpXVXdC949IDXQrQJS6HTeMyYzUuM1ZfuilPF5q82ni4Tmv212jNgRr9Yuk+/XzJPoW67BqfFaspOW5Nzo1TUWIkS7wBAAD6CAJbF5VWnpXkvxsE9EchLrum58e3LX0/Vd+kdQdqteZAjdbur9XyvSWSpNgwl38CZW6cpuS42QEHAAAQQAS2LtpbcU6SVJBIYMPAEB3q0m3Dk3Tb8CRJ0onTF7Rmf63Wtnbg3tpxQpJ/V9zkHP/xycm5cfJEcIcTAACgtxDYumhvxRmFuexKiQ4JdClAj0iK+uAS7wPV57X2QI3W7K/Rol0Vemmzf4VAfkK4Jue4NSXXrQnZsYoMdga4cgAAgIGLwNZFeyrOKj8xgrs9GBTa74D7+0mZ8vos7Tp+2t+BO1DTNoHSZqQRqdGa0np8cnRGjIKd9kCXDwAAMGAQ2Lpof9U53VSUEOgygICw24xGpEZrRGq0/mFmjhpbvNpy5FRbB+53Kw7qv5cdUJDDprGZMW0duOEpUbLzRQ4AAIDrRmDrgnONLao936QMd2igSwH6hCCHXZNy4jQpJ05fvaVAZxua9d6hurYO3E8W7dVPFu1VRLBDE7PjNCUnTpNz3crzhDPABAAA4BoQ2LrgSO15SVJGbFiAKwH6pohgp+YUJWhOaxe65lyj1h64NMBk8e5KSVJ8RJCmtA4wmZrnVlIUd0IBAACuhMDWBUdr6yVJGXF02ICucIcH6c7iZN1ZnCxJKqurb93/VqtV+2r02tbjkqSc+DBNy4vXlFy3JmbHKoIBJgAAAB9AYOuCI3X+wJZOYAOuS1psqO4dn657x6fL57O0p+Ks1uyv0ar9lwaY2G1GI9OiNSXXrWl5bo1Mi5bTbgt06QAAAAFFYOuCI7X1igl1Mr4c6AY2m9GQ5EgNSY7UQ9Oz1dji1eYjJ7Vmf41W76vRr97dp18u3acwl91//601wOVy/w0AAAxCBLYuOFp3Xulx3F8DekKQw67JOW5NznHrn2+VTtU3ad2BWq3eX6PV+2u0dE+VJCkhMsh/9631xRPJAm8AADDwEdi6oKzugkakRgW6DGBQiA516bbhSbpteJIk//23i+Ft2Z4qvbrlmCT/Au+pufGamhenCVlxCgvinzMAADDw8BnOVViWpYozDbo1ih1sQCCkxYbqvvHpuq/1/tvuE2f8AW5fjZ7bcERPrTkkh81odHqMpub5978Vp0bJwf03AAAwAFw1sBlj0iQ9IylRkk/SE5Zl/aLDM0bSLyTdLqle0oOWZW3p/nJ736n6ZjW1+JTA8Ssg4Gw2o2EpURqWEqVHZuSoodmrTYdPtnbgqvWzJaV6fHGpIoIcmpgTp2mtAS7bHcb9NwAA0C91pcPWIumrlmVtMcZESNpsjFlsWdbuds/cJimv9WWCpN+2ftvvVZxpkCQlRhHYgL4m2GnX1Dz/TjepUHXnm7T2QI1/AuW+S/vfkqOC23a/Tcl1yx0eFNjCAQAAuuiqgc2yrBOSTrR+/6wxpkRSiqT2gW2+pGcsy7IkrTfGRBtjklp/bL/WFtjosAF9XmyYS3eMSNYdI5JlWZaO1tVr1T5/gHtnd6Ve2lwuSSpMjGjrvk3IilOIyx7gygEAADp3TXfYjDGZkkZJ2tDhXSmSytq9Xt76tn4f2CpP+wMbRyKB/sUYo4y4MGXEhen+iRny+iztPHa67f7bH9ce0f+uOiSX3abRGdFtC7yHp0TJbuP4JAAA6Bu6HNiMMeGSXpH0ZcuyznR8dyc/xOrk53hY0sOSlJ6efg1lBs7FDhuBDejf7Daj4rRoFadF6wuzcnWhyav3Dte1HZ/8yaK9+smivYoMdmhyjlvT8t2anhevtNjQQJcOAAAGsS4FNmOMU/6w9ifLsl7t5JFySWntXk+VdLzjQ5ZlPSHpCUkaO3bs/wl0fVHlmQbFhbnkcjBxDhhIQlx2zciP14z8eElSzbnGtuXdq/fXaOGuCklSZlyopuXFa1qeW5Ny4hQR7Axk2QAAYJDpypRII+n3kkosy3r8Mo+9IelRY8wL8g8bOT0Q7q9JUsXpBrprwCDgDg/S/JEpmj8yRZZl6UD1ea3aV61V+2r0ypZyPbv+iOw2o1Fp/uOT0/LdGpHC+gAAANCzutJhmyLpAUk7jDFbW9/2LUnpkmRZ1u8kvS3/SP/98o/1/1T3lxoYNeea5IlkohwwmBhjlOsJV64nXJ+akqWmFp+2HD3ZFuB+vrRUP1tSqshgR9v0SY5PAgCAntCVKZGr1fkdtfbPWJK+0F1F9SV155uUlxAe6DIABJDLYdPE7DhNzI7TP9/q/3fh4vHJlfuq9bedHJ8EAAA945qmRA5GdeebFBvqCnQZAPqQ2DCX5hUna15x8hWPT45Oj9bUXI5PAgCA60dgu4ILTV5daPYqNpzABqBz13p88mIHjuOTAACgKwhsV1BX3yRJdNgAdBnHJwEAQHcisF1B3bnWwBZGYANwfa7l+OS0vHhNzeP4JAAAuITAdgVtHTYCG4BucLXjkz9bUqrHF3N8EgAAXEJgu4K6842SCGwAekZXj09mucM0Lc+tqbkcnwQAYLAhsF1B3flmSQQ2AL3jSscnX95crmfWffD45LQ8t0akRstuu+LmFQAA0I8R2K6g7nyj7DajSL6aDaCXXevxyRn58ZqeH6/k6JBAlw4AALoRge0KTtY3KzrEKRtfvQYQYJc7PrlqX7VWlta0HZ/M9YRrel68pue7NTE7TsFOe4ArBwAAN4LAdgVnLjQrMoTuGoC+p+PxyX1V57SytForSqv13IYjemrNIQU5bBqfFdvWfcvzhMsYvgAFAEB/QmC7grMNLYoI5rcIQN9mjFF+QoTyEyL02WnZamj2asOhOq3YW62V+6r1o7dKpLdKlBQVrGl5bs3I92hqrltRoXxBCgCAvo40cgVnG5q5vwag3wl22jUjP14z8uMlScdPXdDKUn94W7izQi9uKpfNSMVp0a3HJ+M1Mo3hJQAA9EUEtis429CihMjgQJcBADckOTpE945P173j09Xi9Wlb+WmtKK3WytJq/erdffrF0n2KDHZoWuvdt+n58UqKYngJAAB9AYHtCs40NHMkEsCA4rDbNCYjRmMyYvSVm/N1qr5Jq/fX+DtwpTV6a8cJSVKeJ1zTW7t047NiGV4CAECAkEauwH+HjSORAAau6FCX7hiRrDtG+IeXlFaeazs++ez6I/r9av/wkgnZcZqe518fkMvwEgAAeg2B7TJavD7VN3m5wwZg0DDGqCAxQgWJEXpoerYuNHm14VCtVpbWaEVplX70Vol+9FaJkqOCNb118uSUHIaXAADQkwhsl3G2oUWSOBIJYNAKcdk1s8CjmQUeSUN07OLwktJqvbXjhF7YWCabkUamRbcFuOJUhpcAANCdSCOXQWADgA9KiQ7RfePTdV/b8JJTWlFaoxWl1frF0n36+ZJ9igpxamqeWzNap08mRjG4CQCAG0EauYwzDc2SxB02AOiEf3hJrMZkxOorN+fr5Pl2w0v2Veut7f7hJfkJ4ZqeF68ZBfEal8nwEgAArhWB7TIuBrbIEH6LAOBqYsJcmlecrHnFl4aXrCit0srSGj2z/oieXH1IwU6bJmTF+XfEFcQr2x3G8BIAAK6CNHIZF49EMnQEAK5N++ElD0/P0YUmr9YfqtXK0mqtKK3WDxbslhZIabEhmpnv0Yz8eE3OjVOoiw9JAAB0xEfHy+AOGwB0jxCXXbMKPJpV4JEkldXVa0VptZbvrdYrW8r17PojctltGpcVo5n5Hs0sYHUAAAAXkUYuo77JH9j4ii8AdK+02FDdPzFD90/MUGOLV5sPn9Ty0mqt2FutH79doh+/XaKU6JC2xd1TcuO4TwwAGLRII5dR3+SVJIW6uCAPAD0lyGHX5Fy3Jue69a3bi3S8dXXA8r3VWrDtuJ5/76gcNqMxGTGaWeA/PlmUFEH3DQAwaBDYLuNiYAthohkA9Jrk6BDdOz5d945PV7PXpy1HLnXfHlu4R48t3CNPRJBm5MdrZoFHU/Pcigqh+wYAGLgIbJdxoalFwU6bbCyABYCAcNptmpAdpwnZcfrG3EJVnWnw330rrdaiXRV6aXO57DajUWnRmlkQrxn5Hg1NjuTfbQDAgEJgu4z6Ji/31wCgD/FEBuvusWm6e2xa2+Lu5Xv9kyd/+k6pfvpOqdzhrra9b9Py4hUb5gp02QAA3BASyWVcaPJyfw0A+qj2i7u/ekuBas41atU+/923ZXur9Or7x2SMVJwa3Xp8Ml4jUqNlp/sGAOhnCGyXUU9gA4B+wx0epLtGpequUany+iztOHZay/dWaUVptX757j79Yuk+xYQ6NS3PH96m5cUrPiIo0GUDAHBVBLbLqG/2KoQjkQDQ79htRiPTojUyLVpfvilfJ883adX+Gi3fW6WVpdV6Y9txSdLwlKjWu2/xGpkWLYfdFuDKAQD4v0gkl1Hf2KJQJkQCQL8XE+bSncXJurM4WT6fpd0nzrR1336z/IB+9e5+RQY7NK317tuM/HglRAYHumwAACQR2C6rvsmrpChGRQPAQGKzGQ1LidKwlCg9OjtPpy80a01r921FabXe2nFCklSUFKlZBfGaVejRKLpvAIAAIrBdxoVmr0K4wwYAA1pUiFO3D0/S7cOTZFmW9lSc1YrSai3bU6UnVh7Ub5YfUGSwQ9Pz4zWrwKMZBfFyh3P3DQDQewhsl1Hf1MLQEQAYRIwxKkqKVFFSpB6ZkaMzDc1as69Gy/ZWadneai3YfkLGSCNSojSzwKNZhR6NSIli7xsAoEcR2C6DPWwAMLhFBjt12/Ak3TY86QN335btrdavWidPxoW5/GsDCj2anudWdCh73wAA3YtEchkXmjgSCQDw63j37eT5Jq3c5z86eXHvm81IYzJi/N23Ao+KkiJkDN03AMCNIbB1oqnFpxafpTACGwCgEzFhLs0fmaL5I1Pk9VnaVn5Ky/f4u28/WbRXP1m0VwmRQZpV4NHMAo+m5rkVHsSHXADAteOjRycuNHkliT1sAICrstuMRqfHaHR6jL5yS4GqzjZoxd5qLd/rnzr5wsYyOe1G4zJjNavAo1mF8cqJD6f7BgDoEhJJJ+qbWySJoSMAgGvmiQjW3WPTdPfYNDV7fdpy5KSW7a3W8r1V+vHbJfrx2yVKjQlpC2+Tst0cwQcAXBaBrRMNzT5JUrCTvTsAgOvntNs0ITtOE7Lj9C+3Fer4qQtavrday/ZW6ZUt5Xp2/RG5HDZNyo5r2/uWERcW6LIBAH0Iga0TjS3+I5HBDr7iCQDoPsnRIfr4hHR9fEK6Glu82njoZOvagCp9/83d+v6bu5XtDmtdGxCv8VmxCuJjEQAMalcNbMaYpyTdIanKsqxhnbx/pqTXJR1qfdOrlmX9oDuL7G2NrR02l4MOGwCgZwQ57Jqa59bUPLe+c8cQHa4537Y24LkNR/TUmkMKddk1JdfdOrwkXsnRIYEuGwDQy7rSYfuDpF9LeuYKz6yyLOuObqmoD2hs8Qc2vqoJAOgtme4wPejO0oNTsnShyat1B2u0bE+13t1TpcW7KyVJhYkRmlng0exCj0anR8th5wuLADDQXTWwWZa10hiT2fOl9B0Xj0QGcYcNABAAIS67ZhcmaHZhgn5gWTpQfU7L9vjvvj256qB+t+KAokKcmpEfrzlFHs3Ij2dpNwAMUN11h22SMWabpOOSvmZZ1q7OHjLGPCzpYUlKT0/vpl+6+zW1ddgIbACAwDLGKNcToVxPhB6anq2zDc1ava9GS/dUadmeKr2x7Xjb0u7ZhQmaU+RRnoe1AQAwUHRHYNsiKcOyrHPGmNslvSYpr7MHLct6QtITkjR27FirG37tHsGRSABAXxUR7NRtw5N02/Ak+XyWth87rXdLKrV0T5UeW7hHjy3co5ToEM0p8h+dnJgdp2AnH88AoL+64cBmWdaZdt9/2xjzG2OM27Ksmhv9uQPl4pFIho4AAPoym81oZFq0RqZF6yu3FKjidIOW7a3S0pIqvbSpXM+sO6IQp39wyZwij2YVeJQYFRzosgEA1+CGA5sxJlFSpWVZljFmvCSbpNobriyALk6J5EgkAKA/SYwK1n3j03Xf+HQ1NHu1/mCt3t3jD3BLSvyDS4YmR2pOoUezixI0IiVKNhtHJwGgL+vKWP/nJc2U5DbGlEv6niSnJFmW9TtJH5X0D8aYFkkXJN1rWVafPe7YFY3cYQMA9HPBTrtmFng0s8Cjf7vT0r6qc1paUqV391Tq18v265fv7pc73KWZBR7NKfRoap5bEcHOQJcNAOigK1Mi77vK+38t/9j/AaNt6Ahn/gEAA4AxRvkJEcpPiNA/zMzRyfNNWrmvWktL/CsDXt5cLqfdaHxWbOt0So+y3GGBLhsAoO6bEjmgtI31p8MGABiAYsJcmj8yRfNHpqjF69OWo6e0dE+l3i2p0g8X7NYPF+xWtjtMswv9g0vGZsZyrxsAAoTA1onGFp+MkRyc6wcADHAOu03js2I1PitW37ytSDWlSVAAACAASURBVGV19f57b3uq9My6I3py9SFFBDk0PT9eswo9mlkQL3d4UKDLBoBBg8DWicYWn4IcNnbYAAAGnbTYUH1ycqY+OTlT5xtbtGZ/jd7dU6V391TprR0nZIxUnBrdOrjEoyFJkXy8BIAeRGDrRGOzlx1sAIBBLyzIoVuGJuqWoYmyLEu7jp/xDy7ZW6X/Wlyq/1pcqqSoYM0p8mhOUYImsfMNALodga0TTV4f99cAAGjHGKNhKVEalhKlL92Up6qzDVq+t1pLSyr16pZjem79UYW67JqW59ZNRf7BJXEcnQSAG0Zg60Rjs09BTgIbAACX44kI1j1j03TP2DQ1NHu17mCtlpZUasnuKi3aVSljpNHpMZpT5NHNRQnK9YRzdBIArgOBrRONLT657AQ2AAC6Ithp16wCj2YVePTD+f6jk0tKKrWkpFL/uXCv/nPhXqXHhuqmogTdVOTRuKxYOfk4CwBdQmDrRGMLd9gAALge7Y9OfvmmfJ04fUFLS6q0tKRSz204oqfWHFJEsEMzCzy6qcijmfkeRYWysBsALofA1onGFo5EAgDQHZKiQnT/xAzdPzFD9U0tWrWvRkt2V+rdPVV6c9tx2W1G4zNj/UcnhyQoI46F3QDQHoGtExfH+gMAgO4T6nLo1qGJunVoorw+S1vLTvnvvZVU6kdvlehHb5UozxOuOUUJunmIRyPTYmRnJyqAQY7A1onGFp+iQzieAQBAT7HbjMZkxGhMRoy+PrdQR2vrtaSkUkv3VOrJVQf1uxUHFBvm0uxC/9HJaXnxCgvi0xYAgw//8nWiqcXHZWgAAHpRelyoPj01S5+emqXTF5q1srRaS0oq9c6uCr28uVwuu02TcuJ00xD/4JKkqJBAlwwAvYLA1okWr09OO0cwAAAIhKgQp+YVJ2tecbKavT5tOnyy7ejkd17bqe+8Jg1NjvQfnSxK0LCUSFYGABiwCGydaPbSYQMAoC9wtnbWJuXE6dt/V6QD1ef9RydLKvXrd/fpl0v3KSkqWDcPSdAtQxI1IZuVAQAGFgJbJ5q9lhx02AAA6FOMMcr1hCvXE65HZuSo7nyTlpZUavHuSr24qUzPrDuiiGCHZhf6J07OyI9XRDB30gH0bwS2TrT4fHLa+OocAAB9WWyYS3ePTdPdY9N0ocmr1ftrtHh3hZaUVOn1rcfb7r3dMtR/dNITGRzokgHgmhHYOtHsteR00GEDAKC/CHHZdfOQBN08JEFen6UtR0/qnV0Vemd3pb7915369l93amRatG4ekqBbhyYoJz6ce28A+gUCWyeavT456LABANAv2W1G4zJjNS4zVt+6vUj7qs5p8W7/xMmfLNqrnyzaqyx3WOu9twSNSmffG4C+i8DWiRavxZRIAAAGAGOM8hMilJ8QoS/MylXF6QYtbr339vSaQ3pi5UHFhbl0U5G/Ozc1z61gpz3QZQNAGwJbJ5gSCQDAwJQYFawHJmbogYkZOtPQrBV7q/XO7kq9veOE/rKpTCFOu6bnu3XLkETNLvQoJswV6JIBDHIEtg4sy1KLz5KDwAYAwIAWGXxp31tTi0/rD9Zq8W5/923RrsrWo5UxunlIom4ZkqC02NBAlwxgECKwddDisyRJTs6yAwAwaLgcNk3Pj9f0/Hj9YP5Q7Th2Wu/s8oe3Hy7YrR8u2K3CxAjdMtQf3oYms6wbQO8gsHXQ7PVJkpwOOmwAAAxGxhiNSI3WiNRofe3WAh2pPd86tOTSsu6U6BDNHZaoW4cmakwGQ0sA9BwCWwfNXn+HzcE/vAAAQFJGXJg+Oy1bn52WrdpzjVpaUqVFuyr07Loj+v3qQ3KHu3TzkETdOjRBk3PccvFFXwDdiMDWQcvFDht32AAAQAdx4UG6Z1ya7hmXprMNzVq+t1oLd1Xoja3H9Px7RxUR7NCcQo/mDkvU9Px4hbr4VAvAjeFfkQ7a7rAR2AAAwBVEtBta0tDs1Zr9NVq4s0JLSir12tbjCnbaND0vXnOHJWpOYYKiQp2BLhlAP0Rg66Cpxd9hc7CHDQAAdFGw0645RQmaU5SgFq9P7x2u06KdFVq0q1Lv7K6Uw2Y0KSdOtw5N1C1DE+SJCA50yQD6CQJbB5c6bAQ2AABw7Rx2mybnuDU5x63vzRuq7cdOa+HOCi3aVaF/fW2nvvP6To1Jj9GtQ/1DS9LjWBcA4PIIbB1whw0AAHQXm81oZFq0RqZF6xtzC7Sv6pwW7qzQwp0V+vHbJfrx2yUakhTZNnEyPyGcdQEAPoDA1kFTa2Bz2AhsAACg+xhjlJ8QofyECH1xTp7K6uq1aJc/vP1sSakeX1yqLHeYbh2aqLnDEjUiJUo2plYDgx6BrYMWL0ciAQBAz0uLDW1bF1B1tkGLd1dq4c4KPbnqoH634oASI4M1d1iibh+exK43YBAjsHXQ4rs4dIQOGwAA6B2eiGB9YkKGPjEhQ6frm/Xu3kr9bUeFnn/vqP6w9rDiI4I0d2iibhueqPGZsXyeAgwiBLYOmlrosAEAgMCJCnXqrlGpumtUqs41tmjZnir9becJvbS5TM+uP6K4MJduHZao24claWI24Q0Y6AhsHVzssDF0BAAABFp4kKNt11t9U4uW763W2ztO6LX3j+nPG44qJtSpW4b4O29Tct18/gIMQAS2Di7eYXNwThwAAPQhoS6Hbh+epNuHJ6mh2asVpf7w9taOE/rLpjJFhTh185AE3d4a3oIc9kCXDKAbENg6aGKsPwAA6OOCnfa2PW4NzV6t3lejt3ec0KJdFXp5c7kighy6aUiCbh+epGl5bgU7CW9Af0Vg6+DSlEgCGwAA6PuCnXbdNCRBNw1JUGOLV2v31+rtHSf0zu5K/fX9Ywpz2TWnyN95m5HvUYiL8Ab0JwS2Di5NieRIJAAA6F+CHHbNKvRoVqFH/+71ae2BWv2ttfP2xrbjCnX533/7sCTNKoxXqItPBYG+jr+lHTS1+AObiw4bAADox5x2m2bkx2tGfrx+9KFh2nCoTm/tOKFFOyv01vYTCnbaNLvQoztGJGt2oYdjk0AfRWDroMXXOnSEDhsAABggHHabpuS6NSXXrR/OH6b3DtXprR3H9bcdFXp7R4VCXXbdVJSgecXJmp7PwBKgL7lqYDPGPCXpDklVlmUN6+T9RtIvJN0uqV7Sg5ZlbenuQntLS+vQEYeNDhsAABh47DajSTlxmpQTp+/PG6r1B+u0YPtxLWw9NhkR5NDNQxM0b0SypuS65XLwOREQSF3psP1B0q8lPXOZ998mKa/1ZYKk37Z+2y81e1mcDQAABgeH3aapeW5NzXPrhx8aptX7a7Rg2wm9s7tCr245pqgQp+YOTdQdxUmalB3Hkm4gAK4a2CzLWmmMybzCI/MlPWNZliVpvTEm2hiTZFnWiW6qsVd5W49E2tnDBgAABhGn3aZZBR7NKvCosWWYVpXWaMH241qw/bj+sqlMcWEuzR2WqDtGJGt8ViyfKwG9pDvusKVIKmv3ennr2/pnYLMuLs7mK0gAAGBwCnJcWhXQ0OzV8r1VenP7Cb2ypVx/2nBUnogg3T48SXeMSNLo9BjZCG9Aj+mOwNbZ31Cr0weNeVjSw5KUnp7eDb9097vYYSOvAQAA+Pe8zR2WpLnDklTf1KKlJVVasP24/vzeUf1h7WElRwX7w1txsopTo+QfbwCgu3RHYCuXlNbu9VRJxzt70LKsJyQ9IUljx47tNNQF2sXARocNAADgg0JdDs0rTta84mSdbWjWkpJKLdh2Qn9cd1hPrj6ktNgQzRuRrPkjU1SQGBHocoEBoTsC2xuSHjXGvCD/sJHT/fX+mnRprD+dfQAAgMuLCHbqrlGpumtUqk7XN2vR7got2H5C/7PyoH6z/IAKEyM0f2SK5hUnKTUmNNDlAv1WV8b6Py9ppiS3MaZc0vckOSXJsqzfSXpb/pH+++Uf6/+pniq2N/h8luw2QzsfAACgi6JCnbpnbJruGZummnONenvHCb2+9bgeW7hHjy3co3GZMbpzZIr+bniSYsNcgS4X6Fe6MiXyvqu835L0hW6rKMBafJbshDUAAIDr4g4P0t9PytTfT8pUWV293th2XK+9f0zfeW2n/u2NXZqW59b8kSm6eUiCwoK647AXMLDxt6QDn2UxphYAAKAbpMWG6guzcvX5mTnaU3FWr289rje3HdeX/7JVwU6bbh6SqPnFyZqeH8+CbuAyCGwdtHgJbAAAAN3JGKOipEgVJUXq67cWaPPRk3p96zG9tf2E3tx2XFEhTt0+PEnzRyZrfGYsawKAdghsHdBhAwAA6Dk2m9G4zFiNy4zV9+YN1ep9NXp96zG9vvWYnn/vqBIjg3XnyGTdWZysocmRzBXAoEdg66DF5yOwAQAA9AKn3aZZhR7NKvSovqlFS0qq9MbWY3pq9SE9sfKgcj3humtUij40KkUp0SGBLhcICAJbB16fCGwAAAC9LNTl0J3F/s7ayfNNenvnCb32/jH9ZNFe/fSdvZqYFacPj07RbcOTFM6wEgwi/GnvwOvzMSUSAAAggGLCXPrEhAx9YkKGjtbW66/vH9Or75frn1/eru+8vlO3Dk3UXaNSNDXXLYedYSUY2AhsHdBhAwAA6DvS40L1pZvy9MU5udpy9JRe3VKuBdv9e97iI4I0vzhZHx6dqiHJkYEuFegRBLYOvNxhAwAA6HOMMRqTEaMxGTH67rwhWranSq9uOaY/rjusJ1cfUmFiRNt9t4TI4ECXC3QbAlsHXktyENgAAAD6rCCHXXOHJWnusCSdPN+kBduP65Utx/Qff9ujxxbu0ZRctz48OkW3Dk1UqItPd9G/8Se4A6/Px+4PAACAfiImzKUHJmXqgUmZOlh9Tq+9f0yvvn9M//SXbQp17dTcYYm6e0yaJmSx3w39E4GtA6/PosMGAADQD2XHh+srtxToyzfla9ORk3p1S7ne2n5Cr245prTYEN09Jk0fGZPKigD0KwS2Drw+SzamRAIAAPRbNpvR+KxYjc/yL+detKtCL24q0+OLS/WzJaWamuvWR8ek6tahiQp22gNdLnBFBLYOvD5LDjuBDQAAYCAIcdn1odZhJGV19Xp5c7le3lyuL72wVRHB/t1v94xN04jUKBm+aI8+iMDWQQsdNgAAgAEpLTZU/3Rzvr40J0/rD9bqpc3lemVLuf604ajyE8J195g0fWhUiuIjggJdKtCGwNaBz+IOGwAAwEBmsxlNznVrcq5b/zZ/qBZsO6GXNpfpx2+X6LGFezSr0KN7xqZpZkG8nCzmRoAR2Dpo8VpMEAIAABgkIoOd+viEdH18Qrr2V53VS5vK9er7x7R4d6Xc4S59ZHSqPjYuTdnx4YEuFYMUga0Dn2XxlRQAAIBBKNcToW/eXqR/vrVAK0qr9eKmMv1+9SH9z8qDmpgdq/vGpzOoBL2OwNZBi89SsJMOGwAAwGDlsNs0pyhBc4oSVHW2QS9vLtcL75XpSy9sVXSoUx8Znar7xqcp1xMR6FIxCBDYOvD5LNk5EgkAAABJnohgfX5mrh6ZnqO1B2r1/MajembdYf1+9SGNy4zRvePS9Xcjkui6occQ2Dpo8VmyMyUSAAAA7dhsRlPz3Jqa51bNuUa9uqVcz79Xpq++tE3/9uYu3TUqRfdNSFdhYmSgS8UAQ2DrwOtj6AgAAAAuzx0epIen5+ihadlaf7BOL2w8quffK9Mf1x3RyLRofXx8uu4oTlKoi0+1ceP4U9SB18dYfwAAAFydMUaTcuI0KSdO35vXpFe3lOuFjWX6+ivb9cO3duujY1J1/8QM5TBhEjeAwNaB16LDBgAAgGsTG+bSZ6dl6zNTs7Tx8Ek9t/6Inlt/RE+vOaypuW7dPzFDNxV55GAaOa4Rga0DOmwAAAC4XsYYjc+K1fisWFWdLdKLG8v05w1H9chzm5UYGayPT0jXvePT5IkIDnSp6CcIbB14GToCAACAbuCJCNajs/P0yIwcvbunSs+uP6LHF5fql0v3ae6wRD0wMUPjs2Jl+NwTV0Bg64Cx/gAAAOhODrtNtwxN1C1DE3Ww+pz+tOGoXtpUpgXbT6ggIUL3T8rQXaNSFB7Ep+b4vzhE20ELgQ0AAAA9JDs+XN+5Y4g2fOsmPfaR4XLYjb7z2k5N/Pel+sGbu3W0tj7QJaKPIcZ34LMIbAAAAOhZIS67PjYuXfeMTdP7Zaf0x7WH9cy6w3p67SHdVJSgT0/J0sRsjkuCwPZ/0GEDAABAbzHGaHR6jEanx+hbtxfp2XVH9Of3jmrx7koVJkbo01OzdGdxsoKd9kCXigDhSGQHXgIbAAAAAiAhMlhfu7VAa/9lth77yHBZlvT1l7dryv97V48vLlXV2YZAl4gAoMPWAVMiAQAAEEjBzkvHJdcdqNVTaw7pV+/u02+X79e8Ecn69NQsDUuJCnSZ6CUEtg68Pkt2O4ENAAAAgWWM0eRctybnunWo5rz+uPawXtpUplffP6aJ2bH63IwczcyP557bAMeRyA7osAEAAKCvyXKH6ft3DtW6b83Rt28v0pHaen3q6Y267Rer9MrmcjW1+AJdInoIga0DL1MiAQAA0EdFBjv10PRsrfjnWXr8nmJZlvTVl7Zpxk+W6clVB3WusSXQJaKbEdjasSxLliXZ6LABAACgD3M5bPrw6FQt/PI0Pf2pccqIC9WP3irRpP9YqscW7lHVGQaUDBTcYWvHsvzfEtgAAADQHxhjNKvAo1kFHm0rO6UnVh7U/6w4oN+vOqQPj07Rw9OzlR0fHugycQMIbO34WhMbJyIBAADQ3xSnReu/PzFah2vO68nVB/XSpnK9uKlMd4xI1hdm5aogMSLQJeI6cCSyHe/FwEZiAwAAQD+V6Q7Tjz40XKu/MVsPTc/WkpJK3frzlXrk2c3aeex0oMvDNaLD1g5HIgEAADBQxEcE6Zu3FemR6Tl6es0hPb32sBbuqtDsQo8enZ2r0ekxgS4RXUCHrR2ORAIAAGCgiQlz6Su3FGj1N2bra7fka8vRk/rwb9bq/ic3aP3B2kCXh6sgsLXjo8MGAACAASoqxKlHZ+dpzTdm65u3FWpPxRnd+8R63fvEOm06XBfo8nAZXQpsxpi5xpi9xpj9xph/6eT9Dxpjqo0xW1tfPtv9pfa8ix028hoAAAAGqrAghz43I0ervzFb371jiPZXnddHf7dOn3zqPe0o545bX3PVwGaMsUv6b0m3SRoi6T5jzJBOHv2LZVkjW1+e7OY6e4XVuiCeDhsAAAAGumCnXZ+emqWVX5+pf7mtUNvKT2ner1frc89u0t6Ks4EuD6260mEbL2m/ZVkHLctqkvSCpPk9W1ZgeLnDBgAAgEEm1OXQIzNytOrrs/Tlm/K0dn+t5v5ipb70wvs6VHM+0OUNel0JbCmSytq9Xt76to4+YozZbox52RiT1i3V9bKLRyLtJDYAAAAMMhHBTn35pnyt/PosPTIjR+/sqtRNj6/QN1/drqozDYEub9DqSmDrLL1YHV5/U1KmZVkjJC2R9MdOfyJjHjbGbDLGbKqurr62SnvBpTtsBDYAAAAMTjFhLn1jbqFWfn2WHpiYoZc3l2vmT5frZ4tLdb6xJdDlDTpdCWzlktp3zFIlHW//gGVZtZZlNba++r+SxnT2E1mW9YRlWWMtyxobHx9/PfX2KPawAQAAAH7xEUH6/p1DteQrMzSrwKNfLN2nmT9drj9vOKoWry/Q5Q0aXQlsGyXlGWOyjDEuSfdKeqP9A8aYpHav3imppPtK7D3sYQMAAAA+KCMuTP/9idF69fOTlREbqm/9dYfm/mKVlpZUyrI6HrxDd7tqYLMsq0XSo5IWyR/EXrQsa5cx5gfGmDtbH/uiMWaXMWabpC9KerCnCu5J7GEDAAAAOjc6PUYvPTJJv7t/jLw+S5/54yZ9/H83MFGyhzm68pBlWW9LervD277b7vvflPTN7i2t9/l87GEDAAAALscYo7nDEjWnyKM/bziqxxeX6vZfrtIDEzP0TzfnKyrEGegSB5wuLc4eLJgSCQAAAFyd027TJydnatnXZupj49L0x3WHNfuny/XixrK2Jgi6B4GtHY5EAgAAAF0XG+bSv981XG8+OlWZ7jB9/ZXtuus3a7S17FSgSxswCGztXBrrH+BCAAAAgH5kWEqUXn5kkh6/p1jHTzfort+s0Xde26kzDc2BLq3fI7C1Y7VNiSSxAQAAANfCGKMPj07Vsq/N1IOTM/WnDUd08+MrtGhXRaBL69cIbO1wJBIAAAC4MeFBDn1v3lD99fNTFBPq0uee3azPPbtJFacbAl1av0Rga8frYw8bAAAA0B2K06L15j9O1TfmFmr53mrd/PgKPbf+CLvbrhGBrZ22xdkkNgAAAOCGOe02/cPMHL3zT9M1Ii1K//raTn3y6Y10264Bga0diyORAAAAQLfLiAvTc5+ZoB9+aJg2HqrTLT9bode3HqPb1gUEtnbaOmzkNQAAAKBbGWP0wMQM/e1L05TrCdeXXtiqR//8vurONwW6tD6NwNYOQ0cAAACAnpXpDtNLj0zW1+cW6J3dFZr785Vaf7A20GX1WQS2dtjDBgAAAPQ8u83o8zNz9doXpig8yKGP/+96/XLpvrYhgLiEwNaOz8ceNgAAAKC3DE2O0hv/OFXzipP1+OJS/f1TG1R9tjHQZfUpBLZ2LgZ6O5fYAAAAgF4RHuTQzz82Uv/vw8O16fBJ3f7LVdp0uC7QZfUZBLZ2OBIJAAAA9D5jjO4dn67XH52iMJdd9/3ver24sSzQZfUJBLZ2Lk2JJLEBAAAAva0wMVKvfWGKJmTF6euvbNf339ilFq8v0GUFFIGtHfawAQAAAIEVHerSHz41Tp+ekqU/rD2sB5/eqDMNzYEuK2AIbO2whw0AAAAIPIfdpu/OG6L//OgIrT9Yq3v/Z72qzjYEuqyAILC1c3GMqKHDBgAAAATcPWPT9PsHx+lw7Xl95LdrdajmfKBL6nUEtnYspkQCAAAAfcqM/Hg9/9BEnW/06qO/Xaudx04HuqReRWBrhyORAAAAQN9TnBatlx+ZpGCnXff/foN2HR88oY3A1o6PoSMAAABAn5QdH67nH5qoUKddn3hyg3YfPxPoknoFga0d9rABAAAAfVd6XKheeHiSQpx2feLJ9dpfdTbQJfU4Als7FnvYAAAAgD7NH9omym6z6ZNPbVTVmYE9PZLA1s7FnXwENgAAAKDvyogL09MPjtPJ+iZ96g8bda6xJdAl9RgCWzsXj0Ta+V0BAAAA+rThqVH670+M1p6Ks/rS8+/Ld3EgxQBDNGnn0h02OmwAAABAXzerwKPv3jFES/dU6TfL9we6nB5BYGvHYkokAAAA0K/8/aQMzR+ZrP9aXKpV+6oDXU63I7C1wx42AAAAoH8xxug/PjxceZ5wfeXFbTpV3xTokroVga0d9rABAAAA/U+oy6GffWykTp5v0g/e3B3ocroVga2dixcVyWsAAABA/zI0OUqfn5WrV98/pmV7qgJdTrchsLVzaUokiQ0AAADobx6dlauc+DD9cMFuNV/c2dXPEdja4UgkAAAA0H+5HDZ9+++KdLDmvJ5bfyTQ5XQLAls7l8b6B7gQAAAAANdlVoFHU3Lj9Kt39+tCkzfQ5dwwAls7VtuUSBIbAAAA0B8ZY/TF2XmqO9+kl7eUB7qcG0Zga4cjkQAAAED/Nz4rViPTovXkqoNtgwX7KwJbO14fe9gAAACA/s4Yo09OztCR2nptPnoy0OXcEAJbO22Ls0lsAAAAQL92y5BEhTjtenXLsUCXckMIbO1YHIkEAAAABoSwIIdmF3m0pKSybVZFf0Rga6etw0ZeAwAAAPq9abluVZ9t1P6qc4Eu5boR2Nph6AgAAAD+f3v3FitXVcdx/PtLK0W5X6zcL0FjBKOIDUWIpglagRCqBrTES70FUTHyYAJqgqS+gIpGjdGgkCBBwBvaB1CbaOITSCEoIirVFKnUcikBEQ2p/H2YXRzHmdNpO5fdM99P0pyZvdf0/M/8z9pr/c9ee4/mj1OPOxiAX23YMuVIdp4FWxc/h02SJEmaP4488IXsvWghf/zb36cdyk4bqmBLckaSPyRZn+TSPvsXJbm52X9HkmNGHegkPPecn8MmSZIkzRdJOG7x3qx/dB4viUyyAPgacCZwPHB+kuN7mn0AeKKqXgp8Cbhy1IFOwrYlkQss2CRJkqR5YfE+i3j86WenHcZOG+YM28nA+qr6c1U9C9wErOhpswK4rnn8feD0ZPerelwSKUmSJM0vB+21B4//Y/ct2BYO0eZw4KGu5xuBpYPaVNXWJE8CBwGPdTdKcgFwAcBRRx21kyGPT1WRdE6dSpIkSdr9rTr1GM458bBph7HThinY+lUvvR9kMEwbqupq4GqAJUuWtO7DEN51ytEsP+GQaYchSZIkaURecei+0w5hlwxTsG0Ejux6fgTw8IA2G5MsBPYDdrt7Zy7ed08W77vntMOQJEmSJGC4a9juBF6W5NgkewArgTU9bdYAq5rH5wI/r93548QlSZIkqQW2e4atuSbtIuCnwALg2qq6L8lqYF1VrQGuAa5Psp7OmbWV4wxakiRJkmbBMEsiqapbgVt7tl3W9fhfwHmjDU2SJEmSZttQH5wtSZIkSZo8CzZJkiRJaikLNkmSJElqKQs2SZIkSWopCzZJkiRJaikLNkmSJElqKQs2SZIkSWqpVNV0vnHyKPDgVL55fwcDj007CD3PfLSHuWgPc9Ee5qI9zEV7mIv2MBftsb1cHF1VL57rP5hawdY2SdZV1ZJpx6EO89Ee5qI9zEV7mIv2MBftYS7aw1y0xyhy4ZJISZIkSWopCzZJkiRJaikLtv+6etoB6H+Yj/YwF+1hLtrDXLSHuWgPc9Ee5qI9djkXXsMmSZIkSS3lGTZJkiRJaqmZK9iSnJHkD0nWJ7m0z/5FSW5u9t+R5JjJRzn/JTkyyS+S3J/kviQf79NmWZInk9zTrpwDHQAABVpJREFU/LtsGrHOgiQbktzbvM/r+uxPkq80/eI3SU6aRpzzXZKXd/2+35PkqSQX97SxX4xRkmuTPJLkt13bDkyyNskDzdcDBrx2VdPmgSSrJhf1/DQgF59P8vvmOHRLkv0HvHbOY5p2zIBcXJ7kr13HorMGvHbOeZd2zIBc3NyVhw1J7hnwWvvFiAyax45rvJipJZFJFgB/BN4EbATuBM6vqt91tfkI8KqqujDJSuCtVfWOqQQ8jyU5FDi0qu5Osg9wF/CWnlwsAz5RVWdPKcyZkWQDsKSq+n5OSDMQfww4C1gKfLmqlk4uwtnTHK/+Ciytqge7ti/DfjE2Sd4APA18u6pe2Wz7HLClqq5oJpwHVNUlPa87EFgHLAGKzjHttVX1xER/gHlkQC6WAz+vqq1JrgTozUXTbgNzHNO0Ywbk4nLg6ar6whyv2+68SzumXy569l8FPFlVq/vs24D9YiQGzWOB9zKG8WLWzrCdDKyvqj9X1bPATcCKnjYrgOuax98HTk+SCcY4E6pqU1Xd3Tz+O3A/cPh0o9IcVtAZHKqqbgf2bw5WGp/TgT91F2sav6r6JbClZ3P3uHAdnUG515uBtVW1pRl01wJnjC3QGdAvF1X1s6ra2jy9HThi4oHNoAH9YhjDzLu0A+bKRTNffTtw40SDmkFzzGPHMl7MWsF2OPBQ1/ON/H+R8HybZlB4EjhoItHNqHSWnb4GuKPP7tcl+XWS25KcMNHAZksBP0tyV5IL+uwfpu9otFYyeNC1X0zWS6pqE3QGaWBxnzb2kcl7P3DbgH3bO6ZpNC5qlqdeO2Dpl/1isl4PbK6qBwbst1+MQc88dizjxawVbP3OlPWuCR2mjUYkyd7AD4CLq+qpnt13A0dX1auBrwI/mnR8M+S0qjoJOBP4aLPkopv9YoKS7AGcA3yvz277RTvZRyYoyaeBrcANA5ps75imXfd14DjgRGATcFWfNvaLyTqfuc+u2S9GbDvz2IEv67Ntzn4xawXbRuDIrudHAA8PapNkIbAfO7cMQNuR5AV0fslvqKof9u6vqqeq6unm8a3AC5IcPOEwZ0JVPdx8fQS4hc4ylm7D9B2NzpnA3VW1uXeH/WIqNm9bAtx8faRPG/vIhDQX6J8NvLMGXIg/xDFNu6iqNlfVv6vqOeCb9H+P7RcT0sxZ3wbcPKiN/WK0BsxjxzJezFrBdifwsiTHNn/BXgms6WmzBth2t5Zz6Vzc7F+DRqxZZ30NcH9VfXFAm0O2XT+Y5GQ6v6+PTy7K2ZBkr+aCWZLsBSwHftvTbA3wnnScQueC5k0TDnWWDPwrqf1iKrrHhVXAj/u0+SmwPMkBzdKw5c02jVCSM4BLgHOq6pkBbYY5pmkX9VzH/Fb6v8fDzLs0Gm8Efl9VG/vttF+M1hzz2LGMFwt3PeTdR3NXqYvovCkLgGur6r4kq4F1VbWGzpt/fZL1dM6srZxexPPaacC7gXu7bj/7KeAogKr6Bp2C+cNJtgL/BFZaPI/FS4BbmhpgIfCdqvpJkgvh+VzcSucOkeuBZ4D3TSnWeS/Ji+jcUe1DXdu6c2G/GKMkNwLLgIOTbAQ+A1wBfDfJB4C/AOc1bZcAF1bVB6tqS5LP0pmgAqyuKldn7IIBufgksAhY2xyzbm/u6nwY8K2qOosBx7Qp/AjzxoBcLEtyIp2lXBtojlnduRg075rCjzBv9MtFVV1Dn+ue7RdjNWgeO5bxYqZu6y9JkiRJu5NZWxIpSZIkSbsNCzZJkiRJaikLNkmSJElqKQs2SZIkSWopCzZJkiRJaikLNkmSJElqKQs2SZIkSWopCzZJkiRJaqn/AOMAKWgZDwyqAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "Kst=particles_np['Kst']\n",
+    "l1 =particles_np['l1']\n",
+    "l2 =particles_np['l2']\n",
+    "q_np=particles_np['q']\n",
+    "q2_array=scalar_product_4(q_np,q_np)\n",
+    "q2_range=np.arange(q2_array.min(), q2_array.max(),1000)\n",
+    "print(np.sqrt(q2_array.min()/4), np.sqrt(q2_array.max())+mKst_mass)\n",
+    "\n",
+    "val=np.sqrt(lambda_function(mB_mass, mKst_mass, q2_range))*beta_l(q2_range, mmu_mass)\n",
+    "plt.plot(q2_range/1e6, val);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_array/1e6,bins=70, weights=weights_np,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lorentz_boost(fvector_to_boost, boost_vector):\n",
+    "    \n",
+    "    boost_vector_spatial=-boost_vector[:,0:3]\n",
+    "    boost_vector_time_component=boost_vector[:,3].reshape(-1,1)\n",
+    "    \n",
+    "    beta = boost_vector_spatial/boost_vector_time_component\n",
+    "    beta2 = scalar_product_3(beta,beta).reshape(-1,1)\n",
+    "    \n",
+    "    gamma = 1./np.sqrt(1.-beta2)\n",
+    "    gamma_ = (gamma-1.)/beta2\n",
+    "    \n",
+    "    ve = fvector_to_boost[:,3].reshape(-1,1)\n",
+    "    vp = fvector_to_boost[:,0:3]\n",
+    "    \n",
+    "    ve2 = gamma*(ve + scalar_product_3(vp,beta).reshape(-1,1))\n",
+    "    vp2 = vp + (gamma*ve + gamma_*scalar_product_3(vp, beta).reshape(-1,1))*beta\n",
+    "    \n",
+    "    boosted_fvector=np.concatenate([vp2,ve2],axis=1)\n",
+    "    return boosted_fvector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_q = lorentz_boost(l1, q_np)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p2_q = lorentz_boost(l2, q_np)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(True, True, True)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1_q[:,0:3]+p2_q[:,0:3]).mean()<1e-10, np.sqrt(scalar_product_4(p1_q,p1_q)).mean()-105<1e-10, np.sqrt(scalar_product_4(p2_q,p2_q)).mean()-105<1e-10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cos_theta_l_np=get_costheta_l(p1_q,z)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def dGamma_weights():\n",
+    "    \n",
+    "    Kst=particles_np['Kst']\n",
+    "    l1 =particles_np['l1']\n",
+    "    l2 =particles_np['l2']\n",
+    "    q=particles_np['q']\n",
+    "    \n",
+    "    \n",
+    "    q2 = scalar_product_4(q,q)\n",
+    "    modq = np.sqrt(q2)\n",
+    "    \n",
+    "    l1_q = lorentz_boost(l1, q)\n",
+    "    l2_q = lorentz_boost(l2, q)\n",
+    "    \n",
+    "\n",
+    "    cos_theta_l=get_costheta_l(l1_q,z)\n",
+    "\n",
+    "    #G_weights = 1/(1-cos_theta_l*(mmu_mass)**2)\n",
+    "    #print(cos_theta_l)\n",
+    "    G_weights = (q2/(1-beta_l(q2,mmu_mass))) #*(1+cos_theta_l+cos_theta_l**2)\n",
+    "    \n",
+    "    return G_weights\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dGamma=dGamma_weights()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_array/1e6,bins=70, weights=weights_np*dGamma,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "q2_array=scalar_product_4(q_np,q_np)\n",
+    "q2_range=np.arange(4*mmu_mass**2, (mB_mass-mKst_mass)**2,1000)\n",
+    "\n",
+    "val=(q2_range/(1-beta_l(q2_range,mmu_mass)))*np.sqrt(lambda_function(mB_mass, mKst_mass, q2_range))*beta_l(q2_range, mmu_mass)\n",
+    "plt.plot(q2_range/1e6, val);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#class dGamma(zfit.pdf.ZPDF):\n",
+    "#    \n",
+    "#    _PARAMS = ['ml','mB','mKst']\n",
+    "#    _N_OBS = 16\n",
+    "#\n",
+    "#    def _unnormalized_pdf(self, x):\n",
+    "#        \n",
+    "#        ml = self.params['ml']\n",
+    "#        mB = self.params['mB']\n",
+    "#        mKst = self.params['mKst']\n",
+    "#        \n",
+    "#        pKstx, pKsty, pKstz, pKstE, qx, qy, qz, qE, p1x, p1y, p1z, p1E, p2x, p2y, p2z, p2E = x.unstack_x()\n",
+    "#        \n",
+    "#        pKst = np.array([pKstx, pKsty, pKstz, pKstE])\n",
+    "#        q = np.array([qx, qy, qz, qE])\n",
+    "#        p1 = np.array([p1x, p1y, p1z, p1E])\n",
+    "#        p2 = np.array([p2x, p2y, p2z, p2E])\n",
+    "#        \n",
+    "#        #z = tf.expand_dims(tf.stack([0., 0., 1., 0.],         axis=0), axis=0)\n",
+    "#        #z = [0.,0.,1.]\n",
+    "#        q=p1+p2\n",
+    "#        q2=scalar_product_4(q,q)\n",
+    "#        modq = ztf.sqrt(q2)\n",
+    "#\n",
+    "#        #q_in_q_rf = lorentz_vector([0.,0.,0.], modq)\n",
+    "#        #p1q = lorentz_boost(p1, q_in_q_rf)\n",
+    "#        #costheta_l= get_costheta_l(p1, z)\n",
+    "#        \n",
+    "#        pdf= lambda_function(mB, mKst, q2)*beta_l(q2, ml)\n",
+    "#        return pdf\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEFCAYAAAD36MwKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAKc0lEQVR4nO3dX4ymZ1nH8d9FV0FQB+MSE/uHqZYUN0ZEJ4iQmEZMbFMXIsSE+ifRNOyJIBqJLp5pYuwBMZqAmg1WYiQlWnvg2gZMENMeEEILoq21pimFbotpCTL+OakNlwfzAtt1uzPZGfZ55+rnc7Izz+47ufJk97v33u8z91Z3B4A5XrD0AAAcLGEHGEbYAYYRdoBhhB1gmCNLD5AkR48e7c3NzaXHADhU7rvvvi9298vOvb4WYd/c3My999679BgAh0pVfe58123FAAwj7ADDLBr2qjpeVae2t7eXHANglEXD3t2nu/vExsbGkmMAjGIrBmAYYQcYRtgBhhF2gGHW4huU9mPz5J0X/dpHb7nxACcBWA9W7ADDCDvAMMIOMIywAwwj7ADDOCsGYBhnxQAMYysGYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGG8R9tAAzjP9oAGMZWDMAwwg4wjLADDCPsAMMIO8Awwg4wjLADDCPsAMMIO8Awwg4wjLADDCPsAMMIO8Awwg4wjLADDCPsAMMIO8Awwg4wjLADDCPsAMMsGvaqOl5Vp7a3t5ccA2CURcPe3ae7+8TGxsaSYwCMYisGYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxhG2AGGEXaAYYQdYBhhBxjmwMNeVddV1T1V9SdVdd1Bf30ALmxPYa+qW6vqyaq6/5zr11fVQ1X1cFWdXF3uJP+d5EVJzhzsuADsZq8r9g8kuf7sC1V1WZL3JbkhybEkN1XVsST3dPcNSX4zyW8f3KgA7MWewt7ddyf50jmXX5Pk4e5+pLufTvKhJG/q7q+sfv4/krzwwCYFYE+O7OO1lyd57KzPzyT5kap6c5KfTPLSJO99rhdX1YkkJ5Lkqquu2scYAJxtP2Gv81zr7r4jyR27vbi7TyU5lSRbW1u9jzkAOMt+noo5k+TKsz6/IskT+xsHgP3az4r9k0leUVVXJ3k8yVuT/OyBTHWJbJ6886Jf++gtNx7gJAAHZ6+PO96W5ONJrq2qM1V1c3c/k+TtST6S5MEkf9ndD3zjRgVgL/a0Yu/um57j+l1J7jrQiQDYl0WPFKiq41V1ant7e8kxAEZZNOzdfbq7T2xsbCw5BsAoDgEDGEbYAYYRdoBhhB1gGE/FAAzjqRiAYWzFAAwj7ADDCDvAMMIOMIywAwwj7ADDeI4dYBjPsQMMYysGYBhhBxhG2AGG2dP/ecr/t3nyzn29/tFbbjygSQCezYodYBhhBxjGc+wAw3iOHWAYWzEAwwg7wDDCDjCMsAMMI+wAwwg7wDDCDjCMsAMMI+wAwzhSAGCYRY/t7e7TSU5vbW29bck5lrCfY38d+QtciK0YgGGEHWAYYQcYRtgBhhF2gGGEHWAYYQcYRtgBhhF2gGGEHWCYRY8UqKrjSY5fc801S45x6DiOALiQRVfs3X26u09sbGwsOQbAKLZiAIYRdoBhhB1gGGEHGEbYAYYRdoBhFn2OnUvPM/AwnxU7wDDCDjCMsAMMI+wAwwg7wDDCDjCMxx3Zs/08Kpl4XBIulUVX7FV1vKpObW9vLzkGwCjOYwcYxh47wDDCDjCMsAMMI+wAw3jckUvGyZJwaVixAwwj7ADDCDvAMMIOMIw3TzkUvPEKe2fFDjCMsAMMI+wAw9hjZzz78zzfWLEDDCPsAMMIO8Awwg4wjDdP4QK88cphZMUOMIywAwyzaNir6nhVndre3l5yDIBRFt1j7+7TSU5vbW29bck54BthP/vziT16Lp6tGIBhhB1gGI87wpryqCUXy4odYBhhBxjGVgwMZBvn+c2KHWAYYQcYxlYM8Cy2cQ4/K3aAYYQdYBhhBxjGHjtwYBx8th6s2AGGEXaAYWzFAGvDo5YHQ9iBEfyl8HW2YgCGsWIHnvemrfat2AGGEXaAYWzFAOzDOm7jWLEDDCPsAMMIO8Awwg4wjLADDCPsAMMIO8Awwg4wjLADDFPdvfQMqaqnknzuIl9+NMkXD3Ccadyf3blHF+b+7G6pe/Ty7n7ZuRfXIuz7UVX3dvfW0nOsK/dnd+7Rhbk/u1u3e2QrBmAYYQcYZkLYTy09wJpzf3bnHl2Y+7O7tbpHh36PHYBnm7BiB+Aswg4wzKEOe1VdX1UPVdXDVXVy6XnWSVVdWVUfq6oHq+qBqnrn0jOto6q6rKo+XVV/u/Qs66iqXlpVt1fVv65+L/3o0jOtk6r6tdWfr/ur6raqetHSMyWHOOxVdVmS9yW5IcmxJDdV1bFlp1orzyT59e7+viSvTfLL7s95vTPJg0sPscb+MMmHu/uVSV4V9+prquryJL+SZKu7vz/JZUneuuxUOw5t2JO8JsnD3f1Idz+d5ENJ3rTwTGuju7/Q3Z9affxf2fkDefmyU62XqroiyY1J3r/0LOuoqr49yY8l+dMk6e6nu/vLy061do4k+ZaqOpLkxUmeWHieJIc77Jcneeysz89EuM6rqjaTvDrJJ5adZO38QZLfSPKVpQdZU9+T5Kkkf7barnp/Vb1k6aHWRXc/nuQ9ST6f5AtJtrv775adasdhDnud55pnN89RVd+a5K+T/Gp3/+fS86yLqvqpJE92931Lz7LGjiT5oSR/3N2vTvI/SbyXtVJV35GdXYKrk3x3kpdU1c8vO9WOwxz2M0muPOvzK7Im/wxaF1X1TdmJ+ge7+46l51kzr0/yxqp6NDvbeD9eVX+x7Ehr50ySM9391X/p3Z6d0LPjJ5J8truf6u7/TXJHktctPFOSwx32TyZ5RVVdXVXfnJ03Lf5m4ZnWRlVVdvZGH+zu3196nnXT3e/u7iu6ezM7v3f+vrvXYrW1Lrr735M8VlXXri69Icm/LDjSuvl8ktdW1YtXf97ekDV5c/nI0gNcrO5+pqrenuQj2Xk3+tbufmDhsdbJ65P8QpJ/rqp/XF37re6+a8GZOHzekeSDq8XTI0l+aeF51kZ3f6Kqbk/yqew8hfbprMnRAo4UABjmMG/FAHAewg4wjLADDCPsAMMIO8AlVlW3VtWTVXX/Hn7ty6vqo1X1T1X1D6ujMC5I2AEuvQ8kuX6Pv/Y9Sf68u38gye8k+b3dXiDsAJdYd9+d5EtnX6uq762qD1fVfVV1T1W9cvVTx5J8dPXxx7KHww6FHWA9nEryju7+4STvSvJHq+ufSfKW1cc/neTbquo7L/SFDu13ngJMsTqs73VJ/mrndIIkyQtXP74ryXur6heT3J3k8ex8p+tzEnaA5b0gyZe7+wfP/YnufiLJm5Ov/QXwlu7e3u2LAbCg1ZHan62qn0l2DvGrqletPj5aVV9t9buT3Lrb1xN2gEusqm5L8vEk11bVmaq6OcnPJbm5qj6T5IF8/U3S65I8VFX/luS7kvzurl/fIWAAs1ixAwwj7ADDCDvAMMIOMIywAwwj7ADDCDvAMP8HJcE65xtjqmgAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(dGamma,bins = 20, log=True);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_4_BtoKllgamma.ipynb b/example_4_BtoKllgamma.ipynb
new file mode 100644
index 0000000..1db29d1
--- /dev/null
+++ b/example_4_BtoKllgamma.ipynb
@@ -0,0 +1,760 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "from phasespace import Particle\n",
+    "#from phasespace.kinematics import lorentz_vector, lorentz_boost\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_probability as tfp\n",
+    "import zfit\n",
+    "\n",
+    "from utils.kin_utils_2 import *\n",
+    "from utils.BtoKll_utils import *\n",
+    "\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmu_mass = 105.0\n",
+    "mB_mass = 5280.0\n",
+    "mKst_mass = 892.0\n",
+    "mgamma_mass = 0\n",
+    "mBbar_mass = mB_mass-mgamma_mass\n",
+    "\n",
+    "minq=2*mmu_mass\n",
+    "maxq=(mBbar_mass-mKst_mass)\n",
+    "\n",
+    "el1 = Particle('l1', mmu_mass)\n",
+    "el2 = Particle('l2', mmu_mass)\n",
+    "\n",
+    "def modq(min_mass, max_mass, n_events):\n",
+    "    \n",
+    "        min_mass = tf.cast(min_mass, tf.float64)\n",
+    "        max_mass = tf.cast(max_mass, tf.float64)\n",
+    "\n",
+    "        min_mass = tf.broadcast_to(min_mass, shape=(n_events,))\n",
+    "        \n",
+    "        modq_mass = tfp.distributions.Uniform(low=min_mass, high=max_mass).sample()\n",
+    "        \n",
+    "        return modq_mass\n",
+    "    \n",
+    "def mBbar(min_mass, max_mass, n_events):\n",
+    "    \n",
+    "        min_mass = tf.cast(min_mass, tf.float64)\n",
+    "        max_mass = tf.cast(max_mass, tf.float64)\n",
+    "\n",
+    "        min_mass = tf.broadcast_to(min_mass, shape=(n_events,))\n",
+    "        \n",
+    "        mBbar_mass = tfp.distributions.Uniform(low=min_mass, high=max_mass).sample()\n",
+    "        \n",
+    "        return mBbar_mass\n",
+    "    \n",
+    "q=Particle('q', modq).set_children(el1, el2)\n",
+    "Kst = Particle('Kst', mKst_mass)\n",
+    "\n",
+    "Bbar = Particle('Bbar', mBbar).set_children(Kst, q)\n",
+    "k = Particle('gamma', mgamma_mass)\n",
+    "B = Particle('B', mB_mass).set_children(Bbar, k)\n",
+    "\n",
+    "#weights, particles = B.generate(n_events=10000)\n",
+    "weights_np, particles_np = B.generate(n_events=1000000)\n",
+    "weights, particles = B.generate_tensor(n_events=1000000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_events=100000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "105.00013069979116 5273.578115490983\n"
+     ]
+    }
+   ],
+   "source": [
+    "Kst=particles_np['Kst']\n",
+    "l1 =particles_np['l1']\n",
+    "l2 =particles_np['l2']\n",
+    "q_np=particles_np['q']\n",
+    "Bbar_np = particles_np['Bbar']\n",
+    "q2_array=scalar_product_4_np(q_np,q_np)\n",
+    "q2_range=np.arange(q2_array.min(), q2_array.max(),1000)\n",
+    "print(np.sqrt(q2_array.min()/4), np.sqrt(q2_array.max())+mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "44100.1097878929"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "q2_array.min()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Bbar_array= scalar_product_4_np(Bbar_np,Bbar_np)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "19.19822678214951"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(q2_array/1e6).max()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist2d(q2_array/1e6,np.sqrt(Bbar_array)/1e3, weights=weights_np, density=True,bins=100);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(np.sqrt(Bbar_array)/1e3, weights=weights_np, bins=100,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_array/1e6, weights=weights_np, bins=100,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "val=np.sqrt(lambda_function_np_2(mB_mass, mKst_mass, q2_range))*beta_l_np(q2_range, mmu_mass)\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(q2_range/1e6, val);\n",
+    "fig=plt.gcf()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.hist(q2_array/1e6, weights=weights_np, bins=100,density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#def matrix_elt(q2, m, m1, m2, cos_theta_l):\n",
+    "#    \n",
+    "#    out = a(q2, m, m1, m2)+b(q2, m, m1, m2)*cos_theta_l+c(q2, m, m1, m2)*ztf.square(cos_theta_l)\n",
+    "#    \n",
+    "#    return out \n",
+    "#\n",
+    "#def a(q2, m, m1, m2):\n",
+    "#    \n",
+    "#    step1=q2*(1+ztf.square(beta_l(q2, m)))+ lambda_function(m1, m2, q2)/2 + 2*m*(ztf.square(m1)-ztf.square(m2)+q2)+4*ztf.square(m)*ztf.square(m1)\n",
+    "#    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "#    \n",
+    "#    return step1\n",
+    "#\n",
+    "#def b(q2, m, m1, m2):\n",
+    "#    \n",
+    "#    step1=2*(q2*(1+ztf.square(beta_l(q2, m)))+ m*(ztf.sqrt(lambda_function(m1, m2, q2))*beta_l(q2,m)+(ztf.square(m1)-ztf.square(m2)+q2)))\n",
+    "#    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "#    \n",
+    "#    return step1\n",
+    "#\n",
+    "#def c(q2, m, m1, m2):\n",
+    "#    \n",
+    "#    step1= q2*(1+ztf.square(beta_l(q2, m)))- lambda_function(m1, m2, q2)/2 + 2*m*ztf.sqrt(lambda_function(m1, m2, q2))*beta_l(q2, m)\n",
+    "#    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1\n",
+    "#    \n",
+    "#    return step1\n",
+    "#\n",
+    "#def phase_space(q2, m, m1, m2):\n",
+    "#    \n",
+    "#    phase_space_term = beta_l(q2, m)*ztf.sqrt(lambda_function(m1, m2, q2))\n",
+    "#    \n",
+    "#    return phase_space_term\n",
+    "#    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GaussianSampleAndWeights():\n",
+    "\n",
+    "        def __call__(self, n_to_produce, limits, dtype):\n",
+    "            \n",
+    "            n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n",
+    "\n",
+    "            weights, phase_space_sample = B.generate_tensor(n_events=n_to_produce) #check order \n",
+    "            \n",
+    "            weights_out = 1/weights\n",
+    "            phase_space_sample_tensor = tf.concat([phase_space_sample[\"Kst\"],phase_space_sample[\"q\"],phase_space_sample[\"l1\"],phase_space_sample[\"l2\"],], axis=1)\n",
+    "            \n",
+    "            weights_max = None\n",
+    "            \n",
+    "            thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n",
+    "            \n",
+    "            return phase_space_sample_tensor, thresholds, weights_out, weights_max, n_to_produce\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml']\n",
+    "    _N_OBS = 16\n",
+    "\n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        ml = self.params['ml']\n",
+    "        mB = self.params['mB']\n",
+    "        mKst = self.params['mKst']\n",
+    "        \n",
+    "        list_ps= x.unstack_x()\n",
+    "        new_list_ps = [tf.expand_dims(ele, axis=1) for ele in list_ps] \n",
+    "        pKstx, pKsty, pKstz, pKstE, qx, qy, qz, qE, p1x, p1y, p1z, p1E, p2x, p2y, p2z, p2E = new_list_ps\n",
+    "        \n",
+    "        pKst = lorentz_vector(tf.concat([pKstx, pKsty, pKstz],axis=-1), pKstE)\n",
+    "        p1 = lorentz_vector(tf.concat([p1x, p1y, p1z],axis=-1), p1E)\n",
+    "        p2 = lorentz_vector(tf.concat([p2x, p2y, p2z],axis=-1), p2E)\n",
+    "        qvec_B = tf.concat([qx, qy, qz],axis=-1)\n",
+    "        q = lorentz_vector(qvec_B, qE)\n",
+    "\n",
+    "        z = tf.cast(tf.expand_dims(tf.stack([0., 0., 1., 0.],         axis=0), axis=0),dtype=tf.float64)\n",
+    "        \n",
+    "        #assert q==p1+p2\n",
+    "        q2=scalar_product_4(q,q)\n",
+    "        modq = ztf.sqrt(q2)\n",
+    "        \n",
+    "        #q_in_q_rf = lorentz_vector(tf.zeros_like(qvec_B), modq)\n",
+    "        p1q = lorentz_boost(p1, p1+p2)\n",
+    "        \n",
+    "        costheta_l= tf.expand_dims(get_costheta_l(p1q, z), axis=1)\n",
+    "        \n",
+    "        pdf = matrix_elt(q2, ml, mB, mKst, costheta_l)\n",
+    "        \n",
+    "        return pdf[:, 0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lepton_min_E = 105\n",
+    "lepton_max_E = 2700\n",
+    "\n",
+    "lepton_min_p = -2700\n",
+    "lepton_max_p = 2700\n",
+    "\n",
+    "Kst_min_E = 892.\n",
+    "Kst_max_E = 2700\n",
+    "\n",
+    "Kst_min_p = -2700\n",
+    "Kst_max_p = 2700\n",
+    "\n",
+    "q_min_E = 2700\n",
+    "q_max_E = 4400\n",
+    "\n",
+    "q_min_p = -2700\n",
+    "q_max_p = 2700"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower =((Kst_min_p,  Kst_min_p,  Kst_min_p,  mKst_mass, q_min_p, q_min_p, q_min_p, q_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E, lepton_min_p,  lepton_min_p,  lepton_min_p,  lepton_min_E,),)\n",
+    "upper =((Kst_max_p , Kst_max_p , Kst_max_p , Kst_max_E, q_max_p, q_max_p, q_max_p, q_max_E, lepton_max_p,  lepton_max_p , lepton_max_p , lepton_max_E, lepton_max_p , lepton_max_p , lepton_max_p , lepton_max_E,),)\n",
+    "\n",
+    "obs = zfit.Space([\"pKstx\",\"pKsty\",\"pKstz\",\"pKstE\", \n",
+    "                  \"qx\", \"qy\", \"qz\", \"qE\",\n",
+    "                  \"p1x\"  ,\"p1y\"  ,\"p1z\"  ,\"p1E\"  , \n",
+    "                  \"p2x\"  ,\"p2y\"  ,\"p2z\"  ,\"p2E\" ],\n",
+    "                 limits=(lower,upper))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)\n",
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par)\n",
+    "#pdf = dGamma(obs=obs, ml = m_lepton)\n",
+    "pdf._sample_and_weights=GaussianSampleAndWeights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = pdf.create_sampler(n=n_events)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "a=sampler.to_pandas()  \n",
+    "plt.subplot(1,2,1)\n",
+    "plt.hist(l1[:,0],weights=weights_np,bins=60);\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.hist(a['p1x'].values[:],bins=60);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1x=a['p1x'].values[:]\n",
+    "p1y=a['p1y'].values[:]\n",
+    "p1z=a['p1z'].values[:]\n",
+    "p1E=a['p1E'].values[:]\n",
+    "\n",
+    "p2x=a['p2x'].values[:]\n",
+    "p2y=a['p2y'].values[:]\n",
+    "p2z=a['p2z'].values[:]\n",
+    "p2E=a['p2E'].values[:]\n",
+    "\n",
+    "qx =a['qx'].values[:]\n",
+    "qy =a['qy'].values[:]\n",
+    "qz =a['qz'].values[:]\n",
+    "qE =a['qE'].values[:]\n",
+    "\n",
+    "pKstx =a['pKstx'].values[:]\n",
+    "pKsty =a['pKsty'].values[:]\n",
+    "pKstz =a['pKstz'].values[:]\n",
+    "pKstE =a['pKstE'].values[:]\n",
+    "\n",
+    "p1=np.array([p1x,p1y,p1z,p1E]).transpose()\n",
+    "p2=np.array([p2x,p2y,p2z,p2E]).transpose()\n",
+    "q = np.array([qx,qy,qz,qE]).transpose()\n",
+    "pKst = np.array([pKstx,pKsty,pKstz,pKstE]).transpose()\n",
+    "#q = p1 + p2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q2_from_sample=scalar_product_4_np(q,q)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(q2_from_sample/1e6,bins=70, density=True);\n",
+    "fig=plt.gcf()\n",
+    "fig.set_size_inches(15,5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([11025., 11025., 11025., ..., 11025., 11025., 11025.])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scalar_product_4_np(p1,p1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1[:,1],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(pKst[:,1],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_q = lorentz_boost_np(p1, p1+p2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "105.0"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(scalar_product_4_np(p1_q,p1_q)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z=np.array([[0.,0.,1.,0] for i in range(n_events)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cos_theta_l_np=get_costheta_l_np(p1_q,z)\n",
+    "plt.hist(cos_theta_l_np,bins=100);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_BtoKll.ipynb b/example_BtoKll.ipynb
new file mode 100644
index 0000000..6029055
--- /dev/null
+++ b/example_BtoKll.ipynb
@@ -0,0 +1,681 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
+      "  warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "import zfit\n",
+    "\n",
+    "#from utils.kin_utils_2 import *\n",
+    "from utils.BtoKll_utils import *\n",
+    "\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmu_mass = 0.5\n",
+    "mB_mass=5280\n",
+    "mKst_mass=892\n",
+    "\n",
+    "lower_q2= 4*mmu_mass*mmu_mass\n",
+    "upper_q2=(mB_mass-mKst_mass)*(mB_mass-mKst_mass)\n",
+    "\n",
+    "#lower_q= 2*mmu_mass\n",
+    "#upper_q=(mB_mass-mKst_mass)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml']\n",
+    "    _N_OBS = 2\n",
+    "    VALID_LIMITS={\n",
+    "                  'cos_theta_l':(-1.,1.),\n",
+    "                  'q2': (lower_q2, upper_q2),\n",
+    "                  #'Eg': (cutoff, 10)\n",
+    "                 }\n",
+    "    \n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "        ml = self.params['ml']\n",
+    "        mB = self.params['mB']\n",
+    "        mKst = self.params['mKst']\n",
+    "        \n",
+    "        q2, cos_theta_l = x.unstack_x()\n",
+    "        #pdf = matrix_elt(q2, ml, mB, mKst, cos_theta_l)*dphi2(mB,mKst,ztf.sqrt(q2))*dphi2(ztf.sqrt(q2),ml,ml)\n",
+    "        pdf = dphi2(mB,mKst,ztf.sqrt(q2))*dphi2(ztf.sqrt(q2),ml,ml)\n",
+    "        #pdf= phase_space(q2, ml, mB, mKst)\n",
+    "        #pdf = beta_l(q2, ml)\n",
+    "        \n",
+    "        return pdf\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameAlreadyTakenError",
+     "evalue": "Another parameter is already named ml. Use a different, unique one.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameAlreadyTakenError\u001b[0m                     Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-33-ed8b43963c30>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmlepton_par\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzfit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'ml'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmmu_mass\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmB_par\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzfit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'mB'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmB_mass\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mmKst_par\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mzfit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mParameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'mKst'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmKst_mass\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/variables.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m    215\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variable_v2_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    216\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 217\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mVariableMetaclass\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    219\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/parameter.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name, value, lower_limit, upper_limit, step_size, floating, dtype, **kwargs)\u001b[0m\n\u001b[1;32m    326\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    327\u001b[0m         super().__init__(initial_value=value, dtype=dtype, name=name, constraint=constraint,\n\u001b[0;32m--> 328\u001b[0;31m                          params={}, **kwargs)\n\u001b[0m\u001b[1;32m    329\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_limit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlower_limit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mztypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper_limit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mupper_limit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mztypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/util/execution.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    132\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    133\u001b[0m         \u001b[0;34m\"\"\"Creates a `self.sess` attribute, a setter `set_sess` (with a fallback to the zfit default session).\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 134\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    135\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sess\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/parameter.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, name, initial_value, **kwargs)\u001b[0m\n\u001b[1;32m    235\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_existing_names\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m             raise NameAlreadyTakenError(\"Another parameter is already named {}. \"\n\u001b[0;32m--> 237\u001b[0;31m                                         \"Use a different, unique one.\".format(name))\n\u001b[0m\u001b[1;32m    238\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_existing_names\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    239\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameAlreadyTakenError\u001b[0m: Another parameter is already named ml. Use a different, unique one."
+     ]
+    }
+   ],
+   "source": [
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)\n",
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lower = ((lower_q2,  -1.),)\n",
+    "upper = ((upper_q2,   1.),)\n",
+    "\n",
+    "obs = zfit.Space([\"q2\",\"cos_theta_l\"], limits=(lower,upper))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_events=1000000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampler = pdf.create_sampler(n=n_events)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(1):\n",
+    "    sampler.resample()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sample=sampler.to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "q2vals_MC = np.array([sample['q2'][i] for i in range(n_events)])\n",
+    "q2vals2 = q2vals_MC.reshape(n_events,1)\n",
+    "\n",
+    "cos_theta_vals_MC = np.array([sample['cos_theta_l'][i] for i in range(n_events)])\n",
+    "cos_theta_vals = cos_theta_vals_MC.reshape(n_events,1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.subplot(2,1,1)\n",
+    "a=plt.hist(q2vals2,bins=100);\n",
+    "plt.subplot(2,1,2)\n",
+    "b=plt.hist(cos_theta_vals,bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "vals=np.arange(lower_q2,upper_q2,1000)\n",
+    "f=dphi2_np(np.sqrt(vals),mmu_mass,mmu_mass)*dphi2_np(mB_mass,mKst_mass,np.sqrt(vals))\n",
+    "plt.subplot(2,1,1)\n",
+    "a=plt.hist(q2vals2,bins=100);\n",
+    "\n",
+    "plt.subplot(2,1,2)\n",
+    "plt.plot(vals/1e6,f) \n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def momenta_map(q2, cos_theta_l, m_l):\n",
+    "    \n",
+    "    n_events = q2.shape[0]\n",
+    "    \n",
+    "    sin_theta_l = np.sqrt(1-np.square(cos_theta_l))\n",
+    "\n",
+    "    beta = dphi2_np(np.sqrt(q2), mmu_mass, mmu_mass)\n",
+    "    lambd = lambda_function_np(mB_mass,mKst_mass,np.sqrt(q2))\n",
+    "    \n",
+    "    phi_l = np.random.uniform(low=-pi,high=pi, size=(n_events,1))\n",
+    "    cos_phi_l = np.cos(phi_l)\n",
+    "    sin_phi_l = np.sin(phi_l)\n",
+    "\n",
+    "    p1_1 = 0.5*np.sqrt(q2)*beta*sin_theta_l*cos_phi_l\n",
+    "    p1_2 = 0.5*np.sqrt(q2)*beta*sin_theta_l*sin_phi_l\n",
+    "    p1_3 = 0.5*np.sqrt(q2)*beta*cos_theta_l\n",
+    "    p1_0 = 0.5*np.sqrt(q2)\n",
+    "    \n",
+    "    p1 = np.concatenate([      p1_1,\n",
+    "                               p1_2,\n",
+    "                               p1_3,\n",
+    "                               p1_0], axis =1)\n",
+    "    \n",
+    "    p2 = np.concatenate([      -p1_1,\n",
+    "                               -p1_2,\n",
+    "                               -p1_3,\n",
+    "                                p1_0], axis =1)\n",
+    "    \n",
+    "\n",
+    "    \n",
+    "    EKst_B = (np.square(mB_mass)+np.square(mKst_mass)-q2)/(2*mB_mass)\n",
+    "    modKst_B = np.sqrt(lambd)/(2*mB_mass)\n",
+    "    \n",
+    "    phi_Kst = np.random.uniform(low=-pi,high=pi, size=(n_events,1))\n",
+    "    theta_Kst = np.random.uniform(low=0,high=pi, size=(n_events,1))\n",
+    "    \n",
+    "    cos_phi_Kst = np.cos(phi_Kst)\n",
+    "    sin_phi_Kst = np.sin(phi_Kst)\n",
+    "        \n",
+    "    cos_theta_Kst = np.cos(theta_Kst)\n",
+    "    sin_theta_Kst = np.sin(theta_Kst)\n",
+    "        \n",
+    "    pKst_B_0 = EKst_B\n",
+    "    pKst_B_1 = modKst_B*sin_theta_Kst*cos_phi_Kst\n",
+    "    pKst_B_2 = modKst_B*sin_theta_Kst*sin_phi_Kst\n",
+    "    pKst_B_3 = modKst_B*cos_theta_Kst\n",
+    "    \n",
+    "    q_B_0 =  mB_mass - EKst_B\n",
+    "    q_B_1 = - pKst_B_1\n",
+    "    q_B_2 = - pKst_B_2\n",
+    "    q_B_3 = - pKst_B_3\n",
+    "    \n",
+    "    pKst_B = np.concatenate([    pKst_B_1,\n",
+    "                                 pKst_B_2,\n",
+    "                                 pKst_B_3,\n",
+    "                                 pKst_B_0], axis =1)\n",
+    "    \n",
+    "    q_B = np.concatenate([       q_B_1,\n",
+    "                                 q_B_2,\n",
+    "                                 q_B_3,\n",
+    "                                 q_B_0,], axis =1)\n",
+    "    q_B_vec = np.concatenate([\n",
+    "                            q_B_1,\n",
+    "                            q_B_2,\n",
+    "                            q_B_3,\n",
+    "                            ], axis=1)\n",
+    "    \n",
+    "    beta_B = q_B_vec/q_B_0\n",
+    "    \n",
+    "    p1_B = lorentz_boost_np(p1, beta_B)\n",
+    "    p2_B = lorentz_boost_np(p2, beta_B)\n",
+    "    \n",
+    "    \n",
+    "    return  pKst_B, q_B, p1_B, p2_B, p1, p2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pKst_B, q_B, p1_B, p2_B, p1, p2 = momenta_map(q2vals2, cos_theta_vals, mmu_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.5000000000058044"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(scalar_product_4_np(p2_B,p2_B)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "892.0"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(scalar_product_4_np(pKst_B,pKst_B)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5280.0"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(pKst_B+p1_B+p2_B)[:,3].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8.941619977775872e-14"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(pKst_B+p1_B+p2_B)[:,0].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-2.012661423633766e-14"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(pKst_B+p1_B+p2_B)[:,1].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-2.0537912082119192e-13"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(pKst_B+p1_B+p2_B)[:,2].mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_B[:,3],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_B[:,0],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAEvCAYAAAD4uAgWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAdRUlEQVR4nO3dfYxmZ3kf4N+dNRDUfNiGhTpe03WTrRqDWkOmtiX6BzUJXgPKOhVEdtuwIVadRFglUtRik0okfERGbSAhBbdO2GBHhMUipF4FU2fDh2ik2HgMDmAc4i24eGMLL11DQEhGNnf/eB+HYT27M7M7uzNz5rqkV/O+93nOmfNKR+P9+X7Oc6q7AwAAwDR831qfAAAAAKtHyAMAAJgQIQ8AAGBChDwAAIAJEfIAAAAmRMgDAACYkNPW+gSO1zOf+czevn37Wp8GAADAmrjrrru+2t1bj6xv2JC3ffv2zM/Pr/VpAAAArImq+r+L1U3XBAAAmBAhDwAAYEKWHfKqaktVfbqq/nR8Preq7qiq+6rq/VX11FF/2vh8YGzfvuAY1476F6rqkgX1naN2oKquWb2vBwAAsLmspJP32iT3Lvj81iRv7+4dSR5JcuWoX5nkke7+sSRvH+NSVecluTzJc5PsTPKuERy3JHlnkkuTnJfkijEWAACAFVpWyKuqbUleluT3x+dKcnGSD4whNya5bLzfNT5nbH/xGL8ryd7ufrS7v5TkQJILxutAd3+xu7+dZO8YCwAAwAott5P320n+U5LvjM/PSPK17n5sfD6Y5Ozx/uwkDyTJ2P71Mf7v60fsc7Q6AAAAK7RkyKuqlyd5uLvvWlheZGgvsW2l9cXO5aqqmq+q+UOHDh3jrAEAADan5XTyXpjkp6vq/symUl6cWWfv9Kp64jl725I8ON4fTHJOkoztP5zk8ML6Efscrf4k3X1Dd89199zWrU965h8AAMCmt2TI6+5ru3tbd2/PbOGUj3b3v03ysSSvGMN2J7llvN83Pmds/2h396hfPlbfPDfJjiSfTHJnkh1jtc6njt+xb1W+HQAAwCZz2tJDjup1SfZW1ZuTfDrJu0f93Un+sKoOZNbBuzxJuvueqro5yeeTPJbkNd39eJJU1dVJbkuyJcme7r7nBM4LAABg06pZk23jmZub6/n5+bU+DQAAgDVRVXd199yR9RPp5AHAprX9mg8dc/v9173sFJ0JAHyvlTwMHQAAgHVOyAMAAJgQIQ8AAGBChDwAAIAJEfIAAAAmRMgDAACYECEPAABgQjwnDwCOYqln4QHAeqSTBwAAMCFCHgAAwIQIeQAAABMi5AEAAEyIkAcAADAhQh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiQBwAAMCFCHgAAwIQIeQAAABOyZMirqu+vqk9W1V9V1T1V9Ruj/p6q+lJV3T1e5496VdU7qupAVX2mql6w4Fi7q+q+8dq9oP4TVfXZsc87qqpOxpcFAACYutOWMebRJBd39zer6ilJ/qKqPjy2/cfu/sAR4y9NsmO8LkxyfZILq+rMJG9IMpekk9xVVfu6+5Ex5qoktye5NcnOJB8OAAAAK7JkJ69nvjk+PmW8+hi77Epy09jv9iSnV9VZSS5Jsr+7D49gtz/JzrHth7r7L7u7k9yU5LIT+E4AAACb1rLuyauqLVV1d5KHMwtqd4xNbxlTMt9eVU8btbOTPLBg94Ojdqz6wUXqAAAArNCyQl53P97d5yfZluSCqnpekmuT/NMk/yLJmUleN4Yvdj9dH0f9Sarqqqqar6r5Q4cOLefUAQAANpUVra7Z3V9L8vEkO7v7oTEl89Ekf5DkgjHsYJJzFuy2LcmDS9S3LVJf7Pff0N1z3T23devWlZw6AADAprCc1TW3VtXp4/3Tk/xkkr8e99JlrIR5WZLPjV32JXnVWGXzoiRf7+6HktyW5CVVdUZVnZHkJUluG9u+UVUXjWO9Ksktq/s1AQAANoflrK55VpIbq2pLZqHw5u7+06r6aFVtzWy65d1JfmmMvzXJS5McSPKtJK9Oku4+XFVvSnLnGPfG7j483v9ykvckeXpmq2paWRMAAOA4LBnyuvszSZ6/SP3io4zvJK85yrY9SfYsUp9P8rylzgUAAIBjW9E9eQAAAKxvQh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiQBwAAMCFCHgAAwIQIeQAAABMi5AEAAEyIkAcAADAhQh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiQBwAAMCFCHgAAwIQIeQAAABMi5AEAAEzIkiGvqr6/qj5ZVX9VVfdU1W+M+rlVdUdV3VdV76+qp47608bnA2P79gXHunbUv1BVlyyo7xy1A1V1zep/TQAAgM1hOZ28R5Nc3N3/PMn5SXZW1UVJ3prk7d29I8kjSa4c469M8kh3/1iSt49xqarzklye5LlJdiZ5V1VtqaotSd6Z5NIk5yW5YowFAABghZYMeT3zzfHxKePVSS5O8oFRvzHJZeP9rvE5Y/uLq6pGfW93P9rdX0pyIMkF43Wgu7/Y3d9OsneMBQAAYIWWdU/e6LjdneThJPuT/J8kX+vux8aQg0nOHu/PTvJAkoztX0/yjIX1I/Y5Wh0AAIAVWlbI6+7Hu/v8JNsy67z9+GLDxs86yraV1p+kqq6qqvmqmj906NDSJw4AALDJrGh1ze7+WpKPJ7koyelVddrYtC3Jg+P9wSTnJMnY/sNJDi+sH7HP0eqL/f4bunuuu+e2bt26klMHAADYFJazuubWqjp9vH96kp9Mcm+SjyV5xRi2O8kt4/2+8Tlj+0e7u0f98rH65rlJdiT5ZJI7k+wYq3U+NbPFWfatxpcDAADYbE5bekjOSnLjWAXz+5Lc3N1/WlWfT7K3qt6c5NNJ3j3GvzvJH1bVgcw6eJcnSXffU1U3J/l8kseSvKa7H0+Sqro6yW1JtiTZ0933rNo3BAAA2ERq1mTbeObm5np+fn6tTwOACdt+zYdOynHvv+5lJ+W4AGwuVXVXd88dWV/RPXkAAACsb0IeAADAhCznnjwAmKSTNR0TANaSTh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiQBwAAMCFCHgAAwIQIeQAAABMi5AEAAEyIkAcAADAhQh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiQBwAAMCFCHgAAwIQsGfKq6pyq+lhV3VtV91TVa0f916vqb6vq7vF66YJ9rq2qA1X1haq6ZEF956gdqKprFtTPrao7quq+qnp/VT11tb8oAADAZlDdfewBVWclOau7P1VVP5jkriSXJfnZJN/s7v96xPjzkrwvyQVJfiTJnyf5J2Pz3yT5qSQHk9yZ5Iru/nxV3Zzkg929t6r+e5K/6u7rj3Vec3NzPT8/v7JvC8Cmsv2aD631KRyX+6972VqfAgAbQFXd1d1zR9aX7OR190Pd/anx/htJ7k1y9jF22ZVkb3c/2t1fSnIgs8B3QZID3f3F7v52kr1JdlVVJbk4yQfG/jdmFiIBAABYoRXdk1dV25M8P8kdo3R1VX2mqvZU1RmjdnaSBxbsdnDUjlZ/RpKvdfdjR9QBAABYoWWHvKr6gSR/nORXuvvvklyf5EeTnJ/koSS/9cTQRXbv46gvdg5XVdV8Vc0fOnRouacOAACwaSwr5FXVUzILeO/t7g8mSXd/pbsf7+7vJPm9zKZjJrNO3DkLdt+W5MFj1L+a5PSqOu2I+pN09w3dPdfdc1u3bl3OqQMAAGwqy1lds5K8O8m93f22BfWzFgz7mSSfG+/3Jbm8qp5WVecm2ZHkk5kttLJjrKT51CSXJ9nXs5VfPpbkFWP/3UluObGvBQAAsDmdtvSQvDDJzyX5bFXdPWqvT3JFVZ2f2dTK+5P8YpJ09z1jtczPJ3ksyWu6+/Ekqaqrk9yWZEuSPd19zzje65Lsrao3J/l0ZqESAACAFVoy5HX3X2Tx++ZuPcY+b0nylkXqty62X3d/Md+d7gkAAMBxWtHqmgAAAKxvQh4AAMCECHkAAAATIuQBAABMiJAHAAAwIUIeAADAhAh5AAAAE7Kch6EDAKfQ9ms+dMzt91/3slN0JgBsREIeABvaUoEIADYb0zUBAAAmRMgDAACYECEPAABgQoQ8AACACRHyAAAAJkTIAwAAmBAhDwAAYEKEPAAAgAnxMHQA2GCO9QD4+6972Sk8EwDWI508AACACRHyAAAAJsR0TQDWtWNNTQQAnkwnDwAAYEKEPAAAgAkR8gAAACZkyZBXVedU1ceq6t6quqeqXjvqZ1bV/qq6b/w8Y9Srqt5RVQeq6jNV9YIFx9o9xt9XVbsX1H+iqj479nlHVdXJ+LIAAABTt5yFVx5L8qvd/amq+sEkd1XV/iQ/n+Qj3X1dVV2T5Jokr0tyaZId43VhkuuTXFhVZyZ5Q5K5JD2Os6+7Hxljrkpye5Jbk+xM8uHV+5oAsDkstVCN5+gBTN+Snbzufqi7PzXefyPJvUnOTrIryY1j2I1JLhvvdyW5qWduT3J6VZ2V5JIk+7v78Ah2+5PsHNt+qLv/srs7yU0LjgUAAMAKrOgRClW1Pcnzk9yR5Nnd/VAyC4JV9awx7OwkDyzY7eCoHat+cJE6AJuExyQAwOpZ9sIrVfUDSf44ya90998da+gitT6O+mLncFVVzVfV/KFDh5Y6ZQAAgE1nWSGvqp6SWcB7b3d/cJS/MqZaZvx8eNQPJjlnwe7bkjy4RH3bIvUn6e4bunuuu+e2bt26nFMHAADYVJazumYleXeSe7v7bQs27UvyxAqZu5PcsqD+qrHK5kVJvj6mdd6W5CVVdcZYifMlSW4b275RVReN3/WqBccCAABgBZZzT94Lk/xcks9W1d2j9vok1yW5uaquTPLlJK8c225N8tIkB5J8K8mrk6S7D1fVm5LcOca9sbsPj/e/nOQ9SZ6e2aqaVtYEAAA4DkuGvO7+iyx+31ySvHiR8Z3kNUc51p4kexapzyd53lLnAgAAwLEte+EVAAAA1r8VPUIBAI6HRyQAwKmjkwcAADAhOnkAsIkcq6t6/3UvO4VnAsDJopMHAAAwIUIeAADAhAh5AAAAEyLkAQAATIiFVwCAJEs/6sLCLAAbg5AHwAnzHDwAWD9M1wQAAJgQIQ8AAGBChDwAAIAJEfIAAAAmxMIrAMCyWH0TYGPQyQMAAJgQnTwAlsVjEgBgY9DJAwAAmBCdPABgVRyr2+t+PYBTR8gDIInpmAAwFaZrAgAATIiQBwAAMCFCHgAAwIS4Jw9gE3HfHQBM35Ihr6r2JHl5koe7+3mj9utJ/n2SQ2PY67v71rHt2iRXJnk8yX/o7ttGfWeS30myJcnvd/d1o35ukr1JzkzyqSQ/193fXq0vCACsvaX+B4PVNwFWz3Kma74nyc5F6m/v7vPH64mAd16Sy5M8d+zzrqraUlVbkrwzyaVJzktyxRibJG8dx9qR5JHMAiIAAADHYcmQ192fSHJ4mcfblWRvdz/a3V9KciDJBeN1oLu/OLp0e5PsqqpKcnGSD4z9b0xy2Qq/AwAAAMOJLLxydVV9pqr2VNUZo3Z2kgcWjDk4akerPyPJ17r7sSPqAAAAHIfjDXnXJ/nRJOcneSjJb416LTK2j6O+qKq6qqrmq2r+0KFDRxsGAACwaR1XyOvur3T34939nSS/l9l0zGTWiTtnwdBtSR48Rv2rSU6vqtOOqB/t997Q3XPdPbd169bjOXUAAIBJO65HKFTVWd390Pj4M0k+N97vS/JHVfW2JD+SZEeST2bWsdsxVtL828wWZ/k33d1V9bEkr8jsPr3dSW453i8DAGxMVt8EWD3LeYTC+5K8KMkzq+pgkjckeVFVnZ/Z1Mr7k/xiknT3PVV1c5LPJ3ksyWu6+/FxnKuT3JbZIxT2dPc941e8Lsneqnpzkk8nefeqfTuATcZz8ACAJUNed1+xSPmoQay735LkLYvUb01y6yL1L+a70z0BAAA4Acc1XROAtaFTx2Z1rGvfVE6A73Uij1AAAABgnRHyAAAAJkTIAwAAmBD35AGsM+67g5Xx+AWA76WTBwAAMCFCHgAAwIQIeQAAABMi5AEAAEyIhVcATjELq8Cp5UHqwGajkwcAADAhOnkAwKbl8QvAFAl5AKvMdEwAYC2ZrgkAADAhQh4AAMCEmK4JcBxMyYTNwT17wEakkwcAADAhOnkAAMfJM/iA9UgnDwAAYEJ08gAW4Z47AGCj0skDAACYEJ08YNPSrQNOJitzAmtFJw8AAGBChDwAAIAJWXK6ZlXtSfLyJA939/NG7cwk70+yPcn9SX62ux+pqkryO0lemuRbSX6+uz819tmd5D+Pw765u28c9Z9I8p4kT09ya5LXdnev0vcDNjHTMYH1zOMXgJNlOZ289yTZeUTtmiQf6e4dST4yPifJpUl2jNdVSa5P/j4UviHJhUkuSPKGqjpj7HP9GPvEfkf+LgAAAJZpyZDX3Z9IcviI8q4kN473Nya5bEH9pp65PcnpVXVWkkuS7O/uw939SJL9SXaObT/U3X85unc3LTgWAAAAK3S8q2s+u7sfSpLufqiqnjXqZyd5YMG4g6N2rPrBReoASzIdEwDgyVb7EQq1SK2Po774wauuymxqZ57znOccz/kBAKx7Hr8AnIjjXV3zK2OqZcbPh0f9YJJzFozbluTBJerbFqkvqrtv6O657p7bunXrcZ46AADAdB1vJ29fkt1Jrhs/b1lQv7qq9ma2yMrXx3TO25L85oLFVl6S5NruPlxV36iqi5LckeRVSX73OM8JmCBTMgGeTKcPOJblPELhfUlelOSZVXUws1Uyr0tyc1VdmeTLSV45ht+a2eMTDmT2CIVXJ8kIc29KcucY98bufmIxl1/Odx+h8OHxAgAA4DgsGfK6+4qjbHrxImM7yWuOcpw9SfYsUp9P8rylzgMAAIClrfbCKwArYjomAMDqOt6FVwAAAFiHdPKAk063DuDUOpG/uxZtgY1PJw8AAGBCdPIAAPh7x+oC6vLBxqCTBwAAMCFCHgAAwISYrgksycIpAAAbh5AHAMCyLPU//dyzB+uD6ZoAAAATopMHJDElEwBgKoQ8AABWhemcsD4IeQAAnBKewQenhpAHm4TpmAAAm4OFVwAAACZEJw8AgDXnfj5YPTp5AAAAE6KTBxPivjsAAIQ82ECEOAAAliLkAQCw7nn8AiyfkAcAwIZm0Rb4XkIerCOmYwIAcKKEPDjFBDkAOLV0+thsPEIBAABgQk4o5FXV/VX12aq6u6rmR+3MqtpfVfeNn2eMelXVO6rqQFV9pqpesOA4u8f4+6pq94l9JQAAgM1rNaZr/qvu/uqCz9ck+Uh3X1dV14zPr0tyaZId43VhkuuTXFhVZyZ5Q5K5JJ3krqra192PrMK5wSlnOiYAbCxW7mRqTsZ0zV1Jbhzvb0xy2YL6TT1ze5LTq+qsJJck2d/dh0ew259k50k4LwAAgMk70U5eJ/mzquok/6O7b0jy7O5+KEm6+6GqetYYe3aSBxbse3DUjlaHdUmnDgA2D4u2sBGdaMh7YXc/OILc/qr662OMrUVqfYz6kw9QdVWSq5LkOc95zkrPFQAAYPJOKOR194Pj58NV9SdJLkjylao6a3Txzkry8Bh+MMk5C3bfluTBUX/REfWPH+X33ZDkhiSZm5tbNAjCatCtAwBgozrukFdV/yDJ93X3N8b7lyR5Y5J9SXYnuW78vGXssi/J1VW1N7OFV74+guBtSX7ziVU4x3GuPd7zAgCAU8V0TtajE+nkPTvJn1TVE8f5o+7+X1V1Z5Kbq+rKJF9O8sox/tYkL01yIMm3krw6Sbr7cFW9KcmdY9wbu/vwCZwXLEmnDgCAqarujTnrcW5urufn59f6NNighDwAYK3p8nGiququ7p47sn4yHqEAAADAGlmNh6HDuqRbBwCsZ+7n42TRyQMAAJgQnTw2LJ06AGDKjvVvHV0+jkUnDwAAYEJ08li3dOoAABbnfj6ORScPAABgQnTyWFO6dQAAq0+nb3PTyQMAAJgQnTxOKp06AID1x8qd06aTBwAAMCFCHgAAwISYrskJMyUTAGA6LNqy8Ql5LEmIAwDgCe7nW/9M1wQAAJgQnTx06gAAYEKEPAAAYFW4n299EPI2Cd06AADWmhB4argnDwAAYEJ08iZCpw4AAEiEPAAAYJ3weIbVIeRtILp1AABsVu7nWz735AEAAEyITt46olMHAADHx1TP71o3nbyq2llVX6iqA1V1zVqfDwAAwEa0Ljp5VbUlyTuT/FSSg0nurKp93f35tT2z1aVTBwAAp95mu59vvXTyLkhyoLu/2N3fTrI3ya41PicAAIANZ1108pKcneSBBZ8PJrlwjc7lhOjWAQDAxjK1Tt96CXm1SK2fNKjqqiRXjY/frKovnNSzYj14ZpKvrvVJMBmuJ1aT64nV5ppiNbmeVlG9da3P4Kj+0WLF9RLyDiY5Z8HnbUkePHJQd9+Q5IZTdVKsvaqa7+65tT4PpsH1xGpyPbHaXFOsJtfT5rZe7sm7M8mOqjq3qp6a5PIk+9b4nAAAADacddHJ6+7HqurqJLcl2ZJkT3ffs8anBQAAsOGsi5CXJN19a5Jb1/o8WHdMz2U1uZ5YTa4nVptritXketrEqvtJ65sAAACwQa2Xe/IAAABYBUIea6aq/ktV/XVVfaaq/qSqTl+w7dqqOlBVX6iqSxbUd47agaq6ZkH93Kq6o6ruq6r3jwV82ESq6pVVdU9Vfaeq5o7Y5npiVR3t2oGFqmpPVT1cVZ9bUDuzqvaPvy/7q+qMUa+qese4pj5TVS9YsM/uMf6+qtq9Ft+FtVdV51TVx6rq3vHfu9eOumuKJxHyWEv7kzyvu/9Zkr9Jcm2SVNV5ma2w+twkO5O8q6q2VNWWJO9McmmS85JcMcYmyVuTvL27dyR5JMmVp/SbsB58Lsm/TvKJhUXXE6ttiWsHFnpPZn93FromyUfG35ePjM/J7HraMV5XJbk+mf0DPskbklyY5IIkb3jiH/FsOo8l+dXu/vEkFyV5zfjb45riSYQ81kx3/1l3PzY+3p7Z8xGTZFeSvd39aHd/KcmBzP4IXZDkQHd/sbu/nWRvkl1VVUkuTvKBsf+NSS47Vd+D9aG77+3uLyyyyfXEalv02lnjc2Id6u5PJDl8RHlXZn9Xku/9+7IryU09c3uS06vqrCSXJNnf3Ye7+5HM/gfpkcGRTaC7H+ruT43330hyb5Kz45piEUIe68UvJPnweH92kgcWbDs4akerPyPJ1xYExifqkLieWH1Hu3ZgOZ7d3Q8ls3+0J3nWqK/0bxWbWFVtT/L8JHfENcUi1s0jFJimqvrzJP9wkU2/1t23jDG/ltkUhPc+sdsi4zuL/0+JPsZ4JmY519Niuy1Scz1xIlwjnAxHu65cb3yPqvqBJH+c5Fe6++9mE1AWH7pIzTW1SQh5nFTd/ZPH2j5u9n15khf3d5/ncTDJOQuGbUvy4Hi/WP2rmU1BOG10XxaOZ0KWup6OwvXEajvWNQVL+UpVndXdD42pcw+P+tGuq4NJXnRE/eOn4DxZh6rqKZkFvPd29wdH2TXFk5iuyZqpqp1JXpfkp7v7Wws27UtyeVU9rarOzeyG4U8muTPJjrHy4VMzW0xj3wiHH0vyirH/7iRH6+qw+bieWG2LXjtrfE5sHPsy+7uSfO/fl31JXjVWRLwoydfH1Lvbkrykqs4Yi2O8ZNTYZMY94+9Ocm93v23BJtcUT+Jh6KyZqjqQ5GlJ/t8o3d7dvzS2/Vpm9+k9ltl0hA+P+kuT/HaSLUn2dPdbRv0fZ7b4wZlJPp3k33X3o6fw67DGqupnkvxukq1Jvpbk7u6+ZGxzPbGqjnbtwEJV9b7MOibPTPKVzFY0/J9Jbk7ynCRfTvLK7j48/gH/3zJbAONbSV7d3fPjOL+Q5PXjsG/p7j84ld+D9aGq/mWS/53ks0m+M8qvz+y+PNcU30PIAwAAmBDTNQEAACZEyAMAAJgQIQ8AAGBChDwAAIAJEfIAAAAmRMgDAACYECEPAABgQoQ8AACACfn/01nJK6Kio6UAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(pKst_B[:,0],bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_B_to_boost=p1_B\n",
+    "p2_B_to_boost=p2_B"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_q = lorentz_boost_np(p1_B_to_boost, -q_B[:,0:3]/q_B[:,3:4])\n",
+    "p2_q = lorentz_boost_np(p2_B_to_boost, -q_B[:,0:3]/q_B[:,3:4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_B[:,0],alpha=0.3,bins=100);\n",
+    "plt.hist(p1[:,0],histtype=\"step\",bins=100);\n",
+    "plt.hist(p1_q[:,0],alpha=0.3,bins=100);\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEFCAYAAAASWssjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAb+klEQVR4nO3df7RV5X3n8fenoqQmJIBoxgA3YAtmoSsZzR2xmkmNtIq2k+usiVNMmiChi5VUU22nU3V0xiyNLc7MitQxMYsGRshKvRqbVqajJcQfy0kjKGj8gcRwg45cYYIGMDimKM53/tjP1e3hnLvPPb/PuZ/XWnfdfb772ec8Z3M43/v82M9WRGBmZjaaX2l3BczMrPM5WZiZWSEnCzMzK+RkYWZmhZwszMys0IR2V6BW06ZNi1mzZrW7GmZmXWXLli0vR8SxYz2ua5PFrFmz2Lx5c7urYWbWVST971qOczeUmZkVcrIwM7NCThZmZlbIycLMzAo5WZiZWSEnCzMzK+RkYWZmhZwszMyskJOFmZkV6toruOux6vplHDj4BgDfec9n+ccrz25zjczMOtu4TBYHDr7B5QvmArBi/S/bXBszs87nbigzMys0LlsWef/x3Xez4pq7Dou7e8rM7G3jPlks/djssnF3T5mZvc3dUGZmVmjctywqyXdPuUvKzMa7wpaFpNWS9kh6uiT+JUnPStoq6T/n4ldJGkr7zs3FF6bYkKQrc/HZkjZJ2i7pDklHNerN1WPpx2Zz+YK5XL5gLi/ud5eUmY1v1bQsbgNuAdaOBCR9AhgAPhwRByUdl+LzgEXAScAHgO9LmpsO+xrw28Aw8KikdRHxDHAjcFNEDEr6BrAUuLURb65RKrUyfL2GmY0XhckiIh6SNKsk/EVgeUQcTGX2pPgAMJjiz0kaAk5L+4YiYgeApEFgQNI24Gzg06nMGuDLdFiyyA+C5we+fb2GmY0XtY5ZzAX+paQbgH8C/jQiHgWmAxtz5YZTDGBnSXw+cAywPyIOlSnfkfKtjEkTj2xzbczMWqPWZDEBmAKcDvwL4E5JJwAqUzYoPzYSo5QvS9IyYBlAX1/fGKvcGJWm2pqZ9bJak8Uw8N2ICOARSf8PmJbiM3PlZgC70na5+MvAZEkTUusiX/4wEbESWAnQ399fMam0m8cyzKzX1Hqdxd+RjTWQBrCPIvviXwcskjRR0mxgDvAI8CgwJ818OopsEHxdSjYPAJ9Kz7sYuLvWN9MpRsYyPJPKzHpFYctC0u3AWcA0ScPAtcBqYHWaTvs6sDh98W+VdCfwDHAIuCQi3kzPcymwHjgCWB0RW9NLXAEMSvoK8DiwqoHvr2U8lmFmvaya2VAXVdj1+xXK3wDcUCZ+D3BPmfgO3p4x1bU8lmFmvcxXcDeZrwQ3s17gZNFk+RbHpB8MsuKabwFOHGbWXZwsWqjSxX1mZp3OyaJN3D1lZt3EyaJN3D1lZt3EyaIDVEoc4ORhZp3ByaLDlE7B9diGmXUC3ynPzMwKuWXR4fID4XnunjKzVnKy6HCVrgwvHdsY4SRiZs3gZNGlKiURj3GYWTM4WfQYX79hZs3gZNFjfJW4mTWDk0UPcyvDzBrFyaKHuZVhZo3i6yzMzKxQYbKQtFrSnnRXvNJ9fyopJE1LjyXpZklDkp6UdGqu7GJJ29PP4lz8o5KeSsfcLEmNenNmZtYY1XRD3QbcAqzNByXNBH4beCEXPo/svttzgPnArcB8SVPJbsfaDwSwRdK6iNiXyiwDNpLdSW8hcG/tb8mKrLp+GQcOvgF4LMPMqlPYsoiIh4C9ZXbdBPwZ2Zf/iAFgbWQ2ApMlHQ+cC2yIiL0pQWwAFqZ9742Ih9M9vNcCF9T3lqzIgYNvcPmCuVy+YC4v7vdYhpkVq2nMQtIngRcj4omSXdOBnbnHwyk2Wny4TLzS6y6TtFnS5pdeeqmWqpuZWQ3GPBtK0tHA1cA55XaXiUUN8bIiYiWwEqC/v79iOTtcfhrtpIlHtrk2ZtZtapk6+2vAbOCJNBY9A3hM0mlkLYOZubIzgF0pflZJ/MEUn1GmvDVYpeVBfC2GmVVjzMkiIp4Cjht5LOl5oD8iXpa0DrhU0iDZAPcrEbFb0nrgzyVNSYedA1wVEXslHZB0OrAJ+Bzw3+p7SzYWvhbDzKpRzdTZ24GHgRMlDUtaOkrxe4AdwBDwV8AfAkTEXuB64NH0c12KAXwR+GY65qd4JpSZWccpbFlExEUF+2fltgO4pEK51cDqMvHNwMlF9TAzs/bxch/2lrHeaMnXa5iNH04W9pax3mhp0sQjuXzBXMDjHWa9zsnCClVKImY2fjhZWEN4Cq5Zb3OysIbwFFyz3uYlys3MrJCThZmZFXI3lDWVp9ea9QYnC2u40kULR6bX5qfgOnGYdRcnC2u4SlNt83EnDrPu4mRhbVFp9pS7rcw6k5OFtV2lbitPwTXrHE4W1na+Qtys83nqrJmZFXKyMDOzQk4WZmZWqJo75a2WtEfS07nYf5H0Y0lPSvpbSZNz+66SNCTpWUnn5uILU2xI0pW5+GxJmyRtl3SHpKMa+QbNzKx+1bQsbgMWlsQ2ACdHxIeBnwBXAUiaBywCTkrHfF3SEZKOAL4GnAfMAy5KZQFuBG6KiDnAPmC027aamVkbVHNb1YckzSqJfS/3cCPwqbQ9AAxGxEHgOUlDwGlp31BE7ACQNAgMSNoGnA18OpVZA3wZuLWWN2O9pdKd+0r5egyz5mvE1NnPA3ek7elkyWPEcIoB7CyJzweOAfZHxKEy5Q8jaRmwDKCvr6/uiltnq3ZKra/HMGu+uga4JV0NHAK+PRIqUyxqiJcVESsjoj8i+o899tixVtfMzGpUc8tC0mLgd4EFETHyBT8MzMwVmwHsStvl4i8DkyVNSK2LfHkzM+sQNSULSQuBK4DfjIjXcrvWAX8t6avAB4A5wCNkLYg5kmYDL5INgn86IkLSA2RjHoPAYuDuWt+MmdeWMmuOwmQh6XbgLGCapGHgWrLZTxOBDZIANkbEFyJiq6Q7gWfIuqcuiYg30/NcCqwHjgBWR8TW9BJXAIOSvgI8Dqxq4PuzcebAwTe8tpRZE1QzG+qiMuGKX+gRcQNwQ5n4PcA9ZeI7eHvGlNmYlS5EaGaN54UEret5IUKz5nOysJ5V6ToNj2WYjZ2ThfWsSi0Oj2WYjZ2ThY1rnj1lVh0nCxvXPHvKrDpOFjbuVJo95TEOs8qcLGzcqTSW4TEOs8p88yMzMyvkZGFmZoXcDWU2Bp49ZeOVk4VZgdIBcc+esvHIycKsgJcTMfOYhZmZVcEtC7Ma5bunPH5hvc7JwqxG+e4pj19Yr6vm5keryW6fuiciTk6xqcAdwCzgeeDfRsQ+ZXdC+kvgfOA14OKIeCwdsxi4Jj3tVyJiTYp/FLgN+FWy+11clrtNq1lXqNTK8Owp6xXVtCxuA24B1uZiVwL3RcRySVemx1cA55HdSnUOMB+4FZifksu1QD8QwBZJ6yJiXyqzDNhIliwWAvfW/9bMWiffypj0g0FWXPOtbNuzp6xHVHOnvIckzSoJD5DdahVgDfAgWbIYANamlsFGSZMlHZ/KboiIvQCSNgALJT0IvDciHk7xtcAFOFlYF6s0e8pjHNbNah2zeH9E7AaIiN2Sjkvx6cDOXLnhFBstPlwmXpakZWStEPr6+mqsull7eIzDulmjB7hVJhY1xMuKiJXASoD+/n6Pa1hP8LiGdYNar7P4WepeIv3ek+LDwMxcuRnAroL4jDJxs3Fj5J4aly+Yy4v73eKwzlRrslgHLE7bi4G7c/HPKXM68ErqrloPnCNpiqQpwDnA+rTvgKTT00yqz+Wey8zMOkQ1U2dvJxugniZpmGxW03LgTklLgReAC1Pxe8imzQ6RTZ1dAhAReyVdDzyayl03MtgNfJG3p87eiwe3bRyodAMms05VzWyoiyrsWlCmbACXVHie1cDqMvHNwMlF9TDrJV5vyrqNr+A26yCeXmudysnCrINUurjPicPazcnCrEP5ugzrJF6i3MzMCrllYdYF8mMZee6eslZxsjDrApVmT7l7ylrF3VBmZlbILQuzLlbaPeVuKWsWJwuzLlbaPeVuKWsWd0OZmVkhtyzMepSXPrdGcrIw6yGlCxT6lq7WKE4WZj3Et3S1ZnGyMBsHvHSI1csD3GZmVsgtC7NxzIPgVq26koWkPwb+AAjgKbI74x0PDAJTgceAz0bE65ImAmuBjwI/B34vIp5Pz3MVsBR4E/ijiFhfT73MrDIPglstak4WkqYDfwTMi4hfSroTWER2W9WbImJQ0jfIksCt6fe+iPh1SYuAG4HfkzQvHXcS8AHg+5LmRsSbdb0zMyvLd+mzWtQ7ZjEB+FVJE4Cjgd3A2cDI+gNrgAvS9kB6TNq/QJJSfDAiDkbEc2T37z6tznqZmVkD1dyyiIgXJf1X4AXgl8D3gC3A/og4lIoNA9PT9nRgZzr2kKRXgGNSfGPuqfPHvIOkZcAygL6+vlqrbmZleHqtjaaebqgpZK2C2cB+4DvAeWWKxsghFfZVih8ejFgJrATo7+8vW8bMauNbutpo6hng/i3guYh4CUDSd4EzgMmSJqTWxQxgVyo/DMwEhlO31fuAvbn4iPwxZtYGla7L8Oyp8aueZPECcLqko8m6oRYAm4EHgE+RzYhaDNydyq9Ljx9O+++PiJC0DvhrSV8lG+CeAzxSR73MrIE8e8qgvjGLTZLuIpseewh4nKyL6H8Cg5K+kmKr0iGrgG9JGiJrUSxKz7M1zaR6Jj3PJZ4JZdY5PHvKABTRnV3//f39sXnz5pqOXXHNkrf+OjKz2qz6wXPukupCkrZERP9Yj/MV3GZWE683Nb54bSgzMyvkloWZ1c3XaPQ+Jwszq5u7pHqfk4WZNZRbGb3JycLMGspXgvcmJwszaxp3T/UOJwszawl3T3U3Jwszawm3Mrqbr7MwM7NCblmYWcu5S6r7OFmYWct5CfTu42RhZh3jwME3vAR6h3KyMLO2Kr1fhnUmJwszayvfL6M71DUbStJkSXdJ+rGkbZJ+Q9JUSRskbU+/p6SyknSzpCFJT0o6Nfc8i1P57ZIW1/umzMysseqdOvuXwD9ExIeAjwDbgCuB+yJiDnBfegxwHtktU+cAy4BbASRNBa4F5gOnAdeOJBgzG7+y7qklrLhmCWcuv7/d1Rn3au6GkvRe4OPAxQAR8TrwuqQB4KxUbA3wIHAFMACsjezWfBtTq+T4VHZDROxNz7sBWAjcXmvdzKz7eY2pzlLPmMUJwEvAf5f0EWALcBnw/ojYDRARuyUdl8pPB3bmjh9OsUrxw0haRtYqoa+vr46qm1k38dXf7VdPN9QE4FTg1og4Bfi/vN3lVI7KxGKU+OHBiJUR0R8R/ccee+xY62tmZjWqJ1kMA8MRsSk9vossefwsdS+Rfu/JlZ+ZO34GsGuUuJmZdYiau6Ei4v9I2inpxIh4FlgAPJN+FgPL0++70yHrgEslDZINZr+SuqnWA3+eG9Q+B7iq1nqZWW+rtFSIr/5urnqvs/gS8G1JRwE7gCVkrZU7JS0FXgAuTGXvAc4HhoDXUlkiYq+k64FHU7nrRga7zcxKVRr4njTxSF/93UR1JYuI+BHQX2bXgjJlA7ikwvOsBlbXUxczG398QV/reIlyMzMr5GRhZmaFnCzMzKyQFxI0s56TnzFVyjOlauNkYWY9Z7SBb8+Uqo27oczMrJCThZmZFXI3lJmNK5XGMzyWMTonCzMbVyqNZ3gsY3TuhjIzs0JuWZiZUXmBQss4WZiZ4RssFXE3lJmZFXKyMDOzQu6GMjMr4fGLwzlZmJmV8PjF4eruhpJ0hKTHJf19ejxb0iZJ2yXdke6ih6SJ6fFQ2j8r9xxXpfizks6tt05mZtZYjRizuAzYlnt8I3BTRMwB9gFLU3wpsC8ifh24KZVD0jxgEXASsBD4uqQjGlAvM7O6ZV1SS1hxzRLOXH5/u6vTNnV1Q0maAfwOcAPwJ5IEnA18OhVZA3wZuBUYSNsAdwG3pPIDwGBEHASekzQEnAY8XE/dzMwaodI9v8fbWEa9YxYrgD8DJqXHxwD7I+JQejwMTE/b04GdABFxSNIrqfx0YGPuOfPHvIOkZcAygL6+vjqrbmY2NuN5LKPmZCHpd4E9EbFF0lkj4TJFo2DfaMe8MxixElgJ0N/fX7aMmVkrjLcZU/W0LM4EPinpfOBdwHvJWhqTJU1IrYsZwK5UfhiYCQxLmgC8D9ibi4/IH2Nm1pHGWyuj5gHuiLgqImZExCyyAer7I+IzwAPAp1KxxcDdaXtdekzaf39ERIovSrOlZgNzgEdqrZeZmTVeM66zuAIYlPQV4HFgVYqvAr6VBrD3kiUYImKrpDuBZ4BDwCUR8WYT6mVmZjVqSLKIiAeBB9P2DrLZTKVl/gm4sMLxN5DNqDIz6zrj4YZKvoLbzKxO4+GGSl5I0MzMCjlZmJlZIScLMzMr5GRhZmaFPMBtZtYkvXSVt5OFmVmT9NJV3u6GMjOzQm5ZmJm1QLd3STlZmJm1QLd3SbkbyszMCrllYWbWYt3YJeVkYWbWYt3YJeVuKDMzK+RkYWZmhWpOFpJmSnpA0jZJWyVdluJTJW2QtD39npLiknSzpCFJT0o6Nfdci1P57ZIWV3pNM7Nek41fLGHFNUs4c/n97a5ORfWMWRwC/l1EPCZpErBF0gbgYuC+iFgu6UrgSrK7551HdsvUOcB84FZgvqSpwLVAPxDpedZFxL466mZm1hW6Zfyinntw746Ix9L2AWAbMB0YANakYmuAC9L2ALA2MhuByZKOB84FNkTE3pQgNgALa62XmZk1XkPGLCTNAk4BNgHvj4jdkCUU4LhUbDqwM3fYcIpVipd7nWWSNkva/NJLLzWi6mZmVoW6p85Keg/wN8DlEfELSRWLlonFKPHDgxErgZUA/f39ZcuYmXWrTr7+oq5kIelIskTx7Yj4bgr/TNLxEbE7dTPtSfFhYGbu8BnArhQ/qyT+YD31MjPrRp08flHPbCgBq4BtEfHV3K51wMiMpsXA3bn459KsqNOBV1I31XrgHElT0sypc1LMzMw6RD0tizOBzwJPSfpRiv0HYDlwp6SlwAvAhWnfPcD5wBDwGrAEICL2SroeeDSVuy4i9tZRLzMza7Cak0VE/IDy4w0AC8qUD+CSCs+1Glhda13MzKy5fAW3mZkV8kKCZmYdqNNmRjlZmJl1oE6bGeVuKDMzK+RkYWZmhZwszMyskJOFmZkVcrIwM7NCThZmZlbIU2fNzDpcJ1xz4WRhZtbhOuGaC3dDmZlZIScLMzMr5GRhZmaFnCzMzKyQk4WZmRXqmGQhaaGkZyUNSbqy3fUxM7O3dUSykHQE8DXgPGAecJGkee2tlZmZjeiIZAGcBgxFxI6IeB0YBAbaXCczM0s65aK86cDO3ONhYH5pIUnLgGXp4auSnq3x9ab98Q28XOOxzTYNOrZu0Nn16+S6getXj06uG7S4frpxTMVL6/bBWl6zU5KFysTisEDESmBl3S8mbY6I/nqfpxk6uW7Q2fXr5LqB61ePTq4bdHb9GlW3TumGGgZm5h7PAHa1qS5mZlaiU5LFo8AcSbMlHQUsAta1uU5mZpZ0RDdURBySdCmwHjgCWB0RW5v4knV3ZTVRJ9cNOrt+nVw3cP3q0cl1g86uX0PqpojDhgbMzMzeoVO6oczMrIM5WZiZWaGeSxZFy4ZImijpjrR/k6RZuX1Xpfizks5tQ93+RNIzkp6UdJ+kD+b2vSnpR+mnKYP/VdTvYkkv5erxB7l9iyVtTz+L21C3m3L1+omk/bl9TT13klZL2iPp6Qr7JenmVPcnJZ2a29fs81ZUt8+kOj0p6YeSPpLb97ykp9J529zoulVZv7MkvZL79/tPuX1NXSKoirr9+1y9nk6fs6lpXyvO3UxJD0jaJmmrpMvKlGncZy8ieuaHbHD8p8AJwFHAE8C8kjJ/CHwjbS8C7kjb81L5icDs9DxHtLhunwCOTttfHKlbevxqB5y7i4Fbyhw7FdiRfk9J21NaWbeS8l8imyTRqnP3ceBU4OkK+88H7iW7nuh0YFMrzluVdTtj5DXJltvZlNv3PDCtzefuLODv6/1MNKNuJWX/FXB/i8/d8cCpaXsS8JMy/2cb9tnrtZZFNcuGDABr0vZdwAJJSvHBiDgYEc8BQ+n5Wla3iHggIl5LDzeSXW/SKvUsuXIusCEi9kbEPmADsLCNdbsIuL2Brz+qiHgI2DtKkQFgbWQ2ApMlHU/zz1th3SLih+m1ofWfuWrOXSVNXyJojHVr6WcOICJ2R8RjafsAsI1sNYy8hn32ei1ZlFs2pPTkvVUmIg4BrwDHVHlss+uWt5TsL4IR75K0WdJGSRc0sF5jrd+/Sc3ZuySNXEjZMecudd3NBu7PhZt97opUqn+zz9tYlX7mAviepC3Kltppl9+Q9ISkeyWdlGIdc+4kHU32Rfs3uXBLz52y7vRTgE0luxr22euI6ywaqJplQyqVqWrJkTpU/fySfh/oB34zF+6LiF2STgDul/RURPy0xfX7H8DtEXFQ0hfIWmhnV3lss+s2YhFwV0S8mYs1+9wVaddnrmqSPkGWLD6WC5+ZzttxwAZJP05/bbfSY8AHI+JVSecDfwfMoYPOHVkX1D9GRL4V0rJzJ+k9ZInq8oj4RenuMofU9NnrtZZFNcuGvFVG0gTgfWRNzWYvOVLV80v6LeBq4JMRcXAkHhG70u8dwINkf0U0UmH9IuLnuTr9FfDRao9tdt1yFlHSHdCCc1ekUv07YpkbSR8GvgkMRMTPR+K587YH+Fsa2y1blYj4RUS8mrbvAY6UNI0OOXfJaJ+5pp47SUeSJYpvR8R3yxRp3GevmQMwrf4hayntIOuGGBn0OqmkzCW8c4D7zrR9Eu8c4N5BYwe4q6nbKWSDdnNK4lOAiWl7GrCdxg/mVVO/43Pb/xrYGG8Plj2X6jklbU9tZd1SuRPJBhbVynOXnnsWlQdpf4d3DjI+0orzVmXd+sjG584oib8bmJTb/iGwsNF1q6J+/2zk35PsC/eFdB6r+kw0s25p/8gfm+9u9blL52EtsGKUMg377DX8H77dP2Sj/z8h+9K9OsWuI/tLHeBdwHfSf5BHgBNyx16djnsWOK8Ndfs+8DPgR+lnXYqfATyV/kM8BSxt07n7C2BrqscDwIdyx34+ndMhYEmr65YefxlYXnJc088d2V+Vu4E3yP5iWwp8AfhC2i+ym3v9NNWhv4Xnrahu3wT25T5zm1P8hHTOnkj/5lc36TNXVL9Lc5+5jeSSWrnPRCvrlspcTDYxJn9cq87dx8i6jp7M/fud36zPnpf7MDOzQr02ZmFmZk3gZGFmZoWcLMzMrJCThZmZFXKyMDPrAkULG5aUrbiwZs2v79lQZmadT9LHgVfJ1no6eQzHfQk4JSI+X8/ru2VhZtYFoszChpJ+TdI/pDWo/pekD5U5tCGLHPba2lBmZuPJSrIL8LZLmg98nWy9NqDiwpo1cbIwM+tCaQHBM4DvZHdZALLlivLKLaxZEycLM7Pu9CvA/oj456OUWUS2Hl5DXszMzLpMZMuRPyfpQnjrFqr52+KeSLZI4MONeD0nCzOzLiDpdrIv/hMlDUtaCnwGWCppZNHC/N0CLyJb5LAhU149ddbMzAq5ZWFmZoWcLMzMrJCThZmZFXKyMDOzQk4WZmZWyMnCzMwKOVmYmVmh/w957j6XIrEGkQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(scalar_product_4_np((p1_B+p2_B),(p1_B+p2_B)),histtype=\"step\",bins=100);\n",
+    "plt.hist(scalar_product_4_np((p1_q+p2_q),(p1_q+p2_q)),alpha=0.5,bins=100);\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z=np.array([[0.,0.,1.,0] for i in range(n_events)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cos_theta_l_np=get_costheta_l_np(p1_B,z)\n",
+    "cos_theta_l_np_2=get_costheta_l_np(p1_q,z)\n",
+    "plt.hist(cos_theta_l_np,bins=100, histtype=\"step\", density=True);\n",
+    "plt.hist(cos_theta_l_np_2,bins=100, alpha=0.5,density=True);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_BtoKllgamma.ipynb b/example_BtoKllgamma.ipynb
new file mode 100644
index 0000000..24f30b6
--- /dev/null
+++ b/example_BtoKllgamma.ipynb
@@ -0,0 +1,574 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "import zfit\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
+    "\n",
+    "from utils.kin_utils_edit import *\n",
+    "from utils.BtoKllgamma_utils import *\n",
+    "import pickle\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#TASK='LOAD'\n",
+    "TASK='SAMPLE'\n",
+    "n_events=100000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mmu_mass = 105\n",
+    "mB_mass=5280\n",
+    "mKst_mass=892\n",
+    "mgamma_mass = 0.1\n",
+    "\n",
+    "mBbar_mass=mB_mass-mgamma_mass\n",
+    "\n",
+    "#lower_q= 2*mmu_mass\n",
+    "#upper_q=(mBbar_mass-mKst_mass)\n",
+    "\n",
+    "lower_q2= 4*mmu_mass*mmu_mass\n",
+    "upper_q2=(mBbar_mass-mKst_mass)*(mBbar_mass-mKst_mass)\n",
+    "\n",
+    "\n",
+    "upper_mBbar2 = mBbar_mass**2\n",
+    "lower_mBbar2 = (2*mmu_mass+mKst_mass)*(2*mmu_mass+mKst_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml','mgamma']\n",
+    "    _N_OBS = 3\n",
+    "    \n",
+    "    \n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "\n",
+    "        mB = self.params['mB']      \n",
+    "        mKst = self.params['mKst']\n",
+    "        ml = self.params['ml']\n",
+    "        mgamma = self.params['mgamma']\n",
+    "        \n",
+    "        q2, mBbar2, cos_theta_l  = x.unstack_x()\n",
+    "        \n",
+    "        \n",
+    "        \"\"\"\n",
+    "        Kinematic functions\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        beta_l = dphi2_tf(ztf.sqrt(q2), ml, ml)\n",
+    "        \n",
+    "        phasespace_term=dphi2_tf(mB, ztf.sqrt(mBbar2), mgamma)*dphi2_tf(ztf.sqrt(mBbar2), mKst, ztf.sqrt(q2))*beta_l\n",
+    "        \n",
+    "        lambda_bar = lambda_function(ztf.sqrt(mBbar2),mKst_mass,ztf.sqrt(q2))\n",
+    "        beta_K = ztf.sqrt(lambda_bar)/(mBbar2-q2+mKst_mass**2)\n",
+    "        beta_q = -ztf.sqrt(lambda_bar)/(mBbar2+q2-mKst_mass**2)\n",
+    "        \n",
+    "        gamma_q = 1/(1-ztf.square(beta_q))\n",
+    "        E_gamma = (mB_mass**2-mBbar2-mgamma_mass**2)/(2*ztf.sqrt(mBbar2))\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        Angular integrals\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        \n",
+    "        \n",
+    "        I12=2*pi*((1+ztf.square(beta_l))/beta_l)*ztf.log((1+beta_l)/(1-beta_l))\n",
+    "        IBK=(2*pi/beta_K)*ztf.log((1+beta_K)/(1-beta_K))\n",
+    "        \n",
+    "        ZBplus =(gamma_q*(1+beta_q*beta_l*cos_theta_l)+ztf.sqrt(1-ztf.square(beta_l)))/(gamma_q*(1+beta_q*beta_l*cos_theta_l)-ztf.sqrt(1-ztf.square(beta_l)))\n",
+    "        ZBminus =(gamma_q*(1-beta_q*beta_l*cos_theta_l)+ztf.sqrt(1-ztf.square(beta_l)))/(gamma_q*(1-beta_q*beta_l*cos_theta_l)-ztf.sqrt(1-ztf.square(beta_l)))        \n",
+    "        \n",
+    "        IBplus = 2*pi*((1+ZBplus)/(ztf.sqrt(ZBplus)))*ztf.log((ztf.sqrt(ZBplus)+1)/(ztf.sqrt(ZBplus)-1))\n",
+    "        IBminus = 2*pi*((1+ZBminus)/(ztf.sqrt(ZBminus)))*ztf.log((ztf.sqrt(ZBminus)+1)/(ztf.sqrt(ZBminus)-1))\n",
+    "        \n",
+    "        ZKplus = (gamma_q*(1-beta_K*beta_q + beta_l*(beta_q-beta_K)*cos_theta_l)+ztf.sqrt((1-ztf.square(beta_l))*(1-ztf.square(beta_K))))/(gamma_q*(1-beta_K*beta_q + beta_l*(beta_q-beta_K)*cos_theta_l)-ztf.sqrt((1-ztf.square(beta_l))*(1-ztf.square(beta_K))))\n",
+    "        ZKminus = (gamma_q*(1-beta_K*beta_q - beta_l*(beta_q-beta_K)*cos_theta_l)+ztf.sqrt((1-ztf.square(beta_l))*(1-ztf.square(beta_K))))/(gamma_q*(1-beta_K*beta_q - beta_l*(beta_q-beta_K)*cos_theta_l)-ztf.sqrt((1-ztf.square(beta_l))*(1-ztf.square(beta_K))))\n",
+    "        \n",
+    "        IKplus = 2*pi*((1+ZKplus)/(ztf.sqrt(ZKplus)))*ztf.log((ztf.sqrt(ZKplus)+1)/(ztf.sqrt(ZKplus)-1))\n",
+    "        IKminus = 2*pi*((1+ZKminus)/(ztf.sqrt(ZKminus)))*ztf.log((ztf.sqrt(ZKminus)+1)/(ztf.sqrt(ZKminus)-1))\n",
+    "        \n",
+    "        pdf_charged = -(1/ztf.square(E_gamma))*(4*(4*pi) +IBK -IBplus +IBminus - IKplus + IKminus -2*I12 )*phasespace_term\n",
+    "        #pdf_neutral = -(1/ztf.square(E_gamma))*(2*(4*pi) - 2*I12 )*phasespace_term\n",
+    "        #pdf =(1/ztf.square(E_gamma))* (2*(4*pi) -2*I12 )*phasespace_term\n",
+    "        \n",
+    "        \n",
+    "        return pdf_charged\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /disk/lhcb_data/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)\n",
+    "mgamma_par = zfit.Parameter('mgamma', mgamma_mass)\n",
+    "mlepton_par = zfit.Parameter('ml', mmu_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /disk/lhcb_data/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "lower = ((lower_q2, lower_mBbar2, -1. ,),)\n",
+    "upper = ((upper_q2, upper_mBbar2,  1. ,),)\n",
+    "\n",
+    "obs = zfit.Space([\"q2\",\"mBbar2\",\"cos_theta_l\",], limits=(lower,upper))\n",
+    "\n",
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par, mgamma= mgamma_par)\n",
+    "\n",
+    "sampler = pdf.create_sampler(n=n_events)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1080 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if TASK=='SAMPLE':\n",
+    "    \n",
+    "    for i in range(1):\n",
+    "        sampler.resample()\n",
+    "    sample = sampler.to_pandas()\n",
+    "    \n",
+    "    \n",
+    "    q2vals = np.array([sample['q2'][i] for i in range(n_events)]).reshape(n_events,1)\n",
+    "    mBbar2vals = np.array([sample['mBbar2'][i] for i in range(n_events)]).reshape(n_events,1)\n",
+    "    cos_theta_vals = np.array([sample['cos_theta_l'][i] for i in range(n_events)]).reshape(n_events,1)\n",
+    "    \n",
+    "    plt.hist(q2vals[:,0],density=True,bins=100);\n",
+    "    fig = plt.gcf()\n",
+    "    fig.set_size_inches(15,5);\n",
+    "    \n",
+    "    plt.subplot(3,1,1)\n",
+    "    #plt.hist2d(q2vals,mBbarvals,density=True,bins=100);\n",
+    "    plt.hist2d(q2vals[:,0]/1e6,mBbar2vals[:,0],label=r'$\\frac{dR_{0}}{dcos_{\\theta l}}$',density=True,bins=100);\n",
+    "    plt.xlabel(r'$q^{2} (GeV^{2})$');\n",
+    "    plt.ylabel(r'$\\bar{m}_{B}$ (MeV)');\n",
+    "    plt.subplot(3,1,2)\n",
+    "    plt.hist(cos_theta_vals,label=r'$\\frac{dR_{0}}{dcos{\\theta_l}}$',density=True,bins=100);\n",
+    "    plt.legend(fontsize='25');\n",
+    "    fig = plt.gcf()\n",
+    "    fig.set_size_inches(15,5)\n",
+    "    plt.subplot(3,1,3)\n",
+    "    plt.hist(mBbar2vals/1e3,label=r'$\\frac{dR_{0}}{d\\bar{m}_{B}}$',density=True,bins=100);\n",
+    "    plt.legend(fontsize='25');\n",
+    "    fig = plt.gcf()\n",
+    "    fig.set_size_inches(15,15);\n",
+    "       \n",
+    "    pKst_Bbar, q_Bbar, p1_Bbar, p2_Bbar, p1, p2 = momenta_map(q2vals, cos_theta_vals, mB_mass, mBbar2vals, mKst_mass, mmu_mass, mgamma_mass, mode='numpy')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if TASK=='LOAD':\n",
+    "    \n",
+    "    #with open('/home/hep/davide/MC_qedbtokst/new_MC_tuple_B+toK+mumu_100K_10eVCutOff.pickle','rb') as f:\n",
+    "    #    MC_tuple= pickle.load(f)\n",
+    "    with open('/home/hep/davide/MC_qedbtokst/new_MC_tuple_B0toK0mumu_500K_100eVCutOff.pickle','rb') as f:\n",
+    "        MC_tuple= pickle.load(f)\n",
+    "        \n",
+    "    pB_Bbar = MC_tuple['pB_Bbar']\n",
+    "    pKst_Bbar = MC_tuple['pKst_Bbar']    \n",
+    "    k_Bbar = MC_tuple['k_Bbar']\n",
+    "    q_Bbar = MC_tuple['q_Bbar']\n",
+    "    p1_Bbar = MC_tuple['p1_Bbar']\n",
+    "    p2_Bbar = MC_tuple['p2_Bbar']\n",
+    "    p1 = MC_tuple['p1']\n",
+    "    p2 = MC_tuple['p2']\n",
+    "    \n",
+    "    pBbar = p1_Bbar+p2_Bbar+pKst_Bbar\n",
+    "    \n",
+    "    q2vals = scalar_product_4_np((p1+p2),(p1+p2))\n",
+    "    mBbarvals = np.sqrt(scalar_product_4_np(pBbar,pBbar))\n",
+    "    \n",
+    "    \n",
+    "    plt.subplot(3,1,1)\n",
+    "    plt.hist(q2vals/1e6,density=True, label=r'$\\frac{dR_{0}}{dq^{2}}$', bins=100);\n",
+    "    plt.legend(fontsize='30');\n",
+    "    plt.subplot(3,1,2)    \n",
+    "    plt.hist(mBbarvals,density=True,label=r'$\\frac{dR_{0}}{d\\bar{m}_{B}}$',bins=100);\n",
+    "    plt.legend(fontsize='30');\n",
+    "    plt.subplot(3,1,3)        \n",
+    "    plt.hist2d(q2vals/1e6,mBbarvals,label=r'$\\frac{dR_{0}}{dcos_{\\theta l}}$', range=((q2vals.min()/1e6,q2vals.max()/1e6),(5270,mBbarvals.max())),density=True,bins=100);\n",
+    "    plt.xlabel(r'$q^{2} (GeV^{2})$');\n",
+    "    plt.ylabel(r'$\\bar{m}_{B}$ (MeV)');\n",
+    "    \n",
+    "    fig = plt.gcf()\n",
+    "    fig.set_size_inches(15,12);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "105.00000000000001"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(np.sqrt(scalar_product_4_np(p2_Bbar,p2_Bbar))).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mass checks ok\n"
+     ]
+    }
+   ],
+   "source": [
+    "Kst_mass_check = (np.sqrt(scalar_product_4_np(pKst_Bbar,pKst_Bbar))).mean()-mKst_mass<10**-10\n",
+    "lepton_mass_check = (np.sqrt(scalar_product_4_np(p2_Bbar,p2_Bbar))).mean()-mmu_mass<10**-10\n",
+    "#B_mass_check = (np.sqrt(scalar_product_4_np(pB_Bbar,pB_Bbar))).mean()-mB_mass<10**10                   \n",
+    "#photon_mass_check = (scalar_product_4_np(k_Bbar,k_Bbar)).mean()-mgamma_mass<10**-10\n",
+    "\n",
+    "if Kst_mass_check and lepton_mass_check:\n",
+    "    print('Mass checks ok')\n",
+    "else:\n",
+    "    print('Mass checks not good')\n",
+    "    print('Kst mass', Kst_mass_check)\n",
+    "    print('lepton mass', lepton_mass_check)\n",
+    "    print('B mass', B_mass_check)\n",
+    "    print('photon_mass_check', photon_mass_check)\n",
+    "    \n",
+    "#pB_Bbar_to_boost=pB_Bbar\n",
+    "#pB = lorentz_boost_np(pB_Bbar_to_boost, -pB_Bbar[:,0:3]/pB_Bbar[:,3:4])\n",
+    "\n",
+    "#spatial_rest_check=pB[:,0].mean()<10**-10 and pB[:,1].mean()<10**-10 and pB[:,2].mean()<10**-10\n",
+    "#Brest_mass_check=pB[:,3].mean()==mB_mass\n",
+    "#\n",
+    "#if spatial_rest_check and Brest_mass_check:\n",
+    "#    print('B rest frame ok')\n",
+    "#else:\n",
+    "#    print('B rest frame not good')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA30AAAEvCAYAAADxU6hsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3df5RV1Z3n/fd3ClERCKCFTYNJaQ/RJuaHhoCJiUnaJx3R7iExbUbzdKRZplEjSbsyyaRMltP5+YSkXT1ZGh/RntZgNLFt86SlB9IOi0cnPRNNRDEq2owlQaVhADEqSgwWfuePe4pcivpxqLpwb516v9a66967z97n7lObXx/2PvtGZiJJkiRJqqZ/0+wOSJIkSZIOHkOfJEmSJFWYoU+SJEmSKszQJ0mSJEkVZuiTJEmSpAoz9EmSJElShY1pdgca4ZhjjsmOjo5md0OSJEmSmuKBBx54NjPb+zpWidDX0dHBmjVrmt0NSZIkSWqKiHiqv2OllndGxFkRsT4iuiKis4/jERFXF8cfjohTB2sbEVMiYlVEPFE8Ty7KD4uIZRHxSEQ8HhFXHNjlSpIkSZJ6DBr6IqINuBaYB8wCLoiIWb2qzQNmFo9FwHUl2nYCqzNzJrC6eA9wHnB4Zr4ZeDtwcUR0DPH6JEmSJGlUKzPTNwfoyswNmbkbuA2Y36vOfODmrLkPmBQR0wZpOx9YVrxeBnyoeJ3AURExBjgS2A28OLTLkyRJkqTRrUzomw48U/d+U1FWps5AbY/NzC0AxfPUovwO4GVgC/A0cFVmPlein5IkSZKkXsqEvuijLEvWKdO2tznAHuB3geOB/xARJ+zXqYhFEbEmItZs3759kFNKkiRJ0uhUJvRtAo6rez8D2FyyzkBttxZLQCmetxXlHwP+KTNfzcxtwP8EZvfuVGbekJmzM3N2e3ufO5NKkiRJ0qhXJvTdD8yMiOMjYixwPrC8V53lwIXFLp6nAS8USzYHarscWFC8XgDcWbx+GviD4lxHAacB/zLE65MkSZKkUW3Q7+nLzO6IWAzcBbQBN2bmuoi4pDi+FFgJnA10AbuAhQO1LU69BLg9Ii6iFvTOK8qvBW4CHqW2PPSmzHy4ERcrSZIkSaNNZA52i13rmz17dvrl7JIkSZJGq4h4IDP3uy0OSn45uyRJkiRpZBp0eackSZKk/WUmO3fu5MUXX2TXrl3s2bOn2V3SCNbW1sa4ceOYOHEiEyZMIKKvL0IYGkOfpBGno3MFG5ec0+xuSJJGscxk27ZtvPzyy0yZMoXf+Z3foa2traH/UNfokZns2bOHl156iWeffZZf//rXTJ06tWG/ngx9kiRJ0gHauXMnL7/8Mm94wxtoa2trdnc0wkUEY8aMYdKkSUyYMIGnnnqKnTt3MnHixIac33v6JEmSpAP04osvMmXKFAOfGq6trY0pU6bw4osvNuychj5JkiTpAO3atYvx48c3uxuqqPHjx7Nr166Gnc/QJ0mSJB2gPXv2OMung6atra2hGwMZ+iRJkqQhcNMWHSyN/rVl6JMkSZKkCjP0SZIkSVKFGfokSZIkqcIMfZIOmY7OFc3ugiRJ0qhj6JMkSZKkCjP0SZIkSVIvP/3pT2lra+PRRx8dUvsbb7yRyZMn89xzzzW4ZwfO0CdJkiRpRHviiSeIiH4f7e3tB3zOz372s3zkIx/h5JNPBuDBBx/kM5/5DG9961uZOHEi7e3tnHHGGfzDP/xDn+0vvPBCJk+ezNe//vVhXVsjjGl2ByRJkiRpOB566CEAPv3pT/OOd7xjv+MHGvruvvtu7r33Xv75n/95b9m3vvUtVq1axbnnnsull17KK6+8wg9+8AM+/OEPc+WVV/KVr3xln3OMGTOGiy++mC996UtceeWVTJo0aQhX1hiGPkktq6NzBRuXnNPsbkiSpBa3du1aAD75yU9y4oknDvt8119/PR0dHZx++ul7yz71qU/x3e9+lyOOOGKfsne/+9184xvf4PLLL2fKlCn7nOdjH/sYV1xxBbfccguLFy8edr+GyuWdkkrr6FwxpB04h9pOkiSpjLVr1zJx4kTe+MY3Dvtcr776Kv/4j//IBz/4QSJib/npp5++T+ADaGtr49xzz6W7u5v169fvd67jjjuOWbNmcccddwy7X8PhTJ8kSZKkEW3t2rWcfPLJ7NixY79jY8eOZeLEiaXP9cADD7Br164+l4n2ZfPmzQBMnTq1z+Nz587l+9//Prt372bs2LGl+9FIzvRJajpnASVJ0lBt2bKFrVu38tOf/pT29vb9Hp/+9KcP6HyPP/44ACeccMKgdf/1X/+Vm266iblz5/J7v/d7fdY54YQTeOWVV9iwYcMB9aORnOmTdFAZ6CRJ0sHUcz/fl7/8Zd71rnftd7y/MNaf7du3AzB58uQB6+3atYsPf/jD7N69m7/5m7/pt97RRx+997wnnXTSAfWlUQx9koalPtTVb7oyWNhzkxZJktQIPaHvIx/5CG9605sadt7M7PfY7t27Offcc1m7di133HEHb37zm/ut+9prrwHsc3/goWbokyRJkg6Sqqx4aeX/qF27di1jxoxpyCYu8Nuvd/jVr37V5/FXX32Vj370o6xatYply5Yxf/78Ac/Xc55jjjmmIf0bCu/pk9QSDnSHT3cElSRJUAt9M2fO5LDDDmvI+X7/938fgK6urv2O7dmzh4997GPceeedLF26lD/90z8d9HxPPvkkRx55ZKl7BA+WUqEvIs6KiPUR0RURnX0cj4i4ujj+cEScOljbiJgSEasi4onieXJR/n9HxEN1j9ci4m2NuFhJrc8gJ0nS6PPVr36ViOD9738/O3fu5Otf/zpz5sxh8uTJHH744Zx00kl84xvfYM+ePfu0e+GFF/jlL3/JrFmzGtaXt7/97YwbN46f//zn+5S/9tprLFiwgDvuuINvf/vb/Pmf/3mp8/3sZz9j7ty5Tdu5E0os74yINuBa4APAJuD+iFiemY/VVZsHzCwec4HrgLmDtO0EVmfmkiIMdgKfz8xbgVuLz34zcGdmPtSYy5V0KByM4FbmHsCez23lJSiSJGl/Dz74IFDb9OStb30rv/zlL4kIjjrqKHbv3s369ev5whe+wLp167jlllv2tnvooYfITF555ZV9ynuMHTuWj370o/uURQTvfe97ueeee/rsy2GHHcYf//Efc9ddd5GZe+/F+9znPsett97KO9/5To4++uj9Pu9d73rXfrN5Tz/9NI8//jiXXnrpAf9MGqnMPX1zgK7M3AAQEbcB84H60DcfuDlrdzveFxGTImIa0DFA2/nA+4r2y4B7gM/3+uwLgB8c8FVJkiRJGjF6Qt8Pf/hDJkyYwNVXX83ChQsZP348GzZs4BOf+AR33303t956KxdffDHvec97gN9u4rJixQpWrNj/P51POeWUfULfzp07AZg2bdqA/bn44ov5u7/7O37yk5/w3ve+F6h9fx/Avffey7333rtfm5tuumm/0PeDH/yAww8/vNQy0IOpzPLO6cAzde83FWVl6gzU9tjM3AJQPPf1bYb/HkOfJEmSVFnPPfccTz/9NADjx4/n7rvv5lOf+hTjx48Hat9z9/d///dMmDABgOXLl+9te/nll5OZ/T56wmSPe+65h4jgC1/4woB9ev/738873/lOrrnmmn3aDvRZf/Znf7bPObq7u7n++uv55Cc/yaRJk4b882mEMqGvr71Fe+9f2l+dMm37/tCIucCuzHy0n+OLImJNRKzp+S4NSdXm5i2SJFVPfTD76le/ytvf/vb96hx99NF7v4NvOF9yvmrVKs4///wBv2Khx1/91V/xox/9iEceeWRIn/W9732PX/3qV3zxi18cUvtGKrO8cxNwXN37GcDmknXGDtB2a0RMy8wtxVLQbb3OeT4DzPJl5g3ADQCzZ88uFSQlHVwGMkmSdKB6Qt/kyZO55JJL+q032JLMMq6++urSdU8//fT9No45EAsXLmThwoVDbt9IZULf/cDMiDge+FdqYexjveosBxYX9+zNBV4owtz2AdouBxYAS4rnO3tOFhH/BjgPOGOoFyap9fUXEg2PkiSNHj335f3RH/0RRxxxRL/1duzYAcCxxx57SPpVJYOGvszsjojFwF1AG3BjZq6LiEuK40uBlcDZQBewC1g4UNvi1EuA2yPiIuBpaiGvxxnApp4NYCS1FnfJlCRJjdIz0zd79uwB6/3sZz8Dapuz6MCUmekjM1dSC3b1ZUvrXidwWdm2RfkO4Mx+2twDnFamb5KaZygzcgfaxlk/SZKq66WXXtr7JejHHHNMv/Xuuecetm3bRkRw9tln72171VVXsWbNGtasWcPWrVtZsGAB3/3udw9F10eUUl/OLkmtys1dJEkauR566CFee+01AAbanPGb3/wmAH/yJ3/C9Om1LwN49tln+fKXv8yDDz446CzhaGfok1QJBj9Jkkae+p07f/zjH/dZ54YbbuCf/umfOOKII/jKV76yt3zatGls2rSJzZs3c8cddxz0vo5khj5JkiRJTdET+iZNmsRdd93FlVdeufcL1Lds2cLnPvc5Lr30UgCuv/56TjrppL1tDz/88L2zfhqYoU+SJElSU/Ts3PmlL32Jk08+ma997Wu87nWv43Wvex2/+7u/y1VXXUVE8O1vf5sLL7ywyb0duQx9kkpx+aQkSWqk3/zmNzz22GMAnHbaafzkJz9h8eLFzJgxg1deeYXp06fz8Y9/nAcffJC/+Iu/aHJvR7ZSu3dKkiRJUiM9/PDDdHd309bWxlve8haOPPJIrrnmGq655ppmd61yDH2SJEnSQeJ32vavZ2nniSeeyJFHHtnk3lSbyzsl9cslnZIk6WDp2cTlbW97W5N7Un3O9EnaT33YM/hJkqSDoSf0nXLKKU3uSfUZ+iTtE+xchiJJkg627u5uHnnkEcCZvkPB0CdJkiTpkBozZgy//vWvh32e73znOzz//PN0d3cDtc1hvva1rwFwxhlncMYZZwz7M6rA0CeNMj2zes7oSZKkke6qq67iqaee2vt+7dq1ezeI+cu//EtDX8HQJ6lyOjpXGGolSRoFNm7c2OwujAju3ilJkiRJFeZMnzSKuTOnJElS9TnTJ2kfBkFJkqRqMfRJqqSOzhX7BVgDrSRJGo0MfZIkSZJUYYY+aZRy1kuSJGl0MPRJkiRJUoUZ+iRJkiSpwgx9kirNZaySpIMlM5vdBVVUo39tGfokSZKkA9TW1saePXua3Q1V1J49e2hra2vY+Qx90ijQ19cXSJKkoRs3bhwvvfRSs7uhinrppZcYN25cw85XKvRFxFkRsT4iuiKis4/jERFXF8cfjohTB2sbEVMiYlVEPFE8T6479paIuDci1kXEIxFxxHAvVJIkSWqUiRMn8txzzznbp4bbs2cPzz33HBMnTmzYOQcNfRHRBlwLzANmARdExKxe1eYBM4vHIuC6Em07gdWZORNYXbwnIsYAtwCXZOabgPcBrw79EiX1GK2zfc50SpIabcKECRx11FE89dRTPP/883R3d3uPn4YsM+nu7ub555/nqaee4qijjmLChAkNO/+YEnXmAF2ZuQEgIm4D5gOP1dWZD9yctV/p90XEpIiYBnQM0HY+tUAHsAy4B/g88IfAw5n5C4DM3DGM65NGjY7OFWxccs4+74F9yiRJUmNEBFOnTmXnzp28+OKLbNu2zVk/DUtbWxvjxo3jmGOOYcKECUREw85dJvRNB56pe78JmFuizvRB2h6bmVsAMnNLREwtyt8IZETcBbQDt2Xmt0r0U1KhflbLGa7+GYwlScMREUycOLGhy/Ckg6FM6OsrYvaeu+6vTpm2ffXp3cA7gF3A6oh4IDNX7/OBEYuoLSXl9a9//SCnlKrFsCJJkqSyymzksgk4ru79DGBzyToDtd1aLAGleN5Wd67/npnPZuYuYCVwKr1k5g2ZOTszZ7e3t5e4DEmSJEkafcqEvvuBmRFxfESMBc4Hlveqsxy4sNjF8zTghWLp5kBtlwMLitcLgDuL13cBb4mIccWmLu9l3/sHJdVxkxJJkiQNZNDlnZnZHRGLqYWxNuDGzFwXEZcUx5dSm407G+iitiRz4UBti1MvAW6PiIuAp4Hzija/ioi/phYYE1iZmf6LVpIkSZKGoMw9fWTmSmrBrr5sad3rBC4r27Yo3wGc2U+bW6h9bYOkATjDd+C8H1KSJI02pb6cXZIkSZI0Mhn6JEmSJKnCDH2SJEmSVGGl7umTNDJ4j58kSZJ6c6ZP0qhkQJYkSaOFoU8aYQwrkiRJOhAu75RGCMOeJEmShsKZPkmSJEmqMEOf1GKc0ZMkSVIjubxTahGGPUmSJB0MzvRJkiRJUoUZ+iRJkiSpwgx9Ugvq6Fzhck9JkiQ1hKFPagEDBTwD4MHnz1eSJFWZoU+SJEmSKszQJ0mSJEkVZuiTJEmSpAoz9EmSJElShRn6pEPMjVkkSZJ0KBn6pCYx+EmSJOlQMPRJkiRJUoUZ+iRJkiSpwsY0uwPSaOYSz9bRMxYbl5zT5J5IkiQ1ljN9kiRJklRhhj6phTkTKEmSpOEqFfoi4qyIWB8RXRHR2cfxiIiri+MPR8Spg7WNiCkRsSoiniieJxflHRHx64h4qHgsbcSFSpIkSdJoNGjoi4g24FpgHjALuCAiZvWqNg+YWTwWAdeVaNsJrM7MmcDq4n2PJzPzbcXjkqFenCRJkiSNdmVm+uYAXZm5ITN3A7cB83vVmQ/cnDX3AZMiYtogbecDy4rXy4APDfNaJEmSJEm9lAl904Fn6t5vKsrK1Bmo7bGZuQWgeJ5aV+/4iFgbEf89It5Too+S1BDeRylJkqqmTOiLPsqyZJ0ybXvbArw+M08BPgN8PyIm7tepiEURsSYi1mzfvn2QU0rNY4iQJElSM5UJfZuA4+rezwA2l6wzUNutxRJQiudtAJn5m8zcUbx+AHgSeGPvTmXmDZk5OzNnt7e3l7gMqfkMgJIkSTrUyoS++4GZEXF8RIwFzgeW96qzHLiw2MXzNOCFYsnmQG2XAwuK1wuAOwEior3YAIaIOIHa5jAbhnyFkiRJkjSKjRmsQmZ2R8Ri4C6gDbgxM9dFxCXF8aXASuBsoAvYBSwcqG1x6iXA7RFxEfA0cF5RfgbwlYjoBvYAl2Tmcw25WkmSJEkaZQYNfQCZuZJasKsvW1r3OoHLyrYtyncAZ/ZR/kPgh2X6JUmSJEkaWKnQJ2l4vJdPkiRJzVLmnj5JJXV0rjDgSZIkqaUY+qSDwOAnSZKkVmHokyRJkqQKM/RJkiRJUoUZ+iRJkiSpwty9UzpIvK9PkiRJrcCZPkmSJEmqMEOfJPXiV29IkqQqMfRJw2RAkCRJUisz9EkHyIAnSZKkkcTQJ0mSJEkVZuiTJEmSpAoz9EkllFnS6bJPSZIktSJDnzQEbt4iSZKkkcLQJ0mSJEkVZuiTJEmSpAoz9EnD4BJPSZIktTpDnyRJkiRVmKFPkiRJkirM0CdJkiRJFTam2R2QRgrv35MkSdJI5EyfJEmSJFWYoU+SJEmSKqxU6IuIsyJifUR0RURnH8cjIq4ujj8cEacO1jYipkTEqoh4onie3Oucr4+IlyLis8O5QEmSJEkazQYNfRHRBlwLzANmARdExKxe1eYBM4vHIuC6Em07gdWZORNYXbyv95+BHw/hmiSpIbyPU5IkVUGZmb45QFdmbsjM3cBtwPxedeYDN2fNfcCkiJg2SNv5wLLi9TLgQz0ni4gPARuAdUO8LkmSJEkS5XbvnA48U/d+EzC3RJ3pg7Q9NjO3AGTmloiYChARRwGfBz4AuLRTTeVMjyRJkka6MjN90UdZlqxTpm1vXwb+c2a+NGCnIhZFxJqIWLN9+/ZBTilJkiRJo1OZ0LcJOK7u/Qxgc8k6A7XdWiwBpXjeVpTPBb4VERuBy4EvRMTi3p3KzBsyc3Zmzm5vby9xGVI5zu5JkiSpSsqEvvuBmRFxfESMBc4Hlveqsxy4sNjF8zTghWLp5kBtlwMLitcLgDsBMvM9mdmRmR3At4H/JzO/M/RLlCRJkqTRa9B7+jKzu5hpuwtoA27MzHURcUlxfCmwEjgb6AJ2AQsHaluceglwe0RcBDwNnNfQK5OkBuiZ+d245Jwm90SSJGloymzkQmaupBbs6suW1r1O4LKybYvyHcCZg3zul8r0T2oEl3VKkiSpikp9ObtUFWWDXUfnCkOgJEmSKsHQJ+EsnyRJkqrL0CdJkiRJFWbokyRJkqQKM/RJkiRJUoUZ+lRZbsYiSZIkGfokSZIkqdIMfRp1nAGUJEnSaGLoU+UNFPAMgJIkSao6Q58kSZIkVZihT5Xk7J0kSZJUY+iTJEmSpAoz9EmSJElShY1pdgekRnJZpyRJkrQvZ/okSZIkqcKc6dOo4AygJEmSRitn+iRJkiSpwgx9qgxn8yRJkqT9GfokSZIkqcK8p08jnjN8kiRJUv+c6dOoZViUJEnSaGDo04jU0bnC0CZJkiSVYOiTJEmSpAoz9EmSJElShZUKfRFxVkSsj4iuiOjs43hExNXF8Ycj4tTB2kbElIhYFRFPFM+Ti/I5EfFQ8fhFRHy4ERcqSZIkSaPRoKEvItqAa4F5wCzggoiY1avaPGBm8VgEXFeibSewOjNnAquL9wCPArMz823AWcD1EeEuo5KayntIJUnSSFVmpm8O0JWZGzJzN3AbML9XnfnAzVlzHzApIqYN0nY+sKx4vQz4EEBm7srM7qL8CCCHeG2SJEmSNOqVmUGbDjxT934TMLdEnemDtD02M7cAZOaWiJjaUyki5gI3Am8APl4XAjWKOdMiSZIkHbgyM33RR1nv2bf+6pRpu3+FzJ9l5puAdwBXRMQR+3UqYlFErImINdu3bx/slBrh+gt8BkFJkiRpYGVC3ybguLr3M4DNJesM1HZrsQSU4nlb7w/OzMeBl4GT+zh2Q2bOzszZ7e3tJS5DkiRJkkafMqHvfmBmRBwfEWOB84HlveosBy4sdvE8DXihWLo5UNvlwILi9QLgToCi7pji9RuAE4GNQ71ASZIkSRrNBr2nLzO7I2IxcBfQBtyYmesi4pLi+FJgJXA20AXsAhYO1LY49RLg9oi4CHgaOK8ofzfQGRGvAq8Bn8zMZxtytRpxXL4pSZIkDU+pr0LIzJXUgl192dK61wlcVrZtUb4DOLOP8u8B3yvTL1VLT8DbuOScJvdEkiRJqo5SX84uSZIkSRqZDH2SJEmSVGGGPrWcjs4V3ssnSZIkNYihTy3L4CdJkiQNn6FPkiRJkirM0CdJkiRJFWbokyRJkqQKM/RJkiRJUoUZ+iSpJHeWlSRJI9GYZndAo0v9P5g3LjmniT2RJEmSRgdn+iRJkiSpwgx9aiqXy0mSJEkHl6FPkiRJkirM0KeW4GyfJEmSdHAY+tQ0Bj1JkiTp4DP0SZIkSVKFGfokSZIkqcIMfZIkSZJUYYY+SZIkSaowQ58kSZIkVZihTwedu3RKkiRJzWPokyRJkqQKM/RJkiRJUoWNaXYHVF31yzpd4ilJkiQ1R6mZvog4KyLWR0RXRHT2cTwi4uri+MMRcepgbSNiSkSsiogniufJRfkHIuKBiHikeP6DRlyoJEmSJI1Gg4a+iGgDrgXmAbOACyJiVq9q84CZxWMRcF2Jtp3A6sycCawu3gM8C/xxZr4ZWAB8b8hXp6ZxZk+SJElqDWWWd84BujJzA0BE3AbMBx6rqzMfuDkzE7gvIiZFxDSgY4C284H3Fe2XAfcAn8/MtXXnXQccERGHZ+ZvhnSFOqQMe5IkSVJrKbO8czrwTN37TUVZmToDtT02M7cAFM9T+/jsjwBrDXytraNzhWFPkiRJalFlZvqij7IsWadM274/NOJNwDeBP+zn+CJqS0l5/etfX+aUOsgMfpIkSVLrKTPTtwk4ru79DGBzyToDtd1aLAGleN7WUykiZgA/Ai7MzCf76lRm3pCZszNzdnt7e4nLkCRJkqTRp0zoux+YGRHHR8RY4Hxgea86y4ELi108TwNeKJZsDtR2ObWNWiie7wSIiEnACuCKzPyfw7g2SZIkSRr1Bl3emZndEbEYuAtoA27MzHURcUlxfCmwEjgb6AJ2AQsHaluceglwe0RcBDwNnFeULwb+LXBlRFxZlP1hZu6dCZQkSZIklVPqy9kzcyW1YFdftrTudQKXlW1blO8Azuyj/GvA18r0S81Rf+/exiXnNLEnkiRJkgZT6svZpf64eYskSZLU2gx9kiRJklRhhj5JkiRJqjBDnyRJkiRVmKFPkiRJkirM0CdJkiRJFWboUynu0in9lr8fJEnSSGLokyRJkqQKK/Xl7BI4uyFJkiSNRM70SZIkSVKFGfokSZIkqcIMfZIkSZJUYd7Tp/3U37u3cck5TeyJJEmSpOFypk/7cLMWSZIkqVoMfZIkSZJUYS7v1ICc+ZMkSZJGNmf6JEmSJKnCDH2SJEmSVGGGvlGuo3OFSzglSZKkCvOePgHeuydJkiRVlTN9kiRJklRhhj5JkiRJqjBDnyRJkiRVmKFvlKjfsMXNWyRJkqTRw9A3ytSHPYOfJEmSVH2lQl9EnBUR6yOiKyI6+zgeEXF1cfzhiDh1sLYRMSUiVkXEE8Xz5KL86Ii4OyJeiojvNOIiJUmSJGm0GjT0RUQbcC0wD5gFXBARs3pVmwfMLB6LgOtKtO0EVmfmTGB18R7gFeBK4LNDvyzVc0ZPkiRJGr3KfE/fHKArMzcARMRtwHzgsbo684GbMzOB+yJiUkRMAzoGaDsfeF/RfhlwD/D5zHwZ+B8R8W+Hd2ky7EmSJEkqs7xzOvBM3ftNRVmZOgO1PTYztwAUz1PLd1uSJEmSVEaZ0Bd9lGXJOmXaDklELIqINRGxZvv27Y04pSRJkiRVTpnQtwk4ru79DGBzyToDtd1aLAGleN5WvtuQmTdk5uzMnN3e3n4gTUcFl3ZKkiRJgnKh735gZkQcHxFjgfOB5b3qLAcuLHbxPA14oViyOVDb5cCC4vUC4M5hXoskSZIkqZdBQ19mdgOLgbuAx4HbM3NdRFwSEZcU1VYCG4Au4G+ATw7UtmizBPhARDwBfKB4D0BEbAT+GviziNjUx26h6oOze5IkSZJ6K7N7J5m5kn6T1mQAAAiwSURBVFqwqy9bWvc6gcvKti3KdwBn9tOmo0y/JEmSJEkDKxX6NHI42ycdGj2/1zYuOafJPZEkSRqYoW+Eqv8Hp0FPkiRJUn/KbOQiSZIkSRqhDH2SJEmSVGGGPkmSJEmqMEOfJEmSJFWYoW+EcxMXSZIkSQMx9I1ABj1JkiRJZRn6JEmSJKnC/J6+EcQZPkmSJEkHytDXwgx5kiRJkobL5Z2SJEmSVGGGPkmSJEmqMENfi3FJpyRJkqRG8p6+FmTwkyRJktQozvRJkiRJUoUZ+iRJkiSpwgx9kiRJklRh3tPXAryHT5IkSdLB4kyfJEmSJFWYM31N4MyeJEmSpEPFmT5JkiRJqjBDnyRJkiRVmKHvEHNppyRJkqRDqVToi4izImJ9RHRFRGcfxyMiri6OPxwRpw7WNiKmRMSqiHiieJ5cd+yKov76iPjgcC+yFXR0rjDwSRXk72tJktTqBg19EdEGXAvMA2YBF0TErF7V5gEzi8ci4LoSbTuB1Zk5E1hdvKc4fj7wJuAs4P8tzjNi+Y9CSZIkSc1SZvfOOUBXZm4AiIjbgPnAY3V15gM3Z2YC90XEpIiYBnQM0HY+8L6i/TLgHuDzRfltmfkb4JcR0VX04d6hX2ZzGPak0aH37/WNS87p8/f/xiXn9Nmuvn7vOv3V7+uz+/rc/j5zoDr9nXu4OjpX9Hmesp9T5mckSZL2F7WcNkCFiD8BzsrMTxTvPw7MzczFdXX+K7AkM/9H8X41tQDX0V/biHg+MyfVneNXmTk5Ir4D3JeZtxTlfwv8ODPv6K+Ps2fPzjVr1gzh8g8uQ5+k0aYnkB3MP//6C9UHWmeon1kmpNcH3MGCeH96n6Ov173P31+d3uft7zqGEsD7+8+IA+nvcDTqPwOGcp7+rq33r7/hnFM1/lx+y5+F+hMRD2Tm7D6PlQh95wEf7BXc5mTmp+rqrAC+0Sv0/UfghP7aDhD6rgXu7RX6VmbmD3v1axG1paQAJwLrS/48GuEY4NlD+Hkqx3FpTY5L63JsWpPj0rocm9bkuLQmx+XQe0Nmtvd1oMzyzk3AcXXvZwCbS9YZO0DbrRExLTO3FEtBtx3A55GZNwA3lOh/w0XEmv5StJrHcWlNjkvrcmxak+PSuhyb1uS4tCbHpbWU2b3zfmBmRBwfEWOpbbKyvFed5cCFxS6epwEvZOaWQdouBxYUrxcAd9aVnx8Rh0fE8dQ2h/n5EK9PkiRJkka1QWf6MrM7IhYDdwFtwI2ZuS4iLimOLwVWAmcDXcAuYOFAbYtTLwFuj4iLgKeB84o26yLidmqbvXQDl2XmnkZdsCRJkiSNJmWWd5KZK6kFu/qypXWvE7isbNuifAdwZj9tvg58vUzfmqQpy0o1KMelNTkurcuxaU2OS+tybFqT49KaHJcWMuhGLpIkSZKkkavMPX2SJEmSpBHK0HcAIuKsiFgfEV0R0dns/lRdRNwYEdsi4tG6sikRsSoiniieJ9cdu6IYm/UR8cG68rdHxCPFsasjIg71tVRJRBwXEXdHxOMRsS4i/qIod2yaLCKOiIifR8QvirH5clHu2LSAiGiLiLXFd9s6Li0iIjYWP9OHImJNUebYNFlETIqIOyLiX4q/b97puDRXRJxY/D7pebwYEZc7LiNEZvoo8aC2Ec2T1L57cCzwC2BWs/tV5QdwBnAq8Ghd2beAzuJ1J/DN4vWsYkwOB44vxqqtOPZz4J1AAD8G5jX72kbyA5gGnFq8ngD8r+Ln79g0f2wCGF+8Pgz4GXCaY9MaD+AzwPeB/1q8d1xa4AFsBI7pVebYNH9clgGfKF6PBSY5Lq3zoPbv4v8NvMFxGRkPZ/rKmwN0ZeaGzNwN3AbMb3KfKi0zfwI816t4PrW/CCieP1RXfltm/iYzf0ltJ9k5UfsOyImZeW/W/pS5ua6NhiAzt2Tmg8XrncDjwHQcm6bLmpeKt4cVj8SxabqImAGcA/yXumLHpXU5Nk0UEROp/cfv3wJk5u7MfB7HpZWcCTyZmU/huIwIhr7ypgPP1L3fVJTp0Do2a98BSfE8tSjvb3ymF697l6sBIqIDOIXajJJj0wKKJYQPAduAVZnp2LSGbwP/EXitrsxxaQ0J/LeIeCAiFhVljk1znQBsB24qlkT/l4g4CsellZwP/KB47biMAIa+8vpaa+zWp62jv/Fx3A6SiBgP/BC4PDNfHKhqH2WOzUGSmXsy823ADGr/o3ryANUdm0MgIv4I2JaZD5Rt0keZ43LwnJ6ZpwLzgMsi4owB6jo2h8YYard3XJeZpwAvU1s22B/H5RCKiLHAvwP+frCqfZQ5Lk1i6CtvE3Bc3fsZwOYm9WU021osC6B43laU9zc+m4rXvcs1DBFxGLXAd2tm/n9FsWPTQoqlUPcAZ+HYNNvpwL+LiI3Ubg34g4i4BcelJWTm5uJ5G/AjardzODbNtQnYVKxUALiDWgh0XFrDPODBzNxavHdcRgBDX3n3AzMj4vjifzjOB5Y3uU+j0XJgQfF6AXBnXfn5EXF4RBwPzAR+Xiwz2BkRpxU7Q11Y10ZDUPwc/xZ4PDP/uu6QY9NkEdEeEZOK10cC/xfwLzg2TZWZV2TmjMzsoPZ3x/+fmX+K49J0EXFUREzoeQ38IfAojk1TZeb/Bp6JiBOLojOBx3BcWsUF/HZpJzguI0Ozd5IZSQ/gbGo7FT4JfLHZ/an6g9ofKFuAV6n9r9BFwNHAauCJ4nlKXf0vFmOznrpdoIDZ1P4SfxL4DhDNvraR/ADeTW0ZxsPAQ8XjbMem+Q/gLcDaYmweBf5TUe7YtMgDeB+/3b3TcWn+eJxAbXfBXwDrev5ud2ya/wDeBqwp/jz7B2Cy49L8BzAO2AG8rq7McRkBjyh+8JIkSZKkCnJ5pyRJkiRVmKFPkiRJkirM0CdJkiRJFWbokyRJkqQKM/RJkiRJUoUZ+iRJkiSpwgx9kiRJklRhhj5JkiRJqrD/A25+PIBhiIlyAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,0], label=r'$p_{1}^{E, (2)}$', density=True,bins=500);\n",
+    "plt.legend(fontsize='25');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,2], label=r'$p_{1}^{y, (2)}$',bins=500);\n",
+    "plt.legend(fontsize='25');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(pKst_Bbar[:,2],density=True, label=r'$p_{K}^{y, (2)}$',bins=500);\n",
+    "plt.legend(fontsize='25');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_Bbar_to_boost=p1_Bbar\n",
+    "p2_Bbar_to_boost=p2_Bbar"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_q = lorentz_boost_np(p1_Bbar_to_boost, -q_Bbar/q_Bbar[:,0:1])\n",
+    "p2_q = lorentz_boost_np(p2_Bbar_to_boost, -q_Bbar/q_Bbar[:,0:1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,0],alpha=0.5, density=True,label=r'$p_{1}^{x, (2)}$', bins=200);\n",
+    "plt.hist(p1[:,0],histtype=\"step\", density=True,label=r'$p_{1}^{x, (3)}$',bins=100);\n",
+    "plt.hist(p1_q[:,0],alpha=0.3,label=r'$p_{1}^{x, (3)}$ xcheck', density=True,bins=100);\n",
+    "plt.legend(fontsize='20');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z=np.array([[0.,0.,0.,1.] for i in range(p1_Bbar.shape[0])])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cos_theta_l_np_Bbar=get_costheta_l_np(p1_Bbar,z)\n",
+    "cos_theta_l_np_q=get_costheta_l_np(p1_q,z)\n",
+    "plt.hist(cos_theta_l_np_Bbar,bins=200, histtype=\"step\", label=r'$cos\\theta_{l}^{(2)}$', density=True);\n",
+    "plt.hist(cos_theta_l_np_q,bins=200, alpha=0.5,label=r'$cos\\theta_{l}^{(3)}$',density=True);\n",
+    "plt.legend(fontsize='20');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(20,7)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if TASK=='SAMPLE':\n",
+    "    \n",
+    "    MC_tuple = {}\n",
+    "    \n",
+    "    #MC_tuple['pB_Bbar']=pB_Bbar\n",
+    "    MC_tuple['pKst_Bbar']=pKst_Bbar\n",
+    "    #MC_tuple['k_Bbar']=k_Bbar\n",
+    "    MC_tuple['q_Bbar']=q_Bbar\n",
+    "    MC_tuple['p1_Bbar']=p1_Bbar\n",
+    "    MC_tuple['p2_Bbar']=p2_Bbar\n",
+    "    MC_tuple['p1']=p1\n",
+    "    MC_tuple['p2']=p2\n",
+    "    MC_tuple['cos_theta_l(2)']=cos_theta_l_np_Bbar\n",
+    "    MC_tuple['cos_theta_l(3)']=cos_theta_l_np_q\n",
+    "    MC_tuple['q2']=q2vals\n",
+    "\n",
+    "    with open('new_MC_tuple_B-toK-mumu_50K_100eVCutOff_trial.pickle','wb') as handle:\n",
+    "        pickle.dump(MC_tuple, handle)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/example_BtoKllgamma_fullydiff.ipynb b/example_BtoKllgamma_fullydiff.ipynb
new file mode 100644
index 0000000..fbbffa4
--- /dev/null
+++ b/example_BtoKllgamma_fullydiff.ipynb
@@ -0,0 +1,659 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from math import pi\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "import zfit\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
+    "\n",
+    "from utils.kin_utils_edit import *\n",
+    "from utils.BtoKllgamma_fullydiff_utils_fix import *\n",
+    "\n",
+    "import pickle\n",
+    "ztf = zfit.ztf\n",
+    "ztyping = zfit.util.ztyping\n",
+    "ztypes = zfit.settings.ztypes\n",
+    "\n",
+    "zfit.run.check_numerics = False\n",
+    "zfit.settings.set_verbosity(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#TASK='LOAD'\n",
+    "TASK='SAMPLE'\n",
+    "n_events=100000\n",
+    "\n",
+    "lepton_flv='mu'\n",
+    "\n",
+    "mB_mass=5280\n",
+    "mKst_mass=892\n",
+    "mgamma_mass = 0.1\n",
+    "\n",
+    "neutral_mesons=True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if lepton_flv=='e':\n",
+    "    l_mass = 0.5\n",
+    "elif lepton_flv=='mu':\n",
+    "    l_mass = 105\n",
+    "\n",
+    "mBbar_mass=mB_mass-mgamma_mass\n",
+    "\n",
+    "lower_q2= 4*l_mass*l_mass\n",
+    "upper_q2=(mBbar_mass-mKst_mass)*(mBbar_mass-mKst_mass)\n",
+    "\n",
+    "\n",
+    "upper_mBbar2 = mBbar_mass**2\n",
+    "lower_mBbar2 = (2*l_mass+mKst_mass)*(2*l_mass+mKst_mass)\n",
+    "\n",
+    "if neutral_mesons:\n",
+    "    filename='MC_tuple_{0}k_B0toK0'+lepton_flv+lepton_flv+'_fulldiff_{1}MeVcutoff.pickle'.format(n_events/1000, mgamma_mass)\n",
+    "else:\n",
+    "    filename='MC_tuple_{0}k_B+toK+'+lepton_flv+lepton_flv+'_fulldiff_{1}MeVcutoff.pickle'.format(n_events/1000, mgamma_mass)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class dGamma(zfit.pdf.ZPDF):\n",
+    "    \n",
+    "    _PARAMS = ['mB','mKst','ml','mgamma']\n",
+    "    _N_OBS = 5\n",
+    "    \n",
+    "    def _unnormalized_pdf(self, x):\n",
+    "        \n",
+    "\n",
+    "        mB = self.params['mB']      \n",
+    "        mKst = self.params['mKst']\n",
+    "        ml = self.params['ml']\n",
+    "        mgamma = self.params['mgamma']\n",
+    "        \n",
+    "        q2, mBbar2, cos_theta_l, cos_theta_gamma, phi_gamma,  = x.unstack_x()\n",
+    "        \n",
+    "        pB_Bbar, pKst_Bbar, k_Bbar, q_Bbar, p1_Bbar, p2_Bbar, p1, p2 = momenta_map(q2,\n",
+    "                                                                                  cos_theta_l,#phi_l,\n",
+    "                                                                                  cos_theta_gamma,phi_gamma,\n",
+    "                                                                                  #cos_theta_Kst,phi_Kst,\n",
+    "                                                                                  mB,mBbar2,mKst,\n",
+    "                                                                                  ml, mgamma, n_events=n_events, mode='tf')\n",
+    "        \"\"\"\n",
+    "        Scalar products\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "        p1k=scalar_product_4(p1_Bbar, k_Bbar)\n",
+    "        p2k=scalar_product_4(p2_Bbar, k_Bbar)\n",
+    "        \n",
+    "        Bk=scalar_product_4(pB_Bbar, k_Bbar)\n",
+    "        Kk=scalar_product_4(pKst_Bbar, k_Bbar)\n",
+    "        \n",
+    "        p1p2 = scalar_product_4(p1,p2)\n",
+    "        p1B = scalar_product_4(p1_Bbar,pB_Bbar)\n",
+    "        p2B = scalar_product_4(p2_Bbar,pB_Bbar)\n",
+    "        \n",
+    "        p1K = scalar_product_4(p1_Bbar,pKst_Bbar)\n",
+    "        p2K = scalar_product_4(p2_Bbar,pKst_Bbar)\n",
+    "        \n",
+    "        BK = scalar_product_4(pB_Bbar,pKst_Bbar)\n",
+    "\n",
+    "\n",
+    "        \"\"\"\n",
+    "        R_{ij} functions\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        R12= (p1p2)/((p1k)*(p2k))\n",
+    "        \n",
+    "        RBK=(BK)/((Bk)*(Kk))\n",
+    "        \n",
+    "        RB1=(p1B)/((p1k)*(Bk))\n",
+    "        RB2=(p2B)/((p2k)*(Bk))\n",
+    "        \n",
+    "        RK1=(p1K)/((p1k)*(Kk))\n",
+    "        RK2=(p2K)/((p2k)*(Kk))\n",
+    "        #\n",
+    "        R11= (ml**2)/((p1k)*(p1k))\n",
+    "        R22= (ml**2)/((p2k)*(p2k))\n",
+    "        \n",
+    "        RKK=(mKst**2)/((Kk)*(Kk))\n",
+    "        RBB=(mB**2)/((Bk)*(Kk))\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        Phasespace\n",
+    "        \n",
+    "        \n",
+    "        \"\"\"\n",
+    "        beta_l=dphi2_tf(ztf.sqrt(q2), ml, ml)\n",
+    "        phasespace_term= tf.expand_dims(dphi2_tf(mB, ztf.sqrt(mBbar2), mgamma)*dphi2_tf(ztf.sqrt(mBbar2), mKst, ztf.sqrt(q2))*beta_l,axis=-1)\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        Total PDF\n",
+    "        \n",
+    "        \"\"\"\n",
+    "        if neutral_mesons==True:\n",
+    "            pdf=-(R11+R22-2*R12)*phasespace_term\n",
+    "        else:\n",
+    "            pdf=-(RBB+RKK+R11+R22 + (RB1-RB2+RK1-RK2) + 2*RBK -2*R12)*phasespace_term\n",
+    "        \n",
+    "        return pdf[:,0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /disk/lhcb_data/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "mB_par = zfit.Parameter('mB', mB_mass)\n",
+    "mKst_par = zfit.Parameter('mKst', mKst_mass)\n",
+    "mgamma_par = zfit.Parameter('mgamma', mgamma_mass)\n",
+    "mlepton_par = zfit.Parameter('ml', l_mass)\n",
+    "mBbar_par = zfit.Parameter('mBbar', mBbar_mass)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From /disk/lhcb_data/davide/miniconda3/envs/zfit_env/lib/python3.6/site-packages/zfit/core/sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "lower = ((lower_q2, lower_mBbar2,  -1. , -1. ,-pi,),)\n",
+    "upper = ((upper_q2, upper_mBbar2,   1. ,  1. , pi,),)\n",
+    "\n",
+    "\n",
+    "#lower = ((lower_q2, lower_mBbar2,  -1., -pi, -1., -pi,  -1., -pi,),)\n",
+    "#upper = ((upper_q2, upper_mBbar2,   1.,  pi,  1.,  pi,   1.,  pi,),)\n",
+    "#\n",
+    "#obs_list=[\"q2\", \"mBbar\", \"theta_l\", \"theta_gamma\", \"phi_gamma\"]\n",
+    "#obs_list=[\"q2\", \"mBbar2\", \"cos_theta_l\", \"phi_l\",\"cos_theta_gamma\", \"phi_gamma\",\"cos_theta_Kst\",\"phi_Kst\"]\n",
+    "obs_list=[\"q2\", \"mBbar2\", \"cos_theta_l\",\"cos_theta_gamma\", \"phi_gamma\"]\n",
+    "obs = zfit.Space(obs_list, limits=(lower,upper))\n",
+    "\n",
+    "pdf = dGamma(obs=obs, ml = mlepton_par, mB = mB_par, mKst = mKst_par, mgamma= mgamma_par)\n",
+    "\n",
+    "sampler = pdf.create_sampler(n=n_events)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sampling done!\n"
+     ]
+    }
+   ],
+   "source": [
+    "if TASK=='SAMPLE':\n",
+    "    \n",
+    "    for i in range(1):\n",
+    "        sampler.resample()\n",
+    "    sample = sampler.to_pandas()\n",
+    "    print('sampling done!')\n",
+    "    MC_tuple={}\n",
+    "    \n",
+    "    for j in range(sample.keys().shape[0]):\n",
+    "    \n",
+    "        MC_tuple[sample.keys()[j]]=np.array([sample[sample.keys()[j]][i] for i in range(n_events)]).reshape(n_events,1)\n",
+    "        \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pB_Bbar, pKst_Bbar, k_Bbar, q_Bbar, p1_Bbar, p2_Bbar, p1, p2=momenta_map(MC_tuple['q2'], \n",
+    "                                                                         MC_tuple['cos_theta_l'],\n",
+    "                                                                         #MC_tuple['phi_l'],\n",
+    "                                                                         MC_tuple['cos_theta_gamma'], \n",
+    "                                                                         MC_tuple['phi_gamma'],\n",
+    "                                                                         #MC_tuple['cos_theta_Kst'], \n",
+    "                                                                         #MC_tuple['phi_Kst'],\n",
+    "                                                                         mB_mass, MC_tuple['mBbar2'], \n",
+    "                                                                         mKst_mass, l_mass, mgamma_mass,\n",
+    "                                                                        mode = 'numpy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p1_Bbar_to_boost=p1_Bbar\n",
+    "p2_Bbar_to_boost=p2_Bbar\n",
+    "p1_q = lorentz_boost_np(p1_Bbar_to_boost, -q_Bbar/q_Bbar[:,0:1])\n",
+    "p2_q = lorentz_boost_np(p2_Bbar_to_boost, -q_Bbar/q_Bbar[:,0:1])\n",
+    "z=np.array([[0.,0.,0.,1.] for i in range(p1_Bbar.shape[0])])\n",
+    "\n",
+    "cos_theta_l_np_Bbar=get_costheta_l_np(p1_Bbar,z)\n",
+    "cos_theta_l_np_q=get_costheta_l_np(p1_q,z)\n",
+    "\n",
+    "\n",
+    "MC_tuple['pB_Bar']=pB_Bbar\n",
+    "MC_tuple['pKst_Bar']=pKst_Bbar\n",
+    "MC_tuple['k_Bar']=k_Bbar\n",
+    "MC_tuple['q_Bar']=q_Bbar\n",
+    "MC_tuple['p1_Bar']=p1_Bbar\n",
+    "MC_tuple['p2_Bar']=p2_Bbar\n",
+    "MC_tuple['p1']=p1\n",
+    "MC_tuple['p2']=p2\n",
+    "MC_tuple['cos_theta_l(3)']=cos_theta_l_np_q.reshape(n_events,1)\n",
+    "MC_tuple['cos_theta_l(2)']=cos_theta_l_np_Bbar.reshape(n_events,1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if TASK=='LOAD':\n",
+    "    with open(filename,'rb') as f:\n",
+    "        MC_tuple= pickle.load(f) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(104.99999999999996, 104.99999999999993)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(scalar_product_4_np(p1_Bbar,p1_Bbar)).mean(),np.sqrt(scalar_product_4_np(p1_q,p1_q)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x1440 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.subplot(4,2,1)\n",
+    "plt.hist(MC_tuple['q2']/1e6,density=True, label=r'$\\frac{dR_{0}}{dq^{2}}$', bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "plt.subplot(4,2,2)    \n",
+    "plt.hist(MC_tuple['mBbar2']/1e6,density=True,label=r'$\\frac{dR_{0}}{d\\bar{p}^{2}_{B}}$',bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "plt.subplot(4,2,3)    \n",
+    "plt.hist(MC_tuple['cos_theta_l'],density=True,label=r'$\\frac{dR_{0}}{dcos\\theta_{l}}$',bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "plt.subplot(4,2,4) \n",
+    "plt.hist(MC_tuple['cos_theta_gamma'],density=True,label=r'$\\frac{dR_{0}}{dcos\\theta_{\\gamma}}$',bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "plt.subplot(4,2,5)    \n",
+    "plt.hist(MC_tuple['phi_gamma'],density=True,label=r'$\\frac{dR_{0}}{d\\phi_{\\gamma}}$',bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "plt.subplot(4,2,6)\n",
+    "#plt.hist(MC_tuple['phi_l'],density=True,label=r'$\\frac{dR_{0}}{d\\phi_{l}}$',bins=100);\n",
+    "#plt.legend(fontsize='25');\n",
+    "#plt.subplot(4,2,7) \n",
+    "#plt.hist(MC_tuple['cos_theta_Kst'],density=True,label=r'$\\frac{dR_{0}}{dcos\\theta_{K}}$',bins=100);\n",
+    "#plt.legend(fontsize='25');\n",
+    "#plt.subplot(4,2,8)\n",
+    "#plt.hist(MC_tuple['phi_Kst'],density=True,label=r'$\\frac{dR_{0}}{d\\phi_{K}}$',bins=100);\n",
+    "#plt.legend(fontsize='25');\n",
+    "\n",
+    "\n",
+    "\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,20);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sample_for_hist=np.array([\n",
+    "    \n",
+    "    MC_tuple['q2'],\n",
+    "    MC_tuple['mBbar2'],\n",
+    "    MC_tuple['cos_theta_l'],\n",
+    "    #MC_tuple['phi_l'],\n",
+    "    MC_tuple['cos_theta_gamma'],\n",
+    "    MC_tuple['phi_gamma'],\n",
+    "    #MC_tuple['cos_theta_Kst'],\n",
+    "    #MC_tuple['phi_Kst'],\n",
+    "]\n",
+    ").reshape(len(obs_list),n_events).transpose()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mass checks ok\n",
+      "B rest frame ok\n"
+     ]
+    }
+   ],
+   "source": [
+    "Kst_mass_check = (np.sqrt(scalar_product_4_np(pKst_Bbar,pKst_Bbar))).mean()-mKst_mass<10**-10\n",
+    "lepton_mass_check = (np.sqrt(scalar_product_4_np(p2_Bbar,p2_Bbar))).mean()-l_mass<10**-10\n",
+    "B_mass_check = (np.sqrt(scalar_product_4_np(pB_Bbar,pB_Bbar))).mean()-mB_mass<10**10                   \n",
+    "photon_mass_check = (np.sqrt(scalar_product_4_np(k_Bbar,k_Bbar))).mean()-mgamma_mass<10**-7\n",
+    "\n",
+    "if Kst_mass_check and lepton_mass_check and B_mass_check and photon_mass_check:\n",
+    "    print('Mass checks ok')\n",
+    "else:\n",
+    "    print('Mass checks not good')\n",
+    "    print('Kst mass', Kst_mass_check)\n",
+    "    print('lepton mass', lepton_mass_check)\n",
+    "    print('B mass', B_mass_check)\n",
+    "    print('photon_mass_check', photon_mass_check)\n",
+    "    \n",
+    "pB_Bbar_to_boost=pB_Bbar\n",
+    "pB = lorentz_boost_np(pB_Bbar_to_boost, -pB_Bbar/pB_Bbar[:,0:1])\n",
+    "\n",
+    "spatial_rest_check=pB[:,1].mean()<10**-10 and pB[:,2].mean()<10**-10 and pB[:,3].mean()<10**-10\n",
+    "Brest_mass_check=pB[:,0].mean()==mB_mass\n",
+    "\n",
+    "if spatial_rest_check and Brest_mass_check:\n",
+    "    print('B rest frame ok')\n",
+    "else:\n",
+    "    print('B rest frame not good')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,0], label=r'$p_{1}^{E, (2)}$', range=(0,2600),density=True,bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "136"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(p1_Bbar[:,0]>2500).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA20AAAEvCAYAAADW/SmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAf/UlEQVR4nO3df7RfZX0n+vfnnkgkJkgggBiggQ6KSFWukV8W1GF6dSptkCILXQqltqAVq7dTR36sFtvCEn+04xWmIzhFo1KUYqfQQUCkMDgLxOGHI7+Ga/hphGuCkUkQSEh47h/nG3oCJznJ+X5Pzs45r9daWee7n/3s/f2csPnmvM/z7GdXay0AAAB00/8x2QUAAACwcUIbAABAhwltAAAAHSa0AQAAdJjQBgAA0GFCGwAAQIfNmOwCkmTevHltwYIFk10GAADApLjtttseb63tMtq+ToS2BQsW5NZbb53sMgAAACZFVT28sX2mRwIAAHSY0AYAANBhQhsAAECHCW0AAAAdJrQBAAB0mNAGAADQYUIbAABAhwltAAAAHSa0AQAAdJjQBgAA0GEzJrsAAACYTK21rFq1KitXrsxTTz2VdevWTXZJbIOGhoYya9as7LDDDpkzZ06qamDnFtoA6IwFp125yf0PnfvOrVQJMF201rJs2bL88pe/zE477ZRXvOIVGRoaGugP3Ex9rbWsW7cuTz75ZB5//PE8/fTT2XXXXQd2HQltAABMW6tWrcovf/nL/Mqv/EqGhoYmuxy2UVWVGTNmZMcdd8ycOXPy8MMPZ9WqVdlhhx0Gcn73tAEAMG2tXLkyO+20k8DGwAwNDWWnnXbKypUrB3ZOoQ0AgGnrqaeeyuzZsye7DKaY2bNn56mnnhrY+YQ2AACmrXXr1hllY+CGhoYGuqCN0AYAwLRm0REGbdDXlNAGAADQYUIbAABAh40Z2qrqoqpaVlV3vaD9I1V1X1XdXVWfGdF+elUt6e17+0QUDQAAMF1sznPavpLk/CRfXd9QVW9LsijJ61prq6tq1177/kmOT/LaJK9M8t2qelVrzWPlAQAAxmHMkbbW2o1JVryg+UNJzm2tre71WdZrX5TkG6211a21B5MsSXLQAOsFAACYVsZ7T9urkhxeVbdU1X+rqjf12ucn+cmIfkt7bQAAAFvNTTfdlKGhodx1111jdx7FRRddlLlz52bFiheOX219mzM9cmPHzU1ySJI3Jbm0qvZJMtralm20E1TVyUlOTpK99tprnGUAwLZtwWlXbnL/Q+e+cytVAjC1/Mmf/El+53d+JwcccMDzbbfffnu+/vWv57rrrsuDDz6YmTNn5jWveU3++I//OEcfffQGx59wwgk5++yzc8455+Sv/uqvtnb5GxjvSNvSJP/Qhv0gyXNJ5vXa9xzRb48kj452gtbaha21ha21hbvssss4ywAAANjQ9ddfn5tvvjl/9Ed/tEH7Zz7zmSxevDgHHXRQPvOZz+TMM8/M6tWr8653vSt/9md/tkHfGTNm5JRTTsnf/M3f5Iknntia5b/IeEPbPyb510lSVa9Ksl2Sx5NckeT4qppZVXsn2TfJDwZRKAAAwOa44IILsmDBgrz5zW/eoP0jH/lIfvrTn+ZLX/pSPvjBD+ZjH/tYbrrpphxyyCH51Kc+9aKpkO9973uzevXqfP3rX9+a5b/ImNMjq+qSJG9NMq+qliY5K8lFSS7qPQZgTZITW2styd1VdWmSe5KsTfJhK0cCMN2NNQUSgOSJJ57I3LlzN7r/i1/8Yk455ZQxz/Pss8/mn/7pn/L+978/VRvevfXCEJckQ0NDOeaYY/L9738/9913Xw499NDn9+25557Zf//9c9lll+XUU0/dgu9msMYMba2192xk1/s20v+cJOf0UxQAADC9tNbyta99bYO2Z599NmeccUZWrlyZt771rZt1nttuuy1PPfVU3vSmN43duefRR4fv6Np1111ftO/ggw/O3/3d32XNmjXZbrvtNvucgzTehUgAAAAGZu7cuXnf+/5lXGjNmjU57rjjsnLlylx55ZV59atfvVnnuffee5Mk++yzz2b1/+lPf5ovf/nLOfjgg/Orv/qrL9q/zz775JlnnskDDzyQ/fbbb7POOWjjvacNAABgQqxZsybHHntsvvvd7+bb3/72Zo+yJcny5cuTZJNTLdd76qmn8q53vStr1qzJl770pVH77LzzzhucdzIYaQMAADpj9erVOfbYY3PDDTfkqquuyuGHHz6u8wwvubFxa9asyTHHHJM77rgjl112WX7t135t1H7PPfdckrzo/ritSWgDAIAxTJUFhbr+7MfVq1fnmGOOyfe+971cddVV+fVf//UtPsf6x4n94he/2GifZ599Nscdd1yuvfbaLF68OIsWLdpo3/XnmTdv3hbXMiimRwIAAJPumWeeydFHH53vfe97ufrqq8cV2JLkNa95TZJkyZIlo+5ft25d3vve9+byyy/PF7/4xQ3uoxvN/fffn+23336z75GbCEIbAAAwEH/5l3+Zqsrb3va2rFq1Kuecc04OOuigzJ07NzNnzsx+++2XT33qU1m3bsOngj3zzDNZtGhRbrrpplxzzTU57LDDxl3DG9/4xsyaNSs/+MGLHxf93HPP5cQTT8xll12Wz3/+8/mDP/iDMc93yy235OCDD560lSMT0yMBAIABuf3225MML97x+te/Pg8++GCqKi972cuyZs2a3HfffTnjjDNy9913b/DA6hNOOCHf+c53cuqpp+b+++/P/fff//y+7bbbLscdd9zz21WVt7zlLbnhhhtGreElL3lJfuu3fivXXHNNWmsb3Iv28Y9/PBdffHEOPfTQ7Lzzzi96aPZhhx22wYjaI488knvvvTcf+tCH+vp76ZfQBgAADMT60Patb30rc+bMyRe+8IWcdNJJmT17dh544IH8/u//fq6//vpcfPHFOeWUU3L44YentZarr746SXL++efn/PPP3+Ccb3jDG54PbatWrUqS7L777pus45RTTsk3v/nN3HjjjXnLW97yfPttt92WJLn55ptz8803v+i4L3/5yxuEtksuuSQzZ84ccwrlRBPaAACAvq1YsSKPPPJIkmT27Nm5/vrr88Y3vvH5/fvss0/+/u//PnvvvXdWrVqVK664IocffniqKitXrtys97jhhhtSVTnjjDM22e9tb3tbDj300Jx33nkbhLaNjc6NZu3atbngggvyh3/4h9lxxx03+7iJILQBTFGbWums66uHjddEre42Vf++AAZp/ShbMnxv28jAtt7OO++cww47LNdcc00eeOCBLX6Pa6+9Nscff/xGl+cf6bOf/WyOOOKI3HnnnZvV/4W+9rWv5Re/+EXOPPPMLT520IQ2AACgb+tD29y5c/PBD35wo/3Gmtq4KV/4whc2u++b3/zmFy14siVOOumknHTSSeM+fpCENgDo01R5fhNAP+64444kyVFHHZWXvvSlG+3385//PEmy2267bZW6pgKhDYCtSsABmJrWj7QtXLhwk/1uueWWJMmBBx444TVNFZ7TBgAA9OXJJ598/mHW8+bN22i/G264IcuWLUtV5Td/8zefP/aTn/xkjjrqqLziFa9IVeV3f/d3t0bZ2wyhDQAA6MsPf/jDPPfcc0mS5cuXb7Tfpz/96STJsccem/nz5ydJHn/88fz5n/95br/99jFH6aYr0yMBYIoaayqqVTGBQRm5cuRVV12Vj370oy/qc+GFF+bqq6/OS1/60vzFX/zF8+277757li5dmvnz5+eZZ57J9ttvv1Vq3pYYaQMAAPqyPrTtuOOOueaaa/Knf/qnzz8I+7HHHsvHP/7xfOhDH0qSXHDBBdlvv/2eP3bmzJnPj7oxOqENAADoy/qVIz/5yU/mgAMOyNlnn52Xv/zlefnLX55XvvKV+dznPpeqyuc///mccMIJk1zttkdoAwAAxm316tW55557kiSHHHJIbrzxxpx66qnZY4898swzz2T+/Pl5//vfn9tvv33UaZOMzT1tAADAuP3oRz/K2rVrMzQ0lNe97nXZfvvtc9555+W8886b7NKmDKENAADGYOGejVs/NfLVr361RUQmiOmRAADAuK1fhOQNb3jDJFcydY0Z2qrqoqpaVlV3jbLvT6qqVdW8EW2nV9WSqrqvqt4+6IIBAIDuWB/aDjzwwEmuZOranOmRX0lyfpKvjmysqj2T/EaSR0a07Z/k+CSvTfLKJN+tqle11tYNqmAA+uf5XQAMwtq1a3PnnXcmMdI2kcYMba21G6tqwSi7/kOSf5/k8hFti5J8o7W2OsmDVbUkyUFJbu6/VAAAoEtmzJiRp59+uu/znH/++XniiSeydu3aJMOLm5x99tlJkiOOOCJHHHFE3++xLRvXQiRV9dtJftpa+59VNXLX/CTfH7G9tNcGAH0ba4QQgG3T5z73uTz88MPPb99xxx3PL3By1llnCW1bekBVzUpyZpL/a7Tdo7S1jZzn5CQnJ8lee+21pWUAAABTxEMPPTTZJXTaeFaP/NUkeyf5n1X1UJI9ktxeVa/I8MjaniP67pHk0dFO0lq7sLW2sLW2cJdddhlHGQAAAFPfFo+0tdbuTLLr+u1ecFvYWnu8qq5I8ndV9dcZXohk3yQ/GFCtAMA2YlNTWS10A7BlNmfJ/0syvJDIq6tqaVV9YGN9W2t3J7k0yT1Jrk7yYStHAgAAjN/mrB75njH2L3jB9jlJzumvLAAAAJJxrh4JMJ14phlWrQRgMo1nIRIAAAC2EqENAACgw0yPBGCgTCUEgMES2gDYYoIZMJW01lJVk10GU0hrbaDnMz0SAIBpa2hoKOvWeUIVg7Vu3boMDQ0N7HxCGwAA09asWbPy5JNPTnYZTDFPPvlkZs2aNbDzCW0AAExbO+ywQ1asWGG0jYFZt25dVqxYkR122GFg53RPGwAA09acOXPy9NNP5+GHH85OO+2U2bNnZ2hoyD1ubJHWWtatW5cnn3wyK1asyMte9rLMmTNnYOcX2oApYao+AHtT39e2+j0BdElVZdddd82qVauycuXKLFu2zKgb4zI0NJRZs2Zl3rx5mTNnzkCDv9AGAMC0VlXZYYcdBjqdDQbJPW0AAAAdJrQBAAB0mNAGAADQYe5pA5hEYy2gAlPRVF04CGCiCG0A0GFWEAXA9EgAAIAOM9IGsI0ytZKpeg1M5OiikUtgW2SkDQAAoMOENgAAgA4T2gAAADpMaAMAAOiwMUNbVV1UVcuq6q4RbZ+tqv9VVT+qqv9SVTuO2Hd6VS2pqvuq6u0TVTgAAMB0sDmrR34lyflJvjqi7dokp7fW1lbVp5OcnuQTVbV/kuOTvDbJK5N8t6pe1VpbN9iyAYDJNFVXrgToojFH2lprNyZZ8YK277TW1vY2v59kj97rRUm+0Vpb3Vp7MMmSJAcNsF4AAIBpZRD3tP1ekqt6r+cn+cmIfUt7bQAAAIxDXw/Xrqozk6xNcvH6plG6tY0ce3KSk5Nkr7326qcMAGDATH8E6I5xh7aqOjHJUUmObK2tD2ZLk+w5otseSR4d7fjW2oVJLkyShQsXjhrsAJgcfmAHgO4Y1/TIqnpHkk8k+e3W2lMjdl2R5PiqmllVeyfZN8kP+i8TAABgehpzpK2qLkny1iTzqmppkrMyvFrkzCTXVlWSfL+19sHW2t1VdWmSezI8bfLDVo4EAAZlrFHgh85951aqBGDrGTO0tdbeM0rz326i/zlJzumnKAAAAIb1tRAJwFTg/i0AoMsGseQ/AAAAE0RoAwAA6DDTIwEmkKmXAEC/hDbgRTYVNKzMBlOHXyowWawCClvG9EgAAIAOE9oAAAA6zPRIAIAJ1s9UVFMFASNtAAAAHSa0AQAAdJjQBgAA0GFCGwAAQIdZiASYFjyPChhLP88O8xkDTCShDaBPflgDACaS6ZEAAAAdZqQNAIBtyqZmOHiuHVORkTYAAIAOE9oAAAA6zPRIAIDNYNEhYLIYaQMAAOgwoQ0AAKDDTI+EbdR0XDnL1CQAYDoac6Stqi6qqmVVddeItp2q6tqq+nHv69wR+06vqiVVdV9VvX2iCgcAAJgONmek7StJzk/y1RFtpyW5rrV2blWd1tv+RFXtn+T4JK9N8sok362qV7XW1g22bGBbNNZI2VQdIQS2HiPy9Gs6zmSh+8YcaWut3ZhkxQuaFyVZ3Hu9OMnRI9q/0Vpb3Vp7MMmSJAcNqFYAAIBpZ7wLkezWWnssSXpfd+21z0/ykxH9lvbaAAAAGIdBrx5Zo7S1UTtWnVxVt1bVrcuXLx9wGQAAAFPDeFeP/FlV7d5ae6yqdk+yrNe+NMmeI/rtkeTR0U7QWrswyYVJsnDhwlGDHTAxJvKeD/eTAAAM1nhH2q5IcmLv9YlJLh/RfnxVzayqvZPsm+QH/ZUIAAAwfY050lZVlyR5a5J5VbU0yVlJzk1yaVV9IMkjSd6dJK21u6vq0iT3JFmb5MNWjgQAGD8r7wJjhrbW2ns2suvIjfQ/J8k5/RQFAADAsEEvRAIAAMAAjXchEgAApjgPmoZuENqAzrDyJADAi5keCQAA0GFG2ugMUzAAAODFjLQBAAB0mJE2mERGFwEAGIuRNgAAgA4T2gAAADrM9EgAgClqrEepmIoP2wahDQBgG9bPMy49H3N6cA/9ts/0SAAAgA4z0gYTaCr+BnMqfk8AMAhGtJgoQhsDY958dwhWAEw0/+7D1mN6JAAAQIcZaYM+GNECgNH5NxIGx0gbAABAhwltAAAAHWZ6JHSUaSUAACRG2gAAADpNaAMAAOgw0yMBAGAb5paKqa+vkbaq+r+r6u6ququqLqmql1bVTlV1bVX9uPd17qCKBQAAmG7GHdqqan6SP0qysLV2QJKhJMcnOS3Jda21fZNc19sGAABgHPqdHjkjyfZV9WySWUkeTXJ6krf29i9OckOST/T5PkwBhu4BAGDLjXukrbX20ySfS/JIkseS/O/W2neS7NZae6zX57Ekuw6iUAAAgOmon+mRc5MsSrJ3klcmeVlVvW8Ljj+5qm6tqluXL18+3jIAAACmtH6mR/6bJA+21pYnSVX9Q5LDkvysqnZvrT1WVbsnWTbawa21C5NcmCQLFy5sfdQBE8q0TgCAwdvUz1gPnfvOrVhJ9/WzeuQjSQ6pqllVVUmOTHJvkiuSnNjrc2KSy/srEQAAYPoa90hba+2Wqrosye1J1ia5I8MjZ7OTXFpVH8hwsHv3IAplehtrtMtvYwCAbZmfddiUvlaPbK2dleSsFzSvzvCoG5PE//QAADB19PVwbQAAACZWv89pAwCAzrCA2JYxQ2vbILRNQ/2s1OODEACYrvwcxGQxPRIAAKDDjLSxAb9BAgCAbhHaOsrDBgfL3ycAsC3zi/XpzfRIAACADhPaAAAAOsz0yG2Q4XEAAJg+jLQBAAB0mNAGAADQYaZHMiWYMgoAsPVZoXvrMNIGAADQYUIbAABAhwltAAAAHeaeNgAAmGDb6v3322rdU42RNgAAgA4T2gAAADpMaAMAAOgwoQ0AAKDDhDYAAIAOs3okAACdYsVC2FBfoa2qdkzyn5MckKQl+b0k9yX5ZpIFSR5Kclxr7Rd9VQkTyD8MAAB0Wb/TI/+fJFe31vZL8vok9yY5Lcl1rbV9k1zX2wYAAGAcxh3aqmqHJEck+dskaa2taa09kWRRksW9bouTHN1vkQAAANNVP9Mj90myPMmXq+r1SW5L8tEku7XWHkuS1tpjVbXraAdX1clJTk6Svfbaq48ytk2m5AEAMJX5eXdw+pkeOSPJ/5nkP7XWDkzyy2zBVMjW2oWttYWttYW77LJLH2UAAABMXf2EtqVJlrbWbultX5bhEPezqto9SXpfl/VXIgAAwPQ17umRrbX/r6p+UlWvbq3dl+TIJPf0/pyY5Nze18sHUikAADAtjDW18qFz37mVKumGfp/T9pEkF1fVdkkeSHJShkfvLq2qDyR5JMm7+3wPAACAaauv0NZa+2GShaPsOrKf8wIAADCs3+e0AQAAMIGENgAAgA4T2gAAADpMaAMAAOgwoQ0AAKDDhDYAAIAOE9oAAAA6TGgDAADoMKENAACgw4Q2AACADhPaAAAAOkxoAwAA6DChDQAAoMNmTHYBU9mC066c7BIAAIBtnJE2AACADhPaAAAAOkxoAwAA6DChDQAAoMOENgAAgA4T2gAAADpMaAMAAOiwvkNbVQ1V1R1V9V972ztV1bVV9ePe17n9lwkAADA9DWKk7aNJ7h2xfVqS61pr+ya5rrcNAADAOPQV2qpqjyTvTPKfRzQvSrK493pxkqP7eQ8AAIDprN+Rts8n+fdJnhvRtltr7bEk6X3dtc/3AAAAmLbGHdqq6qgky1prt43z+JOr6taqunX58uXjLQMAAGBK62ek7c1JfruqHkryjST/uqq+nuRnVbV7kvS+Lhvt4Nbaha21ha21hbvssksfZQAAAExd4w5trbXTW2t7tNYWJDk+yT+31t6X5IokJ/a6nZjk8r6rBAAAmKYm4jlt5yb5jar6cZLf6G0DAAAwDjMGcZLW2g1Jbui9/nmSIwdxXgAAgOluIKFtulpw2pWTXQIAADDFTcT0SAAAAAZEaAMAAOgwoQ0AAKDDhDYAAIAOE9oAAAA6TGgDAADoMKENAACgw4Q2AACADhPaAAAAOkxoAwAA6DChDQAAoMOENgAAgA4T2gAAADpsxmQXAAAAsCUWnHblJvc/dO47t1IlW4eRNgAAgA4T2gAAADpMaAMAAOgwoQ0AAKDDhDYAAIAOE9oAAAA6TGgDAADosHGHtqras6qur6p7q+ruqvpor32nqrq2qn7c+zp3cOUCAABML/2MtK1N8u9aa69JckiSD1fV/klOS3Jda23fJNf1tgEAABiHcYe21tpjrbXbe69XJbk3yfwki5Is7nVbnOTofosEAACYrgZyT1tVLUhyYJJbkuzWWnssGQ52SXYdxHsAAABMR32HtqqaneRbST7WWlu5BcedXFW3VtWty5cv77cMAACAKamv0FZVL8lwYLu4tfYPveafVdXuvf27J1k22rGttQtbawtbawt32WWXfsoAAACYsvpZPbKS/G2Se1trfz1i1xVJTuy9PjHJ5eMvDwAAYHqb0cexb07y/iR3VtUPe21nJDk3yaVV9YEkjyR5d38lAgAATF/jDm2ttf+epDay+8jxnhcAAIB/MZDVIwEAAJgYQhsAAECHCW0AAAAdJrQBAAB0mNAGAADQYUIbAABAhwltAAAAHSa0AQAAdJjQBgAA0GFCGwAAQIcJbQAAAB0mtAEAAHSY0AYAANBhQhsAAECHCW0AAAAdJrQBAAB0mNAGAADQYUIbAABAhwltAAAAHSa0AQAAdJjQBgAA0GFCGwAAQIdNWGirqndU1X1VtaSqTpuo9wEAAJjKJiS0VdVQkv+Y5N8m2T/Je6pq/4l4LwAAgKlsxgSd96AkS1prDyRJVX0jyaIk90zQ+02IBaddOdklAAAA09xETY+cn+QnI7aX9toAAADYAhM10lajtLUNOlSdnOTk3uaTVXXfBNVCd81L8vhkF8E2z3XEoLiWGATXEYPgOupTfXqyKxiXX9nYjokKbUuT7Dlie48kj47s0Fq7MMmFE/T+bAOq6tbW2sLJroNtm+uIQXEtMQiuIwbBdcQLTdT0yP+RZN+q2ruqtktyfJIrJui9AAAApqwJGWlrra2tqlOTXJNkKMlFrbW7J+K9AAAAprKJmh6Z1tq3k3x7os7PlGB6LIPgOmJQXEsMguuIQXAdsYFqrY3dCwAAgEkxUfe0AQAAMABCGxOiqj5bVf+rqn5UVf+lqnYcse/0qlpSVfdV1dtHtL+xqu7s7ftCVVWvfWZVfbPXfktVLdj63xGTpareXVV3V9VzVbXwBftcS/Stqt7Ru4aWVNVpk10P3VNVF1XVsqq6a0TbTlV1bVX9uPd17oh9W/TZxNRXVXtW1fVVdW/v37SP9tpdR2wWoY2Jcm2SA1prr0vy/yY5PUmqav8Mryb62iTvSPI3VTXUO+Y/ZfjZffv2/ryj1/6BJL9orf2rJP8hybb55A3G664kxyS5cWSja4lB6F0z/zHJv02yf5L39K4tGOkr+ZfPkfVOS3Jda23fJNf1tsf72cTUtzbJv2utvSbJIUk+3LtWXEdsFqGNCdFa+05rbW1v8/sZflZfkixK8o3W2urW2oNJliQ5qKp2T7JDa+3mNnyj5VeTHD3imMW915clOdJvlaaP1tq9rbX7RtnlWmIQDkqypLX2QGttTZJvZPg6gee11m5MsuIFzSM/TxZnw8+ZLf1sYoprrT3WWru993pVknuTzI/riM0ktLE1/F6Sq3qv5yf5yYh9S3tt83uvX9i+wTG9IPi/k+w8gfWybXAtMQgbu45gLLu11h5Lhn8gT7Jrr308n01MI72p+QcmuSWuIzbThC35z9RXVd9N8opRdp3ZWru81+fMDE8JuHj9YaP0b5to39QxTBGbcy2Ndtgoba4ltpRrgkEbz2cT00RVzU7yrSQfa62t3MRkD9cRGxDaGLfW2r/Z1P6qOjHJUUmObP/ybImlSfYc0W2PJI/22vcYpX3kMUurakaSl+fF01TYho11LW2Ea4lB2Nh1BGP5WVXt3lp7rDdlbVmvfTyfTUwDVfWSDAe2i1tr/9Brdh2xWUyPZEJU1TuSfCLJb7fWnhqx64okx/dW8ds7wzfQ/qA3JWBVVR3Su8fohCSXjzjmxN7rY5P884gQyPTlWmIQ/keSfatq76raLsM3/l8xyTWxbRj5eXJiNvyc2dLPJqa43n/zv01yb2vtr0fsch2xWTxcmwlRVUuSzEzy817T91trH+ztOzPD97mtzfD0gKt67QszvELX9hm+B+4jrbVWVS9N8rUMz/9ekeT41toDW/HbYRJV1buSnJdklyRPJPlha+3tvX2uJfpWVb+Z5PNJhpJc1Fo7Z5JLomOq6pIkb00yL8nPkpyV5B+TXJpkrySPJHl3a21Fr/8WfTZtze+FyVFVv57ke0nuTPJcr/mMDN/X5jpiTEIbAABAh5keCQAA0GFCGwAAQIcJbQAAAB0mtAEAAHSY0AYAANBhQhsAAECHCW0AAAAdJrQBAAB02P8PwlnjEvmYaRcAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,3], label=r'$p_{1}^{z, (2)}$',range=(-2600,2600),bins=100);\n",
+    "plt.legend(fontsize='25');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#plt.hist(pKst_Bbar[:,1],density=True, label=r'$p_{K}^{y, (2)}$',bins=500);\n",
+    "#plt.legend(fontsize='25');\n",
+    "#fig = plt.gcf()\n",
+    "#fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(p1_Bbar[:,0],alpha=0.5, density=True,label=r'$p_{1}^{E, (2)}$', range=(0,2600),bins=100);\n",
+    "plt.hist(p1[:,0],histtype=\"step\", density=True,label=r'$p_{1}^{E, (3)}$', range=(0,2600), bins=100);\n",
+    "plt.hist(p1_q[:,0],alpha=0.3,label=r'$p_{1}^{E, (3)}$ xcheck', density=True,range=(0,2600), bins=100);\n",
+    "plt.legend(fontsize='20');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(15,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(cos_theta_l_np_Bbar,bins=200, histtype=\"step\", label=r'$cos\\theta_{l}^{(2)}$', density=True);\n",
+    "plt.hist(cos_theta_l_np_q,bins=200, alpha=0.5,label=r'$cos\\theta_{l}^{(3)}$',density=True);\n",
+    "plt.legend(fontsize='20');\n",
+    "fig = plt.gcf()\n",
+    "fig.set_size_inches(20,7)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if TASK=='SAMPLE':\n",
+    "    \n",
+    "    with open(filename,'wb') as handle:\n",
+    "        pickle.dump(MC_tuple, handle)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#bin_n=12\n",
+    "#sample_for_hist_reduced=sample_for_hist[0:20000,:]\n",
+    "#H, edges = np.histogramdd(sample_for_hist_reduced/n_events, bins=bin_n)\n",
+    "#\n",
+    "#x=np.array([H[i,:].sum() for i in range(bin_n)])\n",
+    "#plt.plot(x)\n",
+    "#\n",
+    "#y=np.array([H[:,i,:].sum()/n_events for i in range(bin_n)])\n",
+    "#plt.plot(y)\n",
+    "#\n",
+    "#z=np.array([H[:,:,i].sum()/n_events for i in range(bin_n)])\n",
+    "#plt.plot(z)\n",
+    "#\n",
+    "#plt.plot(np.array([H[:,:,:,i].sum() for i in range(bin_n)]))\n",
+    "#plt.plot(np.array([H[:,:,:,:,i].sum() for i in range(bin_n)]))\n",
+    "##plt.plot(np.array([H[:,:,:,:,:,i].sum() for i in range(bin_n)]))\n",
+    "#\n",
+    "#"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/utils/BtoKll_utils.py b/utils/BtoKll_utils.py
new file mode 100644
index 0000000..d7e25ae
--- /dev/null
+++ b/utils/BtoKll_utils.py
@@ -0,0 +1,51 @@
+
+import numpy as np
+from math import pi
+from utils.kin_utils import *
+import tensorflow as tf
+
+import zfit
+ztf = zfit.ztf
+
+
+
+def a(q2, m, m1, m2):
+    
+    lambd = lambda_function(m1, m2, ztf.sqrt(q2))
+    beta= dphi2(ztf.sqrt(q2), m, m)
+
+    step1=q2*(1+ztf.square(beta)) + lambd/2 + 2*m*(ztf.square(m1)-ztf.square(m2)+q2)+4*ztf.square(m)*ztf.square(m1)
+    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1
+    
+    return step1
+
+def b(q2, m, m1, m2):
+
+    lambd = lambda_function(m1, m2, ztf.sqrt(q2))
+    beta= dphi2(ztf.sqrt(q2), m, m)
+    
+    step1=2*(q2*(1+ztf.square(beta)) + m*(ztf.sqrt(lambd)*beta+(ztf.square(m1)-ztf.square(m2)+q2)))
+    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1
+    
+    return step1
+
+def c(q2, m, m1, m2):
+    
+    lambd = lambda_function(m1, m2, ztf.sqrt(q2))
+    beta= dphi2(ztf.sqrt(q2), m, m)
+
+    step1= q2*(1+ztf.square(beta)) - lambd/2 + 2*m*ztf.sqrt(lambd)*beta
+    #step2 = beta_l(q2, m)*ztf.sqrt(lambda_phase(m1, m2, q2))*step1
+    
+    return step1
+
+
+def matrix_elt(q2, m, m1, m2, cos_theta_l):
+    
+    out = a(q2, m, m1, m2)+b(q2, m, m1, m2)*cos_theta_l+c(q2, m, m1, m2)*ztf.square(cos_theta_l)
+    #out =a(q2, m, m1, m2)+c(q2, m, m1, m2)*ztf.square(cos_theta_l)
+    
+    return out               
+                      
+
+    
\ No newline at end of file
diff --git a/utils/BtoKllgamma_fullydiff_utils.py b/utils/BtoKllgamma_fullydiff_utils.py
new file mode 100644
index 0000000..7b0c342
--- /dev/null
+++ b/utils/BtoKllgamma_fullydiff_utils.py
@@ -0,0 +1,216 @@
+
+import numpy as np
+from math import pi
+from utils.kin_utils_edit import *
+
+import zfit
+ztf = zfit.ztf
+
+def momenta_map(q2, cos_theta_l, #phi_l, 
+                cos_theta_gamma, phi_gamma, 
+                #cos_theta_Kst, phi_Kst, 
+                mB, mBbar2, mKst, m_l, mgamma, mode=None,):
+    
+
+    if mode =='numpy':
+        cos_ = np.cos
+        sin_ = np.sin
+        sqrt_ = np.sqrt
+        square_ = np.square
+        dphi2_ = dphi2_np
+        zero_= np.zeros_like(q2)
+        one_= np.ones_like(q2)
+        pi_ = pi*np.ones_like(q2)
+        conc_ = np.concatenate
+        lorentz_boost_ = lorentz_boost_np
+        n_events_ = q2.shape[0]
+        lambda_f = lambda_function_np
+
+
+    if mode =='tf':
+
+        cos_ = tf.cos
+        sin_ = tf.sin
+        sqrt_ = ztf.sqrt
+        square_ = ztf.square
+        dphi2_ = dphi2_tf
+        zero_ = tf.zeros_like(q2, dtype=tf.float64)
+        one_ = tf.ones_like(q2, dtype=tf.float64)
+        pi_ = pi*tf.ones_like(q2, dtype=tf.float64)
+        conc_ = tf.stack
+        lorentz_boost_ = lorentz_boost
+        lambda_f = lambda_function
+
+    """
+    Decay angles
+    
+    """
+
+    
+    sin_theta_l=sqrt_(1-square_(cos_theta_l))
+
+    #phi_l=draw_random_phi(q2, mode)
+
+    cos_phi_l = draw_random_ones_minusones(q2, mode)#one_
+    sin_phi_l = zero_#1.-cos_phi_l#zero_
+
+    sin_theta_gamma=sqrt_(1-square_(cos_theta_gamma))
+
+    cos_phi_gamma = cos_(phi_gamma)
+    sin_phi_gamma = sin_(phi_gamma)
+
+
+    cos_theta_Kst = draw_random_ones_minusones(q2, mode)
+    sin_theta_Kst = zero_#1.-cos_theta_Kst
+    
+    #phi_Kst=draw_random_phi(q2, mode)
+    cos_phi_Kst = one_#draw_random_ones_minusones(q2, mode)
+    sin_phi_Kst = zero_#1.-cos_phi_Kst
+    
+    
+    
+    """
+    q-RF
+    
+    """
+    beta_l = dphi2_(sqrt_(q2), m_l, m_l)
+    
+    El = sqrt_(q2)/2
+    mod_l = El * beta_l
+
+    p1_1 = mod_l*sin_theta_l*cos_phi_l
+    p1_2 = mod_l*sin_theta_l*sin_phi_l
+    p1_3 = mod_l*cos_theta_l
+    p1_0 = El
+    #
+    
+    p1 = conc_([               p1_0,
+                               p1_1,
+                               p1_2,
+                               p1_3,
+                               ], axis =1)
+    
+
+    p2 = conc_([                p1_0,
+                               -p1_1,
+                               -p1_2,
+                               -p1_3,
+                               ], axis =1)
+    
+    """
+    pBbar-RF
+    
+    """
+    lambda_bar = lambda_f(sqrt_(mBbar2),mKst,sqrt_(q2))
+
+    beta_K = sqrt_(lambda_bar)/(mBbar2-q2+mKst**2)
+    beta_q = -sqrt_(lambda_bar)/(mBbar2+q2-mKst**2)
+
+    gamma_q = 1/sqrt_(1-square_(beta_q))
+    
+    E_gamma = (mB**2-mBbar2-mgamma**2)/(2*sqrt_(mBbar2))
+    E_Kst = (mBbar2-q2+mKst**2)/(2*sqrt_(mBbar2))
+    E_q = (mBbar2+q2-mKst**2)/(2*sqrt_(mBbar2))
+    
+    modk_Bbar = sqrt_(-mgamma**2+E_gamma**2)
+    
+    pKst_Bbar_0 = E_Kst
+    pKst_Bbar_1 = E_Kst*beta_K*(sin_theta_Kst*cos_phi_Kst)
+    pKst_Bbar_2 = E_Kst*beta_K*(sin_theta_Kst*sin_phi_Kst)
+    pKst_Bbar_3 = E_Kst*beta_K*cos_theta_Kst
+    
+    q_Bbar_0 =  E_q
+    q_Bbar_1 =  E_q*beta_q*(sin_theta_Kst*cos_phi_Kst)
+    q_Bbar_2 =  E_q*beta_q*(sin_theta_Kst*sin_phi_Kst)
+    q_Bbar_3 =  E_q*beta_q*cos_theta_Kst
+    
+    k_Bbar_0 =  E_gamma
+    k_Bbar_1 =  modk_Bbar*sin_theta_gamma*cos_phi_gamma
+    k_Bbar_2 =  modk_Bbar*sin_theta_gamma*sin_phi_gamma
+    k_Bbar_3 =  modk_Bbar*cos_theta_gamma
+    
+    pB_Bbar_0 = sqrt_(mBbar2)+k_Bbar_0
+    pB_Bbar_1 = k_Bbar_1
+    pB_Bbar_2 = k_Bbar_2
+    pB_Bbar_3 = k_Bbar_3  
+
+    
+    pKst_Bbar = conc_([         pKst_Bbar_0,
+                                pKst_Bbar_1,
+                                pKst_Bbar_2,
+                                pKst_Bbar_3,
+
+                                ], axis =1)
+    
+    k_Bbar = conc_([         k_Bbar_0,
+                             k_Bbar_1,
+                             k_Bbar_2,
+                             k_Bbar_3,
+
+                             ], axis =1)
+    
+    q_Bbar = conc_([
+                            q_Bbar_0,
+                            q_Bbar_1,
+                            q_Bbar_2,
+                            q_Bbar_3,
+
+                            ], axis=1)
+    
+    pB_Bbar = conc_([
+
+                            pB_Bbar_0,
+                            pB_Bbar_1,
+                            pB_Bbar_2,
+                            pB_Bbar_3,
+                            
+                            ], axis=1)
+
+    
+    # p1_Bbar_0 = El*gamma_q*(1 + beta_l*beta_q*cos_theta_Kst*cos_theta_l + beta_l*beta_q*cos_(phi_Kst-phi_l)*sin_theta_Kst*sin_theta_l)
+    
+    # p1_Bbar_1 = El*(beta_l*cos_phi_l*sin_theta_l + beta_l*(-1 + gamma_q)*cos_phi_Kst**2*cos_phi_l*sin_theta_Kst**2*sin_theta_l + cos_phi_Kst*sin_theta_Kst*(beta_q*gamma_q + beta_l*(-1 + gamma_q)*(cos_theta_Kst*cos_theta_l + sin_theta_Kst*sin_theta_l*sin_phi_Kst*sin_phi_l)))
+    
+    # p1_Bbar_2 = El*(sin_theta_Kst*(beta_q*gamma_q + beta_l*(-1 + gamma_q)*(cos_theta_Kst*cos_theta_l + cos_(phi_Kst-phi_l)*sin_theta_Kst*sin_theta_l))*sin_phi_Kst + beta_l*sin_theta_l*sin_phi_l)
+    
+    # p1_Bbar_3 = (El/2)*(2*beta_q*gamma_q*cos_theta_Kst + beta_l*(1 + gamma_q + (-1 + gamma_q)*cos_(2*theta_Kst))*cos_theta_l + beta_l*(-1 + gamma_q)*cos_(phi_Kst-phi_l)*sin_(2*theta_Kst)*sin_theta_l)
+    
+    
+    # p2_Bbar_0 = -El*gamma_q*(-1 + beta_l*beta_q*cos_theta_Kst*cos_theta_l + beta_l*beta_q*cos_(phi_Kst-phi_l)*sin_theta_Kst*sin_theta_l)
+    
+    # p2_Bbar_1 = El*(-beta_l*cos_phi_l*sin_theta_l - beta_l*(-1 + gamma_q)*cos_phi_Kst**2*cos_phi_l*sin_theta_Kst**2*sin_theta_l + cos_phi_Kst*sin_theta_Kst*(beta_q*gamma_q - beta_l*(-1 + gamma_q)*(cos_theta_Kst*cos_theta_l + sin_theta_Kst*sin_theta_l*sin_phi_Kst*sin_phi_l)))
+    
+    # p2_Bbar_2 = El*(sin_theta_Kst*(beta_q*gamma_q - beta_l*(-1 + gamma_q)*(cos_theta_Kst*cos_theta_l + cos_(phi_Kst-phi_l)*sin_theta_Kst*sin_theta_l))*sin_phi_Kst - beta_l*sin_theta_l*sin_phi_l)
+    
+    # p2_Bbar_3 = (El/2)*(2*beta_q*gamma_q*cos_theta_Kst + 2*beta_l*(-1 - (-1 + gamma_q)*cos_theta_Kst**2)*cos_theta_l - beta_l*(-1 + gamma_q)*cos_(phi_Kst-phi_l)*sin_(2*theta_Kst)*sin_theta_l)
+    
+    # p1_Bbar = conc_([    
+    #                         p1_Bbar_0,
+    #                         p1_Bbar_1,
+    #                         p1_Bbar_2,
+    #                         p1_Bbar_3,
+
+        
+    #                         ],axis=1)
+    
+    # p2_Bbar = conc_([    
+    #                         p2_Bbar_0,
+    #                         p2_Bbar_1,
+    #                         p2_Bbar_2,
+    #                         p2_Bbar_3,
+
+        
+    #                         ],axis=1)
+    if mode =='numpy':
+
+        beta_Bbar = q_Bbar/q_Bbar_0[:,0:1]
+
+    if mode =='tf':
+
+        beta_Bbar = q_Bbar/tf.expand_dims(q_Bbar_0,axis=-1)
+
+    p1_Bbar = lorentz_boost_(p1, beta_Bbar)
+    p2_Bbar = lorentz_boost_(p2, beta_Bbar)    
+
+    
+    return  pB_Bbar, pKst_Bbar, k_Bbar, q_Bbar, p1_Bbar, p2_Bbar, p1, p2
diff --git a/utils/BtoKllgamma_utils.py b/utils/BtoKllgamma_utils.py
new file mode 100644
index 0000000..5ea6d8d
--- /dev/null
+++ b/utils/BtoKllgamma_utils.py
@@ -0,0 +1,179 @@
+
+import numpy as np
+from math import pi
+from utils.kin_utils_edit import *
+
+import zfit
+ztf = zfit.ztf
+
+def momenta_map(q2, cos_theta_l, 
+                mB, mBbar2, mKst, m_l, mgamma, mode=None):
+
+    if mode =='numpy':
+        cos_ = np.cos
+        sin_ = np.sin
+        sqrt_ = np.sqrt
+        square_ = np.square
+        dphi2_ = dphi2_np
+        zero_= np.zeros_like(q2)
+        one_= np.ones_like(q2)
+        pi_ = pi*np.ones_like(q2)
+        conc_ = np.concatenate
+        lorentz_boost_ = lorentz_boost_np
+        n_events_ = q2.shape[0]
+        lambda_f = lambda_function_np
+
+
+    if mode =='tf':
+
+        cos_ = tf.cos
+        sin_ = tf.sin
+        sqrt_ = ztf.sqrt
+        square_ = ztf.square
+        dphi2_ = dphi2_tf
+        zero_ = tf.zeros_like(q2, dtype=tf.float64)
+        one_ = tf.ones_like(q2, dtype=tf.float64)
+        pi_ = pi*tf.ones_like(q2, dtype=tf.float64)
+        conc_ = tf.stack
+        lorentz_boost_ = lorentz_boost
+        lambda_f = lambda_function
+    
+    """
+    Decay variables
+
+    """
+
+    sin_theta_l = sqrt_(1-square_(cos_theta_l))
+
+    """
+    Integrated out variables
+    
+    """
+
+    # phi_gamma = draw_random_angle(q2,mode)
+    
+    # cos_phi_gamma = cos_(phi_gamma)
+    # sin_phi_gamma = sin_(phi_gamma)
+    
+    
+    
+    # cos_theta_gamma = draw_random_costheta(q2, mode)
+    # sin_theta_gamma = sqrt_(1-square_(cos_theta_gamma))
+    
+    """
+    
+    Mute variables
+
+    """
+    
+    
+    phi_l = draw_random_angle(q2,mode)
+    phi_Kst = draw_random_angle(q2,mode)
+    
+    
+    cos_phi_l = cos_(phi_l)
+    sin_phi_l = sin_(phi_l)
+    
+    cos_phi_Kst = cos_(phi_Kst)
+    sin_phi_Kst = sin_(phi_Kst)
+    
+    cos_theta_Kst = draw_random_costheta(q2, mode)
+    sin_theta_Kst = sqrt_(1-square_(cos_theta_Kst))
+    
+    """
+    q-RF
+    
+    """
+    beta = dphi2_(sqrt_(q2), m_l, m_l)
+    
+    p1_1 = 0.5*sqrt_(q2)*beta*sin_theta_l*cos_phi_l
+    p1_2 = 0.5*sqrt_(q2)*beta*sin_theta_l*sin_phi_l
+    p1_3 = 0.5*sqrt_(q2)*beta*cos_theta_l
+    p1_0 = 0.5*sqrt_(q2)
+    
+    p1 = conc_([               p1_0,
+                               p1_1,
+                               p1_2,
+                               p1_3], axis =1)
+    
+    p2 = conc_([                p1_0,
+                               -p1_1,
+                               -p1_2,
+                               -p1_3], axis =1)
+    
+    """
+    pBbar-RF
+    
+    """
+    mgamma_mass=mgamma
+    lambda_bar = lambda_f(sqrt_(mBbar2),mKst,sqrt_(q2))
+
+    beta_K = sqrt_(lambda_bar)/(sqrt_(mBbar2)**2-q2+mKst**2)
+    beta_q = -sqrt_(lambda_bar)/(sqrt_(mBbar2)**2+q2-mKst**2)
+    
+    # E_gamma = (mB**2-sqrt_(mBbar2)**2-mgamma**2)/(2*sqrt_(mBbar2))
+    E_Kst = (sqrt_(mBbar2)**2-q2+mKst**2)/(2*sqrt_(mBbar2))
+    E_q = (sqrt_(mBbar2)**2+q2-mKst**2)/(2*sqrt_(mBbar2))
+    
+    # modk_Bbar = sqrt_(-mgamma_mass**2+E_gamma**2)
+    
+    pKst_Bbar_0 = E_Kst
+    pKst_Bbar_1 = E_Kst*beta_K*(sin_theta_Kst*cos_phi_Kst)
+    pKst_Bbar_2 = E_Kst*beta_K*(sin_theta_Kst*sin_phi_Kst)
+    pKst_Bbar_3 = E_Kst*beta_K*cos_theta_Kst
+    
+    q_Bbar_0 =  E_q
+    q_Bbar_1 =  E_q*beta_q*(sin_theta_Kst*cos_phi_Kst)
+    q_Bbar_2 =  E_q*beta_q*(sin_theta_Kst*sin_phi_Kst)
+    q_Bbar_3 =  E_q*beta_q*cos_theta_Kst
+    
+    # k_Bbar_0 =  E_gamma
+    # k_Bbar_1 =  modk_Bbar*sin_theta_gamma*cos_phi_gamma
+    # k_Bbar_2 =  modk_Bbar*sin_theta_gamma*sin_phi_gamma
+    # k_Bbar_3 =  modk_Bbar*cos_theta_gamma
+    
+    # pB_Bbar_0 = sqrt_(mBbar2)+k_Bbar_0
+    # pB_Bbar_1 = k_Bbar_1
+    # pB_Bbar_2 = k_Bbar_2
+    # pB_Bbar_3 = k_Bbar_3   
+    
+    pKst_Bbar = conc_([         
+                                pKst_Bbar_0,
+                                pKst_Bbar_1,
+                                pKst_Bbar_2,
+                                pKst_Bbar_3], axis =1)
+    
+    # k_Bbar = conc_([k_Bbar_1,
+    #                          k_Bbar_2,
+    #                          k_Bbar_3,
+    #                          k_Bbar_0], axis =1)
+    
+    q_Bbar = conc_([
+                            q_Bbar_0,
+                            q_Bbar_1,
+                            q_Bbar_2,
+                            q_Bbar_3
+                            ], axis=1)
+    
+    # pB_Bbar = conc_([
+    #                         pB_Bbar_1,
+    #                         pB_Bbar_2,
+    #                         pB_Bbar_3,
+    #                         pB_Bbar_0
+    #                         ], axis=1)
+
+    
+    if mode =='numpy':
+
+        beta_Bbar = q_Bbar/q_Bbar_0[:,0:1]
+
+    if mode =='tf':
+
+        beta_Bbar = q_Bbar/tf.expand_dims(q_Bbar_0,axis=-1)
+    
+    p1_Bbar = lorentz_boost_np(p1, beta_Bbar)
+    p2_Bbar = lorentz_boost_np(p2, beta_Bbar)    
+    
+    
+    return  pKst_Bbar, q_Bbar, p1_Bbar, p2_Bbar, p1, p2#pB_Bbar, 
+
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/utils/__init__.py
diff --git a/utils/kin_utils.py b/utils/kin_utils.py
new file mode 100644
index 0000000..d92257f
--- /dev/null
+++ b/utils/kin_utils.py
@@ -0,0 +1,201 @@
+import numpy as np
+from math import pi
+import tensorflow as tf
+
+import zfit
+ztf = zfit.ztf
+
+
+
+def metric_tensor_np():
+    """Metric tensor for Lorentz space (constant)."""
+    return np.array([1.,-1.,-1.,-1.])
+
+
+def metric_tensor():
+    """Metric tensor for Lorentz space (constant)."""
+    return tf.constant([1., -1., -1., -1.], dtype=tf.float64)
+
+
+def scalar_product_3(v1, v2):
+    """Calculate scalar product of two 3-vectors.
+    Arguments:
+        vec1: First vector.
+        vec2: Second vector.
+    """
+    return tf.reduce_sum(v1 * v2, axis=1)    
+
+def scalar_product_4(v1, v2):
+    """Calculate mass scalar for Lorentz 4-momentum.
+    Arguments:
+        vector: Input Lorentz momentum vector.
+    """
+    return tf.reduce_sum(tf.multiply(tf.multiply(v1,v2),metric_tensor()),
+                                 axis=-1, keepdims=True)
+
+def scalar_product_3_np(v1,v2):    
+
+    
+    output = (v1*v2)[:,1:4].sum(axis=1, keepdims=True)
+    
+    return output
+
+
+def scalar_product_4_np(v1,v2):
+    
+    
+    output = (v1*v2*metric_tensor_np()).sum(axis=1 ,keepdims=True)
+    return output
+
+def get_costheta_l(p1, p2):  
+    
+    num = scalar_product_3(p1, p2)
+
+    den1= ztf.sqrt(scalar_product_3(p1, p1))
+    den2= ztf.sqrt(scalar_product_3(p2, p2))
+    
+    costheta_l = num/(den1*den2)
+    
+    return costheta_l
+
+def get_costheta_l_np(p1, p2):  
+    
+    num = scalar_product_3_np(p1, p2)
+
+    den1= np.sqrt(scalar_product_3_np(p1, p1))
+    den2= np.sqrt(scalar_product_3_np(p2, p2))
+    
+    costheta_l = num/(den1*den2)
+    
+    return costheta_l
+
+def beta_l(q2, m):
+    beta_l = ztf.sqrt(1-4*(ztf.square(m)/q2))
+    return beta_l
+
+def beta_l_np(q2, m):
+    beta_l = np.sqrt(1-4*(np.square(m)/q2))
+    return beta_l
+
+def lambda_function(m, c1, c2):
+    
+    #lambd = ztf.square(ztf.square(m)- ztf.square(c1)) -2*ztf.square(c2)*(ztf.square(m) + ztf.square(c1)) +ztf.square(ztf.square(c2))
+    lambd = (ztf.square(m) - ztf.square(c1 + c2))*(ztf.square(m) - ztf.square(c1 - c2))
+    return lambd
+
+def lambda_function_np(m, c1, c2):
+    
+    #lambd = np.square(np.square(m)- np.square(c1)) -2*np.square(c2)*(np.square(m) + np.square(c1)) +np.square(np.square(c2))
+    lambd = (np.square(m) - np.square(c1 + c2))*(np.square(m) - np.square(c1 - c2))
+
+    return lambd    
+
+def dphi2_tf(m, c1, c2):
+
+    lambd = lambda_function(m, c1, c2)
+
+    out = ztf.sqrt(lambd)/(ztf.square(m))
+
+    return out
+
+def dphi2_np(m, c1, c2):
+
+    lambd = lambda_function_np(m, c1, c2)
+
+    out = np.sqrt(lambd)/(np.square(m))
+
+    return out
+
+def spatial_component(vector):
+
+	return tf.gather(vector, indices=[1, 2, 3], axis=-1)
+
+def time_component(vector):
+
+	return tf.gather(vector, indices=[0], axis=-1)
+
+def lorentz_vector(space, time):
+    """Make a Lorentz vector from spatial and time components.
+    Arguments:
+        space: 3-vector of spatial components.
+        time: Time component.
+    """
+    return tf.concat([space, time], axis=-1)
+
+def lorentz_boost(fvector_to_boost, boost_vector):
+    
+   # boost_vector_time_component= time_component(boost_vector)
+    #boost_vector_spatial = 
+    
+    beta = spatial_component(boost_vector)
+    beta2 = tf.expand_dims(scalar_product_3(beta,beta), axis=-1)
+    
+    gamma = 1./ztf.sqrt(1.-beta2)
+    gamma_ = (gamma-1.)/beta2
+    
+    ve = time_component(fvector_to_boost)
+    vp = spatial_component(fvector_to_boost)
+    
+    ve2 = gamma*(ve + tf.expand_dims(scalar_product_3(vp,beta), axis=-1))
+    vp2 = vp + (gamma*ve + gamma_*tf.expand_dims(scalar_product_3(vp, beta), axis=-1))*beta
+
+    boosted_fvector=lorentz_vector(ve2,vp2)
+
+    return boosted_fvector
+
+
+def lorentz_boost_np(fvector_to_boost, boost_vector):
+    
+    beta = boost_vector
+    beta2 = scalar_product_3_np(beta,beta)
+    
+    gamma = 1./np.sqrt(1.-beta2)
+    gamma_ = (gamma-1.)/beta2
+    
+    ve = fvector_to_boost[:,0].reshape(-1,1)
+    vp = fvector_to_boost
+
+    ve2 = gamma*(ve + scalar_product_3_np(fvector_to_boost,beta))
+    vp2 = vp + (gamma*ve + gamma_*scalar_product_3_np(fvector_to_boost, beta))*beta
+
+    boosted_fvector = np.concatenate([ve2,vp2[:,1:4]],axis=1)
+    return boosted_fvector
+
+
+
+def draw_random_angle(q2, mode):
+
+    if mode=='numpy':
+        random_phi_ = np.random.uniform(size=(q2.shape[0],1), low=-pi, high=pi, )
+
+    if mode=='tf':
+
+        random_phi_ = tf.random.uniform(shape=tf.shape(q2), minval=-pi, maxval=pi, dtype=tf.float64)
+
+    return random_phi_
+
+def draw_random_costheta(q2, mode):
+
+    if mode=='numpy':
+        random_cosine_ = np.random.uniform(size=(q2.shape[0],1), low=-1.0, high=1.0, )
+    if mode=='tf':
+        random_cosine_ = tf.random.uniform(shape=tf.shape(q2), minval=-1., maxval=1.0, dtype=tf.float64)
+
+
+    return random_cosine_
+
+def draw_random_ones_minusones(q2, mode):
+    
+    
+    if mode=='numpy':
+        n_events=q2.shape[0]
+        mask = np.random.uniform(size=(n_events,1), low=0, high=1. )>0.5
+        random_one_=np.where(mask,1.,-1.)
+
+    if mode=='tf':
+        mask = tf.random.uniform(shape=tf.shape(q2), minval=0., maxval=1.0, dtype=tf.float64)
+        random_one_ = tf.where(mask>0.5,tf.ones_like(q2),-tf.ones_like(q2))
+
+    return random_one_
+
+    
\ No newline at end of file
diff --git a/utils/zfit_env.yml b/utils/zfit_env.yml
new file mode 100644
index 0000000..ac148e0
--- /dev/null
+++ b/utils/zfit_env.yml
@@ -0,0 +1,132 @@
+name: zfit_env
+channels:
+  - NLeSC
+  - https://conda.anaconda.org/NLeSC
+  - defaults
+dependencies:
+  - _tflow_select=2.3.0=mkl
+  - absl-py=0.7.1=py36_0
+  - appnope=0.1.0=py36hf537a9a_0
+  - astor=0.7.1=py36_0
+  - attrs=19.1.0=py36_1
+  - backcall=0.1.0=py36_0
+  - blas=1.0=mkl
+  - bleach=3.1.0=py36_0
+  - c-ares=1.15.0=h1de35cc_1
+  - ca-certificates=2019.5.15=0
+  - certifi=2019.3.9=py36_0
+  - cycler=0.10.0=py36hfc81398_0
+  - dbus=1.13.2=h5243cc1_0
+  - decorator=4.4.0=py36_1
+  - defusedxml=0.6.0=py_0
+  - entrypoints=0.3=py36_0
+  - expat=2.2.6=h0a44026_0
+  - freetype=2.9.1=hb4e5f40_0
+  - gast=0.2.2=py36_0
+  - gettext=0.19.8.1=h15daf44_3
+  - glib=2.53.6=h33f6a65_2
+  - grpcio=1.16.1=py36h044775b_1
+  - h5py=2.9.0=py36h3134771_0
+  - hdf5=1.10.4=hfa1e0ec_0
+  - icu=58.2=h4b95b61_1
+  - iminuit=1.3.3=py36h6440ff4_0
+  - intel-openmp=2019.4=233
+  - ipykernel=5.1.1=py36h39e3cac_0
+  - ipython=7.5.0=py36h39e3cac_0
+  - ipython_genutils=0.2.0=py36h241746c_0
+  - ipywidgets=7.4.2=py36_0
+  - jedi=0.13.3=py36_0
+  - jinja2=2.10.1=py36_0
+  - jpeg=9b=he5867d9_2
+  - jsonschema=3.0.1=py36_0
+  - jupyter=1.0.0=py36_7
+  - jupyter_client=5.2.4=py36_0
+  - jupyter_console=6.0.0=py36_0
+  - jupyter_core=4.4.0=py36_0
+  - keras-applications=1.0.8=py_0
+  - keras-preprocessing=1.1.0=py_1
+  - kiwisolver=1.1.0=py36h0a44026_0
+  - libcxx=4.0.1=hcfea43d_1
+  - libcxxabi=4.0.1=hcfea43d_1
+  - libedit=3.1.20181209=hb402a30_0
+  - libffi=3.2.1=h475c297_4
+  - libgfortran=3.0.1=h93005f0_2
+  - libiconv=1.15=hdd342a3_7
+  - libpng=1.6.37=ha441bb4_0
+  - libprotobuf=3.8.0=hd9629dc_0
+  - libsodium=1.0.16=h3efe00b_0
+  - markdown=3.1.1=py36_0
+  - markupsafe=1.1.1=py36h1de35cc_0
+  - matplotlib=3.1.0=py36h54f8f79_0
+  - mistune=0.8.4=py36h1de35cc_0
+  - mkl=2019.4=233
+  - mkl_fft=1.0.12=py36h5e564d8_0
+  - mkl_random=1.0.2=py36h27c97d8_0
+  - mock=3.0.5=py36_0
+  - nbconvert=5.5.0=py_0
+  - nbformat=4.4.0=py36h827af21_0
+  - ncurses=6.1=h0a44026_1
+  - notebook=5.7.8=py36_0
+  - numpy=1.16.4=py36hacdab7b_0
+  - numpy-base=1.16.4=py36h6575580_0
+  - openssl=1.1.1c=h1de35cc_1
+  - pandoc=2.2.3.2=0
+  - pandocfilters=1.4.2=py36_1
+  - parso=0.4.0=py_0
+  - pcre=8.35=7
+  - pexpect=4.7.0=py36_0
+  - pickleshare=0.7.5=py36_0
+  - pip=19.1.1=py36_0
+  - prometheus_client=0.6.0=py36_0
+  - prompt_toolkit=2.0.9=py36_0
+  - protobuf=3.8.0=py36h0a44026_0
+  - ptyprocess=0.6.0=py36_0
+  - pygments=2.4.2=py_0
+  - pyparsing=2.4.0=py_0
+  - pyqt=5.9.2=py36h655552a_2
+  - pyrsistent=0.14.11=py36h1de35cc_0
+  - python=3.6.8=haf84260_0
+  - python-dateutil=2.8.0=py36_0
+  - pytz=2019.1=py_0
+  - pyzmq=18.0.0=py36h0a44026_0
+  - qt=5.9.7=h468cd18_1
+  - qtconsole=4.5.1=py_0
+  - readline=7.0=h1de35cc_5
+  - scipy=1.2.1=py36h1410ff5_0
+  - send2trash=1.5.0=py36_0
+  - setuptools=41.0.1=py36_0
+  - sip=4.19.8=py36h0a44026_0
+  - six=1.12.0=py36_0
+  - sqlite=3.28.0=ha441bb4_0
+  - tensorboard=1.13.1=py36haf313ee_0
+  - tensorflow=1.13.1=mkl_py36haf07a9b_0
+  - tensorflow-base=1.13.1=mkl_py36hc36dc97_0
+  - tensorflow-estimator=1.13.0=py_0
+  - termcolor=1.1.0=py36_1
+  - terminado=0.8.2=py36_0
+  - testpath=0.4.2=py36_0
+  - tk=8.6.8=ha441bb4_0
+  - tornado=6.0.2=py36h1de35cc_0
+  - traitlets=4.3.2=py36h65bd3ce_0
+  - wcwidth=0.1.7=py36h8c6ec74_0
+  - webencodings=0.5.1=py36_1
+  - werkzeug=0.15.4=py_0
+  - wheel=0.33.4=py36_0
+  - widgetsnbextension=3.4.2=py36_0
+  - xz=5.2.4=h1de35cc_4
+  - zeromq=4.3.1=h0a44026_3
+  - zlib=1.2.11=h1de35cc_3
+  - pip:
+    - awkward==0.10.3
+    - cachetools==3.1.1
+    - colorlog==4.0.2
+    - pandas==0.24.2
+    - phasespace==1.0.2
+    - tensorflow-probability==0.6.0
+    - texttable==1.6.1
+    - typing==3.6.6
+    - uproot==3.6.5
+    - uproot-methods==0.6.1
+    - zfit==0.3.3
+prefix: /Users/davide/miniconda3/envs/zfit_env
+
diff --git a/zfit_env.yml b/zfit_env.yml
new file mode 100644
index 0000000..5658d34
--- /dev/null
+++ b/zfit_env.yml
@@ -0,0 +1,137 @@
+name: zfit_env
+channels:
+  - https://conda.anaconda.org/NLeSC
+  - conda-forge
+  - defaults
+dependencies:
+  - _tflow_select=2.1.0=gpu
+  - absl-py=0.7.1=py36_0
+  - astor=0.7.1=py_0
+  - attrs=19.1.0=py_0
+  - backcall=0.1.0=py_0
+  - bleach=3.1.0=py_0
+  - c-ares=1.15.0=h14c3975_1001
+  - ca-certificates=2019.6.16=hecc5488_0
+  - certifi=2019.6.16=py36_0
+  - cycler=0.10.0=py_1
+  - dbus=1.13.6=he372182_0
+  - decorator=4.4.0=py_0
+  - defusedxml=0.5.0=py_1
+  - entrypoints=0.3=py36_1000
+  - expat=2.2.5=he1b5a44_1003
+  - fontconfig=2.13.1=he4413a7_1000
+  - freetype=2.10.0=he983fc9_0
+  - gast=0.2.2=py_0
+  - gettext=0.19.8.1=hc5be6a0_1002
+  - glib=2.58.3=h6f030ca_1001
+  - grpcio=1.16.1=py36hf8bcb03_1
+  - gst-plugins-base=1.14.5=h0935bb2_0
+  - gstreamer=1.14.5=h36ae1b5_0
+  - h5py=2.9.0=nompi_py36hf008753_1102
+  - hdf5=1.10.4=nompi_h3c11f04_1106
+  - icu=58.2=hf484d3e_1000
+  - iminuit=1.3.7=py36hb3f55d8_0
+  - ipykernel=5.1.1=py36h24bf2e0_0
+  - ipython=7.5.0=py36h24bf2e0_0
+  - ipython_genutils=0.2.0=py_1
+  - ipywidgets=7.4.2=py_0
+  - jedi=0.14.0=py36_0
+  - jinja2=2.10.1=py_0
+  - jpeg=9c=h14c3975_1001
+  - jsonschema=3.0.1=py36_0
+  - jupyter=1.0.0=py_2
+  - jupyter_client=5.2.4=py_3
+  - jupyter_console=6.0.0=py_0
+  - jupyter_core=4.4.0=py_0
+  - keras-applications=1.0.7=py_1
+  - keras-preprocessing=1.0.9=py_1
+  - kiwisolver=1.1.0=py36hc9558a2_0
+  - libblas=3.8.0=7_openblas
+  - libcblas=3.8.0=7_openblas
+  - libffi=3.2.1=he1b5a44_1006
+  - libgcc-ng=9.1.0=hdf63c60_0
+  - libgfortran-ng=7.3.0=hdf63c60_0
+  - libiconv=1.15=h516909a_1005
+  - liblapack=3.8.0=7_openblas
+  - libpng=1.6.37=hed695b0_0
+  - libprotobuf=3.8.0=h8b12597_0
+  - libsodium=1.0.16=h14c3975_1001
+  - libstdcxx-ng=9.1.0=hdf63c60_0
+  - libuuid=2.32.1=h14c3975_1000
+  - libxcb=1.13=h14c3975_1002
+  - libxml2=2.9.9=h13577e0_0
+  - markdown=2.6.11=py_0
+  - markupsafe=1.1.1=py36h14c3975_0
+  - matplotlib=3.1.0=py36_1
+  - matplotlib-base=3.1.0=py36hfd891ef_1
+  - mistune=0.8.4=py36h14c3975_1000
+  - mock=3.0.5=py36_0
+  - nbconvert=5.5.0=py_0
+  - nbformat=4.4.0=py_1
+  - ncurses=6.1=hf484d3e_1002
+  - notebook=5.7.8=py36_1
+  - numpy=1.16.4=py36h95a1406_0
+  - openblas=0.3.5=h9ac9557_1001
+  - openssl=1.1.1b=h14c3975_1
+  - pandoc=2.7.3=0
+  - pandocfilters=1.4.2=py_1
+  - parso=0.5.0=py_0
+  - pcre=8.41=hf484d3e_1003
+  - pexpect=4.7.0=py36_0
+  - pickleshare=0.7.5=py36_1000
+  - pip=19.1.1=py36_0
+  - prometheus_client=0.7.1=py_0
+  - prompt_toolkit=2.0.9=py_0
+  - protobuf=3.8.0=py36he1b5a44_0
+  - pthread-stubs=0.4=h14c3975_1001
+  - ptyprocess=0.6.0=py_1001
+  - pygments=2.4.2=py_0
+  - pyparsing=2.4.0=py_0
+  - pyqt=5.9.2=py36hcca6a23_0
+  - pyrsistent=0.15.2=py36h516909a_0
+  - python=3.6.7=h381d211_1004
+  - python-dateutil=2.8.0=py_0
+  - pyzmq=18.0.1=py36hc4ba49a_1
+  - qt=5.9.7=h52cfd70_2
+  - qtconsole=4.5.1=py_0
+  - readline=7.0=hf8c457e_1001
+  - scipy=1.3.0=py36h921218d_0
+  - send2trash=1.5.0=py_0
+  - setuptools=41.0.1=py36_0
+  - sip=4.19.8=py36hf484d3e_1000
+  - six=1.12.0=py36_1000
+  - sqlite=3.28.0=h8b20d00_0
+  - tensorboard=1.13.1=py36_0
+  - tensorflow=1.13.1=py36_0
+  - tensorflow-estimator=1.13.0=py_0
+  - tensorflow-gpu=1.13.1=h0d30ee6_0
+  - tensorflow-probability=0.6.0=py_1
+  - termcolor=1.1.0=py_2
+  - terminado=0.8.2=py36_0
+  - testpath=0.4.2=py_1001
+  - tk=8.6.9=hed695b0_1002
+  - tornado=6.0.2=py36h516909a_0
+  - traitlets=4.3.2=py36_1000
+  - wcwidth=0.1.7=py_1
+  - webencodings=0.5.1=py_1
+  - werkzeug=0.15.4=py_0
+  - wheel=0.33.4=py36_0
+  - widgetsnbextension=3.4.2=py36_1000
+  - xorg-libxau=1.0.9=h14c3975_0
+  - xorg-libxdmcp=1.1.3=h516909a_0
+  - xz=5.2.4=h14c3975_1001
+  - zeromq=4.3.1=hf484d3e_1000
+  - zlib=1.2.11=h14c3975_1004
+  - pip:
+    - awkward==0.11.1
+    - cachetools==3.1.1
+    - colorlog==4.0.2
+    - pandas==0.24.2
+    - pytz==2019.1
+    - texttable==1.6.1
+    - typing==3.7.4
+    - uproot==3.7.0
+    - uproot-methods==0.7.0
+    - zfit==0.3.3
+prefix: /disk/lhcb_data/davide/miniconda3/envs/zfit_env
+