diff --git a/atlas/.gitignore b/atlas/.gitignore
index 5bc5f59..97e35e8 100644
--- a/atlas/.gitignore
+++ b/atlas/.gitignore
@@ -212,3 +212,7 @@ __marimo__/
 ntuple_production/production_status.json
 # preprocess json
 preprocess_output.json
+# Dask reports
+*html
+# figures
+*png
diff --git a/atlas/analysis.ipynb b/atlas/analysis.ipynb
index af4440f..7525f23 100644
--- a/atlas/analysis.ipynb
+++ b/atlas/analysis.ipynb
@@ -7,11 +7,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# ! pip install --upgrade atlas_schema\n",
-    "# ! pip install --upgrade git+https://github.com/scikit-hep/mplhep.git\n",
-    "\n",
-    "# import importlib\n",
-    "# importlib.reload(utils)"
+    "! pip install --upgrade --quiet atlas_schema\n",
+    "! pip install --upgrade --quiet --pre mplhep"
    ]
   },
   {
@@ -27,18 +24,19 @@
     "import time\n",
     "\n",
     "import awkward as ak\n",
+    "import cloudpickle\n",
     "import dask\n",
-    "import vector\n",
     "import hist\n",
     "import matplotlib.pyplot as plt\n",
     "import mplhep\n",
     "import numpy as np\n",
     "import uproot\n",
+    "import vector\n",
     "\n",
     "from atlas_schema.schema import NtupleSchema\n",
     "from coffea import processor\n",
     "from coffea.nanoevents import NanoEventsFactory\n",
-    "from dask.distributed import Client, PipInstall\n",
+    "from dask.distributed import Client, PipInstall, performance_report\n",
     "\n",
     "\n",
     "import utils\n",
@@ -49,7 +47,9 @@
     "client = Client(\"tls://localhost:8786\")\n",
     "\n",
     "plugin = PipInstall(packages=[\"atlas_schema\"], pip_options=[\"--upgrade\"])\n",
-    "client.register_plugin(plugin)"
+    "client.register_plugin(plugin)\n",
+    "\n",
+    "cloudpickle.register_pickle_by_value(utils)"
    ]
   },
   {
@@ -74,6 +74,7 @@
     "\n",
     "# construct fileset\n",
     "fileset = {}\n",
+    "input_size_GB = 0\n",
     "for containers_for_category in dataset_info.values():\n",
     "    for container, metadata in containers_for_category.items():\n",
     "        if metadata[\"files_output\"] is None:\n",
@@ -82,13 +83,16 @@
     "\n",
     "        dsid, _, campaign = utils.dsid_rtag_campaign(container)\n",
     "\n",
-    "        # debugging shortcuts\n",
-    "        # if campaign not in [\"mc20a\", \"data15\", \"data16\"]: continue\n",
-    "        # if \"601352\" not in dsid: continue\n",
+    "        # debugging shortcuts, use one or both of the following to reduce workload\n",
+    "        if campaign not in [\"mc23a\", \"data22\"]: continue\n",
+    "        # if \"601229\" not in dsid: continue\n",
     "\n",
     "        weight_xs = utils.sample_xs(campaign, dsid)\n",
     "        lumi = utils.integrated_luminosity(campaign)\n",
     "        fileset[container] = {\"files\": dict((path, \"reco\") for path in metadata[\"files_output\"]), \"metadata\": {\"dsid\": dsid, \"campaign\": campaign, \"weight_xs\": weight_xs, \"lumi\": lumi}}\n",
+    "        input_size_GB += metadata[\"size_output_GB\"]\n",
+    "\n",
+    "print(f\"fileset has {len(fileset)} categories with {sum([len(f[\"files\"]) for f in fileset.values()])} files total, size is {input_size_GB:.2f} GB\")\n",
     "\n",
     "# minimal fileset for debugging\n",
     "# fileset = {\"mc20_13TeV.601352.PhPy8EG_tW_dyn_DR_incl_antitop.deriv.DAOD_PHYSLITE.e8547_s4231_r13144_p6697\": fileset[\"mc20_13TeV.601352.PhPy8EG_tW_dyn_DR_incl_antitop.deriv.DAOD_PHYSLITE.e8547_s4231_r13144_p6697\"]}\n",
@@ -148,16 +152,18 @@
    "outputs": [],
    "source": [
     "run = processor.Runner(\n",
-    "    executor = processor.DaskExecutor(client=client),\n",
-    "    # executor = processor.IterativeExecutor(),\n",
+    "    executor = processor.DaskExecutor(client=client, treereduction=4),\n",
+    "    # executor = processor.IterativeExecutor(),  # to run locally\n",
     "    schema=NtupleSchema,\n",
     "    savemetrics=True,\n",
-    "    chunksize=100_000,\n",
+    "    chunksize=50_000,\n",
     "    skipbadfiles=True,\n",
-    "    # maxchunks=1\n",
+    "    align_clusters=False,\n",
+    "    # maxchunks=1  # for debugging only\n",
     ")\n",
     "\n",
-    "preprocess_output = run.preprocess(fileset)\n",
+    "with performance_report(filename=\"preprocess.html\"):\n",
+    "    preprocess_output = run.preprocess(fileset)\n",
     "\n",
     "# write to disk\n",
     "with open(\"preprocess_output.json\", \"w\") as f:\n",
@@ -187,7 +193,7 @@
    "source": [
     "class Analysis(processor.ProcessorABC):\n",
     "    def __init__(self):\n",
-    "        self.h = hist.new.Regular(30, 0, 300, label=\"leading electron $p_T$\").\\\n",
+    "        self.h = hist.new.Regular(20, 0, 1_000, label=\"$m_{jj}$ [GeV]\").\\\n",
     "            StrCat([], name=\"dsid_and_campaign\", growth=True).\\\n",
     "            StrCat([], name=\"variation\", growth=True).\\\n",
     "            Weight()\n",
@@ -213,12 +219,14 @@
     "            sumw = None  # no normalization for data\n",
     "\n",
     "        for variation in events.systematic_names:\n",
-    "            if variation != \"NOSYS\" and \"EG_SCALE_ALL\" not in variation:\n",
+    "            if variation not in [\"NOSYS\"] + [name for name in events.systematic_names if \"JET_JER_Effective\" in name]:\n",
     "                continue\n",
     "\n",
     "            cut = events[variation][\"pass\"][\"ejets\"] == 1\n",
+    "            # TODO: remaining weights\n",
     "            weight = (events[variation][cut==1].weight.mc if events.metadata[\"dsid\"] != \"data\" else 1.0) * events.metadata[\"weight_xs\"] * events.metadata[\"lumi\"]\n",
-    "            self.h.fill(events[variation][cut==1].el.pt[:, 0] / 1_000, dsid_and_campaign=dsid_and_campaign, variation=variation, weight=weight)\n",
+    "            mjj = (events[variation][cut==1].jet[:, 0] + events[variation][cut==1].jet[:, 1]).mass\n",
+    "            self.h.fill(mjj / 1_000, dsid_and_campaign=dsid_and_campaign, variation=variation, weight=weight)\n",
     "\n",
     "        return {\n",
     "            \"hist\": self.h,\n",
@@ -239,10 +247,20 @@
     "            accumulator[\"hist\"][:, dsid_and_campaign, :] = np.stack([count_normalized, variance_normalized], axis=-1)\n",
     "\n",
     "\n",
-    "t0 = time.perf_counter()\n",
-    "out, report = run(preprocess_output, processor_instance=Analysis())\n",
+    "client.run_on_scheduler(utils.start_tracking)  # track worker count on scheduler\n",
+    "t0 = time.perf_counter()  # track walltime\n",
+    "\n",
+    "with performance_report(filename=\"process.html\"):\n",
+    "    out, report = run(preprocess_output, processor_instance=Analysis())\n",
+    "\n",
     "t1 = time.perf_counter()\n",
-    "report"
+    "worker_count_dict = client.run_on_scheduler(utils.stop_tracking)  # stop tracking, read out data, get average\n",
+    "nworker_avg = utils.get_avg_num_workers(worker_count_dict)\n",
+    "\n",
+    "print(f\"histogram size: {out[\"hist\"].view(True).nbytes / 1_000 / 1_000:.2f} GB\\n\")\n",
+    "\n",
+    "# shortened version of report, dropping extra columns\n",
+    "dict((k, v) for k, v in report.items() if k != \"columns\") | ({\"columns\": report[\"columns\"][0:10] + [\"...\"]})"
    ]
   },
   {
@@ -250,7 +268,10 @@
    "id": "8663e9ff-f8bb-43a0-8978-f2d430d2bbbd",
    "metadata": {},
    "source": [
-    "track XCache egress: [link](https://grafana.mwt2.org/d/EKefjM-Sz/af-network-200gbps-challenge?var-cnode=c111_af_uchicago_edu&var-cnode=c112_af_uchicago_edu&var-cnode=c113_af_uchicago_edu&var-cnode=c114_af_uchicago_edu&var-cnode=c115_af_uchicago_edu&viewPanel=195&kiosk=true&orgId=1&from=now-1h&to=now&timezone=browser&refresh=5s)"
+    "track XCache egress: [link](https://grafana.mwt2.org/d/EKefjM-Sz/af-network-200gbps-challenge?var-cnode=c111_af_uchicago_edu&var-cnode=c112_af_uchicago_edu&var-cnode=c113_af_uchicago_edu&var-cnode=c114_af_uchicago_edu&var-cnode=c115_af_uchicago_edu&viewPanel=195&kiosk=true&orgId=1&from=now-1h&to=now&timezone=browser&refresh=5s)\n",
+    "\n",
+    "**to-do for metrics:**\n",
+    "- data rate by tracking `bytesread` per chunk"
    ]
   },
   {
@@ -260,13 +281,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(f\"data read: {report[\"bytesread\"] / 1000**3:.2f} GB in {report[\"chunks\"]} chunks\")\n",
+    "print(f\"walltime: {t1 - t0:.2f} sec ({(t1 - t0) / 60:.2f} min)\")\n",
+    "print(f\"average worker count: {nworker_avg:.1f}\")\n",
+    "print(f\"number of events processed: {report[\"entries\"]:,}\\n\")\n",
+    "\n",
+    "print(f\"data read: {report[\"bytesread\"] / 1000**3:.2f} GB in {report[\"chunks\"]} chunks (average {report[\"bytesread\"] / 1000**3 / report[\"chunks\"]:.2f} GB per chunk)\")\n",
+    "print(f\"average total data rate: {report[\"bytesread\"] / 1000**3 * 8 / (t1 - t0):.2f} Gbps\")\n",
+    "print(f\"fraction of input files read: {report[\"bytesread\"] / 1000**3 / input_size_GB:.1%}\")\n",
+    "print(f\"number of branches read: {len(report[\"columns\"])}\\n\")\n",
+    "\n",
+    "print(f\"worker-average event rate using \\'processtime\\': {report[\"entries\"] / 1000 / report[\"processtime\"]:.2f} kHz\")\n",
+    "print(f\"worker-average data rate using \\'processtime\\': {report[\"bytesread\"] / 1000**3 * 8 / report[\"processtime\"]:.2f} Gbps\\n\")\n",
     "\n",
-    "print(f\"core-average event rate using \\'processtime\\': {report[\"entries\"] / 1000 / report[\"processtime\"]:.2f} kHz\")\n",
-    "print(f\"core-average data rate using \\'processtime\\': {report[\"bytesread\"] / 1000**3 * 8 / report[\"processtime\"]:.2f} Gbps\")\n",
+    "print(f\"average event rate using walltime and time-averaged worker count: {report[\"entries\"] / 1000 / (t1 - t0) / nworker_avg:.2f} kHz\")\n",
+    "print(f\"average data rate using walltime and time-averaged worker count: {report[\"bytesread\"] / 1000**3 * 8 / (t1 - t0) / nworker_avg:.2f} Gbps\\n\")\n",
     "\n",
-    "print(f\"average event rate using walltime: {report[\"entries\"] / 1000 / (t1 - t0):.2f} kHz\")\n",
-    "print(f\"average data rate using walltime: {report[\"bytesread\"] / 1000**3 * 8 / (t1 - t0):.2f} Gbps\")"
+    "print(f\"fraction of time spent in processing: {report[\"processtime\"] / ((t1 - t0) * nworker_avg):.1%}\")\n",
+    "print(f\"average process task length: {report[\"processtime\"] / report[\"chunks\"]:.1f} sec\")\n",
+    "\n",
+    "_ = utils.plot_worker_count(worker_count_dict)"
    ]
   },
   {
@@ -285,7 +318,7 @@
     "\n",
     "    dsids = sorted(set(dsids))\n",
     "    dsids_in_hist = [dc for dc in out[\"hist\"].axes[1] if dc.split(\"_\")[0] in dsids]\n",
-    "    print(f\"{key}:\\n  - expect {dsids}\\n  - have {dsids_in_hist}\")\n",
+    "    # print(f\"{key}:\\n  - expect {dsids}\\n  - have {dsids_in_hist}\")\n",
     "\n",
     "    if key in [\"data\", \"ttbar_H7\", \"ttbar_hdamp\", \"ttbar_pthard\", \"Wt_DS\", \"Wt_H7\", \"Wt_pthard\"] or len(dsids_in_hist) == 0:\n",
     "        continue  # data drawn separately, skip MC modeling variations and skip empty categories\n",
@@ -293,8 +326,14 @@
     "    mc_stack.append(out[\"hist\"][:, :, \"NOSYS\"].integrate(\"dsid_and_campaign\", dsids_in_hist))\n",
     "    labels.append(key)\n",
     "\n",
-    "fig, ax1, ax2 = mplhep.data_model(\n",
-    "    data_hist=out[\"hist\"].integrate(\"dsid_and_campaign\", [dc for dc in out[\"hist\"].axes[1] if \"data\" in dc])[:, \"NOSYS\"],\n",
+    "try:\n",
+    "    data_hist = out[\"hist\"].integrate(\"dsid_and_campaign\", [dc for dc in out[\"hist\"].axes[1] if \"data\" in dc])[:, \"NOSYS\"]\n",
+    "except ValueError:\n",
+    "    print(\"falling back to plotting first entry of categorical axes as \\\"data\\\"\")\n",
+    "    data_hist = out[\"hist\"][:, 0, 0]\n",
+    "\n",
+    "fig, ax1, ax2 = mplhep.comp.data_model(\n",
+    "    data_hist=data_hist,\n",
     "    stacked_components=mc_stack,\n",
     "    stacked_labels=labels,\n",
     "    # https://scikit-hep.org/mplhep/gallery/model_with_stacked_and_unstacked_histograms_components/\n",
@@ -309,7 +348,7 @@
     "ax2.set_ylim([0.5, 1.5])\n",
     "\n",
     "# compare to e.g. https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/HDBS-2020-11/fig_02a.png\n",
-    "fig.savefig(\"el_pt.png\")"
+    "fig.savefig(\"mjj.png\")"
    ]
   },
   {
@@ -326,9 +365,7 @@
     "    f.write(json.dumps(out[\"hist\"], default=uhi.io.json.default).encode(\"utf-8\"))\n",
     "\n",
     "with gzip.open(\"hist.json.gz\") as f:\n",
-    "    h = hist.Hist(json.loads(f.read(), object_hook=uhi.io.json.object_hook))\n",
-    "\n",
-    "h[:, \"data_data15\", \"NOSYS\"]"
+    "    h = hist.Hist(json.loads(f.read(), object_hook=uhi.io.json.object_hook))"
    ]
   }
  ],
