MC2Dup.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-17T03:48:59.924067Z",
     "start_time": "2020-11-17T03:48:57.190005Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import uproot\n",
    "import aiohttp\n",
    "from matplotlib import pyplot as plt\n",
    "import awkward as ak\n",
    "from keras.layers import Dense, Input\n",
    "from keras.models import Model\n",
    "\n",
    "import omnifold as of\n",
    "import os\n",
    "import tensorflow as tf\n",
    "import coffea\n",
    "from coffea.nanoevents import NanoEventsFactory, NanoAODSchema"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stuff = np.random.normal( loc=[1.1, 1.8], scale=[0.8,0.5], size=(100000, 2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['/device:CPU:0']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "\n",
    "def get_available_devices():\n",
    "    local_device_protos = device_lib.list_local_devices()\n",
    "    return [x.name for x in local_device_protos]\n",
    "\n",
    "print(get_available_devices())\n",
    "print(tf.config.list_physical_devices('GPU'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "physical_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "print(physical_devices)\n",
    "if physical_devices:\n",
    "  tf.config.experimental.set_memory_growth(physical_devices[0], True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100000, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([[0.0000e+00, 0.0000e+00, 5.0000e+00, 1.5000e+01, 2.4000e+01,\n",
       "         1.4000e+01, 8.0000e+00, 3.0000e+00, 0.0000e+00, 0.0000e+00],\n",
       "        [0.0000e+00, 5.0000e+00, 5.3000e+01, 2.3600e+02, 4.0600e+02,\n",
       "         3.5300e+02, 1.3000e+02, 1.9000e+01, 1.0000e+00, 0.0000e+00],\n",
       "        [1.0000e+00, 4.9000e+01, 4.4900e+02, 1.5510e+03, 2.8550e+03,\n",
       "         2.3910e+03, 8.8200e+02, 1.5600e+02, 1.0000e+01, 0.0000e+00],\n",
       "        [1.1000e+01, 1.5200e+02, 1.2650e+03, 4.9040e+03, 8.9670e+03,\n",
       "         7.2820e+03, 2.8860e+03, 4.9200e+02, 3.6000e+01, 0.0000e+00],\n",
       "        [1.3000e+01, 2.0600e+02, 1.6490e+03, 6.7560e+03, 1.2172e+04,\n",
       "         1.0080e+04, 3.8020e+03, 6.3400e+02, 4.4000e+01, 3.0000e+00],\n",
       "        [1.0000e+01, 1.3500e+02, 1.0380e+03, 4.1120e+03, 7.4940e+03,\n",
       "         6.2250e+03, 2.4230e+03, 4.3000e+02, 3.8000e+01, 2.0000e+00],\n",
       "        [2.0000e+00, 2.5000e+01, 2.9600e+02, 1.1780e+03, 2.1420e+03,\n",
       "         1.8320e+03, 6.8500e+02, 1.1900e+02, 1.1000e+01, 0.0000e+00],\n",
       "        [0.0000e+00, 1.0000e+00, 3.6000e+01, 1.6800e+02, 2.6700e+02,\n",
       "         2.1200e+02, 9.3000e+01, 1.1000e+01, 0.0000e+00, 0.0000e+00],\n",
       "        [0.0000e+00, 0.0000e+00, 3.0000e+00, 7.0000e+00, 1.4000e+01,\n",
       "         1.7000e+01, 2.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],\n",
       "        [0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,\n",
       "         1.0000e+00, 0.0000e+00, 1.0000e+00, 0.0000e+00, 0.0000e+00]]),\n",
       " array([-2.16272912, -1.4226602 , -0.68259129,  0.05747763,  0.79754655,\n",
       "         1.53761546,  2.27768438,  3.01775329,  3.75782221,  4.49789112,\n",
       "         5.23796004]),\n",
       " array([-0.36092547,  0.09296044,  0.54684636,  1.00073227,  1.45461819,\n",
       "         1.9085041 ,  2.36239002,  2.81627593,  3.27016185,  3.72404776,\n",
       "         4.17793368]),\n",
       " <matplotlib.collections.QuadMesh at 0x1b0a9818dd0>)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(stuff.shape)\n",
    "plt.hist2d( stuff[:,0], stuff[:,1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "print(gpus)\n",
    "#tf.config.experimental.set_virtual_device_configuration(\n",
    "#    gpus[1],[tf.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)]) #in MB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def synthroot(filename, data, data2):\n",
    "    with uproot.recreate(filename) as file:\n",
    "        file[\"testree\"] = {\"theta0\": data, \"theta_unknown_S\": data2}\n",
    "        file[\"twotree\"] = {\"theta0Z\": data, \"thetaUS\": data2}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-17T03:49:24.308730Z",
     "start_time": "2020-11-17T03:48:59.981078Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tk8\n",
      "[True, True, False, True, False, False, ... True, True, True, True, True, True]\n",
      "tes\n",
      "[[], [], [392, 363], [], ... 242], [6.18e+03, 6.18e+03], [2.86e+03, 2.42e+03]]\n",
      "tpt\n",
      "[False, False, True, False, True, True, True, ... True, True, True, True, True, True]\n",
      "[[392, 363], [189], [1.45e+03, ... [6.18e+03, 6.18e+03], [2.86e+03, 2.42e+03]]\n",
      "FatJet_pt\n",
      "GenJetAK8_mass\n",
      "FatJet_mass\n",
      "GenJetAK8_pt\n",
      "FatJet_phi\n",
      "GenJetAK8_phi\n",
      "FatJet_eta\n",
      "GenJetAK8_eta\n",
      "GenJetAK8_eta\n",
      "FatJet_eta\n",
      "GenJetAK8_phi\n",
      "FatJet_phi\n",
      "GenJetAK8_pt\n",
      "FatJet_mass\n",
      "GenJetAK8_mass\n",
      "FatJet_pt\n",
      "LOOP DONE\n",
      "[[392], [189], [1.45e+03], [778], ... [668], [2.34e+03], [6.18e+03], [2.86e+03]]\n"
     ]
    }
   ],
   "source": [
    "events = uproot.open(\"QCD_pt.root:Events\")\n",
    "#print(events.keys())\n",
    "\n",
    "qcd_mc = uproot.open('QCD_pt.root')\n",
    "uprootevents = qcd_mc['Events']\n",
    "#print(uprootevents.keys())\n",
    "#print(events.keys('FatJet*'))\n",
    "\n",
    "#fatjet_pt = uprootevents['FatJet_pt'].array()\n",
    "#print(ak.num(fatjet_pt))\n",
    "#Ev = events[ak.num(events['FatJet_pt'].array())>0]\n",
    "#print(Ev)\n",
    "\n",
    "\n",
    "\n",
    "fk8 = events['GenJetAK8_pt'].array() # array of all 0s in Genjet\n",
    "tk8 = ak.num(fk8) > 0\n",
    "print('tk8')\n",
    "print(tk8)\n",
    "#print(fpt[tpt])\n",
    "\n",
    "\n",
    "fpt = events['FatJet_pt'].array() # Fat jet with all genjet 0s removed \n",
    "tes = fpt[tk8]\n",
    "print('tes')\n",
    "print(tes)\n",
    "\n",
    "tpt = ak.num(tes) > 0  # Fat jet with both Fat 0s and Gen 0s removed\n",
    "print('tpt')\n",
    "print(tpt)\n",
    "print(tes[tpt])\n",
    "\n",
    "\n",
    "testquants = ['FatJet_pt','FatJet_mass','FatJet_phi', 'FatJet_eta','GenJetAK8_eta','GenJetAK8_phi','GenJetAK8_pt','GenJetAK8_mass']\n",
    "quantvals = []\n",
    "\n",
    "for quantity in range(len(testquants)):\n",
    "    print(testquants[quantity])\n",
    "    print(testquants[-(1+quantity)])\n",
    "    fk8 = events[testquants[-(1+quantity)]].array() # array of all 0s in secondary jet\n",
    "    tk8 = ak.num(fk8) > 0\n",
    "    #print('tk8')\n",
    "    #print(tk8)\n",
    "    #print(fpt[tpt])\n",
    "    \n",
    "    \n",
    "    fpt = events[testquants[quantity]].array() # output jet with all secondary jet 0s removed \n",
    "    tes = fpt[tk8]\n",
    "    #print('tes')\n",
    "    #print(tes)\n",
    "    \n",
    "    tpt = ak.num(tes) > 0  # primary jet with both its own 0s and secondary jet 0s removed\n",
    "    #print('tpt')\n",
    "    #print(tpt)\n",
    "    #print(tes[tpt][:,:1])\n",
    "    quantvals.append(tes[tpt][:,:1])\n",
    "    \n",
    "\n",
    "print(\"LOOP DONE\")\n",
    "#print(uprootevents.keys('FatJet*'))\n",
    "#### getting leading jet pt and mass as storing as numpy-like array\n",
    "jetr = tes[tpt][:,:1]\n",
    "\n",
    "jet_recopt = quantvals[0]\n",
    "jet_recomass = quantvals[1]\n",
    "jet_recophi = quantvals[2]\n",
    "jet_recoeta = quantvals[3]\n",
    "jet_geneta = quantvals[-4]\n",
    "jet_genphi = quantvals[-3]\n",
    "jet_genpt = quantvals[-2]\n",
    "jet_genmass = quantvals[-1]\n",
    "\n",
    "\n",
    "#jet_recopt = events['FatJet_pt'].array()[:,:1]\n",
    "#jet_recomass = uprootevents['FatJet_mass'].array()[:,:1]\n",
    "#jet_genpt = uprootevents['GenJetAK8_pt'].array()[:,:1]\n",
    "#jet_genmass = uprootevents['GenJetAK8_mass'].array()[:,:1]\n",
    "print(jet_recopt)\n",
    "#print(jetr)\n",
    "\n",
    "\n",
    "#Events = events[ak.num(events['FatJet_pt'].array()) > 0]\n",
    "#Events = events[ak.num(events.keys('FatJet*')) > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "amt = len(jet_genmass)//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150396\n"
     ]
    }
   ],
   "source": [
    "#jet_recopt = quantvals[0]\n",
    "#jet_recomass = quantvals[1]\n",
    "#jet_genpt = quantvals[]\n",
    "#jet_genmass = quantvals[3]\n",
    "\n",
    "amt = len(jet_genmass)//2\n",
    "print(amt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150396\n",
      "[[61.2, 379], [36.6, 187], [46.5, ... 1.48e+03], [76.8, 843], [276, 2.56e+03]]\n",
      "[[258, 2.08e+03], [138, 702], [53.7, ... 2.3e+03], [398, 5.96e+03], [148, 2.91e+03]]\n",
      "[[[61.2, 379], [59.6, 392]], [[36.6, ... 921]], [[276, 2.56e+03], [271, 2.63e+03]]]\n"
     ]
    }
   ],
   "source": [
    "# Pretend MC Fat\n",
    "# Pretend Data Gen\n",
    "# Pt, Mass are 2D\n",
    "# Stack both\n",
    "\n",
    "# Split in half to have testing\n",
    "#genjet are MC, True, FatJet be reco\n",
    "#genjet theta G, fatjet, theta S\n",
    "print(amt)\n",
    "theta0_G = np.column_stack((\n",
    "    jet_genmass[:amt],   # 1 dee\n",
    "    jet_genpt[:amt]    # 2 dee\n",
    "))\n",
    "\n",
    "theta0_S = np.column_stack((\n",
    "    jet_recomass[:amt],   # 1 dee\n",
    "    jet_recopt[:amt]    # 2 dee\n",
    "))\n",
    "\n",
    "\n",
    "# Natural\n",
    "theta_unknown_G = np.column_stack([\n",
    "    jet_genmass[amt:],   # 1 dee\n",
    "    jet_genpt[amt:]    # 2 dee\n",
    "])\n",
    "\n",
    "theta_unknown_S = np.column_stack([\n",
    "    jet_recomass[amt:],   # 1 dee\n",
    "    jet_recopt[amt:]    # 2 dee\n",
    "])\n",
    "\n",
    "theta0 = np.stack((theta0_G, theta0_S), axis=1)\n",
    "\n",
    "print(theta0_G)\n",
    "print(theta_unknown_G)\n",
    "print(theta0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"Shape theta0_G:\", theta0_G.shape)\n",
    "#print(\"Shape 0_S:\", theta0_S.shape)\n",
    "#print(\"Shape theta0:\", theta0t.shape)\n",
    "#print(\"Shape unknown s:\", theta_unknown_St.shape)\n",
    "#print(\"Shape theta0 Tree:\", events[\"theta0\"].array(library=\"np\").shape)\n",
    "#print(\"Shape unknown s Tree:\", events[\"theta_unknown_S\"].array(library=\"np\").shape)\n",
    "\n",
    "#theta0 = events[\"theta0\"].array(library=\"np\")\n",
    "#theta_unknown_S = events[\"theta_unknown_S\"].array(library=\"np\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.0000e+00, 7.0000e+00, 5.3390e+03, 1.2124e+04, 9.2000e+03,\n",
       "        7.3020e+03, 6.1350e+03, 5.2290e+03, 4.7240e+03, 4.1370e+03,\n",
       "        3.8220e+03, 3.4950e+03, 3.1990e+03, 3.1540e+03, 2.7660e+03,\n",
       "        2.6220e+03, 2.4570e+03, 2.4050e+03, 2.2540e+03, 2.1610e+03,\n",
       "        2.1110e+03, 1.9960e+03, 1.9260e+03, 1.9020e+03, 1.8450e+03,\n",
       "        1.6860e+03, 1.7000e+03, 1.6070e+03, 1.5930e+03, 1.5430e+03,\n",
       "        1.4630e+03, 1.4810e+03, 1.3870e+03, 1.3980e+03, 1.3390e+03,\n",
       "        1.3510e+03, 1.2780e+03, 1.3050e+03, 1.2390e+03, 1.2100e+03,\n",
       "        1.1860e+03, 1.2280e+03, 1.1070e+03, 1.1420e+03, 1.1300e+03,\n",
       "        1.0300e+03, 1.0120e+03, 9.7100e+02, 9.1300e+02, 9.3300e+02,\n",
       "        8.8600e+02, 8.8400e+02, 8.6000e+02, 8.1400e+02, 8.3300e+02,\n",
       "        7.5700e+02, 7.8400e+02, 7.4600e+02, 6.9600e+02, 7.3200e+02,\n",
       "        6.0800e+02, 6.1000e+02, 6.5300e+02, 5.9800e+02, 6.3500e+02,\n",
       "        5.5700e+02, 5.9300e+02, 5.5200e+02, 5.5700e+02, 5.3700e+02,\n",
       "        5.3800e+02, 5.1500e+02, 4.5200e+02, 4.8000e+02, 4.1300e+02,\n",
       "        4.4600e+02, 4.1300e+02, 4.5600e+02, 4.1800e+02, 4.3300e+02,\n",
       "        4.0100e+02, 3.9600e+02, 3.8900e+02, 3.7600e+02, 3.7700e+02,\n",
       "        3.6600e+02, 3.4500e+02, 3.6600e+02, 3.2900e+02, 3.6100e+02,\n",
       "        3.5600e+02, 3.4700e+02, 3.3400e+02, 3.1700e+02, 3.3600e+02,\n",
       "        2.7500e+02, 2.7300e+02, 2.9200e+02, 2.8500e+02]),\n",
       " array([   0.        ,   60.60606061,  121.21212121,  181.81818182,\n",
       "         242.42424242,  303.03030303,  363.63636364,  424.24242424,\n",
       "         484.84848485,  545.45454545,  606.06060606,  666.66666667,\n",
       "         727.27272727,  787.87878788,  848.48484848,  909.09090909,\n",
       "         969.6969697 , 1030.3030303 , 1090.90909091, 1151.51515152,\n",
       "        1212.12121212, 1272.72727273, 1333.33333333, 1393.93939394,\n",
       "        1454.54545455, 1515.15151515, 1575.75757576, 1636.36363636,\n",
       "        1696.96969697, 1757.57575758, 1818.18181818, 1878.78787879,\n",
       "        1939.39393939, 2000.        , 2060.60606061, 2121.21212121,\n",
       "        2181.81818182, 2242.42424242, 2303.03030303, 2363.63636364,\n",
       "        2424.24242424, 2484.84848485, 2545.45454545, 2606.06060606,\n",
       "        2666.66666667, 2727.27272727, 2787.87878788, 2848.48484848,\n",
       "        2909.09090909, 2969.6969697 , 3030.3030303 , 3090.90909091,\n",
       "        3151.51515152, 3212.12121212, 3272.72727273, 3333.33333333,\n",
       "        3393.93939394, 3454.54545455, 3515.15151515, 3575.75757576,\n",
       "        3636.36363636, 3696.96969697, 3757.57575758, 3818.18181818,\n",
       "        3878.78787879, 3939.39393939, 4000.        , 4060.60606061,\n",
       "        4121.21212121, 4181.81818182, 4242.42424242, 4303.03030303,\n",
       "        4363.63636364, 4424.24242424, 4484.84848485, 4545.45454545,\n",
       "        4606.06060606, 4666.66666667, 4727.27272727, 4787.87878788,\n",
       "        4848.48484848, 4909.09090909, 4969.6969697 , 5030.3030303 ,\n",
       "        5090.90909091, 5151.51515152, 5212.12121212, 5272.72727273,\n",
       "        5333.33333333, 5393.93939394, 5454.54545455, 5515.15151515,\n",
       "        5575.75757576, 5636.36363636, 5696.96969697, 5757.57575758,\n",
       "        5818.18181818, 5878.78787879, 5939.39393939, 6000.        ]),\n",
       " <BarContainer object of 99 artists>)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist( theta0_G[:,0], bins=np.linspace(0,6000, 100) )\n",
    "plt.hist( theta0_G[:,1], bins=np.linspace(0,6000, 100) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b0b2e55c50>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,_,_=plt.hist(theta0_G[:,0],bins=np.linspace(-3,1000,200),color='blue',alpha=0.5,label=\"MC, true\")\n",
    "_,_,_=plt.hist(theta0_S[:,0],bins=np.linspace(-3,1000,200),histtype=\"step\",color='black',ls=':',label=\"MC, reco\")\n",
    "_,_,_=plt.hist(theta_unknown_G[:,0],bins=np.linspace(-3,1000,200),color='orange',alpha=0.5,label=\"Data, true\")\n",
    "_,_,_=plt.hist(theta_unknown_S[:,0],bins=np.linspace(-3,1000,200),histtype=\"step\",color='black',label=\"Data, reco\")\n",
    "plt.xlabel(\"x1\")\n",
    "plt.ylabel(\"events\")\n",
    "plt.legend(frameon=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b0b5365c50>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,_,_=plt.hist(theta0_G[:,1],bins=np.linspace(-3,1000,200),color='blue',alpha=0.5,label=\"MC, true\")\n",
    "_,_,_=plt.hist(theta0_S[:,1],bins=np.linspace(-3,1000,200),histtype=\"step\",color='black',ls=':',label=\"MC, reco\")\n",
    "_,_,_=plt.hist(theta_unknown_G[:, 1],bins=np.linspace(-3,1000,200),color='orange',alpha=0.5,label=\"Data, true\")\n",
    "_,_,_=plt.hist(theta_unknown_S[:, 1],bins=np.linspace(-3,1000,200),histtype=\"step\",color='black',label=\"Data, reco\")\n",
    "plt.xlabel(\"x2\")\n",
    "plt.ylabel(\"events\")\n",
    "plt.legend(frameon=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b0b554c390>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,_,_=plt.hist(jet_geneta[:],bins=np.linspace(-3,3,200),color='blue',alpha=0.5,label=\"gen, eta\")\n",
    "_,_,_=plt.hist(jet_genphi[:],bins=np.linspace(-3,3,200),histtype=\"step\",color='black',ls=':',label=\"gen, phi\")\n",
    "_,_,_=plt.hist(jet_recoeta[:],bins=np.linspace(-3,3,200),color='orange',alpha=0.5,label=\"reco, eta\")\n",
    "_,_,_=plt.hist(jet_recophi[:],bins=np.linspace(-3,3,200),histtype=\"step\",color='green',ls=':',label=\"reco, phi\")\n",
    "#_,_,_=plt.hist(jet_genmass[:],bins=np.linspace(-3,1000,200),color='orange',alpha=0.5,label=\"Data, true\")\n",
    "#_,_,_=plt.hist(jet_genpt[:],bins=np.linspace(-3,1000,200),histtype=\"step\",color='black',label=\"Data, reco\")\n",
    "plt.xlabel(\"parts\")\n",
    "plt.ylabel(\"events\")\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # test 4d\n",
    "# np.random.seed(42)\n",
    "# a = np.random.randint(0, 5, 100)\n",
    "# b = np.random.randint(0, 5, 100)\n",
    "# c = np.random.rand(100)\n",
    "# d = np.random.rand(100)\n",
    "\n",
    "# fig, axs = plt.subplots(5, 5, sharex='col', sharey='row', figsize=(10, 10))\n",
    "\n",
    "# for i in range(5):\n",
    "#     for j in range(5):\n",
    "#         #filter\n",
    "#         mask = (a == i) & (b == j)\n",
    "#         current_c = c[mask]\n",
    "#         current_d = d[mask]\n",
    "\n",
    "#         #scatter in sub\n",
    "#         axs[i, j].scatter(current_c, current_d, s=10)\n",
    "\n",
    "#         #labels\n",
    "#         axs[i, j].set_xlabel('c')\n",
    "#         axs[i, j].set_ylabel('d')\n",
    "\n",
    "#         #title\n",
    "#         axs[i, j].set_title(f'a={i}, b={j}')\n",
    "\n",
    "# plt.tight_layout()\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "to_rectilinear argument must be iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[19], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#Data, true\u001b[39;00m\n\u001b[0;32m      2\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n\u001b[1;32m----> 3\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhist2d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtheta_unknown_S\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtheta_unknown_S\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mOranges\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malpha\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mData, true\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      4\u001b[0m plt\u001b[38;5;241m.\u001b[39mcolorbar()\n\u001b[0;32m      5\u001b[0m plt\u001b[38;5;241m.\u001b[39mxlabel(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\matplotlib\\pyplot.py:2669\u001b[0m, in \u001b[0;36mhist2d\u001b[1;34m(x, y, bins, range, density, weights, cmin, cmax, data, **kwargs)\u001b[0m\n\u001b[0;32m   2665\u001b[0m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[38;5;241m.\u001b[39mhist2d)\n\u001b[0;32m   2666\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mhist2d\u001b[39m(\n\u001b[0;32m   2667\u001b[0m         x, y, bins\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, \u001b[38;5;28mrange\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, weights\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m   2668\u001b[0m         cmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, cmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m-> 2669\u001b[0m     __ret \u001b[38;5;241m=\u001b[39m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhist2d\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   2670\u001b[0m \u001b[43m        \u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbins\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdensity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdensity\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   2671\u001b[0m \u001b[43m        \u001b[49m\u001b[43mweights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmin\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcmax\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmax\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   2672\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdata\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   2673\u001b[0m     sci(__ret[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m   2674\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m __ret\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\matplotlib\\__init__.py:1461\u001b[0m, in \u001b[0;36m_preprocess_data.<locals>.inner\u001b[1;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1458\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[0;32m   1459\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m   1460\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m-> 1461\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1463\u001b[0m     bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1464\u001b[0m     auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[0;32m   1465\u001b[0m                   \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\matplotlib\\axes\\_axes.py:7128\u001b[0m, in \u001b[0;36mAxes.hist2d\u001b[1;34m(self, x, y, bins, range, density, weights, cmin, cmax, **kwargs)\u001b[0m\n\u001b[0;32m   7035\u001b[0m \u001b[38;5;129m@_preprocess_data\u001b[39m(replace_names\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mweights\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[0;32m   7036\u001b[0m \u001b[38;5;129m@_docstring\u001b[39m\u001b[38;5;241m.\u001b[39mdedent_interpd\n\u001b[0;32m   7037\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mhist2d\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, y, bins\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, \u001b[38;5;28mrange\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, weights\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m   7038\u001b[0m            cmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, cmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m   7039\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m   7040\u001b[0m \u001b[38;5;124;03m    Make a 2D histogram plot.\u001b[39;00m\n\u001b[0;32m   7041\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   7125\u001b[0m \u001b[38;5;124;03m      `.colors.PowerNorm`.\u001b[39;00m\n\u001b[0;32m   7126\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m-> 7128\u001b[0m     h, xedges, yedges \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistogram2d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbins\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbins\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m   7129\u001b[0m \u001b[43m                                       \u001b[49m\u001b[43mdensity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdensity\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   7131\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m cmin \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m   7132\u001b[0m         h[h \u001b[38;5;241m<\u001b[39m cmin] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
      "File \u001b[1;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mhistogram2d\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\highlevel.py:1434\u001b[0m, in \u001b[0;36mArray.__array_function__\u001b[1;34m(self, func, types, args, kwargs)\u001b[0m\n\u001b[0;32m   1417\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__array_function__\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, types, args, kwargs):\n\u001b[0;32m   1418\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m   1419\u001b[0m \u001b[38;5;124;03m    Intercepts attempts to pass this Array to those NumPy functions other\u001b[39;00m\n\u001b[0;32m   1420\u001b[0m \u001b[38;5;124;03m    than universal functions that have an Awkward equivalent.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1432\u001b[0m \u001b[38;5;124;03m    See also #__array_ufunc__.\u001b[39;00m\n\u001b[0;32m   1433\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m-> 1434\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mak\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_connect\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_numpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtypes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\_connect\\_numpy.py:37\u001b[0m, in \u001b[0;36marray_function\u001b[1;34m(func, types, args, kwargs)\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m function \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m     36\u001b[0m     args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(_to_rectilinear(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m args)\n\u001b[1;32m---> 37\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m \u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m_to_rectilinear\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\n\u001b[0;32m     38\u001b[0m     out \u001b[38;5;241m=\u001b[39m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m     39\u001b[0m     nplike \u001b[38;5;241m=\u001b[39m ak\u001b[38;5;241m.\u001b[39mnplike\u001b[38;5;241m.\u001b[39mof(out)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\_connect\\_numpy.py:37\u001b[0m, in \u001b[0;36m<dictcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m function \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m     36\u001b[0m     args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(_to_rectilinear(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m args)\n\u001b[1;32m---> 37\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m {k: \u001b[43m_to_rectilinear\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems()}\n\u001b[0;32m     38\u001b[0m     out \u001b[38;5;241m=\u001b[39m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m     39\u001b[0m     nplike \u001b[38;5;241m=\u001b[39m ak\u001b[38;5;241m.\u001b[39mnplike\u001b[38;5;241m.\u001b[39mof(out)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\_connect\\_numpy.py:28\u001b[0m, in \u001b[0;36m_to_rectilinear\u001b[1;34m(arg)\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arg, Iterable):\n\u001b[0;32m     27\u001b[0m     nplike \u001b[38;5;241m=\u001b[39m ak\u001b[38;5;241m.\u001b[39mnplike\u001b[38;5;241m.\u001b[39mof(arg)\n\u001b[1;32m---> 28\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mnplike\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_rectilinear\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallow_missing\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m     29\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m     30\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m arg\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\nplike.py:483\u001b[0m, in \u001b[0;36mNumpy.to_rectilinear\u001b[1;34m(self, array, *args, **kwargs)\u001b[0m\n\u001b[0;32m    480\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m ak\u001b[38;5;241m.\u001b[39moperations\u001b[38;5;241m.\u001b[39mconvert\u001b[38;5;241m.\u001b[39mto_numpy(array, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    482\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(array, Iterable):\n\u001b[1;32m--> 483\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_rectilinear\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43marray\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m    485\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    486\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mto_rectilinear argument must be iterable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\nplike.py:483\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    480\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m ak\u001b[38;5;241m.\u001b[39moperations\u001b[38;5;241m.\u001b[39mconvert\u001b[38;5;241m.\u001b[39mto_numpy(array, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    482\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(array, Iterable):\n\u001b[1;32m--> 483\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m [\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_rectilinear\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m array]\n\u001b[0;32m    485\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    486\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mto_rectilinear argument must be iterable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\nplike.py:486\u001b[0m, in \u001b[0;36mNumpy.to_rectilinear\u001b[1;34m(self, array, *args, **kwargs)\u001b[0m\n\u001b[0;32m    483\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m [\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mto_rectilinear(x, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m array]\n\u001b[0;32m    485\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 486\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mto_rectilinear argument must be iterable\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: to_rectilinear argument must be iterable"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Data, true\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.hist2d(theta_unknown_S[:, 0], theta_unknown_S[:, 1], bins=(20, 20), cmap='Oranges', alpha=0.5, label=\"Data, true\")\n",
    "plt.colorbar()\n",
    "plt.xlabel(\"x1\")\n",
    "plt.ylabel(\"x2\")\n",
    "plt.title(\"Hist: Data, true\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Data, true\n",
    "# theshape=theta_unknown_S.shape\n",
    "# print(theshape)\n",
    "# N = theshape[0] * theshape[1]\n",
    "# plt.figure(figsize=(10, 8))\n",
    "# plt.hist(theta_unknown_S.reshape(N), cmap='Oranges', alpha=0.5, label=\"Data, true\")\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# _, _, _ = plt.hist2d(theta0_G[:, 0], theta0_G[:, 1], bins=(20, 20), cmap='Blues', alpha=0.5, label=\"MC, true\")\n",
    "# _, _, _ = plt.hist2d(theta_unknown_G[:, 0], theta_unknown_G[:, 1], bins=(20, 20), cmap='Oranges', alpha=0.5, label=\"Data, true\")\n",
    "# _, _, _ = plt.hist2d(theta0_G[:, 0], theta0_G[:, 1], bins=(20, 20), weights=myweights[-1, 0, :], cmap='Greys', alpha=0.5, label=\"OmniFolded\")\n",
    "# plt.xlabel(\"x1\")\n",
    "# plt.ylabel(\"x2\")\n",
    "# plt.legend(frameon=False)\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = Input((2,))  # 2D input\n",
    "hidden_layer_1 = Dense(50, activation='relu')(inputs)\n",
    "hidden_layer_2 = Dense(50, activation='relu')(hidden_layer_1)\n",
    "hidden_layer_3 = Dense(50, activation='relu')(hidden_layer_2)\n",
    "outputs = Dense(1, activation='sigmoid')(hidden_layer_3)\n",
    "model = Model(inputs=inputs, outputs=outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theta0G (150396, 2), labels (150396,), labels unknown (150396,), theta 0(150396, 2, 2), theta unknown s(150396, 2)\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 3ms/step\n",
      "16/16 [==============================] - 0s 4ms/step\n"
     ]
    }
   ],
   "source": [
    "myweights = of.omnifold(ak.to_numpy(theta0),ak.to_numpy(theta_unknown_S),20,model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #needless\n",
    "# plt.hist2d(theta0_G[:, 0], theta0_G[:, 1], bins=(20, 20), cmap='Blues', alpha=0.5, label=\"MC, true\")\n",
    "# plt.hist2d(theta_unknown_G[:, 0], theta_unknown_G[:, 1], bins=(20, 20), cmap='Oranges', alpha=0.5, label=\"Data, true\")\n",
    "# plt.hist2d(theta0_G[:, 0], theta0_G[:, 1], bins=(20, 20), weights=myweights[-1, 0, :], cmap='Greys', alpha=0.5, label=\"OmniFolded\")\n",
    "# plt.xlabel(\"x1\")\n",
    "# plt.ylabel(\"x2\")\n",
    "# plt.legend(frameon=False)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "no field named 'shape'\n\n(https://github.com/scikit-hep/awkward-1.0/blob/1.10.5/src/awkward/highlevel.py#L1124)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[31], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShape theta0_G:\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[43mtheta0_G\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m)\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShape weights:\u001b[39m\u001b[38;5;124m\"\u001b[39m, myweights\u001b[38;5;241m.\u001b[39mshape)\n",
      "File \u001b[1;32m~\\LHC_env\\lhc\\Lib\\site-packages\\awkward\\highlevel.py:1123\u001b[0m, in \u001b[0;36mArray.__getattr__\u001b[1;34m(self, where)\u001b[0m\n\u001b[0;32m   1117\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[0;32m   1118\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwhile trying to get field \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m, an exception \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1119\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccurred:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mrepr\u001b[39m(where), \u001b[38;5;28mtype\u001b[39m(err), \u001b[38;5;28mstr\u001b[39m(err))\n\u001b[0;32m   1120\u001b[0m             \u001b[38;5;241m+\u001b[39m ak\u001b[38;5;241m.\u001b[39m_util\u001b[38;5;241m.\u001b[39mexception_suffix(\u001b[38;5;18m__file__\u001b[39m)\n\u001b[0;32m   1121\u001b[0m         ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01merr\u001b[39;00m\n\u001b[0;32m   1122\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1123\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[0;32m   1124\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mno field named \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mwhere\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m ak\u001b[38;5;241m.\u001b[39m_util\u001b[38;5;241m.\u001b[39mexception_suffix(\u001b[38;5;18m__file__\u001b[39m)\n\u001b[0;32m   1125\u001b[0m     )\n",
      "\u001b[1;31mAttributeError\u001b[0m: no field named 'shape'\n\n(https://github.com/scikit-hep/awkward-1.0/blob/1.10.5/src/awkward/highlevel.py#L1124)"
     ]
    }
   ],
   "source": [
    "print(\"Shape theta0_G:\", theta0_G.shape)\n",
    "print(\"Shape weights:\", myweights.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b0c6e7c390>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,_,_=plt.hist(theta0_G[:,0],bins=np.linspace(-3,1000,200),color='blue',alpha=0.5,label=\"MC, true\")\n",
    "_,_,_=plt.hist(theta_unknown_G[:,0],bins=np.linspace(-3,1000,200),color=['orange'],alpha=0.5,label=\"Data, true\")\n",
    "_,_,_=plt.hist(theta0_G[:,0],bins=np.linspace(-3,1000,200),weights=myweights[-1, 0, :],color='black',histtype=\"step\",label=\"OmniFolded\")\n",
    "_,_,_=plt.hist(theta_unknown_S[:,0],bins=np.linspace(-3,1000,200),color=['green'],alpha=0.5,label=\"got\")\n",
    "plt.xlabel(\"X1\")\n",
    "plt.ylabel(\"events\")\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1b0c6a55c90>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGyCAYAAAAFw9vDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABYnklEQVR4nO3deVxU9f4/8NcgDDgoB4dlBopBy20sNUVTUsuFG6ZZLt/KAveyDLuiN1NxQ8X1dss0U+uXy3Vpu4l1NTHTyiVzgRSXUbmpHCtAJgXCCRnl/P6gOc6wKOAwMzCv5+MxD5lzPjPzntNDfPU5n0UhSZIEIiIiIjfm4ewCiIiIiJyNgYiIiIjcHgMRERERuT0GIiIiInJ7DERERETk9hiIiIiIyO0xEBEREZHbYyAiIiIit8dARERERG7P09kF1AUlJSX47bff0LhxYygUCmeXQ0RERFUgSRL++OMPhIaGwsPjDn1AkhN9//330pNPPimFhIRIAKTk5GT5XHFxsfTGG29IDz74oKRSqaSQkBBp2LBh0q+//mrzHr///rv0wgsvSI0bN5YEQZBGjx4t/fHHHzZtjh8/LnXv3l3y9vaW7r33Xmnx4sXVqvPSpUsSAD744IMPPvjgow4+Ll26dMd/653aQ3Tt2jW0b98eo0ePxuDBg23OmUwmpKWlYebMmWjfvj2uXr2KCRMm4KmnnsLRo0fldjExMcjKysKuXbtgNpsxatQojB07Fps3bwYAFBQU4PHHH0dUVBRWrVqFEydOYPTo0fD398fYsWOrVGfjxo0BAJcuXYKfn5+dvj0RERHVpoKCAoSFhcn/jt+OQpJcY3NXhUKB5ORkDBw4sNI2R44cwcMPP4zMzEzodDoYDAa0adMGR44cQadOnQAAKSkp6NevH3755ReEhoZi5cqVmD59OrKzs6FUKgEAU6dOxdatW3HmzJkq1VZQUABBEJCfn89AREREVEdU59/vOjWoOj8/HwqFAv7+/gCAgwcPwt/fXw5DABAVFQUPDw8cOnRIbvPoo4/KYQgAoqOjcfbsWVy9erXCz7l+/ToKCgpsHkRERFR/1ZlAVFRUhClTpuD555+XU152djaCg4Nt2nl6ekKtViM7O1tuo9FobNpYnlvalLVw4UIIgiA/wsLC7P11iIiIyIXUiUBkNpvx7LPPQpIkrFy5stY/b9q0acjPz5cfly5dqvXPJCIiIudx+Wn3ljCUmZmJPXv22NwD1Gq1uHz5sk37Gzdu4MqVK9BqtXKbnJwcmzaW55Y2ZXl7e8Pb29ueX4OIiIhcmEv3EFnCUEZGBr755hsEBATYnI+MjEReXh5SU1PlY3v27EFJSQm6dOkit9m7dy/MZrPcZteuXWjVqhWaNGnimC9CRERELs2pgaiwsBDHjh3DsWPHAAAXLlzAsWPHIIoizGYz/u///g9Hjx7Fpk2bcPPmTWRnZyM7OxvFxcUAAL1ej759++Kll17C4cOHceDAAYwfPx5Dhw5FaGgoAOCFF16AUqnEmDFjcOrUKXzyySd45513MGnSJGd9bSIiInIxTp12/91336FXr17ljo8YMQKJiYlo1qxZha/79ttv0bNnTwDAlStXMH78ePz3v/+Fh4cHhgwZgmXLlqFRo0Zy+/T0dMTFxeHIkSMIDAzEa6+9hilTplS5Tk67JyIiqnuq8++3y6xD5MoYiIiIiOqeersOEREREVFtYCAiIiIit8dARERERG7P5dchIiIiqorERNf+vJEjR2L9+vV4+eWXsWrVKptzcXFxeO+99zBixAisW7dOPp6dnY358+dj+/bt+PXXXxEcHIyHHnoI8fHx6NOnT5U+1zKB6erVq/LWV1Qee4iIiIgcJCwsDB9//DH+/PNP+VhRURE2b94MnU5n0/bixYuIiIjAnj178M9//hMnTpxASkoKevXqhbi4OLvXZlnSxl0xEBERETlIx44dERYWhi1btsjHtmzZAp1Ohw4dOti0ffXVV6FQKHD48GEMGTIELVu2xAMPPIBJkybhxx9/rNLnXbx4UV7epkmTJlAoFBg5ciQAoGfPnhg/fjzi4+MRGBiI6OhoXLx4EQqFQl4fEADy8vKgUCjw3XffycdOnjyJJ554Ao0aNYJGo8GwYcNgNBprdlFcBAMR1VuiKCItLQ2iKDq7FCIi2ejRo7F27Vr5+Zo1azBq1CibNleuXEFKSgri4uLg6+tb7j2qeusrLCwMn3/+OQDg7NmzyMrKwjvvvCOfX79+PZRKJQ4cOFDuNl5l8vLy0Lt3b3To0AFHjx5FSkoKcnJy8Oyzz1bp9a6KY4ioXhJFEa1aNEdRsRkqlQoGg6FcdzQRkTPExsZi2rRpyMzMBAAcOHAAH3/8sU0PzP/+9z9IkoTWrVvf1Wc1aNAAarUaABAcHFwuSLVo0QJLliyRn1+8ePGO7/nuu++iQ4cOWLBggXxszZo1CAsLw7lz59CyZcu7qtlZGIio3hBFEUajEYGBgTAajSgqNmNYdA9s2LkPRqORgYiIXEJQUBD69++PdevWQZIk9O/fH4GBgTZtHLVmckRERLVfc/z4cXz77bc2O0JY/PzzzwxERM4kiiKaN9fDbDZBpVJh06ZNAABNE3/nFkZEVIHRo0dj/PjxAIAVK1aUO9+iRQsoFAqcOXOmVusoezvOw6N0JI11ILPeHB0o3Yd0wIABWLx4cbn3CwkJqYUqHYNjiKheMBqNMJtN6NFjBkwmU50f3EdE9Vvfvn1RXFwMs9mM6OjocufVajWio6OxYsUKXLt2rdz5vLy8Kn+WUqkEANy8efOObYOCggAAWVlZ8jHrAdZA6cDwU6dOoWnTpmjevLnNo6LxTnUFAxHVK/7+4c4ugYjojho0aACDwYDTp0+jQYMGFbZZsWIFbt68iYcffhiff/45MjIyYDAYsGzZMkRGRlb5s8LDw6FQKLBt2zbk5uaisLCw0rYNGzZE165dsWjRIhgMBnz//feYMWOGTZu4uDhcuXIFzz//PI4cOYKff/4ZO3fuxKhRo6oUulwVAxEREZET+Pn53XbD0fvuuw9paWno1asX/vGPf+DBBx/E3/72N+zevRsrV66U240cORI9e/as9H3uuecezJkzB1OnToVGo5Fv1VVmzZo1uHHjBiIiIhAfH4+kpCSb86GhoThw4ABu3ryJxx9/HG3btkV8fDz8/f3lW251EccQERFRveDolaqry3oF6ops3bq13LGQkBC8++67ePfddyt93YULF+S1hiozc+ZMzJw50+aY9aw2a3q9Hj/88IPNsbKDvFu0aGGzllJ9wEBERERUR+Xn5+Pnn3/G9u3bnV1KncdARO4pPbH0z3aJTiyCiOjuCIKAX375xdll1At192YfUQVa+X4JAPKCZ0RERFXBQET1itBIBS8vFZKSkuCj9ILQSOXskoiIqA7gLTOqV4KbCIiLM8BkMqJ36AbkXzPZnJdXs87Nhy5EcFKVRETkahiIqN4RBB0EQQeN+kubQGSzmrWPFwxb46Br58RCiYjIZfCWGbkNm9Wsi8ww5pnu/CIiInILDETkdriaNRERlcVARERERG6PgYiIiIjcHgdVExFR/ZCe6NjPq+bCriNHjsT69esBAJ6enlCr1WjXrh2ef/55jBw5slr7gK1btw7x8fHV2vW+qhITE7F169Zyu9zXd+whIiIicpC+ffsiKysLFy9exI4dO9CrVy9MmDABTz75JG7cuOHs8qrFbDY7uwS7YiAiIiJyEG9vb2i1Wtxzzz3o2LEjEhIS8MUXX2DHjh02m7++9dZbaNu2LXx9fREWFoZXX30VhYWFAEo3ZR01ahTy8/OhUCigUCiQ+NfOths2bECnTp3QuHFjaLVavPDCC7h8+XKV61u3bh3mzJmD48ePy+9tqUuhUGDlypV46qmn4Ovri/nz52PdunXw9/e3eY+tW7dCoVDYHPviiy/QsWNH+Pj44L777sOcOXNcLgAyEFG90zMgET0DEp1dBhFRlfTu3Rvt27e32T3ew8MDy5Ytw6lTp7B+/Xrs2bMHb7zxBgDgkUcewdKlS+Hn54esrCxkZWXh9ddfB1DaazNv3jwcP34cW7duxcWLFzFy5Mgq1/Lcc8/hH//4Bx544AH5vZ977jn5fGJiIgYNGoQTJ05g9OjRVXrPffv2Yfjw4ZgwYQJOnz6N1atXY926dZg/f36V63IEjiEiIiJystatWyM9PV1+Hh8fL//ctGlTJCUl4ZVXXsF7770HpVIJQRCgUCig1Wpt3sc6pNx3331YtmwZOnfujMLCQjRq1OiOdTRs2BCNGjWCp6dnufcGgBdeeAGjRo2q1nebM2cOpk6dihEjRsh1zZs3D2+88QZmz55drfeqTQxERERETiZJks1tpm+++QYLFy7EmTNnUFBQgBs3bqCoqAgmkwkqVeV7NKampiIxMRHHjx/H1atXUVJSAqB0pf42bdrcdZ2dOnWq9muOHz+OAwcO2PQI3bx5s0rfx5F4y4yIiMjJDAYDmjVrBgC4ePEinnzySbRr1w6ff/45UlNTsWLFCgBAcXFxpe9x7do1REdHw8/PD5s2bcKRI0eQnJx8x9dVh6+vr81zDw8PSJJkc6zsYOvCwkLMmTMHx44dkx8nTpxARkYGfHx87FKXPbCHiNxDxmpnV0BEVKE9e/bgxIkTmDhxIoDSXp6SkhL861//kqfif/rppzavUSqVuHnzps2xM2fO4Pfff8eiRYsQFhYGADh69Gi166novSsTFBSEP/74A9euXZPDUtnp+h07dsTZs2fRvHnzatfiSAxEREREDnL9+nVkZ2fj5s2byMnJQUpKChYuXIgnn3wSw4cPBwA0b94cZrMZy5cvx4ABA3DgwAGsWrXK5n2aNm2KwsJC7N69G+3bt4dKpYJOp4NSqcTy5cvxyiuv4OTJk5g3b161a2zatCkuXLiAY8eO4d5770Xjxo3h7e1dYdsuXbpApVIhISEBf//733Ho0CGb2XIAMGvWLDz55JPQ6XT4v//7P3h4eOD48eM4efIkkpKSql1fbeEtMyIiIgdJSUlBSEgImjZtir59++Lbb7/FsmXL8MUXX6BBgwYAgPbt2+Ott97C4sWL8eCDD2LTpk1YuHChzfs88sgjeOWVV/Dcc88hKCgIS5YsQVBQENatW4fPPvsMbdq0waJFi/Dmm2+Wq6Fp06byNP2KDBkyBH379kWvXr0QFBSEjz76qNK2arUaGzduxFdffYW2bdvio48+Kvfe0dHR2LZtG77++mt07twZXbt2xdtvv43wcNfaV1Ihlb35R+UUFBRAEATk5+fDz8/P2eVQBdLS0hAREYHVk8eiZViIfPzcpSy8/M/3kfrxWABAxND3MWDAB/jvf19C6sdj0fE53kojIvdhMpkQEBCAHTt2oGfPns4up9ZV599v9hARERG5iW+//Ra9e/d2izBUXQxEREREbqJ///7Yvn27s8twSQxERERE5PYYiIiIiMjtMRCR2zKcz4W4cyKQnujsUoiIyMkYiMjtqFSB8FF6ITYhGfqBKyBm5Tu7JCIicjIGInI7gqDDuoQ4JAwbBFORGcY8k7NLIiIiJ+NK1eSWNGoB4deCnF0GERG5CPYQERERkdtjDxEREdULoijCaDQ67PMCAwOh0+kc9nn2MHLkSOTl5WHr1q12eb+ePXvioYcewtKlSytt07RpU8THxyM+Pr7Gn5OYmIitW7eW2zjWnhiIyO0ZzuciUBTr3C82IrpFFEXo9XqYTI4bE6hSqWAwGKr9u+PSpUuYPXs2UlJSYDQaERISgoEDB2LWrFkICAiopWpLvfPOO7DesWvkyJFYv359uXYZGRkuvzu9vTEQkduJEFYDCIHgq5Jnm6mSdtboFxsRuQaj0QiTyYSNGzdCr9fX+ucZDAbExsbCaDRW6/fG+fPnERkZiZYtW+Kjjz5Cs2bNcOrUKUyePBk7duzAjz/+CLVaXWt1C4JQ7ljfvn2xdu1am2NBQe43xpKBiOq29MTSPzOyqv1SjVrAuoQ4pP+ciQUbkqv9i42IXI9er0fHjh2dXUal4uLioFQq8fXXX6Nhw4YAAJ1Ohw4dOuD+++/H9OnTsXLlSjRt2hQvvvgizp07hy1btiAgIADLly9HZGQkXnzxRezevRv33Xcf1qxZg06dOgEA1q1bh/j4eHzyySeIj4/HpUuX0L17d6xduxYhIaWbXld0y8zb2xtarbbCer///ntMnjwZx48fh1qtxogRI5CUlARPz4rjw+XLlzFmzBh888030Gq1SEpKKtcmLy8Pr7/+Or744gtcv34dnTp1wttvv4327dvLbRYtWoS3334bJpMJzz77rEMCGgdVk1swnM+F4XxuueMatYBwbZm/aOmJXKyRiOzuypUr2LlzJ1599VU5DFlotVrExMTgk08+kW9pvf322+jWrRt++ukn9O/fH8OGDcPw4cMRGxuLtLQ03H///Rg+fLjNLTCTyYQ333wTGzZswN69eyGKIl5//fUa1fvrr7+iX79+6Ny5M44fP46VK1fiww8/rDDkWIwcORKXLl3Ct99+i//85z947733cPnyZZs2zzzzDC5fvowdO3YgNTUVHTt2RJ8+fXDlyhUAwKefforExEQsWLAAR48eRUhICN57770afYfqYA8R1WvWt8UAwEfpBcFX5eSqiMgdZWRkQJKkSm/p6fV6XL16Fbm5pf/z1q9fP7z88ssAgFmzZmHlypXo3LkznnnmGQDAlClTEBkZiZycHLmHx2w2Y9WqVbj//vsBAOPHj8fcuXNvW9e2bdvQqFEj+fkTTzyBzz77DO+99x7CwsLw7rvvQqFQoHXr1vjtt98wZcoUzJo1Cx4etn0q586dw44dO3D48GF07twZAPDhhx/afN/9+/fj8OHDuHz5Mry9vQEAb775JrZu3Yr//Oc/GDt2LJYuXYoxY8ZgzJgxAICkpCR88803KCoqqsJVrjmn9hDt3bsXAwYMQGhoKBQKRblR75IkYdasWQgJCUHDhg0RFRWFjIwMmzZXrlxBTEwM/Pz84O/vjzFjxqCwsNCmTXp6Onr06AEfHx+EhYVhyZIltf3VyEHErHykGbIq7P0Bbt0WWz15LFZPHot1CXHQqMvfQycichTrHp3badeunfyzRqMBALRt27bcMeseGJVKJYchAAgJCSnXQ1NWr169cOzYMfmxbNkyAKXjpCIjI6FQKOS23bp1Q2FhIX755Zdy72MwGODp6YmIiAj5WOvWreHv7y8/P378OAoLCxEQEIBGjRrJjwsXLuDnn3+W36dLly427x0ZGXnb72APTu0hunbtGtq3b4/Ro0dj8ODB5c4vWbIEy5Ytw/r169GsWTPMnDkT0dHROH36NHx8fAAAMTExyMrKwq5du2A2mzFq1CiMHTsWmzdvBgAUFBTg8ccfR1RUFFatWoUTJ05g9OjR8Pf3x9ixYx36fcm+RFFEq6dWoKjYDKDy3h+NWmAIIiKna968ORQKBQwGAwYNGlTuvMFgQJMmTeTxMl5eXvI5Syip6FhJSYl8zPq8pc2dApivr6/DZpQVFhYiJCQE3333Xblz1sHJGZwaiJ544gk88cQTFZ6TJAlLly7FjBkz8PTTTwMA/v3vf0Oj0WDr1q0YOnQoDAYDUlJScOTIEXlQ2fLly9GvXz+8+eabCA0NxaZNm1BcXIw1a9ZAqVTigQcewLFjx/DWW28xENVxRqMRRcVmJAwbhHBtEARfFYMPEbmsgIAA/O1vf8N7772HiRMn2owjys7OxqZNmzB8+HCbHhln0uv1+PzzzyFJklzTgQMH0LhxY9x7773l2rdu3Ro3btxAamqqfMvs7NmzyMvLk9t07NgR2dnZ8PT0RNOmTSv93EOHDmH48OHysR9//NF+X6wSLjuo+sKFC8jOzkZUVJR8TBAEdOnSBQcPHgQAHDx4EP7+/nIYAoCoqCh4eHjg0KFDcptHH30USqVSbhMdHY2zZ8/i6tWrFX729evXUVBQYPMg1xWuDULLsBCGISJyee+++y6uX7+O6Oho7N27F5cuXUJKSgr+9re/4Z577sH8+fOdXaLs1VdfxaVLl/Daa6/hzJkz+OKLLzB79mxMmjSp3PghAGjVqhX69u2Ll19+GYcOHUJqaipefPFFm+AXFRWFyMhIDBw4EF9//TUuXryIH374AdOnT8fRo0cBABMmTMCaNWuwdu1anDt3DrNnz8apU6dq/fu67KDq7OxsALfukVpoNBr5XHZ2NoKDg23Oe3p6Qq1W27Rp1qxZufewnGvSpEm5z164cCHmzJljny9CREQOYzAYXPpzWrRogaNHj2L27Nl49tlnceXKFWi1WgwcOBCzZ8+u1TWIquuee+7BV199hcmTJ6N9+/ZQq9UYM2YMZsyYUelr1q5dixdffBGPPfYYNBoNkpKSMHPmTPm8QqHAV199henTp2PUqFHIzc2FVqvFo48+Kv/b/Nxzz+Hnn3/GG2+8gaKiIgwZMgTjxo3Dzp07a/X7umwgcqZp06Zh0qRJ8vOCggKEhYU5sSIiIrqdwMBAqFQqxMbGOuwzVSoVAgMDq/268PBwrFu37rZtLl68WO5Y2bFATZs2Lbfq9MiRI23aDBw40KZN2c+9Ux2PPfYYDh8+XOn5smOBtFottm3bZnNs2LBhNs8bN26MZcuWyYO3K5KQkICEhASbY4sXL75trXfLZQORZQphTk6OvKCU5flDDz0ktyk7ev7GjRty4ra0ycnJsWljeV7ZQlTe3t7ydEAiInJ9Op0OBoOBe5lRjblsIGrWrBm0Wi12794tB6CCggIcOnQI48aNA1A6DS8vLw+pqanyNL89e/agpKREnrIXGRmJ6dOnw2w2y6Pvd+3ahVatWlV4u4yIiOomnU7HgEI15tRB1YWFhfK6B0DpQOpjx45BFEUoFArEx8cjKSkJX375JU6cOIHhw4cjNDQUAwcOBFA6Er1v37546aWXcPjwYRw4cADjx4/H0KFDERoaCgB44YUXoFQqMWbMGJw6dQqffPIJ3nnnHZtbYkRA6ZiAtLQ0iFn5zi6FiIgczKk9REePHkWvXr3k55aQMmLECKxbtw5vvPEGrl27hrFjxyIvLw/du3dHSkqKvAYRAGzatAnjx49Hnz594OHhgSFDhtjclxQEAV9//TXi4uIQERGBwMBAzJo1i1PuSSb4quDldWvsgcrHC4atcdC1u8MLiYio3lBIVV0y040VFBRAEATk5+fDz8/P2eXQX9LS0hAREYHVk8eiZVjInV9wG1+cHw2TyYjcXAOSk2OR+vFYdHxutZ0qJSIiZ6jOv98uO4aIyJEEQQdB4NgDIiJ3xUBEBKBnQCIA4JwpCwBgOJ+LQFHkAE0iIjfhsitVEzmD4KuCj9ILsQnJ0Ov1EEXR2SUREZEDMBARWdGoBaxLiEPCsEEwmUwOXdOEiIich7fMiMrQqAWEXwtydhlERORA7CEiup0MzjQjInIHDERUJ4mi6LBNHImIqP7jLTOqc0RRRPPmepjNJvgovSD4qpxdEhER1XEMRFTnGI1GmM0mDBq0Ec+1PwqNWnB2SUREVMfxlhnVWUFBeoYhIiKyCwYiIiIicnsMRES3YTify8UZiYjcAAMRUQW4YjURkXthIKI6K0KovTWCyq1YfXB+rX0WERE5H2eZEVWCK1YTEbkP9hARERGR22MgIiIiIrfHQERERERuj4GIiIiI3B4HVRNVVXrirZ/bJVbSiIiI6iL2EBEREZHbYyAiIiIit8dARERERG6PgYiIiIjcHgdVE1WB4Xwujqbeet63z0ToQgQOriYiqicYiIhuw3qTV2uq5V4wbI2Drp2TCiMiIrtiICK6Dcsmr/nXTPKxzOxcLNiQDGOeCTon1kZERPbDQER0Bxq1AI1acHYZRERUiziomoiIiNweAxERERG5PQYiIiIicnsMREREROT2GIiIiIjI7XGWGZEdiKIIo9EIAAgMDIROxwn5RER1CQMR0V0QRREGgwEDBgyG2Vy6VpFKpYLBYGAoIiKqQxiIiGpIzMpH1+Z6mM0meHmpEBOTApPJiOTkWBiNRgYiIqI6hIGIqIaMeSaYzSYMGrQR4eE9IAg6ZGWlObssIiKqAQ6qJrpLQUF6CAJ7g4iI6jIGIiIiInJ7DEREtcBgMEAURWeXQUREVcRARGRHKlUgvLxUiI2NhV6vZygiIqojGIiI7EgQdIiLM2DQoI0wmUzy2kREROTaGIiI7lKEsNrmuSDoEBSkd1I1RERUEwxERDWU+Vues0sgIiI7YSAiqibBVwUfpReSPtgHH6UXBF+Vs0siIqK7xIUZiapJoxawLiEO+ddMEHxV0KgFGH6vpHHGaqDj6kpOEhGRq2AgIqoBjVqARi1U70Xpibd+bpdYSSMiInIG3jIjIiIit8dARERERG6Pt8yI7KBnQKL883e/J1bajoiIXJNL9xDdvHkTM2fORLNmzdCwYUPcf//9mDdvHiRJkttIkoRZs2YhJCQEDRs2RFRUFDIyMmze58qVK4iJiYGfnx/8/f0xZswYFBYWOvrrEBERkYty6UC0ePFirFy5Eu+++y4MBgMWL16MJUuWYPny5XKbJUuWYNmyZVi1ahUOHToEX19fREdHo6ioSG4TExODU6dOYdeuXdi2bRv27t2LsWPHOuMrERERkQty6VtmP/zwA55++mn0798fANC0aVN89NFHOHz4MIDS3qGlS5dixowZePrppwEA//73v6HRaLB161YMHToUBoMBKSkpOHLkCDp16gQAWL58Ofr164c333wToaGhzvlyVDPpiUBGlrOrICKiesale4geeeQR7N69G+fOnQMAHD9+HPv378cTTzwBALhw4QKys7MRFRUlv0YQBHTp0gUHDx4EABw8eBD+/v5yGAKAqKgoeHh44NChQxV+7vXr11FQUGDzICIiovrLpXuIpk6dioKCArRu3RoNGjTAzZs3MX/+fMTExAAAsrOzAQAajcbmdRqNRj6XnZ2N4OBgm/Oenp5Qq9Vym7IWLlyIOXPm2PvrEBERkYty6R6iTz/9FJs2bcLmzZuRlpaG9evX480338T69etr9XOnTZuG/Px8+XHp0qVa/TyqX3oGJMobvhrO50IURSdXREREd+LSPUSTJ0/G1KlTMXToUABA27ZtkZmZiYULF2LEiBHQarUAgJycHISEhMivy8nJwUMPPQQA0Gq1uHz5ss373rhxA1euXJFfX5a3tze8vb1r4RuRu7DsdxabkAxV0k4YDAbonF0UERFVyqV7iEwmEzw8bEts0KABSkpKAADNmjWDVqvF7t275fMFBQU4dOgQIiMjAQCRkZHIy8tDamqq3GbPnj0oKSlBly5dHPAtyB1Z9jtLGDYIJpMJRqPR2SUREdFtuHQP0YABAzB//nzodDo88MAD+Omnn/DWW29h9OjRAACFQoH4+HgkJSWhRYsWaNasGWbOnInQ0FAMHDgQAKDX69G3b1+89NJLWLVqFcxmM8aPH4+hQ4dyhhnVKo1aQPi1IGeXQUREVeDSgWj58uWYOXMmXn31VVy+fBmhoaF4+eWXMWvWLLnNG2+8gWvXrmHs2LHIy8tD9+7dkZKSAh8fH7nNpk2bMH78ePTp0wceHh4YMmQIli1b5oyvRERERC7IpQNR48aNsXTpUixdurTSNgqFAnPnzsXcuXMrbaNWq7F58+ZaqJCo6sSsfBjzTACAQH8ROh1HFRERuQqXDkRE9YW4dwm6TdmComIzAECl2lg60JqhiIjIJbj0oGqi+sKYZ0JRsRkJwwZxoDURkQtiICJyoHBtEMK1fw20zljt3GKIiEjGQETkAJm/5Tm7BCIiug0GIqJaZFmgMemDffBRekHwVTm7JCIiqgAHVVOdImblw3A+19llVJllgcb8ayYIvipo1ALyr5mcXRYREZXBQER1hiiKaPXUChQVm+tUb4tGLUCjFpxdBhER3QYDEdUZRqNRnqnV7v5whgwiIrIbjiGiOidcG8QwREREdsVARERERG6PgYiIiIjcHgMRERERuT0OqiZyIlEUYTQaERgYWLqvWXrirZPtEit5FRER2RsDEZGTiFn56NpcD7PZBJVKVbrZq7OLIiJyU7xlRuQkxjwTzGYTevSYUeFmr6IoIi0tDaIoOqlCIiL3wR4iIifz9w8vd0zMykfzTmV6j3TsPyIiqi3sISJyQXfqPSIiIvtiICJyYV3uOe7sEoiI3AIDEVFdkLHa2RUQEdVrDERERETk9hiIiIiIyO0xEBE5SeZveQCAVr5fOrcQIiLitHsiRxN8VfBReiHpg33wUXpBaKSSz4lZ+TDmmWA4n+vEComI3A8DEZGDadQC1iXEIf+aCYKvCvnXTABKF2Ls9twKFBWbAcAmLBnO5yJQFLkWERFRLWEgInICjVqARi0AgByIUlNTUVRsRsKwQQjXBkHwLQ1DPkovxCYkQ5W0kws0EhHVEo4hInIywVcFLy8VkpKS4KP0Qrv7w9EyLEQOTesS4pAwbBAXaCQiqkXsISJyMo1aQFycASaTEb1DN8g9R9bnw68FOak6IiL3wB4iIhcgCDqEhHQsF4aIiMgxGIiIiIjI7fGWGbk8URRhNBphMBicXQoREdVTDETk0kRRRPPmepjNpTOxfJRe8uwrIiIie2EgIpdmNBphNpswaNBGBAXpKxx0TEREdLdqNIZo/fr12L59u/z8jTfegL+/Px555BFkZmbarTgii6AgPQcdExFRralRIFqwYAEaNmwIADh48CBWrFiBJUuWIDAwEBMnTrRrgURERES1rUa3zC5duoTmzZsDALZu3YohQ4Zg7Nix6NatG3r27GnP+oiorPTEWz+3S6z4XNnjRER0WzUKRI0aNcLvv/8OnU6Hr7/+GpMmTQIA+Pj44M8//7RrgUTuoGdAYtUaZqyG6K+CMa90kHmgf+n+ZpaZeIG5+dCF8LYiEVF11SgQ/e1vf8OLL76IDh064Ny5c+jXrx8A4NSpU2jatKk96yMiK2JWProNXytvAKtSbcTOnTvRu3c0zGYTVD5eMGyNg66dkwslIqpjajSGaMWKFYiMjERubi4+//xzBAQEACjdnPL555+3a4FEdIsxzyRvAGvZ3+zMmTMwm03o0WMGTEVmufeIiIiqrkY9RAUFBVi2bBk8PGzzVGJiIi5dumSXwoiovMzf8gAA4drye5v5+4c7uBoiovqjRj1EzZo1q3DX7StXrqBZs2Z3XRQR2RJ8VfBReiHpg31cnJKIqBbUqIdIkqQKjxcWFsLHx+euCiKi8jRqAesS4pB/zQTBVwWNWkD+Nd4aIyKyl2oFIstsMoVCgVmzZkGluvV/qTdv3sShQ4fw0EMP2bVAIgCIEFajZUCIs8twKo1a4MKURES1pFqB6KeffgJQ2kN04sQJKJVK+ZxSqUT79u3x+uuv27dCIiIiolpWrUD07bffAgBGjRqFd955B35+frVSFBFVXyvfL/FfZxdBRFRH1WgM0dq1a+1dBxEREZHT1CgQXbt2DYsWLcLu3btx+fJllJSU2Jw/f/68XYojors3caIIk8mI6dMDodPpnF0OEZFLqlEgevHFF/H9999j2LBhCAkJgUKhsHddRGQHoihixQo9zGYTNm5UwWAwMBQREVWgRoFox44d2L59O7p162bveojIjoxGo7yK9b59STAajQxEREQVqNHCjE2aNIFarbZ3LURUS7iKNRHR7dUoEM2bNw+zZs2CycSF4YiIiKjuq1Eg+te//oWdO3dCo9Ggbdu26Nixo83Dnn799VfExsYiICAADRs2RNu2bXH06FH5vCRJmDVrFkJCQtCwYUNERUUhIyPD5j2uXLmCmJgY+Pn5wd/fH2PGjEFhYaFd6yQiIqK6q0ZjiAYOHGjnMip29epVdOvWDb169cKOHTsQFBSEjIwMNGnSRG6zZMkSLFu2DOvXr0ezZs0wc+ZMREdH4/Tp0/I2IjExMcjKysKuXbtgNpsxatQojB07Fps3b3bI9yAiIiLXVqNANHv2bHvXUaHFixcjLCzMZt0j681jJUnC0qVLMWPGDDz99NMAgH//+9/QaDTYunUrhg4dCoPBgJSUFBw5cgSdOnUCACxfvhz9+vXDm2++idDQUId8F6Ja88uXVW5q2JmEwMClHFhNRFRGjW6ZAUBeXh7+3//7f5g2bRquXLkCAEhLS8Ovv/5qt+K+/PJLdOrUCc888wyCg4PRoUMHfPDBB/L5CxcuIDs7G1FRUfIxQRDQpUsXHDx4EABw8OBB+Pv7y2EIAKKiouDh4YFDhw5V+LnXr19HQUGBzYOoTklPLH1krAYAqFSB8FF6ITYhGXq9HqIoOrE4IiLXU6NAlJ6ejpYtW2Lx4sV48803kZeXBwDYsmULpk2bZrfizp8/j5UrV6JFixbYuXMnxo0bh7///e9Yv349ACA7OxsAoNFobF6n0Wjkc9nZ2QgODrY57+npCbVaLbcpa+HChRAEQX6EhYXZ7TsR2Vvmb3l3bCMIOqxLiEPCsEEwmUwwGo22DdITSx9ERG6qRoFo0qRJGDlyJDIyMuRxOgDQr18/7N27127FlZSUoGPHjliwYAE6dOiAsWPH4qWXXsKqVavs9hkVmTZtGvLz8+XHpUuXavXziGpC8FXBR+mFpA/2wUfpBaGRSj4nZuUjzZAFw/lc+ZhGLSBcG+SMUomIXF6NxhAdOXIEq1evLnf8nnvuqbTXpSZCQkLQpk0bm2N6vR6ff/45AECr1QIAcnJyEBISIrfJycnBQw89JLe5fPmyzXvcuHEDV65ckV9flre3N7y9ve31NYhqhUYtYF1CHPKvmSD4qpB/rXQZjH1pmZi6dA+Kis0AAC8vFVSqQGeWSkTk8moUiLy9vSscV3Pu3DkEBdnv/0C7deuGs2fPlvuM8PDSReaaNWsGrVaL3bt3ywGooKAAhw4dwrhx4wAAkZGRyMvLQ2pqKiIiIgAAe/bsQUlJCbp06WK3WomcQaMWoFEL8nMfpRfil+yEj9ILi8fFwL+RLwRfFTTqNU6skojI9dUoED311FOYO3cuPv30UwCAQqGAKIqYMmUKhgwZYrfiJk6ciEceeQQLFizAs88+i8OHD+P999/H+++/L39ufHw8kpKS0KJFC3nafWhoqLw0gF6vR9++feVbbWazGePHj8fQoUM5w4zqlbI9RtZBqapEUYTRaERgIDeCJSL3UuOFGQsLCxEcHIw///wTjz32GJo3b47GjRtj/vz5diuuc+fOSE5OxkcffYQHH3wQ8+bNw9KlSxETEyO3eeONN/Daa69h7Nix6Ny5MwoLC5GSkmIztmnTpk1o3bo1+vTpg379+qF79+5yqCKqTzRqAS3DQmoWhrLy0by5HhEREZyJRkRup0Y9RIIgYNeuXdi/fz/S09NRWFiIjh072kx/t5cnn3wSTz75ZKXnFQoF5s6di7lz51baRq1WcxFGooqkJ8o/GvNM3AiWiNxWjQLRpUuXEBYWhu7du6N79+72romInIgbwRKRO6rRLbOmTZvisccewwcffICrV6/auyYiqmWGnUlI++RliFn5AEpvl1lP0Scicjc1CkRHjx7Fww8/jLlz5yIkJAQDBw7Ef/7zH1y/ft3e9RGRHVnWLopNSEbE0PehH7gCm7ano9VTKxCbkAwfpRce1nzj7DKJiByuRrfMOnTogA4dOmDJkiX47rvvsHnzZowdOxYlJSUYPHgw1qzhFF8iV2Q9Ey2v8Bpmf/ipHIQWj4tBuCZIXs+IiMid1CgQWSgUCvTq1Qu9evXCuHHjMGbMGKxfv56BiMiFWa9dVNE0fQYiInJHdxWIfvnlF2zevBmbN2/GyZMnERkZiRUrVtirNiKqZWUXdrRmMBgAgGsSEZFbqFEgWr16NTZv3oz9+/dDr9cjJiYGX3zxhbyCNBHVXYKvCl5eKsTGxgIAVCoVDAYDQxER1Ws1CkRJSUl4/vnnsWzZMrRv397eNRGRE2nUAuLiDDCZjMjNNSA5OZZrEhFRvVejWWaiKGLAgAH45z//iUceeQS//vorAGDDhg3Yv3+/XQskIscTBB1CQjoiKEgvHxNFEWlpaVzBmojqpRoFoi1btiA6OhoNGzZEWlqaPN0+Pz8fCxYssGuBROR8oije2tajVXOIOyc6uyQiIruqUSBKSkrCqlWr8MEHH8DLy0s+3q1bN6SlpdmtOCJyDUajUd7Ww1RkhjGvkplo6Yk224EQEdUVNQpEZ8+exaOPPlruuCAIyMvLu9uaiMhFcVsPIqqvajSoWqvV4n//+x+aNm1qc3z//v2477777FEXETlRz4BEAMA5UxYAIDMz04nVEBHVvhr1EL300kuYMGECDh06BIVCgd9++w2bNm3C66+/jnHjxtm7RiJyEssU/KSkJJttPT7fnsvB1URUr9Soh2jq1KkoKSlBnz59YDKZ8Oijj8Lb2xuvv/46XnvtNXvXSEROYj0Fv3foBgCAj9ILCzYkY+nnO7k+ERHVGzUKRAqFAtOnT8fkyZPxv//9D4WFhWjTpg0aNWpk7/qIyMkEQQdB0EGj/hJA6XYf6T9nYsGGZHl9IlEUYTQaEZibD11IxStfExG5srvaukOpVKJNmzb2qoWIXJBlPJGFRi0g/FqQ/FwURbRq0RxFxWaofLxg2BoHXbvbvGH6X+/XLvE2jYiIHKtGY4iIiIDS/c727duHomIzhkX3uP2UfCIiF3ZXPURE5J7K7nfmo/RCy7BQJ1dFRFRzDEREVG3Wg60BoHfoBuRfY88QEdVdvGVGRDVi2e8sJKQjNOpbA6kN5zkln4jqHgYiIrILwVcFH6UXYhOSodfrGYqIqE5hICIiu9CoBaxLiEPCsEEwmUwwGo3OLomIqMo4hoiI7KbslHxrXKuIiFwZAxER1UjZ9Ylup9prFRERORhvmRFRrTMajVyriIhcGgMREdWOjNXlDmma+FfttemJt1a0JiJyAAYiIiIicnscQ0REtSc9sfTPjKzbNpMHXAcGQqfT1XpZRERlMRARkXOkJwIAxKx8NB/wPsxmE1QqFQwGAxiJiMjReMuMiJzKmGeC2WxCjx4zuH4RETkNe4jIZU2cKCIz0+DsMshB/P3DnV0CEbkxBiJySaIoYsUKPcxmE3yUXhB8Vc4uiWpAzMqHMc8Ew/lcm+OG87kI9FfZLNDYyvdL/Lcmn/HX+CMAHINERDXGQEQuyWg0wmw2IWHYILS7P9xm81CqG/alZWLq0j0oKjYDAHyUXtBpAuX9zlQ+Xtjy1rPVX5MoPbH0z3aJEEURzZuXBmcAt8YgMRQRUTUxEJFLC9cGMQzVMZZNXuOX7ISP0guLx8XAv5EvBF+VvN9ZZk4uZn/4Kfq+uglAaVgSGv3VC5ixGtCHVOmzLMF50KCNAIDk5FgYjUYGIiKqNgYiIrIrS+jJv2aSQ1DZ89ZtgNIQZfnZWlVvhwUF6e38LYjI3TAQEZHdWUJPddqUDURiVj6ad6rgdpidauTaR0RkjYGIiFySZTp+udthdvitZT32iOOOiAjgOkRE5ILErHx5ZlpQkN7ut8QsY4+49hERWbCHiIhcipiVj27D16Ko2AwvLxVUqkCYTLUTWLj2ERFZMBARkUsx5plQVGxGwrBBMAUshSDoai0QERFZMBARkUsK1wahZdgaAMA5UwWbw6Yn3nHTWCKiqmIgIqI6w2AwAJ63QlDZFbArlZ546+d2iZU0IiJ3xkBERC5P8FXBy0uF2NjYcudqe5wREbkHBiIicimZv+WVO6ZRC4iLM8BkMiJCWG1zzmCeznFGRHTXGIiIyCVYtvxI+mBfhRv6CoIOgqBDywDbbT1++72C9YPSE0v/5O0xIqoiBiIicgl32vKDiKg2MRARkcuoypYfRES1gYGIiOq0ngGJACqemi/vV5abD13IX0ErPbH8dP2M1YBnCET/0dzfjMhNMRARUb1kvTmsyscLhq1xt0LRndqrVNiyZQv0ej2DEZGbqFN7mS1atAgKhQLx8fHysaKiIsTFxSEgIACNGjXCkCFDkJOTY/M6URTRv39/qFQqBAcHY/Lkybhx44aDqyciRxGz8rEvLRNmswnDonvAVGSGMc9029dYNpONjl4Ksxno27cv9Ho9RFF0UNVE5Ex1pofoyJEjWL16Ndq1a2dzfOLEidi+fTs+++wzCIKA8ePHY/DgwThw4AAA4ObNm+jfvz+0Wi1++OEHZGVlYfjw4fDy8sKCBQuc8VWIqBaJoohuz61AUbEZPkovtAwLBXBrEcdAf9XtXo7w8B6IizMgM3MfkpNjYTQa2UtE5AbqRCAqLCxETEwMPvjgAyQlJcnH8/Pz8eGHH2Lz5s3o3bs3AGDt2rXQ6/X48ccf0bVrV3z99dc4ffo0vvnmG2g0Gjz00EOYN28epkyZgsTERCiVSmd9LSKqBampqfJeaO3uL9281UfphdiEZACAyscLmxYOvu17CIIOQUF6+bllLBIAji8iqqfqxC2zuLg49O/fH1FRUTbHU1NTYTabbY63bt0aOp0OBw8eBAAcPHgQbdu2hUajkdtER0ejoKAAp06dqvDzrl+/joKCApsHEbk2y2rWSUlJ8FF6od394fKstXUJcVg9eWzphrFFZqSe/q3K7yuKIpo31yMiIgIRERGV30ZLT7z1IKI6x+V7iD7++GOkpaXhyJEj5c5lZ2dDqVTC39/f5rhGo0F2drbcxjoMWc5bzlVk4cKFmDNnjh2qJyJH0agFbJg+tsJ1jCzByHrxR8uWH3diNBphNpswaNBGAOBtNKJ6yqUD0aVLlzBhwgTs2rULPj4+DvvcadOmYdKkSfLzgoIChIWFOezziahm7rSOUdnFH/Ov7cAnFbTrGZBYbhq/9S00Iqp/XPqWWWpqKi5fvoyOHTvC09MTnp6e+P7777Fs2TJ4enpCo9GguLgYeXl5Nq/LycmBVqsFAGi12nKzzizPLW3K8vb2hp+fn82DiOoHjVpAy7CQ2l0AMj2Rt86I6hiX7iHq06cPTpw4YXNs1KhRaN26NaZMmYKwsDB4eXlh9+7dGDJkCADg7NmzEEURkZGRAIDIyEjMnz8fly9fRnBwMABg165d8PPzQ5s2bRz7hYioxiwLMNYGywy0mqhw8UciqnNcOhA1btwYDz74oM0xX19fBAQEyMfHjBmDSZMmQa1Ww8/PD6+99hoiIyPRtWtXAMDjjz+ONm3aYNiwYViyZAmys7MxY8YMxMXFwdvb2+HfiYhch2VMkWUGWkXjijIzM8u9zmAwIDCwtF2rFs1RVGyu0uKPROS6XDoQVcXbb78NDw8PDBkyBNevX0d0dDTee+89+XyDBg2wbds2jBs3DpGRkfD19cWIESMwd+5cJ1ZNRK7AekwRgL8GY6+Rf7bMWrMOSl5eKsTGxkKlUmHTpk0oKjZjWHQPbNi5D8Y8EwMRUR1V5wLRd999Z/Pcx8cHK1aswIoVKyp9TXh4OL766qtaroyI6qLKBmJr1ALi4gwwmYzoHbpBDkqwWrQxNTW1tG0T/1qpTb4dx7WPiGpdnQtERESOIgg6CIIOGvWX8rGn71uDHP98bNt2a80joVHFq1/fTaCxrH9k2VvNYDAwFBHVIgYiIqJqKtt7ZLnlZq3sZrHVDTSW9Y/k23Fc+4ioVjEQERHVgHXvUUWByLJZbI8eM7BvX5K89Ud1twCxuR2Xnnjr53aJICL7YSAiIqqBqi4D4O9fup+aKIro2rUHzObS8FS216jsfmlE5FgMREREDnC7LUCsxwsBkGewEZHjMBAREdWiVr5f4r9Wz623ALGsZ1RZWCIix3HprTuIiOoiMSv/tqtfq1SBpQtCxsZCr9dDFEUApWGJe6YROQd7iIiI7EjMykerp1agqNhc6ZR8QdBhXUIc0n/OxIINyTAeW1OuTUUrZBNR7WEgIiKqRE32TzPmmVBUbEbCsEFod394hTPQgNKp++HXgsodV6kC5RWyb7fGERHZFwMREVEtCNcGQaMWygWiCGE1WgaEVPo6QdDdcY0jIrI/BiIiIhfz9H2WW2jlA9Xd4FYgRJVjICIispPbDaS+nczf8uxbSAW4FQjR7TEQERHdJcFXVTprLCEZAErH/vjajv2paJC05XVJH+yDj9Lrr01kvyzXzkLMyocxr7THKNBfLA006YmlJ++wcrVlar/1ytk12V+NPUxUXzEQERHdJY1awLqEOPn2luCrgkYtyD/bDJK2CkrWr7N+TUVEUUS350pnrwGASrWxtJfH6nylYSU9EcjIAnBr5ezqqrSHKT2xtAG3EqE6joGIiMgONGqhwkBTdiPYsm0qe11ZRqNRnr0GoHS6vtEInedfU/07N0dRsbnat8Oq2utjjx4mIlfGhRmJiGqZIOgQEtKxSsHnTsK1QQjX2k7Xt0z1HxbdAyaTqcqrXFt6fSIiImwWiLQ+n5aWZnO8pj1MRK6OgYiIqK7KWG3zVNPE/44vaeV7a4ySpdenoiB1p7BUExUFLCJXwVtm5HJEUYTBYHB2GUR2U5MFHsuqzZWrrYOU5RaawWAod4uspix/pwcMGMxZbuSyGIjIpVgP3Kxopg6Ru6loUPad1iay/A+FZVzQnfZWsxBFEd0iu8oDt728VAgNjbir+q3/Tnt5qRAdvRQ7d8ZzDBK5HAYicinWu34/1/6oXcZcENVlFQ3KtgQiw/lcBPrf+p8GoVFpeIqNjQUAqFQqvP/++3hx9O33VrNITU2VB26Ha4P+Cl878Mld1G/9dzo8vAdMppr3NBHVJgYicklBQXpo1BnOLoPIJVivXA3Yrnuk8vHCpoWDAQDBTW6Fp2vXcvHpp4MRGxsLH6UXFo+LQbgm6FaYsrotLTT6az2kv3qh2t0fLv/PiL1Wyg4K0kMQdDaByHJ7DgDXNiKnYyAiIqpjLOsXpf+ciQUbkpF6+jf5nCDoIAilwaKy6f7WvUg+Si+0uDekyushlWVZLFJeKNIiPbH0z7/WPyr3OlFE1649YDaXBi55XFHeX+GP6xqRgzEQERHVQRq1gHYIt1npWvBV4TfpVhtLOLJe/dr6FhwAm7B0uyBUblB3xmqIuSq0emrFX+sfbZR7nYxGIwJz86ELqfz9rG+lAUBycqy8rlJZXCGbHIGBiIiojqpopWvD73d+3a1bcIDlNlxlrAd1e3mpoFIFyues1z/asHMf0tLS8OyzMaUzyXy8YNgad8dagoL08s8GgwGBgbZBinuwkaMwEBER1WG3W+naHtP9rXuUVKrACgdFW6btl1vNOq9q449UqkD5Np4lSOnaoeL3vMPsNPYmUU0xEBER1SP2CEFlWY9LsgSi203jr85q1hHCarQMCwHiDMjM3Fd66yzPhLJRpirvyd4kuhtcqZqIiKpMpQqUZ7jFJiRXOJXfejVsiwhhdblj1gRBZ3P7rDIGg6HSla6te5Oqs4XJ7XB1bffBHiJySaW/PEOcXQYRlSEIOnncEoAqLRRpDza31e7Q+2Ov/dZcqscpPbH0T86+qzXsISIioirpGZCIngGJ0KgFtAwLQcuwENvxS7+U7xmyF0HQIS7OgEGDNtqt9+dOaqPHiVwXe4iIiMghegYk4pyp4nWJyrLeU82i3G219MRbP9diz0lNepw4uLvuYSAiIiKXsi8tE5OH6eVFG8tO969QemKli0BW2Ba46xBVWei50602hiXXxEBERERO1zMgETmKfPxb6YX4JTvh5aVCTEwKfH2DoFIFyrPcLCpas8iRbhd6brdUgEuNSyIbHENERER2kflb3l293rLQ5OrJYxEXZ0Dz5tEICeloE4bkWW6xsdAPXAExK7/anyNm5SPNkFXxzLH0RNtbcZWoyviiim61cVyS62IPERER3RXLZrPyFiJlpuFXpNxWIH+xLDTZErdW0/7u90QAf62xFAB0tdrHzZhngi5EgJiVf9u1kSxEUSy33YjN7SyrvdmqoqYz2ip6HTe7dS4GIiIiuitltxC53TR8661ALPuv1eTzwq8Fyc/FrHw55PgovfCw5hv8t4LXiaKIffv22Ww3UvZ2lnVY2rRpU4WfL4qizWBvAPLzwMA7jHWqhPWtNAC8neYEDERERHTXrLcQsQSiinpsrLcCsd5Y9m5Y9lRLGDYI7e4PrzCQiaKIVi2ay6GpZVho+fcxGm3CUmpqqs15g8GA3NxcDBgwGGazCV5eKgQGtpbXRwJKg0xlQeq236GyzW4ZiByGgYiIiG6rutuBWG6hxSYkA0C5niDLViAa9d2vW2QdusK1QdCohVuBzGBAYO4G6EIEGA1ZlYem9MTSP/+apdYyLNRmQ9uyoccy4DsoSC+vj2QyGZGba5CDTFnizokw5pnueFuvKqt1U+1gICIiIruyvoUGlAYke/QEWbtd6JLPWW0Wa1E2NFUkuImADdPHIv+aCQbzdJvQA6DcrDfrvd4AlFugUhRFdHuu9FYcUMEyAumJVV8yoKbSEys/x9WvATAQERFRLbC+hVZb719Z6LKcsx54XZnKpu9b6v/t99KgUy70oHzPmWXRybKz7Sy34hKGDUK4NggG83Q5XJVV2Z5v1oO9a3Ib7dbrVU5bqsDVMRAREVGddLvQVXbgdVmWwd0V9SLVVNnZdmUHd4drg9AyLAS//a6rNBBV5E4z46r1+r++K0NReQxERETkUNUdk3S3bje4OzNzX+m4n9v0IlVVdWbbVUfZwd7VHWxd7vV/LVVAthiIiIioXqrK4O47DWK2hDfLWkh3UtFsu7uSniiPL9I08a/e6wCb8UGW11sCIm+f2WIgIiIil1bTHqXqDO6uyqKO9lKdTW4rlLEa8Ayp0mBo6zWThEa2AVG+fdbuNm+Q/tdnuMHAawYiIiKqt+40uFveCqSSXiQL61BW1d4ii8pW5b4Ty4DvypTbJDb9Vl2WlbsHTChd7NFH6YUW94bIATEzOxcLNiRjX1omeuhLB2rfbtPZsuequqp2XdrIloGIiIjckvVWILWxRIA8yLqaq3KXHfC9aeHgcm3ErHw071Rmk1irc5ZB1JY1kwa0SLGZhWd9O1GVtBM7d+5E797RFW46W/azrNsCla+qXdc2suXmrkRE5NY0agEtw0LQMiykSmGoZ0BilW7jWW9Wuy4hrtL3LrsPm2XA96BBG2EqMiP19G/lXmPMM5XbJNayae2+tEx5mr9lk9yyn22pLWHYIJhMJpw5c6bSTWfLfpal7aBBG0trrGST2rq2kS17iIiIiGrJnW7ZWS/aaLO4pKBDeHiPO26aa9kktuzijz5KL7S7PxwGqfIemYqWJrjdZrVlz1V1Ve2aboDraAxERERETpKammqzpYglPJW9nXenafzGY2tsFn+03Poz/F61Omo6zqkilnFDZTfAdXUMRERERA5mGSdkGV9kHYasVXcav2Xxx5rWYVlM0hJmAnMrGNT9S+V70FmPGwLKbFOSsRroWPFK3K6AgYiIiMjBLOOETCYjeoduqNZAbuvxRq18v7RZDftu6wBgs5FtZYO6K2MZNzRo0EYEBemhUgVWa1VuZ3LpQdULFy5E586d0bhxYwQHB2PgwIE4e/asTZuioiLExcUhICAAjRo1wpAhQ5CTk2PTRhRF9O/fHyqVCsHBwZg8eTJu3LjhyK9CRERkQxB0CAnpWOUwZD0zLDYh2WZcUdn90yyqMgDcug6NunRj29WTx5YOuC4y12gV76AgPUJCOuLp+9ZUvD9beuKth4tw6R6i77//HnFxcejcuTNu3LiBhIQEPP744zh9+jR8fX0BABMnTsT27dvx2WefQRAEjB8/HoMHD8aBAwcAADdv3kT//v2h1Wrxww8/ICsrC8OHD4eXlxcWLFjgzK9HRERurLoLTla00CQA24HXVZzaf6fPqc2NeYFbm80CqPGGtfbm0oEoJSXF5vm6desQHByM1NRUPProo8jPz8eHH36IzZs3o3fv3gCAtWvXQq/X48cff0TXrl3x9ddf4/Tp0/jmm2+g0Wjw0EMPYd68eZgyZQoSExOhVCqd8dWIiIiqraKwYr1/Wm0HmcqULiIZKD+PEFajZYDtWCbD+VwgLQ25ubkY+NStGXEq1UZs2bIFer3eqcHIpW+ZlZWfXzq4S61WAygdnW82mxEVFSW3ad26NXQ6HQ4ePAgAOHjwINq2bQuNRiO3iY6ORkFBAU6dOlXh51y/fh0FBQU2D6p91kvMExFR1VjWUXJ0GIoQVqN36AZ5zJFer4coiuXaWd/qi4iIQN++fQEAi8fFYPG4GJjNQN++fSt9vaO4dA+RtZKSEsTHx6Nbt2548MEHAQDZ2dlQKpXw9/e3aavRaJCdnS23sQ5DlvOWcxVZuHAh5syZY+dvQLdjPTPBXt2+RERkP5YB3NbjlSyDsjMz9yE5ObbCxRetb/Wl5r8MADYDycu+3lm9RHUmEMXFxeHkyZPYv39/rX/WtGnTMGnSJPl5QUEBwsLCav1z3Zn1zITn2h91WrcvERFVzLI5bNnxSoKgu+MijZZbfb+pOv71/NbU/aq83hHqRCAaP348tm3bhr179+Lee++Vj2u1WhQXFyMvL8+mlygnJwdarVZuc/jwYZv3s8xCs7Qpy9vbG97e3nb+FlQVQUF6aNQZzi6DiIjKCG4iuMR4pdri0mOIJEnC+PHjkZycjD179qBZs2Y25yMiIuDl5YXdu3fLx86ePQtRFBEZGQkAiIyMxIkTJ3D58mW5za5du+Dn54c2bdo45osQERHVUWVvkd3NeKWq7gPnDC7dQxQXF4fNmzfjiy++QOPGjeUxP4IgoGHDhhAEAWPGjMGkSZOgVqvh5+eH1157DZGRkejatSsA4PHHH0ebNm0wbNgwLFmyBNnZ2ZgxYwbi4uLYC0RERG6vsoBiGQxdnSn9mYf/befqHMelA9HKlSsBAD179rQ5vnbtWowcORIA8Pbbb8PDwwNDhgzB9evXER0djffee09u26BBA2zbtg3jxo1DZGQkfH19MWLECMydO9dRX4OqoXQBr6ovO09ERLXDejD07W6R9QxIRI4iH/+283pIjubSgUiSpDu28fHxwYoVK7BixYpK24SHh+Orr76yZ2lERET1XlUXaaxqeHJlLh2IiIiIqG5wxArXtcmlB1UTEREROQIDEREREbk93jIjIiIip+kZkIhzpixnl8EeIiIiIiIGIiIiInJ7DERERETk9hiIiIiIyO0xEBEREZHbYyAiIiIit8dARERERG6PgYiIiIjcHgMRERERuT0GIiIiInJ7DERERETk9hiIiIiIyO0xEBEREZHbYyAiIiIit8dARERERG6PgYiIiIjcnqezCyD3JooijEYjDAaDs0shIiI3xkBETiOKIpo318NsNgEAfJReEHxVTq6KiIjcEQMROY3RaITZbMKgQRsRFKRH79AN0KgFZ5dFRERuiGOIyOmCgvQICenIMERERE7DQERERERuj4GIiIiI3B4DEREREbk9Dqomp4sQVqNlQIizyyAiIjfGHiIiIiJyewxERERE5PYYiIiIiMjtMRARERGR22MgIiIiIrfHQERERERuj4GIiIiI3B4DEREREbk9BiIiIiJyewxERERE5Pa4dQc5hbhzIgxpmc4ug4iICAADETmBKIpo9dQKFBWb4aP0guCrcnZJRETk5hiIyOGMRiOKis1IGDYI7e4Ph0YtOLskIiJycxxDRE4Trg1iGCIiIpfAQERERERuj4GIiIiI3B4DEREREbk9BiJyKFEUYTAYnF0GERGRDc4yI4cRRRHNm+thNps43Z6IiFwKAxE5jNFohNlswqBBG/Fc+6OcYUZERC6Dt8zI4YKC9AxDRETkUhiIyCGsxw5FCKudXA0REZEttwpEK1asQNOmTeHj44MuXbrg8OHDzi7JLYiiiFYtmiM2NpZjh4iIyCW5zRiiTz75BJMmTcKqVavQpUsXLF26FNHR0Th79iyCg4OdXV69JIoijEYjDAYDt+ogIiKX5jaB6K233sJLL72EUaNGAQBWrVqF7du3Y82aNZg6daqTq6vbLMHHWm5uLgY+NQBFxWYAgI/Si2GIiIhcllsEouLiYqSmpmLatGnyMQ8PD0RFReHgwYPl2l+/fh3Xr1+Xn+fn5wMACgoKaqW+7OxsZGdn18p715qf1wIAjFdNeGHqFlw33yjXxNvLE3PGPAvBVwU/VUM0auiDa39eL9eOiIjc25/XiwEAhYWFdv231vJekiTdsa1bBCKj0YibN29Co9HYHNdoNDhz5ky59gsXLsScOXPKHQ8LC6u1Guuj6+YbmP3hp84ug4iI6ojHHnusVt73jz/+gCDc/g6FWwSi6po2bRomTZokPy8pKcGVK1cQEBAAhUJh988rKChAWFgYLl26BD8/P7u/P5XidXYMXmfH4HV2DF5nx6it6yxJEv744w+Ehobesa1bBKLAwEA0aNAAOTk5NsdzcnKg1WrLtff29oa3t7fNMX9//9osEQDg5+fHv3AOwOvsGLzOjsHr7Bi8zo5RG9f5Tj1DFm4x7V6pVCIiIgK7d++Wj5WUlGD37t2IjIx0YmVERETkCtyihwgAJk2ahBEjRqBTp054+OGHsXTpUly7dk2edUZERETuy20C0XPPPYfc3FzMmjUL2dnZeOihh5CSklJuoLUzeHt7Y/bs2eVu05F98To7Bq+zY/A6Owavs2O4wnVWSFWZi0ZERERUj7nFGCIiIiKi22EgIiIiIrfHQERERERuj4GIiIiI3B4DkQtYsWIFmjZtCh8fH3Tp0gWHDx92dkl1xsKFC9G5c2c0btwYwcHBGDhwIM6ePWvTpqioCHFxcQgICECjRo0wZMiQcot0iqKI/v37Q6VSITg4GJMnT8aNG+X3Z6NSixYtgkKhQHx8vHyM19k+fv31V8TGxiIgIAANGzZE27ZtcfToUfm8JEmYNWsWQkJC0LBhQ0RFRSEjI8PmPa5cuYKYmBj4+fnB398fY8aMQWFhoaO/isu6efMmZs6ciWbNmqFhw4a4//77MW/ePJv9rnidq2/v3r0YMGAAQkNDoVAosHXrVpvz9rqm6enp6NGjB3x8fBAWFoYlS5bY5wtI5FQff/yxpFQqpTVr1kinTp2SXnrpJcnf31/Kyclxdml1QnR0tLR27Vrp5MmT0rFjx6R+/fpJOp1OKiwslNu88sorUlhYmLR7927p6NGjUteuXaVHHnlEPn/jxg3pwQcflKKioqSffvpJ+uqrr6TAwEBp2rRpzvhKLu/w4cNS06ZNpXbt2kkTJkyQj/M6370rV65I4eHh0siRI6VDhw5J58+fl3bu3Cn973//k9ssWrRIEgRB2rp1q3T8+HHpqaeekpo1ayb9+eefcpu+fftK7du3l3788Udp3759UvPmzaXnn3/eGV/JJc2fP18KCAiQtm3bJl24cEH67LPPpEaNGknvvPOO3IbXufq++uorafr06dKWLVskAFJycrLNeXtc0/z8fEmj0UgxMTHSyZMnpY8++khq2LChtHr16ruun4HIyR5++GEpLi5Ofn7z5k0pNDRUWrhwoROrqrsuX74sAZC+//57SZIkKS8vT/Ly8pI+++wzuY3BYJAASAcPHpQkqfQvsYeHh5SdnS23WblypeTn5yddv37dsV/Axf3xxx9SixYtpF27dkmPPfaYHIh4ne1jypQpUvfu3Ss9X1JSImm1Wumf//ynfCwvL0/y9vaWPvroI0mSJOn06dMSAOnIkSNymx07dkgKhUL69ddfa6/4OqR///7S6NGjbY4NHjxYiomJkSSJ19keygYie13T9957T2rSpInN74wpU6ZIrVq1uuuaecvMiYqLi5GamoqoqCj5mIeHB6KionDw4EEnVlZ35efnAwDUajUAIDU1FWaz2eYat27dGjqdTr7GBw8eRNu2bW0W6YyOjkZBQQFOnTrlwOpdX1xcHPr3729zPQFeZ3v58ssv0alTJzzzzDMIDg5Ghw4d8MEHH8jnL1y4gOzsbJvrLAgCunTpYnOd/f390alTJ7lNVFQUPDw8cOjQIcd9GRf2yCOPYPfu3Th37hwA4Pjx49i/fz+eeOIJALzOtcFe1/TgwYN49NFHoVQq5TbR0dE4e/Ysrl69elc1us1K1a7IaDTi5s2b5VbL1mg0OHPmjJOqqrtKSkoQHx+Pbt264cEHHwQAZGdnQ6lUltucV6PRIDs7W25T0X8Dyzkq9fHHHyMtLQ1Hjhwpd47X2T7Onz+PlStXYtKkSUhISMCRI0fw97//HUqlEiNGjJCvU0XX0fo6BwcH25z39PSEWq3mdf7L1KlTUVBQgNatW6NBgwa4efMm5s+fj5iYGADgda4F9rqm2dnZaNasWbn3sJxr0qRJjWtkIKJ6Iy4uDidPnsT+/fudXUq9c+nSJUyYMAG7du2Cj4+Ps8upt0pKStCpUycsWLAAANChQwecPHkSq1atwogRI5xcXf3x6aefYtOmTdi8eTMeeOABHDt2DPHx8QgNDeV1dmO8ZeZEgYGBaNCgQbmZODk5OdBqtU6qqm4aP348tm3bhm+//Rb33nuvfFyr1aK4uBh5eXk27a2vsVarrfC/geUcld4Su3z5Mjp27AhPT094enri+++/x7Jly+Dp6QmNRsPrbAchISFo06aNzTG9Xg9RFAHcuk63+52h1Wpx+fJlm/M3btzAlStXeJ3/MnnyZEydOhVDhw5F27ZtMWzYMEycOBELFy4EwOtcG+x1TWvz9wgDkRMplUpERERg9+7d8rGSkhLs3r0bkZGRTqys7pAkCePHj0dycjL27NlTris1IiICXl5eNtf47NmzEEVRvsaRkZE4ceKEzV/EXbt2wc/Pr9w/Tu6qT58+OHHiBI4dOyY/OnXqhJiYGPlnXue7161bt3LLRpw7dw7h4eEAgGbNmkGr1dpc54KCAhw6dMjmOufl5SE1NVVus2fPHpSUlKBLly4O+Bauz2QywcPD9p+/Bg0aoKSkBACvc22w1zWNjIzE3r17YTab5Ta7du1Cq1at7up2GQBOu3e2jz/+WPL29pbWrVsnnT59Who7dqzk7+9vMxOHKjdu3DhJEATpu+++k7KysuSHyWSS27zyyiuSTqeT9uzZIx09elSKjIyUIiMj5fOW6eCPP/64dOzYMSklJUUKCgridPA7sJ5lJkm8zvZw+PBhydPTU5o/f76UkZEhbdq0SVKpVNLGjRvlNosWLZL8/f2lL774QkpPT5eefvrpCqcud+jQQTp06JC0f/9+qUWLFm49HbysESNGSPfcc4887X7Lli1SYGCg9MYbb8hteJ2r748//pB++ukn6aeffpIASG+99Zb0008/SZmZmZIk2eea5uXlSRqNRho2bJh08uRJ6eOPP5ZUKhWn3dcXy5cvl3Q6naRUKqWHH35Y+vHHH51dUp0BoMLH2rVr5TZ//vmn9Oqrr0pNmjSRVCqVNGjQICkrK8vmfS5evCg98cQTUsOGDaXAwEDpH//4h2Q2mx38beqWsoGI19k+/vvf/0oPPvig5O3tLbVu3Vp6//33bc6XlJRIM2fOlDQajeTt7S316dNHOnv2rE2b33//XXr++eelRo0aSX5+ftKoUaOkP/74w5Ffw6UVFBRIEyZMkHQ6neTj4yPdd9990vTp022mcvM6V9+3335b4e/jESNGSJJkv2t6/PhxqXv37pK3t7d0zz33SIsWLbJL/QpJslqak4iIiMgNcQwRERERuT0GIiIiInJ7DERERETk9hiIiIiIyO0xEBEREZHbYyAiIiIit8dARERERG6PgYiIiIjcHgMRERERuT0GIiKq927evIlHHnkEgwcPtjmen5+PsLAwTJ8+HcePH8fzzz+PsLAwNGzYEHq9Hu+8846TKiYiR2MgIqJ6r0GDBli3bh1SUlKwadMm+fhrr70GtVqN2bNnIzU1FcHBwdi4cSNOnTqF6dOnY9q0aXj33XedWDkROQr3MiMit7Fs2TIkJibi1KlTOHz4MJ555hkcOXIE7du3r7B9XFwcDAYD9uzZ4+BKicjRGIiIyG1IkoTevXujQYMGOHHiBF577TXMmDGj0vaxsbEoKirCf/7zHwdWSUTOwEBERG7lzJkz0Ov1aNu2LdLS0uDp6Vlhux9++AGPPfYYtm/fjscff9zBVRKRo3EMERG5lTVr1kClUuHChQv45ZdfKmxz8uRJPP3005g9ezbDEJGbYA8REbkNS6/P119/jaSkJADAN998A4VCIbc5ffo0evXqhRdffBHz5893VqlE5GDsISIit2AymTBy5EiMGzcOvXr1wocffojDhw9j1apVcptTp06hV69eGDFiBMMQkZthDxERuYUJEybgq6++wvHjx6FSqQAAq1evxuuvv44TJ06gsLAQvXv3RnR0NP75z3/Kr2vQoAGCgoKcVTYROQgDERHVe99//z369OmD7777Dt27d7c5Fx0djRs3bqB79+6YO3duudeGh4fj4sWLDqqUiJyFgYiIiIjcHscQERERkdtjICIiIiK3x0BEREREbo+BiIiIiNweAxERERG5PQYiIiIicnsMREREROT2GIiIiIjI7TEQERERkdtjICIiIiK3x0BEREREbu//A1lg1Sr57uocAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,_,_=plt.hist(theta0_G[:,1],bins=np.linspace(-3,1000,200),color=['blue'],alpha=0.5,label=\"MC, true\")\n",
    "_,_,_=plt.hist(theta_unknown_G[:,1],bins=np.linspace(-3,1000,200),color=['orange'],alpha=0.5,label=\"Data, true\")\n",
    "_,_,_=plt.hist(theta0_G[:,1],bins=np.linspace(-3,1000,200),weights=myweights[-1, 0, :],color='black',histtype=\"step\",label=\"OmniFolded\")\n",
    "plt.xlabel(\"X2\")\n",
    "plt.ylabel(\"events\")\n",
    "plt.legend(frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Draw the response matrix    \n",
    "# plt.figure(1)\n",
    "# G, xbins2d, ybins2d, patches2d = plt.hist2d(theta_unknown_S[:,0],theta_unknown_G[:,0], bins=np.linspace(-1,2,20), weights=myweights[0, -1, :], cmap='Blues')\n",
    "# plt.xlabel('True')\n",
    "# plt.ylabel('Reco')\n",
    "# plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Draw the response matrix    \n",
    "# plt.figure(1)\n",
    "# G, xbins2d, ybins2d, patches2d = plt.hist2d(theta_unknown_S[:,1],theta_unknown_G[:,1], bins=np.linspace(-1,2,20), weights=myweights[0, -1, :], cmap='Blues')\n",
    "# plt.xlabel('True')\n",
    "# plt.ylabel('Reco')\n",
    "# plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  },
  "notify_time": "0",
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}