diff --git a/atlas/ntuple_production/ntuple_summary.ipynb b/atlas/ntuple_production/ntuple_summary.ipynb
index 59ab0f5..7914bbc 100644
--- a/atlas/ntuple_production/ntuple_summary.ipynb
+++ b/atlas/ntuple_production/ntuple_summary.ipynb
@@ -18,7 +18,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "fname = \"ntuple_metadata.json.gz\"\n",
+    "fname = \"file_metadata.json.gz\"\n",
     "\n",
     "with gzip.open(fname) as f:\n",
     "    content = json.loads(f.read().decode())"
@@ -35,12 +35,12 @@
      "output_type": "stream",
      "text": [
       "PHYSLITE INPUT\n",
-      "  nfiles:    876,602\n",
-      "  size [GB]: 565,834\n",
-      "  nevents:   59,236,115,268\n",
+      "  nfiles:    877,199\n",
+      "  size [GB]: 566,120\n",
+      "  nevents:   59,251,746,268\n",
       "NTUPLE OUTPUT\n",
-      "  nfiles:    8,728\n",
-      "  size [GB]: 19,629\n"
+      "  nfiles:    9,287\n",
+      "  size [GB]: 21,254\n"
      ]
     }
    ],
@@ -54,6 +54,8 @@
     "\n",
     "sizes_output_GB = []\n",
     "avg_sizes_output_GB = []\n",
+    "nfiles_output = []\n",
+    "\n",
     "\n",
     "for category_info in content.values():\n",
     "    for dataset_info in category_info.values():\n",
@@ -66,6 +68,7 @@
     "            sum_size_output_GB += dataset_info[\"size_output_GB\"]\n",
     "            sizes_output_GB.append(dataset_info[\"size_output_GB\"])\n",
     "            avg_sizes_output_GB.append(dataset_info[\"size_output_GB\"] / dataset_info[\"nfiles_output\"])\n",
+    "            nfiles_output.append(dataset_info[\"nfiles_output\"])\n",
     "\n",
     "print(\"PHYSLITE INPUT\")\n",
     "print(f\"  nfiles:    {sum_nfiles_input:,}\")\n",
@@ -85,9 +88,9 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOsAAAGbCAYAAACVhhQiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAg+RJREFUeJzs3X1cVGX+//H3yM0IBigqDBQqFWbeZlqmVlqJZnmX+81M19Wtbz9Ls9DMMrvBNiFtM1otS9dVysy+bdnW7nqDpZRr5i15m1aSNy1EGYI3CMpcvz9cZh0BGWBgZuD1fDzOQ+ec61znc47juWY+c53rshhjjAAAAAAAAAB4XANPBwAAAAAAAADgHJJ1AAAAAAAAgJcgWQcAAAAAAAB4CZJ1AAAAAAAAgJcgWQcAAAAAAAB4CZJ1AAAAAAAAgJcgWQcAAAAAAAB4CZJ1AAAAAAAAgJcgWQcAAAAAAAB4CZJ1AAAAAAAAgJcgWQcAAAAAtezzzz/XwIEDFR0dLYvFoo8++shpuzFGiYmJio6OVlBQkHr37q3du3c7lSksLNSECRPUrFkzNWrUSIMGDdKRI0ecyuTm5mrUqFEKCwtTWFiYRo0apWPHjtXw2QEAqoNkHQAAAADUspMnT6pTp06aO3dumdtnzZql2bNna+7cudq8ebNsNpvi4+N1/PhxR5mEhAQtX75cy5Yt0/r163XixAkNGDBAxcXFjjIjRoxQRkaGVq5cqZUrVyojI0OjRo2q8fMDAFSdxRhjPB0EAAAAANRXFotFy5cv15AhQySd61UXHR2thIQEPfHEE5LO9aKLjIzUzJkzNXbsWOXl5al58+Z6++23dc8990iS/v3vfysmJkb//Oc/1a9fP+3du1dt27bVxo0b1a1bN0nSxo0b1b17d33zzTe66qqrPHK+AICL8/d0AFVht9v173//WyEhIbJYLJ4OBwDgRsYYHT9+XNHR0WrQwPMdwGlzAKDu8rY2p0RmZqays7PVt29fxzqr1apevXppw4YNGjt2rLZu3aozZ844lYmOjlb79u21YcMG9evXT19++aXCwsIciTpJuuGGGxQWFqYNGzaUmawrLCxUYWGh47Xdbtevv/6qpk2b0g4CqJKauNeePn1aRUVFbqkrMDBQDRs2dEtd7uKTybqSX4wAAHXX4cOHddlll3k6DNocAKgHvKXNKZGdnS1JioyMdFofGRmpgwcPOsoEBgaqSZMmpcqU7J+dna2IiIhS9UdERDjKXCg5OVnTp0+v9jkAwIXcda89ffq0Ylteouyc4ooLu8BmsykzM9OrEnY+mawLCQmRdO4fOjQ01MPRAADcKT8/XzExMY57vafR5gBA3eVtbc6FLuzJZoypsHfbhWXKKn+xeqZOnapJkyY5Xufl5alFixa0gwCqzN332qKiImXnFCtza0uFhlSvp17+cbtiuxxUUVGR7ybr5s2bp3nz5umHH36QJLVr107PPvus+vfvL+ncTX/69OmaP3++cnNz1a1bN7322mtq166do47CwkJNnjxZ7777rgoKCnTbbbfp9ddfr1R2taRhCQ0NpcEAgDrKWx61oc0BgLrPW9qcEjabTdK5nnFRUVGO9Tk5OY7edjabTUVFRcrNzXXqXZeTk6MePXo4yvz000+l6v/5559L9dorYbVaZbVaS62nHQRQXe6+14aGNKh2ss5bVeqsLrvsMr344ovasmWLtmzZoltvvVWDBw92TCHurhmLAAAAAKC+io2Nlc1mU1pammNdUVGR0tPTHYm4Ll26KCAgwKlMVlaWdu3a5SjTvXt35eXladOmTY4yX331lfLy8hxlAMBXFRu7WxZvVKmedQMHDnR6PWPGDM2bN08bN25U27ZtlZKSomnTpmno0KGSpNTUVEVGRmrp0qWOGYsWLlyot99+W3369JEkLVmyRDExMVqzZo369evnptMCAAAAAO914sQJfffdd47XmZmZysjIUHh4uFq0aKGEhAQlJSUpLi5OcXFxSkpKUnBwsEaMGCFJCgsL0/3336/HHntMTZs2VXh4uCZPnqwOHTo4vmtdffXVuv322/XAAw/ozTfflCT9v//3/zRgwABmggXg8+wysstUuw5vVOUx64qLi/X+++/r5MmT6t69u9tmLCrLhTMS5efnVzVsAAAAAPC4LVu26JZbbnG8LhknbvTo0Vq8eLGmTJmigoICjRs3zjHE0OrVq53GfHrllVfk7++vYcOGOYYYWrx4sfz8/Bxl3nnnHT3yyCOO72CDBg3S3Llza+ksAaDm2GVXdfvFVb+GmlHpZN3OnTvVvXt3nT59WpdccomWL1+utm3basOGDZKqP2NRWZiRCAAAAEBd0rt3bxlTfo8Oi8WixMREJSYmllumYcOGmjNnjubMmVNumfDwcC1ZsqQ6oQIAalmlR+K76qqrlJGRoY0bN+qhhx7S6NGjtWfPHsd2d8xYdKGpU6cqLy/PsRw+fLiyYQMAAAAAAKCOKDbGLYs3qnTPusDAQF155ZWSpK5du2rz5s169dVX9cQTT0iq/oxFZSlvRiIAAAAAAADUP3V5zLpqz3FrjFFhYaHbZiwCAAAAAAAALsYuo+JqLt6arKtUz7qnnnpK/fv3V0xMjI4fP65ly5Zp3bp1WrlypSwWi1tmLAIAAAAAAADqq0ol63766SeNGjVKWVlZCgsLU8eOHbVy5UrFx8dLkttmLAIAAAAAAADKU5cfg7WYi01B5KXy8/MVFhamvLw8hYaGejocAIAbeds93tviAQC4D/f4inGNAFSXu+8jJfXt3xupkJDqje52/Lhdra/+yevucZWeYAIAAAAAAADwJPt/lurW4Y3qZbLOGKOCM8VurTMowE8Wi8WtdQIA6oaqtju0LQAAAED9Uy+TdQVnitX22VVurXPP8/0UHFgvLycAoAJVbXdoWwAAAICylczoWt06vBHfAAAAAAAAAOBTis25pbp1eKN6n6zb8nQfBQdWbSbaU0XF6vrCGjdHBACoyypqd2hbAAAAgIoxZl0dFhzoxyNGAIBaQ7sDAAAA4GL4tgAAAAAAAACfYpdFxareZGz2au5fU0jWAQAAAAAAwKfYzbmlunV4I5J1AAAAAAAA8CnFbuhZV939a0oDTwcAAAAAAAAA4Bx61gEAAAAAAMCn1OWedSTrAAAAAAAA4FPsxiK7qeYEE9Xcv6aQrAMAAAAAAIBPqcs96xizDgAAAAAAAPAS9KwDAAAAAACATylWAxVXsw9asZticTeSdQAAAAAAAPApxg1j1hnGrAMAAAAAAACqjzHrAAAAAAAAANQ4knUAAAAAAADwKcWmgVuWyjh79qyefvppxcbGKigoSJdffrmef/552e12RxljjBITExUdHa2goCD17t1bu3fvrtRxSNYBAAAAAADAp9hlkV0NqrlU7jHYmTNn6o033tDcuXO1d+9ezZo1Sy+99JLmzJnjKDNr1izNnj1bc+fO1ebNm2Wz2RQfH6/jx4+7fBzGrAMAAAAAAIBP8cSYdV9++aUGDx6sO++8U5LUqlUrvfvuu9qyZYukc73qUlJSNG3aNA0dOlSSlJqaqsjISC1dulRjx4516Tgk6wAAAAAAQL0T3+DuCsuk2d+vhUjgafn5+U6vrVarrFZrqXI33nij3njjDe3fv1+tW7fW119/rfXr1yslJUWSlJmZqezsbPXt29eprl69emnDhg0k6wAAAAAAAFA3VWXMudJ1GElSTEyM0/rnnntOiYmJpco/8cQTysvLU5s2beTn56fi4mLNmDFD9957ryQpOztbkhQZGem0X2RkpA4ePOhyXCTrAAAAAAAA4FPOjVlXvcdgS/Y/fPiwQkNDHevL6lUnSe+9956WLFmipUuXql27dsrIyFBCQoKio6M1evRoRzmLxTkuY0ypdRdDsg4AAAAAAAA+xa4GKq7mvKl2netZFxoa6pSsK8/jjz+uJ598UsOHD5ckdejQQQcPHlRycrJGjx4tm80m6VwPu6ioKMd+OTk5pXrbXQyzwQIAAAAAAAAVOHXqlBo0cE6l+fn5yW63S5JiY2Nls9mUlpbm2F5UVKT09HT16NHD5ePQsw4AAAAAAAA+xZ1j1rlq4MCBmjFjhlq0aKF27dpp+/btmj17tu677z5J5x5/TUhIUFJSkuLi4hQXF6ekpCQFBwdrxIgRLh+HZB0AAAAAAAB8il0NZHfTY7CumjNnjp555hmNGzdOOTk5io6O1tixY/Xss886ykyZMkUFBQUaN26ccnNz1a1bN61evVohISEuH4dkHQAAAAAAAHxKsbGo2FRvgonK7h8SEqKUlBSlpKSUW8ZisSgxMbHM2WRdxZh1AAAAAAAAgJegZx0AAAAAAAB8SrEbZoMtruRjsLWFZB0AAAAAAAB8it00kL2aE0zYKznBRG3hMVgAgM86e/asnn76acXGxiooKEiXX365nn/+ecfU6ZJkjFFiYqKio6MVFBSk3r17a/fu3R6MGgAAAEB1lfSsq+7ijbwzKgAAXDBz5ky98cYbmjt3rvbu3atZs2bppZde0pw5cxxlZs2apdmzZ2vu3LnavHmzbDab4uPjdfz4cQ9GDgAAAABl4zFYAIDP+vLLLzV48GDdeeedkqRWrVrp3Xff1ZYtWySd61WXkpKiadOmaejQoZKk1NRURUZGaunSpRo7dqzHYgcAAABQdXZVfjbXsurwRvSsAwD4rBtvvFGffvqp9u/fL0n6+uuvtX79et1xxx2SpMzMTGVnZ6tv376OfaxWq3r16qUNGzaUWWdhYaHy8/OdFgAAAADexa4Gblm8ET3rAAA+64knnlBeXp7atGkjPz8/FRcXa8aMGbr33nslSdnZ2ZKkyMhIp/0iIyN18ODBMutMTk7W9OnTazZwAAAAANVSbBqouJoTTFR3/5rinVEBAOCC9957T0uWLNHSpUu1bds2paam6o9//KNSU1Odylkszt3jjTGl1pWYOnWq8vLyHMvhw4drLH4AAAAAuBA96wAAPuvxxx/Xk08+qeHDh0uSOnTooIMHDyo5OVmjR4+WzWaTdK6HXVRUlGO/nJycUr3tSlitVlmt1poPHgAAAB6VZn/f0yGgGuyyyK7qjllXvf1rCj3rAAA+69SpU2rQwLkp8/Pzk91+bqjY2NhY2Ww2paWlObYXFRUpPT1dPXr0qNVYAQAAALhPyWOw1V28ET3rAAA+a+DAgZoxY4ZatGihdu3aafv27Zo9e7buu+8+Secef01ISFBSUpLi4uIUFxenpKQkBQcHa8SIER6OHgAAAEBVFauBiqvZB626+9cUknUAAJ81Z84cPfPMMxo3bpxycnIUHR2tsWPH6tlnn3WUmTJligoKCjRu3Djl5uaqW7duWr16tUJCQjwYOQAAAACUjWQdAMBnhYSEKCUlRSkpKeWWsVgsSkxMVGJiYq3FBQAAAKBm2Y1FdlPNMeuquX9NIVkHAAAAAAAAn2J3w2Owdh6DBQAAAAAAAKrPbhrIXs0JIqq7f02pVFTJycm67rrrFBISooiICA0ZMkT79u1zKjNmzBhZLBan5YYbbnAqU1hYqAkTJqhZs2Zq1KiRBg0apCNHjlT/bAAAAAAAAAAfVqlkXXp6usaPH6+NGzcqLS1NZ8+eVd++fXXy5EmncrfffruysrIcyz//+U+n7QkJCVq+fLmWLVum9evX68SJExowYICKi4urf0YAAAAAAACo04plccvijSr1GOzKlSudXi9atEgRERHaunWrbr75Zsd6q9Uqm81WZh15eXlauHCh3n77bfXp00eStGTJEsXExGjNmjXq169fZc8BAAAAAAAA9QiPwZYjLy9PkhQeHu60ft26dYqIiFDr1q31wAMPKCcnx7Ft69atOnPmjPr27etYFx0drfbt22vDhg1lHqewsFD5+flOCwAAAAAAAOqnYrmjd513qnKyzhijSZMm6cYbb1T79u0d6/v376933nlHn332mV5++WVt3rxZt956qwoLCyVJ2dnZCgwMVJMmTZzqi4yMVHZ2dpnHSk5OVlhYmGOJiYmpatgAAAAAAACA16rybLAPP/ywduzYofXr1zutv+eeexx/b9++vbp27aqWLVvqH//4h4YOHVpufcYYWSxlPys8depUTZo0yfE6Pz+fhB0AAAAAAEA9VZcfg61Ssm7ChAn6+OOP9fnnn+uyyy67aNmoqCi1bNlS3377rSTJZrOpqKhIubm5Tr3rcnJy1KNHjzLrsFqtslqtVQkVAAAAAAAAdUyxaaDiaibbqrt/TalUVMYYPfzww/rwww/12WefKTY2tsJ9jh49qsOHDysqKkqS1KVLFwUEBCgtLc1RJisrS7t27So3WQcAAAAA9cnZs2f19NNPKzY2VkFBQbr88sv1/PPPy263O8oYY5SYmKjo6GgFBQWpd+/e2r17t1M9hYWFmjBhgpo1a6ZGjRpp0KBBOnLkSG2fDgC4nZFF9mouxktng61Usm78+PFasmSJli5dqpCQEGVnZys7O1sFBQWSpBMnTmjy5Mn68ssv9cMPP2jdunUaOHCgmjVrprvuukuSFBYWpvvvv1+PPfaYPv30U23fvl2//e1v1aFDB8fssAAAAABQn82cOVNvvPGG5s6dq71792rWrFl66aWXNGfOHEeZWbNmafbs2Zo7d642b94sm82m+Ph4HT9+3FEmISFBy5cv17Jly7R+/XqdOHFCAwYMUHGxtw6rDgCo1GOw8+bNkyT17t3baf2iRYs0ZswY+fn5aefOnXrrrbd07NgxRUVF6ZZbbtF7772nkJAQR/lXXnlF/v7+GjZsmAoKCnTbbbdp8eLF8vPzq/4ZAQAAAICP+/LLLzV48GDdeeedkqRWrVrp3Xff1ZYtWySd61WXkpKiadOmOcYGT01NVWRkpJYuXaqxY8cqLy9PCxcu1Ntvv+3oGLFkyRLFxMRozZo16tevX6njFhYWOiYHlM6NFw4A3qguPwZbqWSdMeai24OCgrRq1aoK62nYsKHmzJnj9KsQAAAAAOCcG2+8UW+88Yb279+v1q1b6+uvv9b69euVkpIiScrMzFR2drb69u3r2MdqtapXr17asGGDxo4dq61bt+rMmTNOZaKjo9W+fXtt2LChzGRdcnKypk+fXuPnh7LFN7jbpXJp9vdrOBLA+9mNRXZTvcdYq7t/TanybLAAAAAAgJrxxBNPKC8vT23atJGfn5+Ki4s1Y8YM3XvvvZKk7OxsSVJkZKTTfpGRkTp48KCjTGBgoNPEfiVlSva/0NSpUzVp0iTH6/z8fMXExLjtvADAXYrVQMWVG92tzDq8kXdGBQAAAAD12HvvvecYL3zbtm1KTU3VH//4R6WmpjqVs1ice4UYY0qtu9DFylitVoWGhjotAIBzWrVqJYvFUmoZP368JNcm/nEFyToAAAAA8DKPP/64nnzySQ0fPlwdOnTQqFGjNHHiRCUnJ0uSbDabJJXqIZeTk+PobWez2VRUVKTc3NxyywCAryp5DLa6S2Vs3rxZWVlZjiUtLU2SdPfd5x5hd2XiH1eQrAMAAAAAL3Pq1Ck1aOD8dc3Pz092u12SFBsbK5vN5viiKElFRUVKT09Xjx49JEldunRRQECAU5msrCzt2rXLUQYAfJVdDdyyVEbz5s1ls9kcy9///nddccUV6tWrV6mJf9q3b6/U1FSdOnVKS5curdRxGLMOAAAAALzMwIEDNWPGDLVo0ULt2rXT9u3bNXv2bN13332Szj3+mpCQoKSkJMXFxSkuLk5JSUkKDg7WiBEjJElhYWG6//779dhjj6lp06YKDw/X5MmT1aFDB8fssACA0jNfW61WWa3Wi+5TVFSkJUuWaNKkSbJYLDpw4ECFE/+4imQdAAAAAHiZOXPm6JlnntG4ceOUk5Oj6OhojR07Vs8++6yjzJQpU1RQUKBx48YpNzdX3bp10+rVqxUSEuIo88orr8jf31/Dhg1TQUGBbrvtNi1evFh+fn6eOC0AcJtiY1FxNWdzLdn/wol0nnvuOSUmJl50348++kjHjh3TmDFjJLk28Y+rSNYBAAAAgJcJCQlRSkqKUlJSyi1jsViUmJh40S+UDRs21Jw5czRnzhz3BwkAHlSVMefKqkOSDh8+7DShTkW96iRp4cKF6t+/v6Kjo53WV2XinwuRrAMAAAAAAIBPMaaB7KZ6UzGY/+xf2dmvDx48qDVr1ujDDz90rDt/4p+oqCjH+qpM6sMEEwAAAAAAAICLFi1apIiICN15552Oda5M/OMqetYBAAAAAADApxTLomJVc8y6Kuxvt9u1aNEijR49Wv7+/02ruTLxj6tI1gEAAAAAAMCn2I3cMGZd5fdZs2aNDh065Jid+3yuTPzjCpJ1AAAAAAAA8Cl2N4xZV5X9+/btK2PKzvK5MvGPK0jWAQAAAEA5wsPDK1XeYrFo27ZtatmyZQ1FBACo60jWAQAAAEA5jh07ppSUFIWFhVVY1hijcePGqbi4uBYiA4D6zS6L7NUcs666+9cUknUAAAAAcBHDhw9XRESES2UnTJhQw9EAACSp2FhUXM0x66q7f00hWQcAAAAA5bDb7ZUqf/z48RqKBABwPk+NWVcbvDMqAAAAAAAAoB6iZx0AAAAAuODo0aNq2rSpJOnw4cNasGCBCgoKNGjQIN10000ejg51QZr9fU+HUK/EN7i7wjL8m3gvuyyyV/MxVm8ds46edQAAAABwETt37lSrVq0UERGhNm3aKCMjQ9ddd51eeeUVzZ8/X7fccos++ugjT4cJAPWK+c8EE9VZDMk6AAAAAPA9U6ZMUYcOHZSenq7evXtrwIABuuOOO5SXl6fc3FyNHTtWL774oqfDBIB6xW4sblm8EY/BAgAAAMBFbN68WZ999pk6duyoa665RvPnz9e4cePUoMG5vg8TJkzQDTfc4OEoAQB1Bck6AAAAALiIX3/9VTabTZJ0ySWXqFGjRgoPD3dsb9KkCbPAAkAtq8uzwZKsAwAAAIAKWCyWi74GANQudzzGymOwAAAAAOCjxowZI6vVKkk6ffq0HnzwQTVq1EiSVFhY6MnQAKBeKpkkorp1eCOSdQAAAABwEaNHj3Z6/dvf/rZUmd/97ne1FQ4AoI4jWQcAAAAAF7Fo0SJPhwAAuACPwQIAAAAAAABegmQdAAAAANRTWVlZmjt3rmbMmCFJuvHGG3Xq1CnHdj8/P3300Ue69NJLPRUiANQ7dTlZ551z1AIAAACAl3j99dd17Ngxx+uvv/5aN910kwYPHqzBgwfLz89Pr7zyiucCBADUKfSsAwAAAICL+OSTT/TSSy85rXv00Ud1+eWXS5JuuOEGTZo0SX/84x89ER4A1Et1uWcdyToAAAAAuIgffvhBV1xxheN1fHy8GjVq5Hh91VVXKTMz0xOhAUC9ZSTZVb1km3FPKG5Hsg4AAAAALuLs2bPKy8tzvP7www+dtufm5qpBA0YYAoDaVJd71tGiAAAAAMBFXHXVVdqwYUO527/44gu1bt26FiMCANRlJOsAAAAA4CKGDx+uZ599Vjt27Ci17euvv9b06dN17733eiAyAKi/SnrWVXfxRjwGCwAAAAAXkZCQoL///e/q0qWL4uPjddVVV8liseibb75RWlqaunfvroSEBE+HCeA/+gYMd6lcmv39Go4ENakuPwZLsg4AAAAALiIgIEBpaWmaPXu2li1bpnXr1kmS4uLi9Ic//EETJ05UQECAZ4MEgHqGZB0AAAAA1GOBgYF68skn9eSTT3o6FABAHUeyDgAAAAAAAD7FGItMNXvGVXf/msIEEwAAAABQjvDwcP3yyy8ul2/RooUOHjxYgxEBACTJLotbFm9EzzoAAAAAKMexY8e0YsUKhYWFuVT+6NGjKi4uruGoAACMWQcAAAAA9dTo0aM9HQIAwEv8+OOPeuKJJ7RixQoVFBSodevWWrhwobp06SJJMsZo+vTpmj9/vnJzc9WtWze99tprateuncvHIFkHAAAAAOWw2+2eDgEAUAZPjFmXm5urnj176pZbbtGKFSsUERGh77//Xo0bN3aUmTVrlmbPnq3FixerdevWeuGFFxQfH699+/YpJCTEpeOQrAMAAAAAAIBP8cRjsDNnzlRMTIwWLVrkWNeqVSvH340xSklJ0bRp0zR06FBJUmpqqiIjI7V06VKNHTvWpeMwwQQAAAAAAAB8SknPuuoukpSfn++0FBYWlnnMjz/+WF27dtXdd9+tiIgIde7cWQsWLHBsz8zMVHZ2tvr27etYZ7Va1atXL23YsMHlcyNZBwAAAAAAgHorJiZGYWFhjiU5ObnMcgcOHNC8efMUFxenVatW6cEHH9Qjjzyit956S5KUnZ0tSYqMjHTaLzIy0rHNFZVK1iUnJ+u6665TSEiIIiIiNGTIEO3bt8+pjDFGiYmJio6OVlBQkHr37q3du3c7lSksLNSECRPUrFkzNWrUSIMGDdKRI0cqEwoAAAAAAADqKfOfx2Crs5T0rDt8+LDy8vIcy9SpU8s8pt1u17XXXqukpCR17txZY8eO1QMPPKB58+Y5lbNYnB+vNcaUWncxlUrWpaena/z48dq4caPS0tJ09uxZ9e3bVydPnnSUKRlIb+7cudq8ebNsNpvi4+N1/PhxR5mEhAQtX75cy5Yt0/r163XixAkNGDCAKc4BAAAAeKWzZ88qNTW1Uj0jAAA1x0gypprLf+oKDQ11WqxWa5nHjIqKUtu2bZ3WXX311Tp06JAkyWazSVKptiInJ6dUb7uLqVSybuXKlRozZozatWunTp06adGiRTp06JC2bt0qqfRAeu3bt1dqaqpOnTqlpUuXSpLy8vK0cOFCvfzyy+rTp486d+6sJUuWaOfOnVqzZk1lwgEAAACAWuHv76+HHnqo3HGMAAC1yy6LW5bK6NmzZ6knTPfv36+WLVtKkmJjY2Wz2ZSWlubYXlRUpPT0dPXo0cPl41RrzLq8vDxJUnh4uCTXBtLbunWrzpw541QmOjpa7du3L3ewvcLCwlKD/QEAAABAberWrZsyMjI8HQYAwEMmTpyojRs3KikpSd99952WLl2q+fPna/z48ZLOPf6akJCgpKQkLV++XLt27dKYMWMUHBysESNGuHwc/6oGaIzRpEmTdOONN6p9+/aSLj6Q3sGDBx1lAgMD1aRJk1JlyutSnpycrOnTp1c1VAAAAACotnHjxmnSpEk6fPiwunTpokaNGjlt79ixo4ciA4D65/zZXKtTR2Vcd911Wr58uaZOnarnn39esbGxSklJ0ciRIx1lpkyZooKCAo0bN065ubnq1q2bVq9erZCQEJePU+Vk3cMPP6wdO3Zo/fr1pbZVZSC9i5WZOnWqJk2a5Hidn5+vmJiYKkQNAKhrfvzxRz3xxBNasWKFCgoK1Lp1ay1cuFBdunSRdK59mT59uubPn+9oLF977TW1a9fOw5EDAHzNPffcI0l65JFHHOssFovjuwxjcANA7bEbiyzVTNbZq7D/gAEDNGDAgHK3WywWJSYmKjExscpxVSlZN2HCBH388cf6/PPPddlllznWnz+QXlRUlGP9+QPp2Ww2FRUVKTc316l3XU5OTrnP71qt1nIH9wMA1F+5ubnq2bOnbrnlFq1YsUIRERH6/vvv1bhxY0eZkomPFi9erNatW+uFF15QfHy89u3bV6lftwAAyMzM9HQIQL0X3+DuCsuk2d+vhUjgaSWTRFS3Dm9UqWSdMUYTJkzQ8uXLtW7dOsXGxjptP38gvc6dO0v670B6M2fOlCR16dJFAQEBSktL07BhwyRJWVlZ2rVrl2bNmuWOcwIA1BMzZ85UTEyMFi1a5FjXqlUrx98vnPhIklJTUxUZGamlS5dq7NixtR0yAMCHlQwgDgBATarUBBPjx4/XkiVLtHTpUoWEhCg7O1vZ2dkqKCiQ5NpAemFhYbr//vv12GOP6dNPP9X27dv129/+Vh06dFCfPn3cf4YAgDrr448/VteuXXX33XcrIiJCnTt31oIFCxzbXZn46EJMagQAuJi3335bPXv2VHR0tGNc7pSUFP3tb3/zcGQAUL+UjFlX3cUbVSpZN2/ePOXl5al3796KiopyLO+9956jzJQpU5SQkKBx48apa9eu+vHHH0sNpPfKK69oyJAhGjZsmHr27Kng4GB98skn8vPzc9+ZAQDqvAMHDmjevHmKi4vTqlWr9OCDD+qRRx7RW2+9JeniEx9dbFKjsLAwx8IYqQCAEvPmzdOkSZN0xx136NixY44x6ho3bqyUlBTPBgcA9QzJuv8wxpS5jBkzxlGmZCC9rKwsnT59Wunp6Y7ZYks0bNhQc+bM0dGjR3Xq1Cl98sknfBkCAFSa3W7Xtddeq6SkJHXu3Fljx47VAw88oHnz5jmVq8zER1OnTlVeXp5jOXz4cI3FDwDwLXPmzNGCBQs0bdo0p44GXbt21c6dOz0YGQDUP3ZjccvijSqVrAMAwJtERUWpbdu2TuuuvvpqHTp0SJLzxEfnO3/iowtZrVaFhoY6LQAASOeGVygZm/t8VqtVJ0+e9EBEAIC6iGQdAMBn9ezZU/v27XNat3//fscA4OdPfFSiZOKj8mYgBwCgPLGxscrIyCi1fsWKFaV+PAIA1KyS2WCru3ijSs0GCwCAN5k4caJ69OihpKQkDRs2TJs2bdL8+fM1f/58Sc4TH8XFxSkuLk5JSUlOEx8BAOCqxx9/XOPHj9fp06dljNGmTZv07rvvKjk5WX/+8589HR4A1Cvnkm3Ve4yVZB0AAG523XXXafny5Zo6daqef/55xcbGKiUlRSNHjnSUmTJligoKCjRu3Djl5uaqW7dupSY+AgDAFb///e919uxZTZkyRadOndKIESN06aWX6tVXX9Xw4cM9HR4A1CvumCDCWyeYIFkHAPBpAwYM0IABA8rdXjLxUWJiYu0FBQCosx544AE98MAD+uWXX2S32xUREeHpkAAAdQzJOgAAAACopGbNmnk6BACo18x/lurW4Y2YYAIAAAAAXPDTTz9p1KhRio6Olr+/v/z8/JwWAEDtKXkMtrqLN6JnHQAAAAC4YMyYMTp06JCeeeYZRUVFyWLxzi95AFAv1OGudfSsAwAAAAAXrF+/Xu+8844eeughDRkyRIMHD3Za3O3HH3/Ub3/7WzVt2lTBwcG65pprtHXrVsd2Y4wSExMVHR2toKAg9e7dW7t373aqo7CwUBMmTFCzZs3UqFEjDRo0SEeOHHF7rAAA9yFZBwAAAAAuiImJkTG10w0jNzdXPXv2VEBAgFasWKE9e/bo5ZdfVuPGjR1lZs2apdmzZ2vu3LnavHmzbDab4uPjdfz4cUeZhIQELV++XMuWLdP69et14sQJDRgwQMXFxbVyHgBQY9zxCCyPwQIAAACA70pJSdGTTz6pN998U61atarRY82cOVMxMTFatGiRY935xzTGKCUlRdOmTdPQoUMlSampqYqMjNTSpUs1duxY5eXlaeHChXr77bfVp08fSdKSJUsUExOjNWvWqF+/fjV6DgBQk4w5t1S3Dm9EzzoAAAAAcME999yjdevW6YorrlBISIjCw8OdFnf6+OOP1bVrV919992KiIhQ586dtWDBAsf2zMxMZWdnq2/fvo51VqtVvXr10oYNGyRJW7du1ZkzZ5zKREdHq3379o4yFyosLFR+fr7TAgDeiAkmAAAAAKCeS0lJqbVjHThwQPPmzdOkSZP01FNPadOmTXrkkUdktVr1u9/9TtnZ2ZKkyMhIp/0iIyN18OBBSVJ2drYCAwPVpEmTUmVK9r9QcnKypk+fXgNnBLhHmv19t9UV3+DuWj0e4CqSdQAAAADggtGjR9fasex2u7p27aqkpCRJUufOnbV7927NmzdPv/vd7xzlLpyR1hhT4Sy1FyszdepUTZo0yfE6Pz9fMTExVT0NAKg57hhzzkt71vEYLAAAAACU4/zHQC98PLQmHxeNiopS27ZtndZdffXVOnTokCTJZrNJUqkecjk5OY7edjabTUVFRcrNzS23zIWsVqtCQ0OdFgDwRiVj1lV38UYk6wAAAACgHE2aNFFOTo4kqXHjxmrSpEmppWS9O/Xs2VP79u1zWrd//361bNlSkhQbGyubzaa0tDTH9qKiIqWnp6tHjx6SpC5duiggIMCpTFZWlnbt2uUoAwA+y7hp8UI8BgsAAAAA5fjss88ck0esXbu21o47ceJE9ejRQ0lJSRo2bJg2bdqk+fPna/78+ZLOPf6akJCgpKQkxcXFKS4uTklJSQoODtaIESMkSWFhYbr//vv12GOPqWnTpgoPD9fkyZPVoUMHx+ywAADvQ7IOAAAAAMrRq1evMv9e06677jotX75cU6dO1fPPP6/Y2FilpKRo5MiRjjJTpkxRQUGBxo0bp9zcXHXr1k2rV69WSEiIo8wrr7wif39/DRs2TAUFBbrtttu0ePFi+fn51dq5AEBNcMdsrswGCwAAAAB1wKlTp3To0CEVFRU5re/YsaNbjzNgwAANGDCg3O0Wi0WJiYlKTEwst0zDhg01Z84czZkzx62xAYBX8NLHWKuLZB0AAAAAuODnn3/W73//e61YsaLM7cXFxbUcEQDUX3W5Zx0TTAAAAACACxISEpSbm6uNGzcqKChIK1euVGpqquLi4vTxxx97OjwAQB1BzzoAAAAAcMFnn32mv/3tb7ruuuvUoEEDtWzZUvHx8QoNDVVycrLuvPNOT4cIAPWHO2Zz9dLHaOlZBwAAAAAuOHnypCIiIiRJ4eHh+vnnnyVJHTp00LZt2zwZGgDUQxY3Ld6HZB0AAAAAuOCqq67Svn37JEnXXHON3nzzTf3444964403FBUV5eHoAAA1LTExURaLxWmx2WyO7cYYJSYmKjo6WkFBQerdu7d2795d6ePwGCwAAAAAuCAhIUFZWVmSpOeee079+vXTO++8o8DAQC1evNizwQFAfeOhx2DbtWunNWvWOF77+fk5/j5r1izNnj1bixcvVuvWrfXCCy8oPj5e+/btU0hIiMvHIFkHAAAAAC4YOXKk4++dO3fWDz/8oG+++UYtWrRQs2bNPBgZANRDHkrW+fv7O/Wmc1RljFJSUjRt2jQNHTpUkpSamqrIyEgtXbpUY8eOdfkYPAYLAAAAAC54/vnnderUKcfr4OBgXXvttWrUqJGef/55D0YGAPWQsbhnkZSfn++0FBYWlnvYb7/9VtHR0YqNjdXw4cN14MABSVJmZqays7PVt29fR1mr1apevXppw4YNlTo1knUAAAAA4ILp06frxIkTpdafOnVK06dP90BEAAB3iImJUVhYmGNJTk4us1y3bt301ltvadWqVVqwYIGys7PVo0cPHT16VNnZ2ZKkyMhIp30iIyMd21zFY7AAAAAA4AJjjCyW0jMHfv311woPD/dARABQfxlzbqluHZJ0+PBhhYaGOtZbrdYyy/fv39/x9w4dOqh79+664oorlJqaqhtuuEGSSrUT5bUdF0OyDgAAAAAuokmTJo5Z/1q3bu30pau4uFgnTpzQgw8+6MEIAZwvvsHdLpVLs79fw5GgRrlxzLrQ0FCnZJ2rGjVqpA4dOujbb7/VkCFDJEnZ2dlOM4Tn5OSU6m1XEZJ1AAAAAHARKSkpMsbovvvu0/Tp0xUWFubYFhgYqFatWql79+4ejBAA6qHzxpyrVh3VUFhYqL179+qmm25SbGysbDab0tLS1LlzZ0lSUVGR0tPTNXPmzErVS7IOAAAAAC5i9OjRkqTY2Fj16NFDAQEBHo4IAOAJkydP1sCBA9WiRQvl5OTohRdeUH5+vkaPHi2LxaKEhAQlJSUpLi5OcXFxSkpKUnBwsEaMGFGp45CsAwAAAAAX9OrVS3a7Xfv371dOTo7sdrvT9ptvvtlDkQFA/WMx55bq1lEZR44c0b333qtffvlFzZs31w033KCNGzeqZcuWkqQpU6aooKBA48aNU25urrp166bVq1crJCSkUschWQcAAAAALti4caNGjBihgwcPylwwqrnFYlFxcbGHIgOAesiNY9a5atmyZRfdbrFYlJiYqMTExKrHJJJ1AAAAAOCSBx98UF27dtU//vEPRUVFVXp2PwCAG3nBmHU1hWQdAAAAALjg22+/1V//+lddeeWVng4FAFCHNfB0AAAAAADgC7p166bvvvvO02EAAKT/PgZb3cUL0bMOAAAAAFwwYcIEPfbYY8rOzlaHDh1KzQrbsWNHD0UGAPWQB8asqy0k6wAAAADABb/5zW8kSffdd59jncVikTGGCSYAoLaRrAMAAACA+i0zM9PTIQAA6gGSdQAAAADggpYtW3o6BABACWaDBQAAAAB8//33SklJ0d69e2WxWHT11Vfr0Ucf1RVXXOHp0ACgXrGYc0t16/BGzAYLAAAAAC5YtWqV2rZtq02bNqljx45q3769vvrqK7Vr105paWmeDg8A6hdmgwUAAACA+u3JJ5/UxIkT9eKLL5Za/8QTTyg+Pt5DkQEA6hJ61gEAAACAC/bu3av777+/1Pr77rtPe/bs8UBEAIC6iGQdAAAAALigefPmysjIKLU+IyNDERERtR8QANRjFv133LoqL54+iXJU+jHYzz//XC+99JK2bt2qrKwsLV++XEOGDHFsHzNmjFJTU5326datmzZu3Oh4XVhYqMmTJ+vdd99VQUGBbrvtNr3++uu67LLLqn4mAAAAAFCDHnjgAf2///f/dODAAfXo0UMWi0Xr16/XzJkz9dhjj3k6PMCrxTe4u8Iyafb33XIsd9UDL8dssP918uRJderUSb///e/1m9/8pswyt99+uxYtWuR4HRgY6LQ9ISFBn3zyiZYtW6amTZvqscce04ABA7R161b5+flVNiQAAAAAqHHPPPOMQkJC9PLLL2vq1KmSpOjoaCUmJuqRRx7xcHQAgLqi0sm6/v37q3///hctY7VaZbPZytyWl5enhQsX6u2331afPn0kSUuWLFFMTIzWrFmjfv36ldqnsLBQhYWFjtf5+fmVDRsAAAAAqsVisWjixImaOHGijh8/LkkKCQnxcFQAUE+5YzZXL50NtkbGrFu3bp0iIiLUunVrPfDAA8rJyXFs27p1q86cOaO+ffs61kVHR6t9+/basGFDmfUlJycrLCzMscTExNRE2AAAAABQrszMTH377beSziXpShJ13377rX744QcPRgYA9ZBx0+KF3J6s69+/v9555x199tlnevnll7V582bdeuutjp5x2dnZCgwMVJMmTZz2i4yMVHZ2dpl1Tp06VXl5eY7l8OHD7g4bAAAAAC5qzJgxZXYw+OqrrzRmzJjaDwgA6rFqTy7xn8UbVfox2Ircc889jr+3b99eXbt2VcuWLfWPf/xDQ4cOLXc/Y4wslrIH9rNarbJare4OFQAAAABctn37dvXs2bPU+htuuEEPP/ywByICANRFNfIY7PmioqLUsmVLR3dxm82moqIi5ebmOpXLyclRZGRkTYcDAAAAAFVisVgcY9WdLy8vT8XFxR6ICADqMR6DrbqjR4/q8OHDioqKkiR16dJFAQEBSktLc5TJysrSrl271KNHj5oOBwAAAACq5KabblJycrJTYq64uFjJycm68cYbPRgZANRDdThZV+nHYE+cOKHvvvvO8TozM1MZGRkKDw9XeHi4EhMT9Zvf/EZRUVH64Ycf9NRTT6lZs2a66667JElhYWG6//779dhjj6lp06YKDw/X5MmT1aFDB8fssAAAAADgbWbNmqWbb75ZV111lW666SZJ0hdffKH8/Hx99tlnHo4OAOoXd4w5561j1lW6Z92WLVvUuXNnde7cWZI0adIkde7cWc8++6z8/Py0c+dODR48WK1bt9bo0aPVunVrffnll05Tmr/yyisaMmSIhg0bpp49eyo4OFiffPKJ/Pz83HdmAAAAAOBGbdu21Y4dOzRs2DDl5OTo+PHj+t3vfqdvvvlG7du393R4AIA6otI963r37i1jyk89rlq1qsI6GjZsqDlz5mjOnDmVPTwAAAAAeEx0dLSSkpI8HQYAwFjOLdWtwwu5fTZYAAAAAAAAoEa5Y8w5L30MlmQdAAAAAAAAfApj1gEAAAAAAACocSTrAAAAAKAcH3/8sc6cOePpMAAAFzJuWrwQyToAAAAAKMddd92lY8eOSZL8/PyUk5Pj2YAAAOeY/z4KW9WFZB0AAAAA+JjmzZtr48aNkiRjjCwW75w5EADqHQ/3rEtOTpbFYlFCQsJ/QzJGiYmJio6OVlBQkHr37q3du3dXum4mmAAAAACAcjz44IMaPHiwLBaLLBaLbDZbuWWLi4trMTIA1XV7+AMVlln564JaiAS+ZvPmzZo/f746duzotH7WrFmaPXu2Fi9erNatW+uFF15QfHy89u3bp5CQEJfrJ1kHAAAAAOVITEzU8OHD9d1332nQoEFatGiRGjdu7OmwAADueIy1CvufOHFCI0eO1IIFC/TCCy/8typjlJKSomnTpmno0KGSpNTUVEVGRmrp0qUaO3asy8cgWQcAAAAAF9GmTRu1adNGzz33nO6++24FBwd7OiQAqPcc485Vsw5Jys/Pd1pvtVpltVrL3Gf8+PG688471adPH6dkXWZmprKzs9W3b1+nenr16qUNGzaQrAMAAAAAd3vuueckST///LP27dsni8Wi1q1bq3nz5h6ODABQHTExMU6vn3vuOSUmJpYqt2zZMm3btk2bN28utS07O1uSFBkZ6bQ+MjJSBw8erFQ8TDABAKgzanKQVwAATp06pfvuu0/R0dG6+eabddNNNyk6Olr333+/Tp065enwAABVdPjwYeXl5TmWqVOnllnm0Ucf1ZIlS9SwYcNy67pwIqKqTE5Esg4AUCdUNMjr3LlztXnzZtlsNsXHx+v48eMeihQA4KsmTpyo9PR0ffzxxzp27JiOHTumv/3tb0pPT9djjz3m6fAAoH5x42ywoaGhTktZj8Bu3bpVOTk56tKli/z9/eXv76/09HT96U9/kr+/v6NHXUkPuxI5OTmlettVhGQdAMDnnT/Ia5MmTRzrLxzktX379kpNTdWpU6e0dOlSD0YMAPBFH3zwgRYuXKj+/fs7vtDdcccdWrBggf761796OjwAqFdKxqyr7uKq2267TTt37lRGRoZj6dq1q0aOHKmMjAxdfvnlstlsSktLc+xTVFSk9PR09ejRo1LnRrIOAODzzh/k9XwVDfJalsLCQuXn5zstAABI5x6DLat3REREBI/BAoAnuKFXnatCQkLUvn17p6VRo0Zq2rSp2rdv7xiOJykpScuXL9euXbs0ZswYBQcHa8SIEZU6FhNMAAB8mrsHeU1OTtb06dPdHygAwOd1795dzz33nN566y3HeEUFBQWaPn26unfv7uHoAACeNmXKFBUUFGjcuHHKzc1Vt27dtHr1aoWEhFSqHpJ1AACfVTLI6+rVq902yOvUqVM1adIkx+v8/PxSs0MBAOqnV199Vbfffrsuu+wyderUSRaLRRkZGWrYsKFWrVrl6fAAoH6pQu+4MuuohnXr1jm9tlgsSkxMLHMm2cogWQcA8FnnD/Jaori4WJ9//rnmzp2rffv2STrXwy4qKspR5mKDvFqt1jIHlAUAoH379vr222+1ZMkSffPNNzLGaPjw4Ro5cqSCgoI8HR4A1CuVHXOuvDq8Eck6AIDPKhnk9Xy///3v1aZNGz3xxBNOg7x27txZ0n8HeZ05c6YnQgYA+LigoCA98MADng4DAOAFPetqCsk6AIDPKhnk9XznD/IqyTHIa1xcnOLi4pSUlFSlQV4BAAAAoDaQrAMA1GnuGuQVAAAAgPeoy4/BNvB0AAAAuNO6deuUkpLieF0yyGtWVpZOnz6t9PT0Ur3xAADwdsnJybJYLEpISHCsM8YoMTFR0dHRCgoKUu/evbV7926n/QoLCzVhwgQ1a9ZMjRo10qBBg3TkyJFajh4AaoBx0+KFSNYBAAAAgBfbvHmz5s+fr44dOzqtnzVrlmbPnq25c+dq8+bNstlsio+P1/Hjxx1lEhIStHz5ci1btkzr16/XiRMnNGDAABUXF9f2aQCAe5GsAwAAAAAcO3ZMf/7znzV16lT9+uuvkqRt27bpxx9/rJHjnThxQiNHjtSCBQvUpEkTx3pjjFJSUjRt2jQNHTpU7du3V2pqqk6dOqWlS5dKkvLy8rRw4UK9/PLL6tOnjzp37qwlS5Zo586dWrNmTY3ECwCoPpJ1AAAAAOCCHTt2qHXr1po5c6b++Mc/6tixY5Kk5cuXa+rUqTVyzPHjx+vOO+9Unz59nNZnZmYqOztbffv2dayzWq3q1auXNmzYIEnaunWrzpw541QmOjpa7du3d5S5UGFhofLz850WAPBGJWPWVXfxRkwwAQAAAAAumDRpksaMGaNZs2Y5TVTUv3//GpllfNmyZdq2bZs2b95calt2drYkKTIy0ml9ZGSkDh486CgTGBjo1COvpEzJ/hdKTk7W9OnT3RE+UGl9A4ZXWGb1mWVuO97KXxe4rS54gDseY/XSZB096wAAAADABZs3b9bYsWNLrb/00kvLTX5V1eHDh/Xoo49qyZIlatiwYbnlLBaL02tjTKl1F7pYmalTpyovL8+xHD58uPLBA0BtYMw6AAAAAKjfGjZsWOZjofv27VPz5s3deqytW7cqJydHXbp0kb+/v/z9/ZWenq4//elP8vf3d/SouzBJmJOT49hms9lUVFSk3NzccstcyGq1KjQ01GkBANQuknUAAAAA4ILBgwfr+eef15kzZySd69V26NAhPfnkk/rNb37j1mPddttt2rlzpzIyMhxL165dNXLkSGVkZOjyyy+XzWZTWlqaY5+ioiKlp6erR48ekqQuXbooICDAqUxWVpZ27drlKAMAvoox6wAAAACgnvvjH/+oO+64QxERESooKFCvXr2UnZ2t7t27a8aMGW49VkhIiNq3b++0rlGjRmratKljfUJCgpKSkhQXF6e4uDglJSUpODjYMX5eWFiY7r//fj322GNq2rSpwsPDNXnyZHXo0KHUhBUA4HPq8Jh1JOsAAAAAwAWhoaFav369PvvsM23btk12u13XXnutxxJfU6ZMUUFBgcaNG6fc3Fx169ZNq1evdpr84pVXXpG/v7+GDRumgoIC3XbbbVq8eLH8/Pw8EjMAuIs7esbRsw4AAAAAfNihQ4cUGRmpW2+9VbfeeqtjvTFGhw8fVosWLWr0+OvWrXN6bbFYlJiYqMTExHL3adiwoebMmaM5c+bUaGwAAPdhzDoAAAAAcEGrVq107bXX6vvvv3dan5OTo9jYWA9FBQD1FLPBAgAAAACuvvpqXX/99fr000+d1hvjpd/4AKCuIlkHAAAAAPWbxWLR66+/rqefflp33nmn/vSnPzltAwDUHoubFm/EmHUAAAAA4IKS3nMTJ05UmzZtdO+992rHjh169tlnPRwZAKAuIVkHAAAAAJXUv39/bdiwQYMGDdKmTZs8HQ4A1D/ueIyVx2ABAAAAwHf16tVLgYGBjtdt27bVpk2b1KRJE8asA4BaZjHuWbwRPesAAAAAwAVr164ttS48PFzp6ekeiAYA6rk63LOOZB0AAAAAlCM/P1+hoaGOv19MSTkAAKqDZB0AAAAAlKNJkybKyspSRESEGjduXOasr8YYWSwWFRcXeyBCAKjHvLRnXHWRrAMAAACAcnz22WcKDw+XVPZjsAAAz3DHmHOMWQcAAAAAPqZXr15l/h1A5aTZ33dLPfEN7q6wTANrQ5fqsheerrCMu+IGKoPZYAEAAADABStXrtT69esdr1977TVdc801GjFihHJzcz0YGQDUQ8ZNixciWQcAAAAALnj88ccdk0zs3LlTkyZN0h133KEDBw5o0qRJHo4OAOqXksdgq7t4I5J1AAAAAOCCzMxMtW3bVpL0wQcfaODAgUpKStLrr7+uFStWeDg6AKhnPNCzbt68eerYsaNCQ0MVGhqq7t27O93/jTFKTExUdHS0goKC1Lt3b+3evbvSp1bpZN3nn3+ugQMHKjo6WhaLRR999JHTdlcCKyws1IQJE9SsWTM1atRIgwYN0pEjRyodPAAAAADUlsDAQJ06dUqStGbNGvXt21eSFB4e7uhxBwCouy677DK9+OKL2rJli7Zs2aJbb71VgwcPduS9Zs2apdmzZ2vu3LnavHmzbDab4uPjdfz48Uodp9LJupMnT6pTp06aO3dumdtdCSwhIUHLly/XsmXLtH79ep04cUIDBgxgqnMAAAAAXuvGG2/UpEmT9Ic//EGbNm3SnXfeKUnav3+/LrvsMg9HBwD1iycegx04cKDuuOMOtW7dWq1bt9aMGTN0ySWXaOPGjTLGKCUlRdOmTdPQoUPVvn17paam6tSpU1q6dGmljlPpZF3//v31wgsvaOjQoaW2uRJYXl6eFi5cqJdffll9+vRR586dtWTJEu3cuVNr1qypbDgAAAAAUCvmzp0rf39//fWvf9W8efN06aWXSpJWrFih22+/3cPRAUA948bHYPPz852WwsLCCg9fXFysZcuW6eTJk+revbsyMzOVnZ3t6HUtSVarVb169dKGDRsqdWr+lSpdgYoCGzt2rLZu3aozZ844lYmOjlb79u21YcMG9evXr1S9hYWFTheKLuYAAAAAaluLFi3097//vdT6V155xQPRAEA9547ZXP+zf0xMjNPq5557TomJiWXusnPnTnXv3l2nT5/WJZdcouXLl6tt27aOhFxkZKRT+cjISB08eLBSYbk1WZedne0I5HznB5adna3AwEA1adKkVJmS/S+UnJys6dOnuzNUAAAAAAAAQIcPH1ZoaKjjtdVqLbfsVVddpYyMDB07dkwffPCBRo8erfT0dMd2i8XiVN4YU2pdRWpkNtiqBHaxMlOnTlVeXp5jOXz4sNtiBQAAAAAAgG9x55h1JbO7liwXS9YFBgbqyiuvVNeuXZWcnKxOnTrp1Vdflc1mk6RSHdFycnJKdWqriFuTda4EZrPZVFRUpNzc3HLLXMhqtZa6cAAAAAAAAKin3DhmXbXCMEaFhYWKjY2VzWZTWlqaY1tRUZHS09PVo0ePStXp1mSdK4F16dJFAQEBTmWysrK0a9euSgcPAAAAAACA+sdijFuWynjqqaf0xRdf6IcfftDOnTs1bdo0rVu3TiNHjpTFYlFCQoKSkpK0fPly7dq1S2PGjFFwcLBGjBhRqeNUesy6EydO6LvvvnO8zszMVEZGhsLDw9WiRQtHYHFxcYqLi1NSUpJTYGFhYbr//vv12GOPqWnTpgoPD9fkyZPVoUMH9enTp7LhAAAAAAAAADXup59+0qhRo5SVlaWwsDB17NhRK1euVHx8vCRpypQpKigo0Lhx45Sbm6tu3bpp9erVCgkJqdRxKp2s27Jli2655RbH60mTJkmSRo8ercWLF7sU2CuvvCJ/f38NGzZMBQUFuu2227R48WL5+flVNhwAAAAAqDFDhw51ueyHH35Yg5EAAJy4cTZYVy1cuPCi2y0WixITE8udSdZVlU7W9e7dW+Yi3QRdCaxhw4aaM2eO5syZU9nDAwAAAECtCQsL83QIAIAynD9BRHXq8EaVTtYBAAAAQH2xaNEiT4cAACiLB3rW1Ra3TjABAAAAAAAAoOroWQcAAAAALvrrX/+q//u//9OhQ4dUVFTktG3btm0eigqomvgGd1dYJs3+fi1E4l72wtOeDgG1oC4/BkvPOgAAAABwwZ/+9Cf9/ve/V0REhLZv367rr79eTZs21YEDB9S/f39PhwcA9Ytx0+KFSNYBAAAAgAtef/11zZ8/X3PnzlVgYKCmTJmitLQ0PfLII8rLy/N0eABQr5T0rKvu4o1I1gEAAACACw4dOqQePXpIkoKCgnT8+HFJ0qhRo/Tuu+96MjQAQB1Csg4AAAAAXGCz2XT06FFJUsuWLbVx40ZJUmZmpozx0u4ZAFBX8RgsAAAAANRvt956qz755BNJ0v3336+JEycqPj5e99xzj+666y4PRwcA9U9dfARWYjZYAAAAAHDJ/PnzZbfbJUkPPvigwsPDtX79eg0cOFAPPvigh6MDgHrGmHNLdevwQiTrAAAAAMAFR44cUUxMjOP1sGHDNGzYMBljdPjwYbVo0cKD0QEA6goegwUAAAAAF8TGxurnn38utf7XX39VbGysByICgPqrLs8GS886AAAAAHCBMUYWi6XU+hMnTqhhw4YeiAgA6jF3TBBBsg4AAAAAfM+kSZMkSRaLRc8884yCg4Md24qLi/XVV1/pmmuu8VB0AFA/WeznlurW4Y1I1gEAAADARWzfvl3SuZ51O3fuVGBgoGNbYGCgOnXqpMmTJ3sqPABAHUOyDgAAAAAuYu3atZKk3//+93r11VcVGhrq4YgAADwGCwAAAAD13KJFixx/P3LkiCwWiy699FIPRgQA9Zc7Jojw1gkmmA0WAAAAAFxgt9v1/PPPKywsTC1btlSLFi3UuHFj/eEPf5Dd7qUDHwFAXWWMexYvRM86AAAAAHDBtGnTtHDhQr344ovq2bOnjDH617/+pcTERJ0+fVozZszwdIgAgDqAZB0AAAAAuCA1NVV//vOfNWjQIMe6Tp066dJLL9W4ceNI1gFALarLj8GSrAMAAAAAF/z6669q06ZNqfVt2rTRr7/+6oGIgOpJs7/v6RAqzZ0x9wsa5ba64AF1eIIJxqwDAAAAABd06tRJc+fOLbV+7ty56tSpkwciAoD6q6RnXXUXb0TPOgAAAABwwaxZs3TnnXdqzZo16t69uywWizZs2KDDhw/rn//8p6fDAwDUEfSsAwAAAAAX9OrVS/v379ddd92lY8eO6ddff9XQoUO1b98+3XTTTZ4ODwDqF2aDBQAAAID67dChQ4qJiSlzIolDhw6pRYsWHogKAOqnujzBBD3rAAAAAMAFsbGx+vnnn0utP3r0qGJjYz0QEQDUY8ZNixciWQcAAAAALjDGyGKxlFp/4sQJNWzY0AMRAQDqIh6DBQAAAICLmDRpkiTJYrHomWeeUXBwsGNbcXGxvvrqK11zzTUeig4A6icegwUAAACAemr79u3avn27jDHauXOn4/X27dv1zTffqFOnTlq8eLGnwwSA+sVu3LNUQnJysq677jqFhIQoIiJCQ4YM0b59+5zKGGOUmJio6OhoBQUFqXfv3tq9e3eljkOyDgDgs2qrsQQA1G9r167V2rVrNXr0aK1YscLxeu3atVq1apXefPNNxcXFeTpMAKhfPDBmXXp6usaPH6+NGzcqLS1NZ8+eVd++fXXy5ElHmVmzZmn27NmaO3euNm/eLJvNpvj4eB0/ftzl45CsAwD4rNpqLAGUZozRqaKzlV6M8dLnTQAXLFq0SKGhoZ4OAwDgIStXrtSYMWPUrl07derUSYsWLdKhQ4e0detWSec+H6WkpGjatGkaOnSo2rdvr9TUVJ06dUpLly51+TiMWQcA8FkrV650er1o0SJFRERo69atuvnmm0s1lpKUmpqqyMhILV26VGPHji1VZ2FhoQoLCx2v8/Pza/YkAB9VcKZYbZ9dVen99jzfT8GBfAQFAADVY5Ebxqz7z58Xfua3Wq2yWq0V7p+XlydJCg8PlyRlZmYqOztbffv2daqrV69e2rBhQ5nfP8pCzzoAQJ1R2cayLMnJyQoLC3MsMTExNR84AAAAgMoxxj2LpJiYGKfvAMnJyS4c3mjSpEm68cYb1b59e0lSdna2JCkyMtKpbGRkpGObK/hZEwBQJ1S2sTx48GCZ9UydOtUx65907lc2EnbAxW15uo+CA/3K3X6qqFhdX1hTixEBvi85OVkffvihvvnmGwUFBalHjx6aOXOmrrrqKkcZY4ymT5+u+fPnKzc3V926ddNrr72mdu3aOcoUFhZq8uTJevfdd1VQUKDbbrtNr7/+ui677DJPnBYAuI07Z4M9fPiw0zAHrvSqe/jhh7Vjxw6tX7++dL0Wi9NrY0ypdRdDzzoAQJ1Q0li+++67pbZVprG0Wq0KDQ11WjzlVFEx44DBJwQH+ik40P8iS/mJvNrGWHvwFe4alzUhIUHLly/XsmXLtH79ep04cUIDBgxQcXGxJ04LALzShZ//K0rWTZgwQR9//LHWrl3r9OOHzWaTpFK96HJyckp1ILgYetYBAHxeSWP5+eefl9tYRkVFOdZXtrH0lMr0RGIcMMA1jLUHX+GOcVnz8vK0cOFCvf322+rTp48kacmSJYqJidGaNWvUr1+/Wj8vAHCbKszmWmYdlSlujCZMmKDly5dr3bp1io2NddoeGxsrm82mtLQ0de7cWZJUVFSk9PR0zZw50+Xj0LMOAOCzjDF6+OGH9eGHH+qzzz67aGNZoqSx7NGjR22HCwBAlVVlXNatW7fqzJkzTmWio6PVvn37csduLSwsVH5+vtMCAN7IYoxblsoYP368lixZoqVLlyokJETZ2dnKzs5WQUHBuZgsFiUkJCgpKUnLly/Xrl27NGbMGAUHB2vEiBEuH4efBwEAPmv8+PFaunSp/va3vzkaS0kKCwtTUFCQU2MZFxenuLg4JSUlVbqxrE1BAX7a87xrPR0YBwyoHsbag6+o6ris2dnZCgwMVJMmTUqVKW+g8+TkZE2fPt3dpwC4pG/A8Fo9nuFxcN9m/89S3ToqYd68eZKk3r17O61ftGiRxowZI0maMmWKCgoKNG7cOMd4oqtXr1ZISIjLxyFZBwDwWbXVWNYmi8XCo3a1xBijgjNV+5AeFOBXqUGCfUVlrsmpIt//glMy1h7g7dw9iPnFyjDREgCUz5UxbC0WixITE5WYmFjl4/DpBADgs2qrsUTdVNWxy6S6O35Zda4JgJpRnXFZbTabioqKlJub69S7Licnp9zhIKxWq0uzIAKAp1XlMday6vBGjFkHAAAAAF7GHeOydunSRQEBAU5lsrKytGvXLsZuBeD7jJsWL1T3fhIGAACopIrGLpPq3/hlrlyTEkEBrpVzVVUfUa6rjyejfnLHuKxhYWG6//779dhjj6lp06YKDw/X5MmT1aFDB8fssADgs4w5t1S3Di9Esg4AANR7jF1WmievSVUfx62rjyejfnLXuKyvvPKK/P39NWzYMBUUFOi2227T4sWL5efn3iQ7AMB9+DQDAAAAAF7GXeOyNmzYUHPmzNGcOXPcGB0AeJ7FnFuqW4c3IlkHAAAAr1XR47j17fFkAADwHzwGCwAAANQ+HlEGAABlsdjPLdWtwxu5fTbYxMREWSwWp6VkWnHpXHfuxMRERUdHKygoSL1799bu3bvdHQYAAAAAAADgc9yerJOkdu3aKSsry7Hs3LnTsW3WrFmaPXu25s6dq82bN8tmsyk+Pl7Hjx+viVAAAAAAAABQ15Q8BlvdxQvVyDMF/v7+Tr3pShhjlJKSomnTpmno0KGSpNTUVEVGRmrp0qUaO3ZsTYQDAAAAAACAusT8Z6luHV6oRnrWffvtt4qOjlZsbKyGDx+uAwcOSJIyMzOVnZ2tvn37OsparVb16tVLGzZsKLe+wsJC5efnOy0AAKDmGGN0quhslRZXZjAEAAAAqsNijFsWb+T2nnXdunXTW2+9pdatW+unn37SCy+8oB49emj37t3Kzs6WJEVGRjrtExkZqYMHD5ZbZ3JysqZPn+7uUAEAQDkKzhSr7bOrqrTvnuf7MSEAAAAAUEVu/yTdv39/x987dOig7t2764orrlBqaqpuuOEGSZLFYnHaxxhTat35pk6dqkmTJjle5+fnKyYmxs2RAwAAAAAAwCe4Y8y5+tKz7kKNGjVShw4d9O2332rIkCGSpOzsbEVFRTnK5OTklOptdz6r1Sqr1VrToQIAUKcZY1RwptilsqeK/ltuy9N9FBzoV2H5ri+sqVZ8cE1l/h0r6/x/95riyjGqGkdN1g0AALyMkWR3Qx1eqMaTdYWFhdq7d69uuukmxcbGymazKS0tTZ07d5YkFRUVKT09XTNnzqzpUAAAqNeq+mhrcKAfj7V6keo8ouwNajKpS8IYAID6wx1jztWbMesmT56sgQMHqkWLFsrJydELL7yg/Px8jR49WhaLRQkJCUpKSlJcXJzi4uKUlJSk4OBgjRgxwt2hAAAAAABQ4+Ib3F1hmTT7+7UQyX/1DRheYZnVZ5bVQiTnuOsauVIP4Ovcnqw7cuSI7r33Xv3yyy9q3ry5brjhBm3cuFEtW7aUJE2ZMkUFBQUaN26ccnNz1a1bN61evVohISHuDgUAAJTDlUdbSwQFuFYOta8y/46V5c5/96AAP+15vl+NxFGTdQMAAC9m5IYx69wSidu5PVm3bNnFM/MWi0WJiYlKTEx096EBAICLeLS1bvCVf0eLxVJjcdZk3QAAwIvV4QkmGng6AAAAAAAAAADn8DMkAAAAAAAAfItdksUNdXghknUAAAAAAADwKcwGCwAA4AOMMSo4U+xS2VNFrpUDAACAF6rDY9aRrAMAAHVGwZlitX12lafDAAAAAKqMZB0AAAAAAAB8Cz3rAACAN3Plkc769tjnlqf7KDjQz6WyQQGulQMAAICXIFkHAAC8WdcX1ng6BK8THOin4EA+6gAAANRJdXg22AaeDgAAAAAAAADAOfzcDACAjwoK8NOe5/tVeV8AAADAV1mMkaWaj7FWd/+aQs86AAB8lMViUXCgf5UWi6W6zwzAXYwxOlV0thJL/Rp7EAAAoEwlY9ZVd6mEzz//XAMHDlR0dLQsFos++uijC0IySkxMVHR0tIKCgtS7d2/t3r270qdGzzoAAAAPKjhTrLbPrvJ0GAAAAL7FbiRLNXvG2Su3/8mTJ9WpUyf9/ve/129+85tS22fNmqXZs2dr8eLFat26tV544QXFx8dr3759CgkJcfk4JOsAAAAAAACACvTv31/9+/cvc5sxRikpKZo2bZqGDh0qSUpNTVVkZKSWLl2qsWPHunwcknUAAABeYsvTfRQc6Pp4gow9CAAA6q0qPMZaZh2S8vPznVZbrVZZrdZKVZWZmans7Gz17dvXqZ5evXppw4YNJOsAAAB8UXCgn4ID+XgGAN6kb8DwCsuk2d+vsMzt4Q9UWGblrwtciskVptg9Y5zGN7i7wjKunL/Fzz0/MDWwNqywjDl7xi3HgrdzQ7JO5/aPiYlxWvvcc88pMTGxUjVlZ2dLkiIjI53WR0ZG6uDBg5Wqi0+DAAAAAAAA8C1u7Fl3+PBhhYaGOlZXtlfd+S6cyM0YU+nJ3UjWAQAAAAAAoN4KDQ11StZVhc1mk3Suh11UVJRjfU5OTqnedhUhWQcAAGqVMUYFZyr/aE5QgF+lf5X0lMqc46ki9zymBAAAUK/YjUoeY61eHe4RGxsrm82mtLQ0de7cWZJUVFSk9PR0zZw5s1J1kawDAAC1quBMsdo+u6rS++15vp/PjOdW1XMEAACAi4z93FLdOirhxIkT+u677xyvMzMzlZGRofDwcLVo0UIJCQlKSkpSXFyc4uLilJSUpODgYI0YMaJSx/GNT7wAAAAAAABACTeOWeeqLVu26JZbbnG8njRpkiRp9OjRWrx4saZMmaKCggKNGzdOubm56tatm1avXq2QkJBKHYdkHQAA8JgtT/dRcGD5s8OdKipW1xfW1GJE7lfROZ4vKMA9M+UBAADA/Xr37i1zkQSfxWJRYmJipWeSvRDJOgAA4DHBgX4+82jr+SoaZ+787b56jgAAAF7Ny8ascyc+OQIAAFSSr/f2AwAA8HkeeAy2tpCsAwAAAAAAgG8xckOyzi2RuB3JOgAAABcEBfhpz/P9qrQfAAAA4CqSdQAAwK0qM56bL7FYLIw9BwAA4C14DBYAAMA1jOcGAACAGme3S7K7oQ7vQ7LOTdzRSyAowE8Wi8UN0QAAAAAAANRh9KxDRdzRi2DP8/14vAYA4JNqYzw3V34Y89VHbAEAAIASZIYAAEC11cZ4bjxeCwAAAAd61qEsVe1FcL5TRcV8+QAAAAAAAKgMu5FUzWSbnWRdncOscAAA1Kzq/DBWmUdsAQAA4FuMscuY6k0QUd39awqZJgAA4LX4YQwAvIP9p86ynyr/R5Dbfnd/hXU0PJLn2rGCAyssY/wbVFjGLzOr4oNZrRUWsfgHVFimf9unKj5Wi6iK64l8qOJ6JJfi9o+yVVjm9muerbCMX8erKyxz263JFcfTqU2FZfq3fqLCMg2aN62wTHFWdoVl3Cm+wd0Vlkmzv18LkaCu4NMvAAAAAAAAfIsx1X+MlTHrAAAAAAAAADcwbhizjmQdAAAAAAAA4AZ2u2Sp5phzXjpmXcUP+gMAAAAAAACoFfSsAwAAAAAAgG/hMVgAAAAAAADAOxi7Xaaaj8EaL30MlmSdFzlVVOzpECRJQQF+slgsng4DAAAAAACgbPSsQ23o+sIaT4cgSdrzfD8FB9bvt4YxRgVn3Jc8JQEKAAAAAABcUb8zMvA63pIkKzhTrLbPrnJbHCRAAQAAAABwI7uRLPSsQw0ICvDTnuf7eToMnSoqrnbPPnck2twRx/lIkgEAAAAAUAcZI6maY86RrENZLBaL1yWTqjp2nrsTbe5QnXMpseXpPgoO9KtSHd52PQAAQM2p6g+XDJcBAEDlGbuRqWbPOkOyDr7CWxJM7kiSueNcggP9vC6h6qu85TFnAABqQlWH0eBJAAAAcD6Pfip4/fXX9dJLLykrK0vt2rVTSkqKbrrpJk+GBDepaqLtfCRi6h7GAoQn0eYAAOoz2kEAdY6xq/qPwVZz/xrisW+57733nhISEvT666+rZ8+eevPNN9W/f3/t2bNHLVq08FRY9Za7x87zZKKtJs6luqr6OG5d4+7r4C3Xtarvd3oa1h7aHAC1raIfLhkuA7WJdhBAXcRjsDVg9uzZuv/++/W///u/kqSUlBStWrVK8+bNU3JysqfCqre8cey8qvLGc+HDeGne8pizO3jLuIbu6NHqDt72/0+izQFQfa78QHR+mcoMo+EtPz75Im9sc7wR7SCAOomede5VVFSkrVu36sknn3Ra37dvX23YsKFU+cLCQhUWFjpe5+XlSZLy8/OrdPxTRWdlLzzlqOMsjTxqwPnvM5R29vRJnbVX/v/eWS+8rtc+87GnQ5DkPXHsml69nq0l93Z3/crl6TZHot0BfNX5/3cre4+t6P96derGf3lbm+ON3NYOnrj4F9qzZ09XGMvZ4sIKy0iSvbjifw+jip8mMPYiFw7mQhFTcT0NXDg3U1xxYt7iSsySa/kJe8WFjIv/JhU5e9aFpzuK3XMdZa+4TLE5U3E9LnLlM+BZF45Xnc+Svq6m7rVndUaqZpVn5b73ijt55NvCL7/8ouLiYkVGRjqtj4yMVHZ2dqnyycnJmj59eqn1MTEx1Y4lKqXaVQCoAv7v1V1hKe6p5/jx4woLC6t2Pd7U5ki894H6gv/rtcPb2hxv5K52sOW1P1RwpMSqB1kX7Pd0AFVU+i2AC4SFfeimeurmPaYyjh496pbrEBgYKJvNpvXZ/3RDVJLNZlNgYKBb6nIXj/60f+HYSsaYMsdbmjp1qiZNmuR4bbfb9euvv6pp06ZVHp8pPz9fMTExOnz4sEJDQ6tUR13DNXHG9SiNa+KM61GaO66JMUbHjx9XdHS0W2PzZJsj1Y/3C+dYN3COdQPn6JqaanO8UVXbwWPHjqlly5Y6dOiQTyUbfPH/gC/GLBF3bfLFmKVzPXRbtGih8PBwt9TXsGFDZWZmqqjIxZ6oFQgMDFTDhg3dUpe7eCRZ16xZM/n5+ZX6JScnJ6fULz6SZLVaZbVandY1btzYLbGEhob61Ju8NnBNnHE9SuOaOON6lFbda+LOLwPe1OZI9eP9wjnWDZxj3cA5VsyXElBV4Y52UDp3nXzxveSL/wd8MWaJuGuTL8YsSQ0aNHBbXQ0bNvS6BJs7ue9KVUJgYKC6dOmitLQ0p/VpaWnq0aOHJ0ICANRRtDkAgPqMdhAAfI/HHoOdNGmSRo0apa5du6p79+6aP3++Dh06pAcffNBTIQEA6ijaHABAfUY7CAC+xWPJunvuuUdHjx7V888/r6ysLLVv317//Oc/1bJly1o5vtVq1XPPPVdmF+/6imvijOtRGtfEGdejNG+9Jp5ucyTvvTbuxDnWDZxj3cA54nzVaQd99Tr7Yty+GLNE3LXJF2OWfDduT7KYujxPOQAAAAAAAOBDPDJmHQAAAAAAAIDSSNYBAAAAAAAAXoJkHQAAAAAAAOAlSNYBAAAAAAAAXqLeJutef/11xcbGqmHDhurSpYu++OILT4dUI5KTk3XdddcpJCREERERGjJkiPbt2+dUxhijxMRERUdHKygoSL1799bu3budyhQWFmrChAlq1qyZGjVqpEGDBunIkSO1eSo1Ijk5WRaLRQkJCY519e16/Pjjj/rtb3+rpk2bKjg4WNdcc422bt3q2F7frsfZs2f19NNPKzY2VkFBQbr88sv1/PPPy263O8rU5Wvy+eefa+DAgYqOjpbFYtFHH33ktN1d556bm6tRo0YpLCxMYWFhGjVqlI4dO1bDZ+c5db3Nqeh94+tcaUt93bx589SxY0eFhoYqNDRU3bt314oVKzwdVo0q6zOAr0tMTJTFYnFabDabp8Nyu4o+u8C9fK0N88U2yVfbmbrQdvhKW+Cr93fu11VXL5N17733nhISEjRt2jRt375dN910k/r3769Dhw55OjS3S09P1/jx47Vx40alpaXp7Nmz6tu3r06ePOkoM2vWLM2ePVtz587V5s2bZbPZFB8fr+PHjzvKJCQkaPny5Vq2bJnWr1+vEydOaMCAASouLvbEabnF5s2bNX/+fHXs2NFpfX26Hrm5uerZs6cCAgK0YsUK7dmzRy+//LIaN27sKFOfrockzZw5U2+88Ybmzp2rvXv3atasWXrppZc0Z84cR5m6fE1OnjypTp06ae7cuWVud9e5jxgxQhkZGVq5cqVWrlypjIwMjRo1qsbPzxPqQ5tT0fvG17nSlvq6yy67TC+++KK2bNmiLVu26NZbb9XgwYNLJePrivI+A9QF7dq1U1ZWlmPZuXOnp0NyK1c+u8B9fLEN88U2yVfbGV9vO3ytLfC1+zv362oy9dD1119vHnzwQad1bdq0MU8++aSHIqo9OTk5RpJJT083xhhjt9uNzWYzL774oqPM6dOnTVhYmHnjjTeMMcYcO3bMBAQEmGXLljnK/Pjjj6ZBgwZm5cqVtXsCbnL8+HETFxdn0tLSTK9evcyjjz5qjKl/1+OJJ54wN954Y7nb69v1MMaYO++809x3331O64YOHWp++9vfGmPq1zWRZJYvX+547a5z37Nnj5FkNm7c6Cjz5ZdfGknmm2++qeGzqn31rc258H1TF13YltZVTZo0MX/+8589HYbblfcZoC547rnnTKdOnTwdRo2q6LML3MvX2zBfbZN8uZ3xlbbD19oCX7y/c7+unnrXs66oqEhbt25V3759ndb37dtXGzZs8FBUtScvL0+SFB4eLknKzMxUdna20/WwWq3q1auX43ps3bpVZ86ccSoTHR2t9u3b++w1Gz9+vO6880716dPHaX19ux4ff/yxunbtqrvvvlsRERHq3LmzFixY4Nhe366HJN1444369NNPtX//fknS119/rfXr1+uOO+6QVD+vSQl3nfuXX36psLAwdevWzVHmhhtuUFhYmE9fn7LU9zanrrqwLa1riouLtWzZMp08eVLdu3f3dDhuV95ngLri22+/VXR0tGJjYzV8+HAdOHDA0yG5VUWfXeA+tGGe44vtjK+1Hb7YFvja/Z37dfX4ezqA2vbLL7+ouLhYkZGRTusjIyOVnZ3toahqhzFGkyZN0o033qj27dtLkuOcy7oeBw8edJQJDAxUkyZNSpXxxWu2bNkybdu2TZs3by61rb5djwMHDmjevHmaNGmSnnrqKW3atEmPPPKIrFarfve739W76yFJTzzxhPLy8tSmTRv5+fmpuLhYM2bM0L333iup/r1Hzueuc8/OzlZERESp+iMiInz6+pSlPrc5dVVZbWldsXPnTnXv3l2nT5/WJZdcouXLl6tt27aeDsutLvYZoC7o1q2b3nrrLbVu3Vo//fSTXnjhBfXo0UO7d+9W06ZNPR2eW1T02QXuQxvmGb7Wzvhi2+GLbYEv3t+5X1dPvUvWlbBYLE6vjTGl1tU1Dz/8sHbs2KH169eX2laV6+GL1+zw4cN69NFHtXr1ajVs2LDccvXletjtdnXt2lVJSUmSpM6dO2v37t2aN2+e0w20vlwP6dzYLEuWLNHSpUvVrl07ZWRkKCEhQdHR0Ro9erSjXH26Jhdyx7mXVb6uXJ+y1Mc2p666WFvq66666iplZGTo2LFj+uCDDzR69Gilp6d7/ZcuV7n6GcCX9e/f3/H3Dh06qHv37rriiiuUmpqqSZMmeTAy93H1swvchzasdvlaO+NrbYevtgW+eH/nfl099e4x2GbNmsnPz6/Ur0E5OTmlfjWqSyZMmKCPP/5Ya9eu1WWXXeZYXzKDzMWuh81mU1FRkXJzc8st4yu2bt2qnJwcdenSRf7+/vL391d6err+9Kc/yd/f33E+9eV6REVFlWpIr776asegwfXt/SFJjz/+uJ588kkNHz5cHTp00KhRozRx4kQlJydLqp/XpIS7zt1ms+mnn34qVf/PP//s09enLPW1zamrymtL64rAwEBdeeWV6tq1q5KTk9WpUye9+uqrng7LbSr6DODtEwBVRaNGjdShQwd9++23ng7FbSr67AL3oQ2rfb7Yzvha21FX2gJfuL9zv66eepesCwwMVJcuXZSWlua0Pi0tTT169PBQVDXHGKOHH35YH374oT777DPFxsY6bY+NjZXNZnO6HkVFRUpPT3dcjy5duiggIMCpTFZWlnbt2uVz1+y2227Tzp07lZGR4Vi6du2qkSNHKiMjQ5dffnm9uh49e/YsNS38/v371bJlS0n17/0hSadOnVKDBs63Rj8/P9ntdkn185qUcNe5d+/eXXl5edq0aZOjzFdffaW8vDyfvj5lqW9tTl1VUVtaVxljVFhY6Okw3KaizwB+fn6eDtHtCgsLtXfvXkVFRXk6FLep6LML3Ic2rPbUpXbG29uOutIW+ML9nft1NdXmbBbeYtmyZSYgIMAsXLjQ7NmzxyQkJJhGjRqZH374wdOhud1DDz1kwsLCzLp160xWVpZjOXXqlKPMiy++aMLCwsyHH35odu7cae69914TFRVl8vPzHWUefPBBc9lll5k1a9aYbdu2mVtvvdV06tTJnD171hOn5VYXzv5Tn67Hpk2bjL+/v5kxY4b59ttvzTvvvGOCg4PNkiVLHGXq0/UwxpjRo0ebSy+91Pz97383mZmZ5sMPPzTNmjUzU6ZMcZSpy9fk+PHjZvv27Wb79u1Gkpk9e7bZvn27OXjwoDHGfed+++23m44dO5ovv/zSfPnll6ZDhw5mwIABtX6+taE+tDkVvW98nSttqa+bOnWq+fzzz01mZqbZsWOHeeqpp0yDBg3M6tWrPR1ajfKFGQAr47HHHjPr1q0zBw4cMBs3bjQDBgwwISEhdep+48pnF7iPL7Zhvtgm+Wo7U1faDl9oC3zx/s79unrqZbLOGGNee+0107JlSxMYGGiuvfZan5wW2xWSylwWLVrkKGO3281zzz1nbDabsVqt5uabbzY7d+50qqegoMA8/PDDJjw83AQFBZkBAwaYQ4cO1fLZ1IwLb8717Xp88sknpn379sZqtZo2bdqY+fPnO22vb9cjPz/fPProo6ZFixamYcOG5vLLLzfTpk0zhYWFjjJ1+ZqsXbu2zHvG6NGjjTHuO/ejR4+akSNHmpCQEBMSEmJGjhxpcnNza+ksa19db3Mqet/4OlfaUl933333Od6jzZs3N7fddpvPfdmqCl/4glYZ99xzj4mKijIBAQEmOjraDB061OzevdvTYbldRZ9d4F6+1ob5Ypvkq+1MXWk7fKEt8NX7O/frqrMYY0zN9t0DAAAAAAAA4Ip6N2YdAAAAAAAA4K1I1gEAAAAAAABegmQdAAAAAAAA4CVI1gEAAAAAAABegmQdAAAAAAAA4CVI1gEAAAAAAABegmQdAAAAAAAA4CVI1gEAAAAAAABegmQdfMKYMWM0ZMiQKu27bt06WSwWHTt2zK0xVVZiYqIiIyNlsVj00UcfeTSWyvL0NbRYLLJYLGrcuHGdOA4A3/Kvf/1LHTp0UEBAgIYMGVLqnrh48eIavW8kJibqmmuuqbH68V+tWrVSSkqKR449ZswYRztUk58Taus4QH1Gu1F/0G6gppCsQ5X07t1bCQkJtbZfdfTo0UNZWVkKCwur1eOeb+/evZo+fbrefPNNZWVlqX///h6Jo6ofDLzhGi5atEj79+93WldUVKSXXnpJ1157rRo1aqSwsDB16tRJTz/9tP797387yp3fwFgsFjVt2lS33367duzY4VRfVlaWxxpbAN5r0qRJuuaaa5SZmanFixfX+j1x8uTJ+vTTT2vlWHVFVb9QbN68Wf/v//0/9wfkottvv73Mzwlr167VgAED1Lx5czVs2FBXXHGF7rnnHn3++eeOMiXJgJIlKChI7dq10/z5853qevXVV5WVlVUr5wPUV7Qbvod2g3bD25CsQ50XGBgom80mi8XisRi+//57SdLgwYNls9lktVo9FktV1NY1PHPmTLnbGjdurIiICMfrwsJCxcfHKykpSWPGjNHnn3+urVu3atasWTp69KjmzJnjtH9JQ5aVlaVPP/1U/v7+GjBggFMZm83m0YQkgNKKi4tlt9s9GsP333+vW2+9VZdddpkaN25c6+3KJZdcoqZNm9bKsdzpYvd0b9W8eXMFBwfX6DGKiorK3Wa1Wkt9Tnj99dd12223qWnTpnrvvfe0d+9evf322+rRo4cmTpxYqo59+/YpKytLe/bs0dixY/XQQw85fWkPCwuTzWZz70kBXoR2g3ajNtFuoMYYoJJGjx5tJDktmZmZxhhj1q1bZ6677joTGBhobDabeeKJJ8yZM2cuut/Zs2fNfffdZ1q1amUaNmxoWrdubVJSUkodc/DgweXG9MMPP5gBAwaYxo0bm+DgYNO2bVvzj3/8wxhjzNq1a40kk5uba4wxplevXqXiOP8cjh07Zh544AHTvHlzExISYm655RaTkZFx0WuyY8cOc8stt5iGDRua8PBw88ADD5jjx48bY4x57rnnSh2rPLt27TJ33HGHCQkJMZdccom58cYbzXfffWeMMaa4uNhMnz7dXHrppSYwMNB06tTJrFixwrFvZmamkWQ++OAD07t3bxMUFGQ6duxoNmzY4HQdzl+ee+45Y4wxb7/9tunSpYu55JJLTGRkpLn33nvNTz/95Kj7wmu4aNEiExYWZlauXGnatGljGjVqZPr162f+/e9/O53PX/7yF9OmTRtjtVrNVVddZV577bVS8b733numV69exmq1mr/85S9lXhdJZvny5U7rkpOTTYMGDcy2bdvK3Mdutzv+Xtb75/PPPzeSTE5OjtP6knMDUNqKFStMz549TVhYmAkPDzd33nmn4x5ljDE33HCDeeKJJ5z2ycnJMf7+/uazzz4zxhhTWFhoHn/8cRMdHW2Cg4PN9ddfb9auXesoX/J/8JNPPjFXX3218fPzMwcOHDCbNm0yffr0MU2bNjWhoaHm5ptvNlu3bnU61t69e03Pnj2N1Wo1V199tUlLSyt1/zhy5IgZNmyYady4sQkPDzeDBg1y3P8vVHKfOn9ZtGhRuffE83388cfm2muvNVar1cTGxprExERHe1iWtWvXmuuuu84EBwebsLAw06NHD/PDDz8YY861I506dXKULasNa9mypWP77t27Tf/+/U2jRo1MRESE+e1vf2t+/vnnco9dEv/y5ctNXFycsVqtpk+fPubQoUOVOidJZt68eWbQoEEmODjYPPvss2Ue7/Tp0+bxxx83l112mQkMDDRXXnml+fOf/+zYfrHPEsaca8cnTJhgHn/8cdOkSRMTGRnpaM+MMaZly5ZlXpvvvvvODBo0yERERJhGjRqZrl27mrS0NKfYWrZsaV555RWnc1qwYIEZMmSICQoKMldeeaX529/+5rRPRde7V69eZvz48WbixImmadOm5uabby7zupTVVh08eNAEBASYiRMnlrnP+W3dhe/LEpdffrmZNWtWqX3LalsBd6PdoN2g3aDdQNWQrEOlHTt2zHTv3t088MADJisry2RlZZmzZ8+aI0eOmODgYDNu3Dizd+9es3z5ctOsWTPHjbC8/YqKisyzzz5rNm3aZA4cOGCWLFligoODzXvvvec4ZkXJujvvvNPEx8ebHTt2mO+//9588sknJj093RhT+iZ09OhRx/GzsrLM0KFDzVVXXWVOnTpl7Ha76dmzpxk4cKDZvHmz2b9/v3nsscdM06ZNzdGjR8s89smTJ010dLQZOnSo2blzp/n0009NbGysGT16tDHGmOPHj5tFixYZSY5jluXIkSMmPDzcDB061GzevNns27fP/OUvfzHffPONMcaY2bNnm9DQUPPuu++ab775xkyZMsUEBASY/fv3G2P+++GgTZs25u9//7vZt2+f+Z//+R/TsmVLc+bMGVNYWGhSUlJMaGioI46ShOLChQvNP//5T/P999+bL7/80txwww2mf//+jtjK+oAREBBg+vTpYzZv3my2bt1qrr76ajNixAjHPvPnzzdRUVHmgw8+MAcOHDAffPCBCQ8PN4sXL3aKt1WrVo4yP/74Y5nXpqyGoWPHjqZfv35llr/Qhe+f48ePm7Fjx5orr7zSFBcXO5UlWQeU769//av54IMPzP79+8327dvNwIEDTYcOHRz/j+bMmWNatGjh9EFwzpw55tJLL3WUGTFihOnRo4f5/PPPzXfffWdeeuklY7VaHfeykvtLjx49zL/+9S/zzTffmBMnTphPP/3UvP3222bPnj1mz5495v777zeRkZEmPz/fGHPuB42rrrrKxMfHm4yMDPPFF1+Y66+/3un+cfLkSRMXF2fuu+8+s2PHDrNnzx4zYsQIc9VVV5nCwsJS53v27FmTlZVlQkNDTUpKisnKyjKnTp2q8EvXypUrTWhoqFm8eLH5/vvvzerVq02rVq1MYmJimdf1zJkzJiwszEyePNl89913Zs+ePWbx4sXm4MGDxpjSX7rOb8O+++47c+WVV5pRo0YZY4z597//bZo1a2amTp1q9u7da7Zt22bi4+PNLbfcUu6/a8k179q1q9mwYYPZsmWLuf76602PHj0qdU6STEREhFm4cKH5/vvvHV8aLzRs2DATExNjPvzwQ/P999+bNWvWmGXLlhljTIWfJYw59yUmNDTUJCYmmv3795vU1FRjsVjM6tWrjTHnvuiXfEHOyspy/CiTkZFh3njjDbNjxw6zf/9+M23aNNOwYUPHdTam7C9dl112mVm6dKn59ttvzSOPPGIuueQSx2cCV653r169zCWXXGIef/xx880335i9e/eWeV3K+qwze/Zsx+eHilz4vrTb7WbFihUmICDA8ZnofHzpQm2g3aDdoN2g3UDVkKxDlfTq1cs8+uijTuueeuopc9VVVzk1tq+99pq55JJLHI1tWfuVZdy4ceY3v/mN43VFyboOHTqU25iV94uBMeduZo0bNzb79u0zxhjz6aefmtDQUHP69GmncldccYV58803y6x//vz5pkmTJubEiROOdf/4xz9MgwYNTHZ2tjHGmOXLl1+0R50xxkydOtXExsaaoqKiMrdHR0ebGTNmOK277rrrzLhx44wx/01+nf8r0+7du40kxw3e1UTUpk2bjCRHMq+sDxiSnH4Zfe2110xkZKTjdUxMjFm6dKlTvX/4wx9M9+7dneK9sBdlWcpqGBo2bGgeeeQRp3VDhgwxjRo1Mo0aNXIcx5hz7x8/Pz/HNkkmKiqq1K+rJedGsg5wTcmH2507dzpe+/v7m88//9xRpnv37ubxxx83xpz7hdpisZRKzN92221m6tSpxpj/3l8q6tF89uxZExISYj755BNjzLneG/7+/k4fTi/sIbFw4cJS7VRhYaEJCgoyq1atKvdYYWFhZtGiRY7XFX3puummm0xSUpJTHW+//baJiooqs/6jR48aSWbdunVlbr/wS1cJu91u7rrrLtOlSxdz6tQpY4wxzzzzjOnbt69TucOHDxtJjrbuQiXXfOPGjY51e/fuNZLMV1995fI5STIJCQllHqPEvn37jKRSPRNKuPpZ4sYbb3Ta77rrrnPqnePqF4q2bduaOXPmOF6X9aXr6aefdrw+ceKEsVgsjp7trlzvXr16mWuuuabCWMr6rPPggw+a0NBQp3V//etfHe1Zo0aNzI4dO4wx/31flqz39/c3DRo0MC+88EKZx+NLFzyBdiPXETPtBu1GCdoNlMVfgJvs3btX3bt3dxqLoWfPnjpx4oSOHDmiFi1alLvvG2+8oT//+c86ePCgCgoKVFRUVKkZjB555BE99NBDWr16tfr06aPf/OY36tix40X3WbFihZ588kl98sknat26tSRp69atOnHiRKkxHgoKChzjzl1o79696tSpkxo1auRY17NnT9ntdu3bt0+RkZEunUNGRoZuuukmBQQElNqWn5+vf//73+rZs6fT+p49e+rrr792Wnf+eUdFRUmScnJy1KZNm3KPvX37diUmJiojI0O//vqrY5yPQ4cOqW3btmXuExwcrCuuuMLpWDk5OZKkn3/+WYcPH9b999+vBx54wFHm7NmzpcaE69q1a7lxVeTCcT9ef/11nTx5Un/605+cBk+VpFtuuUXz5s2TJP366696/fXX1b9/f23atEktW7ascgxAffL999/rmWee0caNG/XLL7843Svat2+v5s2bKz4+Xu+8845uuukmZWZm6ssvv3T839u2bZuMMY57bonCwkKn+25gYGCpe3hOTo6effZZffbZZ/rpp59UXFysU6dO6dChQ5LOjbcSExPjNKbK9ddf71TH1q1b9d133ykkJMRp/enTp8u9x1fF1q1btXnzZs2YMcOxrri4WKdPn9apU6dKjW0THh6uMWPGqF+/foqPj1efPn00bNgwxz28PE899ZS+/PJLbd68WUFBQY5jr127Vpdcckmp8t9//32pa1/C39/f6X7cpk0bNW7cWHv37tX111/v8jlVdE/PyMiQn5+fevXqVeZ2Vz9LXPj+OL8NKs/Jkyc1ffp0/f3vf9e///1vnT17VgUFBY73UHnOP1ajRo0UEhLiOJar19udbV2/fv2UkZGhH3/8Ub1791ZxcbHT9i+++EIhISEqLCzUpk2b9PDDDys8PFwPPfRQlWMAqop2wzW0G+Wj3ag82o26gWQd3MYYU+rGYIyRVPqGcb7/+7//08SJE/Xyyy+re/fuCgkJ0UsvvaSvvvrK5WP/7//+r/r166d//OMfWr16tZKTk/Xyyy9rwoQJZZbfs2ePhg8frhdffFF9+/Z1rLfb7YqKitK6detK7VPeLKplnXeJygwiW9JgXkxZ1/fCdecn+0q2XWyQ3ZMnT6pv377q27evlixZoubNm+vQoUPq16/fRQczvTCpaLFYHP/eJcdbsGCBunXr5lTOz8/P6fX5Sc7KiIuL0zfffOO0ruQDSnh4eKnyjRo10pVXXul43aVLF4WFhWnBggV64YUXqhQDUN8MHDhQMTExWrBggaKjo2W329W+fXune8XIkSP16KOPas6cOVq6dKnatWunTp06STp3b/Dz89PWrVtL3QvO/9AaFBRU6t42ZswY/fzzz0pJSVHLli1ltVrVvXt3x7Evdi8uYbfb1aVLF73zzjultjVv3rxyF6OC40yfPl1Dhw4tta1hw4Zl7rNo0SI98sgjWrlypd577z09/fTTSktL0w033FBm+SVLluiVV17RunXrdNlllzkde+DAgZo5c2apfSr6ElfW9Tu/HXHlnCq6p1fU1rn6WaKsNqiiAeUff/xxrVq1Sn/84x915ZVXKigoSP/zP/9z0bauomO5er2r09bl5eUpOzvbkVC45JJLdOWVV8rfv+yP8bGxsY7PLO3atdNXX32lGTNm8KULHkG74RrajfLRblQO7UbdQbIOVRIYGFgqI9+2bVt98MEHTjfMDRs2KCQkRJdeemm5+33xxRfq0aOHxo0b51hXlV+qYmJi9OCDD+rBBx/U1KlTtWDBgjKTdUePHtXAgQM1dOjQUrPhXHvttcrOzpa/v79atWrl0nHbtm2r1NRUnTx50nFT/de//qUGDRqU+0tUWTp27KjU1FSdOXOm1A0+NDRU0dHRWr9+vW6++WbH+g0bNpT6BfBiyrr+33zzjX755Re9+OKLiomJkSRt2bLF5TrLEhkZqUsvvVQHDhzQyJEjq1VXee699149/fTT2r59uzp37lzp/S0Wixo0aKCCgoIaiA6oe44ePaq9e/fqzTff1E033SRJWr9+falyQ4YM0dixY7Vy5UotXbpUo0aNcmzr3LmziouLlZOT46jDVV988YVef/113XHHHZKkw4cP65dffnFsb9OmjQ4dOqSffvrJ0aN58+bNTnVce+21eu+99xQREaHQ0NBKHb8yrr32Wu3bt8/pBwJXdO7cWZ07d9bUqVPVvXt3LV26tMwvXV9++aX+93//V2+++Wap7ddee60++OADtWrVqtwP5WU5e/astmzZ4mhT9u3bp2PHjjl6ZVf1nC7UoUMH2e12paenq0+fPqW2u/JZwhUBAQFlft4YM2aM7rrrLknSiRMn9MMPP1T9ZFT16+2q//mf/9GTTz6pmTNn6pVXXqlSHX5+frR18AjaDdfRbpSPdqNyaDfqjgaeDgC+qVWrVvrqq6/0ww8/OLq0jxs3TocPH9aECRP0zTff6G9/+5uee+45TZo0SQ0aNCh3vyuvvFJbtmzRqlWrtH//fj3zzDOlGsqKJCQkaNWqVcrMzNS2bdv02Wef6eqrry6z7NChQxUUFKTExERlZ2c7luLiYvXp00fdu3fXkCFDtGrVKv3www/asGGDnn766XITWCNHjlTDhg01evRo7dq1S2vXrtWECRM0atQolx+BlaSHH35Y+fn5Gj58uLZs2aJvv/1Wb7/9tvbt2yfp3C87M2fO1Hvvvad9+/bpySefVEZGhh599FGXj9GqVSudOHFCn376qX755RedOnVKLVq0UGBgoObMmaMDBw7o448/1h/+8AeX6yxPYmKikpOT9eqrr2r//v3auXOnFi1apNmzZ1e7bkmaOHGiunfvrltvvVWvvvqqtm3bpszMTK1atUorVqwo9etrYWGh49967969mjBhgk6cOKGBAwe6JR6grmvSpImaNm2q+fPn67vvvtNnn32mSZMmlSrXqFEjDR48WM8884z27t2rESNGOLa1bt1aI0eO1O9+9zt9+OGHyszM1ObNmzVz5kz985//vOjxr7zySr399tvau3evvvrqK40cOdLp1/b4+HhdccUVGj16tHbs2KF//etfmjZtmqT//rI+cuRINWvWTIMHD9YXX3yhzMxMpaen69FHH9WRI0fccZkkSc8++6zeeustJSYmavfu3dq7d6+j10NZMjMzNXXqVH355Zc6ePCgVq9erf3795fZjmVnZ+uuu+7S8OHD1a9fP8d97eeff5YkjR8/Xr/++qvuvfdebdq0SQcOHNDq1at13333lfoScr6AgABNmDBBX331lbZt26bf//73uuGGGxxfwip7TuVp1aqVRo8erfvuu08fffSRMjMztW7dOv3f//2fJLn0WcLV43z66afKzs5Wbm6upHPvoQ8//FAZGRn6+uuvNWLEiAp7VVSkqtfbVS1atNDLL7+sV199VaNHj9batWv1ww8/aNu2bfrTn/4kqXSP9ZycHGVnZ+vgwYN6//339fbbb2vw4MHVjgWoLNoN19FulI92o3JoN+qQ2h8mD3XBvn37zA033GCCgoKMJMf05RVNm13WfqdPnzZjxowxYWFhpnHjxuahhx4yTz75pNOgqBVNMPHwww+bK664wlitVtO8eXMzatQo88svvxhjSg/oqjKmLj//HPLz882ECRNMdHS0CQgIMDExMWbkyJGlpiI/344dO8wtt9xiGjZsaMLDw80DDzzgmJzBGNcmmDDGmK+//tr07dvXBAcHm5CQEHPTTTeZ77//3hhzbsaq6dOnm0svvdQEBASYTp06OQYqNea/EzZs377dsS43N9dIcpre/sEHHzRNmzY1khyzJC1dutS0atXKWK1W0717d/Pxxx871eXKdPNlneM777xjrrnmGhMYGGiaNGlibr75ZvPhhx+WG295VM5gpqdPnzYvvvii6dSpkwkKCjJWq9W0adPGTJw40enfa/To0U7/1iEhIea6664zf/3rX0vVyQQTQPnS0tLM1VdfbaxWq+nYsaNZt25dmf8///GPfxhJ5uabby5VR8kM4K1atTIBAQHGZrOZu+66yzHYcXn/B7dt22a6du1qrFariYuLM++//36pQZ337t1revbsaQIDA02bNm3MJ598YiSZlStXOspkZWWZ3/3ud6ZZs2bGarWayy+/3DzwwAMmLy+v3POu7EDhxpybBa9Hjx4mKCjIhIaGmuuvv97Mnz+/zPqzs7PNkCFDTFRUlAkMDDQtW7Y0zz77rGNg7PMHCi859oVLy5YtHfXt37/f3HXXXaZx48YmKCjItGnTxiQkJDgNvn2+kvg/+OADc/nll5vAwEBz6623lpqVr6JzKu9efaGCggIzceJEx/leeeWV5i9/+Ytje0WfJcqarGrw4MGOWdiNMebjjz82V155pfH393dcm8zMTHPLLbeYoKAgExMTY+bOnVuqrrIGCr/wnC58P1R0vV2dXOtin3XS0tJM//79TXh4uPH39zeRkZFmyJAhTu/tC98b/v7+JjY21kyePNlpEqyLnRvgbrQb59Bu0G7QbqCyLMb854FuAPBSFotFy5cv1/9v7w5tFYaiMACfAepgAeYAyQBYHIpUsgOaHQgLgKgDyxYVJDhUwwRPoEgQLySXd8r7vgVOVf/0z709s9ms+Kztdhur1Sq6ris+CyjrfD7HZDKJtm2fFuLwzHsvh8ViEV3XxeFw+Mi8T2Yr9IXc+B25kYPc+G6uwQK9MJ/Pn36GW0JVVVHXddEZQDn7/T6Ox2NcLpc4nU6xXC5jPB774KI3mqaJqqqiaZpiM+q6frmFEP4juUHfyY3v5WQdkF7bthHx+L/CaDTq/RygjN1uF+v1Oq7XawyHw5hOp7HZbGIwGPz1o6XmhEQOt9st7vd7RDw2Ar67CTDLHOgDufEeuZGD3PhuyjoAAAAASMI1WAAAAABIQlkHAAAAAEko6wAAAAAgCWUdAAAAACShrAMAAACAJJR1AAAAAJCEsg4AAAAAklDWAQAAAEASP5U1dpI4irdNAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 1284x400 with 4 Axes>"
+       "<Figure size 1831.84x400 with 6 Axes>"
       ]
      },
      "metadata": {},
@@ -98,13 +101,16 @@
     "import hist\n",
     "import matplotlib.pyplot as plt\n",
     "\n",
-    "fig, (ax1, ax2, ax3) = plt.subplots(figsize=(12, 4), ncols=3, constrained_layout=True)\n",
+    "fig, (ax1, ax2, ax3, ax4) = plt.subplots(figsize=(16, 4), ncols=4, constrained_layout=True)\n",
+    "\n",
+    "hist.new.Regular(20, 0, 1_000, label=\"total size of container [GB]\").Double().fill(sizes_output_GB).plot(ax=ax1, yerr=False)\n",
+    "h = hist.new.Regular(30, 0, 5, label=\"average file size per container [GB]\").Double().fill(avg_sizes_output_GB).plot(ax=ax2, yerr=False)\n",
     "\n",
-    "hist.new.Regular(20, 0, 1000, label=\"total size of container [GB]\").Double().fill(sizes_output_GB).plot(ax=ax1, yerr=False)\n",
-    "h = hist.new.Regular(30, 0, 6, label=\"average file size per container [GB]\").Double().fill(avg_sizes_output_GB).plot(ax=ax2, yerr=False)\n",
+    "h = hist.new.Regular(30, 0, 5, label=\"average file size per container [GB]\").Regular(20, 0, 1_000, label=\"total size of container [GB]\").Double()\n",
+    "_ = h.fill(avg_sizes_output_GB, sizes_output_GB).plot(ax=ax3, cmin=1)\n",
     "\n",
-    "h = hist.new.Regular(30, 0, 6, label=\"average file size per container [GB]\").Regular(20, 0, 1000, label=\"total size of container [GB]\").Double()\n",
-    "_ = h.fill(avg_sizes_output_GB, sizes_output_GB).plot(ax=ax3, cmin=1)"
+    "h = hist.new.Regular(30, 0, 5, label=\"average file size per container [GB]\").Regular(50, 0, 500, label=\"number of files in container\").Double()\n",
+    "_ = h.fill(avg_sizes_output_GB, nfiles_output).plot(ax=ax4, cmin=1)"
    ]
   }
  ],
@@ -124,7 +130,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.5"
+   "version": "3.12.11"
   }
  },
  "nbformat": 4,
diff --git a/atlas/utils.py b/atlas/utils.py
index 4a5a6de..94b8afd 100644
--- a/atlas/utils.py
+++ b/atlas/utils.py
@@ -1,10 +1,56 @@
 # saving preprocessing output
+import asyncio
 import base64
 import dataclasses
+import datetime
 import re
 import urllib.request
 
 import coffea
+import matplotlib.pyplot as plt
+
+
+##################################################
+### Dask task tracking
+##################################################
+
+def start_tracking(dask_scheduler) -> None:
+    """"run on scheduler to track worker count"""
+    dask_scheduler.worker_counts = {}
+    dask_scheduler.track_count = True
+
+    async def track_count() -> None:
+        while dask_scheduler.track_count:
+            dask_scheduler.worker_counts[datetime.datetime.now()] = len(dask_scheduler.workers)
+            await asyncio.sleep(1)
+
+    asyncio.create_task(track_count())
+
+
+def stop_tracking(dask_scheduler) -> dict:
+    """obtain worker count and stop tracking"""
+    dask_scheduler.track_count = False
+    return dask_scheduler.worker_counts
+
+
+def get_avg_num_workers(worker_count_dict: dict) -> float:
+    """get time-averaged worker count"""
+    worker_info = list(worker_count_dict.items())
+    nworker_dt = 0
+    for (t0, nw0), (t1, nw1) in zip(worker_info[:-1], worker_info[1:]):
+        nworker_dt += (nw1 + nw0) / 2 * (t1 - t0).total_seconds()
+    return nworker_dt / (worker_info[-1][0] - worker_info[0][0]).total_seconds()
+
+
+def plot_worker_count(worker_count_dict: dict):
+    """plot worker count over time"""
+    fig, ax = plt.subplots()
+    ax.plot(worker_count_dict.keys(), worker_count_dict.values())
+    ax.tick_params(axis="x", labelrotation=45)
+    ax.set_ylim([0, ax.get_ylim()[1]])
+    ax.set_xlabel("time")
+    ax.set_ylabel("number of workers")
+    return fig, ax
 
 
 ##################################################