diff --git a/asyncflow_queue_limit/asyncflow_mm1.ipynb b/asyncflow_queue_limit/asyncflow_mm1.ipynb
new file mode 100644
index 0000000..db36b08
--- /dev/null
+++ b/asyncflow_queue_limit/asyncflow_mm1.ipynb
@@ -0,0 +1,646 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# AsyncFlow — MM1 Theory vs Simulation (Guided Notebook)\n",
+        "\n",
+        "This notebook shows how to:\n",
+        "\n",
+        "1. Make imports work inside a notebook (src-layout or package install)\n",
+        "2. Build a **single-server** scenario compatible with **M/M/1** assumptions\n",
+        "3. Run the simulation and collect results\n",
+        "4. Compare theory vs observed KPIs (pretty-printed table)\n",
+        "5. Plot the standard dashboards (latency, throughput, server time series)\n",
+        "\n",
+        "> Tip: run this notebook from your project **root folder**.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "c3a69413",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import sys, importlib\n",
+        "\n",
+        "# 1) Svuota tutto ciò che inizia con 'asyncflow' da sys.modules\n",
+        "for m in list(sys.modules):\n",
+        "    if m.startswith(\"asyncflow\"):\n",
+        "        del sys.modules[m]\n",
+        "\n",
+        "from asyncflow import AsyncFlow, SimulationRunner\n",
+        "from asyncflow.analysis import MMc, ResultsAnalyzer, SweepAnalyzer\n",
+        "from asyncflow.components import (\n",
+        "    Client, Server, LinkEdge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
+        ")\n",
+        "from asyncflow.settings import SimulationSettings\n",
+        "\n",
+        "import simpy"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "tags": [
+          "imports"
+        ]
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Imports OK.\n"
+          ]
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import simpy\n",
+        "\n",
+        "# Public AsyncFlow API\n",
+        "from asyncflow import AsyncFlow, SimulationRunner, Sweep\n",
+        "from asyncflow.components import Client, Server, LinkEdge, Endpoint, ArrivalsGenerator\n",
+        "from asyncflow.settings import SimulationSettings\n",
+        "from asyncflow.analysis import MMc, ResultsAnalyzer, SweepAnalyzer\n",
+        "from asyncflow.enums import Distribution\n",
+        "\n",
+        "print(\"Imports OK.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1) Build an M/M/1-friendly scenario\n",
+        "\n",
+        "* **Single server with exponential CPU service**\n",
+        "  One server, one endpoint, exactly **one CPU-bound step** with an **Exponential** service-time RV (mean $E[S]$). No RAM/IO steps in the pipeline.\n",
+        "\n",
+        "* **No load balancer**\n",
+        "  Topology has **exactly one server** and **no LB** (no fan-out, no parallelism).\n",
+        "\n",
+        "* **Deterministic, very small network latency**\n",
+        "  All edges use a **fixed latency** $\\ll 1\\,\\mathrm{ms}$ so queueing is dominated by CPU service (closer to textbook M/M/1).\n",
+        "\n",
+        "* **“Poisson arrivals” via the generator**\n",
+        " \n",
+        "\n",
+        "```mermaid\n",
+        "graph LR;\n",
+        "    rqs1[\"<b>ArrivalsGenerator</b><br/>id: rqs-1\"]\n",
+        "    client1[\"<b>Client</b><br/>id: client-1\"]\n",
+        "    app1[\"<b>Server</b><br/>id: app-1<br/>Endpoint: /api\"]\n",
+        "\n",
+        "    rqs1 -- \"Edge: gen-client<br/>Latency: 0.0001\" --> client1;\n",
+        "    client1 -- \"Request<br/>Edge: client-app<br/>Latency: 0.0001\" --> app1;\n",
+        "    app1 -- \"Response<br/>Edge: app-client<br/>Latency: 0.0001\" --> client1;"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "tags": [
+          "build"
+        ]
+      },
+      "outputs": [],
+      "source": [
+        "def build_payload():\n",
+        "    generator = ArrivalsGenerator(\n",
+        "        id=\"rqs-1\",\n",
+        "        lambda_rps=30,\n",
+        "        model=Distribution.POISSON\n",
+        "    )\n",
+        "\n",
+        "    client = Client(id=\"client-1\")\n",
+        "\n",
+        "    endpoint = Endpoint(\n",
+        "        endpoint_name=\"/api\",\n",
+        "        probability=1.0,\n",
+        "        steps=[\n",
+        "            {\n",
+        "                \"kind\": \"initial_parsing\",  # CPU-bound step\n",
+        "                \"step_operation\": {\n",
+        "                    \"cpu_time\": {\"mean\": 0.015, \"distribution\": \"exponential\"},\n",
+        "                },\n",
+        "            },\n",
+        "        ],\n",
+        "    )\n",
+        "\n",
+        "    server = Server(\n",
+        "        id=\"app-1\",\n",
+        "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+        "        endpoints=[endpoint],\n",
+        "    )\n",
+        "\n",
+        "    e_gen_client = LinkEdge(id=\"gen-client\", source=\"rqs-1\", target=\"client-1\")\n",
+        "    e_client_app = LinkEdge(id=\"client-app\", source=\"client-1\", target=\"app-1\")\n",
+        "    e_app_client = LinkEdge(id=\"app-client\", source=\"app-1\", target=\"client-1\")\n",
+        "\n",
+        "    settings = SimulationSettings(\n",
+        "        total_simulation_time=2400,\n",
+        "        sample_period_s=0.05,\n",
+        "    )\n",
+        "\n",
+        "    payload = (\n",
+        "        AsyncFlow()\n",
+        "        .add_arrivals_generator(generator)\n",
+        "        .add_client(client)\n",
+        "        .add_servers(server)\n",
+        "        .add_edges(e_gen_client, e_client_app, e_app_client)\n",
+        "        .add_simulation_settings(settings)\n",
+        "    ).build_payload()\n",
+        "    return payload\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2) Run the simulation\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "tags": [
+          "run"
+        ]
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Done.\n"
+          ]
+        }
+      ],
+      "source": [
+        "payload = build_payload()\n",
+        "env = simpy.Environment()\n",
+        "runner = SimulationRunner(env=env, simulation_input=payload)\n",
+        "results: ResultsAnalyzer = runner.run()\n",
+        "print(\"Done.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 3) MM1 theory vs observed comparison \n",
+        "If the payload violates MM1 assumptions, a readable error is shown instead.\n",
+        "## Variables (what they represent)\n",
+        "\n",
+        "* **λ (lambda)**: mean **arrival rate**, in requests/second.\n",
+        "* **μ (mu)**: mean **service rate**, in requests/second (= 1 / mean service time).\n",
+        "* **ρ (rho)**: **utilization** of the server, ρ = λ / μ (unitless).\n",
+        "* **W**: **mean time in system** (end-to-end latency, queue + service), in seconds.\n",
+        "* **Wq**: **mean waiting time in queue** (before service), in seconds.\n",
+        "* **L**: **mean number in system** (in queue + in service), unitless.\n",
+        "* **Lq**: **mean number in queue**, unitless.\n",
+        "* **E\\[S]**: **mean service time** at the server (CPU only), in seconds.\n",
+        "\n",
+        "\n",
+        "> In the comparison table you’ll see two columns: **Theory** (closed-form M/M/1 values) and **Observed** (estimates from the run). The run is a single execution; “Theory” is the model prediction, “Observed” is what was measured.\n",
+        "\n",
+        "---\n",
+        "\n",
+        "## How we compute the **Theory** column (M/M/1)\n",
+        "\n",
+        "1. **Predicted arrival rate**\n",
+        "\n",
+        "$$\n",
+        "\\lambda_{\\text{Theory}} \\;=\\; \n",
+        "\\ input data\n",
+        "$$\n",
+        "\n",
+        "2. **Predicted service rate** (from the **CPU exponential step** with mean $E[S]$)\n",
+        "\n",
+        "$$\n",
+        "\\mu_{\\text{Theory}} \\;=\\; \\frac{1}{E[S]}\n",
+        "$$\n",
+        "\n",
+        "3. **M/M/1 closed forms** (valid when $\\lambda_{\\text{Theory}} < \\mu_{\\text{Theory}}$)\n",
+        "\n",
+        "$$\n",
+        "\\begin{aligned}\n",
+        "\\rho_{\\text{Theory}} &= \\frac{\\lambda_{\\text{Theory}}}{\\mu_{\\text{Theory}}} \\\\\n",
+        "W_{\\text{Theory}}    &= \\frac{1}{\\mu_{\\text{Theory}} - \\lambda_{\\text{Theory}}} \\\\\n",
+        "W_{q,\\text{Theory}}  &= \\frac{\\rho_{\\text{Theory}}}{\\mu_{\\text{Theory}} - \\lambda_{\\text{Theory}}} \\\\\n",
+        "L_{\\text{Theory}}    &= \\lambda_{\\text{Theory}}\\, W_{\\text{Theory}} \\;=\\; \\frac{\\rho_{\\text{Theory}}}{1-\\rho_{\\text{Theory}}} \\\\\n",
+        "L_{q,\\text{Theory}}  &= \\lambda_{\\text{Theory}}\\, W_{q,\\text{Theory}} \\;=\\; \\frac{\\rho_{\\text{Theory}}^{2}}{1-\\rho_{\\text{Theory}}}\n",
+        "\\end{aligned}\n",
+        "$$\n",
+        "\n",
+        "If $\\lambda_{\\text{Theory}} \\ge \\mu_{\\text{Theory}}$, the system is **unstable** and $W, W_q, L, L_q$ **diverge** (we display them as $+\\infty$).\n",
+        "\n",
+        "---\n",
+        "\n",
+        "## How we compute the **Observed** column (from the run)\n",
+        "\n",
+        "After the `ResultsAnalyzer` processes metrics:\n",
+        "\n",
+        "1. **Observed arrival rate** (mean throughput across time windows)\n",
+        "\n",
+        "$$\n",
+        "\\lambda_{\\text{Observed}} \\;=\\; \\text{mean}\\big(\\text{windowed RPS series}\\big)\n",
+        "$$\n",
+        "\n",
+        "2. **Observed time in system** (client end-to-end latency)\n",
+        "\n",
+        "$$\n",
+        "W_{\\text{Observed}} \\;=\\; \\text{mean}\\big(\\text{client latencies}\\big)\n",
+        "$$\n",
+        "\n",
+        "3. **Observed service rate** (from server service times)\n",
+        "\n",
+        "$$\n",
+        "\\overline{S}=\\text{mean}(\\text{service\\_time}), \n",
+        "\\qquad\n",
+        "\\mu_{\\text{Observed}}=\n",
+        "\\begin{cases}\n",
+        "1/\\overline{S} & \\overline{S}>0\\\\\n",
+        "+\\infty & \\overline{S}=0\n",
+        "\\end{cases}\n",
+        "$$\n",
+        "\n",
+        "4. **Observed waiting time in queue** (from server queue wait times)\n",
+        "\n",
+        "$$\n",
+        "W_{q,\\text{Observed}} \\;=\\; \\text{mean}(\\text{waiting\\_time})\n",
+        "$$\n",
+        "\n",
+        "5. **Little’s law (observed)**\n",
+        "\n",
+        "$$\n",
+        "L_{\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{\\text{Observed}},\n",
+        "\\qquad\n",
+        "L_{q,\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{q,\\text{Observed}}\n",
+        "$$\n",
+        "\n",
+        "6. **Observed utilization**\n",
+        "\n",
+        "$$\n",
+        "\\rho_{\\text{Observed}}=\n",
+        "\\begin{cases}\n",
+        "\\lambda_{\\text{Observed}} / \\mu_{\\text{Observed}} & \\mu_{\\text{Observed}} \\not\\in \\{0,+\\infty\\}\\\\\n",
+        "0 & \\text{otherwise}\n",
+        "\\end{cases}\n",
+        "$$\n",
+        "\n",
+        "> **Why small deltas appear:** warm-up effects, the user-sampling window (piecewise-constant rate), finite simulation horizon. Increasing the simulation time typically shrinks these deltas.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "tags": [
+          "mm1"
+        ]
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "=================================================================\n",
+            "MMc (RR) — Theory vs Observed\n",
+            "-----------------------------------------------------------------\n",
+            "sym  metric                   theory   observed        abs   rel%\n",
+            "-----------------------------------------------------------------\n",
+            "λ    Arrival rate (1/s)    30.000000  30.068333   0.068333   0.23\n",
+            "μ    Service rate (1/s)    66.666667  66.528911  -0.137755  -0.21\n",
+            "c    Servers                1.000000   1.000000   0.000000   0.00\n",
+            "rho  Utilization            0.450000   0.451959   0.001959   0.44\n",
+            "L    Mean items in sys      0.818182   0.821762   0.003580   0.44\n",
+            "Lq   Mean items in queue    0.368182   0.369803   0.001621   0.44\n",
+            "W    Mean time in sys (s)   0.027273   0.027330   0.000057   0.21\n",
+            "Wq   Mean waiting (s)       0.012273   0.012299   0.000026   0.21\n",
+            "=================================================================\n"
+          ]
+        }
+      ],
+      "source": [
+        "mm1 = MMc()\n",
+        "if mm1.is_compatible(payload):\n",
+        "    mm1.print_comparison(payload, results)  \n",
+        "else:\n",
+        "    print(\"Payload is not compatible with M/M/1:\")\n",
+        "    for reason in mm1.explain_incompatibilities(payload):\n",
+        "        print(\" -\", reason)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### 4) Plot dashboards\n",
+        "\n",
+        "**System-level and per-server charts**\n",
+        "\n",
+        "Beyond the two main panels (latency histogram + throughput time series), AsyncFlow records **rich time series and per-request distributions** that make the system behavior easy to read. In your scenario (single server, exponential CPU only, no I/O/RAM), you’ll see:\n",
+        "\n",
+        "* **System dashboard**\n",
+        "\n",
+        "  * **Request Latency Distribution**: end-to-end histogram (client→server→client) with **mean, P50, P95, P99** markers. Here latency is dominated by CPU service + short queue; vertical lines highlight tail behavior.\n",
+        "  * **Throughput (RPS)**: windowed time series with **mean, P95, max**. Great for spotting stability, oscillations, and warm-up.\n",
+        "\n",
+        "* **Server time-series dashboard (for `app-1`)**\n",
+        "\n",
+        "  * **Ready queue length**: CPU queue over time with **mean/min/max**. With ρ≈0.5 the mean queue ≈0.5, consistent with M/M/1.\n",
+        "  * **I/O queue length**: flat at zero (no I/O step in the pipeline).\n",
+        "  * **RAM in use**: flat at zero (no RAM step in the pipeline).\n",
+        "\n",
+        "* **Server event-metrics dashboard**\n",
+        "\n",
+        "  * **Server-side latency**: histogram of (waiting + service) at the server.\n",
+        "  * **CPU service time**: histogram of **service\\_time** (Exp \\~15 ms) with P95/P99.\n",
+        "  * **CPU waiting time**: histogram of queue **waiting\\_time**; shows the heavy tail under bursts.\n",
+        "  * **I/O time**: flat at zero (no I/O).\n",
+        "\n",
+        "#### What you “get for free” from the collected data\n",
+        "\n",
+        "* **Distributions** (per-request arrays): end-to-end latency, server latency, **service\\_time**, **waiting\\_time**, (optional) **io\\_time** ⇒ percentiles, variance, pre/post comparisons.\n",
+        "* **Time series** (periodic sampling): **ready\\_queue\\_len**, **event\\_loop\\_io\\_sleep** (if I/O exists), **ram\\_in\\_use**, **edge\\_concurrent\\_connection**, plus **throughput series** to estimate observed λ.\n",
+        "* **Derived checks**: automatic **Little’s Law** sanity (L≈λW, Lq≈λWq), observed utilization **ρ̂ = λ̂/μ̂**, and the **MM1 theory vs observed** comparison table you printed.\n",
+        "\n",
+        "> In this specific setup, I/O and RAM panels are flat by design; add I/O or RAM steps and those plots will populate accordingly.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "tags": [
+          "plots"
+        ]
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1680x630 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1680x1120 with 4 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1680x1120 with 4 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# 4.1 System dashboard: latency + throughput\n",
+        "fig_sys, axes_sys = plt.subplots(1, 2, figsize=(12, 4.5), dpi=140)\n",
+        "results.plot_latency_distribution(axes_sys[0])\n",
+        "results.plot_throughput(axes_sys[1])\n",
+        "fig_sys.tight_layout()\n",
+        "plt.show()\n",
+        "\n",
+        "# 4.2 Server time-series and event-metric dashboards\n",
+        "sids = results.list_server_ids()\n",
+        "if sids:\n",
+        "    sid = sids[0]\n",
+        "    fig_ts, axes_ts = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n",
+        "    axes_ts[1, 1].axis(\"off\")\n",
+        "    results.plot_server_timeseries_dashboard(\n",
+        "        ax_ready=axes_ts[0, 0],\n",
+        "        ax_io=axes_ts[0, 1],\n",
+        "        ax_ram=axes_ts[1, 0],\n",
+        "        server_id=sid,\n",
+        "    )\n",
+        "    fig_ts.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "    fig_ev, axes_ev = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n",
+        "    results.plot_server_event_metrics_dashboard(\n",
+        "        ax_latency_hist=axes_ev[0, 0],\n",
+        "        ax_service_hist=axes_ev[0, 1],\n",
+        "        ax_io_hist=axes_ev[1, 0],\n",
+        "        ax_wait_hist=axes_ev[1, 1],\n",
+        "        server_id=sid,\n",
+        "    )\n",
+        "    fig_ev.tight_layout()\n",
+        "    plt.show()\n",
+        "else:\n",
+        "    print(\"No servers present in the topology.\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "8328475f",
+      "metadata": {},
+      "source": [
+        "\n",
+        "## 5) Sweep over mean concurrent users\n",
+        "We iterate the scenario by changing the *mean concurrent users* from 10 to 200 (step 5).\n",
+        "For each grid point we run a fresh simulation and keep the ResultsAnalyzer.\n",
+        "Then we wrap everything in `SweepAnalyzer`, which caches the data for plotting."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "id": "c9063bbe",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Sweep points: 19\n",
+            "Server IDs detected: ['app-1']\n"
+          ]
+        }
+      ],
+      "source": [
+        "payload_base = build_payload()\n",
+        "\n",
+        "sweeper = Sweep()\n",
+        "pairs = sweeper.sweep_on_lambda(\n",
+        "    payload=payload_base,\n",
+        "    lambda_lower_bound=10,\n",
+        "    lambda_upper_bound=100,\n",
+        "    step=5,\n",
+        ")\n",
+        "\n",
+        "# Wrap with the sweep analyzer and pre-collect/caches\n",
+        "sweep = SweepAnalyzer(pairs)\n",
+        "sweep.precollect()\n",
+        "\n",
+        "print(f\"Sweep points: {len(pairs)}\")\n",
+        "if pairs:\n",
+        "    print(\"Server IDs detected:\", pairs[0][1].list_server_ids())\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "dae40bfc",
+      "metadata": {},
+      "source": [
+        "## 6) Global plots (system-level)\n",
+        "We plot: \n",
+        " - Throughput (mean RPS) vs lambda\n",
+        " - Mean latency (W) vs lambda\n",
+        " - latency percentiles vs lambda.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "id": "48716bc8",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1560x585 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 845x520 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig_global = sweep.plot_global_dashboard()\n",
+        "plt.show()\n",
+        "\n",
+        "# 6.2  Latency percentiles vs users (P50, P95, P99)\n",
+        "fig_pct, ax_pct = plt.subplots(1, 1, figsize=(6.5, 4.0), dpi=130)\n",
+        "sweep.plot_global_latency_percentiles(ax_pct)\n",
+        "fig_pct.tight_layout()\n",
+        "plt.show()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "71b7199b",
+      "metadata": {},
+      "source": [
+        "\n",
+        "## 7) Per-server overlays\n",
+        "We plot per-server curves over users (utilization ρ_i, waiting time Wq_i, service rate μ_i, throughput λ_i).\n",
+        "If multiple servers exist, overlays show a line per server.\n",
+        "Below we also show the *single-server* case by explicitly passing the server id.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "id": "9b9f0236",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_56340/23993299.py:28: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
+            "  fig.tight_layout()\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1560x1300 with 5 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# 7.1 Single-server overlays (explicit server id), if present\n",
+        "server_ids = pairs[0][1].list_server_ids() if pairs else []\n",
+        "if server_ids:\n",
+        "    sid = server_ids[0]\n",
+        "\n",
+        "    fig = plt.figure(figsize=(12, 10), dpi=130)\n",
+        "    gs = fig.add_gridspec(nrows=3, ncols=2, hspace=0.35, wspace=0.25)\n",
+        "\n",
+        "    # Row 1 (2 charts)\n",
+        "    ax11 = fig.add_subplot(gs[0, 0])\n",
+        "    ax12 = fig.add_subplot(gs[0, 1])\n",
+        "\n",
+        "    # Row 2 (2 charts)\n",
+        "    ax21 = fig.add_subplot(gs[1, 0])\n",
+        "    ax22 = fig.add_subplot(gs[1, 1])\n",
+        "\n",
+        "    # Row 3 (1 chart spanning both columns)\n",
+        "    ax3 = fig.add_subplot(gs[2, :])\n",
+        "\n",
+        "    # Plots\n",
+        "    sweep.plot_server_utilization_overlay(ax11, server_ids=[sid])\n",
+        "    sweep.plot_server_waiting_time_overlay(ax12, server_ids=[sid])\n",
+        "    sweep.plot_server_service_rate_overlay(ax21, server_ids=[sid])\n",
+        "    sweep.plot_server_throughput_overlay(ax22, server_ids=[sid])\n",
+        "    sweep.plot_server_latency_overlay(ax3, server_ids=[sid])  # full-width\n",
+        "\n",
+        "    fig.suptitle(f\"Per-server overlays — {sid}\", y=0.98)\n",
+        "    fig.tight_layout()\n",
+        "    plt.show()\n",
+        "else:\n",
+        "    print(\"No servers present — skipping per-server overlays.\")\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "asyncflow-sim-py3.12 (3.12.3)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/asyncflow_queue_limit/asyncflow_mmc.ipynb b/asyncflow_queue_limit/asyncflow_mmc.ipynb
new file mode 100644
index 0000000..a2cf0d5
--- /dev/null
+++ b/asyncflow_queue_limit/asyncflow_mmc.ipynb
@@ -0,0 +1,399 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9428ca92",
+   "metadata": {},
+   "source": [
+    "# AsyncFlow — MMc Theory vs Simulation (Guided Notebook)\n",
+    "\n",
+    "This notebook shows how to:\n",
+    "\n",
+    "1. Make imports work inside a notebook (src-layout or package install)\n",
+    "2. Build a **multi-server** scenario compatible with **M/M/c** assumptions\n",
+    "3. Run the simulation and collect results\n",
+    "4. Compare theory vs observed KPIs (pretty-printed table)\n",
+    "5. Plot the standard dashboards (latency, throughput, server time series)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "3e168d4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys, importlib\n",
+    "\n",
+    "\n",
+    "for m in list(sys.modules):\n",
+    "    if m.startswith(\"asyncflow\"):\n",
+    "        del sys.modules[m]\n",
+    "\n",
+    "\n",
+    "from asyncflow import AsyncFlow, SimulationRunner\n",
+    "from asyncflow.analysis import MMc, ResultsAnalyzer\n",
+    "from asyncflow.components import (\n",
+    "    Client, Server, LinkEdge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
+    ")\n",
+    "from asyncflow.settings import SimulationSettings\n",
+    "\n",
+    "import simpy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "id": "dd39a8e3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Imports OK.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import simpy\n",
+    "\n",
+    "# Public AsyncFlow API\n",
+    "from asyncflow import AsyncFlow, SimulationRunner, Sweep\n",
+    "from asyncflow.components import Client, Server, LinkEdge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
+    "from asyncflow.settings import SimulationSettings\n",
+    "from asyncflow.analysis import  ResultsAnalyzer, SweepAnalyzer, MMc\n",
+    "from asyncflow.enums import Distribution\n",
+    "\n",
+    "print(\"Imports OK.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48fbf4f3",
+   "metadata": {},
+   "source": [
+    "## 1) Build an M/M/c split-friendly scenario\n",
+    "\n",
+    "* **Multiple identical servers with exponential CPU service**\n",
+    "  Topology includes **\\$c \\geq 2\\$ identical servers**, each exposing exactly **one endpoint** with exactly **one CPU-bound step**.\n",
+    "  Service times follow an **Exponential** distribution with mean \\$E\\[S]\\$ (service rate \\$\\mu = 1/E\\[S]\\$). No RAM/IO steps are included in the pipeline.\n",
+    "\n",
+    "* **Load balancer with FCFS dispatch**\n",
+    "\n",
+    "* **“Poisson arrivals” via the generator**\n",
+    "  \n",
+    "  \n",
+    "\n",
+    "---\n",
+    "\n",
+    "```mermaid\n",
+    "graph LR;\n",
+    "    rqs1[\"<b>RqsGenerator</b><br/>id: rqs-1\"]\n",
+    "    client1[\"<b>Client</b><br/>id: client-1\"]\n",
+    "    lb1[\"<b>LoadBalancer</b><br/>id: lb-1<br/>Policy: round_robin\"]\n",
+    "    app1[\"<b>Server</b><br/>id: app-1<br/>Endpoint: /api\"]\n",
+    "    app2[\"<b>Server</b><br/>id: app-2<br/>Endpoint: /api\"]\n",
+    "\n",
+    "    rqs1 -- \"Edge: gen-client<br/>Latency: 0.0001\" --> client1;\n",
+    "    client1 -- \"Request<br/>Edge: client-lb<br/>Latency: 0.0001\" --> lb1;\n",
+    "    lb1 -- \"Dispatch<br/>Edge: lb-app1<br/>Latency: 0.0001\" --> app1;\n",
+    "    lb1 -- \"Dispatch<br/>Edge: lb-app2<br/>Latency: 0.0001\" --> app2;\n",
+    "    app1 -- \"Response<br/>Edge: app1-client<br/>Latency: 0.0001\" --> client1;\n",
+    "    app2 -- \"Response<br/>Edge: app2-client<br/>Latency: 0.0001\" --> client1;\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "id": "d2937e5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_payload():\n",
+    "    generator = ArrivalsGenerator(\n",
+    "        id=\"rqs-1\",\n",
+    "        lambda_rps=270,\n",
+    "        model=Distribution.POISSON\n",
+    "    )\n",
+    "\n",
+    "    client = Client(id=\"client-1\")\n",
+    "\n",
+    "    endpoint = Endpoint(\n",
+    "        endpoint_name=\"/api\",\n",
+    "        probability=1.0,\n",
+    "        steps=[\n",
+    "            {\n",
+    "                \"kind\": \"initial_parsing\",\n",
+    "                \"step_operation\": {\n",
+    "                    \"cpu_time\": {\"mean\": 0.01, \"distribution\": \"exponential\"},\n",
+    "                },\n",
+    "            },\n",
+    "        ],\n",
+    "    )\n",
+    "\n",
+    "    srv1 = Server(\n",
+    "        id=\"srv-1\",\n",
+    "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+    "        endpoints=[endpoint],\n",
+    "    )\n",
+    "    srv2 = Server(\n",
+    "        id=\"srv-2\",\n",
+    "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+    "        endpoints=[endpoint],\n",
+    "    )\n",
+    "    \n",
+    "    srv3 = Server(\n",
+    "        id=\"srv-3\",\n",
+    "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+    "        endpoints=[endpoint],\n",
+    "    )\n",
+    "\n",
+    "    lb = LoadBalancer(\n",
+    "        id=\"lb-1\",\n",
+    "        algorithms=\"fcfs\",  \n",
+    "        server_covered={\"srv-1\", \"srv-2\", \"srv-3\"},\n",
+    "    )\n",
+    "\n",
+    "    edges = [\n",
+    "        LinkEdge(id=\"gen-client\",  source=\"rqs-1\",  target=\"client-1\",),\n",
+    "        LinkEdge(id=\"client-lb\",   source=\"client-1\", target=\"lb-1\",  ),\n",
+    "        LinkEdge(id=\"lb-srv1\",     source=\"lb-1\",   target=\"srv-1\",   ),\n",
+    "        LinkEdge(id=\"lb-srv2\",     source=\"lb-1\",   target=\"srv-2\",   ),\n",
+    "        LinkEdge(id=\"lb-srv3\",     source=\"lb-1\",   target=\"srv-3\",   ),\n",
+    "        LinkEdge(id=\"srv1-client\", source=\"srv-1\",  target=\"client-1\",),\n",
+    "        LinkEdge(id=\"srv2-client\", source=\"srv-2\",  target=\"client-1\",),\n",
+    "        LinkEdge(id=\"srv3-client\", source=\"srv-3\",  target=\"client-1\",),\n",
+    "    ]\n",
+    "\n",
+    "    settings = SimulationSettings(\n",
+    "        total_simulation_time=3600,\n",
+    "        sample_period_s=0.05,\n",
+    "    )\n",
+    "\n",
+    "    payload = (\n",
+    "        AsyncFlow()\n",
+    "        .add_arrivals_generator(generator)\n",
+    "        .add_client(client)\n",
+    "        .add_servers(srv1, srv2, srv3)\n",
+    "        .add_load_balancer(lb)\n",
+    "        .add_edges(*edges)\n",
+    "        .add_simulation_settings(settings)\n",
+    "    ).build_payload()\n",
+    "\n",
+    "    return payload\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7682861f",
+   "metadata": {},
+   "source": [
+    "## 2) Run the simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "d0634bc8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "payload = build_payload()\n",
+    "env = simpy.Environment()\n",
+    "runner = SimulationRunner(env=env, simulation_input=payload)\n",
+    "results: ResultsAnalyzer = runner.run()\n",
+    "print(\"Done.\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5fe2a4a",
+   "metadata": {},
+   "source": [
+    "# 3) M/M/c (FCFS) — theory vs observed comparison\n",
+    "\n",
+    "This section shows how we compute the **theoretical Erlang-C KPIs** (pooled queue, FCFS) and compare them against **simulation estimates**.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Variables\n",
+    "\n",
+    "* **$c$**: number of identical servers.\n",
+    "* **$\\lambda$**: global arrival rate (req/s).\n",
+    "* **$\\mu$**: per-server service rate (req/s), $\\mu = 1/\\mathbb{E}[S]$.\n",
+    "* **$\\rho$**: global utilization, $\\rho = \\lambda/(c\\mu)$.\n",
+    "* **$W$**: mean time in system (queue + service).\n",
+    "* **$W_q$**: mean waiting time in queue.\n",
+    "* **$L$**: mean number in system.\n",
+    "* **$L_q$**: mean number in queue.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Theory (Erlang-C formulas)\n",
+    "\n",
+    "We assume **Poisson arrivals** for $\\lambda$ (taken directly from the payload).\n",
+    "\n",
+    "1. Offered load:\n",
+    "\n",
+    "$$\n",
+    "a = \\frac{\\lambda}{\\mu}\n",
+    "$$\n",
+    "\n",
+    "2. Probability system is empty:\n",
+    "\n",
+    "$$\n",
+    "P_0 = \\left[\\sum_{n=0}^{c-1}\\frac{a^n}{n!} + \\frac{a^c}{c!\\,(1-\\rho)}\\right]^{-1}\n",
+    "$$\n",
+    "\n",
+    "3. Probability of waiting (Erlang-C):\n",
+    "\n",
+    "$$\n",
+    "P_w = \\frac{a^c}{c!\\,(1-\\rho)} \\, P_0\n",
+    "$$\n",
+    "\n",
+    "4. Queue length and waiting:\n",
+    "\n",
+    "$$\n",
+    "L_q = P_w \\cdot \\frac{\\rho}{1-\\rho}, \\qquad\n",
+    "W_q = \\frac{L_q}{\\lambda}\n",
+    "$$\n",
+    "\n",
+    "5. Total response time and system size:\n",
+    "\n",
+    "$$\n",
+    "W = W_q + \\frac{1}{\\mu}, \\qquad\n",
+    "L = \\lambda W\n",
+    "$$\n",
+    "\n",
+    "If $\\rho \\ge 1$, the system is unstable and all metrics diverge to $+\\infty$.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Observed (from simulation)\n",
+    "\n",
+    "After processing metrics:\n",
+    "\n",
+    "1. **Arrival rate**:\n",
+    "\n",
+    "$$\n",
+    "\\lambda_{\\text{Observed}} = \\text{mean throughput (client completions)}\n",
+    "$$\n",
+    "\n",
+    "2. **Service rate**:\n",
+    "\n",
+    "$$\n",
+    "\\mu_{\\text{Observed}} = 1 / \\overline{S}, \\quad \\overline{S} = \\text{mean(service\\_time)}\n",
+    "$$\n",
+    "\n",
+    "3. **End-to-end latency**:\n",
+    "\n",
+    "$$\n",
+    "W_{\\text{Observed}} = \\text{mean(client latencies)}\n",
+    "$$\n",
+    "\n",
+    "4. **Waiting time**:\n",
+    "\n",
+    "$$\n",
+    "W_{q,\\text{Observed}} = \\text{mean(waiting\\_time)} \n",
+    "$$\n",
+    "\n",
+    "5. **Little’s law check**:\n",
+    "\n",
+    "$$\n",
+    "L_{\\text{Observed}} = \\lambda_{\\text{Observed}} W_{\\text{Observed}}, \\qquad\n",
+    "L_{q,\\text{Observed}} = \\lambda_{\\text{Observed}} W_{q,\\text{Observed}}\n",
+    "$$\n",
+    "\n",
+    "6. **Utilization**:\n",
+    "\n",
+    "$$\n",
+    "\\rho_{\\text{Observed}} = \\lambda_{\\text{Observed}}/(c\\,\\mu_{\\text{Observed}})\n",
+    "$$\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Comparison\n",
+    "\n",
+    "The analyzer builds a table with two columns — **Theory** (Erlang-C closed forms) and **Observed** (empirical estimates) — and reports absolute and relative deltas.\n",
+    "\n",
+    "This allows us to verify whether AsyncFlow reproduces the textbook M/M/c (FCFS) predictions under Poisson arrivals and exponential service.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "id": "ccd7379b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=================================================================\n",
+      "MMc (FCFS/Erlang-C) — Theory vs Observed\n",
+      "-----------------------------------------------------------------\n",
+      "sym  metric                    theory    observed       abs  rel%\n",
+      "-----------------------------------------------------------------\n",
+      "λ    Arrival rate (1/s)    270.000000  270.258333  0.258333  0.10\n",
+      "μ    Service rate (1/s)    100.000000  100.036707  0.036707  0.04\n",
+      "rho  Utilization             0.900000    0.900531  0.000531  0.06\n",
+      "L    Mean items in sys      10.053549   10.073544  0.019994  0.20\n",
+      "Lq   Mean items in queue     7.353549    7.371934  0.018385  0.25\n",
+      "W    Mean time in sys (s)    0.037235    0.037274  0.000038  0.10\n",
+      "Wq   Mean waiting (s)        0.027235    0.027277  0.000042  0.15\n",
+      "=================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "mmc = MMc()\n",
+    "if mmc.is_compatible(payload):\n",
+    "   mmc.print_comparison(payload, results)  \n",
+    "else:\n",
+    "    print(\"Payload is not compatible with M/M/c:\")\n",
+    "    for reason in mmc.explain_incompatibilities(payload):\n",
+    "        print(\" -\", reason)\n",
+    "   \n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "asyncflow-sim-py3.12 (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/asyncflow_queue_limit/asyncflow_mmc_split.ipynb b/asyncflow_queue_limit/asyncflow_mmc_split.ipynb
new file mode 100644
index 0000000..fa4f999
--- /dev/null
+++ b/asyncflow_queue_limit/asyncflow_mmc_split.ipynb
@@ -0,0 +1,559 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "870337dc",
+   "metadata": {},
+   "source": [
+    "# AsyncFlow — MMc split Theory vs Simulation (Guided Notebook)\n",
+    "\n",
+    "This notebook shows how to:\n",
+    "\n",
+    "1. Make imports work inside a notebook (src-layout or package install)\n",
+    "2. Build a **multi-server** scenario compatible with **M/M/c** assumptions in the case of n parallel M/M/1\n",
+    "3. Run the simulation and collect results\n",
+    "4. Compare theory vs observed KPIs (pretty-printed table)\n",
+    "5. Plot the standard dashboards (latency, throughput, server time series)\n",
+    "\n",
+    "> Tip: run this notebook from your project **root folder**.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b8a94d93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys, importlib\n",
+    "\n",
+    "\n",
+    "for m in list(sys.modules):\n",
+    "    if m.startswith(\"asyncflow\"):\n",
+    "        del sys.modules[m]\n",
+    "\n",
+    "\n",
+    "from asyncflow import AsyncFlow, SimulationRunner\n",
+    "from asyncflow.analysis import MMc, ResultsAnalyzer\n",
+    "from asyncflow.components import (\n",
+    "    Client, Server, LinkEdge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
+    ")\n",
+    "from asyncflow.settings import SimulationSettings\n",
+    "\n",
+    "import simpy\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d1b7ad7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Imports OK.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import simpy\n",
+    "\n",
+    "# Public AsyncFlow API\n",
+    "from asyncflow import AsyncFlow, SimulationRunner, Sweep\n",
+    "from asyncflow.components import Client, Server, LinkEdge, Endpoint, LoadBalancer, ArrivalsGenerator\n",
+    "from asyncflow.settings import SimulationSettings\n",
+    "from asyncflow.analysis import  ResultsAnalyzer, SweepAnalyzer, MMc\n",
+    "from asyncflow.enums import Distribution\n",
+    "\n",
+    "print(\"Imports OK.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d632e4fd",
+   "metadata": {},
+   "source": [
+    "## 1) Build an M/M/c split-friendly scenario\n",
+    "\n",
+    "* **Multiple identical servers with exponential CPU service**\n",
+    "  Topology includes **\\$c \\geq 2\\$ identical servers**, each exposing exactly **one endpoint** with exactly **one CPU-bound step**.\n",
+    "  Service times follow an **Exponential** distribution with mean \\$E\\[S]\\$ (service rate \\$\\mu = 1/E\\[S]\\$). No RAM/IO steps are included in the pipeline.\n",
+    "\n",
+    "* **Load balancer with round-robin dispatch**\n",
+    "  A **single load balancer** is required when \\$c > 1\\$. It splits arrivals **randomly** across servers, so each server has its own local queue.\n",
+    "  This corresponds to a **split M/M/c** model, not the textbook pooled queue.\n",
+    "\n",
+    "* **“Poisson arrivals” via the generator**\n",
+    "  \n",
+    "\n",
+    "  \n",
+    "\n",
+    "---\n",
+    "\n",
+    "```mermaid\n",
+    "graph LR;\n",
+    "    rqs1[\"<b>RqsGenerator</b><br/>id: rqs-1\"]\n",
+    "    client1[\"<b>Client</b><br/>id: client-1\"]\n",
+    "    lb1[\"<b>LoadBalancer</b><br/>id: lb-1<br/>Policy: round_robin\"]\n",
+    "    app1[\"<b>Server</b><br/>id: app-1<br/>Endpoint: /api\"]\n",
+    "    app2[\"<b>Server</b><br/>id: app-2<br/>Endpoint: /api\"]\n",
+    "\n",
+    "    rqs1 -- \"Edge: gen-client<br/>Latency: 0.0001\" --> client1;\n",
+    "    client1 -- \"Request<br/>Edge: client-lb<br/>Latency: 0.0001\" --> lb1;\n",
+    "    lb1 -- \"Dispatch<br/>Edge: lb-app1<br/>Latency: 0.0001\" --> app1;\n",
+    "    lb1 -- \"Dispatch<br/>Edge: lb-app2<br/>Latency: 0.0001\" --> app2;\n",
+    "    app1 -- \"Response<br/>Edge: app1-client<br/>Latency: 0.0001\" --> client1;\n",
+    "    app2 -- \"Response<br/>Edge: app2-client<br/>Latency: 0.0001\" --> client1;\n",
+    "```\n",
+    "\n",
+    "---\n",
+    "\n",
+    "⚠️ **Note on model scope**\n",
+    "This scenario currently represents a **split M/M/c with random dispatch**.\n",
+    "The **textbook M/M/c (Erlang-C)** assumes a **single pooled FCFS queue feeding c servers**, which tends to give lower waiting times (no imbalance across local queues).\n",
+    "\n",
+    "In a future step, we will extend AsyncFlow with a **pooled FCFS dispatcher** at the load balancer, enabling direct comparison against the textbook Erlang-C closed forms.\n",
+    "\n",
+    "---\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ba93587a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_payload():\n",
+    "    generator = ArrivalsGenerator(\n",
+    "        id=\"rqs-1\",\n",
+    "        lambda_rps=30,\n",
+    "        model=Distribution.POISSON\n",
+    "    )\n",
+    "\n",
+    "    client = Client(id=\"client-1\")\n",
+    "\n",
+    "    endpoint = Endpoint(\n",
+    "        endpoint_name=\"/api\",\n",
+    "        probability=1.0,\n",
+    "        steps=[\n",
+    "            {\n",
+    "                \"kind\": \"initial_parsing\",\n",
+    "                \"step_operation\": {\n",
+    "                    \"cpu_time\": {\"mean\": 0.01, \"distribution\": \"exponential\"},\n",
+    "                },\n",
+    "            },\n",
+    "        ],\n",
+    "    )\n",
+    "\n",
+    "    srv1 = Server(\n",
+    "        id=\"srv-1\",\n",
+    "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+    "        endpoints=[endpoint],\n",
+    "    )\n",
+    "    srv2 = Server(\n",
+    "        id=\"srv-2\",\n",
+    "        server_resources={\"cpu_cores\": 1, \"ram_mb\": 2048},\n",
+    "        endpoints=[endpoint],\n",
+    "    )\n",
+    "\n",
+    "    lb = LoadBalancer(\n",
+    "        id=\"lb-1\",\n",
+    "        algorithms=\"random\",  \n",
+    "        server_covered={\"srv-1\", \"srv-2\"},\n",
+    "    )\n",
+    "\n",
+    "    edges = [\n",
+    "        LinkEdge(id=\"gen-client\",  source=\"rqs-1\",  target=\"client-1\",),\n",
+    "        LinkEdge(id=\"client-lb\",   source=\"client-1\", target=\"lb-1\",  ),\n",
+    "        LinkEdge(id=\"lb-srv1\",     source=\"lb-1\",   target=\"srv-1\",   ),\n",
+    "        LinkEdge(id=\"lb-srv2\",     source=\"lb-1\",   target=\"srv-2\",   ),\n",
+    "        LinkEdge(id=\"srv1-client\", source=\"srv-1\",  target=\"client-1\",),\n",
+    "        LinkEdge(id=\"srv2-client\", source=\"srv-2\",  target=\"client-1\",),\n",
+    "    ]\n",
+    "\n",
+    "    settings = SimulationSettings(\n",
+    "        total_simulation_time=2400,\n",
+    "        sample_period_s=0.05,\n",
+    "    )\n",
+    "\n",
+    "    payload = (\n",
+    "        AsyncFlow()\n",
+    "        .add_arrivals_generator(generator)\n",
+    "        .add_client(client)\n",
+    "        .add_servers(srv1, srv2)\n",
+    "        .add_load_balancer(lb)\n",
+    "        .add_edges(*edges)\n",
+    "        .add_simulation_settings(settings)\n",
+    "    ).build_payload()\n",
+    "\n",
+    "    return payload\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac2e1687",
+   "metadata": {},
+   "source": [
+    "## 2) Run the simulation\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "79b4e0e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "payload = build_payload()\n",
+    "env = simpy.Environment()\n",
+    "runner = SimulationRunner(env=env, simulation_input=payload)\n",
+    "results: ResultsAnalyzer = runner.run()\n",
+    "print(\"Done.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da98b8b9",
+   "metadata": {},
+   "source": [
+    "## 3) MMc (Random) — theory vs observed comparison\n",
+    "\n",
+    "If the payload violates MMc assumptions, a readable error is shown instead.\n",
+    "This section matches exactly what the analyzer computes **now**: a **split random model** (not the pooled FCFS/Erlang-C model). When we add **FCFS** in the LB, we’ll also expose the textbook Erlang-C formulas side-by-side.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Variables (what they represent)\n",
+    "\n",
+    "* **$c$**: number of *identical* servers (parallel replicas).\n",
+    "* **$\\lambda$**: global **arrival rate** (req/s).\n",
+    "* **$\\mu$**: **per-server** service rate (req/s) $= 1/\\mathbb{E}[S]$.\n",
+    "* **$\\rho$**: **global utilization**, $\\rho = \\lambda/(c\\,\\mu)$ (unitless).\n",
+    "* **$W$**: **mean time in system** (queue + service), seconds.\n",
+    "* **$W_q$**: **mean waiting time in queue**, seconds.\n",
+    "* **$L$**: **mean number in system** (queue + service), unitless.\n",
+    "* **$L_q$**: **mean number in queue**, unitless.\n",
+    "* **$\\mathbb{E}[S]$**: mean **CPU service time**, seconds.\n",
+    "\n",
+    "Derived (random split model):\n",
+    "\n",
+    "* **$\\lambda_i$**: **per-server arrival rate**, $\\lambda_i = \\lambda/c$.\n",
+    "\n",
+    "> In the comparison table you’ll see two columns: **Theory** (closed-form) and **Observed** (estimates from the run).\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## How we compute the **Theory** column (MMc with Round-Robin split)\n",
+    "\n",
+    "1. **Predicted arrival rate**\n",
+    "\n",
+    "$$\n",
+    "\\lambda_{\\text{Theory}} \n",
+    "$$\n",
+    "\n",
+    "2. **Predicted service rate** (from the **CPU exponential step**)\n",
+    "\n",
+    "$$\n",
+    "\\mu_{\\text{Theory}} \\;=\\; \\frac{1}{\\mathbb{E}[S]}\n",
+    "$$\n",
+    "\n",
+    "3. **Parallelism & utilization**\n",
+    "\n",
+    "$$\n",
+    "c \\;=\\; \\text{number of servers}, \n",
+    "\\qquad\n",
+    "\\rho_{\\text{Theory}} \\;=\\; \\frac{\\lambda_{\\text{Theory}}}{c\\,\\mu_{\\text{Theory}}}\n",
+    "$$\n",
+    "\n",
+    "4. **RR split closed forms** (used by the analyzer today)\n",
+    "\n",
+    "If $\\rho_{\\text{Theory}} \\ge 1$: the system is **unstable** and\n",
+    "$W, W_q, L, L_q$ **diverge** (displayed as $+\\infty$).\n",
+    "\n",
+    "Otherwise, let $\\lambda_i = \\lambda_{\\text{Theory}}/c$. We use:\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "W_{q,\\text{Theory}} &= \\frac{\\rho_{\\text{Theory}}}\n",
+    "                            {\\mu_{\\text{Theory}} - \\lambda_i} \\\\\n",
+    "W_{\\text{Theory}}   &= \\frac{1}{\\mu_{\\text{Theory}}} + W_{q,\\text{Theory}} \\\\\n",
+    "L_{q,\\text{Theory}} &= \\lambda_{\\text{Theory}} \\, W_{q,\\text{Theory}} \\\\\n",
+    "L_{\\text{Theory}}   &= \\lambda_{\\text{Theory}} \\, W_{\\text{Theory}}\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "> 🔎 **Note:** These formulas reflect a **random split** into *c* identical M/M/1 queues (no central pool). They are **not** the Erlang-C (pooled FCFS) formulas. Once we add **FCFS** at the LB, we’ll surface the **textbook pooled M/M/c** KPIs (including $P_0$, $P_w$, etc.) alongside this random split model.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## How we compute the **Observed** column (from the run)\n",
+    "\n",
+    "After `ResultsAnalyzer.process_all_metrics()`:\n",
+    "\n",
+    "1. **Observed arrival rate** (system throughput)\n",
+    "\n",
+    "$$\n",
+    "\\lambda_{\\text{Observed}} \\;=\\; \n",
+    "\\text{mean}\\big(\\text{windowed RPS series (client completions)}\\big)\n",
+    "$$\n",
+    "\n",
+    "*(This is end-to-end, i.e., what exits all servers and reaches the client.)*\n",
+    "\n",
+    "2. **Observed time in system** (client E2E latency)\n",
+    "\n",
+    "$$\n",
+    "W_{\\text{Observed}} \\;=\\; \\text{mean}\\big(\\text{client latencies}\\big)\n",
+    "$$\n",
+    "\n",
+    "3. **Observed service rate** (aggregate across servers)\n",
+    "   Let $\\overline{S} = \\text{mean}(\\texttt{service\\_time})$ *over all servers, weighted by number of jobs*:\n",
+    "\n",
+    "$$\n",
+    "\\mu_{\\text{Observed}} \\;=\\;\n",
+    "\\begin{cases}\n",
+    "1/\\overline{S}, & \\overline{S} > 0 \\\\\n",
+    "+\\infty, & \\overline{S} = 0\n",
+    "\\end{cases}\n",
+    "$$\n",
+    "\n",
+    "4. **Observed waiting time in queue** (aggregate across servers)\n",
+    "\n",
+    "$$\n",
+    "W_{q,\\text{Observed}} \\;=\\; \n",
+    "\\text{mean}\\big(\\texttt{waiting\\_time}\\big)\n",
+    "$$\n",
+    "\n",
+    "5. **Little’s law (observed)**\n",
+    "\n",
+    "$$\n",
+    "L_{\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{\\text{Observed}},\n",
+    "\\qquad\n",
+    "L_{q,\\text{Observed}}=\\lambda_{\\text{Observed}}\\, W_{q,\\text{Observed}}\n",
+    "$$\n",
+    "\n",
+    "6. **Observed utilization (global)**\n",
+    "\n",
+    "$$\n",
+    "\\rho_{\\text{Observed}} \\;=\\;\n",
+    "\\begin{cases}\n",
+    "\\lambda_{\\text{Observed}} / (c\\,\\mu_{\\text{Observed}}),\n",
+    " & \\mu_{\\text{Observed}} \\not\\in \\{0, +\\infty\\} \\\\\n",
+    "0, & \\text{otherwise}\n",
+    "\\end{cases}\n",
+    "$$\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### Why small deltas appear\n",
+    "\n",
+    "* **Finite horizon / warm-up:** Short runs and lack of warm-up bias early windows.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1975945b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "===================================================================\n",
+      "MMc (Random split) — Theory vs Observed\n",
+      "-------------------------------------------------------------------\n",
+      "sym  metric                    theory    observed        abs   rel%\n",
+      "-------------------------------------------------------------------\n",
+      "λ    Arrival rate (1/s)     30.000000   30.127500   0.127500   0.43\n",
+      "μ    Service rate (1/s)    100.000000  100.270024   0.270024   0.27\n",
+      "c    Servers                 2.000000    2.000000   0.000000   0.00\n",
+      "rho  Utilization             0.150000    0.150232   0.000232   0.15\n",
+      "L    Mean items in sys       0.352941    0.352388  -0.000553  -0.16\n",
+      "Lq   Mean items in queue     0.052941    0.051924  -0.001017  -1.92\n",
+      "W    Mean time in sys (s)    0.011765    0.011697  -0.000068  -0.58\n",
+      "Wq   Mean waiting (s)        0.001765    0.001723  -0.000041  -2.34\n",
+      "===================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "mmc = MMc()\n",
+    "if mmc.is_compatible(payload):\n",
+    "   mmc.print_comparison(payload, results)  \n",
+    "else:\n",
+    "    print(\"Payload is not compatible with M/M/c:\")\n",
+    "    for reason in mmc.explain_incompatibilities(payload):\n",
+    "        print(\" -\", reason)\n",
+    "   \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9f940d1e",
+   "metadata": {},
+   "source": [
+    "### 4) Plot dashboards\n",
+    "\n",
+    "**System-level and per-server charts**\n",
+    "\n",
+    "Beyond the two main panels (latency histogram + throughput time series), AsyncFlow records **rich time series and per-request distributions** that make the system behavior easy to read. In your scenario (single server, exponential CPU only, no I/O/RAM), you’ll see:\n",
+    "\n",
+    "* **System dashboard**\n",
+    "\n",
+    "  * **Request Latency Distribution**: end-to-end histogram (client→server→client) with **mean, P50, P95, P99** markers. Here latency is dominated by CPU service + short queue; vertical lines highlight tail behavior.\n",
+    "  * **Throughput (RPS)**: windowed time series with **mean, P95, max**. Great for spotting stability, oscillations, and warm-up.\n",
+    "\n",
+    "* **Server time-series dashboard (for `app-1`)**\n",
+    "\n",
+    "  * **Ready queue length**: CPU queue over time with **mean/min/max**. With ρ≈0.5 the mean queue ≈0.5, consistent with M/M/1.\n",
+    "  * **I/O queue length**: flat at zero (no I/O step in the pipeline).\n",
+    "  * **RAM in use**: flat at zero (no RAM step in the pipeline).\n",
+    "\n",
+    "* **Server event-metrics dashboard**\n",
+    "\n",
+    "  * **Server-side latency**: histogram of (waiting + service) at the server.\n",
+    "  * **CPU service time**: histogram of **service\\_time** (Exp \\~15 ms) with P95/P99.\n",
+    "  * **CPU waiting time**: histogram of queue **waiting\\_time**; shows the heavy tail under bursts.\n",
+    "  * **I/O time**: flat at zero (no I/O).\n",
+    "\n",
+    "#### What you “get for free” from the collected data\n",
+    "\n",
+    "* **Distributions** (per-request arrays): end-to-end latency, server latency, **service\\_time**, **waiting\\_time**, (optional) **io\\_time** ⇒ percentiles, variance, pre/post comparisons.\n",
+    "* **Time series** (periodic sampling): **ready\\_queue\\_len**, **event\\_loop\\_io\\_sleep** (if I/O exists), **ram\\_in\\_use**, **edge\\_concurrent\\_connection**, plus **throughput series** to estimate observed λ.\n",
+    "* **Derived checks**: automatic **Little’s Law** sanity (L≈λW, Lq≈λWq), observed utilization **ρ̂ = λ̂/μ̂**, and the **MM1 theory vs observed** comparison table you printed.\n",
+    "\n",
+    "> In this specific setup, I/O and RAM panels are flat by design; add I/O or RAM steps and those plots will populate accordingly.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d0ccfc68",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABoEAAAJnCAYAAABYl/qlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAViAAAFYgBxNdAoAABAABJREFUeJzs3XdcFEcfBvBn7ziOXhRQEAErWLCLIIrGnsQSe8USa+yxxRZRo0ajRhONih17otFYEqMxKpZXscUutiiKXUQQ6Xf7/kFu5bgDjqIH+nw/HxJ2dnb2t3vLubOzMyOIoiiCiIiIiIiIiIiIiIiI3isyYwdARERERERERERERERE+Y+NQERERERERERERERERO8hNgIRERERERERERERERG9h9gIRERERERERERERERE9B5iIxAREREREREREREREdF7iI1ARERERERERERERERE7yE2AhEREREREREREREREb2H2AhERERERERERERERET0HmIjEBERERERERERERER0XuIjUBERERERERERERERETvITYCERERERERERERERERvYfYCERERERERERERERERPQeYiMQERERERERERERERHRe4iNQERERJSthg0bQhAErF271tihaBEEAYIg4O7du1rpU6dOhSAI6N27t1HiykpBjo2IiIjoXeJ9kbYP/XysWbMGgiDg22+/NXYoeXbw4EEIgoBBgwYZOxQiIjYCEVHhpXkonf5HLpfDzs4OPj4+mDZtGqKjo40dZqEzdepUTJ06FS9fvszV9mvXroUgCPDw8MjXuPS5e/cupk6dioULF771fRVWvXv31vk7USqVcHR0RMWKFdG1a1csWbLknf6t5PUaK8jWrl2LqVOn4vz588YOhYiIiOity3ifaehPQXuxiHJv4cKFmDp1qs5LWTkVFxeHiRMnolixYhgxYoTWurt37+q9jpRKJUqUKIFWrVph69atWZbv4eGhs72JiQkcHR3RqFEjLFu2DKmpqXq3jYiIwNixY1GtWjXY2NjA1NQUzs7OqFq1Knr16oWVK1fi2bNnWts0atQIDRs2xMqVK3Hp0qU8nRsiorwyMXYARER5VbJkSbi5uQEAUlJScO/ePZw+fRqnT5/G8uXLERoairJlyxo5ysJj2rRpANIaD+zs7IwbTDbu3r2LadOmwd3dHSNHjjR2OAWak5MTypUrBwBQq9WIiYnB/fv3ce3aNWzZsgWjR4/GhAkTMHHiRJiY6N4euLm5wdPTE7a2tnmOJT+vMU9PTwCAQqHIa1j5Yu3atQgNDYWHhweqVaumN4+DgwM8PT3h7Oz8boMjIiIiymf+/v56048fPw4AKFeuHJycnHTWFytW7K3GRe/OwoULERERgYYNG+bpRcDZs2fj8ePHmD9/PiwsLDLNV6tWLSiVSgBAbGwsbt++jT179mDPnj3o0qULNm7cCJks83fe01+TiYmJuH37Ng4dOoRDhw4hJCQE+/fvh7W1tZR/586d6NatG+Lj4yEIAkqUKAEvLy8kJCTg+vXruHjxItatWwczMzP06NFDa1/Tpk1DgwYNMHbsWPz555+5PjdERHnFRiAiKvQ+//xzTJ06VSvtr7/+QufOnfHw4UMMHDgQf//9t3GCIyogPv74Y503LtVqNf755x8sWrQIISEhCAoKwoULF7B161aditO6deveYbSGCw8PN3YIOTZ06FAMHTrU2GEQERER5dmxY8f0pguCAACYOHHiBzu0GRkuMTERS5cuhampKXr16pVl3q1bt2o1NiUkJCAoKAhz587Fli1b8MknnyAwMDDT7TNek2q1GsuXL8eQIUNw8uRJTJ48GT/88AMA4P79+1ID0CeffIL58+fDy8tL2jY1NRVHjx7Fxo0b9TZcBQQEoHz58ti3bx+uXr2KihUrGnhGiIjyF4eDI6L3UtOmTTFjxgwAwKFDh/D06VMjR0RU8MhkMtSsWRNr167Fxo0bIQgCtm/fzuH1iIiIiIjondmyZQtevHiBTz/9FEWLFs3Rtubm5vjuu+/g4+MjlZUTMpkMgwYNwoABAwAAGzduhCiKAIDNmzcjPj4eRYsWxbZt27QagADAxMQEH330EVauXIl27drpLb9nz54AgKVLl+YoLiKi/MRGICJ6b9WtWxcAIIoi7ty5ozfPuXPn0KtXL3h4eMDMzAx2dnYICAjA2rVroVarMy378OHDaNasGezs7GBtbY3atWtj9erVAN6MNXz48GGtbTRzs2TstZReZpPc5yXec+fOoXv37nB3d4dSqYSVlRU8PDzQokULzJ8/X7rB1UxCqlGqVCmt8ZKzijuv4uLisGHDBnTt2hUVKlSAra0tzM3NUa5cOQwePFjv59ewYUN89NFHANLGaM44vnPG85+QkICFCxfC398f9vb2UCqVKFWqFAYOHJjp9aGZd2rt2rV48eIFRo4cCQ8PD2ns6f79++Px48eZHpcoivjtt9/Qpk0buLi4QKlUolixYvD19cU333yDR48eAQBOnz4NQRBgYWGBmJiYTMtbvXo1BEFApUqVsjulOdatWzd8/vnnAIA5c+YgKSlJa336c5HR27jG0v8dXb9+Hb169YKrqysUCoXWm3vZ/c0AaW8WTpkyBZ6enjA3N4eTkxO6du2K69ev682f1bEC2mOSaxw+fBiCICA0NBQA0KdPH61ja9iwoZQ3uwl/o6KiMHHiRFSuXBmWlpawsrJClSpVEBQUlOn1kddrlYiIiMjYVCoVFixYgCpVqsDCwgL29vZo2bIlzp49qzd/+vpVTEwMvvrqK+l+L+OwZCdPnkTnzp1RokQJKJVKODg4oHnz5vj111/1lq25t8tqeLPs6ncHDhxA06ZNYWtrC2tra9SpUwchISEAMq8z5tf5iI6OxogRI1CqVCnpfnDAgAF4+PCh3m2zi0ff+dDMBRsREQEA+Oijj7Tuf3PSA2zjxo0AgDZt2hi8TUZ+fn4AgH///TdX2zdu3BhA2r348+fPAQC3b98GAJQtWxbm5ua5Kvezzz4DAGzatCnLZwxERG8Th4MjovdWfHy89LulpaXO+rlz5+Krr76CKIqwtraGl5cXoqKicPToURw9ehQ7d+7Etm3bIJfLtbZbuXIlBgwYAFEUYWtrCy8vLzx48AB9+/Z9qxM+5ibeP//8E61bt0ZKSgqsrKxQvnx5KBQKREZGYt++fdi3bx9GjBgBExMTuLm5wd/fXxq/O/1YywCkeZfehsOHDyMwMBAmJiYoVqwYypUrh9evXyMiIgJLly7Fpk2bsH//funtLgDw9vZGVFQULl++DKVSiVq1ammVmX7umnv37uHjjz/G1atXIZPJ4OrqCnd3d9y8eRPLly/H5s2bsWvXLq0H9elFRkaiWrVqePToESpUqAClUolbt25h5cqVOHjwIP755x/Y2NhobZOQkICuXbti586dAICiRYuiSpUqiI6Oxrlz5xAWFoaSJUuid+/eqF27NqpXr45//vkHmzZtwhdffKE3jhUrVgAA+vfvn+NzbIgRI0Zg1apVePr0KcLCwhAQEJDtNm/7Gjtx4gRmzJgBlUqFihUrwt7ePssxvjNKTk5Go0aNcOLECZQtWxYVK1bElStXsGXLFuzevRt79+5F/fr1DS4vM7a2tvD398elS5cQGxurM/69t7e3QeVcvXoVzZo1w4MHDyCXy1GpUiWo1WpcuXIFly5dwrp16/DXX39lOs9Zbq5VIiIiImNLTU3FJ598gv3796Ns2bIoX748wsPD8fvvv+PgwYMIDQ1F7dq19W4bFRWFWrVq4fbt2/Dy8kLFihWRkJAgrV+wYAFGjx4NURRhb2+PKlWq4OHDh9i/fz/279+Pnj17Ys2aNTm6x8zOkiVLMGTIEACAnZ0dPD09ERkZid69extUZ8zL+YiOjoaPjw9u376NChUqoEKFCrh8+TJWrFiBnTt3IjQ0VKdHS24UK1YM/v7+OHPmDJKSklC5cmWtOlj58uUNKic5ORn/+9//AAC+vr65jkdT/9dX9zeE5sW19DT3zdeuXUNUVFSOeykBQMWKFWFra4sXL17g4sWLmc4bSkT0VolERIVUgwYNRABiUFCQ3vVjxowRAYg2NjZifHy81rotW7aIAEQ7OzsxJCREVKlU0rpTp06JZcuWFQGI06dP19ru6tWroqmpqQhAHD58uJiYmCiKoiiq1WoxODhYlMvloomJiQhAPHTokNa2vXr1yjJeURRFACIA8c6dO/kSb9WqVUUA4rhx43TOQUREhDhnzhytsrKKwVBr1qwRAYju7u4GbxMeHi5u27ZNfPXqlVZ6bGys+PXXX4sAxAoVKohqtVpr/aFDh7LdV1JSknQe2rRpI969e1dal5iYKH711VciANHBwUGMiorS2lZzjSkUCrFZs2biw4cPpXXnzp0TixUrJgIQp0yZorNfzedtZ2cnbt26Ves8x8fHi+vWrROPHj0qpS1btkwEINaoUUPvcVy+fFkEICqVSvH58+eZHm9mcfTq1SvbvGq1WrS3txcBiLNnz9ZapzkXa9as0Up/W9eYu7u7CECUy+Vit27dxOjoaGld+v1kVlZQUJD02Tk4OIjHjh2T1kVFRYmffvqpCEB0dnYWX758adCxaty5c0fab0bZbZs+toyfSWJioujp6SkCEOvUqSNGRERI627duiWd66pVq4qpqal695uba5WIiIgov2nulbK6JxJF7Xs2Dw8P8cyZM9K6Z8+eiXXr1hUBiAEBATrbau5z5XK5WLVqVfHGjRvSOs394sGDB0VBEKT7oOTkZCnPxo0bpbrd3Llztco2pJ6RWf3uwoULUp1w7NixYlJSkrRu7dq1oomJiahQKPTWGfPjfCgUCrFs2bLi5cuXpXX37t0TfXx8RABilSpVdO4lNffeGeMx5Hxkt212jh8/LgIQbW1tdep7Gunvv/XVIeLi4kQPDw8RgNi/f3+9ZWjizOyaHDRokAhALFKkiBTH4cOHpf1WqVJFXL9+vfjkyZMcH2OTJk1EAOKCBQtyvC0RUX7gcHBE9F5JTU3F7du3MXnyZCxYsAAAMHbsWK2u26mpqfjqq68ApA2v1bNnT623vmrXro0tW7ZAEAR8//33SE5OltbNmzcPycnJqF69On744QepF4MgCBgwYAA+//xzpKam5vsx5Tbe8PBwAGmTX2bsvu7m5oZx48bl6xtvueXp6Yn27dvDyspKK93a2hrTp0+Hv78/rl27hlOnTuW47HXr1uHChQuoVasWtm7dCnd3d2mdUqnE7Nmz0apVKzx//hwrV67UW4atrS1+/vlnODs7S2nVq1fHuHHjAAC7d+/Wyn/x4kVpqIdff/0VHTp00DrP5ubmCAwMRL169aS0bt26wcrKCufOncP58+d1YtDE1q5du1y9gWYIQRCk3jhPnjwxaJu3fY15enoiJCQEdnZ2UlpOhmJISUnBDz/8AH9/fymtSJEi2LJlC+zt7fHo0SOsWrUq1/Hlp19++QXXr1+Hqakptm3bptUzqkyZMvjll18gl8tx4cIF/Pbbb3rLyOm1SkRERFQQpKSkYN26dahZs6aU5uDggEWLFgEAjh49mumwuHK5HL/99hvKlSsnpWnuF2fMmAFRFPHJJ59g2rRpUCgUUp5u3bpJ90j6hkPOrfnz5yM1NRWNGzfGd999B1NTU2ldr169MHr0aKSkpGRZRl7OR0pKCkJCQrSGkC5ZsiR++eUXmJiY4OLFi9JoBQWBZmhuZ2dnreGWDREbG4vjx4+jZcuWuHv3LqysrDBq1KgclaFWq7Fs2TIsX74cANCjRw8pjgYNGmDMmDEA0up4gYGBKFasGNzc3NC2bVssWLAADx48yHYfLi4uAJDpMORERG+b8Z/8ERHl0bRp06RxhxUKBcqWLYuZM2fC3t4e3333HSZPnqyVPywsDBEREShevDjatm2rt8yaNWvC3d0dL1++1Bpz+Y8//gAADBs2TO92I0eOzJ+Dyqd4NQ0emzZtyve48ptKpcLOnTsxbNgwfPrppwgICEC9evVQr1493Lx5EwDwzz//5Ljcn3/+GQDQt29frUpfeu3btwcA/P3333rXd+vWTasRQkMz7vStW7e00rdv3y6tb9SokUFxWltbo1u3bgDeDPumkZSUhPXr1wMA+vXrZ1B5uaVpiHv16pVB+d/2NdarVy+YmOR+9NrixYujc+fOOulWVlbSufz9999zXX5+0sTRqVMnuLq66qwvX748WrdurZU3o5xeq0REREQFQZUqVfQO0Vu9enUolUqIoijNz5JR48aN9c7d8/r1a2m+xswaBr788kvI5XI8f/4cYWFhuT+AdP78808Amd+3DxgwINsy8nI+ateuLc2Pm567u7tUnywo978A8OzZMwBpL2oZIv28ora2tqhXrx4OHz6MOnXq4MCBA9kOdTdr1iypnlmrVi0ULVoUX3zxBdRqNerUqYMZM2Zo5Z87dy4OHDiA1q1bw8zMDABw//59/Pbbbxg1ahRKlSqFcePGZfkyqOYlvqdPnxp0jERE+Y1zAhFRoVeyZEnpjfnY2FjcunULCQkJsLOzw0cffaST/8KFCwDS5mxJ3xMjo6ioKABpN3h+fn6IiYmRJlZP/1ZVep6enjAxMcnX3kC5jRcAvvrqK/Tt2xeDBw/G/Pnz0bRpU/j5+aFBgwZaPWKM7dGjR/j000+zbeTRHGNOaM7fkiVLsGHDBr15Xr58CSDt3OmT2XjWxYoVA6DbYKIZ51tf5SsrAwcOxPLly7Fp0ybMnz9fqmTs2LEDUVFRKFOmjN5rOj9pjiX9eN5ZedvXWGZ/a4aqUKGCzrxeGcu+du1anvaRX65fvw4AqFy5cqZ5vL29sWPHDqkHVkY5vVaJiIiICoLM7mEEQYCTkxPu37+f6X1MZveLt27dgkqlApD5/VWRIkVQokQJ3Lt3D+Hh4QbNiZmVly9fSg/6M5v7pXTp0rCxsUFsbGym5eTlfGR1L1mpUiVs3bq1wNz/ApDmb9LUfbKjmVdUFEU8fvwY//77L4C0xqEqVapku/3Nmzellwzlcjns7OzQsGFDdOrUCf369dP74mDjxo3RuHFjJCcn4/z58zh37hz+/vtv/Pnnn4iLi8PcuXMRHx+PxYsX692n5tjSz1VFRPQusRGIiAq9zz//HFOnTpWWX758idGjR2P16tVo1qwZzp8/rzWsUnR0NAAgJiZGmqA+K5oJJtPfZGseqGYkl8tRtGhRg4fSMkRu4wXSzo29vT3mzZuHkydPYtmyZVi2bBkAoE6dOpg9ezYaNmyYb7HmVp8+ffDPP/+gdOnSmDlzJurWrYtixYpJw+317NkT69evz3bYBH0058+QCVjTn7v0MptcNLNhzjQVOn09MrJSo0YN1KpVC2fOnMG2bdvQo0cPAG+GguvXr1+Oh0jICVEUce/ePQCZX+MZve1rLLcTu2pkdRwFrWFEE0fx4sUzzaMZ5i2zmHN6rRIREREVBFnd82nuY0RRzNG2mvslmUwGJyenTMt3dnbGvXv38uWeMC4uTvrd2to603zW1tZZNgLl5XwUpvtfIG2YOwB48eKFQfm3bt2q1fPr/Pnz6NChA7Zs2YLU1FRs3bo1y+3XrFmD3r175ypWU1NT+Pj4wMfHB4MGDcLjx4/RoUMHHD9+HMuWLcOECRNQokQJne00x6Y5ViKid41PBIjovWNnZ4cVK1agbt26iI6OxuDBg7XWa4a7CggIgCiK2f5obhDT38Rn1sijUqky7a2ieXif2c3669ev9abnNl6Ntm3b4vjx43jx4gX++OMPjB8/HmXKlEFYWBiaN28u9ZQxlsePH2Pfvn0AgF27dqFLly5wc3OTGoCA3PUA0tCcv4MHD2Z77u7evZunY9GwsbEB8KaHUU4MHDgQwJuGnzt37uDgwYMwMTHJdWXFUBcvXpRi1vQmM0RBvsayapDVrMtYQc/t32peaeLQ9DjU59GjR1p5iYiIiEg/zf2SWq3OchguffdX2d0PAvrvCdPPcZpVQ8vbbIQpTPe/wJuGqdzW+apVq4YdO3ZAoVBg27Zt2LZtW36Gl6XixYtj6dKlANKeBZw+fVpvPk0jkKEv2hER5Tc2AhHRe0kmk2HhwoUA0sY7Pnz4sLTO29sbAHDlyhWo1WqDy7S1tZXe0L969arePNevX890KDjN21yZ3ZTfuHFDb3pu483I1tYWH3/8Mb799luEh4fD19cXycnJUmODsWgmxyxSpIjeoRxSU1Nx5swZvdsa0itGc/4uXryYhyhzRjMMwf/+978cb9u1a1fY2NggNDQUt27dwqpVqyCKIlq2bJllD5H88OOPPwJIq8z4+PjkePuCeI2Fh4dLw4BkdOXKFQBpQ8all9u/VcCwazIzmvHLL1++nGkeTY+2jDETERERkbayZctKc0tmdn8VHR2NBw8eANC+v9LcD2bVeKTvntDOzk7qdZTZi1B37tzJshdQXmnucbNaV1Duf4G00RAAIDIyEjExMbkqw9vbW5prafz48fk6PHt2ypUrJ/2enJysN4/mHr5WrVrvJCYioozYCERE763atWujZcuWAICgoCApvV69enBxcUFUVBRWrVqVozI//vhjAMCiRYv0rv/hhx8y3VZzc3jy5Em965csWaI3PS/xZsbExAR16tQBAKnSo2FhYQEg86HR8ptmf7GxsXr3uW7dukwrX4bE2qlTJwDATz/99M6OqX379hAEASdOnNBqgDSEpaUlunfvDgAIDg7G2rVrAQD9+/fP5yi1bdq0CatXrwYATJgwAaampnkqr6BcY48ePdI7JERcXJz09/Tpp59qrdP8rZ44cUJvmZq3/fTJy7Fp4vjll18QGRmps/7WrVvYtWuX3piJiIiISJulpSUaNGgAAPj+++/15lm4cCFUKhUcHBy0XoIqW7YsBEFAYmKi3nlLjx8/nulLZi1atACATOtuK1asyNFx5NSpU6f01jnv3buH3377DUDO7n9TU1OzjDmv9/aurq4oU6YMRFFEWFhYrsoAgIkTJ0KpVOL27dtYt25drstJL6tGQI2jR49Kv+uby+nly5e4fv06BEGQrkcioneNjUBE9F7TNP4cOXIEBw8eBJA2ju/cuXMBAMOGDcPChQt1JmiMi4vDr7/+in79+mmljx49GgqFAufOncOoUaOkN31EUcSqVauwatUq6W2zjFq2bAlBEHDhwgVp/0Bat/FFixZhw4YNerfLbbyxsbHo2LEj9u3bp/NG0tmzZ/Hzzz8DSGssS69s2bIAgAMHDuiNJ79VqlQJDg4OSE1NxdChQ5GYmCit27ZtG4YNG5bpJKFlypSBIAh49uxZppWw/v37w9vbGzdv3kSzZs305rty5Qq+/vpr7N69O1+OqXLlytLQbe3bt8eOHTu0hlZITEzEhg0bcOzYMb3ba4aEW7hwIR48eICSJUtKlcn8pFarcfbsWfTp00dqeOrYsSOGDRtm0PaF4RpTKBQYMWKEVoU2Ojoa3bt3x4sXL1C8eHF8/vnnWtu0bt0aALB7925s2bJFSk9MTMTEiROzbNjTHNuhQ4dy3HOvU6dO8PT0RHJyMjp27CjNzwQA//77Lzp16gSVSoWqVauiTZs2OSqbiIiI6EM0adIkCIKAP/74A1OnTtWaY/Tnn3/GnDlzAKT1Hkk/HLWdnR3q168PABgxYoTWUGX//PMPevbsCYVCoXefo0ePhomJCf766y9MmDBBa5/r16/HvHnzMt02PygUCvTq1QvXrl2T0iIjI9G5c2ekpKSgcuXK0v2uhmZ51apVOHTokJQeGxuL/v3749atW5nuT3P/+/fff+c65k8++QQAEBoamusyXFxcpBfnZs6cmS+9gb777jv4+Phg1apVePbsmdY6zfxDPXv2BJA2H2q1atV0yjh69ChEUYSvry+KFCmS55iIiHJFJCIqpBo0aCACEIOCgrLM9+mnn4oAxPr162ulL1y4UDQxMREBiGZmZmLVqlXFOnXqiGXKlBFlMpkIQHR3d9cpb9myZaIgCCIA0c7OTqxdu7bo4uIiAhBHjhwpuru7iwDEQ4cO6Ww7atQoEYAIQHR0dBRr1aolFilSRJTJZOKaNWukdXfu3NHZNqfxRkdHS+WZmpqKFStWFH18fEQPDw8pvU6dOuLr16+19jNv3jxpvZeXlxgQECA2aNBAXLNmTZbnWUNzHDKZTCxatGiWP8eOHRNFURRXrVol7dPW1lasWbOmWKJECRGA2Lx5c7FHjx6ZftYtW7aUjrF69epigwYNxAYNGoj//POPlOfevXti9erVpX2ULFlSrFOnjlitWjXRzs5OSs94jJprLLNjv3PnjrRtRvHx8WLr1q2l9UWLFhVr164tli1bVlQoFFmWK4qiWKdOHWnb7K7xrPTq1UsEIDo5OYn+/v6iv7+/6OfnJ1aqVEm0traW9mFubi7OmDFDTE1N1VuOvnPxNq+xrP6O0svsbyYoKEgEIHbt2lX08/MTAYjlypUTa9asKZqZmYkARAsLi0zLb9eunVR2iRIlxFq1aonW1taimZmZuHz58kw/97CwMOnvsUSJEqK/v7/YoEEDccSIETqx9erVS2f7y5cvS98ncrlcrFKliujt7S2V6eHhId68eVNnu7xcq0RERET5LbP764yyui/SyOy+UHOfm9298vz586X6m729vVi7dm2prgFADAwMFFUqlc52YWFh0n2jpv5Vrlw5qY7SvXv3TPe/ePFiqfyM+xw1apR0TEeOHMn38zF8+HCxbNmyoiAIYqVKlcRq1apJ9UhHR0fx8uXLOmWmpKRI9Q9BEMRSpUqJNWrUEM3MzEQ7Ozvxhx9+yLR+vG3bNulYS5cuLdavX19s0KCB+O2332Z6DBlduXJFutdVq9U669Pfy+qrK2tERkaKSqVSBCCuXLlSa53mvBlarxVFURwzZoy0XwCim5ubWLt2bbFixYpadSkvLy/x7t27esvo1KmTCEAMCQkxeL9ERPmNPYGI6L03depUAGlv4KR/O2nEiBG4dOkShgwZglKlSuHWrVs4e/Ys4uLiEBAQgDlz5uCvv/7SKW/gwIE4cOAAmjRpApVKhatXr8LFxQUrV67EggULsoxl3rx5WLx4MapUqYLY2FjcunULtWvXxsGDB6WeI5nJabzW1tbYuHEj+vbti/Lly+PJkyc4e/YsYmJiUL9+fSxatAhHjhyRuu9rfPnll5g3bx6qVq2Ke/fu4ciRIwgNDcXdu3ezPtEZqNVqREVFZfmjeSvu888/x44dO+Dn54fk5GSEh4fDwcEBc+fOxZ49eyCXyzPdz7p16zB06FC4urriypUrCA0NRWhoKF6+fCnlKVmyJE6ePIlVq1ahWbNmSExMxNmzZ3Hz5k2pJ8jOnTvRpUuXHB1jVszNzfHbb7/hl19+wccffwy5XI7z58/j1atXqFmzJmbMmJFl7x7NW2wymUynp0puPH36FMePH8fx48dx5swZPH78GK6urujSpQuWLFmChw8fYtKkSVme64yMfY0ZwtTUFAcPHsTkyZMhCAIuX74MKysrdOrUCWfOnEHDhg31brd582Z88803KF++PJ49e4a7d++iadOmCAsLQ9OmTTPdn4+PD3777Tc0bNgQr1+/xokTJxAaGorz588bFG+lSpVw8eJFTJgwAZ6enrh58yZu376NihUr4uuvv8Y///wjvW1JRERERNkbNWoU/ve//6Fjx44wMzPD+fPnkZCQgKZNm2Lr1q1Yt24dZDLdx2M+Pj44duwYPv30U5iZmeH69eswNTXFd999hz179mQ6AgQADBkyBPv370fjxo2RmpqKq1evwtnZGatWrcL8+fMRFxcHALCxscn347W3t8epU6cwbNgwxMXF4erVq3B0dETfvn1x7tw5vfOwmpiYYP/+/Rg9ejTc3NwQGRmJhw8fonPnzvjnn3+kOU/1ad++PVavXo06derg2bNnOHbsGEJDQxEeHm5wzBUrVsRHH32Eu3fv4siRI7k6bgAoUaKENDpGfvQG+uabb7B//36MGTMGvr6+SEhIwD///IPbt2/DxsYGH3/8MYKDg3HhwgW4u7vrbB8TE4Ndu3ahaNGi0jDlRETGIIhiuvFpiIgozzw8PBAREYFDhw5l+oCZKDuzZs3CpEmT0KJFC+zdu9fY4RARERERUT549uwZnJycIAgCoqOjYWtrmy/l9u7dGyEhIQgKCpJehCxMjh07hvr166NVq1bSPJiF3cyZMzF58mTMnz8fo0aNMnY4RPQBY08gIiKiAkalUmHlypUAgAEDBhg5GiIiIiIiyi+a+/wqVarkWwPQ+6BevXro2LEjdu/ejbCwMGOHk2cvX77EvHnzULZsWQwdOtTY4RDRBy7zvqtERERkFIsWLcKdO3dQunRpnUlbiYiIiIioYNu0aRPs7e3RrFkzabhllUqFVatWYdq0aQCAYcOGGTPEAmnevHmoWLEinj59auxQ8uzOnTsYMWIEmjVrBlNTU2OHQ0QfODYCERERFQDnz5/HyJEj8ezZM1y9ehUAMGfOnBzN0UNERERERMZ37tw5zJ8/H1ZWVihXrhzkcjlu3LiB2NhYAEC3bt3yZd7P942bm1uhHMpOn+rVq6N69erGDoOICAAbgYiIiAqEly9fIjQ0FAqFAhUrVsRXX32FDh06GDssIiIiIiLKoU6dOuHly5c4duwY7ty5g7i4ONjZ2aFZs2bo06cPOnfuDEEQjB0mERF9IARRFEVjB0FERERERERERERERET5S2bsAIiIiIiIiIiIiIiIiCj/sRGIiIiIiIiIiIiIiIjoPcRGICIiIiIiIiIiIiIiovcQG4GIiIiIiIiIiIiIiIjeQybGDoDyj5eXF6Kjo1G6dGljh0JEREREZDT//vsv7O3tER4ebuxQPkislxARERERFZx6CRuB3iPR0dGIj4832v5jY2MBADY2NkaLISdMBBEd3V5Iy1vvFUGqKBgxIuMpbJ9dQSXKRKRUTpGWFZcVENRv75ri55ZzMkEOTwdfafn685NQi6p3Hgc/u8KJn1vhxc+ucMrL52bMe2JivYQKJl4XlBleG6QPrwvKDK8N0iez66Kg1EvYCPQe0bxpd+LECaPs/8iRIwCAgIAAo+w/x5JeAYtqSYvDQ/4ClNZGDMh4Ct1nV0C9TnmNVjtaScu7F++GpcLyre2Pn1vOJSemYmPQSWl52bTZMDV79/8U8rMrnPi5FV787AqnvHxufn5++R0O5QDrJVQQ8bqgzPDaIH14XVBmeG2QPpldFwWlXsI5gYiIiIiIiIiIiIiIiN5D7AlElE9UcXFAamragokJ5FZWxg2IiIiIiIiIiIiIiD5obASiD5cgA4qW1V7OgwejRiHh7DkAgHnNGnBbvjxP5VHhI0CAu4271jIVLIIgwM7JQmuZiIiIiIiIiIjofcVGIPpwmVoCfX43dhT0HrFQWGBNizXGDoOyoFDK0XZ0DWOHQURERERERERE9E5wTiAiIiIiIiIiIiIiIqL3EHsCEeUT+y5dYN2oMQDAxMnRyNEQERERERERERER0YeOjUBE+cS6USNjh0BEREREREREREREJGEjEH241Crg+Y03yw7lAZncePFQoadSq3An5o60XMq2FOS8pgoUtVpE9OPX0rJ9cUvIZIIRI6L3mVqtxtOnTxEbG4uUlBSo1Wpjh/TBMjc3BwBcunTJyJGQIWQyGRQKBUxMTJCammrscIiIiIgKFNYzjIt1iw+Hpl5iY2MDJycnyGSFd2YdNgLRhyslHlj32ZvlYWcApbXRwqHCL1GViAF/DZCWd7fdDUuZpREjooxSk1XY9cN5abn7NF+YmvGfQsp/iYmJuHPnDlJSUqQ0QWCDo7EolUpjh0A5oFKpoFKpYGZmhtTUVCQmJsLMzMzYYREREREZHesZxse6xYdDUy9JTExEdHQ0SpUqVWjrJXzyRURERJTPnj59ipSUFFhYWMDFxQVmZmaF+q2hwi4pKQkAK2yFhVqtRmJiIiIjI/H69Ws8ffoUbm5uxg6LiIiIyOhYzzA+1i0+HJp6ycOHDxEfH1+o6yX8lqAPmACY2735Ad+cICKi/BEbGwsA8PDwgIWFBStmRDkgk8lgYWGBEiVKQCaTSX9PRERERB861jOI3h1NvcTDwwMACnW9hD2B6MOltAKGhOVbcY9nzETitWsAALMKFVB88qR8K5uIiAoXURQhCAJMTHirRZRbJiYmEAQBoigaOxQiIiKiAoH1DKJ3732ol/AbgyifJN+LQFJ4OABAZmlh5GiIiIiIiIiIiIiI6EPHRiAiIiIiIiIiIiNLTFHhysMYxCWpYKWUo5KLLcwUcmOHRURERIUcG4GI8om5dxXILCwBAMoyZYwcDRERERERERUGT2ITse7EXWw/9wAv41MgQoQAAXYWCrSrUQK9/DzgZGNm7DCJiIiokGIjEH241Gog/vmbZQsHIA8T6jkOG5oPQREREREREdGH4tqjWAxcfxaPYxORolJDBgGCkDbvx+PYRKw4ege7LzxCcGBNVHC2MXa4REREVAjl/ok3UWGX8hpYVv/NT8prY0dEREREREREH4gnsYkYuP4sHr5MgFotwtxEDnNTOcwUaf83N5FDrRbx8GUCBq4/i6exicYOmYiIiAohNgIRERERERVSK1asQNWqVWFubg5HR0d069YNEREROSojKioKX3zxBVxcXKBUKuHp6Yk5c+YgNTVVJ+/WrVvRt29fVK9eHaamphAEAYcPH9Zb7s2bNzF16lT4+/ujePHisLS0RMWKFTF8+HA8evQoN4dLRPReWXfiLh7/17CjNJFBJhO01stkApQmaY9tHscmYt2JnH2/ExER5dSlS5fQtWtXeHl5wc7ODubm5ihfvjwGDBiAmzdv6t0mPj4e48ePh4eHB5RKJTw8PDB+/HjEx8cbvN+3Xc94+vQpxowZAy8vL1hYWKBYsWKoX78+Nm7caHCMhRmHgyMiIiIiKoS+/vprzJgxA/7+/li4cCGePXuGhQsX4vDhwzh16hRcXV2zLePVq1cICAjA9evXMXjwYFSpUgVHjhzB+PHjcfnyZaxfv14r/08//YSTJ0/C29sbXl5euHTpUqZlr1q1CosXL0arVq3QqVMnmJub4+TJk1iyZAk2bNiA//3vf/Dy8srzeaCCSSbIkZyo25CYGYVSDkF48wBcFEWkJKkM3l5uIoPcRPsdR1WKGiqV2uAyTM20q8eM4b8Y1CJSkvMWQ2qKCmqV+O5iUMggl2vHoFaJENUw+Lp8GzGkPw+JKSrsOvMASFXDUi6HTBQAMe0zBwAIAlJlgCAIMJXLkJCqwo5zkRhQ1wNmCnnuY0hWQa027LMQBAEKpfa+1GoRqXk9DwUsBlVK2v8zuzbeVgwpySqIeTkPKjVSUwz/2zZRyCDLSwwyAQrT9zSGJNWbv73/ZHZd6ItBpVJDlZMYTOU6jb76YtBHFEWtfy/Tp+dUxnJyWkZety/sMWjyvW/n4e7du3j27Bnatm2LEiVKwNTUFNevX8fatWuxadMmHD16FNWqVZO2U6lU+OSTTxAaGorAwEAEBATgwoULmDdvHsLCwvDXX39BLs/+3y199QxRFPUey8qVK/HTTz+hVatW6NixY6b1DM22MTEx8PHxwePHj9G3b19UrVoVsbGx2LBhA3r06IErV65g5syZ2Z5LURQz/bdClSJC0NPdRibIoRYN//fibWEjEBFRPjGVm2Jq3alay1SwyBUyfNTDS2uZiKgwunHjBr799lvUqFEDhw8fholJ2m19ixYt4OPjg4kTJ2LdunXZljN37lxcvXoV8+fPx6hRowAA/fr1g62tLRYvXow+ffqgUaNGUv6QkBC4uLhAoVBg6tSpWTYCdejQAePHj4ednZ2UNmDAAPj6+mLgwIGYMmUKfvnll1yeASroPB18sTHopMH5e33rj/R1blFEjrav1sQN1Zu6aaWd//seLh6KNGh7QRDQe7a/VpoqVZ2jGGo0d0fVRiW10s7tj8DlIw8M2l5uIkPPmXW10lKSVDmKodbHHvBuqN0AfGbvXVw9/tCg7RVKOXpM99NKS0pIxebpYQbHUKdVaVSs56KVdnrPHYSffGzQ9koLBboF1dFKS4hLwc8zTxkcg99nZeDl56yV9uSCGi8jRNzdn/35tLAxRedJPlppr2OSsHX2GYNj8G9fFuV9imul/W/7bdw+9xQAkKJSo1U8IIpm0rUvSv8BXstFbC+a9tBIJhMgg4CUVynYMi0MCrlh97D1O5VH2ZpOWmnHtt7EnYvPM9lCm01RM7QfV0srLeZpPH5b8I9B2wNAg66eKF3NUSvtyJYbiLgSZdD2dk4WaDu6hlZa9OPX2PXDeYNj+KiHFzy8HbTSDm+6jvvXXgAAkv9rzMns2ijibIk2I6trpUVFxmHPTxcMjqFJr4ooWbGIVtqhddfw4OZLg7Z3cLVGq2FVtdKe3YvDH8suGhxDs88roYSnvVba32uu4tG/MQZt7+Rug08HV9FKe3InFn+uuGxwDC36V4ZzWTuttP0rr+BpRKxB2zuXtkWLgd5aaY9uxWD/6isGx/DJoCooVkp7fq0/l1/G88hXWmmZXRclytmhWb/KWmkPr7/EgZCrBsfQckhVOLpZa6X9sfQiXjzKfpoCr0+VsLRV6qSrUtVITjD85QszSwUEufbD7sTXKQY3yMlNZFBaKApeDCnqHL2EYmZpCiFD+0RiXEqWjSiaVaqkZMgVcijNtR+v5zgGK1NkbNfLLob09MWQmqJGSi5jaNWqFVq1aoX4V8lvDhZAm5Zt0aBRfcybOx8rlq2S0kPWr0VoaCiGDRuGH3/8UUov6eqGr8aPw4rgVegV2DvbGNauWYsSriW06hlJ8alIeJWsk7fVx20wYsgorXpGn1594efnp1XPSE1WIyUpFZvWb0ZERATmfDsXQwcPk7bp3aMvKleriKVLlmLy+CCYW+s+x0t4lQJAhFotIj4mKdP7suRkFYqUlQEfaaeXK+qD689PZHv8bxuffhHlk5fbd+DZ4p/wbPFPeLl9h7HDISNQyBQIcA2QfhQyRfYb0Tsll8vg4e0g/WR8G4+I3p21a9dCEAQcPHgQ3333HcqVKwczMzNUqFABmzdvBgA8fPgQPXr0gKOjI8zNzdGsWTPcunVLb3khISHw8/ODlZUVLCwsULNmTaxdu1Yn3/79+9G1a1eUKVMG5ubmsLGxQUBAAHbv3q2Tt3fv3hAEAa9evcKXX34pDZdWuXJlozdebNq0CSqVCsOHD5cagACgVq1aCAgIwLZt25CQkJBtOevWrYOFhQW++OILrfTRo0dL69Nzd3eHQmHYv2+1atXSqphpdOnSBQBw8aLhD66IiN43oii196RL1F6fXtrDOVEnnYiItK3fuA6WtmY4HHoI3y+cjyrVK6GIky1q1K6KX7b9DAB49OghPu/fG8WKO2Vbz9iwaT0+atIATi5F4VDcHvUa+GHDRt2XrTT1DE+v8ihazA7FXR3R7OPG+GPv7zp5B3zRD5a2Znj16hVGjSpY9YzMlCyZ9rLNy5cvtdI3b0kbTk1Tf9AYNPALmJubS+uzk5N6Ro0aNXNUz4iJTWtodi6u/YKIhYUF7GxtYW5hYdB+CzP2BKJ89TwuCZvC7uVom2513LLPVAjE/rkXCWfPAQDMa9aAXbu2Ro6IiIgKshcbNyL6v8YOjZI//QRTd3e9+VMePcK9/v210uzad0DRPr0z3ceDseOQeO3NW4km9kXgvj7z3iGxf/6JZ4sXa6U5f/MNLKpXz2SLvJswYQLi4uLQt29fmJubY/ny5ejevTvkcjnGjRuHunXrYvr06YiIiMDChQvx2Wef4eLFi5DJ3jTiDhw4EMuXL8enn36Kb775BgqFAnv37kWfPn1w8+ZNTJkyRcq7du1aPHnyBD169ICrqyuePXuGkJAQtG7dGlu2bEHnzp11YmzevDksLCwwbtw4qFQqLFmyBJ07d0apUqVQu3btbI8xLi4OiYmGT+bt4OCQbZ6wsLS38uvWrauzrm7duggNDcWlS5fg4+Ojs17jyZMniIiIQN26dWFubq61zsPDA87Ozjh1yvA37w314EFar4hixYrle9lERIWFIAAC9DQEZUIU0zbSMwoUEZGWV1u34NU27YYEx3kLoSip//mbpp4hqt+0Tlu1bgub7oGZ7uPppAlIvhkuLZvYF0GJ1Wsyzf/6wH7ErFimleY84xtY1qyRyRZ5FzRtCl6/jkPPwN4wNzfHmrWr8Hm/3pDL5JgcNBF1fHwxdeo03L9/T6uekd6wEUOweu0qtGj+Mb6eFASFQoH9f+3DoCEDcPvfW/jmm5lSXk09o1u3biju5Iznz59j4+YN6NilPUJWr0eH9h11YmzTrhWsrC116hlHDh1HzRo1sz3GuLg4pKhSdHoCpSSrkJKk2xPIoWj29QyNxMRExMW9QkpyMm7dvoVZs9OO9ePmH0t5RFHE2XNn4eLsAvcM9Vhzc3NU8a6Kc/+cy3QYw/yWWT2jcaMmkMlkCJr2NSwsLFDFuwpiYmOxes1K3Lx1E4t/XPLWYzM2NgIRERERGYHqRTSSb93WShOTdbu6S+tSU3Xyq6KyHs4l5cEDrW3UjlkPtaGKidWNyYDeJHkRHx+Ps2fPwszMDADQqVMneHh4oEuXLpg5cyYmTJgg5XVycsLo0aPx999/o2nTpgCAPXv2YPny5Zg9eza++uorKe/QoUMxePBgzJkzB4GBgShVqhQAYMWKFbC0tNSKYeTIkahWrRqmT5+utxHIy8sLq1evlpY7dOiAcuXKYeHChQZNJDp06FCEhIQYfE4MGfohMjJtiCt98/5o0iIjI7NsBMqqDE16eHi43nV58fXXXwMA+vTpk+9lU8Fx/flJLJs22+D8GZ8LCALQfZqvwdtnnIMGAKo1dtMZGi0n5CayPMdQo5k7qjYuqSe3YRRKeZ5jqPWxB6o3y/2Ld0pzkzzHULtlKdT82CPXMZhbKXIWg54hf4tVlcHJG/D3N7yc9CxtlXmOoW67MvBtUxpA2pxAn/54DE9eJcJcnjY/SFzymwd2MgFQ/PfIRq0WoYYIhbUCXYbWydGcQBnV61gOdduXNWh7fQ/sbJ0s8nweArqUz9GcQBnZF7fMcwwNu3lKMRw/fhxA5teGvhiKulrlOYaPelbI0ZxAGTm65SwGEz0xNO5TMUfz8WRUrJRNnmNo1q9SnmJwLmub5xhaDKisc/+V2XWhLwYXT7ucxWCq+zf8yRdVDLoHDL9xVe/1IDeRSUNZxcXHIuXOv1rrlQoRSj1DXQH66xlC3Eu9Q2NpqJ480qlnpI8ho6SUeJ2YxETdeoaZZd5GVJErZNKcbolJCTh77k09o3tgV5QqVQq9Pg/EjBkzpHqGIAha9YwmTZoASKtnrF67Ct9++61WPWPIsC8wfPhwfL9wPgYNHojSpdO+1zX1jPSf45ivRqN69eqYM+9bBPbuLqWb/Pc9XqFiWj1D85lq6hnLVvyEDRs2ZHu8g4ePzlE9Q602fO6qjVtCMHz4cGm5ePHi+O677zB42BdSvFFRUYiPj0flypV1tjcxlcHNvSTCTp1EYuprFClSRCdPdpQWJllehxllrGeYmMpgYmqK2r41sGnTJowZMwYdOreT8tvZ2WHHjh1o1apVpmWaW6ddkzKZAEs7JbpP0/+C5PHjx/XOCXQzKv9fqssNNgIR5RNBbgLhv+FYBDn/tIiIiAwxbNgwqWIGAM7OzvD09MSVK1fw5ZdfauVt2LAhAOD69etSI1BISAiUSiW6d++O58+1G8Xatm2LpUuX4uDBg+jbty8AaDUAvX79GomJiRBFEY0aNUJwcDBevXoFa2vtMdrTV/qAtKEKypcvjxs3bhh0jOPGjUOPHj0Mymuo+Ph4AIBSqTsmvOZ8avLkpgxNOdmVkVOzZs3Cr7/+is8++wy9evXK17KpYFGLKukhTG4IgpCn7YH/JmLPw/x/jOG/GGR5j8FEIQfy8FwvP2KQyQVAjlyXk9/nwdTMBK1rlcCKo3fwWq2GUpAhJd1z3bRGoP8moVapoZDL0LaGK2ys9X9nGxyDnofPOSHLj/NQwGKQK9JOfE7KzI8YFHk9D3IZTPM4vDVj+C8GpW4MObku5HJZnoca1xeDPpn1pkifLkA3jyAIOeqJIQiZ7yunsWmiMiR/XnuLpD/OYcOGafV2d3FxkeoZo0aN0tqXvnrGunXroFQq0aNHD0RFvZnHLCkpCa1bt8by5cvx999/S41AmnqGIAh66xlxcXE69Yzx48drxZG+nmHIuchpPSMn57dt27aoUKECXr9+jUuXLuGXX35BTEwMVCqVNGybZvhpffUJQRCkeklCQkKuPtucXLf66hnpty1SpAg8PT3RoUMHBAQEIDY2FqtXr0bHjh2xZs0adOvWLdMY0v+e2XeC5jsjI7WoMij+t41PqonyScml73/XQcpaYmoivjn5jbT8te/XMDMxy2ILetdSk1U4vOm6tNywm2eeK6FElDdlypTRSStSpAhcXFy0Goc06QC0KmFXr15FUlISSpbM/E37J0+eSL/fvXsXX3/9Nf744w+8ePFCJ290dLRO5UxfjA4ODoiIiMh0n+lVrFgRFStWNCivoSz+G7c6KSlJZyg3zdBzFtmMbZ2+DH0SExOzLSMnfvjhB0yaNAkNGzbExo0b38mQEEREBVkvPw/svvAID18mIClV9+1stTqtAQgAnG3N0NNP/5CxRESk613UMx4/fiz9/r7UMzRcXV2lEQPatGmD7t27o2rVqnj8+DFWrlwJwLD6RPp8b0t29Yw//vgDrVq1wqJFizB48GApPTAwEHXr1sWAAQPQpEkTODk5vdU4jYmNQERE+UQlqnDi4QmtZSpY1GoR96+90FomMhZ5EXuYltW+6RdMM+/qLpiY6OSXZzOms6JECahiY6RlE/usu+DLbW10Y8rQwJDf5HL9DbGZpQPaw6Wp1WpYWVlhx44dmeYvUaIEgLQxswMCAhATE4MRI0agSpUqsLGxgUwmw+rVq7F582a9QySYmOi/ZTZkyA4AiImJkd6SM0Tx4sWzzePq6orLly8jMjIS5cqV01qX3TBv6ctInz+jyMjIbMsw1Pfff4/Ro0ejcePG2LVr11uvCBIRFQZONmYIDqyJgevP4nFsIpDu3lQtAgmpKijkMjjbpuVzsuELZkSUPdYz/tvnW6pnJP83hLepqanUC+h9qmdkplSpUggICMDatWvx008/QalUokiRIrCwsMiyPmFpaQl7e/tc7zc7htQz5s2bB7VarTP0t0wmQ4cOHRAWFoaTJ0+idevWby1OY2MjEBEREZERFOneHUW6d88+438Uzs4os2dPjvZRYu53Ocpv06IFbFq0yNE2xla+fHmEh4fD29tbZwJQDc2baQcPHsT9+/exatUqfP7551p5VqxY8dZiHDFiRL7PCeTj44M///wTJ06c0GkEOnHiBMzNzfWOzZ1esWLF4ObmhvPnzyMhIUGrR1FERAQePXqEZs2aGRx3ZubMmYPx48ejRYsW2LFjh86bl0REH7IKzjbYNsgP605E4KdDtzRzskMmAMVtzdCuuit6+rmzAYiIDMZ6Rv7IrJ6hqVukHwLtfapnZCUhIQEqlQqxsbFwdHSEIAioVasWjhw5goiICLi7u2vlPX/+PHx8fN7aCACG1jMePnwIAFCpdF/WTk1Nm48vJSXlrcRYULARiIiIiIgKrd69e2PXrl0YM2YMQkJCIJNpj8ceExMDQRCgVCqlt/4yVn4uXryI33777a3F+DbmBOrWrRtmzpyJH374Ad26dZPeIjxz5gxCQ0PRvXt3rbfgYmJi8OjRIzg4OMDB4c2bnYGBgZg5cyaWLl2KUaNGSenz58+X1ufFrFmzMGnSJLRs2RLbtm3LdP4hIqIPmZONGcY098Sa43egFgERItyKWGDX0HowU3DoYiIiYzCknmFmZvbe1TMeP36st8fQmTNncPz4cZQtWxaOjo5SemBgII4cOYL58+fjxx9/lNKXLl2KhIQEnfrEo0ePEBMTAzc3tzyNDpCTekalSpVw/fp1rFq1ChMmTJDSk5KSsGHDBshkMtSuXTvXsRQGbAQiIiIiokKrbdu2GDRoEJYtW4ZLly6hXbt2cHFxwZMnT3Dx4kXs2rUL58+fh4eHB/z9/eHs7IzRo0fj33//hYeHB65du4YVK1bA29sbZ8+efSsxvo2xuj09PTFu3Dh8++23aNiwIQIDA/H8+XMsWLAATk5OmDVrllb+HTt2oE+fPggKCsLUqVOl9HHjxmHbtm0YN24c7t69i6pVqyI0NBTr169H165d0bhxY61yjhw5giNHjki/A8D69etx7NgxAGmVQM0bgD/99BMmTZqEYsWKoV27dti6davOceR3pZWIqDATBAFyAQAEWCpN2ABERGREmdUzHjx4gMuXL2PPnj24du3ae1fP6Nq1K1JSUtCgQQO4ubkhKSkJ58+fx+bNmyEIApYtW6aVv0+fPli3bh0WLVqEmJgYBAQE4MKFC1iyZAnq16+P3r17a+WfMGECQkJCcOjQITRs2FBKf5v1jEmTJuHPP//EpEmTcPHiRQQEBCA2NhYhISG4du0avvzyS7i5ueX53BVkbAQiyieJ169D/eoVAEBmbQ0zT08jR0RERPRhWLp0KRo1aoTg4GAsWLAAr1+/hpOTEzw9PTFr1izpTTY7Ozvs378fX331FZYuXYqkpCRUqVIFGzduxLlz595a5extmTlzJtzd3fHTTz9hxIgRsLKyQtOmTTFr1qwsJ7BNz8bGBkePHsXkyZOxdetWBAcHw93dHbNmzcKYMWN08h88eBDTpk3TSlu9erX0e7169aTK2enTpwEAT5480RkWQ4ONQERERERUUGVWzyhXrtx7W8/o1asXfv75Z4SEhOD58+cAADc3N/Ts2ROjRo2CZ4bnnXK5HH/88QemT5+On3/+GZs3b4azszNGjRqFKVOmZDkHU3pvs55Ro0YNhIWFYdasWQgNDZV6Dnl7e+sdwu99JIh5HQyQCgw/Pz8AaePAG8ORI0fwPC4JiUVz1vjRrY6RWlqTXgGLar1ZHnYGUFrnurh7AwYg4ew5AIB5zRpwW748rxG+M5oW9oCAACNHUri9TnmNVjtaScu72+6GpcLyre2Pn1vOJSemYmPQSWm5+zRfmJq9+/ch+NkVTjn53C5dugQA8Pb2fqsxkWH0jdtNBV9SUhKuX78OQRBy/Ldk7PviD52xzz//nSV9CsN1UTlon/R7uWJW2DHY34jRfDgKw7VB715BvS5YzzA+1i0+TNn97WX2nWHs+2INWfZZiIiIiIiIiIjoXXk7U2gTERHRh4iNQEREREREREREBQiHbCEiIqL8wjmBiPKJ0+jRWnMCEREREREREREREREZExuBiPKJmWfO5kIiIiIiIiIiIiIiInqb2AhEHy5BBjh6ai8T5YEAAaXtSmstU8EiCAKKOFtqLRMREREREREREb2v2AhEHy5TS6DXLmNHQe8RC4UFVjZbaewwKAsKpRxtRlY3dhhERERERFniq0pERESUX9j1gYiIiIiIiIioABGNHQARERG9N9gIRERERERERERERERE9B7icHBE+eT+F4ORcO4cAMC8Rg2UXLrEyBERERERERERERER0YeMjUD04VKrgCeX3ywXqwzI5LkuTlSlQkxNlX6nD49KrcKN6BvScnn78pDn4Zqi/KdWi4iKjJOWi7paQSbjiOtERERERERERPR+YiMQfbhS4oGNnd4sDzsDKK2NFw8VeomqRAz5e4i0vLvtbljKLI0YEWWUmqzCnp8uSMvdp/nC1Iz/FBIRERERERER0fuJT76I8olNi49hXqUqAEDh4mLkaIiIiIiIiIiIiIjoQ8dGIPqACYCVo/ZyHti1a5u3cIiIiIiIiIiIiIiI8pHM2AEQGY3SChh07M2P0srYEREREX0w7t69C0EQtH7MzMzg6emJsWPHIjo6Wiu/h4eHTn7Nz549e/TuY8WKFahatSrs7Ozg6uqKbt26ISIi4l0cXq5pYjY3N4ejo2OuYo6KisIXX3wBFxcXKJVKeHp6Ys6cOUhN1T9n4cWLF9GqVSvY29vD0tISvr6+2L59u968sbGx+Oabb+Dt7Q1ra2sULVoUtWvXxk8//YSUlJQcHy8RERERUX7KaT3j9evXmDhxIsqVKwelUglHR0d07twZN2/e1Cn78OHDMDMzg5mZmc4+HBwc3tUh5khoaCjatWuHMmXKwNraGlZWVqhQoQLGjBmDhw8f6t1mx44dqF+/PqytrWFpaYk6depg8+bNOd739u3b4evrC0tLS9jb26NVq1a4ePGi3rypqamYM2cOPD09oVQq4eLigi+++AJRUVF68+e0zvOhY08gIiIiIjKa+vXrY8CAAQDSbuT37NmDefPmYf/+/Th9+jRMTU2lvF5eXpg0aZJOGdWrV9dJ+/rrrzFjxgz4+/tj7ty5eP78ORYvXozDhw/j1KlTcHV1fXsHlUvpY164cCGePXuGhQsX5ijmV69eISAgANevX8fgwYNRpUoVHDlyBOPHj8fly5exfv16rfwXLlxAvXr1oFQqMXr0aDg4OGDDhg1o3749Vq5cib59+0p5U1NT0bhxY5w7dw6BgYEYOnQokpKS8Ouvv2Lo0KH43//+h40bN+b7eSEiIiIiyilD6hkJCQlo2LAhzpw5g88++wxffvklnj17hiVLlsDX1xf/+9//4OnpqVN237590bBhQ600MzOzd3FYOXbt2jUkJSWhR48ecHZ2hiAIuHjxIpYuXYr169fj3LlzKFGihJR/7ty5GDduHEqXLo1JkybB0tIS27dvR7du3RAZGYmxY8catN9Vq1ahX79+qFy5MubMmYPExEQsWrQI/v7+OHbsGKpWraqVv0+fPtiwYQNatmyJMWPG4M6dO1i4cCGOHDmCkydPwtr6zTzuOa3zEBuBiIiIiMiISpcujR49ekjLI0aMQMuWLfH7779j586d6Nixo7SuWLFiWnkzc+PGDXz77beoUaMGDh8+DJVKBQBo2bIlfHx8MHHiRKxbty7/DyYPMsZsYpJ2m96iRYscxTx37lxcvXoV8+fPx6hRowAA/fr1g62tLRYvXow+ffqgUaNGUv5hw4bh9evXOHToEGrVqgUgrVJbp04djBo1Cu3bt4ednR2AtDcfz5w5gxEjRmDhwoVSGUOGDEGtWrWwefNm/PTTT1J+IiIiIiJjMaSesXz5cpw5cwYDBgxAcHCwlDcwMBCVK1fGsGHDsH//fp2y69SpY1C9pCAYNGgQBg0apJPeoEEDdO7cGcuXL8e0adMAAE+fPsXXX3+NYsWK4ezZs9J9/dChQ/HJJ59g8uTJ6NixIzw8PLLcZ3R0NEaNGgVXV1ccP34cNjY2AIBOnTqhYsWKGDZsGI4cOSLlP3jwIDZs2IDWrVtj586dUnrNmjXRoUMHzJ07F9OnT5fSc1rnIQ4HR0REREQFTIsWLQAAt27d0lmXmpqK2NhYiKKY6fabNm2CSqXC8OHDpcYUAKhVqxYCAgKwbds2JCQk5H/geZBfMa9btw4WFhb44osvtNJHjx4trde4e/cujh49igYNGkgNQACgUCgwfPhwxMbG4rfffpPSY2JiAAAuLi5aZcvlchQvXhxyuRxKpdLwgyYiIiIieocy1jMOHjwIIK0XSnqlS5dG/fr1ceDAAdy/f19vWfHx8QWuTpET7u7uAKA1PN7x48eRlJSEzz77TOvFLkEQ0LNnTyQnJ2PDhg3Zlr1z507ExsaiX79+UgMQALi5uaFDhw44evQo7t69K6Vr6iiaBh2N9u3bw8PDQ+dluJzUeSgNewLRh0utBl49erNs7QzIct8u+mzRYiTdvg0AUJYpA8dhQ/MaIRERvc9OrQBOr3z3+208BfD6VP+6qNvAlm7aabX7AT79335c6dy4cQMAdMbVDgsLg4WFBVJSUmBhYYEmTZpg+vTpOkMJhIWFAQDq1q2rU3bdunURGhqKS5cuwcfHJ1fxxcXFITEx0eD8howPnh8xP3nyBBEREahbty7Mzc211nl4eMDZ2RmnTp0yeJ8AcOrUKfTu3RsAUK9ePVhZWeG7776Du7s7/Pz8kJSUhJ9//hn79u1DUFCQzn6JiIiI6N3aHL4ZP4f/nKcyvIp6YXb92ZmuH390PMKjwvO0j85endHVq2ueysipjPWMpKQkAICFhYVOXgsLC4iiiLCwMJQsWVJr3ZgxY6Sh5lxdXdGjRw98/fXXesvJiZiYGIPn2ZTL5bC3tze47Pj4eKnh6sqVKxg/fjwA4NNP39QNszsfAHDy5Mls95VdPSMkJASnTp2SehSFhYVBJpPB19dXJ7+fnx82b96Mp0+fwsnJKcd1HkrDRiD6cKW8Blak6xo47AygtM48fzYSLl1EwtlzAAB1/Ou8RkdERO+718+BZ3mrOOVKYmzm61TJujG9fv5Ww0lKSsLz52n7ePHiBXbt2oWlS5fC1tYWbdq0kfJVrFgRffr0QYUKFSCTyXD69GksXrwY+/fvx/79+1G/fn0pb2RkJADonUNHkxYZGZnrRqChQ4ciJCTE4PxZ9VrSyI+YsypDkx4eHm5Q/vT71ChWrBh27dqFQYMGoUuXLlK6mZkZgoOD0b//u20sJCJ6nxnwTwcRkV7RidG4HXM7T2XYKG2yXP8w7mGe9xGdGJ19pjwwpJ5RqVIl7Nu3DwcPHkSVKlWkbePj46WGjHv37knpCoUCH3/8MVq0aIFSpUrh6dOn2L59O2bPno0DBw4gNDQ0Tw1Bbdq0QWhoqEF53d3dtXrTZGfKlCmYP3++tFyqVCmsXbsWzZs3l9IqVaoEIG0YaFEUIQiCtO7QoUMAtM9HZnJaz4iMjISDg4PeUQXS53dycspxnYfSsBGIiIiIiIxmy5Yt2LJli1ZatWrVEBwcDCcnJyntjz/+0MrToUMHdO7cGb6+vhgwYACuXbsmrYuPjwcAvZUIzYStmjy5MW7cuHwfAzw/Ys6qDE056cvIzT5tbGxQvnx51KtXDy1atEBKSgq2bt2KgQMH4uXLlwZPFEtERERE9DYZUs8YPHgwgoODMWXKFFhaWqJJkyZ4/vw5goKCEBUVBUD7ftjf3x87duwA8OYeum/fvhgzZgzmz5+PH3/8Uephkxvz58/XGp4tKzntgT9w4EC0aNECMTExOHv2LPbs2YMXL15oNfZ4e3ujefPm2LdvH3r37o1Ro0bB0tIS27dvx8qVaaNYGFKPymk9Iz4+PtNeTRnz57TOQ2kKVSPQhg0bcPToUZw9exaXLl1CcnIy1qxZIw1RoZGSkoJdu3Zh165dOHXqFO7fvw9BEFCxYkX07t0bAwYMgFwu17uPjRs34ocffsCVK1dgamoKf39/TJ8+HTVq1NCb//Tp0wgKCsL//vc/pKSkwNvbG6NGjUKnTp305n/06BEmT56MP/74A9HR0XB3d0fPnj0xbtw4KBSKPJ0fMi5TN3eoX8dLvxMREVH2mjVrhrFjx0IQBCiVSri7u+sMt5CZGjVqoHXr1vj1119x69YtlC1bFsCboQqSkpJ0KkeaYdzy8oZexYoVUbFixVxvr09+xJy+DH0SExO1ysgqv759XrhwAf7+/hg+fDi+++47Kb1bt27o2LEjxo8fjxYtWsDb2zvLOImIKHvpXr4mIqJcMKSeUaZMGezduxf9+vWThncDgEaNGmH8+PGYPn261pw2mQkKCsL333+PPXv25KkRqGbNmrneNjvlypVDuXLlAKTNtfPZZ5+hbt26eP36NSZPnizl27JlCwYNGoT169dLc+sUK1YMq1evRufOnQ06HzmtZ1hYWGRZh0mfP6d1HkpTqBqBJk+ejIiICDg4OMDZ2RkRERF6892+fRsdOnSAlZUVGjdujNatWyMmJga7d+/G4MGD8ccff2DXrl1aXdoAYObMmZg8eTLc3d0xaNAgvHr1Clu2bEHdunXx999/w9/fXyv/oUOH0Lx5c5iZmaFLly6wtrbGr7/+is6dO+P+/fvSZFQajx8/Rp06dRAZGYm2bduiXLlyCA0NxeTJk3Hq1Cn89ttvOjFR4VF88iRjh0BGZio3xYx6M7SWqWCRK2Ro0qui1jKR0Vg6AI5e736/ZlnctMtNdWOyzH4+m7xwdnZGkyZNcr19qVKlAABPnz6VGoFcXV1x+fJlREZGShUdjeyGDzBETExMjiaBLV68eLZ58iNmfUMrZCwnfRlZ5de3zx9++AFJSUno3LmzTv7OnTtj27ZtOHToEBuBiIiIiIzI3sweZWzL5KkMFyuXbNfHJmUxzLQB7M0Mn88mNwytZ9SvXx/h4eG4fv06nj59CldXV5QuXRrjxo0DAFSoUCHbMqytrVG0aFE8ffo0TzG/ePECycnJBuWVy+VwdHTM9b58fHzg5eWFZcuWaTUC2dnZYcuWLVi8eDHCw8NhZmaGqlWr4ubNmwAMOx/p6xkZ8+urZ7i6uuLGjRtISkrS6eGTMX9O6zyUplA1Aq1cuRLlypWDu7s7Zs+ejQkTJujNZ21tjZ9++gm9evWCpaWllD5//nw0bNgQe/bswbZt29CxY0dp3c2bNzF16lSUL18ep06dgq2tLYC0boG+vr7o378/Ll++DJks7YFhamoq+vfvD5lMhiNHjqBatWoA0sZX9PHxwcSJE9GhQwe4u7/pEfLVV1/h/v37WLp0KQYNGgQgbYz4bt26SV0Uu3Z9txOiEVH+UcgUqOuiO+kdFRxyuQwlKxYxdhhEaXz6p/0UJEXLAEPCjB1Fjmgmd03f0OLj44M///wTJ06c0GlQOXHiBMzNzVG5cuVc73PEiBH5PidQfsRcrFgxuLm54fz580hISNDqURQREYFHjx6hWbNmWvvUlJ+RJi39HEQPHz4EAKhUKp38qampAGDwRLZERJQ1zglERLnV1asrunq93eeLs+vPfqvlv2uCIMDLywteXm9eiNu7dy9sbW11OgXo8+LFCzx//tygBpKstGvX7q3NCaRPQkJCpsPPOTg4oF69etKyZnjuTz75JNtyfXx8sGzZMpw4cQJNmzbVWqepZ9SuXVsrf3h4OMLCwhAQEKCT393dXRrCL6d1HkpTqF6BbtKkiVajSmZKlCiBwYMHazUAAYClpSVGjRoFADp/UGvWrEFqaiomTZokNQABaWNFdu3aFdeuXcOxY8ek9IMHD+L27dvo1q2b1AAEALa2tpg4cSKSk5O1Hg68evUKP//8M0qXLo2BAwdK6YIgYPbstC/OFStWGHAWiIiIiD4smvG4Mzp8+DD27NkDb29vlC5dWkrv1q0b5HI5fvjhB6lxAgDOnDmD0NBQtG/fPk9DBIwbNw5//fWXwT+GyGnMMTExCA8Plya71QgMDER8fDyWLl2qla6ZBDYwMFBKK1WqFPz9/XH48GGcPXtWSk9NTcWPP/4Ia2tradJc4M1EsatWrdIqWxRFrF69GgDg6+tr0PESERERERVUP/74Iy5fvoxRo0Zp3YPrq5eIoij1Gvrss8/ytN/58+cbXMfYuHGjQWU+fvxYb/quXbvw77//om7d7F9m/vfffzFnzhx4eXlpdaoA0kbkCg8P10r77LPPYG1tjRUrViA29k2PsXv37mHr1q2oV6+eNKID8KaOoqmzaGzfvh13797VqsNo8hta56E0haonUH7QzLtjYqJ96IcPHwYAvS2FzZs3x9q1axEaGiq1RmaXH9BuaDpx4gSSkpLQtGlTnSHf3N3d4enpiePHj0OlUmU6XxERERHRh2j9+vVYvnw5WrRogVKlSkEmk+HMmTPYsGEDLC0tdRolPD09MW7cOHz77bdo2LAhunTpgqioKCxatAhOTk6YNWtWnuJ5G3MCZYw5MDAQz58/x4IFC/TGvGPHDvTp0wdBQUGYOnWqlD5u3Dhs27YN48aNw927d1G1alWEhoZi/fr16Nq1Kxo3bqxVzo8//oiAgAA0b94cX375JRwcHLB+/XqcO3cOwcHBWhO0jhw5Uvos7t+/j08++QTJycnYunUrTp48ibZt2xr0piQRERERUUEREBCA6tWrw8vLC6IoYt++fdi1axfatGmDiRMnauVt0aIFHB0dUaNGDXh4eODZs2f47bffcOrUKQQEBGDIkCF5iuVtzAnk7++PcuXKoU6dOihZsiRiY2Nx8uRJbN++HUWKFMH333+vlX/u3Lk4ceIE/Pz8UKRIEVy7dg0rV66EUqnE1q1bYWqqPfVB48aNERERoTX6gb29PebOnYtBgwbB398fAwcORFJSEhYtWgQgrQ6SXpMmTdC1a1ds3rwZrVq1Qps2bXDnzh0sWLAAXl5eGDt2rFb+nNZ56ANsBNK8pZix8ebmzZuwsrLSO2a7ZkgOzdiH6X/POFwHkDYciZWVlcH5NenXr19HRESE1pus+vj5+elNv3z5Mtzc3HDkyJEst39bYmNjIVOLMIu6nqPtjhy5+3YCyoY8NR610o2zeeb4cahMPsyJwzSt8sa6dih3+LkVXvzsCqecfG7m5uZQKpWZTlZJbybyVKlU2Z6nqlWromzZsvj111/x/PlzpKamwsXFBb169cKYMWNQqlQpnTKmTJkCFxcXBAcHY8yYMbCyskKjRo0wffp0ODk5FcjPJn3MI0aMyDJmzbBrqampWulKpRIHDhzA1KlTsXXrVgQHB8PNzQ3Tp0/Hl19+qXPclSpVwqFDhxAUFIS5c+ciOTkZlStXxqZNm9CuXTut/E5OTjh+/Dhmz56NAwcO4MCBAzAxMUH58uUxe/ZsDB06NF/Pq6YimZiYmOPvy9jYWIMmrSUiKqg4XTAR0bvh5+eHXbt2YeXKlRAEAZUqVUJwcDD69esnTQui0aFDB+zcuRMrVqxAdHQ0lEolKlSogAULFmDIkCFS54OCZPDgwfj999+xfPlyREVFQaFQwMPDA8OHD8eYMWPg4qI9/1OVKlWwe/duzJ49G3FxcXBxcUFgYCAmTZpk0FynGgMHDkTRokUxd+5cjBs3DqampqhXrx5mzpyJqlWr6uQPCQmBt7c31qxZgyFDhqBIkSIIDAzEjBkzdO7rbWxscPToUUyePFmq87i7u2PWrFkYM2ZM7k7Ue+6DagRavnw59u7di0aNGumMXxgTEyONLZiR5kKLiYnRyg9Aa+i4jNvkNH/GfVDhYnr+AmT/fX5qW1skV9P9QqP3W7I6GRueb5CWezj0gKnMNIst6F1Tp4qIDFNLy651ZJCZsIZNZAweHh5ITEw0KG/dunUNGqYgPUEQ0L9/f/Tv319qTMjYG7ugSR9zdnr27ImePXvqXefo6IiffvoJP/30k0H7rVKlCnbs2GFQXjc3NyxZssSgvERElHucE4iIKHc8PDwMmpNTY86cOZgzZ45Beb/66iuMHDkSQNrLV4XB6NGjMXr0aIPzN2/eXBrlyhBZzUvUoUMHdOjQwaByFAoFJkyYgAkTJhiU39HREcHBwQgODjYo/4fug2kE2rNnD4YOHQp3d3ds2LAh+w0KMH2T9wJveghlnEDrXTly5AiexyUhsahnjrYLqOP2liLKRtIr4NybB/T+/v6A0jrXxd3bsAEJZ88BAMxr1oDb8GF5DvFd0bxda6xr533xOuU1Zu14M1yPn78fLBWWWWyRN/zcci45MRUb952UluvW9YWp2bv/p5CfXeGUk8/t0qVLAApPxeB9p+mdws+jcNF8bmZmZloTxxqCvYCIiIiIiIjSyLLPUvj98ccf6NChA4oVK4aDBw/C2dlZJ4+trW2mvXA0w7+k78Wj+T2rbXKaP+M+iIiIiIiIiIiIiIiIcuu9bwT6/fff0a5dOzg4OODQoUOZzrdTrlw5xMXF4fHjxzrr9M3no2+eII3Hjx8jLi7O4PyadFNTU7i5GalXDBERERERERERERERvVfe60ag33//He3bt0eRIkVw6NAhlC1bNtO8DRo0AADs379fZ92+ffu08uQmv6+vL0xNTfHXX3/pjEsZERGB69evw9/fHyYmH8wIfe+dEt9/j7J/H0DZvw+gxPffGzscIiIiIiIiKqQK+DR2REREVIi8t41Ae/fuRfv27WFvb49Dhw5p9crRp0+fPjAxMcHMmTO1hmw7f/48Nm/ejAoVKqBevXpSeuPGjVG6dGls2rQJ58+fl9JjYmIwa9YsmJqaak3Wa2Njgy5duuDff//VmrBKFEVpwitDJgGmgktuZQW5nV3aj5WVscMhIiIiIiKiQioHc5oTERERZalQdTtZuXIljh07BuDNhMsrV67E4cOHAQD16tVDv379EB4ejrZt2yIpKQkNGzbE5s2bdcry8PBA7969peXy5ctj6tSpmDx5MqpWrYr27dvj1atX2LJlCwBgxYoVkMnetJmZmJhg5cqVaN68OQICAtClSxdYW1vj119/RUREBObNmwcPDw+tfc6ePRuHDh3C4MGDceDAAZQtWxahoaE4efIkWrVqhS5duuTj2SIiIiIiIiIiIiIiog9ZoWoEOnbsGEJCQrTSjh8/juPHj0vL/fr1w+PHj5GUlAQAUiNORg0aNNBqBAKASZMmwcPDAwsXLsTSpUthamqK+vXr45tvvkGNGjV0yvjoo49w7NgxBAUF4eeff0ZKSgq8vb0xZ84cdO7cWSe/s7MzwsLCMHnyZPz+++/YvXs33N3d8c0332DcuHEQ2N+biIiIiIiIiIiIiIjySaFqBFq7di3Wrl2bbb6GDRvqzLtjqO7du6N79+4G5/fx8cHevXsNzu/s7IxVq1blJjQiIiIiIiIiIiIiIiKDFapGIKKCLOXxY4j/9UATlEooihc3ckRERERERERERERE9CFjIxBRPnk0ZQoSzp4DAJjXrAG35cuNHBERERERERERERERfcjYCEQfLkEGFPfWXibKAwECPIt4ai1TwSIIAhxcrbWWiYiIiIiIiIiI3ldsBKIPl6kl0GObsaOg94iFwgJLmyw1dhiUBYVSjlbDqho7DCIiIiIiKuQSU1S48jAGcUkqWCnlqORiCzOF3NhhERER6WAjEFE+Kfp5X6jatQMAyO3sjRwNEREREX1IPDw8EBERoXddgwYNcPjwYa20pKQkzJkzB+vXr8f9+/dRpEgRtGzZEjNmzICTk9M7iJiIqHB6EpuIdSfuYvu5B3gZnwIRIgQIsLNQoF2NEujl5wEnGzNjh0lERCRhIxBRPrH0rWPsEIiIiIjoA2Zra4uRI0fqpHt4eGgtq9VqtGnTBvv27YOvry/at2+PmzdvYuXKlfj7779x8uRJODo6vpugiYgKkWuPYjFw/Vk8jk1EikoNGQQIAiCKIh7HJmLF0TvYfeERggNrooKzjbHDJSIiAgBwEhQiIiIieufu3r0LQRC0fszMzODp6YmxY8ciOjpaK//r168xceJElCtXDkqlEo6OjujcuTNu3rypU/bhw4d1yjUzM0ubF8zB4V0dYo6lpqZizpw58PT0hFKphIuLC7744gtERUXlqJyIiAh069YNjo6OMDc3R9WqVbFixQqdfK9fv8aAAQNQo0YNODg4QKlUws3NDa1atcKhQ4d08uv7zNL/xMXF5frYKX/Y2dlh6tSpOj+9e/fWyhcSEoJ9+/aha9eu+N///ofZs2fj119/xZIlS/Dvv/9i8uTJxjkAIqIC7ElsIgauP4uHLxOgVoswN5HD3FQOM0Xa/81N5FCrRTx8mYCB68/iaWyisUMmIsrU2rVrM72vr1Wrlk7+3r17Z5p/zJgxOdr39u3b4evrC0tLS9jb26NVq1a4ePGi3rw5rSNFRUXhiy++gIuLC5RKJTw9PTFnzhykpqbmKMb3DXsC0YdLlQo8uvBm2bkqIOefBOVeqjoV16KuScsVilaAiYzXVEGiVqnx7N6bh5SOblaQyfk+BJEx1a9fHwMGDACQdsO+Z88ezJs3D/v378fp06dhamqKhIQENGzYEGfOnMFnn32GL7/8Es+ePcOSJUvg6+uL//3vf/D09NQpe8CAAahfvz5SUlIAAAqFAmZmBXd4lj59+mDDhg1o2bIlxowZgzt37mDhwoU4cuQITp48CWtr62zLiIyMhK+vL2JiYjBy5EiUKlUKO3fuxIABA3Dv3j188803Ut74+HicP38e9evXh4eHB2xtbfHw4UNs2LABjRo1wvLly9G/f3+dfbRt2xbt/hsCN72CfG5Jm6ZR8Ntvv4UgCFL6wIEDMXfuXGzcuBELFy6Eubm5sUIkIipw1p24i8f/NewoTWRa358AIJMJUAoyJKWq8Tg2EetORGBMc937EyKigmTixImoUKGCVlrRokUzzb9+/XqdtIoVKxq8v1WrVqFfv36oXLky5syZg8TERCxatAj+/v44duwYqlbVnsc5J3WkV69eISAgANevX8fgwYNRpUoVHDlyBOPHj8fly5f1xv6h4NNJ+nClJgBbur1ZHnYGkGf/cIUoM0mqJIw4NEJa3t12NxuBCpjUFDX+WPbm7ZLu03xhykYgIqMqXbo0evToIS2PGDECLVu2xO+//46dO3eiY8eOWL58Oc6cOYMBAwYgODhYyhsYGIjKlStj2LBh2L9/v07Zfn5+6NGjB5KSkgAASqXy7R9QLh08eBAbNmxA69atsXPnTim9Zs2a6NChA+bOnYvp06dnW87EiRPx+PFj/Prrr1JDTf/+/dG6dWt8++236NmzJ8qVKwcAcHR0xKlTp3TKGDlyJMqUKYMZM2bobQSqUqWK1mdGBUdSUhLWrl2Lhw8fwsbGBrVr10adOtpDFicmJiIsLAyenp5wd3fXWicIApo2bYrg4GCcOXMG9evXf5fhE1E6orEDIC2JKSpsP/cAKSo1zE3kEAQBKSo1UlRqKOQyKP6rUwiCAFO5DAmpKmz/JxJDG5WFmUJu5OiJiDLXtGlTNGzY0OD8eakHREdHY9SoUXB1dcXx48dhY5M2bGanTp1QsWJFDBs2DEeOHJHy57SONHfuXFy9ehXz58/HqFGjAAD9+vWDra0tFi9ejD59+qBRo0a5jr8w49NJIiIiIiPYHL4ZP4f/nKcyvIp6YXb92ZmuH390PMKjwvO0j85endHVq2ueysipFi1a4Pfff8etW7cApN38A2lvgaVXunRp1K9fH3/99Rfu37+PkiVL6pQVHx+P5OTkAt+jYd26dQAgVVY02rdvDw8PD6xbty7bRqD4+Hhs27YNpUqV0umpM2rUKOzevRsbN27E1KlTsyzHysoKRYoUwYMHDzLNk5iYiNTUVFhZWWVZFr1bjx8/1vk7qV27NjZv3owyZcoAAG7fvg21Wi01BmakSb9582a2jUB+fn560y9fvgw3NzetSvy7FBsbCwBG2z8VTIXhukhVvRmq5lVsbIGO9X1iyLVxM1qFqLhECADUogrqVCBJlbYuKVUNQVQD6ToGCQCev0rExj+OoJw9G4EKo4L6nWFubg6lUim95KTP1aOPcPXYozztp2gJK3zUs3ym6w+tu4GoB3kbCrhiPWdUrO+cpzL0WbduHQYMGIC9e/fi3LlzWL16NSIjI+Hh4YGJEyeic+fOePjwISZOnIgDBw4gLi4O/v7++PHHH6X7JSBtDsW5c+fiwIEDuHnzJqKiouDo6IiPPvoIU6ZM0XqZZv369ejfvz8GDRqEhQsXSunJyclo1KgRLl++jNDQUJ1eLsakGS0hOTkZUVFRUCgUWb40p1KlfeklJibi1atXsLS0hFyes++3bdu2ITY2FsOHD9e6josVK4a2bdtiw4YNuH79ujSf5Zo1awAAQ4cO1brmW7ZsCXd3d4SEhGDSpElSekhICCwsLPD5559r5R86dCgWL16MNWvWwN/fP0cxa4iiiKSkpEy/EzL7zoiNjZUau4yJjUD0ARMAG2ft5Tx4OGEiEi6l9TAw964Cl29n5ak8IiJ6v0UnRuN2zO08lWGjzPpm8mHcwzzvIzoxOvtM+ezGjRsAIM3fo7mBt7Cw0MlrYWEBURQRFham0wg0YsQI6YF4iRIlEBgYiK+//lpvOTkRExMjVZqyI5fLYW9vn22+sLAwyGQy+Pr66qzz8/PD5s2b8fTpUzg5OWVaxqVLl5CQkKD3wbyfnx8EQdDb80elUiE6OhoqlQqPHj3C8uXLER4ejq5d9Tf+zZ8/H9OnT4coinB0dET79u3xzTffFOj5lj4Effr0Qf369VG5cmVYWVnhxo0b+P7777F+/Xo0btwYly5dgrW1NWJiYgAAtra2esvRVFI1+YjIOIS8VU8pnyWkioCY+VMDEXrWif9tR/SOJcSl4OXjhDyVoTTP+pFx3IvEPO8jIc6w++ncmjJlCuLi4tC7d2+Ym5tj1apV6N27N+RyOSZOnAhfX19MmTIF9+7dw6JFi9CxY0ecOXMGMllaz77k5GTMnz8fbdq0wccffwwbGxtcvnwZISEhOHToEM6cOYMiRYoASBuh4OjRo1i2bBnq16+P9u3bA0jrpX/mzBksXrw4Tw1Amnt1QygUikzv8/Tp2LGj1IBRpkwZfP755xgxYgRMTPRfA8WKFUNsbCzkcjlq1qyJ0aNHo02bNgbt6/Tp0wCgt87j6+uLDRs24MyZM1Ij0OnTpyGTyXR6tgNAnTp18Msvv0h1pCdPnuDevXvw9fXVeQHQw8MDzs7OOHPmjEFxvo/YCEQfLqUVMOBwvhWXGvUcqY8ep/3u4pJv5RIREb3PkpKS8Pz5cwDAixcvsGvXLixduhS2trZSZaJSpUrYt28fDh48iCpVqkjbxsfHIywsDABw7949KV2hUODTTz/FJ598gpIlS+LBgwfYuXMnZs+ejQMHDiA0NDRPDUFt2rRBaGioQXnd3d1x9+7dbPNFRkbCwcFB79t3rq6uUp6sGoEiIyO18qenVCrh4OAg5Unv2rVr8Pb2lpYtLCzQv39/zJ8/XyufTCZDw4YN0aZNG5QqVQoxMTHYt28fli1bhn379uHkyZNZxkdvV1BQkNZytWrVpB5m69evx4oVK3R6muXViRMn9KZrGiIDAgLydX+G0ryBaaz9U8FUGK4Lk7/3Sb9bW1shICB3bytTzhhybVhGvMBP509BlaqGiVwOURSBdA9k5XI5ZOla7lJUKsjlMvjVqo6a7tm/DEIFT0H9zrh06RKArIc5Nslh7wx9ZDJZlvvQNJTkhYlc/laGa1YoFACAhIQEnDt3Tpq3slu3bvDw8EBgYCBmzpyJCRMmSNs4Oztj9OjROHbsGJo2bQoAMDU1xaNHj3TqDa1atcKnn36KDRs2YOzYsVL60qVLce7cOXzxxRfw8fHB5cuXsXjxYnTr1g1DhgzJ0zH5+voiIiLCoLwNGjTA4cOHs81na2uLTp06oUmTJnB2dsaDBw+knjUnTpzAzp07tT5nFxcXDBs2DLVq1YKdnR2uX7+ORYsWoXPnzvjuu++0zkVmHj1K66FWunRpnc++VKlSAIAnT55I6x48eAAHBwe9PWk0PbGePXuGkiVL4tmzZwAANze3TOtU4eHhub7mBEGAmZkZateurXd9Zt8ZBaEXEMBGICIiIiIyoi1btmDLli1aadWqVUNwcLDUoDB48GAEBwdjypQpsLS0RJMmTfD8+XMEBQUhKioKQFqDkIa/vz/27NkjLSclJaFPnz6YNGkS5s+fjx9//BHjx4/Pdczz589HdLRhPaQMHYYuPj4+0x5Dmopr+mPMrAwg84cCZmZmessoVaoU/vrrL6SkpODOnTtYv349Xr9+jYSEBK2JVt3c3HDo0CGtbXv27Ak/Pz8MGzYMU6ZMwbJly7KMkd69gQMHYv369Th+/DhGjRolvRmaWU8fzZugOXmDlIjyH/uPFCyVXGxhZ6HA49hEqNVilj211GoRaoiwt1SgkkvBePhH9CEaNmyYdB8NpDX0eHp64sqVK/jyyy+18mrmxLl+/brUCCQIgtQApFarERsbi9TUVFStWhW2trbSy2gaFhYW2Lp1K2rVqoW2bdsiMjISnp6eWnOa5tbGjRuRkGBYzytDRiEA0ubh6dSpk1bagAED0KlTJ2zbtg2//PILunTpIq2bM2eOThkDBw5EtWrVMGnSJHTp0kXv8NzpZVVf0VfnyUkdKbd1oQ8FG4GI8omlX10onNN6AJn+122RiIgoM/Zm9ihjWyb7jFlwscq656mLlQtik2LztA97s7f79mqzZs0wduxYCIIApVIJd3d3ncpDmTJlsHfvXvTr1w8DBgyQ0hs1aoTx48dj+vTpBr1hFRQUhO+//x579uzJUyNQzZo1c71tZiwsLDId2z0xMVHKk10ZALIsx87OTidd07Cm0a9fP9StWxcfffQR/vnnH5iamma53yFDhmDatGlaDW9UcGiG6Xv9+jWAtDcvZTIZbt68qTe/Jj2zOYOIiD5EZgo52tUogRVH7yBZpYapXH8rkCiKSFapoZDL0K66K8wUnA+I3j1za1PYO1vmqQzrombZrk+MT80yT3bMrbO+x8yr9PP7aBQpUgQuLi5ajUOadADSC2Yav/32G7777jucPXsWycnJWutevHihU76Xlxe+//57DBw4EAqFAr/88ku+zKGZ23lsckoQBAQFBWHbtm3Ys2ePViOQPjY2Nhg1ahSGDRuGffv2oV+/flnmz6q+oq/Ok5M6kiF1obwOC16YsRGIKJ8U7dPb2CEQEVEh0tWrK7p66Z9zJb/Mrj/7rZafH5ydnbUaIDJTv359hIeH4/r163j69ClcXV1RunRpjBs3DgBQoUKFbMuwtrZG0aJF8fTp0zzF/OLFC51KYGbkcjkcHR2zzefq6oobN24gKSlJ5+21rIZ5y1hG+vzpaYbdq1WrVraxmJqaokuXLhg7diyOHDmS7ecjCAI8PDxw4cKFbMumd0/zlqpmbHVzc3P4+Pjg5MmTiIiI0JrUWBRF/PXXX7C0tDToWiGit4dTAhU8vfw8sPvCIzx8mYAklW5fLbU6rQEIAJxtzdDTz10nD9G74N3QFd4Ns75vzKumn1d6q+XnB3kmw+Jllg6k3Qtp7Ny5E23btkWtWrXw/fffw83NDebm5khOTkbPnj2hVqv1br9r1y4AQEpKCi5fvqw1nLW+/CkqESJECBCgkAsQ9HQ1fPbsmcFzApmamkqNWrmhGZbN0DpTTvKnr69krL/pq/PkpI6UVV1Ik55dfep9lvcBHIkKK7UKiL775kdt2JcpERERGYcgCPDy8kJAQABKly4NANi7dy9sbW0NejvuxYsXeP78OYoXL56nONq1awdnZ2eDfjIbMzojHx8fqNVqnWElgLR5V9zd3bOdb8fb2xtmZmZ652k5efIkRFGEj4+PQfFohpswZNg7lUqF27dv5/m8Uu6Fh4frHd4iPDwcX331FYC0cfA1ND3qJkyYoPWwIzg4GP/++y+6d+9u8FCGREQfCicbMwQH1oSLnTnkGR7SJqaokJCqgkwmoIS9OYIDa8LJJuueFERUsIWEhMDMzAyhoaEYMmQIWrVqhSZNmsDX1zfTe+S5c+fi999/x1dffYVKlSph4MCBuHHjhk4+lVpEXGIKnscl42V8MmLiU/AyPhnP45IRl5gClVq7obl27doG1z/atWuXp+PWxGvovX1O8mvqIvrqK5q09PWnnNSRihUrBjc3N5w/f15n6LyIiAg8evTI4LrQ+4g9gejDlRIPrGr+ZnnYGUBpnXl+IiIiKlB+/PFHXL58GdOmTdPq2h8VFYWiRYtq5RVFUeo19Nlnn+Vpv29jTqDAwECsW7cO8+fP15pMdPv27bh79y4mT56slf/58+d4/vw5nJ2dpblbLCws0L59e2zcuBHbt2/XqgDOnz8fcrkcXbu+6X329OlTODo66rxt+PLlS4SEhEAmk2lVlPSdVwCYNWsWoqOj0aNHD4OOlfLfli1b8P333yMgIADu7u6wtLTEjRs38McffyAlJQUTJkzQuq569eqFn3/+GZs3b8adO3fQoEED3Lp1C9u3b0epUqUwY8YMIx4NEQGcE6igquBsg22D/LAs9DbWHL8rfU6mchmKWJmiXXVX9PRzZwMQ0XtALpdDEASdHj/ffvut3l5Ax48fx6RJk9C4cWPMmjULvXr1Qu3atdGpUyecPHlSGoIuRaVGTIJuQw+QVmd5naxCYqoatuYKKORp/TfexpxA+u7tNfeNgHad6fXr15DL5TrD6D158gRz586FUqlEixYttNbdvn0bKSkp8PLyktI+++wzjBgxAitWrMDIkSOlIb3v3buHrVu3ol69elLPIiDndaTAwEDMnDkTS5cuxahRo6T0+fPnS+s/VGwEIiIiIqICLyAgANWrV4eXlxdEUcS+ffuwa9cutGnTBhMnTtTK26JFCxQrVgy1atWCq6srHj16hN27d+P06dMICAjAkCFD8hTL25gTqEmTJujatSs2b96MVq1aoU2bNrhz5w4WLFgALy8vjB07Viv/4sWLMW3aNKxZswa9e/eW0mfNmoUDBw4gMDAQZ8+eRalSpbBz507s2bMHEyZMgKenp5R3yZIl2LBhA1q3bo1SpUpBoVDg9u3bWLduHZ4+fYoZM2ZoDRXWv39/vHz5EnXr1oWbmxtiY2Oxf/9+/PXXX6hYsSKmTp2a7+eFDPPRRx/h2rVr+Oeff3D06FHEx8fDwcEBn3zyCQYPHoxmzZpp5ZfJZNi5cydmz56N9evXY8GCBShSpAj69u2LGTNmGDSEIRHRh8rJxgyDPyqLn0/fh1oERIhY0KkaPvJy4hxARO+Rjh07Ytu2bWjQoAF69+4t1UGuXLkizbmoERUVhS5dusDBwQEbN26ETCZDhQoVsHTpUvTs2RMjR47EsmXLoFKLWg1A+ob+FAEpn72FKeQy4a3MCeTt7Y169erB29sbzs7OePjwITZv3ozw8HB06dIFbdu2lfLevHkTzZs3R5s2bVCuXDnY2dnhxo0bWLVqFV6+fInFixfDxUV7vtrGjRsjIiJCq9e5vb095s6di0GDBsHf3x8DBw5EUlISFi1aBCDtJb/0clpHGjduHLZt24Zx48bh7t27qFq1KkJDQ7F+/Xp07doVjRs3zu/TWGiwEYiIiIiICjw/Pz/s2rULK1euhCAIqFSpEoKDg9GvXz/IZNojHHfo0AG7d+/G0qVLER0dDaVSCS8vLyxYsABDhgyBQqEw0lFkLSQkBN7e3lizZg2GDBmCIkWKIDAwEDNmzJDeksuOm5sbTpw4gYkTJyI4OBhxcXEoX748li1bJg0BptGkSRNcv34du3btwuPHj5GcnAwnJyf4+/vjiy++QNOmTbXyt2zZEhs2bMCqVavw4sULmJiYoGzZspg6dSpGjx6dL5PeUu40aNAADRo0yNE2SqUSQUFBCAoKektRERG93wRBgFwAAAGVS9iyAYjoPdOpUyfExcVhwYIFGDduHKytrdG0aVP8/fffaNSokZRPFEUEBgbi4cOH+Ouvv1CsWDFpXWBgIEJDQxEcHIyGDRui5Wfts2wA0qRrGoISklWwMns7j++7deuG0NBQHDx4EDExMbC0tESVKlXw1VdfoVevXlqjBRQvXhzNmzfHsWPH8Msvv+D169coWrQoGjRogC+//FKrl052Bg4ciKJFi2Lu3LkYN24cTE1NUa9ePcycORNVq1bVyZ+TOpKNjQ2OHj2KyZMnY+vWrQgODoa7uztmzZqFMWPG5P5kvQcEMX1zHBVqfn5+APSPq/guHDlyBM/jkpBY1DP7zOl0q+P2liLKRtIrYFG6CW/zOBzci3XrkXzvHgDA1M0NRXoWni6GR44cAYAcfWmTrlR1Kv55+o+0XN2pOkxkb6+tnZ9bzqlVajy6FSMtO5e1hUz+7qfH42dXOOXkc7t06RKAtLeryPiSkpIAQGcyUSrYkpKScP36dQiCkOO/JWPfF3/ojH3++e8s6VMYrovKQfuk38s6WeG3Ifn/5jfpys218TwuCQ3nHpaW/xxZH672FplvQIVOQf3OYD3D+HJbtxBFEc/jkqEWRa0GIM2D+YyNQiIAmSDAwcpUZ/hmevey+9vL7DvD2PfFGuwJRJRP4o4dRcLZcwAA85o1ClUjEOUPE5kJahc3bAJwMg6ZXIYSnoaNj0tERERERERElB9SVCIy9sUQM/yu0xAkikhRiTA1YSMQ5c27f/2ZiIiIiIiIiIgyxSFbCheOsUNE2RFz+c2e2+2I0mNPIKJ8Ire1g8l/E8PJbe2MGwwREREREREREREVCEKmswC9ne2I0mMjEFE+KTH3O2OHQERERERERETvGKfrIKLsKOQCBEHQGRIuK4IgQCHnFwzlHRuBiIjySUJqAiYdmyQtz6w3E+Ym5kaMiDJKSVbh7zVXpeXGfSpCYSo3YkRERERERLr4yI+I6P0iCALMFTK8Tlbpnf8nPU0zkblCDoGtzJQP2AhERJRP1KIa55+e11qmgkVUi3j0b4zWMhERERFRQcO71MKFcwJ9WBJTVLjyMAZxSSpYKeWo5GILM8W7eblQEASo1WqIosjGgULI3NQEialqqNSZz/SjSZfLBJjzpdUCQRRFiKIImUxm7FByjY1ARERERERERERERFl4EpuIdSfuYvu5B3gZnwIRIgQIsLNQoF2NEujl5wEnG7O3GoOZmRni4+MRFxcHa2vrt7ovyn9ymQBbcwViElKg0vNSqpghn1zGhr6CIC4uDkDa319hVXibr4iIiIiIiIiIiIyMHTLef9cexaLjshNYcfQOHscmIjlVjVSViORUNR7HJmLF0TvosOwErj2Kfatx2NraAgAiIyPx6tWrHM0vQwWDQi6DvYUpLE11+2bIBAGWpiawtzCFQs7H9sYmiiJevXqFyMhIAG/+/goj9gQiyifxZ89C9fIlAEBuZweLmjWNGxARERERERERvXV8Dv9+exKbiIHrz+LhywQAgLmJHLJ0PTTUahHJKjUevkzAwPVnsW2Q31vrEVS0aFG8evUKcXFxuHPnDgBwWLh3TNPwlh/nPWNvIPb8KVjSN7JaWVmhaNGiRowmb9gIRJRPngcHI+HsOQCAec0acFu+3MgRERERERERERFRXqw7cRePYxMBAEoTmc7Df5lMgFKQIem/XkHrTkRgTHPPtxKLTCaDh4cHoqKiEBMTg8TERPYGeseSkpIA5M/QYE/+u640XOzM81wm5R+ZTAYzMzPY2tqiaNGinBOIiIiIiIiIiIjoQ8B39T8ciSkqbD/3ACkqNcxN5BAEAanqtKHgTGQCTP4bsksQBJjKZUhIVWH7P5EY2qgszBTytxKTTCaDo6MjHB0d30r5lLUjR44AAGrXrp3nsroG7dNavjzNJ89lEulTeJuviIiIiIiIiIiI3jH2u/hwXHkYg5fxKZBBkIaAS0xRI1UtIjFVrdULRyYTIIOA6NcpuPLw7c4NRESUE+wJRJRPik8JgpgQDwAQzC2MHA0REREREREREeVFXJIKIkRoRoATMzQBqkVAnq5rmCCk5YlLSn2HURIRZY09gYjyialrCSjLlYOyXDmYupYwdjhEREQF2t27dyEIgtaPmZkZPD09MXbsWERHR2vlf/36NSZOnIhy5cpBqVTC0dERnTt3xs2bN/WWf+HCBbRr1w4ODg6wsbGBt7c3vvnmG2kM74IoPj4e48ePh4eHB5RKJTw8PDB+/HjEx8fnqJyLFy+iVatWsLe3h6WlJXx9fbF9+3a9eTN+Bul/Ll++nOV+Hj58CDs7OwiCgKlTp+YoRiIiIqLCwEophwABhk67I4qAAAFWSr53T0QFB7+RiIiIiMho6tevjwEDBgAAoqKisGfPHsybNw/79+/H6dOnYWpqioSEBDRs2BBnzpzBZ599hi+//BLPnj3DkiVL4Ovri//973/w9Hwz+e6xY8fQpEkTKBQKDBkyBK6urggLC0NQUBDCwsKwe/dunQl9jU2lUuGTTz5BaGgoAgMDERAQgAsXLmDevHkICwvDgQMHIJdnP678hQsXUK9ePSiVSowePRoODg7YsGED2rdvj5UrV6Jv374626T/DNIrWbJklvv64osvoFKpDD9IIiKi90TBuougt6mSiy3sLBR4HJsItVqEkMXr9Gq1CDVE2FsqUMnF5t0FSUSUDTYC0YdLkAMlamgvE+WBTJChkkMlrWUqWASZACd3G61lIjKu0qVLo0ePHtLyiBEj0LJlS/z+++/YuXMnOnbsiOXLl+PMmTMYMGAAgoODpbyBgYGoXLkyhg0bhv3790vpw4YNQ3JyMg4ePIi6desiKSkJ/fv3R8WKFTFx4kRs3rwZ3bp1e6fHmZ2QkBCEhoZi2LBh+PHHH6V0Dw8PjBkzBiEhIfj888+zLWfYsGF4/fo1Dh06hFq1agEA+vbtizp16mDUqFFo37497OzstLbJ+BkYYsuWLfj999/x3XffYfTo0TnaloiIqLDjnEAfDjOFHO1qlMCKo3eQrFLDNJMXiURRRLJKDYVchnbVXWGm4DMmIio42AhEHy5TC6DrZmNHQe8RcxNzLGq0yNhhUBYUpnJ8OriKscMgAgBcOhyJS6EP8lSGY0krNP28Uqbr/1p9Bc/ux+VpH94NSsC7oWueysipFi1a4Pfff8etW7cAAAcPHgQA9OnTRytf6dKlUb9+ffz111+4f/8+SpYsiejoaJw/fx6enp6oW7euVv7evXtj4sSJWL16dYFrBFq3bh0A6DSoDB48GF9//TXWrVuXbSPQ3bt3cfToUTRs2FBqAAIAhUKB4cOHo0+fPvjtt9/Qu3dvnW1TUlKQmJgIa2vrbGN9/vw5hg8fjhEjRqBGjRrZ5iciMqbEFBWuPIzBxWepMDcR4JOi4sNZIsqRXn4e2H3hER6+TEBSqm4ToFqd1gAEAM62Zujp5/6uQyQiyhIbgYjyiToxEdAMiSKXQ2ZmZtyAiIioQEt4lYzoR6/zVIaZRda3cq+iEvO8j4RXyXnaPjdu3LgBAHBwcAAAaR4fCwsLnbwWFhYQRRFhYWEoWbJktnkBICwsDKIo5npIuOjoaIOHQVMoFLC1tc0yjyiKOH36NFxcXODurv3QwNzcHNWqVcOZM2eyjTksLAwAdBq/0qedOnVKpxFo27Zt2LBhA1QqFWxtbdGyZUvMmDEDHh4eevczYsQIWFpaYvr06Th9+nSWx0ZEZCxPYhOx7sRdbD/3AC/jU9K+twVg5dXDaFejBHr5ecDJpgDX2QydgISMguMJfFicbMwQHFgTA9efxeOYRKjS9QVLSk1bUshlcLZNy1egv1uI6IPERiAyuk1h93K8Tbc6bm8hkryJHD4cCWfPAQDMa9aA2/LlRo6IiIio4EtKSsLz588BAC9evMCuXbuwdOlS2Nraok2bNgCASpUqYd++fTh48CCqVHnTmy8+Pl5q+Lh3L+1+olixYnBwcMC1a9fw+PFjFC9eXMp/6NAhAEBcXByio6NRpEiRXMVcvXp1REREGJS3QYMGOHz4cJZ5Xrx4gfj4eFSuXFnveldXV5w4cSLbmCMjI6X8+spIn0ejVq1aaN++PcqXL4+kpCQcPXoUK1aswN69e3H8+HF4eXlp5f/jjz+wadMm7N27F5aWllkeFxGRsVx7FJv2sDY2ESkqNWT/PbIXReBxbCJWHL2D3RceITiwJio4c94OIspeBWcbbBvkh9XH7yA49F+pGUghl6GolSnaVXdFTz93NgARUYHERiAiIiIiMpotW7Zgy5YtWmnVqlVDcHAwnJycAKQNiRYcHIwpU6bA0tISTZo0wfPnzxEUFISoqCgAaQ1CACAIAkaPHo0JEyagTZs2+O677+Ds7IzTp09jzJgxMDU1RXJyMuLj43PdCLRx40YkJCQYlNfe3j7bPJrYlUql3vVm//Uuzi7mrMpJX0Z6GXvydO3aFR9//DFat26NkSNH4s8//5TWxcbGYuDAgejatStatGiR3WERERnFk9hEDFx/Fg9fpn1Pm5vIIZMJSFWlAgBkghzJKjUevkzAwPVnsW2QX8F8aJvL3qr0brCf1ofJycYMI5uUx/oTEVCLgAgRMz6rjJZVXDjMJBEVaGwEog+XKhV4cObNcolagJx/EpR7qepUXHp+SVr2dvCGiYzXVEGiVqnx5E6stFyslA1kcpkRI6IPmbm1Keyd89aTwrpo1g+trIuaITE+NU/7MLc2zdP22WnWrBnGjh0LQRCgVCrh7u6OkiVLauUpU6YM9u7di379+mHAgAFSeqNGjTB+/HhMnz4dNjZv3uT+6quvkJSUhLlz56Jhw4YA0hpGJk+ejF27duH06dNa+XPK398/19vqoxmmTjOUXUaJiYla+XJTjqFlAECrVq1Qs2ZN/P3330hMTJQakMaNG4f4+HgsXLgw2zKIiIxl3Ym7eByb9p2nNJHpDKMpkwlQCjIkparxODYR605EYExzT2OESkSFlCAIkAsAIKCCsw0bgIiowOPTSfpwpSYAv/R6szzsDCDPfjLkzNi17wCr+gEAAJP/3lymD0uSKgmjD7+Z0Ht3291sBCpgUlPU+HPFZWm5+zRfmLIRiIzEu6ErvBvqDtuVn5p+Xumtlp8fnJ2d0aRJk2zz1a9fH+Hh4bh+/TqePn0KV1dXlC5dGuPGjQMAVKhQQcorCAKCgoIwbtw4XLp0CfHx8ahYsSKcnJzw448/wsXFJU+NQM+ePTN4TiBTU9NsexwVKVIEFhYWOkO1aURGRsLS0jLbXkWZDfmWPk3fUHH6lCpVCmfPnsWLFy/g4uKCc+fOYfny5Zg8eTJiY2MRG5vWoP7gwQMAaUPa3bp1C46OjtnOgURE9LYkpqiw/dwDpKjUMDeRQxAEiBCRkipCrQZM/rvtEwQBpnIZElJV2P5PJIY2KlvwHuJyTqACjf20iIioMOHTSaJ8YtO82f/ZO/P4Nqpz7//OzGizHTs72FlZQwgUkrCZJUBLCZRCS9huewnLbSChBS4FCpTCLbeU3kIptAUKgbRAQkvDEgop5Q20hDgEsyQOKQQogeyxnd1WbGuZmXPeP0YzmhmNpJEsW3byfO/Hl0oanXnOeZZRnucs5RaBIAiCIPZqGGM47LDDHOfUvPbaa6ipqfFcnROJRHDcccdZK2OWL1+O7du3Y8aMGd2S49hjjy3pmUCMMRxzzDFoaGjAhg0bMGbMGOuzWCyGDz/8EMcdd1zGbHY3xx13HACgsbEx4zPzPfOafHz++ecIBAIYMmQIAOPMJSEE7r77btx9990Z1z/00EPW37XXXuvrHgRBEKVmdXM72rpUSGCQJCNmqrpAUucAAMHTSRBJYpDAsLtTxermKCaPyb99J0EQBEEQRH+EikDEvguTgIGjna8JgiAIgug3/O53v8PHH3+M//3f/827zVksFsMNN9yAcDiMH/3oR926b6nPBAKA6dOno6GhAb/+9a/xu9/9znr/0UcfRSwWw/Tp0x3Xt7S0oL29HaNHj7b6fsABB+Ckk07CW2+9hRUrVmDy5MkAAE3T8Lvf/Q4DBgzAt771LauNnTt3WkUeO/PmzcO//vUvnHvuudb5Qscddxyef/75jGtXr16Nu+66CxdddBEuvvhiTJw40Vd/CYIgeoKOhA4B4ThOJ6lx63/rrsU1jBlnenQkurd1KkEQBEEQRF+GikDEvkuwEpjxRrmlIAiCIAjCB1OmTMHEiRNx2GGHQQiBRYsW4ZVXXsG3vvUt3H777Y5rly1bhltuuQVnnXUWRowYgU2bNmHevHnYsGED5s6di0MPPbRbspT6TCAAuPLKKzF37lw89NBDaG9vx5QpU7Bq1Sr8/ve/xymnnIIrrrjCcf2Pf/xjPP3001i8eLF17hFgFMamTJmCqVOn4oc//CGGDh2KefPmoampCbNnz3YUpX7+859j2bJl+OpXv4rRo0cjmUzi7bffxosvvoja2lrH2T91dXW48MILM+QeOnQoAODwww/3/JwgCKI3qQrJYGAQPrdSEwJgYKgK9cHUSJ7VnwRBEARBEH7pg790CIIgCIIgCMJJfX09XnnlFcyZMweMMUyYMAGzZ8/GjBkzIEnO1bwjRozA4MGD8eijj2LHjh0YNGgQTj75ZDz33HOYNGlSmXqQG1mW8fe//x0/+9nPMH/+fDz77LOora3FjTfeiP/5n/+BLPs7q2LSpElYtmwZfvKTn+BXv/oVkskkjjzySDz//PMZRZrTTz8dn332Gf70pz9hx44dEEJg7NixuPHGG3HrrbdiOJ1xSBBEP2NCXQ0GVgTQGo2Dc2FtCecF5wIcAoMqA5hQV/w5cQRBEARBEH0dKgIRBEEQBEEQvc7YsWN9z9QGgHvvvRf33nuv77YXLlxovTbPBDK3NuurVFVV4b777sN9992X99qnnnoKTz31lOdnRx11FP72t7/lbeO8887DeeedV6iYDk477bSC9EgQBNGThAMypk0agSeWrkNS5whl2fJbCOOcoIAsYdrEkQgH/BXaexWKrQRBEARBlAgqAhFEidj6y3sR//dnAIDwuMOw3223llkigiAIgiAIgiCIfYvL68di4aoWNLfFkLCdB2TCuVEAAoDamjAuqx/T2yISHsRVHaub29GR0FEVkjGhrqZvFueIfkNP2RTVZ4meJpftUqwkioWKQMS+C9eBXWvTrwcfCEjFB87E2i8R/9dHAAAWCHRXOoIgCIIgCIIgCKJAhleHMXv6ZMyctwKt0TjAnRnbmKYjIEuorTGuG14dLpOkBABsjcYxt3E9FjRtQVuXCgEBBoaBFQFMmzQCl9ePJR0RBUE2RfRXuBD41aLPPG136oT9ADAsWt1Kdk0UBRWBiH0XtQt46pvp19ctB0IDyicPQRAEQRAEQRAE0W3G11bjhVn1mNu4AY8s/gL2MlBtTRjTJo7EZfVj+nbCjGU/z2hv4dOWqFWsU3UOCQyMGdv1tUbjeGLpOixc1YLZ0ydjfC2d20TkpzdsSoCWAhGlR+cCcVXHE0vXZdhuS3scT72zAQDAAEiMYiVRON4b5BIEUTDh8Yej4vjjUXH88QiPP7zc4hAEQRAEQRAEQeyzDK8O4+ap41AZlBEJyAhIQFAG3rzpNNw8dVzfLgABe/2eU1ujccyctwLNbTFwLhBRZESCMsIB478RRQbnAs1tMcyctwLbovFyi0z0ccplUwx7f8GW6Fm4MApAAsiw3VBAcliYABAOSBQriYKhlUAEUSKG//CGcotAEARBEARBEARB2GCMQWbpmgqdndA3mNu43tiuD0BIkcBcK58kiSHEJCQ0jtZoHHMbN+DmqePKISrRT+gtm9rL67NEGVB1bq0vc9uu/TOTpM4RUoxnGcVKwi9UBCIIgigRITmEX5/2a8drom+hBCScddURjtcE0RMwxsA5hxAi4x+gBEH4QwgBIQQkiWI1QRDE3kRc1bGgaQtUnSOiyNZvJVXnEAIIKAwMDIwxBGUJMU3HgpWbce1XD6YiHuGJl00JCKiaAGOAIpNNEX0TIQQ0PV3mYYyBCwFV55AZHJ+ZqLoAoCMoGwUjsmvCD1QEIgiCKBGKpGDi8InlFoPIgSRLqD14YLnFIPYBwuEwurq60NHRgQED6Lw5giiGzs5OCCEQDvfxLZsIgiCIgljd3I62LhUSGCTJKABpOkdC4wAAAeaY5S6BYXenitXNUUweM6hschN9Fy+bSmo8lSwHAAkB2Xi/1DZFZwQR3YELZFhQTNUhBKDm+J6qCwjBrWIPxUoiHzStjiAIgiAIosTU1NQAADZv3ow9e/ZA0L4RBOEbIQT27NmDrVu3Qtd1y58IgiCIvYOOhA4BY4WGiVkAAmBL3BswZiTaOxJab4lI9DO8bMpuR3b7ArpnU/SrniglXkVEv/901DjFSsI/tBKIIAiCIAiixAwZMgR79uxBR0cH1q1bBwC0LVwZMYtwpIP+gakvVVWhaRqGDBlSZokIgiCIUlIVksHAfE+SEQJgYKgKUQqL8IZsiuivMJTu3ydk10QuyCoIokS0L1wItbkFABCoq0XNueeWWSKCIAiiXEiShLFjx2Lnzp1ob29HPB6n1UBlJJFIAABtK9ZPkCQJ4XAY27Ztg6ZpdCYQQRDEXsaEuhoMrAigNRoH58LavssLzgU4BAZVBjChrroXpST6E71pU/SbniglEgMYur/CjGIlkQ8qAhFEiWhfuBCxFU0AgMjkSVQE2geJaTHc0nCL9fq+KfchokTKKBHhRk3qeH3Oauv1mTMmIBCkAxOJnkGSJAwbNgzDhg0rtyj7PA0NDQCAY489tsySEIXQ3NxcbhEIgiCIHiAckDFt0gg8sXQdkjpHiHkX+4UQSOocAVnCtIkj+9RB51QG6FuU06ZKuZKD2PdgjEGRmbV9obvIKEuAzr2+maYvx0qi70BFIIIgiBLBBcfqHasdr4m+heAC2zZEHa8JgiAIgiAIwg9xVcfq5nZ0JHRUhWRMqKuhZFuRXF4/FgtXtaC5LYaExjOKKpwbSU0AqK0J47L6Mb0vJFEUbj85aFgVvtzegV2dKrbtiWP4gBAGVwZL7j9um3LDuUBC0wEAAyNBHD2qBnFVL1gG+hckUWoCsgRN1yGQeX6VzAA9x3dLGSvpGbd306+KQM888wyWLl2KFStW4KOPPkIymcSTTz6JK664wvP6aDSKu+66Cy+++CJaW1tRW1uLiy66CD/96U9RVVWVcT3nHI888ggef/xxfPHFF6iqqsIZZ5yBe+65BwceeKDnPRYtWoRf/OIXaGpqAmMMkydPxh133IGvfe1rntd//vnnuOOOO/Dmm2+is7MThx56KGbNmoVZs2bRPvUEQRAEQRAEQRAE0cfYGo1jbuN6LGjagrYu1TiAHgwDKwKYNmkELq8fi+HVtOVoIQyvDmP29MmYOW8FWqNxwDU5K6bpCMgSamuM62h8+z5uP+GCQ+eAntKtXcOKxDCkKogLJ48smf/ks6ku1UilMwBtMRXXPfsh+TDRJ5AYQzggI67qxlaGNttN5qoAoTSxkp5x+wb9qgh0xx13YMOGDRg6dChqa2uxYcOGrNd2dnbi1FNPxYcffogzzzwT3/nOd7By5Urcf//9WLJkCRoaGjL2hZ85cybmzJmDCRMm4Prrr0dzczOee+45vP7663j33XdxyCGHOK5/5plnMH36dAwbNswqRM2fPx9f//rX8dxzz+HCCy90XP/JJ5/gxBNPRCwWw8UXX4y6ujq8+uqr+P73v49PPvkEDz30UGkGiigLox9/vNwiEARBEARBEARBECXk05aolVRWdQ4JDIwZ2++0RuN4Yuk6LFzVgtnTJ2N8LZ3DUAjja6vxwqx6zG3cgEeXfGkVCwBjRvu0iSNxWf0YSj72A9x+wgSQa18MjQtsjSbweMPakvqP3aYeWfyF56odxozVE3qRPkxHAhE9gSwxRIIy/uukA/Dw4i98f6+7sZKecfsO/eqU1Tlz5mD9+vXYvn07Zs2alfPa++67Dx9++CFuvfVWLFq0CL/85S+xaNEi3Hrrrfjggw/w4IMPOq5fvHgx5syZgylTpqCpqQn33nsv5s2bh7/+9a/YtWsXrr32Wsf1u3fvxnXXXYehQ4eiqakJDz30EB566CE0NTVhyJAhuOaaa7Bnzx7Hd6655hq0t7fjr3/9K+bNm4d7770XTU1NOOWUU/Dwww+jsbGxNANFEARBEARBEARBEES32BqNY+a8FWhui4FzgYgiIxKUEQ4Y/40oMjgXaG6LYea8FdgWjZdb5H7H8Oowbp46DrU1YUQCMsIBCZGAjDdvOg03Tx3XZwtAVAhI4/aTkCz53jJN1QW2lNh/TJuqCMoIK+m0pywxVARkVAQV8mGiTyIxhun1YxynTAUkhsqQjKqQgqpQ5lqOv1x1QtGxkp5x+xb9qgh0xhlnYMyY/HsbCiEwZ84cVFVV4c4773R8duedd6Kqqgpz5sxxvP/EE08AAO6++24Eg0Hr/bPPPhunnXYaXn/9dWzcuNF6//nnn0dbWxuuu+46jBw50np/5MiRuPbaa7Fjxw689NJL1vuff/45GhoacPrpp+Pss8+23g8Gg7j77rsdMhAEQRAEQRAEQRAEUV7mNq43tpUCEFIkY5seG5LEEEolmVujccxtzL5bSaHsazUGiTHIEoMiSZAlRudQ9CPcfqILUZD98tSKg1L6DwAwxqDbqnXhXvZhgiiGuY3rHf4jywzMVhZymTCeW765W/cq1zOO6H361XZwflmzZg2am5sxdepUVFZWOj6rrKzESSedhEWLFmHTpk0YNWoUAOCtt96yPnMzdepUvPXWW1iyZAmmT59uXQ8AZ555puf1d911F5YsWYLLLrss7/Unn3wyKisrsWTJEl/9q6+v93z/448/xujRo9HQ0OCrnVITjUYhcYHwzn/3+L0aGtZ3uw1Z68IxyaT1evmyZdCVim632x+JRqMAUDbb2VuI8ziSNptatmwZwlLPzVwjvRWOrgokbZvqLlu2DHKg989jI931T0hv/RfSXf+kO3qLRqOorqYtKwiCKJ64qmNB0xaoOkdEkcEYg4CAphvpuYBsJMYYYwjKEmKajgUrN+Parx5MBQxin8HtJwAsH/GLEICq85L7jxDCIYt5DrfOBXQuEJAZGGOF+/C+VqEleg0hBBY0bXG9ByR1DgmAImeu5SjWb7yecQCgc+Msr6L9g+iz9KuVQH5Zs2YNAGSc4WNivm9e19nZiZaWFhxwwAGQ5UxDdl+f7x6FXi/LMg444ACsX78emqbl6R1BEARBEARBEARBEH4oNl+7urkdbV0qJDBrdrSqCSQ0joTGofH0iSeSxCCBYXenitXN0RJIDfT+NCWCKBy3n3BRnM8xoKT+A8BTFiEEYqqOpM4R13rWhwmiULgA2rpUx3tJnSOpGfZqPzfNpFib9XrGcSEQUzn5x17KXrkSqL29HQBQU1Pj+bk5K9C8rtDr832n0OvN73DOsWfPHgwaNMjzGpNsZweZK4SmTJmS8/s9RUNDA3Z0JBAfMq7H7zXl+NHdbySxB2hKb/130kknAaEBxTf3xRfgnZ0AAKmyEqGDD+62iL2FOcO2XLazt9CpdiL4ktOmKgOVOb7RPUhvhZOMa1j/+rvW65NOOgHBcO8/Ckl3/RPSW/+FdNc/6Y7eaBUQQRDdpSOhQ0CA2aoxST2dFEuoHEooPa+WMUBAoCNBEzv3BQrb8Gzvxe0n3RmXUvuPlyyqLYnuTqj79WHSPdFTeNmW/fyxpKZnfl6k33g941TbM65Y/yD6LntlEYggysHW++5DbEUTACAyeRJGP/54mSUiCIIgCIIgCIIgiqEqJIOBQQh/CV8hAAbmeXB3MVCamegPuP2EdWMNWyn9pxhZSu3DBFEoxfhPsTZb7mcc0fvsldvBmatt7Ctx7Jj7i5vXFXp9vu8Uer35HcYYBgwofiUKQRAEQRAEQRAEQRDdZ0JdDQZWBMAhwD224LHDuQCHwKDKACbU0UpEYt/B7SfuQ+v9IoCS+4/EPLZVzOLKhfiwz5w5QRSMxICBFYEcV2Q6WLF+4/2M83ZgesbtHeyVRSCvM3nsuM/nqaysRG1tLdatWwddz1xa53WeT657FHq9rutYt24dDjjgACgKVVR7DSYDo45L/zE62IzoHhKTcPTwo60/ie2VIbZfwySG2gNrrD9W7L9SCIIgCIIgiH5Bsb/2wgEZ0yaNQECWkNR51tnSQggkdY6ALGHaxJF0YDaxT+H2k2JgDD3iP4wxKHI6ApAPE30dxhimTRpR0HeKtVl6xu177JUVh0MOOQR1dXVYtmwZOjs7UVmZPpOjs7MTy5YtwwEHHIBRo0ZZ75966qn4y1/+gmXLlmXsO75o0SIAzv3ITz31VDz77LN4/fXXccIJJ3hef+qppzquB4DXX38dt912m+P6t99+G52dnY7riV4gWAFcMq9kzQ377/8G37MHACDRiq59kogSwQOnPVBuMYgcBIIyzpp5ZLnFIAiCIAiCIHqJ7kzav7x+LBauakFzWwwJzZXgZsbsaDPxXVsTxmX1Y7pxt4zmcxJXdaxubkdHQkdVSMaEuhpKzpWIfWFsS9nHnH7iA4mxkvuPSUCWoOk6BICExjP8qhgfzhVT9gXbIXqWy+vH4veLv/S0MyEE3B7WHb/J57s9+YzracgXM9kri0CMMcyYMQM/+9nPcPfdd+OXv/yl9dndd9+Njo4O3H777Y7vXH311fjLX/6CO++8E2+88QaCQeNw99deew1vvfUWzjzzTIwZkzb2iy++GLfeeiseeugh/Nd//RdGjhwJANi8eTMefvhhDB06FOeff751/bhx4zBlyhQsXrwYr732Gs4++2wAQDKZxJ133gkAmDFjRs8MCNErRCZMKLcIBEEQBEEQBEEQRIkYXh3G7OmTMXPeCrRG44BtWzghgJimIyBLqK0xrhteHe5xmbZG45jbuB4LmragrUs1DvYGw8CKAKZNGoHL68f2ihx7IwWNbT/dEqwn7CeXn+QjIDPUDYz0mP9IjCEckBHXdEgSQ9KV6C6VD5NfEqVieHXYsFlVzwgzXiXWpxvXF21fbt/tKf/oTcgXs9OvikBz5szB22+/DQD46KOPrPfeeustAMDJJ59sFVJuueUWvPzyy7j33nuxcuVKTJo0CU1NTXj99ddx7LHH4oYbbnC0ffrpp2PGjBmYM2cOJk2ahHPOOQctLS2YP38+Bg8ejIceeshx/aBBg/Dwww9j+vTpmDRpEi655BIAwPz587Fz507Mnz8/43yf3//+9zjppJPw7W9/G5dccglqa2vx6quvYvXq1bj22mtx4oknlnrICIIgCIIgCIIgCIIokvG11XhhVj3mNm7AI4u/gP3khNqaMKZNHInL6seUPKnklUb/tCVqJetUnUMCA2PG7PDWaBxPLF2HhataMHv6ZIyvpXMbCmFjVMcdjzXu1WPbk/aTy0+ylYT2rw7hwsmjesR/7MiScZj95fVjMbdxPaJxzfqsFD68bkcnZj1DfkmUDlliiARlqDqHqucuqnbXvuy++/Q767EnUVr/6E3oGZmbflUEevvtt/H000873lu2bBmWLVtmvTaLQJWVlViyZAnuuusuvPjii1i8eDFqa2tx00034ac//SkikUhG+7Nnz8aRRx6Jxx9/HL/97W9RVVWF888/H/fccw8OOuigjOsvvfRSDB06FL/4xS/w5JNPgjGGyZMn44477sAZZ5yRcf2ECRPw3nvv4Y477sCrr76Kzs5OHHrooXjkkUdwzTXXdHd4CIIgCIIgCIIgCIIoMcOrw7h56jg8uWwduAAEBAZGAnjzptN6bXuZrdE4Zs5bgea2GAAgosiQbOdbmtv2NLfFMHPeCrwwq75fJO36ArvjHL9rimFX3HjtZ2z7G71hP15+cuqhw3DI8Cr84e314IJDCCMpKzGGt350eq/5j8QYbp46DqGAlNpqy1gdUIwP289O4ULg569+gu17EgDIL4nSITHm2M4QMIqqjDkX23Euum1fpu8CAn94e323/KNc0DMyP/2qCPTUU0/hqaee8n19TU0NHnzwQTz44IO+rpckCddffz2uv/563/c466yzcNZZZ/m+fty4cXj++ed9X0/0ILoGbGxMvx5dD8j9yiWIPobGNazcttJ6PXH4RCgS2VRfguscLV+0W69rD66BJEtllIggCIIgCILoLzDGYJwzb2wx1ZvJsbmN642ttgCEFAmMOU83kSSGEJOQ0Dhao3HMbdyQSuoR+fjHBhW74gIA8z22/elsDKB37cfuJ8MGhBAJKpAlBhlOfylHclmRJMgSg3nqVndlUHWOHR1GAYj8kig1qs4dK+kkxiBca+tCSunsS5FL6x+9CT0j80OZL2LfRYsBL85I/2mxcktE9HMSegK3Ntxq/SX0RLlFIlxoKsfrf1xt/Wlq4QeXEgRBEARBEERPY09fxVUdC5q2QNU5grKR3BIQUHUOjad/zzLGEJQlqDrHgpWbEVf13he8nxFXdSzbokLnsMYWAHRujK+56sM9trF+NLZe9gMAGuepJLN3H0tlP/aVM3sDZm+EENB048/tl7ptqQb5JVEMpn25cR+5VUr7YmD5L+qD0DPSH1QEIogSsfm66/D5Kafg81NOwebrriu3OARBEARBEARBEEQP4Z5lXGrseb7Vze1o61IhgVnb26iaQELjiKvOhLMkMUhg2N2pYnVztEdl3BtY3dyODlUYW5SlxlZAIK7qxvjaDkq3j+2arR3lErlgvOxH5wJxlSOhcahaz9qPO2ldTtyrKLqDseUdHLaTSI1pTNXBBfklUTymfdnJZr/7un3RM9IftE8Rse/CJGDIwc7X3YAnEhBdMet/EwRBEARBEARBEER36UjoxhkNtrpTUk8XJxKajopgOr3DmJEs7LAd8E1405HQAeFceaXp6VSr7qpgmGPbmew/Y+tlPwktPQM+qXMElXQ+pNT2w/e2lUCp7lgrqGzWo9nsRdU5Qkp6Oy3yS6IQvAo+uQqq+7J90TPSH1QEIvZdgpXAla+WWwqCIAiCIAiCIAiCyEpVSAYDy7qtVsZscWEkpqtClPLJR1VIBlg6sZ8Pc2wrg/1nbPPZj5tS209fWglUSszij9/VReSXRCEUujVbKeyrhxe49hj0jPTHvtVbguhBBpxxBsKHjQcABEaOKLM0BEEQBEEQBEEQRE/Rm7myCXU1GFgRQGs0Ds6Ftd2NF5wLcAgMqgxgQl11L0rZP5lQV4OqAMPuuChobA8eXtWLUnaPcttPXzoTqBSimEUfiRlxQAiQXxIlx7IvH9eWyr76aQ2o7DGuv0BnAhFEiRh08cUYfuMPMfzGH2LQxReXWxyCIAiCIAiCIAhiLyAckDFt0ggEZAlJnWef7SwEkjpHQJYwbeJIhAOy53VEmnBAxkkjApAl7LVjW077MWbnd7uZPgljDIps/O2ttkOUD9O+8kH2Rc9Iv9BKIIIgCIIgCIIgCGKfIa7qxmHwCR1VIRkT6mr2uURAsfSVsesrcvihVLJeXj8WC1e1oLkthoTGMz7nXFhnINTWhHFZ/Zhuy96XiKs6mjbuwifNewAAh9dVY9LoQSXR+9fHBPBei4pdcSCh8YwtkbzGtr9tcea2H3eO1I/9FGvL/eVMIHf/krpAME8SPiBLqIkEsH1Pok/7ZSniUK42ejoml6r9/vTsAAz70nQ952og0+7KZV/dtQvzml2dKrbtiWP4gBAGVwYL1s2+/oz0AxWBiH0XrgM7Pk+/HnooIPXd4E8QBEEQBEEQRPFsjcYxt3E9FjRtQVuXahwiDIaBFQFMmzQCl9ePxfDqcLnF7JP0lbHrK3L4odSyDq8OY/b0yZg5bwVao3HHQStCADFNR0CWUFtjXNdXxqG7bI3G8ehbX+D5FZvRmdCt9xmAypCMCyePwvdPO6hb/R0YlnD9pAge/wRojcahuhKIXmPb2h4v+n7lwG0/mquKlct+umvLfb0ElK1/EZnjpBEBHHZ03Nk/W4ckxnDHOYfj3v/3WYZfarqAxsvrl6WIQ7namDphPwAMi1a39khMLlUc7U/PDjsSYwgHZMTV7IUgSWIls69CzgTqrl0IAHMb1+P55ZuxqzPpiEmKxDCkKogLJ4/0rZt99RlZCFQEIvZd1C5g7rfTr69bDoQGlE0cgiAIgiAIgiB6hk9bolZiQNU5JDAwZmwN0hqN44ml67BwVQtmT5+M8bX71h7x+egrY9dX5LDIkSzrKVnH11bjhVn1mNu4AY8s/sJKCjIYM5unTRyJy+rH7DXJrU9borjyyQ+MhJ4LAaAjoeOpd9Zj0epW/PGKY7ul99HVMl6YdRzmNm7AM+9uQFtMtT7zM7b9YbGL3X5mN3wJVU8Lna2PpbDlvrwSKFf/4qrAa+uSWPVYY87+HTC00tMvZYlheHWobH5ZCt3laqOlPY6n3tkAwIhBEittTC5VHO1zz44CkSWGSFCGqnNounAUgxiAq085sNftq7t28eKKLWAM2N6RgKZnxgeNC2yNJvB4w9qCdLOvPSMLhc4EIgiCIAiCIAiCIPZatkbjmDlvBZrbYuBcIKLIiARlhAPGfyOKDM4FmttimDlvBbZ5JJz3VfrK2PUVOfqCrMOrw7h56jhUBGVEAjLCAQl1A8N486bTcPPUcXtNcmtrNI7vPe1dAHLT0h7HjKeXd1vv5tjectY4a2wjAdlzbEWfX9/ijdnHCbXVeftYMlvuo0PFhcjZv4BsLCZw98+rO15+eeaE/crml6XQXa42QgHJUQcXAMIBqWRxrlS215+eHbmQGENIkR32FQkYr3vbvrprF7rO0RqNo6U97lkAsqPqAlsK1M2+8owsBioCEUSJ2PHYY9jyo1uw5Ue3YMdjj5VbHIIgCIIgCIIgYGw3YiaSQ4oESXIu4ZAkhpBi/NO4NRrH3MYNvS5jX6WvjF1fkcMPvSUrYwyyxKBIRoKtL59rUQxzG9cXtOVaa3vp9B6QJWtsZYntdWMLAExieftYKlvuqyuB1FQyGsjSPwYEUllTv75q98vhA8Jls51S6C5XG6rOM4ph5nkrftvvaflL2U5fwW5fssTACtm/zWf7+eiuXUgFysxTK4gK1c3e/owsBioCEUSJ6GpqQsebb6LjzTfR1dRUbnGIMhCSQ/jt6b+1/kJyqNwiES6UgIRvzPqK9acE6DFIEARBEHszcVXHgqYtUHWOoCxZCQ4uBDSdW7P5GWMIyhJUnWPBys2Iq3quZvcJvMZOCAFV546kbk+PXTYd6pxD4+nkUm/r0CuN1VfGrL8jhMCLKzaDF1A70IXAi000lqUiV+xUC4ydfbEGJISApgtPXxUOX0VG//pif+xk053GOXTuLw7l0n9S0z1XcKi6KEmcy2t7wp/tZX92iLI+O/oz2cZU+LQLIUTGeWT5EAKkmxJB2S+CIIgSoUgKjhx2pPWnSHTsWl9DkiXsd0C19SfJ9BgkCIIgiL2Z1c3taOtSIYFZs1W5EOhK6ohrHEnNNUMVDLs7VaxujpZL5D6D19jFNY6ExhFTdcd2WD05dl5yaJwjpnLEVQ7VPcu4jDr0kjWm6taY2Sm3rH0ZLoBdnWr+C13s6kyWZCyLmV3fX7eHy4aXLQsIxJKGPSdU/37Xl0bGLCBwYci1N/qql+5U3YiXMVV3FECy9c2rDcAYo6Se3dq7kt1/NuSzvbjP57ZXOzoXiKk64io9/4uhW3YhhOV3hcIA0k0JoAwlQZSIQF0d9PZ2638TBEEQBEEQBFFeOhJGQsqe07UXDVRdIGT7VzFjRrKpI6H1opR9E6+xM2eRCwFwDtjn0/TU2HnJEbcloBMaR8AmSDl16CWrOelZCGP8ZFviLJesfX21QU8iUv9X8PcESqJ3sS8PfgovW7YfSu+ezZ/LlvvidnDplUyp16kENWD4rFtme//82ma57MhLdwlbwSOhciih3DEzW/z30yVdF1Bkf3HOr/w6T4+67tP2vNqxb02W1DmCSt94dvQXvJ9xwteqTY07v1copJvuQ0UggigRtXfdVW4RCIIgCIIgCIKwURWSwcB8J+OEABgYqkL0T+W+MnZ9RQ4/9CdZ+xr25CADgzn/v9A2aCxLQ6lsmbG+VdA0ZbEszKdsxfhqubqdT3fud736Vqj+C20/F6WyPa92crVJ8Tg/3bELIO13xX6XdNM9aB8cgiAIgiAIgiAIYq9kQl0NBlYEwCHA80xV5VyAQ2BQZQAT6qp7ScK+S18Zu74ihx9KKWuJz/vu89hzihIDBlcGCm5jcGWwJHov9WHr/ZFS2nJfWlllSiIxY4up/hBXCqUUuiukjWLa72n5S9kOkaa7dmH6XaEIgHRTAqgIRBAEUSK61C5c849rrL8utavcIhEu1ISOhQ+tsv7UBB0sSBAEQRB7M+GAjGmTRiAgS0i6Dvy2I4RAUje2FZs2cSTCAbmXJe179JWx6ytyuPEqFPRVWfsbjDFcMHkkpAKyhTJjuGBS+cayD9U5SkIpbbkbNYQegzEGRWY++oeifbVcNlEK3Xm1UWhttNg4Vyrbo3hcOPl07HdMs7fPoBQS2FMykW5KA62jIgiCKBECAv/e9W/Ha6JvIYTAjs17HK8JgiAIgti7ubx+LBauakFzWyx1LoLz+c+5sM4JqK0J47L6MWWQsjTEVR2rm9vRkdBRFZIxoa6mW0mTzLFzUujYeckHIO97lxw7qqRy9CSlGrPe/plaatsptE138vHy+rH468pmbGmL+bpX7cDe1Xt//GeEXR8dCS2V2M+ekHXbsvtSv7ac1PXUmS4CDMxYDVCm1VZ2vQVkCUOrQkb/9EyFcgFo3Fi9kNNXs/y7v6fyAX78qhRxyN2G/ZwfwFjRka2Hus6NIgGAIRVBXHzMyIL6duh+AzCoIoAdHUkkNA7JtYTBr+25++D22956dpj92tWpYtueOIYPCGFwZRAHDavK8I2epBRxvjt2wbko+IwwibGyP9f3FqgIRBAEQRAEQRAEQey1DK8OY/b0yZg5bwVao3EkNWcCIqbpCMgSamuM64ZXh8skafFsjcYxt3E9FjRtQVuXaiWUBlYEMG3SCFxeP7aofrnHzj6lP6HpEICvsfOSDwKQZeOEAOuQeY/3zH5MOXQo3l6zE9s7EhlLC/qSDh1j1h6HPR1WyJj1Fj1hO8W06c4LDq8OY87lx+DKJz8wbC8HdTXGteUey76Klz6SqYS4uRrGC7f/q65iQj6/40Jg5cbd+HJ7J2JqegcGBuO+26LxsupMYszhq7rNV+OqDiEAWQJGDIo4+leuAmAhfpUrdgP+Yqa7jYTq1H+2YbAXnRiAti4Vlzz+bs544tU3IQAIo5dqkc9tdx+0Xn52mP16fvlm7OpMOu7PYBS/7SIxAL9a9Bm4EJBKWCgtZZwv1i7MYltAljC8MggA2N6RgOZRgDUJyAx1AyN94lm5N0BFIIIoER0NDdC27wAAKMOGomrKlDJLRBAEQRAEQRAEAIyvrcYLs+oxt3EDnly2Dp3JdEKytiaMaRNH4rL6Mf0yyfBpSzSdpNU5JLDUYewCrdE4nli6DgtXtWD29MkYX1v4fvr2sXtk8RdWgkeRJQytCuYdOy/5AAFdANDS10lmMsz2niwZp8q3RuN4aWUzhlWFMG3iCMz/YJMj0dTXdGiO2VPvrMejb31pyRqQJQzxMWa9RU/YTinbHF9bjVeuPQmPvvUl/vLBRsRcycaqkIKLJo/ENacdVPax7Ktk04eZeFZ1AU3X8WlL1FMfdv+f9+4GtMdU67NcfqdzkVp1EM3YDk6k7nvhY41Fx6VSYfbv8Ya1+MPb6yxfDcoSKhWBk0YEcMcl9UXZVymLRcX4VbbYDfiPmfY2nlu+Cdv2JKzP9q8O4+wj9gcAPPXO+ozkP4MRwzU9t+9n7xugC0BiwnpdqPzuPsxu+BKqrejQk88Os1/N7THPQkeqxpXx3hNL10HVOMIB2XgGlkgOP7bDfJ7YYx/T+cs3YbvNLmprwjhrQqZdKBLDsAEha7wBYG7jBjy8+AvPe+xfHcKFk0f1iWfl3gIVgQiiROx65hnEVjQBACKTJ1ERiCAIgiAIgiD6EMOrw7h56ji0dSXxYtMWaybsmzed1m/3md8ajRtJptSWWRFFhmRLGplb3TS3xTBz3gq8MKu4ZKY5dk8uWwcujG2Ofnz2eFxy7KicY+clHxgQS2aey+h1bgjnAhVB2TqXY2s0jne+3IlwQALA+rQOh1eHcePXD8XT76y3xuzu847AuUfX+ZK1p3fL6gnb6U6b2fo7vDqMn543AWcfuT8u+8P7qa2EjG2Tlt9xRp/Re1/cHS6XPrqSGmwL8HLq2PT/YQNC+OVrn+X1Oy6MApA5JjIzkvluuhuXisFri7bh1WH84PSD8ez7Gy1fvf+ioxDeuQZBmWWuWnO3mUX5pbKJ7viVV+yWWGEx02zjW0fV4bxHlln6f35WPUYNrgAA/OWDjYirxvZvEgNCigTZtodbNhn99k1PGWtIkQqW396Ht9dsx7+3dvT4s8Ps15bdXZ62nwvODSuNqzoiQblbK4IKtZ1zv1Lnu21zTL8+YTj+Y/Z71pi+ev3JGFwZAgA8t3yTZXfTTxiDm84c5xhvu21ywSGEUaCSGMNbPzq9z8T3vQXvNZ8EQRAEQRAEQRAEsReiyBJkiUGRjP/25yTD3Mb11lZZIUVyJHcAQJIYQorxz/7WaBxzGzd0636MMWvsDt1vQN6x85JPTZ0T4QcBo/jj7ofGRb/RoX3MxtdV9xlZe8J2utNmvlUTIUWGIksIKjKCigRFlvrMWPZV8unDjh8dB3zGTruPy3nO/ylFXCoFEmMOXz28thpBuYcrsT4pha/a+6YUGTMjIdmh/6CSTilrPF1eUyTmKADlktFv30wT4kJ0K+YzifXKs8Psl9fkhnyY42SsmMs8z6kYOcx289nOyk27i5BXzjqmdrsbPbjCc7zNawKyEdvNOFNK3ZTrDLK+BhWBCIIgCIIgCIIgCKKfEVd1LGjaAlXnCMoSGDNWxmicQ9gy6owxBGUJqs6xYOVmxNXMVTi9Jp8Qjq14/KDpqUOzbf3QdOHoY3+hEJF7snteugGMLbx0XpztZGtT49xxEHix9tjXcnh93fqy6YMLAZ1nJpZLFR/iqu7Y+ipX8rUccSmrX7nEzKVfv7GnFD7cE35VbELc/T3z/tl0ni+etHUlsz7D3H1TUgW57sb+3nhsmDpLakUWcGzD3J3+ZrMdIZy/E+x6+XhLe798tuZjb+xTMdB2cARRIuruvRdCNfbHZYFAmaUhCIIgCIIgCGJvZnVzO9q6VEhg1uzehMqhceP8hIqgbO3vL0kMEhh2d6pY3RzF5DGDyiJfMbOaBQDOjQPazX7oEODCWGXQl+mraScv3ehcIJZKHIdSs7EB/7bj1WZS49Zh4BW2bY282uxrRZ7+jpc+uBDo8tiKEYAvHfvR0ermdt92X4645Je+kjP2jPOaDlUXYIBjuzC/41msr7m/ZhZ4vHSu6hyJVBEkYjvbxi7jqx+1ZH+GAagI2Z5hzDhLTsB761C/9IZa0zoDiikD2Wu0Zn+LedZ52Q4AxFQdXBjb9lUEjbKAqZeYqhsregq4n9tX/J4rRPQ+VAQiiBKhDOo7P1gIgiAIgiAIgti76UjoqRUy6fe0VHZMCCNBp9gSP4wZKbSOhFY2+ZKFHo6Qwkj9GQ2lcoGO98pBMXfuK4UOL93EtXRxIKFxqwgE+LMdb32ns5nJ1EHn2drsK0l3oDjd9rWZ5p76yLEyoVTxoSNR2Iqe3o5LWekR9XW/US89mqspze3CQkp2v/KiVGHILFZ46Txhs7W4qqMylE4/mzLu7kxmf4bBWAUT8KhGeJ3r5Jte8FNTZ0g9qwrF3b9in3VetsOFsIpoXBhxy1whxJgxPIXer4+FPk9oOzgD2g6OIAiCIAiCIAiCIPoZValZ0lkTMK73hTBm6FaFemcuaF75CsA+s9hsrz/ONi5kLHoyZ+Wpmxyy+bGdfPp2v93b9lgI/SCnmRcvfeTe4iy/PvyYZFWosHM8etsO/Os2+5VuG89q8yUwpLx+VUScLzYh7hZBT908n86z+f6gymBBMcOkO7G/N3zb1FmxN3P3r9j+FvoMFsJ47vTYs7WMhZi+VqQvF1QEIgiCIAiCIAiCIIh+xoS6GgysCIBDgOfZH4dzAQ6BQZUBTKir7nPy5cM8Y9zsB4Oxlc3eTE/mrHrCdrrbZn+bqN3Xk4qF+p8fHfvR0YS6Gt8p5HLEpWxkrL7oI+rtCV8tlauZ28EVq/Nzjqz13zfz/Bp0L/b3hl7TOiturCVbpr47/S3GdiIBudvP1m6t1CJ6FCoCEfsuTAbGnpT+Y4XNWCEINxKTcMx+x1h/EqMQ29dgEsOIQwZaf2xvzx4QBEEQBLHXEg7ImDZpBAKyhKTOsyalhRBI6sb2XtMmjnRsydUX5PODMZs53Q9FZmXf3sXP7ftKItlNT9hOX7fHQtgb/oVQqP/50YefFQLhgAxFtq/cy37fvmwHhbhutqR3Kfy/J/yqVKHTLMz41blbxoEVwZx9Y7bvaakt8PpC7M+HqbOgUmQ+yDYM3elvMbZzxIiagu/XH4o+fd1meou+t+6WIHqLYAVw4R9L1py2YwdEMgkAYMEglKFDS9Y20T+IKBHcd+p95RaDyEEgKOPMGUeUWwyCIAiCIPopcVXH6uZ2dCR0BGQgqQl8sa0DAHB4XTUmjR7Uq8nMy+vHYuGqFjS3xRxnMJhwLqxzWWprwrj4mJFYsWEXOhI6qkIyJtTVOOS198/rczt+Ej/55POLux/b9ySKbmtvx22jAIOqiwx9unXj1qaX7bzz5XZ80rwHgGHvh9dW48vtHZa9XHLsKKvNuA97vKx+TE8NQ8kQQuT0Geu6MsiWi7iqY+KogRgYCWBnRxJxLXchaFBFABcfM7Ko+7hjRkCWoOk6BABdAFKO0dmvOoSjR9XgjU+2YtueOIYPCGFwZdAxzoXEJfv1GudgYKmVDakkcNZEuPN1QtPxyQ4NG6I6Pmdri4rv2WJkof0pRZwvFSJ1poyAwEeb2zF6cAXCAdmhc81j1Uk23y+kbwxwnFVWlPy95Klmv7bs7kKhR+F1JtNnLCndnLRqH9+4xjNW+ehCQE2N+8BIECMGhrFqU1tG0SSXzRZa7HS3ZT+XqKfo6ys3ewsqAhFEiWi+/XbEVjQBACKTJ2H044+XWSKCIAiCIAiCIErB1mgccxvXY0HTFuzuTCKpc7jzXAxAZUjGhZNH4funHYTh1eEel2t4dRizp0/GzHkr0BqNwy5UUjcS+wFZwrABQdQfOASXPP4u2rpU47BoMAysCGDapBH4xhG1+PvHLVjQtMXz88vrxxbVH1O+GU8vR2t7vOh+xjQdAVlCbY3R3oWPNhbd1t6K20ZVzqFzwy5liUGRGQalZt6b+sxmO0B6zIcNCOLokQNx9u+WotN1ADwDIEkMisQgMcNejh07CLs7k9jjOphe5wJdXEdQZqgdGMHs6ZN7xUeKhQsBVefQdIFL57yf4RNfP3y/covoid0O2rpU6IKDC5E3UdvWpeKSx9/N7e+uA+Z/tegzz5ih6hwhRUJC42BA1iR4RUhGZ1zHrGeaHIUDRWIYUhXE2UfsD4Bh0epWX3HJ3fe4mi4eBBWBbdH8MYgLgaSm45LH3kWXmrL3zz51xPfzjqpzfMfveT1u+fzG2Vy+qnOBmNDzxvlEyp8lxlDMWret0TgeW/IlupK6VUa5/aWPcP/r/8a0SSMAGCtP4qoOiTFrlZCJO4ab/cz3DAOMZ9jgSBB74lpK/uLprVqAvV/N7TFrJVOhxFQORRIIKlJRfR9eHcYvph2Ba+Y1YU9Cg+763O4jbTEVf/2wGZouoMgMAVnyZbN+2RNTPWNGXNWt+3VXv0RuqAhEEARBEARBEARBEFn4tCVqJaiSOVazCAAdCR1PvbMei1a34o9XHIvxtT1/zsX42mq8MKsecxs34JHFX1gJOkWSMHRAEFMOGYala3ZgwcotUHUOCQyMGTNjW6NxzG5Yi9lL1oIxYwa3+/Mnlq7DwlUtmD19suO+hR4e7XcGdlVIRoer2FBbE8a0iSNxWf2YPlM48NP/3pp1ntA4Lnqs0dNGzZn5GhdobXfq0247v3/rC0cdqLYmjCmHDMObn23Dy6uaPe8rYCShdS4gMaClXccrq1pyyhoOyPjF+UfisP3LewZMLprbYojZkt1JjWf4xEsrt0DnAnIf2l7aHqvsvs6Qf6WSpmf6uzt+mT3VuUBc1fHE0nWeMUUIQINASJFwyH5V+GJ7J2JJd/oZ6Epo8AqpGhfYGk3gqXc2WPeVWPa4NL622rPvJgKGj1z4WCNOOnhI1jHQuUAsVfjRuFNee3x/9aOWgnWfTTfZ+uMmW5yXJIb9qkN547wQgKbrCAfkgreDM2VvaY857EjVuSW7qnGEAzIiQRknHzIUb6ze6rg2VwzP/gxjGDYghGkTR+KgYZW48+XVhQnuQW8uCLH368ll6xwrfApB4wJ60tBdofHm05Yobn7uXxlFeTdmLOfCeGqpuoCq6/j2I8uwszOZ02Z/NHWcsy2PMda5wBNL16EzqWW0Zd7PtM+eiKm0HZwBFYGIfsmf39tY8He+e/zoHpCEIAiCIAiCIIi9la3RuDGTty1W0HYiLe1xzHh6OV76/om9tiLo5qnj8OSyddZWPT847WCcd3Qdpv/hfWxNzYCPKDIkW4JF07lj265IQIJsO5Xa3IqnuS2GmfNWgAthzdT1U+Awx29rNO45OzyiSMY2VanXIUXC8ju+jsl3v2H1g4HhzZtO63NnhvQVuBDWKishRM6Ev5noM/X5wqx6y3aefX8DupLcGvNnrzoB33niXWzzufUeF7mLDeYB511JHT9e8JF1b78UWnQslq3ROJ56Z72jH5Fg2vZMn9gaTYBzgUhQhsRY2c9/sscqINPXORfplS0eRIJyhr976YgLowAkUm1mu49ZeDls/wE4ePgA/L+PW42YIWBtP+h3h0gBIByQrESuW85H/3MSrvlTU0bfO1yJ7+a2GF79V4sjjpls2xO3CkD52L4nAZYas1wrF0yT8KObfOMOeMf5kw8eiju/eXjOOG/XSVzVHfacD8cz0PVZSJHBkF51arZ97lfqsGzNDktGyUcM9+rbpSeMwc1njkM4IGPxZ9t8y5yL3nZTs19cCPzx7XWe22T6wT6+flfLbI3G8b2nPzBWWPmAc4GAzJC0rVpqaY9DllhOm73n1U89fcq6NhUzEpqxSszdlumnxfSRKAw6tZzYd9FV4Ms303+62q3mhlxxBfa/66fY/66fYsgVV5RGRqJfoXIV7zS/Y/2pvHs2RZQeXefY9Mku60/Xi9+bniAIgiCIvZ+5jeutBEqhSYnW9jjmNm7oCbGywhgztv6SJBw4rArPLd9kyR9SJEfiBTDOA7DjPstBkhhCqcOtzRnshWAfv5DrkGwGQJYlBG0HinMhUjPV0/2QJUYFoByoOoee0pvEWN4kp3lFa9Rpn+4xf275poK38Mt1b8mmR/e9+xJzG9ejPZb933F2nzBmsPeNf0+4fc3t6+7XXrj93a0jxhhU3Vm0zXUfAeDfWzsgS2nb0kVx6+OStnF2y/k/r6zO2Xc7nQndU2fzP9hckDx23efrjx/d5Bp3N3ZfHVoVyhvn3TqJ+yx2uWW3x2ov2e1jUmwMt3/PPG/I+MC3yH0SRWIZz9tCKTTezG1cX1AMNyYJZL7PIHLa7M7ORE658sUMtwx9JabujVARiNh30eLAS9ek/7Ti96gGgMoTT0TNueei5txzUXniiSUSkuhPJPUk7nj7DusvqSfLLRLhQlc5/vH0J9afrtIPDIIgCIIgvImrOhY0GVvrBCQG1eOw61zoQuDFps0FJdxKSVLjlvxB2TaLXqS2fBEi45wCTRfQOHes8mGMIShL1vko5oqofCsz7ONnv3+64XT79vuXa7wKpS9MVDZ1KAAEJOZ5ILsbnQMB2UjmL1jpbZ9CCLy4YnPGuVfdxW5L2e5dTkyb1V0dN7dJMmGMIZBKiNt9olxk8zW73H5lzKUjLRUD7NcCRkxxj5nJl9s6rM+8Yo5fND1TB0FZQlLjWLlxt2eccxOUjSKUW2dxVcff/rWlKJlyjasQ/nRj70+hvqFx7zgvUjrxKrnFVd1X+3ljuE12Sx5d5Nw2tdyUy1dVl+8Ui994E1f1omK4V6FK58bKLPO3g4lps5qe6VMmdp+XJQbGGASy2ybQN2Lq3goVgQiCIAiCIAiCIAjCxermdrR1qcbZEkVm/Hd1JrG6OVpiyfyxeXeXJb8581bjHF1JHV1JHaqemYIxZolzxJPOJJ4kMUipNSRmUinffH77+PlZhWDev1zj1RP0dB7L2DYphY9VQIB5vaHP3Z2q53hzAezq7JldDUxbynbvcmLarLu+GVN1xJK6IwGa3hYRJS+WFYqXryV17pA7n4x2f86moy0eW4JxIRBL6oipumO1jklc42jvSqauLX47LgFjK0F7scmQM70Vodl3nQt0eZy/IknM2rLQPh6W3ouQiYvchQUv3agp3XS5baoI32jrVDPaFzDONoqpOhIekx658Bdni43hW1Lb3hFptu1JlGQrOr/xZnVze8liuACgasL67eD2Qcbg+m2Qxu7zZsyMq4b9u39n2O9X7pi6t0JnAhH7LkwCho1zviYIgiAIgiAIgoBxCLiASCU4istICIGMcyl6i7jKLfnt75l4JWxN9NRKIfsMb5bKnhpjkT8haB8/L7K1UK7x6o/Y7bIQG7Xbtdd4C2SfpV0Kct27nFg2i8xihblNUUjJ3NbKGKvyZS29fM1cjSFS/1vx2MrLjqYLa3UT4K2jhJZZWEnazvRKasaKETdqaiVAKWwqoemoCNpSmSll2XsX95DTfb09jnUk9KILtrn6ZIxfpm4StpUyCZU7zugp1DdUnhnnjVVGxv/OtjrQT/v5YjiyPAtKtcKvJxZblmuBSSlXR/l5Bpu6KxX23wtuHzRLq15yuWUQtlWDumtlUa7vEaWBikDEvkuwErj8lXJLQRAEQRAEQRBEH6QqJIOBGcWQItNRjAFVofL8szsclCz5i8GdzjGbMcci35jYx68QyjVe/RG7DgqxUbtde403s1rrmUScEMh673Ji2WyWz7OZcrHxoVTk8zXDl3PL6P6ql468znXxYyFmcakU45RR0/BYfZAz5LjiGJAavyJFy9knkV83PCNJXphvBKTMOJ8v5DL4i7PFxvC+fIZbuYoLAaV0k879+JGpu56I4W4fNMfUS66ifzv190Og+ii09IEgCIIgCIIgCIIgXEyoq8HAioCRpCuykDK4MogJddUllswfowZVWPLzLLPB/aZZOBfgqRUS5q5A+ZJp9vHLdn8veco1Xv0Ridl0KIQvfZrFHQ6BQZUBz/GWGDC4MlAyOe2YtpTt3uXEtFk/eVNzBrvdJ8qFH18rRMZsOhoxMFJwajasSBhYEbRkKOVQGXIa7YrU63zXm8Vt+3hYei8Qs51cd82nG/t4FOMbAysDBcdZifmLs8XG8JGDIplvFkMPHLxWrpVAQyuDJbF9v/FmQl1NyWJ4rttxLlKFS2+57D7Phb8SXF+IqXsrVAQiiBLRfMcdWHv+NKw9fxqa77ij3OIQBEEQBEEQBNENwgEZ0yaNQECWoHKBQIFZCZkxXDBpZNlmRQcVyZI/qXPP2dy5togyPxFCIKlzBCQJisyyHg7uxj5+2e5vtm+Xpy/PIu9N/KTLGGOGTgCoXMBjJ64MZMnYnisgS5g20ds+GWO4YPLIkifiLFvKce9yYtqsnKfjQghri7NCfKKn8ONrfmXMpaOQIjtiBhc8b2L7oOFV1nia9loKTDmDioSJowfljTOAsaWVbPqMbTzCARnnHFlXsAz5dC9QWBwsxjcUKX+cd1MRVHy1n09285U7hgdLuOql1JRrkzFZlkpi+37jTTgglyyGZ3uumDaryJk+ZWL3eZ0LX/bZF2Lq3krf9UyC6Gdo27ZB3bgR6saN0LZtK7c4BEEQBEEQBEF0k8vrx2L/6jAAZN27Phu1A8O4rH5MT4iVFyEEvtzegUP3G4BBFQEIOM+hMGF5usS5sL5XWxNGwJYNyrddS1zVMXHUQAyMBCCEcUC8o20BqBpHUrcdMs0YVmzYZSWKzPMD3vhkK/703ga88Umr4/O+RFzVsWLDLiz5fDtWbNiV91yMQq93f0/jHDoXUCRmJdn9TNY31wvV1uS2z8vrx6K2JpL1cy9yWYQQTlsql2/k4/L6saiJZJ9Bb/cJBlg+UYhJmjp023V3zlKxxyovX8+7koNl+rtbR4wZ/TX1nNAyV4jotrNDGIDD9h/g+Nz+/WJxy/mTbxyGQRUBcCEc5555URmSHXHM5OJjRhUsh8SMrdJM3cdVHToXlm9qqbHwo5vu+Ia7ffezStWcOqkK+9+G0d62PVYDqWKoxhGz2a2hX38aLiQGZmvRq41s7cZVHTFVt/TTm88RIbpv+/Z4kw173yeOGmjprjt4hQ67zQ6pDDnkco+rvd9uG3LHDz99JIqnb23AShC9CdeBrR+nX+93BCD1rZlIBEEQBEEQBEGUj+HVYcyePhkz561AazQO3efhznU1Ycy5/BgML0ECphC4EFB1Dk0XeOifX0CSUslpIeC1WVgyR2I4puoQMBIytTVhPPqfk3Dx7Hetz7OtVNkajWNu43osaNqCti4VujCSkl75toTuHM+ExnHpnPcRU3VILJ18umrucusaRWJG8UNmCMgSpDLNGDZnKrv7a4w0w8CKAM47qg5cCEtGAZHz+oSmW31yJ1Ld3zOT3WZStzocwLZoPGexkgGQJYbaGsOuc9nn8GrDhq988gO0RuO+xiRXSpULY4a3n3t7yt5Lah5eHcYVJ47FA298ntEfnQvEhKGjYVUh7OpMFmR/pg6fX74ZuzqT0Gz+p0gMQ6qCuHDySFxeP7bg8XHHKnvm1pTb9Cmvk0JUnUNF2t+z6Uhixmq9mKpDCGM7NjsxW4wMB2RUBBV0JrSM78dVHbLMoOmFJ+JjKT8ZNiCI+gOH4Ad/Xom2LjXV5eztjRgUwfEHDMbfP2rN+GzIgCAiqX75JaFxJAHMWboWC1eFsWh1q+P7//h0K3616DNcXj82q264SPenWN+w676lPWatUrPktMXZkCLlXemWq2376CQ0Afd4qzpHe0zN2abfGJiL1vYY5r27wdEGBCCnVkaavsXAMCCsYNTgCDbvjmFbNGFJzABLPz39rBYQDtsvpvwUDshZxyXbmFaGZFQGZXQmiy8we/1MsNvsDWccgjv/ujrr981+R4Iy9sRVhw25J4cUYptE4VARiNh3UbuAP12cfn3dciA0IPv1eag49lgoQ4cBAIIHjO2mcARBEARBEARRPPfeey9uu+02AEBjYyNOOOEEx+fRaBR33XUXXnzxRbS2tqK2thYXXXQRfvrTn6KqqqocIvdZxtdW44VZ9ZjbuAFzG9cjGteyXlsVUnDR5JG45rSDer0A9GlLFLFkOrmkcQ5JMAgB6AKQsiz7YamMsPvToCJhcGUQ0yaOxGX1YzC4MuhLBjPRqeocEljByftEKomarT5lJvdUXUDT9bJuKZatv0IItEbjeHLZeqg6RzggQ5YY1u3oxLV/Xpn1eiHg2Sev+5gIAB1xDZGAjGBAgprInuyTJIZpE0fgxq8f6mGfmYoaX1uNV649CY++9SXmL9+ErjyJxLqBYUw9fH8AwFPvrHfYVDggYcbJB+Ky+jFF+UZvLv4aMSiCSFC2CqrmrSXGsF9NCNMmjsRXDxuOy/74vu82TR02t8c8Cx8aF9gaTeDxhrVYuKoFs6dPxvjaws5MsseqRxZ/YZMb2L8mjKAsY9seo6Dn7psiMQwbELL8PZ+OGHKv/Mr1mSwxRIIy/uukA/DUO+vQ4WGzwweEcM6RtQAybam2JowphwzD0jU7sGDlFssn5FSRyz26DEY8e35mPf64bH1OuSqCMpKajlz1fnuBWgB47eNWzz7HVI4nlq6z9OmlG5bqj99xz8b42mr837QjcM0zTVD17M+ohMah6v4mM9jbfmFWPR5e/AXmNm7I+NyIYcb/VnWBB974N3QuPBP6+WJmthhoR+cCF89+1xUPBXQBwNZ1WWIQ3FiptG1PIqMdATj0U6i/FYRIy2TGFnexLhe5/CnXmMY1HYrEUBWSPf0sILOccmTzKbvNbtodyyu/LDFcNeUArN7cjr95FGFNNC6gJ8v7XN+boSIQQZSIoVddVW4RCIIgCIIgCAIff/wxfvrTn6KyshKdnZ0Zn3d2duLUU0/Fhx9+iDPPPBPf+c53sHLlStx///1YsmQJGhoaEA73bgGjNylmRcHw6jBunjoOlSEZv/vnF9asY2EddMwgMWD5HWeUJXmxNRrHzHkrHImaoCxBSW2rYmzdkpkAqgzJ1ooTjXPHVkr/d/5XcPaR+1v90VyJQ6+VKjPnrUBzm5EQiigyJImBC4FYAbOQC8n1Cxjb32yLxnu96Kbq3LO/JpwLJHRuyRgKSPi/v3+GHR2JrNd3pWaIx1UdSd0Ys2zj2mFbXSEAzyRnBkLgnS934sav++/n8OowfnreBFxy7Ch8+5FlqZVGDLedPQ73L/o3BJg16/zNm06z7OW55ZtSyUPjs5MPHoqbp47zf2O36L18mofEGEKKjKAsrH4cO3YwnrjsGIQDMjbu7PLdlqnDLbu7kC/vq+oCW9pimDlvBV6YVV/UqpCbp47Dk8vWWXIfNbIGT//X8bj2zyst+3P37ZJjRuHH3xifM34xxlJbrqWKzYxBYcJRMIkEJMTUtN13Jb0LEhJjuHnqOAwIK/jNP9aACw4hjOS1xBgWXncy9kv13W5LEhieveoETP/D+9iaWqHm9iW7bwBGATKoyLnHUqTlCgcU47wTTYfOYa12kiWGkCwBDJ4FUbdq5dQWe802fbp1s9+AMBb9cEq3nxtbo3H8eMHH6Eo6V1ECRpzvTBUABICdHcmCY+bw6jC+ffQIzGvcYPUzkDr/h8EZj3Z1JiEEEAk6V65ki2Um7hjYEc9cUWTan70NMHg+Y3Tutf7V1Z5LPz31HLHbhj226FxkrIbJ9v24qmeMKRci75gm9fSzPWidS2T8ZnnrR6fha79eklWOSNAoG7h96i9XnYDRQyoBAJt2+4yFAmja2OZ4KxyQMrZwLOdzfW+HNtojCIIgCIIgCILYS1BVFZdffjmOPvponH/++Z7X3Hffffjwww9x6623YtGiRfjlL3+JRYsW4dZbb8UHH3yABx98sJel7l26s6JAkYytdBTJKLAEFBlBRUZQMV6Xa/bq3Mb1ObfskiTmuY2MvZDj/vzjLW05++NOyttlCCmSlYhSU4UQvxSqHgF4zk7vaXZ3Jj37ayJJDCHF3AYOSGocOzsTOa83ETASqUD2cS0UmRlJ/NZovKjxCgVkKLJk2fuEuhpINn+QJeawF8aY47PubvNTrmOg7P0YXBm0+ui2/1zimTr0c2YTYCR2i9WTiV3ugRVBT1+2XzNyUEXe+MXg9OeQknmAuyzZzgYB8FnrnpxtBmTDPgKyYVfm60gwuy09t3xTQT6h5Rj4bOfCGPdMTxpgAMIF+h9jDCHFGA+7Pu39iQTlkjw37HEi4JLRXbDXuCjKtl5aucVh57KUuW2liQAyVhzli2XuGPju2l3pPrDM54nZRq5nTD6X89JPT+BlZ4wx6AUENq8xVXXu4znk9En7b5aQIhcsBwA8t3xzTjm9eG/tLmzvcE5WkLPMyinXc31vh4pABEEQJSIsh/HI1x6x/sIyzVroayhBGd/8wVHWnxKkZcYEQRDE3sU999yD1atX449//CNkOfM5J4TAnDlzUFVVhTvvvNPx2Z133omqqirMmTOnt8QlSkBc1bGgaUtGcogD1vkwQgjPRKhxVo93yubVj1p9H1RvlyEoS1bCTue8qDM/CmXBys2+ZS0FQgi0x9SM/goIRzKNOWZsA5ouHNdzIbKe4dPWpaKtK+k5rsUcaM4YQ1CWoOq8qPHqzUPUPe9f1rsXj+kbSZ/niQFGwatYPeWiu+cqJTWnP7sLQF58ua0Dut/qlw+EEJ4+kcuXND0d57KtKPN619xKEzDGLu1//uXtrt/5IVv8zUWhssRVHYtWZ27j5Y55gLG1IOAcdy8Zze9m08mHm9ocMgohLPuz2rC9Vwy9oZ9sFCO7w5ZT3/d6DnHXcyiYWhVs/74fObLpxj5WfvxBCIGVm9oy7pOr+NTb+tgXoO3gCIIgSoQsyRg/ZHy5xSByIEkMw0YXf/YXQRAEQfRlmpqacM899+BnP/sZDj/8cM9r1qxZg+bmZkydOhWVlZWOzyorK3HSSSdh0aJF2LRpE0aNGpXzfvX19Z7vf/zxxxg9ejQaGhqK60g3iUajAJD1/s3NcWi2MxMKkfPLtUnHd92Uo89rduvY2RHPOOw9mTq0PCgBYN5JTnNLo5DHvJhdHXH86e8NOGRQajs4Lhx9/9e//gVti5IhAxc6uA7oHFALO3qiaHbsccpqx5I5lWzqjo7Mtrgw+sdYur8QQFI3im8yAwIyPAfdvJ6nrgcMHUmuKbqaLvCbBQ3Y2ZFwjCsEkOPYn6wIIcCFDgbv8VKTSUeh0D1OLR3cof9Vq1Zl+IL9O+7PduzYkXPsYzHnWTnua79s03Perzu4Y8a/t6iefr516zbrmq2dzvFYvnw5Wgdk2l82/8yLyG3X+bDLtmPHTjQ0NGDnzljW+LV27Vo0IPvsfgBYtibh6IOu6RAuH3e3H1N1rN3cCk3PNNqGhgZ8uc47pr6z7B1UBMxiQvpzLoCdHbrDJ9y+5EYASKoaGhoasHlTwtHekoYGSIxhd5xnyJFOlqflEAX4n5Fc16wWTH3a79PV2VmwHdu/39Laij/9facj/rqP/FG1zPEt1LbW7Naxu9O5ioPrHEkt8/y2dMENUHUdCgf+9PeGjGeEqpvn1aWfU3Y64qol40fbNah6+sw7znVwYbTRnRKjl378jEm+3xluNm+OZ9iX11k7+TDH1NzyT8BY3ZHzOZTl+wDwTuM7jnF105XQPX8f2Mfq37s0R9+8fJeL9Hl/dtxbwWW7RzE4/Kyrq1d+n2Wzi2g0iurqHjxzyie0EoggCIIgCIIgCKKfk0gkcNlll+Hoo4/GLbfckvW6NWvWAAAOOeQQz8/N983riL5PTDMyQdnmfid5/pm6XpNthdl2kTL0VgEIACD8y1qS25mrA5wiWGeH+JncbR/zZJax2pPMHFetiMRhBl7j1c1VIj1NmRciFU0+/8wGA3rdrvOheq3ocXfM45JiupB1vAQyY40PXxLWfwtYCeTxXgELujK/3wP6ZMhvY56LKQqUxetagcwCUMY1wvZ9u4y2VVa5iiH2+3rFgJIuNO1Bf8u20qyotoTzv3a9c+R/Drnvm0uOrDoucKxESscFrUbsY/Fvb4BWAhFEidj97LNIbtwEAAiOHoVB3/lOmSUiCIIgCIIg9hX+53/+B2vWrMGKFSs8t4EzaW9vBwDU1NR4fm7OVDSvy0VjY6Pn++YKoSlTpuRtoycwZ2Bmu/+bbauhtKRnvBci56fiSyjrvsj6eTn6XLlhFx758H3oGke2VJoiy1B59unrAjDsxjZbX5Yl1B8zEZPHDAJgbE+lLH7D+vwrX/kKTjxoaIYMiml/HrPPewpZlh2y2lH+ucgQJzUruDs6MttiTEATOgBm9VfnwjF+iqwYCWf7CghmvA8Acdf4KLLiHDMGTJpwKP6+7lPHuOoiNd27QBgzZFV1PUO3ABBc+g/otsPV3eP05fYOKO8ts15/5aijoHy43HGN/TvmWJkMHToUU6ZMzipf5L3F6NKTWe9fuWE3lKb3s96vO7hjxo6mzVA+W51x3fDhwzFlykQAwIadnVDefdv6bPLkYzBu/8wdB0zf0HL4nycst13nwz7+Q4cOwZQpx+CZ9cuhtO30vP6ggw7ElFMOzNnmKnUN8OXn1mtZlsF1e/kTUBQFsM3AZ4xh+NDBWL9nd0Z7U6ZMwRfSOihrP8/47MSTTsSAcCCjL5wZZRy7T7h9yQtFljFlyhQs6/gUypaN1vunnDIFssTQ2h6HsmyJ4ztcOPthxVGf2XuJpeOD3e8e+1fajquqKjBlyim+2rP6YhuP/fffH/XHjHTFXw6Vp3XiJW2htlW5YRceXvmeo11JkgCeWRWTJcm6TpFlKDJD/TFHZz4jbHYiSbJxbphmf4+lZfx8O5QPV1jPMVmRjfOIuvmcMeNxtriYjXy/M9wsiX4CpXmT4z3GRM7ncjYU2Rir9PfTdqZxDvtSMLN/xoea4/sAcMIJ9VCWLM4pB/PQs91+wut2QVn5gfVZ/Yknoibi9F3GBDTOC9oasjvxz35vAKioCPfK77NsdtEXVgEBtBKIIErGnsWL0fbcc2h77jnsWby43OIQBEEQBEEQ+wiNjY24//77cccdd+CII44otzh9nu6ei9HXmFBXg4EVAWQ/GtvYbqfQbtdEAphQl05c5Mp72mXgJTz/wy+DKp2y9jQSMw60Lri/Ar6vVySGc46sLem4ci7AIUoyXv11ZU6p8Nv/tG8U5oMCvW/X+Rg1uCJvH9wrbcKKhIEVwZLJIDEU7BMMsJLebnKddcV8XpePUvqdF8XE30JlmVBXg+pUYj8f5nk0DLC2HStGxoqg4pDR/hwr5XOmp/UDeMeLYp7L9jE1v+9nTM3P7d/vjhyFjpXEDH0W4kZ9Lf7tDVARiCAIokR0qV2Y8foM669L7Sq3SIQLNaHj5d+stP7UYjZUJwiCIIg+hKZpuPzyy/GVr3wFt912W97rzRVA2Vb6mPuZZ1sptDfQneR1X8x7hwMypk0agYCc/Z/3jDHrsG6/nH1ELcLuAwV8yJDUebcSpsUwbeJI37KWAsYYBlYE8vbX/r7EAEVmvsdnYEUAAyuCJRtXIQSSOkdAlooar/IXfcouQFESmL4RVPyn3xhD0XrqSYKKBEVOxxE/9njQ8KqCYw8A65B7jw8K9glFZlZ72a722iaOMeNcFSC1nVURTpDP70oxKaHQ+MtQeMwMB2ScOWE/X9eaZ4vZx72YZ8TE0QMdMhqrsYz2krooyXOmu3HR93087Ys5/MkP9jE1v+/nOZTUecb3DbmKk8M+Vn70wBjDxFEDC7pPX4t/ewO0HRxBlAipshJSTbX1v4l9DwGBtW1rHa+JvoUQArtaOh2vCYIgCKI/09HRYZ3fEwx6z7Y2t2d76aWXcPjhhwPIfuZPvjOD+jNxVcfq5nZs2R2DzoUx+7UXlwWZ9+9I6KgKyZhQV+NIcOT7PBeX14/FwlUt2LjLexIS58KanZ0N9+eH7FeJR9/6Aq3tcQypCqIyqEDVOSTGMmYS22VoboshUcjBGd2EAbisfkzR3zfHfVenim174hg+IITBlUFr/O16Me0GACJBGRJj2NmRRFzjGYnuhKpbyVAGIKRIqIkEsaMjgbjH+CRtB3cwAEMqQwC8xrW436+6ACQIDKkI4uJjRmZ87uUJ9r63dSUhhLAl03v3d3T6HAyROkNEYMWGXQX5SS6SutFeR0LHuh2dzr6m7rktGseKDbtw0LAqNG3YjaSmQwgjkd/45Q50JFRPeUwdbtnd5esME4kx1NaEC7Zruy0nNQ7GjLZybcFk9u3L7R1Zx9Ns99PmKGTGoKW0n9BFxsxy+4oEBmB87QBAFBZnhRBYuWE3OICqkOzQBVB4rLEXyDXd2JJKQICBIabqGOAqoJtjovO0XwgYh9gXYvc6F4in/Lq2JtKtOJUP+5i4z25yS6zIzCFLrmeP/bPx+1eD2drL9UxhSI+7qbtcetO5cFSaGYDJYwZZPvnF1j0QQiAgS9B0HUIIxDwPOyqMuGr48JCqIA7Zr6qgmGKPGbnGrSokQ7X11x7D7P7kB9Ofzd8vAVnC0KqQNaaSyyE5TxeA7DpxY42rDxkYcz5z/cp+wkFD8ElLFNv2JPLfA917rhPeUBGIIErEyAcfLLcIBEEQBEEQxD5GKBTC9773Pc/PGhoasGbNGpx33nkYNmwYxo4di0MOOQR1dXVYtmwZOjs7UWmbvNTZ2Ylly5bhgAMOwKhRo3qrCz3O1mgccxvXY0HTFrR1qUimkoAMRjJsWzSO4dVhX20VM3/EfX8z+TiwIoBpk0bgG0fU4u8ft2T9/PL6sXnlG14dxuzpk/GN3y71TMjENB0BWYKucUcSz+oXgITqTMr95KXMM1FMGID5H2zCwcOqLNlMGWbOW4HWaDz/ieElgMGYYe5Xf3ZMvTy/fDN2dSatgg1gbMU2sCKAMUMqsHl3DNGYkaaL28aoa1cMAYWBCwEhkJFotydizYTd9087EPct+jc6PFajJ23XyxKz0oLucU16HJTNAOxfEwYXAluj2RNsQgBtXSouefzdnLbFhcCvFn3msEkhgKTGrZnnvc3OziQSmg5NTydML53zfkF+4sXWaBzP/zuBZVtUxN58HwICOhfQdAGjmyxVNADeX7cLFz/W6FnIuWvhJ5AlhqFVQVw4eaRDHrsOm9tj0HJUggIyQ93ACGZPn+y7P7lsGQCWrtmBXy36DAlb0pwLAVXn1ng+v3wz/rqy2TGeAnDELo1zqLrTrlVXX8wCp+mbFUEFXT53X7DLdNW85al2GOKqbtmdxJhjPFvaY3nbVXWjIParRZ9h/vJNjuLB1x9swAWTRuCsI/bPGBM3eoEPAAGj+CozoP7AIZ7XdHcegvl9h421xXIWaMxCRa5n09QJ+wFgWLS61RED7K1ms+MhlSF0JDRItiKqXcbvPf0BWtvjju8kddeZMxLDnKXr8PvFX0LAKJokbc+vUs3lNLuwoyOJW174FySW/9nrFTNyjRsDA2NAUjPO7zHjSTEkbP5l+oT9+aC6imvms7+2Joxt0YSlExNzHCXGrEkPbtnsumEAKlzPXD+64ELg3S93IqHljwXdea4TuaEiEEEQBEEQBEEQRD8lEolgzpw5np9dccUVWLNmDX784x/jhBNOsN6fMWMGfvazn+Huu+/GL3/5S+v9u+++Gx0dHbj99tt7XO7e4tOWaDo5onNIYNbZOQJGAvPCxxoxe/pkjK8t/d7zXvdnzEiKtUbjmN2wFrOXrAVjxhY67s+fWLoOC1e1+JJvfG01IkHZM4lZWxPGtIkj8cdl6wDA85qBFQHs7lJ99UsAePVfLVi5sc0h2/jaarwwqx5zGzfgkcVfWO0zBgwfEMK2aKKAGc/Z60j2BJg7qeUHUy/ZEvIaF9jRkcSOjqQli/suAo7zt3OiC6ArqePXb3zuWQDyuv+67Z34tCWK8bXVjnF96p11jjYYgJqKAF7+wUmIxjSc/buGrElsWWLQ9Ny2Za5eeGLpOofNciEsn9F0HRt39t7W15+2RPE/L3+cUXBIarxgP3G3ayTNk9A5IDGjWKCn+mrkU9P3NJP62dC5UYR7vGFthjx2HT7duA574pl2sH91CBdOHoXL6sf4ToDms2XASBw/3rAWim2ZgDvZy4VwjOeLK7aAMaP4ZtqBu3wcDsgIygKdyXRf9q8OY0dHomDfNO3OvENSM1YdCpfdmQWM8bXV+L9pR+CaZ5qg6lrOtlVdQNV1PN6wNsOGtqb6+/zyTYgl/a2EcBMJSKlVQln6JoAXmzbjnS93Yvb0yUXcITv2BLxpYzfMX4l3vtyV9TsdcQ3nPbwsQ7/ms6elPY6n3tkAwDxDJh0D7FSGFHQk0mNvxuWbzjwUP3/106z3Z6n/y7WGROMC0Zhq3dsssvfU1AKdC2uFTWtUzxpTssWMXOMmhLAVEEvTA7tPALBiy5/f34hdnUnrOvPZf1n9GHz110tytilLzPM3hJJ6bpjP3GznazmEs2H69tIvduQ9uyjQjec6kR86E4ggCIIgCIIgCGIf4pZbbsFRRx2Fe++9F1OnTsWPf/xjTJ06Fffeey+OPfZY3HDDDeUWsSRsjcbTs6K5QESREQnKGdt2NbfFMHPeCmyLxrO0lKaQ+bvZ7h8OGP8NyRI0XUDjAqouEFYkx+cRRQbnoiD5JMYQUmRUBGVEAjLCAQmRgIw3bzoNN08dl9rKLfOaqpCcP7HjQuMCWzxkG14dxs1TxznaP2hYFZ6bWe8hr7FNmhfhgIzKVBshhSEoSwgpRn8qgjJCilxUosjUy5bdXTlXZNjhwrsgVeiM7vZY7mS1naQuHGNrjuvFx4xy6LYiKGNIZRDDq8MYOiCIkGJ85h6ZgMzy2hYX6US822bt2yMJAA+88XneLQZLgamvHR5bCBXrJ/Z2jVUTQECG1ddAEWfY2FH13L5x/VcPybDrASEZb/3odNw8dVxBK4D82rKqG7qNqbrnbH9Flqzx1HWjGNTSHodus4OAy1e7kjoUiSGkSJY9vnr9yQX7pt3uTCKBdCw0MbZk07EtGsfWaBw/XvAxOhP+fUrVBdxHkoQVCbrOsW1Psqj0PIOxijLfd+02Yfcb5rkRY/EIAJ9v7ciQ0X2Nl37DARkhV+wQAMIBKSMGAIAiwaF7My7XRALO+6dswbTXrdF4hlAhRUJYcb6ppIoSQUXqtc0nhTBswium5IoZucYtFCgs9R5SJIQUf5YhAMyctwIAcPPUcfjF+Ud4PvuzxRT3E8zr98H3Tzs45zM311PQ7ttCCASV3L2iAlDPQkUggiAIgiAIgiCIfYjKykosWbIEN9xwAz799FP8+te/xmeffYabbroJ//znPxGJRMotYkmY27je2JYMRlJFypHYbY3GMbdxQ6/e3721kHsLJymVXC1GPsYYZIlBkYxZu17nG9iv0blwzB72C0+tWPKSzd7+gLCC55ZvykgVsdRMaS+MLZyMNgKykQg0ZyF35ywnUy+F7lbXW0lIO15jq6TGwNSt45DvlJBanuJUNttS9XQyO5/P7EqtIOhp0n7kLUuxfmL3z4AExzlXuc7Q8Usu3wgF5Ay7VmSp4LONCrVlP2sRJIk5krAMIqcddCR1cCEsewwqhZ/PZLe7fBhb1G0omR+7+1sowqPNbJg20ZN+M7dxPdp8rugEMvXrpQv3Vm0mexJO3eeLy85novNaibGMVXbmXXsjzpgYKwCFZ0zJFTNyjVuh8nPrzCB/2GUMKlLeZ7+DbKttbc/vA4ZWFv3MtY+L4sNGelPX+yK0HRxBEARBEARBEMReyFNPPYWnnnrK87Oamho8+OCDeLCHzrUUkkCn2un7+gqlwpXMFujS/G83FZSCCMjp2cdJXeDFpg1QRQwRRQKT0mcTCAhASmc+goqEmM6xYOVmXPvVg62kiZcMSR4DWJaVBiL9z+u4qmNB0xaoPImIIqz7cyGMoocANMEd0zI1AQREBRhLzw5nDAgqScR0jhc//AJXnlKbJ6mjIfOf+VpaFx6yCyEQ17lxdjsDwEOuKzggeScVBQBVwCGbWxcAoPMkXlz5JSC5VnMwZiT6bPowsqohaLpAUDYPhOcAy16kcttaUA4iIDllAFMhBMeLK79EkifAck2JTcngJPs4eMIVAC5dMRVgPpNcAlD1kMMuda5D9bBBzgx/61KTEIilbcsmgxCG/UmSBkBP2ZawbEsXOjShWTbJJBkAgxBBV6LQGAc9JWMQkuW7Dj2YMopAxjjEtTh04dwOTbC4Q8edaifiqo4XVxpbeAVlCbp1HlJKF8xYBeLui9tP3PYQV3W82LTOig9c8JQMKjgX0Jlw1pwEA0TQpaDc9uD2jepwxJLBinUsCTPVLRjLGTMZGCoCFa4+bESSx3LbskNkL5tMAkwAYACTIISAhnRs0mGMi1FgZLDHl6DMEFdVcEmz7KAj2eGwT1XEoAk9qz2oOofGE84YAABMAodRHIBksxXB8GLTJgjBrDNiAB2Q/K0IMnb4s/uFsRozPQ4+cNmD8CmDaRMQQFCEwZjsKIJ3qV3+VpuyuCG/cMa4jkQcL678EjoSjmdL1hZ5ADqXrHsKLjx1oQkgACm1x1k6fnEhgfOALU4DgI4E73LYgGAMO7uieHHll1BFIvVMTrXFAwBSdmdWgVK60AHogkEVIvsSBiFljEMh9mCOg/0Gmi4QDCQcMeW7Jwx3yG/GDA4VgARNdz+XjXiqCAYtl/weMqi6cWYhWCJb7duBKoAXV67DtV892HU+j46OZIct3mQ+/7vUTptvBpEhKEsgobv16Yz1cbXL0ybjqg5NVy3/Zea+qm5ft6HpAQRlyfF7sJDfkgEpgKDsjtUaOOK+23H/Hi1EhjiPQ2aZv9GEJMB4+Vc4URGIIEpEbNUq6O3tAAC5pgaRo44qs0QEQRAEQRAEUR7UI1Sc+9K5vq9/48I3HP9w5oIX9P3LJ1yOyydcbr3eEOWIhv6JimFv2/4xb0ytDcH4M2GMoUIAuzfcidXNUUweMwgAkOTJDBk6kxowKsuZLm2nAzgHALC6uR1tXSqCg5dAGvSedX8zx2jc05UIEQo6v7wVEjO2mGFgAEtAGv0rVAiBPYzh2y8HEJBzZJOqTwaiJznfG/QPnPvSr43/PSpzSy0GpGXhIXSuvdl5gRRH5YG5i4V22X5w9A9wwaEXOD7frixEx7D3UDnUO/ljT+EJHkHX2huNLcmEcag65E5gRHYZzn3pt47X/z3pv/Gtg7/l7MaQRZAGrEIHWFY5LBn0KnSt+2/He0zZg4qxD+f8np3EtnOgRY92vBca/hqUAR/5+r7QahDfcC12d6qWXbZ0tuDV3Tdk2OAuBpz7UsgoMo5OWvpMbD0X2p6vADBmt2tJHZHav0KuMs7rkADLthx2ABiVFW0QutZfAyGM7eQAgAV3omL047bL0okthx5MW9sxDeg6wpHc/sV7v8DbW9529KFtcAIYlH597ku/hapzdAysgdQ+0zHrXgpuR2T0nFSClGX0xe0nd514F6aMnGK9Xt3cjj1V81Ex7HMwxmBuNmXmaivhhCf3Q2zjDMd7UqgFkVFPIR+mPPee+gucWHei8V2zL8OeA8JrARjFlnNf+k3WdsYNHodHz3jU0Yd2fT0qD8wvg0m8+T+gdx3keC9c9xzkSGq1kpcdGG+n9mIbCWxOx1mJMUgVmxCu+5NlB//x998Ao9LFvEVtsqH7UaniwdbpQOIA6/PW9jhCI56FHN6cIa+p3kqbOHpsDHa2XgbGUnVOAHLFeoTr/uJ7HGKbLwOPjwIAa8VFZOSfIIWafX1f7zoQ8ebvON6TK9ciXPucbxl4y/cgayMdOf7rF1+PtW1r8395VAKIHQJs/46jiPTc6jfRMewXqMgT30xiG2eAJ/eDzgUSGocQQGT0k5CCOzyvZ25ddI5DvOXCdJwGgIpP8avV9wKj0kUYAeDbLz+AjmEqKoamC0aVQqBr49UQyWFI2laMVIyeAxbYbX3f7Y92tI7DkWg93/GeMmA1Qvst9DUGANC14RoIdbBDXlb7GJgStWLKBX9T0DFMs+S3xwxtz5EQW89zylD9EULDXzX640eG9ddCaDUOGSrGPgYmd2T/ko1ox0Ssbj7e+WZVE8776/3p1x7P/yv+8Zu0v275IaAPcF4w4nf47b9Vhz4BZ6xPahwYpQIdk4Fd51ixfnVzO5SBTQgOfQMALFutzGGenWt/CC4Cjm0bL/nbJehS/U0KOv+Q83HdxOucb1a/h52D/olzX3JP7PBm4fkLURlwWt0Fr1yApJ5/tXQymcQpA07B1/A1x/vq4SqCH7uLU70PFYEIokRsf+QRxFY0AQAikydh9OOP5/kGQRAEQRAEQRA9QUwzplvbE2S5ji8xcpzCcch1d+hI6BA5759rD31ATx3CbMnHjO+UYJcqD0rRaG7ZRJH3MZJJpZ49W46N3YqncLvM3T8unGtBTNsSHuMshLDsVs165kxP6MjATNBn20FICOdnfv2kI6Hbru9pMuUpxTkwRh9Kbcve7WWLnU7NF2cHCS33yjivewsIYzmCWZzqBuWKBoWdJuaPuFqcTWi6yPl8NMluB/l1b/iAyOpzPfNsKx6zR1ZM4YX9puhNGAN46jnRV2QC0nG2UHrmuU8A+8CZQEIILFiwAKeffjpqa2tRUVGBcePGYebMmVi7NrPCHo1GceONN2LMmDEIhUIYO3YsfvSjH6Gjw7v6yjnHQw89hCOPPBKRSATDhg3Dd77zHc+2TRYtWoRTTz0VAwYMQHV1NU4//XT885//LFmfCYIgCIIgCIIg9mUiirG3md+EiJFyYKgKlWaeZFXIWMlTbELGnRY1t2Lq5nn1WShFo7llY7YVG4W12hMd7l/JpcLtsrD+mbbl9S1/5uvvfsXo0tw9yLcf+/STqlB6i7yeJ1OeUhSfjD6U3z/SQ1icLObZK4XAwNKrk7pJuaKB5Q8lrEQaWyAW3l53h9GPb0upZ0BfKlLkwlo/bMYUqbDfFL2JENmfE/nE7cnumHG2UHrmuU8A+8BKoJtvvhkPPPAAamtr8e1vfxvV1dVYtWoVnnjiCTz77LN45513cMQRRwAAOjs7ceqpp+LDDz/EmWeeie985ztYuXIl7r//fixZsgQNDQ0Ih8OO9mfOnIk5c+ZgwoQJuP7669Hc3IznnnsOr7/+Ot59910ccsghjuufeeYZTJ8+HcOGDcMVV1wBAJg/fz6+/vWv47nnnsOFF17YK+NCEARBEARBEETv8NFHH+GDDz7AhRdeiOrqagBALBbDjTfeiFdeeQWRSAQ333wzZs2aVWZJS0fg4wAWPux/OxbJdaiFxCQsPN//94OSc5uNMdUSqhNfw9Z1JyAiGwfcdya9Z6VWpM4Eqh0QwIS6akebbhkeb1iLPyzNMuHPdibQhLoaDKwIoHXXqZCjUzLuH5IZkrqPueAiBL7hR4jpHPtXh/DX607JeSbQ8T9/K/PN3Wdg4Q9+bnx+zz8ybyEEutQcB7PzcOYWcTYYg0M2ty4AoJZ/C2L719AazdyOJlOgVLuwbZulVwKbbsn6lYU/OcPxOvNMAIDvnAp9x9cxqCqE1mgi9yICr9UH2oCc45B5w8x0S2Lb2Uhsn+rv+8IYg0GVabusrazFOYN+g+eXb3JcOrg6hIXTT8GOPQl847cNaX16ybD1m1DavgkGBs6FZVuqpmNnp2Z1vSooI6FmDoRIDkHn2putNF1FIH1+g10Plq2lzoiwW/vtx9+ecSbQ2b9twK6O9HY7C39yBuKqjnN+9zY6XatpeHKYpYuqoOEP9r64/cRtDxPqajCg4xJsbY0hIhvne3AOJLMudspMSvJEbV57sPtGdTiSft/8H9svhlnylWWGhbd9LaON9HecMkyoq0GNPBatKV34SuZ62EO8+WLrLByFMYQU5ogHjrZd48CFAO8aha61N1t28MwNU3DWbxqsa86aNBKxpIb/93Frqg3n+S3714SR2PIdiALO46mtDkAIhtZoHAyA3jW2aN80C42xzf9Z2JlALvTOA33JYBavKpRwRr3md6f/ztcKIcO3Mp8DF0/4Kh5/XWBrNOHTHgLGahfbW7FNV/oeByYkZ5wGgK7x+NGE83HHS+ltL5nE8NebT8M5v1uKrXsSiMjGmUCdSfNMoNR1MGyta+OMAnSRWUTU9kyA1jnO3/cBhwyWHC2zIGwx5cVZJ2Lao+9Y8nPBETdDmJcM0SOhdYzvlgxd62f5qukxBuw/oAIT6qqxdI1tK7+OSXjpvP+2tsb0ev4/ee3JOO/h1NacGeeeAdhyPW44dzx+tvATh3ALb0/H+sYvd+KGv6yE2yYn1NVAa5sENXoUAON3D2NAXMuuW8YDkFxhav4352e93k3GWYAAED0eQ9hJWHjpyb7aqFAyN/B78bwXfX132bJlnmcCBT7xkKsM7NVFoNbWVvzmN7/BmDFjsGrVKtTUpPdXfPDBB3HjjTfigQcewB//+EcAwH333YcPP/wQt956K375y19a1952222499578eCDD+LHP/6x9f7ixYsxZ84cTJkyBW+88QaCQcNhvvvd7+Ib3/gGrr32WixatMi6fvfu3bjuuuswdOhQNDU1YeTIkQCAW2+9FRMnTsQ111yDqVOnYsAA1x6MRM8gKcBBpztfd4P9b78dPBYzmopE8lxN7I3ITEZ9Xb3jNdG3kCSGUeMHO14TBEEQRE/z85//HG+//TauvPJK673bb78ds2fPRlVVFXbs2IEf/OAHOOigg/D1r3+9jJKWDsZZxp7qBX2fde/7QZnhgklj8MTSdUhqwphtzr2LQEmNISAxTJs40pE49pIhKEUAEXY3kUE4IGPapBFZ789kCQoTObbYMhACSGpBBCSGC44+EEMqqnNe7/1PfCXdDw/ZGYCwzBHPWgiSAO69lz5jQECS8soWkIK4YOJBeGTxl3nkt0ktM9t5M1LOcfdlK8JIeF4w8SA8sXQd1DzbUGWSfRx8IwIFTb0OKJLDLmVJRsDDBiURQmWgEl0BBQwRKEzPblsiAAg5ZVvcsq3nV2yCwpLW9wSXAcGRKbAxDrJkJPQYZOsShx5y6CuseNihCDuSqZWBSlQGgAsmHmjoS7fry6YLoUAI4ehLPj8JB2RcMOkAyz9lltp3riCTyG0PuXxDMu3annQVhcU8ow+ji7RlGyKYVrHEwCBDgQ41VXWTJSBb86ouIEkKJKZYdhBWKhy6D7AIVKZltYeALEGRQnljoZ0LJo2CgLD1XQa4v397S8ypZsYYFIlB5cGCfNOOUbzIL4NpE8ZWobL1XZOKgJ/TY5B1LKtCYVww8SDMXrIWms/91TKOmBP+x0GSGCTJeS4YICMsO22ACYYhFdVW7E1qAkGFAdxpWIrMDDsoQAZv/NuDF4rMAB5yxJS6mkEO+WUmHIYkMfeWdsXLYJ6/puohX+MQUCRcMPEAjwkiMiqUSgTN1XYedhMJVOSM1RAhhNz6hDPWh+WY43NztVQ4IEORA1B143eJYAxMytS7Hedz36A7vwVTrUJCuFvt+P1uWPIeS8b7Rt6ppNvBJRI+ZvX0IuvXrwfnHCeddJKjAAQA3/zmNwEA27dvB2DMfpozZw6qqqpw5513Oq698847UVVVhTlz5jjef+KJJwAAd999t1UAAoCzzz4bp512Gl5//XVs3LjRev/5559HW1sbrrvuOqsABAAjR47Etddeix07duCll14qQc8JXwQiwPmPpf8C3SvcBMeORXj8eITHj0dw7NjSyEj0K8JKGPecfI/15/WPG6K8KEEZZ1xxuPWnBKlQRxAEQfQ877//Pk4//XTrH7aapuHJJ5/Ecccdh23btmHdunUYNmwYfvvb3+ZpiSiEy+vHYv9q4/dYvnMnamvCuPiYkVixYReWfL4dKzbsSp2v0HP3V/JsA8Stw7oFBlUEMGZIBf703ga88UlrSeSzE1ZkDK4s/NBiiTHU1oRxWf2YnNcJAUwcNdB3uwywZi+n2xDQuYDGOXQuILLsyxNXdYceeep6nRtJukuOHYX9q8M9tLVeafEztoCxImPFhl1458sd0LmAIuXeUMe0Lfc9ArJkfc+0vWwMqQxm6Mg+9m4dFbvFj92P/PQlmx+77cK0AwBQeem3hmMABlUEcMh+VZn+yvzbcy4uOXYUBlX4n2HOXP91I4SAqhnyWO/l0JsQAgOChs0kNR1JjeP9dbsy+mLVvISApnPr2ne+3AFV5w6789OHy+rHWHbR3d3UEqruu2CSTZ5CZB8YCUBirCh9A4Yd61xA1Y0x3Ly7y2Ffl9ePRU3Ev01wgdR5N4VTE1YyYoAdu43bfU4ASKiZz0S5j8RkRWKe8dH0Ny4E3OKXUnQpVZj026ZdRtOuzLFvWLOt5L8X3ORavWb3bY0L8Bx2z2CMvd1m7HK7Y3hP9mlvpaQrgerq6nDppZdixowZOPLII0vZdFEccsghCAaDWLZsGaLRqLX1AgD87W9/AwB87WvGcts1a9agubkZU6dORWWls8JXWVmJk046CYsWLcKmTZswatQoAMBbb71lfeZm6tSpeOutt7BkyRJMnz7duh4AzjzzTM/r77rrLixZsgSXXXZZzn7V19d7vv/xxx9j9OjRaGho8Py8p4lGo5C4QHjnv8ty/3w0NKwvtwh9lmg0CgBlsx2iOEhv/RfSXf+E9NZ/Id31T7qjN/dv/3Kzfft2698QAPDBBx8gGo1i1qxZCIfDqKurw7e+9S38/e9/L6OUex/Dq8OYPX0yZs5bgdZoPOvJ0/vVhFB/4BBc8vi7aOtSjVnaYBhYEcC0SSNwef1YDM+RhC7m/knNWHWjyMzY9ovBMRNe1TmSIr3Nzo49CfzohX9ZnysSw5CqIC6cPLJo+Uy4EIhrPD1b2CeKxDBiUASzp0/Oen8uBFSd48NNbbju2Q99tSsxIKTI1moJsw3NtX0egzF+ZhJyazSOuY3rsaBpC9q6VHDBoXNkJHgvmf0uphw6FG+vEdi6Jw6tgBUI3aUmoqA9pvm6NiiznGMLpMdm464YLp3zPrgwCiIMxgx/nXtPJI9rRuK9tiZs3YOBQWIM4YCMuKpDkhi0LNv2MAA3nHEo7vn7pw45Tr//LcuH4ip36MjPNldemH50+R/fx7Y9mROPY5qOgCxh2ICgpx8PCAzUlYwAAQAASURBVCsYNTiCzbtjiMY0h38bdrATW6OxjKRudzAOlGdo61Jx64v/csSTbxxRi0Uft6IrqTtGJK4Bv1r0mS9/dtu6n5ENmHpIXRxX9Yzv6QLQUyuuTN3lWqHDBdAWtydiBb7/pyYARnwwY0pXUkdc1VwrigT+84n3EFAkcG6slkxoObalTMkUDsgYXh3G1mgc9QcNxgvLu3z03imzHVOmQo8YMmUBgAFhBbs6E1lXTJkIAbTFVCQ1jiSM8dVyrIqwY+r8+eWbEbOS3wJL1+xE45fvYkhVEGcfsT8AhqTu35iLrX8xGEWRee9uzPisPZZEQtMdMfvSOe9jQFjBkKogIAS8zCqRY5uw3sQdHwUM30w/WzK/U8rHiJ8YbsIAx3Nid5dz7K/900owZsSfRCpWSt2snLpX6uSqZzqeKYxBzaFjWWKOFcmXznkfAysCmDphPwAMi1a3lvQ32r5ISVcCDRgwAA899BCOPvpo1NfX449//CO6ugoLyKVkyJAh+OUvf4mNGzfisMMOwzXXXINbb70VZ511Fm699VZ8//vfx7XXXgvAKAIByDjDx8R837yus7MTLS0tOOCAAyDLmTPJ3dfnu4fX9QRBEARBEARB9H8URXHsmvDWW2+BMYbTT09vTTxkyBDs2LHD6+tENxhfW40XZtXj6lMOzJhVa8w6BSAYFqzcgtZoHEnNKDYkNY7WaBxPLF2HCx9rxKctRlGy0Nnb2e6vpBJMs6YchFeuPQkzpxzk+FxmqW16hJGkcyeYNG6c+/B4w1qHfIWic4FYUkdM5Yj6LE4Axth98yu1eH5mPQ7b37vgarat6gJJnSPpc8sq+xDb23CPvIBROIsldfz9Xy246LFGPLF0HVqjcSRUHQlNeM7wb43G8dLKZgDAhZNGIlvta1hVEIfX+tuqfXBlEAcPy75djCIxVARl/PY/JuLKE8fmbMtYBcUwdmhl1rEFnGOjc8Nmzf4KGMltkbq32/b3rw7j6lMO9NSfLDFEgjKuPuVAYxtDD9kiQRkjB0cy5LD7kCmHqaM9cTVnv3MxvrYad5wzHgE5sy+1NWFMmzjC048Tqo5texJYsaENW6MJKzlq+rdpByeNUDDAtRDOjA9KEUvGBIzVFZouHPeb3bAW33pkGd76fHumPQtkxBsvPm2JOmxd0wVklnslQkiRMHPKQTj+gMGQJWbpOFfd19RdsWgpu1i/sxOvr271LJAIwLLbhMYRUiRPHdvtTpaYNQYvrWwuWfLdTzNG4UdyyCJLDDNOPgAVwfxz7BlLr7oxx/fzrR1547fZ39kNaz0Loebz4Kl3NuCpd9ZjT9x/LC8Uuy7280i861zg/kWfZ8Rs0xc/bdmTVWdSyt8iAW87MO+fjQOHVOSNr36orUnHRyHg6W+FUpHyN78rfPLFcLsezBj+aUs0Y+w1no4/ZizWi638mbK5fgfla82MN6ccMhSDKpyB1oyzLCWrva2kxtHSHrfsurU9/280IjclXQm0bt06vP7665gzZw4WLlyIq666Cj/84Q/xne98BzNmzMAxxxxTytv54oc//CFGjBiBGTNm4LHHHrPeP/nkk/Hd734XimIMQXt7OwBkbBtnYs4kNK8r9Pp83/G6PhuNjY2e75srhKZMmZK3jZ6goaEBOzoSiA8p4AC2XmTK8aPLLUKfxZxhWy7bIYqD9NZ/Id31T0hv/RfSXf+kO3rrS6uAAGDs2LFYvHix9fr555/HAQccgDFj0ts8bdmyBUOGDCmHeHs9w6vDuHnqODy5bB24gDWLFKnVClujcQBARJEd5wVybhQvmttimDlvBV6Y5b0jQzH3/9HUcfjP48dYM8kPr6uxPueCIyjL6ExqeY8oUXWBLSn5np95QkFycSEcqwECCkMyxyxdRQJkyZhFLDHg4mNHZZ19uzUad7QtMSAUkNCVzL99i4CxSiEUkJDIek6R8/rr/7ISAkYiKSRLObf/CysSVF1gazSOd77cibFDK7FldxxccAhhnHMjMYYXrjkR0//wfl55ASPB9+NvjMf1z66Ebm15Y4yTcXaOYVeDKoL46XkT8NzyTdZ1IrUSjDFmjS1jLOc2S27dAUAkKIMLkTHGOhcIByQAzLL91/77FAysyL79n8QYbp46Dv/a3IYP1u+2vmfKlk0Ouw91JNKJaAFg5cZ2bIvGi56xXVMRREiREZSFw4+fveoETP/D+xl+zIWR8LQjhGGHjDHLv7dG41CTwIWHhvCXf2sZfeVCQE9mrprJh4BRMLC2AdU54nkKoZwLR7xxj9XWaBwz561Ac1vM0VcT+5gDxmoyWZJw8sFDcfPUcbjmmRWOz90LRmSJIagwxJP5/c4PAsCbn23zfW1C44gEZQRlOHRstzsuhGMMKgIyunppW6hhA4L4ysiBeHftLus9LgTmvL3OX2xL2Z9muzap8az6BtI637K7q6SrTYohpEhGQSKlC7c4ZjxIaJlj4b7Wa+WVEEYbQUVCSJEyfN20A3OrM3ecPe7AIVZ8NZ+lnMM638pvH9+86TSEA3JOf1M1DQlXNyuC6RWssaTm0Ndphw5Dw5odqX4a8ueLByZeMdwdi01Zd3Y6i4ShgAQGI951pWJ1XNURSclaim0w/UyOkRjD1An7Y9qkkbjlhX9l/A7zaiEUkBCzxV53TPX6jUYrgnJT0pVAjDFMnToVzz//PDZv3oz77rsPI0aMwOOPP47jjz8eEydOxKOPPmpt7dAb/OxnP8Oll16K22+/HZs2bcKePXuwdOlSxONxnHbaaXjllVd6TRaij6GrwOevp//04mcmAYBQVYhk0vhTu9cW0T9RuYqGzQ3Wn8rJDvoaus6x/qMd1p9ewFJ5giAIgiiW6dOnY9WqVTj++OMxZcoUrFq1Ct/97ncd1/zrX//KuisBURoYM2ZtK5IEWWKOWachRXIkUwHj0GtzJURrNI65jRu6lTCx3/+Q4QMyDnE2P+cCRrLG5724MFZgzH13Q0HyqLoz8ZJvixizMGEvamRjbuN659ZtjEEt4HeXuULA73CbZw2EFAm6yL3xmJbaegow9NrWpUKWGAKyjKAiWX18bvkmYxs/H2zbk8BrH7cah8zLEoKK0ZYiS55jZb8uFJARVOSMsc01xG7d5bpWpPpst/3MA8S9MVc6mN9z9yXDhnKsmkloOuY2FmajdsxEo9uP7Xqy+7FbNiBlVyk7tPv3rrjA6h26Z1+92vGLfVsu3YdDu+ONm7mN6z37auK2A4G0Dt149YsBGdsu9ibG6hieoWO73ak6zzkGPUlCExljqeocuzqTvr5vtz872fQNpHXezcUbJYEL4dCF26Rz+YqXL7phjFk2YL72soNscdYUzfxeQJatpUO5rCRgn/whhBUfc/mbV/3G/oxz2+W6HZ2OfvqJByZeMdwdi+2yemGXxz7GxZDv+Z+tZ4zBes55/Q5z42VPSdcY54uZhJOSFoHsDB06FDfddBM++eQTLF26FJdffjm++OILXHvttairq8OVV16J99/3N6umWP7xj3/gpz/9Ka699lrcdtttGDlyJKqqqnDyySdj4cKFCAQCuOmmmwCkV+dkW4ljFq7M6wq9Pt93vK4nehgtDrxyXfpP8/cDPxubfvADfF5/Ij6vPxGbfvCDEglJ9CeSehJ3vXOX9ZfU/f0YJHoPXeVY/Mxn1p9eys2/CYIgCCIL1157LS666CIsX74cb7/9Ns4++2zcfvvt1uerV6/GqlWr8NWvfrWMUu5bGAeUG+mFoC1Rn3mgOUNQlqDqHAtWbu5W4qQQuQrZrkUII1nyUtMW39vV2fsP+DvUWtP9HV4fV3UsaNqS835+KDTpKVIzxvPdR9MFwGDpta1LzdzeRggsaNriW9+qzvHWv7cVfdh7IWg69+xjrtS9X90VQkLNLoeXLFwAC1ZuLvowby/p7Xqy+zEX3rIBZpEjXVAKyhJ0Dny6S/O0g+6cGWXey2877njjPhTdq69AWvduP3br3fxKNnm6299SkMtWTfm8xqA36Ehojthsj9fBHCv37LjHlwGe+gbSOve7lWZP49aNvSd221GK2S8Nxso1r/v4x31WTVqmXKZityNNN1YzZfM3AWGcN+chXi65N+zqsj4rxs9ytW2XNWPss9zGbK+YUS50O7hsAuUbB6/PMmNa9phJZNJjRSA7AwYMQEVFBRRFMZa96Tqefvpp1NfX45xzzsG2bf6WhxbKa6+9BgCOvbZN9t9/fxx22GH44osv0NHRkfdMHvd5PpWVlaitrcW6deug65lG5nX+T6575DuTiCAIgiAIgiCI/kkoFML8+fOxe/dutLe3429/+xvC4fSWFfvttx9WrlyJ66+/voxS7lsYW8wYmDNkkxpHZ1K3Hbqd/lwCw+5OFds9zmPoKbkKSawwALuzHFid7z5+EfBXmFnd3I62LueK+ELu1520rqbnv48AwHlar7oQGf3iAmjrUiH5lEYCw564VtLZ+tlyoDs6kp7bKHUm9KxbUvnVndf3srFhZ2fG56rO0ZnQM7ZhM9ndqWJ1c+l2hrHryfRjjXN05djOTACORL4kGSsIYlrmGBXjJ+57xVVeUDv2eGMfK9Ov7H0FgFhSR2dC91xhkk3v2eTRu9nfUpDLVk257WPQ3fNNCoFz4TjbypSHsdyr4OxkrL5i8NQ3YNd5+fUCZOrGnox3PFOLLM6ZY1hsvHJjl8lvwVAAWN0c9fQ3nQt0JXR0Jb2LcgJAV1JPbVPnJKFxq0+lfv46ZHX1szPLGUClGuPukG8cPAv/yOxTtphJZNJjRaCOjg48/vjjOO644zBx4kT8/ve/x6GHHoo//OEP2LVrF95//31ceOGFeO211zBz5swekSGZNGbhb9++3fPz7du3Q5IkBAIBHHLIIairq8OyZcvQ2dnpuK6zsxPLli3DAQccgFGjRlnvn3rqqdZnbhYtWgTAuYf5qaeeCgB4/fXXs15vXkP0AkwC9j8y/cd6pSZKEARBEARB7APccsstGWd5VldXY8CAzIPmhw4diqOOOop2BehFvOa/mklUnQto3JnkYcz4Tq6zZgohWz4q24x+P2RbgZHrPsXcIx8dCb3o9rtLof1nqYMp3N8zx9JvLtOwj+LHtRCKXY2WTzavvuaajO8ulgKw/MMruchSMrjPrfGNR5teeor7WOnvOfs8ix10l/TZJf4x4419rEy/svdV49zaVirbahF7H0wxyrfhmz+yyefw2xS9PfNfs68E6ka8tuOlb8AWS3t3wVNOvOzJ/X6p79PbbXQkNE9/i2v5zwYTABJeNmmLL6V+/jpk9bgk7nFGk9leMSuuMgpqBTRRKptx9ymbDxFOSp71fvfdd/G9730PdXV1mDVrFj777DNcffXVaGpqwnvvvYcrr7wSkUgExxxzDObPn4///M//xJtvvllqMQAAJ510EgDggQceyNiC7bHHHsPmzZtRX1+PUCgExhhmzJiBjo4O3H333Y5r7777bnR0dOCqq65yvH/11VcDAO68806r4AQYK5DeeustnHnmmY7DXi+++GLU1NTgoYcewubNm633N2/ejIcffhhDhw7F+eefX5rOE/kJVgKXvpD+C1Z2q7mB3/42hn7/+xj6/e9j4Le/XRoZCYIgCIIgiH7JAw88gJNPPhn7778/rrrqKvztb39DItGzq0gI/7A8WTV3XkQI4ztBpWcnjplyFZMaYan/K+Q+xdwjH1Uhuej2u0uh/U+dK57xPXMs/ebHRCpP2xv9DvjcdsqNXbZS7Azn91wh654pGapCSlH380oYFqonqy2v67PYQTkw4419rEy/ciRRffTbqw/l6pdfssnn8NsUvV3OUmwrfroTr+146RuwxdI+VLNzxBGbYKW2qWLac9cmipWpKqQU7W8APLeKs8eXUj9/vWS1k+39nooDfgtL3bl/tt9oxT5f9hVKOjpHHnkkPvnkEwghMHHiRMycORPf/e53UVVVlfU7EyZMwJ/+9KdSimFx0UUX4dFHH0VDQwMOPfRQnHfeeRg4cCCamprw5ptvIhKJ4IEHHrCuv+WWW/Dyyy/j3nvvxcqVKzFp0iQ0NTXh9ddfx7HHHosbbrjB0f7pp5+OGTNmYM6cOZg0aRLOOecctLS0YP78+Rg8eDAeeughx/WDBg3Cww8/jOnTp2PSpEm45JJLAADz58/Hzp07MX/+fM+ZgUT/oPob3yi3CARBEARBEEQfoaWlBa+88gpefvll/PnPf8Yf//hHVFRU4Mwzz8S3vvUtnHPOORgyZEi5xdxnkZi5MsHY4ifXVj6cC3AIDKoMYFhVqKj7+U2K2OXKMqnXu30AgyoCaI+pea9138cvLPW9fEyoq8HAigBi7aU7+8Uvigxk2YnMggGQpLReZcYy+iUxoDoSyHnQth0OgQHhQNZt0Ioh2yqkoVXBHtNdIYwZUlmwHIMqA5hQV13U/bxcyK6nfH5sxz62nAsIAUQCgHstTTF+4kUh7djjjX2sTL+y9zVfe269m/0uVb96gly2asrNIQrSd6mQJIYB4UCGPEIYeisGIQDBMvUNpHXe0q73CX25dWP3SccztcgqszmGpYpXdpn8FyZg6cHtb90hKEtWn0r9/HXEBp+Nmu35KiTnWRJbyIoe+5WlikPZYiaRSUmnMa1duxZXXnkl3nvvPaxYsQJXX311zgIQAPznf/4nFi9eXEoxLGRZxuuvv47/+7//w4gRI/DnP/8Zv/nNb/Dvf/8bl156KVasWIHjjjvOur6yshJLlizBDTfcgE8//RS//vWv8dlnn+Gmm27CP//5T0QikYx7zJ49G7/97W8BAL/97W/x97//Heeffz7ef/99HHrooRnXX3rppXjttddw2GGH4cknn8RTTz2Fww8/HK+//jouuuiiHhkHgiAIgiAIgiB6l2HDhuF73/seXnnlFezYsQMvvPACLrjgAjQ0NOCKK65AbW0tTjvtNPzmN7/B2rVryy3uPgdjzDpAOanznAeRJ3WOgCxh2sSRUIpcheE3J2bKJReQcGLMWB3y7YkjfJ97YO8/4C8Jo8jMV/vhgIxpk0b4kiMXhebcmMdKDi8U2ZhZb+q1piKQ0S/GGKZNGuF71U1AlnDauOG9clC9IksFH7zu1l0ptloKyKwgOSQGTJs4suAVRCZePmTXUy4/zt6m4d+yBIwfrHjaQbGH3Lsa8tWOO97Yx8r0q0L6ms1nS9avHiBXnDHlLlbf3aUqJDtisz1ee53J5AcBeOobSOu8p1eg+iUzjqSx25Tndos+SKa+5/dZ48b9DbtMuUzFbkeKzBAOyEX5Wy5GD66w+lSM/+UaE7usms8qULFj7EWxQ1OKOJQrZhKZlHQlUEtLC6qrC6u6jRo1ynHOTqkJhUK47bbbcNttt/m6vqamBg8++CAefPBBX9dLkoTrr7++oENczzrrLJx11lm+rycIgiAIgiAIov8SiURw/vnn4/zzzwfnHG+//Tb++te/4pVXXsGNN96Im266CYcffjjOP/98nHfeeTjmmGPKLfI+QUCWoOnGyg2vs344F1Zir7YmjMvqx+DP72/M225c1bG6uR0dCR1VIRkT6moK2sIrIEsIyBI64qr3tjIuGID9qkO49PjRmNu4oaD7aHr6jAM1x3lHDM5tyIQQ+HzrHqi6sPoIAE0bd+GT5j2OLZOKgQEIKRLiKvdVrjATs37ObFIkZl1XWxNGQGJoScZTh1QLc4MxTBw1EAMjAWzbk38bx9qaML5xZC3+38etAIzxMc+CESJVoGIMn7ZEMW5/f7t/5EqsKRKDpvsr5bh1l/++AlwAb3yyFc1tMag6h8SMMRHW/2dIajzDhnIRCsi4rH5Mxvumv8RSh31LzHvmuTmb364niQGX14/FwlUtaG6LFXRml92/B4cZjhqu4JPdmedJFNLHbKgaR/51O8ZYCABDKoK4+JiRGZ+7+5pxNIfrFhJj0HSOnR0JLPl8O3Z3Jq1ktswY1LKvLXHix1YDsoShVaGC9d1dGIAq2yoguzxVIQW7OpOZX/LJwEgAR4+qQVzVM5LYps637O7y9TzoKbx047Y3+zO1u/fx8nXPuGCLtZ+1RvHOlzug6zp0YcQqP0cq6baOSIzhjU+2YtueOMYOqcSgigB2dCQLtjV3IawmomDzbmH1oZC44jUmghvxXwD403sb8O2jR2DhqhZs3t3l2YZ9pVo+P3OPfbbzxkwSKofOhXV9e1cS63d2oiPhjOlekzTyjUOulUJJzWgfAGprIp7PF8JJSYtAlZWViEajqKqqgiRlGhTnHB0dHaisrIQsU3WOKDO6BrSsSr+uPQqQaf9IgiAIgiAIoueQJAlTpkzBlClT8MADD2D16tX461//ipdffhn33HMP7rnnHtTV1WHTpk3lFnWvR2LGjN9hA0LGtl+2JImZHA7IEmprwpg9fTKGV4dztseFwK8WfYYFTVvQ1qVaCZGBFQF8e+IIcCEg+Zh5KzGG846qw5LPt6O5PZZ3VrUQQDzJMe/djb7vwYWAqjsLLNluw2DMNJYYs76n6QK/+PtnxmodATDJSHqpJchSSgwIKcaM+3CAWYnxXFSHFOhCIObjkPh4qnhRWxPGL84/Atc/+yG6kpn3mPVMU9Yt2dzUH2hs7ciFQFLT4Z0zE/jJSx/jwX98joSmIyBLvnRlZ2s0jvfX7UJM9ZeQtOsuH5wLJDTd0uFVc5fnvP62BR9B1TlCioSElr9YN7jCmUDfGo1jbuN6y19MPTMYs9S3ReOWz22NxrGgaXOGnhiApxvX4/+mHYEfL/g4w4+zoXOBmNAtO7h6PLAj5v09M074scNs+J2db7pPW5eKSx5/F9MmjcDl9WOtcRhebcSimfNWoDUaz0jOuu9iJq4/2LAb33vqg1SitnepjiiIxvIf1u7XViXGHGOQTd8MQFCRkPRhm35l8ypuS4zh+q8dgscb1mLjLu8EfD7aYique/ZDDKwIeOr8F9OOwPefaUI0Xp5D77Ppxr3tm+krVSEF2zsKPwOxbmAY26MJ6xnj9nVzFZj5LHLH2hUb2vDdJ95LvXLK5jfSJjTuiH1yasu0QsuNbpt7f/1uAEYBX5GZb180J0R4jYnJT176GBIDxu0/ANXhANo8toWNabrVXjY/sz/f7ff5+aufeD6zzBj+5/c2Op69ZzzYAIkZK+QSGrd0F42pqAo7c6754muuMTJXjsks/QwmclPSNYX/+7//i+HDh2Pnzp2en+/cuRP77bcf7rnnnlLeliCKQ4sBf/lu+k+LlVsigiAIgiAIYh9jwoQJ+MlPfoL3338fmzZtwsMPP4wjjjii3GLtM8gSwwuz6nH1KQc6kkSKxIzk8CkH4vmZ9Thsf2PHi2yrM3QuEEvqeGLpOis5q+kCSY2jNRrHH5aus1Y6+GFoVQgvzKrHrCkHYWAkc/a5ibHCBNjRmcAf3vZ3D1NWvwWbkCJBlpjjewKApnOoGkdc44glebcLQMbsZIaacMBa2SNLDJGgjECeLWPa4ipiqo6Ij61gTL3+4nyjcLCrM+mZaNK4/6LWgpVb8KPnV6Erma0AZKALga3RBFRdFGQPAPBpSxQXPdaIVZvafH/H1J0btx1/2hLFjo5EQTrc3ZmEqgskNKMQlG/Hqpb2OC58rBGftkStvtj9xbyzAKDqIuPaNz7ZmqEnAeCJpevw4wUf4/+mHZnhx+YquWPGDHK8LzGnf4+qzm83fkZmQFhBRQm2I1J1I248sXSdNQ4m42urrZg1IOx/EqtWQAHIHLfJowfmTJ77SSjmKwAFZAYl5ed+t8G0j0HGFmCpNo24IVnxI18/hlYFPT+TGfLKNnpwBV6YVe95n5DMcMyYQQjlcBDO088Kt84/bYni9gUf+ypwA/6LHYVQSGSXJYZbzhqXNx64CcgMd55zOBIat54xbhnMuKnqPG+sdZOrD8Ecq2L0VAGoVMVTjQvEVX/Py4DMrCK715jY4QL4tGUP2mMqZJZpB7U1Ycsv7LZsPgvcz3c77V1qxjPLHsPbupxFJy6MfppFaFN3v1/yJTZ7FErtz/li7FcXwItNmzNiJZFJSYtAf/vb3/C1r30Nw4YN8/x82LBhOOOMM/Dyyy+X8rYE0SfYdv/92Hj11dh49dXYdv/95RaHIAiCIAiC6OMIIbBmzRpr1U9dXR2uueYavPbaa2WWbN9ieHUYN08dh4qgjEhARjgg4ZpTD8KbN52Gm6eO87UCyJzFyrlARJERCRpnCkSCMiKKDF0YiZW4qvs6NFtAWHLdc/6RCLsyajIDKkMyKoMKKoKK73vYZfVLQuPQOM/4XlBm3dqeKBKQrPGOBGRUBGWEFBnMlWyVmDH7O1dyKKLIEALoShqJ0pAipdtN/TcgAUEZePOm0zC9fgx+vOBjNLfFSpLc03WOnQVuB5VPV/aJ2lujccyctwJbdncVrLt89ma2XagurbM2YKyuynckihBAc1sM33v6A8x4ejma22IOf3FPTM+4NptNc4Hmthh+vOAjXFY/xuHHwweEsORHp+OFa050vH/CQUMK9m8/dMY1dPm8Nvc9jcS02beZ81ZgWzRufW7Ghu+dfAAiARkhpbjkaTYGVgSw5EenY/7Mese42f0pHJBwxzcP7/Z9K4Mygkrhq+K84rY9jpjtSYwhpMiO60IyQ1BmCMgMQVlC0/98HfNn1qPS1VZIBgIy8somUvK47xMJyDjx4KF44ZoTUX/gkIw4bsgHx7PCrvPVW9oxc94KI04JeH7fhAEIK342HUwTkrMXjWQGRGz38/vsMmUpdKc+mQE/+9sneeUX8LftZy6CMkM4ICGsGM+V3txWsBDMlTSF6FTAKIqEFOawwzdvOs3hF3by/S4I2GO9qkPj3LJLzgUUn3Xvtq4kHl+61tOOTD8NB6SMQr4fVF1gi0esJJyUtAi0du1aHHbYYTmvGTduHNatW1fK2xJEnyD++eeIrWhCbEUT4p9/Xm5xCIIgCIIgiD7CggULcNlll2H37t3We+vXr8dXvvIVHHbYYRg7diz+4z/+A3o399InugdLbV+iSBLGDq30PGDYK0li31YtpEiQ3EUMiSGkpJMoqs4998Z33Md2o6AiOc4sMNu0t+F1Dy/cW8D5QQCeWyr53eIqGxoX1njLUu5DqvPJbfQ/nd7gQljtSqn/ylI64Tq3cb2xlRRKM3O+0AS2SS5d2VVuylvokGdr396MfSwKatslSz7RzCFqbY+jtd24n5e/2LFfm201mKn31mgccxs3OPxYkSXLj+3vD64M+j5AvBCfKWUq2dxqD0j3zY2c6pNxfkdp7x0OyMb2fLZxs/uTIkn4rDXa7fvuSehZfcAPbvmyxRH7dQFFRlAxikVBRcLAimCWtrovj7nqQpJYRhx3Y49jrdE4/ueV1ZZvhjyeA3YE0ttj+UXl2e1Gkhhk+zlwyIwlIos8b/57W0FyAEBcE9gWLXwLuWLQuPF8MCdO9PYWiX7pzlaGSd35fM0W7wQyt4Z1Y3++CQDxpO6wy0KeS21dak5/d69YLKT/XIissZIwKOkBKKqqep4FZIcxhnicqnIEQex9hOUwHv/6447XRN9CCco477+PdrwmCIIgiJ7m0UcfxdatWzFo0CDrvR/+8IdYvXo1vvrVr2Lnzp14/vnn8bWvfQ1XXXVVGSUlTPwm/4QQjjN7ciUgTcxt4nK2a/vf5tZy+XDfIygLx3txVffVjhdeSZ7uTp72ktEL9xhngzFjVr/G9Zxtx1UdC5q2QNU5IoqMGO9+8VXtRkEs3ziY8uazmWLa707bhRYBGWMISAwxzUi7RhQpp+7d1xp3y7ynqfeYpmPByv/P3p3HSVHc/QP/VHX3zOzBLsu9y6kIiogHaBQPUKNgNNGgiTdi4hV/MRivYFQUvIIa4xOvqPBEg3kSTbwxKiSRK4gHh0ZREZRDWA7l2GWPmenuqt8fPT0799lzf995EZmZnu7qqurqob5dVVsgZde5xuukTlWqdS8X7OwNPbdrTj4grDPXlDInaez0m/DqZsIp0KSUePvz9Dv7IwkhIYCU2oJSZor02rEO3cTqzXsgYY10BJD0++k2Q+luH9mWxLq8pJRYtu6b9HYckE0wMB1CAqaZ+f0wX7J5zkJIQAiRtI/el8HvAlMCInD/BJB0FKhN4Sx4rFjXe7ZtmZRWHbLbShLN0ZFABxxwAN5+++2E27z99tvYb7/9nDwsIUXBM3w4qsaMRtWY0fAMH17o5JACULiCAxoOCP5ROAUYig3nDD2baoN/Ej15SAghhDjl008/xXe+853g63379uEf//gHzjvvPPzrX//C+++/jxEjRuCPf/xjAVNJUhLR6xXrCXxTSLT7DLT7jZjTnkgAm3a1JzlM1/c2746eAkwIJD1GZAfSmuaWonriOVYagejFxtMZ5WD/tou3b8DKh70dOjhYUfwWTJRWIDS9zu3frl/Z7jttYZ1+1t91U6DNZ0R3KEdumyCPOGfgYNjTroeda7KRF3EPF+D0CJt0GUKGndua5vD1LoSQYWl0qjYLCaxpbo27Bpq9zT5v4vV+UsKSXwP5kGpViRf4SKbNa8SsS0ICPiM8EG2VufUZC7wudF0Eossp3vm0+TIMrOexOU40CqpcpBLb/2JHW0b5EFovU8WZNbou/r0/+zJhQMy2klgcvdefffbZ+PDDD3H77bdHTWVgmiamT5+ODz/8ED/+8Y+dPCwhRaHPjTdi0FNPYdBTT6HPjTcWOjmEEEIIIaRI7N69G/369Qu+/s9//gPDMHDBBRcAADRNw6mnnoovv/yyUEkkGYq1VLPXsObWlzL+WgPJFvkO7VOMtR5JcBqbBMeITFvGHXM5lMpS9akvZ5/a99p8JiRkRlM95Uqic7TTm00HabK8yFfna2g67L+nUn9TqQNW56IM2zbbgQWZ1j2n2O2AfW5tvvCgi9UOOJ9GCViBuQT7durIdtUrdF7nmiHiV0bdlNGBJBb2n6LJn9B0xH4AoVhSmlhppDI7qZxjuz+z3wXZ1stY33OqTGK1lcTi6HRwN9xwA5577jncc889eO6553DSSSehf//+2Lp1KxYuXIgvv/wSI0aMwI3UQU4IIYQQQgipEHV1ddi1a1fw9cKFC8E5xwknnBB8T9M0tLcnHh1Cik+stX1C+8XMOI/JViVZjyS0MyTZtvGOEZm2WnfxjVJPZTn7TJe8j/e9WrcCBpb1VGFOSnSOdnqz6R+L3L+9Kyf2nWk6kpVr5LbJOgiljLXP7E4s07rnFDtQaZ9brTu8C0/EPGcHjgug1q0mHB3DAqWSra5RTIWOyqZ2LrGCx6l8M9HUevY+WOQbKKb8sYSmI1b9YEWT0sSsVBbPPSAXUimJ6gynx8+0Xib6nlM1J1ZbSSyO5kptbS2WLFmCq6++Gi+//DLWr18f/Ixzjh/96Ed4/PHHUVtb6+RhCSGEEEIIIaRoHXTQQZg3bx7uvvtuKIqCv/zlLxgzZkzYGkGbNm1C3759C5hKkgnOkHZXEgMwpFdNwm1CO9cG9ajO6BiRfY4jm+qLqtsrVhpjSSePRSAglmjfI5vq0b1aw/ZWb3D7QkqWD3Z6t7Vk/sR2srzIdN9pC+s1jur2TrJtfNa6MhINNRpaOvTg+/ECpEkPF5DJ9e0klbOwcxvZVBf2uRAyLI1OpZMzRB0r1jbVbhW+Nn92B5OptwWFlk3cuMatptWOCVh5ItFVzoUWWU6xzoUzK7jc4s2gTcnjhaZxa6Rg4e8AuaOmMPfXAb1rMmrjMqmXQsqE17sT7a0EYraVxOL41K+9e/fGCy+8gObmZsybNw9//vOf8frrr6O5uRnPP/88evbs6fQhCSGkKHToHfjJWz8J/unQOwqdJBJB95l4+cFVwT96EU6LQgghpPxMnToVzc3NGDBgAAYNGoRt27bh6quvDtvm3XffxWGHHVagFJJI8Z5IjV62hEFVQp+Mjt19Efq+qjC4kvTOhO7FpfKwY8T9TsQxIhdd9mgKtBT2E0suOiBjpRGI7miNzON4pJTwB+b/irdvwMqHs0f3h6bw4PbZ0rLIoERpBbrS61J5Rs9Jx9q/nceh+057v2mes5QSeqDTUGEs9hRYIVLd1i53TeE4+4gBYecaLwaU6iiwVOteLtjZG3punohRgULKnKSx2qVGHSsSYwzjh/XO+lics6TXQD5kNTAwhe8qPL12zKVyHDGoIaydUpJcpuk2Q+luH1VOMTKNMYbjM6wXarITdAhngKIoBbu2U5XNfZczazBGMm4t/XxQGMLrZYpfN4UMXgexrvds2zIWSFestpJYcnaF9e3bF2eccQYuvPBCnH766ejTp0+uDkUIIUVBQmJT66bgn0qYZ7bUSCmxd2dH8E8xTQNCCCGkfJ1zzjl47LHHMHLkSAwfPhz33XcfLr300uDnixcvRmtrK0477bTCJZJkTFO6OudjrW8ihITP6BqhoqXQ0RX6E8Xu2EjUNZLqMdyaknYggQFwZxiASLTPVPLBltr5i5T3PWXsEPSr8wBw5knwWGtjpCLVfLDTm26nYLp5kda+I9KSLGl2FjV2r0K/eut48dYDsoVuq8eJ6Nj7aKz34JKxg8M+S2ekV7wYRLK6F8rJDjZN4QnPDegKcqWTxmQYrFErqZgwsm/Wx63zqGm1BaVKyvTascZ6D+46a2Tw2vQZIun170qjAz2Vdj30+onVlsS7ur47Iv3+X4/K0KebO+3vZcIdCHrb5VGMoaBs77vuFAP7EinUSxleD6rcSlr1MlT3ai3h9Z5NW8YZi9tWEgtNkkeIQ1rfeAP6tu0AAK2xH+pOP73AKSKEEEIIIcXi6quvjhr9Yxs/fjz27NmT5xSVN78p8c6X3+DT5n0AgIOb6oIPf5hCBjo1rDUtFq3difU72+DTTTBmPY264dt2eHUz7GlSr26ieW8nDCHAwKypSxgDZwweTYFXN8E5ixp+0KGb0DiDgDXygsfpbZZSQkjrwaJtLZ3w6taI5fU72yCkhEvl8BsiZsdbh24GR2ZEHkNKiZWbdqPNZ0IIAU1h8Jupd46rnAWf4DUcmD6NxUijnU4hrQ4nKRHMXwBheRwrBZ2GCU3haKz3YGerDwxWOUvI4NolQlodsSs37cbIpno8OXkMrnp2Jb7e3ZF1IEhROOrdCna368k3DhE63RcYgvUKADr8BhZ/8Q1q3QqG9q7FtaccgPveXItv9vlSTq/CAL9hAoH9qpxZT4eH7KBPnQdPTh6D7z/yn7SmT9ND6pBH5WCMxS0fwAqy9G+owpOTx0BK4KpnV2J7qzfucJ3IbZv3dsYMtnFudfw9OXkM+tR5IKUMXuNSAs+8swH9u1fBtKdOi3H9+U2J5jYTumlCSgbGrDrHA/91qwxeI3ne/PjIAfjnpzuwuyO9ehCLzxBQFYYe1S5c+91hqKvSAFjt0JrmFrT5TGzZ3QHDFACzRgwKKcPKJV32tWk/jW9nd2ie2u2m3U4mapdSMXb/nli49hvrWk1zNJBXN6Oucxn8fxa3vGPt55PmlmD5Syms/UgE6oIIjqrwGwI+3YSAhBTW56+s3oLmlk4IIRKOvkjUjtnvaQpH3zo3rv3uMHzT5se1pxyA//nnOuzY54OepA76TAmVA0liqwCsclY4g0eLfd3qpoRuds2aoSk8rG0GgK0x7oeANZLMrfKkQV6bW+VQFY77fzQKF895P2ldUrO4F7lVDiVQRnZ5VLkU7G7PclpDB9nXYaLySURhganupACDhCkZHn17HXy6aZUTZ2H3mmT3V7tNsQNTwpT47oje+PuKLejwm3FHXEZqqHbhsuP3w2MLv4z6LPT3TyZtisKBnjUarj5xf3y2fR++3mM98MuYtf5fp24G76cjm+ordqSQ40GgTz/9FI8++ig++OAD7N27F6YZPdUOYwxffhld6ISUsr2vvILOlasAAFVjRlMQiBBCCCGEAADuvPNOnHjiiRg3blzcbf7zn//g7bffxu23357HlJWfHa1ePLvGi6VbdHjN95NsbXUxXPr0B1HvP/L2Ojz3wWb8aMwAnH5II974ZBteWrUV3+zzBTufGKzpcTSFQ+EMVS4F5x45EM+8szFsbwyAS+OQuog52mBHqxdzl29Eh7+rA+b1j5rxr892gMHqDA7t2I0RZwo7liEEGLM6uXRTwDAlLpr9HnQhkMnsZ/FGYKQrNL9CA0BWx7WVTplgezuPY23bWO/B2UcMwPcO6YcfPr4s6vNQF895H92rNZw9uj/u+eEhuGLuCniTdFYy2FMxsUCnc/hnV56wP0b2r8MNf/sIfsNMqRMWsPI2Xv5u/LYDV879AKaw8sgOSqTDCC4UYx3Db0owCHy+rRVHD+2aqn9EYx1617qxq92XURDBDlh4NA5DyJhlObhnDZ6/8hj0CTxB/sLPxmLu8k14bOH6mOX+96vGok+dBztavTj5oN746/tfx+z4veg7g3D1iUMhAcx47RO0+8P7oGa89mnUvu0Aq33t/d87bWjx2bmUeX3/+8otKXeIJsMDi2O0dOq49eVPMOvNzzGwRxW27OlES4ce83pWWGAdGZn+GmKxrs0drZ3w6kZEfZbB/97/1tqsA6gLPt0BQ8i4aYjFLreXVm1Fpx5/eu9k+7TbnnH3L8SuNh/MkGsl+F9ptamAgNdvYPPuiCnfJfDqR9vw6kfbAFgBo9BAQ6R47ZhL5aiv0jCgoRpb9nTg1pc/CQazunlUjOpfh6++aceeBAHGGpcCgKHNZ8Tdxs4XQ1iBrsj2LHI7+zO/KYCIrH71w+Zg4Di0jbzlpY9TCgBZwY6uvDqgT7e4bTzQVbczCQBVuxRIKaPKhTHgoH61eOfL3WnvM1cUbgWihZSBckqN/dvAlIAZ1jhI/HbBF10vQ4I6/7t0A4SUCe+v3as17PPqkBLBe+XTyzalfD72dfj/ThyKXhGjveLd/0PPJxVCADv3+fHrFz8JTjnn1UWwznT4O3HVsyvAwIL3/yljhwTvR5XC0SDQ4sWLcdppp8Hn80FVVfTt2xeqGn0Imn6HEEIIIYQQUilmzJiBGTNmJAwCLV68GDNnzqQgUBY+29aKnzz9Aba3Zv8UvpDAjlYfnlz8JZ5c/BUYC3Q8hfxTVsJ6QtYwu0YMvf35zqh9MQYrwCMB029ta3dHfratNTgiIvRfyaYE2uOsXRirU0TlzHpKG11PcId24CULcuSaS+HQYqwDYAoZ9+njyPxVOAuMylDgUrqeGmZgePuGE7Hh23Zc9ezKpEEMn2Fie6uJJ5d8hScXf5W0QzEy7aFPLNtPU9848UAs/3JX4IlqNThywhAi5YBQrPP3hTz5n+mUc7H2e+Gcd/HIBaNx+qGNwfcVHp63QoqwUTFSCviMro660A66rrKS8GgKXAqi8mhYn9qwDrc+dR7cOPFAPL1sQ9S2jDH0qfOEXR96nIz89+c7cdSQHrjz9U+tkUVJzl03Jd75chfe+O82zHrrczS3dMJwaJlQpwJAgJVWKa1rRBcCnbqJnft8Cb8TWvVdCgfn6GoEIkaaxcrzUJ9ta8Wlf3w/Yf114nTteh3reo/FFBI/fmK5VSeSRLUT7TO07UmWr7YUBoNBSKBTF3Cr4dOnhX41Vjs27bSD8Mf/bMDHW1ugmwIc1rUnpcQ3bT7s7dRR71GD5Ro68smUAroh4TckdJG8MnfdJxKfULLTDR05KGGPQJIpj4TrCkV0iZU3UlojsDK9vtwKw369arBpV3gAz64D72/Yk9mOc8QQEoY//B4ej8K6rvt080cC+PvKr4PtduQ9wG4fLj9+fzywYG0GZ2KxR3rVVWlhU90muv8D6Z1PaOjWEDJ4Xw/dhxFYW257qxezl27AvI+24cnJYzCisS6d0ylpjgaBbr75ZhiGgTlz5mDKlClQlMocXkUIIYQQQggh6fD7/fTvpyzsaPXisj99kLQTOF12pxYAVAVGOUR2nEkAnbrVYdO8tzNqH9UuFaYQ6NStJ3q9uondHX7saPUGp7nKlkdTICHDAkfF9OilbgqoSvh6REIm7gCy2XlW5eqaQo4xFliM2nrd0qmnnJdSIuXpvWKlPfLYXens2h9jDJwDRuIH8gvGlMAvnluNIb2qcXBTfdhn9vkp6GqPrLIKf1LbpXJ49fBO+NCysjrckw9dipefkdeHqrCYndZb93TgF39dhXQGMHX4TUx9bjVEIKBXjKpUBTwQ3O30px+l0k2BKsXaRyyx8twmpMRlf/oAO1IMjmRD5V0LzAOxr/fQdNnTcgKAW+EpBbgj95lq25ONVNZKseu+kMCcpRuwI3D/ssveJoSE3xTY1e6HlLDKlVnXl5ASeuDaFFKiSlXQkWB0VLEJLZfwtfC68qYzy7LymxL+iHoSWgfSmQYzn1JJVRazP1rfD4wECy2H0DZZSIk5//kqq2P4DBHVDuXjGozkDkxbal9PzXs7cdWzK/HCz8ZWzIggR4NAH330Ec4//3z89Kc/dXK3hJSEgY891jVpbppz2RJCCCGEkPKWaF0Cv9+PpUuXok+f9BdTJpa5yzdie4uzAaBIyUaMJPo0bI0eAP/8dAc+29YaDFq5VQ4jg47eUmE9eS7gVrsCC7qZ+jQ3sb4fau7yjSkHACWQ1ppIyY4dT7JRCoVmConbX12DF64+Num2TpZVqkLL1K3ywPUXnYqIAXopc2J9q1yyO03TyftQ2ZTDPq+B9iRTijnFjDHCLV7aQ/PCrYYHj5IJ3WemeZquVNfE0U2Bnfu66nrk7wXOGdyMw6ubEAjPm8g8SXddpUILLZdYE9M5UVYSiFrzJ3S/jAGVOmFVcN0vxL/mMglChx0DXfdDu4zzdQ2G8gfOz76efIbA9lYv5i7fhBsnHpjn1BSGo0Ggmpoa+ocLqVhM0wqdBEIIIYQQUiT233//sNcPPfQQnn766ajtTNPEt99+C6/XiyuuuCJfySsrXt3Eiw6uxRFPKmulaEr0gtVCyqjn7Zd+8Q1cgc7IKlXJuuOu3W/Ao8ZfkLwYGKaES+laqNlI8xHm0O+HklLipVVbg3lppDAdUrp1Jd6x45Ey+VRLxWDV5j3Y2+FH92pX3OcY45VV5CigUOnmV6xjhpaptZ/Y+Vn8uZwZ3RQpBxHiyaQcpJTo8FnBhnyINwojMu2h9dAVmGYtkzZE4yLt72VKBKYxA+IvixF6XlVa173AbwjopoCmcLgCwR1VYTANGcwbIDwP7La11ISeT6hM7hPxtHTqwSBZ5H6LPB6cU6GnHuuac+o+ZpgyOKrWyXJNh25KaIoMjnZyKRydhomXVm/BNScfEJzWt5w5+ivx9NNPx9KlS53cJSGEEEIIIYSUHCEEpLTmH7c7HWL90TQNI0eOxE033YQHH3yw0MkuSWuaW7C7Pft1gJwR3dnqjTE1T6vPwJ4OPzhY3Oma0iED61AUM2u6IuvvmYzeCP1+KCGBvR26Y3mZzrGjNgpJUykQEnjj4+1Jt3GqrFKVjzItdtkGgIDMykFI5C0AlEhk2kProTVNXmb10hD5DRwmW2/IPg/GukZ/SWlNV2WNWhTB0RP2iFI7b2LlQbGPQIzFPp/I+FWmo/xiMYXM6v5TCWJdc07ue+veTsg49TZfQtfW45yBg2FPu441za0FSlF+OToS6IEHHsDxxx+PqVOnYtasWaiurnZy94QQQgghhBBSEjZu3Bj8O+cc1113HW6//fbCJaiMtfnMmNPIFEKsdMTsSAnp+KskVv6wjMvL/n70e7nPy1jHDv88Ok2lYHd74k5qJ8sqve9W3vWRC+mWQzHV3dC0R6Yru3qZP34j8cjErroePmVo2DYy+lqIdx6lEoCOJGOckdNlle39pxIkuuay5dMFpCyuNoYxKz1teZr+stAcDQKdf/75qK2txWOPPYZnnnkGw4cPR11dXdR2jDH8+9//dvLQhBBCCCGEEFKUNmzYgO7duxc6GWWr1q2AIf50UfnEUu1sZYHOh9J7aDsrdv6knE9xvh/rvVxPg5QszWGLmmd4foXQo8ad8HMnyyrd75bi1FbFJt1yKKa6G5qWyHRlVy/zV69cSdZkyrSuF1M5OYEheio7p88x2/tPJUh0zWXL41Jyst90RB5bSuu9Wrej4ZGi5ehZLlq0KPj3trY2rFq1KuZ2pbZQGSlTXAWGnRL+Ogv+jRshOjutXVVVwTVkSFb7I6VHYQqO73982GtSXDhnGDyyZ9hrQgghJNcGDx4c8/2NGzfin//8JzweDyZNmoTa2to8p6w8jGyqR48aDdtbE49oyI/UOvLq3CpcqoId+7wQQlbEbxIGwD5NzpB2V2zo90NxBtRVadjeauVlLsQ7dqjQp5tLpTg5A04f1S/pNk6VVTrpCi3TSrg+ciGTcuDM+lPoESWRaQ+th0LIjOoXA6ByQDfzFwbqXZs4yBo8L4mkdd2eyio0byKvzVK8UuzziYyDZdL2xKNwltX9pxLEuuac3Hf/7lWQKGz+85BFcYSQEJBoqNEwsil6AEs5cjQIJESFPcZESptWBZz1mGO7237vvehcaQU+q8aMxqCnnnJs36Q0eFQP7jzuzkIngySguhScfMmIQieDEEJIhbn33nsxe/ZsrFq1Cg0NDQCsB+i+//3vozPwENFdd92Fd999Fz169ChkUkuSR1NwzpgB+MOiLwvecZnqIsrjhvdG/4YqzF66AX5TwM0cXa63KKkKCz4Qai9yns6i06HfD8UYw9mj+wfzMhXpdnLHO3aosJFAjEFL8/wKYfSgBnSvdiXcxsmySlVkmSa6PqgzN75MyoExhlqPijavUdD2NDLtofXQbwq4VQ6VMxhpJFJVGDjnUBXnFrxPhDPApSZu2+3zApCwrkspYQTSHJo3odemvQZhqV0Ridr2dNueeGo9ajD/IvdbDEHPQgmtLbGuOU1hMMzsJ3BTFQZN4cH9OlWu6Qodeec3BTSF4+wjBsCjVcYD3OX/S5MQQgghhBBCCuiVV17BkCFDggEgAJg2bRqEEJg5cyauvvpqrF+/Hv/zP/9TuESWuCljh6CxvqqgaUjU1Rq5LsSgntU476iB6FfngQTg1cv7gUoGQFM4pJQwhYQhBBSW+qQw9vdtofsxhQzLy1RoafSEhKbdMAV8ugGvbsKnmzBMASklvLqJL3bsC6ZHShmW3mLEGXD+dwbCq0evWWKfq98w4TcEONIbYaBGPEIupcTeDj8Wf/ENVm7ajb0dfrzz5TeYs/Qr+A0RzMdQU8YOCbs+zDgPHdsjV9KV6fdKRaxrzq6bkeUbmf/dPFpB29N4aVcDIwiElPDqIq3yC21DVJ6fCanccQJAUefFGfp0s0YM+Yzoa8EwBTp1MxhoDm1bNIUHzyXWd0uBfT5evwlTSOimVS91M737RCK17vBO/tB8q9QAUKTIdhuw8ql7lZb1vjlj0APtjJSyYMEIKSWEkPAZ1v2ksd6DS8bGHq1fjnI26V1bWxu++OILtLe344QTTsjVYQhJ2V/e25z2dy48elAOUkIIIYQQQirJxo0b8eMf/zj4urm5GR988AFuuOEG3HbbbQCAtWvX4uWXX8add9Ko4kz0qfNgzpQj8ZOnP8D2Vm9B0qBwoG+dB1v3dkZ9Fhnjefjf6zFn6Vfo373a6pQo404oBqszVDdFxk8UK4HOKSFlzP386A/L0bPWFT2fUBy+xGu1h+EM8Okmwh9atl7ogYIbfdc/oZsi+GQzg/Xks0fl8BrFGeBTOMP0V9bgwQVf4OzR/WEKCSEl/IaJ8CSnX2JeXUBVJBTOrM5uU2LFpj24cu4HMEyJeA+Aq5zBpXJwxiABjB3aAy+s2GJtH+c7NR4VChj2dOpppbGYrzkWY2qstL6PdK65rk/t/Nc4wx8uHoMpf3wfO/flf5rNZGm38kbCTPE6ZkDwSX+fYToysiEZt8qh8NDAdfz2iwEYPbgBqzbtxTdtvqg2wx9xweiBEQycMXDG4NEUeHUTnDP4i7S9ScR6SILh/NnvojMYlHa2hLa1+MAZgvkGWPfsEsyuIAZrpJkvi5MIzWW73bbzyK6vigPRcp8hcO8bn6GuSkW7P40bsMPsY2sKQ1P3Kjw5eQz61HkKlp58czz4tnHjRpx11lloaGjAUUcdhZNOOin42bJly3DwwQeHrR1ESLno/fOfo/9Dv0P/h36H3j//eaGTQwghhBBCikRrayu6d+8efL1kyRIwxvCDH/wg+N7o0aOxeXP6Dy2RLiMa6/DaNcdhwuDsn1rNhCGszrlUdfgF1u1sK+rO6GypnMEd6KTSs+h4NYREh99Ep9+MuZ+d+3z4bNu+uMGFWBgAJYW+LVMi6X47AumySVhTA/oMAVcqB3GIveZJso4ee/0NvyGwvdWL2Us3YEerFx3+yABQZuzz9+pd5S4k4DPiB4AAq5ytMhb48RPL8fLqZpgy8SikTr+JvV695Ke5YQCqNI5ql4L+3avCzlnlXetoJKJya/qmTK+5rvyXGNFYh7k//Q6SzGaWE9m2F6E0haEqsCB9vPYjValcypxZ5Rg5ErDdZ8Q9vgTw1ifbAQBnH9EfPaqj72EsZOSablrlZAZuHgq3zvHKE/ZHtav0prUyhFX3drX7c3YMa4RRV/vS6VBbVwjWqDarzDXFajMu/M7AuCPPUmW326F5pJsSbV7DkXTv8xrYuif1h3Q0hQWupdijwbK5sxqmxM/GDcVB/SpjLSCboyOBNm/ejGOOOQa7du3CWWedhe3bt2P58uXBz48++mh8++23+Otf/4oTTzzRyUMTkjYmdDR9szT4urn3CZA8838wVh12mBPJIiVMFzqWbumqUycMOAFaFnWKOM80BTZ9vCv4evConlCKfKoOQgghpa9v377YtGlT8PU///lPuN1uHH300cH3vF5vVmtoEEufOg8uHunB4i06GOOBhbQZDhtQj0+3tQKwptbx5Wgu+kI8NV/MVIXBpwvHnul2aj9VmvWUvpBWcClXJKKf4s8Ve40Uux2xp/wyRHTgpUpTgttZU+OYRROMlLCCAFv3doIBqNaUwAgHM2ZeCglUqdY2ANDmy7zDUmWAUcB8YIGRHfv1qsGedj+EBIQUcKsK2v0mOEPCNXAYJBTOs7rmJIDtrV7sbPWiVzc3PJraNX2ZKfKSP04eIjjVmG7G3a9LYWF1S2UAGAussQO4FA7OObpXaxg9qAFvfrwNAhJS2MEZ67pTOcB59L8td7R68dm21oTnJaS13ZJ130QFkKpdCjhjMIVAZ2BYqQycU1XgM84YJo8djGff3QTAmTatxq2gPc6wydJbechity+h3FmOpslWZP1LxqOFjzLjjOGmiQdhaJ9aPPDWWojAlGeZXquReaQlSZ/KASVwP3Hyt5U9IknhgEuxRkxLyMC6PjKraXQlgOmvfoLDBtbj4KZ6x9Jc7BwNAt1xxx3Ys2cPFi9ejGOPPRYzZ84MCwKpqooTTjgBy5Ytc/KwhGREEX4ctebu4OvXx82DQR32JAt+04+73+2qU/MmzaMgUJExdYHFf10bfH3RQcdQEIgQQkjOHXXUUXj11Vfx+uuvw+Px4Pnnn8dJJ50Et9sd3GbDhg1oamoqYCrLC2OAGnKP71nr7ur0LlSiKpDfcC4A5BQGBDvQ0hm5VeyElGAhi8ozxqCpCoRhwkzQMce51YFsFtlaIkJKVIcEq+IteM8ggwGgbBUyAGQ9hW8FfADrfBUGGIY10sye4s1IELQ0BGDK7K85U0jMXb4JU44dEkyLqjD4S/B6sa/xRHmicI7QueUYZ3CrCgzTCijagR0prY5pd5qLyM9dvhG+JHnnUhh0U2J7S+ojJSLrzNzlG7MKgkZKtBpPcbUWyRVz0CpRYDfe9rG6MDSFB3/3dPidqwc8Tttrs+81PsPZBypitYf2+B+fA78tDCFx+6tr8MLVx2a5p9LhaM/X/PnzMWnSJBx7bPwMHDx4MLZu3erkYQkhhBBCCCGkaN1yyy0wDANnnXUWJk6cCK/Xi1tuuSX4uc/nw5IlS8JGBpHcsEZHFGtXUPkpltEloRizAgztPiNsCrdSZ5gyalH4ePXdZwh0+I3gQt16ERZUYBAfAGvEQ7wn9U1hPR3uD5xTKbPLkIeN5rJG4bgUnnS0qD3tnhNeXLUFnXpXfgohivJ6TkY302/zY11LtnQnkzOFxEurtiZd44kxBo2zwOiv8M86/SY6dTPmPuy0Smkdx3SwkJzu1C9WhX4YIN0ii1c/7dbB6Ws12f3BMCWEEI7/top3nk7+jlu9eQ/2duRuGsJi4+hIoN27d2PIkCEJt5FSwuejIfKk8CTj2F0/Muw1IYQQQgghThs9ejTeffddPPvsswCAc889F9/5zneCn69evRonnXQSLrzwwkIlsezZHXfWdCKkktnTKJVbPbADAKHrlsSr7/aT5z5DgKc5qiGfhAAkRMIn5SWsjvZSHKUSyS5DO9Zjlx9jcGy0U6p2t/vxxY624OtSXT8FSL/NTxhMS3Nn+7wG9nboqW0cJ8hn1/GYHeLoSmvKx0lROQXJEym14Gastj70FJy+VpMFFmXgmE5nY6zzBJz9HWdK4I2Pt+PCowc5tMfi5mgQqG/fvli3bl3CbT7++GMMGlQZmUuKm6lUYcmYRwqdDEIIIYQQUgEOO+wwHBZnDcljjjkGL7/8cp5TVJmcWWqclDRZvlMCWvWbRbxO5TvFSUIildhOqXXiJiIRMhIoUDaFWC1OSqA9ZGqxYq4n2YgXW4t3vunmgilEYB2T5N9Nlsfx6nno94p52jPinMi2Pvqz/MrVMWOdp9PH2t1eOQNVHB36cOqpp+L111/Hf//735ifL126FG+//TZOP/10Jw9LSFHYct11WHfyyVh38snYct11hU4OIYQQQggpQm1tbVi1ahWWLl1a6KRUpERrHBBS6iLrd6nX91TTX9pnGY6BBQMT9vkXolOfMaDG1fXceKnXpXQ5db4K52BgKZVhpsdkIf+jAFBliKwroaPECnGt5uqYsfbr9LF61LiTb1QmHA0C3XbbbaiqqsK4ceNwzz33YP369QCAN998E9OnT8dpp52GXr164aabbnLysIQUBdHeDtHSav1pby90cgghhBBCSBHZuHEjzjrrLDQ0NOCoo47CSSedFPxs2bJlOPjgg7Fo0aLCJbDM2Z0GnJVXhzFJX5JlVUoWQ/SohlTqe55nGUsL50CyEEis8y5VXecS0V5JQOR5uFOPGhcO6FMbfK2W8Oz56VaPRHUq3lpB8XTzqOheraW2cZr7BrrSyhlSPw4pacnavHxfqyxwTKeb4Xjn6eTvOIUBp4/q59Deip+jVWPIkCGYP38+GhoaMH36dPzlL3+BlBLf//73cc8996B3795444030NjY6ORhCSGEEEIIIaRobd68GccccwzeeOMNnHXWWRg7dmxYR9LRRx+Nb7/9Fn/9618LmMrKwBiDGjnBPMmZYuycz6CftSSoCgOLiHClUt8ZrAXpiw1LcV4rhQPlEtq1yzA4EihQfgpn8JsiaQDCyYDYOaMHwK11dRlyzovyek5GU9Jv82NdS7Z0mw+FM5w9un/S4LOUErqQwYBOquy0MmYdRynFQqpw6RZZrPopgeATDvm+VlWFgXPu+G+reNehk7/jjhjUgO7VLkf2VQocXRMIsP4Bs27dOsybNw/vvfcedu/ejbq6Ohx99NE466yz4HJVTuaS4saEgZ4tHwdf76ofBckzvyS6nXQS3EMPAAC4Bg3MOn2EEEIIIaQ83HHHHdizZw8WL16MY489FjNnzsTy5cuDn6uqihNOOAHLli0rYCrLg1c38dFOHX4DMIQJzgCVM0hYi2obpsj7E/WVTOUMullcq4kUU1qcwgBoVjQEUkoICQgpIKU1Bi5RPEU3RdKFvwuBMwavIZJG7SQYhEORPY/K4DMKW1/9hsC3+3wwTAEwQGEM1W4VLV4dnbqZ8LucAyoD/GZ29ZwDOHxgPZZ88Q38hgAC63JwlNZ6WqHXhWGaMfNESsAQIuZ3wreT8BkmdrR4rbIJbMzAAClgShZY+4dB5VZHvG3K2CGYs3QDfEb83POb1rpBjd2rIITEthZvSueocgZTSEhIHNzUDVUaR5svcT2Jp5zXEyrW82IA3CqHVxcpThkYu37apJQwhczrtcoZgyEEFMZgOLRiT6zztO9tEtKRY6mc4c6zRmaVzlLjeBAIsP4RM2nSJEyaNCkXuyfEEYrw4fjVNwRfvz5uHowsgkANF1zgRLIIIYQQQkiZmT9/PiZNmoRjjz027jaDBw/G22+/ncdUlZcdrV48uOBzvLy6GbppdQvYwR6/KfHvT3fAKNZeoDLmNynTs8VY4jgIA+DRFACAzzCD9d+SPP8zKaNcdxa7FAaPpqDVayTdljMEAhWZs0fQmLKwncVW2Ums+npv2Pt+w59Sh64pABNIGvhLRgC4Yu7KiO+X1rVsXxc8MJLAoynw6tGBIAmEXTNulQe/A1jXns8wYZgS7X4T37btjnNEGfyv3wQ4E3AH5uXqU+fB/r1q8Nn2fXHTyxnQ1L0KT04eg11tPlw85/2UcrxT76oZP/+/D1P4RjQG65qj9jq/7DqqcAaPxmLWz1jb8xijY77Z58Pr/21Guz+zAGA2EgU3MxF5nkJK6KaA4eADJSpneOTCI3BwU71DeywNOQkCEUIIIYQQQgix7N69G0OGDEm4jZQSPp8vPwkqM59ta8XFc97DrnZ/3G0qJQCkMGuqFOvJcFLKGKzpcH48ZgD+vnJLVAeY/bmmcEgJdPoTdyCmSgkEQ2Kxny7Pdd3ymxISqXVmVmkKpAbsSyFgFElh1nRAbn0fljUbMHPUCZ7tdZluF6t9jGxGA+SqjN0KgwAc7dCNeRyVh02NpnBmjbhI0mHtMwQYs6bgE9IaVZVJbghpBWh2tHrx2bZWfPVt4nWj3SrHvZNG4aB+ddi5z5tSWrNltyEMgK9AASAGa0pHKREY5VE5QuuowhmqXErMYEdoWx8rAGQKiSl/fB8795X+b0iFAe6QAJApZNLgWLoObqzDb398aMUFgACHg0B33nlnStsxxjB9+nQnD00IIYQQQgghRalv375Yt25dwm0+/vhjDBo0KE8pKh87Wr249On3EwaAilWNW4EUQGdIB0doB3wmT/ILCVRpHAyBzpMcdyKWo3SfiGewRuukO6Oaxq21Xxhj4YUdmGLK/qx3Nw/cqgKX0jUVTujnQmbXSValKWAAOgJTjdl1yOqUDUwDxgBAwpvHaKoZmB4r2RHbfUZa564F1pIYu39PPHzBEfAZAt994N+ZJjMlodelPVWfLw95WYxXv9+UqHIpULlMeQqsTPgMAc5Z2GiCWCMWGAC3Zk3HBVj1zaubcGscTgyq+KS5FT995oOkoyU6dYFfv/QxXvjZWHyzz5eztltTrDzxaByGKWFKGTz3fHAFjh/azklYQexyno4ulsg6yhlL2NbHIqREp24mnSqyVITeR7O9t8XT0qmjV63b4b2WBkeDQDNmzEj4OWMMUkoKAhFCypJH8eB/J/5v2GtSXFSXgh9ed0TYa0IIISTXTj31VDz77LP473//i0MPPTTq86VLl+Ltt9/GL3/5y/wnrsTNXb4RO1pL8+lXBgbGA+vmBHo+Qjs7Qt9PlTW1kYBbVWDKYuwCLn5GBnme0RLVDNDU5L9F7b4/xhis+EX40XQz+450HjJiQsLKA3dE2jr86Y+0yUaqtTeT0QNuVcHBTfXoXu3CA/M/R0eOTy30ulQYYOQ3K4uKnRf233N9HLsex71O7HV9Ir6b7RSDoba3eFMKcGxv9WLu8k1o8+W2gmgKh6ZwmELAn+fggQSgRqz14jec7+gvBZF11BavrY/FvpbKRWieOHFvi2V7i3Wd3TjxwBzsvbg5GgRauHBhzPdbWlqwatUqPPzwwzjllFPw85//3MnDEkJIUVC4gv3q9yt0MkgCnDM09KspdDIIIYRUmNtuuw0vvPACxo0bh5tuugnr168HALz55pt455138Lvf/Q69evXCTTfdVOCUlhavbuKFFV8XOhkZsx+QtJ7wDaxjFNLjEfp+OgxTQuPWlDIkfemO6AGs9TzS/Z5hSrgUGfcJbxsLdFHHXtReOlbOoWsPRaZNCJFRvuRDusmyzw2w2pCXVm3Ny7mFHlev8GtTD4zyyrXQPI93nXSNeAvnZJ1IJVCsKQw+Q+DFVV/ntO0OzZNCXNeRbUtoG1aJV0Wq94FYpJRl2Zbk+jeMKSVeXLUF15x8QHA9vUrhaBBo/PjxcT8788wzcdFFF2H06NE455xznDwsIUXh29mz4d+wEQDg2m8Iel1xRWETRAghhBBCisKQIUMwf/58nH/++Zg+fXpwhoTvf//7kFJi0KBBeOGFF9DY2FjopJaUNc0t2NWuFzoZGfPHeALYCdZIjsrsUCuUTPJawupoVrLoDc/VGhqRaSunWQXtcwOsNmRvh56XaahCj0vy0z6F5nmi4zm9sH1MSSoZZwwcDLva9JhBKaeE5kkhruvItqXS1gGKlM19oFzbk3z8htnd7sea5laMGdyQw6MUH0eDQMkMGzYMkyZNwqxZs3Deeefl89CE5FzHBx+gc+UqAEDVmNEABYEIIYQQQkjA0UcfjXXr1mHevHl47733sHv3btTV1eHoo4/GWWedBZfLVegklpw2n4ncLi2eW7op4U7wL/JszqyU86WSyBTGCCR6QDyX5RyatnKrT/b55LsNKbd8LAVFk+cpJIMxK725TrO9/0LlTTm3LZlI5T4Q/3vlKefXgETOp10sRnkNAgFAnz59sHbt2nwflhBCCCGEEEIKSlVVTJo0CZMmTSp0UspCrVtJMFFWOcj8vMo7X8pH5FoksbdB3FEEqXw/U6H7Lrf6ZJ9bVxuS3+OS/CmaPE9yCUlYHdOcsWB4JHdJYUg80WRuRbctlS3TPCjnvMt13WQMqE30FE6ZyusZ+3w+vPXWW+jevXs+D0tIXqh9+kAbNCj4d1J5OvQOXPnPK4Ovnzr1KVRr1QVMEYmk+0y89vvVwddnXnsENHdlzQNLCCGElIuRTfXoWaNhxz5/oZNSVBgAlQO6WU7d9sUtk644BmstoaTbJdiGs6R9yxmJTJvKAX9+14/PGfvcGLPakO7VGra15P7kUi3vSpGP8ENonhc8jJnk4EJICEj0qXVBNyW+bcvNfS00TwpxXUdeB7lqw0pFNu1CubYn+fgN06PGhZFNdTnae/FyNAg0d+7cmO8bhoGtW7fiueeew+eff46pU6c6eVhCikLT3XcXOgmkwCQkmtuaw16T4iKlROsub9hrQgghJNfuvPPOlLZjjGH69Ok5Tk358GgKfnTkQDy28MtCJyUrob9HOAtZwyLD3ymqwsA5h6qU56LRuRZaBqnKZG0GVWEpLQbOWPxnohljUBXmSDmHVrfItHHOwVn+F5FPRbodyKHn5tEUnD26P/6w6Mucn1vocTWHyqxUaYEFUHKdB6F5nu51kkk7EE8qddQwJTSF45zRA7HPp+NP72xy5uARQvOkENd1ZNsS2oZVYjAo1ftALIyxsmxLcv0bRmEM54weAI9WeQ8DOxoEuvTSS2NWXvvHK2MMF1xwAWbNmuXkYQkhhBBCCCGkaM2YMSPh54wxSCkpCJSBKWOH4MWVW7G91Zt84yJkmgJGSA8cB2Cv1Z1J3wcDoCkcAKByBsOkx5LSpTArIJJOvqWbx6HlBFh9JrphwgwclzNAASAZx/Ivd8FnCHBIgHFISDCw4FPgCmPQsyhlwxQwIxeIl4DfEFBY1zE1zuDLY2dj6LWQCIM1qifVjmyVW+3t1j2d+MOi9djZ6oXKAH+OT42HtPOawqGbZTK0Kk2hdd8wzZy1T/ZxpJQwTAGRZqTDrXJ06qnUwOSqXAo6kgy5MaVEraai1q1g7NAeOQkCMVjtm9+w8sMQEi4OePNYFdUYw1c0hcOo0OshtF1IhZQSQiJ4H1B5+QWBGABDCPCkW2amsbsHl4wdnKO9FzdHg0BPP/10zPc552hoaMCYMWPQ2Njo5CEJIYQQQgghpKgtXLgw5vstLS1YtWoVHn74YZxyyin4+c9/nueUlb4+dR48/ZOjcPGc97CrvfSmhes0wjsZjZC+nHQHAjEg+GSrzzApAJShTPp90ykru5w4YxBSwus3o4IdQgLWktUC/1n/bcgnzneU6jE6x6337PcL0zmrKAwihc5NxhkYZMpBILtj/7WPmvHaR9mkMD0+Q8AP6yl3TeGo0hR06pXV8R1a9wEr0OI1nAm0RB7HrXL4dDOjYDoA6KZIORCZTLIAkK2lU8est9bmdIo0r2Fd24Wa3tGrC6iKNerJbgN1UxTsXuVUGWcqsl3gcYJBdj5F3tftqdPqq1wl+RsoFr8pM3sKJgUMwJjBDTnZdylwNAg0ZcoUJ3dHCCGEEEIIISVv/PjxcT8788wzcdFFF2H06NE455xz8piq8jGisQ5vXnsCpr/yMeZ/urPQyck7hq4OJCmBTn/unq4n2VE5g0u1OvpMISsuCJCOKk2BbhpJtxNCJlw3qZhIWFOgGaYJj6ag2qVkFagoNW6VQwmMBDGFhC+FAFAmnfSawrIOLuUgNpWy0ICmk0GKYqhmodeAS+XwG4ULAAGFDQDZItsFJWK0lCkkvHrs+7pEV111KcwKoJC4JIBXP2zG+xt244+XHoURjZW1LlCuRlcRQgghhBBCCEnBsGHDMGnSJJo2OwsSwGfb2wqdjLxzqxzVLgVu1RoBFK+jKBNK4Gl04hwz0LsrJAWAkrFHT7hVDo/G4VGtP26VhdXLKk2BWy2tri0J61oVMvURTPnmUpy/+n2GCJxz/E7tSBJAlcbhTiM95dQRLgB4VAaPyqFxK5CslkHDLGHVh/IpqeyFtgu2VK+VXe3+oq33uWhLsrWtxYvL/7QCO0t0KuFMOToSaMmSJRl/d9y4cQ6mhJD8a3/nHRi7dgEA1J49UXPssQVOESGEEEIIKRV9+vTB2rVrC52MkjV3+caSXRcoG0JKMGZ1gDs9pU6R9ieVNOuJ72J49rx0CCnhVroW8PYZ4R2inLNgcK2USKDgoyASMXKQp6H1P9W9yxylpZT4TYlqlwI1sJaSzzCpgS5T9jViP9hRyKnynFKs1+/2Fi/mLt+EGyceWOik5I2jQaATTzwx5cWsIpkVuggYKR+7nnkGnStXAQCqxoymIBAhhBBCCEmJz+fDW2+9he7duxc6KSXJq5t4adXWiuxcN0wJlyKDfyfFr9wW8c4Vl8JhCDNYx1lgAfXIei4hc7KuTD4Uad8ogNylTTdl2iMMM/lOORESEEKAcw4pJbUhZa7c7uvF2s6ZUuLFVVtwzckHBNdTLHeOBoFuv/12vPfee5g/fz6GDRuG4447Dn379sWOHTvwzjvv4IsvvsDEiRNxzDHHOHlYQgghhBBCCClac+fOjfm+YRjYunUrnnvuOXz++eeYOnVqnlNWHtY0t2Bvhw4OBgFZ8k/NpkOiq4Olks6blD8eWBfDruMKs/4bWc91Q0JS5S8pmRRXpRexIQAXL94OdeIcuq/nz+52P9Y0t2LM4IZCJyUvHA0Cffe738WsWbPw1FNP4bLLLgsbFSSlxOzZs3Httdfi1ltvxfHHH+/koQkhhBBCCCGkKF166aUxZ0yQgZ5LxhguuOACWhMoQ20+ExKBxeErsMekssJepBJZdZzFrOuVOAKQVB677lN7XxmonPNDSqDNZxQ6GXnjaBBo+vTpOOOMM3D55ZdHfcYYw5VXXom33noL06dPx8KFC508NCEF13TvvZB+PwCAuVwFTg0hhBBCCCkWTz/9dMz3OedoaGjAmDFj0NjYmOdUlY9atwIGa6qoSuw2YRU9URKpBHYdj1nXKzT4SypLwmuAlB0q5/xgDKh1OxoaKWqOnunKlStx7bXXJtxmxIgRePjhh508LCEZkUzB1j4nhr3OhtqrV5YpIqVOYQpOHHhi2GtSXDhn2O/QXmGvCSGEkFybMmVKoZNQ1kY21aN7tYbtrd5CJyXvGAD75wz1hZNyIgLzIYXWcc6i6znV+9KTSZlVejmr3Pov/fO1/NF9PX961Lgwsqmu0MnIG0eDQC6XC6tXr064zerVq+GiURKkCJiKBx8ccnuhk0HKiEf14PaxVKeKmepScOJFBxU6GYQQQghxkEdTcPbo/pi9dAP8JbpAfKZUhQWnGlQVRguGlwBNscqLyioxf2Cat9A6zhgrq3rOWfGu8ZKrtGVS/yv9muHMGjkMWNeAVkbXAIlWbvf1Ym3nFMZwzugB8GiV8/C2o0GgCRMm4G9/+xtmzZqF66+/PizY4/f78eCDD2L+/Pk477zznDwsIYQQQgghhBStJUuWZPzdcePGOZiS8jVl7BDM+2gbNu/uKHRS8oYB0BSrY1AIAelwL4tHZfAZlTnFXq7Rw/zJicCaaWrE0AdN4TBMM1gvi7FzMVUcQLGGrVVudT47mb2hbVZoGSaTyXfKidseBhSgKRy6aRYoNSTXOGMwhQRn0e1dKdI44CvC6trY3YNLxg4udDLyytEg0AMPPIClS5fi1ltvxe9//3sceeSR6NOnD3bu3IkVK1Zg586daGpqwv333+/kYQkhhBBCCCGkaJ144onBpzrTZVJHT0okgLFDe1RUEAiw6ken6fx0MUrgyXOPBnj10u6AKjal/lR3vgRiQPDqAqoioSkcnDFwxuDRFHTqpd82GkVcFfwO11MGa9QmD9wLPZqSctviNwRcKodb5fBW2GhPwGozGJPBvOOMoarIrgGFAdS0OcMXqOP2tHCpZGuVpkBVGPZ5jZymLRPFGABqqvdgzpQj0afOU+ik5JWjQaABAwZgxYoVuPnmm/G3v/0N//jHP4KfeTweTJ48GbNmzUK/fv2cPCwhRcHYswdS1wEATNOgNjQUOEWEEEIIIaQY3H777Xjvvfcwf/58DBs2DMcddxz69u2LHTt24J133sEXX3yBiRMn4phjjil0UkvSZ9tacdWzKytuTSCJ3HWumBLo9JvwaAqqXAr8hokK7HslBaRwBkNYI1F0U8IwrfqoBEYGpbJWhsqtJ+pLuW9a5cCYwT3w3obdhU5KxlTO4FJ5MIhhS7VcDCFh+M2KHUFnCAnTH17/Fc5QXeC2mQFQOGAKCgDlgkTq+WoIAbeqUjAuCQbgzMObcOvpIyouAAQ4HAQCgH79+uGZZ57B7NmzsXbtWrS0tKC+vh7Dhw8v6FpAL7/8Mh5//HGsWrUK7e3taGxsxDHHHIP7778fAwcODG7X2tqKGTNm4MUXX8T27dvR2NiIH//4x7jjjjtQW1sbtV8hBB577DE89dRTWL9+PWpra3HKKafgnnvuwf777x8zLfPnz8e9996LVatWgTGGMWPG4LbbbsN3v/vdnJ0/icaEjgE73g6+3tL3ZEiuZby/5mnT0LlyFQCgasxoDHrqqazTSEqLLnS8vbmrTp086GRoWdQp4jzTFNjw4bfB1/sd3guKwhN8gxBCCMned7/7XcyaNQtPPfUULrvssrBRQVJKzJ49G9deey1uvfVWHH/88QVMaenZ0erFVc+uRPPezkInpexIWKOA3BqHSQEgALRIdz55NAVtvq6n2kPro08XwXJINKWaKSQ8GgfAIKSAvwSnN3SpCk4f1Yj3N+wuirS7FAb7Skh1ujgzYs4+IWVGo1iK4fyzkc30f3b9r3IpYSOCPJoKKSUMU8CX595/dwGmDKVpSmMzhURLp56TfHEpDDwwJMlniJLOe8aA1Zv3FjoZBeN4EMimaRoOOeSQXO0+ZVJK/OxnP8NTTz2FoUOH4vzzz0e3bt3Q3NyMxYsXY9OmTcEgUHt7O8aPH48PP/wQEyZMwAUXXIDVq1fjt7/9LRYvXowlS5bA4wmPFF511VWYM2cORo4cialTp6K5uRl/+9vfsGDBArz77rsYNmxY2PZ//vOfMXnyZPTu3RuXXnopAOD555/Hqaeeir/97W/40Y9+lJd8IYAi/Bjz2X3B19t6Hw+DOuxJFvymH/e931Wnju9/PAWBioypCyz92xfB14NG9qAgECGEkJybPn06zjjjDFx++eVRnzHGcOWVV+Ktt97C9OnTsXDhwgKksHTNXb4xOALIrXKYfpq6zEkS1lRMlKcWyofCilUfWYJVxyWsURRulcMwSrP8dFPgP+u+LZq0S1htrc9Iva21RnMJuFVrAXa9QqPKisKgIPMpISPz0cYYK8jaUn6H14wq1mOWAilz174ZQqJaVdK65ouVBLC91Yu5yzfhxokHFjo5eZeTIND27dvx0ksv4fPPP0dHRwfmzJkDAPjmm2+wYcMGjBo1ClVVVbk4dJSHH34YTz31FP7f//t/ePjhh6Eo4Y2lYXQ9WXL//ffjww8/xLRp0zBr1qzg+zfffDPuu+8+PPTQQ/j1r38dfH/hwoWYM2cOxo0bh3/+85/BkU4XXnghTj/9dFxzzTWYP39+cPs9e/bgF7/4BXr16oVVq1ZhwIABAIBp06bhiCOOwNVXX42JEyeiW7duOckLQgghhBBCSP6tXLkS1157bcJtRowYgYcffjhPKSoPXt3ES6u2QjcFqlQl43WXSGJx+tcJySl/nEBBuvXRMCU0LmCU6BxJuinx/sbimQou0/w0TAmXYn2nUtfF0k2Z9ZR2dj5GjiguRJ4W4t5A96PYcpktQlrrD5ZqGxpKSiuQ+tLqLbjm5APg0ZTkXyojjgeBHn/8cdxwww3w+XwArIi0HQTauXMnxo4diyeeeAJXXHGF04eO0tnZiZkzZ2L//ffH73//+6gAEACoqpUFUkrMmTMHtbW1mD59etg206dPx2OPPYY5c+aEBYFmz54NALjrrrvCprr73ve+hxNPPBELFizA5s2bMWjQIADA3//+d+zduxczZ84MBoAAay2la665BjNmzMDLL7+MSy65xLlMIHFJxvFt98PDXkf6y3ubU95f3ZEToQ47Csfs3xNq715OJJEQQgghhJQBl8uF1atXJ9xm9erVBZ0+uxStaW7B3g4dHIGpSmBN9SFLv5+CkIrnd2ihE2s0UGmOArK1+4pnsfdM81OCOvCB7OuhnY9KSDSJ8pXkml7ibWgoBmBPu441za0YM7iy1nJ3dA6cefPm4ZprrsGoUaPw2muv4eqrrw77fOTIkTj00EPxyiuvOHnYuBYsWIA9e/bghz/8IUzTxEsvvYRZs2bhiSeewPr168O2XbduHZqbm3HcccehpqYm7LOamhocd9xx+Oqrr/D1118H31+0aFHws0gTJ04EACxevDhsewCYMGFCStuT3DKVKvxn9O+Cf0wlu9FprYcdhd3jJqL7OWejdtw4h1JJCCGEEEJK3YQJE/DWW29h1qxZ8Pv9YZ/5/X785je/wfz584P/JiCpafOZkJAIHQBkL5pNCKkMqVzxpT6BVLGlPtP8lIH/kexE5iHlKcm1cqtjEjJszblK4ehIoAceeACDBg3CwoULUVNTg5UrV0ZtM2rUKCxdutTJw8ZlH19RFBx66KH44ouudSA457juuuvw29/+FoAVBAIQtYaPbdiwYZg/fz7WrVuHgQMHor29Hdu2bcMhhxwSc4SRvR97v8mOEWv7eMaOHRvz/U8++QSDBg3CkiVLku4jF1pbW8GFhGfX2oIcv1gsWbKx0ElIW2trKwAUrO6UC6/whnXsLFu2DB7uSfCN7FC5pc/UJfz+rkVIly1bBkXLf2cRlV1ponIrXVR2pSmbcmttbUVdXZ3TScrYAw88gKVLl+LWW2/F73//exx55JHo06cPdu7ciRUrVmDnzp1oamrC/fffX+iklpRatwIGBklDfwghCTAwFF8oJXXFFtrOND9Z0Z1JaYrMR8pXkmul3oZGYmCodedkhZyi5uhIoA8//BBnnHFG1EiaUP3798eOHTucPGxcO3fuBAD87ne/Q319Pd5//33s27cPS5YswfDhw/Hggw/iD3/4AwCgpaUFAFBfXx9zX/Y/Iu3t0t0+2XdibU8IIYQQQggpfQMGDMCKFSswefJktLS04B//+Aeefvpp/OMf/0BLSwsmT56MDz74IGzKaJLcyKZ6dK/WICAhaD4cQkgMDIDKiy+Qko6aIuqszDQ/GQDOrD+VLNvTt/MxVKXnKck9rcTb0FASQEONhpFNxfOwWL44eicRQkDTtITb7Ny5E26328nDJkwPYM3B/corr6CpqQkAcMIJJ+Dvf/87DjvsMDz44INR09YVu+XLl8d83x4hNK5AU5EtWbIE37b54O15YEGOXyzGHT2o0ElIm/2EbaHqTrlo19vherlrLv/jjjsONVr8oHi2qNzS5/ca2Ljg3eDr4447Bi5P/v9RRWVXmqjcSheVXWnKptyKaRSQrV+/fnjmmWcwe/ZsrF27Fi0tLaivr8fw4cNpLaAMeTQFZ4/uj9lLN8BvCrhjrPFJsscZrTlBike69VFVGDjnUBUJvQQXNtcUhu/s1wP//DQ/D1Mnk2l+qgoDC8zdqSmsJMsiW1pgIZ9szj00H22MsYLkaSHuDXQ/ii2X43Q4s2bYUqVZ8tctY4CmcJx9xAB4tOhZvcqdoz1fBx54YMKp3gzDwJIlSzBq1CgnDxuXPeLmyCOPDAaAbIcccgj2339/rF+/Hnv37g1uG28kjj0dhb1duttHfqdnz55Jtye5xYSB3nu6Fuj9puEISF48T9gQQgghhJDyo2kaDjnkkEIno2xMGTsE8z7ahua9nfAZAuU0XUmxUKjTLUjj1gLZpDAYALfK4dVF8EoXSaaD1BQe/K9hmiXZQvSudRXNZEyZ5CeD1Y74DWGtLVIMJ1IAUkooLLuJtez8j9xvQR6BKEQ5VmjdSSaX2cIBeHUTsgx+CHDG0FjvwSVjBxc6KQXhaDtx0UUXYfXq1Zg5c2bUZ6Zp4sYbb8RXX32FSy65xMnDxnXggdaIlO7du8f83H6/s7Mz6Zo8kev51NTUoLGxERs2bIBpmkm3D/17rGMkW5OIOE8RPhz70bTgH0X4strfgGcexvA7r8WG887DthkznEkkIYQQQggpG9u3b8fjjz+OqVOn4vLLLw++/8033+D9999HZ2dnAVNXmvrUefDk5DFo6l4FxgCDOugdR0GPLpQXhcNgjf5jjCG0HzxZv6RuimCgqBSnzdJNib+8/3XR9H3rpoAhBHRTpJwmCcBrSPhNAd2U0MugMzkThgB8psyqLP1GV30WUsKrG2j3m/AVYIRGIZpDaoLzz5CAISSie75Li6YwDGiowpOTx6BPXe7W7i5mjgaBfvGLX2D8+PG48847MXz4cLz44osAgHPPPRfDhg3Dww8/jFNPPRWXXXaZk4eN66STTgIAfPbZZ1Gf6bqO9evXo6amBr1798awYcPQ1NSEZcuWob29PWzb9vZ2LFu2DPvttx8GDhwYfH/8+PHBzyLNnz8fQPj0FePHjwcALFiwIO729jak9Lh27YRn62b4138Jvbm50MkhhBBCCCFF5PHHH8d+++2Ha665Bo8++iiefvrp4Gc7d+7E2LFj8ec//7mAKSxdIxrr8JuzD0FVBU7tUapUzuBWS7BHnqSFM8CV5WXJYHXeVQV21Ok30wr26qZEh99Eh99Eic9kVBR0U8Kri5KfFqpUGUKi029CNwU60rwWAKvtzfaaJKTUMABXjRuKv181Fgf1K74po/PF0SCQpmmYP38+br75ZuzatQuffPIJpJR44YUXsHv3bkybNg2vvfZa1PyVuTJ06FBMmDAB69evx5w5c8I+mzVrFvbu3YtJkyZBVVUwxnD55Zejra0Nd911V9i2d911F9ra2nDFFVeEvX/llVcCAKZPnw6/3x98/80338SiRYswYcIEDB7cNcTs3HPPRX19PR555BFs2bIl+P6WLVvw6KOPolevXpg0aZJj508IIYQQQggpvHnz5uGaa67BqFGj8Nprr0WtSTpy5EgceuiheOWVVwqTwBK3o9WLX7/0CTr8ZtksXFzuVIXBZ1AncjnSOINL4ajWODyaAj2Lx8ddCkO1S4FbtXqtvXppTueWK26Vw6NyavcqjAQC05+mT1VYWtekWsZL7bkUBo1bUxWS8qRxoEpTUO1ScOPEAyt2BJDN8QVQXC4X7rnnHtx9991Yu3Ytdu/ejbq6OowYMQKKkv9w8+OPP45jjz0WV1xxBV555RUcdNBBWL16Nd5++20MHjwYDzzwQHDbX/3qV3j11Vdx3333YfXq1Rg9ejRWrVqFBQsW4KijjsIvf/nLsH2fdNJJuPzyyzFnzhyMHj0aZ5xxBrZt24bnn38ePXr0wCOPPBK2fUNDAx599FFMnjwZo0ePxnnnnQcAeP7557Fr1y48//zz6NatW87zhORG+7CDYdZ0w5BeNXAP3b/QySEF4FE8mPu9uWGvSXFRXQrOuWlM2GtCCCEk1x544AEMGjQICxcuRE1NDVauXBm1zahRoxKur0rim7t8I7a3egEACqcp4UqBnwqpfDHAFeg59hnZBW0MIeEKjBhLZ/qxSmFPC0b5QlJlrcuUunKeuU8CcGsqfIYJk0a2lSVTAu5SnAc0RxwNAu2///743ve+h8ceewyMMRx00EFO7j4jQ4cOxYoVK3D77bfjrbfewoIFC9CvXz/8/Oc/x+23344+ffoEt62pqcHixYsxY8YMvPjii1i4cCEaGxtxww034I477kBVVVXU/p988kmMGjUKTz31FH7/+9+jtrYWkyZNwj333IOhQ4dGbX/xxRejV69euPfee/H000+DMYYxY8bgtttuwymnnJLTvCC5tePMCwEAxx09qMApIYWicAUDug0odDJIApwz1PWKbssJIYSQXPrwww8xefJk1NTUxN2mf//+2LFjRx5TVR68uomXVm2FbgpUqQr8MdZrJcWnnDsWK51hSrgUGfx7NoQEhBBgjGW9r3Kkm5JGAZG0pNv2lnNbbZgSGhfUtpQx+x7CeRkPaUuDo0Ggb7/9FnV1xTe33sCBA8Pm3E6kvr4eDz30EB566KGUtuecY+rUqZg6dWrK6TnttNNw2mmnpbw9IYQQQgghpHQJIaBpWsJtdu7cCbfbnacUlY81zS3Y26GDg4FzBkkxIEIKSqKr49iJrlVDWCP8qJs2NsoXQjIjYbUvdA2VN0MALooBAXA4CHTooYfiiy++cHKXhBBCCCGEEFLSDjzwwIRTvRmGgSVLlmDUqFF5TFV5aPOZkJDI07KzhJAUSAe7VaWjeyOEkC7UupQ/KuMujsbCpk2bhnnz5mHhwoVO7pYQQgghhBBCStZFF12E1atXY+bMmVGfmaaJG2+8EV999RUuueSSAqSutNW6FTAwSPvf+PRvfUIKjgX+V2z7IoSQUNS2lD8q4y6OjgTas2cPJkyYgAkTJuCHP/whjjrqKPTt2xcsxmNZ9A8cQki56dA78NP5Pw2+/uPEP6Jaqy5gikgkv9fAqw+tDr4+67oj4PI4eiskhBBCovziF7/AvHnzcOedd+L//u//4PF4AADnnnsuVqxYgY0bN2LChAm47LLLCpzS0jOyqR7dqzVsb/VClPPiBYSUCAbAXoebIfu4rMoBxpzZVzmifCEkMwxW+6KbdA2VM5WmggtytOfr0ksvBWMMUkq8+OKLePHFFwEgLAgkpQRjjIJApOz0XPQGXN9sx85l9dAG9EfDuecWOkkkzyQkdnbsDHtNik/bXl+hk0AIIaTCaJqG+fPnY+bMmXjiiSewZ88eAMALL7yAuro6TJs2DTNnzoz58BxJzKMpOHt0f8xeugF+UxQ6OSRFnJX3guOVTFVYsC1TFQY9i0XXOUNwQe9s91WONMXKZ8oXkqp0295ybqtVhYFzDlWRdA2VqdB7CHEgCNTa2gqPxwOXy4Wnn37aiTQRUpLqV76D2i/WYI/CUDVmNAWBCCGEEEJIkMvlwj333IO7774ba9euxe7du1FXV4cRI0ZAURRs2LABM2fOxDPPPFPopJacKWOHYN5H29C8t7NsO6vKCQPgVjk6dQralSPOGEwhwRmgKRyGaWb8aJzKGQxhrdxO3XjROLPGAdFoIJIKu+316iKl+lLubTUD4DdoGFA5c9MwoDBZB4EaGhowY8YMTJ8+HVOmTAEAvPfee3jvvfcwderUrBNICCGEEEIIIeWCMYaDDjoo+Hrz5s246667MHfuXBiGkVEQyOv14pZbbsGKFSuwfv167N69G927d8fQoUNx+eWX4+KLL4amaWHfaW1txYwZM/Diiy9i+/btaGxsxI9//GPccccdqK2tzfY086pPnQdPTh6Dq55diS17OrrWByJFx+5UNChaV7Z8htVhzGA9ae9WOXxGap3OkfymBAr8hL4SGAlRjDXWzmtCUqFwa5SeR1Pg1RMHZxmskbYKZ6jSGDp1M1/JzBs/jf4pay6FQaFRQGGyzg0pJWTEr+y33noL1113Xba7JqSkSM0F4faAVVeBu92FTg4hhBBCCCmw//znPzjppJNQV1eHHj164KyzzsLatWsBAB0dHbj++usxfPhw/O///i969+6Nhx9+OKPjtLW14Q9/+AMYYzjjjDNw/fXXY9KkSdi6dSt++tOf4vvf/z6E6OosbG9vx/jx4/HQQw/hoIMOwnXXXYcDDzwQv/3tb3HyySfD6/U6cv75NKKxDi/8bCwG96D1GIsRgzV1lR0QoKl3klOYNRKmVElY05T5DAG3yqEphV2e26PyjNaGMAMBoFIuC6dp1K9akgwh0ek3IWTyietDP1c4Q7VLobVVSEnRTQmTHjgJQ6thE+KQDVNvBwBcePSgAqeEEEIIIYQU2sqVK3HKKafA7/cH35s3bx5WrFiBpUuX4swzz8Snn36KpqYmTJs2DVdeeSXcGT5I1KNHD7S0tMDlcoW9bxgGTj31VCxYsABvvvkmzjjjDADA/fffjw8//BDTpk3DrFmzgtvffPPNuO+++/DQQw/h17/+dUZpKSQJYGcbrf3nNJfCwBjgN1Jf8dKjMjDGISHBwMCZVT6d/tSnBnMpDJwxCCHgL6EBD1a6Aa+ReedTlcahcA4hJcw08qwYSVgjVqpcClyKParGiqwIIWCPG2KQMETuRtzYaXADMIW0OsIloKfYSWgImnbNVsyzg7lVDgZkPPqsVGk8tXKxr8dUeHUTVS4FnFltsUdTIaWEYQr4KJAfZE05JtO6R1Y6+zeCkCJn+SYRXocJBYEIIYQQQgghxHH3338//H4/fvOb3+Cyyy4DAMyePRu33norTjjhBOzYsQO33XYbbrnlFng8nqyOxTmPCgABgKqqmDRpEhYtWoT169cDsGZymDNnDmprazF9+vSw7adPn47HHnsMc+bMyToI9Mt9bdh85ZUAgPof/AD1P/hB1DY7H/ofeD/7FADg3n8o+t48LWqb1vkLsPfFF4KvBzz8MHhEfvm3bMX2O2diwzftmLa7A88P/y7W9Nwval83rfgLuukdAIAVfQ7Ea0NPiNpm0vrFOOKbdQCAPe5aPDT6/KhtDv1mPX60flHw9cOH/wjfVnUP26Za9+LmFX8Ovv7HkLF4r3Fk1L5+9t9X0NT+LQBgbfeB+L8RE6O2OWXTBxjX/BEAwGQcM4/5adQ2Q1qa8dNP3wi+/uPBp2NjfVPUdne8+0co0uoAXNJ0GP41+KiobS76bD4O3Ps1AKC5phf+94hJkBHTYR29bQ3O2Lg8+HrWkRejQ+sqF1MCjb4WXLXi+eB7Lx5wIlb1HBp1vOtWPYcGXxsAYHXvYXj5gPEAAqMvFA6flDjzyyU4cqc1im6fVo0Hjrwwaj8jd23AeV/8O/j60UPPxs6aHmHbuEwdt73/p+Dr+YO+g2X9D43a1+Ufv4ZBbTsBAF/W98efDv5e1DYnfb0KJ21ZFXx9+9jLg+m2+0cHtW7H5WteD27zpxGn4cvuA6L2ddt7z8AlDADAO42H4N9Dx0LhgG52dWSfv/ZfOHj3RgDAzqoGPHr4OVH7OXLHZzjzq2XB1w+MuQD7XDVh23T37sP1q7vK5aWh4/Bhn+FR+7p29d/Q09sKAPi45/74+/CTo7Y5Y8M7OHq7dQ13qG7MOmpy1DYH7t6Ei9b+EwwA5wxPH3E2tnfrbX2oWEMLFGHixiVzguf6r4FHYsmAw6P29dM1r2NI63YAwMa6fvjjyO9HbTNuy4c45esVwdczj/4JTK4ERiYJuFUFAzq+xU9WvwQhrM7H/zvwVKztMThqXzd/8CyqDSuw/F6/g/GP/Y6N2ubHX7yNUbu+AgDs8tTh90dErw18+M4vcPaXS4Kvf3fEedjr6Ra2TTd/O25a+dfg69f2Pw4r+o6I2tc1H76IPp17AACf9hiC5w48JWqb0za+i2O3fQIA8HMVdx99adQ2Q/duwZTP3gq+njPy+9hc1y9quzuXzwn+feGA0Vg4cHTUNlM+fRNDW7YCADbX9sGcUWdGbXPc1v9i4ub3g6/v/s4U+JXwaUr7tO/GNf99Kfg6k7ZcBGYq+mGFteVvD0nelj9x6A+jtknUltvXTKN/X1Zteagzv1xaMm15qERtuV3nJKLb8reGHBO1r1Jvy21PjDoLzbW9w7ZRhIk73ns6+DpeW37xf1/Hfvu2QwiJDWm25aGa2r7Bzz5+Nfg6si236/DN7z+LzVe+CADodtJJaLjggqjjfTt7Njo++AAAoPbpg6a7747apv2dd7ArZNrmpnvvhdqrV9g2rK3r9y8A9Lj44qj9FAoFgQghhBBCCCHEYcuWLcPJJ5+MadO6Ahu//vWv8a9//QuLFi3CAw88gOuvvz6naRBC4K23rE6+Qw45BACwbt06NDc3Y+LEiaipCe9QqKmpwXHHHYf58+fj66+/xsCBAzM+9jDDQOdKq1OlesyRMbfxrVsX3EbqesxtjJ07g9sAAMzodQlkZwc6Vq5CN7+JkVKim7895r6G79mMHr59AKwOsVj6t32Dkbs2AAC+iegMtNX524PbAIBmGlHbcCnCtlneL7rTEACGtmzF/i3NAIBOJTqQBwB9OvcE92UwJeY2Nbo37Hg1euwp/Q7etRGqtPLw84bYMxgM2rcjuK8qwwfdlFHTePXwtoYdj8vwJ8sNU0Iz/Djom6+60jQgdj04cM/X6N25FwCwMyTPDVNC4wKGKdHUvit4vN3ubjH2YnWih6bJY/qjtokslxV9DoraBgD2b92GA/dsttIRJ897h5RLqNCp7qoMX9g2tXpnzH2N2L0pmN4v65vCzt02cN/O4L66deuIuZ8G776w46ki+nrRhBG2zcIB0Z36ADBs7xY0tu8CAOyJk+eNIeWyT6uKuU03vSO8XIwYo/WEwMEh23zU64CY+xrSuj1mnofq3bk3bBsWEr40TAmXIuExfGF10w4oRDpo9yZ0C5TZ5m59Y24zIKTN2FbTM+Y2Db628DZDRLcZqjDDtlnaFN2hDVhtxqB9OwBYneix9O3YHdyXN067Uqt3hh2vKla5AGHbfBIjIAMAg0PKJVadA4CeSdoMwLpmQ7fJpC2326tKa8tjDWiLbMtjyUdbHqqU2vJQidry0HtkZFseS/m05dHlwiDDtonXlg9q2YaDAtvFGwWUqC0PTUNYmxGjLTdMiWG7NqFzt5Ve99DYafJv2Bj8vakNiv37yNi1K+w3qfTHyAPDDNvGmHhazH0VAgWBCCGEEEIIIcRhO3fuxEUXXRT1/pgxY7Bo0SJMmTLF8WP6/X7ce++9kFJi165d+Pe//43PP/8cP/nJT/Dd734XgBUEAoBhw4bF3MewYcMwf/58rFu3LmkQaOzYsTHf/+STTyD7D4ARCNhs2LgBny5ZErVd3a5d0ALb7N2zF5tibOP5cj1qQgI//1m2DIgYCaQ0N6POMEPWqpWBPzT9h1PSnapFAtCFiHov3X34TSendLLrRfFz/tyLhyFMGBGd7SJO4MBp1lPhJoyYx6M2o1xUYpuRK0605eWrq82gPCle1lUsg79Jt2zZgrUxfm/Wbt8Od2AbX1sblsTYxv3556gN+U363nvvQ/TsGqXW2toKpW0fGkK2WfvFWrS2tqKurs6pU8qYI0GgP//5z3j33XeDr+2pBk4//fSY2zPG8I9//MOJQxNCCCGEEEJI0TEMI2qkDYDgez17xn5iPBt+vx8zZ84MvmaM4cYbb8RvfvOb4HstLS0AgPr6+pj7sP+Ram+Xqc8BjDzAetpS9OgRcxujqSk4ssdsjJ6GCABEfXfoB4Q8tcmjV6aWLhf2Dt4fG1usTvPIKVNsXzQMCj4l2hznif2ttb2D0w/tcdfG3KbVVRM2RZGuRP+zWjAets1uT+x//H9Z3x+dqrUWVLyRBjurGoL7MlnslbnbNU/Y8dq12FMMftpzSHAKoZ1VDTG32dytL6oCTzLHGzG121MXdjwRI11+puKzXtY2Ulr5FsvahoHYWW2lZWvE1DJ2XK+5pmfwePFGP+yLKJdYIyAiy2VXnHL5qq4RRmDamU0xpsgCgG9CyiWeTtUdtk1bnCesP+sxODiF0I5q63qREb2KX3frE6y/8cpuj6db2PEMHv3ku87VsG3i1fN13QcE6+2WiHKxbQsplw419ppm+7Tq4DYMgC9WuUgWlqZ4Izc2hpTFxrjl0j1sX5Hj2KS00vBpz/2CHbfx6tTnPQYHp4OLN8pnS0ibEa8+7XHXhrcZPLrNMLgSXi6e2E/sf1nfH/tcVnq/7tYn5jY7qnsE9+WPcSzAqouhx+uMU37h5RK73m2q6xcclbK5NnaadqXQZngVV9g21JaXT1tuK5+2PHa5xGrLI5VDWw4AXjW6XCRSb8vtNdYybcvtNIS1GXHq1NqGwahvCPze7B07D8x+fYO/N0X32L+RRbe6sN+kUotuM6SihG9TF3tfhcCkjPxpkR4e40d40oMyBjPGMH6SHftJvOXLlyfZMjeWLFmCb9t88PY8sCDHT5dqtOP7S7rmJn993DwYauybWSqqNq6D0tGO747oA96tG6pGxh4mXIzsCPe4ceMKnJLS1q634wcvd9WpeZPmoUbLvE4lQ+WWPr/XwP/d0fXQwkUzj4HLk/9BsVR2pYnKrXRR2ZWmbMqt0L+LAevfSTNmzMDtt98e9v7MmTNx55135vTfQ0IINDc3Y968ebjlllswcuRIvPHGG6irq8Nf/vIXXHTRRbj11ltxd4z5zm+99Vbce++9eOmllzBp0qSMjl+I/F+5aTcunvM+vLpJT+QWiSpNgcKtThtTSHTq6dd5l8LhN4t4FfocKsdzD60ToTKtH9mkIZ/HJKSUOdGWExIpn/e4Kk3BZ3flflq2eP92KYZ/lwAOjATasCHxvImEFCvBVHzd79Sw19lofPFPqP1iDbYoDFVjRmPQU09lm0RSYlSu4tTBp4a9JsWFKwxDR/cJe00IIYTkSuSMCUDiWROcmjGBc44BAwbg6quvRq9evXDuuefinnvuwX333RccARRvpE9rq7V4cLyRQsVqZFM9uldr2NZCnVO5YD+xm872oX39nGW2D5UDull5U+2U47lH1olQmdSPbNOQr2OS/KNydY4TbXkloDxJTz7vcYnuPZUm6x7KwYMHO5EOQvJOKG6sPPjXhU4GKSNuxY1fH011qpipmoJx5w0vdDIIIYRUiPXr1weDPpHeeuutqPcYc/5fqRMmTAAALFq0CEDXWkD22kCRkq0ZVKw8moKzR/fHHxZ9GXOBbJI5LfDQjG6mnrGqwsLqM2MMqsLS3gfnHKoi0/peoWWSX5FK9dwTiawToTKpH9mmIV/HJPnlxPVXijhDTu59TrTl5a5S61w28nmPS3TvqTT0mDohhBBCCCGEOKxYZkxobm4GAGiaBsAK7jQ1NWHZsmVob28PW7eovb0dy5Ytw3777YeBAwcWJL3ZmDJ2CP64bCM6/TQayFEy/ae/Vc5gmAKmEMGOyXS6YBgATbGmntcUDsPMzzR/Tj3NnW13E4M17ZLKAMOhNBUDn2FCCgnGADAWrFsSEiIPswIpzMpXIQVMU4L6bMuP3W7kq80oFipn8OeoQuumAGfMug8wltc2uRSo3AoyUJ6kTg0Mzcl1XQr9LUEoCESIY5rPvwLc24mJI/uCx1gEmBBCCCGEVI58zpjw6aefYsiQIaiuDl8Qt6OjA9dffz2ArunnGGO4/PLLceedd+Kuu+7CrFmzgtvfddddaGtrwy233JK3tDtlR6sXc5dvhJmPnuQKo2fweHmnnl05uFUOHnhylzMGj6bkZb0nJ/bvxFPNflMCZbaOcli+yOD/5ZXXkADKK18LgQMo1pbWCliUT+A0VbkLAEnYuckAKByQMrX8ZUBFjBrq1AUUZgW0y/xUHePVBVRF5nyatlhr0FUyCgIR4hBvf+sf+lWHDSpwSgghhBBCSCX529/+ht/97nc4/vjjMWTIENTV1WHr1q148803sWvXLpxwwgm47rrrgtv/6le/wquvvor77rsPq1evxujRo7Fq1SosWLAARx11FH75y18W7mQy8Nm2Vlz17Epsb/XCb1APTDnwGQKMsWAHjsIZqlwKdFOUfYeik+zuL8ox4qRiDQABNCVXLkkARoqFr3IGVyCYr3IBry7Kuh1KpdoVc/A03yTyc60aQsL0m/BoSs6PVQooCEQqFhM6Bm1fEHy9ud8ESK4VMEWk1OlCx4KNXXVqwpAJ0KhOFRXTFPhy5c7g66Fj+kCh4cGEEEJK3Pe//300NzfjnXfewfLly9HW1ob6+noceuihOP/88/HTn/4Uqtr1T7+amhosXrwYM2bMwIsvvoiFCxeisbERN9xwA+644w5UVVUV8GzSs6PVi6ueXYnmvZ2Qsji6mNwqBwPgTbW3jESRALy6iSqXEjYiiKYhSo1LsfKKMQYpJYS0plxj6JrSyTAMeGlQTNbcqjU0IjheQgIMEv4iv/zdKrem5ZPUVhHnmSEjSGk9FgtdZYVh/57Y2epFnzpPoZNTUBQEIhVLEX4c8fmDwddb+5wIgzrsSRb8ph8PruiqUycOPJGCQEXG1AWWvdi1QPeQQ3tREIgQQkjJO/LII3HkkUem9Z36+no89NBDeOihh3KUqvyYu3wjtrd6AVhBArMIAkGiCNJQDqwnhQXcatcTvLpZ3k+TO0Wiq+OVMQZr3fLwjljTsRWQKpuQMqyOAtbaR8Wet0JKuBUlkFZCnBXaflO7TQpNApi7fBNunHhgoZNSUNTzRQghhBBCCCGk5Hh1Ey+t2grdFNA4y2jtmlzQTUlTEjnEMGVwhJeUEgbla0pC8y0WykvnROZ1qeStYUoIQdMrktyx61gpXA+k/L20egu8emUHvWkkEKlYknHs7HFk2GtCCCGEEEJIaVjT3IK9HTo4GEDTzZQlCUBIQGEITGlGUhGab7FQXjonMq9LJW/TWd+FkEzYdawUrgdS/va061jT3IoxgxsKnZSCoSAQqVimUoV3Dr/fsf3t/+BtqP1iDdYqDFVjRmPQU085tm9CCCGEEEJIuDafaa1zwqz1Tkh5ssqWURmnyc63+J8Rp4TmdSnlbSmllZQmqmOkWEhItPmMQiejoGjoAyGEEEIIIYSQklPrVsDAICXA4nR2k9Jnly2VcXoS5RflpbNC87OU8raU0kpKE9UxUiwYGGrdlT0WhoJAhBBCCCGEEEJKzsimenSv1iAggQTrn5DSxQDwQB8iZ/HGtZBIofkWC+WlcyLzulTylgFQqUeQ5JBdx0rheiDlr6FGw8imukIno6AqOwRGiIP2jD0Z7cMPwWEDu0Nraix0cgghhBBCCClrHk3B2aP7Y/bSDdCFhMYZdFH4YJAWWByEFlzPnqowsMB6T4wxqAqjfE1BaL7FQnnpnMi8LpW8VRUGzjk0RRZ9WklpsuuYSnWMFIGzjxgAj6YUOhkFRUEgUrGY0NF39wfB1zt6HAXJtYz3t+fYkwEAvY4elHXaCCGEEEIIIclNGTsE8z7ahua9nRBFNBqInnx2hqbwqNeGadIqE0kwAFLKqECQlBJCWmsjKIzBoBU7ssYZi8rrUqinnDGYQkLlxR+wIqXJvjZK4Xog5Y0BuGTs4EIno+AoCEQqliL8OOa/twVfvz5uHowsgkCEEEIIIYSQ/OpT58GTk8fgqmdXYnurF6YhCp0k6lB1kN8QcKkcPNDBzhmDW+XwFkE5FzO/KeE3TaicwRWY80s3BQyzvII+DIBL5fAbomDn5TME/LBGPWiKVVdLoZ76Ammzp+wq4qSSEhV2bagMfqOcWh9SSpRE86NWEJoBlBBCCCGEEEJIyRrRWIcXfjYWV56wP3p3cxU6OcRBhpDo9JswA9P8mUIGO69JcoaQ6PCb6PSb0MssAMQZUOVSoCk88F/nOvnS3ZOEFfy162op1VOJ0gwAUZ9uabCvDQoAkUIyhMSPnliOz7a1FjopBUVBIEIIIYQQQgghJa1PnQeTxw6GxumfuIm4VQ6P/UfjqNIUVGvW62IlAXh1E4YQ8OqVN6WQy4HgRjnmmZDW9HaANUIs0ye9WeAPB+BROWpcCmrcKmpcCqo0BW6VQUtx3xJAp25WZD3NBbddHoGysNusGpdSVGt7qNxaC86lWG1plcbLbkpQl8LK7pzKlYPx8LLSvLcTVz27EjtbvYVOSsHQdHCEEOKQKrUKfznjL2GvSXHRXAp+fPORYa8JIYQQUh7mLt+I7RX8j/tUCCnhViN//zDohlmQ9KRKAgWd8quQDFGJZ50anyFQ7bICmP4Mh7OoCoPCZODvXcFQxhgUBihQ4JPpXR9UYs4QUoIxq0ysju2u3m1/EbVZjLGwdtVnlF8Q0BDlNZKwnFE5xbe91Yu5yzfhxokHFjopBUFBIEIc0vjC0/Bs2YivG6rhHjYMfa77ZaGTRPKMM45+Nf0KnQySAOMMtQ2eQieDEEIIIQ7z6iZeXLkF1F+emGFKuJTwReyllDBKYB2jSi3bSj3vVAgJCCGCf8+EYUpwBWBxnp4vleujHMVqrwCrTIpp7bXQdJZrfaF2qHRQWcXmUjg6DRMvrd6Ca04+oKhGE+YLBYEIcUjVpi9R+8UadCgM0tALnRxCCCGEEEIqxprmFuxup9/gyUhYHUSh08UISU8Ok9KV7Xo2MvAn3gxKdH0UTqz2Cii+Tu7QdFJ9IaQ4cc7AwbCnXcea5laMGdxQ6CTlXfFO/EsIIYQQQgghhKSgzWeCJqtJTWQ+Ub6RUiYD/8tqHwm+TtdHYcXK/2IsEztNxZg2QoiFMesabfMZhU5KQdBIIEIc4msaCB4YAbS9ujf+897mlL974dGDcpUsQgghhBBCyl6tW4G1bDV1wCUTubw3LfdNSllX/c382o83FVz4/kkhxMr/YiwTO03FmDZCiEVK6xqtdVdmOKQyz5qQHNh6wVWFTgIpsA69A1PemhJ8/afT/oRqrbqAKSKR/F4DLz+4Kvh60g2j4fLQrZAQQggpdSOb6tGjRsP2Vl+hk1LUGAAe0UfJGSh8RkqWGpjfxm9m9n2G+FPBAXR9FFKs9gpx3iuk0HRSfSGkOAkhISDRUKNhZFNdoZNTEDQdHCGEOERCYlfnruAfGgpenDpa/cE/hBBCCCkPHk3BOWMGFF3nYLFRFRa1yDpjDGrkohtFqFLLtlLPOxWcAZxz60+G+WRdE/E/L5XroxzFaq8Aq0y0IiqT0HSWa32hdqh0UFnF5jcFNIXj7CMGwKMphU5OQVAQiBBCCCGEEEJIyZsydgga66sKnYyiJqWETzfg1U34dBN+Q0AIq2Ok2PuN1Art2eJIPFKlkjEAumHCFBKuDDve7a9JCZhCwhACppAwTesa6dQNCJHew31UXs5QOYMQAn5DwGd0tVf2Z8WCMwZTSIhA3WFl9jAoA+BSaKK7UqEyaoPiaaz34JKxgwudjIKhOXAIIYQQQgghhJS8PnUezJlyJM59fCn26YVOTXEyhP03Gfyv37SeHHapDH6jeMey+81iTVluGZV52ikxJWBa/5fxPryhGZzFfkJRkTmjUxcR78jAtH+R7xeWzyiu9OSClxqikuEv/+qYkf4NVXhy8hj0qfMUOikFQyOBCCGEEEIIIYSUhRGNdfjJKA/9QzdNQgI+Q0JTcj/NUhnOlEQIIWWLwj+k1GkKw9+vGouD+lXmWkA2GglEiEPqP1gKbe9uAIDevQdajjqhwCkihBBCCCGk8nRzMbhUQOGKNUWPlBBC0oiKFPhNCY/KYCB3HX8VOqCHEEJICjSFAVIiaiBYmVAC07WxwP8xMHAmabRVDmkKr+gRQDYKAhHikJ5L5qP2izUAgLbhIykIRAghhBBCSAGFLtDtM0yKPqSIOqIIIeWGWXEFUioYQ7mOQeKcwa0qYe/5DGemoiSx6WaZRhTTRKPkCSGEEEIIIYSULSklDAoAEUIIIUVPN8v7nm2YEjIkIimlhF7G51sMDFPCq1OgjYJAhBBCCCGEEELKRuSSM0KW6/PEhBBCUkI3gZJSzsUlYf0usYlyPtkiIQGsaW4tdDIKjqaDI8QhG34xHUxYQwwlp/gqIYQQQgghhcBYeBhIlnV3EiGEEEJKifW7hIX8neRam88odBIKjoJAhDhEutzUdBNCCCGEEFJkWNTYIEIIIRWlfJeYISUo9HcJ/UbJj1o3hUAoB0jFEkzFpsbvhb0mJBsqV/G9/b4X9poUF64wDDuqb9hrQgghhJQ3zqj/jxBCKhndA0pLOZcXg/W7xMapSyLnGICRTXWFTkbBUQ8lqVhCcWP1iJsKnQxSRtyKGzcdRXWqmKmaguN/NKzQySCEEEJIDkX2pzDGoCqMFl4mhBBCipwWeFCzXO/ZqsLCpq1ljEGj3yg5pSoMHk0pdDIKjoJAhBBCCCGEEELKBmOAlIApJCQkGBhUzmCYNPN+KjgAUehEEEKIgwQ1/iVDU6w1tg3TLMt7NmcMumlCSgbGrNcqpyBQrjB01alKR0EgQhzi+mY7uM8LABBuD/y9+xU4RYQQQgghhFSWHa1e/HuTHz4TgGkG32cAFA6YojimmGEAXCqHzyi+cEvxpYgQQpzjVjn8hiiKe0Gqynl6tEi6KaApHB5NgVdPLxDEAHg0BYYwoZtJNwcAqAwwsshclQPp3Mq77vtdB2UZ7IckZ9cHzmjOPYCCQIQ4ZsDcR1H7xRoAQNvwkfjqhrsLnCJCCCGEEEIqx2fbWnHVsyuxdY8R9ZlEV+eKyllglFD+MVjTkmgKh5SV1bFHypdbYRAo3+mbSPmpcinQTVHUI0RD7xeGKeCvkOtLNyUM04RHU4LllKxtCc0ra/vUj5dNAAjo+m2hMCDTIgr9jUKcoXIGl8opABSCgkCkYjGhY0jzG8HXG5tOh+RaAVNESp0udLzxVVedOn3/06FRnSoqpimw7v0dwdfDvtMXCg0NJoQQQkrejlYvrnp2JZr3dibt0DOFhFtl8Bn57fxzqxwqt9YCEFKm/YRzNgJLLAQXoBYSUDgry05Fl1Kc5+VWOTgDvHppjUBIhd+UcGu8qDvUE9EYoJdiwklGfIZAlcbhVhW4FAlTSHjT6IF3qxzD+9biy51tkGAQUsDv0P3EpTBwzsDAwJm1XowhKicAZJMAvLqJKpcSLCchASEFpLQfn+iaTs3OK900CxaMNunBjpS5VQ4G61p0Or9cgWAgo+BPFAoCkYqlCD8O++L3wddf9zsFBnXYkyz4TT9+v6qrTp0y+BQKAhUZUxdY/sqXwdf7H9GbgkCEEEJIGZi7fCO2t1pTMyss8foPElandb47aoSUYMz63aGb+Q0EcM7gVrsWRfYZhesoyzWjSBf/ENLqxCzO1GVHAiU3vVYoCgBVHp8hUO2yOopNmd4QDCEl6qtc4Dywdo3h3HUtAag8/N+n/godIiJh3SvdqgLGGBQGKFASfseX7bCeLFFTkhohrZzKRX5JgAJAcVAQiBCH7PjB+djV1goAMGrrCpwaQgghhBBCKoNXN/HSqq3QTYEqVYEpks8DU4g4gWFKuBQZ/Hshjs0Yg5SybANAQPEuAK+bEuXcLVWs+U5ILEICQghrpE2a7aFhyq5ObCkdbc9D22rASmMlX1uR+ZGIaaYxBxwpqFzeD9OpM5WGgkCkYkmmYHuvsWGvs9E+/JBsk0QIIYQQQghJ05rmFuzt0MFhTaNjFulD0xJdHeX57tOzj51slBTJLcp6QoqHIQCFp39dSgDtPmvtOadH94W21XYaK1lkfiSiV3helZpc3Q/TqTOVhoJApGKZigfvHnpPoZNBCCGEEEIIyUKbz4SERCk89FnIFVNkYA2F0ly1hRBCnCWzaA3NYEDf+fbUbqtztf9SE5ofybcjJPU6U2loIQRCCCGEEEIIISWr1q2AgUGWQP8PC/yvUMcO/S8hhFSybNpjleeuPQ3dJ7XXqecB5RWxUV2IjYJAhBBCCCGEEEJK1simenSv1iAgIYp4rjMGgDPrT767J+xjI+S/JP8o6wkpHirPrD1mAGrd1sRKTrfnoW01YKWxkkXmRyJahedVqcnV/TCdOlNp6BIhhBBCCCGEEFKyPJqCs0f3h6Zw+E2R0oigQnQQqAoDY9YfNc+T1dvHBgDGGDSlfJ+TLdbOH03Jf7nnU7HmOyGxcAZwzjNqj9WQa9np9jy0rQasNFbytRWZH4koSnbrfJP8yeX9MJ06U2kqLgh03333BX94v/vuu1Gft7a24vrrr8fgwYPhdrsxZMgQ3HTTTWhra4u5PyEEHnnkEYwaNQpVVVXo3bs3LrjgAnz11Vdx0zB//nyMHz8e3bp1Q11dHU466ST8+9//duwcSWqY0NG0c0nwDxN6Vvsb/MR9GPGrn2LEr36KwU/c51AqCSGEEEIIIclMGTsE/eo8AAAjSRCIAXAVIAjCABimgG6YyPfcdZrCo17XuDPrMCv2rpVijbNwxgoyCiwfCnVNOYEB0Eox4UWkFLNPYVZ7bJgirSALg9V+hn4l8nWm7H0DgJQShing0w1U6lI3ofkRSUoJU0gYQsAUEkJYZUlhoNLAAKg5uh9yxoJ1IrSOeHUzB0crLRUVBPrkk09wxx13oKamJubn7e3tGD9+PB566CEcdNBBuO6663DggQfit7/9LU4++WR4vd6o71x11VWYOnUqpJSYOnUqTjvtNLz00ks46qijsG7duqjt//znP+O0007DZ599hksvvRRTpkzBmjVrcOqpp+KFF15w/JxJfIrw4zufzAj+UYQ/u/2174PWsgdayx4o7fscSiUhhBBCCCEkmT51Hjw5eQyaulcl7VRQOIPPyP8S0n5TwmsI+EwJXeT52IaACASehJTQTQEzwzQUe39kvvM2VT5DFKTe5QNngLdEz82tcnBemoGMYlGK5a4LwGsIq01O9uRACIV3jQCyccbgdmDeNnsfXt1Au9+E1xDQBVCkTVpOMVijfHnEiA4hJXyGiQ6/iU7dhFcX6NRNdOhWWVI3fzQGoEpTUKUpwYdlCs1vSnTm6J7hM7rqRGgdOem3i/DA/M+xszW6b79SVEwQSNd1TJkyBYcffjgmTZoUc5v7778fH374IaZNm4b58+dj1qxZmD9/PqZNm4YPPvgADz30UNj2CxcuxJw5czBu3DisWrUK9913H5599lm88sor2L17N6655pqw7ffs2YNf/OIX6NWrF1atWoVHHnkEjzzyCFatWoWePXvi6quvxr59FDwghBBCCCGEkHSNaKzDCz8bi+MHqFGfMVhrKzAAhijNzupsGEKi029CN0XgvxKd9FQscYiZwQXlVqxpCQvNCszmJpDBkdtp8moTjObjDPCouZn6kaFyg2Z2W9rmNYLvmULCZ2QfqvEaAh1+Ew7sKi9UzlClccfXLdIUhiqXEgy42czgfaz07uFaAef0s/NK4QyvXXMcfnLsENS4Km/M1PZWL2Yv3YAfPbEcn21rLXRyCqJigkD33HMP1qxZgz/+8Y8x54mUUmLOnDmora3F9OnTwz6bPn06amtrMWfOnLD3Z8+eDQC466674HK5gu9/73vfw4knnogFCxZg8+bNwff//ve/Y+/evfjFL36BAQMGBN8fMGAArrnmGnz77bd4+eWXHTlfkn/7Rh2JXSecil0nnIp9o44sdHIIIYQQQgipOH3qPJgw2AW3Yj356tF48L+mKK0n1p3uWJOwnpC186CQnVKFojLAo3K41eI691KdSi0bflNGdfKWksj41ZjBDXBxqyw1heHm0w5CU0NVzmZ+dKscT1w8BrVuFdUah0vh0BSGwT2qUa1xVLtUqIoCt6qg2qWEtYc1LgW1bhU1LgXP/OQo1FepaU+j6NE4PE43UiVCAvjv1r0QUkJIa5qpUrq3OMWlciicw6NZdcmjcmjcujY4uv6ko0rjcKuxRwCVcj7XelRUaRw1gWtxcM9qnH/UgORfdIhXNyGkRJ86D+44cyTevPYEeFQOl8LgUjguPnogfnfuYWFthJ1Wtxr//qRw56fT5AzoWa05u1NY934hJJr3duKqZ1dW5Iig6EekytCqVatwzz334M4778TBBx8cc5t169ahubkZEydOjJourqamBscddxzmz5+Pr7/+GgMHDgQALFq0KPhZpIkTJ2LRokVYvHgxJk+eHNweACZMmBBz+xkzZmDx4sW45JJLEp7P2LFjY77/ySefYNCgQViyZEnC7+dKa2sruJDw7FpbkOOnSzU7wUTX0xue3etgKFUZ72/fmBEARnTtL418WLJkY8bHdUJra2sgHYWpO+VCSIHre18ffP3BOx+As9z9MKZyS5+UEoNO7nq9/L1lBVk0kMquNFG5lS4qu9KUTbm1trairq7O6SSREsGY9cfqYLbu86HBj1Ihcpxg6zdQqeVKdiQAVeHwGcU1CqoSR6dJWNMUlirGWNjaXlJKuLSuLrZ9Ph079/lydnwhJVyq9YAz5xyuwD87+9Z5sKs9fKp7xlggyMOi3j/xwD7o082DDn87zBSHdElYdTa4H1RaS2LdU9RAELPSzt2mmwLuQB1kjEFVGNSINXx8hgmRxlBBQ0jEWgZIN0vvHh6qpVOHwq1pAxUGNFS70JnHuUslrDy0eVxKWFkN61uHIwY1QOXhma8wwEiwLJXKuTXVbCbDQePgjGFPZ3ZrtsdiCAm3yuEzBLa3ejF3+SbcOPFAx49TzMo+bO/z+XDJJZfg8MMPx69+9au429nr9wwbNizm5/b79nbt7e3Ytm0b9ttvv5gjiyK3T3aMWNsTQkoLZxx1Sl3wTy4DQCQzjDFoVV1/ChEAIoQQQkh+WQtsl173Ua6DQDJXQxSKmCkBIQT0IqsPuS7rYlVO5/3FjrbgNSWlxEurtkI3Rc6mgzNMCX+sYGYGxxMZtJG62fWdSvwnlZTheVCJDFMmvI9kcu+Ntc9SvYeHEjL83ISQWPrFN3lNg2Fao6kAINWxp8nyPhdlo3GWk3uDYUqAAS6FQzcFXlq9JZgflaLsRwLdfvvtWLduHVauXBkzWGNraWkBANTX18f83H6S0N4u3e2TfSfW9vEsX7485vv2CKFx48Yl3UcuLFmyBN+2+eDtWRqRVNVoh+Rdl4C3xzAYak2Cb+TOuKMHFeS4NvsJ20LVHZIZKrfSRWVXmqjcSheVXWnKptxoFBAJJWTlPqmdSKXmSQkPPiFFzKub0BTrKX8hgb0dOjiYFSDJQcBVAtjwbXvU+5nEYzIdKWl/J3JUVCWpzLO2SFh1Pd5Ugpnce2Pts1zu4aHn1mmYaPUZSb/j9PHXNLdizOCGqM/iBXKT5b1EDsomR1FlCUAIa5Q4B8Oedj1ufpSrsg4CLV++HL/97W8xY8YMHHLIIYVODiFx/eW9zck3inBhgQNHhBBCCCGEFKPI7oPKm2grNRX48D4Aqg8key4lMAVSCKszVAJgwTqW6xEyHX5nnmIX5TQkK08qcQq8WOw6H/+z7PdZTm22fW6iQJGttkDgKdW2KVne8xxMK5vL8rbznzHr7215DsQVWtnOVWQYBqZMmYJDDz0UN998c9Lt7dE58Ubi2HOS29ulu32y78TanhBCCCGEEEJImljky0oNdyRWiVM4AVQfSPY0NboOWSuQscDfrf/lenBMtSt6tptMrmueqznryliionUFRoTlC4O16H0hJGpPM21rI79XTm22fS6cs4yfxHAlKWt3gs9r3WogHamJl/f2+kY8Bz8kclne9r6ltP5u50elKNuzbWtrC66v43K5Ym5jT5/28ssv4+CDDwYQf02eyPV8ampq0NjYiA0bNsA0zaip5mKt/zNs2DCsWLEC69atQ8+ePZNuT0pL77dehGf7FgCAt98AfHPaOQVOEcm3Dr0DF/7jwuDrv5zxF1Rr1QVMEYnk9xp44b6Vwdc/mjYGLk/Z3goJIYSQihTZfWD3tZTPs8TOYKjMfFE54NAAClKBrPYkupPSoynB9T44A+qqNGxv9YLn6AJjAIb0jJ7OPpMOVLfKM2oL7O9U4vpitlj55lI5pGRoz1ND49EUcA4gz4MaGJBwzatY916FMZgJ6kusfZbLPTz03Go0BXVuFbs79LT3oSkM/gRlrXIGX5zvjmyypktOdW3keHlfpVl94FJK58smR+0JA8C5NfJRQKKhRgvmR6Uo254vt9uNyy67LOZnS5Yswbp163DmmWeid+/eGDJkCIYNG4ampiYsW7YM7e3tqKnpupm2t7dj2bJl2G+//TBw4MDg++PHj8dzzz2HZcuWRc1VPn/+fADhc5iPHz8ef/3rX7FgwQIcc8wxMbcfP358didOCqbbmtWo/WINAKBt+EgKAlUgCYlWf2vYa1J8fGn+0CKEEEJIaWOMQVUY9BJbWJoH1hbJFStfUHL5kg2FAZxzaIrM6XmnW3a5LutiVU7nPbxvLb7Y0QbAurbOHt0fs5dugJ6jRahUhSUdEZCqTNpILTDURTdlRS4HxJjV2Q7EbkNT7WQvZarCEp5nJvUq1j5L9R4eijNr9Ix9bpwznDC8N179sDmt/agKy3ikjKoweALBm5RHAiXJ+1yUjS5kTu4NqsIACfhNAU3hOPuIAcH8qBRlOx1cVVUV5syZE/PPscceCwD49a9/jTlz5uDwww8HYwyXX3452tracNddd4Xt66677kJbWxuuuOKKsPevvPJKAMD06dPh9/uD77/55ptYtGgRJkyYgMGDBwffP/fcc1FfX49HHnkEW7ZsCb6/ZcsWPProo+jVqxcmTZrkeF4QQgghhBBCSKWI1UGi8tKbUCbRlC5OEFJCU8q2SyAmzgBTyGDnbS6Pk/p0O10jMSpNrsshl0JHvzAAB/brBlNIGELAFBLnHTUQ/eo8OTm2NRog9rVr959LKcPSk2y0jqakVwdNIWEGOn5Lt2s+cx5Vgabwkry3OIUzBsMU1p849SyyXiWrh5yxmNukWz+LTe9ad9Q1O2Fk37T2wWBNNZipRPd7O29jtRvJ8l7NQcCzsXuV4+WtcgZfICjfWO/BJWMHJ/lG+SnbkUCZ+NWvfoVXX30V9913H1avXo3Ro0dj1apVWLBgAY466ij88pe/DNv+pJNOwuWXX445c+Zg9OjROOOMM7Bt2zY8//zz6NGjBx555JGw7RsaGvDoo49i8uTJGD16NM477zwAwPPPP49du3bh+eefR7du3fJ1usRhRl13+Hv0Cv6dEEIIIYQQUlhCSuimgGGmPka7WKadMYSES2XwG86lRgk8XSsB+E0J3aysedF0AejCBIM1LVyOBmmkvF8GayonxgAlh+kpVv4SfLJfSKDTbyI06QpneO2jZnTqXdfTeU++i3HDe+Gbfb6w97Nl15l4a3H4DQGfYUa1eQzWk/CaEr2Oh2EK6KZIq90rlxFcmWAADurbDZ9sa4l5b2n3GQmnSXOak/UrHb4YDVZkPePMGn3i1U1IAMmaOJ8h4Ed0XY3cD2CNaiiVJvPaU4bj3jc+C3uvodqFKk1JufwYA7y6mfTaizcNoW4K7Gz1ok+dJ2rtsNZOHXOWfoUOvxmz3XCrHD6jq43o9JtgzJq5Lb2WI7m+9W6ccEAvPPfB147u12tYI4Aa6z14cvIY9MlRkL6YURAoRE1NDRYvXowZM2bgxRdfxMKFC9HY2IgbbrgBd9xxB6qqqqK+8+STT2LUqFF46qmn8Pvf/x61tbWYNGkS7rnnHgwdOjRq+4svvhi9evXCvffei6effhqMMYwZMwa33XYbTjnllHycJsmRzVfcWOgkEEIIIYQQUvHszg1TyLAOo1QVS99mLqa+sXcZmBUlpx25oQGnYiPRFXBRGFCoWIRVBhJ+3eluNJIrjHUtzK6bJkxhBWwNX3jH6/ZWL15e3QwlMG2YKbKfLFzl1hRw8QJAppD4ZGtLzLZDwmpTDNOER1OgBKIUn21rxZY9nTDKNKoz4eC+6N+9Cm98sg07WmOtlJI6u0NcYQyf72iN20ZLFK5NKbRY9UzhDFUuBbopwBiDP0m0O15dDd2PIawRKrECUaFqXApq3Cp27ku/7ONNSaZyK/qRzvMZj7y9DqaQwXOxp4VTOEO1S4HfMGM+BFDtUnBAn1rsaPVib4ee9HwT0U2JHz2xHE9OHoOm+q7+bVNIzPnPBrT5jKg2KlgWkHCrHKaUMExprXsFCQaGhhoN3+zzQeXMagvTeOgmFIP1MAQkw0urt2Z8nvE01ntw9hEDcMnYwRUZAAIqNAj0zDPP4Jlnnon5WX19PR566CE89NBDKe2Lc46pU6di6tSpKR//tNNOw2mnnZby9oQQQgghhBBCUsNgPZ3qM9IPAGXCpbC0RjRo3BqRko5E8+N3r9Jw6bFDMKxvLa75y+qUztmUgTUKkizSnS6VAyrnUDiDhPW0cLETEqjSOKQELjthPzyzbGPeFnQHYj9NT4rXoIZq/O68w/HUkq+wYM324PUWObKsSlXgNwX0wIXrVhl8RnaBIDNBoEZIK+idjIQ1mqDKZa2FcdWzK8s2AAQAa5pbcfcPD8G07x2EI+78J0xhIt3L263ao1pQMu1aLJwBKgOeuexo/PTpDwAGSCHhy0HEKrSe2SOC3KqCkU11+OjrvfCm0O5F7sM6B2s/HiZR7VKTBvZ8hoBuphcAcgVGIbHA1HRCAkIK3PGDQ9C7mwsAw8//vCKtJxx27vNBCBl2LjZrlJManIpNSAmA4bELj8AJw3vDoynYtKsd5z65HDtbfVm1Ic17O3HVsyvxx0uPAtDVbvgMM+H6ThJWXla5FLgUYO5lR6PNZ6DWrWJkUx2OvPtfAKwgjkuRgQdArCARD3kw56rxQ9HNo6LdZ+LJxeshwYLbARJeXWBHqzfpedR5FLR6U78O3SrH2zecWHFrAEWqyCAQIYQQQgghhJDyZYj8jUBJuwOVpT/hXLytOQM6dBOGkPh0W2tae5USqHLxqOlfsiEkoAbWHfDnKQiXLWtUkIRbtTqHCjW1EikNXsPEmMEN2Phte/i0SRHXNecMbtZ1ffkzfDo+lPVUvgjW1VD2dG6pzEJm7wewRiyVs537vJi7fBNunHggFM5giPTb39D10+x2rRTXp1E4g0tVcOzQXsF22idy197Fqq88zQcP4tV5vyHhM/SU9pFuzM6eihWwrmuFAQoUXHj0IADAA/M/T/tBDsjE1699LFXpqllH7dcjGLT424qvsacjtfNNZnurF89/sBlAeLvhUhg6E/yeCU3/mMENcbez8yzyKlEVhguPHoS+dR689cl2cG6vUWRtFzrdnFvlMOIUHGNAmy+9QhVSVnwACLCmUCSEEEIIIYQQQsqCbsq8TsWTbgwok2ne4vWZqQqDbgq8uOprvLgyvelTJOB4T6aQgBACMjBlTKkwTAkhBF5cuaWi1zohye1u92Nvhx+bd3ck3ZaxrqfgnapXhmkt1h4q9HpLdY12a7otGQwGlSvDlHhp9RZralApM2p/7TzPJJ+LSWTdyUc7HXlMU6R/zFjp9gfWsUpGzaCc7PtYLF7dxEurtqYd0LWDO/a5MCDlWKR9zGTT6KXCpXDopsC8/26DECJYFgpnCUcC2WK1P+mId4TQuugKjMKKhyP99tQwUxspWe4oCEQIIYQQQgghpGxsbSvvTs1QCmPgYNjVpmNPhz/t78fp58qKIYp3LaB47DWCdrc786Q1KV+GkPjHx9vgTzF4kkrHajpireUVer2lczwJgIOVZEAjVYwBe9p1rGluzTgQZ+d5pvlcLCLrTj7a6chjdvij151Jdx9CWg9G8BSeYhAZPukQL96yprkFe7MYkZPJWnz2MTmyLy/Ord8Mezv8YSOm460zFimT9IeJc5jQush5krRkUKQS1tSQlY6mgyPEIbWffQh1n9WoGN3q0Dbi8MImiBBCCCGEkArkLaERKE5gzJp7HzL9nhEJGRhN1PU0cKJ1R1LdZymWQGmmmhTCnnZ/VG+swllGo0wyISMmJMum7mYwO2XJkZCBRe8zP9FyaR9CzyNf5xRaX40MnzwI3Yed7lTqbqbnGO97bT4z63xL9fsscL7BYzp0rdr55nTepHTsOBGcfNTFNp+R82MUOwoCEeKQPm+8gNov1gAA2oaPpCAQIYQQQgghBeBK9hRpidIUZk3FEvG+lNZTvJk8mM7A4FIYpLTm4ner1hom2WCB/5WarjQXrrPXpTD4KyyIWYoaalxRHbIq59ACC6K7lNxOuhN5fWVzvWUxs1PJYGCodatZ5VMptmmxhJ5Hvs4p9DhKhvfnWOlOpe6yDCMn8fKm1q1knW/pfj94TIeuVRmIpzHpbN6k9N04X421zypNgd8U4CyzaXQj1bopBEI5QCqWYCo29P9B2GtCsqFyFT8Y+oOw16S4cIXhoGP6hb0mhBBCSHlpqi3P+7tL5dAUhAVphJQQkOhT64KULO1F3jm3Ol+cXDBZ5VZHT6zupWIddMBgpbuuSsP2Vl/B0qFSEKjoqZzhjFGNuPv1z9ApwgOmsRZ8T7R+hsKQ9vplDEBkPzoPud7SWa+DARCQZR0IkhJoqNEwsqkuKt9SFZrnmeRzsYisOzxOO53LY9a41LSPGTPdzKq7yfAMz06NE8cd2VSP7tUaOlsye1jCPpd0Htqwj7mtxcy6vISwfjM0VLvR0uGHbtpTvEkoKQR3YrU/6bC/Gnn+oXVRCAnOGRTOUMWtNlU3Q0bxZJABDMDIproMUlxeqIeSVCyhuPHRgdcVOhmkjLgVN64bQ3WqmKmagrGTDih0MgghhBCSQ6rCMupczRRn6c2RrynpTxtldZCwqClTDFNCUzjOGT0QEhKPLfwy5X0GF6Z2MGbGGcC51XumxjhPhTMYWU43lwuqwsA5xzljBuAPi77Mas2DTMrXVorrjFSaHjUudK92YXDPany+fV/CbaWUwboUq53gnMFMs66oSvQC7oyx4PWWamxCCzwMxxhzZMH5SOm2i7miKgxnHzEAHk0BYyyj6zM0z9PN52ISWXdC600xHzPWPlyKFd5JVneNDE4t9D4WyaMpOHt0fzy+8Mu0YhFG4HxjXb9xsfBjzl66AXqW16rfFNAUjjMPa8L/vbcZqiKhmxKmkFB58jNKK/1pCK0XflPAzXjc4wik376oirMPu5Sq3I5RJaSCfP2Ta/H5nY/i8zsfxdc/ubbQySGEEEIIIaQi6YbM6knVdDBYU3ilvD2zRhKkK9FXGus9uGTsYEwZOySteA5jgM8QEA721KqcBZ+Q15ToZbtVXpyTKnFmpXvK2CForK/Kal9aFlOBOVkWxa4Y60EqetW6AQD79a4JOwczYq0TISR8RtdYBScmIGAIr1/2iBRTyOCT9KnijEFhDH27ubNPWAzueEMp8qy+SsO5Rw4Ivs7k+gz9Tqx2rRRE1h1bLs/HGmFprTNnCAFTSAgh0zpmaLrtum4IAYUjpborhIQrzSK372OhxzOFhFe3Rv9MGTsEWrrVKHDCnDEYQmCf10Cb1wju3zADfwLHihxpNmXsEPSr82T920ZKicZ6Dy48ehCA8PJPZRQqZywsL+IdwxQSumnCp5vwGSb8hnV+vkAQy2+I4DZ+Q0A3BRTW9fsg2W+Txu5Vabd3idJcKYqjVSakDOg9esPftz/8fftD79G70MkhhBBCCCGkouxo9eKB+Z/jwZVe6M4/2B6TBOBN41FjBsAb8iRvqp0YhgA6/WbUU8+9urnx5OQx6FPnQZ86j/W0ewr7cykMPWvc4Jyh0zDR6Tfh1a3/hqatSlPSCnL5TYkOv4lOv4FOvxn1pLTXSGUCn/zzGQIdfhN/Wr4R9/9oFPrVeZJ+h8Hq6I7MHb8h0upoUUI6771pPuWtpDmtUDGJTHepzNK8o8WLGa+twaLPvwmry526QLvPCF5HHboJEdKRG6tNSmc0BIM1IoAHMk5Iiefe32xdb7oJn2GNE0x1jz5DwGtYac4FfyZDMHKg1WvgvKfexQPzP4eQEpwxVKUxIsClIJjngPV3j6YkHVVQTNdlZN0JZZ9PLpLLGeDVBTp1M/jfj7bshW4KaGpqU4/Z+ewzzGBd9+oCHX5rf8kIxL72EvGbEu1+E+0hx+vUTZz020V4YP7nAIBB3dLLMU8gauQzBLy6wOfb9+Fn/7cyuH9v4Hq0j9XhN/HIv9dhZ2CK1z51Hjw5eQz6N1THnaouJYxh7P49g/WTMwa3yuFSOcwUHkLwGeF5sTNkClohJXxGV775DAldyODoHq8h8N0HF+HMR/6DW17+OLiNPxAcsn8fVLsUMIaw3yahurlV/O+UI1GVRr31GSJmmisNBYEIIYQQQgghhJS0z7a14sdPLMfspRvQ4ku/81HlDP3q3PjJsUPwk2OHoKm7B26He6VdCodbVdBY70GtW0G1S0GVS4GmRI+OsZ5+ZqjSODSFoZtbhUvlwUW17c9v//7BOKhf1zz3CmcpPYGvmxIXHzMQV56wPxrrPXCpHKrC4AoENTSFocqlBLdNh4Q1FV+yb3lUHlisvQsD8JNjh6Q1WsqpEQcSwOylG/Drlz7Bg+cehp8cOwS17tgdvf3qPIGy41FlqCoMbk1B3zo3etRoSY9r55XKGRojgk/xcoEB6FmjocatlkzwJFLoqAQG4JSD+2K/ntWFS1CKvm3345l3NsbsgJaANSqHAwqHY4utqNy6Hu3r3xQSnX4Tr/93W9aH2N2hZ5/AGFwqB2fW2iqFHAFomALbW72YvXQDOv0mTCGhcIZql5KwM13lDG4l9ihMhTOM6Feb8LjxrksGZ0fBMQA/PLwJlx47OP59JKTuxKIE6pc9RaBTHcWx7gN+MxAUSCFIaLftnX7TmoIv4vNd7f6U0uFUONKuR2c+ugyb9qW3V1+MSFSimIsEMHf5JvzoieX4bFsrAGBEYx1+c/YhqHYlXtlF5fHrmBASL63eiotmvwdTWCN2fIZIe0pIOy/s9NltUrLfC526wH+3tmCfN37wucNvoEpT0KvWHfxtAnTV5x8c1oiD+tVBUVL7vRMvzZWI1gQiFYsLHfttfS34ekP/MyF48h/phMSjmzpe+7KrTp059ExoCtWpYmIaAmvf3R58feAx/aAUyVQFhBBCCMnMjlYvrnp2JZr3dqa0WLfdCdejxoUrxu2P/XvXoEeNGyOb6oJPHU/73kF4aeUW3PLKJ46kkTNrWqLfnD0Kxw/rhZN/uwitgU4Qt6rApVhrh0hIMLDAwtFWx4fCgUvGDsbJI/qieW8nfvXCf4Ofd692hR3HehI3eWeOBPDnd7/GP6Yej2tOPgBrmlvR5jNQ61Zxyf++B8YYhLSmfMnV8/y6KfDXK4/GVc+uRKvXCJ73HWeOxPMrvoYZYyQREL0WQCrnmyohJJr3duLXL32MF342FtO+dxBWbd6Dz7a14r4314Izq8N0v141+HhrSyA9LKwMn5g8BrVuFSOb6nD7q5/g7yu2pJSHppD46xVH47Tf/ydYD+r/P3vvHidFce7/f6p7emb2wi6LgOxyWQQBETkR8LYaIWgUY86JihqORrwkKibHeHLUozEniSYajdFfTGLyTVCjCMbEKJjEE3PQRBGDxMjFG4Ki3FmW6y7D7s6lL/X7o6d7u3u6Z7pne3b28rx98ZKZ6a566nmeeqqpp6uqIoIjKQUaBzSugXMGxoDpYwZjV2sSew6nADDEIixUPcREARlVA4P+Jn0pGFwRQVtSgcB0u5957DCs+HB/iWorPRURXWca1/2IIzzdWd/Qt/ZLt3DX3YPjgyAAEATgjAlDsWZra1Y+PY49de2puGHJGiSzk9/G+UgcemYg3UOrAuOSCHD9LBQOICWrqIiK2RUwEXPrKn3VFjP7OGMMiuo+Ua1xjo15zoOqlERkVA2GJWIRAYwBj199MhiAf2w5hEdWbgHnmrmCy2k3Bn01kTXW2VYeZs+JExjw1c8ci4lHV+PZNbs8x5FCGHEsImioikVwoN1fgqWUpBQtrz9XRER09uAWXxUREWlFRYvHShKBARHGkLEYzZC/mDOkVK6PRwuWrMVzNzSBA7hj2fvozKgQs9vsuZFvKKjI+mbz4RRUjXfpN6B88YgAWdXl+8qTb4X6rKBoQEdGRU2FhPsumwYpIuCGJWtNfzaSYH6fd9xkNnQ63Meq3/4EJYGIAYugZTB18y/Mz9vrz6MkENEtMloGv3i7y6fOO+Y8SgL1MlRFw5svbDE/H3vScEoCEQRBEEQfZ/HqbeakjMAY1AKzLfoCBIZEWsGRlIJzjh+Rc01cEvNO8gWFAzickvH2zjZ89vijc35njGXfHHefsIuIAmY01mHsUZV53+iWVf8Tq62dGSxevR23zpmEGY11NlmCllUMKgd+8OdNiEkiIhn7RE6+uhljxc2o+SAWEZBW9JUDhm5OHz8Up48fiode3myRwV0ukQGzJnZtDb5pzxHfOuQAnl27O2tfZpZplCuia1XSoY4M9h5JmzIX8vmgSNm3r8M+M8pKa6cCDm6uCFr58f7Ab6P3JkRRQFxg6MyoCLh4riAcep+IRURb35BEBrWM267pb+KLGDm4EmtZm/5dNo7NaKyDYIlV1hiXVkqXXHZDEBhiTICSTSwbujTkigRcTierWt6ts6z1AfpkdUwUcfr4oQCA9rQ+iZ9WuubeRcE+eS8IDJLAbFtEapybclsx4lGhccQPisZxOFma1WHFkM9PhDxjYSkQBJb3GYMxhqgkQkkrZgK4O32VZdODxnjEwc1nnXhEQEcmeALM8E3DrwyJgg6risa7xsvDqdD7s8Y59h1J4+2dbbh1ziTX5x45YCLZJrNljB9I0MwXQYSEkOyA2J6A2J6AkOwotzgEQRAEQRAE0e9JySqWrdutnzEgMCg+JqxVTZ+QkVUNy9bvcj0sOCWrWL6hxeXu4uAceevzi/NMB+ukTUpWoQSYfVY17ikP5zxQWcWyfkdrTpIhaDvChDGGqCiEYquUrOLj/e2B7lm2fpdtNZvbFCfnHDsOJSGrGqKi4PtN/6Awpk9ClwpZ06Co3DyA/Z9bD/XK86J6C4rKoWV1ZuBm+57UoWE/L9w2geup2JIji0VXheTOhyF/oaEmX30MuXrw04/zyR1GHDBkKlf8DYqm9WzSWOOar2eMsGKy9Vll6bqdWLp2dyhxX4/t9u+C5voVlQMMkAQW+F4/FHpmSsmFt55zYsgc1hjfF6GVQMSAhTMRe4Z92va5O4z9f/eh+qMNAID2iVOw5ZZ7ulUeQRAEQRAEQRD52dB8GG2dMgQwgDFfE6D6NQwCGFo7ZGxoTthWwhjlJkJ+G5oBZn1Fl+GY97GekrCh+XCgCWDG4Nl+zceZPmGgcqDT8TZz0HaEjSDk9w2/bGg+HHiLttYO3efyLUzQOJBRNAhgpX8TvoSn2xtbzRkTiJ3pvj8ZV8p+w6GvFOlN0/McwSePeyq25MOQu5jztIqR301P3SnHKXdYvdSQSSjdYstQ6emFg4pavO8WkyixPqscbJfBGMKL+6x7G0dyAJqGko8RXs9MxTwnGDKLIY3xfRFKAhEDFlWM482p3y+3GARBEARBEARBFEl7WtXPP2D2hEghrPe0p3PPfdDLDR+v+gph3e7HVp5FyPYiJtG95Amiy+7ifJm7UDtExlDqzaTy+YZfirVHVoLsZ/drOLhtVZhzhVhY9IQfGHX0pM+VilK3oTfqKKhMPd0Gr57RdRJPMAz5vabQvbbrdLa7kB4iecspbX8v1ZabYZ5XJYmsx32pWJt1t07z+SZ7JlyxWG8NQ3M9NT54PaMVWx7AQhnj+yK0HRxBEARBEARBEATRJ6mOiWBg4Nx96yEvrPdUx3LfjdTLDR+v+gphzMc555isUzDVseA7G3jJ46ZLUWDZ85TCxVlmvnZIYvDzO4ohn28A/l5+LsaHWPY/qxxe11h/ExiDJArd9lmB6QeHW+tyku9MqmJglv/6IladlboNbuXHy3y+adA296SdJZF5bptVrBzGfc6uqcdHhpiHPZz1FarfK86VUn9m20qQABIYEA3RV6Oi0OMxI199EaE0Y5P1WaW7ubm4LbaHI1tPxDyvZ7RiywMKj/H9lYHVWoIoIQdmfx6HpzcBAOTaIWWWhiAIgiAIgiD6P1MaajG4UtIPS+bc15vGxhSeBo66KglTGmpcy62pkJA6kg5NVg541ueX3JVAXa2d0lAb6E1rzr3lEZj7W9vxiIjOTHjrcEQGVMREZDq73sbN145YRIRW4n2KNC2/b/hlSkMtYpGuw+H9UFcl4XBn1zaEbm0VGCBFGNKKBk3j5tZAsYiAqMiKOiwc0CfMcw6dd6k/rJVYxnoGI6cUj4nIdPbw/k7dhAGoiIrmxKJXvwmrrogAyI4tqSKi0CP7Yrm1y2o/13tcfgtbR8ZZcG6yeSUdCsmdDy/5rclTP/UV0gNz+bU7cvvBlKkEDlwRFQEOhDWiMsYQETiKDHfB6wMQEXP7n0E8j/2B4vze+qwyvDoKzhn2HknZ4n4QbAn8bhqZARAEQCvh+VH5npmmNNQGToqZMoc0xvdFaCUQQYREYnoTDs7+PA7O/jwS2WQQQRAEQRAEQRClIy6JmDt9JCRRgKxxX9uxiAIgqxySKGDutFGukzdxScScKSNCk5Mx5K3Pz/1A/pVAcUkM9CayKDBPeRhzf6vZ63tATyIEZdqYOkQE+7RE0HaECeccGVXrlq0M4pKI8cOrA90zd9ooW6LPLQnEGMPIwRWQRAEZVbMfOB/itnCcc8ilOPE7iyQKiGRXajDGcMoxQ/rcWqCI2HMrmCIigyAItr7htmKjVNK49clInpU2XuSLIcXgVZ7TNlZdFSO3s75CQ02h+pxy+1l94yV3WL3UkKlUK1rcZO9OTYLQc1Paus0FX88YXrYMqlfrs8rF00fj4hkjXeN+UDjnOXnjoDmliMgADsgaL0liMt8zE2MMcUn0XHXnhSFzWGN8X4SSQMSAhWkyRu59xfzDtHAPfiUIgiAIgiAIovRc1TQWI2riANwnzZ3w7LRTfW0cVzY1el73+akjQptQFRhzrY9zDlXjUDQNipr9o2lQNW6b5DH+WmjCOciWYEOqonnb7yzLkEfy2BMuGnCvuIjA8P0LpkCz6EDVOFKyiojg3tJSn0GQzs6MFfIN5+SyU36DKQ01vu3BAFzZ1GgrL5VRXH1izJBK0+eNFUHdhfMu/WoaN3VhyGagOQ9xKpL62rjNlz4zaXio20X1BFafN3QmMN23w54YFRiDompglriQUTWoDnuUZBUSy+33DN6xwJTF0Te0bJzjAfy1kBo1zrMJHztutjEQGDP7k6ZpyCga0oqKjKJBVVVTZo3rZ5Y5Y7Tgog+bTB71GbHByIVYY6xzQQUHt41n+kowZtNnKbZtk0QBwwfFQi+3FIQR9/wiiYK+gqSAzjXHqjTDvrLKEWHBUsbOZxXrs066yNV/XrFd3x7NPxGBdY2XgytCTz57PTNZiUX8P+8w5pC5QNn9lb41whJEiIhaBidvuMf8I2qZcotEEARBEARBEERAhtfEsXD+DDQMroDoJxHBgRG1+j3DsxMqVvYmUnhg+Sbc9Lu3Q5lQlUSGUXUVtvpUjSOtqOjMqEjKKlKyhpSS/SNrSMr6b2lFtU8EOmc8HAIK2Tdk/fC1z4x3bb+zLKNKjQPJjD5R6kaQbcgiAsPdF07Bn9/bg+a2lKmDpKxixj0vIylrrrrvSKtIOuoZUin5qnNInCEi5J/oEgSGkQ5bucGYPvnstGFSVjH7wRV4YPkm7EukUBmN2HToWR70Ca0nV2+zldeecfcJzmH6vCAwJBUVnWmlW4dcKxpHR1pFR1pBUlFNXVRIos2nlBA6BYMuv5B1aI1zrPhwH9QSb/UXNrqddJ80dDZqSCV+dtk0jKqrDHVFRTobHzKW7qdxICmXfis4gTFbcpNBX+kmeKym0TjX+8CRtK1vdGbjXBAfyjl7x1GlonEkM1rOxHtK1kzbdMr2OJpWdHk6MrpMGVWDrOqrAJMKN2XOqEBGQ06MTis8Jw4mM2rB+ozY0Napzz0JrOsMIafrd6RVZCyZIVFgph6d8eBAe3jblgLA9DF1oZYHAB0ZBZ2Z3PhUbI83+lxP0Zm1qyjoyQnJ8ahhjQPIbv1mxE5jG7KUqgVKlojMPh4ZzzpH18SLSoDZYvvgCod8LJAtUopmjhG/vuokX+OcXwSW/xmtI63ggeWbcCSl+JaZOWQuNMb3V+hMIILoozz95o5A119+6pgSSUIQBEEQBEEQ5WVyfQ2eu6EJi1dvx5JVH+Nwnve7OLi+6sFl9mDjngQWLFmLlkQKcjfP2YgIDEOro7hkxmhc2dRoTjhs3JPAgfZ0zpvfuXLqbw8rqvckn9fKmEJnD/idrBEFhoqoCFnVIGa37eLgULITUALTJ6L9IjB9gvGaM8bi/v/7EC2JFFRHAR3p/BN7xtURgSEaEfCba0/D79fsxDNrdqAz426zfxlVg2snqrhtZQeiEb09ipr7xvb1Z46z2cqL9pSCpMfZSC2JFB59fSteeGcPZjTW2XToVmdEZBCZ/obyo69vzWs3wyfe3HoIAEyff2bNDuw/EuylRi/bceiTj3OnjcTN50zEWf/fa1A1f+dt+cGw23Ej9LMYjBUSf9u4z/SrMJBEhqgo2JKThr4FBqRDyGZxDghZ+9VVSZg7bZTpPyc11mHx6u14du1OHGzPuLZt+KAYNM7R1imH2nYnbraTRJbjj273SREhu6qJIS1riIgMkih4JoAMez76+tZAsaEQYtZf88XN6piIsycfjbe2HUJrh2zGemgc4GGeRJRbkr5VG/LWZ8SG2grJjHt+V3S4+YcRD275/Tt4/OqTgzfCgWG7/9vQkvc6IxEX5DgYY7w1tg3tbh+MRgTUVUnYfyQNSRTAub7CxakmZqlT0Xi3fTIuiXjw0k/hvuffwsZDen0cXdsP1lVJEBnDwY6M2UcqoiL+7VMNeH3zfrR2yNC4BlWzbxvn1CUDcPUZY3Htp4/JGY9kVUMxTyfW2P5fn52As3+80pTv1GOG4MO9R3CoPYOUi086vbm+Nm6Ld9ZxTs7jGJVRESMHV+CT/e2etmDQt21ze0ZTNY4X3mlGysXWXsQierxyxuiBCCWBCIIgCIIgCIIgiD7P8Jo45jc14pl/fAKBZbe1cpkkEBjD3kQKC5asxXM3NJmTAcZ3zW1JAEBMEpAq4i372ngE3/nX43HMsGpMaaixraIw6gg0eQbgf9/dg/88ewIGV0btvznK0bg+iVeoeA7gFys+wflT6wtOhuhvq4s4bdwQfPUzx6I9reCGJWsh6PM06AywAujoQTF87wtT8NXfrDP1XCzGJOrQQTHc+YUpuP1zx2Hdjla8u6sNP/vrx3riSmAQBYaZE4ZjcHyvrT1RkWcn8DgY9MTArXMmFaxX4xwb9yQ8dVwREZFRNTS3JdHamYHGed46OWAmlFTVn7+lZNX03/lNjVi2bpev+6wwx6naogBEmABF0wDO8cYnB3HzObk+FRGQc55EIaTsPRywJf2sZWucQwCKmtyUBMDaVaMiw7t3zQEATPv+y676LhaBAfGIiHR2FUJtXMJ9c6fi0xOG2vr68Jo4bp0zCTeedSw2NCdwqCOD/UfS+N4LGyAwXZZ/+1QD/nvOJNvvkgjc9tx7RacrRMZyVlQ11MZxsDOjn8sC3QdrKiQcbM8ADDmJWGtb6yokfOvzk3FUdQwLFq/Je5aOzZ4hZYCMyWcjZjonoyOCnoRTNH3F3Podbfjddadhf3sGO1s7cd+LG3GgPaOvoizhQrPBFRL+46xj8YtXP/asz4gNB9vT0Li9Lc5+FRMFpH3Gg31H0liwZK0Za4rB3hcLXasnDhiAT40ejGljBuOJVdvyjgVCdnWMseok3c0VbA9fNg2fnjAUJ93zV/0LxlAZFaBpGr79r1NwqCONIVUxnD91BOKSiNc3H8A3l76Lgx3BdwBi0LcXVDQNnRkVdyx7DzUMkERAFERoHPjV/BmojkUwpaEG1z65Bq2dXcdNCIzhqqax+N4XpmBDcwLtaQXVsQjGD6vCJ/s70J5WsGDxGrMyI1b959kTUBXrmrbfm0jhK0++hX1Hilv5JTJYYvtEm3znThmBX14xAxuaE7hhyVocSck2ec49/mi89MFeM5a+cstnclYdO8e5n102DV97aq1ZhsiAv/znmZj/63+CMQYB7kk5xuD6jGb4aErR41wh4hEGxgSbbQbaGUBOKAlEECEx8qn/h8rtHwMAOhuPxe4rvlZmiYiepiJSgecveN72mehdSFERl333VNtngiAIgiD6D4tXb0NrWp9VqJBE1y3KYhEBaUVDSyKFxau3mxP/i1dvQ0siZV5T7Hxhe1rFtoOduOSk0a7yGXUEK1PB4tXb8Z+fnWD73pkEklX3bdTcaO3I2NpfCIExzGjUtwkSsweeZAJux7PvSAbf/dMGm55VWXV947cQ+lvwmrlFXlwScfr4oTh9/FAsfmM7EqmurYfc5osYY9k32oNNmsqqlnfVhiAwxJjuYx1pBaKgT4x51ZlRuhIsgssEvheG/3LwonwqFmHozFiSQEyAFBEQ4czWP5w+JbAiUjVM34pPzp6XIWcnt61lSwLTtwkrInkQkyLQMoqZKOCAOdmn+6q7votFEPStEtOKhsMpGW/vbMNnjz/a9dq4JJr9BgDufXFj3t8fWL6pW/K5RYCkoiEiGPtXMciKirakDMb0Ptjp0QcZY2hNyti8tx1nTz46bwIIsNszFhGgdCPZZiAw+yoJR+4SAmM5fvv7Nbtw65xJeGXTXrR2yuZ2i2HI40VrUsYf327OW58RG5LZrfVsqwIdWSMpoicd/L4w0JJIgXNuxpqgWG0XFRmSefqh0YdjERHDsucHyQUSVhXZ/iKrHMxybk6xuTmvPicIgusuOG/vbEVrZ3FHQDCGHB9LR3n2Nz2mz5o4zHa9WxnOvg4AMxr1FzsiPrayXbx6G1oOB4/1BkbMMmK72+8zGutQERVNHzWIRgRbLM2XTDF0cs7xRyNmuY4B+P2anWhJpPTEWkRw3c7S6xnN8FGjf6keq3ENVA7ERGazzUCHzgQiiJCI7W1GxY6tqNixFbG9zeUWhygDAhNQG6s1/+j/QCJ6E0xgiFdJ5h8W9omtBEEQBEGUjZSsYtm63VA1/a1qrwlLxvRtomRVw7L1u/Q3S7P3yqqGqCgUnOzMh8o5lq7bZTtDwypfocky1zI1jmXrd+WcQ2GdAEnJKpQAS4yMMp1y+oVznnfbF9c6Ocf6Ha02PXfnGBhF5a7yO+0X1hMf51zfQquAzIaPaRzZ691vMMoz8LslGGP6hNjSdTvx3JpdRW1x5HVEubV/LF23M8enijmMXlG5zQiKytHWmbGV3Z0+57zfyy+c+u5ufc44ErgMx2cjRnQHN/MkkrJpN0MHfmKdtX3pAu0LU7dWcrbJ8hnX2zozocV0P2QULSe2ecnp6+g6zn0ngCIC69pusoj+6bSdH10Zdakax7J1uwva3rBPkXneHNzGWC9Ssoqla4uLk1asPnYoVXgcsNLd487CaIOzj1h9pSdmRTjnvvqkW2y1+qjIgvko0QXNUBIEQRAEQRAEQRB9ng3Nh9HWqb/dXug9D0FgEMDQ2iFjQ3PCvFcAgxDCSyKHOjLY0JxwlU8oYrqFAWjtkLFpj71M6wTHhubDgd6oZgxm+/1eb6XYyShjG6Qw9MwBbN57pNvl+MU4/8EPgsDMt9y9dOUsL4hKBTAcbJdxqMi32/PZz+gfB9vlHJmKMTuHfRKUA/jze3tKtjsXB1z9Ooj9/OCMI0Fx9ikjRoSNajkLxdCBn1hnbd+mlvz9zKnbUh1xlG9S1yrvn9/bE2pML4QA/7HNKwFrJdhZa3q7i02wFNMvjLraOmVz3C0oZ4h2cBtjvdjQfBiHOsLpV4aPqVpJdxcEYI8PYbXB2kdKeAyZKxrgu086Y6vVR/0mdMNKOPYnaDs4ggiJznGToMX0vSpTIxvLLA1BEARBEARBDCza02p2v/ou8m01w5h+Nkt7Wt82jIPbJl26M13FOcxyc+QrYv8bU1bH9kLWYtrTwVciWNtf8FqHzPmPlM+PVbeiABSxOMrEV7tDWgVgtNm3CbMXcnMTG/fyisHwiWJfdC5Ut1G+2/dh0OpyNofIGLq/WZuOm193R98GomPy0hlHuoMRI0qB4YOmD1uaoa8kca/XaF9HgfY55S5VO5wIjlfbDXlbOzKuMb1kUmULt3qHwLomoSMWv3GTQWQM1pRrUP2xArEmH251RQRWcGUiB4eiauY5MaVPi1jqdhljvehuv4o4nIxl7Rok9nY3boYZG+yx3X9CpbtwnvVOn7qwxla3tos+fZTogpJABBESLRfNL7cIBEEQBEEQBDFgqY6J2WPPu4hLuXvbG3Cuv5FdHYsA2Uks2/YojPmaCHODMWTLdZGvqO16rLLav7eW74Yx9xgRBGQc2Ra3Mv3i5212L6wakAQBqlZ8Fsir3VbCev/caLObBY3zVWxw+31e5RUD5/oKALDiJrkK1W2W72htRBAgq90/W6WuKprznRRhCHpsS47Os7j5dXf0Deh9KerYy8urbxaDESNKgVGu6cMWs+pbF2pQXWKd3/Y55S5VO5w4J+gNeeuqojnxNiJ6J7u6Dbf9D4A+/hhblkUtfuqmGVFkiGj6mWCxiBBYf7xArMmH2z1+zlBiYIiIQnbc7UYmvwjcxlgvuvpVcNsLDJBEu354NtlX4h0GbXSnDU6MPtLTdMUef22wxh4vH+WyBo17p3rK0c7eDG0HRxAEERIdcgf+9fl/Nf90yB3lFolwkEkpeOq7q80/mVT339gjCIIgCKJ3MKWhFoMrJXDe9fa1KDDbG9gGmsahgaOuSsKUhhrzXg0cmmUi1GuCuRBDqqKY0lDjKp/bwe2F4IApqxdTGmpdpzvikojKaCRnBQPnhcu04pzwKnZnH4Flt2nJ6lkUip+mYQAmjSgsf1iTdQJzn8CNRwRURSO2CWlN63on30tXzvJ8i8kBDRxHVUsYUpmbTPGDcwWFtXKjfxxVLeXI5KWDfDgnTBmAz0+tzymnGE+QXA5YYYCrXxcju7XMiqho24rIGUcCl+lwTCNGdAfXBIPATB80dGCNdYwxVEhiTqy0tm9yff72OXVbqh3Y8m0FZZX381Prc2K6VMJt4TTkxjaBMVRGI6iMRrIJVR3XFXZgiEuiGUeCiKpxvd35Yk0+3PpFoS23jLpqKyRz3C0oZ4h7c7mNsV5MaajFkKrg/SpfnxeF0p+jY42HxbbBibWPWH3Fau5SrZ4RBLg+ZxWSc0pDjc1HjSQSYwwVURGVUfcXQYrtD/0ZSgIRBEGESKfcaf4heidyWjX/EARBEATRf4hLIuZOHwlRABTN+21TzjkyqgZJFDB32ijEJdG8VxL11TLWSQbnW8CFEBnDxdP1ct3kc5u0LlimwExZHa2xlR8JIKt3me441VmsbqaNqbPpmTEWSG4rEZH5kj+st4ENWQsllQwfExmy13usBHK03S1h6Vo+9OTHxdNH45KTRhU30eW0p0N2o3ynbYqxV0RktvoiIsPgyqitnO5OPDpXfLj5RXd9zepHbnGkuxgxojs4k72APlFv+KChA2esc8Nv+xi6p9t8OIv0G9cHV0ZzYroQMLkShGhEyIltXnL62f6SMZbTdi8UlUMShbyxplBdtr7oI6Nj1CUKDHOnjyxoe8M+YU3Mu42xXsQlERfPCB4n8/X5IfHC40CYFNsGK84+EsRXit121ApjzPU5q5CccUm0+ajKg/ko0QUlgQiCIAiCIAiCIIh+wVVNYzEkrv+jP61o+moMx2SBsT1PfW0cVzY12u4dURO33Qu4rzTIR/1ge7lO+Yw6ghCPCPjiSaMAGJOIHIqm4eN97WZ7DFn9TnkMqYp6yumXYnRz9wVTcvQcRG4DFqB+Yx6Ic5i6U118ww+SKORdIaZpHGlFn+WtjIoQGMtbn7XtGue+9MABHF0Tw5VNjbiqaSzqaysCtyOl2GeiNc6hapopu9E/nLYx7OUXxvTklmokVtFlN2vZslr47XA3ePatcuPWQn4RKXLlmXUbOKuNnXEkCG5yXNU0tlurlXKSdgBqKyI2v48IzDXWuWFtn6ZpyCga0oqKjKJBy27jaNxttWdaCWd7MKdobl3Wyx5uMb3Y1Z2FqK91j21ecgLI6VfOa4N0h/rauM3vreOEW+xx/m7tF5kCfdHZx65qGoshLts7WjHaHY0I2e3usnL4bqEdYzz0SzFxUsrT54dV9HxyodhYb+D17OMkzC3UnH427+TRZh/JeGzN6BVbnfGl0HhRzAs3/R3SCEEQBEEQBEEQBNEvGF4Tx03TKzC0Qn9Lt1NW4ZxnUDlQGRNx79ypGG5JyAyviWPh/BloGFwBQWBIKiqSGX2y0++UCAPw2FUn2cp1yrdw/gzXt/XzkVI0XPKr1bj4l6vQmVGRlFWkZA0/+9vHmP3gCjywfBM27D4MWc3dbK4zo6IjoyCtdCWLGIAbzzrWU06/CNltpKI+XlkfURPHY1edhOMbanP0nJY13284G5OVcUlPsPi5rT2l4NkP00irMHWXlFV0ZlSkFRVagGSQwBiOr6+x1ZtRNaRk3V+SigrGdB9TNH2yKl99AtNXrTAAoij4nhRNZTQ8uXobAN3ngiYXnee/yCpHUtbAOTCiVvfT4TVxm3wATHv5hUH3X8bsdgPsbReY7gtB6Uir6JR1nTvLt6JxjrSi2z7oxDMDkJLtNhYEhpF1FaaewmJ4Tdym7yAIAkPGkXwRBYYdh5I2v0/JGprGD8HRNXFbrHP6hNG+fUfSuPzRf6BT1pBRNciq/qZ+p6yhM6OgtSOj12+1Z0hLbpy2cn7OZw+3mJ5ReOgToQzAwvkzXGNbMqPm+M3Q6hgqsitQrf3Kea0xThTS5PCaGBbOnwGBMdPPreOENfYomoYHlm/K+T0la+YWZwKDZ1909rGUrOLJ1duQ9jh7z8Cwz7ihVRAFodsr5y5duBoPLN/kO3YPz44/QeJkSs61neFjQVfBhkExbbDi9exTCjTOc/ysM6Ni3sJ/dMUeDxV6xVYjvgyKRcz+1ZlW0OlxdpWsaoHG9oEAJYEIIiSGvP4SRjz/FEY8/xSGvP5SucUhCIIgCIIgiAHJmBoR15wQR0WeSaZkRsUdS9/Dxj0J2/eT62vw3A1NuP7McaivjSMa0bfYMQ71zjftExH0/emPK3BGzeT6GgyrjkESuxIYhV5YVTWOfUfSWLu9zTYJqmgaWhIpLFy5BRf8YpXnoefWc5IkUZdz9JDK/JX6RBQYThxdh2tOH4vqmLvOIwLD09edaurGTc9SREA8IqA6pu/x79SJvnohhnknj0ZFVPSdSFM1jmfW7MRftmZyfuPIJj9cJsDzURWLoCIqmjaMCF1+MrQ6igpJ1CcOHROjXvWJWd+5/sxxaBgcRzwiFPSJAx1pPPr6Vlzyq9UAgD/deEZeG/iFg4Nz+4oLQz5JZKa9rOgTwwJiEf0MLjG7+icWERCLiKivjWPGmDpXuxlln3P80aivLX5iUmR6fW5+oWq6zmXV36Zzhq9dc/pYXHP6WNQPtseC+to4rj9zHJ5d0FSwv+fFw4Wt+i7k5ZLIUBUVEZcESNlt3nSf1ItXNA7F4dscwPPrmwEAc6eNNG1qqI5ly312QRO27OvAhb9YhfU721zr1zjwf++3QM7ucWb15SDJbmb5f5D59UL2cIs1UUmAVORsqK5bZiajjXiaL7Y5/eabn5sEUWCu/cp67WcnH43KqOjpC0b9P5z7LzhuRE1ePzdiT0rW8MjKLa6/K5r+/8+dUJ/TF61tNeyqahx///gAHn19Kw4n85+1a9inwnJ+S3fSKHsTaTyyckug2D25vsYzTjLoKzeN2MWAAn3eW/qwtiBzK8bahspocCf2evax0t2tOQ0/fPT1rTkltSRSZuz53Alu58Ihb2wVBYYLThyJ688ch6HVUXB4ryYzxtp8bR1oRMotAEH0Fwb/cyWqP9oAAGifOAWHzjy3zBIRBEEQBEEQxMCjNaXhifdT6MzoEwac27fVqZREZFQNzW1JLFiyFs/d0JSzIujWOZNw41nHYkNzAu1pBc1tSdzzvx+AMb282847Dj/48wcA9APXRSHY3vOiwBCLiIiKumy/mj8D7SkZ33vhAxxoT/veBsjYosq5tZf9GqZPAnP98HJJFFxXSnSHaETAnV+Ygts/dxzW7WjFxj0JbN3fgefW7jJ1M2xQzHaPm56rYxHzsO8NzQkc6shg/5E0hg2KYkhVDFMaarC7LYk/vt3sSy6Nc6Rk1bYKyg0O/a3vfYmU7zekBdZlw/+YPR5TRg5GRtHw/Rc2oLVDBqBPxLuZxqivImpfFWPVx87WTnxz6btIuay6ERgQj+T6sWGDf3xyENctfgvGrQLL3VbLiSQyRBiDrHHsTaTMMp3tfeWWz2BDcwJfeuwfYFn/r4qJ+OUVJ5k2HD+sCp/s77DZdOFrW/CBx2ScwPSJvYfmnYhp338ZGteQUfxPRQqsK9khCMzm34YP+CmrrlLC/5w/GccMq8aUhhpztcLtnzsux0fDOAMoH1b/0ruv3ocXzp+Bj/e3g3NgSkMNpo2pAwBTvr2Hk7jzTxtsK54YcidKtayd3/jkIH533WnY357Bj1/+COu2t+qHsDOGfUfSuOl363OSSE449BVveiwUTF/+33ebsTeRBgeHfrqK3hZV0zC9sQ6zJw3H5PoaRCMCMiqHJDK0dmTwvRc+wMH2DMD0BHlGsa6cs/vyw5dNw6cnDM1rD7dYcyQl4/bn3oWqaUgp3FxJlq+pw6ujuOsLU1AVl/D65v347Zs7XON+vtgWl0S8smmvpT32fmW99pVN+/D3jw8AQI4vGH2PMYa6Kgl7Eynffu71soDB2u2t+N11p2HOT17PqcvA6FeAPp5FI0LeLQCvbGo0Y2uQPumnHc5Ymo/hNfGcscroS4wB1z65FoC+jdnCK0+CqnGPPl++FSbONry7qw0th1Ooikbw7NpdOJhdmedMjjmffTTOTZ0VSjf7jcZW27pt11aRHbf2JlJYu70VcUkAwGx+duucSXnrqIpFML+pEX98ezcEpt/r1W854PqcN1ChJBBBEARBEARBEATRb/jrdhmHUhwAQzw7MWXbfktgiDH9+5ZECotXb3eddIhLImY06hOs63a02g5WnzqqFtFI9yeBjcO/Z00chgeWb0JbUtYnNbj/CXC1wHYnkihAEvXtrMA5ZFVDLATZ3YhLIk4fPxSnjx+KVR8fwB8syRqvJJlVz1bcvnMj37yfsT0eAyAJQDpPLogDnr6Qv36GccOqTRvuPZIGAMQi+uHXXpOFPCuf0xaGPl7ZtDdnay8rXn4cl0ScNv6orGKy51oJDOkCE78aB8SIAEHgtjKdGPJFhK630BljOfaa0Zj/jBA34pK+ykBRgk2xCix7WDhydeq2RaIXHRkV2w524pKTRufI5dcfg+BnM0MjRhgrD2ZNGo5Zk4bnXGfI9+6uNiiaPX4wlnuWTizS5Tu/X7MLt86ZhPrauG31zp1/er9gAshKWtFsqxOM1S7WdT4CgIgo4HMn1OPqM47JKcOIg4zpMurxrUsG5mjM2zvb8Nnjj/Yln9WOW/a3gzFmbhcqMH286Mx4JyfaUgo+2HMEt86ZhO0HOwom/oP4jZ9rnb5gZfHqbaGlJfYd0X3Cbjs71tgaiwgFk8zW2Grtk24JyqB4xdJ8WMcqg/U7Ws2/M8YwbfRgVMV677S5sw1m34FuE6cvO8cMznnozwJW28YiAhTHVm1WGfYdSZnXBV0Xtnj1Nuw9ktbjhCigM88Wpfme8wYatB0cQYSFIIKL+h8IpX0riCAIgiAIgiCIXFKyilW7ZaiavkrGa5KOMYaoKEBWNSxbv8t8o9kvYZ8GkJJVLFu3G7KqZeX2d5/GOZQCk/uA3l7jwHhFzT0kvLuEvLAof10+r+MW3YiM+ZKxGF8wpMq1YeEKvWxhlFVoYtXLjzOKZvMLP7KoGtffxnaUGbavFIL79GkrqgZzKzOrTlOyGqisYuNBb8Jpey8KxUBN07B+R1ugujWu32etIwjF9KHu2Mvqa1Exu5qzQFK5N/qHobewUDSet+9b9eZcIeSFoTdV447YFJLMIYxrffn0GL99x9rvvXTm76S9XJyxu5AMStYXgtpN1bRAcaK39tty0HtTmgTRx9jyX98rtwgEQRAEQRAEMaDZ0HwY7bK+tU+hg8kFgUEAQ2uHjA3NiZK86e+XDc2H0dYpQwALdKB6dpc3XxjbvvDsfT19rHVP12fVDbOsislHsb7AWHE2NGzhPAPFKMuP1G5+vKnliO0+vz6iafr2W9YygWBntHSXID5twAFzuYuhU0DXY6AVRT0cD0qRPN2yv8N/THD4jlUcRSu8haAbigYUcVQJgOL6UHfsZfU1P1uJWXXVHYqdZPdiy/4OtHXKoZXHgLx9Pze2FsbQW2cI28C54RVLu0Ox/bOnxzogWN8x+r2a3UbNqTPXdcg+jBboeSR77pKG4HY70J6xtbVQEqm3POf1BmglEEEQBEEQBEEQBNEvaE+rgCPBkW9ChDF9wqM9nf9Q69z7wp3maU+r2VUYoRbrSXcPfu5NuE2oGnZ1UmheuRhf0GVwt6GfiWU3OY2yvBAdDXH6cWcmtw1+Jn+sdRpl9rSvFF0ft/5V/9Ceb/8/F4qNB72JZCacNhdrB5sPBbzXrQ8VirXdsZdbGyMlGC9KTWdG6VY/darYOGfFq0y37wuFOkNvasBVfkHobqxy5hLyJ+vKkerxxq3vWMcJp7TGdabOQmhOIb9w9q2uF1OC2S2java2FpC9t/bbckBJIIIgCIIgCIIgCKJfUB0TAWZ/G1USmb4dGJA9hLgLzvWJnuqA+/6HPf1THRP1Y9MDzmH5STK4Efab6L7q7OEq3dooCfkTQcX4AqBPVLvZMOLj9WY3OY2ycq/V5Y+K+f14UDy3DVKk8PSPtU6jzJ7yFcM/iq7PmjjIfqiOBdumvdh4UCyl0GxFtPg2MxcdBsV6X9D45NaHRMYQya4aiLr4cHfs5dbGqCjoW5zBZYWEVVdF1Vga4lJuvJBEZrbDCyOexBx61TjP2/fdvi9ka0NvzgR2mIQdq3p6zOoObn0nFsn6MtN9xAo3cz8s+39v/OrBTf/xiKivzGa5/dc4qzGo3aKiYGsrA4OUZ6zt6bjemyENEAMWjUnYMuoi22eC6A6SIOGiCRfZPhO9C1EUcPwZDbbPBEEQBEH0H6Y01KJaYmhNcWgaz245wlwnRjWNQwNHXZWEKQ01ZZC2iykNtRhcKaElkYLmcw8mBiAiArLqbwuWrgmXwitiSkFPJ56MCVAO/awCZCfDKqMRqBpH0uV8gGJ9gSHXhobvxSUBKY9Dq71sYZS157BdRrdDyt38eEpDbc5WchGBIQNvX2EABCG3zMMhbjPlB6vd/MIAc1bTqlM3PVgRGWBdmNBb4kF3GDesyrf+8sXAiFDclnDWed6gk+hufQiwT2AnNXuf6I69rL6mcZ49O4yhMqr3s7SsePrHB82Hi6qzFBwzrAqDKyUkLfGCgaEyO+51pJUcf2AAKrOJA83x9gEH8vb9nNiaRRIZZI+VPobeKiQxcP/2Q7nGtd6C6/hj8WUrRr/3qzO/yVy32C0KDFUeMnAUZ7dh1dGctsYiImIRIJk9d8pWVz+I62FBs1/EgEUTo3h34tfNP5oYLbdIRB8nKkbx9WlfN/9Eyad6HaIk4NQvjDP/iBINgwRBEATRn4hLIs4YKUEUsluG5DnYOqNqkEQBc6eNynlLthBhvyEcl0TMnT4Skihk5S58T0RkEJjga7WJ9cDmSPYA9LC3tCsbHs1gjJm6UTn3pdNifMEg14aFKzRs4VVWwe3rPPw4Lok2v+Cc2/ThKQtYTpk95Sfmzj4F5HRDFLqSFVadOvVQiGLjQbGUQrWxSG6b3TzRzXdsq3gEAdPGDA5Ut8D0+/zgJlMxfag79rL6WsbHAfU97R9+iYq63rxw8zOjv7shCSxv37fqTeMIZCcmMEdsKnirL7xiaTCCCON9bTmGVr99x9rv/epMYP4044zdhWSIZH0hqN0iohAoTvTWflsOaPaLIEIivmMLqj58D1Ufvof4ji3lFocgCIIgCIIgBiTnNEoYEtcnFdKKlrOyRtM40oq+MqO+No4rmxp7XEY3rmoaixE1cQC5Ey7OKRJm2RIsUmACReVd7WXQJ0TKQVgTYzkTRnnmfyRRMHUnF1jVwICifcEQyWpDN99z1pfPFlc1jc07aVXIj61tVzR9ZZz1O6f8UVHoNX3DS04vuGVLI6dOg5TVm+JBd3C22W2O1I+d777ghLxn5DhxbitWzKR8oT5knfDtTp81SrHqqlCf7b3+wXFV01iHzfNPjOez6/Cawu0Mojennaz3hpEDKue45peeSAwV6jvO+O5XZ0G2dSzkF1YZhg/yL4OTIGNt7+23PU/v7iUE0YdoePZxjP/xdzH+x99Fw7OPl1scgiAIgiAIghiQDI4LuGl6BRoGV0AQGJKKimRGRUrW/59UVAgCw8i6CiycPwPDsxMJQTDeoOacQ9U4FE2DqhV+kzwfw2viWDh/BhoGV+QmfVw+pxVNb5eqISIyz0m9lKyBMWB4TQxxSfQ1oVOoXc7fg24ZVWo4eFYujmhEwKC4BIHpW+clMyoyin17Ngb9TeogvmDVwSf725GSVZsNDd9z1mWtL58thtfEcfLYITbbB/FjBvsZDElFRVrWXFcXCYwhJWuh9I0g2HS4T9ehIU88u21UIRj0LYcqY6KrTp16sOLcuepnl51Y8jZb8VqJYdWLomb/ZPtaymUbQ1uZzJ/+GEOOnZ3ueHxDLX7279N8JYKiIoPoWAVUzLy3Wx+y+r0Ra4rps24YuqqvjefU59zFMTT/YLkxtJBdc2Ju9v+KpmFTyxHUVEg2m8saN9vhjM+SyJAyxg9ZtdXNAPzokn/B8Jq45zjAsysrpQjLnjuj681tKzg3O1n9szu5EUlkvmJpKdC4/sfNfmaCy6K/DbsTBW3sJGiTCvUdZ3xngCnf9oOdNvlsMSjbxkJY/ULf5i2/DHd94Xhwiw79Pj/pzzPubXVLBvV0XO/N0JlABDFAePrNHZ6/xdvTrtdcfuqYkspEEARBEARBdJ/du3fj2WefxYsvvohNmzahpaUFQ4YMwRlnnIHbbrsNp556as49iUQCd911F5YuXYqWlhbU19fj0ksvxZ133onq6uoytCJcxtSIeO6GU7B49XYsW78LrR0yOPTDruuqJMydNgpXNjUWPTFwsD2NtKJCUbntTWYG4IHlm3BV09i8ZXtNdkyur8FzNzThgl+sQsvhlFl2TBJRUxHB6LpK7GztRCKp2Npz7vEj0JlR8Ps1u1zLjYoCZjTW4ZVN+/K2a28i5dmuzfvasWH3Ybz4/h50ZlTb72u2HfLV7lKzN5HC4tXb0NKWsk3wSyLDMTUCDiQ5UpoAlXOoCs+eq8QgiYLvSUSNc2w70GHTwYPLP8ITq7Zh7vSRuKppLJ67ocn0vQPtGTMRFLS+mgoJFVERsqpBUfWEViE/NnTgtBGDPnkmCgKkrBwAg6IZsoXTN/ygcY4Hlm+yyfjQXzdj8T+2I62okEQBosBsbefQt31Tta7ET0RkGFIVxdxpo7DtYAdWfLi/oB7yccOSdaYNy+HHfmSe/eAKXzIa+ssoKlQtd8VFLCJi9qThGFLZtYW5m0ue/y/1GDu0Et/94was39GakzgDkE2wcnCoNt/2uTNcDkYcdIvfGteTu0H6bCFEgeHJL5+C59ftxrL1u3CoPQNZy03eWv2j2KUdexMpLF27K8fGXnbVOLf1ATe+/8IH+PkrH0PRNMQlAYrGUSGJWZtwqJwDHObLAl/59DibXsEZ0opmxqbaCimnfxoITF9ZZnwvgCMeFcDhfh6QKDC7qoyzu1hXf3ajQhIw4ehBaG5Loq1ThmKZ3I8IDEOro7hkxmg8vmpraH7gHJbdijX66AcHs0nCbAOs9ksras44+q3n38ODL31Y8viSr+8Y8f1zJ4zAC+802+y7cOUnWLpuF+ZMORqtHRnbbylZw8sftEDR3Pud13NDNMIQRSRnjDn3+BEAgP95/n3b2XzG+LgvkfKlH2dbD7VnkFJyfbDccb03QUkgYsAiaDLG71xqfv5k9MXQBKmMEhF9HVmVsXRzl09dPOFiSCL5VG9CVTR88Pdm8/Pxn26A6PFmIEEQBEH0FR5++GHcf//9GD9+PM4991wMGzYMmzdvxh/+8Af84Q9/wNNPP4158+aZ13d0dGDWrFl4++23ce655+Kyyy7D+vXr8eCDD+K1117DypUrEY/3/X8oD6+J49Y5k3DjWcdiQ3MC7WkF1bEIpjTUdGtveFXj+Oay91wnvDiAR1/fihfe2YOF82dgcn3wg4iH18Qxqq4CiaSsn7cAjqeuPdWUOyWrtvZEBIav/3Y9mg8nPcvsyKj4v/dboGoccUnUJ+Yc12zck8CCJWs927XtQAcu+MUqMJfzAdKK1u12+8Vrus+QvyWRypmo7kir2CoDdTHgBxecgCNJBT/8v036QdYBJhCNN753yUmbDhRNQ0siZdOB4XtLVm/H//fyh2BggevjnENg+qHXUZFj8VdOzevHVh1Y5dMPcNcn5WviEu44/zicP7UeAELtG34wdPjo61tddcg5oKiq6adG2zUO/Gr+DPPt/4zKbTL/97Pv2Oq49Ferc/RQCKcNS+nHgH2S2ct2OTIe9i8j53BNAAFAR0bB0//cgVc27StYzvENtXjuq6fjn1sP4oan1uFwUratDDCSArLKTdsBwbaRcuIVv3/88kd4Z2db0eV61jcohlvnTMI5xx+N65eswcH2DJyas/rHv32qIXAdho2b25I5NnHzvV2tnUj6SGJmVGvf0WP8tWeOwxnHDkV7WsFdf3of+xJpM/Y49dqZVnDrs++AMQZV47h+8Vrsb0+71utcaKEB6Mx4ZHKgb0WpZlRs3JMwfcyIAfnalZQ1bNyTwNE1cfzokskYFJew/0gawwZFMaQqZvb7RW9sK6Cd4nGOktY+6lwlZthv6drdaO3M5Iyjspo7RpQqvuR79tl6oMM1zigax57DKSx6Y7trmclsg639G8j/3NCRURERGIZURvH1sydgcn2N+bzSkkhBdqySNWLIJb9a7Vs/RluNfptO5PptT8f13gwlgYgBi6BlMOWTR8zPW0f+W7eSQM2XfhlisgMAoFZUdVs+ou+R0TJ45N0un/q38f9GSaBehqpoWPOXbebnSaeNoCQQQRAE0ec55ZRTsGLFCsyaNcv2/euvv46zzz4bX/3qV3HhhRciFosBAH70ox/h7bffxu23344f/vCH5vXf/OY3cf/99+Ohhx7CHXfc0aNtKCVxScSMxrpQytK4PnnltsWXeY3G0dyWxIIla/HcDU1Fv3nKGIN+xjKzyW9tz95ECpf+ajV2t3a6vqFvxXiTOiWrqIjaJ/r3JlLm5KQX3FKGE4HltrsnKSR/RNQnNw+mgJ/8dTPuufAEiAHOOgG6bM8BMIcaohEBAhgyqpZj+2OHVyNS5JII20oexvL6cT4dSKKACNPla+3M4Cd/3YxPHzsUw2viofUNP1h16Ny2x9BhZ/Z3w08Fxsy+MGviMN91NLclA2/PGI8IkNVw+q8fDA+02q6QzBz6JHohGa26dqMiIub4a77NufYmUrj12XeRSMo5V4kCM2ODYbt9iVS3tvoycMbvoP02CHsTKXz9t+uzCSAgwgDrwgKrzp5+cwe0bJLWb9mGjTUXGzvt8csvTccjK7f4S2JyIC4JSMqaqf+0rJl6q4pFwFjGdotVrzsPdYIxZvpMS0i2s4hn+pisagUTQAayqicmfvLXzSXvi4VwxlcGe3yuiIhIK7ru3IhLIsDhOkaUCmffyTtGCCy7ciwXfWs3fftMa/827Oo17ho+fbAjg0dWbsEvvzQdX/3NOvP6mCQg5cymAYH14+y3XnL0lN57MzTzRRAhkRozDh2TpqJj0lSkxowrtzgEQRAEQRDEAGHu3Lk5CSAAOPPMMzF79my0trbivffeA6CvLHjsscdQXV2N73znO7brv/Od76C6uhqPPfZYj8jdF5FVreDklXE4eksihcWr3d+qDYvFq7ehJZEKdCaP/ratfeLFKKdYGGMF213KIxus8sciQs4EJmMMUnb2oyWRwp/f3RO4Dqvt3doiCO468N7EyQcBbnXqwK98PYlVh14yGrj5adA6gq5EUTReFh1ZbedHZpZtYT4ZC8UqN3/IV3Uh/7LCAV2uPAV24/i0kpETRxziW3WWSMmB/NNatiTm6sVpj+/+aQPaOmVfZTsT9BzAuh2tvmUzKNQ/u4PhYwfaM4EiosZ5j/VFp1xW+/vxjUJ9N2gM9jozrFjy9WFVyz9SWVewGv270HODm09b68+nryA2t8oRZGweiFASiBiwcCZi9/DPmH84K+2yd4IgCIIgCILoaSRJX5UcieibQGzevBnNzc0444wzUFVlX71eVVWFM844A1u2bMHOnTt7XNbeDuccSna5TcRlEs+AMYaoKEBWNSxbvyvwYdCAv8mflKxi2brdeVcleaGo3LzPKEdWNUTF4qcInO0uRq5iSMqKTX6v7dYYAyKCPtH5yqZ9gVaJpGTVtL1ellcdubbvzmS33wSS04Y58nFv+XoKJXuuiYGfbfEU1f9h4YC9j0qW1Sn+ZeQAQ8/piDGb7fzKrGp6IsFLRqseAO/1PU5/UF3OwQF8+JcLy9bv6p2ZHg/8ttHQmaZx3/4ZtOyMounnLwXwX8WxFHRD8+FAvmv1majIAm1b6QdZ1bB03U60drqv1vCWC2WJV0BXv/FjP865r75brhhcqA2FVhI7WbpuJ5auLfzc4PRpPzGkkH6sz0dB+1a5fKm3QNvBEQMWVYzjrRO+W24xCIIgCIIgCKIk7NixA3/9619RX1+PqVOnAtCTQAAwYcIE13smTJiA5cuXY/PmzRg9enTe8pua3Lf8ev/99zFmzBisXLmyG9IXTyKRAIBQ6/+4VYWsWraw4XnOQFAVAPoE0oEjKfzmxZWYUGd/4SyVTtsm7ZyyHj7cCUVVPX8HgM2tKg62p3K2pfEDB/DqW+8ieiBmK0fjxU2M6BOI9nb/7c13zO8AYNXf/45ICFs57e3QbOU++/Jqm/ya2rV1jYGmaRAYhwB9AqmtMw3G9OusePnM5lb79kXOiV+uaVAsPmG1fXuG2+TNh7P+/fuTtnvzyefUgU0+rkFR3eVz+qYTp+yGDNbvM2m1YH97d7PjHCVHuZpDh4CxGkg17ZSvjpa9SVsfVXnhVXv2mqAfbq/o9QXRURCs7d6xfTt+8+Ju03Z+Zda3hNNcZdx22BGrfMhhlPPxjj2ucaeQfzGX2g4cSYEp6ZzkhMEnn3yClVrwlw1aDxWOjX7Y0+6IIy+94dJGc+0fgFyftfpnPjly9OcYPhhy7aHxfJvz5eLUckdaMf2i/UiHrf/nxJlOzeYzzngWBgzA/iNpFLG4D+DefdEtthbrEx8eUmzlvf766xAF5ur/zOEbhfqcqqrQLAZ19l23dvz976+HMmYChftwPgSWO+btP5IGA/I+N3j5tFG/V/5U42pe/ezYsQMrV+51bZdbmW6xLuy4buD1/JlIJFBTU/6ziGglEEEQBEEQBEEQRD9DlmXMnz8f6XQa999/P0RR/8fu4cOHAQC1tbWu9xn/SDWuI7oo6qV2DiSVIm70Me+TVPQN+oudIsqo4ZTjCgfSPfSibVrNlb/QTkYcwezpZkOjDoF57HpVrO2tRfi83c2GkkU+14VrIcgXBLeFYVYdepnMrw4YmO3aohehcPvfS60jq+0Cycy7/u+UsVA5UTdlc3cbOWU0MPyLwdu/8okRhnnCJOXSRqtfesUUPzYrFGOjJdqUJojvurXD1U+6QwGf8IJl7+3JeAV0xXU3+0WErs9RIb8fiCUcI/zi1Qag8Njv6vtZW3rd69VfrNczr7HJUkch/RTqW5KH7D3tS70FWglEEARBEARBEATRj9A0DVdffTVWrlyJ6667DvPnzy9JPatXr3b93lghNHPmzJLUWwjjDcww66/e0YrImjchZ1+fFQQRUN2zHBFR/2e2rKoQRQFNJ02zHc4MAPFVf0OGd72d6pT15xtXI9KR8PwdAKq2H8Iv3v4nlCCv9FqYPHE8Zn56nFmOqmiIiCKg+Fu1YoUxpt+LrnZPmXQs/rL9I/OaM888E1I3tpsz2H6wA5F//N38fNKJU/Hr99d1yZ8lbXn7VxAEAPoMNwODmD2/wXnIvJfPVG0/BLzV5e+MMcQlERzcdes+q+1bOzKIvP+2r7Y56//N9jWItB30JZ/NhgAiIhD1IZ/TN51E/rbcVUbr99GYWLC//Xnfu0Bz18qPiBhBRESuDh3+FxFF00756vjffe8gsneP2Ucjomj+vTBd9YvZ+oLoKAhWvY0d24imCUMtthN8yyyKIlRFy5FxyO7DiPxzdd5yopJ9KtBo64jhQ/FJItfffPmXYyWDKIqoqa5EQnY/NH78+PGY+eljfLXVyqOb30TkSFuOjEH5eF87Im+uMj+fPO1f8Oj7a21tVFQFUREQI2JOP0qrCsC7/DOfHE79KUyDdTlQxFF+RlG6nexijJl+Meidv+NAusP8zSnrzkOdiKxaafqMKIr6tloiIGgaUnLw5TuiwGzb2TEwCAID83GuXm5jdJnc+qIzPgHF+0R86yFE1r/VVc6ZMyEIzNX/FVVBzOIbqsY9+1xFNHfq3Rlf3NoR1pgJePdhDg5NA5J5tkeTIhGosn3pjiDo5yIpKs95bogI+vhoxfRp1vWMZMjQnnbG/Ehe/YwZMwYzZ05ybZfsWGIU84h1Ycd1A6/nz96wCgiglUAEERrjHroTU792CaZ+7RKMe+jOcotDEARBEARBDEA0TcOXv/xlPP3007jiiivwq1/9yva7sQLIa6WPsZWF10qhgYyxRRQAFJrG0jQODRx1VRKmNOT+47/QeQt+VuVMaajF4EoJms/rneWPParaUQ6H5vMMCq/6rO1uPKrK46pwOW7EIN/ya1y3XU1cytkKLh9TGmpd2+yWYHHavjuTuX5XhnjZ0I98PcXwQTHfOuz6LXfLPu9rma2PgvOi+oUg9JyOGJjNdn5l1q/xltGmhwJY2zqkKup6TRD/MqirklBVqiUuJWByQ417HGG57dS0rtUHfvwzSIzV7eHf7y1i2qiMioF81za+WQKPWMTZQMY2YVY0cBxVLeUk3v3AgR6PV0DX6h1P+1l8o9g+11NtyteHg8hucFS1hLrKqKtPO13G6tM8+9l2Pdyu96ef4H2r58e+3gQlgYgBC9NkjN6z3PzDNLl7BWoqmKr/CbTBJkEQBEEQBEGEgKZpuOaaa/Dkk0/isssuw6JFi7IrILowzgIyzgZyUujMoIGMvtrFOBvCe7KBc46MqkESBcydNirnjdiwiEsi5k4fiWihvc9ciIi8UEDwAABqaUlEQVTMvM8oRxIFZHwe2BBx2cPF2W6nXKFuN2chFrHL73ZQu7HVlqIBkijgrOOGBzr4PC6JtjZ7HQYftu39JpCcNuwp+YIQEQVfOrTfE+yAemsflTUe+DyNiKjPUvakjqy28yuzKACyyj1ltOoB8PYjpz94rTrw619W5k4bBVHoO1OOQfuQIDDf/hm07GhEwLQxdYESJs6YfMLI2kC+a/WZjMpNGfO1z0s8t/FBEgVcPH006irdE43ecqHH+qKXXfzYjzHmq++WKwbna4MzXvjh4umjcfGMws8NTp/2E0MK6cfqkn1h7OtN9J2ITBAhI2oZzNh4v/lH1DLlFokgCIIgCIIgisJIAC1evBjz5s3DkiVLzHOArEyYMAENDQ1YtWoVOjo6bL91dHRg1apVOOaYYzB69OieEr1PIYlCwWRGKrutSn1tHFc2NbpewzmHqnEomgZV4+Y9BpqW/3eDq5rGYkRNPNBb4yzbDrdy/OKc7OKcI509UCRfu8MgLas5urHKn1a0nDeCNc5h7GhUXxvH5/+l3pTbj54Bu+05z32bWdP86cBap6Jm/3jUH+SMmII68ClfqVBUzbaqIOUhoxWBMV8JB6BrYtBqJy3AaiAG3a9LrSOr/fccTub4rx+ZjSvcZEwrKhRVK+g8bv6gqJpnfyjkX06+eNIoaI7+pWld5e881Jm3v5UaX3HE0USrzmorpEBbdVnLll1eInDa4+4LpmBwpWS7xssvGMuNyfW18cD6tfYdPzaORXLHQ8aAqIteDB8bXBUJ9EKAwFigsdRvvHAjo9j9P205JMuPb2heCYhsGjZfDOacQ1E1ZBQVGUUfF8LuH/n6cL5nG+6yyuaLJ40q+Nzg5tNu9Tu1xjkPFH+tcriZoNxjX2+CkkAEERJtp8zEvvMuxr7zLkbbKeXZ/5wgCIIgCIIYeBhbwC1evBiXXnopnnrqKdcEEKC/8Xnttdeivb0dd999t+23u+++G+3t7bjuuut6Quw+iZA9C2b4oJjnNSoHKmMi7p07FcMdEyR7Eyk8sHwT9iZSSMoqUrKGpKxi9oMr8MDyTdiw+zAeWL4J7+xqc/19XyJlK294TRwL58/AyLrKgm/yRgR945q4JEJwvN09vCaOe+eegEof2zcJDDlnRGgcEASGkXUVWDh/Rk67gcJb4BXC0N0Vv/6nTTcX/r9VeHL1Ntw39wQ0DK6AIDAkFfvkmaJyCAwYWsGwcP6MbNJKRWdG9aVnvd267RkAMCCpqEhmVKRk/f9JRXXVgTEpqbnUmVKyf3zUXwjDF6w68CNfqTHs9sQb25CyTKqqGkenrKIzoyAlq+hMK+h0THqmFQ2dGRVpRfWcYHVi2KlhcAVEUQi0HV9K0UqmI0MPVvs/t3YXZj+4wua/fmQWGXJk3JtI4a4/vY8rHnsTKUVDvmNcnP5w70Un4MnV2/CHt5s9+4OXfyUzCjrSueeIfe5nr2PdjlZbeZ3Z/6dkDb95c3u3/L1YDDtcvegtm2z/+rO/58QRWQUyKlz70JdOHZMTR/Nh05/jPrf+eXxDLa6fOc42Me9ZGweSDoP/8e1mU7+K5m+Fp9F36mvjEASGTll1ta0pt5y7MSqD3m/t5wHB9LFtBzp990lJZBjl0Rfd+lNS1uNrUJ8yyvrGM2/79n8v36iK5Y6hHWldj24x2Oi3HRkVKUVDRtVXrKQUDU33/Q13/WlDaP0j3xiRdrGlVX6nB8175B+2/mJF0binT1vr9/QvxtA07qii2uXskuUc+3ojuadTEQRRFIfOPLfcIoTO02/uCHzP5aeOKYEkBEEQBEEQhBff//738eSTT6K6uhoTJ07EPffck3PNhRdeiBNPPBEAcNttt+GPf/wj7r//fqxfvx7Tp0/HunXr8NJLL+Hkk0/GN77xjZ5tQB9DFBj+8+wJ+Oay9zyvSWZU3LH0PSycPwOT6/W95zfuSWDBkrVoSaTgfBG8JZHCwpVbsPC1LWAs903xlkQKj76+FS+8s8dWJgBMrq/Bczc0YfHq7Xh27U4cbM9AsUzARQSGodVRzJo0HC+802xOQFonSzbuSeBby95HZ8Z7ws9A49m9/S0ixiICrjtzHK5savScYOlOCsiqO1mxT0ftO5I2dXPf3KlY/clBLFu/C81tXRNnNRUSZjUwfLZRAufA7Uvfc30bP5+eAd32FVERR1VFoXKO1g4ZHBwMDHVVEuZOG+WqA2OlQaHJz5bD9vr9bwinY/WFZet3+ZavVFjtllHcJ6I5ByDk2bIMen9QVBUb9yRybOKGKDCbHg61ZyBrGlTNco4L0wtnjIGBgzFg6KB4SXRk1YO1narGbT5339ypeOGdZjy7dify7cwYl0Tce9FUHDeiK7Zc88RbaPE5WRyNCKY/NI0fgjuWve9qI7f+YNXrwfYM0oq75TrS+VcxKCov2N/CJl8c2XsklRNHfrv6ExyROQSB5fShv27cF7h+Q393/+8H+N9395i+EI0IGFIVzfG9UXWVqIiKkFUNisoRk0RoXPdjzrnuu8x9e1Krb4FziILga3s5UWB47MqTsOiNbQX90EBgwHEjanCwI41EUgEH11dLco6IyCAyZvqYW9x1YoxZl8wY7doXvfoToMeLID6Vzyfy+b/TN6rjItLZ5JEbHPr5SnOnjcTN50zE8Jp4wX7bnlax6I1tWL6hBY9ffXIo/cNrjOAcgMbBNeQkfNxwxq2rn/gnFFVf8yQwhqgouI45Rv0/fvkjT//SNI5l63fjjU8OutrQzYuNcuc98g9sO9Bh61vlGPt6K5QEIgiCCInKSCVeuOgF22eidyHFRHzpe6fZPhMEQRBEX2fbtm0AgPb2dvzgBz9wvWbs2LFmEqiqqgqvvfYa7rrrLixduhSvvvoq6uvrccstt+DOO+9ERUWFaxmEjsY5fvo39zOVAKBSEpFRNTS3JbFgyVo8d0MTOIAFS9aiuS3pek9MFGyrJLLz0yYVkdwyrZMZw2viuHXOJNx41rHY0JzAoY4M9h9JY9igKIZUxTCloQaf7G/Hn9/dk1P33kQKC5asxe7WzpzklLcOsnJHBAiM4eSxdbh1ziR/NwfEkM/QXUwSbCuR4hEBssrR3JbEHcvew3M3NOHGs47FtO+/bCZA/vOzE3CsuhOtKQ0LlqzF/iNp17oK6RnQJ7jGDq3Co1eehA3NCbSnFVTHIpjSUON6zkBrZ8ZXAgjQba5q3Kx/zJDgfdHpC4XkKxVOu0kCg2xJTlZKItKKam6tx5iuW9VjCyqjD7nZxA03PUiivhouo3JUxyIYP6wKn+zvwOo161ERYfjS+TND15FTD1YkUUBEYKbP/fdz72QPmmfQjyfitm2nYqIARdNXRxm+zgF85Un/CSAAePiyafj0hKE4nJRx6a9Wm7JFBP3cLAOv/nDrnEm49KRR+OLC1dh/JA0GBjXgNlwcQIWl7waxbTEUE0dOjLZge0LDsZNPCK0PDa+J45KTRuOVTfugcd3Gj191MqY31rmWLTCGWEREVORY/JVTzf48flgV3trWiv95/j0cbM8ADLa+Y/UtReNgqoqKaO4qUC/e+ORgoO0o29MKnl3QhP3tGbSnFTz2+has294KDv2lCEPvuWObfpaLxoHBlRL+5/zJOGZYtaeu8/UnA03z51POsqIRwbYFXD7/t/pGRtHw/Rc2oLVDP2dcYHDtt+Acb3xyEDefo9ftt9/uOZzCtU+uwfNfOz2U/uGMjTtbO3HfixtxoD0DQcjdltMNq27uWPYeJFFAVNTb3TR+CP5j9gRPG3Lo/mXEOWfsqHB5hvLbrmOHV2NfImX2raeuPbXHx77eDCWBCIIgQoIxhiqpqtxiEHlgjCEap6GPIAiC6F8sWrQIixYtCnRPbW0tHnroITz00EOlEaofI6saDrS7JxEAfVu0GNMnk1oSKSxevR0c3JzsiUUEqBl7UqDQBKpbmW5Jl7gkYkZjXaD2LF69DS3ZSZOgaFw/nN7PG+bF7gZnyAfounOKqU+SshzdiOZyj+wZFSrw1+0yWhLeq5386hnwr+sVH+4PtJ6HgQNgaEmkitYZUJwvhInTbvoKgC5NCIK+9VRnRk8EMaZPCHdkvFeQ5LOJl64K6WFGYxQd2yPmtWHj1IPiaJ/N5w6nwKCv7ohJ2clxS2ZWigiIcJYbWw4H2y7q7Z1t+OzxR+PhVzbbZNMPeLfbyKs//H7NTrR2ytn+l99uXigaRyzir791l4JxRGCIMbtuT6lgmFAnYubEYaHKYqziEbN7S04b454AssIYy/Hjt3e2oi0p6/7iYgPDfkp2vJFVDbFIYR///Zqd+iobn4GLQ++bv1+zy7TfsnW7wBhDRuka62IRAUlZtZUrigLi2bO4OjIqth3sxCUneZ9JWKg/Gd/78SlnWc4xMJ//R8Uu33hg+Sbszb5YEItkX+jg4fbblsPh9w8jNr6yaS9aO2UwuD+fuOHUDeccsYgIkQENgyvyxlxD7wx6nOt01Oem9yBY+1Y5x8DeCJ0JRBAEQRAEQRAEQRA+0A9v5q7b71hh2e1QZFXD0nU7sXTtbsiqhqgouJ6N4yzPrXRrmcvW7wp8aDRz2UQlJatYtm43Mor3eQD5UNTuHcRdCEO+fLoDCuuGMX31x6rdMmRVy3t+Unf17JT/H1sOBrpH1fSzMGRVTwqUUr+lwq/drHA995WXMGzSkwTxX0lg0LieEJZE5svXl67biefW7AqcwF26bhfaOjNF961i7OuGonKAIbT+5kWxcSTjd2lkNylGfUHaZPziJ15zzvHn9/Z4bt/ofk9u3+S8a7wE0K34bRDWeBBmWcWUU0y/VTnH0nXh9w83+f2tWuW2Nvl9FihW731xHOyN9Osk0O7du/GTn/wE5557LsaMGYNoNIoRI0bg4osvxptvvul6TyKRwM0334zGxkbEYjGMHTsW//3f/4329nbX6zVNw8MPP4ypU6eioqICw4YNw2WXXYYtW7Z4yrV8+XLMmjULgwYNQk1NDWbPno2//e1vobSZIAiCIAiCIAiCCBdjmkLfYsTfpJ0gMAhgONguo7UzAwEMQnbFjOBYOeN3esMos7VDxobmhG/53WAANjQfRlunXPTEQPYYAV+TwMVMFHfJ16W7nFKyX+TTDQPD9oSGdpnrZRWQJSw9b2g+XPBsFCc8K7EAPRFUzAqtcuNqNxeVG/3J/Kzl71v5bdKdU6dKg5serNjaav8AAJ5+ao0thzozgeU61JHBn9/b42Kj/PUZundrVzExhEO3eZhxzY1CdrBilWV7wn8iJAjFJs2sBPEt4+9GvM6HxoHDSX1MCLaCETn2s/Zv0098+pgbrn7nocpC5bnqr4iyipGpO/027P4RRH4rWrZrGG3y41ue9XlUaNW7rewQ+s9ApV8ngR5++GH813/9F7Zs2YJzzz0Xt9xyCz796U/jj3/8I04//XQ888wztus7Ojowa9YsPPTQQzjuuOPwX//1X5g0aRIefPBBnHXWWUilcpfqLViwADfddBM457jppptw3nnnYdmyZTj55JOxeXPuPtFPPfUUzjvvPGzcuBFXX301rrrqKmzYsAHnnHMOnnvuuZLpgig9I55fgrE/vwdjf34PRjy/pNziEARBEARBEAQREtz8f3aK3mMSIh6x/xObZc/1MLa7MohFBHO+SfJYlWJ861Vme9p7WzO/tKdVvU3dmFPhRa0h8ochn31CkyGSnTSKZA/l7vrNWzdJRZ+R9Jo/iorh69nUb0CsbS6lfkuFm90iIjMnF6NZn3a2jYMjHhFhbOTnnBsM0/d7Ajc9GG0XGGwr0qy6MP5u1VksT2wJCudAa0cmRzbJR33tacW1XVKkuOnFrphaOtu6ySv4iCNJpff2vSC+ZaVQPDF9qogxwWk/t7qiEcGUOS4Fi7lubc63jV6+8tzKEhkztzZ1jsteZbnaQbS0MeR+G3b/cO3LYuG+bLVtkLHKrT7r81CFh0/0xXGwN9KvD0Y45ZRTsGLFCsyaNcv2/euvv46zzz4bX/3qV3HhhRciFosBAH70ox/h7bffxu23344f/vCH5vXf/OY3cf/99+Ohhx7CHXfcYX7/6quv4rHHHsPMmTPx8ssvIxqNAgAuv/xynH/++bjxxhuxfPly8/rW1lZ8/etfx9ChQ7Fu3TqMGjUKAHD77bdj2rRp+OpXv4o5c+Zg0KBBJdMJUToqt3yI6o82AACEdLA9eYn+QYfcgYv/dLH5eekXltIZQb2MTErB7+7+p/n5379zCp0RRBAEQRCEb4yJQufWJJXR7MS1I8PAuT7ZyBjALS+VC4yhMiYCXH97VlZzV4vEJSF7b26ZDAzVse4/w1THRL1N3ZhfcdtmLiwM+Zz6jkuiea6GlXy6qYgwwGEHg0qXA9PD0LOp34AKtra5lPotFW52Y2CoiIrZRBwzv7PCoE/CVsb0id20rEGzlJHPJr3x5XA3PURFAZKg+6It8eDydzedGRixBSx452UMqKuK+rKRtb4u3fOcewutrvOUxYyp4cU1J8XGkYpIL3SqLEF8y0qheMKQ9akixgSn/dzqEhhDpS8fy8WtzQLzjrD5yvP2CSGQbK6xrkAbu9Nvw+4fXjotKIvFtsat1rgVtD7jechL70Q49OuVQHPnzs1JAAHAmWeeidmzZ6O1tRXvvfceAP0h/rHHHkN1dTW+853v2K7/zne+g+rqajz22GO27x999FEAwN13320mgADgc5/7HD7zmc/gpZdewo4dO8zvn332WbS1teHrX/+6mQACgFGjRuHGG2/EgQMH8Pzzz3e/4QRBlI2MmjH/EL0TVdHMPwRBEARBEH4wpiCy82s5b/G6JYA0jUMDx1HVEuoqo9DAoWn2CVfGmFmmszxByE0AGWXWVUmY0lDT7XZNaajF4EoJxT4Vua3WCJMu+ey6A7z17aYbxoDGGgHVEtPLchjQ2YSw9DyloRZVscIHsefKotcviUJJ9VsqvOxm+LyB0/cFwXKdy8RfmL7fE3jqgbm0z+aT3joD7LFlSGUUQRlSFcXnp9b7spG1PkP3bu1yi2OF0ONc+HHNSbFxpLGm906ZBvGtrkn6wvFaYEBthT4mBLEnB3LsZ/WJoD7mhnebc68tVJ7fGFWorGLK6U6/Dbt/FNOXjX4LdLXJ6lv5Vu0Uq/e+OA72Rgbs68+SJAEAIhFdBZs3b0ZzczPmzJmDqir7m/tVVVU444wzsHz5cuzcuROjR48GAKxYscL8zcmcOXOwYsUKvPbaa5g/f755PQCce+65rtffddddeO2113DllVfmlb2pqcn1+/fffx9jxozBypUr895fKhKJBASNI37ww7LUH5SImgTTupZSxg9thiJWFF2eWlOBdP0I8+99RQ8AICj6yqUwZF65clu3y+irpLQUMpmu5M+qVasQF+Ilqy+R0PeDLVef74uoMkcm0/Wm7apVqyBKPf9EQbbrm5Dd+i5ku75Jd+yWSCRQU9M3JgmJvoExVcEYM7fZkfMcGs45R0bVIIkCLp4+Ghwcj76+FRlVQ4zZD0M2yrSWFxHdJvK6ypw7bVTebXB8wfQ34edOH4lHX98KWdECv/wdyXOAfRhY5XPTnUEh3TAAUZHhjJESlm9XzMPK3fCjZ79tjksiTj1mCP5vw15f1wOAKOi+JYkChg+KobVT9n1vb8Gv3aww43X+PJeF5vs9RBD/lTWenXzVY4HAcleoGNc6Y8svV3wS6Oyoi6ePwuDKaLf6ltu9zjhWiIior0IMNa65UGwciYr++21PE6RNhkX8xGvGGD4/tR5PvbkDss+XJhlz75tWn+hO/C6mzYXKC6usYsoppt+KjOHi6eH3Dy/58/Vl4/nE2ia3FXVB6nPi1PuiN7Z1t6kE+vlKIC927NiBv/71r6ivr8fUqVMBwDy/Z8KECa73GN8b13V0dGDPnj045phjIIq5ndB5faE63K4n+hZ7516C7V//BrZ//RvYO/eScotDEARBEARBEEQJkEQBQ6tjnr9rGkc6O3lWXxvHlU2NuKppLEbU6C8HpRUt5230iGMSJCLkvhHrLDMoXvMzhmxB37RlyH92QEbRoGociqb/PyXnbnnnh0K689IN59ysf/uhDmRUjnMaJbMsN/zq2bmFUD5mTRoe8I16ZtZ/9KB4KDosBVb9ZhQtRza/dhOY7u8CY67XWclnE0NHvU1Xgfx3cAVG1Abz9auaxqK+NtjLrF88aVRw2Ry6d7tXEgXfvs6ydg8a1xSVF2Xn7rTVDVktvb8ViqFB2gTo2275kfWLJ40ONCYIjOXoTNF0O5mrZ33I6Efvbm12hmOjfYXKC8sniiknaL+tH1zcuO+HIH2ZMX3bQWebrM8ChbZv667e85WuasXFh4HCgFsJJMsy5s+fj3Q6jfvvv99M4Bw+fBgAUFtb63qf8SahcV3Q6wvd43a9F6tXr3b93lghNHPmzIJllIKVK1fiQHsaqaMmlaX+oESUDnChqwukhkyAEhmY57cYK4DCsN3MU8d0u4y+SofcgejzXct6zzjjjJKeCWS8GV2uPt8XyaQUbHvpH+bnM844rSxnApHt+iZkt74L2a5v0h270SogImxsW1Yxhjv/7Xh89al15hvWSVmFwBg4h7mNV31tHAvnz8Dw7GTHwvkzsGDJWrQkUkgqKgRkzwrK3mO8Fc8YkFI0CNnDk/OVGQbDa+KmbM2Hk3lXyRg01MbR2imbZwdY9bM3kcLi1dvw23/uRNIyATP7wRWYO30krmoaG0h+q3xeurPqhgN4YPkmdGZU0z6Pvb4Vz0jAGSMl3Df3RNzy+3fRkug6xzWtaCXTM+ccogD4eameARAFhmGDomgadxSWrd+NjOXGYnUYJoZ9rfpNyVqObP7tVoHbzzsOP/zLppzrVNt2QXC1iSHP/76zJxR/C5vA/svh+1qjXY9ddRKueeItm0/nY94j/zB1E0Q2qx692iUwwNdiIK7HOb/9zbDz2h2tRfWJoHYYXhPHpjxyPPWPHUX7W6HcilHH02/mr6NQm1TObYkcY2K9kKxBxgRJZGgYXGHqzJD9lU17kZItQY9zcDBzrCx2bLPKtudwEp0uk/wqB2riIu6dOzV0nwizHL/9tqE2jseuOqlkcSxIXxYYQ0rWctp0yS/d56mD1Ned5x3D71Z9fMCW+Owt40BvYUCtBNI0DVdffTVWrlyJ6667ztymjSAIgiAIgiAIgiC8cE6BjRtWjYqoCEnU33mNRgRERIZoRJ+4uP7McXh2QROOG9GVkJxcX4PnbmjC9WeOQ31tPOeeG2aOx59uPAMLZo53/d2tzLAwZLth5ngcXROD6DFLWR2L4JrTx+IP/3EGRJfXxDfuSeDSX63Go69vRWuH/YzMlkQKj76+FZf8ajU27kkUJZ+X7gzdcA6zfqvNFI2jNcXxl60Z3LHsffzH7GNN2wH6ioQgeva7HdzGPQn8+OWPCiaARIEhLgmoHxzH3GkjAc5yEkBA93QYBqrGXfXrJZtfu50/td71OkFg2RVnDBVRMccmVn/rzKgF5SkXfvVw3IiaQNday//TjWfgmtPHotrHGVRW3QAIXF++dkkRAfGIgAop/6ogDn1Cee60kQX7m9XO3ekTxejWS45E0r5NY1j+Zq2jrbNwHV5tiogMouC+KqOQrJzznDHBuToVAEbUxLBg5nhTZ1bZbQkg6MkEDg5BYKZ8xY5tk+trcN/cE1CRZ2u0ZEbFHUvfK7lPdKecfP2WwT7elmLcLyS/0ZerYyKqYxHEJQFSSM8kYekdsPeZdC8bM3sbA2YlkKZp+PKXv4ynn34aV1xxBX71q1/ZfjdW53itxDH2JDeuC3q9856jjjqq4PUEQRAEQRAEQRBE70RgDLGIiKjI8bPLpiEiCqiORTClocZz3/7hNXHcOmcSbjzrWGxoTqA9reTcc3xDbd7fi6VQ3sIp26GODJrbkkjKCiKCgCkNNZg2ps5Tjr2JlP7meFsSACBFGDJKV6qgIiIio2pobktiwZK1eO6GpsArgvLpzlm/lagogHMNigY0tyXxi1c/hiQKiIqAxoEfz/sUhg+K+9azn+3gDHkOOZJhBjFRgKzqE1ZDKqO4b+5UTDi6GvN//U/szb4ZLgCwTml1V4fdQeP61jpu+mV5ZPPj84C7fX/9+has3d7qmnRz2lt0vLVeTl254VcPQa+13nPnF6bg9s8dh79t3Itv/+F9HE7KYMh9m99NN0HryydrRtHw/Rc2oPlwCsiuSDEQGRARBCiaBnCONz45iJvP8S7faefu9olidOsmh/PMlO74m+HeOTFUZMj4qMPZpp2tnbjvxY040J4BYwDj9hcZnOX89N9P9KWrbz//Hj7Z3wHG9PFvxX/PNnVWqD9WSnqdnHMMrojiW5+fjFF1lUWNbXsTKdyx7H10ZlSIArOtGLTWVWqfCKMca79dt6MVG/ckwDkKjrelIJ/8AEJ/JilW79bhICc+MNjOWept40C5GRBJIE3TcM0112Dx4sW47LLLsGjRIgiCfRFUoTN5nOf5VFVVob6+Hlu3boWqqjnnArmd/zNhwgSsWbMGmzdvzkkCFTqTiCAIgiAIgiAIgigP+fInjDH8y6jBGDbI+5wgJ3FJxIzGuqJ/LyXF1M0YsHj1NnNbm1hEyE78ds3GCAJDjAlIKxpaEiksXr0dt84Jvh21l3zO+hXHyhCBAZKgT0we7EhnrxMhMuDTxw7FoLgUWJZ8WOVxQ8q++ZxWNBxOyXh7ZxvW72y1tSElq7bZ27B0WAyyqpmiuOq3gGx+/cp63fPrdnmuunLaO6NqUNXw/S1sgvSvYvpiXBLxwZ4EOjJqNlEtoMOnrboTd6z3PrB8E/YeSYMBiEn2+hljuu9z5ss2TjunZD15VKgtQeT1Q0580cKPbzkxNGAdRpte2bQXrZ16AjAWEZCUVdu5Oc5ynl+/O69cRrlHVcewszVp+95L9rTibafWpIzNe9txwYkjA+nHra54tn1aCHEyrHG32H57+vihOH380G7X31285C/VM0l39J4TH/L4XW8aB8pFv98OzpoAmjdvHpYsWZKTsAH05EtDQwNWrVqFjo4O228dHR1YtWoVjjnmGIwePdr8ftasWeZvTpYvXw7Avof5rFmzAAAvvfSS5/XGNUTfo2bdahz16p9x1Kt/Rs06//thEgRBEARBEARB9GVUjWPZut2QVQ1RUfCcuGeMIZpdAbNs/a7QDm1OyarP+vVVQYrKoajcXNHjd3u3rnLyX2+Vx20bJWs5hj6WrtuJpWvtbXBbb1QqHeaDc26eC1IO+zrxb++e11W5Kbduwqy/3G3pSTnCqqOYcpa/32Jb3Rg0HvaknXqLTxDlh3whOP06CWRsAbd48WJceumleOqpp1wTQIDuFNdeey3a29tx99132367++670d7ejuuuu872/fXXXw8A+M53voNMpmuJ91/+8hesWLEC5557LhobG83vv/jFL6K2thYPP/wwdu3aZX6/a9cu/PznP8fQoUNx0UUXdbvdRHkY+uqfMfJ3j2Hk7x7D0Ff/XG5xCIIgCIIgCILoIQLOmfU7jqQUtHXK+mHS2aSH21kUgP5mrgCG1g4ZG5rD2aN/Q/PhnPqtWO0jCNkDqGHfNiZMbPIUcA5DHwfbZbR2Zmxt8Lq3FDrMh2bZTspNv1Y5e0I2N3v3pL/1Ztx045WH7A19MV/9rnbuwbb0lBwMLLQ63O2fv28cTsq2WOhnu8tCdZbKTu51Ud8fiJQ71vVF+vV2cN///vfx5JNPorq6GhMnTsQ999yTc82FF16IE088EQBw22234Y9//CPuv/9+rF+/HtOnT8e6devw0ksv4eSTT8Y3vvEN272zZ8/Gtddei8ceewzTp0/H5z//eezZswfPPPMMhgwZgocffth2fV1dHX7+859j/vz5mD59OubNmwcAeOaZZ3Dw4EE888wzGDRoUEl0QRAEQRAEQRAEQYRDX8z5OCfJvSbNi0HVNHBw28SfKDCIjEHlPGc1jJ6E4WhPK6HU355Wc+qXsmd2CEyXRbW8/Ku3nYODI1xNeMtjJRaxv49r6AOc2e6JRgSoGRU8zz1h6TAf3GVNUlzSt+YytvzqSdk87Z3dCShaRl2VGzfdxCIiUrLuRxUltpV7/fp2TMZKPL/1u5VVjj7hJocoMPP8EUkMFt/c4oJ7HQIEpgWqo5DO4q46A5CNhcXgWqcoQNH0bejCtJOXfyXztm9g9P2BhqffqeUfM3sr/ToJtG3bNgBAe3s7fvCDH7heM3bsWDMJVFVVhddeew133XUXli5dildffRX19fW45ZZbcOedd6KioiLn/oULF2Lq1Kl45JFH8NOf/hTV1dW46KKL8IMf/ADjx4/Puf6KK67A0KFDce+99+KJJ54AYwwzZszAt7/9bXz2s58Nre1EYTQm4eMxX7R9JojuIAkSvjjpi7bPRO9CFAWcMHOk7TNBEARBEATRPURBAAPLeYM8HhXAee6b6JzrqZfqWDhTEtUxMaf+WESEJOoTRM40j5HUML4PeyWXmzwGlVHRVR8Cy65Qspx6LzCGyqgIjtLrMB9uabKIIKAyqv/ifBM/LNm81iO46ZcZuuoBf+vNuOlGFHTdAKWzVb76JVGAKAT3FbeyytEnXP0NDBUh+ptXzAhaR3E6s/fxfNtp+pWdMYZKKXw79RafIMqH4at5xwGQL7jRr1u+aNEiLFq0KNA9tbW1eOihh/DQQw/5ul4QBNx000246aabfNdx3nnn4bzzzgskFxE+mhjF+8feEFp52752B1j29TLuse3gQODpN3cEvufyU8eUQJKeJypGccOnwvMpInxEScDJnz+m3GIQBEEQBEH0KwbFJQyulNCSSEHTuG2LLufEoaZxaOCoq5IwpaEmlPqnNNS61u+2DZKmcXPiM89xPeHJ48hkOGUy9DG8OgrOGfYeceiQ5aZgSqHDfAgM2bVT8KXfUsvmZe+e8rfejKdueshWQftivvrztaUn+0Sp/Y2x8OooRme1FVFfqyO8donrSTv1Fp8gyg/5QnDoFWiCCAmtogpqdQ3U6hpoFVXlFocgCIIgCIIgCMKklOcWiQLD3OkjIYkCMqrmeaYE5xwZVYMkCpg7bRTiUjgvz8Ul0Wf9QEbVEBEZIiIzJ8bD3hDOKo+S5+Ahqz4unj4aF88onw7zwZiuLwC9Qjb/9u55XZWbcusmzPrL3ZaelCOsOoopZ84JI2xJwqBnAvWknXqLTxDe9NQZieQLwaEkEEEQBEEQBEEQBEEMADjnUDUORdPw0d4jSMlq4Zt8lNXWmcG8k0djRE0cAJBWNGiO5IemcaQVfa+z+to4rmxqLL4hLlzVNDZ//RyQs1utDa2OQSrxtsBWedxw00fBNpRYh24YdrauBuop2VSty8dUjdv8tTfqqrdQbt2EWX+529KTcoRVR9ByLpo2MqcMNzTeO/pjb/EJwp2AOUSfZXb5XnNb0vQ98oVgUBKIIAiCIAiCIAiCILpBD734WjR7Eyk8sWorOjMqkrKKlKzhBy9uxOwHV+CB5ZuwL5EKVNYDyzfZylq3oxXzFv4DTeOH4OiaOASBIamoSGZUpGT9/0lFhSAwjKyrwML5MzA8T4KkGIbXxLFw/gw0DK5wrV9W9W3NRtZV4JufO862PVUp3lw25BlSFbV9n08fhdpQah1acdo5rWRPUuL6dnpJuXSyGXX/deNe08eSsmrz196kq95GuXUTZv3lbktPyGGEn7DqCFrO0OqYXR5HQDT649rtrb2iP/YWnyBKj9vzxtJ1u0zfA0C+EIB+fSYQQeRD0GQcu+P35uePx3wRmiCVUSKiryOrMn7/UZdPfXHiFyGJ5FO9CVXR8P7K3ebnE2aOhBih9yEIgiAIgghGT213EgYb9ySwYMla7DmchPUdWUXV0JJI4dHXt+KFd/Zg4fwZmFyff698o6yWRMpWlsaBlkQKz69vxrDqGOZOG4mVm/ejtUMGBwcDQ12VhLnTRuHKpsaSTcRMrq/Bczc0YfHq7Vi2fpet/kpRwxkjJXx7XhP2HPaf9OquPDedPQF3/+8HUFQ9iRIRWV595GtDT+gQ8LYzAKgcEJh+/kJE0M8rCVM2a92Z7BvcBm7+Wm5d9VbKrZsw6y93W3pSjrDqCFLOzkOdnuX01v7YW3yCyCWs5yOvcUjVeI7vkS/4g5JAxIBF0DI4fsuvzc9bRl3YrSSQdGg/mJwBAHApCnnIsG7LSPQtMloGv36vy6cuPPZCSgL1MlRFw7rl283Pk0+vpyQQQRAEQRD9lr2JFBYsWYvmtmTOZH4sIoJBP+OluS2JBUvW4rkbmjwnSqxlOREFhlh2X/69iRTe+OQgfnfdadjfnkF7WkF1LIIpDTU9shf/8Jo4bp0zCTeedSw2NCfM+lu3vIuoyDC8Jt5jSSAAqK2QEIuIiIocGgd+NX9GQX14taEndJjPzgBQKYnm+QuDK6L41ucnY1RdZSiyOesWmZ50MqiIiK7+Wi5d9XbKrZsw6y93W0oph3PlTVh1dLccZ38UmJ7wNyh3f+wtPkGET75xSBIFRASW43vkC4WhJBBBhMToJ36K6o82AADaJ07BllvuKbNEBEEQBEEQBEGUglLseV8KFq/ehpbsVm9RkSHp2C9fEBhiTEBa0VcFLV69HbfOmVSwrFhEgJKxnyfkLOv3a3Z5ltUTxCURMxrrzM8rt5d3+RZjDCIDZk30/7Kgsw09QRA7tyZlbN7bjgtO9HemSNC604pm62z5/LUcuuorlFs3YdZf7raEIQfzuYFoWG0tthxnf0z10v7YW3yCCI+gzxuG75Ev5IdefyYGLBqLYOeIc8w/GqOcKEEQBEEQBEEQhekL28GlZBXL1u2GrGqIikLO2+YGjDFERQGyqmHZ+l22w75LUVZvpC/Ysycop537u48RRF+C+iNRLsj3SgclgYgBiybGsPb4O8w/mhgrfBNBEARBEARBEEQfYEPzYbR1yhDAIAj5sxyCwCCAobVDxobmROCyrN8UKqs/ECRn1FdWjQHudra2tZR2dq3bQ9EDwceIgUNvy0FzzgvGAivUH4kwKfi8YfmKfC8YtPSBIEJi3/mX4NCZ5wIAlEH5D1QlCIIgCIIgCKL/4PWmajlpT6v64cg+RWMM4OBoTyu+yjK262IAoo4zFvOV1Rvxuz2TQR/K6wTCzc5xSUBS1rJ/t5+tEKad3eqOigIUVQVH3/cxguhLuPbHiAA1o/fHGPVHokS4+Z4kMsiq/l1EtI/X5Hv+oSQQQYRE++QTyy0CQRAEQRAEQRAEAKA6JoKBgftcisK5ngypjuVOE7iVJYlC9i3c3CRYvrIGGrwPpYzc7CwKAiqjun2FEtrZrW7GGCqjIjQOiAL5GEH0BIwx1/4oZPsjR2ljATGwcfO9WEREROAQWO5LG+R7/qHt4AiCIAiCIAiCIAgiEL1v5Y+TKQ21GFwpQQOHpuVPRGgahwaOuioJUxpydzXwKktkLCcBVKis3oBTG0EXcvV+6xeHl50FxnImfcO2s1fdjLGcBFBf8DGC8EsvXEiatz+WOhYQAxvP5w2hbz5v9CYoTUYMWJgmY0zLS+bnHSPOBRekMko0cHn6zR2B77n81DElkIQgCIIgCIIg/ND7V3fEJRFzp4/Eo69vRUbVIInuM42c8+zvAuZOG5Wz5ZdbWTHmflizn7J6I0HnYINYvy+dCVROO/d3HyOIvgT1R6JckO+VDloJRAxYRC2DaZv+P/OPqGXKLRJBEARBEARBEL0Q5wREWlahahyKpkHVOFKyWibJ8nNV01iMqIkDADJqbjZC0zjSin7eS31tHFc2NfoqK61oOauLgpRVbtJKcPtxzs17Didl3zbPKFqf8BWDctq5P/kYQfQVvMYz6o+EX6zj474jqW6Pc+R7pYGSQARBEARBEARBEASRB2Nveo1zpBUVVy9ag6SsIiVrSMoqLvp/q/DA8k3Yl0iVWVI7w2viWDh/BhoGV8CxoxbSioqkokIQGEbWVWDh/BkYnp10KViWwJBUVCQzKlKy/v8gZZWL1pSGB5Zvwn/8Zp3Nfuc8tNLTfnsTKTywfBM6M6p5z3u72jD7wRV5bW7c98O/bLLVVei+clNOO/cHHyOIoLitcugJjBh1+WNvuo5nAKg/EnlxGx9f/mBft8c5GgtKA20HRxAhMebRB1G55UMAQOe4Sdhx3a1lloggCIIgCIIgiLAw3pDmAA4cSdt+23ckjUdf34oX3tmDhfNnYHJ979mbfnJ9DZ67oQk//dtmPP3mDnMrM0kUcFR1FHOnjcKVTY2+JlGMshav3o5l63ehtUMGBwcDQ12VFKisnmZHQsXP1iXRltkKOfsGsUFLIuVqv417EliwZC1aEinbFnAa977HeZ/funoT5bRzX/YxgvBDbzgDKF+Mco5n1B8JNzzHR42HMs7RWBA+lAQiiJCIJNoQPXQAAJAZenSZpSHKQWWkEn+5+C/m56gQLaM0hBtSTMT8e5rMz2KEFsQSBEEQBFGY1s6MmQACgJgkICV3TZzFIwJklaO5LYkFS9biuRuaetXExPCaOL786WPwh/W7oXGAg+Pei6bi/Kn1gffRH14Tx61zJuHGs47FhuYE2tMKqmMRTGmo6bV78u9NpPCzdUkcSHIIDIhGBHMrGQCoiIjIqJrNfhzAgiVr0dyWzClPFBhiopBzz/CaOPYmUrb7IiKDbNmKz62u3uQrBuW0c1/0MYLoKzhjlJ/xjPojYcXpQ1YiIoMkuI+PQaGxIFwoCUQQBBESjDHExFi5xSDywBhDhB4WCIIgCIIIyJ/f3WN701VwvMotMIZYhCGtaGhJpLB49XbcOmdSzwpZAAb9WUhk+qcpDbXdmkSJSyJmNNaFJV5JWbx6Gw6ldAvGIgIcxwtAEBhiTLDZj0N/m9m4R8moBe+5dc4kLF69zX6fxgGL93jd11spp537ko8RRF/BGaOcp8V5jWfUHwmDnHHO5/hYLOR74UCvQBNESByZMg2tTZ9Ba9NncGTKtHKLQxAEQRAEQRBECKRkFa99tL/gdYwxREUBsqph2fpd3T4YudQ4zwjqr6RkFcvW7YaqARHB+/wNq/2WrtuJpWt3Q1Y1REXB1z3L1u9CW2cGy9YFv6+3+wpBEP0DIx5SjCKKhXyo70IrgQgiJPafd3G5RSAIgiAIgiAIImQ2NB/GkZTi61pBYBDA0NohY0Nzole/uVquw8h7mg3Nh9HWKYOxwokvw34H27PXg0FwuYm53NPaIePP7+1BW6dsu8+ryr7kKwRB9A+MeOgV26xQjCLcIB/qu9BKIIIgCIIgCIIgCILwoD2tum6XY8x9iIzZEiqM6WfutKf9JY56CmfSZ6CsBNLtx23JGFGw2M+hCMN+nNsPcI9azpKMOs6VNO5p7cjodVnuE0Vmfo541NXbfIUgiP6JGQ8toagvjmdE+XDzIUnseukhKrqPj+RD5YdWAhEEQYREh9yBL/zhC+bnP134J1RJVWWUiHCSSSl4+q43zc+X33UqonEaCgmCIAiC8KY6Jrqu5qiQRKic5yQROAcYGKpjvfsZw3muUX9Ftx/LSeTls5/A9MQN7zorHVFRyE6Q5urOsHldVVSvi3fVxsBQ2cd9hSCI8Chn5DXjIbdHxIqoCFWjGEUUxs2HYhEREUFPDDlfOCEf6j2QBQiC6JM8/eaOwPdcfuqYEkhix/kwRfQ+yEYEQRAEQQRhSkMtBsUjSLdnbN8zxhBxTHZoGocGjroqCVMaanpSzMAMlCTQlIZaDK6U0HJYhWZ5DMxnv+HVUXDOsPdICprGzS1vnBOk1nvqqiR8fmo9fv7Kx2hJ2O/r675CEET/wIyHzhgFlrNSkWIU4YaXDxUaH8mHyg9tB0cQBEEQBEEQBEEQHsQlEZ+ZNLzgdZxzZFQNkihg7rRRiEtiD0jnH+f0zADJASEuiZg7fSREAVA07xeCrPa7ePpoXDxjJCRRQEbVfN0zd9ooDK6MYu704Pf1Nl8hCKJ/YsRDilFEsZAP9V0oCUQQITHspT9g5FP/DyOf+n8Y9tIfyi0OQRAEQRAEQRAh8dnJw21JFFXTbL9rGkda0b+rr43jyqbGHpSuOAod6NyfuKppLIbE9famFQ2aZp+0crPfVU1jMaImHugeo65i7iMIYmCQUTSoGoei6f9PyWqP1k8xiugu5EN9E0oCEURIDHpvDY56/WUc9frLGPTemnKLQxAEQRAEQRBEN9mbSOGB5Zvw7T+8bztTJilr6EgrSMkqkhkVSUWFIDCMrKvAwvkzMDw7OdKbGUA5IAyvieOm6RUYWsEgCAxJRbdbPvsNr4lj4fwZaBhc4fseo65i7iMIon9jjCe3PPsOkrKKlKwhKauY/eAKPLB8E/YlUj0iB8UooruQD/VN6EwggiAIgiAIgiAIgnCwcU8CC5asRUsiBVnRcn7nAFSNIxoRcFR1DHOnjcKVTY19ZrKDlfV48p5nTI2Ib59WiY94PZat34XWDhkcHAwMdVWSq/0m19fguRuasHj1dt/3dOc+giD6J/nGk5ZECo++vhUvvLMHC+fPwOT60p+dQjGK6C7kQ30PSgIRREioVYMg19aZfycIgiAIgiAIom+yN5HCgiVr0dyWBABEI4K5tQkAVESye+EDGFwh4XfXnYYxR1WVSVp/aI59+wfSSiCDwXEBt86chBvPOhYbmhNoTyuojkUwpaHG87yC4TVx3Don2D3duY8giP5F7njCkFa64nFFRERG1dDclsSCJWvx3A1NPTJxTjGK6C7kQ30LSgIRREhsv+H2cotAEARBEARBEEQILF69DS3ZrXliEQGO7e4higLiAkNa0dCalPH7Nbtw65xJZZDUP842DKQzgZzEJREzGutKfk937iMIon+QO55wwLLBqCAwxJj+okFLIoXFq7f36HhCMYroLuRDfQNKAhEEMWB4+s0dge+5/NQxJZCEIAiCIAiC6K2kZBXL1u2GrGqoiIhgjAGOVTQAwBhDVBSQVFQsW78LN551bK9+85XnrAQauEkggiCInqC/jicEQfQ9hHILQBAEQRAEQRAEQRC9hQ3Nh9HWKUMAK7haRhAYBDC0dsjY0JzoIQmLwzntOIAXAhEEQfQI7uOJe/DtS+MJQRB9D0oCEQRBEARBEARBEESW9rSqH25smacTBWYmTUTHChrGAA6O9rTSg1IGx3kmEKOVQARBECXFbTwRBJifRaFvjicEQfQ9aDs4YsCiMQkfNV5u+0wQ3UESJFw++XLbZ6J3IYoC/mX2KNtngiAIgiAIK9UxEQwsZ/u0CkmEqvGcSTvOAQaG6ljv/ue1ptk/00oggiCI0uI2njAwVEgiNI1DFPvmeEIQRN+DogoxYNHEKD4Yf21o5VV99D4i7fqSXaW6Bh0TTwitbKJvEBWjuHZqeD5FhI8oCZhx3thyi0EQBEEQRC9mSkMtBldKaEmkoGnc3MKHMYaIY8JO0zg0cNRVSZjSUFMOcYuGzgQiCIIoLV7jicAYhH40nhAE0fuhV6AJIiSOfuF3aFz4ABoXPoCjX/hducUhCIIgCIIgCKII4pKIudNHQhIFZFQtZ0WQAeccGVWDJAqYO21Urz/E27kdHCWBCIIgSkt/HU8Iguh70EoggiCIPDz95o7A91x+6pgSSEIQBEEQBEH0FFc1jcUL7+xBc1sSaUVDVBQsh3rrb2xnVH1/tfraOK5saiyXqL5JySpUjevnU4AhraioiNJEI0EQRCnpj+MJQRB9D1oJRBAEQRAEQRAEQRAWhtfEsXD+DDQMroAgMCQVFcmMipSs/z+pqBAEhpF1FVg4fwaG18TLLbInexMpPLB8E254ai2SsoqUrCEpqzjvp6/jgeWbsC+RKreIBEEQ/Zb+NJ4QBNF3oZVAxIBF0GRM3P60+fmjxsuhCVLR5e268kYIaf0fUFqMBu2BiMplrDn0AuQNdQCAy4+7HJJYvE8R4aMqGt59dZf5+V9mj4IYofchCIIgCILIZXJ9DZ67oQmLV2/HsvW70Nohm6to6qokzJ02Clc2NfbqCbuNexJYsGQtWhIpyIpm+21vIoVHX9+KF97Zg4XzZ2ByPZ1BQRAEUQr6w3hCEETfhpJAxIBF0DI4buuT5uePR1/SrSRQZtiIMMQi+jCKJuOfrc/jvXZ9W41LJl5CSaBehqpoePuvXVv8TTmzgZJABEEQBEF4MrwmjlvnTMKNZx2LDc0JtKcVVMcimNJQ0+vPbNibSGHBkrVobksCAKIRAWlLIqgiIiKjamhuS2LBkrV47oYmmoAkCIIoEX15PCEIou9DSSCCIAiCIAiCIAiCyENcEjGjsa7cYgRi8eptaMlu9RaLCNAc55ELAkOM6YmhlkQKi1dvx61zJpVBUoIgiIFDXxxPCILo+1ASiBiwaCyC7fWfs30mCIIgCIIgCILo66RkFcvW7YasaqiIiGCMAZznXMcYQ1QUkFRULFu/CzeedSy9kU4QBEEQBNHPoFlvYsCiiTGsn/zf5RaD6IckZRUA8Pu3diImVvq65/JTx5RSJIIgCIIgCGIAsaH5MNo6ZQhgEASW91pBYBDA0NohY0Nzgt5QJwiCIAiC6GdQEoggQoJl0mCavsc2FwTwaKzMEhEEQRAEQRAEMRBpT6v6oeOW/I8gAAwAB+DMCzEGcHC0p5WeFJMgCIIgCILoASgJRBAhcczDd6P6ow0AgPaJU7DllnvKLBFBEARBEARBEAOR6pgIBgZu2QKOgaEiKkLVOCKOLBDn+u/VMZoiIAiCIAiC6G/QEx5BEEQv4Ok3dwS+Z1QJ5CAIgiAIgiD6PlMaajG4UkJLIgVN4+aWcAJjEER7AkjTODRw1FVJmNJQUw5xCYIgCIIgiBIilFsAgigXTJNxzK4/mn+YJpdbJIIgCIIgCIIgiG4Tl0TMnT4Skiggo2q2FUFWOOfIqBokUcDcaaMQl8QelpQgCIIgCIIoNbQSiBiwiFoGn/rop+bnnSM+C0WQii7v4Mw5SPzLyQAAefCQbstHEARBEARBEARRLFc1jcUL7+xBc1sSaUVDVBTMFUGAvgIoo+pnmtbXxnFlU2O5RCUIgiAIgiBKCCWBCCIkDp98ZrlFIAiCIAiCIAiCAAAMr4lj4fwZWLBkLVoSKSQVFQIYGNPPANLAIYkC6mv164bXxMstMkEQBEEQBFECKAlEEARBEARBEARBEP2QyfU1eO6GJixevR3L1u9Ca4cMDg4GhroqCXOnjcKVTY2UACIIgiAIgujHUBKIIAgiJKJCBf5j/CLzMyvxsWsH2tMAgKff3OH7nstPHVMqcfoEUkzEVfedYX5mLM/FBEEQBEEQ/YDhNXHcOmcSbjzrWGxoTqA9raA6FsGUhho6A4ggCIIgCGIAQEkggiCIkGCMgYH+Id2bYYxR4ocgCIIgiAFJXBIxo7Gu3GIQBEEQBEEQPQwlgQiCIAYQQVYNGQz01UMEQRAEQRAEQRAEQRAE0VehJBBBhMTI3y5ExY4tAIDkmHHYfdmCMktEEARBEARBEARBEARBEARBDGQoCUQQIRFr3onKLR8BALSIVGZpiHLAOQeHZn5mEMD6wd5jQVcP9eaVQ5xzcN71mTH0CxsRBEEQBEEQBEEQBEEQhBuUBCIIggiJjJbEI1u7VoBdf8xCxMTKMkpEOJHTKn5z5z/Mz1/63mmIxmkoJAiCIAiCIAiCIAiCIPonNPNFECGRbBwPLooAgNSoseUVhiAIgiAIgiAIgiAIgiAIghjwUBKIIEJizyXXlFsEgugVBN0+DujdW8gRBEEQBEEQBEEQBEEQRF9FKLcABEEQBEEQBEEQBEEQBEEQBEEQRPjQSiCCIAii7NDqIYIgCIIgCIIgCIIgCIIIH0oClYG33noLd955J9544w3IsoypU6fi5ptvxhe/+MVyi0YQBNFnKCZxdMmnGkogCUEQBEEQBEEQBEEQBEH0TigJ1MO8+uqrmDNnDuLxOP793/8dgwYNwtKlSzFv3jzs3LkTt9xyS7lFJAiC6Lc8u2YXkhnV9plJ4e+MSquUCIIgCIIgCIIgCIIgiN4AJYF6EEVRcN1110EQBKxcuRInnngiAOC73/0uTjnlFHzrW9/CJZdcgsbGxvIKShRF3RuvIHpwHwAgc9RwtJ5+VpklIgiiXBRapRRvT+dcR4kjgiAIgiAIgiAIgiAIImwoCdSDvPLKK/jkk09wzTXXmAkgAKitrcW3vvUtXH311XjyySfx3e9+t3xCEkVTt/oVVH+0AQDQPnEKJYEIgghEMdvbFQMlmwiCIAiCIAiCIAiCIAYOlATqQVasWAEAOPfcc3N+mzNnDgDgtdde60mRCIIgiAFGTyWbegJKaBEEQRAEQRAEQRAEQeSHcc55uYUYKFx66aV47rnnsGbNGsyYMSPn90GDBqGurg47duSfoGtqanL9fs2aNZAkCcccc0wo8gZFVVVwAGDhn69RCqoiGv7v/L3m5/NePBodSvGyf4dzTM7+fSOAuxnrnoA9Cdf0//cR2/VaooB0XZcO5Uc1IFPC+shugZHEGOaf3LXacslb34espnteELJd32QA2y0i9KExzQVV1c8CE0URihb80bevt7+vYrVbULZu3YpBgwZh7969hS8mQufoo49GZ2cnTjjhhLLUn0gkAAA1NTVlqZ/onZBfEF6QbxBukF8QXpBvEG54+cX777+PysrKsv+7hFYC9SCHDx8GoG//5kZNTY15TTFEIhEMGjSobEHo/fffB4Cy/WOvGC5YWWf+PVYNxLpR1i8cn4d0o6yepi/artfyG8vfK7N/SgTZrTj+sOlH5t8HDYoDiPe4DGS7vgnZre9CtuubdMduxstVRHkot+6Nl+qozxNWyC8IL8g3CDfILwgvyDcIN7z8orKysuzPxgAlgfokq1evLrcIrhgrlHqrfIQ3ZLu+Cdmt70K265uQ3fouZLu+Cdmt77Jp06ay1k++Q7hBfkF4Qb5BuEF+QXhBvkG40dv9YuDtZ1JGjBVAXqt9EomE5yohgiAIgiAIgiAIgiAIgiAIgiCIIFASqAeZMGECAGDz5s05v7W0tKC9vd28hiAIgiAIgiAIgiAIgiAIgiAIojtQEqgHmTVrFgDgpZdeyvlt+fLltmsIgiAIgiAIgiAIgiAIgiAIgiC6AyWBepCzzz4b48aNw9NPP423337b/P7w4cO49957EY1GceWVV5ZPQIIgCIIgCIIgCIIgCIIgCIIg+g2RcgswkIhEInjssccwZ84czJw5E//+7/+OQYMGYenSpdi+fTsefPBBjB07ttxiEgRBEARBEARBEARBEARBEATRD2Ccc15uIQYa//znP3HnnXfijTfegCzLmDp1Km6++WbMmzev3KIRBEEQBEEQBEEQBEEQBEEQBNFPoCQQQRAEQRAEQRAEQRAEQRAEQRBEP4TOBCIIgiAIgiAIgiAIgiAIgiAIguiHUBKIIAiCIAiCIAiCIAiCIAiCIAiiH0JJIIIgCIIgCIIgCIIgCIIgCIIgiH4IJYEIgiAIgiAIgiAIgiAIgiAIgiD6IZQEIgiCIAiCIAiCIAiCIAiCIAiC6IdQEoggCIIgCIIgCIIgCIIgCIIgCKIfQkkgAgDw1ltv4fzzz8fgwYNRVVWF0047Db///e8DlZFOp/H9738fEyZMQDweR0NDA66//nrs27fP857f/OY3OOWUU1BVVYW6ujr867/+K9atW9fd5gwYetpub7/9Nr7zne/gtNNOw/DhwxGLxTBu3Dh87Wtfw+7du8Nq1oCgXH3Oyvnnnw/GGOLxeDFNGJCUy26ZTAY//vGPcdJJJ2HQoEEYNGgQTjjhBPzHf/xHd5s0YCiH7ZLJJH784x9j+vTpqKurw+DBg/GpT30KP/jBD3D48OEwmtXv6a7dPvnkE9x11134whe+gJEjR4IxhrFjxxa8b/ny5Zg1axYGDRqEmpoazJ49G3/729+60ZKBR0/bbvPmzbj33nsxc+ZMNDQ0IBqNYvTo0bjyyiuxadOmEFpE9AXCiPVE72bs2LFgjLn++cxnPpNzPf0btX/x1FNPYcGCBTjppJMQi8XAGMOiRYs8r08kErj55pvR2NiIWCyGsWPH4r//+7/R3t7uer2maXj44YcxdepUVFRUYNiwYbjsssuwZcsWzzromaF3EMQ37rrrLs84whjDtm3bXO8LauuPPvoIX/ziFzF06FBUVFTgU5/6FH75y1+Ccx5Ciwk/7N69Gz/5yU9w7rnnYsyYMYhGoxgxYgQuvvhivPnmm673UNzo/wT1i34TMzgx4HnllVe4JEl80KBB/LrrruM333wzb2xs5AD4gw8+6KsMVVX5nDlzOAB+2mmn8dtvv53PnTuXM8b4uHHj+L59+3LuueeeezgA3tjYyG+++WZ+3XXX8UGDBvFYLMb//ve/h93Mfkc57HbqqadyAPyUU07hX//61/mtt97KzzzzTA6ADx06lG/cuLEUTe13lKvPWXnkkUe4IAg8Ho/zWCwWRrP6PeWy26FDh/gpp5zCAfDTTz+d33LLLfyWW27hc+fO5UcddVTYzeyXlMN2mUzGjJknnngi/8Y3vsG/8Y1v8E996lMcAJ8yZQrv6OgoRXP7DWHY7YknnuAAuCiK/IQTTuCCIPDGxsa89yxZsoQD4MOGDeM33ngjv/HGG/mwYcM4Y4w/++yzIbSs/1MO282bN48D4CeccAK/4YYb+G233cY/97nPcQC8oqKCv/baayG1juithOF3RO+nsbGR19bW8jvvvDPnzxNPPGG7lv6N2v8w+vTQoUPNvzvtbtDe3s5PPPFEDoCfe+65/Pbbb+fnnnsuB8BPPvlknkwmc+659tprzee02267jV9xxRU8Go3yIUOG8I8++ijnenpm6D0E8Y0777yTA+BXXXWVayxpbW3NuSeorTds2MBra2t5NBrlV1xxBb/tttv4lClTOAB+4403htx6wovbb7+dA+Djx4/nX/nKV/g3v/lNfvHFF3NRFLkgCPx3v/ud7XqKGwODoH7RX2IGJYEGOLIs8/Hjx/NYLMbXr19vft/W1sYnTpzIo9Eo37ZtW8FyHn/8cQ6AX3bZZVzTNPP7X/7ylxwAv/76623Xf/TRRzwSifCJEyfytrY28/v169fzWCzGJ0+ezFVV7X4D+ynlstvPfvYzvnnz5pxyfvjDH3IA/Pzzzy++UQOEctnOytatW/mgQYP4rbfeyhsbGykJ5INy2u3CCy/kjDH+m9/8xlUuIj/lst0zzzzDAfCLLroop6wLLriAA+BPPvlk8Q3r54Rlt08++YSvXr2ad3Z2cs45j8VieRMJhw4d4oMHD+ZDhw7lO3fuNL/fuXMnHzp0KB86dChPJBJFt2sgUC7bPfHEE3zdunU53//2t7/lAPjxxx8fuC1E3yEsvyN6P42NjQWT+Qb0b9T+x8svv2z25fvuuy/vRP93v/tdDoDffvvttu+Nyb97773X9v0rr7zCAfCZM2fydDptfv/iiy+aE8JW6JmhdxHEN4wJ3VdffdVX2cXYeubMmRwAf/HFF83v0um0+RLtG2+8EayBRFEsXbqUr1ixIuf7lStXckmSeF1dHU+lUub3FDcGBkH9or/EDEoCDXCWL1/OAfBrrrkm57dFixZxAPx73/tewXKampo4gJx/XGmaxseNG8erqqrMf8Rzzvkdd9zhOQF29dVXcwD0xmYeymU3LxRF4RUVFbyqqsp/IwYo5badpml89uzZfOLEibyzs5OSQD4pl91Wr17NAfD58+d3vxEDlHLZzvjH5yOPPJJT1iOPPEJvphcgLLs5KZRIWLhwoWfZd911FyXvfFAu2+Vj4sSJHADfv39/UfcTvZ9S+R3R+wiSBKJ/o/Zv8k30a5rGGxoaeHV1NW9vb7f91t7ezqurq/m4ceNs31922WWeNv7MZz7DAfDt27eb39EzQ+8l7CRQUFt/+OGHHACfPXt2zvUrVqzwHK+InsVY4fPWW29xziluEDpOv+C8/8QMOhNogLNixQoAwLnnnpvz25w5cwAAr732Wt4yUqkU3nzzTUyaNAmNjY223xhjOOecc9DR0YE1a9aEWu9Aplx284IxBkmSEIlEfLZg4FJu2z388MN47bXX8Pjjj6OioqLIVgw8ymW3Z555BgBw6aWX4sCBA3j88cdx33334amnnsLBgwe706QBQ7lsd8IJJwAA/vKXv+SU9+c//xmMMcyePTtQWwYS5XpOoOeT7tMbdShJEgDQc0o/pjf6HVE60uk0Fi1ahHvvvRc///nPXffvp3+jDmw2b96M5uZmnHHGGaiqqrL9VlVVhTPOOANbtmzBzp07ze9XrFhh/ubEzf7kL32flStX4v7778cDDzyAP/zhD55nvgS1db7rP/3pT6Oqqop8oxfgfD6kuEEA+f/d0NdjBv1LaICzefNmAMCECRNyfhsxYgSqq6vNa7z45JNPoGmaaxnWsjdv3owzzzzT/Ht1dTVGjBiR93rCnXLZzYvnnnsOiUQCl156qR/xBzTltN3mzZtxxx134KabbnJ9SCG8KZfd1q5da353xRVXIJFImNdXV1fjsccew7x584I3aABRLtt9/vOfx4UXXojnn38e06ZNMw+rfvXVV7F161Y88sgjmD59erHN6veEYbew66XnE3+Uy3Ze/POf/8SGDRtw8sknY/DgwT1WL9Gz9Da/I0pLS0sLrrnmGtt3J598Mn77299i/PjxAOjfqAOdfDHB+H758uXYvHkzRo8ejY6ODuzZswcnnHACRFF0vd5abqE6yF/6Bnfeeaft8+DBg/HTn/4UV155pe37oLbOd70oijjmmGPwwQcfQFEUekGlTOzYsQN//etfUV9fj6lTpwKguEG4+4WVvh4zaCXQAOfw4cMAgNraWtffa2pqzGu6U4b1OuPvQa4n7JTLbm7s3LkTN910EyoqKnD33XfnvZYon+00TcNVV12F+vp6/OAHPwgs90CnXHbbt28fAOC2227DhRdeiE8++QStra146qmnIAgC5s+fj3fffTdYYwYY5bIdYwxLly7F7bffjnfeeQc/+clP8JOf/ATvvPMOLrroIpxzzjmB2zKQCMNuYddLzyf+KJftvGS56qqrIAgCfvSjH/VInUR56E1+R5SWa665Bn/729+wd+9edHR0YP369Zg/fz7eeustnH322Thy5AgA+jfqQCeo/Yv1F697yF96N5/61Kfw+OOPY8uWLUgmk9i6dSsefvhhMMZw9dVX409/+pPt+qC29uNPmqaZ8YroWWRZxvz585FOp3H//febCRyKGwMbL78A+k/MoCQQQRBFc/DgQZx//vnYt28fHnnkEUyaNKncIhEePPDAA/jHP/6BX//616isrCy3OIRPNE0DAEydOhWLFi3CuHHjMHjwYHzpS1/CD3/4Q8iyjJ/97GdllpJwo7OzExdddBEWLVqE3/72tzhw4AAOHDiA3/3ud/i///s/nHLKKdi2bVu5xSSIfksymcRFF12ETZs24e677zZX4xEE0be58847cdZZZ2H48OGorKzEiSeeiMWLF2P+/PnYvn07Hn300XKLSBBEL+eiiy7CNddcg2OOOQbxeBxjx47FjTfeiGeffRYA8O1vf7vMEhKlQtM0XH311Vi5ciWuu+46zJ8/v9wiEb2AQn7RX2IGJYEGOEaW0SvTnEgkPDORQcqwXmf8Pcj1hJ1y2c3KwYMHcfbZZ2PDhg345S9/iSuuuMKX7AOdctjuo48+wp133omvfe1rmDVrVlFyD3TKGSsB4N/+7d/AGLNd/4UvfAEAfJ3bNZApl+3uvfde/OlPf8IjjzyCefPm4aijjsJRRx2FefPmYeHChdi3bx+tystDGHYLu156PvFHuWxnJZVK4YILLsCrr76KO+64A9/61rdKWh9RfnqD3xHlZcGCBQCAVatWAaB/ow50gtq/O8/p9MzQfzj77LMxfvx4vPfee7ZtuIPa2o8/McYwaNCg0GQnCqNpGr785S/j6aefxhVXXIFf/epXtt8pbgxMCvlFPvpazKAk0AAn356TLS0taG9v99wP02DcuHEQBMFz30q3vQ0nTJiA9vZ2tLS0+LqesFMuuxkYCaB33nkHP//5z81/dBGFKYftPvjgA6TTafziF78AY8z2Z/v27Uin0+bntra2brSu/1KuPmesrnM7x8L4LplMFpR/IFMu2/3lL38BAMyePTvneuO79evX+2jBwCQMu4VdLz2f+KNctjNIJpP4whe+gJdffhm33XYb7r333pLVRfQeyu13RPkZOnQoAKCjowMA/Rt1oFPobA2nPauqqlBfX4+tW7dCVdWC1xeqg/yl72LEks7OTvO7oLbOd72qqti6dSuOOeYYOg+oB9E0Dddccw2efPJJXHbZZVi0aBEEwT4lTnFj4OHHLwrRl2IGJYEGOMaqgJdeeinnt+XLl9uu8aKiogKnnHIKPvzwQ2zfvt32G+ccL7/8MqqqqnDSSSeFWu9Aplx2A+wJoIcffhhf+9rXutOUAUc5bDd27Fh85Stfcf1TXV0NURTNz7FYLIxm9jvK1efOOussAHoiz4nx3dixY/03ZABSLttlMhkAwP79+3PKM76j/uZNuZ4T6Pmk+5RTh8lkEhdccAFefvll3Hrrrbj//vtLUg/R+6C+S7z55psAup6L6N+oA5sJEyagoaEBq1atMhODBh0dHVi1ahWOOeYYjB492vx+1qxZ5m9ODPvPnDnTdj1A/tKf6OjowIYNG1BVVWVO7ALBbZ3v+r///e/o6Ogg3+hBjIn+xYsXY968eViyZIntvBcDihsDC79+kY8+FzM4MaCRZZmPGzeOx2Ixvn79evP7trY2PnHiRB6NRvnWrVvN75ubm/nGjRt5W1ubrZzHH3+cA+CXXXYZ1zTN/P6Xv/wlB8Cvv/562/Uffvghj0QifOLEibay1q9fz2OxGJ88eTJXVTXcxvYjymW3gwcP8hNPPJED4D/96U9L0rb+Trls50VjYyOPxWLdatNAoFx2O3z4MB86dCiPx+P83XffNb9Pp9P8c5/7HAfAH3vssXAb288ol+0WLFjAAfArr7zSNp4pisK/9KUvcQD8f/7nf8JtbD8iLLs5icVivLGx0fP3Q4cO8draWj506FC+c+dO8/udO3fyoUOH8qFDh/JEIlFsswYE5bJdMpnk55xzDgfAb7755m62guhrBPU7om+yceNG3tHR4fr9iBEjOAD+2muvmd/Tv1H7N/fddx8HwJ944gnX37/73e9yAPz222+3fX/77bdzAPzee++1ff/KK69wAHzmzJk8nU6b37/44oscAD/33HNt19MzQ+8ln28kEgn+4Ycf5nzf2dnJL7vsMg6AX3PNNbbfirH1zJkzOQD+4osvmt+l02l+5plncgB81apV3Wwl4QdVVflVV13FAfBLL72Uy7Kc93qKGwODIH7Rn2IGJYEI/sorr3BJkvigQYP4ddddx2+++Wbe2NjIAfAHH3zQdq3RSZyDqaqqfM6cORwAP+200/jtt9/OL774Ys4Y48cccwzft29fTr333HMPB8AbGxv5zTffzK+77jo+aNAgHovF+N///vdSNrlfUA67zZo1iwPgxx13HL/zzjtd/7S2tpa45X2fcvU5NygJ5J9y2e3555/noijyyspKfuWVV/L//M//5FOmTPn/27v3qKjLPI7jn+EyiFzVSEQD3BVdYL1UXmMVOBm4WkdYDVtT0ROuGpiZSZopVHZWd93CqFObHEXxpLvFZrqsJt7Tws1qy0xtRcDVXNRSVhZRkWf/6DDbNCiXMHR6v86Z4+G5fH/PM79xZp75zjw/I8kMHz7c1NTUXM9pO4XWOHdlZWW2D6QiIyPN9OnTzfTp001ERISRZMLCwszXX399vad+U2uJ83b69GmTnJxsu7m4uBgvLy+7stOnT9v1ycvLM5JMQECASUtLM2lpaSYgIMBYLBbz5z//+XpP2ym0xrmrixMYGHjV9ygkAZxbUx53uDllZGQYHx8fM2LECPPwww+b2bNnm5EjRxp3d3cjycydO9euPWtU57Ns2TLba8Add9xhJJmoqChb2bJly2xtKysrTe/evW0fxM6ZM8fExcUZSaZfv36mqqrKIX5KSortvVt6eroZP368sVqtpn379vV+CMh7hhtHYx8bJSUlxmKxmP79+5vk5GTzxBNPmIkTJ5ouXboYSaZnz57mzJkzDvGbeq4/++wz4+fnZ6xWqxk/frxJT0+3reHS0tKu+/2Bb2RkZBhJxtvb28ybN6/e94ff/vIIzxs/Dk15XDjTcwZJIBhjjNm7d68ZNmyY8fX1NZ6enqZ///5m7dq1Du2utlA3xpjq6mqTmZlpfvrTnxqr1WoCAwNNSkqK+fe//33V465evdr07dvXeHp6Gj8/PzN8+HDz4YcftuTUnNoPfd7qFtLXuvEBS+O01v+57yIJ1DStdd52795thg0bZvz9/Y3VajWRkZFm8eLFDX6TCf/XGufuxIkTJi0tzXTr1s1YrVbj4eFhevToYWbPnk0CqJG+73krKSlp1uvWxo0bzeDBg42Xl5fx9vY20dHRprCw8DrN0jn90Oeu7osq17pt3779+k4ara6xjzvcnHbs2GGSkpJMWFiY8fX1NW5ubiYwMNCMHDnSvPPOO/X2YY3qXOpeM652S05Otmt/7tw58+ijj5rbbrvNuLu7m+DgYDNr1qyrftP+ypUrZunSpSYyMtJ4eHiYDh06mDFjxpgjR45cdUy8Z7gxNPaxUVFRYVJTU02/fv1MQECAcXNzMz4+PqZ///7md7/7Xb0f8tdp6rk+dOiQGT16tGnfvr3x8PAwPXv2NC+//LLdLxNxfTX0uKjvPSjPG86vKY8LZ3rOsBhjjAAAAAAAAAAAAOBUXFp7AAAAAAAAAAAAAGh5JIEAAAAAAAAAAACcEEkgAAAAAAAAAAAAJ0QSCAAAAAAAAAAAwAmRBAIAAAAAAAAAAHBCJIEAAAAAAAAAAACcEEkgAAAAAAAAAAAAJ0QSCAAAAAAAAAAAwAmRBAIAAAAAAAAAAHBCJIEAAAAAAAAAAACcEEkgAAAAAAAAAAAAJ0QSCAAAJ5SQkKDw8HBduXKlyX1zcnLk6uqq/fv3X4eRAQAAAD9eMTExslgsrT2MRjPG6M4771RcXFyz+j/11FPy8fFReXl5C48MANBYJIEAAK2qtLRUFotFw4YNa/HYmZmZslgs2rFjR4vHvpHt3LlTb7/9tjIyMuTq6trk/snJyQoJCdHs2bOvw+gAAAAA52CxWJp0uxmtWrVKH330kZ555plm9Z81a5ZcXFyUkZHRwiMDADSWW2sPAAAAtKz58+crJCRESUlJzerv7u6umTNn6pFHHtGePXsUFRXVwiMEAAAAbn71JTaysrJUUVFx1aTHqlWrVFVVdb2H1iJqa2uVmZmpwYMHa+DAgc2K0a5dO6WkpGjp0qWaO3euQkJCWniUAICGkAQCAMCJHDhwQO+++67mzZsnF5fm/+D3gQce0GOPPaZXX32VJBAAAABQj8zMTIey3NxcVVRU1FsnScHBwdd3UC1o48aNKi0t1bx5875XnHHjxun5559XTk6Onn322RYaHQCgsdgODgBw06ioqNDixYsVHR2toKAgWa1WBQUFacKECSouLrZrGxMTo6efflqSFBsba9uCITQ01K7dqVOnNHPmTHXr1k0eHh665ZZbNGrUKH322WcOxw8NDVVoaKgqKys1Y8YMBQUFycPDQ7169dKbb75Z75gvXbqkF154Qf369ZOPj4+8vb0VERGhxx57TGfPnlVtba1CQkLUoUMHXbx4sd4YQ4YMkZubm44fP97gfbRixQpJ0v3331/v/bdgwQJFRETI29tbvr6+6tatm5KTk1VWVmbXNiAgQDExMXrzzTdVWVnZ4HEBAAAANKy+awLl5ubKYrEoNzdXGzZs0IABA9S2bVt17txZ8+fPV21trSRp5cqV6t27tzw9PRUcHKzf//739R7DGKPly5crKipKvr6+atu2rfr27avly5c3aawrVqyQxWLRqFGjHOpOnjypGTNmKCwsTJ6envL391d4eLimTp2qiooKu7a33367unXrptzc3CYdHwDQMvglEADgpnHw4EEtWLBAsbGxSkxMlJeXlw4dOqTXX39dBQUF+uijj2zbC0ycOFHSN9fHSU5OtiV//P39bfGKi4sVExOj48ePKy4uTgkJCTp16pTy8/P1zjvvaOvWrRowYIDdGC5fvqy4uDidPXtWo0aNUlVVldauXaukpCRt2rTJ7oKpFy5c0D333KM9e/YoLCxMkyZNkoeHh/75z3/qj3/8oyZMmKA+ffooJSVFCxYsUH5+vsaOHWt3vMOHD+vdd9/ViBEj1KVLlwbvo61bt8rLy0s///nP7cqNMYqPj9fevXsVFRWlYcOGycXFRWVlZVq/fr3Gjx/vsDXDoEGDtGXLFr333nvNvhAsAAAAgMZ56623tHnzZiUkJCgqKkoFBQVauHChjDHy8/PTwoULNXLkSMXExCg/P1/p6enq2LGjJkyYYIthjNGDDz6oNWvWKCwsTGPHjpXValVhYaEeeughff7551qyZEmDYzHGaPv27erRo4fatWtnV1dVVaWoqCiVlpYqLi5OiYmJunTpkkpKSpSXl6fHH39cfn5+dn0GDRqkvLw8ffHFF+revXvL3GEAgMYxAAC0opKSEiPJxMfHN9j23Llz5quvvnIo37Ztm3FxcTEpKSl25RkZGUaS2b59e73x7rrrLuPq6mo2bdpkV3748GHj4+NjevbsaVceEhJiJJmRI0eaixcv2sq3bNlS7xxmzZplJJnx48ebmpoah7mcP3/eGGPMiRMnjJubm4mJiXEY4+OPP24kmXXr1tU7h287f/68cXFxMVFRUQ51n376qZFkEhISHOqqq6ttY/m2t99+20gyCxYsaPDYAAAAAP6/Zria6Ohoh/oVK1YYScbd3d38/e9/t5X/5z//Mbfeeqtp27atCQwMNMXFxba6Y8eOGavV6rBmee2114wkM2nSJHPp0iVb+cWLF819991nJJl9+/Y1OI8DBw4YSebBBx90qFu/fr2RZB599FGHuvPnz5vq6mqH8qVLlxpJZvny5Q0eGwDQstgODgBw0/Dz81P79u0dymNjYxUZGaktW7Y0OtbHH3+s9957T8nJyYqPj7er6969uyZPnqz9+/fXuy3cCy+8IKvVavv77rvvVkhIiD744ANbWU1NjV577TX5+flp6dKlcnV1dZiLt7e3JCkoKEj33Xefdu7cqSNHjtjaXL58WatWrVKnTp00YsSIBuf05Zdfqra2Vh07drxqG09PT4cyDw8P21i+rS5OY7ahAwAAAPD9jBs3Tv369bP97ePjo3vvvVdVVVWaNm2afvKTn9jqbrvtNv3iF7/Q559/rpqaGlv5Sy+9JC8vL7388styd3e3lVutVj333HOSpDVr1jQ4lro1QFPXFt7e3vLw8HAoZ20BAK2H7eAAADeVHTt2KCsrS3v37tWZM2fsFjzfTsw0pKioSJJUXl5e70VbDx06ZPv321ur+fv7q2vXrg7tu3Tpovfff9+u//nz5zV06FCH7RPqM2XKFL311lvKycnRokWLJEnr16/XqVOn9OSTT8rNreGX7K+++so2xu8KDw9Xr169tGbNGh0/flwJCQmKiYlRnz595OJS/3dC6hJuZ86cafDYAAAAAL6fPn36OJR16tTpmnVXrlxReXm5OnfurKqqKu3fv19BQUFavHixQ/vLly9L+v9a51qutbYYMmSIOnXqpEWLFumTTz7Rvffeq+joaIWHhztc76gOawsAaD0kgQAAN4033nhDY8aMkbe3t+Lj4xUaGqq2bdvaLqJaVlbW6Fhff/21JKmgoEAFBQVXbfff//7X7u/v7m1dx83NzXbBVkm2i6F27ty5UeOJi4tT165dtXLlSi1cuFBubm7KycmRxWLRQw891KgYdd/Eq66urnd827ZtU2ZmpvLz8zVr1ixJUkBAgNLS0jRv3jyHXytduHBBktS2bdtGHR8AAABA8/n6+jqU1X0Z7Fp1dcmds2fPyhijEydO6Omnn77qcb67xqnPtdYWfn5+Kioq0oIFC7Rhwwb97W9/k/TNr5PmzJmjhx9+2KEPawsAaD0kgQAAN43MzEy1adNGH374ocLCwuzq1q5d26RYdYuo7OxspaWltdgY69R9Y+7EiRONam+xWPSb3/xGc+fO1YYNG9S3b19t3rxZd999t922D9cSEBAg6f8Jru/q0KGDsrOz9eKLL+rQoUPatm2bsrOzlZGRIXd3d82dO9eufV2curgAAAAAblx1a5w777xT+/bt+16xGlpbBAcHKzc3V7W1tfr000+1efNmvfjii0pNTVW7du3061//2q49awsAaD1cEwgAcNMoLi5WeHi4QwLo5MmTOnr0qEP7ul+2XLlyxaFuwIABkmS3hVtL6tGjh3x9ffXBBx/o7NmzjeozadIkubu7KycnR8uXL1dtba0mT57c6GMGBQWpQ4cOOnz48DXbWSwWhYeHKzU1VYWFhZK+2Xruu+ri9OzZs9FjAAAAANA6fHx8FB4eroMHD+rcuXPfK1ZkZKRcXFwaXFu4uLioT58+Sk9Pt11riLUFANxYSAIBAG4aISEhOnLkiMrLy21l1dXVmjZtmm0LhG+r23f6X//6l0Nd//79NWDAAK1Zs0Z/+tOfHOpra2u1c+fOZo/Vzc1NU6ZMUUVFhWbMmOGQiKqoqFBlZaVdWceOHZWQkKBNmzbplVde0S233KKEhIRGH9NisWjw4MEqKSnR6dOn7epKS0tVWlrq0KfuvmzTpo1D3d69eyVJ0dHRjR4DAAAAgNbzyCOPqKqqSpMnT65327eSkpJ61wXf5e/vr169emnfvn12215L0oEDB+zWZHUaWlu4ubnprrvuauRMAAAthe3gAAA3hP3792vixIn11v3sZz/TnDlzNH36dE2fPl233367Ro8erZqaGhUWFsoYo969e+uTTz6x6xcbGyuLxaInn3xSBw4ckJ+fn/z9/W3bv61Zs0axsbF64IEHlJWVpTvuuEOenp46duyY3n//fZ0+fbrePbAb65lnnlFRUZHy8vJUVFSkX/7yl/Lw8NDRo0e1adMm7d692+ECr1OnTtUbb7yh8vJyzZo1S1artUnHTExM1Lp161RYWKixY8fayv/xj3/oV7/6lfr376+IiAgFBgbqxIkTWrdunVxcXDRz5ky7OMYYbd26VeHh4erevXuz7wMAAAAAP5wpU6aoqKhIK1eu1J49ezR06FAFBQWpvLxchw4d0t69e/X6668rNDS0wViJiYnKyMhQUVGRXfKmsLBQs2fPVlRUlLp3764OHTro6NGjWr9+vdq0aaPU1FS7OJWVlSoqKtI999wjLy+vlp4yAKABJIEAADeEL7/8UitXrqy3Ljo6WnPmzFFqaqrc3d2VnZ2tZcuWyd/fXyNGjNBvf/tb3X///Q79IiIitGLFCv3hD39Qdna2Ll68qJCQEFsSqGvXrvr444/1/PPPa926dVqxYoVcXV3VqVMnDRkyRKNHj/5ec2rTpo0KCwv10ksvafXq1Vq2bJlcXV0VHBysqVOn1rvwio2NVXBwsI4dO6aUlJQmHzMpKUkzZ87U6tWr7ZJAffv21RNPPKEdO3aooKBA586dU2BgoIYOHarZs2dr4MCBdnF27dqlY8eOKSsrq8ljAAAAANA6LBaLcnNzNXz4cC1btkx//etfVVlZqVtvvVVhYWFasmSJhg4d2qhYKSkpevbZZ7V69Wq7JFB8fLxKS0u1a9cu/eUvf1FlZaU6d+6sMWPGKD09XREREXZx8vPzdeHCBU2ZMqVF5woAaByLMca09iAAAMA3Tp48qeDgYA0aNEi7du1qVoz58+dr0aJFOnLkiEJCQpoVY9y4cdq4caOKi4vl7+/frBgAAAAAbm7jx49XQUGBysrK5OPj06wYgwcPVnl5uQ4ePGi7bisA4IfDNYEAALiBZGVlqaamRtOmTWt2jPT0dLVv317PPfdcs/p/8cUXWrt2rZ566ikSQAAAAMCP2MKFC3XhwgVlZ2c3q//WrVu1e/duLV68mAQQALQStoMDAKCVVVRU6JVXXlFZWZlycnIUERGhpKSkZsfz8fFRXl6e9u3bpytXrjR5sXX8+HFlZGQ47OUNAAAA4MclJCREK1euVHl5ebP6V1RUaMmSJUpMTGzhkQEAGovt4AAAaGWlpaXq2rWr2rRpo4EDB+rVV19Vjx49WntYAAAAAAAAuMmRBAIAAAAAAAAAAHBCXBMIAAAAAAAAAADACZEEAgAAAAAAAAAAcEIkgQAAAAAAAAAAAJwQSSAAAAAAAAAAAAAnRBIIAAAAAAAAAADACZEEAgAAAAAAAAAAcEIkgQAAAAAAAAAAAJwQSSAAAAAAAAAAAAAnRBIIAAAAAAAAAADACZEEAgAAAAAAAAAAcEIkgQAAAAAAAAAAAJwQSSAAAAAAAAAAAAAn9D8vPUJsXom2tAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1680x630 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1680x1120 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1680x1120 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABoEAAARQCAYAAAAiOPiKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAViAAAFYgBxNdAoAABAABJREFUeJzs3XdYFFfbBvB7l96RCAqiYEFsoFHEggLGWGKJvTfUqImJGkuwvIkdS4zRaBKDFbDHFpPYoyKKKFbEDiioiA0p0svO9wffriy7wNJcWe/fdXElzJw588wwu+6zz5wzIkEQBBAREREREREREREREZFGEas7ACIiIiIiIiIiIiIiIip/LAIRERERERERERERERFpIBaBiIiIiIiIiIiIiIiINBCLQERERERERERERERERBqIRSAiIiIiIiIiIiIiIiINxCIQERERERERERERERGRBmIRiIiIiIiIiIiIiIiISAOxCERERERERERERERERKSBWAQiIiIiIiIiIiIiIiLSQCwCERERERERERERERERaSAWgYiIiIiIiIiIiIiIiDQQi0BEREREREREREREREQaiEUgIiIiIiIiIiIiIiIiDcQiEBERERFRBYqOjoZIJIJIJFJ3KBrLy8sLIpEI8+fPV3coRERERERE7xUWgYiIiIiIiiEt4pT0x8/PT92hE1UqUVFRWLlyJXr27IlatWpBT08PxsbGcHZ2hre3N2JjY9UdIhERERFRpaKt7gCIiIiIiN53bm5uSpcHBwcDABwcHGBlZaWwvlq1atDR0YGjo2OFxvehs7a2hqOjI6pWraruUKgMcnNzUa9ePdnvlpaWcHJyQnx8PG7evInw8HCsX78e+/btQ8eOHdUYKRERERFR5SESBEFQdxBERERERJWRdIq3LVu2wMvLS73BEFVyOTk5sLCwwPjx4+Hl5YUmTZrI1t26dQvDhw/H9evXYW5ujnv37iktvBIRERERkTxOB0dERERERERqp6WlhYcPH+Knn36SKwABQOPGjXHgwAFoa2sjMTERu3btUlOURERERESVC4tAREREREQVKDo6WvaMoIK8vLwgEokwf/58JCcnY8aMGahTpw4MDAxQu3ZtfP/998jMzAQACIIAX19ftGjRAsbGxrCwsMCgQYMQExNT5P7379+PHj16oFq1atDV1UW1atXQu3dvBAUFlfqYIiMjMX78eNSrVw/6+vowNDRErVq10KFDB/j4+CA1NbVcYpk/fz5EIhG8vLyQmZmJJUuWwNnZGcbGxnLnM/95VCY9PR2rV6+Gm5sbqlSpAj09PdSuXRsTJkzAw4cPlW6TmZmJn3/+Ga1atYKZmRl0dHRgZWUFZ2dnfP3117h69WrJTpoanTp1Cn369IGNjQ10dHRgZmaGunXrok+fPti8ebNc24LX67Fjx/DZZ5/B0tISYrEYfn5+GDt2LEQiEcaPH1/kftu0aQORSISffvpJpThFIhE++uijQtfb29ujUaNGAIA7d+6o1CcRERER0YeORSAiIiIiIjVLSkpC69atsXr1apiamsLGxgYxMTHw8fHBgAEDIAgChg4dii+//BLJycmoU6cOUlJS8Oeff6Jdu3Z4/fq1Qp+ZmZno378/+vXrh0OHDkEQBDRp0gQ5OTk4ePAgPD09Vf5yPr9r166hefPm2LBhA2JjY1G3bl00atQI2dnZCAoKwvfff4+4uLhyjSUjIwOenp743//+h7S0NDRs2BCmpqYqxfvo0SO4uLhg6tSpuHDhAkxNTdGwYUO8ePEC69evR9OmTREYGCi3TW5uLrp06YLp06cjNDQUFhYW+Pjjj2FqaoqIiAj8/vvv2L9/f4nPnTps3LgRHTt2xF9//YX09HQ0btwY9vb2SEhIwF9//YW5c+cWuu3q1avRtWtXXLx4EbVr14adnR0AYOTIkQCAPXv2ICMjQ+m2ERERuHDhArS0tDBs2LByO5709HQAgJGRUbn1SURERESkyVgEIiIiIiJSs99++w1VqlRBdHQ0rl+/jqioKBw5cgTa2tr4559/MGDAAAQGBiI4OBgRERG4ceMG7ty5g1q1auHJkyf4+eefFfqcOnUq9u3bh8aNG+PcuXN48eIFrl69ivj4eGzbtg0GBgbw9vbGmTNnShTrggUL8ObNGwwfPhzPnz/HrVu3cPnyZcTFxeHZs2f49ddfFQo0ZY1l7969ePr0KS5duoTIyEhcunQJz549KzbWrKwsfP7557h9+zZ69eqFBw8eICYmBtevX8fr168xc+ZMvHnzBgMGDJArpP3zzz84c+YMatSogbCwMDx8+BChoaGIjIzEmzdvcPjwYbRr165E500dcnNzMWvWLADAmjVr8PLlS1y/fh1hYWF4/fo17ty5A29v70K39/b2xk8//YSXL18iNDQUDx8+xKBBg+Du7g57e3skJibi77//Vrrt1q1bAQCdOnWCtbV1uRzP5cuXERERAQDw8PAolz6JiIiIiDQdi0BERERERGqmpaWFXbt2wdbWVrasS5cu6NOnDwBg3759WLNmDdq2bStbX7duXdkX+IcOHZLr7969e/D19YWpqSkOHToENzc3ufXDhg3DokWLIAgCli9fXqJY7969CwCYMWOGQrHH0tISX3/9NaysrMo1ltzcXOzcuRMuLi6yZQYGBsXGGhAQgLCwMLi4uGDPnj2ykSwAoKenh2XLlqFnz5549eoVNm7cqHCMAwYMgLOzs1yf2tra+Oyzz9C1a9di969uL1++RHx8PMzNzTFp0iRoa2vLrW/QoAEmT55c6PZeXl6YPn06tLS0ZMsMDAwgEokwfPhwAHnnuCBBELBt2zYAb0cNlVVWVha++uorAECzZs3QvXv3cumXiIiIiEjTsQhERERERKRmXbt2Rc2aNRWWt2jRAgBQpUoVDBgwQGG9tCgSGRkpt3zv3r2QSCT47LPP5Aof+fXr1w8AEBgYiNzcXJVjlfa3a9cuSCSSYtuXRywNGzaUK4Cpavfu3QCAsWPHQkdHp8h9nzx5UrZMGueJEyfw8uXLEu/3fWFlZQUDAwMkJSXh8OHDJd7+iy++KHSdtLhz7NgxvHjxQm7duXPn8PDhQ5iamqJ3794l3q8yEydOxOXLl6Gvr4+AgACIxUxliYiIiIhUoV18EyIiIiIiqkj16tVTulw6oqZu3bpFrk9JSZFbHhYWBgAICQkpdNoyQRAA5D1jJT4+Xm70TlG+++47/Pfff1i2bBkCAgLQpUsXtGnTBu3bt0eDBg0U2pdHLI0bN1YptsL2/fvvv8tGphSUmJgIAHj8+LFsWe/eveHo6Ihbt26hZs2a6NChA9q3b4+2bduiTZs20NPTUzmGZ8+eoX///qWKvyjnzp0rto1YLMaMGTOwaNEidO/eHU5OTujYsSPatGkDd3d3VK9evcjtizrvDg4OaN26NS5cuIAdO3bg22+/la2Tjg4aMGCASiO2ijNr1ixs2rQJ2tra2LVrF5ycnMrcJxERERHRh4JFICIiIiIiNSvsIfcikUil9QUlJCQAAB49eoRHjx4Vu/+0tDQAwObNm7F582aF9d26dcOcOXMAAJ9++ilOnToFHx8fBAYGYsuWLdiyZQsAoFGjRli4cKFsdE1ZYsmvsOMvjnTf4eHhJdqvgYEBzp49i4ULF2LXrl04evQojh49CgAwNTXFuHHjsHDhQhgaGhbbb0ZGBoKDg0sVf3lYsGAB7OzssHbtWoSFhSE8PByrV6+GSCRCx44d8dNPP6Fp06ZKty3uvI8aNQoXLlxAQECArAiUkZGBPXv2yNZLFVUMK6qgNW/ePCxfvhxaWlrYsWMHevXqVWRMREREREQkj2PoiYiIiIg0jLGxMQBg7ty5EASh2B97e3sAeYWa4OBghZ/79+/L9e/h4YHjx48jMTERJ0+exIIFC+Ds7Izbt2+jf//+OHLkSJljKc/zcOrUqWL3Gx0dLbetpaUl1q5dixcvXuDmzZvw9fVF3759kZaWhpUrV2L06NEqxWBvb6/ScZf0R1UikQhjx47F9evX8eLFCxw4cADffvstqlevjv/++w+ffPIJYmNjVe4vv0GDBkFPTw/Xrl3DrVu3AAB///03kpKSULt2bbmRX9JimLKfwixevBgLFy6ElpYWtm7dqnRKRCIiIiIiKhqLQEREREREGkY6XdaNGzdKtN38+fOVFhz8/PyUtjc0NMQnn3yCuXPn4vr167KRHr///nuZYykP5bFvkUiExo0bY/z48di3bx/++usvAMCff/6J+Pj48gjznbG0tETv3r2xatUq3Lt3D7Vr18br16+xa9euUvVXpUoV9OjRAwDg7+8PANi6dSuAvGcG5R+pVlQxTJnly5fjhx9+gFgshp+fH4YMGVKqGImIiIiIPnQsAhERERERaZgBAwZAJBLh0KFDuH379jvZp0gkgpubGwDIjSxRRyxSAwcOBAD89ttvSqeZKw3pMQIo9Qia94GJiQmcnZ0BlO04Ro4cCQDYsWMHnj17Jps2T7q8NH7++WfMmjULYrEYW7ZswfDhw0vdFxERERHRh45FICIiIiIiDePk5IQvvvgC2dnZ6Ny5M/7991+FERdPnz7F77//jmXLlpWo7wEDBmD//v0KRZWoqCisX78eANCyZct3Ektxxo0bBycnJ0RERKBz585KRwTdunULP/zwA/755x/Zsp9//hk//vgjYmJi5NqmpaVh/vz5AAAzMzM4ODiUa7zl7fbt2xg7dizOnTsHiUQit+7EiRM4efIkAPm/V0l99tlnsLS0RGxsLMaPH4+cnBy0a9cOderUKVV/v/32G6ZPnw6xWIxNmzaVqZhERERERESAtroDICIiIiKi8vfrr78iLS0N27dvR8+ePVGlShXUrVsXQF7R5enTpwCAUaNGlajfEydOYO/evdDW1kbdunVhbm6O169fIzIyEoIgwMHBAQsXLnwnsRRHT08Phw4dQq9evRAcHIymTZuiZs2asLGxQWZmJqKjo5GYmAgA2LJli2y7R48e4ZdffsHMmTNhbW2NGjVqICsrC1FRUUhNTYW2tjZ8fX1hYGBQrvGWt6ysLGzevBmbN2+GoaEh6tWrBz09PcTGxsrOea9evTBo0KBS70NHRweDBw/G2rVrZYW00hZunj59ikmTJgHIe57Txo0bsXHjRqVtP/74Y6xdu7Z0QRMRERERfUBYBCIiIiIi0kC6urrYtm0bvLy8sHHjRoSEhCA8PBwAUL16dfTu3Rs9e/bE559/XqJ+AwICcPz4cZw/fx6xsbGIioqCoaEhXFxc0Lt3b0yaNAkmJibvJBZV1KxZExcuXMC2bduwe/duXLt2DVeuXIGenh5q1qyJvn37olevXujcubNsm6+++gqWlpY4ffo0IiMjcevWLUgkEtja2sLd3R3ffvutbCq191n9+vWxadMmnDx5ElevXsXjx4/x5s0bmJub49NPP8XIkSMxbNgwiMVlmyBi1KhRsoKMvr6+bBq+ksrKypKNEktOTkZwcHChbbW1mcoSEREREalCJBT2JE4iIiIiIiIiIiIiIiKqtPhMICIiIiIiIiIiIiIiIg3EIhAREREREREREREREZEGYhGIiIiIiIiIiIiIiIhIA7EIREREREREREREREREpIFYBCIiIiIiIiIiIiIiItJALAIRERERERERERERERFpIBaBiIiIiIiIiIiIiIiINBCLQERERERERERERERERBqIRSAiIiIiIiIiIiIiIiINxCIQERERERERERERERGRBmIRiIiIiIiIiIiIiIiISAOxCERERERERERERERERKSBWAQiIiIiIiIiIiIiIiLSQCwCERERERERERERERERaSAWgYiIiIiIiIiIiIiIiDQQi0BEREREREREREREREQaiEUgIiIiIiIiIiIiIiIiDcQiEBERERERERERERERkQZiEYiIiIiIiIiIiIiIiEgDsQhERERERERERERERESkgVgEIiIiIiIiIiIiIiIi0kAsAhEREREREREREREREWkgFoGIiIiIiIiIiIiIiIg0EItAREREREREREREREREGohFICKiD5iXlxdEIhHmz5+v7lCIiIiIiIiIiIionLEIRERUAp6enhCJRHI/WlpaMDc3h6urKxYsWICEhAR1h1kpnDx5EqNHj0a9evVgbGwMIyMj1K1bF6NGjcLx48fVHR5pkJSUFOzevRtjx46Fk5MTjI2Noaenh5o1a2LAgAE4efKkukMkIiIi0mjSPKq4m8+WLVsGkUiEZcuWKazLycmBn58fPv/8c9ja2kJfXx9VqlSBs7Mzpk2bhrt375ZLrAkJCVi6dCnat2+PatWqQVdXF1ZWVnBzc4OPjw9ev35dLvshAoDw8HAsXrwYnTt3hrW1NXR1dWFmZoaWLVti4cKF/H6BiMqFSBAEQd1BEBFVFp6enjhz5gxq1qyJWrVqAQCys7Px6NEjPHv2DABgY2ODM2fOoF69euoMVSVeXl7w9/fHvHnz3tlooKSkJAwbNgyHDh0CABgbG6NOnToQi8WIiorCmzdvAABdu3bFzp07YW5u/k7iIs01YsQIbNu2DQCgp6cHBwcHiMViREREID09HQAwadIk/PLLLxCJROoMlYiIiEgjSfOo4vKO1q1b4+LFi7hz5w4aNGggW37r1i3069cP9+7dAwBYWlrCzs4OaWlpuH//PnJycqClpQVvb2/4+PiU+jPd3r17MW7cOCQmJgIA7O3tYWlpiVevXuHhw4cAADMzM/j6+mLQoEGl2geRVFRUlNz3BjY2NrCxsUFcXBxiY2MBANbW1jh27BicnJzUFSYRaQCOBCIiKoUxY8bg3LlzOHfuHC5evIi4uDgcP34cVapUwdOnTzFhwgR1h/heSktLg4eHBw4dOoSqVavCz88Pr169QlhYGK5du4ZXr14hICAAlpaWOHr0KNzd3ZGamqrusEkDfPbZZ/j777+RmJiI8PBwhIWF4eXLl5gyZQoAYO3atdi4caOaoyQiIiL6cMXFxSE0NBSOjo5yBaDbt2/Dzc0N9+7dg7OzM06fPo3nz5/j0qVLuHXrFl68eIF58+ZBJBJh6dKlpc7Ftm3bhoEDByIxMRF9+/bF/fv38fDhQ4SGhuLBgweIjIxE//79kZSUhCFDhsDf37+8Dp0+UIIgwNLSEvPnz0dUVBRiY2Nx6dIlPHnyBOfOnYOdnR3i4uLQu3dvZGZmqjtcIqrEWAQiIionnTp1wuLFiwEAp0+fxosXL9Qc0ftn6tSpCAsLg7m5OYKCgjBq1Cjo6enJ1uvq6mLEiBE4c+YMzM3NER4ejqlTp6oxYtIEq1atwuHDh9GzZ0/o6+vLlhsZGWH16tX49NNPAQDr1q1TV4hEREREH7yDBw9CEAT07t1btiwnJwcDBw5EUlISXFxccO7cOdnUclJVqlTB/PnzsXXrVgDAhg0bsHv37hLtOyoqChMmTIAgCPjyyy+xb98+ODg4yLWpW7cu9uzZI2s3ceJEREZGlv6A6YNna2uLhw8fYt68eahTp47cOjc3N2zfvh0A8ODBAxw7dkwdIRKRhmARiIioHLVt2xZA3h090ukCCrp69SpGjRoFe3t76Ovrw9zcHO7u7vDz84NEIlFoLwgCjhw5gm+++QYff/wxLC0toaenhxo1aqB///44e/ZskTE9fPgQI0eORPXq1aGvr4/69evj+++/l02DVdCKFSsgEong5uZWZL8jR46ESCTC119/XWQ7qZiYGGzevBkAsHz5cjRs2LDQtg0bNpTNA75lyxZER0fLrZcmfn5+fkq3j46Olj2zqTCnT5/GgAEDUKNGDejq6uKjjz5Cly5dcPDgQaXt58+fD5FIBC8vr0L7tLe3h0gkQmBgoNL1kZGRmDhxIurXrw9DQ0OYmJigZcuWWL16daW7s+vZs2eYNm0aGjVqBENDQ+jr66NGjRpo27Ytvv/+ezx//lyuff6/WVxcHCZOnIjatWtDT08Pnp6eOHv2LEQiEczMzJCRkVHofn19fSESidCkSROVY61atWqR67t16wYAuHPnjsp9EhEREVH5+uuvvwBArgi0e/du3Lp1C2KxGFu3boWJiUmh2w8ePBiDBw8GAMybN09pblWYZcuWIS0tDbVr18aqVauKbLt69WrY29sjLS1N4dlFgYGBEIlEsLe3L3R7Ly+vIp+PlJiYiIULF6JFixYwMzODvr4+HB0dMWPGjEJvNJTmPgXzJik/Pz+IRCJ4enoqXZ+bm4stW7agY8eOqFq1KnR1dVGjRg0MGzYMYWFhhR7L+2rfvn3o2rUrrKysoKOjgypVqqB+/foYMmQIDhw4INe24N9s586d8PDwgIWFhSy369ixI0QiEZYsWVLoPiUSCWxtbSESibB3716V4tTX14eRkVGh693c3GBmZgaAuQoRlQ2LQERE5SgtLU32/8o+zK1YsQIuLi4ICAjA69ev0aBBA5iYmODs2bMYPXo0+vXrh9zcXLltUlNT0a1bN/z++++IjY2FjY0NGjZsiPT0dOzbtw8eHh74448/lMZz9epVfPzxx9i6dStev36NRo0aQSQSwcfHBx06dEBWVpbCNl5eXtDV1cX58+cL/aCZmJgo+2A7btw4lc7Nn3/+iZycHJibm2PUqFHFth81ahTMzc2Rk5ODP//8U6V9qEIQBEyePBmffPIJ9u7di/T0dDRp0gQ6Ojo4fvw4evfujUmTJpXb/qS2b9+OJk2aYN26dXjy5Anq1q0LKysrXL16FVOnTkWHDh1kz0N63z158gTNmzfHqlWrEBERATs7Ozg7O0MsFiM0NBQ+Pj4IDw9Xum1kZCScnZ2xfv16mJiYoFGjRtDV1UW7du1Qu3ZtJCcny74AUCYgIABAXhGyvEgLokUlYERERERUcZKTk3H69GlYW1ujVatWsuU7duwAAHTp0kVuirjCfPvttwCAe/fu4cqVKyrtOzc3VzZy6Msvv5QbOa6Mvr4+vvzySwB5OU7B/K0swsLC0KRJE8ybNw83btyApaUlHBwcEB0djZUrV6JZs2a4efNmue0PABISEtChQweMGTMGp06dgp6eHpo0aYI3b95gx44daNmyJXbt2lWu+6xIP/zwA/r37y8bOePs7AwbGxs8f/4cu3btwsqVKwvddurUqRg6dCju3buHevXqwcbGBsDb3EM62kyZkydPIjY2FlWqVEHPnj3L5VhycnKQnZ0NgLkKEZUNi0BEROVIeleRqakp6tatK7du9+7d8Pb2hpmZGfz9/ZGYmIjr16/j8ePHCA0NRb169fDXX38p3F2kq6sLX19fPHnyBC9evEBYWBiuX7+Oly9fYvfu3TAwMMDkyZPx+PFjue0yMzMxaNAgJCUlwcPDA48ePcLVq1dx7949nD9/Hg8ePFB6h5KlpSX69u0LAIU+I2X79u1IT0+Hi4sLmjVrptK5OXfuHACgXbt2clPAFUZfX182sio4OFilfahixYoVWLt2LWxtbfHPP//g9evXuHr1Kp49e4ajR4/CysoKv/76a5Ef8EsqODgYXl5eEAQBq1evlj2XJioqCnfu3EHLli0REhIiS1rfdz/99BPi4uLQsWNHPH36FHfu3EFoaCgeP36M169fY8uWLbC1tVW67bJly9CsWTM8fvwYN27cwLVr13Dw4EGIRCKMGDECwNtCT0FRUVE4f/48xGIxhg8fXi7HIpFIZEm/h4dHufRJRERERCVz+PBhZGVl4fPPP5cbzS/NITp27KhSPy1btpSNFlI1h7hx44bsZixV9/PJJ58AAN68eYMbN26otE1xXr9+jR49eiA2Nhbjxo3D06dPERkZifDwcLx48QIjR45EXFwc+vfvj5ycnHLZJwAMGzYMZ8+eRbt27RAeHo7Y2FhcvXoViYmJWLVqFXJzczF69Gjcv3+/3PZZUV69eoWlS5dCW1sbf/75J54/f44rV67g1q1bSEpKwuXLlzF69Gil2z558gTr1q3Dtm3bZM+nevLkCdq0aYN+/frByMgId+/eRWhoqNLtpfnjoEGDVMp3VfHXX3/JbjRlrkJEZcEiEBFRGeXk5CAqKgrff/+9bOqA7777DgYGBnJtZs6cCQDYvHkzRo4cCbH47Vuw9O4qkUiEn3/+WW6Ejq6uLsaPHy+7C0lKS0sLAwcOxNSpU5GdnS27S07qzz//RGRkJPT19bF7925Ur15dtq5NmzZYvXq17K6igqQPU926davS0UKbNm0CoPooIACyIlW9evVU3kY6D/eTJ09U3qYoCQkJWLRoEbS0tHDgwAH06NFDbn2XLl1kz4VZunRpuewTAGbOnImcnBwsW7YMU6ZMga6urmxd/fr1sW/fPhgZGcHf3x9Pnz4tt/1WlLt37wIAJk2aBEtLS7l1pqam8PLyKvROTQsLC+zduxfW1tayZdLXivQOu+PHjytMJwe8Taw+/fRThddDaa1evRo3btyAWCzG7Nmzy6VPIiIiIioZZVPBJScnIzk5GYDqOYRYLJY9W0XVHCL/zXSq7if/84LKK1f5+eef8eTJE/Tq1Qvr16+X+5xtZmaGzZs34+OPP8a9e/ewf//+ctnnf//9hyNHjqBWrVr4559/5KZcFovF+Pbbb/H1118jIyMDq1evLpd9VqTIyEjk5uaiSZMmGDBggML04C1atMDYsWOVbpubm4u5c+di2LBhsu1EIhH09PRgbGyMPn36AFB+w1pqaqrsb1JeMxYkJiZi+vTpAICePXvCycmpXPolog8Ti0BERKWwYMEC2bzLOjo6qFevHnx8fFClShX8+OOP+P777+XaX7x4ETExMahevbrsw2NBLVq0gJ2dHRITE5VOXRAaGorZs2ejd+/e8PT0RLt27dCuXTvZVGnXrl2Ta3/48GEAwMCBA1GtWjWF/gYNGiRXGMrP09MTjo6OePnypcIzcq5cuYJr167ByMgIQ4YMKeQMKZLeXWdsbKzyNtK20uSvrA4fPoyUlBS4uLjAxcVFaZuePXtCR0cHd+7cQVxcXJn3GRsbi+DgYGhra+OLL75Q2qZmzZpo2bIlcnNzcebMmTLvs6LZ2dkBAPbu3au0SFiU/v37y+a1Lqhu3bpo27YtcnNzZQ9BzW/btm0AoNJ0gqo4ffq0rDg7e/bsQq8JIiIiIqo4WVlZOHLkCExNTWUjbADITZVcmhwiKSlJpfal2U/+duWVq+Sfkk4ZLS0t9OrVC0De1GPluc8hQ4bA3NxcaZt+/fqV6z4rkjRPuX//Pi5fvlzi7QvL14C3xZ1du3Yp3Ey5f/9+pKamon79+mjTpk2J91tQTk4OBg8ejEePHsHS0rLQ6d+JiFSlre4AiIgqo5o1a6JWrVoA8j70R0ZGIj09Hebm5ujQoYNCe+nDNNPT09GuXbtC+42PjweQdzea9MNjTk4OxowZU+z0ZNJtpaSjNRo3bqy0vZaWFho0aIBnz54pXT9+/HhMnz4dmzZtwoABA2TLN2zYACCviFTUg1kLkrZNSUlReRtp2/Ka/1j6d3j48GGRfwfpnV+PHz+WG7FSln1qaWnhs88+K7SddHqFgtP6FWbSpEkKhb+y+t///ldkjFJTpkxBQEAAtm3bhiNHjqBz585o27Yt2rVrh6ZNmyrccZdfYdej1MiRI3H+/HkEBARg2rRpsuXBwcGIioqCiYlJoYXUkggNDUWvXr1kCdbChQvL3CcRERERldypU6eQnJyMQYMGyY2Yz59rlCaHKOzGo4IK7keV7fLHUx65SmpqKiIjIwHkPdNm8eLFSttJR8urmjMUR5qr7N+/Xzb1XkEZGRkl2ue1a9fK/Rmr1tbW2LNnj0rtRowYga1bt8LV1RWurq7w9PREmzZt4O7ujipVqhS6bdWqVWFlZVXo+o4dO6JGjRqIjY3FoUOH5EatSUcHSae3LguJRIJRo0bh2LFjMDExwT///FNusyAQ0YeLRSAiolIYM2YM5s+fL/tdOlR78+bN6Ny5M65fvy4rEgF505ABeXejqTI3tXTeXyDv+Stbt26Fvr4+li5dii5duqBWrVowNDSESCTC5s2bMXbsWIW7kaR3tCkbBSRV1LpRo0Zhzpw5OHHiBB49eoRatWohLS0NO3fuBFCyqeAAwNbWFteuXZMlN6qIiIgAANSuXbtE+yqM9O/w4sULvHjxotj2+f8OZd1nZmZmif/2RQkPDy/XZyUBUDoFmzKNGjXChQsXsGDBAhw9ehQ7d+6UXRd2dnaYPXu2bErBgopLkgcNGoQpU6YgLCwM4eHhsmkPpEXQAQMGyE21WFgxrKiC1tWrV9GlSxe8efMGffv2xdatW+WmZyQiIiKid0fZVHBA3jTDpqamspvuVCGRSPDgwQMAKPQZlQXlbxcZGYkWLVoUu400TwHKJ1dJTEyU/b8qI1jKI08B3uYqERERcsekTHp6ukp9qprzloR0hI8qNm3aBCcnJ2zYsAEXL17ExYsXAQDa2tr4/PPPsXLlStjb2ytsV1yeIn0u6fLlyxEQECC7XmNjY3Hq1Cm5Z5wChRfDiipoCYKAsWPHYseOHTAyMsKhQ4fQqlUrFY+ciKhw/MaDiKgcmJubY8OGDWjbti0SEhIwceJEufXS6QLc3d0hCEKxP15eXrJt/fz8AOQVg7799ls0bNgQRkZGstEWBUcASUnvaCvqi/2i1n300Ufo378/JBIJNm/eDCDvOUPJyclo0qQJWrduXfRJKUA68iY4OBiZmZnFts/IyMD58+cBAG3btpVbJz12QRCUbpuamqp0ufTvMHLkSJX+Dp6enirvs7D9SvdZq1YtlfaZv7hYlMDAQJX6K8lP/uuuOE2bNsX+/fuRmJiI4OBgLF++HG5uboiJicGXX34pe7ZSSZmbm+Pzzz8HAPj7+wPIK6BJpz0sOMe2tBhW8KewazssLAydOnVCYmIievXqhV27dkFbm/fEEBEREamDIAj4+++/oauri27duimsd3NzA6D6VGSXLl2S3Qwn3bY4TZs2leVOqu7n1KlTAPI+uzZq1Ei2vKw5AwA8ePCg2M/tgYGBSvsubX60efNmlfIFVXh6epZ7nhIdHa3SvgFAR0cH3333He7fv4/Hjx9j165dmDBhAkxMTLB//358+umnJRpZlp80Fzl06BBev34NANi+fTskEgk8PDzkilXSYljBn0uXLintWxAEjB8/Hn5+fjA0NMS///6L9u3blypOIqKCWAQiIionYrFY9rDMQ4cOyX0wl45muHXrFiQSSYn6ffjwIYC8ApIyFy5cULq8QYMGAIDbt28rXZ+bm4t79+4VuW/paI4tW7ZAIpFg48aNAIqeK7kwAwcOhLa2NhISEpQ+TLOggIAAJCYmQltbG4MGDZJbJ71Lq7Av+qVTqxUk/TvcuHGjJKGrtM+EhAS8evWq0H0+efJElihoEl1dXbRt2xbe3t44d+4cZsyYAQD4/fffS92nNLnasWMHcnNz8e+//yIhIQH29vYKr4PCimHKClo3b97Ep59+itevX6NHjx74888/oaOjU+o4iYiIiKhsLl68iLi4OHTo0AGmpqYK64cOHQoAOHbsmGy666L88ssvAID69eurNKIHyJu2eeDAgQAAX1/fYm9Yy8jIgK+vL4C8HCf/50lpzlDUrAPKchUzMzPUrFkTQMXkKhWRH1UGtra2GDRoEP744w+Eh4fD1NQUUVFROHbsWKn6a9SoEVq0aIGsrCzs2rULwNsZCwo+t7SwYlhhBa2vv/4aGzduhIGBAf7++2+5GxKJiMqKRSAionLUsmVL9OjRAwAwb9482fJ27drBxsYG8fHx2LRpU4n6NDQ0BADExcUprLt79y7++ecfpdtJp8LavXu30iTkzz//VNpnfu3bt0fDhg3x6NEjrFmzBsHBwdDT0yvVXMf29vYYPXo0AMDb2xt37twptO2dO3cwc+ZMAHmFqPxT6wGAg4MDACAkJETp9oWNQunRowcMDAxw/fp1nDhxokTxS/d57do1pYlhYUWPOnXqoEWLFpBIJFi5cmWJ9lkZSe+4jI2NLXUfXbt2hZWVFeLi4vDff//JzbFd1POGinLnzh107NgRr169Qrdu3bBv3z65OeeJiIiI6N0rbCo4qcGDB6Nhw4aQSCQYMWKEbJSPMrt27ZJNUTx//vwSTfc7a9YsGBgY4MGDB/j222+LbDt16lQ8fPgQRkZGmD17tty6evXqQSQSISMjQ+mUxcHBwYUWXKSFqJ9//hm5ubkqxw4UnR8lJibKzkth+wwICFB5aujKqkaNGrKp+8qSq0hvWNu6dSuuXbuGmzdvwtDQEP379y91n5MnT8a6deugr6+PgwcPomPHjqXui4hIKYGIiFTm4eEhABDmzZtXaJtLly4JAAQAwsmTJ2XLt2/fLgAQ9PT0hFWrVglpaWly271580bYu3evMHbsWLnlvXr1EgAILVq0EJ4+fSpbfv36daFevXqCvr6+AEDw8PCQ2y49PV2oU6eOAEDo0KGD8Pz5c9m6kJAQwcrKStDR0Sn2eFavXi0AELS1tQUAwtChQ4s4Q0VLSUkRnJycBABC1apVBT8/PyEjI0O2PjMzU9i6datgaWkpABBatWolpKamKvRz6tQpAYAgEomEnTt3yh3z7NmzZcel7J85Hx8fAYBgZmYm+Pv7C9nZ2XLr4+PjBX9/f2HGjBlyy5OTkwUjIyMBgDBp0iQhJydHtm7Xrl2CoaGhbL+nT5+W2zYwMFDQ1tYWRCKR8L///U9ISEiQW5+eni4cPnxY6NevX7Hn8H0wbtw4ISAgQOE44uLiBHd3dwGA0LlzZ7l10tfOli1bVNrHlClTBABCly5dZOc1IiKiVPFGREQI1tbWAgDhs88+k7vmiIiIiKjiFZZHOTo6CiKRSC7PKSg8PFwwNTUVAAjOzs5CYGCgIJFIZOtfv34tzJs3T5avjB49ulQx+vn5CSKRSAAg9O3bV7h//77c+sjISGHAgAECAEEsFgu7d+9W2o/083D79u2FV69eyZZfvXpVqFOnTqE52IsXLwQbGxsBgNCrVy8hKipKbr1EIhFCQ0OFKVOmCKGhoXLr5s6dKwAQrK2thevXr8uWx8XFCZ999plsnwVzRkEQhM6dOwsAhIYNGwpnz55VWB8VFSUsX75c2LBhg9LjfZ+cOHFCmDJlinDlyhW5ayQ3N1fYtm2boKWlJQAQzp8/L1t3+vRpAYBgZ2en0j5evHghO589evQQAAjDhw8vdczfffedAEDQ19cXjh07Vup+iIiKwiIQEVEJqFIEEgRB6N69u+yDf36rV6+WJSf6+vpC06ZNhVatWgl169YVxGKx0g+fN27ckBUf9PT0BGdnZ8HR0VEAINSsWVNYsmRJoR/oQ0NDZQmTrq6u0Lx5c9m2rVq1EoYMGVLs8bx+/VpWaFJW4CiphIQEoWvXrrL+jI2NhaZNmwrNmjUTTExMZMtHjBghJCcnF9pP3759ZW1r1KghuLi4CCYmJoK+vr6wfv36QotAEolE9kFbuv/mzZsLrq6ugp2dnSzxU3Y+16xZI9vO3NxccHFxEapXry4AEBYuXCjY2dkVeo52794t+ztqa2sLjRs3Flq3bi04OjoWWbR6HzVt2lRWhKtbt67QqlUroUGDBrJr28rKSrh9+7bcNiUtAl25ckV2TgAIbdu2LXW80sQWgODi4iK4ubkV+hMXF1fq/RARERGRcsryqDt37sjykuLcuHFDcHBwkH2ms7S0FFxcXIRGjRrJPoNqaWkJ3333nZCbm1vqOHft2iWYmZnJ9mNvby+4urrKbq4DINjY2AiHDx8utI+LFy/K8idpzieNvUuXLsKwYcMKzcFu3Lgh1K5dW7avOnXqCK1atRKcnJxkuYSyfCMxMVEWo1gsFhwdHYWmTZsK2traQq1atYTFixcXmuMkJCQIn376qaxvKysroWXLlkLz5s1lN+epkgO/Dw4cOCCL19TUVGjWrJnQokULueOYNGmS3DYlLQIJgiD07NlTLlc5fvx4qeI9f/683HkvKk/x8fEp1T6IiASBRSAiohJRtQiUfzTQf//9J7fuzp07wtdffy00bNhQMDIyErS1tYVq1aoJnp6ewvLlyxXuOBOEvGSgV69egrm5uaCnpyfUqVNHmDx5svDq1Sthy5YthX6gF4S8O7eGDRsmWFpaCnp6ekK9evWEOXPmCGlpacKoUaNUOp7hw4cLAAQHB4ci25XE8ePHhZEjRwp16tQRDA0N5T5ET5w4sdjtMzMzhUWLFgn169cXdHV1hapVqwp9+/YVwsLChIcPHxZbVAkNDRVGjx4t1K1bV9DX1xd0dHQEGxsboWvXrsLatWuFx48fK91u165dgqurq2BgYCCYmJgI7du3F/bv3y8IglBkEUgQBOHx48eCt7e30LRpU8HExETQ0tISPvroI6Ft27bCvHnzhGvXrhV73O+D06dPC9OnTxdcXV0Fa2trQUdHRzAyMhKcnZ2FWbNmCS9evFDYpqRFIEEQhCZNmsj+jn/88Uep45XuW5Wfhw8flno/RERERKScsjxq6dKlAgBh6dKlKvWRlZUlbNq0SejevbtgY2Mj6OrqCqampkKTJk2EKVOmKNyEVFrx8fGCj4+P0LZtW6Fq1aqym/UACEZGRip9Xrx8+bLQvXt3wdzcXNDX1xcaN24s/Pjjj0J2dnaxOVhKSoqwatUqwd3dXbCwsBC0tLQEExMTwdnZWfj666+FEydOKMxmIAh5o37GjRsn+3xeq1Yt4ZtvvlEpZ8zNzRX27Nkj9OrVS7a9gYGBULduXWHIkCHCzp07haSkpBKcRfV49eqV8Ntvvwl9+/YVHBwcBFNTU0FbW1uwtrYWevbsKfz9998K25SmCLR37165GxJLW3iU7luVn1GjRpVqH0REgiAIIkEQBBARERWhc+fOOHHiBJYtWyZ7Vk9FmDt3LhYtWgQAWL9+PcaNG1dh+yIiIiIiIvVp3bo1Ll68iDt37qBBgwbqDqdIDx8+RIcOHRATEwMnJycEBgbCwsJC3WERERGphEUgIiIqUlRUFBwcHKCjo4NHjx6hWrVqFbq/+fPnY8GCBRCLxdi6dSuGDh1aofsjIiIiIqJ3Ky4uDjVq1ED9+vVx9+5ddYejkujoaHTo0AHR0dFo2bIlTp48CRMTE3WHRUREVCxtdQdARETvr9zcXMycOROCIGDw4MEVXgAC8opAderUwYMHD/Dw4UOkpqbCyMiowvdLRERERETvhrW1NSQSibrDKBF7e3ucOXMGW7ZsgSAIOH/+PLp06aLusIiIiIrFkUBERKTAz88PW7ZsQVRUFGJjY2FsbIzw8HDY29urOzQiIiIiIiIiIiJSkVjdARAR0fsnOjoaQUFBSEpKgru7O06cOMECEBERERERERERUSXDkUBEREREREREREREREQaiCOBiIiIiIiIiIiIiIiINBCLQERERERERERERERERBqIRSAiIiIiIiIiIiIiIiINxCIQERERERERERERERGRBtJWdwBUdg0aNEBCQgLq1Kmj7lCIiIiIiIr14MEDVKlSBXfv3lV3KFRJMOchIiIiosrmfcl7WATSAAkJCUhLS1PLvpOTkwEApqamatk/vT94LRDA64Dy8DogKV4LBCi/DtT12ZUqL3XmPADfzygPrwMCeB3QW7wWCOB1QG+9z3kPi0AaQHo3XEhIyDvfd1BQEADA3d39ne+b3i+8FgjgdUB5eB2QFK8FApRfB23atFFXOFRJqTPnAfh+Rnl4HRDA64De4rVAAK8Deut9znv4TCAiIiIiIiIiIiIiIiINxCIQERERERERERERERGRBmIRiIiIiIiIiIiIiIiISAOxCERERERERERERERERKSBWAQiIiIiIiIiIiIiIiLSQNrqDoCIiIhIXSQSCeLj45GUlISMjAwIgqDukDSKgYEBACA8PFzNkVB5E4lE0NfXh5mZGT766COIxby3jIiIiOh9lZGRgRcvXiA5OZk5TzljzqO5NCnnYRGIiIiIPkgSiQTR0dFISUmRLROJRGqMSPPo6empOwSqIBKJBGlpaUhLS8ObN29gb29fqZMiIiIiIk0lkUjw8OFDZGdnA2DOU96Y82guTcp5WAQiIiKiD1J8fDxSUlKgo6MDW1tbGBsbMyEqZ5mZmQCYGGkiQRCQkpKCJ0+eICUlBfHx8bC0tFR3WERERERUwIsXL5CdnQ1DQ0PY29tDW5tfB5cn5jyaS5NynspZuiIiIiIqo6SkJACAra0tTExMWAAiKgGRSAQTExPY2toCePt6IiIiIqL3S3JyMgDAxsaGBSCiEtCknIdFICIiIvogZWRkAACMjY3VHAlR5SV9/UhfT0RERET0fpFOA6evr6/mSIgqJ03IeVgEIiIiog+SIAgQiUQcAURUBtLXEB8wTERERPR+kkgkEIlElfZZJkTqpgk5D1/9JbR8+XLZH/7ChQsqbyeRSLB27Vo4OTnBwMAAlpaWGDJkCB48eFCB0RIRERERERERERER0YeKRaASuHnzJubNmwcjI6MSbzthwgRMnjwZgiBg8uTJ6Nq1K/bv34+WLVsiIiKiAqIlIiIiIiIiIiIiIqIPGZ8GpqLs7GyMGjUKzZo1g4ODA7Zt26bytqdPn8bGjRvh7u6OEydOQFdXFwAwdOhQdOvWDd988w2OHTtWUaETEREREREREREREdEHiCOBVOTj44Nbt25h8+bN0NLSKtG2GzZsAAAsWrRIVgACgM8++wyenp44fvw4Hj16VK7xEhERERERERERERHRh40jgVRw9epV+Pj4YOHChWjUqFGJtw8MDISRkRHc3NwU1nXp0gWBgYE4c+YMRowYUeoYBQHIyshRub2Onpbcg7AFQUB2Zq7K22tpi6GlLV9DzM2WIDdXonIfuvrylx9j+P8YJAKys8oWQ052LiS5qj+srMwx6CjWk9URg5ZW+Z4HiURATlljyMqFRKJaDCKRCDp68kXmyhZDbrYAsZI6uTSGzece4ujNZxje2g6fN7OpkBgA5echOysXQlnOQ64EOdmqv7a1dcQQqxDDs+QMzP/7FrREIszv2RiWpnp5MYhF0NF9NzEUprQx5Gbn9Z+VkaM8hsxclR+oqCyG3FwJcktyHnS1IBaL5JZJY1D14Y75/80EUKoHQpa1j8ocQ/52H9p52LBhA3777Tfcv38fxsbG6NSpE5YsWQJ7e3uV+4iPj8f333+Pv//+G/Hx8bC3t8eYMWMwffp0aGtry7ZPSEjAtm3bcPToUdy6dQvPnz+HtbU1WrRogTlz5uDjjz9WOA57e3vExMQo3e/ff/+NHj16qHwecnMkyM1RfG3mf0+QHa9EgKjA65KIiIiIiCqnDRs24Ndff5XLe5YuXQo7OzuV+5DmPQcPHiw078nvxo0b+N///odz584hKysLTk5O8Pb2Rt++fZX2v3//fvz4448IDw+Hrq4u2rVrBx8fHzg7O5f6uCsLFoGKkZmZiZEjR6JZs2bw9vYu8fapqamIi4tDkyZNlI4gcnBwAACVngvUpk0bpctv3rwJG8ta2DI7SOW4GvTSkku8BYmAuwdV/4K1agMxLBuKkZycDAAICgrCi1sSxN9X/Uu5hn0KfOGeK+De36rHYNlIjKqO8l8sPg+X4HWkajGIxECDXvIx5GYLuP+v6jFYNRbjo/ryMTwLy0XCA9W+TBJrA4495WPIyRQQcVj1GKo5iWFRr0AM13OR8FC1GLR0gfrd5WPIThcQeVT1GKo3FUOragqAvGsBAOKu5iIxRrUYtPUBh88KxJAmIPKY6jFYfyyGub38eXh6ORdJj1WLQccAqNdVPoasFAFRJ1SPwaaFGGa15GOIDc1FcqxqMegaAXU7y8eQmSzgwUnVY6jRUgxTW/kYnlzIxZs41WLQMwHqfCofQ0aigIenVYtBkEjwkXMWgsTy70ePQ3KRHCcgOUtAGwBR9yOwZXek8hhMRajTUf79Mv21gOgzqp8H29ZimFjLn4dHwblIfaHaedA3F6F2B/kY0l4JiDmregw124phXE0+hpizuUh7JR9DapYAx/9f9Oe1CzDUyXtvNrAQwd5DPobUlwIenVM9hlrttGBkKf8la/SZXKS/Vu08GFYVwa69fAwpzyV4fL7o91lBkrf+/r9BsGuvBcOq8jE8PJ2LjETVYjCyEqGWm3wMb+IkeHJB9X9v7D20YGAhH8ODk7mo/4kxjMz1kJacVeT2InHee2V+Qi6Qm61yCNDSAwp8X47czLybOFQh0gK0dMoWg7YeADXFkJORVS4xiLUAcQWch5xMABUQw8LF8/HjT8vQpnUbLF+6Aq9evcJv635F4OlAnD13Fra2tsXG8ObNG3To5I6IiPsYN3YCmjRpgvMh5zBr1iyEhYVhy5YtAABJLhB0OhhTp06Fh7snxnh9Acuqloh6EIVNmzdg//792LzRHwP6Dcw7D/r/H7sgwNHRETNnzoSkwDE0qNe40NdH/vMgCAIyMzPxt1/e58GC8r8nSL14lIxq9mZK+yYiIiIiosrjhx9+wOLFi+Hm5obVq1fj5cuXWL16NQIDAxEaGiqX9xTmzZs3cHd3x7179zBx4kQ4OzsjKCgIs2bNws2bN7F161a59mFhYWjXrh309PQwffp0VK1aFdu2bUO/fv2wceNGjB07Vq79pk2b8MUXX6BJkyZYvnw5MjIysHbtWri5ueHcuXNo2rRpuZ6T9w2LQMWYO3cuIiIicOXKlRJPAwcASUlJAAAzM+VJrqmpqVw7IiJNpeLgkw9Odr7zkiUBDNUXChGVo4jICKxctQLNmn6MI/+ekN251unTzvD4pB3mzp2LzZs3F9vP6jU/4+7dO1i6eDkmfTMFADBm9BiYmZth3bp1GDlyJDp06AAAqO9QH9cuh6NunbpyfQwaOATtPFpj5uzv0K9Pf4jF8gVqKysrDB06FDkZ5XHkRERERET0obh//z6WLl2K5s2bIzAwUJb3dO3aFa6urpgzZw4CAgKK7WfFihW4ffs2Vq5ciWnTpgEAvvjiC5iZmeHXX3/F6NGj8cknn8jaT5o0CampqTh9+jRcXFwAAGPHjkWrVq0wbdo09OvXD+bm5gCAhIQETJs2Dba2tggODpZ9Hz9w4EA0atQIkyZNkt3UrqlYBCpCSEgIfvrpJ8yfPx9NmjRRdzgICQlRurxNmzZITcqUe95Qcdq7u8lNjSORCHhwJFjl7evUqYWP3WvJXiDu7u64khaNN9FPVNpeJBLB3V1+eryc7Fw8PKr8GJWpW9cOTd1ryi279OYhUh7FqrS9lrYY7u5t5ZZlZeQg+vgFlWOoV88eTu7y1eyLiQ+Q+uSpStvr6GnB3V1+hFdGajZi/ruocgz169dBo3by02qFxEciNfaZStvrGerA3b2V3LK05Cw8OhWqcgyOjnXxIjtvNJu7uzsA4NyLCKTFPVdpe0NjXbi7u8otS0nIwKPTl1WOoUGDeqjvWl1uWVDcfaQ/f6HS9sYmenB3bym3LPlVOh6fuaJyDA0b1ke9FlZyywIf30XGy1cqbW9qqg93dxe5ZQnPUvHk7DWVY2jUyBF1mlnKLTsVfQeZ8fEqbW9mZgh39+Zyy+KfpiA2+LpK22dlZcHA0FB2HUj99+A2Ul++gij77W3mhb1nValiBHd3+SmLXj56g6chYSrFAADOTo1Qs5GF3LLj928iNjFRpe0tLEzg7i5/F8jzh8mIu3hD5RiaOjdGDccqcsuO3glHXLJ80V+UmSn3u/S8fPSRKdzd5Yckx0Um4lnoTZVjaNa0Cazrmcste3PzBl6kJKu0vWVVM7i7O8kti72XgOeXbxW5XVZW3sgBXV1dfPyxM6rVNpVbnxQWhldpb1SKwcrSHO7u8v8GP779Gi+u3lZpewBo3rwpLGuZyC1LuHoNIlHe1FQFR+gUpKUlhp6e/NCPnOxcSHJUn4ZVV0dHYVq89OwslaujWuKyx6BTwhi2bg/AlxPH49DfR3D12lX4BWzBkyePUbt2bcydOxdDhgzBo+jH8J7pjZMn/0NKagratnHD6pVrULduXhFCOsJHJAK27diKLX6bEH4zHBKJBA0bNsSkSZMwqN9Q5B8C89/JE9i6PQBXrlxG3LM46OjowNnJGd9Onoaen38OPb23H1+9vLzg7++PZ09eYtGShdi3fy9ev45H3br1MNt7Dvr17a94HnR1FaYHlGRlQVBxKJBYS0suBiBvmsWCf4s9e3chNzcXX305ETo6b9u3aN4C7u7uOHDgADZu3AgDAwMAQG5WFpQNBdq5ezsMDQ0x7ovxsmtVS0sL3t7eWLduHXbt2oWuXbsiOzNXYYo5qSaNG6NRw8YIu3EdL1+9QPVq1aGrowuRWASRSASxWAwtLS0kvEmEiYmxwjRvymhpa0H3/8+DSCSCvr4+6tWzRmJEtELb/O8JUgULUURERERE6uDn54fRo0fj5MmTuHz5MjZs2IDHj+XznqdPn8Lb2xvHjh1DSkoK2rdvj99//x316tVT6M/f3x9//PEHwsPl8x4vLy+5dsePH8eWLVsQGhqKp0+fQkdHB82aNcN3332Hnj17yrWV5j3JycmYO3cudu/ejfj4eDg4OGDu3LkYOHBgRZ6iIu3YsQO5ubmYPHmy3JRtLi4ucHd3x969e+Hr6yvLewoTEBAAQ0NDfPXVV3LLp0+fjl9//RUBAQGyIlB0dDTOnj0LT09PWQEIyMt5J0+ejNGjR+Ovv/6SnfODBw8iOTkZ06ZNkxWAAKBWrVro378//P39ER0dXWg+pQlYBCpETk4ORo0aBWdnZ8yaNavU/UhHABU20kc6nVphI4VUZWiqh2ELWqvcvmBuLxKhRNsXfAYNADTrWAtOnsUP7yuqz7LG0LyzHZp2rKmktWp09LTKHIPLZ/b4uHOtUsegZ6Bd5hha9qiNFp/ZlzoGA2OdksWgI8aLYPkpDVv3qgPXHrVLHYORWcmuaWXPJWrbty5a96pT6hiMLfTLHEO7AQ5o20/xQ4Eyyr50M7MyLHMM7oPrl+iZQAVVqW6kcgzBwcFKnwnkOdQRZjFWGB/wtqh28X8eKsfwka1xmc9Dh5ENS/RMoIIsa5UsBm0lMXQc3UghhlY+J+V+l54XZc/KqFbbtMwxdP6icYmeCVSQdT2zYmMIDs67qcDNrbXSGLqOb1KiZwIVZONoXrLzoKt4UXb7yhl37t2CSCSCgYnygmTC9h1I2Lnz/wPJ+0/N336Drp0dtLTFCttlx8Xh8bjxcsvM+/eDRYEP+1L6Rjp46u2NjNt3ZMu0LCxgF+Bf6LEkHz2Kl7/+mvfL/59C60WLYPBxs0K3KYq+kU6h66TPSVuweB5SUlIwduwYGBoaYv369Rg2bJisENG2bVssWLgAMTEx+OWXXzBkxECEhYVBLBbLvvyfNGkSNmzYgO7du2PRokXQ0dHBkSNHMHr0aNy/fx8+Pj6y/e7aswPxr19h+IjhsLW1xcuXLxEQEIABg/th586dGDx4sEKsfQZ8DkNDQ3h7f4fc3Ny8ETKjh8OxkQNatmyp0L6gHGQiI1PFYTCZgKWBfLFdW0cMbR356+Hq9bz3O89P3BWulTZt2uDMmTMIDw+Hq2veTRAGxop/i+fPn+PRo0do27YtLKzkPyva29vD2toaoaF5N21o64qhXUhxXSKR4MXL59DV1YW1rRX09eXbXbx4EYaGhsjOzoahoSE+/fRTLFiwoMRTIjRqZwPH1tUVlud/T5DyDTQuUd9EREREVDFeb9/+Nu/5f9K8R5nsuDg8GjdObpl5v/74aLRXofuI/c4bGXfe3sinXcUCdlsLHx0il/f8P+tFi2BY4BmX5Wn27Nn/n/eMhYGBgdK8Z+HChYiJicHq1avRu3dv3Lghf6PohAkTsH79eqV5T0REhFze4+fnh+fPn2P48Ld5j7+/Pz7//HPs2rULgwYNUoixS5cu/5/3eCM3Nxe///47Bg0ahNq1a6uU96SkpCAjQ/Xh/1WrVi22zcWLeTeyt23bVmFd27ZtFfIeZZ4/f46YmBi0bdtWoVhUMO9RZZ8AEBoaKisCFdfe398foaGhLAJ9iFJSUmTP6SnsbnXpM3oOHDiA3r17K21jZGQEa2trPHz4ELm5uQpTykn3IX02UGmJRIoPtS/Z9qIybQ/8/4PYlXzZxxhKGIO47DFo62gBhX+vxxhUJC6PGJR8+azJMWjpKL97XFtXC1p6WsjO99IoyXGVx3nQKet50BJDV6tsd64riyG7QJdFHWdFxVASqsQgvQ4KOxYdvbLFoKUlhlZZz4OelqzYV9ioh9yEBGRFRcktE/6/qKF0m9xchfa58fGF9i8SiZAd+1RuG+3k5CJHYeQmJSMrskBMGekqjdwoLIbi1qWlpeHKlSvQ1897iMzAgQNhb2+PwYMHw8fHB7Nnz5ZtU61aNUyfPh2nTp1Cp06dAACHDx/Ghg0bsGzZMsycOVPW9ptvvsHEiRPx448/Yty4cahdO+/GgQ0bNsDIyEgulqlTp6JZs2ZYtGiR0iJQgwYN5KZWGzBgABwcHPDLL79g+/btxZ6HSZMmwd+/8OJbQQWLmMrO45MneaOja9asqbC+Zs2asjbSZEhZH7GxeaObbW1tla63tbXF3bt3C91e6vfff0dcXBxGjRqlkFQ1atQIo0ePRsOGDSEWi3Hp0iX8+uuvOH78OI4fP4727dsX2m9BWtpipTenKHtPUFbgJSIiIqJ3L/d1gmKOkVX4c1OFnByF9rnxRc+Akh0bK7eNxLLo2SmU5j3p6UVuU1YlyXusrKwwffp0nDx5UjYTyr///ov169cXmvcsX74cX3zxRZF5z7fffotmzZph4cKFSotABfOe/v37w8HBAatXr1Yp7/nmm2/KlPcoI817lD33R7osf95T0j6ky6V5T0n2Wdr2mohFoELo6ekpPEBKKigoCBEREfj8889haWlZbJXQw8MDu3btQnBwsMIUSceOHQMAheVERERE74NJkybJEiEAsLa2hqOjI27duoWpU6fKtfX09AQA3Lt3T1YE2rZtG/T09DBs2DC8eiWfHPbp0wfr1q3Df//9h3H/fzdh/kQoNTUVGRkZEAQBn3zyCXx9ffHmzRuYmMhP75c/yQIAOzs71K9fH/fv31fpGL29vTF8+HCV2qoqLS0NQN5nyoKk51PapjR9SPspro/AwEDMmDEDtWvXxs8//6yw/vDhw3K/9+/fH4MGDULr1q0xfvx43LlzR2EbIiIiIiJNU9q8R/qdrr+/P/OeAioq7ynpPssjxsqORaBCGBgYYOPGjUrXeXl5ISIiArNnz0br1m+ntXj16hVevXqFqlWryg2XGz9+PHbt2oUffvgBJ06ckI0sOnLkCAIDA9G5c2fYFTLEkoiIiEidpM/3yc/CwgI2NjZySZJ0OQDE53sO2Z07d5CZmSkb/aLMs2dvn2MXHR2NH374AYcPH8br168V2iYkJCgkQ8pirFq1KmJiYgrdZ36NGjVCo0aNVGqrKkNDQwBAZmamwugb6RQM0jaq9KFMRkZGkX0EBwejZ8+esLS0xPHjx2V/n+I0b94cn3/+Ofbt24fIyEilc50TEREREWmSsuY9t2/fZt7zjvKeotor22dJ22siFoHK0a+//ooFCxZg3rx5mD9/vmx5hw4d8MUXX2Djxo1o3rw5unfvjri4OOzevRsWFhZYu3at+oImIiIipbQsqkC3nvyHbFEhU8QCgEhbW6G91kdFz6GsU6MGcpPfPjdQu0rRX9JrmZkqxlTMAzbLquBUtsUtB+SnDZBIJDA2NsaBAwcKbV+nTt7z21JSUuDu7o6kpCRMmTIFzs7OMDU1hVgsxubNm7Fz505IJBKF7fM/gLSwOIqSlJSE9BJML1G9uuJzbwqytbXFzZs38eTJE4Vpf4ub7iB/H/nbF/TkyZNC+wgKCkL37t1RpUoVnDp1qsSFHOk0FS9evGARiIiIiEiDMe/5/30y71HwvuY9RbVXts/87Rs2bFiqGCs7FoHeEV9fXzg5OWH9+vX45ZdfYGxsjD59+sDHx0dpFZeIiIjUy2LYMFgMG6Zyex1ra9T9998S7aPGih9L1N60a1eYdu1aom3UzcHBAffu3YOTkxOqVatWZNtTp07h8ePH2LRpE8aMGSO3bsOGDRUW45QpU8p9bmxXV1ccPXoUISEhCslQSEgIDAwM0KRJkyL7qFatGmrVqoXr168jPT1d7s66mJgYxMXFoXPnzgrbnT59Gj169ICVlRVOnTolK+iUhHRKCVUSPyIiIiKqvJj3lI/69evj7t27zHvyqai8R/p8oZCQEIW+pMvyP4PI1dUVf/zxB0JCQmTTlhds37Jly2KPtTIr21OVP1B+fn4QBEFuKjgAmD9/PgRBkBsFJCUWizF58mTcvHkTGRkZePXqFXbt2sUCEBEREWm0ESNGAABmzJih9G62pKQk2bB86V12BZONGzdu4K+//qqwGL29vXHixAmVf1QxdOhQaGlp4ZdffkFOTo5s+eXLl3HmzBn069dPbsqBpKQk3L17V2H+8BEjRiAtLQ3r1q2TW75y5UrZ+vxOnjyJ7t27w9raGmfOnCmyAJR/+or8AgMD8e+//8LJyUl2tyIRERERERXOy8sLAPMeqYrMe2rXrg03NzcEBgbiypUrsuU5OTlYs2YNTExM0KtXL9ny3r17w8TEBBs2bEBycrJs+aNHj7Bnzx60a9euVDfOVSYcCUREREREFaZXr1748ssv8ccffyA8PBx9+/aFjY0Nnj9/jhs3buDvv//GnTt3YG9vDzc3N1hbW2P69Ol48OAB7O3tcefOHWzYsAFOTk5yH/DLU0XMje3o6Ahvb28sXboUnp6eGDFiBF69eoVVq1bBysoKS5YskWt/4MABjB49WmFaYW9vb+zduxfe3t6Ijo5G06ZNcebMGWzduhVDhgxBx44dZW0vX76Mnj17Ijs7G+PGjUNQUJBCXJ06dZLdmbh161asX78eXbt2Re3atSEWi3H58mVs27YNRkZG2LRpU7meEyIiIiIiTdWnTx/mPe8o7wGANWvWwN3dHV26dMHUqVNRtWpVbN26FVevXoWvry+qVKkia1ulShWsWLECX375Jdzc3DBhwgRkZmbKHtGyZs2acj0n7yMWgYiIiIioQq1btw6ffPIJfH19sWrVKqSmpsLKygqOjo5YsmSJbMoxc3NzHD9+HDNnzsS6deuQmZkJZ2dnbN++HVevXq2wZKii+Pj4wM7ODr/99humTJkCY2NjdOrUCUuWLCnygbH5mZqa4uzZs/j++++xZ88e+Pr6ws7ODkuWLMGMGTPk2t68eVM2x/esWbOU9nf69GlZEahly5YIDAzE/v378fLlS+Tk5KBGjRoYM2YMZs2apfF3wxERERERlSfmPe8m7wGA5s2bIzg4GP/73/+wYsUKZGVlwcnJCXv27EH//v0V2k+YMAEfffQRVqxYAW9vb+jq6qJdu3bw8fFB06ZNy3wO3nciQdUnR9F7q02bNgCUz4NY0aR3mLq7u7/zfdP7hdcCAUVfB1cfJWDkplDZ7zcXdHlncb3Pmsw7Jve7JpyXyvJ+EB4eDgBwcnJScySaSzrdgZ6enpojoYpU3GtJ2XuCOj+/UuWk7mumsvzbRhWL1wEBvA7orcpyLTDvqVjMeT4MqryO3ue8h88EIiIiIiIiIiIiIiIi0kAsAhEREREREREREREREWkgFoGIiIiIiIiIiIiIiIg0EItAREREREREREREREREGohFICIiIiIiIiIiIiIiIg3EIhAREREREREREREREZEGYhGIiIiIiIiIiIiIiIhIA7EIRERE74RI3QEQERERERERERF9YFgEIiIiIiIiIiIiIiIi0kAsAhEREREREREREREREWkgFoGIiIiIiIiIiIiIiIg0EItAREREREREREREREREGohFICIiIiKqMNHR0RCJRJg/f766QyEiIiIiIqoQzHvofcYiEBERERGRim7cuIGePXuiSpUqMDIyQuvWrbF///4S97NhwwY0bdoUBgYGsLS0xNChQxETE6O0bVpaGmbNmgV7e3vo6enB3t4es2bNQlpamtL2MTExGDp0KCwtLWFgYICmTZtiw4YNJY6RiIiIiIg+TMx7NIu2ugMgIiIiIs1lZ2eH9PR0aGtX/o+dYWFhaNeuHfT09DB9+nRUrVoV27ZtQ79+/bBx40aMHTtWpX5++OEHLF68GG5ubli9ejVevnyJ1atXIzAwEKGhobC1tZW1zc3NRbdu3XDmzBmMGDEC7u7uCAsLw08//YSLFy/iv//+g5aWlqz9kydP0Lp1ayQlJeHbb79F7dq1cfDgQYwfPx6PHj3CokWLyv28EBERERF96Jj3KGLe8/6o/FclEREREb23RCIR9PT01B1GuZg0aRJSU1Nx+vRpuLi4AADGjh2LVq1aYdq0aejXrx/Mzc2L7OP+/ftYunQpmjdvjsDAQFmS2LVrV7i6umLOnDkICAiQtff398eZM2cwadIkrFmzRrbc3t4eM2bMgL+/P8aMGSNbPmfOHDx79gz79u1D3759AQDjxo3D559/jqVLl2LkyJFwcHAor1NCRERERETIy3v09fXVHUa5YN6jeTgdHBEREREp8PPzg0gkwqlTp/Djjz/CwcEB+vr6aNiwIXbu3AkAePr0KYYPHy4bft+5c2dERkbK9aNsbuz8y06cOAE3NzcYGhrCwsICw4cPR3x8/Ls8VJVER0fj7Nmz8PDwkCVCAKCjo4PJkycjOTkZf/31V7H97NixA7m5uZg8ebLcXYIuLi5wd3fH3r17kZ6eLlsuTYymT58u18/EiRNhYGAglzilpaVh7969qF27tiwRkpo2bRpyc3Oxffv2Eh03EREREZEmY94jj3mPZuJIICIiIiIldt7did13d5epjwYfNcCy9ssKXT/r7Czcjb9bpn0MajAIQxoMKVMfRZk9ezZSUlIwduxYGBgYYP369Rg2bBi0tLTg7e2Ntm3bYuHChYiJicHq1avRu3dv3LhxA2Jx8fcaHT16FGvWrMG4ceMwcuRIXLx4EX5+fkhISMChQ4dKHXN2djaSkpJUbm9iYlLsaKWLFy8CANq2bauwTrosNDQUXl5eZernzJkzCA8Ph6urKwRBwKVLl2BjYwM7Ozu5tgYGBmjWrBkuX74MQRAgEokQHh6O9PR0tGnTRqHvNm3aQCQSITQ0tMj4iIiIiOjDwrwnT2nzHlUw71Hsh3nPu8UiEBEREZESCRkJiEqKKlMfpnqmRa5/mvK0zPtIyEgo0/bFSUtLw5UrV2RTGwwcOBD29vYYPHgwfHx8MHv2bFlbKysrTJ8+HSdPnkSnTp2K7TssLAzXr1+Ho6MjAGDChAnQ1tbGhg0bEBERUerh+8HBwejQoYPK7bds2VJsEvPkyRMAkJu3Wkq6TNqmPPpxdXXF69evkZaWhiZNmijty9bWFiEhIUhISICFhUWRfevp6aFq1aoqxUhEREREHw7mPXlKm/e4u7sX2zfznsL7Yd7zbrAIRERERESFmjRpktzc1tbW1nB0dMStW7cwdepUubaenp4AgHv37qlUBOrdu7csEZLq3LkzNmzYgPv375c6GWratClOnDihcvvGjRsX2yYtLQ0AlN45Jz0/0jbl1U9RbQu2t7CwUKm9KjESEREREX1oSpv3qFIEYt5TdD/Meyoei0BEREREVKi6desqLLOwsICNjY3Cg08tLCwAQOW5rZX1XbVqVQDAq1evShqqTJUqVfDpp5+WentlDA0NAQCZmZkK6zIyMuTaqNqPgYFBkf0Utc/Sti/uAa6kOS5duoR58+bh/PnzyM7OhpOTE6ZNm4aBAweq3EdmZiaWL1+OrVu34vHjx7CwsECPHj2wePFiWFlZFbt9t27dcOTIEejp6cmuVyIiIqL3EfOePMx7NBOLQERERERKVNGvgrpmih/WS8LG2KbY9cmZyWXaRxX9KmXavjhaWlolWg4AgiCo1Hf+B4SWtg9lsrKy8Pr1a5Xbm5mZKSQmBRU19UFR0xEo6+fmzZt48uSJwh1/BfuxsLCAoaFhoVMZPHnyBEZGRqhSpUqxMWZmZuLVq1dyD3clzXX69Gl06dIF+vr6GDx4MExMTLBv3z4MGjQIjx8/VnjgrjISiQS9evXCsWPH0Lp1a/Tr1w8RERHYuHEjTp48iQsXLsDS0rLQ7Tds2IBjx45BX1+/TK9nIiIiqljMe/Iw78nDvEczsQhEREREpMSQBkMq9MGjAIp8eCqV3vnz58t9bmxXV1cAQEhIiMI66TJpm+L6OXr0KEJCQhSSoZCQEBgYGMjmwhaJRHBxcUFQUBBiYmLkHpKanp6O69evw9XVFSKRCADg5OQEfX19pTFeuHABgiCoFCNVbjk5ORg3bhzEYjGCgoLQrFkzAMDcuXPh6uqKOXPmoH///goP3S3I398fx44dw5AhQ7B9+3bZdfbHH3/gq6++wvfffw9fX1+l20ZHR2P69OmYNm0a9uzZg2fPnpXrMRIREVH5Yd5TeTHvYd6jKrG6AyAiIiIiKk/SubFV/enSpUuxfdauXRtubm4IDAzElStXZMtzcnKwZs0amJiYoFevXnLb3L17F1FR8g/AHTp0KLS0tPDLL78gJydHtvzy5cs4c+YM+vXrJze9wogRIwAAK1eulOtn3bp1SE9Pl60H8qZF6NevHx4+fIj9+/fLtV+5ciW0tLQwZEjFJvikfqdOnUJUVBSGDh0qKwABeXd+zpkzB1lZWfD39y+2nw0bNgAAli5dKku4gbwHGdepUwfbt29Henq6wnaCIGDMmDGwtrbGwoULy35ARERERKQU8x7mPariSCAiIiIi0igVMTc2AKxZswbu7u7o0qULpk6diqpVq2Lr1q24evUqfH19ZdMTSDVs2BB2dnaIjo6WLXN0dIS3tzeWLl0KT09PjBgxAq9evcKqVatgZWWFJUuWyPUxevRoBAQEYO3atUhKSoK7uzvCwsLw+++/o3379gp38i1ZsgT//fcfRowYgStXrqB27do4ePAg/v33X8yePVvhgbSkeQIDAwHkPWy4IGnif+bMmSL7yMjIwMWLF+Ho6KgwYkgkEqFTp07w9fXF5cuX0b59e7n1a9euxZkzZxAUFFTsdCNEREREVHrMe5j3qIpFICIiUgtBEOTuLCYiet81b94cwcHB+N///ocVK1YgKysLTk5O2LNnD/r3769yPz4+PrCzs8Nvv/2GKVOmwNjYGJ06dcKSJUtQs2ZNubZaWlo4fPgwFi5ciN27d2Pnzp2wtrbGtGnTMHfuXIU5ymvVqoWQkBDMmTMHvr6+SElJQf369fHHH39g/Pjx5XIe6P0WEREBAArTbgBA9erVYWxsLGtTmKioKEgkEqV95O87IiJCrggUERGB2bNnY/LkyXBzcytV/G3atFG6/ObNm6hVqxaCgoJK1W9ZJSfnPcdAXfun9wOvAwJ4HdBbleVaMDAwgJ6eHjIzM9UdynspOzsbQN7zdQqeI4lEAkEQFJZLf8/JyZE90yf/Mun/K1smlZWVJdv/+/a3ady4MU6fPo158+bJ8p4mTZpgx44d6Nu3r9J4lZ2nuXPnwsbGBr6+vrK855NPPsHChQthZWWl0P7AgQNYsmQJ9uzZg507d6J69eqYMmUK5syZg5ycHLkRRdWqVUNgYCDmzp0ry3scHBywdu1afPHFF+V+TqXHV9TrXdl7QnJyMkxNTcs1ltJgEYiIiN4JFnyIKhcvL69C54uWjjQoyN7eXuHBpqouk/L09HyvHyLftGlT/Pvvvyq1Lew4RCIRJkyYgAkTJqjUj7GxMX788Uf8+OOPKrWvXbs2du7cqVJb0jxJSUkA8qZ/U8bU1FTWpix95G8H5H1JMmrUKFhbW8PHx6fEcRMRERGpw8iRIzFy5Eil606cOKF0ub29PTIyMgC8/cyff5mydgV5eHgUuu594OzsjAMHDqjUtrDjEIlEGDduHMaNG6dSP8bGxliyZInCKKHC1K5dG1u3blWp7YeORSAiIiIiIiIqkxUrVuDChQs4ffq03PzuJaXsAb/A2xFC7u7upe67LKR3dKpr//R+4HVAAK8DequyXAvh4eEAAD09PTVHopmkI054fjWbSCSCvr4+WrZsWWgbZe8J78MoIAAQqzsAIiIiIiIiKh/S0TuFjfZJTk4udIRPSfrI3+7+/fuYN28eJk6cCA8Pj1LFTUREREREFYNFoCJkZGRg2rRpcHd3h42NDfT19VG9enW4ublhy5YtsjkjixMYGAiRSFToj5+fX8UeCBERERERfRDyP6+noGfPnsnmSy9KnTp1IBaLC312UMHnDt2+fRuZmZn47bffFHKdmJgYZGZmyn5PTEwsw9EREREREVFJcTq4IqSkpGDdunVwdXVF9+7dYWlpiYSEBBw5cgRjxozBrl27cOTIEYjFqtXSPDw84OnpqbC8WbNm5Rs4ERERERF9kDw8PLB06VIcP34cgwcPllt37NgxWZuiGBgYwNXVFRcuXEBMTAzs7Oxk6wRBwIkTJ2BkZAQXFxcAefPdjx07Vmlfu3fvRnp6uuwZY5wqhYiIiIjo3WIRqAgWFhZISkqCrq6u3PKcnBx06tQJx48fx5EjR9C9e3eV+vP09MT8+fMrIFIiIiIiIiKgY8eOqFOnDnbs2IHJkyfLbjhLSkrCkiVLoKurK/fw47i4OCQlJcHa2lpumrjx48fjwoULmD17NrZv3w6RSAQA8PX1xYMHDzB+/HgYGBgAyLupbePGjUrj+e+///Ds2bNC1xMRERERUcXidHBFEIvFCgUgANDW1kafPn0AAJGRke86LCIiIiIiIqW0tbWxceNGSCQSuLu7Y/z48Zg+fTqaNm2K+/fvY8mSJbC3t5e1nz17Nho2bIgDBw7I9TNq1Ch06dIFO3fuRNu2bTFr1iz0798fEydORO3atbF48eJ3fGRERERERFQaHAlUChKJBEePHgUANGnSROXtIiIisHr1aqSnp8PW1haffPIJatSoUVFhEhERERHRB6hDhw44d+4c5s2bh927dyM7OxtOTk5Yvnw5Bg0apFIfYrEYBw8exLJly7B161asWrUKFhYWGDt2LBYvXgxLS8sKPgoiIiIiIioPLAKpICsrC0uWLIEgCIiPj8fJkydx9+5djB49Gh07dlS5nx07dmDHjh2y37W1tTFp0iSsWLECWlpaxW7fpk0bpctv3ryJWrVqISgoSOVYyktycjIAqGXf9H7htUBA0ddBVGIucnJzZL8HBQXJppb5kOU/J4BmvIYqy/uBgYEB9PT0kJmZqe5QNJYgCADAc6zhBEFAZmZmoa95Ze8JycnJMDU1fSfxfahcXV1x5MiRYtv5+fnBz89P6To9PT3MmzcP8+bNK3Uc0dHRpd6WiIiIiIjKjkUgFWRlZWHBggWy30UiEWbMmIGlS5eqtL2lpSWWLVuGHj16wN7eHqmpqQgJCcGsWbOwatUqiEQirFy5sqLCJyIiIiIiIiIiIiKiDxCLQCowNjaGIAiQSCR4+vQp/vnnH8yZMwchISE4fPhwsXcxNm7cGI0bN5b9bmRkhF69eqFVq1ZwdnbGmjVrMHPmTFhZWRXZT0hIiNLl0hFC7u7uJTyyspPe0amOfdP7hdcCAUVfB6aPE6F95aLsd3d3d44EAqB98pjc75rwGqos7wfh4eEA8u50p4ohHQHEc6zZRCIR9PX10bJlS6Xrlb0ncBQQERERERHRuyFWdwCViVgshq2tLb766iusX78ewcHB8PHxKXV/1atXR69evZCTk4OLFy8WvwEREREREREREREREZGKWAQqpc6dOwMAAgMDy9RP1apVAQCpqallDYmIiIiIiIiIiIiIiEiGRaBSevr0KQBAR0enTP1IRwDZ29uXNSQiIiIiIiIiIiIiIiIZFoGKcPv2baSlpSksT0tLw7Rp0wAA3bp1ky1/9eoV7t69i1evXsm1v3LlitL+f/nlF5w+fRoODg6FzqFORERERJXH9evXoaOjA5FIBD8/vxJte+PGDfTs2RNVqlSBkZERWrdujf379xfafv/+/WjdujWMjIxQpUoV9OzZEzdu3FDaNicnB8uXL4ejoyP09PRgY2ODr776CvHx8SWKkYiIiIiIPkxpaWmYNWsW7O3toaenB3t7e8yaNUvp9+dFYd7z7mmrO4D32Z9//omff/4Z7dq1g729PUxNTREbG4sjR44gPj4e7du3x9SpU2Xtf/31VyxYsADz5s3D/PnzZcv79esHHR0duLi4wNbWFqmpqbhw4QKuXbsGc3NzbNu2DVpaWmo4QiKid0cQBHWHQERUoXJycjB27Fjo6+sjJSWlRNuGhYWhXbt20NPTw/Tp01G1alVs27YN/fr1w8aNGzF27Fi59ps2bcIXX3yBJk2aYPny5cjIyMDatWvh5uaGc+fOoWnTpnLtR48ejW3btqFHjx6YMWMGHj58iNWrVyMoKAgXLlyAiYlJmY+fiIiIiIg0U25uLrp164YzZ85gxIgRcHd3R1hYGH766SdcvHgR//33n0rfbzPvUQ8WgYrQo0cPPH36FOfPn0dISAhSUlJgZmYGZ2dnDB48GGPGjIG2dvGn8KuvvsKxY8cQFBSE+Ph4iMVi2NnZ4dtvv8X06dNha2v7Do6GiIiIiCrSTz/9hIiICMycORM//PBDibadNGkSUlNTcfr0abi4uAAAxo4di1atWmHatGno168fzM3NAQAJCQmYNm0abG1tERwcDFNTUwDAwIED0ahRI0yaNAlBQUGyvk+dOoVt27bh888/x8GDB2XLW7Rogf79+2PFihVYuHBhGY+eiIiIiIg0lb+/P86cOYNJkyZhzZo1suX29vaYMWMG/P39MWbMmGL7Yd6jHpwOrgguLi5Yv349bt68iYSEBGRnZ+PVq1c4deoUxo8fr1AAmj9/PgRBkBsFBAAzZ87EqVOnEBsbi4yMDKSlpeHOnTtYtWoVC0BERET0XvLz84NIJMKpU6fw448/wsHBAfr6+mjYsCF27twJIO8ZicOHD4elpSUMDAzQuXNnREZGyvUjkUiwZMkSeHp6wtraGrq6uqhRowZGjRqFR48eybX19/eHSCTCN998I7c8KysLrq6uMDAwwPXr1yv0uEvr/v37WLBgAXx8fEr8+S46Ohpnz56Fh4eHLBEC8p49OXnyZCQnJ+Ovv/6SLT948CCSk5PxxRdfyBIhAKhVqxb69++Ps2fPIjo6WrY8ICAAAGTTGUv169cP9vb2svVERERERB8a5j2qkeYM06dPl1s+ceJEGBgYqJRTMO9RH44EIiIitRAEQCRSdxREhQsPfILwM7Fl6sOypjE6jWlc6PoTm2/h5eOSTRtWkJNHDTh5VtxNJbNnz0ZKSgrGjh0LAwMDrF+/HsOGDYOWlha8vb3Rtm1bLFy4EDExMVi9ejV69+6NGzduQCzOu9coKysLy5cvR9++fdG9e3eYmZnhxo0b2Lx5M06ePIkbN27AwsICADBq1CicOXMGv/32Gzw8PDBgwAAAgLe3Ny5dugRfX180a9as1MeSkJCA3Nxcldrq6OjAzMxMpbaCIGDs2LFo2rQpvv766xInFxcvXgQAtG3bVmGddFloaCi8vLxUau/v74/Q0FDY29vL2ovFYrRu3VqhfZs2bbBz5068ePECVlZWJYqbiIiIiCo/5j15Spv3SGly3iMIAi5dugQbGxvY2dnJrTMwMECzZs1w+fJlCIIAURFf9DDvUR8WgYiI6J0o6oMA0fso/U0WEuJSy9SHvmHRH7XexGeUeR/pb7LKtH1x0tLScOXKFejr6wPIG3pvb2+PwYMHw8fHB7Nnz5a1tbKywvTp03Hy5El06tQJAKCnp4e4uDgYGhrK9du7d2906tQJmzZtwnfffSdb/uuvv+LSpUv44osv8PHHH+PmzZv45ZdfMHToUIwfP75Mx/Lxxx8jJiZGpbYeHh4IDAxUqe3vv/+Oixcv4sqVK7LiV0k8efIEAJSOIJIuk7YpbfuqVatCT0+vyPYfYjJERERE9KFj3pOntHmPu7s7AM3Oe16/fo20tDQ0adJE6XpbW1uEhIQgISFBVuhShnmP+rAIRERERESFmjRpkiwRAgBra2s4Ojri1q1bmDp1qlxbT09PAMC9e/dkRSCRSCRLhCQSCZKTk5GTk4NmzZrBzMxMdneXlKGhIfbs2QMXFxf06dMHT548gaOjI3x9fct8LNu3b0d6erpKbatUqaJSu0ePHmH27NmYMWMGnJycShVXWloaAChNVqTnXtqmtO0LOx5l7YmIiIiIPjSlzXukRSBNznuKyj8A+ZyiqCIQ8x71YRGIiIiIiApVt25dhWUWFhawsbGRS5KkywEgPj5ebvlff/2FH3/8EVeuXEFWlvwdfK9fv1bov0GDBvj5558xYcIE6Ojo4M8//4SxsXFZDwVubm5l7qOgCRMmoFq1apg7d26p+5Ami5mZmQrrMjIy5NqUtr2ytoW1JyIiIiL60DDvKVxR+Qegek7BvEd9WAQiIiIiUsLARBdVrI3K1IfJR/rFrs9IyynTPgxMdMu0fXG0tLRKtBzImzNa6p9//sGAAQPg4uKCn3/+GbVq1YKBgQEAYPDgwZBIJEq3//vvvwEA2dnZuHnzJpydnctyGACAly9fqjw3tq6ubpF3sQHAgQMHcPToUfj6+spNQ/DixQvZfyMjI2FjY1NksqFsKgMpZVMg5G/fsGFDldrfv38fmZmZCnfRFTXFAhERERFpPuY9ecqa9xw8eBB9+vTRyLzHwsIChoaGSvMVIC+nMDIyKnZUEfMe9WERiIiIiEgJJ0/bCn3wKIAiH56qKbZt2wZ9fX2cOXNGrhCSmpqKhIQEpdusWLEChw4dwsyZM/Hvv/9iwoQJcHFxQf369csUS8uWLct1bmxpXxMmTFC6fubMmZg5cyb++ecf9OjRo9B+XF1dAQAhISEK66TLpG2k///HH38gJCRENu1ewfYtW7aUa3/37l1cvHhRNl1F/vZ2dnYf5LzYRERERMS8p7z4+/trbN4jEong4uKCoKAgxMTEwM7OTrYuPT0d169fh6ura7HPgmbeoz4sAhERERFRhdHS0oJIJFK4823RokVK74YLDg7G//73P3Ts2BFLlizBqFGj0LJlSwwcOBAXLlxQmIqhJMp7buwePXoovZMsMDAQv/32G77++mt4enrCxcVFti4uLg5JSUmoVauWLDmsXbs23NzcEBgYiCtXrqBFixYAgJycHKxZswYmJibo1auXrI/evXtjypQp2LBhA7799luYmpoCyHs+0Z49e9CuXTvUrl1b1n7EiBEICAjAypUr5ZKh/fv3Izo6Gt9//71K54SIiIiIiJTT5LwHyMspgoKCsHLlSqxZs0a2fN26dUhPT8eIESPk2jPveb+wCEREREREFaZv377Yv38/PDw84OXlBUEQcOzYMdy+fRtVq1aVaxsfH4/BgwejatWq2L59O8RiMRo2bIh169Zh5MiR+Pbbb/HHH3+UOpbynhu7Xr16qFevnsLylJQUAICLiwv69+8vt2727Nnw9/fH6dOnZQ+UBYA1a9bA3d0dXbp0wdSpU1G1alVs3boVV69eha+vr1xyVqVKFaxYsQJffvkl3NzcMGHCBGRmZmLt2rWyvvL79NNPMWTIEOzcuRM9e/ZEr1698PDhQ6xatQoNGjTAd999V16nhIiIiIjogzRgwADs3btXI/MeABg9ejQCAgKwdu1aJCUlwd3dHWFhYfj999/Rvn17eHl5ybVn3vN+YRGIiIiIiCpM//79kZmZiVWrVsHb2xsmJibo1KkTzp49i3bt2snaCYKAESNG4OnTpzhx4gSqVasmWzdixAicOXMGvr6+8PT0xODBg9VxKBWqefPmsrsBV6xYgaysLDg5OWHPnj0KhSQgbwq6jz76CCtWrIC3tzd0dXXRrl07+Pj4oGnTpgrt/f394eTkhC1btuDrr7+GhYUFRowYgcWLF8vuqCMiIiIiotIZOHAgUlJSNDbv0dLSwuHDh7Fw4ULs3r0bO3fuhLW1NaZNm4a5c+cW+eyk/Jj3qIdIyP8EK6qU2rRpA0D5fIoVLSgoCAAU5lmkDw+vBQKKvg6uP07E8I0XZb/fmNcZYnHR88V+CJrMOyb3+80FXdQUSfmpLO8H4eHhAAAnJyc1R6K5MjMzAUDhoZykWYp7LSl7T1Dn51eqnNR9zVSWf9uoYvE6IIDXAb1VWa4F5j0ViznPh0GV19H7nPeI1bp3IiIiIiIiIiIiIiIiqhAsAhEREREREREREREREWkgFoGIiIiIiIiIiIiIiIg0EItAREREREREREREREREGohFICIiIiIiIiIiIiIiIg3EIhAREREREREREREREZEGYhGIiIiIiIiIiIiIiIhIA7EIRERERB8kkUgEQRCQk5Oj7lCIKq2cnBwIggCRSKTuUIiIiIhICbFYDEEQkJubq+5QiColTch5WAQiIiKiD5KpqSkAIDo6GmlpaZBIJGqOiKjykEgkSEtLQ3R0NIC3ryciIiIier/o6+sDAGJiYlgIIioBTcp5tNUdABERfZgEdQdAHzwrKyukpqYiLS0NkZGRAFCp7+x5HwlC3iud51XzSP+2AKCjowMrKys1RkNEREREhalZsyaioqKQkpKCW7du8bN5OWPOo7k0KedhEYiIiN4Jfhyi942+vj4cHR3x4sULJCcnIzs7m6OByllmZiaAt3cfkubQ0tKCjo4OzMzMYGlpCbGYEwwQERERvY90dXVRt25dPH78GBkZGcx5yhlzHs2lSTkPi0BERET0wRKLxahevTqqV6+u7lA0UlBQEACgZcuWao6EiIiIiOjDJS0EUfljzkOVQeUtXxEREREREREREREREVGhWAQiIiIiIiIiIiIiIiLSQCwCERERERERERERERERaSAWgYiIiIiIiIiIiIiIiDQQi0BEREREREREREREREQaiEUgIiIiIiIiIiIiIiIiDcQiEBERERERERERERERkQZiEYiIiIiIiIiIiIiIiEgDsQhERERERERERERERESkgVgEIiIiIiIiIiIiIiIi0kAsAhEREREREREREREREWkgFoGKkJGRgWnTpsHd3R02NjbQ19dH9erV4ebmhi1btiA7O1vlviQSCdauXQsnJycYGBjA0tISQ4YMwYMHDyrwCIiIiIiIiIiIiIiI6EPFIlARUlJSsG7dOohEInTv3h3Tpk1Dnz59EBsbizFjxqBHjx6QSCQq9TVhwgRMnjwZgiBg8uTJ6Nq1K/bv34+WLVsiIiKigo+EiIiIiIiIiIiIiIg+NNrqDuB9ZmFhgaSkJOjq6sotz8nJQadOnXD8+HEcOXIE3bt3L7Kf06dPY+PGjXB3d8eJEydk/Q0dOhTdunXDN998g2PHjlXYcRARERERERERERER0YeHI4GKIBaLFQpAAKCtrY0+ffoAACIjI4vtZ8OGDQCARYsWyfX32WefwdPTE8ePH8ejR4/KKWoiIiIiIiIiIiIiIiIWgUpFIpHg6NGjAIAmTZoU2z4wMBBGRkZwc3NTWNelSxcAwJkzZ8o3SHpvxCWlo8fas/hkZSBuP00ucx+3niaVc4Tql5MrwRf+l9HS5z/8e+NpufSZKxHw1bYrcFn8Hw5ce1Iuff556TFcFp/ApJ3XIAhCufRJmu2PM1FosegE5v99S92hyJy4/Rytl5zEqM2hyMjOVWss6Vm5GLHpItosPYnTd1+oNRZlrj9OhMeK0+j9WzBevMlQdzjv1J+X897vvtlxtcj3u4zsXIzaHIpWS/7D8VvP3klsQfdfou3Skxi64QJSM3PeyT6JiIiIiIiIKitOB6eCrKwsLFmyBIIgID4+HidPnsTdu3cxevRodOzYschtU1NTERcXhyZNmkBLS0thvYODAwCo9FygNm3aKF1+8+ZN1KpVC0FBQSocTflKTs4raqhj35XF79fSEfky70uqLzYHY5m7Udn62HQeyz1K3kdFK8u1cDEuG+ci8r5gnfHnNZgmFj/CrjjXnufg9N10AMDsfWH46M2DMvc59/gbAMCJW0/xx4EENK7Kt9CCiroOHiTmIif37Re2QUFB0BKL3lls6rD6RN41sys0Gk66L2FpqHjvRf5zAlT8++mk/7+OLz7IwPLdp9GhluKI17JS9f3g2MMsXHqYCQD4atslrO9sUu6xlMWUkylIzxXwPCkNMwOCMNpJX90hvTPS97v/bsdh3YFENCnk/e70oyxcfJD3N5y884rC37AiPieM///YXqdmYOGO0+heV6/c+qaKoew6SE5OhqmpqbpCIiIiIiIi+mDwG0wVZGVlYcGCBbLfRSIRZsyYgaVLlxa7bVJS3qgNMzMzpeulya+0HWme8Fdvv+B9nSEpcx8JmaXr43325E35H9PT1Io9T8/TJGhcoXsgTZOUKcDSUN1RyItJVu/7ycMk9Y5EKk567tsRMLfjP9wRJ89TJWhSVfk6dV9DD5I0799EIiIiIiIiovLEIpAKjI2NIQgCJBIJnj59in/++Qdz5sxBSEgIDh8+/M7uYgwJCVG6XDpCyN3d/Z3EkZ/0jk517Luy0D59HCLJ2y8SS3OuyqOPilaWa+Fyxj1oP46W/V4ex3dHiIL2w7cjisqjT+2Tx2T/7+DgAPdWdmXuU9MUdR2YP0mE9pWLst/bt28PbS3NnpU0/zXT7ONmaF6rSpFtgIp/feffn7W1Ndzdncp9H6q+H+x/eg3a8W+ngXvf3tvynysDA933Lr6KlP/Y6zk4wL218ve7Y/Hh0H7+dhrPgueoIj4n5I+tatWqcHdvUW59U8VQdh1wFBAREREREdG7odnfvpUzsVgMW1tbfPXVV1i/fj2Cg4Ph4+NT5DbSEUCFjfSRTo9R2EghIiIiIiIiIiIiIiKi0mARqJQ6d+4MAAgMDCyynZGREaytrfHw4UPk5ipOeyN9FpD02UBERERERERERERERETlgUWgUnr6NG/qEx0dnWLbenh4IDU1FcHBwQrrjh3Lm9LkQ5pihoiIiIiIiIiIiIiIKh6LQEW4ffs20tLSFJanpaVh2rRpAIBu3brJlr969Qp3797Fq1ev5NqPHz8eAPDDDz8gKytLtvzIkSMIDAxE586dYWfHZ4sQEREREREREREREVH50VZ3AO+zP//8Ez///DPatWsHe3t7mJqaIjY2FkeOHEF8fDzat2+PqVOnytr/+uuvWLBgAebNm4f58+fLlnfo0AFffPEFNm7ciObNm6N79+6Ii4vD7t27YWFhgbVr16rh6IiIiIiIiIiIiIiISJOxCFSEHj164OnTpzh//jxCQkKQkpICMzMzODs7Y/DgwRgzZgy0tVU7hb6+vnBycsL69evxyy+/wNjYGH369IGPjw/q1q1bwUdCRET0/hHUHQARERERERERkYZjEagILi4ucHFxUbn9/Pnz5UYA5ScWizF58mRMnjy5nKIj0hz8IpiIiIiIiIiIiIio/PGZQERERERERERERERERBqIRSAiUjuRugMgIrXga5+IiIiIiIiIqGKxCEREVAoC57CjEuI1U7l90H++9/jifY9DIyIiIiIiInovsAhEVAmIeLt8ifGcERFVPL7XEhEREREREb3fWAQiIqJ3gnfsExERvTuXLl1Ct27dYG5uDiMjI7Ru3Rp//vlnifrIzMzEwoUL4eDgAH19fdjY2GD8+PF48eKFQtvr16/jhx9+QOvWrWFlZQU9PT3UqVMHEydORGxsbHkdFhERERERlZC2ugMg0nS8S5qIiIiI3qXTp0+jS5cu0NfXx+DBg2FiYoJ9+/Zh0KBBePz4MaZPn15sHxKJBL169cKxY8fQunVr9OvXDxEREdi4cSNOnjyJCxcuwNLSUtb+yy+/xMWLF+Hq6orBgwdDT08PFy9exLp167Bnzx6cPXsWDRo0qMjDJiIiIiIiJVgEIiIiIrXg4DAiovKXk5ODcePGQSwWIygoCM2aNQMAzJ07F66urpgzZw769+8POzu7Ivvx9/fHsWPHMGTIEGzfvh2i/7+z6Y8//sBXX32F77//Hr6+vrL2w4YNw7Zt21CvXj25fpYvX45Zs2Zh+vTpOHToUPkeLBERERERFYvTwREREREREWmIU6dOISoqCkOHDpUVgADAzMwMc+bMQVZWFvz9/YvtZ8OGDQCApUuXygpAADBhwgTUqVMH27dvR3p6umz5pEmTFApAADBjxgwYGBjgzJkzZTgqIiIiIiIqLY4EIiK142gAIiIiovIRGBgIAOjcubPCui5dugBAsQWZjIwMXLx4EY6OjgojhkQiETp16gRfX19cvnwZ7du3L7IvkUgEHR0duUJSUdq0aaN0+c2bN1GrVi0EBQWp1E95S05OBgC17Z/eD7wOCOB1QG/xWiCA1wG9pexaSE5OhqmpqbpCkuFIICIiUgsW/4iIiMpfREQEAMDBwUFhXfXq1WFsbCxrU5ioqChIJBKlfeTvu7h+AGDv3r1ITk5WWpQiIiIiIqKKx5FARKR2qt0XSpWdijcA0weElwQRUflLSkoCkDf9mzKmpqayNmXpI3+7wjx+/BiTJ0+GgYEBFi1aVGRbqZCQEKXLpSOE3N3dVeqnvEnv6FTX/un9wOuAAF4H9BavBQJ4HdBbyq6F92EUEMAiEBEREREREZWz+Ph4dOvWDS9evEBAQAAcHR3VHRIRERER0QeJ08ERERERERFpCOnoncJG6SQnJxc6wqckfeRvV1B8fDw6duyIW7duYd26dRg+fLhKsRMRERERUfljEYiIiIiIiEhDFPW8nmfPniElJaXQZ/1I1alTB2KxuNBn/hT13CFpASgsLAy//vorJkyYUNJDICIiIiKicsQiEBEREamFoO4AqNITeBURKfDw8AAAHD9+XGHdsWPH5NoUxsDAAK6urrh37x5iYmLk1gmCgBMnTsDIyAguLi5y6/IXgNauXYuJEyeW5VCIiIiIiKgcsAhEVAnw4eklJ6rgs8avHankeNVUZsIH/Ocr6tAr+r2WiEquY8eOqFOnDnbs2IHr16/LliclJWHJkiXQ1dXFyJEjZcvj4uJw9+5dhanfxo8fDwCYPXs2hHxvgr6+vnjw4AGGDRsGAwMD2fLXr1/j008/RVhYGH755Rd88803FXSERERERERUEtrqDoCIiIiIiIjKh7a2NjZu3IguXbrA3d0dgwcPhomJCfbt24eYmBj89NNPsLe3l7WfPXs2/P39sWXLFnh5ecmWjxo1Crt378bOnTvx8OFDeHh4IDIyEvv370ft2rWxePFiuf327dsX169fR4MGDfD69WvMnz9fIbZvv/0W5ubmFXPgRERERESkFItAREREREREGqRDhw44d+4c5s2bh927dyM7OxtOTk5Yvnw5Bg0apFIfYrEYBw8exLJly7B161asWrUKFhYWGDt2LBYvXgxLS0u59tHR0QCAu3fvYsGCBUr79PLyYhGIiIiIiOgdYxGIiIiIiIhIw7i6uuLIkSPFtvPz84Ofn5/SdXp6epg3bx7mzZtXbD/SIhAREREREb1f+EwgogrGpyUQESnH90ciIiIiIiIioorFIhAREREREREREREREZEGYhGIiIiIiIiIiIiIiIhIA1XqZwKFhobi0qVLSExMRG5ursJ6kUiEH374QQ2RERERUXEEdQdARFRKzEOIiIiIiKiyqJRFoNevX6N3794IDg6GIBT+FRKTLyIiIiIiKi/MQ4iIiIiIqLKplEWgadOm4dy5c/D09MSoUaNga2sLbe1KeShERERERFRJMA8hIiIiIqLKplJmLP/++y9cXV1x8uRJiEQidYdDREREREQfAOYhRERERERU2YjVHUBppKenw93dnYkXERER0QesiNm4iCoE8xAiIiIiIqpsKmURqFmzZoiOjlZ3GETvjKZ/0VAR3+FV+CnjN49UQrxkKjehQt6pKoeirl0N/+eJSAHzECIiIiIiqmwqZRFo3rx5+Pvvv3HhwgV1h0JERKXEoggREVU2zEOIiIiIiKiyqRTPBAoICFBY1r17d3h4eGDYsGFo3rw5TE1NlW47cuTIig6PiMqIN5J/GET8S1MBvCKI6H3HPISIiIiIiCq7SlEE8vLyUpgOS/j/W8j9/Pzg5+endL1IJGLyRURE9J7iYDAiet8xDyEiIiIiosquUhSBtmzZou4QiEqNX3ISERERVU7MQ4iIiIiIqLKrFEWgUaNGqWW/sbGx2LNnDw4fPoy7d+/i2bNnsLCwgJubG7y9vdGqVSuV+gkMDESHDh0KXb9lyxZ4eXmVU9RERERERFQe1JWHEBERERERlZdKUQQqKCAgAM2aNYOzs3OhbW7evImrV6+WaRqGtWvXYvny5ahbty46d+4MS0tLRERE4K+//sJff/2FHTt2YNCgQSr35+HhAU9PT4XlzZo1K3WMRERERET0bryrPISIiIiIiKi8VMoikJeXF+bPn19k8nXw4EHMnTu3TMmXq6srAgMD4eHhIbf87Nmz6NixI7766iv07t0benp6KvXn6emJ+fPnlzoeqpz44HMiIiIizfCu8hAiIiIiIqLyIlZ3ABUlNzcXYnHZDq9v374KBSAAaN++PTp06ICEhASEh4eXaR9ERERERKQ5yiMPISIiIiIiKi+VciSQKq5duwYLC4sK619HRwcAoK2t+imMiIjA6tWrkZ6eDltbW3zyySeoUaNGRYVIVGkI6g6AiIiIqJxUdB5CRERERERUEpWmCPTJJ5/I/e7n54fAwECFdrm5uXjy5Amio6MxcODAConl0aNH+O+//2BtbQ0nJyeVt9uxYwd27Ngh+11bWxuTJk3CihUroKWlVez2bdq0Ubr85s2bqFWrFoKCglSOpbwkJycDgFr2XVlkZ+cgR3hb5ijNucrOzkaOpGx9VLSyXAsxjzKRk5sj+708ji/qQVa595m/v4jISARlPypzn5qmqOvgYVKu3Dk8d+4stMWaPWFi/uO9fv060h4p/rObvw1Q8a/v/PuLi4tDUFBCue9D1feDFy/Sy/11Wp7yx5aRnvvexVeR8h97ZGQkgnKUv989fZpR5N+wIj4n5N/fq/j4D+rvUlkpuw6Sk5NhamqqrpBK5H3KQ4iIiIiIiEqq0hSB8idaIpEI0dHRiI6OVmgnFothYWGBAQMGYPXq/2PvzsObqvI/jn9ulu4tFMoqOxRURBlEFIECKuA66rgg46C4oc5PHUecQRwU3HXUQcUZNxzrLirq6KhTFFkUAWVTQZayl6Xs0D1tkvv7IzRtmqRN9yZ9v55HH3Jzcu73nnNym3PPPec+U+dxlJSUaPz48XI4HHriiSdCGrxp06aNHn/8cV144YXq1q2b8vPztWTJEt1zzz2aMWOGDMPQ008/XeexAuGiPoYBjMgeWwAAAA2kqfRDAAAAAKAmwmYQyO12e/9tsVg0ffp03X///Q0ew4QJE7Ro0SLddNNNGj9+fEif69u3r/r27et9HR8fr4svvlinn366Tj75ZD333HOaPHmy2rZtW2k+S5YsCbi9dIZQWlpaiEdSd0rv6GyMfYcL+4K5kqtsFk9Nyipq4VcynWXfgaZY3rVpC8uLNsiWtc37ui6Ob6OxRbYtmXWap21ehvffqb16KW1wt1rnGWkqawfJO4/Ktnyp9/XQocMUZYvsZyaUbzP9+/fXwG7+ywOVTyPV//e7/P46dOigtLTQZ7SGKtTzwZzdq2Q7uM/7uqmd28qXVUysvcnFV5/KH3uvXr2Udma3gOnmHV4jW/Yu7+uKZVQfvxPKx9a6dWulpQ2ss7xRPwK1g3CZBSQ1jX4IAAAAANRUWF59mz9/vq699toG3afb7db111+vd955R3/4wx/04osv1jrP9u3b6+KLL5bT6dSyZcvqIEoADYXnGKG6aDPhzWzGFWg254MHKmiMfggAAAAA1EbYzAQqb/jw4Q26P7fbreuuu05vvPGGxo0bp/T0dFksdTN+lpKSIknKz8+vk/wAAAAA1I+G7ocAAAAAQG2F5SDQgw8+WGUai8WipKQk9enTRyNGjFB0dHSN9lV+AGjs2LF68803Q3oOUKhKZwB169atzvIEAAAAUPcash8CAAAAAHUhLAeBpk+fLqPcU9/LL1NScbthGEpOTtY//vEPXXPNNdXaT+kScG+88YauuOIKvfXWW5UOAB04cEAHDhxQSkqKd4aPJK1YsUKnnnqqX/pnn31W8+fPV2pqqk477bRqxQYAAACgYTVUPwQAAAAA6kpYDgLNnz9f//jHP/TVV1/pmmuu0ZAhQ9SuXTvt3btXixcv1htvvKHRo0frmmuu0cqVKzVz5kxdf/316tixo84555yQ9/Pggw/q9ddfV0JCgnr37q2HH37YL80ll1yi/v37S5Kef/55PfDAA5o2bZqmT5/uTXPZZZfJbrdr4MCB6tSpk/Lz87V06VKtWrVKLVu2rHJwCQAAAEDja6h+CAAAAADUlbAcBMrMzNTChQu1cuVKHX/88T7vjR8/XnfeeadOP/10/fa3v9XDDz+s3//+9xowYICefvrpanW+tm3bJknKy8vTI488EjBNt27dvINAwdx6663KyMjQokWLdPDgQVksFnXt2lV33nmnJk2apE6dOoUcExCJeOQ40DyZfPkBhJmG6ocAAAAAQF2xNHYANfHss89q7Nixfh2vUscff7zGjh2rGTNmSJJOPPFEXXTRRfrhhx+qtZ/09HSZplnpfxMmTPCmnz59ukzT9JkFJEmTJ0/WN998o127dqmoqEgFBQVat26dZsyYwQAQAAAAECYaqh8CAAAAAHUlLAeBNm3apFatWlWapnXr1tq8ebP3dc+ePZWXl1ffoQEAQmQyBwwAEGbohwAAAAAIN2E5CNSmTRt9+eWXPg9iLc80TX355Zdq3bq1d9vhw4fVokWLhgoR8Cr/kGAERgk1D3wVUBFtAkC4oR8CAAAAINyE5SDQVVddpZ9//lm//e1v9fPPP/u89/PPP+viiy/WL7/8onHjxnm3//DDDzrhhBMaOlQAAADUE54rhYZGPwQAAABAuLE1dgA18cADD2j58uX6/PPP9cUXXyg+Pl5t2rTR/v37lZ+fL9M0lZaWpgceeECSlJ2drW7duunKK69s5MiBmuFu+epjBhYA1D/OtWhu6IcAAAAACDdhORMoNjZWX3/9tV555RWlpaXJbrdrx44dstvtGj58uF555RV98803io2NlSS1b99eH3/8sc8deQAAAABQHfRDAAAAAISbsJwJJEkWi0U33HCDbrjhhsYOBUAzxBJEqC7aTHhrzvXXjA8dCIh+CAAAAIBwEpYzgQAAQPhrzgMrAAAAAAAADSFsZwJJktPp1IYNG3TkyBG5XK6AadLS0ho4KgDVxXVgAAAQTuiHAAAAAAgXYTkIZJqm7r//fs2cOVO5ubmVpg3WKQMAAACA6qAfAgAAACDchOUg0EMPPaRHHnlELVu21DXXXKNOnTrJZgvLQwEAAAAQJuiHAAAAAAg3Ydlj+fe//62uXbtq+fLlat26dWOHA6CWjMYOAECjMPjyAwgz9EMAAAAAhBtLYwdQE9nZ2brkkkvoeAFAGDF5+BMAIMzRDwEAAAAQbsJyEKh79+7Kyclp7DAAAAAANCP0QwAAAACEm7AcBLr11lv13//+V/v27WvsUAAAAAA0E/RDAAAAAISbsHwm0MUXX6xvv/1WZ555pu6//34NGDBASUlJAdN26dKlgaMDAAChYIlAAOGGfggAAACAcBOWg0Ddu3eXYRgyTVPXXXdd0HSGYcjpdDZgZIA/nnveOOq73HmgPaqLNhPemnP9NeNDB/zQDwEAAAAQbsJyEOiaa66R0ZyvxgARhskAAAAgHNAPAQAAABBuwnIQKD09vbFDANDMsYwVqos2E96ac/0140MH/NAPAQAAABBuLI0dAAAAAAAAAAAAAOpeWM4EKpWdna2PPvpI69evV35+vl599VVJ0v79+7V161b169dPsbGxjRwlACCQ5jyzAgAQ3uiHAAAAAAgXYTsI9K9//UuTJk2Sw+GQ5Hn4amnna9++fRo8eLBefPFF3XTTTY0ZJoAQsLJ+88AjFFARbQJAOKIfAgAAACCchOVycJ999pluu+029evXT59++qluvfVWn/f79u2rk08+WZ988knjBAgAAAAg4tAPAQAAABBuwnIm0JNPPqkuXbpo/vz5io+P14oVK/zS9OvXT99++20jRAcAAELBkoAAwg39EAAAAADhJixnAq1evVoXXHCB4uPjg6Y57rjjtHfv3gaMCgAAAEAkox8CAAAAINyE5SCQ2+2W3W6vNM2+ffsUHR3dQBEBwXGjOwAAQGSgHwIAAAAg3ITlIFCfPn0qXWLB6XRq0aJF6tevXwNGBQAAACCS0Q8BAAAAEG7CchDo6quv1qpVq/TAAw/4vedyuXT33Xdry5YtuuaaaxohOgDVxWwpAEDN8BcEDYt+CAAAAIBwY2vsAGri9ttv12effaYHH3xQb7/9tmJiYiRJV155pZYvX65t27Zp9OjRuuGGGxo5UqCuGI0dQNgxKDIAqHeca9Hc0A8BAAAAEG7CciaQ3W5XRkaG7rnnHh08eFBr1qyRaZr68MMPdejQIU2ePFmffvqpDK5MAAAAAKgj9EMAAAAAhJuwnAkkSVFRUXrkkUf08MMPa8OGDTp06JCSkpJ0wgknyGq1NnZ4gBeXAKpGGQHNE9dIAYQj+iEAAAAAwknYDgKVMgxDxx9/fGOHAaCZMU2eQ4Hqoc34o0jCA/UEBEY/BAAAAEA4CMvl4AAAAAAAAAAAAFC5sJgJdNZZZ9Xoc4ZhaN68eTXe765du/TBBx/oiy++0Pr165Wdna1WrVppyJAh+utf/6rTTz895Lzcbrf++c9/6uWXX9amTZuUkJCgc845R4888oh69OhR4xgBAAAA1I/G6ofUhR9//FHTpk3T999/r5KSEvXr10933XWXrrzyypDzcDgceuKJJ/Tmm28qKytLrVq10oUXXqiHH35Ybdu2DfiZt99+W88++6zWrl2rqKgoDRkyRA8++KAGDBhQV4cGAAAAoBrCYhBowYIFNfpcbR/IOnPmTD3xxBPq2bOnRo8erTZt2igzM1OffPKJPvnkE73zzjsaO3ZsSHndfPPNmjVrlvr27as77rhDu3fv1vvvv6+5c+dq6dKlSk1NrVWsAAAAAOpWY/VDamv+/PkaM2aMYmJidNVVVykxMVFz5szR2LFjlZWVpUmTJlWZh9vt1sUXX6yMjAydccYZuuyyy5SZmalZs2Zp3rx5Wrp0qdq0aePzmUceeURTp05V165ddcsttyg3N1fvvfeezjzzTM2bN09Dhgypr0MGAAAAEERYDAK53e5G2e+gQYO0YMECDR8+3Gf7t99+q7PPPlu33nqrLrnkEkVHR1eaz/z58zVr1iylpaXpq6++UlRUlCTp97//vc4//3zddtttysjIqLfjAAAAAFB9jdUPqQ2n06mbbrpJFotFixYtUv/+/SVJ999/vwYNGqR7771Xl19+ubp27VppPq+//royMjI0btw4vf32296BrRdffFG33nqrpk6dqpdeesmbPjMzU9OnT1fv3r31ww8/qEWLFpKkP/7xjzrjjDN00003ac2aNbJYWJEcAAAAaEj8Aq/E7373O78BIEkaNmyYRo4cqcOHD+uXX36pMp9XXnlFkvTQQw95B4Ak6bzzztOIESM0d+5c7dixo+4CB8IMzxwHAACoG9988402b96s3//+994BIElq0aKF7r33XhUXF+v111+vMp/SPsxjjz3mM7Pp5ptvVo8ePfT222+rsLDQu/21116T0+nU3/72N+8AkCT1799f48aN07p16/Tdd9/VwRECAAAAqI6wmAnUFNntdkmSzVZ1ES5YsEDx8fEBlz8YM2aMFixYoIULF2r8+PF1HmdDcbrcyilySpISY2yyWy0qdrqV73AqOT6qik9LpmnqYH6x3KapVnFRMiXlFjkVZbOoxOmWxWKoRaxduUUlslksio2ySpJcblOHC4rVOj7K2zk9mOdQscutDi1iq9xvvsN5LH5T0XaLYuxWud2mdh4uVKuEKCVEB67fohKXHE63WsTaA75f2bEfKSiWaSpouZSWRXJclKyWwEuJFBQ75TYlm8UIGsfRwhJF28qO6VCFcqqpQMfudLmV43ArMcqQaZo6lF+sFrF22ayVjzOX1mdVcopKFGX1HEt5geq/MiUut3KLnGpVoeyLSlw6kOeQxTDUJjFa9iriDiXO0tiS46K0/WC+OraMldNtymJ42kdslFXRNquKSlzafaRQ3VrHyxKkvqursNil3KISxUZZlRgTuI0eKSj2xlDVsQRSVOJSscutpGP5l9al2zSVV2zKNE0dLSyRy20qLsqm2CirzEpG+0rbdKDvXLB6K/2uGJISY+yKstXNfQ15DqdM01Sx063WCcFnepa2davFUGGJSykJ0XI43bIYUlyU/3EczC+W221WWc+5RZ5ys1gMbx3kFJXIbrEov9hZaXs/WlCiXEeJOiXHBXzf4XRVum/TNLX7aJHio6xqEWvXwfxitYqL8sZc/rwSqqISlxwlbiXG2LRpf546tIiRpKBtsyFU1r4Li11yut1B48tzOL11XPFvUum532Y1ZLNY5DJNv/ZQUOxUUYlbVsNQUqyt0vN9KH8PKpPncMpR4lKUzVIn5b0/16H9uQ71bpdQ5fm9Og7lF3t/OwRSeg6Isll0pKA4pDxL60lS0HNLIEcKihVjtyr7aJHat4ipVluvSul3wWWaSoqxhVyG5b93pXnkFTuVEGVTi7jg9ep0uXW0sEStyp0zyrdfRK7SJexGjx7t996YMWMkSQsXLqw0j6KiIi1btkx9+vTxmzFkGIZGjRqll156ScuXL9ewYcNC2m96eroWLlyotLS06h5SWVxbtmjNLTdLkpJGj1LSKP99HXj5ZRVlZkqSWnftrg5T7vG+53a7lZOfp5z5C5Tzxefe7R0fekiWmBiffIp379HRfzytaNPzt+HIwDOU36OX1mbtV7Gz7FzkmvGUlJfrefGbgbJeeJFPPonxSXLNflvm8h89MSQny/GnP/vF7f7lZ5mfzPG+ttx6u4yUFEXZoxUd5fk9YubnyTV9qhyGVGIxZIw5X5ZB/s+pdb3yopS9x/Mitbda3nCr777cbuV+8YnM7771bLBaZb33fr98zO1b5X4jXXa3qWhTst7yfzJ6epYxdziKvOXgevRByeX5jWEMHSbLyHP88oqb/Z7Mdb960nTqJN32ZxUU5fvG9cMymRlflJXBpMky4jy/aUrLwdy3V64nH5MkFVkk16WXy9LvZP8ymDlDOnLE8+Lk/rJd8jslxCX6pCn+4D0VrFjmeZGQKOuf7/bLx/3rrzLnzPbE4HZr/znnq7hVa23a56nzQkehSvLz5f77I97PGGePkeXMM/3z+vcsxR+7+dPo3VvWm/4ol8vlUw7uBQtkfjvf+9p63wM+eURHxcq+K0uufz5XdhzXXi9X927+ZfDEw1JxiWd/ZwyWZdS5MgzDpxxcb/xbJb/8rCKrIbVtK+vN/+cf98rlMj//zPs69u57FZ3iuxRkfvYulTzzVFkZ/PZSWU7p7x/TP5+VcfCQ4t2mjP6/kfXqayVJTpdThUUFnjT/+1z68QfPB2JiZf3LPX752Ldslu2NssFs6x13qbBNG7lcJd5tptMt92Nl5WeMOEeWY+cri2FVfFy8Z38vzJS5ZbOckoq6d5f12uv8y+Dbb2Uu+Nr7evOFl8hmj/G2A0kys3Yo9/kZch/7/WGM/b0svfv4l8GTj0tFhTJMKWHwEFkvudz7Xmk5uD76QFq7xrOxVStZ/+9P/jH9tFr2T+YoyvTs0DrlPhmtWqugqEAul+c6h5mbI/czT5eVwQUXyTJgoPd1aTm4nn5cZna2J4aTTlLJ5f7PjnN/9T+ZS5d4XkTZZZ08VZIUExXrvT5mblgv16wXVWCR3IYhy4QbZHTu4l8GD03z/tuWdpYSzvc9b5aUlCj/tRelLVs8G47rLOv1N/rH9P33MudlKNptym5K1ocflxHtOZeXloO5d5/cL/+zrAwuGyvLiSf65GO12hT15ONSTo4nzemD5b74dyoqLvRJ5/rPx9LPqz0vWraU9fY/a/Mhz/e3za5Dstvtcq9cLve7b0mS8i2GjD96zuXlmQUFcj/9RFlMY86XffAQxcX49uEKn3lSjuzdnhepvWW96mr/Mpj/tfdcHiOLYh5/2uf9/IJ8ubZtkvuNdO82yzUTZHTt7peX+cgDiivxnMstZ50jy3kXqrikRI5y5eB6720pc6PnRfsOst50i08esTFxsiz5Xu7/fOTdVjR5isxY3+tz5oEDcr8ws6wMLrlMln4ny2q1Ky6mLK3zsQdVfPigii0W6eT+sl58qV/crv9+Jq1a7nmRkKiEKffLZvX9rZu7fJlcH75XVgYT/09GO99nG5qOYrn//ogsphTnNmW54LeyjPA8G7J8Obj+PUvaleX5UI8esl59rbcdJG7dJUmK/vY7WebN9eZte/IZ5RXkyix3UcTM2iF3+qtlMf1+vIyevTzpbXbFRnvKwfm3v0rFxSo2TJWcOUSWUef6l8GH70nr1nleHDuXx8XEy2ot68u4l36vnE8+KNvfnZNkJCb5lsGRw3LPfMYTg2kq7orfyzJwkPf90nJw/fNZ6dAhz8a+J8n6uyv8Y/rf54pdulRWGVJcnGwPPCpJPuXg3rhB5ux3ymK64WYZHTuWlZvNrhirXa4pZX+fS0aNkTPA9XXX669JO7Z5XnTp5j2Xly8H97yvFP3N/5Rr9Zw3j3v0URl23/5UcdYO7XuurG12vPFGtRp4mk+aIodDW6bcI3eB5+9WwplnquWlnrZZ4CiSJB3JzdGht99WwerVcmzZougePfxibmiGaVZ2WQ6B7NixQ71791arVq2UlZXl86WqKD8/XwkJCTrppJMCzhqaM2eOLr/8ct1333168MEHK93v4MGDA25fs2aNunTpohdeeKF6B1IHcnJy5DalF9fbtOWo549F10Sr/jIoVo8vK9DOPLd+lxqtc7tXPhD09q9FWrjT84Otd7JVxS5pW47vxcrTO9i1ItupOLs0eVCc2sRZ9OyKQq096NTwTnZdfWKMftxTold+8Xzhzu4SpbHHB7+AuyPHpad/LFShy/MVaBNr0b1nxOnhJQU6WORZ+uNvZ8Spa5Jv/eY43Hp0WaGOFLl1Xb8Ynd6hwgnDZerRpQXane/Wlb2j9fGmYpW4/b9ml/SK1vk9/Mvl3XVFmp9VohNa2XTnqTEyDEO3f50nR4A8JM90vopxLM8u0au/FCkpyqIpp8fq/Q0OLd/r1Ont7brh5JiA+YTiSJFbjy0rVE6xWzf0i9HA9naZpql/LC/UhkNOpXWQoqKi9fWOYvVJtuqugbFBL1b/esCpf64uUrRV6tXSqtX7nd73HjgzXh0SPBfHVmSXaNYvRUqMMjTl9Dglx3i2m6apZ1YUat0hl87qYtdVx/se19xtxfpwo8P7+oVzEvTYskLtyHXptz2jdGFPT9vILTY1aUGeN12C3dBTI+JlCRD3xLllP/Iv7x2t0d3K6u+nfU69+FOh4u2G7jk9Tu+tc+jnA06/PEq1j7Po9gGx+tt3ZZ2+l0cnBk0fqr35bt23uCzPu06N1fGtfX8AzdterNkbHOoQb9HfzohTlNX3WEuPJeHYsbSO9b1QeajQrceWFSivxNTEk2MVbZP+ucpTl7FWt/YXSipXfjbD0LQz4zRzZaH2FZYtq/P82QmKshrKynHpqeWFcrmlO0+NVa/kcj9UTFOPLSvU9hyXLuoRpYt6lX2nS78rktQx3vP9rXgs1bX+kFMzVxZ5v7NjukXpst6BzyOz1zs0b4fvBWm7xZDdIt19Wqw6JVp92owkDWhr0y39fX8AV0xTXlKUoVFdo/TJJoeOnao0uINd1/Xz/x5vOOTU08s9P0z7pdh0+wDf/Ticph5eWqC9BWV1cGZHuyacVJbXcysKteagb7sd2M6miafEatmeEr32S5Faxlh07+mxSooOfgE7p7QDFZOoR5cW6HCRW+UXVLJbDN32mxjN31Hi892vi+9AVVbudeqVnwuVGOVp361iyo5jf4Fbjy8rUJFLurV/jJ5bWdbhibcZ+uNvYvXsikLZLNIFPaL0yaZiRVulv5wWpzZxhh5d6vm7V16szdDdA2PVOcmqHTkuPby0wPue3WKoxG0GrC8p8N+DUK0/5NQ/lpfFf8eAWJ2UEvqF//Lt8rLUaFkt0vsbys6pL41KkGEYeuvXIi3aWXbBpWIdlraFpCTfDkapTzc59N8txeqWZNU9p8f6nXvdpqm//1Do/Y1R0QmtrPrzQN8O84Zj3+PiY9/jKIuhOwbEqHeryo//6+3FPscoSY8Ni/c7B9ZEYYmpR5YWeM+BPVpY9ddB/sdbUfnv3Z2nxuq5FYU6UFTWxiYNjFWfAMfl/dt82KVRXaN0RZ9obT7i0jPLC2WxeD7XJanuBriqEqgd3HrrrUpKStKSJUsaLI7m4oorrtCHH36o5cuX69RTT/V7PzExUcnJyZWuRLB27VqddNJJuvDCC/XZZ5/5vf/000/r7rvv1quvvqrrr79ektSmTRsVFRUpN9f/79qKFSs0cOBAjR8/Xm+88Ual8VfW52kdm6DbrvyXJMk0DCnAV8go95v5rJ1vKO+usgEXl8ul5R8flUzJKH8hJlBepmQtnK8xyxfJ4TL1zMCr9EPHkzRQWTo5p0PZ/kzT+1GzNC/va1OvtYjSLSs/1LAdqyRJu5Naad2pdwQ8Rku5mNzH8lmZtEerDc9F1ITiAr30xSP6+sxzZI0aIlOGzEBlUC4ml+HSaxVujrObDl1z1Agad8WYLHlzNXz5Ej085Aata+O5iHGGe4dOzO1QZRlIUomlRO3WfqjfZG+QJG1r0VEPjrxeVx/1PX8ZpmTIvwwkaVmLPVqrLmqfd0BPfz1DkpQx9HzZ7IMUSMWYimzFejshwSfN1es/VWz7c0MqA0mKOvpffdZysLKS2nt/6w5z7VBqXgefugtWLyWWXJ07z3OBdk2bXnpsyHWKN3I19kjZb7HycVcsA0la3HKv3Adcmv7ty95tb5x3nY4r8l/eMVC95NvzNTuupTfNnT+8o+OKd2vDSXcELQNDvt+XpYk7tcbqezFrVPF2dS0o+15UjLt8TMWWQzr3m5la0ulkPT/Q84zllsZh/e5IQtC4K1pv+1X/99X73td/G/FH9UqQuuT7XtQNVi9HonL0UWxrSdLU72bphANbta1DO23pc0vgMgjQNr9puU/bzOO827od2aWhOqQY9amyDAxJRZZsWbf+pNdPKRsASTH267dHWoZUBpLUetfb6r/RM+j9p9F360Bcss4t2aOOBWWDDpYK57ryVxUOxBzWp9Ft9fg3z6lzzl5J0v/6nyF7sv9F5mAxzW15UDvN9pKkfvsydc/36fpi5DWKNbsHLYPyMR2JytaHcb4DRR2MvTr/cHKVZVBaL+12vK4Tt2zTDRferyKbp+92oSNbbYta++0vUEzZsQd0wTevq2WR5+/XN91OU8ZvztDoI61DKgNJ+rzlEe012+jMnT/p/5Z72uaXZ92oKLNTlWVgytCu+AP6n72DT5obt3wktbqwijIoi6njllf14ADfQf9Lig6olaNFlWUgSQ5t0Pnz35Uk/af3cL1/4mh1M3brrCNlg75Vtc1PWuZq4OYNuvbn/3q3fTTmz2pR3EIVBYppR/w+fW0r+149O/dJbet+nHLbXB5SGZiS5iTn64iZ7JNmbP4BJZaU/Q6trG0WmWt03sI5evuk8/RFr6GSpF7GTqUdaRdSGUjSvqPfatzKed7XV1/yiMYWHFF8SXyVZSBJmxOytdDaWZL06n8fUIyzWEtO6a/C5ItDKgPTMDS7ZZHyzbK+2VnbflCnVj0V5U6ssgwkqdi1Utvyo7SoywDveycoS4OPtg+pDAzT1Ckrn1LrnHzlRcXq5vM9A8dX5+Up2lV2jaWytrk+cY9+UEe9/mnZwPFbZ12sDuZvQioDSXq7hVMOeX4HXbxhga7J/Fr/HTZZVjM66O+/8n/zilO2a+hZA3ySLPt5o4z15c4PRrkyMMu2GaYpmdLr6eOV0K9fo/d7WA6umkpKSjR+/Hg5HA498cQTlQ4ASdLRo0clyWdJhPJKO8Ol6cLRxqPyuTizPdell38u8l4I+yjTEeyjXgvLXUDaeNjlNwAkeS6EOE1TOcWm3lvv0M5cl9Yeu1hZ+vnSASBJfhdnK3rl5yLvAJAk7S906+NMh3cASJJmriz0+9znW4p16NgFzVfL7a/U4l0l2p3vyeP9jcGP/ZNNgd8rvai97pBTWblVr0MfKI6Xfy6Sy5QOO9x661fPAJAkLcsuUUFJzcd9/7OpWIcdbrlMzz4kactRtzYc9tTXoj3S18fKfcNhl7YcDR7/MysLVeI2lVdi+lwElqS315Udz0vHjuWIw9QnmWV1uiPXrXWHPPv9ZkeJqrJyn1M7cj3pP91cls//tvq2k7wSU7/sr3y2RCD/XF0olynlFJv656rCSgeAJCm7wO0zACR5Bldq6731vu3q2QBtePaxi5x78t36bqd/2ZUey9Fi02cgrdScTIeOFptymdILPxXqmRVldbnff3dymqZe+bnIZwCovNfWFKnQaarY7Sm78n7a59L2Y+eDz7b41lXpd0WSdue79f3uqttBVZ5bUeQzaJuxLfh5JNA5psRtqsBpKn2NQ4HusVi5z1mtes4pNjUns2wASJKW7CmRw+mf99PlLvj/EqD9Lcgq8RkAqsjhMv0GgCRp+V6nchxuvfpLkdySDhW59cXW0GZjZGwt1sEKA0CSp5yeXRGgsTSAF38q9J5TPs70PY731juUW2KqxG36DACV+ueqQhUfq+MPNjq87f7tdUVanu30GwCSpEKnqdfWeM5p/65wri5ta78ccGp3nv95p7p/D8p7boXvvgIdT3VUHBzZnlM3z0n577Hv9bYcV8Bz768HXUEHgIJ5vtwAkCQVu03NXOX/97qiiscoSXMq+TteHfN2FPucA7ccdenXA1UfV/nv3f2L830GgCTf73155f82f7XdU8YvrC6Uw22q0GkG/P2CyBFK/6OqvkdN+jBHjx6N6D4PAAAAEK5YC6Ia3G63JkyYoEWLFummm25q8OXbgo0Ylt4tV5ulFWpq0aJFKsktkc3qe+FwV6Fd5VeZqio227yMau13f0mUUvueItsPP/rso2I+le334LwMv6VYjhqJsllzvK8LXP55vL7lR9msh4Lu44eMDbJlbvO+jrJZZDoDXywLFF/5Y+h5wska3LO17Iu+lquk8otF5fMqn8euIt+6GHj6GUqpZImryjy/bolP+aSlpcm5fq9sK1bLeWzKeflpt9369FVan7Z++VSMsaJdBRbv8ZRPl2dNUFqaZ2mFxZsOyPbjCp9Yytts3Srb5o3e162P6yHb2o1+6d/evlw260Gfz7brmqq00zpXGnOvnj2VNqR7wPf2FqpGSyWd9JtT1att7WZCTPn+G1Vc4a1i2ZSPNSalk9LSjg/6/iF3nNLShvm8/+RP38lm9R3AKhWoHUjS7gL/bUOHDvUsu1Tuu+gwfePduWyHbGvWBTyWim0ooU1npaX5L7lQLfMy/P4wBjuPVNaGdxccOyd9M9fvvYr1XN3znyQNGnym3zKQVZ3/vjmyVjbrTp9tHTp0UFpaP0meJadsC74JuL/+AwfJVrpkjKTi6FZKSxsYMK3k+dsgSSVH4mWzHgiarm3btrId2hc05vpQvpxyjXilpZVNJZ+6dL7f96dUTIzdU0YB3t9daFGLDt1kW7cp4GezCz3Hti/A351SvU/qrwFdfO9YC/T3IGTVaMuB+Oy7Z0/Ztmz0eb/78SdpWGobzT+6VrY9Ze2q4j5K20Io36NA596Dq3bK9tPaoHG2bt1KaWm+0/Nd8zL86slVSQyBYil12PQ/B9bEF/t/ls26x2dbhx69lfabwHeHVhZTRYGOq/Rvc/k0BeXKZX9Rw/5uDNQOgs0OAyrr82Rvz/LesWmU+78PQyq9DbPd6YM0oFy7K3E6teLjzz3vl/towJmWhmRLbqnEQadp4/bDcsQmKMZmkc30P497h50D5JMUG62DyR2UWeT5DX0wPnjbD3Srls1mUdKx5eBirG5ltu2pgqhYJUgBZ5v4x+SJoTyraUo5zoA3rATKJzcmUZlte8qSmOTNy1Zo+KXz7C9wUPtaHadMt+d34t7ENkqItqviEZuG3yYvu9WqpKhoRbvjlNm2pyTJYY+p9IJGWVaemCqWQ25Sa4WyRkJpPjmxSTKjYxRjs3if9WstsFTYlwI2S08awxt7dqvjlBQbrVizwqC8YVRaL3arRc6EsjKQJFmC35jqXy+GTznsb9VRpsMIVuy+eRxjs9uUFO1blobLEvJzXt2GRZlte+pAcgdvLHHucr9rqygDSTKjYnzKwB6fIIvh3z8JVi9Gue9FdutOslks2t/Sd6aYD0N+S1vbDENJMWXlYC9JUElRrqJDuHfFlOSyWJWX3M6nPsrKwZAZQokeTGjlLYeYuDglxUbLqHBPlxnk3569eNrDrpQuKorxHH9OfAsF/MUZpF6i7TYlWY8dQ0ILZbbtKZfVJrOSeyJ9YjIsft/NGJctYLz+MXnqZV9CiuxtrYqPjVGUzfPdNIrLz8qsIhvD0LY23RTv8MzYP9KynaLtgc4uwesl1m5VkjVazsSW3jpxWayeH6EB+JaBb5ssdTS+par8tVSuXvYmtfXLwyjy318wJVabN/a8lm2UFButaJf/+aWyvOKibHIktfb5fhpBToqB8rEYvueo7W266VBc/LFzfZCTa4W2GRdll9tS4ZpXQeXnufIxFduilNm2p4qSWntjiXZa/dJVpiihpU8ZJMVGSwX+8QfLp3w5bGnTXXaXU0diWyg66CoC/m0zIdouq1FWDsVJrfxmAwZS+r7DHq3ipJY+9WEvsfilq6xetrfqokMxxSqyR5flk5fnk6yyeGwWixKjfc/3JVExUpD79ALllRBtV/Sx9pDfMkVxAwdKFkNyB//9Vz6nhKREv37Tlj2HdWCD2+dDpe3cNEzvFs8/TFnifWeANRYGgULkdrt1/fXX65133tEf/vAHvfjiiyF9rvRuuGB3vZUujxHsrjkAAAAACFUo/Y/k5OSA71Unj/LpSv9d332etl066cZHzw45fVL8xT6vrRaLbnxkZMifj4k6VzHR0eoiqfWxwczTBl0rR0loM2IlaXJikqSyZ+SUPpco9BiiFeNzwf0iFRYV1SCGMtWP4XzFREfrqnLbCouGViuGlom+zwu4zeVSbkHgm4oCx1C+HDx55RcVqqQktJnghmHovgTfm61crpHViiE25nylLfE8Q6j0glB+0ZBqxdAi4Q/e15PlWaKwOjH8KSZa0fZoSWU3pF5UzXJ4wKcczlGJ06n8woKgn6noDm8MZfIKBsvpCm3mrqccrpMkTT+2rboxxMacp2j7Xd7XV0nKK8ivVgyPeMvhnGrHsHTpUg209dRZI8/y2V7dGFpUaJM1KwdPXZR+P3ML8uRyhTZj2zAMPZGQqPLnqN+VlKigKPQZ5HfGxCrK55ka11UrBqvVokfifAfgiqsZQ1zMhYqy233OUdWNITHuBu/rq6oRw9KlSyVJd4644Fg5nCPpj5Kko3m5IQ22l8XgWw6OkmEqLAp9Vnp87EX6c4XnllcnBpt1lBLiJkkqa0+OEke1YvhzbJzsNpuksqVYqxeDVQlx5S+Yn1PtGO70xlCmejGMVkJcvE97qiqG0nZwxhlnSJLiYy/0ieGqasZgt9sVX/pspL+dE1IMFU2Ki6+wetU51Yzh3LIYjqluDIlxF3ljmHBsW43K4b4x3m2XOBwqKq5pOXjK8ubcnOAfqCDa7v8Yj6suOVdF5weOoWJbkKQ5yxv/eUASg0Ahcbvduu666/TGG29o3LhxSk9PlyWEh9lLUnx8vDp06KCtW7fK5XL5LR+XeeyhpampqXUeNwAAAIDmpbRfkZmZ6fdMoOzsbOXl5WnQoMDPUSnVo0cPWSwWb1+lokB9mNTUVC1ZskTZ2dlq3759lelrwmIYaplY81lkFoulVp+XpNiYGMXG1PwZm8TgYbVaax1DfEysVOECFTFUn91mq3UMvhdtIz+GuOjAbb8plEPFgYTqirLbKwzqEENlSttCoLQVB/mqK9ruP+BaXcTQMDGUtoPKvr/NoRwaIoaY6Io3x1Rfbc+zlcUQSltoLDwTqArlB4DGjh2rN998s8rnAFU0fPhw5efna/HixX7vZWR4lvlojKXcUDPVeC43IljNn6wEIByFerdSJGq+Rw6Ep+HDh0uS5s71X5K0tO9RmiaY2NhYDRo0SBs2bND27dt93jNNU1999ZXi4+M1cGDZ0qB1sV8AAAAAdS+sB4E+/vhjXXnllTr55JPVq1cv7/b169fr73//u3bt2lWr/EuXgHvjjTd0xRVX6K233qp0AOjAgQNav369Dhzwff7BxIkTJUn33XefiovLpsx/+eWXWrBggUaPHq2uXbvWKlYAAAAADaO++yG1cfbZZ6tHjx565513tHr1au/2o0eP6tFHH1VUVJSuueYa7/Y9e/Zo/fr1fku5lfZhpkyZ4jMQ/tJLL2nLli26+uqrFRtbNvvguuuuk81m0yOPPOKT1+rVq/Xuu+/qhBNO0NChQ+v6cAEAAABUISyXg3O73Ro3bpw+/PBDSZ471QoLy9bqTE5O1t/+9je5XC5NmTKlxvt58MEH9frrryshIUG9e/fWww8/7JfmkksuUf/+/SVJzz//vB544AFNmzZN06dP96YZOXKkbrzxRs2aNUsDBgzQBRdcoD179mj27Nlq1aqVZs6cWeMY0fQxcwgAwgPnawBVaah+SG3YbDbNmjVLY8aMUVpamq666iolJiZqzpw52r59u5566il169bNm37KlCl6/fXX9dprr2nChAne7ddee61mz56td999V1u3btXw4cO1adMmffTRR+revbtf36h3796aPn26pk6dqlNOOUWXXXaZcnNz9d5770mSXnnllZCX1AYAAABQd8LyV/iMGTP0wQcf6Oabb9bhw4d19913+7zfrl07DRs2TJ9//nmt9rNt2zZJUl5enh555BE98MADfv+Vv7uuMi+99JKeffZZSdKzzz6rL774Qpdeeql++OEH9e7du1ZxAgAAAKh/DdUPqa2RI0fqu+++05AhQzR79my98MILateund577z1NmjQppDwsFov+85//aPr06dq/f79mzJihxYsX64YbbtCSJUvUpk0bv8/87W9/01tvvaU2bdrohRde0Pvvv69hw4bp+++/15AhQ+r6MAEAAACEICxnAqWnp+u0007Tv/71L0mSEeDW3V69etW685Wenq709PSQ00+fPt1nBlB5FotFd9xxh+64445axQSPxn0+QcPdKm6G+5MYahh+Yx912Jd7HQqn56CES6RhVKRe9RVzYxdFY++/vKrKuKmdl+qjTTS1Y5Tq9/sajucCNFw/pC4MGjRIX375ZZXpKuvzREdHa9q0aZo2bVrI+7366qt19dVXh5weAAAAQP0Ky5lAmzZt0rBhwypN07p1ax08eLCBIgLKNLXlhCpexK9NeIE+azTgoFhtBLpIIzWt+BvjgmBNLro2tTbeLNWgrVRVb/VRr82prTSnY21ITekcXRsN3T4ipdyaIvohAAAAAMJNWA4CxcbG+j24tKLt27erZcuWDRNQMxdJlxm4iAc0LXwnIxvVCyDc0A8BAAAAEG7CchDoN7/5jTIyMlRUVBTw/UOHDul///ufzjjjjAaODAAAAECkoh8CAAAAINyE5SDQHXfcoZ07d+qyyy7Tzp07fd7bvHmzLr30Uh09epTn70S4+lg6i+VTAKD54i9A+OG5Omho9EMAAAAAhBtbYwdQExdffLEmT56sJ554Ql27dlV8fLwkqW3btjp48KBM09R9992ns846q5EjBeoGS2JVH0UGAPWPmyfQ3NAPAQAAABBuwnImkCQ99thjysjI0IUXXqi4uDhZrVa53W6de+65+vLLL/XAAw80dogAAAAAIgz9EAAAAADhJCxnApUaNWqURo0a1dhhoJlhVg4AAEDzRj8EAAAAQLgI25lAaN54BkDoGrOozBru3QxSwQ1V76HshzbY9IRLnYRJmA2iscuiOm2msqR10/YauzSCC3ROro9om+J3uD5DaorHCwAAAACIPGE5E2jHjh0hp+3SpUs9RgL4a2oThSpeZDJqMZUp4Eeb2gEHEeywI21mV0McT4QVWbNR1bNb6qNem9PzYprTsTakyDlHN/CBREy5NT30QwAAAACEm7AcBOrWrVtIF7INw5DT6WyAiNCccF0FACJTbQbJATQP9EMAAAAAhJuwHAS65pprAna+jh49qp9++klbt27V8OHD1a1bt4YPDgBqqFFWBmI5orBU06UWUblgS1ECQCn6IQAAAADCTVgOAqWnpwd9zzRNPf300/r73/+uV199teGCQoPjhu3mjepvHqjnyEb9Agg39EMAAAAAhBtLYwdQ1wzD0N13362+ffvqL3/5S2OHA6CecL8+AABoSuiHAAAAAGiKIm4QqNTAgQP1zTffNHYYiEDMQAIAAEAw9EMAAAAANCUROwi0efNmHsaKamOABwCar1Ae9g4AVaEfAgAAAKApCctnAgXjdru1a9cupaen6z//+Y/OPvvsxg4J9cSUqWbx/O46OMbGfIB8uNZRmIbd7DVmW0fNUGPV0MQKy2wiJ/imEQVAPwQAAABA0xWWg0AWi6XSu3VN01RycrKefvrpBowKzYXRCI8yr80e6/I6XaBjr4/SCBZydQ6l4jkiWJzc+F+5gO2HQquVJnLtvFrCMeZQ1NVh1UU+4VrGdXk6aIpFUJ+DXU3xeFE1+iEAAAAAwk1YDgKlpaUF7HxZLBYlJyfrtNNO03XXXae2bds2QnRo9pr4BfKmHV3oIuU46loTb35oRFW1jXpZCq0ZtUe+e6hMQ7cPmmP9oR8CAAAAINyE5SDQggULGjsERKhwvRMbAAAA9Y9+CAAAAIBwY2nsABD+uPsZjSESx+sYhAQAAAAAAABQl8JyJlCp7OxsffTRR1q/fr3y8/P16quvSpL279+vrVu3ql+/foqNjW3kKBFOQhnQYtALUmQOQjVFfN8iW1Or3sriYZAWQHn0QwAAAACEi7AdBPrXv/6lSZMmyeFwSPI8y6C087Vv3z4NHjxYL774om666abGDBMAAABABKEfAgAAACCchOVycJ999pluu+029evXT59++qluvfVWn/f79u2rk08+WZ988knjBAgAAAAg4tAPAQAAABBuwnIm0JNPPqkuXbpo/vz5io+P14oVK/zS9OvXT99++20jRNf8NMYSOc1lWZ66OMzGLKpwradwjTsSVacuqLfwQ5WFrqmVVVOLB2go9EMAAAAAhJuwnAm0evVqXXDBBYqPjw+a5rjjjtPevXsbMCqUZ0bw1dhwe0ZJXVZFoGM36qFAgsVcvl1Ve69B4jSa0FNJmmLbMgNc6m2CYYaVQGXa1IVjzCGpoxNkXfzNi9ASrpZAxVgff2Oaikj+rRTJ6IcAAAAACDdhOQjkdrtlt9srTbNv3z5FR0c3UESIFHVxrampX66K4OtpUNMa1ELTUlXLqI+WE3atMewCRrho6KYVyYNnjY1+CAAAAIBwE5aDQH369Kl0iQWn06lFixapX79+DRgVGhp30DZv1D4AgN8CaGj0QwAAAACEm7AcBLr66qu1atUqPfDAA37vuVwu3X333dqyZYuuueaaRogOka4xZlpwQ2/1UWZA/eH7hVI0BTQ39EMAAAAAhBtbYwdQE7fffrs+++wzPfjgg3r77bcVExMjSbryyiu1fPlybdu2TaNHj9YNN9zQyJE2Dw31nBgAAACgMdEPAQAAABBuwnImkN1uV0ZGhu655x4dPHhQa9askWma+vDDD3Xo0CFNnjxZn376KQMRAMJKY6xq1JgLKbGKU801dtk19v7rTaQeF4A6Qz8EAAAAQLgJy5lAkhQVFaVHHnlEDz/8sDZs2KBDhw4pKSlJJ5xwgqxWa2OH1+zV9xr9ptk8ZhvVTTE23lXN+txz5Nc+pOotO8b1e0SyJjfw1tTiARoQ/RAAAAAA4SRsB4FKGYah448/vrHDQHPSjEcfAi791/Bh1EjQOMPlAJqQZjD+iuaKtt3kUCVoyuiHAAAAAAgHYbkcHIDIFmwmWVO68by+Z7s1Fc3kMBtUOJZpOMYciuoclllJ6roonqZcxk05tvpWn8fejIsVAAAAANCAwnImUI8ePUJKZxiGNm/eXOP9vPXWW/r222+1YsUK/fLLLyouLtZrr72mCRMmhJzHggULNHLkyKDvVzc/NH1NfZaEESH3VXPxLLCm3v7QeKpqG/XRdprDsp2lmtOxovoaunnQGutPQ/VDAAAAAKCuhOUgkNvtDnix5ejRozpy5IgkqUOHDoqKiqrVfqZOnart27crJSVFHTp00Pbt22uc1/DhwzVixAi/7f379695gGgUXFgBAABonhqqHwIAAAAAdSUsB4G2bdtW6Xt33XWX9u7dq6+++qpW+5k1a5ZSU1PVtWtXPf7445oyZUqN8xoxYoSmT59eq3gAAAAANJ6G6ocAAAAAQF2JuGcCdevWTbNnz9bhw4f1t7/9rVZ5nXPOOeratWsdRQagLjEjCwAANCV12Q8BAAAAgLoScYNAkmS32zVq1Ci9//77jR2KV2Zmpp555hk99thjevPNN7Vr167GDqnOBLoYH67PRoiU5+UAAKqPvwAAaqsp9kMAAAAANG9huRxcKAoKCnTo0KHGDsPrnXfe0TvvvON9bbPZdPvtt+vJJ5+U1WoNKY/BgwcH3L5mzRp16dJFixYtqpNYqyMnJ0cFhZLT5XvprLDIJafL9L6uKjany1mt/RYVubT6p9U+n1u0aJFfPpXtN9A+Dx8+LKfLVWkeB/YX+u23vG3bHD7vF5uGnG5TgQSKr/xnf/75Z7n32FTsKPYpz6ryqmz/i7//XglRNbvUefhwgU/5LFq0SL/sd3r2Z5p++16zdo2iD2wImFdldW5R2fGUT5eTk+Pd/usBZ6X1sGlbsc/7mzIzA6bfX6E+JWlj5kYtcmyrNOYtW7ZokbkzpOMJ1fLly7U3KbTzQTCFhYV+baVi2ZSPNSsrS4sW7Q/6fkFBgd/nc3Ly5XS5AwcQoB0E893i7xRtNSr93m7MKg5azxU/t2NHlhYt2lflfisTKO5g55GqjjHQOUmSVqxYof3l6rkmbef7Jd8rMcr3Po6qzn87dxb5pdmzZ48WLTosSXI4zaCx/Pjjjz7vHTx4sNLza05OjiRp3z7/71d5+/ftq/R7XB/K7y83N9dnnwUFhUHbdrHD5ffdKmW6pc2bN1d6rMHaQ6mfflqtoizfn2WB/h6EqjptuarPb9myxS+/X9askXWfTTt3FVVah6VtIZTvUWaAc++63SWVltvBQ4cqPceVV5PfIvn5+XXSLnfv9v/+bdywUYsKtlY7pooCxffzfv+/kdX5jVTXArWDnJwcJSUlNVgMDamp9UMAAAAANG8RORPo22+/1bvvvqs+ffo0dihq06aNHn/8ca1Zs0Z5eXnau3evPvnkE/Xq1UszZszQX//618YOEeXUxwSmOsmyidyeHnDWV33spy4yrZhHkDybSNGGlYYts8iroUg4ojCd7OmnWodRSeLmPIu0vo88UtpaIJF8bM1ZU+qHAAAAAIAUpjOBzjrrrIDbnU6ndu3a5X1g6/3339+AUQXWt29f9e3b1/s6Pj5eF198sU4//XSdfPLJeu655zR58mS1bdu2yryWLFkScHvpDKG0tLS6CboaFi1apLi8EtmsvneXxkTbVGyWbasqNtu8jGrtNybGrlNOPkW2Vct99lExn8r2G2ifycktZcs9UmkeH+xaJduhfUHfX+HYKFtW2Z29drtVrhLf2UWVxVc+rn4n99Ow1DaK/m6eSszK7wYun1f5POw2i9zOsjvbzzxzsFrGRVWaVzAvb1wmW94Rn30amftl+3ml9w5jm7XstNL3xL5K69s+YF6V1bnFKDue8ukSExOUljZEkmTddEC2n1b4xFLe9iXbZNtUNgspNTVVtsz1funf37lStkO+M2FSU1OVdrr/88DKx9KzZ0+lDe0e0vGE6tSBp+r49rW7Kzpm6XwVuIp9tlUsm/KxdurUSWlpJwZ9Py4uxu/zSWsWy1aYF3D/gdpBMEOHDFVslLXS7232j1mybfw14HsVP9e5c2elpR1f5X4rE6geg51HqqrztLQ02b6Z67d9wKmn6oQOZfVck7YzePCZahXv+z2u6vz3be6vsu3O8tnWoUMHpaX1kyQVFDtlWzgv4P4GnnaabEu/875u3bq10tIGBo2v9G7/Nm0S/L5f5bVp27bS82l9KF9OCYnxSksb6n0d9+MC5TodAT8XHWULeh62WQ317NlTti0bg+430N+o8k45pb8GdW8VNNbSvwehqk5brurzPXv2kG1rps/7J53UV2nHt/NrVxX3UdoWQvkepab2VtrpXXzez/l5t2y//hI0zlatkpWWNihonuXV5LdIXLz/ObAm5h76Rba9u322pfburbSBnasdU0WB4jM3ev42l09Tnd9IdS1QOwjXWUDh1A8BAAAAAClMB4EWLFgQcLthGEpOTtbo0aN11113adSoUQ0bWDW0b99eF198sWbNmqVly5bpoosuauyQEKKqbtxt6nf2Ruod66Zphu2zqOoSRYCaqo9zQ3P6TjafI0VNNPTfXtpj/YmEfggAAACA5iUsB4Hc7iDPoggzKSkpkjzrzQOoHi5wAahrzWnQCkDNREo/BAAAAEDzEZHPBAoXy5YtkyR169atcQMBAAAAAAAAAAARJyxnApXat2+fdu3aJbfbreOOO07t2wd+9khDOHDggA4cOKCUlBTvDB9JWrFihU499VS/9M8++6zmz5+v1NRUnXbaaQ0ZKgAAAIBaaEr9EAAAAACoTNgNAjkcDj377LN65ZVXtGXLFp/3kpOTNX78eP3pT3+qk9k1s2bN0nffeR6E/csvv3i3la4FPnToUN14442SpOeff14PPPCApk2bpunTp3vzuOyyy2S32zVw4EB16tRJ+fn5Wrp0qVatWqWWLVvqrbfektVqrXWsqBumWXUaVguC5HkGEYDmw1Tz/c5zugM8GrIfAgAAAAB1JawGgbKysnTBBRdo7dq1Mk1THTt2VOfOnb3v7d69W88++6zefPNNvffeezrnnHMkSXv27NG3336rK6+8slr7++677/T666/7bFu8eLEWL17sfV06CBTMrbfeqoyMDC1atEgHDx6UxWJR165ddeedd2rSpEnq1KlTtWKCR3O5AF8Xh9mYJRWutdRMmpekyHoGSnO6SB8ptdZczuV1oakVVVOLB6hvDd0PAQAAAIC6EjbPBCopKdH555+vNWvWaNy4cVq3bp127typJUuWaMmSJdq5c6fWrVunq6++WocOHdIll1yibdu2afPmzRo6dKjWr19f7X2mp6fLNM2g/6Wnp3vTTp8+XaZp+swCkqTJkyfrm2++0a5du1RUVKSCggKtW7dOM2bMYAAIYSfQeIHRSJejq3v9MVickTQI0lAoMwANpbH+xgDlNUY/BAAAAADqStjMBHrppZe0du1aTZs2TdOmTQuYpk+fPnrzzTfVu3dvTZs2TVdffbW2bdumAwcOBHwuDyJLXdxRHsq1bS5HNU2mGf5L9TXGnfWNOROjOc3cqWuNXXLMAgHQnNAPAQAAABDOwmYm0Pvvv69evXrp/vvvrzLt1KlTlZqaqiVLlqioqEgZGRm64IILGiBKNCRmI4QmHJdbChZx+e3UfsNo9NYTgRUdhl/JejuPNPZ5vK4Oq06W7gzHhlHHmuLAcL1WS9M7XARBPwQAAABAOAubQaBff/1Vo0ePDumCkWEY3rTLli3TiBEj6j9ANLimesGsyS9d08TDQ+1QvQimqr+f9TEe05zaI/clNI4m+lPAT0O3D9pj3aIfAgAAACCchc0gUF5enlq0aBFy+qSkJNlsNvXq1aseowIaBhdzaoBCA+oNXy8AzQn9EAAAAADhLGwGgdq2batNmzaFnH7z5s1q27ZtPUaE5qqxly8CAABAw6EfAgAAACCchc0g0ODBg/Xll18qOzu7yrTZ2dn6/PPPNXTo0AaIDAAAAECkoh8CAAAAIJyFzSDQLbfcory8PF166aU6cOBA0HQHDx7UpZdeqoKCAt18880NGCEQGBOHGkaYPBYC1UXF1pmqnqPWGM9WaarPdquJCDoU1APaR3ijHwIAAAAgnNkaO4BQjRw5UjfddJNeeeUVnXDCCbr55pt11llnqXPnzpKkrKwszZs3T6+88ooOHDigiRMn8iBWIMJE+ngaA4ZoqlgGE80VTR8S/RAAAAAA4S1sBoEk6V//+peSkpI0Y8YMPfbYY3rsscd83jdNUxaLRXfffbffewAAAABQE/RDAAAAAISrsBoEslqtevLJJzVx4kSlp6dryZIl3rW527dvrzPPPFPXXnutUlNTGzlSoOkIyxVoggQdlsdSDSwXhFA19DJqkbRsW3lmNc4qlRVBXZRPUy7h6pRTrfbTBAuhPmNqqHJF3aAfAgAAACBchdUgUKnU1FQ98sgjjR0GEFBTXzqmqceH2om4Zbsi7HAaU1Vtoz6aTlV5RlJ7DeVQDDXtwR7Un4Zu6gYnz3pDPwQAAABAuLE0dgBAUxLKBcnqXlZpinc2AwD8cdkcAAAAAABEGgaBAESESF2uCgAAAAAAAABqikEgAACAhsBUIwANICcnR3fddZe6du2q6OhodevWTX/5y1+Ul5dX7bwyMjI0fPhwJSYmKikpSSNHjtS8efP80h08eFAvv/yyfvvb36pHjx6Kjo5WSkqKzjvvPGVkZNTFYQEAAACoIQaBUC/qe06G2QD7CKoBL+LVxTE25gSZcJ2cE6Zhg4oLO8zgC11TK6mmUnVNJAygycjPz9fw4cM1Y8YMHX/88frzn/+sPn366KmnntJZZ52loqKikPN66623dO6552rdunWaMGGCrr32Wq1du1ajRo3Shx9+6JP2gw8+0M0336wVK1Zo6NChuuuuu3Teeedp4cKFOvfcc/Xkk0/W9aECAAAACJGtsQMAULWmfPN4U32ue6hhNdHwmzTKDLQBlArlWXq1y79eswcizt///netXr1akydP1uOPP+7dfs899+iJJ57QjBkzNGXKlCrzOXz4sG6//XalpKRo5cqV6tSpkyRp8uTJ+s1vfqNbb71VY8aMUWJioiSpd+/e+vTTT3XBBRfIYim7z3Dq1Kk6/fTT9be//U1XX321OnbsWMdHDAAAAKAqzARCrQW6QMM1GwBAuGHAAUA4M01Ts2bNUkJCgu677z6f9+677z4lJCRo1qxZIeX1wQcf6MiRI7r99tu9A0CS1KlTJ9122206cOCAPv74Y+/2s846SxdddJHPAJAk9enTR2PHjlVJSYm+//77WhwdAAAAgJpiEAiIcOG43FLQiMPwWMJdOLafps4MwwWswi/i0NRV8w41m8rGmPiqNc12Vp8xUeeoa5mZmdq9e7eGDBmi+Ph4n/fi4+M1ZMgQbdmyRVlZWVXmtWDBAknS6NGj/d4bM2aMJGnhwoUhxWW32yVJNhuLUAAAAACNgV/iQDUZVcxzauo3kjf1+FA71C+CaYy20ZzaY3M6VlRfQ7cPZrU1T5mZmZKk1NTUgO+npqYqIyNDmZmZ6ty5c43zKt1WmqYyOTk5+vDDDxUTE6Nhw4ZVmV6SBg8eHHD7mjVr1KVLFy1atCikfOpaTk6OJDXa/tE00A4g0Q5QhrYAiXaAMoHaQk5OjpKSkhorJC9mAiFicEdt8xYJ1d8Ybbgxvzd8Z2uusYuusfdfX2iTAMLZ0aNHJUktWrQI+H5p57M0XU3zqk4+t9xyi/bu3at7771XrVu3rjI9AAAAgLrHTCCErXC5yZW7cYGa4+sT2QxOkADgZ9KkSXI4HCGn/9Of/hR09k9jmjJlit59912de+65uvfee0P+3JIlSwJuL50hlJaWVifxVVfpHZ2NtX80DbQDSLQDlKEtQKIdoEygttAUZgFJDAIB1cY1S0jMGACam7r4yhuGEZYnjzAMGQhrL730kvLz80NOf/nllys1NdU7ayfYDJ3S5SmCzRQqr3xeFWfwhJLPfffdp8cff1xnnXWWPvroI1mt1qoPBAAAAEC9YBAI9aK+rxfV1wWppja+Y9bBgTbutbswvXLIFc+wRK2Fn7o4x9WlpjzI39TKqmlFA0SWvLy8Gn2uqmf1VPXMoIp5LV++XJmZmX6DQFXlc9999+nhhx/WiBEj9Nlnnyk2NjbkYwAAAABQ93gmEICQBVq6qQlfM/UR7OJuU77o21RRZgAAND2pqanq2LGjFi9e7DeTKD8/X4sXL1b37t3VuXPnKvMaPny4JGnu3Ll+72VkZPikKa90AGj48OH6/PPPFRcXV5NDAQAAAFCHGAQCyuHOZgBAfWEAFUB9MgxDN954o/Ly8vTQQw/5vPfQQw8pLy9PN910k8/2goICrV+/Xjt27PDZfuWVV6pFixaaOXOmdu7c6d2+c+dOPf/880pJSdGll17q85n7779fDz/8sIYNG8YAEAAAANCEsBwcai3QNa1Ivs4VdscWQSNblR1KE1spKWxUdVGaYq17ddFWG/o8FKnfrzo7rjrIx+Tb1iQbWn0uw9f0jhaR4K9//av+85//6IknntCqVas0YMAArVy5UnPnztVpp52mO++80yf9Dz/8oJEjR2r48OFasGCBd3tycrKef/55jR8/XgMGDNDYsWMlSbNnz9bBgwc1e/ZsJSYmetOnp6froYceks1m06BBg/Tkk0/6xTZixAiNGDGiPg4bAAAAQCUYBELYaqoXT5r6nd6BlnQLSxFyGHWOckEwjdA2IuZ8E4LmdKxNSX0/K6mucm/o9kFrbL7i4+O1cOFCTZ8+XXPmzNH8+fPVoUMHTZo0SdOmTavW83n+8Ic/KCUlRY8++qhee+01GYahU089VVOnTtU555zjk3bbtm2SJKfTqaeffjpongwCAQAAAA2PQSAgDHBxMYAqrsxRZED94euFUrQFoOlp0aKFZsyYoRkzZlSZdsSIEZUOpp577rk699xzq8xn+vTpmj59enXCBAAAANBAeCYQADRjTXD1JYSAaqsfRj0PaTBgAgAAAAAAGhqDQEA5XKADmhZmwUU26hcAAAAAAKB+MQiEelHfd6k3lwdo18VRNmZJhesskzANu9mr72eDoO5RZ6FraiVF3QEAAAAAEB4YBAIQsoD37DeRG/mrGhgMFmYTCR9AM8DMp+qjxAAAAAAAqB0Ggarw1ltv6eabb9bAgQMVHR0twzCUnp5e7Xzcbrdmzpypfv36KTY2Vm3atNG4ceO0ZcuWug8a9YpreE0E9QAAAAAAAAAAlWIQqApTp07Vyy+/rO3bt6tDhw41zufmm2/WHXfcIdM0dccdd+jcc8/VRx99pNNOO02ZmZl1GDFqgwEeAGi++BsAAAAAAAAiDYNAVZg1a5a2bdum/fv365ZbbqlRHvPnz9esWbOUlpamlStX6oknntCbb76pTz75RIcOHdJtt91Wx1E3Pq6jlaEs6o7PIyga+XEUzeW5VM3lMFGVyGwI1Tmqyh6BE5mlU6ahjq9JlmM9BsVjlQAAAAAADcHW2AE0deecc06t83jllVckSQ899JCioqK828877zyNGDFCc+fO1Y4dO9SlS5da7wv1z6hiWKepP/OhaUeH2qJ+EUxV56762WfzEcqpvzmVR6QI23EaGhsAAAAA4BgGgRrAggULFB8fryFDhvi9N2bMGC1YsEALFy7U+PHjGyG62jlS5NZ3u0pU8WpDTpHT5/VjX6zTofxijenbXlsO5KlP+yTF2Cxyuk1ZajBoku9wac6KnT7b1mfn+qV774cdapsUrRXbD6tTcpzOO6m9vlm/T+1bxATMd/m2w37bjhQUq2VclNxuU+/9mKXPf9nj8/7/1uxRtN2qlPho9e2YpJ2HC33eLyh2BT2OOSt2ymY11CLWrpXbD8tV4bbgj1fu0tb9+TpaWBI0j1I/ZR1R+xYxmvLRL5Wme25epv5wRldl5xRp64F8WQxDe454Yr7kN8fpg+VZOq17K0VZLdqwN1ctYu3aebhQreKjtGK7b/n8+7utfsdb3j8XbFKn5Di1SojSN+v3qWdKvLq0jlOJq2aX1bYeyNebS7apZVyU9uYU+bz3/eaD2nOkSL/p0lJf/LJHry3e5vP+w5+v83l9tKBEK7MOa8HG/X77+fv/NqioxKWB3VqpQ4sYdWgRq91HfI/z5UVbdGrXZC3dckijTmxXo+Op6I73VunmtB7q1TZBhmHI6XIrp6hEZ/ZMUYzdqoJipzL35um45FhlHSrQofxi5RSV6J1lO9S1dbxO7JCkvTmOgHnvz3Uo63CBVu044rP9vR+zlNa7jZLjotS9TbwSon3/LOzLdeiBz9bqilM7a9eRQu3LLQq6j+o6lF+sj1bt8tu+ZtdR9e2YpJwip6Z/utbnvTkrdurMXq2VfbTI73O/7slRxtpspSREafO+fLlNU4UlLh0pKNGVp3XWcS1j9b81e7T9YIHGnd5Fby3drgKHS4UlLv26O0fXntktYJyf/7xHxyXHau3uozqxQ5JWZx0J6fgcTnfA7Q98tlYX9OugoakpirZZQ8qrouXbDumUzi2VV+RUfrHLr32WWrcnR6uzjujEDklyB5h28J/Vu5XvcOq6Id313o9ZQff3vzXZPq+/33xQ32UeUKv4KPVoE68N2bkqKHZpfXaOhqWm6NNNDrWPt+jnXUcrPY5FFb5/+3KKtGFvrqyGoRK3qR2HCtS/U0v9tPOInC63VmUd0cBurbRpb66S46NUUOzS9UO6a19ukYpK3Nq8P0+7jxTq5E4ttS+3SNsO5CvWbtWw3m3ULjFG/1681Wd/WYcKtD/XoW8z92torxQdyCsOGmtRSfBzuST9c/6mSt/fn+sI2iYkafaPWdp5uFAndkhSq/gorduT4/P+17/u1dGCEp10XJKKStzaebhQu48UakN2rs7s1VpJMXYdLiiW25QO5Qf+jj6VsUEpCVEa2K2Vft55VDlFJTqY59BZx7dTvsOphBibNu/PU16Fv+FvLtnul9eCjfvVsWWsNu/P99meuTdXvdomaFHmAf33p93KO1QklymtLN6ohGib4qNt6pESr11HChVj923/m/fl6R9fbVT7pBiNPL6N1u3J8fu7U9GW/fn6eecRtU+K0VvLdmjz/rygaTPWZuuk41poceYB/feXPTq+faIk6boh3bQryN+y/bkOZe7N1cuLtqhNYrRO7tRSOYUlGtS9lbYezFe0zaJ1e3K1aON+jenbXpI0um87bcjOlSEpJsqqfTlFmrd+b8D8TdPU57/sUfeUeMVF2bQhO0e7jhSpZaxd5/VrX+mxl3p50WZ1To5TlM2i3u0S9W3mAT36he/fvDeXbPP73MerdqrEaeq3/Tv61QUAAAAAIHIYpsliFKF6/PHHNWXKFL322muaMGFCSJ/Jz89XQkKCTjrpJP3yi//F+Tlz5ujyyy/XfffdpwcffLDSvAYPHhxw+5o1a9SlSxe98MILIcVUVw4VuXXPwmMXW5r47Jfaeu6sBN3xTfALS6W6Jlq1PbfyC4URq/RUUkdt4eXRnotzE+f6D+41tAl9Y/T2OodK3I1zukyOtuixtDg9tKRAu/KCX0QOZlB7u3454FShs/L428ZadH6PKKWv9R9gCVkdtYORne2an1X14Gd1nNTapjUHnVUnrCNtYy3aV1j9+qor1/aN0eu1qcvaqOPzAcKL1ZC8Y/20hUq1ibVofyOeJ0qV/s2tLzk5nkHNpKQk77Zbb71VSUlJWrJkSb3uG5GjtC/UWG1m0aJFkqS0tLRG2T+aBtoBJNoBytAWINEOUCZQW2js37CleCZQPTt61HMXdIsWLQK+X9oZLk0XTj7fHPyO6UizaGdoF6Ob7QBQhEtfW9RoA0CSdNjh1uJdzhoNAEnSD9klVQ4ASdK+QnftBoDqUF0PAElq0AEgSY06ACSp8QaA0OzVcLJns9QUBoAk6XBR04gDAAAAAFD3WA4ujAQbMSwdUWzoEed3d6yQDM8SQTZrZDel1h26yLZ5a9UJmzGny3OBva7aQml7ts3LqJP8wl2bTt1k21D5clNNQV23A4Qn2gFK0RbCw6mnDVKn5Lh6yz/QHXHlZwUBAAAAAOoPM4HqWekMoGAzfUqXxwg2UwgAAAAAAAAAAKAmGASqZ/Hx8erQoYO2bt0ql8t/qbDMzExJUmpqakOHBgAAAAAAAAAAIhiDQA1g+PDhys/P1+LFi/3ey8jwLHXFw8OaNh5vgMZm0ggBAPWEvzEAAAAAELkYBKpDBw4c0Pr163XgwAGf7RMnTpQk3XfffSouLvZu//LLL7VgwQKNHj1aXbt2bdBY64JhNHYEAAAAAAAAAAAgGJ7SW4VZs2bpu+++kyT98ssv3m0LFiyQJA0dOlQ33nijJOn555/XAw88oGnTpmn69OnePEaOHKkbb7xRs2bN0oABA3TBBRdoz549mj17tlq1aqWZM2c26DEBAAAAAAAAAIDIxyBQFb777ju9/vrrPtsWL17ss7Rb6SBQZV566SX169dPL7/8sp599lklJCTo0ksv1SOPPKKePXvWedwAAAAAAAAAAKB5YxCoCunp6UpPTw8p7fTp031mAJVnsVh0xx136I477qi74NBwWCwfjYwWCAAAAAAAAKC6eCYQaswQDwUCAAAAAAAAAKCpYhAIAMIAQ64AAAAAAAAAqotBIAAIAywHBwAAAAAAAKC6GAQCQsAFeAAAEKl49CEAAAAARC4GgVBzrE8FAAAAAAAAAECTxSAQAIQB7tIGAAAAAAAAUF0MAgEAAAAAAAAAAEQgBoGAEDALAwAARCqTpx8CAAAAQMRiEAg1xiOBAAAAAAAAAABouhgEAoAwwF3aAAAAAAAAAKqLQSAAAAAAAAAAAIAIxCAQEAJmYQAAgEjFsw8BAAAAIHIxCIQaMwyeCgQ0FC7QAQAAAAAAAKguBoEAAAAAAAAAAAAiEINAABAGmHgHAAAAAAAAoLoYBEKNcU0aaDgsBwcAAAAAAACguhgEAgAAAJox7jMAAAAAgMjFIBAAAAAAAAAAAEAEYhAIAAAAAAAAAAAgAjEIhBprTg+q53ksAAAAAAAAAIBwwyAQAAAA0IyZ3O0CAAAAABGLQSAAAAAAAAAAAIAIxCAQAAAAAAAAAABABGIQCAgBi6QAAIBIZTSnBz0CAAAAQDPDIBAAAADQjPFMIAAAAACIXAwCAQAAAAAAAAAARCAGgQAAAAAAAAAAACIQg0Cosea0ejyrpAAAAAAAAAAAwg2DQAAAAEAzxr0uAAAAABC5GAQCAAAAAAAAAACIQAwCAQAAAAAAAAAARCAGgVBjhtF8ngpkslAKGpnJg6kAAAAAAAAAVBODQAAAAEAzxn0GAAAAABC5GAQKwY8//qjzzz9fLVu2VHx8vM444wy9//77IX8+PT1dhmEE/W/BggX1FzyAiNCcZt4BAAAAAAAAqBu2xg6gqZs/f77GjBmjmJgYXXXVVUpMTNScOXM0duxYZWVladKkSSHndfHFF6t///5+27t161Z3AQOISCwHBwAAAAAAAKC6GASqhNPp1E033SSLxaJFixZ5B3Duv/9+DRo0SPfee68uv/xyde3aNaT8LrnkEk2YMKH+Am5gzWpeAtffAQAAAAAAAABhhuXgKvHNN99o8+bN+v3vf+8zg6dFixa69957VVxcrNdff73xAgQAAABqjbtdAAAAACBSMROoEqXP6hk9erTfe2PGjJEkLVy4MOT8Vq1apYMHD8rpdKpbt24655xz1Lp16zqJFUBkYzU4AAAAAAAAANXFIFAlMjMzJUmpqal+77Vv314JCQneNKF47rnnfF7HxsZq2rRpmjx5ckifHzx4cMDta9asUZcuXbRo0aKQY6kLe/cVeq9MO13OBt13Q8vamRXxx1hrddwWStsz5e6xbfu28CiLZnJOQBVoByhFWwgLPy5frt0J1nrLPycnR5J8fqvm5OQoKSmp3vYJAAAAAPBgObhKHD16VJJn+bdAkpKSvGkq0717d82cOVMbN25UQUGBdu7cqTfeeEOtWrXSPffco5kzZ9Zp3AAAAAAAAAAAAMwEagDDhw/X8OHDva+PO+44jR8/XgMGDNDAgQM1ffp03XrrrbLZKq+OJUuWBNxeOkMoLS2t7oIOwSfZq6W9uyRJNmtkN6XOnTrLtmtHY4fRpJXe5V1XbaG0PdvmZdRJfuGuW9dusm3f0thhVKmu2wHCE+0ApWgL4WHgqQOV2i6x3vIvnQFU/rcqs4AAAAAAoGEwE6gSpTOAgs32ycnJCTpLKBR9+/bV0KFDdejQIa1bt67G+QAAAAAAAAAAAFTEIFAlSp8FFOi5P9nZ2crLywv4vKDqSElJkSTl5+fXKh8AAAAAyMnJ0V133aWuXbsqOjpa3bp101/+8hfl5eVVO6+MjAwNHz5ciYmJSkpK0siRIzVv3ryQPjt79mwZhiHDMPTee+9Ve98AAAAA6gaDQJUoXcJt7ty5fu9lZGT4pKkJl8ul5cuXS5K6du1a43waiyGjsUMAAAAAcEx+fr6GDx+uGTNm6Pjjj9ef//xn9enTR0899ZTOOussFRUVhZzXW2+9pXPPPVfr1q3ThAkTdO2112rt2rUaNWqUPvzww0o/m52drf/7v/9TfHx8bQ8JAAAAQC0xCFSJs88+Wz169NA777yj1atXe7cfPXpUjz76qKKionTNNdd4t+/Zs0fr16/3Wz5uxYoVfnm7XC7dc8892rRpk0aOHKkOHTrU23Gg9szGDgDNHm0QAFBf+BsTOf7+979r9erVmjx5sjIyMvT4448rIyNDkydP1o8//qgZM2aElM/hw4d1++23KyUlRStXrtTMmTM1c+ZMrVy5Uq1bt9att96q3NzcoJ+fOHGiEhMTdcstt9TVoQEAAACoIQaBKmGz2TRr1iy53W6lpaVp4sSJmjRpkk455RRt3LhRjz76qLp16+ZNP2XKFJ1wwgn6+OOPffIZOHCgTjnlFI0fP1733HOPJk6cqBNPPFFPPfWUOnXqpFmzZjXwkQEAAACIJKZpatasWUpISNB9993n8959992nhISEkPsdH3zwgY4cOaLbb79dnTp18m7v1KmTbrvtNh04cMCvz1MqPT1dn332mTcWAAAAAI2LQaAqjBw5Ut99952GDBmi2bNn64UXXlC7du303nvvadKkSSHlMWnSJCUmJuqrr77SP/7xD73zzjuKjY3V1KlT9fPPP6tHjx71fBQAAAAAIllmZqZ2796tIUOG+C3DFh8fryFDhmjLli3KysqqMq8FCxZIkkaPHu333pgxYyRJCxcu9HsvKytLd955pyZOnKizzz67BkcBAAAAoK7ZGjuAcDBo0CB9+eWXVaZLT09Xenq63/annnqqHqJqfAaPBAIAAACahMzMTElSampqwPdTU1OVkZGhzMxMde7cucZ5lW4rTVPKNE3dcMMNSkpKqlX/Z/DgwQG3r1mzRl26dNGiRYtqnHdt5OTkSFKj7R9NA+0AEu0AZWgLkGgHKBOoLeTk5CgpKamxQvJiEAgIgWmyWj4aF00QAABUpvS5pC1atAj4fmnns+LzS6ubV7B8XnzxRX311Vf63//+p8TExNADBwAAAFCvGAQCAAAAmjFuNGhaJk2aJIfDEXL6P/3pT0Fn/zSULVu26C9/+Yuuv/5673JxNbVkyZKA20tnCKWlpdUq/5oqvaOzsfaPpoF2AIl2gDK0BUi0A5QJ1BaawiwgiUEgAAAAAGgyXnrpJeXn54ec/vLLL1dqaqp31k6wmT6ly1MEmylUXvm8WrduXWU+N9xwg1q2bKl//OMfIccNAAAAoGFYGjsAhC8eCQQAAADUrby8PJmmGfJ/I0aMkBT8WT2lqnpmUHmV5RUon1WrVmnXrl1q2bKlDMPw/vfAAw9IksaNGyfDMPTMM8+EVggAAAAA6gwzgQAAAAAgzKWmpqpjx45avHix8vPzFR8f730vPz9fixcvVvfu3dW5c+cq8xo+fLjeffddzZ07V2eccYbPexkZGd40pa655hoVFBT45bNy5UqtWrVKI0eOVI8ePXTSSSfV9PAAAAAA1BCDQAAQBkzxwAYAQP3gb0xkMAxDN954ox588EE99NBDevzxx73vPfTQQ8rLy9O9997r85mCggLt2LFDcXFx6tKli3f7lVdeqcmTJ2vmzJm6/vrr1alTJ0nSzp079fzzzyslJUWXXnqpN/1zzz0XMKbp06dr1apVmjhxoq666qq6PFwAAAAAIWIQCADCgMECjAAAoAp//etf9Z///EdPPPGEVq1apQEDBmjlypWaO3euTjvtNN15550+6X/44QeNHDlSw4cP14IFC7zbk5OT9fzzz2v8+PEaMGCAxo4dK0maPXu2Dh48qNmzZysxMbEBjwwAAABATfFMIAAAAKAZ40aDyBEfH6+FCxfqzjvv1Lp16/T0009r/fr1mjRpkubNm6fY2NiQ8/rDH/6gL7/8Uscff7xee+01paen68QTT9TcuXN1xRVX1ONRAAAAAKhLzAQCQmCySgoaGUv1AACAULRo0UIzZszQjBkzqkw7YsQImZX80D333HN17rnn1jiW6dOna/r06TX+PAAAAIDaYyYQAAAA0IxxowEAAAAARC4GgQAgDLBUDwAAAAAAAIDqYhAIAMIAd2kDAAAAAAAAqC4GgYAQcPkdAAAAAAAAABBuGAQCAAAAmjGTu10AAAAAIGIxCAQAAAAAAAAAABCBGARCjRnN6Dn1zehQ0URxlzYAAAAAAACA6mIQCAgB198BAAAAAAAAAOGGQSAAAACgGWO2KQAAAABELgaBACAMcH0OAAAAAAAAQHUxCIQaM3hSDgAAAAAAAAAATRaDQEAIWCYFAAAAAAAAABBuGAQCAAAAAAAAAACIQAwCAQAAAAAAAAAARCAGgVBjBo8EAgAAAAAAAACgyWIQCAiBKR4KhEbGg6kAAAAAAAAAVBODQAAAAEAzxs0uAAAAABC5GAQCAAAAAAAAAACIQAwCocZ4JhAAAAAAAAAAAE0Xg0BACHgcCwAAAAAAAAAg3DAIBABhgHFIAEB94WYXAAAAAIhcDAIBAAAAAAAAAABEIAaBUAs8FAgAAAAAAAAAgKaKQaAQ/Pjjjzr//PPVsmVLxcfH64wzztD7779frTwcDocefPBBpaamKiYmRh07dtTEiRO1b9++eooaAAAAAAAAAAA0Z7bGDqCpmz9/vsaMGaOYmBhdddVVSkxM1Jw5czR27FhlZWVp0qRJVebhdrt18cUXKyMjQ2eccYYuu+wyZWZmatasWZo3b56WLl2qNm3aNMDRAAhXPK8BAAAAAAAAQHUxCFQJp9Opm266SRaLRYsWLVL//v0lSffff78GDRqke++9V5dffrm6du1aaT6vv/66MjIyNG7cOL399tsyDM8yai+++KJuvfVWTZ06VS+99FKtYnVs2aIdEydKklpcdJFaXHSRX5p9M55R0bpfJUnRPXqq3T2T/dLkZMzVkTkfel93eu45WWJifNIU79yl7Acf0FnZeeqbU6g5x5+tzHapfnndvvRNJRQXSJJWtz9eX/Ye7pfmwg3z1W/vRknS0ehE/ev03/ul6bs3U7/d8I339UsDx+pQXEufNLElRbpzyeve11/1HKLlx53kl9d1K+eofd4BSdKmVl30wUnn+aUZsXWZBmetliS5DYueGHaTX5ouR3br6p8/875+++SLtKNlR790k799RRbTLUla0rm/FnQ/3S/NFWu+VK9DOyRJ2Qkpem3AZX5pBu5ao1GbF3tfPzP4WhXafeulVcER3bx8tvf1p33O0toA9fLHZe+ohSNXkvRLu976b5+RfmnO27hQ/bPXS5LyouI084zxfmmO379Fl677yvv6xf6Xan98K580Uc5iTfr+Ne/rb7qfoWWdT/HL65pVn+i43L2SpG0tO+ndky/wSzN023IN27HC+/qxtJv90nQ6mq3xP/3H+/q9k87X1lad/dLd/d2/ZXeXSJJ+OO5kzes52C/N736dqz4HtkqSDsQl65WBV/ql6b/nV52X+a339czT/6C86HifNC2KcvXHH97xvv5v7xH6pX0fv7xu+eE9JRcdlST92qan/nPCOX5pRm/6TqfuXitJKrJFa8aZE/zS9Dq4TVeszfC+fu03v1N2ou8gs9Xt0l+/m+V9vbDbafq+ywC/vK7+6VN1ObpHkrSjRQe9fcpv/dKcuWOlhm/70fv60cET5LJYfdK0z92v61Z95H39Qd8x2tS6m19ef/4+XTFOhyRpRce+mttrqF+ai9d9rRP3b5YkHY5poRcHXeWXpl/2Bl24cYH39b8G/V5HYxJ90iQ48nX7sre8r79MHabVHU70y+um5e8rpeCwJGlDSnd9dOJovzRnb16iQbt+liSVWOx6auj1fmm6H8rSVWu+8L5+85SLtbNFe790UxaV/S34tsup+q7bQL80437+XN2O7JQk7Upspzd+c4lfmtOzftJZW5d6Xz995nUqtkX5pGmTf1A3rig73398wiitb9PDL6+anMufC/B94VweHufyWaderv3xrX3ScC6P/HO5Mf8r7Vg01/u68z//KcNu90lTvG2bsh991Pu6zf/9n2JP8W8HO//8Z7nz8yVJiSNHKnncOL80B155RY4tWxTdw/+cAwAAAACoWwwCVeKbb77R5s2bdd1113kHgCSpRYsWuvfeezVhwgS9/vrruv/++yvN55VXXpEkPfbYY94BIEm6+eab9eSTT+rtt9/WM888o9jY2BrH6s7PV+GKlZKkuFP9LxpKkiMz05vGLCkJmMa5b583jSTJ5fJLYxYWqHDFSrV1utXK5VZicX7AvHod3KGWRTmSPBfEAumQu1/H798iSToYlxwwTWJxvjeNJEW5/GO3ul0+aX7s6H/RUJK6H96lrkd2SfJceAkkJf+wN6+KF7NLxZUU+uwvrqQwYLo+B7bK6vaUYWarwIOFnXL2evOKLXEETNOy8KjP/krzLC/KVeKTZn6Ai5SS1OvQDrU+dlH7QJAyb593wJvXkZikgGkSKtRLjLPYL43FNH3SrGp/QsC8uh7drV4Ht0uSXEbgMk8pOOyTVyAxziKfNPFB6qX3wW2KPjbYsK3lcQHTHFeuXnYm+V+sl6SWhbk++7O5nX5p7C6nT5pvu5waMK8eh7PU7thF7SMVBiwkyTCkdnkHvXnlR8UFzCehuKBCvfi3KaNCvaxp63+BWZK6HN1TZZm3Ljjik8aQ/5SlGKfDJ03pgEJFqQe3K/7Ye8HKvGPuPm9ee4OcV1oU+daL3eVfLza3b70s6dQ/YF7dDu9Sp5xsSZ6L6IG0zS+rF0eQ80p8hXNGjLMoYLryadalBL442rlcvdgCnAskKbnCOcMSYCpZtLPYt156ci7nXO5pFxVxLq+7c7nUNM/l2l/h91+Ac4a7sNAnjevo0YBZFf70k9xHPeeM6J69AqYp3rrNO1AEAAAAAKhfDAJVYsGCBZKk0aP97/weM2aMJGnhwoWV5lFUVKRly5apT58+fjOGDMPQqFGj9NJLL2n58uUaNmxYjWM1JRXaPR32AhUrv8S/Y11gcXrTRFe4UGuapgqcBSowHd40kpRfki9Lhet0DlehSiymTL8LBE7JKLtwUmQ3VejypCmxuSSjwkVP0/fuZ1OmfxpJLmuJT0xui8OTzrSpYhMusZpyWiSntSRgXg6725tXsS3QxVNTJdaycnJZPDF9u2mnT35uS7EK7absLsnmNirkUVYOhXZTVvexMrA6A8bkzy0ZvhfhnBXKwLQ4pNILbAHKodhqyhWkDIoqloHhkEzfi6imTG+aInvV9WIPVJRGiUzDtz05g5RBsc3tt+3tpdtU7C7ypi9fL578K7Yn3zuWJcltBN5fkd2U2yhtm6VpDL9ycBumHDZPuwmUj1+9KMCgqVFSoQyCt02H3VR0ScX25GkPy7bt0ck2Z5X1Yhr+ZSmjRCoXm2m4KqmXYOUQrAwq1ovDk0fFNmkz5Tp2aMHbpimLaQZ5WJ2nHIptZbFXVi9Oi+n/3TSKPfnI8x2qvF4Cl0Og/ZWUq5diW7k0pl2S74Vwh82U2/CcQwLl5ROTJdAXy+VbBlXUS5RTspqBy6H0PObNOWC9BKoN17E2VaZ8TEV297F2IM+5MFA52M2yc3k5geulWDJ9ZzG5DLPCeSxAvZRrmzZ3gPUUDYdfGQSrl2KbqVi/sRHfcqiybVY4BkkyjeKyc7k3BkeQerH6neecFlMl1krKwKdeTHnav2+duiwV/8b6l4FpeMrJakpRzornqLJycNgq/n0pkoxj7fjY30UzwECxp734xuBTBj4xBSkHW7C/LwHqxYzyK4cie1lkZhVt0xrgNFtaDn6/M4KcM9wyZVHF72ZZOfj/9qlYL1apwufdRuDzQfl68TlnlCuHXYcL1FVl56D8knwZFb7nRa5Cn5iKTf+B3BJXiQptbrmPpYsySpRfkq8id5E3X0kqMJzy+/kEAAAAAKgXhul/JR/HXHHFFfrwww+1fPlynXqq/x2fiYmJSk5O1o4dO4LmsXbtWp100km68MIL9dlnn/m9//TTT+vuu+/Wq6++quuv919CqLzBg/2XOZGkNWvWKDnRoq7TPHeNm3a7FOV/sckoKpRcnisX/1gzRIVXlC2J4jbdmpo1VSopkVFcdqXLjIvzTEEoz+3W+Wti1PWHFjJNac7xZ2ldmx6yJM+XpeX33mTxxYWyHLuYUWKxqaj8UkSmIee2e/XbjQt18r5MSdKB2DjNunyrX9w2t0ux5e6AzbfHym0Ych8aIffRIZI8SwhNWvaWFp9ySKuPP6oia5RKrP5jnHElRbIeW9LHbdp1dPf0CoXkUHznx7x3qJsKfPe/1e1WnLNIg39qpQHrW+jNk87X9mNLCFlazZWlhWd5rITiAu8lmmKrXQ5rhYEKd7Qu+6KfUg9nSZL2JKTo1QGjZes6wyeZ3eVUjKusXvLssTKP1Yvr4CiZOYPUuuCIbl3pWdppwakHtPz4YjkD3P3uVy9GCzl33OWT5pztX2vFmfM9IcpQfpT/LLXy9ZK2orW+T7jWsxzcsbgsKf+VNeEnJZSUzfpwWKNUHKBeWuW6NfGTDpKkrS2P09snnSfZjsrW+XlvmihXiaLLzRzIrVAvrgMX6Lhd7TXh5/96t/3zvDjlpvi3qYTiQu+MlWKLXQ6bXaazhVxZt3nTXL7ua7V3ZOrtC3bKZVhUUGHJJsm/XhwHLlGB4zSfNLGtZism9mfv62BtM764SC3zrBr/eSetTemhj48/69hO9svW6WVJnjv0o9ylF1IN5QWol3abh+i67zd5X796ysXa13OhjPgNPukSi8vXi13Fx9qmWZwi1y7P8kzjf/6vuuZka39Lh945d68K7f4zLvzqxR4n177fySwomynQIXe/2ie9rG0dPfsstEUHbJul9dL6SJR6/jxKGT3PLHszepdsHdMV4yyW/VgZuGVRflTgevndgmR13+1pIzMHjtXRmERZ278rI9ZzN7xhmkooN7ugYr2Yjo5y7b5ON6+cozbHZlss6ZmshWeu99tftLNEUe7Sc0ZZvbiyr5JZ2FOS1OPwTv1+7f/08cg92t22SAW2GLks/gMs5evFnt9O+47c4fO+EbNNCSn/ls30XFgP1jajXE5Fu4p18fz26rQvVn8ffK23jq0dXpcRs1MW0634krILxoHqxSzsqts/tXhnb61q10dfnNxR1vbv+aTzrRffc4Zr9zUyHZ110r5NuuTYMn0fjNqtre0sclf4+xKoXoqLe8uV7buc1Hm707X0NM/fDqdhDdg2o10l3nP5pV8fp3+f8Eef963HzZLNtkdx5WZlBauXvtsMXfRtW0nS4k6naH6302TErZe13RxvmtgSR6X14tx1o07bdkBjtizxbnviyhKZ0Yd80llM02fmS2m9mPl95Np3uXf7bT++p/3tsjV38H7/v7HHVKyXo/v+JJX4LimW2H6GbNYD3tf59hi5Dd8yMEwpoaRAvXbEa8yStvq62yAt7XSy572En2Vt4/l9U/5vbLB6GbBsmEZv3Oh9/fDQG2Xt/LwMW9msktK/saUKbNHe2VzuvH5y7/csZzb5+3TZ3U792iNXGacflcPmfzNAjNMhu9u3XpxZt0nOFmUx7VmnvX3fVUGsJ135v7GlytfLCVsSlXfkd/q5Xe+yMkpcIWvK/xRfXCTLscHmYPUS7SzWxI87KL7IpkJbtJ4+tkyfrcs/JKtnHxV/+1Rsm+6cATL2j9aUcsv0zT4jWVtT/c9R5dtm+Xpxbv+z5PacJy8/+LMu379Sfxm5WUU2M8jvP5eMwrJ6OTN6oC7o4bvE4KKcRcrYPcc7pmfabFJ0tNxuT5lYSo/BUaSfH1mnvu1O1pIlSwSEorQv1FhtZtGiRZKktLS0Rtk/mgbaASTaAcrQFiDRDlAmUFto7N+wpZgJVImjx5a5aNGiRcD3k5KSvGlqk0f5dDXlTkqUGR9faRozpuyiXP7llwe+295u9wwiVcZiUdGwoVqWOkxztwVe8kZSwIGDij7tPVyflj5fwiiRTX/3S+O0WP0u+FdUaI/Rw0NvlKXVPFmilgZN53NRzgzc/B2BBmsqcFksyo2K0/96nqkvUgIPzknBl48qb3bfMRWj9EtTYrUFHDgo72BcSz089EZJkqX1l7JYVgZM51cvASYbfN3jdNmillW6v/L18mnqcJk5rfzSmIb/YE0gh2KTvLEHU1xuoCKYnUntffKxxHwasJ0HGjyp6MMTzpFsA2SLeiFomor14rJHSxW+Eg5blEpCKIP8qBjlJSZXWg4OW5Qc8r+gWN7uxDZ6eOgIn22BFmUKpV7ePPlCzz+i9spmnxUwTSj1siexjfa1TZURlVlputJ6yWnZTpvKDwCVU2SLUlEVZVBitemdk86T2SPw0kiSZBpGSGXwUrnnuhjRWbLK/wKrw2aXQ5WXwZbkTp6L3a3fkhG1PWi68jGZ7hbSEf80gS6sV1RstanYatPrJ18ks6hbwDRuwxJSGTwzyPdZbYY2+6UJpV7WtO2lNW09S0NZk1+TYez2SxNqvfyv1xBZo3ZVmqb8ufzf/S/2+25KZefyqqxp20s/DfV/lkx5odTLjx376seOfb2vrcZLFeeCyB1iGTx/2lUy4tfKGvVJ0DSh1EuBLVqGvfL9lZ7LV3Q4QT8OvTR4XgEGJCv6oeNJ+qFt5Z2jUOvliWPP0jESV8tq+zxgmiJbtKqag7uywwmyxbeWbHlB05Svl6XHnSR3dO+A6QINTFfksEVpxulXS67Ay8VJof32cVmsPn8zjKQfAp6jQmmbB/ufqpwThsid9YBMM8hvO4vV57emO7FlwGRmXOW/RyVJ0TGSNfCSgQAAAACAusUgUBgJNmI4ePBg7S/cr6gAs3+CGTZsmKzl7vh2uV2K+jD0z/fs0VO9Txygua95BlxsVptksaji0iRBGYbnMz7bzNA/L8/dpBa/PKoRgxQgBmfAz0fbLHK63HJVmDdXMYaOLWO0u7YxWGzV+rzVYlVUdJSKneXWp6ltXVirG4NFzmN3DHvzqk45VIihU3KsOreJ1kqnVU63u3QCW+UxGJZjcZfPN/QYDAWoC6tnuZ1om0UOZ9VBWC3WADEYoccQsC6sMmQoymZRicutQKtaVRVDckK0DldcEiyIFnFRyvFrk/7LDgXn+R77f7eqUQ4ydHyHltq0r9wF2Rp8LyqWQ+uEaB101a4uqhNDi7ho5RXXpj1YApwfQo8h2maRo1w5tG8Ro+yjRdX7XgQqh5BiKG2ohqzWevheVKtNSjaLzT8GNXQMtS2H2rUHSbJZrZK75jFYDMP/726AGKwWQy7vyaqsLXhjCHgTRqgx1MHf/lrWRcAYqvN3V56/N91SkhRltWjj3rzqxxDoN1C124NNMjx5jDrtRKUN6KTYj2NlloS2SECXLl2U9hvfAb3d63cr6mf/35PFx2aZl/+talScaQQAAAAAqBcMAlWidPZOsFk6OTk5Sk4O/DDm6uRRPl1NpcSk6LNL/ZebC8ZSYakXi2Gp1uejLFGyW+16ebTnLta0tDQVu0aqxO2/Pnww8XbfO0U9zyUaWe0YyqubGM6pZQyDaxWD23Sr0On/HKrqxOBwjZAzwIOtAzFkKK7CXeCeGM4LPQZrlJZ85xmkLJ3yWDcxBJ9lFSgGu6Vuy8HldqnIdXGtYihyDpfLDPRsl+rE8LsmEMPlQT7ha/HixbL3smvkcN/vct3EMDakz0uBy6HQmSa3GcKIYpAYnG6nHK7fB/mEv2hrtGfwoYYxWAyLYm2+s9Y8MYwP8omGiuFsOVwTKv3c4sWLJUlDhgwJGENBybDAz4YJMYYS91kqdlW+hGp5MdYYnxsfqhuD1bAqxuY7w8MTw01NIIZbmkAM/xf0M+XbQl3EYLPYFG31ndniieGOIJ/wF2uL9fsdVDcx/LlxY3CdpWL3pFrFMPvC2SF/vuI5VpIuS71MF/W8yG97xXYgSWf946yQ9wUAAAAAqDkGgSqRmupZSigzM9PvmUDZ2dnKy8vToEGDKs2jR48eslgsyswMvAxS6fbSfdWUYRh+gwkN+XnJc9E1yhr6bCJiCMxiWGodQ7Q12u/iEDFUn9ViVbyldjFUvGAa6THEWALvqymUQ8WBhOqyWWx+gxnEEFhpOwj2Ha44wFZddos94AXo6iCGhomhqrbQEDGEIiJisNr9bgqprtr+3Q0WQ6B2UHEACgAAAABQP+h9VWL4cM+zaubOnev3XkZGhk+aYGJjYzVo0CBt2LBB27f7PgfCNE199dVXio+P18CBA+soagAAAAAAAAAAAAaBKnX22WerR48eeuedd7R69Wrv9qNHj+rRRx9VVFSUrrnmGu/2PXv2aP369X5Lv02cOFGSNGXKFJlm2TIfL730krZs2aKrr75asbG1uzMbAAAAAAAAAACgPAaBKmGz2TRr1iy53W6lpaVp4sSJmjRpkk455RRt3LhRjz76qLp16+ZNP2XKFJ1wwgn6+OOPffK59tprNWbMGL377rs688wzdc899+jyyy/XH//4R3Xv3l0PP/xwAx8ZAAAAAAAAAACIdAwCVWHkyJH67rvvNGTIEM2ePVsvvPCC2rVrp/fee0+TJoX28F2LxaL//Oc/mj59uvbv368ZM2Zo8eLFuuGGG7RkyRK1adOmno8CAAAAAAAAAAA0N7V7unQzMWjQIH355ZdVpktPT1d6enrA96KjozVt2jRNmzatjqMDAAAAAAAAAADwx0wgAAAAAAAAAACACMQgEAAAAAAAAAAAQARiEAgAAAAAAAAAACACMQgEAAAAAAAAAAAQgRgEAgAAAAAAAAAAiEAMAgEAAAAAAAAAAEQgBoEAAAAAAAAAAAAiEINAAAAAAAAAAAAAEYhBIAAAAAAAAAAAgAhkmKZpNnYQqJ127dqpoKBAJ510UoPvOycnR5KUlJTU4PtG00JbgEQ7gAftAKVoC5ACt4M1a9YoLi5Oe/fubaywEGYas88jcT6DB+0AEu0AZWgLkGgHKNOU+z3MBIoAycnJiouLa5R979ixQzt27GiUfaNpoS1Aoh3Ag3aAUrQFSIHbQVxcnJKTkxspIoSjxuzzSJzP4EE7gEQ7QBnaAiTaAco05X4PM4FQKzSOvvoAAKGdSURBVIMHD5YkLVmypJEjQWOjLUCiHcCDdoBStAVItANEBtoxJNoBPGgHKEVbgEQ7QJmm3BaYCQQAAAAAAAAAABCBGAQCAAAAAAAAAACIQAwCAQAAAAAAAAAARCAGgQAAAAAAAAAAACIQg0AAAAAAAAAAAAARyDBN02zsIAAAAAAAAAAAAFC3mAkEAAAAAAAAAAAQgRgEAgAAAAAAAAAAiEAMAgEAAAAAAAAAAEQgBoEAAAAAAAAAAAAiEINAAAAAAAAAAAAAEYhBIAAAAAAAAAAAgAjEIBAAAAAAAAAAAEAEYhAINfLjjz/q/PPPV8uWLRUfH68zzjhD77//fmOHhVrq1q2bDMMI+N+IESP80jscDj344INKTU1VTEyMOnbsqIkTJ2rfvn1B9/H2229r0KBBio+PV3Jysi688EKtXLmyHo8Kwbz11lu6+eabNXDgQEVHR8swDKWnpwdNn5OTo7vuuktdu3ZVdHS0unXrpr/85S/Ky8sLmN7tdmvmzJnq16+fYmNj1aZNG40bN05btmwJuo+MjAwNHz5ciYmJSkpK0siRIzVv3rzaHioqUZ12MH369KDnCMMwtG3btoCfq269bty4UVdeeaVSUlIUGxurU045RS+88IJM06yDI0Ygu3bt0jPPPKPRo0erS5cuioqKUvv27XXZZZdp2bJlAT/DOSHyVLcdcE5Ac0C/J/LQ52le6PNAos8DD/o8kJpvn8dWJ7mgWZk/f77GjBmjmJgYXXXVVUpMTNScOXM0duxYZWVladKkSY0dImqhRYsWuvPOO/22d+vWzee12+3WxRdfrIyMDJ1xxhm67LLLlJmZqVmzZmnevHlaunSp2rRp4/OZRx55RFOnTlXXrl11yy23KDc3V++9957OPPNMzZs3T0OGDKnHI0NFU6dO1fbt25WSkqIOHTpo+/btQdPm5+dr+PDhWr16tUaPHq1x48Zp1apVeuqpp7Rw4UItWrRIMTExPp+5+eabNWvWLPXt21d33HGHdu/erffff19z587V0qVLlZqa6pP+rbfe0vjx49WmTRtNmDBBkjR79myNGjVK77//vi6//PI6LwNUrx2Uuvbaa/3OCZLUsmVLv23Vrddff/1VZ555pgoLC3XllVeqY8eO+vzzz/XHP/5Rv/76q2bOnFmTw0QVZs6cqSeeeEI9e/bU6NGj1aZNG2VmZuqTTz7RJ598onfeeUdjx471puecEJmq2w5KcU5ApKLfE7no8zQf9Hkg0eeBB30eSM24z2MC1VBSUmL27NnTjI6ONletWuXdfuTIEbN3795mVFSUuW3btsYLELXStWtXs2vXriGl/fe//21KMseNG2e63W7v9hdeeMGUZE6cONEn/caNG02bzWb27t3bPHLkiHf7qlWrzOjoaPOEE04wXS5XnRwHQvPVV195v6+PPfaYKcl87bXXAqa9//77TUnm5MmTfbZPnjzZlGQ++uijPtu/+eYbU5KZlpZmOhwO7/YvvvjClGSOHj3aJ/2hQ4fMli1bmikpKWZWVpZ3e1ZWlpmSkmKmpKSYOTk5tTlcBFGddjBt2jRTkjl//vyQ8q5JvaalpZmSzC+++MK7zeFwmMOGDTMlmd9//331DhAhmTNnjrlgwQK/7YsWLTLtdruZnJxsFhUVebdzTohM1W0HnBMQyej3RC76PM0LfR6YJn0eeNDngWk23z4Pg0ColoyMDFOSed111/m9l56ebkoyH3jggUaIDHWhOh2iwYMHm5L8Or9ut9vs0aOHGR8fbxYUFHi3T5kyxZRkvv766355TZgwwZRkLly4sFbxo+Yq+yHsdrvNjh07mgkJCWZeXp7Pe3l5eWZCQoLZo0cPn+3jxo0LWqcjRowwJZnbt2/3bnvppZeCnj+mT58etO2gbtV1h6i69bphwwZTkjly5Ei/9AsWLAj69wf1a/To0aYk88cffzRNk3NCc1WxHZgm5wRENvo9kYs+T/NFnwemSZ8HgdHngWlGdp+HZwKhWhYsWCBJGj16tN97Y8aMkSQtXLiwIUNCHXM4HEpPT9ejjz6q559/PuB6mEVFRVq2bJn69Omjrl27+rxnGIZGjRql/Px8LV++3LudthO+MjMztXv3bg0ZMkTx8fE+78XHx2vIkCHasmWLsrKyvNsXLFjgfa+iQPVN+wgvixYt0hNPPKEnn3xSn3zySdD1kKtbr5WlHzp0qOLj42kHjcBut0uSbDbPKsKcE5qniu2gPM4JiESchyIbfR5UxO8bVMTvm+aFPg+kyO7z8EwgVEtmZqYk+a1hKUnt27dXQkKCNw3CU3Z2tq677jqfbaeddpreffdd9ezZU5K0efNmud3ugO1AKmsfmZmZGjZsmPffCQkJat++faXp0fRU9r0v3Z6RkaHMzEx17txZ+fn52rNnj0466SRZrdaA6cvnW9U+aB9Nz7Rp03xet2zZUs8++6yuueYan+3VrdfK0lutVnXv3l2//vqrnE5nwB9lqHs7duzQ119/rQ4dOqhfv36SOCc0R4HaQXmcExCJ6PdENvo8qIjfN6iI3zfNB30eSJHf52EmEKrl6NGjkjwP0gwkKSnJmwbh57rrrtO8efO0d+9e5efna9WqVRo/frx+/PFHnX322crNzZUUWjson67039VJj6ajuvVd0/YR7DO0j6bjlFNO0b///W9t2bJFhYWF2rp1q2bOnCnDMDRhwgR9+umnPumrW6+htB232+09F6F+lZSUaPz48XI4HHriiSe8nRnOCc1LsHYgcU5AZKPfE7no8yAQft+gFL9vmhf6PJCaR5+HIWUAXhVHtfv376833nhDkvTmm2/qlVde0V133dUYoQFoAi699FKf1926ddNtt92mE044QaNGjdLUqVP129/+tpGiQ11yu92aMGGCFi1apJtuuknjx49v7JDQCKpqB5wTAIQj+jwAKsPvm+aDPg+k5tPnYSYQqqV0VDLYSHROTk7QkUuEr5tvvlmStHjxYkmhtYPy6Ur/XZ30aDqqW981bR/BPkP7aPrOPvts9ezZU7/88ou3vqTq12sobccwDCUmJtZZ7PDndrt1/fXX65133tEf/vAHvfjiiz7vc05oHqpqB5XhnIBIQL+n+aHP07zx+wZV4fdNZKHPA6l59XkYBEK1VLYmZXZ2tvLy8oKul4nwlZKSIknKz8+XJPXo0UMWiyXo2qSB1rNMTU1VXl6esrOzQ0qPpqOqtWgr1l98fLw6dOigrVu3yuVyVZm+qn3QPsJD6XmioKDAu6269VpZepfLpa1bt6p79+6sjV2P3G63rrvuOr3++usaN26c0tPTZbH4/lzknBD5QmkHVeGcgHBHv6f5oc/TvPH7BqHg901koM8Dqfn1eRgEQrUMHz5ckjR37ly/9zIyMnzSIHIsW7ZMkmfKoyTFxsZq0KBB2rBhg7Zv3+6T1jRNffXVV4qPj9fAgQO922k74Ss1NVUdO3bU4sWLvZ3iUvn5+Vq8eLG6d++uzp07e7cPHz7c+15FpfWdlpbmk16ifYSr/Px8rV27VvHx8d4fQVL167Wy9N99953y8/NpB/Wo9EfwG2+8obFjx+rNN98M+lBTzgmRK9R2UBnOCYgEnIeaH/o8zRu/b1AVft9EBvo8kJppn8cEqqGkpMTs0aOHGR0dba5atcq7/ciRI2bv3r3NqKgoc+vWrY0WH2pu3bp1Zn5+fsDt7du3NyWZCxcu9G7/97//bUoyx40bZ7rdbu/2F154wZRkTpw40SefDRs2mDabzezdu7d55MgR7/ZVq1aZ0dHR5gknnGC6XK56ODKE4rHHHjMlma+99lrA9++//35Tkjl58mSf7ZMnTzYlmY8++qjP9m+++caUZKalpZkOh8O7/YsvvjAlmaNHj/ZJf+jQIbNFixZmSkqKmZWV5d2elZVlpqSkmCkpKWZOTk4tjxJVqawd5OTkmBs2bPDbXlBQYI4bN86UZF533XU+79WkXtPS0kxJ5hdffOHd5nA4zGHDhpmSzMWLF9fyKBGIy+Uyr732WlOSecUVV5glJSWVpuecEJmq0w44JyDS0e+JTPR5mjf6PDBN+jzNGX0emGbz7fMYpmmatR9KQnMyf/58jRkzRjExMbrqqquUmJioOXPmaPv27Xrqqac0adKkxg4RNTB9+nT94x//UFpamrp27ar4+Hht3LhRX3zxhUpKSjRlyhQ9+uij3vRut1vnn3++MjIydMYZZ2j48OHatGmTPvroI3Xr1k3Lli1TmzZtfPbxyCOPaOrUqeratasuu+wy5ebm6r333lNxcbHmzZunIUOGNPRhN2uzZs3Sd999J0n65ZdftHLlSg0ZMkS9evWSJA0dOlQ33nijJM8dDkOGDNFPP/2k0aNHa8CAAVq5cqXmzp2r0047TQsXLlRsbKxP/jfddJNmzZqlvn376oILLtCePXs0e/ZsJSQkaMmSJerd+//Zu++4Ksv/j+Pvwx6C4NYcuDVnijhQMM2RWWpa7j3zm1maqzTNVab+LK2vmZrgNkeZlaG5UHPkHrkHau4RiGw5vz/4cuR4WAKGHV7Px4Mect/XfV2f++aGOLzPdd3lzNovXrxYXbt2Vf78+dW+fXtJ0ooVK3T79m2tWLFCb7zxxtO+JDlSeu+DixcvqlSpUqpVq5YqVqyoQoUK6caNG/rtt9905coVValSRVu2bFHevHnN+n/Sr+vx48fl6+uryMhItW/fXoULF9bPP/+s48eP6+2339asWbP+gauS84wbN04ff/yxcuXKpcGDByc71bx169aqXr26JH4mWKsnuQ/4mYCcgNc91ofXPDkPr3kg8ZoHCXjNAykHv+bJdIyEHGnPnj3G5s2bG93d3Y3Ozs5GHx8f4/Lly7O7LGTC1q1bjW+++aaxbNmyRnd3d6OdnZ2xUKFCxlatWhmDgoKSPSYqKso4btw4Y+nSpY0ODg7GQoUKGfv06WO8fv16iuMsXrzY6O3tbXR2djbmzp3b2KJFC+P+/fuf1mkhFYnvfEjpo3v37mbt//77b+O7775rLFasmNHe3t5YvHhx49ChQ1N8Z8rDhw+NX3zxhbFSpUpGR0dHY968eY3t27c3nj17NsWa1q9fb2zQoIHR1dXVmCtXLqO/v79x48aNWXnaeEx674PQ0FDjf/7zH2OtWrWM+fPnN9rZ2Rnd3NyMPj4+xs8++8wYERGR4hhP+nU9efKksV27dsY8efIYHR0djVWqVDF+9dVXZu/ARdZK6z5QMu+W5GeC9XmS+4CfCcgpeN1jXXjNk/PwmgdGI695kIDXPDAac+5rHmYCAQAAAAAAAAAAWCGb7C4AAAAAAAAAAAAAWY8QCAAAAAAAAAAAwAoRAgEAAAAAAAAAAFghQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAAAAAAAWCFCIAAAAAAAAAAAACtECAQA+Ndp2LChDAZDdpeRbkajUTVr1lTTpk0zdPzo0aPl5uamGzduZHFlAAAAAJ5VvO4BAGQFQiAAQLYyGAxP9PFvtHDhQh04cEDjx4/P0PFDhw6VjY2Nxo4dm8WVAQAAAPgn8LonbbzuAYCnw2A0Go3ZXQQAIOcaN26cxbbPP/9coaGhyf7yP27cOF26dEkRERGqUKHCP1Bh5sTHx6t06dIqVqyYgoODM9zP0KFD9cUXX+jcuXMqUaJEFlYIAAAA4GnjdU/68LoHALIeIRAA4Jnj5eWlkJAQWcP/on7++We1bNlSc+fOVZ8+fTLcz8GDB1WjRg2NHj1aEyZMyMIKAQAAAGQHXvdY4nUPAGQ9loMDAPzrJLc2dkBAgAwGgwICArRu3TrVrl1bLi4ueu655zRmzBjFx8dLkgIDA1WtWjU5OzurePHimjp1arJjGI1Gffvtt/L19ZW7u7tcXFzk7e2tb7/99olqXbBggQwGg9q2bWux79q1axo8eLDKli0rZ2dneXh4qGLFihowYIBCQ0PN2r7wwgsqU6aMAgICnmh8AAAAAP9OvO4BAGQFu+wuAACArPT9999rw4YNat26tXx9ffXzzz9r4sSJMhqNyp07tyZOnKhWrVqpYcOGWr16tYYPH66CBQuqW7dupj6MRqM6d+6sZcuWqWzZsurUqZMcHBy0ceNG9e7dW3/++aemTZuWZi1Go1FbtmxR+fLl5enpabYvIiJCvr6+unjxopo2bao2bdooJiZGFy5c0KJFi/T+++8rd+7cZsfUrVtXixYt0unTp1WuXLmsuWAAAAAA/nV43QMASC9CIACAVVm/fr127typWrVqSZI+/vhjlSlTRjNmzJC7u7sOHjyoUqVKSZLef/99lSlTRtOmTTN7MTRv3jwtW7ZMPXv21Jw5c2Rvby9JiomJUbt27TR9+nR17NhRNWvWTLWWEydO6O7du3r55Zct9m3atEkXLlzQu+++qxkzZpjtCw8PN42ZlLe3txYtWqSdO3fyYggAAADIwXjdAwBIL5aDAwBYlS5dupheCEmSm5ubWrZsqYiICL311lumF0KSVKxYMdWvX19//vmn4uLiTNu//PJLubq66quvvjJ7UeLg4KBJkyZJkpYtW5ZmLVeuXJEkFSxYMMU2zs7OFtty5colR0dHi+2J/ST2CwAAACBn4nUPACC9mAkEALAq1atXt9hWuHDhVPc9fPhQN27c0HPPPaeIiAgdPXpURYoU0ZQpUyzax8bGSpJOnjyZZi137tyRJHl4eFjs8/PzU+HChfXpp5/q8OHDatmypfz9/VWxYkWLdb8T5cmTR5J0+/btNMcGAAAAYL143QMASC9CIACAVXF3d7fYZmdnl+a+xBc59+7dk9Fo1F9//aWPP/44xXEePHiQZi2J73aLioqy2Jc7d27t3r1bH330kdatW6dffvlFUsK79EaOHKmBAwdaHBMZGSlJcnFxSXNsAAAAANaL1z0AgPRiOTgAAJJIfMFUs2ZNGY3GFD+2bNmSZl/58+eXJN29ezfZ/cWLF1dAQIBu3bqlgwcPasqUKYqPj9d//vOfZJddSOwnsV8AAAAAyAhe9wBAzkEIBABAEm5ubqpYsaJOnDihv//+O1N9VapUSTY2Njp16lSq7WxsbFS9enUNHz7c9CLoxx9/tGiX2E+VKlUyVRcAAACAnI3XPQCQcxACAQDwmHfeeUcRERHq27dvsssfXLhwQRcvXkyzHw8PD1WtWlX79u1TfHy82b7jx4/rxo0bFsckbnNycrLYt2fPHtnZ2alevXrpPBMAAAAASB6vewAgZ+CZQAAAPKZ///7avXu3AgMDtXPnTr300ksqUqSIbty4oZMnT2rPnj1aunSpvLy80uyrTZs2Gjt2rHbv3m32Imbjxo0aNmyYfH19Va5cOeXNm1fnz5/Xjz/+KCcnJ/3nP/8x6yc8PFy7d+9WkyZN5OrqmtWnDAAAACCH4XUPAOQMzAQCAOAxBoNBAQEBWrFihSpVqqSffvpJ//d//6eNGzfKyclJ06ZN00svvZSuvvr06SM7OzstXrzYbHuzZs30n//8R2FhYVqzZo1mzJihffv2qX379tq/f7+8vb3N2q9evVqRkZHq379/lp0nAAAAgJyL1z0AkDMYjEajMbuLAADAmnXt2lU///yzQkJC5ObmlqE+GjRooBs3bujEiROytbXN4goBAAAAIHN43QMAzyZmAgEA8JRNnDhRkZGRmjVrVoaO37Rpk3bs2KEpU6bwQggAAADAM4nXPQDwbCIEAgDgKStRooQCAwMz/G640NBQTZs2TW3atMniygAAAAAga/C6BwCeTSwHBwAAAAAAAAAAYIWYCQQAAAAAAAAAAGCFCIEAAAAAAAAAAACsECEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFaIEAgAAAAAAAAAAMAKEQIBAAAAAAAAAABYIUIgAAAAAAAAAAAAK0QIBAAAAAAAAAAAYIUIgQAAAAAAAAAAAKwQIRAAAAAAAAAAAIAVIgQCAAAAAAAAAACwQoRAAAAAAAAAAAAAVogQCAAAAAAAAAAAwAoRAgEAAAAAAAAAAFghQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAJ6yhg0bymAwmH3Y2trKw8NDPj4++vjjj3Xv3r109bVlyxZTHy+99FKa7ceNG2c25uXLl1NtP3bsWLM6r1+/nq66JGnr1q2m4y5evJiuury8vNLdP5Do6tWr+u9//6t27dqpdOnScnJykouLi8qXL6+BAwfq1KlT2V0iAAAAAADAM8EuuwsAgJyiWLFiKl68uCQpNjZWly5d0h9//KE//vhD33zzjbZt26YyZcqk2se3335r+vfmzZsVEhKiEiVKpGv8+Ph4BQYGavTo0cnuNxqNCgwMTOfZANmndu3aunLliiTJw8NDzz//vMLDw3Xu3DmdPn1a3377rebPn6/OnTtnc6UAAAAAAADZi5lAAPAP6dWrl3bs2KEdO3Zoz549unbtmjZs2CBPT09dvXpV/fv3T/X4sLAwrV69WpLk6ekpo9GoBQsWpGvs8uXLy2AwKCAgIMU2iaFSxYoV031OQHZwcHBQ3759tWfPHt25c0cHDhzQ6dOndf78eTVq1EjR0dHq0aOH/vzzz+wuFQAAAAAAIFsRAgFANmrSpIkmTpwoKWGpt5s3b6bYdtmyZYqMjFTx4sU1btw4SVJAQICMRmOa43h5ecnf31/nzp1TcHBwsm0SA6WePXs+4VkA/6w9e/bom2++kY+Pj2xsHv0qU7x4ca1evVr58uVTXFyc5s2bl41VAgAAAAAAZD9CIADIZvXq1ZOUsBzbhQsXUmyXuBRc165d1blzZzk4OCgkJESbNm1K1ziJ4U5ys4HCwsK0Zs0a5cmTR6+99toTnkHWun79uoYMGaLnn39eLi4ucnJy0nPPPad69epp9OjRunHjhln7K1eu6IsvvlDz5s1VunRpOTs7y93dXTVr1tTEiRN1//79FMeKj4/X7NmzVaNGDbm4uChfvnx65ZVXtHPnTl28eNH0jKOUbNmyRW+88Yaee+45OTg4KG/evGrWrJnWrl2bZdfjn3LgwAF17txZJUqUkKOjo3LlyiUvLy81b95c06dPtwgbkz7/ae/evWrXrp0KFSokW1tbjRs3ThMmTJDBYFDTpk1THbdjx44yGAx6++23011rvnz5Utzn4eFh+p46ceJEuvsEAAAAAACwRoRAAJDNIiIiTP92dXVNts3x48e1d+9eSVK3bt2UN29etWzZUpL5c4JS065dO7m5uWnlypV68OCB2b7ly5crMjJSnTp1kqOjY0ZOI0tcuXJFNWrU0IwZM3TmzBmVKFFCVatWlY2Njfbu3atJkybp6NGjZsd8/vnnevfddxUcHCyj0agqVaoof/78Onz4sMaMGaM6dero3r17FmMZjUZ16tRJAwcO1MGDB5U3b16VLFlSO3fulL+/v3744YcU6zQajXrnnXfUqFEjrVq1SpGRkapcubLs7e21YcMGtW7dWoMGDcrqy/PU/Prrr6pTp46WLl2qu3fvqly5cipXrpwiIiIUFBSk999/Xw8fPkz22NWrV8vX11dBQUEqWrSoypQpI4PBoK5du8pgMGjTpk26evVqsseGhYWZArNu3bpl2flERkZKSvn7CQAAAAAAIKcgBAKAbPb9999Lktzd3VW6dOlk2yQGPXXr1lW5cuUkSd27dzcd//fff6c5jouLi958802Fh4dr5cqVZvuelaXgpk2bpmvXrqlx48a6evWqTpw4ob179+ry5cu6e/euFixYoKJFi5od8/LLL2vr1q26f/++zp8/r7179+rcuXO6cOGCXnvtNf35558aNWqUxVizZ8/WihUr5ODgoOXLl+vy5cv6448/dP36dQ0YMEDDhw9Psc6pU6dq1qxZKlq0qNatW6e7d+/qwIEDun79un799VcVKFBAX375pRYtWpTl1+hpGDlypGJjYzV8+HDdvHlTR48e1YEDB3Tz5k2FhIRoypQpZsuuJTVixAgNHjxYt27d0r59+3Tq1CkNHz5cXl5eatCggeLj47V48eJkj00M0CpUqCAfH58sOZerV69q27ZtkiR/f/8s6RMAAAAAAODfihAIALJBXFyczp07p9GjR2vGjBmSpGHDhsnZ2dmibWxsrOmP6InBjyS1aNFCBQoUUFRUlJYuXZqucRNDnsTQR5JOnjyp3bt3q2rVqqpRo0aGzykrnDx5UpI0aNAg5c+f32yfu7u7evTooQoVKphtb9y4sfz9/WVra2u2vVixYlq2bJns7e21ZMkSs5ksRqNRU6dOlSSNGTNG7du3N+1zcnLSrFmzVLNmzWRrvHfvniZMmCBbW1t9//33phlZiZo1a6bZs2dLkj755JMnOf1sk3jdP/jgA4t7sHjx4ho+fHiKIVDjxo01bdo0OTk5mbYl9pE4uyelMGzhwoVm7bLCwIEDFRMTo8KFC6tXr15Z1i8AAAAAAMC/ESEQAPxDPv74Y9NzVOzt7VWmTBlNmjRJnp6e+uyzzzR69Ohkj/v555918+ZNOTo6moUVdnZ26tSpkyTzUCc1vr6+Klu2rLZv367z58+bHfss/MG8RIkSkhJmiMTExKT7uLCwMM2dO1c9e/ZUs2bN1KBBA9WvX19NmzaVjY2NwsPDdebMGVP7kydP6uLFi5KkPn36WPRnMBjUt2/fZMf65ZdfFB4eLm9vb3l7eyfb5tVXX5W9vb1OnDiha9eupfs8skvidU9vmJhU7969U9z3xhtvyNnZWceOHdOBAwfM9oWEhCg4OFg2Njbq2rXrE4+bnAkTJmjt2rUyGAwKCAhgOTgAAAAAAJDj2WV3AQCQUxQrVkzFixeXlBBanD17VpGRkfLw8NCLL76Y4nGJS8G1atVKHh4eZvt69Oihzz//XPv27dOxY8dUuXLlNOvo0aOHPvzwQwUEBGjs2LFatGiR7O3t1blz54yfXBYZPHiwFi5cqMWLF2v9+vVq2rSp6tWrp/r166tatWoyGAwWxwQHB+uNN97QzZs3U+37zp07pn+fOnVKklSwYEEVKlQo2fYvvPBCstsPHz4sSbpw4YLq16+f4niJtV6+fFmFCxdOtTZJqfaVUatWrUrx/JIaMWKEevfurYEDB2r69Olq0qSJ6tatK39/f1NAlJJKlSqluM/d3V2tWrXS8uXLtXDhQrOZZosXL5bRaFSjRo0slvjLiK+//lofffSRJGnWrFlq2rRppvsEAAAAAAD4tyMEAoB/SK9evTRu3DjT53///beGDh2qb7/9Vk2bNtWhQ4dMIVGi69eva/369ZKSXzKrWrVqqlatmg4fPqz58+eblpZLTbdu3TRmzBgFBgaqVq1aunbtml5//XXly5cvU+eXdDm2pEuvJScuLk5SwmympJ5//nnt3r1bH3/8sX799VctW7ZMy5Ytk5QwW2XUqFHq37+/qX1YWJjatWunW7duqXHjxho5cqSqVq0qT09P2dvbS0pYzuzy5cuKjY01HRceHi5JcnNzS7HGlPbdu3dPknTz5s00gydJioiISLONJO3cuTNd7Z5EVFRUutr16tVLnp6emjZtmnbv3q2vv/5aX3/9tSSpdu3a+vTTT9WwYcNkj01rtk337t21fPlyLVu2TNOmTTN9zROXiEu6xKGUchiWWqA1f/58DRw4UJI0ffp0/ec//0m1JgAAAAAAgJyCEAgAsomHh4fmzp2rkydP6vfff9fAgQP1008/mbVZuHChKTB5/Nkzj1u8eLE+++wzU/iRkqJFi6pJkyYKCgrSO++8I+nRs4IyI+kspcSgJCWJ+x+f2SQlBFtr1qxRTEyM9u3bpx07dujHH3/Uzp07NWDAAMXHx+utt96SlLA0261bt1SsWDGtW7fO4nk2RqMx2Vpy5colSbp//36KNaa0L/HYbt26KTAwMNXzfBJGozHL+sqINm3aqE2bNgoNDdXvv/+u4OBgrVy5Unv27FGzZs20d+9eVatW7Yn7bdKkiQoXLqxr167p119/VcuWLbV3716dOnVKuXLl0uuvv27WPqUwLKVAa+HCherXr5+MRqOmTJmiIUOGPHGNAAAAAAAA1opnAgFANrKxsdHnn38uKeHZP1u3bjXbn/i8Hnd3dxUsWDDFDxsbG92+fVs//vhjusbt0aOHJOnixYsqVKiQmjdvnulzKV26tCmAOnToUKptE/dXrFgxxTYODg6qV6+ehg8frh07duj999+XJP33v/81tblw4YIkqVatWhYBkCQdO3bMNOsnqfLly0uSbty4oRs3bqRa4+OqVKkiSTpy5EiKtf+b5c6dWy+//LI++eQTnTx5UnXq1FFMTIzmzZuXof5sbW1Nz65auHChpEezgNq2bWsxk8hoNCb74eXlZdH30qVL1bNnT8XHx2vy5MkaPnx4hmoEAAAAAACwVoRAAJDNatWqZZrlM3bsWNP233//XSdPnpQkbd26VdevX0/xo1WrVpIePT8oLa1bt9bLL79sWkLt8WXZMsLFxcW0ZFhAQECK7U6cOKHdu3dLklq0aJHu/n19fSVJf/31l9mYknTt2rVkj5k6dWqy2ytUqGAKFebPn59sm5RCj5YtW8rZ2VmHDh3Sxo0b01X7v5WdnZ1q164tyfy6P6nEpQzXrVunW7duafny5WbbM+K7775Tt27dFB8frwkTJmjUqFEZ7gsAAAAAAMBaEQIBwDMgMfwJDg7W5s2bJT0KdKpVq6YXXngh1eMTl3MLCgrS1atX0xzPyclJv/zyi3777TcNHjw4M6Wb+eijj2Rra6udO3eqb9++unv3rtn+ffv2qU2bNoqPj1flypX1xhtvmO3v16+fFi1apL///tts+/Xr103PO6pVq5Zpu5+fnyRp165d+uabb0zbY2JiNGbMGC1ZskQODg4WdRoMBtOskfHjx2vVqlWmfdHR0Ro8eLD++OOPZM+xQIECGj16tCTpjTfeMFuyL9Hdu3e1cOFCDRs2LNk+niVhYWF64403FBQUpJiYGLN9+/fv14oVKySZX/cnVbVqVVWrVk1RUVHq3bu3bt++reLFi+vFF1/MUH9r165V586d9fDhQ3388cemrwcAAAAAAADMEQIBwDPA29tbr7zyiiRp3LhxevDggb777jtJUq9evdI8/uWXX1ahQoX08OHDLH1OzZOqX7++5syZI3t7e82bN08FCxZUlSpVVKdOHRUvXly1atXSqVOnVK5cOf3www8WM5D27t2rbt26KU+ePCpTpozq1KmjihUrqlixYgoODlaBAgVMy+dJ0gsvvKCuXbtKkvr376/nnntOtWrVUoECBTRx4kSNHz9ehQsXTrbWAQMGqH379oqOjtYbb7yh4sWLy8fHRwULFtRXX32lKVOmSEpYsu9xo0aN0rBhwxQaGqru3bvL09NTNWvWVO3ateXl5aV8+fKpe/fuKQZJz5L4+HitWrVKzZs3l5ubmypVqqTatWurZMmS8vb21vXr11W7du1Mh4VJZwNJUpcuXWQwGDLU15tvvqm4uDg5Ojpqw4YNql+/frIfj4eMAAAAAAAAOQ0hEAA8I8aNGydJ2r59u1atWqX79+/LwcFBnTt3TvNYOzs70x/ZE58jlF169+6to0ePatCgQapQoYJCQkK0f/9+RUZG6sUXX9TMmTN18OBBlS5d2uLYzz//XEOHDlWtWrUUERGhAwcO6PLly3r++ec1cuRIHTt2zOI5QgsWLNCUKVNUvnx53bp1S+fOnVONGjX0/fff68MPP0yxToPBoKVLl+q///2vqlWrplu3buns2bOqU6eOtmzZoiZNmkhKeB5Tcsd+9tln2rt3r3r27KmCBQvqzz//1MGDBxUbG6tmzZpp1qxZWrx4cSav5tPn5uamJUuWqHfv3ipXrpxu3Lih/fv3KzQ0VA0aNNCsWbMUHBxsWnovozp37mwW+mVmKbjEGUvR0dHauXNnih//hhAOAAAAAADgaTIYjUZjdhcBAMCzZuXKlXrzzTf1wgsv6MCBA9ldDgAAAAAAAPDEmAkEAEAy5s2bJ+nRc4cAAAAAAACAfxtCIABAjvXZZ5/p4MGDZttCQ0M1aNAgbdiwQfb29urfv382VQcAAAAAAABkDsvBAQByLG9vb+3fv18FChSQl5eXoqKidPLkScXExMjGxkZfffWVBgwYkN1lAgAAAAAAABlCCAQAyLG+++47LV++XAcOHNCdO3cUExOjAgUKqH79+nr33XdVu3bt7C4RAAAAAAAAyDBCIAAAAAAAAAAAACvEM4EAAAAAAAAAAACsECEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFbILrsLQOZVqFBB9+7dU6lSpbK7FAAAACBN58+fl6enp06ePJndpQAAAACAVSMEsgL37t1TREREtowdFhYmSXJ3d8+W8fHs4F6AxH2ABNwHSMS9ACn5+yC7fncFAAAAgJyGEMgKJM4A2rVr1z8+dnBwsCTJz8/vHx8bzxbuBUjcB0jAfYBE3AuQkr8P6tatm13lAAAAAECOwjOBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAAAAAAAWCG77C4AAAAgu8THx+vmzZsKCwtTbGys4uPjs7skq+Ls7CxJOnr0aDZXgqxmY2Mje3t7ubu7q0CBArKx4b1lAAAAAPAsIgQCAAA5UlRUlC5cuKDY2FjTNoPBkI0VWR9HR8fsLgFPycOHD/Xw4UNFRUXp3r17KlmypJycnLK7LAAAAADAYwiBAABAjnTz5k3FxsbKxcVFRYoUkZOTE7MZslh0dLQkwiBrFB8fr6ioKF29elURERG6efOmihcvnt1lAQAAAAAew186AABAjhQWFiZJ8vLykouLCwEQ8ARsbGzk4uIiLy8vSY++nwAAAAAAzxb+2gEAAHIko9Eog8EgOzsmRgMZZWdnJ4PBIKPRmN2lAAAAAACSQQgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAeErmzp2ratWqydnZWfnz51enTp0UEhLyRH3cuXNHb731looUKSJHR0eVL19eU6ZMUVxcXLLtjxw5oldffVWenp5ydXVVnTp1tGbNmhT7X7NmjerUqSNXV1d5enrq1Vdf1ZEjR56oRgAAAADAs4kQCAAAAHgKxowZo379+snNzU2ff/65Bg8erA0bNqhu3bq6cuVKuvq4f/++/Pz8NHfuXLVr105fffWVateurZEjR6pnz54W7Q8fPixfX1/t2rVLQ4cO1fTp02VnZ6e2bdtq/vz5Fu3nz5+vtm3b6sGDB5oyZYo+/PBDHTlyRL6+vjp8+HCmrwEAAAAAIHvZZXcBAAAAgLU5ffq0PvnkE9WoUUNbt26VnV3Cr93NmzeXj4+PPvjgAy1cuDDNfqZOnao///xT06dP15AhQyRJffr0Ue7cufXll1+qZ8+eatSokan9oEGD9ODBA23ZskXe3t6SpN69e6t27doaMmSI2rZtKw8PD0nSvXv3NGTIEBUtWlQ7d+6Uu7u7JOnNN9/U888/r0GDBik4ODgrLwsAAAAA4B/GTCAAAIAU3F2yROdatjT7iEllKa/Ya9cs2t9ZEJDqGH8NG27WPqRrt1Tbh/36q8UYEQcPZuT0UhUQECCDwaDNmzfrs88+U9myZeXk5KSKFStq2bJlkqSrV6+qS5cuyp8/v5ydndW0aVOdPXs22f4CAwNVt25d5cqVSy4uLqpZs6YCAgIs2m3YsEEdO3ZU6dKl5ezsLHd3d/n5+WndunUWbXv06CGDwaD79+/rvffeMy2XVrlyZX333XdZej2e1NKlS/Xw4UO98847pgBIkry9veXn56dVq1YpMjIyzX4WLlwoFxcXvfXWW2bbhw4datqf6OLFi9q+fbv8/f1NAZAk2dvb65133lFYWJh++OEH0/a1a9cqLCxMffr0MQVAklS8eHG1a9dO27dv18WLF5/01AEAAAAAzxBmAgEAAKTg4d17ijl7zmybMSYmxfbGuDiL9g/v3E51jNi//jI7Jj5/WOo1hYZZ1pSOMCGjRo0apfDwcPXu3VvOzs765ptv1LlzZ9na2mr48OGqV6+exo8fr5CQEH3++edq3bq1jhw5IhubR+816t+/v7755hu98sormjBhguzt7bV+/Xr17NlTZ86c0aRJk0xtAwICdOPGDXXp0kVFixbVrVu3FBgYqNdee03Lly9X+/btLWps1qyZXFxcNHz4cD18+FD//e9/1b59e5UsWVK1atVK8xzDw8MVFRWV7muSL1++NNvs2bNHklSvXj2LffXq1dO2bdt09OhR+fj4pNjHjRs3FBISonr16snZ2dlsn5eXlwoXLqy9e/eme0xJ2rt3r3r06JGu9oGBgdq7d6+8vLxSOVMAAAAAwLOMEAgAAAApioiI0P79++Xk5CQpYakwLy8vdejQQZMmTdKoUaNMbQsUKKChQ4dq06ZNatKkiSTpl19+0TfffKNPP/1UI0aMMLV9++23NXDgQE2ZMkV9+vRRyZIlJUlz586Vq6urWQ3vvvuuqlevrvHjxycbAlWoUEHffvut6fN27dqpbNmy+vzzz7VkyZI0z/Htt99WYGBguq+J0WhMs03iM3+KFi1qsS9x25UrV1INgVLrI3H7yZMnn3jMjLYHAAAAAPz7EAIBAAAgRYMGDTIFQJJUuHBhlS9fXsePH9d7771n1rZhw4aSpFOnTplCoMWLF8vR0VGdO3fW7dvms6LatGmj2bNn67ffflPfvn0lySwAevDggaKiomQ0GtWoUSPNmTNH9+/fl5ubm1k/ScMlSSpRooTKlSun06dPp+schw8fri5duqSrbXpFRERIkhwdHS32JV7PxDYZ6SOxn6R9POmYWVEjAAAAAODZRggEAACQAts8nnIoU9psm8HBIcX2Bjs7i/a2eVNfOsz+uef0MCzU9LmdZ57Ua8rtblnTY0uFZaXSpUtbbMuTJ4+KFCliFg4lbpekO3fumLadOHFC0dHRKlasWIpjXL9+3fTvixcvasyYMfrll1909+5di7b37t2zCIGSqzFfvnwKSeX5TUk9//zzev7559PVNr1cXFwkSdHR0RZLuSUuPZfYJj19JCcqKsqsj9TaJzfmk7YHAAAAAPz7EAIBAACkIE/nzsrTuXO629sXLqzSP/30RGM8N/WzJ2rv3ry53Js3f6JjMsPW1vaJtkvmy6XFx8crV65c+v7771NsX6pUKUkJz+bx8/NTaGioBg8erKpVq8rd3V02Njb69ttvtWzZMsXHx1scb2eX/K+06Vm2TZJCQ0MV+QTPVSpUqFCabYoWLapjx47pypUrKlu2rNm+tJZ5S9pH0vaPu3LlilkfqbVPbsyk7StWrJihGgEAAAAAzzZCIAAAADw1ZcuW1alTp1SlShUVLFgw1babN2/W5cuXNX/+fPXq1cts39y5c59ajYMHD87yZwL5+Pjo119/1a5duyxCoF27dsnZ2VmVK1dOtY+CBQuqePHiOnTokCIjI81mFIWEhOjatWtq2rSp2ZiJ/T8ucVvSZxD5+Pjo66+/1q5du0zL9z3evlatWmmeKwAAAADg2WWT3QUAAADAenXt2lWS9P777yc7iyc0NNS0HFni7KLHQ5YjR47ohx9+eGo1Dh8+XBs3bkz3R3p06tRJtra2+uKLLxQXF2favm/fPm3btk1t27Y1W2otNDRUJ0+etHhuUteuXRUREaHZs2ebbZ8+fbppf6KSJUvK19dXW7du1f79+03b4+LiNHPmTLm5ualVq1am7a1bt5abm5vmzp2rsLAw0/ZLly5p5cqVql+/vkqWLJmu8wUAAAAAPJuYCQQAAICnplWrVhowYIC+/vprHT16VK+//rqKFCmiGzdu6MiRI/rxxx914sQJeXl5ydfXV4ULF9bQoUN1/vx5eXl56cSJE5o7d66qVKliFmxkpafxTKDy5ctr+PDh+uSTT9SwYUN17dpVt2/f1owZM1SgQAFNnjzZrP3333+vnj17auzYsRo3bpxp+/Dhw7Vq1SoNHz5cFy9eVLVq1bRt2zYtWrRIHTt2VOPGjc36mTlzpvz8/NSsWTO99957ypcvnxYtWqQDBw5ozpw58vT0NLX19PTU1KlTNWDAAPn6+qp///6Kjo7WrFmzTH0BAAAAAP7dCIEAAADwVM2ePVuNGjXSnDlzNGPGDD148EAFChRQ+fLlNXnyZNMzdjw8PLRhwwaNGDFCs2fPVnR0tKpWraolS5bowIEDTy0EelomTZqkEiVK6KuvvtLgwYOVK1cuNWnSRJMnT1axYsXS1Ye7u7u2b9+u0aNHa+XKlZozZ45KlCihyZMn6/3337doX6NGDe3cuVMffvihpk6dqpiYGFWpUkUrV65Uu3btLNr3799fefPm1dSpUzV8+HA5ODiofv36mjRpkqpVq5bpawAAAAAAyF4GY3qfmItnVt26dSUlv/770xYcHCxJ8vPz+8fHxrOFewES9wES/Fvug6NHj0qSqlSpks2VWK/EZd4cHR2zuRI8TWl9LyX3MyE7f38FAAAAgJyEZwIBAAAAAAAAAABYIUIgAAAAAAAAAAAAK0QIBAAAAAAAAAAAYIUIgQAAAAAAAAAAAKwQIRAAAAAAAAAAAIAVIgQCAAAAAAAAAACwQoRAAAAAAAAAAAAAVogQCAAAAAAAAAAAwAoRAgEAAAAAAAAAAFghQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAJ6aixcvymAwaNy4cdldCgAAAAAAOQ4hEAAAAJBOR44c0auvvipPT0+5urqqTp06WrNmzRP3M3fuXFWrVk3Ozs7Knz+/OnXqpJCQkGTbRkREaOTIkfLy8pKjo6O8vLw0cuRIRUREJNs+JCREnTp1Uv78+eXs7Kxq1app7ty5T1wjAAAAAODfzy67CwAAAID1KlGihCIjI2Vn9+//tfPw4cOqX7++HB0dNXToUOXLl0+LFy9W27ZtNW/ePPXu3Ttd/YwZM0YTJ06Ur6+vPv/8c926dUuff/65tm7dqr1796po0aKmtg8fPlSLFi20bds2de3aVX5+fjp8+LCmTZumPXv26LfffpOtra2p/ZUrV1SnTh2Fhobq3XffVcmSJbV27Vr169dPly5d0oQJE7L8ugAAAAAAnl3//lfjAAAAeGYZDAY5OjpmdxlZYtCgQXrw4IG2bNkib29vSVLv3r1Vu3ZtDRkyRG3btpWHh0eqfZw+fVqffPKJatSooa1bt5rCsebNm8vHx0cffPCBFi5caGofGBiobdu2adCgQZo5c6Zpu5eXl95//30FBgaqV69epu0ffPCBrl+/rtWrV+v111+XJPXt21evvfaaPvnkE3Xr1k1ly5bNqksCAAAAAHjGsRwcAAAALAQEBMhgMGjz5s367LPPVLZsWTk5OalixYpatmyZJOnq1avq0qWLadmxpk2b6uzZs2b9JPdMoKTbNm7cKF9fX7m4uChPnjzq0qWL7ty580+earpcvHhR27dvl7+/vykAkiR7e3u98847CgsL0w8//JBmP0uXLtXDhw/1zjvvmM2O8vb2lp+fn1atWqXIyEjT9sRAaOjQoWb9DBw4UM7OzmaBUUREhFatWqWSJUuaAqBEQ4YM0cOHD7VkyZInOm8AAAAAwL8bM4EAAABSsOzkMq04uSJTfVTIW0GfNvg0xf0jt4/UyTsnMzVG+wrt1bFCx0z1kZJRo0YpPDxcvXv3lrOzs7755ht17txZtra2Gj58uOrVq6fx48crJCREn3/+uVq3bq0jR47Ixibt9xr9+uuvmjlzpvr27atu3bppz549CggI0L179/Tzzz9nuObY2FiFhoamu72bm1uas5X27NkjSapXr57FvsRte/fuVY8ePTLVz7Zt23T06FH5+PjIaDTqjz/+UJEiRVSiRAmzts7Ozqpevbr27dsno9Eog8Ggo0ePKjIyUnXr1rXou27dujIYDNq7d2+q9QEAAAAArAshEAAAQAruRd3TudBzmerD3dE91f1Xw69meox7UfcydXxqIiIitH//fjk5OUmS3nzzTXl5ealDhw6aNGmSRo0aZWpboEABDR06VJs2bVKTJk3S7Pvw4cM6dOiQypcvL0nq37+/7OzsNHfuXJ05cybDy5bt3LlTL774YrrbL1iwIM3w5sqVK5Jk9ryeRInbEttkRT8+Pj66e/euIiIiVLly5WT7Klq0qHbt2qV79+4pT548qfbt6OiofPnypatGAAAAAID1yHEh0B9//KGxY8fq999/V2xsrKpUqaIhQ4bozTffTHcf0dHRmjJlihYtWqTLly8rT548atmypSZOnKgCBQqkeXyLFi20fv16OTo6KioqKjOnAwAA8FQNGjTIFABJUuHChVW+fHkdP35c7733nlnbhg0bSpJOnTqVrhCodevWpgAoUdOmTTV37lydPn06wyFQtWrVtHHjxnS3r1SpUpptIiIiJCnZGUOJ1yexTVb1k1rbx9vnyZMnXe3TUyMAAAAAwHrkqBBoy5YtatasmZycnNShQwe5ublp9erVat++vS5fvmyx1npy4uPj1apVKwUFBalOnTpq27atzpw5o3nz5mnTpk3avXu38ufPn+Lxc+fOVVBQkJycnGQ0GrPy9AAAALJc6dKlLbblyZNHRYoUMQuHErdLSvczfZLrO1++fJKk27dvP2mpJp6ennrppZcyfHxyXFxcJCW8GehxiW/qSWyT3n6cnZ1T7Se1MTPa3sPDI80aAQAAAADWI8eEQHFxcerbt69sbGwUHBys6tWrS5I++ugj+fj46IMPPlC7du0s1lt/XGBgoIKCgtSxY0ctWbJEBoNBkvT111/rrbfe0ujRozVnzpxkj7148aKGDh2qIUOGaOXKlbp+/XqWniMAAMhank6eKp3bMqh4EkVyFUlzf1h0WKbG8HTyzNTxqbG1tX2i7ZLS/UYXO7uUfxXNzJtlYmJidPfu3XS3z507t0Ug87jUlnxLbRm25Po5duyYrly5YjHT6fF+8uTJIxcXlxSXcLty5YpcXV3l6emZZo3R0dG6ffu2vL2906wRAAAAAGA9ckwItHnzZp07d049e/Y0BUBSwov+Dz74QD169FBgYKA++uijVPuZO3euJOmTTz4xBUBSwhr2U6dO1ZIlS/T5559b/CHBaDSqV69eKly4sMaPH6+VK1dm3ckBAICnomOFjupYoeNTHePTBp8+1f5zot9//z3Lnwnk4+MjSdq1a5fFvsRtiW3S6ufXX3/Vrl27LEKgXbt2ydnZ2fQMIIPBIG9vbwUHByskJMTszUqRkZE6dOiQfHx8TL+TVqlSRU5OTsnWuHv3bhmNxnTVCAAAAACwHjkmBNq6daukhHXmH9esWTNJ0rZt21LtIyoqSnv27FH58uUtZgwZDAY1adJEc+bM0b59+9SgQQOz/bNmzdK2bdsUHByc5jtNAQAAkHFP45lAJUuWlK+vr7Zu3ar9+/erZs2akhJmm8+cOVNubm5q1aqV2TEnT56Uvb292bJ3nTp10qRJk/TFF1+oU6dOptlQ+/bt07Zt29S5c2ezZeW6du2q4OBgTZ8+XTNnzjRtnz17tiIjI9W1a1fTNhcXF7Vt21ZLlizRmjVr9Prrr5v2TZ8+Xba2turY8emGmgAAAACAZ0uOCYHOnDkjSck+YLhQoULKlSuXqU1Kzp07p/j4+BQfUpy4/cyZM2Yh0JkzZzRq1Ci988478vX1zegpqG7dusluP3bsmIoXL67g4OAM951RYWEJy9dkx9h4tnAvQOI+QIJ/y33g7OwsR0fHFJ+fktPFxsZKSlha7fFrFB8fL6PRaLE98fO4uDhFR0ebLemWuC25dknFxMSYxs/o18bFxcXiDTlpSc9Y06ZN00svvaRmzZpp0KBByps3r5YuXaoDBw7oyy+/lIuLi1k/FStWVPHixXX69GnTNi8vLw0ZMkRTp06Vn5+fOnXqpDt37mjWrFkqUKCAxo4da9ZHp06dFBAQoFmzZunu3buqX7++jh49qjlz5sjX11cdO3Y0az927Fj99ttv6tq1q/bs2SMvLy/99NNP+uWXXzRs2DB5eXll+T2feC+k9D2f3M+EsLAwubu7Z2kdAAAAAABLOSYECg0NlZSw/Fty3N3dTW0y00fSdlLCH0m6d++uwoULa9KkSU9cNwAAAJ4NL7zwgrZs2aKxY8dqxowZiomJUeXKlbV06VKzWTdpGT9+vIoXL645c+bo/fffV65cudSoUSONHz9exYoVM2tra2urtWvXavLkyVq5cqW+++47FSpUSIMHD9YHH3xg8Wym4sWLa+vWrfroo480f/58hYeHq2zZspo1a5b69OmTJdcBAAAAAPDvkWNCoOwydepU7d69W1u2bDFb2iMjklvfXXo0Q8jPzy9T/WdE4js6s2NsPFu4FyBxHyDBv+U+OHr0qCTJ0dExmyt5NvXt21d9+/ZNdl9KMz7Kly9vNvsnOjpaXl5eZtuSa5dU06ZNU9z3LKhVq5Z++eWXdLVN7Tzefvttvf322+nqx9HRUdOnT9f06dPT1b5ChQr67rvv0tU2KxgMBjk5OalWrVrJ7k/uZwKzgAAAAADgn2GT3QX8UxJn76Q02ycsLCzFGT5P0kfSdqdPn9bYsWM1cOBA+fv7Z6huAAAAAAAAAACAjMgxIVDS5/U87vr166alMlJTqlQp2djYpPjsoMefO/Tnn38qOjpaX331lQwGg9lHSEiIoqOjTZ///fffmTg7AAAAAAAAAAAAczlmOTh/f3998skn2rBhgzp06GC2LygoyNQmNc7OzvLx8dHu3bsVEhKiEiVKmPYZjUZt3LhRrq6u8vb2lpTw4N/evXsn29eKFSsUGRmpHj16SGIpGgAAAAAAAAAAkLVyTAjUuHFjlSpVSkuXLtU777yj6tWrS0pY2m3y5MlycHBQt27dTO2vXbum0NBQFS5c2GyZuH79+mn37t0aNWqUlixZIoPBIEmaM2eOzp8/r379+snZ2VmSVL16dc2bNy/Zen777Tddv349xf0AAAAAAAAAAACZkWOWg7Ozs9O8efMUHx8vPz8/9evXT0OHDlW1atV0+vRpTZ48WV5eXqb2o0aNUsWKFfX999+b9dO9e3c1a9ZMy5YtU7169TRy5Ei1a9dOAwcOVMmSJTVx4sR/+MwAAAAAAAAAAAAs5ZgQSJJefPFF7dixQ76+vlqxYoVmz56tggULavny5Ro6dGi6+rCxsdHatWs1btw43bp1SzNmzNDOnTvVu3dv7dq1S/nz53/KZwEAAAAAAAAAAJC2HLMcXCIfHx+tX78+zXYBAQEKCAhIdp+jo6PGjh2rsWPHZriOixcvZvhYAAAAAAAAAACAtOSomUAAAAAAAAAAAAA5BSEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFaIEAgAAAAAAAAAAMAKEQIBAAAAAAAAAABYIUIgAAAAIBMiIiI0cuRIeXl5ydHRUV5eXho5cqQiIiKeqJ8jR47o1Vdflaenp1xdXVWnTh2tWbMmxfZr1qxRnTp15OrqKk9PT7366qs6cuRIsm3j4uI0ZcoUlS9fXo6OjipSpIjeeust3blz54lqBAAAAAD8uxACAQAAABn08OFDtWjRQlOmTJGfn5+++uorvfrqq5o2bZpeeeUVPXz4MF39HD58WL6+vtq1a5eGDh2q6dOny87OTm3bttX8+fMt2s+fP19t27bVgwcPNGXKFH344Yc6cuSIfH19dfjwYYv2PXv21MiRI1WuXDl9+eWX6tGjhwIDA+Xn56f79+9n+joAAAAAAJ5NdtldAAAAAPBvFRgYqG3btmnQoEGaOXOmabuXl5fef/99BQYGqlevXmn2M2jQID148EBbtmyRt7e3JKl3796qXbu2hgwZorZt28rDw0OSdO/ePQ0ZMkRFixbVzp075e7uLkl688039fzzz2vQoEEKDg429b1582YtXrxYr732mtauXWvaXrNmTbVr105Tp07V+PHjs+JyAAAAAACeMcwEAgAAgIWAgAAZDAZt3rxZn332mcqWLSsnJydVrFhRy5YtkyRdvXpVXbp0Uf78+eXs7KymTZvq7NmzZv3Ex8dr8uTJatiwoQoXLiwHBwc999xz6t69uy5dumTWNjAwUAaDQW+//bbZ9piYGPn4+MjZ2VmHDh16quf9pBYuXChJGjp0qNn2gQMHytnZ2bQ/NRcvXtT27dvl7+9vCoAkyd7eXu+8847CwsL0ww8/mLavXbtWYWFh6tOnjykAkqTixYurXbt22r59uy5evGhR45AhQ8zGbdu2rby8vNJVIwAAAADg34mZQAAAACk4uvWKjm77K1N95C+WS016VUpx/8Zvj+vW5fBMjVHF/zlVaVg0U32kZNSoUQoPD1fv3r3l7Oysb775Rp07d5atra2GDx+uevXqafz48QoJCdHnn3+u1q1b68iRI7KxSXivUUxMjKZMmaLXX39dr7zyinLnzq0jR47o22+/1aZNm3TkyBHlyZNHktS9e3dt27ZNX331lfz9/fXGG29IkoYPH64//vhDc+bMUfXq1TN8Lvfu3Uv38mz29vbKnTt3qm2MRqP++OMPFSlSRCVKlDDb5+zsrOrVq2vfvn0yGo0yGAwp9rNnzx5JUr169Sz2JW7bu3evevToka72gYGB2rt3r7y8vEztbWxsVKdOHYv2devW1bJly3Tz5k0VKFAg1fMFAAAAAPz7EAIBAACkIPJ+jO5de5CpPpxcUv916/6dqEyPEXk/JlPHpyYiIkL79++Xk5OTpIQlx7y8vNShQwdNmjRJo0aNMrUtUKCAhg4dqk2bNqlJkyaSJEdHR127dk0uLi5m/bZu3VpNmjTR/PnzNWzYMNP2L7/8Un/88Yf69OmjF154QceOHdMXX3yhTp06qV+/fpk6lxdeeEEhISHpauvv76+tW7em2ubu3buKiIhQ5cqVk91ftGhR7dq1S/fu3TMFXcm5cuWKqX1yfSRtk9H2+fLlk6OjY6rtCYEAAAAAwPoQAgEAACBFgwYNMgVAklS4cGGVL19ex48f13vvvWfWtmHDhpKkU6dOmUIgg8FgCoDi4+MVFhamuLg4Va9eXblz5zbNaknk4uKilStXytvbW23atNGVK1dUvnx5zZkzJ9PnsmTJEkVGRqarraenZ5ptIiIiJCnZcEWS6bpFRESkGgKl1k/SPjLTPqXzSa49AAAAAMB6EAIBAAAgRaVLl7bYlidPHhUpUsQsHErcLkl37twx2/7DDz/os88+0/79+xUTYz5r6e7duxb9V6hQQf/3f/+n/v37y97eXt99951y5cqV2VORr69vpvtIKjHcio6OTnZ/VFSUWbuM9JNcHxlpn9kaAQAAAAD/ToRAAAAAKXB2c5BnYddM9eGW1ynN/VERcZkaw9nNIVPHp8bW1vaJtksJz8pJtG7dOr3xxhvy9vbW//3f/6l48eJydnaWJHXo0EHx8fHJHv/jjz9KkmJjY3Xs2DFVrVo1M6chSbp161a6nwnk4OCQ6uwdKSH0cnFxMVt6LakrV67I1dU1zVlFyS3hlrSPpG0eb1+xYsV0tT99+rSio6MtZg+ltrQcAAAAAODfjxAIAAAgBVUaFlWVhk/3j+NNelV6qv1nt8WLF8vJyUnbtm0zm23y4MED3bt3L9ljpk6dqp9//lkjRozQTz/9pP79+8vb21vlypXLVC21atXK0mcCGQwGeXt7Kzg4WCEhISpRooRpX2RkpA4dOiQfHx8ZDIZU+/Hx8ZEk7dq1y2Jf4rbENon//vrrr7Vr1y7TsnuPt69Vq5ZZ+5MnT2rPnj3y8/OzaF+iRAmeBwQAAAAAVooQCAAAAE+Nra2tDAaDxYyfCRMmJDsLaOfOnfrwww/VuHFjTZ48Wd27d1etWrX05ptvavfu3RZL0D2JrH4mkCR17dpVwcHBmj59umbOnGnaPnv2bEVGRqpr165m7a9du6bQ0FAVL17cFIqVLFlSvr6+2rp1q/bv36+aNWtKkuLi4jRz5ky5ubmpVatWpj5at26twYMHa+7cuXr33Xfl7u4uSbp06ZJWrlyp+vXrq2TJkmY1Lly4UNOnTzcLgdasWaOLFy9q9OjR6TpXAAAAAMC/DyEQAAAAnprXX39da9askb+/v3r06CGj0aigoCD9+eefypcvn1nbO3fuqEOHDsqXL5+WLFkiGxsbVaxYUbNnz1a3bt307rvv6uuvv85wLVn9TCBJ6tmzpxYuXKhZs2YpNDRUfn5+Onz4sP773/+qQYMG6tGjh1n7UaNGKTAwUFu2bFHDhg1N22fOnCk/Pz81a9ZM7733nvLly6dFixbpwIEDmjNnjlko5enpqalTp2rAgAHy9fVV//79FR0drVmzZpn6Suqll15Sx44dtWzZMr366qtq1aqVLly4oBkzZqhChQoaNmxYll8XAAAAAMCzgRAIAAAAT027du0UHR2tGTNmaPjw4XJzc1OTJk20fft21a9f39TOaDSqa9euunr1qjZu3KiCBQua9nXt2lXbtm3TnDlz1LBhQ3Xo0CE7TiVZtra2+uWXXzR+/HitWLFCy5YtU+HChTVkyBB99NFHqT47KakaNWqYZkFNnTpVMTExqlKlilauXKl27dpZtO/fv7/y5s2rqVOnavjw4XJwcFD9+vU1adIkVatWzaJ9YGCgqlSpogULFug///mP8uTJo65du2rixImmmUQAAAAAAOtjMCZ9ci/+lerWrSsp+XXkn7bg4GBJslhfHjkP9wIk7gMk+LfcB0ePHpUkValSJZsrsV7R0dGSJEdHx2yuBE9TWt9Lyf1MyM7fXwEAAAAgJ7HJ7gIAAAAAAAAAAACQ9QiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQCAHMlgMMhoNMpoNGZ3KcC/VuL3kMFgyO5SAAAAAADJIAQCAAA5kpOTkyQpPDw8mysB/r0Sv38Sv58AAAAAAM8WQiAAAJAj5c6dW5J05coV3b9/nxlBwBMwGo26f/++rly5IunR9xMAAAAA4Nlil90FAAAAZIe8efPq/v37Cg8P14ULFySJJa2yWGKwxnW1PklD01y5cilv3rzZWA0AAAAAICWEQAAAIEeysbGRl5eX7ty5o9DQUEVFRTEbKItFR0dLYqkwa2RjYyMnJyflzp1befPmlY0NCwwAAAAAwLOIEAgAAORYNjY2yp8/v/Lnz5/dpVil4OBgSVKtWrWyuRIAAAAAAHIm3rIHAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAAAAAAAWCFCIAAAAAAAAAAAACtECAQAAAAAAAAAAGCFCIEAAAAAAAAAAACsECEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFaIEAgAAAAAAAAAAMAKEQIBAAAAAAAAAABYIUIgAAAAAAAAAAAAK0QIBAAAAAAAAAAAYIUIgQAAAAAAAAAAAKwQIRAAAAAAAAAAAIAVIgQCAAAAAAAAAACwQoRAAAAAAAAAAAAAVogQCAAAAAAAAAAAwAoRAgEAAAAAAAAAAFghQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWKMeFQH/88YdatGghDw8Pubq6qk6dOvruu++eqI/o6GiNHz9eZcuWlZOTk4oUKaJ+/frp5s2bFm0PHTqkMWPGqE6dOipQoIAcHR1VqlQpDRw4UH/99VdWnRYAAAAAAAAAAIAZu+wu4J+0ZcsWNWvWTE5OTurQoYPc3Ny0evVqtW/fXpcvX9bQoUPT7CM+Pl6tWrVSUFCQ6tSpo7Zt2+rMmTOaN2+eNm3apN27dyt//vym9gMGDNCePXvk4+OjDh06yNHRUXv27NHs2bO1cuVKbd++XRUqVHiapw0AAAAAAAAAAHKgHBMCxcXFqW/fvrKxsVFwcLCqV68uSfroo4/k4+OjDz74QO3atVOJEiVS7ScwMFBBQUHq2LGjlixZIoPBIEn6+uuv9dZbb2n06NGaM2eOqX3nzp21ePFilSlTxqyfKVOmaOTIkRo6dKh+/vnnrD1ZAAAAAAAAAACQ4+WY5eA2b96sc+fOqVOnTqYASJJy586tDz74QDExMQoMDEyzn7lz50qSPvnkE1MAJEn9+/dXqVKltGTJEkVGRpq2Dxo0yCIAkqT3339fzs7O2rZtWybOCgAAAAAAAAAAIHk5JgTaunWrJKlp06YW+5o1ayZJaQYyUVFR2rNnj8qXL28xY8hgMKhJkyZ68OCB9u3bl2Y9BoNB9vb2srPLMZOxAAAAAAAAAADAPyjHJBBnzpyRJJUtW9ZiX6FChZQrVy5Tm5ScO3dO8fHxyfaRtO8zZ86oQYMGqfa1atUqhYWF6Y033khP+ZKkunXrJrv92LFjKl68uIKDg9PdV1YJCwuTpGwZG88W7gVI3AdIwH2ARNwLkJK/D8LCwuTu7p5dJQEAAABAjpFjZgKFhoZKSlj+LTnu7u6mNpnpI2m7lFy+fFnvvPOOnJ2dNWHChFTbAgAAAAAAAAAAZESOmQn0rLhz545atGihmzdvauHChSpfvny6j921a1ey2xNnCPn5+WVJjU8i8R2d2TE2ni3cC5C4D5CA+wCJuBcgJX8fMAsIAAAAAP4ZOWYmUOLsnZRm6YSFhaU4w+dJ+kja7nF37txR48aNdfz4cc2ePVtdunRJV+0AAAAAAAAAAABPKseEQEmf1/O469evKzw8PMVn/SQqVaqUbGxsUnx2UGrPHUoMgA4fPqwvv/xS/fv3f9JTAAAAAAAAAAAASLccEwL5+/tLkjZs2GCxLygoyKxNSpydneXj46NTp04pJCTEbJ/RaNTGjRvl6uoqb29vs31JA6BZs2Zp4MCBmTkVAAAAAAAAAACANOWYEKhx48YqVaqUli5dqkOHDpm2h4aGavLkyXJwcFC3bt1M269du6aTJ09aLP3Wr18/SdKoUaNkNBpN2+fMmaPz58+rc+fOcnZ2Nm2/e/euXnrpJR0+fFhffPGF3n777ad0hgAAAAAAAAAAAI/YZXcB/xQ7OzvNmzdPzZo1k5+fnzp06CA3NzetXr1aISEhmjZtmry8vEztR40apcDAQC1YsEA9evQwbe/evbtWrFihZcuW6cKFC/L399fZs2e1Zs0alSxZUhMnTjQb9/XXX9ehQ4dUoUIF3b17V+PGjbOo7d1335WHh8fTOXEAAAAAAAAAAJAj5ZgQSJJefPFF7dixQ2PHjtWKFSsUGxurKlWqaMqUKWrfvn26+rCxsdHatWv16aefatGiRZoxY4by5Mmj3r17a+LEicqfP79Z+4sXL0qSTp48qY8//jjZPnv06EEIBAAAAAAAAAAAslSOCoEkycfHR+vXr0+zXUBAgAICApLd5+joqLFjx2rs2LFp9pMYAgEAAAAAAAAAAPyTcswzgQAAAAAAAAAAAHISQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAAAAAAAWCFCIAAAAAAAAAAAACtECAQAAAAAAAAAAGCFCIEAAAAAAAAAAACsECEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFaIEAgAAAAAAAAAAMAKEQIBAAAAAAAAAABYIUIgAAAAAAAAAAAAK0QIBAAAAAAAAAAAYIUIgQAAAAAAAAAAAKwQIRAAAAAAAAAAAIAVIgQCAAAAAAAAAACwQoRAAAAAAAAAAAAAVsguqzqKiIjQ77//rp07d+rKlSu6ffu2XFxclD9/flWpUkX+/v4qU6ZMVg0HAAAAAAAAAACAVGQ6BNq1a5e+/vprrVq1SlFRUTIajcm2MxgMqlixogYMGKBu3brJ3d09s0MDAAAAAAAAAAAgBRkOgY4fP65hw4YpKChItra2atiwoerWrStvb28VLFhQefLkUWRkpO7evatTp05p9+7d2rx5s9555x19/PHHGjNmjAYOHCg7uyybjAQAAAAAAAAAAID/yXACU61aNZUoUUJffPGFOnTooHz58qXY1t/fX/369ZMkbdu2TXPnztXQoUN1//59ffjhhxktAQAAAAAAAAAAACnIcAg0Z84cde/e/Yln8vj7+8vf319jx47VlStXMjo8AAAAAAAAAAAAUpHhEKh3796ZGrhs2bIqW7ZspvoAAAAAAAAAAABA8myyuwAAAAAAAAAAAABkvQzPBEqPy5cv6+DBg4qPj1fdunVVsGDBpzkcAAAAAAAAAAAA/ifTM4EOHDigHj16qGXLlho7dqzCwsIkScOGDVPp0qXVpk0btW3bViVKlNBnn32W6YIBAAAAAAAAAACQtkzNBDp27Jj8/PwUEREhSVq/fr12796tDh06aPr06fLy8lKNGjV07949bd++XaNGjVLVqlXVvHnzLCkeAAAAAAAAAAAAyctUCPTJJ58oMjJSn332mZo3b66goCCNGDFCZ8+eVbt27bR06VLZ2SUM8ccff6h+/fr66quvCIEAAAAAAAAAAACeskyFQNu3b1fjxo31/vvvS5IqV66sDRs26LffftOPP/5oCoAkqVatWnr11Ve1Y8eOzFUMAAAAAAAAAACANGXqmUDXr19X9erVzbZVq1ZNklSmTBmL9mXLltWdO3cyMyQAAAAAAAAAAADSIVMhUFxcnHLlymW2zdXVVZLk6Oho0d7JyUnx8fGZGRIAAAAAAAAAAADpkKkQCAAAAAAAAAAAAM+mTD0TSJIePHigmzdvmj4PDw+XJN26dUtGo9GsbeI+AAAAAAAAAAAAPF2ZDoGmTZumadOmmW0zGo0qVKhQZrsGAAAAAAAAAABABmUqBPLz85PBYMiqWgAAAAAAAAAAAJBFMhUCbd26NYvKAAAAAAAAAAAAQFayye4CAAAAAAAAAAAAkPUIgQAAAAAAAAAAAKxQppaDGz9+/BMfYzAYNGbMmMwMCwAAAAAAAAAAgDRkKgQaN26cDAaDJMloNKbrGEIgAAAAAAAAAACApy9TIZAk2dnZqUWLFmrTpo0cHR2zoiYAAAAAAAAAAABkUqZCoGHDhmnRokVau3attm/frk6dOqlXr16qXr16FpUHAAAAAAAAAACAjLDJzMFTpkzR5cuX9cMPP6h+/fr6+uuvVbNmTdWoUUNfffWV7t27l1V1AgAAAAAAAAAA4AlkKgSSJFtbW7322mv64YcfdOXKFX366aeKjo7WoEGDVKRIEXXs2FEbN27MiloBAAAAAAAAAACQTpkOgZIqUKCAhg0bpuPHj2vnzp3q2rWrfvnlFzVv3lzr1q3LyqEAAAAAAAAAAACQiiwNgcw6trGRwWCQJBmNxqc1DAAAAAAAAAAAAJJhl5Wd3bp1SwsXLtSCBQt04sQJ2dvbq1WrVurVq5eaNm2alUMBAAAAAAAAAAAgFZkOgeLj4/XTTz/p22+/1fr16xUbG6uqVatqxowZ6tKli/LkyZMVdQIAAAAAAAAAAOAJZCoEGj58uBYvXqwbN24od+7c6tOnj3r37q0aNWpkVX0AAAAAAAAAAADIgEyFQNOmTZO9vb1effVVvf7663JyctLZs2d19uzZVI978803MzMsAAAAAAAAAAAA0pDp5eBiY2O1bt06rVu3Ls22RqNRBoOBEAgAAAAAAAAAAOApy1QINHbs2KyqAwAAAAAAAAAAAFmIEAgAAAAAAAAAAMAK2WR3AQAAAAAAAAAAAMh6GQ6BjEZjpgfPij4AAAAAAAAAAABgKcMhUOXKlbVy5coMHXv58mUNGDBAU6ZMyejwmfLHH3+oRYsW8vDwkKurq+rUqaPvvvvuifqIjo7W+PHjVbZsWTk5OalIkSLq16+fbt68meIxS5YskY+Pj1xdXeXp6amWLVvqwIEDmT0dAAAAAAAAAAAACxkOgcqWLav27durVKlSGjt2rI4ePZrqzJ47d+5o+fLlatmypcqUKaO1a9fK29s7o8Nn2JYtW+Tr66sdO3bozTff1IABA3T9+nW1b99e06dPT1cf8fHxatWqlcaOHat8+fLp3XffVd26dTVv3jzVrVtXt27dsjhm0qRJ6tKli27evKkBAwbojTfeUHBwsOrVq6edO3dm9WkCAAAAAAAAAIAczi6jB/7www/atm2bxowZowkTJmjixIlydXVV9erVVbBgQXl4eCgqKkp3797VqVOndOHCBUmSp6enRowYoeHDhytXrlxZdiLpERcXp759+8rGxkbBwcGqXr26JOmjjz6Sj4+PPvjgA7Vr104lSpRItZ/AwEAFBQWpY8eOWrJkiQwGgyTp66+/1ltvvaXRo0drzpw5pvZnzpzRuHHjVK5cOe3du1e5c+eWJA0cOFB16tRR3759dezYMdnY8IgmAAAAAAAAAACQNTKVOvj7+ys4OFhHjx7Ve++9pzJlyuj333/X6tWrNX/+fC1ZskTr169XaGioWrVqpYCAAP31118aP378Px4ASdLmzZt17tw5derUyRQASVLu3Ln1wQcfKCYmRoGBgWn2M3fuXEnSJ598YgqAJKl///4qVaqUlixZosjISNP2BQsWKC4uTh9++KEpAJKk6tWrq2PHjjpx4oR27NiRBWcIAAAAAAAAAACQIMMzgZKqVKmSpk2bJkl68OCBrl69qjt37sjZ2Vn58+dXkSJFsmKYTNu6daskqWnTphb7mjVrJknatm1bqn1ERUVpz549Kl++vMWMIYPBoCZNmmjOnDnat2+fGjRokK5xAwICtG3bNvn5+T3pKT2q6/x5HRvQX5Lk3rSJ3JtYjnX7m28UdeaMJClviZIqPGqkaV98fLzCHoQrbMtWhf3ys2l7kQkTZOPkZNZPzNVrCv2/6Yp8EKvQm6HaWbOJfrjmLuPDGMXHx5na1ft5gRyiIyRJ17wq6VSNhmb92Nq7qMrvP6vI+WOSpAeu7trWsrtF3QUvn1LFP34zfb63SSdFuHnKYGMvG1t7SZJ9VIQarZqlWBsp1tZGZ6o20F9lqlr05b35O+X6O2G5vjsFS+jPhm+a7TfGx8vryBYVP5XwrCajjY22tX7Loh/Pm3+p2o4fZB8XL3uj9MdLHXS3UML9kPQ6+P8wW4b4eEnSpfI1dL5SXYu+au34Rfn/OidJCstTUL8376r4h9FmbZ47e0Rlj2w3fb6zZW/FOiR8XRKvg2voHdVfN0+SFGNj0NE6TXSjWHmL8eqsXyinyPuSpBvFK+iE90uytXc2a1Nx13rlu5TwdYlxdNHvr/S06Cf/X2dVaU+QJMkhLl4/135Voe559cO1Q5Kk+Lho2cREqsG6uaZjzlWup8vlXrDoq+bWVSp445ok6U4hL+17qb2M8Q/NroPXn3vldfIP0+dbX/+PWR8GG3vluXNDtTcsMW3b07CN7hQsajGe39pvZPMwVpJ0pUw1na1aX5LB7DpU3/a98l0+rWh7G0W45dHeJh0t+ily4bjKHdxq+nz3K30Um8vTrI1j2E35rH8ULp+s2UjXS1S06KtO0GI5h4fKOS5e10tU1OEGr0mS2XUodyhYRc4flSTF2Tlqx2t9LPopcP2yvLf9YPp818vd9HfuPDIaHz66Vg/j5L/20WzFC8/XUUiFmgn7DAbZ2CVcB58NS+V587IeSrpZuKgO+rWxGK/Eyf0q+edu0+drfNsp3t7RdB9Ikvuda6oRtEgPbRNC86P1XtGdQl4WfdX/cZ7s4qJlMEq3SlXXCZ8mpn2J16HSng3K/1fCz7Eo19za3ayLRT+FQk6o6p7fZPe/FUqDW/dXZC4PxcdFyWhM+H50jHqgur8EmI45/UJDXS1Z6dE1+t918F03X7lCb0uSrhYtq0O+zS3GK3Nkh4qePSxJire1V3Crfgl92DjIxjbhf7N5r16Q9+bvFGVro3gb6aDf6wrNV9iir4ZrvjL9O6RiLV2q2tBsf/zDOFUNXiXPm5clSWF5CulAw7YW/RQ7fVClj/0uh7h42Rml39q/p4f2Dgl9/O86uIbeUa1Ny03HHK/dTLeeK2PWj8Fgo0Zr58kx8oGkhO+Xo7VekjE+xqxdxX2bVPDSSUlSlLObfqr1siRp9aXfTdeh8IXjqrrzJ0lSpJ2N9jRN+FmelH1MlHx/mm/6/EzVBrpatrps7Mz/P1Rr/QI5hSV8Xe4ULKGjvi0trkGp47tMP8sdHkqbOg0zv5ZxkfK4cUXVdvxg2na4fmvdK/CcRV+NVv9XTnEJ30PnK9XRmRf8Ff8wVsb4WFObKjt/Ut4bIZKkcI/82tfI/P8vNraOKnH6oCru22TatrFNX9PP8kQu9+/JZ+NS0+cnar2kG8XKy2CwlY2do2m73/dfyz4iVDF2Nv/7Wd7You7yB7aq8MXjkhJ+lu9+bYAMNrZmbfJeOKrn9/5q+vyPxh30IHdesza2sTFqsG6ubB8a5Rhv1KkaDXXx+dqSZHYdamxdLfe71yVJ9woU0+H6r+n27XuSEu4FSSrz5z6VO7rL1HdQlxF6GBsp6dGSwrlvX9MLwWtMnx/xfU13CxaTJLPr8NLy/5NtXKziDNL5Ci/872e5ucq71ivftfOSZPpZbmPraHYdip45pFL7N8j4vzf27GrRQ9FOrmb9OEeEqfaviyRJdg+NOlX7ZV0tXcW0P/E61AlaLKcHoZKkW8+V1fHalr+PlTsUrJKnDslWBsU6OGnzm4Mlyew65L1+UVV+f/T72P4X2+m+Z0HT5waDrWwNtmq67NFSxier+ep8hRoW470Q/L1y374qSQrNV8T0szzpdXjlzjGVPRSsMJuEa/Dc5Mky2Nub9RNz+ZJuzpxl+rxInz7K413LrE1UdLTOjxqp+IiE3/9y1asnjzZtFBEdJUn6+36YJOnukiWKOH9eLqVKWdQLAAAAAMhaBmNqD/KxMm+88YZWrVqlffv2qWbNmhb73dzc5OnpqUuXLqXYx/Hjx1W5cmW1bNlS69ats9g/ffp0vf/++5o/f7569eolScqfP7+ioqJ0//59i/b79++Xt7e3unbtqoULF6Zaf926lgGCJB07dkx5nXPp7Tf/K0kJf8QwWLYzxD/6Uje6slDhQ94zff7w4UPt+z5UMkqGJLdEsn0ZJdvILXppb7Bi4436olYH7X2uiryNl1Q17NEfNQ1Go+lQY2Jfps+NWpDbQQMOrFKDSwclSVfd8+hEzXeSPUebJDXF/6+fA+7XdMhQXJKUKyZCc36ZpN/qvSRbB18ZZZAxuWuQpKaHhodakNs8/LA3RqtbqCHFuh+vySZ8g/z37dJE3946kT/hDxl14i/p+fuF07wGkhRrE6uCx1fpheunJEkXcxfR+Bd7qXOoeT5rMEoGWV4DSdqT+5qOq7gKhd/W9N9mSJKC6reQnb1PsnU/XlOUXYyWPDYzr/PJH+VcqHm6roEkOYT+pHUedXXZvZD0v7YNHl5S2fDCZl+7lL4usTb31XxTwh+yjuUvo098e8rVcF/t/370x9GkdT9+DSRpp8cNxd9+qHHbvzFtW/hyTz0XZbm8Y3Jflwf2D7TCxcPU5t29S/VczFWdqvxOitfAIPPvl91uV3TM1vwPWk1iQlQi4tH3xeN1J60pxuaumm+epV1Fq+pL7/aSJA/DPb3+d64U637cSbs/9Z+N35k+/7DhQJXJJRV/UMCsXUpfl78dwrTGOeEPwKN3zFPF2xd0sXBBnS8/IPlrkMy9udnjpi4aH/0h3evvv1Rfd+Wk8mleA4OkKJvrsr1wWIHVXjXty2e4pdf+9kjXNZCkvH8tUfXTCWHR4Kbv67aLp5rHXlORiHzJXwND0rOQbjvd04+OBfTp5pkqFnZDkvRr9Tqy97QMgVKqaYPHHV0xFpIkVbl5RiN/D9AvL3aTs7FkitcgaU1/O1zXKpfiZvsLG26oxT3PNK9B4tel4KVAPX/+onq3/EhR//vDecvo6yoQlddivORquu58W69sDpRHVML/vzZ71VLQC3XU9G/zkCC1r8vPHn/rhjG/6l05rP/sS7g31zfqIwejZUD7eE1GGfSX6239am8emPU5v0bK0zKNa/CopiLn52t8DfNAv3XUbeWJzp3mNZCkaJ1Siy3LJElry/nru+ebystwVY3+zp+uayBJP3jcl/e5U+p+5CfTtjXN3lPumNx6XHI1XXK9qd/sHn1ffbFhqi6WfE7387dL1zUwSlrt+UB/G82Dt/YPbsst1j3Na2BjNCrKeEwvb1utJZVf1i9lEgKXMoYr8vu7YLqugSTdDN2ujgceBWGdW09S+4i/5RprHrqk9HU5l+u6ttkmBELzf/pYTnEx2lWtuiI9W6XrGhgNBq3wiNIDo5upTaOLe1U0T2k5xLuleQ0kKebhAV184KDg4o8Cl4q6rLqhhdJ1DQxGo6odmKa8YQ8U7uCs/i1GJ1yL8HA5PnwU9KV2b550u6a9KqLAH8eati1u1EqFjZZvtEippiW54xSthN+Dht3crjp7g/RTgxGyNTqm+Ptf0v/nxeQLUf1G5qHTniOnZTiZ5OeD4X/jGR99nljTrJUjVaRkHu3atUsAAAAAgKcnRz2EJjQ04Z2ZSZdkS8rd3d3UJjN9JG2X+O8naQ8AAAAAAAAAAJBZWbIcHP4ZKb1Tsm7duroecvnRuyuT/NeMQUp8K2bB2j6qkWT5udi4OO3//ueE/UkONST3bliDZOfpIYcXaujW7b/lXcZTjV+spHN778pwP2l7o0xvGDUYLPoa1aKSCtmeUoxrwtJpTrk9kh/PaDR7h77hf/2VL+yml2skLN9kE/lAMReqKN41l2xiExol25ck0+Q3Q0INSUVHhyt0zVklnSCXWk3xuT0UU7GKOjaqrMhiJSVJZ3+/LUO4wbL2ZK6BrY1BXjWqKOZCwjJNeQoU0YCGZRX+48XHB1SSkmTQo3foVinqodeqVpL93VuK+et/S9M4u8gQJ9OsnBT7Mhhka2OwuA5Odn/q0m3TYGl+XR565FHjsm564OGkMmUSlpM6G3xLhgcGs2uZUl8Gg41iKibUXrR4aY1qUUn3Q28qcv21x4ZM+etSs7inylctqJjbj5bn8cjlJEN0GvfU/74u9rY2Zteh8MPKenDVKaFdMl87i34kVS+RV69WNb+W5367LmNEknP9X3/JdCbZJFyHcuUrm2q5e/uy4n67m2TIR/dvcjWVL5HfdC0lqUfjSjp+7IwMEeZtU/q6ONk/ug6FH1RWzJVcinVzSvkaWNyb0vN57dTR59F1cLzhoTPb98gYk/Y1MBol2dqqep3KKvLioz5uXTsn47bwdF0DGY16WKCQYmwTZpK91aSS4nJ76lzQbRkik/neTKw9SV8uDrYa1aKSPG5XVsydhFlU+UsUUej9NH6uJOmnccVCKuKVcA4uIY6KuVdFsreXMSbla5C0H3t7O4vvzeuXbaQd0UmuQepfl7hCRRTj6KYhzSvJ6JAww+D8L3cSvi9S+NmalJuTvRwqV1HMg4SZQFUqV1Zc2UIy7I7T48y+Lo8uhl6pWkQFnysntxNxinmQcG8a7WxliE3mGhgTZoomLcrdyV6jmplfhwdrdupB1KMx0vp5H1+0mMW1vLhuhwzRSvMaSJLs7E3fV7VrVVbp+pV05WycDPtSugaWNbWrWUylC9krJjbEtM3RzlaG2MevQfJfF09XB41q/OgcnK9V1UNHm9R/Rsn869K+VgnlyVfMbP+lNTtkfLSqXar3ptHRUTEVq6hhvUqq5p1QS8jJSBkOGczamV2DJJ9LUuVKpRQTedPUflSLSrr8/S4Z4pKMmcq9WcDNSaMa/u86nK+imNgYPfTMl85rkNCmZ71Scsv9aHZk7iMR+vNktP63WmTy1yBJTUYnZ71co6J8Kz36elw4Fi7DMYPS+t0nUWypcoqJjpOtk4vp3vxr1V4Z4pP/GfV4Tc95OGt4nUqKOfPo532B/J4y3ErfNZCkAQ3LysUl4U1KVc88kJvuSjYGKT7l3/+SfsfkcnezWMr4/LV7un0q3uwggwwyGoymzwAAAAAA/yyWg0viWV8OLiV169ZVvNGooI0b0n2Mu2su2dg8mgiW+Eyg9HJycJSTo6OCg4MlSX5+foqMilJ0bEwaRz7i4eZu9nlGa0jKGmp4+PCh7kc8yFQND6IiFRsbm8IR5gwGg3LncjPb9qQ1ODs5as+uPZJk+oNQdtTgaJ+11yE2Lk4PIiNSOCJ9NYRHPFDcw4cpHGF9NezevVsOdnZq9GKjbKtBSv463I8I18OH8SkckXYNMbGxioiKTHcNLk7OcnjsmRpPUoOtrY3cXMyXavy31LB7d8JzourUqZNsDaHh95XeXz+SqyE6NlqRUdEpHGHJ1dlF9nbm73t5khrsbG2Vy8V8uTJqSF8NSe+FrKjB3t5erk7mS7k+6XVwc3GVra35s5GsoYao6GhFxWSuhsRn9qSHo72DnB97bmRKNTx+H0hS08YvydbWluXgAAAAAOApy1EzgcqWLStJOnPmjEUIdP36dYWHh8vHJ/nnqCQqVaqUbGxsdObMmWT3J25PHCvx37t27dL169dVqFChNNtnhI3BYBEmPNHxNjaZOl6SnJ2cLP4YQA1PztbWNtM1uDo5S4/9cYganpy9nV2ma3j8D6bWXoOLY/L3/rNwHR4PEp6Ug729RZhBDclLvA9S+po9HrA9KUd7y5DvSVHDP1NDWvfCP1FDelhDDU6Olm8KeVKZ/TmbUg3J3QePB1AAAAAAgKcjRz0TyN/fX5K0YYPljJmgoCCzNilxdnaWj4+PTp06pZCQELN9RqNRGzdulKurq7y9vbN0XAAAAAAAAAAAgCeRo0Kgxo0bq1SpUlq6dKkOHTpk2h4aGqrJkyfLwcFB3bp1M22/du2aTp48qdDQULN++vXrJ0kaNWqU2bIdc+bM0fnz59W5c2c5Oz+afdCzZ0/Z2dlp0qRJZn0dOnRIy5YtU8WKFVW/fv2sPl0AAAAAAAAAAJCD5ajl4Ozs7DRv3jw1a9ZMfn5+6tChg9zc3LR69WqFhIRo2rRp8vLyMrUfNWqUAgMDtWDBAvXo0cO0vXv37lqxYoWWLVumCxcuyN/fX2fPntWaNWtUsmRJTZw40WzccuXKady4cRo9erSqVaumtm3b6v79+1q+fLkkae7cuWbP5wEAAAAAAAAAAMisHJc8vPjii9qxY4d8fX21YsUKzZ49WwULFtTy5cs1dOjQdPVhY2OjtWvXaty4cbp165ZmzJihnTt3qnfv3tq1a5fy589vccyHH36oxYsXK3/+/Jo9e7a+++47NWjQQL///rt8fX2z+jQBAAAAAAAAAEAOl6mZQBl5oKvBYFBcXFxmhs00Hx8frV+/Ps12AQEBCggISHafo6Ojxo4dq7Fjx6Z73M6dO6tz587pbg8AAAAAAAAAAJBRmQqBjEaj7O3tVapUqayqBwAAAAAAAAAAAFkgUyGQo6OjoqOjZTAY1LNnT3Xr1k0FCxbMqtoAAAAAAAAAAACQQZl6JtC1a9c0c+ZMOTs7a8SIESpWrJjatGmjdevWKT4+PqtqBAAAAAAAAAAAwBPKVAjk4eGht99+W/v379fBgwc1YMAAbd++Xa1bt9Zzzz2nESNG6NSpU1lVKwAAAAAAAAAAANIpUyFQUtWqVdPMmTN19epVLV26VFWrVtX06dP1/PPPq379+jp58mRWDQUAAAAAAAAAAIA0ZFkIlMjBwUHt27dXUFCQtm/friJFimjXrl06ffp0Vg8FAAAAAAAAAACAFGR5CBQbG6uVK1fq5Zdflp+fn/766y/5+PioXLlyWT0UAAAAAAAAAAAAUmCXVR0dOnRICxYs0NKlS3Xnzh0VKFBAgwcPVu/evVWxYsWsGgYAAAAAAAAAAADpkKkQ6N69e1qyZIkWLFigQ4cOycbGRi+//LJ69eqlli1bys4uyzImAAAAAAAAAAAAPIFMpTSFCxdWbGysypUrp08++UTdu3dXwYIFs6o2AAAAAAAAAAAAZFCmQqCYmBjZ29vLYDAoICBAAQEBaR5jMBh0/PjxzAwLAAAAAAAAAACANGR6vbbY2FidPHkyK2oBAAAAAAAAAABAFslUCBQfH59VdQAAAAAAAAAAACAL2WR3AQAAAAAAAAAAAMh6/1gIFBsbq5UrV6p58+b/1JAAAAAAAAAAAAA5VqafCZSWY8eOaf78+Vq8eLHu3r37tIcDAAAAAAAAAACAnlIIdP/+fS1dulTffvut9u3bJ0lycnJSx44d1bNnz6cxJAAAAAAAAAAAAJLI0hAoODhY8+fP1+rVqxUZGSmj0ShJat68uZYvXy53d/esHA4AAAAAAAAAAAApyHQIdP36dQUEBOjbb7/VuXPnZDQaVbx4cXXp0kVdu3ZVxYoVVbRoUQIgAAAAAAAAAACAf1CmQqBXX31VQUFBiouLk5ubm3r06KGuXbuqYcOGWVQeAAAAAAAAAAAAMiJTIdDPP/8sGxsbDRs2TOPHj5ejo2NW1QUAAAAAAAAAAIBMsMnMwaVKlVJ8fLymTZum2rVr6//+7/90/fr1rKoNAAAAAAAAAAAAGZSpEOjs2bPavHmzOnbsqNOnT+v9999XsWLF9PLLL2vZsmWKiorKqjoBAAAAAAAAAADwBDK1HJwkNWzYUA0bNlRoaKiWLFmi+fPnKygoSBs2bFCuXLlkMBgUFhaWFbUCAAAAAAAAAAAgnTI1Eyip3Llza+DAgdq/f78OHjyot956S7a2tjIajVq5cqVKly6tCRMmKCQkJKuGBAAAAAAAAAAAQAqyLARKqlq1avryyy917do1LV68WA0bNtTFixc1duxYlSlT5mkMCQAAAAAAAAAAgCSeSgiUyNHRUZ06ddKmTZt07tw5ffjhhypcuPDTHBIAAAAAAAAAAADKgmcCpZeXl5d69uypy5cv/1NDAgAAAAAAAAAA5FhPdSZQokuXLqlv376qWLGiFi1a9E8MCQAAAAAAAAAAkKNlOgTasWOHXnzxRbm7uytPnjxq1aqVTp06JUmKiIjQkCFDVK5cOc2fP1/58+fXzJkzM100AAAAAAAAAAAAUpep5eD279+vl156STExMaZt69at0759+7R9+3a99tpr+vPPP1WkSBGNGDFC/fr1k6OjY6aLBgAAAAAAAAAAQOoyNRPos88+U0xMjD755BPdvHlTN2/e1KRJk3Tt2jU1aNBAJ0+e1OjRo3X27FkNGjSIAAgAAAAAAAAAAOAfkqmZQDt37lSjRo00YsQI07ZRo0bpt99+09atWzV16lQNGTIk00UCAAAAAAAAAADgyWRqJtDNmzdVs2ZNi+2J27p3756Z7gEAAAAAAAAAAJBBmQqB4uLi5OrqarE9cVvevHkz0z0AAAAAAAAAAAAyKFMhEAAAAAAAAAAAAJ5NmXomkCQtXrxYu3fvNtt29uxZSVKLFi0s2hsMBv3888+ZHRYAAAAAAAAAAACpyHQIdPbsWVPo87hff/3VYpvBYMjskAAAAAAAAAAAAEhDpkKgCxcuZFUdAAAAAAAAAAAAyEKZCoFKlCiRVXUAAAAAAAAAAAAgC9lkdwEAAAAAAAAAAADIeoRAAAAAAAAAAAAAVogQCAAAAAAAAAAAwAoRAgEAAAAAAAAAAFghQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAAAAAAAWCFCIAAAAAAAAAAAACtECAQAAAAAAAAAAGCFCIEAAAAAAAAAAACsECEQAAAAAAAAAACAFSIEAgAAAAAAAAAAsEKEQAAAAAAAAAAAAFaIEAgAAAAAAAAAAMAKEQIBAAAAAAAAAABYIUIgAAAAAAAAAAAAK5SjQqCwsDANGTJEJUqUkKOjo7y8vDRs2DCFh4c/cV9BQUHy9/eXm5ub3N3d9eKLL2rTpk0W7e7cuaNvvvlGr732mkqVKiVHR0fly5dPL7/8soKCgrLitAAAAAAAAAAAACzkmBDowYMH8vf314wZM1ShQgW99957Kl++vKZNm6ZGjRopKioq3X0tXrxYzZs314kTJ9SjRw91795dx48fV5MmTbRq1SqztitXrlT//v21f/9+1a9fX0OGDNHLL7+sbdu2qXnz5po6dWpWnyoAAAAAAAAAAIDssruAf8pnn32mQ4cOacSIEfr0009N20eOHKkpU6ZoxowZGjVqVJr93Lt3T4MGDVK+fPl04MABFS1aVJI0YsQIvfDCC3rrrbfUrFkzubm5SZLKlSunH3/8Ua+88opsbB5lbqNHj1bt2rX14YcfqnPnzipSpEgWnzEAAAAAAAAAAMjJcsRMIKPRqHnz5ilXrlwaM2aM2b4xY8YoV65cmjdvXrr6Wrlypf7++28NGjTIFABJUtGiRfX222/r9u3b+v77703bGzVqpFdffdUsAJKk8uXLq3379oqNjdXvv/+eibMDAAAAAAAAAACwlCNCoDNnzujq1avy9fWVq6ur2T5XV1f5+vrq/Pnzunz5cpp9bd26VZLUtGlTi33NmjWTJG3bti1dddnb20uS7OxyzIQsAAAAAAAAAADwD8kR6cOZM2ckSWXLlk12f9myZRUUFKQzZ86oWLFiGe4rcVtim9SEhYVp1apVcnJyUoMGDdJsL0l169ZNdvuxY8dUvHhxBQcHp6ufrBQWFiZJ2TI2ni3cC5C4D5CA+wCJuBcgJX8fhIWFyd3dPbtKAgAAAIAcI0fMBAoNDZUk5c6dO9n9iS9AE9tltK8n6WfAgAG6ceOGPvjgA+XNmzfN9gAAAAAAAAAAAE/iXzUTaOjQoYqOjk53+8GDB6c4+yc7jRo1SsuWLVPz5s31wQcfpPu4Xbt2Jbs9cYaQn59fltT3JBLf0ZkdY+PZwr0AifsACbgPkIh7AVLy9wGzgAAAAADgn/GvCoHmzJmjBw8epLt9u3btVLZsWdOsnZRm6CQuUZHSTKGkkvb1+Aye9PQzZswYffrpp2rUqJHWrFkjW1vbtE8EAAAAAAAAAADgCf2rQqDw8PAMHZfWs3rSembQ433t27dPZ86csQiB0upnzJgxmjhxoho2bKh169bJ2dk53ecAAAAAAAAAAADwJHLEM4HKli2rIkWKaOfOnRYziR48eKCdO3eqZMmSKlasWJp9+fv7S5I2bNhgsS8oKMisTVKJAZC/v79+/vlnubi4ZORUAAAAAAAAAAAA0iVHhEAGg0F9+vRReHi4JkyYYLZvwoQJCg8PV9++fc22R0RE6OTJk7p06ZLZ9jfffFO5c+fWrFmzdOXKFdP2K1eu6Msvv1S+fPnUpk0bs2M++ugjTZw4UQ0aNCAAAgAAAAAAAAAA/4h/1XJwmTF8+HCtXbtWU6ZM0cGDB1WjRg0dOHBAGzZsUK1atfTuu++atd+7d69efPFF+fv7a+vWrabtnp6e+vLLL9W1a1fVqFFD7du3lyStWLFCd+7c0YoVK+Tm5mZqHxAQoAkTJsjOzk4+Pj6aOnWqRW0NGzZUw4YNn8ZpAwAAAAAAAACAHCrHhECurq7atm2bxo0bp9WrV2vLli0qXLiwhg4dqrFjxz7R83m6dOmifPnyafLkyVqwYIEMBoNq1qyp0aNH66WXXjJre/HiRUlSXFycpk+fnmKfhEAAAAAAAAAAACAr5ZgQSJJy586tGTNmaMaMGWm2bdiwoYxGY4r7mzdvrubNm6fZz7hx4zRu3LgnKRMAAAAAAAAAACDTcsQzgQAAAAAAAAAAAHIaQiAAAAAAAAAAAAArRAgEAAAAAAAAAABghQiBAAAAAAAAAAAArBAhEAAAAAAAAAAAgBUiBAIAAAAAAAAAALBChEAAAAAAAAAAAABWiBAIAAAAAAAAAADAChECAQAAAAD+v717D/KqvO8A/FlFLi7LJcIEjAheQKmxWgWrrrJYFS91aqwXJBXvookaqURpUy94l4SIFjMmI6OoRMXUaLVqgeCFkSrVsMkYRSWCgDdao4AsiMqe/pHZrSvXRRQ4PM/MzrDvec973rPny6vs53fOAQAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEtqgQaPHixbn44ovTvXv3tGrVKj169Mgll1ySJUuWNHusiRMnpqamJlVVVWnXrl0OOeSQTJkyZZ32nTBhQioqKlJRUZH777+/2ccGAAAAAABYmy0mBKqrq0tNTU1Gjx6d3XffPf/4j/+Y3XbbLaNGjcrf/M3f5OOPP17nscaPH58jjzwyM2fOzOmnn57TTjstL7/8cg4//PD827/92xr3fe+993L++eensrLyy54SAAAAAADAam0xIdCPf/zj/O53v8vw4cMzceLE3HjjjZk4cWKGDx+eF154IaNHj16ncT788MNceOGF6dSpU2bMmJExY8ZkzJgxmTFjRrbbbrt873vfy0cffbTa/YcMGZKqqqqcd955G+rUAAAAAAAAVrJFhEBFUWTs2LFp27ZtLr/88ibbLr/88rRt2zZjx45dp7F+9atfZeHChbnwwguzww47NLbvsMMOueCCC/L+++/noYceWuW+48aNy6OPPto4FwAAAAAAgK/KFhECzZo1K++8806qq6tXegxbZWVlqqurM3v27MyfP3+tYz399NNJkgEDBqy07YgjjkiSPPPMMyttmz9/foYOHZohQ4bk0EMPXY+zAAAAAAAAWHctNvYEvg6zZs1KkvTs2XOV23v27JmJEydm1qxZ6dat23qP1dDW0KdBURQ566yz0q5du4waNarZ829wwAEHrLL9D3/4Q3bcccdMnTp1vcdeX4sXL06SjXJsNi1qgUQd8GfqgAZqgWTVdbB48eK0a9duY00JAABgi7FFhECLFi1KkrRv336V2xv+AdrQb33HWt04P//5zzN58uT853/+Z6qqqtZ94gAAAAAAAOtpswqBhg0bluXLl69z/4suumi1d/98XWbPnp1LLrkkZ555ZuPj4tbXc889t8r2hjuE+vXr96XGXx8Nn+jcGMdm06IWSNQBf6YOaKAWSFZdB+4CAgAA+HpsViHQL37xi9TV1a1z/xNOOCE9e/ZsvGtndXf6NDyiYnV3Cn3e58fabrvt1jrOWWedlQ4dOuSmm25a53kDAAAAAAB8WVtt7Ak0x5IlS1IUxTp/9e/fP8nq39XTYG3vDPq8NY21qnFqa2vz9ttvp0OHDqmoqGj8uuqqq5IkgwYNSkVFRW6++eZ1+yEAAAAAAACsg83qTqD11bNnz2y//faZNm1a6urqUllZ2bitrq4u06ZNy0477ZRu3bqtdayamprcd999mTRpUvbff/8m2yZOnNjYp8Gpp56apUuXrjTOjBkzUltbm0MOOSQ777xzvv3tb6/v6QEAAAAAAKxkiwiBKioqcvbZZ+fqq6/ONddckxtvvLFx2zXXXJMlS5bkRz/6UZN9li5dmnnz5mXbbbfNjjvu2Nh+0kknZfjw4RkzZkzOPPPM7LDDDkmSt956K7feems6deqU4447rrH/v/7rv65yTiNGjEhtbW2GDBmSk08+eUOeLgAAAAAAwJYRAiXJpZdemn//93/PyJEjU1tbm3322SczZszIpEmT0rdv3wwdOrRJ///+7//OIYcckpqamjz99NON7R07dsytt96awYMHZ5999snAgQOTJBMmTMif/vSnTJgwIVVVVV/jmQEAAAAAAKxss3on0JdRWVmZZ555JkOHDs3MmTPz05/+NK+++mqGDRuWKVOmpE2bNus81imnnJInnngiu+++e+68886MGzcuf/EXf5FJkyblxBNP/ArPAgAAAAAAYN1sMXcCJUn79u0zevTojB49eq19+/fvn6IoVrv9yCOPzJFHHrnecxkxYkRGjBix3vsDAAAAAACsyRZzJxAAAAAAAMCWRAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACghIRAAAAAAAEAJCYEAAAAAAABKSAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACghIRAAAAAAAEAJCYEAAAAAAABKSAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACghIRAAAAAAAEAJCYEAAAAAAABKSAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACghIRAAAAAAAEAJCYEAAAAAAABKSAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACghIRAAAAAAAEAJCYEAAAAAAABKSAgEAAAAAABQQkIgAAAAAACAEhICAQAAAAAAlJAQCAAAAAAAoISEQAAAAAAAACUkBAIAAAAAACihFht7Anx5s2fPztKlS3PAAQd87cdevHhxkqRdu3Zf+7HZtKgFEnXAn6kDGqgFklXXwR/+8Idsu+22G2tKAAAAWwx3ApVAx44dN9o/oufNm5d58+ZtlGOzaVELJOqAP1MHNFALJKuug2233TYdO3bcSDMCAADYclQURVFs7Emw+Wq4++i5557byDNhY1MLJOqAP1MHNFALJOoAAABgY3InEAAAAAAAQAkJgQAAAAAAAEpICAQAAAAAAFBCQiAAAAAAAIASEgIBAAAAAACUUEVRFMXGngQAAAAAAAAbljuBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQ6+WFF17I0UcfnQ4dOqSysjL7779/HnjggY09Lb6kHj16pKKiYpVf/fv3X6n/8uXLc/XVV6dnz55p3bp1tt9++wwZMiT/8z//s9pj/PKXv8x+++2XysrKdOzYMcccc0xmzJjxFZ4VqzN+/Pice+656dOnT1q1apWKioqMGzdutf0XL16ciy++ON27d0+rVq3So0ePXHLJJVmyZMkq+9fX12fMmDHZc88906ZNm3Tu3DmDBg3K7NmzV3uMiRMnpqamJlVVVWnXrl0OOeSQTJky5cueKmvQnDoYMWLEateIioqKvPnmm6vcr7nX9fXXX89JJ52UTp06pU2bNtlrr71y2223pSiKDXDGrMrbb7+dm2++OQMGDMiOO+6Yli1bpkuXLjn++OMzffr0Ve5jTSif5taBNQEAAGDT12JjT4DNz1NPPZUjjjgirVu3zsknn5yqqqo8+OCDGThwYObPn59hw4Zt7CnyJbRv3z5Dhw5dqb1Hjx5Nvq+vr8+xxx6biRMnZv/998/xxx+fWbNmZezYsZkyZUqef/75dO7cuck+1113XS677LJ079495513Xj766KPcf//9OfDAAzNlypRUV1d/hWfGF1122WWZO3duOnXqlK5du2bu3Lmr7VtXV5eampr87ne/y4ABAzJo0KDU1tZm1KhReeaZZzJ16tS0bt26yT7nnntuxo4dmz322CM/+MEP8s477+SBBx7IpEmT8vzzz6dnz55N+o8fPz6DBw9O586dc/rppydJJkyYkMMPPzwPPPBATjjhhA3+M6B5ddDgtNNOW2lNSJIOHTqs1Nbc6/rKK6/kwAMPzLJly3LSSSdl++23z2OPPZbvf//7eeWVVzJmzJj1OU3WYsyYMRk5cmR22WWXDBgwIJ07d86sWbPy8MMP5+GHH869996bgQMHNva3JpRTc+uggTUBAABgE1ZAM3z66afFLrvsUrRq1aqora1tbF+4cGHRq1evomXLlsWbb7658SbIl9K9e/eie/fu69T3jjvuKJIUgwYNKurr6xvbb7vttiJJMWTIkCb9X3/99aJFixZFr169ioULFza219bWFq1atSp69+5drFixYoOcB+tm8uTJjX9fb7jhhiJJceedd66y7xVXXFEkKYYPH96kffjw4UWS4vrrr2/S/uSTTxZJin79+hXLly9vbH/88ceLJMWAAQOa9P/ggw+KDh06FJ06dSrmz5/f2D5//vyiU6dORadOnYrFixd/mdNlNZpTB1deeWWRpHjqqafWaez1ua79+vUrkhSPP/54Y9vy5cuLgw8+uEhS/Nd//VfzTpB18uCDDxZPP/30Su1Tp04tttlmm6Jjx47Fxx9/3NhuTSin5taBNQEAAGDT53FwNMuTTz6ZN954I9/97nez9957N7a3b98+P/rRj/LJJ5/krrvu2ngT5Gtz++23J0luuOGGVFRUNLafe+652XnnnfPLX/4yy5Yta2y/884789lnn+Vf/uVf0r59+8b2vffeO4MGDcrMmTPz7LPPfn0nQA477LB07959rf2KosjYsWPTtm3bXH755U22XX755Wnbtm3Gjh3bpL2hPq655pq0bNmysf2oo45K//79M2nSpMybN6+x/Ve/+lUWLlyYCy+8MDvssENj+w477JALLrgg77//fh566KH1Ok/WbF3rYH0097q+/vrrmTp1ag455JAcddRRje0tW7bMNddck+T/a4sN6+///u9TU1OzUvvBBx+cQw45JB9++GFeeumlJNaEMmtOHawPawIAAMDXTwhEszz99NNJkgEDBqy07YgjjkiSPPPMM1/nlNjAli9fnnHjxuX666/Prbfeusp3AHz88ceZPn16dtttt5V+eVxRUZHDDz88dXV1efHFFxvb1c7ma9asWXnnnXdSXV2dysrKJtsqKytTXV2d2bNnZ/78+Y3tTz/9dOO2L1rV9VYfm5epU6dm5MiR+clPfpKHH354te+Aae51XVP/gw46KJWVlepgI9hmm22SJC1a/PkpwtaELdMX6+DzrAkAAACbLu8EollmzZqVJCs9tz9JunTpkrZt2zb2YfP03nvv5YwzzmjS1rdv39x3333ZZZddkiRvvPFG6uvrV1kHyf/Xx6xZs3LwwQc3/rlt27bp0qXLGvuz6VnT3/uG9okTJ2bWrFnp1q1b6urq8u677+bb3/52tt5661X2//y4azuG+tj0XHnllU2+79ChQ2655ZaceuqpTdqbe13X1H/rrbfOTjvtlFdeeSWfffbZKn8RzYY3b968/OY3v0nXrl2z5557JrEmbIlWVQefZ00AAADYdLkTiGZZtGhRkjR5nNfntWvXrrEPm58zzjgjU6ZMyYIFC1JXV5fa2toMHjw4L7zwQg499NB89NFHSdatDj7fr+HPzenPpqO513t962N1+6iPTcdee+2VO+64I7Nnz86yZcsyZ86cjBkzJhUVFTn99NPzyCOPNOnf3Ou6LrVTX1/fuBbx1fr0008zePDgLF++PCNHjmwMcKwJW5bV1UFiTQAAANgc+Mgc0OiLn+Tde++9c/fddydJ7rnnntx+++25+OKLN8bUgE3Acccd1+T7Hj165IILLkjv3r1z+OGH57LLLsvf/d3fbaTZsSHV19fn9NNPz9SpU3POOedk8ODBG3tKbARrqwNrAgAAwKbPnUA0S8MnMVf36dvFixev9tOabL7OPffcJMm0adOSrFsdfL5fw5+b059NR3Ov9/rWx+r2UR+bvkMPPTS77LJLXnrppcbrlTT/uq5L7VRUVKSqqmqDzZ2V1dfX58wzz8y9996bU045JT//+c+bbLcmbBnWVgdrYk0AAADYdAiBaJY1PYf/vffey5IlS1b7jgA2X506dUqS1NXVJUl23nnnbLXVVqt9H8OqnuHfs2fPLFmyJO+999469WfTsbb3b3zx+lVWVqZr166ZM2dOVqxYsdb+azuG+tg8NKwTS5cubWxr7nVdU/8VK1Zkzpw52Wmnnbz74ytUX1+fM844I3fddVcGDRqUcePGZautmv7vojWh/NalDtbGmgAAALBpEALRLDU1NUmSSZMmrbRt4sSJTfpQHtOnT0/y58e8JEmbNm2y33775bXXXsvcuXOb9C2KIpMnT05lZWX69OnT2K52Nl89e/bM9ttvn2nTpjUGgQ3q6uoybdq07LTTTunWrVtje01NTeO2L2q43v369WvSP1Efm6u6urq8/PLLqaysbPzFb9L867qm/s8++2zq6urUwVeo4Rf/d999dwYOHJh77rmnyftfGlgTym1d62BNrAkAAACbkAKa4dNPPy123nnnolWrVkVtbW1j+8KFC4tevXoVLVu2LObMmbPR5sf6mzlzZlFXV7fK9i5duhRJimeeeaax/Y477iiSFIMGDSrq6+sb22+77bYiSTFkyJAm47z22mtFixYtil69ehULFy5sbK+trS1atWpV9O7du1ixYsVXcGasixtuuKFIUtx5552r3H7FFVcUSYrhw4c3aR8+fHiRpLj++uubtD/55JNFkqJfv37F8uXLG9sff/zxIkkxYMCAJv0/+OCDon379kWnTp2K+fPnN7bPnz+/6NSpU9GpU6di8eLFX/IsWZs11cHixYuL1157baX2pUuXFoMGDSqSFGeccUaTbetzXfv161ckKR5//PHGtuXLlxcHH3xwkaSYNm3alzxLVmXFihXFaaedViQpTjzxxOLTTz9dY39rQjk1pw6sCQAAAJuHiqIoiq81dWKz99RTT+WII45I69atc/LJJ6eqqioPPvhg5s6dm1GjRmXYsGEbe4qshxEjRuSmm25Kv3790r1791RWVub111/P448/nk8//TT//M//nOuvv76xf319fY4++uhMnDgx+++/f2pqavLHP/4xv/71r9OjR49Mnz49nTt3bnKM6667Lpdddlm6d++e448/Ph999FHuv//+fPLJJ5kyZUqqq6u/7tPeoo0dOzbPPvtskuSll17KjBkzUl1dnV133TVJctBBB+Xss89O8udPdVdXV+f3v/99BgwYkH322SczZszIpEmT0rdv3zzzzDNp06ZNk/HPOeecjB07NnvssUf+9m//Nu+++24mTJiQtm3b5rnnnkuvXr2a9B8/fnwGDx6czp07Z+DAgUmSCRMm5P3338+ECRNy4oknftU/ki3SutbBm2++mZ133jl9+/ZN796906VLlyxYsCC/+c1v8tZbb2XPPffMU089le22267J+M29ri+//HKqq6uzbNmyDBw4MF27ds1jjz2Wl19+ORdccEHGjBnzNfxUtjwjRozIVVddlbZt2+aiiy5a5eO1vvOd72TvvfdOYk0oq+bUgTUBAABgM7GxUyg2T9OnTy+OPPLIol27dkWbNm2K/fbbr7j//vs39rT4Ep5++unipJNOKnr27Fm0a9euaNGiRdGlS5fi2GOPLSZOnLjKfT7++ONixIgRxS677FK0bNmy6NKlS3H22WcX77333mqPM378+KJPnz5FmzZtivbt2xdHH3108dvf/varOi3WoOHT3qv7Ou2005r0X7hwYTF06NCiW7duxTbbbFPsuOOOxbBhw1b7afwVK1YUt9xyS7HHHnsUrVq1Krbbbrti4MCBxR//+MfVzumJJ54oDj744KKysrJo27ZtUVNTU0yePHlDnjZfsK51sGjRouL8888v+vbtW3Tu3Llo0aJFUVVVVey3337Fj3/842Lp0qWrPUZzr+urr75anHDCCcU3vvGNolWrVsWee+5Z/OxnP2ty1yEb1trqIKu4Q8yaUD7NqQNrAgAAwObBnUAAAAAAAAAltNXGngAAAAAAAAAbnhAIAAAAAACghIRAAAAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAQAkJgQAAAAAAAEpICAQAAAAAAFBCQiAAAAAAAIASEgIBAAAAAACUkBAIAAAAAACghIRAAAAAAAAAJSQEAmCz079//1RUVGzsaayzoiiy7777ZsCAAeu1/2WXXZaqqqosWLBgA88MAAAAgDITAgGwUVVUVDTra3N09913Z8aMGbn66qvXa/9hw4Zlq622ypVXXrmBZwYAAABAmVUURVFs7EkAsOUaMWLESm0333xzFi1atMrQY8SIEZk3b16WLl2a3Xff/WuY4ZdTX1+fXXbZJd26dcvUqVPXe5xhw4bllltuyRtvvJHu3btvwBkCAAAAUFZCIAA2OT169MjcuXNThv9EPfbYYznmmGNy++235+yzz17vcWpra7PPPvvksssuyzXXXLMBZwgAAABAWXkcHACbnVW9E2jcuHGpqKjIuHHj8uijj+av//qvs+222+Zb3/pWLr/88tTX1ydJ7rrrruy1115p06ZNdtxxx/zkJz9Z5TGKosgdd9yR6urqtGvXLttuu2369OmTO+64o1lzvfPOO1NRUZHjjz9+pW3vvvtuLrroovTs2TNt2rRJhw4d0rt375x33nlZtGhRk75/9Vd/lV133TXjxo1r1vEBAAAA2HK12NgTAIAN6aGHHsqkSZPyne98J9XV1Xnsscdy7bXXpiiKtG/fPtdee22OPfbY9O/fPw8++GAuvfTSfPOb38ypp57aOEZRFPmHf/iH3HfffenZs2e++93vpmXLlpk8eXLOOuusvPLKKxk1atRa51IURZ566qnstttu6dixY5NtS5cuTXV1dd58880MGDAgxx13XD755JPMmTMn99xzT374wx+mffv2TfY54IADcs899+T1119Pr169NswPDAAAAIDSEgIBUCpPPPFEpk2blr59+yZJrrrqquy6664ZPXp02rVrl9ra2uy8885Jkh/+8IfZddddM2rUqCYh0NixY3PffffljDPOyC9+8Ytss802SZJPPvkkJ5xwQn76059m0KBB2Xfffdc4l5kzZ+aDDz7IUUcdtdK2KVOmZM6cORk6dGhGjx7dZNuSJUsaj/l5ffr0yT333JNp06YJgQAAAABYK4+DA6BUTjnllMYAKEmqqqpyzDHHZOnSpfne977XGAAlSbdu3XLQQQfllVdeyWeffdbYfuutt6aysjI/+9nPmoQxLVu2zHXXXZckue+++9Y6l7feeitJ8s1vfnO1fdq0abNSW9u2bdOqVauV2hvGaRgXAAAAANbEnUAAlMree++9UlvXrl3XuG3FihVZsGBBvvWtb2Xp0qV56aWXsv3222fkyJEr9f/000+TJK+++upa5/KnP/0pSdKhQ4eVtvXr1y9du3bNjTfemN///vc55phjUlNTk969e6/0vqMG3/jGN5Ik77///lqPDQAAAABCIABKpV27diu1tWjRYq3bGsKdDz/8MEVR5O23385VV1212uPU1dWtdS4Nd/l8/PHHK21r3759nn/++VxxxRV59NFH8/jjjyf5891J//RP/5Tvf//7K+2zbNmyJMm222671mMDAAAAgMfBAcDnNARF++67b4qiWO3XU089tdaxOnfunCT54IMPVrl9xx13zLhx4/K///u/qa2tzciRI1NfX5/zzz9/lY+baxinYVwAAAAAWBMhEAB8TlVVVXr37p2ZM2dm4cKFX2qsPfbYI1tttVVee+21Nfbbaqutsvfee+fSSy9tDH8eeeSRlfo1jLPnnnt+qXkBAAAAsGUQAgHAF/zgBz/I0qVLc84556zysW9z5szJm2++udZxOnTokL/8y7/Miy++mPr6+ibbXn755SxYsGClfRraWrduvdK26dOnp0WLFjnwwAPX8UwAAAAA2JJ5JxAAfMG5556b559/PnfddVemTZuWww47LNtvv30WLFiQV199NdOnT8+9996bHj16rHWs4447LldeeWWef/75JuHN5MmTc8kll6S6ujq9evXKdtttl9mzZ+eRRx5J69atc/755zcZZ8mSJXn++edz+OGHp7KyckOfMgAAAAAl5E4gAPiCioqKjBs3LhMmTMgee+yR//iP/8hNN92UyZMnp3Xr1hk1alQOO+ywdRrr7LPPTosWLTJ+/Pgm7UcccUTOP//8LF68OL/+9a8zevTovPjiixk4cGB++9vfpk+fPk36P/jgg1m2bFnOPffcDXaeAAAAAJRbRVEUxcaeBACU2eDBg/PYY49l7ty5qaqqWq8xDj744CxYsCAzZ87M1ltvvYFnCAAAAEAZuRMIAL5i1157bZYtW5YxY8as1/5TpkzJs88+m5EjRwqAAAAAAFhnQiAA+Ip17949d91113rfBbRo0aKMGjUqxx133AaeGQAAAABl5nFwAAAAAAAAJeROIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoISEQAAAAAABACQmBAAAAAAAASkgIBAAAAAAAUEJCIAAAAAAAgBISAgEAAAAAAJSQEAgAAAAAAKCEhEAAAAAAAAAlJAQCAAAAAAAoof8DLR0mskKSeHQAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1680x1120 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1680x1120 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 4.1 System dashboard: latency + throughput\n",
+    "fig_sys, axes_sys = plt.subplots(1, 2, figsize=(12, 4.5), dpi=140)\n",
+    "results.plot_latency_distribution(axes_sys[0])\n",
+    "results.plot_throughput(axes_sys[1])\n",
+    "fig_sys.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# 4.2 Server time-series and event-metric dashboards\n",
+    "sids = results.list_server_ids()\n",
+    "for sid in sids:\n",
+    "    # --- dashboards ---\n",
+    "    fig_ts, axes_ts = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n",
+    "    axes_ts[1, 1].axis(\"off\")\n",
+    "    results.plot_server_timeseries_dashboard(\n",
+    "        ax_ready=axes_ts[0, 0],\n",
+    "        ax_io=axes_ts[0, 1],\n",
+    "        ax_ram=axes_ts[1, 0],\n",
+    "        server_id=sid,\n",
+    "    )\n",
+    "    fig_ts.suptitle(f\"Time-series — {sid}\")\n",
+    "    fig_ts.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "    fig_ev, axes_ev = plt.subplots(2, 2, figsize=(12, 8), dpi=140)\n",
+    "    results.plot_server_event_metrics_dashboard(\n",
+    "        ax_latency_hist=axes_ev[0, 0],\n",
+    "        ax_service_hist=axes_ev[0, 1],\n",
+    "        ax_io_hist=axes_ev[1, 0],\n",
+    "        ax_wait_hist=axes_ev[1, 1],\n",
+    "        server_id=sid,\n",
+    "    )\n",
+    "    fig_ev.suptitle(f\"Event metrics — {sid}\")\n",
+    "    fig_ev.tight_layout()\n",
+    "    plt.show()\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "asyncflow-sim-py3.12 (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/api/components.md b/docs/api/components.md
index 15f97c2..d775dc5 100644
--- a/docs/api/components.md
+++ b/docs/api/components.md
@@ -17,7 +17,7 @@ These classes are Pydantic models with strict validation and are the
 from asyncflow.components import (
     Client,
     Server,
-    ServerResources,
+    NodesResources,
     LoadBalancer,
     Endpoint,
     Edge,
@@ -32,7 +32,7 @@ from asyncflow.enums import Distribution
 
 ```python
 from asyncflow.components import (
-    Client, Server, ServerResources, LoadBalancer, Endpoint, Edge
+    Client, Server, NodesResources, LoadBalancer, Endpoint, Edge
 )
 
 # Nodes
@@ -49,7 +49,7 @@ endpoint = Endpoint(
 
 server = Server(
     id="srv-1",
-    server_resources=ServerResources(cpu_cores=2, ram_mb=2048),
+    server_resources=NodesResources(cpu_cores=2, ram_mb=2048),
     endpoints=[endpoint],
 )
 
@@ -103,10 +103,10 @@ Client(id: str)
 
 ---
 
-### `ServerResources`
+### `NodesResources`
 
 ```python
-ServerResources(
+NodesResources(
     cpu_cores: int = 1,          # ≥ 1 NOW MUST BE FIXED TO ONE
     ram_mb: int = 1024,          # ≥ 256
     db_connection_pool: int | None = None,
@@ -114,7 +114,7 @@ ServerResources(
 ```
 
 * Server capacity knobs used by the runtime (CPU tokens, RAM reservoir, optional DB pool).
-* You may pass a **dict** instead of `ServerResources`; Pydantic will coerce it.
+* You may pass a **dict** instead of `NodesResources`; Pydantic will coerce it.
 
 **Bounds & defaults**
 
@@ -166,7 +166,7 @@ Each step is a dict with **exactly one** operation:
 ```python
 Server(
     id: str,
-    server_resources: ServerResources | dict,
+    server_resources: NodesResources | dict,
     endpoints: list[Endpoint],
 )
 ```
@@ -234,7 +234,7 @@ Edge(
 ## Type coercion & enums
 
 * You may pass strings for enums (`kind`, `distribution`, etc.); they will be validated against the allowed values.
-* For `ServerResources` and `Edge.latency` you can pass dictionaries; Pydantic will coerce them to typed models.
+* For `NodesResources` and `Edge.latency` you can pass dictionaries; Pydantic will coerce them to typed models.
 * If you prefer, you can import and use the enums:
 
   ```python
diff --git a/docs/index.md b/docs/index.md
index a4affc2..cdb8768 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -14,7 +14,7 @@ AsyncFlow is a discrete-event simulator for Python async backends (FastAPI/Uvico
 ## Public API (stable surface)
 
 * **[High-Level API](api/high-level.md)** — The two entry points you’ll use most: `AsyncFlow` (builder) and `SimulationRunner` (orchestrator).
-* **[Components](api/components.md)** — Public Pydantic models for topology: `Client`, `Server`, `Endpoint`, `Edge`, `LoadBalancer`, `ServerResources`.
+* **[Components](api/components.md)** — Public Pydantic models for topology: `Client`, `Server`, `Endpoint`, `Edge`, `LoadBalancer`, `NodesResources`.
 * **[Workload](api/workload.md)** — Traffic inputs: `RqsGenerator` and `RVConfig` (random variables).
 * **[Settings](api/settings.md)** — Global controls: `SimulationSettings` (duration, sampling cadence, metrics).
 * **[Enums](api/enums.md)** — Optional importable enums: distributions, step kinds/ops, metric names, node/edge types, LB algorithms.
diff --git a/docs/internals/runtime-and-resources.md b/docs/internals/runtime-and-resources.md
index 32f1611..903fddf 100644
--- a/docs/internals/runtime-and-resources.md
+++ b/docs/internals/runtime-and-resources.md
@@ -88,7 +88,7 @@ AsyncFlow mirrors that physical constraint through the **Resource layer**, which
 
 | Responsibility        | Implementation detail                                                                                                                                                                                            |
 | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Discover capacity** | Walks the *validated* `TopologyGraph.nodes.servers`, reading `cpu_cores` and `ram_mb` from each `ServerResources` spec.                                                                                          |
+| **Discover capacity** | Walks the *validated* `TopologyGraph.nodes.servers`, reading `cpu_cores` and `ram_mb` from each `NodesResources` spec.                                                                                          |
 | **Mint containers**   | Calls `build_containers(env, spec)` which returns<br>`{"CPU": simpy.Container(init=cpu_cores), "RAM": simpy.Container(init=ram_mb)}` — the containers start **full** so a server can immediately consume tokens. |
 | **Registry map**      | Stores them in a private dict `_by_server: dict[str, ServerContainers]`.                                                                                                                                         |
 | **Public API**        | `registry[server_id] → ServerContainers` (raises `KeyError` if the ID is unknown).                                                                                                                               |
diff --git a/docs/internals/simulation-input.md b/docs/internals/simulation-input.md
index f6bbbcd..aa9a8c5 100644
--- a/docs/internals/simulation-input.md
+++ b/docs/internals/simulation-input.md
@@ -114,15 +114,15 @@ class Client(BaseModel):
     # validator: type must equal SystemNodes.CLIENT
 ```
 
-#### `ServerResources`
+#### `NodesResources`
 
 ```python
-class ServerResources(BaseModel):
-    cpu_cores: PositiveInt = Field(ServerResourcesDefaults.CPU_CORES,
-                                   ge=ServerResourcesDefaults.MINIMUM_CPU_CORES)
-    db_connection_pool: PositiveInt | None = Field(ServerResourcesDefaults.DB_CONNECTION_POOL)
-    ram_mb: PositiveInt = Field(ServerResourcesDefaults.RAM_MB,
-                                ge=ServerResourcesDefaults.MINIMUM_RAM_MB)
+class NodesResources(BaseModel):
+    cpu_cores: PositiveInt = Field(NodesResourcesDefaults.CPU_CORES,
+                                   ge=NodesResourcesDefaults.MINIMUM_CPU_CORES)
+    db_connection_pool: PositiveInt | None = Field(NodesResourcesDefaults.DB_CONNECTION_POOL)
+    ram_mb: PositiveInt = Field(NodesResourcesDefaults.RAM_MB,
+                                ge=NodesResourcesDefaults.MINIMUM_RAM_MB)
 ```
 
 Each attribute maps directly to a SimPy primitive (core tokens, RAM container, optional DB pool).
@@ -164,7 +164,7 @@ Canonical lowercase names avoid accidental duplicates by case.
 class Server(BaseModel):
     id: str
     type: SystemNodes = SystemNodes.SERVER
-    server_resources: ServerResources
+    server_resources: NodesResources
     endpoints: list[Endpoint]
     # validator: type must equal SystemNodes.SERVER
 ```
@@ -302,7 +302,7 @@ class SimulationSettings(BaseModel):
 ### Nodes
 
 * `Client.type == client`, `Server.type == server`, `LoadBalancer.type == load_balancer` (enforced).
-* `ServerResources` obey lower bounds: `cpu_cores ≥ 1`, `ram_mb ≥ 256`.
+* `NodesResources` obey lower bounds: `cpu_cores ≥ 1`, `ram_mb ≥ 256`.
 * `TopologyNodes` contains **unique ids** across `client`, `servers[]`, and (optional) `load_balancer`. Duplicates → `ValueError`.
 * `TopologyNodes` forbids unknown fields (`extra="forbid"`).
 
diff --git a/examples/builder_input/event_injection/lb_two_servers.py b/examples/builder_input/event_injection/lb_two_servers.py
deleted file mode 100644
index 8af411f..0000000
--- a/examples/builder_input/event_injection/lb_two_servers.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""
-AsyncFlow builder example — LB + 2 servers (medium load) with events.
-
-Topology
-  generator → client → LB → srv-1
-                         └→ srv-2
-  srv-1 → client
-  srv-2 → client
-
-Workload
-  ~40 rps (120 users × 20 req/min ÷ 60).
-
-Events
-  - Edge spike on client→LB (+15 ms) @ [100s, 160s]
-  - srv-1 outage @ [180s, 240s]
-  - Edge spike on LB→srv-2 (+20 ms) @ [300s, 360s]
-  - srv-2 outage @ [360s, 420s]
-  - Edge spike on gen→client (+10 ms) @ [480s, 540s]
-
-Outputs
-  PNGs saved under `lb_two_servers_events_plots/` next to this script:
-    - dashboard (latency + throughput)
-    - per-server plots: ready queue, I/O queue, RAM
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import simpy
-
-# Public builder API
-from asyncflow import AsyncFlow
-from asyncflow.components import Client, Server, Edge, Endpoint, LoadBalancer
-from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
-
-# Runner + Analyzer
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-def build_and_run() -> ResultsAnalyzer:
-    """Build the scenario via the builder and run the simulation."""
-    # ── Workload (generator) ───────────────────────────────────────────────
-    generator = RqsGenerator(
-        id="rqs-1",
-        avg_active_users={"mean": 120},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
-    )
-
-    # ── Client ────────────────────────────────────────────────────────────
-    client = Client(id="client-1")
-
-    # ── Servers (identical endpoint: CPU 2ms → RAM 128MB → IO 12ms) ───────
-    endpoint = Endpoint(
-        endpoint_name="/api",
-        steps=[
-            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.002}},
-            {"kind": "ram", "step_operation": {"necessary_ram": 128}},
-            {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.012}},
-        ],
-    )
-    srv1 = Server(
-        id="srv-1",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-    srv2 = Server(
-        id="srv-2",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-
-    # ── Load Balancer ─────────────────────────────────────────────────────
-    lb = LoadBalancer(
-        id="lb-1",
-        algorithms="round_robin",
-        server_covered=["srv-1", "srv-2"],
-    )
-
-    # ── Edges (exponential latency) ───────────────────────────────────────
-    e_gen_client = Edge(
-        id="gen-client",
-        source="rqs-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_client_lb = Edge(
-        id="client-lb",
-        source="client-1",
-        target="lb-1",
-        latency={"mean": 0.002, "distribution": "exponential"},
-    )
-    e_lb_srv1 = Edge(
-        id="lb-srv1",
-        source="lb-1",
-        target="srv-1",
-        latency={"mean": 0.002, "distribution": "exponential"},
-    )
-    e_lb_srv2 = Edge(
-        id="lb-srv2",
-        source="lb-1",
-        target="srv-2",
-        latency={"mean": 0.002, "distribution": "exponential"},
-    )
-    e_srv1_client = Edge(
-        id="srv1-client",
-        source="srv-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_srv2_client = Edge(
-        id="srv2-client",
-        source="srv-2",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-
-    # ── Simulation settings ───────────────────────────────────────────────
-    settings = SimulationSettings(
-        total_simulation_time=600,
-        sample_period_s=0.05,
-        enabled_sample_metrics=[
-            "ready_queue_len",
-            "event_loop_io_sleep",
-            "ram_in_use",
-            "edge_concurrent_connection",
-        ],
-        enabled_event_metrics=["rqs_clock"],
-    )
-
-    # ── Assemble payload + events via builder ─────────────────────────────
-    payload = (
-        AsyncFlow()
-        .add_generator(generator)
-        .add_client(client)
-        .add_servers(srv1, srv2)
-        .add_load_balancer(lb)
-        .add_edges(
-            e_gen_client,
-            e_client_lb,
-            e_lb_srv1,
-            e_lb_srv2,
-            e_srv1_client,
-            e_srv2_client,
-        )
-        .add_simulation_settings(settings)
-        # Events
-        .add_network_spike(
-            event_id="ev-spike-1",
-            edge_id="client-lb",
-            t_start=100.0,
-            t_end=160.0,
-            spike_s=0.015,  # +15 ms
-        )
-        .add_server_outage(
-            event_id="ev-srv1-down",
-            server_id="srv-1",
-            t_start=180.0,
-            t_end=240.0,
-        )
-        .add_network_spike(
-            event_id="ev-spike-2",
-            edge_id="lb-srv2",
-            t_start=300.0,
-            t_end=360.0,
-            spike_s=0.020,  # +20 ms
-        )
-        .add_server_outage(
-            event_id="ev-srv2-down",
-            server_id="srv-2",
-            t_start=360.0,
-            t_end=420.0,
-        )
-        .add_network_spike(
-            event_id="ev-spike-3",
-            edge_id="gen-client",
-            t_start=480.0,
-            t_end=540.0,
-            spike_s=0.010,  # +10 ms
-        )
-        .build_payload()
-    )
-
-    # ── Run ───────────────────────────────────────────────────────────────
-    env = simpy.Environment()
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-    return results
-
-
-def main() -> None:
-    res = build_and_run()
-    print(res.format_latency_stats())
-
-    # Output directory next to this script
-    script_dir = Path(__file__).parent
-    out_dir = script_dir / "lb_two_servers_events_plots"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    # Dashboard (latency + throughput)
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    res.plot_base_dashboard(axes[0], axes[1])
-    fig.tight_layout()
-    dash_path = out_dir / "lb_two_servers_events_dashboard.png"
-    fig.savefig(dash_path)
-    print(f"Saved: {dash_path}")
-
-    # Per-server plots
-    for sid in res.list_server_ids():
-        # Ready queue
-        f1, a1 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_ready_queue(a1, sid)
-        f1.tight_layout()
-        p1 = out_dir / f"lb_two_servers_events_ready_queue_{sid}.png"
-        f1.savefig(p1)
-        print(f"Saved: {p1}")
-
-        # I/O queue
-        f2, a2 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_io_queue(a2, sid)
-        f2.tight_layout()
-        p2 = out_dir / f"lb_two_servers_events_io_queue_{sid}.png"
-        f2.savefig(p2)
-        print(f"Saved: {p2}")
-
-        # RAM usage
-        f3, a3 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_ram(a3, sid)
-        f3.tight_layout()
-        p3 = out_dir / f"lb_two_servers_events_ram_{sid}.png"
-        f3.savefig(p3)
-        print(f"Saved: {p3}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_dashboard.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_dashboard.png
deleted file mode 100644
index 2177ffb..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_dashboard.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-1.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-1.png
deleted file mode 100644
index 9c7ffba..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-2.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-2.png
deleted file mode 100644
index 678c839..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_io_queue_srv-2.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-1.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-1.png
deleted file mode 100644
index c8102f8..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-2.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-2.png
deleted file mode 100644
index ddf4a20..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ram_srv-2.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-1.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-1.png
deleted file mode 100644
index 3464e5f..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-2.png b/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-2.png
deleted file mode 100644
index cfb8c0f..0000000
Binary files a/examples/builder_input/event_injection/lb_two_servers_events_plots/lb_two_servers_events_ready_queue_srv-2.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/single_server.py b/examples/builder_input/event_injection/single_server.py
deleted file mode 100644
index 0c514b2..0000000
--- a/examples/builder_input/event_injection/single_server.py
+++ /dev/null
@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-"""
-AsyncFlow builder example — build, run, and visualize a single-server async system
-with event injections (latency spike on edge + server outage).
-
-Topology (single server)
-    generator ──edge──> client ──edge──> server ──edge──> client
-
-Load model
-    ~100 active users, 20 requests/min each (Poisson-like aggregate).
-
-Server model
-    1 CPU core, 2 GB RAM
-    Endpoint pipeline: CPU(1 ms) → RAM(100 MB) → I/O wait (100 ms)
-    Semantics:
-      - CPU step blocks the event loop
-      - RAM step holds a working set until request completion
-      - I/O step is non-blocking (event-loop friendly)
-
-Network model
-    Each edge has exponential latency with mean 3 ms.
-
-Events
-    - ev-spike-1: deterministic latency spike (+20 ms) on client→server edge,
-      active from t=120s to t=240s
-    - ev-outage-1: server outage for srv-1 from t=300s to t=360s
-
-Outputs
-    - Prints latency statistics to stdout
-    - Saves PNGs in `single_server_plot/` next to this script:
-        * dashboard (latency + throughput)
-        * per-server plots (ready queue, I/O queue, RAM)
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-import simpy
-import matplotlib.pyplot as plt
-
-# Public AsyncFlow API (builder)
-from asyncflow import AsyncFlow
-from asyncflow.components import Client, Server, Edge, Endpoint
-from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
-
-# Runner + Analyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def build_and_run() -> ResultsAnalyzer:
-    """Build the scenario via the Pythonic builder and run the simulation."""
-    # Workload (generator)
-    generator = RqsGenerator(
-        id="rqs-1",
-        avg_active_users={"mean": 100},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
-    )
-
-    # Client
-    client = Client(id="client-1")
-
-    # Server + endpoint (CPU → RAM → I/O)
-    endpoint = Endpoint(
-        endpoint_name="ep-1",
-        probability=1.0,
-        steps=[
-            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.001}},  # 1 ms
-            {"kind": "ram", "step_operation": {"necessary_ram": 100}},           # 100 MB
-            {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.100}},   # 100 ms
-        ],
-    )
-    server = Server(
-        id="srv-1",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-
-    # Network edges (3 ms mean, exponential)
-    e_gen_client = Edge(
-        id="gen-client",
-        source="rqs-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_client_srv = Edge(
-        id="client-srv",
-        source="client-1",
-        target="srv-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_srv_client = Edge(
-        id="srv-client",
-        source="srv-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-
-    # Simulation settings
-    settings = SimulationSettings(
-        total_simulation_time=500,
-        sample_period_s=0.05,
-        enabled_sample_metrics=[
-            "ready_queue_len",
-            "event_loop_io_sleep",
-            "ram_in_use",
-            "edge_concurrent_connection",
-        ],
-        enabled_event_metrics=["rqs_clock"],
-    )
-
-    # Assemble payload with events
-    payload = (
-        AsyncFlow()
-        .add_generator(generator)
-        .add_client(client)
-        .add_servers(server)
-        .add_edges(e_gen_client, e_client_srv, e_srv_client)
-        .add_simulation_settings(settings)
-        # Events
-        .add_network_spike(
-            event_id="ev-spike-1",
-            edge_id="client-srv",
-            t_start=120.0,
-            t_end=240.0,
-            spike_s=0.020,  # 20 ms spike
-        )
-    ).build_payload()
-
-    # Run
-    env = simpy.Environment()
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-    return results
-
-
-def main() -> None:
-    # Build & run
-    res = build_and_run()
-
-    # Print concise latency summary
-    print(res.format_latency_stats())
-
-    # Prepare output dir
-    script_dir = Path(__file__).parent
-    out_dir = script_dir / "single_server_plot"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    # Dashboard (latency + throughput)
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    res.plot_base_dashboard(axes[0], axes[1])
-    fig.tight_layout()
-    dash_path = out_dir / "event_inj_single_server_dashboard.png"
-    fig.savefig(dash_path)
-    print(f"Saved: {dash_path}")
-
-    # Per-server plots
-    for sid in res.list_server_ids():
-        # Ready queue
-        f1, a1 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_ready_queue(a1, sid)
-        f1.tight_layout()
-        p1 = out_dir / f"event_inj_single_server_ready_queue_{sid}.png"
-        f1.savefig(p1)
-        print(f"Saved: {p1}")
-
-        # I/O queue
-        f2, a2 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_io_queue(a2, sid)
-        f2.tight_layout()
-        p2 = out_dir / f"event_inj_single_server_io_queue_{sid}.png"
-        f2.savefig(p2)
-        print(f"Saved: {p2}")
-
-        # RAM usage
-        f3, a3 = plt.subplots(figsize=(10, 5))
-        res.plot_single_server_ram(a3, sid)
-        f3.tight_layout()
-        p3 = out_dir / f"event_inj_single_server_ram_{sid}.png"
-        f3.savefig(p3)
-        print(f"Saved: {p3}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_dashboard.png b/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_dashboard.png
deleted file mode 100644
index 1a81453..0000000
Binary files a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_dashboard.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_io_queue_srv-1.png b/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_io_queue_srv-1.png
deleted file mode 100644
index ed08233..0000000
Binary files a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ram_srv-1.png b/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ram_srv-1.png
deleted file mode 100644
index 476bd79..0000000
Binary files a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ram_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ready_queue_srv-1.png b/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ready_queue_srv-1.png
deleted file mode 100644
index a6fcf29..0000000
Binary files a/examples/builder_input/event_injection/single_server_plot/event_inj_single_server_ready_queue_srv-1.png and /dev/null differ
diff --git a/examples/builder_input/load_balancer/lb_dashboard.png b/examples/builder_input/load_balancer/lb_dashboard.png
deleted file mode 100644
index dd6cc80..0000000
Binary files a/examples/builder_input/load_balancer/lb_dashboard.png and /dev/null differ
diff --git a/examples/builder_input/load_balancer/lb_server_srv-1_metrics.png b/examples/builder_input/load_balancer/lb_server_srv-1_metrics.png
deleted file mode 100644
index d7f57e6..0000000
Binary files a/examples/builder_input/load_balancer/lb_server_srv-1_metrics.png and /dev/null differ
diff --git a/examples/builder_input/load_balancer/lb_server_srv-2_metrics.png b/examples/builder_input/load_balancer/lb_server_srv-2_metrics.png
deleted file mode 100644
index f055ff4..0000000
Binary files a/examples/builder_input/load_balancer/lb_server_srv-2_metrics.png and /dev/null differ
diff --git a/examples/builder_input/load_balancer/two_servers.py b/examples/builder_input/load_balancer/two_servers.py
deleted file mode 100644
index a57d090..0000000
--- a/examples/builder_input/load_balancer/two_servers.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""
-Didactic example: AsyncFlow with a Load Balancer and two **identical** servers.
-
-Goal
-----
-Show a realistic, symmetric backend behind a load balancer, and export plots
-that match the public `ResultsAnalyzer` API (no YAML needed).
-
-Topology
---------
-    generator ──edge──> client ──edge──> LB ──edge──> srv-1
-                                         └──edge──> srv-2
-    srv-1 ──edge──> client
-    srv-2 ──edge──> client
-
-Load model
-----------
-~120 active users, 20 requests/min each (Poisson-like aggregate by default).
-
-Server model (both srv-1 and srv-2)
------------------------------------
-• 1 CPU cores, 2 GB RAM
-• Endpoint pipeline: CPU(2 ms) → RAM(128 MB) → I/O wait (15 ms)
-  - CPU step blocks the event loop
-  - RAM step holds a working set until the request completes
-  - I/O step is non-blocking (event-loop friendly)
-
-Network model
--------------
-Every edge uses an exponential latency with mean 3 ms.
-
-Outputs
--------
-• Prints latency statistics to stdout
-• Saves, in the same folder as this script:
-  - `lb_dashboard.png`  (Latency histogram + Throughput)
-  - `lb_server_<id>_metrics.png` for each server (Ready / I/O / RAM)
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import simpy
-import matplotlib.pyplot as plt
-
-# Public AsyncFlow API (builder-style)
-from asyncflow import AsyncFlow
-from asyncflow.components import Client, Server, Edge, Endpoint, LoadBalancer
-from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
-
-# Runner + Analyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def main() -> None:
-    # ── 1) Build the scenario programmatically (no YAML) ────────────────────
-    # Workload (traffic generator)
-    generator = RqsGenerator(
-        id="rqs-1",
-        avg_active_users={"mean": 120},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
-    )
-
-    # Client
-    client = Client(id="client-1")
-
-    # Two identical servers: CPU(2ms) → RAM(128MB) → IO(15ms)
-    endpoint = Endpoint(
-        endpoint_name="/api",
-        probability=1.0,
-        steps=[
-            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.002}},
-            {"kind": "ram", "step_operation": {"necessary_ram": 128}},
-            {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.015}},
-        ],
-    )
-
-    srv1 = Server(
-        id="srv-1",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-    srv2 = Server(
-        id="srv-2",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-
-    # Load balancer (round-robin)
-    lb = LoadBalancer(
-        id="lb-1",
-        algorithms="round_robin",
-        server_covered={"srv-1", "srv-2"},
-    )
-
-    # Network edges (3 ms mean, exponential)
-    edges = [
-        Edge(
-            id="gen-client",
-            source="rqs-1",
-            target="client-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-        Edge(
-            id="client-lb",
-            source="client-1",
-            target="lb-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-        Edge(
-            id="lb-srv1",
-            source="lb-1",
-            target="srv-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-        Edge(
-            id="lb-srv2",
-            source="lb-1",
-            target="srv-2",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-        Edge(
-            id="srv1-client",
-            source="srv-1",
-            target="client-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-        Edge(
-            id="srv2-client",
-            source="srv-2",
-            target="client-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
-        ),
-    ]
-
-    # Simulation settings
-    settings = SimulationSettings(
-        total_simulation_time=600,
-        sample_period_s=0.05,
-        enabled_sample_metrics=[
-            "ready_queue_len",
-            "event_loop_io_sleep",
-            "ram_in_use",
-            "edge_concurrent_connection",
-        ],
-        enabled_event_metrics=["rqs_clock"],
-    )
-
-    # Assemble the payload with the builder
-    payload = (
-        AsyncFlow()
-        .add_generator(generator)
-        .add_client(client)
-        .add_servers(srv1, srv2)
-        .add_load_balancer(lb)
-        .add_edges(*edges)
-        .add_simulation_settings(settings)
-    ).build_payload()
-
-    # ── 2) Run the simulation ───────────────────────────────────────────────
-    env = simpy.Environment()
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-
-    # ── 3) Print a concise latency summary ──────────────────────────────────
-    print(results.format_latency_stats())
-
-    # ── 4) Save plots (same directory as this script) ───────────────────────
-    out_dir = Path(__file__).parent
-
-    # 4a) Dashboard: latency + throughput (single figure)
-    fig_dash, axes = plt.subplots(
-        1, 2, figsize=(14, 5), dpi=160, constrained_layout=True
-    )
-    results.plot_latency_distribution(axes[0])
-    results.plot_throughput(axes[1])
-    dash_path = out_dir / "lb_dashboard.png"
-    fig_dash.savefig(dash_path, bbox_inches="tight")
-    print(f"🖼️  Dashboard saved to: {dash_path}")
-
-    # 4b) Per-server figures: Ready | I/O | RAM (one row per server)
-    for sid in results.list_server_ids():
-        fig_srv, axs = plt.subplots(
-            1, 3, figsize=(18, 4.2), dpi=160, constrained_layout=True
-        )
-        results.plot_single_server_ready_queue(axs[0], sid)
-        results.plot_single_server_io_queue(axs[1], sid)
-        results.plot_single_server_ram(axs[2], sid)
-        fig_srv.suptitle(f"Server metrics — {sid}", fontsize=16)
-        srv_path = out_dir / f"lb_server_{sid}_metrics.png"
-        fig_srv.savefig(srv_path, bbox_inches="tight")
-        print(f"🖼️  Per-server plots saved to: {srv_path}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/builder_input/single_server/builder_service_plots.png b/examples/builder_input/single_server/builder_service_plots.png
deleted file mode 100644
index 31c230e..0000000
Binary files a/examples/builder_input/single_server/builder_service_plots.png and /dev/null differ
diff --git a/examples/builder_input/single_server/single_server.py b/examples/builder_input/single_server/single_server.py
deleted file mode 100644
index 7fb7e99..0000000
--- a/examples/builder_input/single_server/single_server.py
+++ /dev/null
@@ -1,161 +0,0 @@
-"""
-AsyncFlow builder example — build, run, and visualize a single-server async system.
-
-Topology (single server)
-    generator ──edge──> client ──edge──> server ──edge──> client
-
-Load model
-    ~100 active users, 20 requests/min each (Poisson-like aggregate).
-
-Server model
-    1 CPU core, 2 GB RAM
-    Endpoint pipeline: CPU(1 ms) → RAM(100 MB) → I/O wait (100 ms)
-    Semantics:
-      - CPU step blocks the event loop
-      - RAM step holds a working set until request completion
-      - I/O step is non-blocking (event-loop friendly)
-
-Network model
-    Each edge has exponential latency with mean 3 ms.
-
-Outputs
-    - Prints latency statistics to stdout
-    - Saves a 2×2 PNG in the same directory as this script:
-        [0,0] Latency histogram (with mean/P50/P95/P99)
-        [0,1] Throughput (with mean/P95/max overlays)
-        [1,0] Ready queue for the first server
-        [1,1] RAM usage for the first server
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-import simpy
-import matplotlib.pyplot as plt
-
-# Public AsyncFlow API (builder)
-from asyncflow import AsyncFlow
-from asyncflow.components import Client, Server, Edge, Endpoint
-from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
-
-# Runner + Analyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def build_and_run() -> ResultsAnalyzer:
-    """Build the scenario via the Pythonic builder and run the simulation."""
-    # Workload (generator)
-    generator = RqsGenerator(
-        id="rqs-1",
-        avg_active_users={"mean": 100},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
-    )
-
-    # Client
-    client = Client(id="client-1")
-
-    # Server + endpoint (CPU → RAM → I/O)
-    endpoint = Endpoint(
-        endpoint_name="/api",
-        probability=1.0,
-        steps=[
-            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.001}},  # 1 ms
-            {"kind": "ram", "step_operation": {"necessary_ram": 100}},           # 100 MB
-            {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.100}},   # 100 ms
-        ],
-    )
-    server = Server(
-        id="app-1",
-        server_resources={"cpu_cores": 1, "ram_mb": 2048},
-        endpoints=[endpoint],
-    )
-
-    # Network edges (3 ms mean, exponential)
-    e_gen_client = Edge(
-        id="gen-client",
-        source="rqs-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_client_app = Edge(
-        id="client-app",
-        source="client-1",
-        target="app-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-    e_app_client = Edge(
-        id="app-client",
-        source="app-1",
-        target="client-1",
-        latency={"mean": 0.003, "distribution": "exponential"},
-    )
-
-    # Simulation settings
-    settings = SimulationSettings(
-        total_simulation_time=300,
-        sample_period_s=0.05,
-        enabled_sample_metrics=[
-            "ready_queue_len",
-            "event_loop_io_sleep",
-            "ram_in_use",
-            "edge_concurrent_connection",
-        ],
-        enabled_event_metrics=["rqs_clock"],
-    )
-
-    # Assemble payload with the builder
-    payload = (
-        AsyncFlow()
-        .add_generator(generator)
-        .add_client(client)
-        .add_servers(server)
-        .add_edges(e_gen_client, e_client_app, e_app_client)
-        .add_simulation_settings(settings)
-    ).build_payload()
-
-    # Run
-    env = simpy.Environment()
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-    return results
-
-
-def main() -> None:
-    # Build & run
-    res = build_and_run()
-
-    # Print concise latency summary
-    print(res.format_latency_stats())
-
-    # Prepare figure in the same folder as this script
-    script_dir = Path(__file__).parent
-    out_path = script_dir / "builder_service_plots.png"
-
-    # 2×2: Latency | Throughput | Ready (first server) | RAM (first server)
-    fig, axes = plt.subplots(2, 2, figsize=(12, 8), dpi=160)
-
-    # Top row
-    res.plot_latency_distribution(axes[0, 0])
-    res.plot_throughput(axes[0, 1])
-
-    # Bottom row — first server, if present
-    sids = res.list_server_ids()
-    if sids:
-        sid = sids[0]
-        res.plot_single_server_ready_queue(axes[1, 0], sid)
-        res.plot_single_server_ram(axes[1, 1], sid)
-    else:
-        for ax in (axes[1, 0], axes[1, 1]):
-            ax.text(0.5, 0.5, "No servers", ha="center", va="center")
-            ax.axis("off")
-
-    fig.tight_layout()
-    fig.savefig(out_path)
-    print(f"Plots saved to: {out_path}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/data/event_inj_lb.yml b/examples/yaml_input/data/event_inj_lb.yml
deleted file mode 100644
index 5d97bc8..0000000
--- a/examples/yaml_input/data/event_inj_lb.yml
+++ /dev/null
@@ -1,102 +0,0 @@
-# AsyncFlow SimulationPayload — LB + 2 servers (medium load) with events
-#
-# Topology:
-#   generator → client → LB → srv-1
-#                              └→ srv-2
-#   srv-1 → client
-#   srv-2 → client
-#
-# Workload targets ~40 rps (120 users × 20 req/min ÷ 60).
-
-rqs_input:
-  id: rqs-1
-  avg_active_users: { mean: 120 }
-  avg_request_per_minute_per_user: { mean: 20 }
-  user_sampling_window: 60
-
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-
-    load_balancer:
-      id: lb-1
-      algorithms: round_robin
-      server_covered: [srv-1, srv-2]
-
-    servers:
-      - id: srv-1
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: /api
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.002 }         # 2 ms CPU
-              - kind: ram
-                step_operation: { necessary_ram: 128 }      # 128 MB
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.012 }  # 12 ms I/O wait
-
-      - id: srv-2
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: /api
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.002 }
-              - kind: ram
-                step_operation: { necessary_ram: 128 }
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.012 }
-
-  edges:
-    - { id: gen-client,  source: rqs-1,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-    - { id: client-lb,   source: client-1, target: lb-1,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: lb-srv1,     source: lb-1,    target: srv-1,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: lb-srv2,     source: lb-1,    target: srv-2,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: srv1-client, source: srv-1,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-    - { id: srv2-client, source: srv-2,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-
-sim_settings:
-  total_simulation_time: 600
-  sample_period_s: 0.05
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
-
-# Events:
-# - Edge spikes (added latency in seconds) that stress different paths at different times.
-# - Server outages that never overlap (so at least one server stays up).
-events:
-  # Edge spike: client → LB gets +15 ms from t=100s to t=160s
-  - event_id: ev-spike-1
-    target_id: client-lb
-    start: { kind: network_spike_start, t_start: 100.0, spike_s: 0.015 }
-    end:   { kind: network_spike_end,   t_end:   160.0 }
-
-  # Server outage: srv-1 down from t=180s to t=240s
-  - event_id: ev-srv1-down
-    target_id: srv-1
-    start: { kind: server_down, t_start: 180.0 }
-    end:   { kind: server_up,   t_end:   240.0 }
-
-  # Edge spike focused on srv-2 leg (LB → srv-2) from t=300s to t=360s (+20 ms)
-  - event_id: ev-spike-2
-    target_id: lb-srv2
-    start: { kind: network_spike_start, t_start: 300.0, spike_s: 0.020 }
-    end:   { kind: network_spike_end,   t_end:   360.0 }
-
-  # Server outage: srv-2 down from t=360s to t=420s (starts right after the spike ends)
-  - event_id: ev-srv2-down
-    target_id: srv-2
-    start: { kind: server_down, t_start: 360.0 }
-    end:   { kind: server_up,   t_end:   420.0 }
-
-  # Late spike on generator → client from t=480s to t=540s (+10 ms)
-  - event_id: ev-spike-3
-    target_id: gen-client
-    start: { kind: network_spike_start, t_start: 480.0, spike_s: 0.010 }
-    end:   { kind: network_spike_end,   t_end:   540.0 }
diff --git a/examples/yaml_input/data/event_inj_single_server.yml b/examples/yaml_input/data/event_inj_single_server.yml
deleted file mode 100644
index 9e7d2ec..0000000
--- a/examples/yaml_input/data/event_inj_single_server.yml
+++ /dev/null
@@ -1,77 +0,0 @@
-# ───────────────────────────────────────────────────────────────
-# AsyncFlow scenario: generator ➜ client ➜ server ➜ client
-# with event injection (edge spike + server outage)
-# ───────────────────────────────────────────────────────────────
-
-# 1) Traffic generator (light load)
-rqs_input:
-  id: rqs-1
-  avg_active_users: { mean: 100 }
-  avg_request_per_minute_per_user: { mean: 20 }
-  user_sampling_window: 60
-
-# 2) Topology
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-    servers:
-      - id: srv-1
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: ep-1
-            probability: 1.0
-            steps:
-              # CPU-bound parse (~1ms)
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.001 }
-              # Hold 100 MB while processing
-              - kind: ram
-                step_operation: { necessary_ram: 100 }
-              # Non-blocking I/O wait (~100ms)
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.1 }
-
-  edges:
-    - id: gen-to-client
-      source: rqs-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: client-to-server
-      source: client-1
-      target: srv-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: server-to-client
-      source: srv-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-# 3) Simulation settings
-sim_settings:
-  total_simulation_time: 500
-  sample_period_s: 0.05
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
-
-# 4) Events (validated by Pydantic)
-# - ev-spike-1: deterministic latency spike (+20ms) on the client→server edge
-#   from t=120s to t=240s
-# - ev-outage-1: server outage for srv-1 from t=300s to t=360s
-events:
-  - event_id: ev-spike-1
-    target_id: client-to-server
-    start:
-      kind: network_spike_start
-      t_start: 120.0
-      spike_s: 2.00
-    end:
-      kind: network_spike_end
-      t_end: 240.0
-
-  
\ No newline at end of file
diff --git a/examples/yaml_input/data/heavy_inj_single_server.yml b/examples/yaml_input/data/heavy_inj_single_server.yml
deleted file mode 100644
index 839cf33..0000000
--- a/examples/yaml_input/data/heavy_inj_single_server.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-# ───────────────────────────────────────────────────────────────
-# AsyncFlow scenario (HEAVY): generator ➜ client ➜ server ➜ client
-# Edge-latency spike + heavier workload to provoke queue growth.
-# ───────────────────────────────────────────────────────────────
-
-# 1) Traffic generator (heavier load)
-rqs_input:
-  id: rqs-1
-  # More concurrent users and higher per-user rate drive the system harder.
-  avg_active_users: { mean: 300 }
-  avg_request_per_minute_per_user: { mean: 30 }
-  user_sampling_window: 60
-
-# 2) Topology
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-    servers:
-      - id: srv-1
-        # Keep just 1 CPU core so the server becomes a bottleneck.
-        server_resources: { cpu_cores: 1, ram_mb: 8000 }
-        endpoints:
-          - endpoint_name: ep-1
-            probability: 1.0
-            steps:
-              # Heavier CPU (~5 ms) to increase service time
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.005 }
-              # Larger working set to keep RAM busy
-              - kind: ram
-                step_operation: { necessary_ram: 200 }
-              # Longer I/O wait (~200 ms) to create a noticeable I/O queue
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.2 }
-
-  edges:
-    - id: gen-to-client
-      source: rqs-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: client-to-server
-      source: client-1
-      target: srv-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: server-to-client
-      source: srv-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-# 3) Simulation settings
-sim_settings:
-  # Longer horizon so we clearly see pre-/during-/post-spike behavior.
-  total_simulation_time: 600
-  sample_period_s: 0.05
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
-
-# 4) Events (validated by Pydantic)
-# Large deterministic edge spike (+3.0 s) during [180, 300] s on the
-# client→server edge. With the heavier workload, this should help
-# exacerbate queue growth/oscillations around the spike window.
-events:
-  - event_id: ev-spike-heavy
-    target_id: client-to-server
-    start:
-      kind: network_spike_start
-      t_start: 180.0
-      spike_s: 3.0
-    end:
-      kind: network_spike_end
-      t_end: 300.0
diff --git a/examples/yaml_input/data/single_server.yml b/examples/yaml_input/data/single_server.yml
deleted file mode 100644
index 844b1ad..0000000
--- a/examples/yaml_input/data/single_server.yml
+++ /dev/null
@@ -1,56 +0,0 @@
-# ───────────────────────────────────────────────────────────────
-# AsyncFlow scenario: generator ➜ client ➜ server ➜ client
-# ───────────────────────────────────────────────────────────────
-
-# 1. Traffic generator (light load)
-rqs_input:
-  id: rqs-1
-  avg_active_users: { mean: 100 }
-  avg_request_per_minute_per_user: { mean: 20 }
-  user_sampling_window: 60
-
-# 2. Topology
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-    servers:
-      - id: srv-1
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: ep-1
-            probability: 1.0
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.001 }
-              - kind: ram
-                step_operation: { necessary_ram: 100}
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.1 }
-
-  edges:
-    - id: gen-to-client
-      source: rqs-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: client-to-server
-      source: client-1
-      target: srv-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: server-to-client
-      source: srv-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-# 3. Simulation settings
-sim_settings:
-  total_simulation_time: 500
-  sample_period_s: 0.05
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
diff --git a/examples/yaml_input/data/two_servers_lb.yml b/examples/yaml_input/data/two_servers_lb.yml
deleted file mode 100644
index 6adf5cb..0000000
--- a/examples/yaml_input/data/two_servers_lb.yml
+++ /dev/null
@@ -1,71 +0,0 @@
-# AsyncFlow SimulationPayload — Load Balancer + 2 identical app servers
-#
-# Topology:
-#   generator → client → LB → srv-1
-#                              └→ srv-2
-#   srv-1 → client
-#   srv-2 → client
-#
-# Each server runs: CPU(2 ms) → RAM(128 MB) → IO wait(12 ms)
-# All network links use exponential latency with small means (2–3 ms).
-#
-
-
-rqs_input:
-  id: rqs-1
-  avg_active_users: { mean: 400 }
-  avg_request_per_minute_per_user: { mean: 20 }
-  user_sampling_window: 60
-
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-
-    load_balancer:
-      id: lb-1
-      algorithms: round_robin
-      server_covered: [srv-1, srv-2]
-
-    servers:
-      - id: srv-1
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: /api
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.002 }         # 2 ms CPU (blocks event loop)
-              - kind: ram
-                step_operation: { necessary_ram: 128 }      # 128 MB working set
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.012 }  # 12 ms non-blocking I/O
-
-      - id: srv-2
-        server_resources: { cpu_cores: 1, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: /api
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.002 }
-              - kind: ram
-                step_operation: { necessary_ram: 128 }
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.012 }
-
-  edges:
-    - { id: gen-client,  source: rqs-1,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-    - { id: client-lb,   source: client-1, target: lb-1,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: lb-srv1,     source: lb-1,    target: srv-1,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: lb-srv2,     source: lb-1,    target: srv-2,    latency: { mean: 0.002, distribution: exponential } }
-    - { id: srv1-client, source: srv-1,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-    - { id: srv2-client, source: srv-2,   target: client-1, latency: { mean: 0.003, distribution: exponential } }
-
-sim_settings:
-  total_simulation_time: 600
-  sample_period_s: 0.05
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
diff --git a/examples/yaml_input/event_injections/heavy_single_server.py b/examples/yaml_input/event_injections/heavy_single_server.py
deleted file mode 100644
index 72605af..0000000
--- a/examples/yaml_input/event_injections/heavy_single_server.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""
-Run the *heavy* YAML scenario with event injections and export charts.
-
-Scenario file:
-  data/heavy_event_inj_single_server.yml
-
-Outputs (saved under a folder next to this script):
-  examples/yaml_input/event_injections/heavy_single_server_plot/
-    - heavy_event_inj_single_server_dashboard.png
-    - heavy_event_inj_single_server_ready_queue_<server>.png
-    - heavy_event_inj_single_server_io_queue_<server>.png
-    - heavy_event_inj_single_server_ram_<server>.png
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import simpy
-
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-def main() -> None:
-    """Defines paths, runs the simulation, and generates all outputs."""
-    # --- 1. Define File Paths ---
-    script_dir = Path(__file__).parent
-    yaml_path = script_dir.parent / "data" / "heavy_inj_single_server.yml"
-    output_base_name = "heavy_inj_single_server"
-
-    if not yaml_path.exists():
-        msg = f"YAML configuration file not found: {yaml_path}"
-        raise FileNotFoundError(msg)
-
-    # Create/ensure the output directory (overwrite files if present).
-    out_dir = script_dir / "heavy_single_server_plot"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    # --- 2. Run the Simulation ---
-    env = simpy.Environment()
-    runner = SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
-    results: ResultsAnalyzer = runner.run()
-
-    # --- 3. Dashboard (latency + throughput) ---
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    results.plot_base_dashboard(axes[0], axes[1])
-    fig.tight_layout()
-    dash_path = out_dir / f"{output_base_name}_dashboard.png"
-    fig.savefig(dash_path)
-    print(f"Saved: {dash_path}")
-
-    # --- 4. Per-server plots ---
-    for sid in results.list_server_ids():
-        # Ready queue
-        f1, a1 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ready_queue(a1, sid)
-        f1.tight_layout()
-        p1 = out_dir / f"{output_base_name}_ready_queue_{sid}.png"
-        f1.savefig(p1)
-        print(f"Saved: {p1}")
-
-        # I/O queue
-        f2, a2 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_io_queue(a2, sid)
-        f2.tight_layout()
-        p2 = out_dir / f"{output_base_name}_io_queue_{sid}.png"
-        f2.savefig(p2)
-        print(f"Saved: {p2}")
-
-        # RAM usage
-        f3, a3 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ram(a3, sid)
-        f3.tight_layout()
-        p3 = out_dir / f"{output_base_name}_ram_{sid}.png"
-        f3.savefig(p3)
-        print(f"Saved: {p3}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_dashboard.png b/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_dashboard.png
deleted file mode 100644
index 4662ae0..0000000
Binary files a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_dashboard.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_io_queue_srv-1.png b/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_io_queue_srv-1.png
deleted file mode 100644
index 941a8db..0000000
Binary files a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ram_srv-1.png b/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ram_srv-1.png
deleted file mode 100644
index 1efba07..0000000
Binary files a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ram_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ready_queue_srv-1.png b/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ready_queue_srv-1.png
deleted file mode 100644
index 23f09f3..0000000
Binary files a/examples/yaml_input/event_injections/heavy_single_server_plot/heavy_inj_single_server_ready_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers.py b/examples/yaml_input/event_injections/lb_two_servers.py
deleted file mode 100644
index a2b666c..0000000
--- a/examples/yaml_input/event_injections/lb_two_servers.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""
-Run the YAML scenario with LB + 2 servers and export charts.
-
-Scenario file:
-  data/lb_two_servers_events.yml
-
-Outputs (saved in subfolder next to this script):
-  - dashboard PNG (latency + throughput)
-  - per-server PNGs: ready queue, I/O queue, RAM
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-import matplotlib.pyplot as plt
-import simpy
-
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-def main() -> None:
-    """Defines paths, runs the simulation, and generates all outputs."""
-    # --- 1. Define paths ---
-    script_dir = Path(__file__).parent
-    yaml_path = script_dir.parent / "data" / "event_inj_lb.yml"
-
-    out_dir = script_dir / "lb_two_servers_plots"
-    out_dir.mkdir(exist_ok=True)  # create if missing
-
-    output_base_name = "lb_two_servers_events"
-
-    if not yaml_path.exists():
-        msg = f"YAML configuration file not found: {yaml_path}"
-        raise FileNotFoundError(msg)
-
-    # --- 2. Run the simulation ---
-    env = simpy.Environment()
-    runner = SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
-    results: ResultsAnalyzer = runner.run()
-
-    # --- 3. Dashboard (latency + throughput) ---
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    results.plot_base_dashboard(axes[0], axes[1])
-    fig.tight_layout()
-    dash_path = out_dir / f"{output_base_name}_dashboard.png"
-    fig.savefig(dash_path)
-    print(f"Saved: {dash_path}")
-
-    # --- 4. Per-server plots ---
-    for sid in results.list_server_ids():
-        # Ready queue
-        f1, a1 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ready_queue(a1, sid)
-        f1.tight_layout()
-        p1 = out_dir / f"{output_base_name}_ready_queue_{sid}.png"
-        f1.savefig(p1)
-        print(f"Saved: {p1}")
-
-        # I/O queue
-        f2, a2 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_io_queue(a2, sid)
-        f2.tight_layout()
-        p2 = out_dir / f"{output_base_name}_io_queue_{sid}.png"
-        f2.savefig(p2)
-        print(f"Saved: {p2}")
-
-        # RAM usage
-        f3, a3 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ram(a3, sid)
-        f3.tight_layout()
-        p3 = out_dir / f"{output_base_name}_ram_{sid}.png"
-        f3.savefig(p3)
-        print(f"Saved: {p3}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_dashboard.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_dashboard.png
deleted file mode 100644
index f23ee2a..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_dashboard.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-1.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-1.png
deleted file mode 100644
index 7565139..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-2.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-2.png
deleted file mode 100644
index 3531413..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_io_queue_srv-2.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-1.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-1.png
deleted file mode 100644
index b0ccfbc..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-2.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-2.png
deleted file mode 100644
index c0a9ddc..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ram_srv-2.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-1.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-1.png
deleted file mode 100644
index 7cdbbcf..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-2.png b/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-2.png
deleted file mode 100644
index 8b732ab..0000000
Binary files a/examples/yaml_input/event_injections/lb_two_servers_plots/lb_two_servers_events_ready_queue_srv-2.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/single_server.py b/examples/yaml_input/event_injections/single_server.py
deleted file mode 100644
index 58d1603..0000000
--- a/examples/yaml_input/event_injections/single_server.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""
-Run the YAML scenario with event injections and export charts.
-
-Scenario file:
-  data/event_inj_single_server.yml
-
-Outputs (saved under a folder next to this script):
-  examples/yaml_input/event_injections/single_server_plot/
-    - event_inj_single_server_dashboard.png
-    - event_inj_single_server_ready_queue_<server>.png
-    - event_inj_single_server_io_queue_<server>.png
-    - event_inj_single_server_ram_<server>.png
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import simpy
-
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-def main() -> None:
-    """Defines paths, runs the simulation, and generates all outputs."""
-    # --- 1. Define File Paths ---
-    script_dir = Path(__file__).parent           # same folder as this file
-    yaml_path = script_dir.parent / "data" / "event_inj_single_server.yml"
-    output_base_name = "event_inj_single_server"  # prefix for output files
-
-    if not yaml_path.exists():
-        msg = f"YAML configuration file not found: {yaml_path}"
-        raise FileNotFoundError(msg)
-
-    # Create/ensure the output directory:
-    out_dir = script_dir / "single_server_plot"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    # --- 2. Run the Simulation ---
-    env = simpy.Environment()
-    runner = SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
-    results: ResultsAnalyzer = runner.run()
-
-    # --- 3. Dashboard (latency + throughput) ---
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    results.plot_base_dashboard(axes[0], axes[1])
-    fig.tight_layout()
-    dash_path = out_dir / f"{output_base_name}_dashboard.png"
-    fig.savefig(dash_path)
-    print(f"Saved: {dash_path}")
-
-    # --- 4. Per-server plots ---
-    for sid in results.list_server_ids():
-        # Ready queue
-        f1, a1 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ready_queue(a1, sid)
-        f1.tight_layout()
-        p1 = out_dir / f"{output_base_name}_ready_queue_{sid}.png"
-        f1.savefig(p1)
-        print(f"Saved: {p1}")
-
-        # I/O queue
-        f2, a2 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_io_queue(a2, sid)
-        f2.tight_layout()
-        p2 = out_dir / f"{output_base_name}_io_queue_{sid}.png"
-        f2.savefig(p2)
-        print(f"Saved: {p2}")
-
-        # RAM usage
-        f3, a3 = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ram(a3, sid)
-        f3.tight_layout()
-        p3 = out_dir / f"{output_base_name}_ram_{sid}.png"
-        f3.savefig(p3)
-        print(f"Saved: {p3}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_dashboard.png b/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_dashboard.png
deleted file mode 100644
index c98a6a7..0000000
Binary files a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_dashboard.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_io_queue_srv-1.png b/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_io_queue_srv-1.png
deleted file mode 100644
index 3a68e5e..0000000
Binary files a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ram_srv-1.png b/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ram_srv-1.png
deleted file mode 100644
index 404a2d9..0000000
Binary files a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ram_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ready_queue_srv-1.png b/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ready_queue_srv-1.png
deleted file mode 100644
index 0ec5bbd..0000000
Binary files a/examples/yaml_input/event_injections/single_server_plot/event_inj_single_server_ready_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/load_balancer/two_servers.py b/examples/yaml_input/load_balancer/two_servers.py
deleted file mode 100644
index a6fb125..0000000
--- a/examples/yaml_input/load_balancer/two_servers.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-"""
-Walkthrough: run a Load-Balanced (2 servers) AsyncFlow scenario from YAML.
-
-What this script does
----------------------
-1) Loads the SimulationPayload from a YAML file (round-robin LB, 2 identical servers).
-2) Runs the simulation via `SimulationRunner`.
-3) Prints a concise latency summary to stdout.
-4) Saves plots **in the same folder as this script**:
-   • `lb_dashboard.png` (Latency histogram + Throughput)
-   • One figure per server with 3 panels: Ready Queue, I/O Queue, RAM usage.
-
-How to use
-----------
-- Put this script and `two_servers_lb.yml` in the same directory.
-- Run: `python run_lb_from_yaml.py`
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-import simpy
-import matplotlib.pyplot as plt
-
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def main() -> None:
-    # Paths (same directory as this script)
-    script_dir = Path(__file__).parent
-    out_dir = script_dir / "two_servers_plot"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    yaml_path = script_dir.parent / "data" / "two_servers_lb.yml"
-    if not yaml_path.exists():
-        raise FileNotFoundError(f"YAML configuration not found: {yaml_path}")
-
-    # Run the simulation
-    print(f"🚀 Loading and running simulation from: {yaml_path}")
-    env = simpy.Environment()
-    runner = SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
-    results: ResultsAnalyzer = runner.run()
-    print("✅ Simulation finished!")
-
-    # Print concise latency summary
-    print(results.format_latency_stats())
-
-    # ---- Plots: dashboard (latency + throughput) ----
-    fig_dash, axes_dash = plt.subplots(1, 2, figsize=(14, 5), dpi=160)
-    results.plot_latency_distribution(axes_dash[0])
-    results.plot_throughput(axes_dash[1])
-    fig_dash.tight_layout()
-    out_dashboard = out_dir / "lb_dashboard.png"
-    fig_dash.savefig(out_dashboard, bbox_inches="tight")
-    print(f"🖼️  Dashboard saved to: {out_dashboard}")
-
-    # ---- Per-server metrics: one figure per server (Ready | I/O | RAM) ----
-    for sid in results.list_server_ids():
-        fig_row, axes = plt.subplots(1, 3, figsize=(16, 3.8), dpi=160)
-        results.plot_single_server_ready_queue(axes[0], sid)
-        results.plot_single_server_io_queue(axes[1], sid)
-        results.plot_single_server_ram(axes[2], sid)
-        fig_row.suptitle(f"Server metrics — {sid}", y=1.04, fontsize=14)
-        fig_row.tight_layout()
-        out_path = out_dir / f"lb_server_{sid}_metrics.png"
-        fig_row.savefig(out_path, bbox_inches="tight")
-        print(f"🖼️  Server metrics for '{sid}' saved to: {out_path}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/load_balancer/two_servers_plot/lb_dashboard.png b/examples/yaml_input/load_balancer/two_servers_plot/lb_dashboard.png
deleted file mode 100644
index 95c9a14..0000000
Binary files a/examples/yaml_input/load_balancer/two_servers_plot/lb_dashboard.png and /dev/null differ
diff --git a/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-1_metrics.png b/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-1_metrics.png
deleted file mode 100644
index 76ef6c5..0000000
Binary files a/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-1_metrics.png and /dev/null differ
diff --git a/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-2_metrics.png b/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-2_metrics.png
deleted file mode 100644
index fac7f78..0000000
Binary files a/examples/yaml_input/load_balancer/two_servers_plot/lb_server_srv-2_metrics.png and /dev/null differ
diff --git a/examples/yaml_input/single_server/single_server.py b/examples/yaml_input/single_server/single_server.py
deleted file mode 100644
index 722de75..0000000
--- a/examples/yaml_input/single_server/single_server.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""
-AsyncFlow — YAML single-server example: run and export charts.
-
-System (single server)
-  generator → client → server → client
-
-Load
-  ~100 active users, ~20 requests/min each (stochastic aggregate).
-
-Server
-  1 CPU core, 2 GB RAM, endpoint "ep-1":
-    CPU(1 ms) → RAM(100 MB) → I/O wait (100 ms)
-  Semantics:
-    - CPU step blocks the event loop
-    - RAM step holds a working set until the request leaves the server
-    - I/O step is non-blocking (event-loop friendly)
-
-Network
-  Each edge has exponential latency with mean 3 ms.
-
-Simulation settings
-  Duration: 500 s
-  Sampling period: 50 ms
-
-What this script does
-  1) Loads the YAML scenario and runs the simulation.
-  2) Prints latency statistics to stdout.
-  3) Saves charts next to this script:
-     - Dashboard PNG: latency histogram (mean/P50/P95/P99)
-       and throughput (mean/P95/max) side-by-side.
-     - Per-server PNGs: Ready queue, I/O queue, and RAM usage for each server.
-"""
-
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-# SimPy environment is required by SimulationRunner.from_yaml
-import simpy
-
-# matplotlib is needed to create figures for plotting
-import matplotlib.pyplot as plt
-
-# The only imports a user needs to run a simulation
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
-
-# --- Basic Logging Setup ---
-logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
-
-
-def main() -> None:
-    """Defines paths, runs the simulation, and generates all outputs."""
-    # --- 1. Define File Paths ---
-    script_dir = Path(__file__).parent                # same folder as this script
-    out_dir = script_dir / "single_server_plot"       # outputs will go here
-    out_dir.mkdir(parents=True, exist_ok=True)        # create if not exists
-
-    yaml_path = script_dir.parent / "data" / "single_server.yml"
-    output_base_name = "single_server_results"        # prefix for output files
-
-    if not yaml_path.exists():
-        raise FileNotFoundError(f"YAML configuration file not found: {yaml_path}")
-
-    # --- 2. Run the Simulation ---
-    print(f"🚀 Loading and running simulation from: {yaml_path}")
-    env = simpy.Environment()  # Create the SimPy environment
-    runner = SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)  # pass env
-    results: ResultsAnalyzer = runner.run()
-    print("✅ Simulation finished!")
-
-    # Plot 1: The main dashboard (Latency Distribution + Throughput)
-    fig_base, axes_base = plt.subplots(1, 2, figsize=(14, 5))
-    results.plot_base_dashboard(axes_base[0], axes_base[1])
-    fig_base.tight_layout()
-    base_plot_path = out_dir / f"{output_base_name}_dashboard.png"
-    fig_base.savefig(base_plot_path)
-    print(f"🖼️  Base dashboard saved to: {base_plot_path}")
-
-    # Plot 2: Individual plots for each server's metrics
-    server_ids = results.list_server_ids()
-    for sid in server_ids:
-        # Ready queue (separate)
-        fig_rdy, ax_rdy = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ready_queue(ax_rdy, sid)
-        fig_rdy.tight_layout()
-        rdy_path = out_dir / f"{output_base_name}_ready_queue_{sid}.png"
-        fig_rdy.savefig(rdy_path)
-        print(f"🖼️  Ready queue for '{sid}' saved to: {rdy_path}")
-
-        # I/O queue (separate)
-        fig_io, ax_io = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_io_queue(ax_io, sid)
-        fig_io.tight_layout()
-        io_path = out_dir / f"{output_base_name}_io_queue_{sid}.png"
-        fig_io.savefig(io_path)
-        print(f"🖼️  I/O queue for '{sid}' saved to: {io_path}")
-
-        # RAM (separate)
-        fig_r, ax_r = plt.subplots(figsize=(10, 5))
-        results.plot_single_server_ram(ax_r, sid)
-        fig_r.tight_layout()
-        r_path = out_dir / f"{output_base_name}_ram_{sid}.png"
-        fig_r.savefig(r_path)
-        print(f"🖼️  RAM plot for '{sid}' saved to: {r_path}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/examples/yaml_input/single_server/single_server_plot/single_server_results_dashboard.png b/examples/yaml_input/single_server/single_server_plot/single_server_results_dashboard.png
deleted file mode 100644
index b54350d..0000000
Binary files a/examples/yaml_input/single_server/single_server_plot/single_server_results_dashboard.png and /dev/null differ
diff --git a/examples/yaml_input/single_server/single_server_plot/single_server_results_io_queue_srv-1.png b/examples/yaml_input/single_server/single_server_plot/single_server_results_io_queue_srv-1.png
deleted file mode 100644
index c13b68e..0000000
Binary files a/examples/yaml_input/single_server/single_server_plot/single_server_results_io_queue_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/single_server/single_server_plot/single_server_results_ram_srv-1.png b/examples/yaml_input/single_server/single_server_plot/single_server_results_ram_srv-1.png
deleted file mode 100644
index 511c132..0000000
Binary files a/examples/yaml_input/single_server/single_server_plot/single_server_results_ram_srv-1.png and /dev/null differ
diff --git a/examples/yaml_input/single_server/single_server_plot/single_server_results_ready_queue_srv-1.png b/examples/yaml_input/single_server/single_server_plot/single_server_results_ready_queue_srv-1.png
deleted file mode 100644
index 4eaf2bd..0000000
Binary files a/examples/yaml_input/single_server/single_server_plot/single_server_results_ready_queue_srv-1.png and /dev/null differ
diff --git a/pyproject.toml b/pyproject.toml
index ca8f555..c9691be 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "asyncflow-sim"
-version = "0.1.1"
+version = "0.1.2"
 description = "Digital-twin simulator for distributed async systems. Build what-if scenarios and quantify capacity, latency and throughput offline, before you deploy."
 authors = ["Gioele Botta"]
 readme = "README.md"
diff --git a/src/asyncflow/__init__.py b/src/asyncflow/__init__.py
index 0f38c83..bcaa60c 100644
--- a/src/asyncflow/__init__.py
+++ b/src/asyncflow/__init__.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from asyncflow.builder.asyncflow_builder import AsyncFlow
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.runner.sweep import Sweep
 
-__all__ = ["AsyncFlow",  "SimulationRunner"]
+__all__ = ["AsyncFlow",  "SimulationRunner", "Sweep"]
diff --git a/src/asyncflow/analysis/__init__.py b/src/asyncflow/analysis/__init__.py
index 825de6e..3d895eb 100644
--- a/src/asyncflow/analysis/__init__.py
+++ b/src/asyncflow/analysis/__init__.py
@@ -1,5 +1,7 @@
 """Public module exposing the results analyzer"""
 
-from asyncflow.metrics.analyzer import ResultsAnalyzer
+from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+from asyncflow.metrics.sweep_analyzer import SweepAnalyzer
+from asyncflow.queue_theory_analysis.mmc import MMc
 
-__all__ = ["ResultsAnalyzer"]
+__all__ = ["MMc", "ResultsAnalyzer", "SweepAnalyzer"]
diff --git a/src/asyncflow/builder/asyncflow_builder.py b/src/asyncflow/builder/asyncflow_builder.py
index ef33e7b..7d79bd6 100644
--- a/src/asyncflow/builder/asyncflow_builder.py
+++ b/src/asyncflow/builder/asyncflow_builder.py
@@ -4,11 +4,12 @@
 
 from typing import Self
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription, SystemEdges
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.events.injection import End, EventInjection, Start
 from asyncflow.schemas.payload import SimulationPayload
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.graph import TopologyGraph
 from asyncflow.schemas.topology.nodes import (
     Client,
@@ -16,7 +17,6 @@
     Server,
     TopologyNodes,
 )
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 
 class AsyncFlow:
@@ -24,20 +24,25 @@ class AsyncFlow:
 
     def __init__(self) -> None:
         """Instance attributes necessary to define the simulation payload"""
-        self._generator: RqsGenerator | None = None
+        self._arrivals: ArrivalsGenerator | None = None
         self._client: Client | None = None
         self._servers: list[Server] | None = None
-        self._edges: list[Edge] | None = None
+        self._net_edges: list[NetworkEdge] | None = None
+        self._link_edges: list[LinkEdge] | None = None
         self._sim_settings: SimulationSettings | None = None
         self._load_balancer: LoadBalancer | None = None
         self._events: list[EventInjection] = []
+        self._edges_kind: SystemEdges | None = None
 
-    def add_generator(self, rqs_generator: RqsGenerator) -> Self:
+    def add_arrivals_generator(
+        self,
+        arrivals: ArrivalsGenerator,
+        ) -> Self:
         """Method to instantiate the generator"""
-        if not isinstance(rqs_generator, RqsGenerator):
-            msg = "You must add a RqsGenerator instance"
+        if not isinstance(arrivals, ArrivalsGenerator):
+            msg = "You must add a ArrivalsGenerator instance"
             raise TypeError(msg)
-        self._generator = rqs_generator
+        self._arrivals = arrivals
         return self
 
     def add_client(self, client: Client) -> Self:
@@ -61,18 +66,48 @@ def add_servers(self, *servers: Server) -> Self:
             self._servers.append(server)
         return self
 
-    def add_edges(self, *edges: Edge) -> Self:
-        """Method to instantiate the list of edges"""
-        if self._edges is None:
-            self._edges = []
+    def add_edges(self, *edges: NetworkEdge | LinkEdge) -> Self:
+        """Add edges; enforces homogeneous type (all NetworkEdge or all LinkEdge)."""
+        if not edges:
+            return self
+
+        if self._edges_kind is None:
+            first = edges[0]
+            if isinstance(first, NetworkEdge):
+                self._edges_kind = SystemEdges.NETWORK_CONNECTION
+                self._net_edges = []
+            elif isinstance(first, LinkEdge):
+                self._edges_kind = SystemEdges.LINK_CONNECTION
+                self._link_edges = []
+            else:
+                msg = "Edges must be NetworkEdge or LinkEdge."
+                raise TypeError(msg)
+
+        assert self._edges_kind is not None
 
-        for edge in edges:
-            if not isinstance(edge, Edge):
-                msg = "All the instances must be of the type Edge"
+        if self._edges_kind == SystemEdges.NETWORK_CONNECTION:
+            assert self._net_edges is not None
+            if any(not isinstance(e, NetworkEdge) for e in edges):
+                msg = "Cannot mix LinkEdge with NetworkEdge."
                 raise TypeError(msg)
-            self._edges.append(edge)
+            # ⬇️ Build a typed batch so mypy is happy
+            net_batch: list[NetworkEdge] = [
+                e for e in edges if isinstance(e, NetworkEdge)
+            ]
+            self._net_edges.extend(net_batch)
+        else:
+            assert self._link_edges is not None
+            if any(not isinstance(e, LinkEdge) for e in edges):
+                msg = "Cannot mix NetworkEdge with LinkEdge."
+                raise TypeError(msg)
+            # ⬇️ Typed batch for LinkEdge
+            link_batch: list[LinkEdge] = [e for e in edges if isinstance(e, LinkEdge)]
+            self._link_edges.extend(link_batch)
+
         return self
 
+
+
     def add_simulation_settings(self, sim_settings: SimulationSettings) -> Self:
         """Method to instantiate the settings for the simulation"""
         if not isinstance(sim_settings, SimulationSettings):
@@ -142,8 +177,8 @@ def add_server_outage(
 
     def build_payload(self) -> SimulationPayload:
         """Method to build the payload for the simulation"""
-        if self._generator is None:
-            msg = "The generator input must be instantiated before the simulation"
+        if self._arrivals is None:
+            msg = "The arrivals generator must be instantiated before the simulation"
             raise ValueError(msg)
         if self._client is None:
             msg = "The client input must be instantiated before the simulation"
@@ -151,9 +186,23 @@ def build_payload(self) -> SimulationPayload:
         if not self._servers:
             msg = "You must instantiate at least one server before the simulation"
             raise ValueError(msg)
-        if not self._edges:
-            msg = "You must instantiate edges before the simulation"
+        if self._edges_kind is None:
+            msg = "You must instantiate edges before the simulation."
             raise ValueError(msg)
+
+        # mypy facilitator
+        edges_u: list[NetworkEdge] | list[LinkEdge]
+        if self._edges_kind == SystemEdges.NETWORK_CONNECTION:
+            if not self._net_edges:
+                msg = "You must instantiate edges before the simulation."
+                raise ValueError(msg)
+            edges_u = self._net_edges
+        else:
+            if not self._link_edges:
+                msg = "You must instantiate edges before the simulation."
+                raise ValueError(msg)
+            edges_u = self._link_edges
+
         if self._sim_settings is None:
             msg = "The simulation settings must be instantiated before the simulation"
             raise ValueError(msg)
@@ -166,11 +215,11 @@ def build_payload(self) -> SimulationPayload:
 
         graph = TopologyGraph(
             nodes = nodes,
-            edges=self._edges,
+            edges=edges_u,
         )
 
         return SimulationPayload.model_validate({
-            "rqs_input": self._generator,
+            "arrivals": self._arrivals,
             "topology_graph": graph,
             "sim_settings": self._sim_settings,
             "events": self._events or None,
diff --git a/src/asyncflow/components/__init__.py b/src/asyncflow/components/__init__.py
index 12e9e9e..b6c452b 100644
--- a/src/asyncflow/components/__init__.py
+++ b/src/asyncflow/components/__init__.py
@@ -1,24 +1,27 @@
 """Public components: re-exports Pydantic schemas (topology)."""
 from __future__ import annotations
 
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.endpoint import Endpoint
 from asyncflow.schemas.topology.nodes import (
     Client,
     LoadBalancer,
+    NodesResources,
     Server,
-    ServerResources,
 )
 
 __all__ = [
+    "ArrivalsGenerator",
     "Client",
-    "Edge",
     "Endpoint",
     "EventInjection",
+    "LinkEdge",
     "LoadBalancer",
+    "NetworkEdge",
+    "NodesResources",
     "Server",
-    "ServerResources",
     ]
 
 
diff --git a/src/asyncflow/config/constants.py b/src/asyncflow/config/constants.py
index 29b2229..025cdee 100644
--- a/src/asyncflow/config/constants.py
+++ b/src/asyncflow/config/constants.py
@@ -7,117 +7,19 @@
  JSON / YAML payloads can be strictly validated with Pydantic.
  Front-end and simulation engine share a single source of truth.
  Ruff, mypy and IDEs can leverage the strong typing provided by Enum classes.
-
-IMPORTANT: Changing any enum value is a breaking-change for every
-stored configuration file. Add new members whenever possible instead of
-renaming existing ones.
 """
 
-from enum import Enum, IntEnum, StrEnum
-
-# ======================================================================
-# CONSTANTS FOR THE REQUEST-GENERATOR COMPONENT
-# ======================================================================
-
-
-class TimeDefaults(IntEnum):
-    """
-    Default time-related constants (expressed in seconds).
-
-    These values are used when the user omits an explicit parameter. They also
-    serve as lower / upper bounds for validation for the requests generator.
-    """
-
-    MIN_TO_SEC = 60  # 1 minute → 60 s
-    USER_SAMPLING_WINDOW = 60  # every 60 seconds sample the number of active user
-    SIMULATION_TIME = 3_600  # run 1 h if user gives no value
-    MIN_SIMULATION_TIME = 5  # 5 seconds give a broad spectrum
-    MIN_USER_SAMPLING_WINDOW = 1 # 1 s minimum
-    MAX_USER_SAMPLING_WINDOW = 120 # 2 min maximum
-
-
-class Distribution(StrEnum):
-    """
-    Probability distributions accepted by app.schemas.RVConfig.
-
-    The string value is exactly the identifier that must appear in JSON
-    payloads.  The simulation engine will map each name to the corresponding
-    random sampler (e.g.numpy.random.poisson).
-    """
-
-    POISSON = "poisson"
-    NORMAL = "normal"
-    LOG_NORMAL = "log_normal"
-    EXPONENTIAL = "exponential"
-    UNIFORM = "uniform"
-
-# ======================================================================
-# CONSTANTS FOR ENDPOINT STEP DEFINITION (REQUEST-HANDLER)
-# ======================================================================
-
-class EndpointStepIO(StrEnum):
-    """
-    I/O-bound operation categories that can occur inside an endpoint step.
-      - TASK_SPAWN
-         Spawns an additional ``asyncio.Task`` and returns immediately.
-      - LLM
-         Performs a remote Large-Language-Model inference call.
-        - WAIT
-          Passive, *non-blocking* wait for I/O completion; no new task spawned.
-        - DB
-          Round-trip to a relational / NoSQL database.
-        - CACHE
-          Access to a local or distributed cache layer.
-    """
-
-    TASK_SPAWN = "io_task_spawn"
-    LLM        = "io_llm"
-    WAIT       = "io_wait"
-    DB         = "io_db"
-    CACHE      = "io_cache"
+from __future__ import annotations
 
+from typing import Final  # needed for type-hinted module constants
 
-class EndpointStepCPU(StrEnum):
-    """
-    CPU-bound operation categories inside an endpoint step.
-
-    Use these when the coroutine keeps the Python interpreter busy
-    (GIL-bound or compute-heavy code) rather than waiting for I/O.
-    """
-
-    INITIAL_PARSING      = "initial_parsing"
-    CPU_BOUND_OPERATION  = "cpu_bound_operation"
-
-
-class EndpointStepRAM(StrEnum):
-    """
-    Memory-related operations inside a step.
-
-    Currently limited to a single category, but kept as an Enum so that future
-    resource types (e.g. GPU memory) can be added without schema changes.
-    """
-
-    RAM = "ram"
-
-
-class StepOperation(StrEnum):
-    """
-    Keys used inside the metrics dictionary of a step.
-
-    CPU_TIME - Service time (seconds) during which the coroutine occupies
-      the CPU / GIL.
-    NECESSARY_RAM - Peak memory (MB) required by the step.
-    """
-
-    CPU_TIME        = "cpu_time"
-    IO_WAITING_TIME = "io_waiting_time"
-    NECESSARY_RAM   = "necessary_ram"
+from asyncflow.config.enums import VariabilityLevel
 
 # ======================================================================
 # CONSTANTS FOR THE RESOURCES OF A SERVER
 # ======================================================================
 
-class ServerResourcesDefaults:
+class NodesResourcesDefaults:
     """Resources available for a single server"""
 
     CPU_CORES = 1
@@ -126,144 +28,38 @@ class ServerResourcesDefaults:
     MINIMUM_RAM_MB = 256
     DB_CONNECTION_POOL = None
 
+
 # ======================================================================
 # CONSTANTS FOR NETWORK PARAMETERS
 # ======================================================================
 
 class NetworkParameters:
-  """parameters for the network"""
-
-  MIN_DROPOUT_RATE = 0.0
-  DROPOUT_RATE = 0.01
-  MAX_DROPOUT_RATE = 1.0
-
-# ======================================================================
-# NAME FOR LOAD BALANCER ALGORITHMS
-# ======================================================================
-
-class LbAlgorithmsName(StrEnum):
-  """definition of the available algortithms for the Load Balancer"""
-
-  ROUND_ROBIN = "round_robin"
-  LEAST_CONNECTIONS = "least_connection"
+    """Parameters for the network."""
 
+    MIN_DROPOUT_RATE = 0.0
+    DROPOUT_RATE = 0.01
+    MAX_DROPOUT_RATE = 1.0
 
-# ======================================================================
-# CONSTANTS FOR THE MACRO-TOPOLOGY GRAPH
-# ======================================================================
-
-class SystemNodes(StrEnum):
-    """
-    High-level node categories of the system topology graph.
-
-    Each member represents a *macro-component* that may have its own SimPy
-    resources (CPU cores, DB pool, etc.).
-    """
-
-    GENERATOR     = "generator"
-    SERVER        = "server"
-    CLIENT        = "client"
-    LOAD_BALANCER = "load_balancer"
-
-class SystemEdges(StrEnum):
-    """
-    Edge categories connecting different class SystemNodes.
-
-    Currently only network links are modeled; new types (IPC queue, message
-    bus, stream) can be added without impacting existing payloads.
-    """
-
-    NETWORK_CONNECTION = "network_connection"
-
-# ======================================================================
-# CONSTANTS FOR THE EVENT TO INJECT IN THE SIMULATION
-# ======================================================================
-
-class EventDescription(StrEnum):
-  """Description for the events you may inject during the simulation"""
-
-  SERVER_UP = "server_up"
-  SERVER_DOWN = "server_down"
-  NETWORK_SPIKE_START = "network_spike_start"
-  NETWORK_SPIKE_END = "network_spike_end"
-
-
-# ======================================================================
-# CONSTANTS FOR SAMPLED METRICS
-# ======================================================================
-
-class SampledMetricName(StrEnum):
-  """
-  Define the metrics sampled every fixed amount of
-  time to create a time series
-  """
-
-  # Mandatory metrics to collect
-  READY_QUEUE_LEN = "ready_queue_len" #length of the event loop ready q
-  EVENT_LOOP_IO_SLEEP = "event_loop_io_sleep"
-  RAM_IN_USE = "ram_in_use"
-  EDGE_CONCURRENT_CONNECTION = "edge_concurrent_connection"
-
-
-class SamplePeriods(float, Enum):
-  """
-  Defining the value of the sample periods for the metrics for which
-  we have to extract a time series
-  """
-
-  STANDARD_TIME = 0.01 # 10 MILLISECONDS
-  MINIMUM_TIME = 0.001 # 1 MILLISECOND
-  MAXIMUM_TIME = 0.1   # 100 MILLISECONDS
 
 # ======================================================================
-# CONSTANTS FOR EVENT METRICS
+# CONSTANTS FOR ARRIVAL VARIABILITY PRESETS (shared across samplers)
 # ======================================================================
 
-class EventMetricName(StrEnum):
-  """
-  Define the metrics triggered by event with no
-  time series
-  """
-
-  # Mandatory
-  RQS_CLOCK = "rqs_clock" # useful to collect starting and finishing time of rqs
-  # Not mandatory
-  LLM_COST = "llm_cost"
+SCV_PRESETS: Final[dict[VariabilityLevel, float]] = {
+    VariabilityLevel.LOW: 0.25,
+    VariabilityLevel.MEDIUM: 1.0,
+    VariabilityLevel.HIGH: 4.0,
+}
 
 
 # ======================================================================
-# CONSTANTS FOR AGGREGATED METRICS
+# DERIVED SAMPLER TUNING CONSTANTS
 # ======================================================================
+class Tuning:
+  """class of constants to tune behaviour of arrivals sampler"""
 
-class AggregatedMetricName(StrEnum):
-  """aggregated metrics to calculate at the end of simulation"""
-
-  LATENCY_STATS = "latency_stats"
-  THROUGHPUT = "throughput_rps"
-  LLM_STATS = "llm_stats"
-
-# ======================================================================
-# CONSTANTS FOR SERVER RUNTIME
-# ======================================================================
-
-class ServerResourceName(StrEnum):
-  """Keys for each server resource type, used when building the container map."""
-
-  CPU = "CPU"
-  RAM = "RAM"
-
-# ======================================================================
-# CONSTANTS FOR LATENCY STATS
-# ======================================================================
-
-class LatencyKey(StrEnum):
-  """Keys for the collection of the latency stats"""
-
-  TOTAL_REQUESTS = "total_requests"
-  MEAN           = "mean"
-  MEDIAN         = "median"
-  STD_DEV        = "std_dev"
-  P95            = "p95"
-  P99            = "p99"
-  MIN            = "min"
-  MAX            = "max"
+  PARETO_ALPHA_EPS: Final[float] = 1e-6   # ensure finite variance: alpha > 2
+  WEIBULL_K_LOW: Final[float] = 2.10      # matches SCV≈0.25
+  WEIBULL_K_MED: Final[float] = 1.0       # SCV=1 (exponential)
+  WEIBULL_K_HIGH: Final[float] = 0.543    # matches SCV≈4
+  UNIFORM_REL_HALF_WIDTH: Final[float] = 0.5  # c2 = w^2 / 3 ≈ 0.0833
diff --git a/src/asyncflow/config/enums.py b/src/asyncflow/config/enums.py
new file mode 100644
index 0000000..78b6f16
--- /dev/null
+++ b/src/asyncflow/config/enums.py
@@ -0,0 +1,273 @@
+"""
+Application-wide Enums.
+
+This module groups all the static enumerations used by the AsyncFlow backend
+so that:
+
+ JSON / YAML payloads can be strictly validated with Pydantic.
+ Front-end and simulation engine share a single source of truth.
+ Ruff, mypy and IDEs can leverage the strong typing provided by Enum classes.
+
+IMPORTANT: Changing any enum value is a breaking-change for every
+stored configuration file. Add new members whenever possible instead of
+renaming existing ones.
+"""
+
+from enum import Enum, IntEnum, StrEnum
+
+# ======================================================================
+# CONSTANTS FOR THE REQUEST-GENERATOR COMPONENT
+# ======================================================================
+
+
+class TimeDefaults(IntEnum):
+    """
+    Default time-related constants (expressed in seconds).
+
+    These values are used when the user omits an explicit parameter. They also
+    serve as lower / upper bounds for validation for the requests generator.
+    """
+
+    MIN_TO_SEC = 60  # 1 minute → 60 s
+    USER_SAMPLING_WINDOW = 60  # every 60 seconds sample the number of active user
+    SIMULATION_TIME = 3_600  # run 1 h if user gives no value
+    MIN_SIMULATION_TIME = 5  # 5 seconds give a broad spectrum
+    MIN_USER_SAMPLING_WINDOW = 1 # 1 s minimum
+    MAX_USER_SAMPLING_WINDOW = 120 # 2 min maximum
+
+
+class Distribution(StrEnum):
+    """
+    Probability distributions accepted by app.schemas.RVConfig.
+
+    The string value is exactly the identifier that must appear in JSON
+    payloads.  The simulation engine will map each name to the corresponding
+    random sampler (e.g.numpy.random.poisson).
+    """
+
+    POISSON = "poisson"
+    LOG_NORMAL = "log_normal"
+    EXPONENTIAL = "exponential"
+    UNIFORM = "uniform"
+    EMPIRICAL = "empirical"
+    WEIBULL = "weibull"
+    PARETO = "pareto"
+    ERLANG = "erlang"
+    DETERMINISTIC = "deterministic"
+
+class VariabilityLevel(StrEnum):
+  """Wrapper to define three level of fluctuations"""
+
+  LOW = "low"
+  MEDIUM = "medium"
+  HIGH = "high"
+
+# ======================================================================
+# CONSTANTS FOR ENDPOINT STEP DEFINITION (REQUEST-HANDLER)
+# ======================================================================
+
+class EndpointStepIO(StrEnum):
+    """
+    I/O-bound operation categories that can occur inside an endpoint step.
+      - TASK_SPAWN
+         Spawns an additional ``asyncio.Task`` and returns immediately.
+      - LLM
+         Performs a remote Large-Language-Model inference call.
+        - WAIT
+          Passive, *non-blocking* wait for I/O completion; no new task spawned.
+        - DB
+          Round-trip to a relational / NoSQL database.
+        - CACHE
+          Access to a local or distributed cache layer.
+    """
+
+    TASK_SPAWN = "io_task_spawn"
+    LLM        = "io_llm"
+    WAIT       = "io_wait"
+    DB         = "io_db"
+    CACHE      = "io_cache"
+
+
+class EndpointStepCPU(StrEnum):
+    """
+    CPU-bound operation categories inside an endpoint step.
+
+    Use these when the coroutine keeps the Python interpreter busy
+    (GIL-bound or compute-heavy code) rather than waiting for I/O.
+    """
+
+    INITIAL_PARSING      = "initial_parsing"
+    CPU_BOUND_OPERATION  = "cpu_bound_operation"
+
+
+class EndpointStepRAM(StrEnum):
+    """
+    Memory-related operations inside a step.
+
+    Currently limited to a single category, but kept as an Enum so that future
+    resource types (e.g. GPU memory) can be added without schema changes.
+    """
+
+    RAM = "ram"
+
+
+class StepOperation(StrEnum):
+    """
+    Keys used inside the metrics dictionary of a step.
+
+    CPU_TIME - Service time (seconds) during which the coroutine occupies
+      the CPU / GIL.
+    NECESSARY_RAM - Peak memory (MB) required by the step.
+    """
+
+    CPU_TIME        = "cpu_time"
+    IO_WAITING_TIME = "io_waiting_time"
+    NECESSARY_RAM   = "necessary_ram"
+
+# ======================================================================
+# NAME FOR LOAD BALANCER ALGORITHMS
+# ======================================================================
+
+class LbAlgorithmsName(StrEnum):
+  """definition of the available algortithms for the Load Balancer"""
+
+  ROUND_ROBIN = "round_robin"
+  LEAST_CONNECTIONS = "least_connection"
+  RANDOM = "random"
+  FCFS = "fcfs"
+
+
+# ======================================================================
+# CONSTANTS FOR THE MACRO-TOPOLOGY GRAPH
+# ======================================================================
+
+class SystemNodes(StrEnum):
+    """
+    High-level node categories of the system topology graph.
+
+    Each member represents a *macro-component* that may have its own SimPy
+    resources (CPU cores, DB pool, etc.).
+    """
+
+    GENERATOR     = "generator"
+    SERVER        = "server"
+    CLIENT        = "client"
+    LOAD_BALANCER = "load_balancer"
+
+class SystemEdges(StrEnum):
+    """
+    Edge categories connecting different class SystemNodes.
+
+    Currently only network links are modeled; new types (IPC queue, message
+    bus, stream) can be added without impacting existing payloads.
+    """
+
+    NETWORK_CONNECTION = "network_connection"
+    LINK_CONNECTION = "link_connection"
+
+# ======================================================================
+# CONSTANTS FOR THE EVENT TO INJECT IN THE SIMULATION
+# ======================================================================
+
+class EventDescription(StrEnum):
+  """Description for the events you may inject during the simulation"""
+
+  SERVER_UP = "server_up"
+  SERVER_DOWN = "server_down"
+  NETWORK_SPIKE_START = "network_spike_start"
+  NETWORK_SPIKE_END = "network_spike_end"
+
+
+# ======================================================================
+# CONSTANTS FOR SAMPLED METRICS
+# ======================================================================
+
+class SampledMetricName(StrEnum):
+  """
+  Define the metrics sampled every fixed amount of
+  time to create a time series
+  """
+
+  # Mandatory metrics to collect
+  READY_QUEUE_LEN = "ready_queue_len" #length of the event loop ready q
+  EVENT_LOOP_IO_SLEEP = "event_loop_io_sleep"
+  RAM_IN_USE = "ram_in_use"
+  EDGE_CONCURRENT_CONNECTION = "edge_concurrent_connection"
+
+
+class SamplePeriods(float, Enum):
+  """
+  Defining the value of the sample periods for the metrics for which
+  we have to extract a time series
+  """
+
+  STANDARD_TIME = 0.01 # 10 MILLISECONDS
+  MINIMUM_TIME = 0.001 # 1 MILLISECOND
+  MAXIMUM_TIME = 0.5   # 500 MILLISECONDS
+
+# ======================================================================
+# CONSTANTS FOR EVENT METRICS
+# ======================================================================
+
+class EventMetricName(StrEnum):
+  """
+  Define the metrics triggered by event with no
+  time series
+  """
+
+  # Mandatory
+  RQS_CLOCK = "rqs_clock" # useful to collect starting and finishing time of rqs
+  RQS_SERVER_CLOCK = "rqs_server_clock" #useful for latency and throughput of the server
+  SERVICE_TIME = "service_time"
+  IO_TIME = "io_time"
+  WAITING_TIME = "waiting_time"
+
+
+  # Not mandatory now not implemented
+  LLM_COST = "llm_cost"
+
+
+# ======================================================================
+# CONSTANTS FOR AGGREGATED METRICS
+# ======================================================================
+
+class AggregatedMetricName(StrEnum):
+  """aggregated metrics to calculate at the end of simulation"""
+
+  LATENCY_STATS = "latency_stats"
+  THROUGHPUT = "throughput_rps"
+  SERVER_THROUGHPUT = "server_throughput"
+  SERVER_LATENCY_STATS = "server_latency_stats"
+  SERVICE_TIME_STATS = "service_time_stats"
+  IO_TIME_STATS = "io_time_stats"
+  WAITING_TIME_STATS = "waiting_time_stats"
+  UTILIZATION = "utilization"
+
+  # now not implemented
+  LLM_STATS = "llm_stats"
+
+# ======================================================================
+# CONSTANTS FOR SERVER RUNTIME
+# ======================================================================
+
+class ServerResourceName(StrEnum):
+  """Keys for each server resource type, used when building the container map."""
+
+  CPU = "CPU"
+  RAM = "RAM"
+
+# ======================================================================
+# CONSTANTS FOR LATENCY STATS
+# ======================================================================
+
+class LatencyKey(StrEnum):
+  """Keys for the collection of the latency stats"""
+
+  TOTAL_REQUESTS = "total_requests"
+  MEAN           = "mean"
+  MEDIAN         = "median"
+  STD_DEV        = "std_dev"
+  P95            = "p95"
+  P99            = "p99"
+  MIN            = "min"
+  MAX            = "max"
diff --git a/src/asyncflow/enums/__init__.py b/src/asyncflow/enums/__init__.py
index a07a18f..86283b0 100644
--- a/src/asyncflow/enums/__init__.py
+++ b/src/asyncflow/enums/__init__.py
@@ -1,6 +1,6 @@
 """Public enums used in scenario definitions."""
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     Distribution,
     EndpointStepCPU,
     EndpointStepIO,
diff --git a/src/asyncflow/metrics/client.py b/src/asyncflow/metrics/client.py
index 2e49638..c2632d2 100644
--- a/src/asyncflow/metrics/client.py
+++ b/src/asyncflow/metrics/client.py
@@ -9,7 +9,9 @@
 class RqsClock(NamedTuple):
     """
     structure to register time of generation and
-    time of elaboration for each request
+    time of elaboration for each request during
+    all the cycle of elaboration starting and ending
+    with the client
     """
 
     start: float
diff --git a/src/asyncflow/metrics/collector.py b/src/asyncflow/metrics/collector.py
index 38c2f0d..ac613d1 100644
--- a/src/asyncflow/metrics/collector.py
+++ b/src/asyncflow/metrics/collector.py
@@ -4,7 +4,7 @@
 
 import simpy
 
-from asyncflow.config.constants import SampledMetricName
+from asyncflow.config.enums import SampledMetricName
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.actors.server import ServerRuntime
 from asyncflow.schemas.settings.simulation import SimulationSettings
diff --git a/src/asyncflow/metrics/edge.py b/src/asyncflow/metrics/edge.py
index f9626dd..b060d2e 100644
--- a/src/asyncflow/metrics/edge.py
+++ b/src/asyncflow/metrics/edge.py
@@ -2,7 +2,7 @@
 
 from collections.abc import Iterable
 
-from asyncflow.config.constants import SampledMetricName
+from asyncflow.config.enums import SampledMetricName
 
 # Initialize one time outside the function all possible metrics
 # related to the edges, the idea of this structure is to
diff --git a/src/asyncflow/metrics/server.py b/src/asyncflow/metrics/server.py
index 6ebb96e..016d464 100644
--- a/src/asyncflow/metrics/server.py
+++ b/src/asyncflow/metrics/server.py
@@ -1,11 +1,11 @@
 """
 initialization of the structure to gather the sampled metrics
-for the server of the system
+and event metrics for the server of the system
 """
-
 from collections.abc import Iterable
+from dataclasses import dataclass
 
-from asyncflow.config.constants import SampledMetricName
+from asyncflow.config.enums import SampledMetricName
 
 # Initialize one time outside the function all possible metrics
 # related to the servers, the idea of this structure is to
@@ -32,3 +32,14 @@ def build_server_metrics(
         metric: [] for metric in SERVER_METRICS
         if metric in enabled_sample_metrics
     }
+
+# For the client we choosed a named tuple, here we prefer
+# a dataclass because we need mutability since start and
+# are updated in two different steps
+@dataclass
+class ServerClock:
+    """Server-side request timing: start + finish."""
+
+    start: float
+    finish: float | None = None
+
diff --git a/src/asyncflow/metrics/analyzer.py b/src/asyncflow/metrics/simulation_analyzer.py
similarity index 65%
rename from src/asyncflow/metrics/analyzer.py
rename to src/asyncflow/metrics/simulation_analyzer.py
index b9a6ea2..e61aeb2 100644
--- a/src/asyncflow/metrics/analyzer.py
+++ b/src/asyncflow/metrics/simulation_analyzer.py
@@ -3,11 +3,15 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypedDict
 
 import numpy as np
 
-from asyncflow.config.constants import LatencyKey, SampledMetricName
+from asyncflow.config.enums import (
+    EventMetricName,
+    LatencyKey,
+    SampledMetricName,
+)
 from asyncflow.config.plot_constants import (
     LATENCY_PLOT,
     RAM_PLOT,
@@ -15,24 +19,38 @@
     THROUGHPUT_PLOT,
     PlotCfg,
 )
+from asyncflow.metrics.server import ServerClock
 
 if TYPE_CHECKING:
     # Standard library typing imports in type-checking block (TC003).
-    from collections.abc import Iterable
+    from collections.abc import Iterable, Sequence
 
     from matplotlib.axes import Axes
     from matplotlib.lines import Line2D
 
     from asyncflow.runtime.actors.client import ClientRuntime
     from asyncflow.runtime.actors.edge import EdgeRuntime
+    from asyncflow.runtime.actors.load_balancer import LoadBalancerRuntime
     from asyncflow.runtime.actors.server import ServerRuntime
     from asyncflow.schemas.settings.simulation import SimulationSettings
 
 
-# Short alias to keep signatures within 88 chars (E501).
+# Short alias to keep signatures within 88 chars.
 Series = tuple[list[float], list[float]]
 
 
+class ServerArrays(TypedDict):
+    """Object to collect relevant data for each server"""
+
+    latencies: list[float]
+    service_time: list[float]
+    io_time: list[float]
+    waiting_time: list[float]
+    finish_times: list[float]
+
+ServerArraysMap = dict[str, ServerArrays]
+
+
 class ResultsAnalyzer:
     """Analyze and visualize the results of a completed simulation.
 
@@ -55,12 +73,14 @@ def __init__(
         servers: list[ServerRuntime],
         edges: list[EdgeRuntime],
         settings: SimulationSettings,
+        lb: LoadBalancerRuntime | None = None,
     ) -> None:
         """Initialize with the runtime objects and original settings."""
         self._client = client
         self._servers = servers
         self._edges = edges
         self._settings = settings
+        self.lb = lb
 
         # Lazily computed caches
         self.latencies: list[float] | None = None
@@ -68,18 +88,122 @@ def __init__(
         self.throughput_series: Series | None = None
         # Sampled metrics are stored with string metric keys for simplicity.
         self.sampled_metrics: dict[str, dict[str, list[float]]] | None = None
+        # Per-server, per-request arrays (filled lazily by _collect_server_event_arrays)
+        # Map: server_id -> {
+        #   'latencies':     list[float],  # server-side (finish - start)
+        #   'service_time':  list[float],
+        #   'io_time':       list[float],
+        #   'waiting_time':  list[float],
+        #   'finish_times':  list[float],  # for per-server throughput
+        # }
+        self.server_event_arrays: ServerArraysMap | None = None
 
     # ─────────────────────────────────────────────
     # Core computation
     # ─────────────────────────────────────────────
     def process_all_metrics(self) -> None:
         """Compute all aggregated and sampled metrics if not already done."""
+        # Client-side: end-to-end latencies + 1s throughput
         if self.latency_stats is None and self._client.rqs_clock:
             self._process_event_metrics()
 
+        # Sampled time series from servers/edges (RAM, queues, etc.)
         if self.sampled_metrics is None:
             self._extract_sampled_metrics()
 
+        # Per-server per-request arrays (service/io/wait/server-latency/finishes)
+        self.get_server_event_arrays()  # single call, handles lazy init
+
+    def _build_server_event_arrays(self) -> ServerArraysMap:
+        """Pure builder: returns {server_id -> arrays} without mutating self."""
+        out: ServerArraysMap = {}
+
+        for srv in self._servers:
+            sid = srv.server_config.id
+            latencies: list[float] = []
+            service: list[float] = []
+            io_w: list[float] = []
+            wait: list[float] = []
+            finishes: list[float] = []
+
+            # srv.server_rqs_clock: Mapping[int, MetricBucket]
+            for bucket in srv.server_rqs_clock.values():
+                # Server clock (if present and completed)
+                clock = bucket.get(EventMetricName.RQS_SERVER_CLOCK)
+                if isinstance(clock, ServerClock) and clock.finish is not None:
+                    latencies.append(float(clock.finish - clock.start))
+                    finishes.append(float(clock.finish))
+
+                # Accumulators are floats in the bucket
+                st = bucket.get(EventMetricName.SERVICE_TIME, 0.0)
+                if isinstance(st, float):
+                    service.append(st)
+
+                it = bucket.get(EventMetricName.IO_TIME, 0.0)
+                if isinstance(it, float):
+                    io_w.append(it)
+
+                wt = bucket.get(EventMetricName.WAITING_TIME, 0.0)
+                if isinstance(wt, float):
+                    wait.append(wt)
+
+            out[sid] = ServerArrays(
+                latencies=latencies,
+                service_time=service,
+                io_time=io_w,
+                waiting_time=wait,
+                finish_times=finishes,
+            )
+
+        return out
+
+    def _ensure_server_arrays(self) -> ServerArraysMap:
+        """Ensure self.server_event_arrays is built exactly once, and return it."""
+        if self.server_event_arrays is None:
+            self.server_event_arrays = self._build_server_event_arrays()
+        return self.server_event_arrays
+
+    def get_server_event_arrays(self) -> ServerArraysMap:
+        """Return {server_id -> per-request arrays} (computed lazily)."""
+        return self._ensure_server_arrays()
+
+    def get_server_throughput_series(
+        self, server_id: str, *, window_s: float | None = None,
+    ) -> Series:
+        """
+        Return (timestamps, RPS) for a single server
+        in fixed windows (default 1s)
+        """
+        if window_s is None:
+            window_s = ResultsAnalyzer._WINDOW_SIZE_S
+
+        arrays = self.get_server_event_arrays().get(server_id)
+        if arrays is None:
+            return ([], [])
+
+        finishes = sorted(arrays["finish_times"])
+        if not finishes:
+            return ([], [])
+
+        end_time = self._settings.total_simulation_time
+        timestamps: list[float] = []
+        rps_values: list[float] = []
+        idx = 0
+        window = float(window_s)
+        current_end = window
+
+        while current_end <= end_time:
+            count = 0
+            while idx < len(finishes) and finishes[idx] <= current_end:
+                count += 1
+                idx += 1
+            timestamps.append(current_end)
+            rps_values.append(count / window)
+            current_end += window
+
+        return (timestamps, rps_values)
+
+
     def _process_event_metrics(self) -> None:
         """Calculate latency stats and throughput time series (1s RPS)."""
         # 1) Latencies
@@ -243,6 +367,17 @@ def get_series(self, key: SampledMetricName | str, entity_id: str) -> Series:
         times = (np.arange(len(vals)) * self._settings.sample_period_s).tolist()
         return times, vals
 
+    def get_lb_waiting_times(self) -> Sequence[float]:
+        """
+        Return LB waiting times (FCFS). If LB missing or property absent, return empty
+        useful when the routing algo is fcfs
+        """
+        try:
+            return () if self.lb is None else self.lb.lb_waiting_times
+        except AttributeError:
+            return ()
+
+
     # ─────────────────────────────────────────────
     # Plotting helpers
     # ─────────────────────────────────────────────
@@ -533,7 +668,6 @@ def plot_single_server_io_queue(self, ax: Axes, server_id: str) -> None:
         leg.get_frame().set_facecolor("white")
 
 
-
     def plot_single_server_ram(self, ax: Axes, server_id: str) -> None:
         """Plot RAM usage with mean/min/max lines and a single legend box with
         values. No trend/ewma, no legend entry for the main series.
@@ -587,3 +721,187 @@ def plot_single_server_ram(self, ax: Axes, server_id: str) -> None:
             fontsize=9.5,
         )
         leg.get_frame().set_facecolor("white")
+
+    # -------------------------------------------------
+    # SERVER METRICS PLOT
+    #--------------------------------------------------
+
+    def _plot_histogram_with_overlays(
+        self,
+        ax: Axes,
+        data: list[float],
+        *,
+        title: str,
+        xlabel: str,
+        show_p50: bool = False,
+    ) -> None:
+        """Render a histogram with mean/(optional)P50/P95/P99 overlays
+        and a compact legend.
+        """
+        if not data:
+            ax.text(0.5, 0.5, "No data", ha="center", va="center")
+            ax.set_title(title)
+            ax.set_xlabel(xlabel)
+            ax.set_ylabel("count")
+            ax.grid(visible=True)
+            return
+
+        # Colors consistent with the rest of the module
+        col_mean = "#d62728"   # red
+        col_p50  = "#ff7f0e"   # orange
+        col_p95  = "#2ca02c"   # green
+        col_p99  = "#9467bd"   # purple
+        hist_color = "#1f77b4" # soft blue
+
+        arr = np.asarray(data, dtype=float)
+        v_mean = float(np.mean(arr))
+        v_p95  = float(np.percentile(arr, 95))
+        v_p99  = float(np.percentile(arr, 99))
+
+        # Histogram (subtle to let overlays stand out)
+        ax.hist(
+            arr, bins=50, color=hist_color, alpha=0.40,
+            edgecolor="none", zorder=1,
+        )
+
+        # Overlays
+        ax.axvline(
+            v_mean, color=col_mean, linestyle=":", linewidth=1.8,
+            alpha=0.95, zorder=3,
+        )
+        handles: list[Line2D] = []
+
+        # Legend handles (dummy lines with values)
+        h_mean = ax.plot(
+            [], [], color=col_mean, linestyle=":", linewidth=2.4,
+            label=f"mean = {v_mean:.3f}",
+        )[0]
+        handles.append(h_mean)
+
+        if show_p50:
+            v_p50 = float(np.percentile(arr, 50))
+            ax.axvline(
+                v_p50, color=col_p50, linestyle="-.", linewidth=1.6,
+                alpha=0.90, zorder=3,
+            )
+            h_p50 = ax.plot(
+                [], [], color=col_p50, linestyle="-.", linewidth=2.4,
+                label=f"P50  = {v_p50:.3f}",
+            )[0]
+            handles.append(h_p50)
+
+        ax.axvline(
+            v_p95, color=col_p95, linestyle="--", linewidth=1.6,
+            alpha=0.90, zorder=3,
+        )
+        ax.axvline(
+            v_p99, color=col_p99, linestyle="--", linewidth=1.6,
+            alpha=0.90, zorder=3,
+        )
+
+        h_p95 = ax.plot(
+            [], [], color=col_p95, linestyle="--", linewidth=2.4,
+            label=f"P95  = {v_p95:.3f}",
+        )[0]
+        h_p99 = ax.plot(
+            [], [], color=col_p99, linestyle="--", linewidth=2.4,
+            label=f"P99  = {v_p99:.3f}",
+        )[0]
+        handles.extend([h_p95, h_p99])
+
+        # Titles / labels / grid
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel("count")
+        ax.grid(visible=True)
+
+        # Legend (top-right) with readable background
+        leg = ax.legend(
+            handles=handles,
+            loc="upper right",
+            bbox_to_anchor=(0.98, 0.98),
+            borderaxespad=0.0,
+            framealpha=0.90,
+            fancybox=True,
+            handlelength=2.6,
+            fontsize=9.5,
+        )
+        leg.get_frame().set_facecolor("white")
+
+
+    def plot_server_event_metrics_dashboard(
+            self,
+            ax_latency_hist: Axes,
+            ax_service_hist: Axes,
+            ax_io_hist: Axes,
+            ax_wait_hist: Axes,
+            server_id: str,
+        ) -> None:
+            """Dashboard of per-request distributions for a single server:
+            - server-side latency (finish - start)
+            - accumulated SERVICE_TIME (CPU)
+            - accumulated IO_TIME
+            - accumulated WAITING_TIME
+            """
+            arrays = self.get_server_event_arrays().get(server_id, None)
+            if arrays is None:
+                # Graceful empty state for all panes
+                for ax, msg in [
+                    (ax_latency_hist, "No server-side latencies"),
+                    (ax_service_hist, "No service-time samples"),
+                    (ax_io_hist, "No I/O-time samples"),
+                    (ax_wait_hist, "No waiting-time samples"),
+                ]:
+                    ax.text(0.5, 0.5, msg, ha="center", va="center")
+                    ax.grid(visible=True)
+                return
+
+            # 1) Server-side latency histogram (mean/P50/P95/P99)
+            self._plot_histogram_with_overlays(
+                ax_latency_hist,
+                arrays["latencies"],
+                title=f"Server latency — {server_id}",
+                xlabel="seconds",
+                show_p50=True,
+            )
+
+            # 2) CPU service time (mean/P95/P99)
+            self._plot_histogram_with_overlays(
+                ax_service_hist,
+                arrays["service_time"],
+                title=f"CPU service time — {server_id}",
+                xlabel="seconds",
+                show_p50=False,
+            )
+
+            # 3) I/O wait time (mean/P95/P99)
+            self._plot_histogram_with_overlays(
+                ax_io_hist,
+                arrays["io_time"],
+                title=f"I/O time — {server_id}",
+                xlabel="seconds",
+                show_p50=False,
+            )
+
+            # 4) CPU waiting time (mean/P95/P99)
+            self._plot_histogram_with_overlays(
+                ax_wait_hist,
+                arrays["waiting_time"],
+                title=f"CPU waiting time — {server_id}",
+                xlabel="seconds",
+                show_p50=False,
+            )
+
+    def plot_server_timeseries_dashboard(
+        self,
+        ax_ready: Axes,
+        ax_io: Axes,
+        ax_ram: Axes,
+        server_id: str,
+        ) -> None:
+        """Quick dashboard for one server: Ready queue, I/O queue, and RAM series."""
+        # Reuse existing single-plot helpers for consistency.
+        self.plot_single_server_ready_queue(ax_ready, server_id)
+        self.plot_single_server_io_queue(ax_io, server_id)
+        self.plot_single_server_ram(ax_ram, server_id)
+
diff --git a/src/asyncflow/metrics/sweep_analyzer.py b/src/asyncflow/metrics/sweep_analyzer.py
new file mode 100644
index 0000000..491e72b
--- /dev/null
+++ b/src/asyncflow/metrics/sweep_analyzer.py
@@ -0,0 +1,455 @@
+"""
+SweepAnalyzer — build plots from a sweep over *mean rps*.
+
+Global
+------
+- Throughput (mean RPS) vs. users
+- Mean latency (W) vs. users
+- (Opzionale) Latency percentiles vs. users
+
+Per-server (overlay)
+--------------------
+- Utilization rho_i vs. users
+- Waiting time Wq_i vs. users
+- Service rate mu_i vs. users
+- Throughput lambda_i vs. users
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, cast
+
+import matplotlib.pyplot as plt
+
+from asyncflow.config.enums import LatencyKey
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable
+
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Data containers
+# ──────────────────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class GlobalPoint:
+    """One sweep point (global/system metrics collected today)."""
+
+    users: int
+    lambda_rps: float          # mean throughput (RPS)
+    W: float                   # mean end-to-end latency (s)
+    p50: float                 # latency median (s)
+    p95: float                 # latency P95 (s)
+    p99: float                 # latency P99 (s)
+
+
+@dataclass(frozen=True)
+class ServerPoint:
+    """One sweep point for a single server."""
+
+    users: int
+    server_id: str
+    lambda_rps: float          # server throughput (estimated)
+    mu_rps: float              # 1 / mean(service_time)
+    rho: float                 # lambda / mu
+    Wq: float                  # mean waiting time (s)
+    service_mean_s: float      # mean service time (s)
+    completions: int           # number of completed requests
+    server_latency_mean_s: float
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Analyzer
+# ──────────────────────────────────────────────────────────────────────
+
+class SweepAnalyzer:
+    """
+    Build plots from a sweep over *mean rps*.
+
+    Input
+    -----
+    pairs : Iterable[tuple[int, ResultsAnalyzer]]
+        Output of Sweep.sweep_on_user(...): (users, analyzer).
+
+    Caching
+    -------
+    Collections are private and executed once. All plotters read from caches.
+    """
+
+    def __init__(self, pairs: Iterable[tuple[int, ResultsAnalyzer]]) -> None:
+        """Initialize with (users, ResultsAnalyzer) pairs and prepare caches."""
+        self._pairs: list[tuple[int, ResultsAnalyzer]] = sorted(
+            (int(u), ra) for (u, ra) in pairs
+        )
+        # Caches
+        self._global_points: list[GlobalPoint] = []
+        self._server_points: dict[str, list[ServerPoint]] = {}
+        self._collected_global: bool = False
+        self._collected_servers: bool = False
+
+    # ──────────────────────────────────────────────────────────────────
+    # Public convenience
+    # ──────────────────────────────────────────────────────────────────
+
+    def precollect(self) -> None:
+        """Warm both caches once (optional)."""
+        self._ensure_global_collected()
+        self._ensure_servers_collected()
+
+    # ──────────────────────────────────────────────────────────────────
+    # Private collectors (one-time)
+    # ──────────────────────────────────────────────────────────────────
+
+    def _ensure_global_collected(self) -> None:
+        if self._collected_global:
+            return
+        self._collect_global()
+        self._collected_global = True
+
+    def _ensure_servers_collected(self) -> None:
+        if self._collected_servers:
+            return
+        self._collect_servers()
+        self._collected_servers = True
+
+    def _collect_global(self) -> None:
+        """Compute global/system metrics (throughput & latency) once."""
+        out: list[GlobalPoint] = []
+
+        for users, ra in self._pairs:
+            # Ensure metrics are computed
+            ra.process_all_metrics()
+
+            # λ: mean throughput from the time series
+            _, rps_series = ra.get_throughput_series()
+            if rps_series:
+                lambda_rps = float(sum(rps_series)) / float(len(rps_series))
+            else:
+                lambda_rps = 0.0
+
+            # Latency stats → W and percentiles
+            lat = ra.get_latency_stats()
+            w_mean = float(lat.get(LatencyKey.MEAN, 0.0))
+            p50 = float(lat.get(LatencyKey.MEDIAN, 0.0))
+            p95 = float(lat.get(LatencyKey.P95, 0.0))
+            p99 = float(lat.get(LatencyKey.P99, 0.0))
+
+            out.append(
+                GlobalPoint(
+                    users=users,
+                    lambda_rps=lambda_rps,
+                    W=w_mean,
+                    p50=p50,
+                    p95=p95,
+                    p99=p99,
+                ),
+            )
+
+        self._global_points = out
+
+    def _collect_servers(self) -> None:
+        """
+        Compute per-server metrics across the sweep once.
+
+        Server throughput λᵢ is estimated via completions split:
+            λᵢ ≈ (nᵢ / Σⱼ nⱼ) · λ_tot
+        """
+        points: dict[str, list[ServerPoint]] = {}
+
+        for users, ra in self._pairs:
+            ra.process_all_metrics()
+
+            # Global lambda for proportional split
+            _, rps_series = ra.get_throughput_series()
+            lambda_tot = (
+                float(sum(rps_series)) / float(len(rps_series))
+                if rps_series
+                else 0.0
+            )
+
+            arrays_map = cast(
+                "dict[str, dict[str, list[float]]]",
+                ra.get_server_event_arrays(),
+            )
+            sids = ra.list_server_ids()
+
+            total_compl = 0
+            per_server_compl: dict[str, int] = {}
+            for sid in sids:
+                arr_for_count: dict[str, list[float]] = arrays_map.get(sid, {})
+                n = len(arr_for_count.get("finish_times", []))
+                per_server_compl[sid] = n
+                total_compl += n
+
+            for sid in sids:
+                arr: dict[str, list[float]] = arrays_map.get(sid, {})
+
+                # μᵢ from mean(service_time)
+                s_vals: list[float] = arr.get("service_time", [])
+                if s_vals:
+                    s_mean = float(sum(s_vals)) / float(len(s_vals))
+                    mu = (1.0 / s_mean) if s_mean > 0.0 else float("inf")
+                else:
+                    s_mean = 0.0
+                    mu = float("inf")
+
+                # Wqᵢ from mean(waiting_time)
+                wq_vals: list[float] = arr.get("waiting_time", [])
+                wq_mean = (
+                    float(sum(wq_vals)) / float(len(wq_vals))
+                    if wq_vals
+                    else 0.0
+                )
+
+                # server latency
+                lat_vals: list[float] = arr.get("latencies", [])
+                if lat_vals:
+                    server_lat_mean = float(sum(lat_vals)) / float(len(lat_vals))
+                else:
+                    server_lat_mean = wq_mean + (
+                        1.0 / mu if mu not in (0.0, float("inf")) else s_mean)
+
+                # λᵢ via proportional split of completions
+                n_i = per_server_compl.get(sid, 0)
+                if total_compl > 0:
+                    lambda_i = (n_i / float(total_compl)) * lambda_tot
+                else:
+                    lambda_i = 0.0
+
+                # ρᵢ = λᵢ / μᵢ
+                rho = (lambda_i / mu) if mu not in (0.0, float("inf")) else 0.0
+
+                points.setdefault(sid, []).append(
+                    ServerPoint(
+                        users=users,
+                        server_id=sid,
+                        lambda_rps=lambda_i,
+                        mu_rps=mu,
+                        rho=rho,
+                        Wq=wq_mean,
+                        service_mean_s=s_mean,
+                        completions=n_i,
+                        server_latency_mean_s=server_lat_mean,
+                    ),
+                )
+
+        self._server_points = points
+
+    # ──────────────────────────────────────────────────────────────────
+    # Global plotters (cached)
+    # ──────────────────────────────────────────────────────────────────
+
+    def plot_global_throughput(self, ax: Axes) -> None:
+        """Plot mean throughput (RPS) vs. mean rps."""
+        self._ensure_global_collected()
+        pts = self._global_points
+        xs = [p.users for p in pts]
+        ys = [p.lambda_rps for p in pts]
+        ax.plot(xs, ys, marker="o")
+        ax.set_title("Throughput (mean RPS) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("RPS")
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_global_latency(self, ax: Axes) -> None:
+        """Plot mean system time (W) vs. mean rps."""
+        self._ensure_global_collected()
+        pts = self._global_points
+        xs = [p.users for p in pts]
+        ys = [p.W for p in pts]
+        ax.plot(xs, ys, marker="o")
+        ax.set_title("Mean system time (W) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("W (seconds)")
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_global_latency_percentiles(self, ax: Axes) -> None:
+        """Plot P50, P95, P99 latency vs. mean rps."""
+        self._ensure_global_collected()
+        pts = self._global_points
+        xs = [p.users for p in pts]
+        ax.plot(xs, [p.p50 for p in pts], marker="o", label="P50")
+        ax.plot(xs, [p.p95 for p in pts], marker="o", label="P95")
+        ax.plot(xs, [p.p99 for p in pts], marker="o", label="P99")
+        ax.set_title("Latency percentiles vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("Latency (seconds)")
+        ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_global_dashboard(self) -> Figure:
+        """1x2 dashboard: throughput and mean latency (W)."""
+        fig, axes = plt.subplots(1, 2, figsize=(12, 4.5), dpi=130)
+        self.plot_global_throughput(axes[0])
+        self.plot_global_latency(axes[1])
+        fig.tight_layout()
+        return fig
+
+    # ──────────────────────────────────────────────────────────────────
+    # Per-server plotters (overlay; cached)
+    # ──────────────────────────────────────────────────────────────────
+
+    def _select_top_servers(
+        self,
+        by: Literal["rho", "Wq", "mu", "lambda"],
+        max_servers: int,
+    ) -> list[str]:
+        """Pick up to `max_servers` “hottest” servers at max users (from cache)."""
+        self._ensure_servers_collected()
+        data = self._server_points
+        if not data:
+            return []
+
+        max_users = max(
+            (pt.users for pts in data.values() for pt in pts),
+            default=0,
+        )
+        scores: list[tuple[str, float]] = []
+        for sid, pts in data.items():
+            at_max = [p for p in pts if p.users == max_users]
+            if not at_max:
+                continue
+            p = at_max[-1]
+            if by == "rho":
+                val = p.rho
+            elif by == "Wq":
+                val = p.Wq
+            elif by == "mu":
+                val = -p.mu_rps if p.mu_rps not in (0.0, float("inf")) else -0.0
+            else:  # "lambda"
+                val = p.lambda_rps
+            scores.append((sid, float(val)))
+
+        scores.sort(key=lambda x: x[1], reverse=True)
+        return [sid for sid, _ in scores[:max_servers]]
+
+    def plot_server_utilization_overlay(
+        self,
+        ax: Axes,
+        *,
+        max_servers: int = 5,
+        server_ids: list[str] | None = None,
+    ) -> None:
+        """Overlay of server utilization rho vs. users (auto-picks hottest)"""
+        self._ensure_servers_collected()
+        ids = server_ids or self._select_top_servers("rho", max_servers)
+        for sid in sorted(ids):
+            pts = self._server_points.get(sid, [])
+            xs = [p.users for p in pts]
+            ys = [p.rho for p in pts]
+            ax.plot(xs, ys, marker="o", label=sid)
+        ax.set_title("Server utilization (rho) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("rho")
+        if ids:
+            ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_server_waiting_time_overlay(
+        self,
+        ax: Axes,
+        *,
+        max_servers: int = 5,
+        server_ids: list[str] | None = None,
+    ) -> None:
+        """Overlay of server waiting time Wqᵢ vs. users (auto-picks hottest)"""
+        self._ensure_servers_collected()
+        ids = server_ids or self._select_top_servers("Wq", max_servers)
+        for sid in sorted(ids):
+            pts = self._server_points.get(sid, [])
+            xs = [p.users for p in pts]
+            ys = [p.Wq for p in pts]
+            ax.plot(xs, ys, marker="o", label=sid)
+        ax.set_title("Server waiting time (Wq) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("Wq (seconds)")
+        if ids:
+            ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_server_service_rate_overlay(
+        self,
+        ax: Axes,
+        *,
+        max_servers: int = 5,
+        server_ids: list[str] | None = None,
+    ) -> None:
+        """Overlay of server service rate μ vs. users (auto-picks hottest)"""
+        self._ensure_servers_collected()
+        ids = server_ids or self._select_top_servers("mu", max_servers)
+        for sid in sorted(ids):
+            pts = self._server_points.get(sid, [])
+            xs = [p.users for p in pts]
+            ys = [p.mu_rps for p in pts]
+            ax.plot(xs, ys, marker="o", label=sid)
+        ax.set_title("Server service rate (mu) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("mu (1/s)")
+        if ids:
+            ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_server_throughput_overlay(
+        self,
+        ax: Axes,
+        *,
+        max_servers: int = 5,
+        server_ids: list[str] | None = None,
+    ) -> None:
+        """Overlay of server throughput λ vs. users (auto-picks hottest by default)."""
+        self._ensure_servers_collected()
+        ids = server_ids or self._select_top_servers("lambda", max_servers)
+        for sid in sorted(ids):
+            pts = self._server_points.get(sid, [])
+            xs = [p.users for p in pts]
+            ys = [p.lambda_rps for p in pts]
+            ax.plot(xs, ys, marker="o", label=sid)
+        ax.set_title("Server throughput (lambda) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("lambda (1/s)")
+        if ids:
+            ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+    def plot_server_latency_overlay(
+        self, ax: Axes, *, max_servers: int = 5, server_ids: list[str] | None = None,
+    ) -> None:
+        """Plot of the latency vs concurrent user"""
+        self._ensure_servers_collected()
+        ids = server_ids or self._select_top_servers("Wq", max_servers)
+        for sid in sorted(ids):
+            pts = self._server_points.get(sid, [])
+            xs = [p.users for p in pts]
+            ys = [p.server_latency_mean_s for p in pts]
+            ax.plot(xs, ys, marker="o", label=sid)
+        ax.set_title("Server latency (waiting+service) vs. mean Lambda_rps")
+        ax.set_xlabel("mean rps")
+        ax.set_ylabel("Server latency (s)")
+        if ids:
+            ax.legend()
+        ax.grid(visible=True, alpha=0.3)
+
+
+    def plot_server_dashboard(self) -> Figure:
+        """2x3 per-server overlay: rho_i, Wq_i, mu_i, lambda_i, server latency."""
+        fig, axes = plt.subplots(2, 3, figsize=(16, 8), dpi=130)
+
+        # Row 1
+        self.plot_server_utilization_overlay(axes[0, 0])
+        self.plot_server_waiting_time_overlay(axes[0, 1])
+        self.plot_server_service_rate_overlay(axes[0, 2])
+
+        # Row 2
+        self.plot_server_throughput_overlay(axes[1, 0])
+        self.plot_server_latency_overlay(axes[1, 1])
+        axes[1, 2].axis("off")  # keep layout symmetric
+
+        fig.tight_layout()
+        return fig
+
diff --git a/src/asyncflow/queue_theory_analysis/base.py b/src/asyncflow/queue_theory_analysis/base.py
new file mode 100644
index 0000000..5de4bbb
--- /dev/null
+++ b/src/asyncflow/queue_theory_analysis/base.py
@@ -0,0 +1,37 @@
+"""Base interfaces for queueing-theory analyzers.
+
+Each concrete analyzer (e.g. MM1) must:
+- declare its compatibility rules against an AsyncFlow payload
+- compute closed-form KPIs when assumptions are satisfied
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from asyncflow.schemas.payload import SimulationPayload
+
+
+class QueueTheoryBase(ABC):
+    """Abstract base for all queue-theory analyzers."""
+
+    @abstractmethod
+    def explain_incompatibilities(self, payload: SimulationPayload) -> list[str]:
+        """Return a list of human-readable reasons why the payload is incompatible.
+        Empty list means 'compatible'.
+        """
+
+    def is_compatible(self, payload: SimulationPayload) -> bool:
+        """Shorthand boolean check."""
+        return not self.explain_incompatibilities(payload)
+
+    def validate_or_raise(self, payload: SimulationPayload) -> None:
+        """Raise ValueError with a compact message if incompatible."""
+        errs = self.explain_incompatibilities(payload)
+        if errs:
+            bullet = "\n - "
+            msg = "Payload is not compatible with this queueing model:" + bullet
+            msg += bullet.join(errs)
+            raise ValueError(msg)
diff --git a/src/asyncflow/queue_theory_analysis/mmc.py b/src/asyncflow/queue_theory_analysis/mmc.py
new file mode 100644
index 0000000..3313892
--- /dev/null
+++ b/src/asyncflow/queue_theory_analysis/mmc.py
@@ -0,0 +1,663 @@
+"""
+Check if asyncflow under the hypothesis of a MMc queue
+(c >= 1), reproduce the theory.
+"""
+
+from __future__ import annotations
+
+import math
+import sys
+from typing import TYPE_CHECKING, Literal, TextIO, TypedDict, cast
+from weakref import WeakSet
+
+from asyncflow.config.enums import (
+    Distribution,
+    EndpointStepCPU,
+    LatencyKey,
+    LbAlgorithmsName,
+)
+from asyncflow.queue_theory_analysis.base import QueueTheoryBase
+from asyncflow.schemas.common.random_variables import RVConfig
+from asyncflow.schemas.topology.edges import LinkEdge
+
+if TYPE_CHECKING:
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
+
+
+class MMcParams(TypedDict):
+    """
+    Minimal global parameters for the M/M/c split model (round-robin into
+    per-server queues). These are either directly specified by the payload
+    or trivially derived and also observable from runs.
+
+    - lambda_rate (λ): arrival rate [1/s]
+    - mu_rate (μ): per-server service rate [1/s]
+    - c: number of parallel servers (c >= 1)
+    - rho (rho = λ/(cμ)): global utilization (stability requires rho < 1)
+    - a (λ/μ): offered load (expected busy servers); derivable and observable
+    - capacity_rate (cμ): total service capacity [1/s]
+    """
+
+    lambda_rate: float
+    mu_rate: float
+    c: int                  # c >= 1
+    rho: float              # rho = λ / (c * μ)
+    a: float                # λ / μ
+    capacity_rate: float    # c * μ
+
+MMcResultKey = Literal["lambda_rate", "mu_rate", "c", "rho", "L", "Lq", "W", "Wq"]
+
+class MMcResults(TypedDict):
+    """
+    Closed-form KPIs for the M/M/c split model (round-robin), restricted to
+    quantities you can also measure from the simulator (no Erlang-C terms).
+
+    Exposes:
+    - (λ, μ, c, rho) for clarity/logging and cross-checks
+    - L, Lq via Little's Law (L = λW, Lq = λWq)
+    - W, Wq (mean system time and mean waiting time)
+    """
+
+    # Parameters (echoed for convenience)
+    lambda_rate: float
+    mu_rate: float
+    c: int
+    rho: float
+
+    # Queue sizes and times (all observable)
+    L: float                # mean jobs in system
+    Lq: float               # mean jobs in queue
+    W: float                # mean time in system [s]
+    Wq: float               # mean waiting time [s]
+
+
+
+class MMcKPIRow(TypedDict):
+    """
+    One formatted row for theory vs observed comparison (M/M/c).
+    Same shape as the MM1 KPIRow; separate name to avoid collisions.
+    """
+
+    symbol: str
+    name: str
+    theory: float | str
+    observed: float | str
+    abs_diff: float | str
+    rel_diff_pct: float | str  # percentage (e.g., "3.2" means +3.2%)
+
+
+class MMcCompatGlobalRow(TypedDict):
+    """Row for global compatibility checks."""
+
+    scope: str   # "topology" | "generator" | "edges"
+    issue: str   # human-readable message
+
+
+class MMcCompatServerRow(TypedDict):
+    """Row for per-server compatibility checks."""
+
+    server_index: int
+    server_id: str
+    issue: str
+
+
+class MMc(QueueTheoryBase):
+    """Analyzer for the M/M/c split model (Round-Robin), c>=1, with strict checks."""
+
+    def __init__(self) -> None:
+        """Track analyzers we've already processed; weak refs avoid leaks."""
+        self._processed_ras: WeakSet[ResultsAnalyzer] = WeakSet()
+
+    # ──────────────────────────────────────────────────────────────────
+    # Compatibility checks split into helpers to keep cyclomatic low
+    # ──────────────────────────────────────────────────────────────────
+    def _check_topology(self, payload: SimulationPayload) -> list[str]:
+        errs: list[str] = []
+        nodes = payload.topology_graph.nodes
+        c = len(nodes.servers)
+
+        if c == 0:
+            errs.append("requires at least one server.")
+            return errs
+
+        lb = nodes.load_balancer
+        if c == 1:
+            if lb is not None:
+                errs.append("for c=1 the load balancer must be absent.")
+        elif lb is None:
+            errs.append("for c>1 a load balancer is required.")
+        elif lb.algorithms not in {LbAlgorithmsName.RANDOM, LbAlgorithmsName.FCFS}:
+             errs.append("supported lb algorithms: RANDOM (split) or FCFS (pooled).")
+
+        return errs
+
+    def _check_generator(self, payload: SimulationPayload) -> list[str]:
+        errs: list[str] = []
+        arrivals = payload.arrivals
+        if arrivals.model not in {Distribution.POISSON, Distribution.EXPONENTIAL}:
+            errs.append("arrivals.model must be 'poisson' or 'exponential'.")
+        return errs
+
+    def _check_edges(self, payload: SimulationPayload) -> list[str]:
+        errs: list[str] = []
+        if not payload.topology_graph.edges:
+            errs.append("topology must include at least one edge.")
+            return errs
+        # In pydantic we define edges to be only of type Network or Link
+        # The types are mutually exclusive hence we have to be sure only
+        # one edge is of the link type
+        edge = payload.topology_graph.edges[0]
+        if not isinstance(edge, LinkEdge):
+            errs.append(
+                "In MMc models edges are just connector, use link_edge as a type",
+            )
+        return errs
+
+    def _check_server_model(self, payload: SimulationPayload) -> list[str]:
+        errs: list[str] = []
+        servers = payload.topology_graph.nodes.servers
+
+        mu_ref: float | None = None
+        for idx, server in enumerate(servers):
+            if len(server.endpoints) != 1:
+                errs.append(f"server[{idx}] must expose exactly one endpoint.")
+                continue
+
+            steps = server.endpoints[0].steps
+            if len(steps) != 1:
+                errs.append(f"server[{idx}] endpoint must contain exactly one step.")
+                continue
+
+            step = steps[0]
+            if not isinstance(step.kind, EndpointStepCPU):
+                errs.append(f"server[{idx}] single step must be CPU-bound.")
+                continue
+
+            # Pydantic già fa CPU_TIME → qui prendiamo solo i parametri RV
+            _, op_data = next(iter(step.step_operation.items()))
+
+            if not isinstance(op_data, RVConfig):
+                errs.append(
+                    f"server[{idx}] service time must be an exponential RVConfig.")
+                continue
+            if op_data.distribution != Distribution.EXPONENTIAL:
+                errs.append(
+                    f"server[{idx}] service time distribution must be exponential.")
+                continue
+            if op_data.mean <= 0:
+                errs.append(
+                    f"server[{idx}] service time mean must be > 0.")
+                continue
+
+            mu_i = 1.0 / float(op_data.mean)
+            if mu_ref is None:
+                mu_ref = mu_i
+            # identicità dei server (tolleranza numerica)
+            elif abs(mu_i - mu_ref) > 1e-12 * max(1.0, mu_ref):
+                errs.append(
+                    f"all servers must be identical; "
+                    f"found different μ at server[{idx}].",
+                )
+
+        return errs
+
+    # ------------- Compatibility (public) --------------------------------
+    def explain_incompatibilities(
+        self, payload: SimulationPayload,
+    ) -> list[str]:
+        """Collect and return all MMc assumption violations."""
+        errors: list[str] = []
+        errors.extend(self._check_topology(payload))
+        errors.extend(self._check_generator(payload))
+        errors.extend(self._check_edges(payload))
+        # Only check server model if we do have servers
+        if payload.topology_graph.nodes.servers:
+            errors.extend(self._check_server_model(payload))
+        return errors
+
+    # ------------- private method to build dict from theory --------------
+
+    def _arrival_rate_lambda_rate(self, payload: SimulationPayload) -> float:
+        """λ = users_mean * rpm_per_user / 60."""
+        return payload.arrivals.lambda_rps
+
+
+    def _service_rate_mu_rate(self, payload: SimulationPayload) -> float:
+        """μ = 1 / E[S] from the (identical) CPU exponential step."""
+        server0 = payload.topology_graph.nodes.servers[0]
+        step0 = server0.endpoints[0].steps[0]
+        _, rv = next(iter(step0.step_operation.items()))
+        rv_cfg = cast("RVConfig", rv)
+        return 1.0 / float(rv_cfg.mean)
+
+
+    def _server_count(self, payload: SimulationPayload) -> int:
+        """C = number of parallel servers."""
+        return len(payload.topology_graph.nodes.servers)
+
+
+    def _total_capacity_rate(self, server_count: int, mu_rate: float) -> float:
+        """Total capacity = c * μ [1/s]."""
+        return server_count * mu_rate
+
+
+    def _rho_from(
+        self,
+        lambda_rate: float,
+        server_count: int,
+        mu_rate: float,
+    ) -> float:
+        """Rho = λ / (c * μ)."""
+        capacity = server_count * mu_rate
+        return (lambda_rate / capacity) if capacity > 0.0 else float("inf")
+
+
+    def _offered_load_a(self, lambda_rate: float, mu_rate: float) -> float:
+        """A = λ / μ (expected busy servers)."""
+        return (lambda_rate / mu_rate) if mu_rate > 0.0 else float("inf")
+
+
+    def _build_params(self, payload: SimulationPayload) -> MMcParams:
+        """Build MMcParams (theory) from payload."""
+        lambda_rate = self._arrival_rate_lambda_rate(payload)
+        mu_rate = self._service_rate_mu_rate(payload)
+        server_count = self._server_count(payload)
+        capacity_rate = self._total_capacity_rate(server_count, mu_rate)
+        rho = self._rho_from(lambda_rate, server_count, mu_rate)
+        offered_load = self._offered_load_a(lambda_rate, mu_rate)
+        return MMcParams(
+            lambda_rate=lambda_rate,
+            mu_rate=mu_rate,
+            c=server_count,
+            rho=rho,
+            a=offered_load,
+            capacity_rate=capacity_rate,
+        )
+
+    # ────────────────────────────────────────────────────────────────────
+    # Centralized RA processing (avoid repeated processing)
+    # ────────────────────────────────────────────────────────────────────
+
+    def _ensure_metrics_processed(
+        self,
+        results_analyzer: ResultsAnalyzer,
+    ) -> None:
+        """Call process_all_metrics() at most once per ResultsAnalyzer."""
+        if results_analyzer not in self._processed_ras:
+            results_analyzer.process_all_metrics()
+            self._processed_ras.add(results_analyzer)
+
+
+    # ────────────────────────────────────────────────────────────────────
+    # Helpers: observed (from ResultsAnalyzer)
+    # ────────────────────────────────────────────────────────────────────
+
+    def _observed_lambda_rate(self, results_analyzer: ResultsAnalyzer) -> float:
+        """Estimate λ̂ from throughput series (mean RPS)."""
+        self._ensure_metrics_processed(results_analyzer)
+        _, rps_series = results_analyzer.get_throughput_series()
+        return (sum(rps_series) / len(rps_series)) if rps_series else 0.0
+
+
+    def _observed_mu_rate(self, results_analyzer: ResultsAnalyzer) -> float:
+        """
+        Estimate μ̂ = 1 / mean(service_time) aggregating all servers
+        (weighted by number of jobs per server).
+        """
+        self._ensure_metrics_processed(results_analyzer)
+        arrays_map = results_analyzer.get_server_event_arrays()
+
+        service_time_sum: float = 0.0
+        service_time_count: int = 0
+        for arrays in arrays_map.values():
+            values = arrays.get("service_time") or []
+            service_time_sum += float(sum(values))
+            service_time_count += len(values)
+
+        mean_service_time = (
+            service_time_sum / service_time_count if service_time_count > 0 else 0.0
+        )
+        return (1.0 / mean_service_time) if mean_service_time > 0.0 else float("inf")
+
+
+    def _build_observed_params(
+        self,
+        payload: SimulationPayload,
+        results_analyzer: ResultsAnalyzer,
+    ) -> MMcParams:
+        """Build MMcParams using observed λ̂, μ̂ and c from payload."""
+        observed_lambda_rate = self._observed_lambda_rate(results_analyzer)
+        observed_mu_rate = self._observed_mu_rate(results_analyzer)
+        server_count = self._server_count(payload)
+        capacity_rate = self._total_capacity_rate(server_count, observed_mu_rate)
+        observed_rho = self._rho_from(
+            observed_lambda_rate,
+            server_count,
+            observed_mu_rate,
+        )
+        observed_a = self._offered_load_a(
+            observed_lambda_rate,
+            observed_mu_rate,
+        )
+        return MMcParams(
+            lambda_rate=observed_lambda_rate,
+            mu_rate=observed_mu_rate,
+            c=server_count,
+            rho=observed_rho,
+            a=observed_a,
+            capacity_rate=capacity_rate,
+        )
+
+    # ────────────────────────────────────────────────────────────────────
+    # Closed form (Random): theory → MMcResults split model ( n parallel mm1)
+    # ────────────────────────────────────────────────────────────────────
+
+    def _theoretical_kpis_split(self, payload: SimulationPayload) -> MMcResults:
+        """
+        Closed forms for Random split: λ_i=λ/c;
+        Wq=rho/(μ-λ_i); W=1/μ+Wq; Lq=λWq; L=λW
+        """
+        self.validate_or_raise(payload)
+        params = self._build_params(payload)
+
+        lambda_rate = params["lambda_rate"]
+        mu_rate = params["mu_rate"]
+        server_count = params["c"]
+        rho = params["rho"]
+
+        if rho >= 1.0:
+            inf = float("inf")
+            return MMcResults(
+                lambda_rate=lambda_rate,
+                mu_rate=mu_rate,
+                c=server_count,
+                rho=rho,
+                L=inf,
+                Lq=inf,
+                W=inf,
+                Wq=inf,
+            )
+
+        per_server_lambda = lambda_rate / server_count
+        denom = (mu_rate - per_server_lambda)
+        wq = rho / denom if denom > 0.0 else float("inf")
+        w = (1.0 / mu_rate) + wq
+        lq = lambda_rate * wq
+        l_sys = lambda_rate * w
+
+        return MMcResults(
+            lambda_rate=lambda_rate,
+            mu_rate=mu_rate,
+            c=server_count,
+            rho=rho,
+            L=l_sys,
+            Lq=lq,
+            W=w,
+            Wq=wq,
+        )
+
+
+    def _theoretical_mmc_erlang_c_kpis(
+        self,
+        lambda_rate: float,
+        mu_rate: float,
+        c: int,
+    ) -> MMcResults:
+        """Closed forms for pooled M/M/c (FCFS, Erlang-C)."""
+        rho = self._rho_from(lambda_rate, c, mu_rate)
+        if rho >= 1.0:
+            inf = float("inf")
+            return MMcResults(
+                lambda_rate=lambda_rate,
+                mu_rate=mu_rate,
+                c=c,
+                rho=rho,
+                L=inf, Lq=inf, W=inf, Wq=inf,
+            )
+
+        a = lambda_rate / mu_rate  # offered traffic
+        # P0
+        s = sum((a**n) / math.factorial(n) for n in range(c))
+        tail = (a**c) / math.factorial(c) * (1.0 / (1.0 - rho))
+        p0 = 1.0 / (s + tail)
+        pw = ((a**c) / math.factorial(c)) * (1.0 / (1.0 - rho)) * p0
+        lq = pw * (rho / (1.0 - rho))
+        wq = lq / lambda_rate
+        w = wq + 1.0 / mu_rate
+        lam = lambda_rate * w
+
+        return MMcResults(
+            lambda_rate=lambda_rate,
+            mu_rate=mu_rate,
+            c=c,
+            rho=rho,
+            L=lam,
+            Lq=lq,
+            W=w,
+            Wq=wq,
+        )
+
+    def _theoretical_kpis_pooled(self, payload: SimulationPayload) -> MMcResults:
+        """Closed forms for pooled M/M/c (LB=FCFS, central queue)."""
+        # riusa i builder che hai già
+        params = self._build_params(payload)
+        return self._theoretical_mmc_erlang_c_kpis(
+            lambda_rate=params["lambda_rate"],
+            mu_rate=params["mu_rate"],
+            c=params["c"],
+    )
+
+
+    def evaluate(self, payload: SimulationPayload) -> MMcResults:
+        """Return closed-form KPIs: split (RR/RANDOM) or pooled (FCFS)."""
+        self.validate_or_raise(payload)
+        lb = payload.topology_graph.nodes.load_balancer
+        if (lb is not None) and (lb.algorithms == LbAlgorithmsName.FCFS):
+            return self._theoretical_kpis_pooled(payload)
+        # default: split (random/RR)
+        return self._theoretical_kpis_split(payload)
+
+
+    # ────────────────────────────────────────────────────────────────────
+    # Observed KPIs → MMcResults (coerenti con definizioni sopra)
+    # ────────────────────────────────────────────────────────────────────
+
+    def _observed_kpis(
+        self,
+        payload: SimulationPayload,
+        results_analyzer: ResultsAnalyzer,
+    ) -> MMcResults:
+        """
+        Empirical KPIs:
+        - λ̂: mean throughput
+        - μ̂: 1 / mean(service_time)
+        - Ŵ: mean client latency
+        - Wq̂: mean waiting_time (server arrays)
+        - L̂: λ̂ * Ŵ
+        - Lq̂: λ̂ * Wq̂
+        - rhô: λ̂ / (c μ̂)
+        """
+        self._ensure_metrics_processed(results_analyzer)
+
+        lambda_hat = self._observed_lambda_rate(results_analyzer)
+        mu_hat = self._observed_mu_rate(results_analyzer)
+        server_count = self._server_count(payload)
+
+        # Ŵ from latency stats (client-side);
+        lat_stats = results_analyzer.get_latency_stats()
+        w_hat = float(lat_stats.get(LatencyKey.MEAN, 0.0))
+
+        lb = payload.topology_graph.nodes.load_balancer
+        is_fcfs = (lb is not None) and (lb.algorithms == LbAlgorithmsName.FCFS)
+
+        # Collect waiting time from LB if the algo is FCFS
+        if is_fcfs:
+            lb_waits = list(results_analyzer.get_lb_waiting_times())
+            wq_hat = (sum(lb_waits) / len(lb_waits)) if lb_waits else 0.0
+        else:
+            arrays_map = results_analyzer.get_server_event_arrays()
+            wait_sum = 0.0
+            wait_count = 0
+            for arrays in arrays_map.values():
+                vals = arrays.get("waiting_time") or []
+                wait_sum += float(sum(vals))
+                wait_count += len(vals)
+            wq_hat = (wait_sum / wait_count) if wait_count > 0 else 0.0
+
+        l_hat = lambda_hat * w_hat
+        lq_hat = lambda_hat * wq_hat
+        rho_hat = (
+            lambda_hat / (server_count * mu_hat)
+            if mu_hat not in (0.0, float("inf")) else 0.0
+        )
+
+        return MMcResults(
+            lambda_rate=lambda_hat,
+            mu_rate=mu_hat,
+            c=server_count,
+            rho=rho_hat,
+            L=l_hat,
+            Lq=lq_hat,
+            W=w_hat,
+            Wq=wq_hat,
+        )
+
+    # ────────────────────────────────────────────────────────────────────
+    # Comparison table (same shape as MM1, senza Erlang terms)
+    # ────────────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _safe_delta(theory_value: float, observed_value: float) -> tuple[str, str, str]:
+        """Return (theory_str, abs_diff_str, rel_diff_str) with inf-safe logic."""
+        def fmt(x: float) -> str:
+            return "∞" if x == float("inf") else f"{x:.6f}"
+        theory_str = fmt(theory_value)
+        if theory_value == float("inf"):
+            return theory_str, "—", "—"
+        abs_diff = observed_value - theory_value
+        rel_pct = (
+            abs_diff / theory_value * 100.0
+            ) if theory_value != 0.0 else float("inf")
+        rel_str = "∞" if rel_pct == float("inf") else f"{rel_pct:.2f}"
+        return theory_str, f"{abs_diff:.6f}", rel_str
+
+
+    def compare_against_run(
+        self,
+        payload: SimulationPayload,
+        results_analyzer: ResultsAnalyzer,
+    ) -> list[MMcKPIRow]:
+        """Build a table with theory vs observed and deltas."""
+        self.validate_or_raise(payload)
+
+        lb = payload.topology_graph.nodes.load_balancer
+        if (lb is not None) and (lb.algorithms == LbAlgorithmsName.FCFS):
+            theory = self._theoretical_kpis_pooled(payload)
+        else:
+            theory = self._theoretical_kpis_split(payload)
+
+        observed = self._observed_kpis(payload, results_analyzer)
+
+        rows: list[MMcKPIRow] = []
+
+        def add(symbol: str, name: str, key: MMcResultKey) -> None:
+            theory_value = float(theory[key])
+            observed_value = float(observed[key])
+            th_s, abs_s, rel_s = self._safe_delta(theory_value, observed_value)
+            rows.append(
+                MMcKPIRow(
+                    symbol=symbol,
+                    name=name,
+                    theory=th_s,
+                    observed=f"{observed_value:.6f}",
+                    abs_diff=abs_s,
+                    rel_diff_pct=rel_s,
+                ),
+            )
+
+        add("λ", "Arrival rate (1/s)", "lambda_rate")
+        add("μ", "Service rate (1/s)", "mu_rate")
+        add("rho", "Utilization", "rho")
+        add("L", "Mean items in sys", "L")
+        add("Lq", "Mean items in queue", "Lq")
+        add("W", "Mean time in sys (s)", "W")
+        add("Wq", "Mean waiting (s)", "Wq")
+
+        return rows
+
+    # ────────────────────────────────────────────────────────────────────
+    # Pretty table (KPI):
+    # ────────────────────────────────────────────────────────────────────
+
+    def _title_for(self, payload: SimulationPayload) -> str:
+        lb = payload.topology_graph.nodes.load_balancer
+        if lb is not None and lb.algorithms == LbAlgorithmsName.FCFS:
+            return "MMc (FCFS/Erlang-C) — Theory vs Observed"
+        # default to random split when no LB or non-FCFS
+        return "MMc (Random split) — Theory vs Observed"
+
+    @staticmethod
+    def _format_kpi_table(
+        rows: list[MMcKPIRow],
+        title: str = "MMc — Theory vs Observed",
+    ) -> str:
+        data = [
+            (
+                r["symbol"],
+                r["name"],
+                str(r["theory"]),
+                str(r["observed"]),
+                str(r["abs_diff"]),
+                str(r["rel_diff_pct"]),
+            )
+            for r in rows
+        ]
+        headers = ("sym", "metric", "theory", "observed", "abs", "rel%")
+        w_sym = max(len(headers[0]), *(len(d[0]) for d in data))
+        w_met = max(len(headers[1]), *(len(d[1]) for d in data))
+        w_th  = max(len(headers[2]), *(len(d[2]) for d in data))
+        w_ob  = max(len(headers[3]), *(len(d[3]) for d in data))
+        w_abs = max(len(headers[4]), *(len(d[4]) for d in data))
+        w_rel = max(len(headers[5]), *(len(d[5]) for d in data))
+
+        header = (
+            f"{headers[0]:<{w_sym}}  {headers[1]:<{w_met}}  "
+            f"{headers[2]:>{w_th}}  {headers[3]:>{w_ob}}  "
+            f"{headers[4]:>{w_abs}}  {headers[5]:>{w_rel}}"
+        )
+        sep = "-" * len(header)
+        top = "=" * max(len(title), len(header))
+
+        lines = [top, title, sep, header, sep]
+        for sym, met, th, ob, ad, rd in data:
+            lines.append(
+                f"{sym:<{w_sym}}  {met:<{w_met}}  "
+                f"{th:>{w_th}}  {ob:>{w_ob}}  {ad:>{w_abs}}  {rd:>{w_rel}}",
+            )
+        lines.append(top)
+        return "\n".join(lines)
+
+    def compare_and_format(
+        self,
+        payload: SimulationPayload,
+        results_analyzer: ResultsAnalyzer,
+    ) -> str:
+        """Compare theoretical and simulated results"""
+        rows = self.compare_against_run(payload, results_analyzer)
+        title = self._title_for(payload)
+        return self._format_kpi_table(rows, title=title)
+
+    def print_comparison(
+        self,
+        payload: SimulationPayload,
+        results_analyzer: ResultsAnalyzer,
+        *,
+        file: TextIO | None = None,
+    ) -> None:
+        """Print the MMc KPI table (theory vs observed)."""
+        out = self.compare_and_format(payload, results_analyzer)
+        stream: TextIO = sys.stdout if file is None else file
+        print(out, file=stream)
+
diff --git a/src/asyncflow/resources/server_containers.py b/src/asyncflow/resources/server_containers.py
index 1401247..d3302df 100644
--- a/src/asyncflow/resources/server_containers.py
+++ b/src/asyncflow/resources/server_containers.py
@@ -11,8 +11,8 @@
 
 import simpy
 
-from asyncflow.config.constants import ServerResourceName
-from asyncflow.schemas.topology.nodes import ServerResources
+from asyncflow.config.enums import ServerResourceName
+from asyncflow.schemas.topology.nodes import NodesResources
 
 # ==============================================================
 # DICT FOR THE REGISTRY TO INITIALIZE RESOURCES FOR EACH SERVER
@@ -33,12 +33,12 @@ class ServerContainers(TypedDict):
 # Central funcrion to initialize  the dictionary with ram and cpu container
 def build_containers(
     env: simpy.Environment,
-    spec: ServerResources,
+    spec: NodesResources,
     ) -> ServerContainers:
     """
     Construct and return a mapping of SimPy Containers for a server's CPU and RAM.
 
-    Given a SimPy environment and a validated ServerResources spec, this function
+    Given a SimPy environment and a validated NodesResources spec, this function
     initializes one simpy.Container for CPU (with capacity equal to cpu_cores)
     and one for RAM (with capacity equal to ram_mb), then returns them in a
     ServerContainers TypedDict keyed by "CPU" and "RAM".
@@ -47,7 +47,7 @@ def build_containers(
     ----------
     env : simpy.Environment
         The simulation environment in which the Containers will be created.
-    spec : ServerResources
+    spec : NodesResources
         A Pydantic model instance defining the server's cpu_cores and ram_mb.
 
     Returns
diff --git a/src/asyncflow/runtime/simulation_runner.py b/src/asyncflow/runner/simulation.py
similarity index 83%
rename from src/asyncflow/runtime/simulation_runner.py
rename to src/asyncflow/runner/simulation.py
index 08ae0df..d1e84c7 100644
--- a/src/asyncflow/runtime/simulation_runner.py
+++ b/src/asyncflow/runner/simulation.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections import OrderedDict
+from functools import partial
 from itertools import chain
 from pathlib import Path
 from types import MappingProxyType
@@ -12,13 +13,14 @@
 import simpy
 import yaml
 
-from asyncflow.metrics.analyzer import ResultsAnalyzer
+from asyncflow.config.enums import LbAlgorithmsName
 from asyncflow.metrics.collector import SampledMetricCollector
+from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
 from asyncflow.resources.registry import ResourcesRuntime
+from asyncflow.runtime.actors.arrivals_generator import ArrivalsGeneratorRuntime
 from asyncflow.runtime.actors.client import ClientRuntime
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.actors.load_balancer import LoadBalancerRuntime
-from asyncflow.runtime.actors.rqs_generator import RqsGeneratorRuntime
 from asyncflow.runtime.actors.server import ServerRuntime
 from asyncflow.runtime.events.injection import EventInjectionRuntime
 from asyncflow.schemas.payload import SimulationPayload
@@ -26,14 +28,14 @@
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+    from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
     from asyncflow.schemas.events.injection import EventInjection
-    from asyncflow.schemas.topology.edges import Edge
+    from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
     from asyncflow.schemas.topology.nodes import (
         Client,
         LoadBalancer,
         Server,
     )
-    from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 # --- PROTOCOL DEFINITION ---
 # This is the contract that all runtime actors must follow.
@@ -70,16 +72,19 @@ def __init__(
         self.servers: list[Server] = simulation_input.topology_graph.nodes.servers
         self.client: Client = simulation_input.topology_graph.nodes.client
         self.events: list[EventInjection] | None = None
-        self.rqs_generator: RqsGenerator = simulation_input.rqs_input
+        self.arrivals: ArrivalsGenerator = simulation_input.arrivals
         self.lb: LoadBalancer | None = None
         self.simulation_settings = simulation_input.sim_settings
-        self.edges: list[Edge] = simulation_input.topology_graph.edges
+        # Edges can be NetworkEdge or LinkEdge; TopologyGraph ensures homogeneity.
+        self.edges: list[NetworkEdge] | list[LinkEdge] = (
+            simulation_input.topology_graph.edges
+        )
         self.rng = np.random.default_rng()
 
         # Object needed to start the simulation
         self._servers_runtime: dict[str, ServerRuntime] = {}
         self._client_runtime: dict[str, ClientRuntime] = {}
-        self._rqs_runtime: dict[str, RqsGeneratorRuntime] = {}
+        self._arrivals_runtime: dict[str, ArrivalsGeneratorRuntime] = {}
         # right now we allow max one LB per simulation so we don't need a dict
         self._lb_runtime: LoadBalancerRuntime | None = None
         self._edges_runtime: dict[tuple[str, str], EdgeRuntime] = {}
@@ -130,10 +135,10 @@ def _build_rqs_generator(self) -> None:
         In the future we might add CDN so we will need
         multiple generators , one for each client
         """
-        self._rqs_runtime[self.rqs_generator.id] = RqsGeneratorRuntime(
+        self._arrivals_runtime[self.arrivals.id] = ArrivalsGeneratorRuntime(
             env = self.env,
             out_edge=None,
-            rqs_generator_data=self.rqs_generator,
+            arrivals=self.arrivals,
             sim_settings=self.simulation_settings,
             rng=self.rng,
         )
@@ -199,9 +204,6 @@ def _build_load_balancer(self) -> None:
             lb_box=self._make_inbox(),
         )
 
-
-
-
     def _build_edges(self) -> None:
         """Initialization of the edges runtime dictionary from the input data"""
         # We need to merge all previous dictionary for the nodes to assign
@@ -209,7 +211,7 @@ def _build_edges(self) -> None:
         all_nodes: dict[str, object] = {
             **self._servers_runtime,
             **self._client_runtime,
-            **self._rqs_runtime,
+            **self._arrivals_runtime,
         }
 
         if self._lb_runtime is not None:
@@ -225,11 +227,15 @@ def _build_edges(self) -> None:
                 target_box = target_object.client_box
             elif isinstance(target_object, LoadBalancerRuntime):
                 target_box = target_object.lb_box
+
+
             else:
                 msg = f"Unknown runtime for {edge.target!r}"
                 raise TypeError(msg)
 
-
+            # prepare a dict of edges runtime with unique key as a tuple
+            # once all are ready we have to assign each one to the source node
+            # to allow the transport of the state through the edge
             self._edges_runtime[(edge.source, edge.target)] = (
                 EdgeRuntime(
                     env=self.env,
@@ -239,22 +245,45 @@ def _build_edges(self) -> None:
                     settings=self.simulation_settings,
                 )
             )
+
             # Here we assign the outer edges to all nodes
             source_object = all_nodes[edge.source]
 
             if isinstance(source_object, (
                 ServerRuntime,
                 ClientRuntime,
-                RqsGeneratorRuntime,
+                ArrivalsGeneratorRuntime,
                 )):
                 source_object.out_edge = self._edges_runtime[(
                     edge.source,
                     edge.target)
                 ]
+
+            # since multiple edges fan out from the LB we use a dict
+            # to have access in o(1) and assign the correct Edge runtime
             elif isinstance(source_object, LoadBalancerRuntime):
                 self._lb_out_edges[edge.id] = (
                     self._edges_runtime[(edge.source, edge.target)]
                 )
+
+                if isinstance(target_object, ServerRuntime) and (
+                    source_object.lb_config.algorithms == LbAlgorithmsName.FCFS
+                    ):
+                    # if the target is a server we pass the callback to comunicate
+                    # to the Lb that the server is free
+
+                    assert self._lb_runtime is not None
+                    lb_rt = self._lb_runtime
+                    edge_id = edge.id
+
+                    # We use functools.partial here to "pre-bind" the edge_id argument
+                    # of LoadBalancerRuntime.mark_free.
+                    # This turns it into a zero-argument
+                    # callable, so the ServerRuntime can simply
+                    # call notify_server_free()
+                    # when done, without needing to know its own edge_id.
+                    target_object.notify_server_free = partial(lb_rt.mark_free, edge_id)
+
             else:
                 msg =  f"Unknown runtime for {edge.source!r}"
                 raise TypeError(msg)
@@ -276,6 +305,12 @@ def _build_events(self) -> None:
             env=self.env,
             servers=self.servers,
             lb_out_edges=self._lb_out_edges,
+            on_edge_added=(
+            self._lb_runtime.on_edge_added
+            if (self._lb_runtime is not None
+                and self._lb_runtime.lb_config.algorithms == LbAlgorithmsName.FCFS)
+            else None
+        ),
         )
 
         # container only readable
@@ -314,7 +349,7 @@ def _start_all_processes(self) -> None:
         # ------------------------------------------------------------------
 
         runtimes = chain(
-        self._rqs_runtime.values(),
+        self._arrivals_runtime.values(),
         self._client_runtime.values(),
         self._servers_runtime.values(),
         ([] if self._lb_runtime is None else [self._lb_runtime]),
@@ -360,12 +395,12 @@ def run(self) -> ResultsAnalyzer:
         # 3 ATTACH EVENTS TO THE COMPONENTS
         self._build_events()
 
-        # 3. START ALL COROUTINES
+        # 4. START ALL COROUTINES
         self._start_events()
         self._start_all_processes()
         self._start_metric_collector()
 
-        # 4. ADVANCE THE SIMULATION
+        # 5. ADVANCE THE SIMULATION
         self.env.run(until=self.simulation_settings.total_simulation_time)
 
         return ResultsAnalyzer(
@@ -373,6 +408,7 @@ def run(self) -> ResultsAnalyzer:
             servers=list(self._servers_runtime.values()),
             edges=list(self._edges_runtime.values()),
             settings=self.simulation_settings,
+            lb=self._lb_runtime,
         )
 
     # ------------------------------------------------------------------ #
@@ -397,5 +433,13 @@ def from_yaml(
         payload = SimulationPayload.model_validate(data)
         return cls(env=env, simulation_input=payload)
 
+    # Method usefull to pass to the sweep class a payload
+    # directly from a yaml
+    @classmethod
+    def payload_from_yaml(cls, yaml_path: str | Path) -> SimulationPayload:
+        """Helper to return a valid payload"""
+        data = yaml.safe_load(Path(yaml_path).read_text())
+        return SimulationPayload.model_validate(data)
+
 
 
diff --git a/src/asyncflow/runner/sweep.py b/src/asyncflow/runner/sweep.py
new file mode 100644
index 0000000..899db14
--- /dev/null
+++ b/src/asyncflow/runner/sweep.py
@@ -0,0 +1,140 @@
+"""
+class to define method to iterate over some variables of the input
+to evaluate how a given scenario with different initial conditions
+(for example the number of concurrent users), behave. It is really
+useful to find insights and analyze eventual breakpoint on a given
+topology. Right now the class will accept only as a varying parameter
+the concurrent users, in the future we will extend it to arbitrary
+parameters.
+"""
+
+
+import simpy
+
+from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.payload import SimulationPayload
+
+
+class Sweep:
+    """
+    Class to manage scenario when we want to iterate over a
+    set of initial data to see for example the impact on a defined
+    topology varying the initial workload
+    """
+
+    def __init__(
+        self,
+        *,
+        # passing the object class not instance of the class
+        # Why:
+        # - Each sweep run must be isolated: fresh Environment, fresh state,
+        #   fresh queues.
+        # - Reusing a single instance would carry state from the previous run
+        #   (SimPy processes, resources, partial metrics, RNG state, etc.)
+        #   → tainted results.
+        # - By passing the CLASS we can instantiate on demand inside the loop,
+        #   guaranteeing a fresh object for every grid point.
+        simulation_cls: type[SimulationRunner] = SimulationRunner,
+        ) -> None:
+        """
+        Instantiation of the sweep class
+        Args:
+            simulation_cls (type[SimulationRunner], optional): object of
+            the SimulationRunner class
+        """
+        self.simulation_cls = simulation_cls
+
+        # to trace the last grid
+        self._last_users_grid: list[int] = []
+
+    # ---------------------------------------------------
+    # Helpers
+    # ---------------------------------------------------
+
+    @staticmethod
+    def _default_env_factory() -> simpy.Environment:
+        """Ritorna un Environment nuovo e pulito per ogni run."""
+        return simpy.Environment()
+
+
+
+    #----------------------------------------------------
+    # Method to iterate over the users
+    # ---------------------------------------------------
+
+    def sweep_on_lambda(
+    self,
+    *,
+    payload: SimulationPayload,
+    lambda_lower_bound: float,
+    lambda_upper_bound: float,
+    step: float,
+) -> list[tuple[float, ResultsAnalyzer]]:
+        """
+        Sweep the arrival rate (`lambda_rps`, requests/second) over a range and run a
+        simulation for each value.
+
+        Parameters
+        ----------
+        payload
+            A fully validated `SimulationPayload` used as the base configuration.
+            It will be deep-copied and patched with each `lambda_rps` value.
+        lambda_lower_bound
+            Inclusive lower bound for `lambda_rps` (> 0).
+        lambda_upper_bound
+            Inclusive upper bound for `lambda_rps` (>= lower bound, > 0).
+        step
+            Positive increment for the sweep grid.
+
+        Returns
+        -------
+        list[tuple[float, ResultsAnalyzer]]
+            A list of pairs `(lambda_rps, analyzer)` for each grid point.
+
+        Notes
+        -----
+        - Uses `model_copy(deep=True)` (Pydantic v2) to avoid mutating the input payload
+        - Builds the sweep grid robustly against floating-point accumulation errors.
+
+        """
+        # --- Validate inputs early for clear error messages ---
+        if step <= 0.0:
+            msg="step must be > 0"
+            raise ValueError(msg)
+        if lambda_lower_bound <= 0.0 or lambda_upper_bound <= 0.0:
+            msg="The lower and upper bound must be strictly bigger than 0"
+            raise ValueError(msg)
+        if lambda_upper_bound < lambda_lower_bound:
+            msg="lambda_upper_bound must be >= lambda_lower_bound"
+            raise ValueError(msg)
+
+        # --- Build a numerically robust grid of lambda values ---
+        eps = step * 1e-9  # tiny slack to counter FP accumulation on the final step
+        lam = float(lambda_lower_bound)
+        lambda_grid: list[float] = []
+        while lam <= lambda_upper_bound + eps:
+            lambda_grid.append(float(lam))
+            lam += step
+
+        # Keep the last grid if your class wants to expose it later (optional).
+        self._last_lambda_grid = lambda_grid[:]
+
+        results: list[tuple[float, ResultsAnalyzer]] = []
+
+        for lam in lambda_grid:
+            # 1) Clone the payload and override the arrival rate
+            pl = payload.model_copy(deep=True)
+            pl.arrivals = pl.arrivals.model_copy(update={"lambda_rps": lam})
+
+            # 2) Instantiate and run the simulation
+            runner = self.simulation_cls(
+                env=self._default_env_factory(),
+                simulation_input=pl,
+            )
+            analyzer = runner.run()
+
+            # 3) Accumulate the result
+            results.append((lam, analyzer))
+
+        return results
diff --git a/src/asyncflow/runtime/actors/rqs_generator.py b/src/asyncflow/runtime/actors/arrivals_generator.py
similarity index 59%
rename from src/asyncflow/runtime/actors/rqs_generator.py
rename to src/asyncflow/runtime/actors/arrivals_generator.py
index 1b67213..dd243ca 100644
--- a/src/asyncflow/runtime/actors/rqs_generator.py
+++ b/src/asyncflow/runtime/actors/arrivals_generator.py
@@ -9,10 +9,9 @@
 
 import numpy as np
 
-from asyncflow.config.constants import Distribution, SystemNodes
+from asyncflow.config.enums import SystemNodes
 from asyncflow.runtime.rqs_state import RequestState
-from asyncflow.samplers.gaussian_poisson import gaussian_poisson_sampling
-from asyncflow.samplers.poisson_poisson import poisson_poisson_sampling
+from asyncflow.samplers.arrivals import general_interarrivals
 
 if TYPE_CHECKING:
 
@@ -21,11 +20,10 @@
     import simpy
 
     from asyncflow.runtime.actors.edge import EdgeRuntime
+    from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
     from asyncflow.schemas.settings.simulation import SimulationSettings
-    from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
-
-class RqsGeneratorRuntime:
+class ArrivalsGeneratorRuntime:
     """
     A “node” that produces request contexts at stochastic inter-arrival times
     and immediately pushes them down the pipeline via an EdgeRuntime.
@@ -36,22 +34,22 @@ def __init__(
         *,
         env: simpy.Environment,
         out_edge: EdgeRuntime | None,
-        rqs_generator_data: RqsGenerator,
+        arrivals: ArrivalsGenerator,
         sim_settings: SimulationSettings,
         rng: np.random.Generator | None = None,
         ) -> None:
         """
-        Definition of the instance attributes for the RqsGeneratorRuntime
+        Definition of the instance attributes for the ArrivalsGeneratorRuntime
 
         Args:
             env (simpy.Environment): environment for the simulation
             out_edge (EdgeRuntime): edge connecting this node with the next one
-            rqs_generator_data (RqsGenerator): data do define the sampler
+            arrivals (ArrivalsGenerator): data do define the sampler
             sim_settings (SimulationSettings): settings to start the simulation
             rng (np.random.Generator | None, optional): random variable generator.
 
         """
-        self.rqs_generator_data = rqs_generator_data
+        self.arrivals = arrivals
         self.sim_settings = sim_settings
         self.rng =  rng or np.random.default_rng()
         self.out_edge = out_edge
@@ -64,41 +62,15 @@ def _next_id(self) -> int:
         return self.id_counter
 
 
-    def _requests_generator(self) -> Generator[float, None, None]:
-        """
-        Return an iterator of inter-arrival gaps (seconds) according to the model
-        chosen in *input_data*.
-
-        Notes
-        -----
-        * If ``avg_active_users.distribution`` is ``"gaussian"`` or ``"normal"``,
-        the Gaussian-Poisson sampler is used.
-        * Otherwise the default Poisson-Poisson sampler is returned.
-
-        """
-        dist = self.rqs_generator_data.avg_active_users.distribution
-
-        if dist == Distribution.NORMAL:
-            #Gaussian-Poisson model
-            return gaussian_poisson_sampling(
-                input_data=self.rqs_generator_data,
-                sim_settings=self.sim_settings,
-                rng=self.rng,
-
-            )
-
-        # Poisson + Poisson
-        return poisson_poisson_sampling(
-            input_data=self.rqs_generator_data,
-            sim_settings=self.sim_settings,
-            rng=self.rng,
-        )
-
     def _event_arrival(self) -> Generator[simpy.Event, None, None]:
         """Simulating the process of event generation"""
         assert self.out_edge is not None
 
-        time_gaps = self._requests_generator()
+        time_gaps = general_interarrivals(
+          simulation_time_s=self.sim_settings.total_simulation_time,
+          rng=self.rng,
+          arrivals=self.arrivals,
+        )
 
         for gap in time_gaps:
             yield self.env.timeout(gap)
@@ -110,7 +82,7 @@ def _event_arrival(self) -> Generator[simpy.Event, None, None]:
             )
             state.record_hop(
                 SystemNodes.GENERATOR,
-                self.rqs_generator_data.id,
+                self.arrivals.id,
                 self.env.now,
             )
             # transport is a method of the edge runtime
diff --git a/src/asyncflow/runtime/actors/client.py b/src/asyncflow/runtime/actors/client.py
index 6c752f1..71848c8 100644
--- a/src/asyncflow/runtime/actors/client.py
+++ b/src/asyncflow/runtime/actors/client.py
@@ -5,7 +5,7 @@
 
 import simpy
 
-from asyncflow.config.constants import SystemNodes
+from asyncflow.config.enums import SystemNodes
 from asyncflow.metrics.client import RqsClock
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.schemas.topology.nodes import Client
diff --git a/src/asyncflow/runtime/actors/edge.py b/src/asyncflow/runtime/actors/edge.py
index 63c8f45..259bca0 100644
--- a/src/asyncflow/runtime/actors/edge.py
+++ b/src/asyncflow/runtime/actors/edge.py
@@ -6,21 +6,26 @@
 waits the sampled delay (and any resource wait) before delivering the
 message to the target node's inbox.
 """
+
+
 from collections.abc import Container, Generator, Mapping
 from typing import TYPE_CHECKING
 
 import numpy as np
 import simpy
 
-from asyncflow.config.constants import SampledMetricName, SystemEdges
+from asyncflow.config.enums import SampledMetricName, SystemEdges
 from asyncflow.metrics.edge import build_edge_metrics
 from asyncflow.runtime.rqs_state import RequestState
 from asyncflow.samplers.common_helpers import general_sampler
+from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 
 if TYPE_CHECKING:
-    from asyncflow.schemas.common.random_variables import RVConfig
+    from pydantic import PositiveFloat
+
+
 
 
 class EdgeRuntime:
@@ -30,7 +35,7 @@ def __init__( # Noqa: PLR0913
         self,
         *,
         env: simpy.Environment,
-        edge_config: Edge,
+        edge_config: NetworkEdge | LinkEdge,
 
         # ------------------------------------------------------------
         # ATTRIBUTES FROM THE OBJECT EVENTINJECTIONRUNTIME
@@ -70,10 +75,14 @@ def __init__( # Noqa: PLR0913
         # verify that each optional metric is active. For deafult metric settings
         # is not needed but as we will scale as explained above we will need it
 
-    def _deliver(self, state: RequestState) -> Generator[simpy.Event, None, None]:
+    def _deliver_network(
+        self,
+        state: RequestState,
+        ) -> Generator[simpy.Event, None, None]:
         """Function to deliver the state to the next node"""
         # extract the random variables defining the latency of the edge
-        random_variable: RVConfig = self.edge_config.latency
+
+        assert isinstance(self.edge_config, NetworkEdge)
 
         uniform_variable = self.rng.uniform()
         if uniform_variable < self.edge_config.dropout_rate:
@@ -85,9 +94,15 @@ def _deliver(self, state: RequestState) -> Generator[simpy.Event, None, None]:
             )
             return
 
+        # latency
+        latency: RVConfig | PositiveFloat = self.edge_config.latency
+
         self._concurrent_connections +=1
 
-        transit_time = general_sampler(random_variable, self.rng)
+        if isinstance(latency, RVConfig):
+            transit_time = general_sampler(latency, self.rng)
+        else:
+            transit_time = latency
 
 
         # Logic to add if exists the event injection for the given edge
@@ -115,13 +130,30 @@ def _deliver(self, state: RequestState) -> Generator[simpy.Event, None, None]:
         self._concurrent_connections -=1
         yield self.target_box.put(state)
 
+    def _deliver_link(self, state: RequestState) -> Generator[simpy.Event, None, None]:
+        """Function to deliver the state to the next node"""
+        state.record_hop(
+            SystemEdges.LINK_CONNECTION,
+            self.edge_config.id,
+            self.env.now,
+            )
+
+        # Advance to the next simulation event tick (zero-time delay) so that link
+        # deliveries are processed after the current event, preserving causal order
+        # and avoiding same-tick side effects.
+        yield self.env.timeout(0)
+        yield self.target_box.put(state)
+
 
     def transport(self, state: RequestState) -> simpy.Process:
         """
         Called by the upstream node. Immediately spins off a SimPy process
         that will handle drop + delay + delivery of `state`.
         """
-        return self.env.process(self._deliver(state))
+        if isinstance(self.edge_config, NetworkEdge):
+            return self.env.process(self._deliver_network(state))
+
+        return self.env.process(self._deliver_link(state))
 
     @property
     def enabled_metrics(self) -> dict[SampledMetricName, list[float | int]]:
diff --git a/src/asyncflow/runtime/actors/load_balancer.py b/src/asyncflow/runtime/actors/load_balancer.py
index 343cd84..8ca0792 100644
--- a/src/asyncflow/runtime/actors/load_balancer.py
+++ b/src/asyncflow/runtime/actors/load_balancer.py
@@ -2,16 +2,16 @@
 
 
 from collections import OrderedDict
-from collections.abc import Generator
-from typing import (
-    TYPE_CHECKING,
-)
+from collections.abc import Generator, Sequence
+from typing import TYPE_CHECKING, cast
 
 import simpy
 
-from asyncflow.config.constants import SystemNodes
+from asyncflow.config.enums import LbAlgorithmsName, SystemNodes
 from asyncflow.runtime.actors.edge import EdgeRuntime
-from asyncflow.runtime.actors.routing.lb_algorithms import LB_TABLE
+from asyncflow.runtime.actors.routing.lb_algorithms import (
+    LB_TABLE,
+)
 from asyncflow.schemas.topology.nodes import LoadBalancer
 
 if TYPE_CHECKING:
@@ -55,6 +55,42 @@ def __init__(
         self.lb_out_edges = lb_out_edges
         self.lb_box = lb_box
 
+        # FIFO of free edges connecting to ready servers
+        self._free_edges = simpy.Store(env)
+
+        # Global collection of LB waiting times (FCFS only).
+        # We store one value per request that actually waited at the LB.
+        # This is aggregate-only: we do NOT track per-request IDs here.
+        # We need it to compare simulated and theoretical results of
+        # queue theory
+        self._lb_waiting_time: list[float] = []
+
+
+    # Helpers FCFS
+
+    def on_edge_added(self, edge_id: str) -> None:
+        """
+        Called when EventInjection re-enables an edge.
+        We push one token so the edge becomes immediately eligible.
+        """
+        if edge_id in self.lb_out_edges:
+            self._free_edges.put(edge_id)
+
+
+    def _prime_free_edges(self) -> None:
+        """Prepare initial edges in the FIFO"""
+        for edge_id in self.lb_out_edges:
+            self._free_edges.put(edge_id)
+
+
+    def mark_free(self, edge_id: str) -> None:
+        """
+        Put the token if and only if the edges is still
+        available, the event injection might remove temporary
+        a server by removing its connection with the LB
+        """
+        if edge_id in self.lb_out_edges:
+            self._free_edges.put(edge_id)
 
 
     def _forwarder(self) -> Generator[simpy.Event, None, None]:
@@ -62,15 +98,63 @@ def _forwarder(self) -> Generator[simpy.Event, None, None]:
         while True:
             state: RequestState = yield self.lb_box.get()  # type: ignore[assignment]
 
-            state.record_hop(
-                    SystemNodes.LOAD_BALANCER,
-                    self.lb_config.id,
-                    self.env.now,
-                )
-
-            out_edge = LB_TABLE[self.lb_config.algorithms](self.lb_out_edges)
-            out_edge.transport(state)
+            if self.lb_config.algorithms == LbAlgorithmsName.FCFS:
+
+                hist = getattr(state, "history", None)
+                if hist:
+                    last = hist[-1]
+                    t_arrival = getattr(last, "timestamp", float(self.env.now))
+                else:
+                    t_arrival = float(self.env.now)
+
+
+                state.record_hop(
+                        SystemNodes.LOAD_BALANCER,
+                        self.lb_config.id,
+                        self.env.now,
+                    )
+
+            # The idea is the following: when a request arrives and the algorithm
+            # is FCFS, we maintain a FIFO of available edges. If an edge connected
+            # to a server is ready, the loop continues and (assuming no event injection
+            # has removed the server) the waiting time should be 0. If no edge is
+            # available, the request waits until the server notifies the LB via the
+            # `mark_free` callback. At that point, the edge is released and we can
+            # compute the waiting time.
+            #
+            # The check on the OrderedDict is important because an event injection
+            # may temporarily remove a server by cutting its edge from the load
+            # balancer. In such cases, the loop restarts until a valid edge is found.
+
+                while True:
+                    edge_id = cast("str", (yield self._free_edges.get()))
+                    # if event injection remove the edge,
+                    # discard the token and wait
+                    if edge_id in self.lb_out_edges:
+                        break
+                    # token stale → loop and take the next
+
+                waiting_time = self.env.now - t_arrival
+                if waiting_time >= 0:
+                    self._lb_waiting_time.append(waiting_time)
+
+                edge_rt = self.lb_out_edges[edge_id]
+                edge_rt.transport(state)
+            else:
+                state.record_hop(
+                SystemNodes.LOAD_BALANCER,
+                self.lb_config.id,
+                self.env.now,
+            )
+                edge_rt = LB_TABLE[self.lb_config.algorithms](self.lb_out_edges)
+                edge_rt.transport(state)
 
     def start(self) -> simpy.Process:
-        """Initialization of the simpy process for the LB"""
+        """Start the process and populate FIFO"""
+        self._prime_free_edges()
         return self.env.process(self._forwarder())
+
+    @property
+    def lb_waiting_times(self) -> Sequence[float]:
+        """Read-only view of LB FCFS waiting times (one per waited request)."""
+        return tuple(self._lb_waiting_time)
diff --git a/src/asyncflow/runtime/actors/routing/lb_algorithms.py b/src/asyncflow/runtime/actors/routing/lb_algorithms.py
index 47f950d..c3186f4 100644
--- a/src/asyncflow/runtime/actors/routing/lb_algorithms.py
+++ b/src/asyncflow/runtime/actors/routing/lb_algorithms.py
@@ -1,9 +1,9 @@
 """algorithms to simulate the load balancer during the simulation"""
-
+import random
 from collections import OrderedDict
 from collections.abc import Callable
 
-from asyncflow.config.constants import LbAlgorithmsName
+from asyncflow.config.enums import LbAlgorithmsName
 from asyncflow.runtime.actors.edge import EdgeRuntime
 
 
@@ -35,11 +35,23 @@ def round_robin(
 
     return value
 
+def random_choice(
+    edges: OrderedDict[str, EdgeRuntime],
+) -> EdgeRuntime:
+    """Pick a random outgoing edge uniformly"""
+    idx = random.randrange(len(edges)) # noqa: S311
+    for i, edge in enumerate(edges.values()):
+        if i == idx:
+            return edge
+
+    return next(iter(edges.values()))
 
 LB_TABLE: dict[LbAlgorithmsName,
                Callable[[OrderedDict[str, EdgeRuntime]], EdgeRuntime]] = {
     LbAlgorithmsName.LEAST_CONNECTIONS: least_connections,
     LbAlgorithmsName.ROUND_ROBIN: round_robin,
+    LbAlgorithmsName.RANDOM: random_choice,
 }
 
 
+
diff --git a/src/asyncflow/runtime/actors/server.py b/src/asyncflow/runtime/actors/server.py
index d83f94d..55eceb7 100644
--- a/src/asyncflow/runtime/actors/server.py
+++ b/src/asyncflow/runtime/actors/server.py
@@ -3,32 +3,62 @@
 during the simulation
 """
 
-from collections.abc import Generator
+from collections import defaultdict
+from collections.abc import Callable, Generator, Mapping
+from types import MappingProxyType
 from typing import cast
 
 import numpy as np
 import simpy
+from pydantic import PositiveFloat, PositiveInt
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     EndpointStepCPU,
     EndpointStepIO,
     EndpointStepRAM,
+    EventMetricName,
     SampledMetricName,
     ServerResourceName,
     StepOperation,
     SystemNodes,
 )
-from asyncflow.metrics.server import build_server_metrics
+from asyncflow.metrics.server import ServerClock, build_server_metrics
 from asyncflow.resources.server_containers import ServerContainers
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.rqs_state import RequestState
+from asyncflow.samplers.common_helpers import general_sampler
+from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.settings.simulation import SimulationSettings
 from asyncflow.schemas.topology.nodes import Server
 
+# Initialization of the nested dict to collect the metrics
+# for the server
+MetricValue = ServerClock | float
+MetricBucket = dict[EventMetricName, MetricValue]
 
 class ServerRuntime:
     """class to define the server during the simulation"""
 
+    @staticmethod
+    def _new_metric_bucket() -> MetricBucket:
+        """
+        Factory for a per-request metric bucket.
+        Returns a fresh dict pre-populated with cumulative metrics that
+        always start at 0.0 (I/O time, waiting time, service time).
+        Event-specific clocks (e.g. RQS_SERVER_CLOCK) are added later
+        when the request is actually dispatched.
+        This function is used as the `default_factory` for the
+        `_server_rqs_clock` defaultdict, so each new request id gets
+        its own independent bucket automatically.
+        """
+        return {
+            EventMetricName.IO_TIME: 0.0,
+            EventMetricName.WAITING_TIME: 0.0,
+            EventMetricName.SERVICE_TIME: 0.0,
+            # RQS_SERVER_CLOCK will be added in the dispatcher
+        }
+
+
     def __init__( # noqa: PLR0913
         self,
         *,
@@ -75,6 +105,94 @@ def __init__( # noqa: PLR0913
             settings.enabled_sample_metrics,
         )
 
+        # Per-request metrics are keyed by request_id (int), not by RequestState object:
+        # - ints are stable, lightweight, and hash/GC-friendly
+        # - avoids holding strong refs to RequestState (no memory leaks)
+        self._server_rqs_clock: defaultdict[int, MetricBucket]
+        self._server_rqs_clock = defaultdict(self._new_metric_bucket)
+        # we need to comunicate when a server is free again to the LB
+        # for algorithms like FCFS
+        self.notify_server_free: Callable[[], None] | None = None
+
+    # ------------------------------------------------------------------
+    # HELPERS
+    # ------------------------------------------------------------------
+
+    def _sample_duration(
+        self, time: RVConfig | PositiveFloat | PositiveInt,
+        ) -> float:
+        """
+        Return a non-negative duration in seconds.
+
+        - RVConfig -> sample via general_sampler(self.rng)
+        - float/int -> cast to float
+        - Negative draws are clamped to 0.0 (e.g., Normal tails).
+        """
+        if isinstance(time, RVConfig):
+            time = float(general_sampler(time, self.rng))
+        else:
+            time = float(time)
+
+        return time
+
+    def _compute_latency_cpu(
+        self,
+        cpu_time:PositiveFloat | PositiveInt | RVConfig,
+        ) -> float:
+        """Helper to compute the latency of a cpu bound given step"""
+        return self._sample_duration(cpu_time)
+
+    def _compute_latency_io(
+        self,
+        io_time:PositiveFloat | PositiveInt | RVConfig,
+        ) -> float:
+        """Helper to compute the latency of a IO bound given step"""
+        return self._sample_duration(io_time)
+
+    # -------------------------------------------------------------------
+    # Main function to elaborate a request
+    # -------------------------------------------------------------------
+
+    def _dispatcher(self) -> Generator[simpy.Event, None, None]:
+        """
+        The main dispatcher loop. It pulls requests from the inbox and
+        spawns a new '_handle_request' process for each one.
+        """
+        # we assume in the current model that there is a one
+        # to one correspondence between cpu cores and workers
+        # before entering in the loop in the current implementation
+        # we reserve the ram necessary to run the processes
+        if self.server_config.ram_per_process:
+            processes_ram = (
+                self.server_config.ram_per_process *
+                self.server_config.server_resources.cpu_cores
+            )
+
+            yield self.server_resources[
+                ServerResourceName.RAM.value
+                ].get(processes_ram)
+
+
+        while True:
+            # Wait for a request to arrive in the server's inbox
+            raw_state = yield self.server_box.get()
+            request_state = cast("RequestState", raw_state)
+
+            # Start the collection of the metric initializing
+            # the principal key that is the unique id of the
+            # state elaborated
+            bucket = self._server_rqs_clock[request_state.id]
+            bucket[EventMetricName.RQS_SERVER_CLOCK] = ServerClock(
+            start=self.env.now,
+        )
+
+            # Spawn a new, independent process to handle this request
+            self.env.process(self._handle_request(request_state))
+
+    def start(self) -> simpy.Process:
+        """Generate the process to simulate the server inside simpy env"""
+        return self.env.process(self._dispatcher())
+
     # right now we disable the warnings but a refactor will be done soon
     def _handle_request( # noqa: PLR0915, PLR0912, C901
         self,
@@ -103,11 +221,12 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
 
 
         # Extract the total ram to execute the endpoint
-        total_ram = sum(
-            step.step_operation[StepOperation.NECESSARY_RAM]
-            for step in selected_endpoint.steps
-            if isinstance(step.kind, EndpointStepRAM)
-        )
+        total_ram = 0
+        for step in selected_endpoint.steps:
+            if isinstance(step.kind, EndpointStepRAM):
+                ram = step.step_operation[StepOperation.NECESSARY_RAM]
+                assert isinstance(ram, int)
+                total_ram += ram
 
         # ------------------------------------------------------------------
         # CPU & RAM SCHEDULING
@@ -155,6 +274,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
         core_locked = False
         is_in_io_queue = False
         waiting_cpu = False
+        wait_start: float | None = None
 
 
         # --- Step Execution: CPU & I/O dynamics ---
@@ -196,7 +316,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
 
         for step in selected_endpoint.steps:
 
-            if step.kind in EndpointStepCPU:
+            if isinstance(step.kind, EndpointStepCPU):
                 # with the boolean we avoid redundant operation of asking
                 # the core multiple time on a given step
                 # for example if we have two consecutive cpu bound step
@@ -207,6 +327,11 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
                     is_in_io_queue = False
                     self._el_io_queue_len -= 1
 
+                # core_locked is a local variable just for the single request
+                # if the request already block the core so we avoid all the if
+                # conditions and we add the coroutine, if it is not blocked, we
+                # have to ask for a core, because it might be occupy from another
+                # request
                 if not core_locked:
                     # simpy create an event and if it can be satisfied is triggered
                     cpu_req = self.server_resources[ServerResourceName.CPU.value].get(1)
@@ -214,6 +339,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
                     # no trigger ready queue without execution
                     if not cpu_req.triggered:
                         waiting_cpu = True
+                        wait_start = self.env.now
                         self._el_ready_queue_len += 1
 
                     # at this point wait for the cpu
@@ -221,20 +347,46 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
 
                     # here the cpu is free
                     if waiting_cpu:
+                        assert wait_start is not None
+                        bucket = self._server_rqs_clock[state.id]
+
+                        # mypy assert
+                        value = bucket[EventMetricName.WAITING_TIME]
+                        assert isinstance(value, float)
+
+                        # assign delta
+                        bucket[EventMetricName.WAITING_TIME] = (
+                          value + (self.env.now - wait_start)
+                        )
+                        wait_start = None
                         waiting_cpu = False
                         self._el_ready_queue_len -= 1
 
                     core_locked = True
 
-                cpu_time = step.step_operation[StepOperation.CPU_TIME]
+                cpu_time = self._compute_latency_cpu(
+                    step.step_operation[StepOperation.CPU_TIME],
+                )
+
+                bucket = self._server_rqs_clock[state.id]
+
+                # mypy assertion
+                value = bucket[EventMetricName.SERVICE_TIME]
+                assert isinstance(value, float)
+
+                # delta assignment
+                bucket[EventMetricName.SERVICE_TIME] = value + cpu_time
+
                 # Execute the step giving back the control to the simpy env
                 yield self.env.timeout(cpu_time)
 
             # since the object is of an Enum class we check if the step.kind
             # is one member of enum
-            elif step.kind in EndpointStepIO:
+            elif isinstance(step.kind, EndpointStepIO):
                 # define the io time
-                io_time = step.step_operation[StepOperation.IO_WAITING_TIME]
+                io_time = self._compute_latency_io(
+                    step.step_operation[StepOperation.IO_WAITING_TIME],
+                    )
 
                 if core_locked:
                     # release the core coming from a cpu step
@@ -244,7 +396,7 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
                     if not is_in_io_queue:
                         is_in_io_queue = True
                         self._el_io_queue_len += 1
-                
+
                 # here is a sage check: the first step should always
                 # be a cpu bound (parsing of the request), if an user
                 # start with a I/O this allow to don't break the flux
@@ -252,6 +404,14 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
                     is_in_io_queue = True
                     self._el_io_queue_len += 1
 
+                bucket = self._server_rqs_clock[state.id]
+
+                # assert for mypy
+                value = bucket[EventMetricName.IO_TIME]
+                assert isinstance(value, float)
+
+                # assign the delta
+                bucket[EventMetricName.IO_TIME] = value + io_time
                 yield self.env.timeout(io_time)
 
         if core_locked:
@@ -266,17 +426,26 @@ def _handle_request( # noqa: PLR0915, PLR0912, C901
             waiting_cpu = False
             self._el_ready_queue_len -= 1
 
-
         if total_ram:
-
             self._ram_in_use -= total_ram
             yield self.server_resources[ServerResourceName.RAM.value].put(total_ram)
 
+        bucket = self._server_rqs_clock[state.id]
+        clock = cast("ServerClock", bucket[EventMetricName.RQS_SERVER_CLOCK])
+        clock.finish = self.env.now
+
+        # callable to comunicate with the LB that a server is free throgh their
+        # connecting edge, it is useful for algo like FCFS, the wiring is done
+        # in the simulation_runner
+        server_free = self.notify_server_free
+        if server_free is not None:
+            server_free()
+
         assert self.out_edge is not None
         self.out_edge.transport(state)
 
 
-    # we need three accessor because we need to read these private attribute
+    # we need these accessor because we need to read these private attribute
     # in the sampled metric collector
     @property
     def ready_queue_len(self) -> int:
@@ -298,21 +467,28 @@ def enabled_metrics(self) -> dict[SampledMetricName, list[float | int]]:
         """Read-only access to the metric store."""
         return self._server_enabled_metrics
 
-
-
-    def _dispatcher(self) -> Generator[simpy.Event, None, None]:
+    @property
+    def server_rqs_clock(self) -> Mapping[int, MetricBucket]:
         """
-        The main dispatcher loop. It pulls requests from the inbox and
-        spawns a new '_handle_request' process for each one.
+        Read-only snapshot of the per-request server metrics.
+
+        Returns
+        -------
+        Mapping[int, MetricBucket]
+            A mapping from request id → metric bucket, where each bucket is a
+            dict[EventMetricName, float | ServerClock]. The top-level mapping is
+            immutable (cannot add/remove keys) and is created from a shallow copy
+            to avoid defaultdict autovivification.
+
+        Notes
+        -----
+        This is a *snapshot* of the current state: as the server runs, the
+        underlying buckets may continue to change.
+        Buckets themselves are not frozen; **do not mutate them** from callers.
+        Treat the returned structure as read-only.
+
         """
-        while True:
-            # Wait for a request to arrive in the server's inbox
-            raw_state = yield self.server_box.get()
-            request_state = cast("RequestState", raw_state)
-            # Spawn a new, independent process to handle this request
-            self.env.process(self._handle_request(request_state))
+        return MappingProxyType(dict(self._server_rqs_clock))
+
 
-    def start(self) -> simpy.Process:
-        """Generate the process to simulate the server inside simpy env"""
-        return self.env.process(self._dispatcher())
 
diff --git a/src/asyncflow/runtime/events/injection.py b/src/asyncflow/runtime/events/injection.py
index 753c5d3..a7e5703 100644
--- a/src/asyncflow/runtime/events/injection.py
+++ b/src/asyncflow/runtime/events/injection.py
@@ -4,14 +4,14 @@
 scheduled server outages over a defined time window.
 """
 from collections import OrderedDict
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from typing import cast
 
 import simpy
 
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.nodes import Server
 
 # Helpers to distinguish when the event start and when the event finish
@@ -32,16 +32,19 @@ class EventInjectionRuntime:
     event effects during the simulation.
     """
 
-    def __init__(
+    def __init__( # noqa: PLR0913
         self,
         *,
         events: list[EventInjection] | None,
-        edges: list[Edge],
+        edges: list[NetworkEdge] | list[LinkEdge],
         env: simpy.Environment,
         servers: list[Server],
         # This is initiated in the simulation runner to understand
         # the process there are extensive comments in that file
         lb_out_edges: OrderedDict[str, EdgeRuntime],
+
+        #notify the lb when a server is back up and running
+        on_edge_added: Callable[[str], None] | None = None,
     ) -> None:
         """
         Definition of the attributes of the instance for
@@ -54,6 +57,10 @@ def __init__(
             servers (list[Server]): input data of the server
             lb_out_edges: OrderedDict[str, EdgeRuntime]:
             ordered dict to handle server events
+            on_edge_added: callback from the load balancer runtim
+            useful if the routing algo is fcfs and a server is removed
+            when the server is back up, is becoming available again
+            for the lb to route a request to a server
 
         """
         self.events = events
@@ -61,6 +68,7 @@ def __init__(
         self.env = env
         self.servers = servers
         self.lb_out_edges = lb_out_edges
+        self._on_edge_added = on_edge_added
 
         # Nested mapping for edge spikes:
         # edges_events: Dict[event_id, Dict[edge_id, float]]
@@ -116,6 +124,20 @@ def __init__(
         self._servers_ids = {server.id for server in self.servers}
         self._edges_ids = {edge.id for edge in self.edges}
 
+        # If any event targets an edge, we only need to inspect the first edge:
+        # the topology type is homogeneous by construction
+        # (list[NetworkEdge] | list[LinkEdge]),
+        # so checking one element determines the type of the entire list.
+        if self.events and self.edges and any(
+            ev.target_id in self._edges_ids for ev in self.events
+        ):
+            first_edge = self.edges[0]
+            if not isinstance(first_edge, NetworkEdge):
+                msg=("Edge events are present, but the topology uses LinkEdge. "
+                    "Edge-targeted events require NetworkEdge "
+                    "(network_connection) edges.")
+                raise ValueError(msg)
+
         for event in self.events:
             start_event = (
                 event.start.t_start, event.event_id, event.target_id, START_MARK,
@@ -225,6 +247,9 @@ def _assign_server_state(self) -> Generator[simpy.Event, None, None]:
                 self.lb_out_edges[edge_id] = edge_runtime
                 self.lb_out_edges.move_to_end(edge_id)
 
+                if self._on_edge_added is not None:
+                    self._on_edge_added(edge_id)
+
 
 
 
diff --git a/src/asyncflow/runtime/rqs_state.py b/src/asyncflow/runtime/rqs_state.py
index 71b8389..cadc3ec 100644
--- a/src/asyncflow/runtime/rqs_state.py
+++ b/src/asyncflow/runtime/rqs_state.py
@@ -6,7 +6,7 @@
 from typing import TYPE_CHECKING, NamedTuple
 
 if TYPE_CHECKING:
-    from asyncflow.config.constants import SystemEdges, SystemNodes
+    from asyncflow.config.enums import SystemEdges, SystemNodes
 
 
 class Hop(NamedTuple):
diff --git a/src/asyncflow/samplers/arrivals.py b/src/asyncflow/samplers/arrivals.py
new file mode 100644
index 0000000..7f6da61
--- /dev/null
+++ b/src/asyncflow/samplers/arrivals.py
@@ -0,0 +1,380 @@
+"""
+Inter-arrival sampling helpers (infinite generators truncated at horizon).
+
+Each helper yields i.i.d. inter-arrival gaps (seconds) according to the
+chosen family, stopping once the cumulative time would exceed
+`simulation_time_s`.
+
+Signatures are uniform for easier factory wiring:
+- lambda_rps: mean arrival rate (req/s), must be > 0
+- simulation_time_s: simulation horizon in seconds (int)
+- variability: VariabilityLevel or None (ignored if not applicable)
+- rng: numpy Generator for reproducibility
+
+These helpers are intended to be wired by an external public factory.
+"""
+
+from __future__ import annotations
+
+from math import gamma, isfinite, log, sqrt
+from typing import TYPE_CHECKING, Protocol
+
+from asyncflow.config.constants import SCV_PRESETS, Tuning
+from asyncflow.config.enums import Distribution, VariabilityLevel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+    from collections.abc import Generator as FloatGen
+
+    import numpy as np
+
+    from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+
+
+
+# ---- Utilities -------------------------------------------------------------
+
+
+def _iid_to_horizon(
+    *,
+    draw_one: Callable[[], float],
+    simulation_time_s: int,
+) -> FloatGen[float, None, None]:
+    """
+    Yield i.i.d. gaps from `draw_one` until the horizon would be exceeded.
+
+    The last draw is dropped if it would push the virtual clock past
+    `simulation_time_s`.
+    """
+    now = 0.0
+    while True:
+        delta = float(draw_one())
+        if now + delta > float(simulation_time_s):
+            break
+        now += delta
+        yield delta
+
+
+def _weibull_shape_for_level(level: VariabilityLevel) -> float:
+    """
+    Map variability level to a Weibull shape k.
+
+    Empirical mapping that matches SCV presets reasonably well:
+    LOW → k≈2.10, MEDIUM → k=1.0, HIGH → k≈0.543.
+    """
+    if level is VariabilityLevel.LOW:
+        return Tuning.WEIBULL_K_LOW
+    if level is VariabilityLevel.MEDIUM:
+        return Tuning.WEIBULL_K_MED
+    return Tuning.WEIBULL_K_HIGH  # HIGH
+
+
+# ---- Samplers --------------------------------------------------------------
+
+
+def _build_empirical_from_timestamps(
+    *,
+    timestamps_s: Iterable[float],
+    origin_s: float = 0.0,
+    assume_sorted: bool = False,
+    clamp_min_s: float = 0.0,
+) -> FloatGen[float, None, None]:
+    """
+    Yield inter-arrival gaps from absolute timestamps, anchored at origin.
+
+    Gaps strictly smaller than `clamp_min_s` are clamped to that threshold
+    to avoid zero-length hot loops and numerical noise.
+    """
+    # Materialize and validate
+    timestamp_s: list[float] = []
+    for i, v in enumerate(timestamps_s):
+        if not isfinite(v):
+            msg = f"non-finite value in timestamps at index {i}: {v!r}."
+            raise ValueError(msg)
+        timestamp_s.append(float(v))
+    if not timestamp_s:
+        msg="empirical sequence is empty."
+        raise ValueError(msg)
+
+    if not assume_sorted:
+        timestamp_s.sort()
+
+    # Keep only timestamps at or after the origin
+    timestamp_s = [t for t in timestamp_s if t >= origin_s]
+    if not timestamp_s:
+        msg="no timestamps at or after origin; nothing to simulate."
+        raise ValueError(msg)
+
+    # First gap from origin, then consecutive differences
+    first_gap = timestamp_s[0] - origin_s
+    yield first_gap if first_gap >= clamp_min_s else float(clamp_min_s)
+
+    prev = timestamp_s[0]
+    for t in timestamp_s[1:]:
+        d = t - prev
+        yield d if d >= clamp_min_s else float(clamp_min_s)
+        prev = t
+
+
+
+def _exponential_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Exponential inter-arrivals with mean 1 / lambda_rps (SCV fixed to 1).
+
+    `variability` is ignored.
+    """
+    scale = 1.0 / lambda_rps
+    return _iid_to_horizon(
+        draw_one=lambda: rng.exponential(scale=scale),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _poisson_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Alias for exponential inter-arrivals of a homogeneous Poisson process.
+
+    `variability` is ignored.
+    """
+    return _exponential_interarrivals(
+        lambda_rps=lambda_rps,
+        simulation_time_s=simulation_time_s,
+        rng=rng,
+    )
+
+
+def _deterministic_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Deterministic inter-arrivals with period 1 / lambda_rps (SCV = 0).
+
+    `variability` is ignored.
+    """
+    _ = rng  # kept for signature uniformity
+    value = 1.0 / lambda_rps
+    return _iid_to_horizon(
+        draw_one=lambda: value,
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _lognormal_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    variability: VariabilityLevel,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """Lognormal inter-arrivals tuned by SCV presets."""
+    assert variability is not None
+
+    c2 = SCV_PRESETS[variability]
+    sigma = sqrt(log(1.0 + c2))
+    mu = log(1.0 / lambda_rps) - 0.5 * sigma * sigma
+    return _iid_to_horizon(
+        draw_one=lambda: rng.lognormal(mean=mu, sigma=sigma),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _weibull_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    variability: VariabilityLevel,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Weibull inter-arrivals tuned by SCV via the shape k.
+
+    Scale is set so E[T] = 1 / lambda:
+      theta = (1 / lambda) / Gamma(1 + 1/k)
+    """
+    assert variability is not None
+
+    k = _weibull_shape_for_level(variability)
+    theta = (1.0 / lambda_rps) / gamma(1.0 + 1.0 / k)
+    return _iid_to_horizon(
+        draw_one=lambda: theta * rng.weibull(a=k),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _pareto_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    variability: VariabilityLevel,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Pareto type-I inter-arrivals tuned by SCV (finite variance).
+
+    With target c2:
+      alpha = 1 + sqrt(1 + 1 / c2)  (forced > 2)
+      x_m   = (alpha - 1) / (alpha * lambda)
+    """
+    assert variability is not None
+
+    c2 = SCV_PRESETS[variability]
+    alpha = 1.0 + sqrt(1.0 + 1.0 / c2)
+    alpha = max(alpha, 2.0 + Tuning.PARETO_ALPHA_EPS)
+    x_m = (alpha - 1.0) / (alpha * lambda_rps)
+    return _iid_to_horizon(
+        draw_one=lambda: x_m * (rng.pareto(a=alpha) + 1.0),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _erlang_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    variability: VariabilityLevel,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Erlang (Gamma with integer k) inter-arrivals tuned by SCV.
+
+    We pick k = round(1 / c2) clamped to [1, 10]. For k=1 it reduces to Exp.
+    Scale is theta = (1 / lambda) / k so that E[T] = 1 / lambda.
+    """
+    assert variability is not None
+
+    c2 = SCV_PRESETS[variability]
+    k_int = max(1, min(10, round(1.0 / c2)))
+    theta = (1.0 / lambda_rps) / float(k_int)
+    return _iid_to_horizon(
+        draw_one=lambda: rng.gamma(shape=k_int, scale=theta),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+def _uniform_interarrivals(
+    *,
+    lambda_rps: float,
+    simulation_time_s: int,
+    rng: np.random.Generator,
+) -> FloatGen[float, None, None]:
+    """
+    Uniform[a, b] inter-arrivals with fixed relative half-width.
+
+    `variability` is ignored. We use a symmetric band around 1/lambda:
+    mu = 1 / lambda, w = UNIFORM_REL_HALF_WIDTH
+    a = mu * (1 - w), b = mu * (1 + w).
+    This yields a low and bounded SCV (w^2 / 3).
+    """
+    mu = 1.0 / lambda_rps
+    w = Tuning.UNIFORM_REL_HALF_WIDTH
+    a = mu * (1.0 - w)
+    b = mu * (1.0 + w)
+    return _iid_to_horizon(
+        draw_one=lambda: rng.uniform(low=a, high=b),
+        simulation_time_s=simulation_time_s,
+    )
+
+
+# ------------------------------------------------------------
+# Define a global function to pass the correct sampler using
+# dispatch tables to avoid a lot of if else
+# ------------------------------------------------------------
+
+# ---- mypy compliance ----
+
+class VarSampler(Protocol):
+    """Sampler protocol that REQUIRES a variability level."""
+
+    def __call__(
+        self,
+        *,
+        lambda_rps: float,
+        simulation_time_s: int,
+        variability: VariabilityLevel,
+        rng: np.random.Generator,
+    ) -> FloatGen[float, None, None]:
+        """Yield inter-arrival gaps for the given rate, horizon and RNG."""
+        ...
+
+
+class NoVarSampler(Protocol):
+    """Sampler protocol that IGNORES variability."""
+
+    def __call__(
+        self,
+        *,
+        lambda_rps: float,
+        simulation_time_s: int,
+        rng: np.random.Generator,
+    ) -> FloatGen[float, None, None]:
+        """Yield inter-arrival gaps for the given rate, horizon and RNG."""
+        ...
+
+
+VAR_DISTRIBUTION: dict[Distribution, VarSampler] = {
+    Distribution.LOG_NORMAL: _lognormal_interarrivals,
+    Distribution.WEIBULL: _weibull_interarrivals,
+    Distribution.PARETO: _pareto_interarrivals,
+    Distribution.ERLANG: _erlang_interarrivals,
+}
+
+NO_VAR_DISTRIBUTION: dict[Distribution, NoVarSampler] = {
+    Distribution.EXPONENTIAL: _exponential_interarrivals,
+    Distribution.POISSON: _poisson_interarrivals,
+    Distribution.DETERMINISTIC: _deterministic_interarrivals,
+    Distribution.UNIFORM: _uniform_interarrivals,
+}
+
+def general_interarrivals(
+    *,
+    simulation_time_s: int,
+    rng: np.random.Generator,
+    arrivals: ArrivalsGenerator,
+) -> FloatGen[float, None, None]:
+    """
+    General function to select the correct function based on the choice
+    of the user to generate interarrivals.
+    """
+    model = arrivals.model
+
+    if model is Distribution.EMPIRICAL:
+        if arrivals.empirical_data is None:
+            msg = "empirical_data is required when model=EMPIRICAL."
+            raise ValueError(msg)
+        return _build_empirical_from_timestamps(
+            timestamps_s=arrivals.empirical_data,
+            origin_s=0.0,
+            assume_sorted=False,
+            clamp_min_s=0.0,
+        )
+
+    if arrivals.variability is None:
+        sampler_no_var: NoVarSampler = NO_VAR_DISTRIBUTION[model]
+        return sampler_no_var(
+            lambda_rps=arrivals.lambda_rps,
+            simulation_time_s=simulation_time_s,
+            rng=rng,
+        )
+
+    sampler_var: VarSampler = VAR_DISTRIBUTION[model]
+    return sampler_var(
+        lambda_rps=arrivals.lambda_rps,
+        simulation_time_s=simulation_time_s,
+        variability=arrivals.variability,
+        rng=rng,
+    )
+
+
diff --git a/src/asyncflow/samplers/common_helpers.py b/src/asyncflow/samplers/common_helpers.py
index 4f2f675..f276fb0 100644
--- a/src/asyncflow/samplers/common_helpers.py
+++ b/src/asyncflow/samplers/common_helpers.py
@@ -3,7 +3,7 @@
 
 import numpy as np
 
-from asyncflow.config.constants import Distribution
+from asyncflow.config.enums import Distribution
 from asyncflow.schemas.common.random_variables import RVConfig
 
 
@@ -74,11 +74,6 @@ def general_sampler(random_variable: RVConfig, rng: np.random.Generator) -> floa
             assert var is None
             return exponential_variable_generator(mean, rng)
 
-        # ── Distributions that *do* need a variance parameter ───────────
-        case Distribution.NORMAL:
-            assert var is not None
-            return truncated_gaussian_generator(mean, var, rng)
-
         case Distribution.LOG_NORMAL:
             assert var is not None
             return lognormal_variable_generator(mean, var, rng)
diff --git a/src/asyncflow/samplers/gaussian_poisson.py b/src/asyncflow/samplers/gaussian_poisson.py
deleted file mode 100644
index b96eca5..0000000
--- a/src/asyncflow/samplers/gaussian_poisson.py
+++ /dev/null
@@ -1,94 +0,0 @@
-"""
-event sampler in the case of gaussian distribution
-for concurrent user and poisson distribution for rqs per minute per user.
-The rationale behind this choice is about considering scenario
-with variance bigger or smaller w.r.t the one inherited from
-the Poisson distribution
-"""
-
-import math
-from collections.abc import Generator
-
-import numpy as np
-
-from asyncflow.config.constants import TimeDefaults
-from asyncflow.samplers.common_helpers import (
-    truncated_gaussian_generator,
-    uniform_variable_generator,
-)
-from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-
-def gaussian_poisson_sampling(
-    input_data: RqsGenerator,
-    sim_settings: SimulationSettings,
-    *,
-    rng: np.random.Generator,
-) -> Generator[float, None, None]:
-    """
-    Yield inter-arrival gaps (seconds) for the compound Gaussian-Poisson process.
-
-    Algorithm
-    ---------
-    1. Every *sampling_window_s* seconds, draw
-         U ~ Gaussian(mean_concurrent_user, variance).
-    2. Compute the aggregate rate
-         Λ = U * (mean_req_per_minute_per_user / 60)  [req/s].
-    3. While inside the current window, draw gaps
-         Δt ~ Exponential(Λ)   using inverse-CDF.
-    4. Stop once the virtual clock exceeds *total_simulation_time*.
-    """
-    simulation_time = sim_settings.total_simulation_time
-    user_sampling_window = input_data.user_sampling_window
-
-    # λ_u : mean concurrent users per window
-    mean_concurrent_user = float(input_data.avg_active_users.mean)
-
-    # Let's be sure that the variance is not None (guaranteed from pydantic)
-    variance_concurrent_user = input_data.avg_active_users.variance
-    assert variance_concurrent_user is not None
-    variance_concurrent_user = float(variance_concurrent_user)
-
-    # λ_r / 60 : mean req/s per user
-    mean_req_per_sec_per_user = (
-        float(
-            input_data.avg_request_per_minute_per_user.mean)
-        / TimeDefaults.MIN_TO_SEC
-    )
-
-    now = 0.0                 # virtual clock (s)
-    window_end = 0.0          # end of the current user window
-    lam = 0.0                 # aggregate rate Λ (req/s)
-
-    while now < simulation_time:
-        # (Re)sample U at the start of each window
-        if now >= window_end:
-            window_end = now + float(user_sampling_window)
-            users = truncated_gaussian_generator(
-                mean_concurrent_user,
-                variance_concurrent_user,
-                rng,
-            )
-            lam = users * mean_req_per_sec_per_user
-
-        # No users → fast-forward to next window
-        if lam <= 0.0:
-            now = window_end
-            continue
-
-        # Exponential gap from a protected uniform value
-        u_raw = max(uniform_variable_generator(rng), 1e-15)
-        delta_t = -math.log(1.0 - u_raw) / lam
-
-        # End simulation if the next event exceeds the horizon
-        if now + delta_t > simulation_time:
-            break
-
-        # If the gap crosses the window boundary, jump to it
-        if now + delta_t >= window_end:
-            now = window_end
-            continue
-
-        now += delta_t
-        yield delta_t
diff --git a/src/asyncflow/samplers/poisson_poisson.py b/src/asyncflow/samplers/poisson_poisson.py
deleted file mode 100644
index ea7a4fb..0000000
--- a/src/asyncflow/samplers/poisson_poisson.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""
-event sampler in the case of poisson distribution
-both for concurrent user and rqs per minute per user
-"""
-
-import math
-from collections.abc import Generator
-
-import numpy as np
-
-from asyncflow.config.constants import TimeDefaults
-from asyncflow.samplers.common_helpers import (
-    poisson_variable_generator,
-    uniform_variable_generator,
-)
-from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-
-def poisson_poisson_sampling(
-    input_data: RqsGenerator,
-    sim_settings: SimulationSettings,
-    *,
-    rng: np.random.Generator,
-) ->  Generator[float, None, None]:
-    """
-    Yield inter-arrival gaps (seconds) for the compound Poisson-Poisson process.
-
-    Algorithm
-    ---------
-    1. Every sampling_window_s seconds, draw
-         U ~ Poisson(mean_concurrent_user).
-    2. Compute the aggregate rate
-         Λ = U * (mean_req_per_minute_per_user / 60)  [req/s].
-    3. While inside the current window, draw gaps
-         Δt ~ Exponential(Λ)   using inverse-CDF.
-    4. Stop once the virtual clock exceeds *total_simulation_time*.
-    """
-    simulation_time = sim_settings.total_simulation_time
-    user_sampling_window = input_data.user_sampling_window
-
-    # λ_u : mean concurrent users per window
-    mean_concurrent_user = float(input_data.avg_active_users.mean)
-
-    # λ_r / 60 : mean req/s per user
-    mean_req_per_sec_per_user = (
-        float(
-            input_data.avg_request_per_minute_per_user.mean)
-        / TimeDefaults.MIN_TO_SEC
-    )
-
-    now = 0.0                 # virtual clock (s)
-    window_end = 0.0          # end of the current user window
-    lam = 0.0                 # aggregate rate Λ (req/s)
-
-    while now < simulation_time:
-        # (Re)sample U at the start of each window
-        if now >= window_end:
-            window_end = now + float(user_sampling_window)
-            users = poisson_variable_generator(mean_concurrent_user, rng)
-            lam = users * mean_req_per_sec_per_user
-
-        # No users → fast-forward to next window
-        if lam <= 0.0:
-            now = window_end
-            continue
-
-        # Exponential gap from a protected uniform value
-        u_raw = max(uniform_variable_generator(rng), 1e-15)
-        delta_t = -math.log(1.0 - u_raw) / lam
-
-        # End simulation if the next event exceeds the horizon
-        if now + delta_t > simulation_time:
-            break
-
-        # If the gap crosses the window boundary, jump to it
-        if now + delta_t >= window_end:
-            now = window_end
-            continue
-
-        now += delta_t
-        yield delta_t
diff --git a/src/asyncflow/schemas/arrivals/generator.py b/src/asyncflow/schemas/arrivals/generator.py
new file mode 100644
index 0000000..d6ec208
--- /dev/null
+++ b/src/asyncflow/schemas/arrivals/generator.py
@@ -0,0 +1,76 @@
+"""Define the schemas for the simulator"""
+
+from collections.abc import Iterable
+from typing import Self
+
+from pydantic import BaseModel, PositiveFloat, model_validator
+
+from asyncflow.config.enums import Distribution, SystemNodes, VariabilityLevel
+
+FORBIDS_VARIABILITY = {
+    Distribution.EXPONENTIAL,
+    Distribution.DETERMINISTIC,
+    Distribution.EMPIRICAL,
+    Distribution.POISSON,
+    Distribution.UNIFORM,
+}
+
+REQUIRES_VARIABILITY = {
+    Distribution.LOG_NORMAL,
+    Distribution.WEIBULL,
+    Distribution.PARETO,
+    Distribution.ERLANG,
+}
+
+class ArrivalsGenerator(BaseModel):
+    """Define the expected variables for the simulation"""
+
+    id: str
+    type: SystemNodes = SystemNodes.GENERATOR
+    lambda_rps: PositiveFloat
+    model: Distribution
+    variability: None | VariabilityLevel = None
+    empirical_data: Iterable[float] | None = None
+
+    @model_validator(mode="after")
+    def _check_variability_semantics(self) -> Self:
+        """
+        Validate the semantic consistency between model and variability.
+
+        - For models where variability cannot be configured, variability must be None.
+        - For models that require a variability level to determine shape/dispersion,
+          variability must be provided.
+        """
+        if self.model in FORBIDS_VARIABILITY and self.variability is not None:
+            msg = (f"variability is not allowed for model={self.model} "
+                  "(intrinsic or non-configurable variability).")
+            raise ValueError(msg)
+
+        if self.model in REQUIRES_VARIABILITY and self.variability is None:
+            msg = (f"variability is required for model={self.model} "
+                   "(specify low|medium|high).")
+            raise ValueError(msg)
+
+        return self
+
+
+    @model_validator(mode="after")
+    def _check_empirical_semantics(self) -> Self:
+        """
+        Validate presence/absence of empirical_data based on the model.
+
+        Rules
+        -----
+        * If model is EMPIRICAL, empirical_data MUST be provided (not None).
+        * If model is not EMPIRICAL, empirical_data MUST be None.
+        """
+        if self.model is Distribution.EMPIRICAL:
+            if self.empirical_data is None:
+                msg="empirical_data must be provided when model=EMPIRICAL."
+                raise ValueError(msg)
+        elif self.empirical_data is not None:
+            msg="empirical_data is only allowed when model=EMPIRICAL."
+            raise ValueError(msg)
+
+        return self
+
diff --git a/src/asyncflow/schemas/common/random_variables.py b/src/asyncflow/schemas/common/random_variables.py
index d827b92..e6e0dec 100644
--- a/src/asyncflow/schemas/common/random_variables.py
+++ b/src/asyncflow/schemas/common/random_variables.py
@@ -1,34 +1,21 @@
 """Definition of the schema for a Random variable"""
 
-from pydantic import BaseModel, field_validator, model_validator
+from pydantic import BaseModel, NonNegativeFloat, model_validator
 
-from asyncflow.config.constants import Distribution
+from asyncflow.config.enums import Distribution
 
 
 class RVConfig(BaseModel):
     """class to configure random variables"""
 
-    mean: float
+    mean: NonNegativeFloat
     distribution: Distribution = Distribution.POISSON
-    variance: float | None = None
-
-    @field_validator("mean", mode="before")
-    def ensure_mean_is_numeric_and_positive(
-        cls, # noqa: N805
-        v: float,
-        ) -> float:
-        """Ensure `mean` is numeric, then coerce to float."""
-        err_msg = "mean must be a number (int or float)"
-        if not isinstance(v, (float, int)):
-            raise ValueError(err_msg)  # noqa: TRY004
-
-        return float(v)
+    variance: NonNegativeFloat | None = None
 
     @model_validator(mode="after")  # type: ignore[arg-type]
     def default_variance(cls, model: "RVConfig") -> "RVConfig":  # noqa: N805
         """Set variance = mean when distribution require and variance is missing."""
         needs_variance: set[Distribution] = {
-            Distribution.NORMAL,
             Distribution.LOG_NORMAL,
         }
 
diff --git a/src/asyncflow/schemas/events/injection.py b/src/asyncflow/schemas/events/injection.py
index 266f920..c6fc3fd 100644
--- a/src/asyncflow/schemas/events/injection.py
+++ b/src/asyncflow/schemas/events/injection.py
@@ -10,7 +10,7 @@
     model_validator,
 )
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
 
 # Event input schema:
 # - Each event has its own identifier (event_id) and references the affected
diff --git a/src/asyncflow/schemas/payload.py b/src/asyncflow/schemas/payload.py
index cd5cf7d..053bc4c 100644
--- a/src/asyncflow/schemas/payload.py
+++ b/src/asyncflow/schemas/payload.py
@@ -2,17 +2,17 @@
 
 from pydantic import BaseModel, field_validator, model_validator
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.events.injection import EventInjection
 from asyncflow.schemas.settings.simulation import SimulationSettings
 from asyncflow.schemas.topology.graph import TopologyGraph
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 
 class SimulationPayload(BaseModel):
     """Full input structure to perform a simulation"""
 
-    rqs_input: RqsGenerator
+    arrivals: ArrivalsGenerator
     topology_graph: TopologyGraph
     sim_settings: SimulationSettings
     events: list[EventInjection] | None = None
diff --git a/src/asyncflow/schemas/settings/simulation.py b/src/asyncflow/schemas/settings/simulation.py
index 7f0d145..964cc6e 100644
--- a/src/asyncflow/schemas/settings/simulation.py
+++ b/src/asyncflow/schemas/settings/simulation.py
@@ -2,7 +2,7 @@
 
 from pydantic import BaseModel, Field
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     EventMetricName,
     SampledMetricName,
     SamplePeriods,
@@ -32,6 +32,10 @@ class SimulationSettings(BaseModel):
     enabled_event_metrics: set[EventMetricName] = Field(
         default_factory=lambda: {
             EventMetricName.RQS_CLOCK,
+            EventMetricName.RQS_SERVER_CLOCK,
+            EventMetricName.SERVICE_TIME,
+            EventMetricName.IO_TIME,
+            EventMetricName.WAITING_TIME,
         },
         description="Which per-event KPIs to collect by default.",
     )
diff --git a/src/asyncflow/schemas/topology/edges.py b/src/asyncflow/schemas/topology/edges.py
index 6e3d03b..a2b57da 100644
--- a/src/asyncflow/schemas/topology/edges.py
+++ b/src/asyncflow/schemas/topology/edges.py
@@ -3,26 +3,19 @@
 links between different nodes
 """
 
-from pydantic import (
-    BaseModel,
-    Field,
-    field_validator,
-    model_validator,
-)
+from pydantic import BaseModel, Field, PositiveFloat, field_validator, model_validator
 from pydantic_core.core_schema import ValidationInfo
 
-from asyncflow.config.constants import (
-    NetworkParameters,
-    SystemEdges,
-)
+from asyncflow.config.constants import NetworkParameters
+from asyncflow.config.enums import SystemEdges
 from asyncflow.schemas.common.random_variables import RVConfig
 
 #-------------------------------------------------------------
 # Definition of the edges structure for the graph representing
-# the topoogy of the system defined for the simulation
+# the topology of the system defined for the simulation
 #-------------------------------------------------------------
 
-class Edge(BaseModel):
+class NetworkEdge(BaseModel):
     """
     A directed connection in the topology graph.
 
@@ -32,11 +25,9 @@ class Edge(BaseModel):
         Identifier of the source node (where the request comes from).
     target : str
         Identifier of the destination node (where the request goes to).
-    latency : RVConfig
-        Random-variable configuration for network latency on this link.
-    probability : float
-        Probability of taking this edge when there are multiple outgoing links.
-        Must be in [0.0, 1.0]. Defaults to 1.0 (always taken).
+    latency : RVConfig | PositiveFloat
+        Random-variable configuration for network latency on this link or
+        positive float value.
     edge_type : SystemEdges
         Category of the link (e.g. network, queue, stream).
 
@@ -45,7 +36,7 @@ class Edge(BaseModel):
     id: str
     source: str
     target: str
-    latency: RVConfig
+    latency: RVConfig | PositiveFloat
     edge_type: SystemEdges = SystemEdges.NETWORK_CONNECTION
     dropout_rate: float = Field(
         NetworkParameters.DROPOUT_RATE,
@@ -66,10 +57,13 @@ class Edge(BaseModel):
     @field_validator("latency", mode="after")
     def ensure_latency_is_non_negative(
         cls, # noqa: N805
-        v: RVConfig,
+        v: RVConfig | PositiveFloat,
         info: ValidationInfo,
-        ) -> RVConfig:
+        ) -> RVConfig | PositiveFloat:
         """Ensures that the latency's mean and variance are positive."""
+        if not isinstance(v, RVConfig):
+            return v
+
         mean = v.mean
         variance = v.variance
 
@@ -79,9 +73,10 @@ def ensure_latency_is_non_negative(
         if mean <= 0:
             msg = f"The mean latency of the edge '{edge_id}' must be positive"
             raise ValueError(msg)
+
         if variance is not None and variance < 0: # Variance can be zero
             msg = (
-                f"The variance of the latency of the edge {edge_id}"
+                f"The variance of the latency of the edge {edge_id} "
                 "must be non negative"
             )
             raise ValueError(msg)
@@ -89,11 +84,51 @@ def ensure_latency_is_non_negative(
 
 
     @model_validator(mode="after") # type: ignore[arg-type]
-    def check_src_trgt_different(cls, model: "Edge") -> "Edge": # noqa: N805
+    def check_src_trgt_different(cls, model: "NetworkEdge") -> "NetworkEdge": # noqa: N805
         """Ensure source is different from target"""
         if model.source == model.target:
             msg = "source and target must be different nodes"
             raise ValueError(msg)
         return model
 
+    @field_validator("edge_type", mode="after")
+    def ensure_edge_type_is_correct(cls, v: SystemEdges) -> SystemEdges: # noqa: N805
+        """
+        Ensure the type of an edge not representing the network is network_connection
+        useful for to test model where the network is not negligible
+        """
+        if v != SystemEdges.NETWORK_CONNECTION:
+            msg=f"The type of the edge must be {SystemEdges.NETWORK_CONNECTION}"
+            raise ValueError(msg)
+        return v
+
 
+class LinkEdge(BaseModel):
+    """
+    Edges without latency, they may be useful in situations where
+    it is not necessary to model the network
+    """
+
+    id: str
+    source: str
+    target: str
+    edge_type: SystemEdges = SystemEdges.LINK_CONNECTION
+
+    @field_validator("edge_type", mode="after")
+    def ensure_edge_type_is_correct(cls, v: SystemEdges) -> SystemEdges: # noqa: N805
+        """
+        Ensure the type of an edge not representing the network is link_connection
+        useful for to test model where the network is negligible
+        """
+        if v != SystemEdges.LINK_CONNECTION:
+            msg=f"The type of the edge must be {SystemEdges.LINK_CONNECTION}"
+            raise ValueError(msg)
+        return v
+
+    @model_validator(mode="after") # type: ignore[arg-type]
+    def check_src_trgt_different(cls, model: "LinkEdge") -> "LinkEdge": # noqa: N805
+        """Ensure source is different from target"""
+        if model.source == model.target:
+            msg = "source and target must be different nodes"
+            raise ValueError(msg)
+        return model
diff --git a/src/asyncflow/schemas/topology/endpoint.py b/src/asyncflow/schemas/topology/endpoint.py
index aa91c7b..05429c6 100644
--- a/src/asyncflow/schemas/topology/endpoint.py
+++ b/src/asyncflow/schemas/topology/endpoint.py
@@ -8,12 +8,13 @@
     model_validator,
 )
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     EndpointStepCPU,
     EndpointStepIO,
     EndpointStepRAM,
     StepOperation,
 )
+from asyncflow.schemas.common.random_variables import RVConfig
 
 
 class Step(BaseModel):
@@ -23,7 +24,7 @@ class Step(BaseModel):
     """
 
     kind: EndpointStepIO | EndpointStepCPU | EndpointStepRAM
-    step_operation: dict[StepOperation, PositiveFloat | PositiveInt]
+    step_operation: dict[StepOperation, PositiveFloat | PositiveInt | RVConfig]
 
     @field_validator("step_operation", mode="before")
     def ensure_non_empty(
@@ -85,6 +86,55 @@ def ensure_coherence_type_operation(
 
         return model
 
+    @model_validator(mode="after")  # type: ignore[arg-type]
+    def ensure_cpu_io_positive_rv(cls, model: "Step") -> "Step":  # noqa: N805
+        """
+        For CPU/IO steps: if the operation is an RVConfig, require mean > 0
+        and variance ≥ 0. Deterministic PositiveFloat è già validato.
+        """
+        # safe anche se per qualche motivo ci fossero 0/2+ chiavi
+        op_val = next(iter(model.step_operation.values()), None)
+        if op_val is None:
+            return model
+
+        if isinstance(model.kind, EndpointStepCPU) and isinstance(op_val, RVConfig):
+            if op_val.mean <= 0:
+                msg = "CPU_TIME RVConfig.mean must be > 0"
+                raise ValueError(msg)
+            if op_val.variance is not None and op_val.variance < 0:
+                msg = "CPU_TIME RVConfig.variance must be >= 0"
+                raise ValueError(msg)
+
+        if isinstance(model.kind, EndpointStepIO) and isinstance(op_val, RVConfig):
+            if op_val.mean <= 0:
+                msg = "IO_WAITING_TIME RVConfig.mean must be > 0"
+                raise ValueError(msg)
+            if op_val.variance is not None and op_val.variance < 0:
+                msg = "IO_WAITING_TIME RVConfig.variance must be >= 0"
+                raise ValueError(msg)
+
+        return model
+
+    @model_validator(mode="after")  # type: ignore[arg-type]
+    def ensure_ram_positive_int(cls, model: "Step") -> "Step":  # noqa: N805
+        """For RAM steps: operation must be a positive integer (no RVs/floats)"""
+        if not isinstance(model.kind, EndpointStepRAM):
+            return model
+
+        op_val = next(iter(model.step_operation.values()), None)
+        if op_val is None:
+            return model
+
+        if isinstance(op_val, RVConfig) or not isinstance(op_val, int):
+            msg = "NECESSARY_RAM must be a positive integer"
+            raise TypeError(msg)
+
+        if op_val <= 0:
+            msg = "NECESSARY_RAM must be > 0"
+            raise ValueError(msg)
+
+        return model
+
 
 
 
diff --git a/src/asyncflow/schemas/topology/graph.py b/src/asyncflow/schemas/topology/graph.py
index 91cf857..7cb5af5 100644
--- a/src/asyncflow/schemas/topology/graph.py
+++ b/src/asyncflow/schemas/topology/graph.py
@@ -13,7 +13,7 @@
     model_validator,
 )
 
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.nodes import TopologyNodes
 
 #-------------------------------------------------------------
@@ -28,7 +28,7 @@ class TopologyGraph(BaseModel):
     """
 
     nodes: TopologyNodes
-    edges: list[Edge]
+    edges: list[NetworkEdge] | list[LinkEdge]
 
     @model_validator(mode="after") # type: ignore[arg-type]
     def unique_ids(
diff --git a/src/asyncflow/schemas/topology/nodes.py b/src/asyncflow/schemas/topology/nodes.py
index 5ada69b..75a4f66 100644
--- a/src/asyncflow/schemas/topology/nodes.py
+++ b/src/asyncflow/schemas/topology/nodes.py
@@ -15,18 +15,44 @@
     model_validator,
 )
 
-from asyncflow.config.constants import (
+from asyncflow.config.constants import NodesResourcesDefaults
+from asyncflow.config.enums import (
     LbAlgorithmsName,
-    ServerResourcesDefaults,
     SystemNodes,
 )
 from asyncflow.schemas.topology.endpoint import Endpoint
 
 #-------------------------------------------------------------
 # Definition of the nodes structure for the graph representing
-# the topoogy of the system defined for the simulation
+# the topology of the system defined for the simulation
 #-------------------------------------------------------------
 
+# -------------------------------------------------------------
+# Resources you may assign to a node
+# -------------------------------------------------------------
+
+class NodesResources(BaseModel):
+    """
+    Quantifiable resources available on a node (server/LB/client).
+    Each attribute maps to a SimPy resource primitive or container.
+    """
+
+    cpu_cores: PositiveInt = Field(
+        NodesResourcesDefaults.CPU_CORES,
+        ge = NodesResourcesDefaults.MINIMUM_CPU_CORES,
+        description="Number of CPU cores available for processing.",
+    )
+
+    db_connection_pool: PositiveInt | None = Field(
+        NodesResourcesDefaults.DB_CONNECTION_POOL,
+        description="Size of the database connection pool, if applicable.",
+    )
+
+    ram_mb: PositiveInt = Field(
+        NodesResourcesDefaults.RAM_MB,
+        ge = NodesResourcesDefaults.MINIMUM_RAM_MB,
+        description="Total available RAM in megabytes.")
+
 # -------------------------------------------------------------
 # CLIENT
 # -------------------------------------------------------------
@@ -37,43 +63,36 @@ class Client(BaseModel):
     id: str
     type: SystemNodes = SystemNodes.CLIENT
 
+    # A client may be hosted on a virtual machine
+    # and technically has resources.
+    # At this stage, client-side bottlenecks
+    # are not modeled, so resources are optional.
+
+    client_resources: NodesResources | None = None
+    ram_per_process: PositiveInt | None = None
+
     @field_validator("type", mode="after")
     def ensure_type_is_standard(cls, v: SystemNodes) -> SystemNodes: # noqa: N805
-        """Ensure the type of the client is standard"""
+        """Ensure the node type is CLIENT."""
         if v != SystemNodes.CLIENT:
             msg = f"The type should have a standard value: {SystemNodes.CLIENT}"
             raise ValueError(msg)
         return v
 
-# -------------------------------------------------------------
-# SERVER RESOURCES
-# -------------------------------------------------------------
-
-class ServerResources(BaseModel):
-    """
-    Defines the quantifiable resources available on a server node.
-    Each attribute maps directly to a SimPy resource primitive.
-    """
+    @model_validator(mode="after") # type: ignore[arg-type]
+    def ram_and_ram_per_process_are_coherent(
+        cls, # noqa: N805
+        model: "Client",
+        ) -> "Client":
+        """Check that if ram per process exist, ram is assigned to the client"""
+        if model.ram_per_process and not model.client_resources:
+            msg = ("To reserve per-process RAM for the client "
+                   f"'{model.id}', define resources in 'client_resources'.")
+            raise ValueError(msg)
 
-    cpu_cores: PositiveInt = Field(
-        ServerResourcesDefaults.CPU_CORES,
-        ge = ServerResourcesDefaults.MINIMUM_CPU_CORES,
-        description="Number of CPU cores available for processing.",
-    )
-    db_connection_pool: PositiveInt | None = Field(
-        ServerResourcesDefaults.DB_CONNECTION_POOL,
-        description="Size of the database connection pool, if applicable.",
-    )
+        return model
 
-    # Risorse modellate come simpy.Container (livello)
-    ram_mb: PositiveInt = Field(
-        ServerResourcesDefaults.RAM_MB,
-        ge = ServerResourcesDefaults.MINIMUM_RAM_MB,
-        description="Total available RAM in Megabytes.")
 
-    # for the future
-    # disk_iops_limit: PositiveInt | None = None
-    # network_throughput_mbps: PositiveInt | None = None
 
 # -------------------------------------------------------------
 # SERVER
@@ -84,20 +103,20 @@ class Server(BaseModel):
     definition of the server class:
     - id: is the server identifier
     - type: is the type of node in the structure
-    - server resources: is a dictionary to define the resources
+    - nodes resources: is a dictionary to define the resources
       of the machine where the server is living
     - endpoints: is the list of all endpoints in a server
     """
 
     id: str
     type: SystemNodes = SystemNodes.SERVER
-    #Later define a valide structure for the keys of server resources
-    server_resources : ServerResources
-    endpoints : list[Endpoint]
+    server_resources: NodesResources
+    endpoints: list[Endpoint] = Field(min_length=1)
+    ram_per_process: PositiveInt | None = None
 
     @field_validator("type", mode="after")
     def ensure_type_is_standard(cls, v: SystemNodes) -> SystemNodes: # noqa: N805
-        """Ensure the type of the server is standard"""
+        """Ensure the node type is SERVER."""
         if v != SystemNodes.SERVER:
             msg = f"The type should have a standard value: {SystemNodes.SERVER}"
             raise ValueError(msg)
@@ -116,16 +135,35 @@ class LoadBalancer(BaseModel):
     algorithms: LbAlgorithmsName = LbAlgorithmsName.ROUND_ROBIN
     server_covered: set[str] = Field(default_factory=set)
 
+    # In the next release, once the new network model is introduced,
+    # we will monitor resource-related bottlenecks that can occur at the LB,
+    # especially RAM pressure. Until then, we keep this optional to maintain
+    # compatibility with the current public API.
+    lb_resources: NodesResources | None = None
+    ram_per_process: PositiveInt | None = None
 
 
     @field_validator("type", mode="after")
     def ensure_type_is_standard(cls, v: SystemNodes) -> SystemNodes: # noqa: N805
-        """Ensure the type of the server is standard"""
+        """Ensure the node type is LOAD_BALANCER."""
         if v != SystemNodes.LOAD_BALANCER:
             msg = f"The type should have a standard value: {SystemNodes.LOAD_BALANCER}"
             raise ValueError(msg)
         return v
 
+    @model_validator(mode="after") # type: ignore[arg-type]
+    def ram_and_ram_per_process_are_coherent(
+        cls, # noqa: N805
+        model: "LoadBalancer",
+        ) -> "LoadBalancer":
+        """Check that if ram per process exist, ram is assigned to LB"""
+        if model.ram_per_process and not model.lb_resources:
+            msg = ("To reserve per-process RAM for the load balancer "
+                   f"'{model.id}', define resources in 'lb_resources'.")
+            raise ValueError(msg)
+
+        return model
+
 
 # -------------------------------------------------------------
 # NODES CLASS WITH ALL POSSIBLE OBJECTS REPRESENTED BY A NODE
@@ -141,8 +179,8 @@ class TopologyNodes(BaseModel):
 
     servers: list[Server]
     client: Client
-    # Right now we accept just one LB, in the future we
-    # will change this
+
+    # For now we accept a single LB; this may change in the future.
     load_balancer: LoadBalancer | None = None
 
     @model_validator(mode="after") # type: ignore[arg-type]
@@ -150,7 +188,7 @@ def unique_ids(
         cls, # noqa: N805
         model: "TopologyNodes",
         ) -> "TopologyNodes":
-        """Check that all id are unique"""
+        """Ensure that all node IDs are unique."""
         ids = [server.id for server in model.servers] + [model.client.id]
 
         if model.load_balancer is not None:
@@ -159,8 +197,54 @@ def unique_ids(
         counter = Counter(ids)
         duplicate = [node_id for node_id, value in counter.items() if value > 1]
         if duplicate:
-            msg = f"The following node ids are duplicate {duplicate}"
+            msg = f"Duplicate node IDs detected: {duplicate}"
             raise ValueError(msg)
         return model
 
+    @model_validator(mode="after") # type: ignore[arg-type]
+    def ensure_servers_covered_by_lb_exist(
+        cls, # noqa: N805
+        model: "TopologyNodes",
+        ) -> "TopologyNodes":
+        """Ensure that all servers covered by the LB exist."""
+        if not model.load_balancer:
+            return model
+
+        server_ids = {server.id for server in model.servers}
+
+        for server_id in model.load_balancer.server_covered:
+            if server_id not in server_ids:
+                msg = (
+                       f"Load balancer '{model.load_balancer.id}' "
+                       f"references unknown server '{server_id}'. "
+                       "Define it under 'servers' or remove it from 'server_covered'."
+                       )
+                raise ValueError(msg)
+
+        return model
+
+    @model_validator(mode="after") # type: ignore[arg-type]
+    def ensure_ram_and_ram_per_process_is_valid(
+        cls, # noqa: N805
+        model: "TopologyNodes",
+        ) -> "TopologyNodes":
+        """Ensure the total ram for processes is not higher than the ram available"""
+        for server in model.servers:
+            if server.ram_per_process:
+               total_ram_for_processes = (
+                   server.server_resources.cpu_cores *
+                   server.ram_per_process
+               )
+               if total_ram_for_processes >= server.server_resources.ram_mb:
+                   msg = (f"Server '{server.id}': "
+                          f"per-process RAM total ({total_ram_for_processes} MB) "
+                          f"exceeds or is equal to total RAM "
+                          f"({server.server_resources.ram_mb} MB)."
+                   )
+                   raise ValueError(msg)
+
+        return model
+
+
+    # Reject unknown fields to keep schemas strict and predictable.
     model_config = ConfigDict(extra="forbid")
diff --git a/src/asyncflow/schemas/workload/rqs_generator.py b/src/asyncflow/schemas/workload/rqs_generator.py
deleted file mode 100644
index a6fbf3b..0000000
--- a/src/asyncflow/schemas/workload/rqs_generator.py
+++ /dev/null
@@ -1,59 +0,0 @@
-"""Define the schemas for the simulator"""
-
-
-from pydantic import BaseModel, Field, field_validator
-
-from asyncflow.config.constants import Distribution, SystemNodes, TimeDefaults
-from asyncflow.schemas.common.random_variables import RVConfig
-
-
-class RqsGenerator(BaseModel):
-    """Define the expected variables for the simulation"""
-
-    id: str
-    type: SystemNodes = SystemNodes.GENERATOR
-    avg_active_users: RVConfig
-    avg_request_per_minute_per_user: RVConfig
-
-    user_sampling_window: int = Field(
-        default=TimeDefaults.USER_SAMPLING_WINDOW,
-        ge=TimeDefaults.MIN_USER_SAMPLING_WINDOW,
-        le=TimeDefaults.MAX_USER_SAMPLING_WINDOW,
-        description=(
-            "Sampling window in seconds "
-            f"({TimeDefaults.MIN_USER_SAMPLING_WINDOW}-"
-            f"{TimeDefaults.MAX_USER_SAMPLING_WINDOW})."
-        ),
-    )
-
-    @field_validator("avg_request_per_minute_per_user", mode="after")
-    def ensure_avg_request_is_poisson(
-        cls, # noqa: N805
-        v: RVConfig,
-        ) -> RVConfig:
-        """
-        Force the distribution for the rqs generator to be poisson
-        at the moment we have a joint sampler just for the poisson-poisson
-        and gaussian-poisson case
-        """
-        if v.distribution != Distribution.POISSON:
-            msg = "At the moment the variable avg request must be Poisson"
-            raise ValueError(msg)
-        return v
-
-    @field_validator("avg_active_users", mode="after")
-    def ensure_avg_user_is_poisson_or_gaussian(
-        cls, # noqa: N805
-        v: RVConfig,
-        ) -> RVConfig:
-        """
-        Force the distribution for the rqs generator to be poisson
-        at the moment we have a joint sampler just for the poisson-poisson
-        and gaussian-poisson case
-        """
-        if v.distribution not in {Distribution.POISSON, Distribution.NORMAL}:
-            msg = "At the moment the variable active user must be Poisson or Gaussian"
-            raise ValueError(msg)
-        return v
-
-
diff --git a/src/asyncflow/workload/__init__.py b/src/asyncflow/workload/__init__.py
deleted file mode 100644
index c4b8735..0000000
--- a/src/asyncflow/workload/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""Public workload API."""
-from __future__ import annotations
-
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-__all__ = ["RVConfig", "RqsGenerator"]
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..c75472e
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1 @@
+"""package to ensure smooth import"""
diff --git a/tests/conftest.py b/tests/conftest.py
index 6834764..80a1768 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -5,23 +5,23 @@
 from numpy.random import Generator as NpGenerator
 from numpy.random import default_rng
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     Distribution,
     EventMetricName,
     SampledMetricName,
     SamplePeriods,
     TimeDefaults,
 )
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.payload import SimulationPayload
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import NetworkEdge
 from asyncflow.schemas.topology.graph import TopologyGraph
 from asyncflow.schemas.topology.nodes import (
     Client,
     TopologyNodes,
 )
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 # ============================================================================
 # STANDARD CONFIGURATION FOR INPUT VARIABLES
@@ -90,16 +90,15 @@ def sim_settings(
 
 
 @pytest.fixture
-def rqs_input() -> RqsGenerator:
+def arrivals_gen() -> ArrivalsGenerator:
     """
     One active user issuing two requests per minute—sufficient to
     exercise the entire request-generator pipeline with minimal overhead.
     """
-    return RqsGenerator(
+    return ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users=RVConfig(mean=1.0),
-        avg_request_per_minute_per_user=RVConfig(mean=2.0),
-        user_sampling_window=TimeDefaults.USER_SAMPLING_WINDOW,
+        lambda_rps=20,
+        model=Distribution.POISSON,
     )
 
 
@@ -119,7 +118,7 @@ def topology_minimal() -> TopologyGraph:
     client = Client(id="client-1")
 
     # Stub edge: generator id comes from rqs_input fixture (“rqs-1”)
-    edge = Edge(
+    edge = NetworkEdge(
         id="gen-to-client",
         source="rqs-1",
         target="client-1",
@@ -135,11 +134,7 @@ def topology_minimal() -> TopologyGraph:
 
 
 @pytest.fixture
-def payload_base(
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-    topology_minimal: TopologyGraph,
-) -> SimulationPayload:
+def payload_base() -> SimulationPayload:
     """
     End-to-end payload used by integration tests and FastAPI endpoint tests.
 
@@ -147,9 +142,9 @@ def payload_base(
     by the simulation engine.
     """
     return SimulationPayload(
-        rqs_input=rqs_input,
-        topology_graph=topology_minimal,
-        sim_settings=sim_settings,
+        arrivals=arrivals_gen(),
+        topology_graph=topology_minimal(),
+        sim_settings=sim_settings(),
 
     )
 
@@ -160,3 +155,4 @@ def payload_base(
 def env() -> simpy.Environment:
     """Return a fresh SimPy environment per test."""
     return simpy.Environment()
+
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index 2c94d6f..273ea06 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -1,13 +1,41 @@
-"""Shared fixtures used by several integration-test groups."""
+"""Project-wide fixtures and factory-fixtures for integration tests.
+
+Design goals
+------------
+- DRY: shared builders live here (arrivals, servers, edges, topologies, events).
+- Flexible: factory fixtures let tests customize times/means without repetition.
+- Safe: each test gets a fresh SimPy env; no state leakage between tests.
+"""
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Protocol
 
 import pytest
 import simpy
 
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.config.enums import (
+    Distribution,
+    EndpointStepCPU,
+    EventDescription,
+    StepOperation,
+)
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.common.random_variables import RVConfig
+from asyncflow.schemas.events.injection import EventInjection
+from asyncflow.schemas.payload import SimulationPayload
+from asyncflow.schemas.settings.simulation import SimulationSettings
+from asyncflow.schemas.topology.edges import NetworkEdge
+from asyncflow.schemas.topology.endpoint import Endpoint, Step
+from asyncflow.schemas.topology.graph import TopologyGraph
+from asyncflow.schemas.topology.nodes import (
+    Client,
+    LoadBalancer,
+    NodesResources,
+    Server,
+    TopologyNodes,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -15,32 +43,299 @@
 
 
 # --------------------------------------------------------------------------- #
-# Environment                                                                 #
+# Core environment / runner helpers                                           #
 # --------------------------------------------------------------------------- #
+
 @pytest.fixture
 def env() -> simpy.Environment:
-    """A fresh SimPy environment per test."""
+    """Fresh SimPy environment per test."""
     return simpy.Environment()
 
 
-# --------------------------------------------------------------------------- #
-# Runner factory (load YAML scenarios)                                        #
-# --------------------------------------------------------------------------- #
 @pytest.fixture
-def make_runner(
+def sim_settings() -> SimulationSettings:
+    """Default short horizon; tests can override via model_copy()."""
+    return SimulationSettings(total_simulation_time=5)
+
+
+@pytest.fixture
+def make_runner_from_yaml(
     env: simpy.Environment,
 ) -> Callable[[str | Path], SimulationRunner]:
+    """Factory that loads a YAML scenario and returns a SimulationRunner."""
+
+    def _factory(yaml_path: str | Path) -> SimulationRunner:
+        return SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
+
+    return _factory
+
+
+@pytest.fixture
+def make_runner_from_payload(
+    env: simpy.Environment,
+) -> Callable[[SimulationPayload], SimulationRunner]:
+    """Factory that wraps a validated payload into a SimulationRunner."""
+
+    def _factory(payload: SimulationPayload) -> SimulationRunner:
+        return SimulationRunner(env=env, simulation_input=payload)
+
+    return _factory
+
+
+# --------------------------------------------------------------------------- #
+# Arrivals / servers / edges factories                                        #
+# --------------------------------------------------------------------------- #
+
+@pytest.fixture
+def arrivals_factory() -> Callable[[str, float, Distribution], ArrivalsGenerator]:
+    """Build an ArrivalsGenerator with the chosen rate and model."""
+
+    def _make(
+        rid: str,
+        lambda_rps: float = 20.0,
+        model: Distribution = Distribution.POISSON,
+    ) -> ArrivalsGenerator:
+        return ArrivalsGenerator(id=rid, lambda_rps=lambda_rps, model=model)
+
+    return _make
+
+
+@pytest.fixture
+def arrivals_poisson(
+    arrivals_factory: Callable[..., ArrivalsGenerator],
+    ) -> ArrivalsGenerator:
+    """Convenience: Poisson arrivals @ 20 rps."""
+    return arrivals_factory("rqs-1", 20.0, Distribution.POISSON)
+
+
+@pytest.fixture
+def server_factory() -> Callable[[str, float | None], Server]:
     """
-    Factory that loads a YAML scenario and instantiates a
-    :class:`SimulationRunner`.
+    Build a server. If `service_time_s` is None, the server has no steps.
+    Otherwise, a single CPU step with mean service time is created.
+    """
+
+    def _make(sid: str, service_time_s: float | None = 0.001) -> Server:
+        if service_time_s is None:
+            endpoints: list[Endpoint] = []
+        else:
+            ep = Endpoint(
+                endpoint_name="get",
+                steps=[
+                    Step(
+                        kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+                        step_operation={StepOperation.CPU_TIME: service_time_s},
+                    ),
+                ],
+            )
+            endpoints = [ep]
+        return Server(id=sid, server_resources=NodesResources(), endpoints=endpoints)
+
+    return _make
+
+
+class EdgeFactory(Protocol):
+    """Callable that builds an `Edge` with a latency RV."""
 
-    Usage inside a test::
+    def __call__(
+        self,
+        eid: str,
+        src: str,
+        tgt: str,
+        mean: float,
+        dist: Distribution = ...,
+    ) -> NetworkEdge:
+        """Return an `Edge` from ids and latency parameters."""
 
-        runner = make_runner("scenarios/minimal.yml")
-        results = runner.run()
+
+@pytest.fixture
+def edge_factory() -> Callable[..., NetworkEdge]:
+    """
+    Build an edge with a latency RV. Defaults to Poisson(mean=1ms) to keep
+    tests fast; pass another distribution/mean when needed.
     """
 
-    def _factory(yaml_path: str | Path) -> SimulationRunner:
-        return SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
+    def _make(
+        eid: str,
+        src: str,
+        tgt: str,
+        mean: float = 0.001,
+        dist: Distribution = Distribution.POISSON,
+    ) -> NetworkEdge:
+        return NetworkEdge(
+            id=eid,
+            source=src,
+            target=tgt,
+            latency=RVConfig(mean=mean, distribution=dist),
+        )
+
+    return _make
+
+
+# --------------------------------------------------------------------------- #
+# Topology builders                                                           #
+# --------------------------------------------------------------------------- #
+
+class TwoServersBuilder(Protocol):
+    """Callable that returns a two-server `TopologyGraph`."""
+
+    def __call__(
+        self, *, service_time_s: float | None = ..., edge_mean: float = ...,
+    ) -> TopologyGraph:
+        """Build the graph with two servers and a load balancer."""
+
+
+class SingleServerBuilder(Protocol):
+    """Callable that returns a single-server `TopologyGraph`."""
+
+    def __call__(
+        self, *, service_time_s: float | None = ..., edge_mean: float = ...,
+    ) -> TopologyGraph:
+        """Build the graph with one server and a load balancer."""
+
+
+@pytest.fixture
+def topology_two_servers(
+    server_factory: Callable[[str, float | None], Server],
+    edge_factory: Callable[..., NetworkEdge],
+) -> Callable[..., TopologyGraph]:
+    """Factory for a two-server topology with a load balancer"""
+    def _make(*, service_time_s: float | None = 0.001,
+              edge_mean: float = 0.001) -> TopologyGraph:
+        client = Client(id="client-1")
+        lb = LoadBalancer(id="lb-1")
+        srv1 = server_factory("srv-1", service_time_s)
+        srv2 = server_factory("srv-2", service_time_s)
+
+        edges = [
+            edge_factory("gen-to-client", "rqs-1", "client-1", edge_mean),
+            edge_factory("client-to-lb", "client-1", "lb-1", edge_mean),
+            edge_factory("lb-to-srv1", "lb-1", "srv-1", edge_mean),
+            edge_factory("lb-to-srv2", "lb-1", "srv-2", edge_mean),
+            edge_factory("srv1-to-client", "srv-1", "client-1", edge_mean),
+            edge_factory("srv2-to-client", "srv-2", "client-1", edge_mean),
+        ]
+        nodes = TopologyNodes(
+            servers=[srv1, srv2], client=client, load_balancer=lb,
+        )
+        return TopologyGraph(nodes=nodes, edges=edges)
+    return _make
+
+
+@pytest.fixture
+def topology_single_server(
+    server_factory: Callable[[str, float | None], Server],
+    edge_factory: Callable[..., NetworkEdge],
+) -> Callable[..., TopologyGraph]:
+    """Factory for a single-server topology with a load balancer in front"""
+    def _make(*, service_time_s: float | None = 0.001,
+              edge_mean: float = 0.001) -> TopologyGraph:
+        client = Client(id="client-1")
+        lb = LoadBalancer(id="lb-1")
+        srv = server_factory("srv-1", service_time_s)
+
+        edges = [
+            edge_factory("gen-to-client", "rqs-1", "client-1", edge_mean),
+            edge_factory("client-to-lb", "client-1", "lb-1", edge_mean),
+            edge_factory("lb-to-srv1", "lb-1", "srv-1", edge_mean),
+            edge_factory("srv1-to-client", "srv-1", "client-1", edge_mean),
+        ]
+        nodes = TopologyNodes(
+            servers=[srv], client=client, load_balancer=lb,
+        )
+        return TopologyGraph(nodes=nodes, edges=edges)
+    return _make
+
+# --------------------------------------------------------------------------- #
+# Event factories                                                             #
+# --------------------------------------------------------------------------- #
+
+@pytest.fixture
+def spike_event_factory() -> Callable[[float, float, float, str], EventInjection]:
+    """Build a NETWORK_SPIKE event targeting an edge."""
+
+    def _make(
+        t_start: float,
+        t_end: float,
+        spike_s: float,
+        edge_id: str = "client-to-lb",
+    ) -> EventInjection:
+        return EventInjection(
+            event_id="spike",
+            target_id=edge_id,
+            start={
+                "kind": EventDescription.NETWORK_SPIKE_START,
+                "t_start": t_start,
+                "spike_s": spike_s,
+            },
+            end={"kind": EventDescription.NETWORK_SPIKE_END, "t_end": t_end},
+        )
+
+    return _make
+
+
+@pytest.fixture
+def outage_event_factory() -> Callable[[float, float, str], EventInjection]:
+    """Build a SERVER_DOWN/UP interval targeting a server."""
+
+    def _make(
+        t_start: float,
+        t_end: float,
+        server_id: str = "srv-1",
+    ) -> EventInjection:
+        return EventInjection(
+            event_id="outage",
+            target_id=server_id,
+            start={"kind": EventDescription.SERVER_DOWN, "t_start": t_start},
+            end={"kind": EventDescription.SERVER_UP, "t_end": t_end},
+        )
+
+    return _make
+
+
+# --------------------------------------------------------------------------- #
+# Payload helpers                                                             #
+# --------------------------------------------------------------------------- #
+
+@pytest.fixture
+def make_payload() -> Callable[
+    [ArrivalsGenerator, TopologyGraph, SimulationSettings, list[EventInjection] | None],
+    SimulationPayload,
+]:
+    """Factory that assembles a validated :class:`SimulationPayload`."""
+
+    def _factory(
+        arrivals: ArrivalsGenerator,
+        topo: TopologyGraph,
+        sim: SimulationSettings,
+        events: list[EventInjection] | None = None,
+    ) -> SimulationPayload:
+        return SimulationPayload(
+            arrivals=arrivals,
+            topology_graph=topo,
+            sim_settings=sim,
+            events=events,
+        )
 
     return _factory
+
+
+@pytest.fixture
+def payload_base(
+    arrivals_poisson: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
+) -> SimulationPayload:
+    """
+    Minimal payload: generator + client node, no servers/LB, no edges.
+
+    Useful for smoke tests that patch out edges and only exercise the
+    runner's boot/shutdown paths.
+    """
+    nodes = TopologyNodes(servers=[], client=Client(id="client-1"))
+    topo = TopologyGraph(nodes=nodes, edges=[])
+    return SimulationPayload(
+        arrivals=arrivals_poisson,
+        topology_graph=topo,
+        sim_settings=sim_settings,
+        events=None,
+    )
diff --git a/tests/integration/event_injection/lb_two_servers.py b/tests/integration/event_injection/lb_two_servers.py
deleted file mode 100644
index 4272719..0000000
--- a/tests/integration/event_injection/lb_two_servers.py
+++ /dev/null
@@ -1,113 +0,0 @@
-"""Integration test: LB with two servers and concurrent event injections.
-
-Topology:
-
-  rqs-1 → client-1 → lb-1 → {srv-1, srv-2}
-                     srv-* → client-1
-
-Events:
-- NETWORK_SPIKE on 'client-to-lb' in [0.20, 0.35].
-- SERVER_DOWN/UP on 'srv-1' in [0.40, 0.55].
-
-Assertions:
-- Simulation completes.
-- Latency stats and throughput exist.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import simpy
-
-from asyncflow.config.constants import Distribution, EventDescription, LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.payload import SimulationPayload
-from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
-from asyncflow.schemas.topology.graph import TopologyGraph
-from asyncflow.schemas.topology.nodes import (
-    Client,
-    LoadBalancer,
-    Server,
-    ServerResources,
-    TopologyNodes,
-)
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-if TYPE_CHECKING:
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def _server(sid: str) -> Server:
-    return Server(id=sid, server_resources=ServerResources(), endpoints=[])
-
-
-def _edge(eid: str, src: str, tgt: str, mean: float = 0.002) -> Edge:
-    return Edge(
-        id=eid,
-        source=src,
-        target=tgt,
-        latency=RVConfig(mean=mean, distribution=Distribution.POISSON),
-    )
-
-
-def test_lb_two_servers_with_events_end_to_end() -> None:
-    """Round-robin LB with events; check that KPIs are produced."""
-    env = simpy.Environment()
-    rqs = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=RVConfig(mean=1.0),
-        avg_request_per_minute_per_user=RVConfig(mean=2.0),
-        user_sampling_window=10.0,
-    )
-    sim = SimulationSettings(total_simulation_time=0.8)
-
-    client = Client(id="client-1")
-    lb = LoadBalancer(id="lb-1")
-    srv1 = _server("srv-1")
-    srv2 = _server("srv-2")
-
-    edges = [
-        _edge("gen-to-client", "rqs-1", "client-1"),
-        _edge("client-to-lb", "client-1", "lb-1"),
-        _edge("lb-to-srv1", "lb-1", "srv-1"),
-        _edge("lb-to-srv2", "lb-1", "srv-2"),
-        _edge("srv1-to-client", "srv-1", "client-1"),
-        _edge("srv2-to-client", "srv-2", "client-1"),
-    ]
-    nodes = TopologyNodes(servers=[srv1, srv2], client=client, load_balancer=lb)
-    topo = TopologyGraph(nodes=nodes, edges=edges)
-
-    events = [
-        EventInjection(
-            event_id="spike",
-            target_id="client-to-lb",
-            start={
-                "kind": EventDescription.NETWORK_SPIKE_START,
-                "t_start": 0.20,
-                "spike_s": 0.02,
-            },
-            end={"kind": EventDescription.NETWORK_SPIKE_END, "t_end": 0.35},
-        ),
-        EventInjection(
-            event_id="outage-srv1",
-            target_id="srv-1",
-            start={"kind": EventDescription.SERVER_DOWN, "t_start": 0.40},
-            end={"kind": EventDescription.SERVER_UP, "t_end": 0.55},
-        ),
-    ]
-
-    payload = SimulationPayload(rqs_input=rqs, topology_graph=topo, sim_settings=sim)
-    payload.events = events
-
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-
-    stats = results.get_latency_stats()
-    assert stats
-    assert stats[LatencyKey.TOTAL_REQUESTS] > 0
-    ts, rps = results.get_throughput_series()
-    assert len(ts) == len(rps) > 0
diff --git a/tests/integration/event_injection/single_server.py b/tests/integration/event_injection/single_server.py
deleted file mode 100644
index 1698305..0000000
--- a/tests/integration/event_injection/single_server.py
+++ /dev/null
@@ -1,108 +0,0 @@
-"""Integration test: single server with edge spike and server outage.
-
-Topology:
-
-  rqs-1 → client-1 → lb-1 → srv-1
-                      srv-1 → client-1
-
-Events:
-- NETWORK_SPIKE on 'client-to-lb' during a small window.
-- SERVER_DOWN/UP on 'srv-1' during a small window.
-
-Assertions focus on end-to-end KPIs; the fine-grained event sequencing is
-covered by unit tests in the event injection suite.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import simpy
-
-from asyncflow.config.constants import Distribution, EventDescription, LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.payload import SimulationPayload
-from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
-from asyncflow.schemas.topology.graph import TopologyGraph
-from asyncflow.schemas.topology.nodes import (
-    Client,
-    LoadBalancer,
-    Server,
-    ServerResources,
-    TopologyNodes,
-)
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-if TYPE_CHECKING:
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def _server(sid: str) -> Server:
-    return Server(id=sid, server_resources=ServerResources(), endpoints=[])
-
-
-def _edge(eid: str, src: str, tgt: str, mean: float = 0.002) -> Edge:
-    return Edge(
-        id=eid,
-        source=src,
-        target=tgt,
-        latency=RVConfig(mean=mean, distribution=Distribution.POISSON),
-    )
-
-
-def test_single_server_with_spike_and_outage_end_to_end() -> None:
-    """Run with both edge spike and server outage; verify KPIs exist."""
-    env = simpy.Environment()
-    rqs = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=RVConfig(mean=1.0),
-        avg_request_per_minute_per_user=RVConfig(mean=2.0),
-        user_sampling_window=10.0,
-    )
-    sim = SimulationSettings(total_simulation_time=1.0)
-
-    client = Client(id="client-1")
-    lb = LoadBalancer(id="lb-1")
-    srv = _server("srv-1")
-
-    edges = [
-        _edge("gen-to-client", "rqs-1", "client-1"),
-        _edge("client-to-lb", "client-1", "lb-1"),
-        _edge("lb-to-srv1", "lb-1", "srv-1"),
-        _edge("srv1-to-client", "srv-1", "client-1"),
-    ]
-    nodes = TopologyNodes(servers=[srv], client=client, load_balancer=lb)
-    topo = TopologyGraph(nodes=nodes, edges=edges)
-
-    # Events in a short (but disjoint) schedule to avoid cross-process ties
-    events = [
-        EventInjection(
-            event_id="spike",
-            target_id="client-to-lb",
-            start={
-                "kind": EventDescription.NETWORK_SPIKE_START,
-                "t_start": 0.2,
-                "spike_s": 0.01,
-            },
-            end={"kind": EventDescription.NETWORK_SPIKE_END, "t_end": 0.4},
-        ),
-        EventInjection(
-            event_id="outage",
-            target_id="srv-1",
-            start={"kind": EventDescription.SERVER_DOWN, "t_start": 0.5},
-            end={"kind": EventDescription.SERVER_UP, "t_end": 0.7},
-        ),
-    ]
-
-    payload = SimulationPayload(rqs_input=rqs, topology_graph=topo, sim_settings=sim)
-    payload.events = events
-
-    runner = SimulationRunner(env=env, simulation_input=payload)
-    results: ResultsAnalyzer = runner.run()
-
-    stats = results.get_latency_stats()
-    assert stats
-    assert stats[LatencyKey.TOTAL_REQUESTS] > 0
diff --git a/tests/integration/event_injection/test_lb_two_servers.py b/tests/integration/event_injection/test_lb_two_servers.py
new file mode 100644
index 0000000..ec82f82
--- /dev/null
+++ b/tests/integration/event_injection/test_lb_two_servers.py
@@ -0,0 +1,82 @@
+"""Integration test: LB with two servers and concurrent event injections.
+
+Topology:
+  rqs-1 → client-1 → lb-1 → {srv-1, srv-2}
+                     srv-* → client-1
+
+Events:
+- NETWORK_SPIKE on 'client-to-lb' in [0.20, 0.35].
+- SERVER_DOWN/UP on 'srv-1' in [0.40, 0.55].
+
+Assertions:
+- Simulation completes.
+- Latency stats and throughput exist.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from asyncflow.config.enums import Distribution, EventDescription, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.events.injection import EventInjection
+from asyncflow.schemas.settings.simulation import SimulationSettings
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import simpy
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
+    from asyncflow.schemas.topology.graph import TopologyGraph
+
+
+def test_lb_two_servers_with_events_end_to_end(
+    env: simpy.Environment,
+     topology_two_servers: Callable[..., TopologyGraph],
+    make_payload: Callable[
+        [ArrivalsGenerator, TopologyGraph, SimulationSettings,
+         list[EventInjection] | None],
+        SimulationPayload,
+    ],
+) -> None:
+    """Round-robin LB with events; check that KPIs are produced."""
+    arrivals = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=20.0,
+        model=Distribution.POISSON,
+    )
+    topo = topology_two_servers(service_time_s=0.001, edge_mean=0.002)
+    sim = SimulationSettings(total_simulation_time=5)
+
+    events = [
+        EventInjection(
+            event_id="spike",
+            target_id="client-to-lb",
+            start={
+                "kind": EventDescription.NETWORK_SPIKE_START,
+                "t_start": 0.20,
+                "spike_s": 0.02,
+            },
+            end={"kind": EventDescription.NETWORK_SPIKE_END, "t_end": 0.35},
+        ),
+        EventInjection(
+            event_id="outage-srv1",
+            target_id="srv-1",
+            start={"kind": EventDescription.SERVER_DOWN, "t_start": 0.40},
+            end={"kind": EventDescription.SERVER_UP, "t_end": 0.55},
+        ),
+    ]
+
+    payload = make_payload(arrivals, topo, sim, events)
+
+    runner = SimulationRunner(env=env, simulation_input=payload)
+    results: ResultsAnalyzer = runner.run()
+
+    stats = results.get_latency_stats()
+    assert stats
+    assert stats[LatencyKey.TOTAL_REQUESTS] > 0
+    ts, rps = results.get_throughput_series()
+    assert len(ts) == len(rps) > 0
diff --git a/tests/integration/event_injection/test_single_server.py b/tests/integration/event_injection/test_single_server.py
new file mode 100644
index 0000000..f397d26
--- /dev/null
+++ b/tests/integration/event_injection/test_single_server.py
@@ -0,0 +1,74 @@
+"""Integration test: single server with edge spike and server outage.
+
+Topology:
+  rqs-1 → client-1 → lb-1 → srv-1
+                      srv-1 → client-1
+
+Events:
+- NETWORK_SPIKE on 'client-to-lb' during a small window.
+- SERVER_DOWN/UP on 'srv-1' during a small window.
+
+Assertions focus on end-to-end KPIs; the fine-grained event sequencing is
+covered by unit tests in the event injection suite.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from asyncflow.config.enums import Distribution, EventDescription, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.events.injection import EventInjection
+from asyncflow.schemas.settings.simulation import SimulationSettings
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import simpy
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
+    from asyncflow.schemas.topology.graph import TopologyGraph
+
+
+
+def test_single_server_with_spike(
+    env: simpy.Environment,
+    topology_single_server: Callable[..., TopologyGraph],
+    make_payload: Callable[
+        [ArrivalsGenerator, TopologyGraph, SimulationSettings,
+         list[EventInjection] | None],
+        SimulationPayload,
+    ],
+) -> None:
+    """Run with both edge spike and server outage; verify KPIs exist."""
+    arrivals = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=20.0,
+        model=Distribution.POISSON,
+    )
+    topo = topology_single_server(service_time_s=0.001, edge_mean=0.002)
+    sim = SimulationSettings(total_simulation_time=5)
+
+    events = [
+        EventInjection(
+            event_id="spike",
+            target_id="client-to-lb",
+            start={
+                "kind": EventDescription.NETWORK_SPIKE_START,
+                "t_start": 0.2,
+                "spike_s": 0.01,
+            },
+            end={"kind": EventDescription.NETWORK_SPIKE_END, "t_end": 0.4},
+        ),
+    ]
+
+    payload = make_payload(arrivals, topo, sim, events)
+
+    runner = SimulationRunner(env=env, simulation_input=payload)
+    results: ResultsAnalyzer = runner.run()
+
+    stats = results.get_latency_stats()
+    assert stats
+    assert stats[LatencyKey.TOTAL_REQUESTS] > 0
diff --git a/tests/integration/load_balancer/test_lb_basic.py b/tests/integration/load_balancer/test_lb_basic.py
index 293f5ef..50062f8 100644
--- a/tests/integration/load_balancer/test_lb_basic.py
+++ b/tests/integration/load_balancer/test_lb_basic.py
@@ -15,100 +15,47 @@
 
 from typing import TYPE_CHECKING
 
-import simpy
-
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     Distribution,
-    EndpointStepCPU,
     LatencyKey,
     SampledMetricName,
-    StepOperation,
 )
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.payload import SimulationPayload
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
-from asyncflow.schemas.topology.endpoint import (
-    Endpoint,
-    Step,
-)
-from asyncflow.schemas.topology.graph import TopologyGraph
-from asyncflow.schemas.topology.nodes import (
-    Client,
-    LoadBalancer,
-    Server,
-    ServerResources,
-    TopologyNodes,
-)
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 if TYPE_CHECKING:
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
-
-
-def _server(server_id: str) -> Server:
-    """Minimal server with a single CPU-bound endpoint."""
-    ep = Endpoint(
-        endpoint_name="get",
-        steps=[
-            Step(
-                kind=EndpointStepCPU.CPU_BOUND_OPERATION,
-                step_operation={StepOperation.CPU_TIME: 0.001},
-            ),
-        ],
-    )
-    return Server(
-        id=server_id,
-        server_resources=ServerResources(),  # defaults are fine
-        endpoints=[ep],
-    )
+    from collections.abc import Callable
 
+    import simpy
 
-def _edge(eid: str, src: str, tgt: str, mean: float = 0.001) -> Edge:
-    """Low-latency edge to keep tests fast/deterministic enough."""
-    return Edge(
-        id=eid,
-        source=src,
-        target=tgt,
-        latency=RVConfig(mean=mean, distribution=Distribution.POISSON),
-    )
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
+    from asyncflow.schemas.topology.graph import TopologyGraph
 
 
-def test_lb_two_servers_end_to_end_smoke() -> None:
+def test_lb_two_servers_end_to_end_smoke(
+    env: simpy.Environment,
+    topology_two_servers: Callable[..., TopologyGraph],
+    make_payload: Callable[
+        [ArrivalsGenerator, TopologyGraph, SimulationSettings, None],
+        SimulationPayload,
+    ],
+) -> None:
     """Run end-to-end with LB and two servers; check basic KPIs exist."""
-    env = simpy.Environment()
-
-    # Stronger workload to avoid empty stats due to randomness:
-    # ~5 active users generating ~60 rpm each → ~5 rps expected.
-    rqs = RqsGenerator(
+    arrivals = ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users=RVConfig(mean=5.0),
-        avg_request_per_minute_per_user=RVConfig(mean=60.0),
-        user_sampling_window=5.0,
+        lambda_rps=20.0,
+        model=Distribution.POISSON,
     )
+
     # Horizon must be >= 5 (schema), use a bit more to accumulate samples.
     sim = SimulationSettings(total_simulation_time=8.0)
 
     # Topology: rqs→client→lb→srv{1,2} and back srv→client
-    client = Client(id="client-1")
-    lb = LoadBalancer(id="lb-1")
-
-    srv1 = _server("srv-1")
-    srv2 = _server("srv-2")
-
-    edges = [
-        _edge("gen-to-client", "rqs-1", "client-1"),
-        _edge("client-to-lb", "client-1", "lb-1"),
-        _edge("lb-to-srv1", "lb-1", "srv-1"),
-        _edge("lb-to-srv2", "lb-1", "srv-2"),
-        _edge("srv1-to-client", "srv-1", "client-1"),
-        _edge("srv2-to-client", "srv-2", "client-1"),
-    ]
-    nodes = TopologyNodes(servers=[srv1, srv2], client=client, load_balancer=lb)
-    topo = TopologyGraph(nodes=nodes, edges=edges)
-
-    payload = SimulationPayload(rqs_input=rqs, topology_graph=topo, sim_settings=sim)
+    topo = topology_two_servers(service_time_s=0.001, edge_mean=0.001)
+
+    payload = make_payload(arrivals, topo, sim, None)
 
     runner = SimulationRunner(env=env, simulation_input=payload)
     results: ResultsAnalyzer = runner.run()
diff --git a/tests/integration/minimal/conftest.py b/tests/integration/minimal/conftest.py
deleted file mode 100644
index f29bf49..0000000
--- a/tests/integration/minimal/conftest.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""
-Local fixtures for the *minimal* integration scenario.
-
-We **do not** add any Edge to the TopologyGraph because the core schema
-forbids generator-origin edges. Instead we patch the single
-`RqsGeneratorRuntime` after the `SimulationRunner` is built, giving it a
-*no-op* EdgeRuntime so its internal assertion passes.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import pytest
-import simpy
-
-from asyncflow.config.constants import TimeDefaults
-from asyncflow.runtime.simulation_runner import SimulationRunner
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-if TYPE_CHECKING:
-    from asyncflow.schemas.payload import SimulationPayload
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# 0-traffic generator (shadows the project-wide fixture)
-# ──────────────────────────────────────────────────────────────────────────────
-@pytest.fixture(scope="session")
-def rqs_input() -> RqsGenerator:
-    """A generator that never emits any request."""
-    return RqsGenerator(
-        id="rqs-zero",
-        avg_active_users=RVConfig(mean=0.0),
-        avg_request_per_minute_per_user=RVConfig(mean=0.0),
-        user_sampling_window=TimeDefaults.USER_SAMPLING_WINDOW,
-    )
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# SimPy env - local to this directory
-# ──────────────────────────────────────────────────────────────────────────────
-@pytest.fixture
-def env() -> simpy.Environment:
-    """Fresh environment per test module."""
-    return simpy.Environment()
-
-
-class _NoOpEdge:
-    """EdgeRuntime stand-in that simply discards every state."""
-
-    def transport(self, _state: object) -> None:  # ANN001: _state annotated
-        return  # swallow the request silently
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Runner factory - assigns the dummy edge *after* building the runner
-# ──────────────────────────────────────────────────────────────────────────────
-@pytest.fixture
-def runner(
-    env: simpy.Environment,
-    payload_base: SimulationPayload,
-) -> SimulationRunner:
-    """Build a `SimulationRunner` and patch the generator's `out_edge`."""
-    sim_runner = SimulationRunner(env=env, simulation_input=payload_base)
-
-    def _patch_noop_edge(r: SimulationRunner) -> None:
-
-        gen_rt = next(iter(r._rqs_runtime.values()))  # noqa: SLF001
-        gen_rt.out_edge = _NoOpEdge()  # type: ignore[assignment]
-
-
-    sim_runner._patch_noop_edge = _patch_noop_edge  # type: ignore[attr-defined] # noqa: SLF001
-
-    return sim_runner
diff --git a/tests/integration/minimal/test_minimal.py b/tests/integration/minimal/test_minimal.py
index 7ae9507..6c78651 100644
--- a/tests/integration/minimal/test_minimal.py
+++ b/tests/integration/minimal/test_minimal.py
@@ -7,7 +7,7 @@
 generator ──Ø── client          (Ø == no real EdgeRuntime)
 
 The request-generator cannot emit messages because its ``out_edge`` is
-replaced by a no-op stub.  The client is patched the same way so its own
+replaced by a no-op stub. The client is patched the same way so its own
 forwarder never attempts a network send.
 """
 
@@ -16,45 +16,39 @@
 from typing import TYPE_CHECKING
 
 import pytest
-import simpy
 
-from asyncflow.metrics.analyzer import ResultsAnalyzer
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+from asyncflow.runner.simulation import SimulationRunner
 
 if TYPE_CHECKING:
+    import simpy
+
     from asyncflow.schemas.payload import SimulationPayload
 
 
 # --------------------------------------------------------------------------- #
 # Helpers                                                                     #
 # --------------------------------------------------------------------------- #
-
 class _NoOpEdge:
     """Edge stub: swallows every transport call."""
 
-    def transport(self) -> None:
-        # Nothing to do - we just black-hole the message.
+    def transport(self, *_: object, **__: object) -> None:
+        # Nothing to do — black-hole the message.
         return
 
 
+
 # --------------------------------------------------------------------------- #
-# Local fixtures                                                              #
+# Local fixtures (use global env from shared conftest)                        #
 # --------------------------------------------------------------------------- #
-@pytest.fixture
-def env() -> simpy.Environment:
-    """Fresh SimPy environment for this test file."""
-    return simpy.Environment()
-
-
 @pytest.fixture
 def runner(
     env: simpy.Environment,
-    payload_base: SimulationPayload,  # comes from project-wide conftest
+    payload_base: SimulationPayload,  # provided by project-wide conftest
 ) -> SimulationRunner:
-    """SimulationRunner already loaded with *minimal* payload."""
+    """SimulationRunner already loaded with a *minimal* payload."""
     return SimulationRunner(env=env, simulation_input=payload_base)
 
-
 # --------------------------------------------------------------------------- #
 # Tests                                                                       #
 # --------------------------------------------------------------------------- #
@@ -66,35 +60,38 @@ def test_smoke_minimal_runs(runner: SimulationRunner) -> None:
     * execute its clock,
     * leave all metric collections empty.
     """
-    # ── 1. Build generator + patch its edge ──────────────────────────────
-    runner._build_rqs_generator()  # noqa: SLF001 - private builder ok in test
-    gen_rt = next(iter(runner._rqs_runtime.values()))  # noqa: SLF001
+    # ── 1) Build generator + patch its edge ──────────────────────────────
+    runner._build_rqs_generator()  # noqa: SLF001 - private builder OK in tests
+    gen_rt = next(iter(runner._arrivals_runtime.values()))  # noqa: SLF001
     gen_rt.out_edge = _NoOpEdge()  # type: ignore[assignment]
 
-    # ── 2. Build client + patch its edge ─────────────────────────────────
+    # ── 2) Build client + patch its edge ─────────────────────────────────
     runner._build_client()  # noqa: SLF001
     cli_rt = next(iter(runner._client_runtime.values()))  # noqa: SLF001
     cli_rt.out_edge = _NoOpEdge()  # type: ignore[assignment]
 
-    # ── 3. Build remaining artefacts (no servers / no LB present) ───────
+    # ── 3) Start processes (no servers / no LB present) ──────────────────
     runner._start_all_processes()  # noqa: SLF001
-    runner._start_metric_collector() # noqa: SLF001
+    runner._start_metric_collector()  # noqa: SLF001
 
-    # ── 4. Run the clock ─────────────────────────────────────────────────
+    # ── 4) Run the clock ─────────────────────────────────────────────────
     runner.env.run(until=runner.simulation_settings.total_simulation_time)
 
-    # ── 5. Post-processing - everything must be empty ───────────────────
+    # ── 5) Post-processing — everything must be empty ────────────────────
     results: ResultsAnalyzer = ResultsAnalyzer(
         client=cli_rt,
-        servers=[],          # none built
-        edges=[],            # none built
+        servers=[],  # none built
+        edges=[],  # none built
         settings=runner.simulation_settings,
     )
 
     # No latencies were produced
     assert results.get_latency_stats() == {}
+
     # Throughput time-series must be entirely empty
     timestamps, rps = results.get_throughput_series()
     assert timestamps == []
+    assert rps == []
+
     # No sampled metrics either
     assert results.get_sampled_metrics() == {}
diff --git a/tests/integration/payload/data/invalid/missing_field.yml b/tests/integration/payload/data/invalid/missing_field.yml
deleted file mode 100644
index c74102d..0000000
--- a/tests/integration/payload/data/invalid/missing_field.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-rqs_input:
-  id: gen-1
-  avg_active_users: { mean: 1 }
-  avg_request_per_minute_per_user: { mean: 10 }
-
-topology_graph:
-  nodes:
-    client: { id: cli }
-    servers:
-      - id: srv-1              
-        endpoints:
-          - endpoint_name: ep
-            steps:
-              - { kind: cpu_parse, step_operation: { cpu_time: 0.001 } }
-
-  edges: []
-sim_settings: { total_simulation_time: 10 }
diff --git a/tests/integration/payload/data/invalid/negative_latency.yml b/tests/integration/payload/data/invalid/negative_latency.yml
deleted file mode 100644
index f69fb60..0000000
--- a/tests/integration/payload/data/invalid/negative_latency.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-rqs_input:
-  id: gen-1
-  avg_active_users: { mean: 1 }
-  avg_request_per_minute_per_user: { mean: 10 }
-
-topology_graph:
-  nodes:
-    client: { id: cli }
-    servers: []
-  edges:
-    - id: bad-lat
-      source: gen-1
-      target: cli
-      latency: { mean: -0.001 }   
-sim_settings: { total_simulation_time: 5 }
diff --git a/tests/integration/payload/data/invalid/wrong_enum.yml b/tests/integration/payload/data/invalid/wrong_enum.yml
deleted file mode 100644
index 58a1c50..0000000
--- a/tests/integration/payload/data/invalid/wrong_enum.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-rqs_input:
-  id: gen-1
-  avg_active_users: { mean: 1 }
-  avg_request_per_minute_per_user:
-    mean: 10
-    distribution: gamma   # not valid enum
-
-topology_graph:
-  nodes:
-    client: { id: cli }
-    servers: []
-  edges: []
-sim_settings: { total_simulation_time: 5 }
diff --git a/tests/integration/payload/test_payload_invalid.py b/tests/integration/payload/test_payload_invalid.py
deleted file mode 100644
index 8cd5226..0000000
--- a/tests/integration/payload/test_payload_invalid.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""test to verify validation on invalid yml"""
-
-from pathlib import Path
-
-import pytest
-import yaml
-from pydantic import ValidationError
-
-from asyncflow.schemas.payload import SimulationPayload
-
-DATA_DIR = Path(__file__).parent / "data" / "invalid"
-YMLS = sorted(DATA_DIR.glob("*.yml"))
-
-@pytest.mark.integration
-@pytest.mark.parametrize("yaml_path", YMLS, ids=lambda p: p.stem)
-def test_invalid_payloads_raise(yaml_path: Path)  -> None :
-    raw = yaml.safe_load(yaml_path.read_text())
-    with pytest.raises(ValidationError):
-        SimulationPayload.model_validate(raw)
diff --git a/tests/integration/single_server/conftest.py b/tests/integration/single_server/conftest.py
deleted file mode 100644
index f45633a..0000000
--- a/tests/integration/single_server/conftest.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""
-Fixtures for the *single-server* integration scenario:
-
-generator ──edge──> server ──edge──> client
-
-The topology is stored as a YAML file (`tests/data/single_server.yml`) so
-tests remain declarative and we avoid duplicating Pydantic wiring logic.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import pytest
-import simpy
-
-if TYPE_CHECKING:  # heavy imports only when type-checking
-    from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-# --------------------------------------------------------------------------- #
-# Shared SimPy environment (function-scope so every test starts fresh)        #
-# --------------------------------------------------------------------------- #
-@pytest.fixture
-def env() -> simpy.Environment:
-    """Return an empty ``simpy.Environment`` for each test."""
-    return simpy.Environment()
-
-
-# --------------------------------------------------------------------------- #
-# Build a SimulationRunner from the YAML scenario                             #
-# --------------------------------------------------------------------------- #
-@pytest.fixture
-def runner(env: simpy.Environment) -> SimulationRunner:
-    """
-    Load *single_server.yml* through the public constructor
-    :pymeth:`SimulationRunner.from_yaml`.
-    """
-    # import deferred to avoid ruff TC001
-    from asyncflow.runtime.simulation_runner import SimulationRunner  # noqa: PLC0415
-
-    yaml_path: Path = (
-        Path(__file__).parent / "data" / "single_server.yml"
-    )
-
-    return SimulationRunner.from_yaml(env=env, yaml_path=yaml_path)
diff --git a/tests/integration/single_server/data/single_server.yml b/tests/integration/single_server/data/single_server.yml
deleted file mode 100644
index c6ec078..0000000
--- a/tests/integration/single_server/data/single_server.yml
+++ /dev/null
@@ -1,54 +0,0 @@
-# ───────────────────────────────────────────────────────────────
-# AsyncFlow scenario: generator ➜ client ➜ server ➜ client
-# ───────────────────────────────────────────────────────────────
-
-# 1. Traffic generator (light load)
-rqs_input:
-  id: rqs-1
-  avg_active_users: { mean: 5 }
-  avg_request_per_minute_per_user: { mean: 40 }
-  user_sampling_window: 60
-
-# 2. Topology
-topology_graph:
-  nodes:
-    client: { id: client-1 }
-    servers:
-      - id: srv-1
-        server_resources: { cpu_cores: 2, ram_mb: 2048 }
-        endpoints:
-          - endpoint_name: ep-1
-            probability: 1.0
-            steps:
-              - kind: initial_parsing
-                step_operation: { cpu_time: 0.001 }
-              - kind: io_wait
-                step_operation: { io_waiting_time: 0.002 }
-
-  edges:
-    - id: gen-to-client
-      source: rqs-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: client-to-server
-      source: client-1
-      target: srv-1
-      latency: { mean: 0.003, distribution: exponential }
-
-    - id: server-to-client
-      source: srv-1
-      target: client-1
-      latency: { mean: 0.003, distribution: exponential }
-
-# 3. Simulation settings
-sim_settings:
-  total_simulation_time: 50
-  sample_period_s: 0.01
-  enabled_sample_metrics:
-    - ready_queue_len
-    - event_loop_io_sleep
-    - ram_in_use
-    - edge_concurrent_connection
-  enabled_event_metrics:
-    - rqs_clock
diff --git a/tests/integration/single_server/test_int_single_server.py b/tests/integration/single_server/test_int_single_server.py
deleted file mode 100644
index efb1ef9..0000000
--- a/tests/integration/single_server/test_int_single_server.py
+++ /dev/null
@@ -1,63 +0,0 @@
-"""
-End-to-end verification of a *functional* topology (1 generator, 1 server).
-
-Assertions cover:
-
-* non-zero latency stats,
-* throughput series length > 0,
-* presence of sampled metrics for both edge & server.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import numpy as np
-import pytest
-
-from asyncflow.config.constants import LatencyKey, SampledMetricName
-
-if TYPE_CHECKING:  # only needed for type-checking
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
-    from asyncflow.runtime.simulation_runner import SimulationRunner
-
-
-# --------------------------------------------------------------------------- #
-# Tests                                                                       #
-# --------------------------------------------------------------------------- #
-@pytest.mark.integration
-def test_single_server_happy_path(runner: SimulationRunner) -> None:
-    """Run the simulation and ensure that *something* was processed.
-
-    Make the test deterministic and sufficiently loaded so at least one request
-    is generated and measured.
-    """
-    # Deterministic RNG for the whole runner
-    runner.rng = np.random.default_rng(0)
-
-    # Increase horizon and load to avoid zero-request realizations
-    runner.simulation_settings.total_simulation_time = 30
-    runner.rqs_generator.avg_active_users.mean = 5.0
-    runner.rqs_generator.avg_request_per_minute_per_user.mean = 30.0
-
-    results: ResultsAnalyzer = runner.run()
-
-    # ── Latency stats must exist ───────────────────────────────────────────
-    stats = results.get_latency_stats()
-    assert stats, "Expected non-empty latency statistics."
-    assert stats[LatencyKey.TOTAL_REQUESTS] > 0
-    assert stats[LatencyKey.MEAN] > 0.0
-
-    # ── Throughput series must have at least one bucket > 0 ───────────────
-    ts, rps = results.get_throughput_series()
-    assert len(ts) == len(rps) > 0
-    assert any(val > 0 for val in rps)
-
-    # ── Sampled metrics must include *one* server and *one* edge ───────────
-    sampled = results.get_sampled_metrics()
-
-    assert SampledMetricName.RAM_IN_USE in sampled
-    assert sampled[SampledMetricName.RAM_IN_USE], "Server RAM time-series missing."
-
-    assert SampledMetricName.EDGE_CONCURRENT_CONNECTION in sampled
-
diff --git a/tests/system/test_sys_ev_inj_lb_two_servers.py b/tests/system/test_sys_ev_inj_lb_two_servers.py
index 15e978b..4be2cf6 100644
--- a/tests/system/test_sys_ev_inj_lb_two_servers.py
+++ b/tests/system/test_sys_ev_inj_lb_two_servers.py
@@ -31,14 +31,14 @@
 import simpy
 
 from asyncflow import AsyncFlow
-from asyncflow.components import Client, Edge, Endpoint, LoadBalancer, Server
-from asyncflow.config.constants import LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.components import Client, Endpoint, LoadBalancer, NetworkEdge, Server
+from asyncflow.config.enums import Distribution, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
 
 if TYPE_CHECKING:
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
     from asyncflow.schemas.payload import SimulationPayload
 
 pytestmark = [
@@ -68,11 +68,10 @@ def _seed_all(seed: int = SEED) -> None:
 def _build_payload(*, with_events: bool) -> SimulationPayload:
     """Build payload for client + LB + two servers; optionally add events."""
     # Workload: ~26.7 rps (80 users * 20 rpm / 60).
-    gen = RqsGenerator(
+    gen = ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users={"mean": 80},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
+        lambda_rps=20,
+        model=Distribution.POISSON,
     )
     client = Client(id="client-1")
     lb = LoadBalancer(id="lb-1", algorithm="round_robin")
@@ -99,37 +98,37 @@ def _build_payload(*, with_events: bool) -> SimulationPayload:
 
     # Edges: generator→client, client→lb, lb→srv-{1,2}, srv-{1,2}→client.
     edges = [
-        Edge(
+        NetworkEdge(
             id="gen-client",
             source="rqs-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="client-lb",
             source="client-1",
             target="lb-1",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="lb-srv-1",
             source="lb-1",
             target="srv-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="lb-srv-2",
             source="lb-1",
             target="srv-2",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv1-client",
             source="srv-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv2-client",
             source="srv-2",
             target="client-1",
@@ -151,7 +150,7 @@ def _build_payload(*, with_events: bool) -> SimulationPayload:
 
     flow = (
         AsyncFlow()
-        .add_generator(gen)
+        .add_arrivals_generator(gen)
         .add_client(client)
         .add_load_balancer(lb)
         .add_servers(srv1, srv2)
diff --git a/tests/system/test_sys_ev_inj_single_server.py b/tests/system/test_sys_ev_inj_single_server.py
index e1132c3..655ebe6 100644
--- a/tests/system/test_sys_ev_inj_single_server.py
+++ b/tests/system/test_sys_ev_inj_single_server.py
@@ -34,14 +34,14 @@
 import simpy
 
 from asyncflow import AsyncFlow
-from asyncflow.components import Client, Edge, Endpoint, Server
-from asyncflow.config.constants import LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.components import Client, Endpoint, NetworkEdge, Server
+from asyncflow.config.enums import Distribution, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
 
 if TYPE_CHECKING:
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
     from asyncflow.schemas.payload import SimulationPayload
 
 pytestmark = [
@@ -69,11 +69,10 @@ def _seed_all(seed: int = SEED) -> None:
 def _build_payload(*, with_spike: bool) -> SimulationPayload:
     """Build a single-server payload; optionally inject an edge spike."""
     # Workload: ~26.7 rps (80 users * 20 rpm / 60).
-    gen = RqsGenerator(
+    gen = ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users={"mean": 80},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
+        lambda_rps=20,
+        model=Distribution.POISSON,
     )
     client = Client(id="client-1")
 
@@ -93,19 +92,19 @@ def _build_payload(*, with_spike: bool) -> SimulationPayload:
 
     # Edges: baseline exponential latencies around a few milliseconds.
     edges = [
-        Edge(
+        NetworkEdge(
             id="gen-client",
             source="rqs-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="client-srv",
             source="client-1",
             target="srv-1",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv-client",
             source="srv-1",
             target="client-1",
@@ -128,7 +127,7 @@ def _build_payload(*, with_spike: bool) -> SimulationPayload:
 
     flow = (
         AsyncFlow()
-        .add_generator(gen)
+        .add_arrivals_generator(gen)
         .add_client(client)
         .add_servers(srv)
         .add_edges(*edges)
diff --git a/tests/system/test_sys_lb_two_servers.py b/tests/system/test_sys_lb_two_servers.py
index b273065..8eb705d 100644
--- a/tests/system/test_sys_lb_two_servers.py
+++ b/tests/system/test_sys_lb_two_servers.py
@@ -25,15 +25,15 @@
 import simpy
 
 from asyncflow import AsyncFlow
-from asyncflow.components import Client, Edge, Endpoint, LoadBalancer, Server
-from asyncflow.config.constants import LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.components import Client, Endpoint, LoadBalancer, NetworkEdge, Server
+from asyncflow.config.enums import Distribution, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
 
 if TYPE_CHECKING:
     # Imported only for type checking (ruff: TC001)
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
     from asyncflow.schemas.payload import SimulationPayload
 
 pytestmark = [
@@ -56,11 +56,10 @@ def _seed_all(seed: int = SEED) -> None:
 
 
 def _build_payload() -> SimulationPayload:
-    gen = RqsGenerator(
+    gen = ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users={"mean": 120},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
+        lambda_rps=20,
+        model=Distribution.POISSON,
     )
     client = Client(id="client-1")
 
@@ -90,37 +89,37 @@ def _build_payload() -> SimulationPayload:
     )
 
     edges = [
-        Edge(
+        NetworkEdge(
             id="gen-client",
             source="rqs-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="client-lb",
             source="client-1",
             target="lb-1",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="lb-srv1",
             source="lb-1",
             target="srv-1",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="lb-srv2",
             source="lb-1",
             target="srv-2",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv1-client",
             source="srv-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv2-client",
             source="srv-2",
             target="client-1",
@@ -142,7 +141,7 @@ def _build_payload() -> SimulationPayload:
 
     flow = (
         AsyncFlow()
-        .add_generator(gen)
+        .add_arrivals_generator(gen)
         .add_client(client)
         .add_load_balancer(lb)
         .add_servers(srv1, srv2)
@@ -172,11 +171,11 @@ def test_system_lb_two_servers_balanced_and_sane() -> None:
     mean_lat = float(stats.get(LatencyKey.MEAN, 0.0))
     assert 0.020 <= mean_lat <= 0.060
 
-    # Throughput sanity vs nominal λ ≈ 40 rps
+    # Throughput sanity vs nominal λ ≈ 20 rps
     _, rps = res.get_throughput_series()
     assert rps, "No throughput series produced."
     rps_mean = float(np.mean(rps))
-    lam = 120 * 20 / 60.0
+    lam = 20
     assert abs(rps_mean - lam) / lam <= REL_TOL
 
     # Load balance check: edge concurrency lb→srv1 vs lb→srv2 close
diff --git a/tests/system/test_sys_single_server.py b/tests/system/test_sys_single_server.py
index ff2cd32..9b4c081 100644
--- a/tests/system/test_sys_single_server.py
+++ b/tests/system/test_sys_single_server.py
@@ -24,15 +24,15 @@
 import simpy
 
 from asyncflow import AsyncFlow
-from asyncflow.components import Client, Edge, Endpoint, Server
-from asyncflow.config.constants import LatencyKey
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.components import Client, Endpoint, NetworkEdge, Server
+from asyncflow.config.enums import Distribution, LatencyKey
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator
 
 if TYPE_CHECKING:
     # Imported only for type checking (ruff: TC001)
-    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
     from asyncflow.schemas.payload import SimulationPayload
 
 pytestmark = [
@@ -55,11 +55,10 @@ def _seed_all(seed: int = SEED) -> None:
 
 def _build_payload() -> SimulationPayload:
     # Workload: ~26.7 rps (80 users * 20 rpm / 60)
-    gen = RqsGenerator(
+    gen = ArrivalsGenerator(
         id="rqs-1",
-        avg_active_users={"mean": 80},
-        avg_request_per_minute_per_user={"mean": 20},
-        user_sampling_window=60,
+        lambda_rps=20,
+        model=Distribution.POISSON,
     )
     client = Client(id="client-1")
 
@@ -78,19 +77,19 @@ def _build_payload() -> SimulationPayload:
     )
 
     edges = [
-        Edge(
+        NetworkEdge(
             id="gen-client",
             source="rqs-1",
             target="client-1",
             latency={"mean": 0.003, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="client-srv",
             source="client-1",
             target="srv-1",
             latency={"mean": 0.002, "distribution": "exponential"},
         ),
-        Edge(
+        NetworkEdge(
             id="srv-client",
             source="srv-1",
             target="client-1",
@@ -112,7 +111,7 @@ def _build_payload() -> SimulationPayload:
 
     flow = (
         AsyncFlow()
-        .add_generator(gen)
+        .add_arrivals_generator(gen)
         .add_client(client)
         .add_servers(srv)
         .add_edges(*edges)
@@ -140,7 +139,7 @@ def test_system_single_server_sane() -> None:
     _, rps = res.get_throughput_series()
     assert rps, "No throughput series produced."
     rps_mean = float(np.mean(rps))
-    lam = 80 * 20 / 60.0
+    lam = 20
     assert abs(rps_mean - lam) / lam <= REL_TOL
 
     # Sampled metrics present for srv-1
diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py
index e0310a0..c75472e 100644
--- a/tests/unit/__init__.py
+++ b/tests/unit/__init__.py
@@ -1 +1 @@
-"""Unit tests."""
+"""package to ensure smooth import"""
diff --git a/tests/unit/helpers.py b/tests/unit/helpers.py
new file mode 100644
index 0000000..6af5d5e
--- /dev/null
+++ b/tests/unit/helpers.py
@@ -0,0 +1,14 @@
+from asyncflow.config.enums import EndpointStepCPU, StepOperation
+from asyncflow.schemas.topology.endpoint import Endpoint, Step
+
+
+def make_min_ep(ep_id: str = "ep-1", cpu_time: float = 0.1) -> Endpoint:
+    return Endpoint(
+        endpoint_name=ep_id,
+        steps=[
+            Step(
+                kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+                step_operation={StepOperation.CPU_TIME: cpu_time},
+            ),
+        ],
+    )
diff --git a/tests/unit/metrics/test_analyzer.py b/tests/unit/metrics/test_simulation_analyzer.py
similarity index 65%
rename from tests/unit/metrics/test_analyzer.py
rename to tests/unit/metrics/test_simulation_analyzer.py
index 901b646..4d727eb 100644
--- a/tests/unit/metrics/test_analyzer.py
+++ b/tests/unit/metrics/test_simulation_analyzer.py
@@ -19,7 +19,9 @@
 from matplotlib.figure import Figure
 
 from asyncflow.analysis import ResultsAnalyzer
+from asyncflow.config.enums import EventMetricName
 from asyncflow.enums import SampledMetricName
+from asyncflow.metrics.server import ServerClock
 
 if TYPE_CHECKING:
     from asyncflow.runtime.actors.client import ClientRuntime
@@ -73,6 +75,9 @@ def __init__(self, identifier: str, metrics: dict[str, list[float]]) -> None:
         self.enabled_metrics = {
             DummyName(name): values for name, values in metrics.items()
         }
+        self.server_rqs_clock: dict[
+            int,
+            dict[EventMetricName, float | ServerClock]] = {}
 
 
 class DummyEdgeConfig:
@@ -288,3 +293,145 @@ def test_plot_single_server_ram(
     assert any(lbl.lower().startswith("max") for lbl in labels)
     assert len(labels) == 3
 
+# ---------------------------------------------------------------
+# Test server event metric
+# ---------------------------------------------------------------
+
+def _mk_bucket(
+    st: float, io: float, wt: float, start: float, finish: float,
+) -> dict[EventMetricName, float | ServerClock]:
+    """Helper to build one metric bucket like the real server does."""
+    return {
+        EventMetricName.SERVICE_TIME: st,
+        EventMetricName.IO_TIME: io,
+        EventMetricName.WAITING_TIME: wt,
+        EventMetricName.RQS_SERVER_CLOCK: ServerClock(start=start, finish=finish),
+    }
+
+
+def test_get_server_event_arrays_extracts_fields(
+    sim_settings: SimulationSettings) -> None:
+    """Analyzer should extract per-request arrays for a server from its buckets."""
+    sim_settings.total_simulation_time = 2
+    sim_settings.sample_period_s = 0.5
+
+    client = DummyClient([])
+
+    srv = DummyServer("srvA", {
+        "ready_queue_len": [0, 0],
+        "event_loop_io_sleep": [0, 1],
+        "ram_in_use": [128.0, 256.0],
+    })
+    # Populate per-request buckets (two requests)
+    srv.server_rqs_clock = {
+        1: _mk_bucket(0.004, 0.010, 0.001, 0.100, 0.115),  # latency 0.015
+        2: _mk_bucket(0.006, 0.020, 0.000, 0.300, 0.326),  # latency 0.026
+    }
+
+    an = ResultsAnalyzer(
+        client=cast("ClientRuntime", client),
+        servers=[cast("ServerRuntime", srv)],
+        edges=[],
+        settings=sim_settings,
+    )
+
+    arrays = an.get_server_event_arrays()
+    assert "srvA" in arrays
+    a = arrays["srvA"]
+
+    # Order of buckets is not relevant; compare sorted values
+    assert sorted(a["service_time"]) == [0.004, 0.006]
+    assert sorted(a["io_time"]) == [0.010, 0.020]
+    assert sorted(a["waiting_time"]) == [0.000, 0.001]
+    assert pytest.approx(sorted(a["latencies"])) == sorted([0.015, 0.026])
+    assert pytest.approx(sorted(a["finish_times"])) == sorted([0.115, 0.326])
+
+
+def test_get_server_throughput_series_per_server(
+    sim_settings: SimulationSettings) -> None:
+    """Throughput per-server should count completions within each fixed window."""
+    sim_settings.total_simulation_time = 3
+    sim_settings.sample_period_s = 0.5
+    client = DummyClient([])
+
+    srv = DummyServer("srvT", {})
+    # Three completions at 0.8s, 1.2s, 2.6s
+    srv.server_rqs_clock = {
+        10: _mk_bucket(0.001, 0.002, 0.000, 0.00, 0.80),
+        11: _mk_bucket(0.001, 0.002, 0.000, 0.90, 1.20),
+        12: _mk_bucket(0.001, 0.002, 0.000, 2.30, 2.60),
+    }
+
+    an = ResultsAnalyzer(
+        client=cast("ClientRuntime", client),
+        servers=[cast("ServerRuntime", srv)],
+        edges=[],
+        settings=sim_settings,
+    )
+
+    # 1s windows → boundaries at 1.0, 2.0, 3.0 → counts [1,1,1]
+    ts1, rps1 = an.get_server_throughput_series("srvT", window_s=1.0)
+    assert ts1 == [1.0, 2.0, 3.0]
+    assert rps1 == [1.0, 1.0, 1.0]
+
+    # 0.5s windows → boundaries 0.5,1.0,1.5,2.0,2.5,3.0
+    # counts per window [0,1,1,0,0,1] → rates [0,2,2,0,0,2]
+    ts2, rps2 = an.get_server_throughput_series("srvT", window_s=0.5)
+    assert ts2[:6] == [0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
+    assert rps2[:6] == [0.0, 2.0, 2.0, 0.0, 0.0, 2.0]
+
+
+def test_plot_server_event_metrics_dashboard_smoke_and_legends(
+    sim_settings: SimulationSettings,
+) -> None:
+    """Dashboard (latency/service/io/wait) should set titles and show a legend."""
+    sim_settings.total_simulation_time = 1
+    client = DummyClient([])
+
+    srv = DummyServer("srvZ", {})
+    srv.server_rqs_clock = {
+        1: _mk_bucket(0.003, 0.012, 0.000, 0.10, 0.115),
+        2: _mk_bucket(0.007, 0.018, 0.002, 0.20, 0.230),
+        3: _mk_bucket(0.005, 0.010, 0.001, 0.30, 0.315),
+    }
+
+    an = ResultsAnalyzer(
+        client=cast("ClientRuntime", client),
+        servers=[cast("ServerRuntime", srv)],
+        edges=[],
+        settings=sim_settings,
+    )
+
+    fig = Figure()
+    ax_lat, ax_svc, ax_io, ax_wait = fig.subplots(2, 2).ravel()
+    an.plot_server_event_metrics_dashboard(ax_lat, ax_svc, ax_io, ax_wait, "srvZ")
+
+    # Titles contain expected labels
+    assert "Server latency — srvZ" in ax_lat.get_title()
+    assert "CPU service time — srvZ" in ax_svc.get_title()
+    assert "I/O time — srvZ" in ax_io.get_title()
+    assert "CPU waiting time — srvZ" in ax_wait.get_title()
+
+    # Legends exist and contain at least 'mean' (and 'P50' on latency pane)
+    for ax in (ax_lat, ax_svc, ax_io, ax_wait):
+        lg = ax.get_legend()
+        assert lg is not None
+        labels = [t.get_text().lower() for t in lg.get_texts()]
+        assert any(lbl.startswith("mean") for lbl in labels)
+    # Latency pane also shows P50
+    lat_labels = [t.get_text() for t in ax_lat.get_legend().get_texts()]
+    assert any("P50" in s for s in lat_labels)
+
+
+def test_plot_server_timeseries_dashboard_sets_titles(
+    analyzer_with_metrics: ResultsAnalyzer,
+) -> None:
+    """Time-series dashboard for a server wires the three single-plot helpers."""
+    fig = Figure()
+    ax_ready, ax_io, ax_ram = fig.subplots(1, 3)
+    analyzer_with_metrics.plot_server_timeseries_dashboard(
+        ax_ready, ax_io, ax_ram, "srvX")
+
+    assert "Ready Queue" in ax_ready.get_title()
+    assert "I/O Queue" in ax_io.get_title()
+    assert "RAM" in ax_ram.get_title()
diff --git a/tests/unit/metrics/test_sweep_analyzer.py b/tests/unit/metrics/test_sweep_analyzer.py
new file mode 100644
index 0000000..c597351
--- /dev/null
+++ b/tests/unit/metrics/test_sweep_analyzer.py
@@ -0,0 +1,261 @@
+"""Unit tests for SweepAnalyzer (global and per-server collections & plots)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import pytest
+
+from asyncflow.config.enums import LatencyKey
+from asyncflow.metrics.sweep_analyzer import SweepAnalyzer
+
+# Headless backend for CI
+mpl.use("Agg")
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+
+
+# ---------------------------------------------------------------------------
+# Fakes
+# ---------------------------------------------------------------------------
+
+
+class _FakeResultsAnalyzer:
+    """Minimal fake of ResultsAnalyzer for SweepAnalyzer tests."""
+
+    def __init__(
+        self,
+        *,
+        rps_series: list[float],
+        latency_stats: dict[LatencyKey, float],
+        server_ids: list[str],
+        server_arrays: dict[str, dict[str, list[float]]],
+    ) -> None:
+        self._rps_series = list(rps_series)
+        self._latency_stats = dict(latency_stats)
+        self._server_ids = list(server_ids)
+        self._server_arrays = {
+            sid: {k: list(v) for k, v in arrays.items()}
+            for sid, arrays in server_arrays.items()
+        }
+        self.process_calls = 0
+
+    # Public API mirrored from the real analyzer
+
+    def process_all_metrics(self) -> None:
+        self.process_calls += 1
+
+    def get_throughput_series(self) -> tuple[list[float], list[float]]:
+        """Return (timestamps, rps). We only care about the RPS values."""
+        n = len(self._rps_series)
+        timestamps = [float(i + 1) for i in range(n)]
+        return timestamps, list(self._rps_series)
+
+    def get_latency_stats(self) -> dict[LatencyKey, float]:
+        return dict(self._latency_stats)
+
+    def list_server_ids(self) -> list[str]:
+        return list(self._server_ids)
+
+    def get_server_event_arrays(self) -> dict[str, dict[str, list[float]]]:
+        return {
+            sid: {k: list(v) for k, v in arrays.items()}
+            for sid, arrays in self._server_arrays.items()
+        }
+
+
+def _cast_pair(
+    users: int,
+    fra: _FakeResultsAnalyzer,
+) -> tuple[int, ResultsAnalyzer]:
+    """Cast helper to satisfy mypy on constructor signature."""
+    return users, cast("ResultsAnalyzer", fra)
+
+
+# ---------------------------------------------------------------------------
+# Tests — Global collection and plots
+# ---------------------------------------------------------------------------
+
+
+def test_global_collection_and_plots_match_expected_values() -> None:
+    """Global throughput mean and mean latency must match the inputs."""
+    # Pair 1: mean RPS = 100, mean latency = 0.05
+    ra1 = _FakeResultsAnalyzer(
+        rps_series=[100.0, 110.0, 90.0],
+        latency_stats={
+            LatencyKey.MEAN: 0.05,
+            LatencyKey.MEDIAN: 0.04,
+            LatencyKey.P95: 0.10,
+            LatencyKey.P99: 0.20,
+        },
+        server_ids=["s1"],
+        server_arrays={
+            "s1": {
+                "service_time": [0.01],
+                "waiting_time": [0.005],
+                "finish_times": [0.1, 0.2],
+            },
+        },
+    )
+
+    # Pair 2: mean RPS = 200, mean latency = 0.06
+    ra2 = _FakeResultsAnalyzer(
+        rps_series=[200.0, 190.0, 210.0],
+        latency_stats={
+            LatencyKey.MEAN: 0.06,
+            LatencyKey.MEDIAN: 0.05,
+            LatencyKey.P95: 0.12,
+            LatencyKey.P99: 0.22,
+        },
+        server_ids=["s1"],
+        server_arrays={
+            "s1": {
+                "service_time": [0.01],
+                "waiting_time": [0.004],
+                "finish_times": [0.3, 0.4],
+            },
+        },
+    )
+
+    sa = SweepAnalyzer(
+        [_cast_pair(10, ra1), _cast_pair(20, ra2)],
+    )
+
+    # Global dashboard and line data
+    fig = sa.plot_global_dashboard()
+    axes = fig.get_axes()
+    assert len(axes) == 2
+
+    # Throughput axis
+    thr_line = axes[0].lines[0]
+    x_thr = list(cast("Iterable[float]", thr_line.get_xdata()))
+    y_thr = list(cast("Iterable[float]", thr_line.get_ydata()))
+    assert x_thr == [10, 20]
+    assert pytest.approx(y_thr) == [100.0, 200.0]
+
+    # Latency axis
+    lat_line = axes[1].lines[0]
+    x_lat = list(cast("Iterable[float]", lat_line.get_xdata()))
+    y_lat = list(cast("Iterable[float]", lat_line.get_ydata()))
+    assert x_lat == [10, 20]
+    assert pytest.approx(y_lat) == [0.05, 0.06]
+
+    plt.close(fig)
+
+
+# ---------------------------------------------------------------------------
+# Tests — Per-server collection and overlays
+# ---------------------------------------------------------------------------
+
+
+def test_server_overlays_compute_lambda_mu_rho_and_wq() -> None:
+    """Per-server metrics must follow completions split and means."""
+    # lambda_tot = 100 (mean of [100, 100])
+    # completions: s1=60, s2=40 -> lambda1=60, lambda2=40
+    # mu1 = 1/0.01 = 100, mu2 = 1/0.02 = 50
+    # rho1 = 0.6, rho2 = 0.8
+    # wq means from waiting_time arrays
+    ra = _FakeResultsAnalyzer(
+        rps_series=[100.0, 100.0],
+        latency_stats={LatencyKey.MEAN: 0.05},
+        server_ids=["s1", "s2"],
+        server_arrays={
+            "s1": {
+                "service_time": [0.01] * 5,
+                "waiting_time": [0.005] * 5,
+                "finish_times": [0.0] * 60,
+            },
+            "s2": {
+                "service_time": [0.02] * 5,
+                "waiting_time": [0.004] * 5,
+                "finish_times": [0.0] * 40,
+            },
+        },
+    )
+
+    sa = SweepAnalyzer([_cast_pair(10, ra)])
+
+    # Utilization overlay
+    fig1, ax1 = plt.subplots(1, 1)
+    sa.plot_server_utilization_overlay(ax1, server_ids=["s1", "s2"])
+    lines = {line.get_label(): line for line in ax1.get_lines()}
+    assert "s1" in lines
+    assert "s2" in lines
+    y_rho_s1 = next(iter(cast("Iterable[float]", lines["s1"].get_ydata())))
+    y_rho_s2 = next(iter(cast("Iterable[float]", lines["s2"].get_ydata())))
+    assert pytest.approx(y_rho_s1) == 0.6
+    assert pytest.approx(y_rho_s2) == 0.8
+    plt.close(fig1)
+
+    # Service rate overlay
+    fig2, ax2 = plt.subplots(1, 1)
+    sa.plot_server_service_rate_overlay(ax2, server_ids=["s1", "s2"])
+    lines2 = {line.get_label(): line for line in ax2.get_lines()}
+    mu_s1 = next(iter(cast("Iterable[float]", lines2["s1"].get_ydata())))
+    mu_s2 = next(iter(cast("Iterable[float]", lines2["s2"].get_ydata())))
+    assert pytest.approx(mu_s1) == 100.0
+    assert pytest.approx(mu_s2) == 50.0
+    plt.close(fig2)
+
+    # Waiting time overlay
+    fig3, ax3 = plt.subplots(1, 1)
+    sa.plot_server_waiting_time_overlay(ax3, server_ids=["s1", "s2"])
+    lines3 = {line.get_label(): line for line in ax3.get_lines()}
+    wq_s1 = next(iter(cast("Iterable[float]", lines3["s1"].get_ydata())))
+    wq_s2 = next(iter(cast("Iterable[float]", lines3["s2"].get_ydata())))
+    assert pytest.approx(wq_s1) == 0.005
+    assert pytest.approx(wq_s2) == 0.004
+    plt.close(fig3)
+
+    # Throughput overlay
+    fig4, ax4 = plt.subplots(1, 1)
+    sa.plot_server_throughput_overlay(ax4, server_ids=["s1", "s2"])
+    lines4 = {line.get_label(): line for line in ax4.get_lines()}
+    lam_s1 = next(iter(cast("Iterable[float]", lines4["s1"].get_ydata())))
+    lam_s2 = next(iter(cast("Iterable[float]", lines4["s2"].get_ydata())))
+    assert pytest.approx(lam_s1) == 60.0
+    assert pytest.approx(lam_s2) == 40.0
+    plt.close(fig4)
+
+
+# ---------------------------------------------------------------------------
+# Tests — Caching behavior
+# ---------------------------------------------------------------------------
+
+
+def test_precollect_runs_each_analyzer_once_per_collector() -> None:
+    """precollect() plus plots should call process_all_metrics exactly twice."""
+    # Two pairs to make sure iteration is covered.
+    ra1 = _FakeResultsAnalyzer(
+        rps_series=[10.0, 20.0],
+        latency_stats={LatencyKey.MEAN: 0.1},
+        server_ids=["s1"],
+        server_arrays={"s1": {"service_time": [0.05], "waiting_time": [0.01]}},
+    )
+    ra2 = _FakeResultsAnalyzer(
+        rps_series=[30.0, 40.0],
+        latency_stats={LatencyKey.MEAN: 0.2},
+        server_ids=["s2"],
+        server_arrays={"s2": {"service_time": [0.02], "waiting_time": [0.02]}},
+    )
+
+    sa = SweepAnalyzer([_cast_pair(5, ra1), _cast_pair(15, ra2)])
+
+    # Warm caches (global + servers)
+    sa.precollect()
+
+    # Plot both dashboards (should NOT trigger recomputation)
+    fig_g = sa.plot_global_dashboard()
+    fig_s = sa.plot_server_dashboard()
+    plt.close(fig_g)
+    plt.close(fig_s)
+
+    # Each analyzer should have been processed exactly twice:
+    # once for global collection + once for server collection.
+    assert ra1.process_calls == 2
+    assert ra2.process_calls == 2
diff --git a/tests/unit/public_api/test_import.py b/tests/unit/public_api/test_import.py
index 2bea333..5eba664 100644
--- a/tests/unit/public_api/test_import.py
+++ b/tests/unit/public_api/test_import.py
@@ -1,32 +1,52 @@
-"""Unit tests for the public components import surface.
+"""Unit tests for the public import surface of the asyncflow package.
 
-Verifies that:
-- `asyncflow.components` exposes the expected `__all__`.
-- All symbols in `__all__` are importable and are classes.
+Checks:
+- Each public module exposes the expected `__all__`.
+- Symbols referenced in `__all__` are importable.
+- Symbols are of the expected kind (class or Enum).
 """
 
 from __future__ import annotations
 
 import importlib
+from enum import Enum
 from typing import TYPE_CHECKING
 
+# Root facade
+from asyncflow import AsyncFlow, SimulationRunner, Sweep
+
+# Public subpackages
+from asyncflow.analysis import MMc, ResultsAnalyzer, SweepAnalyzer
 from asyncflow.components import (
+    ArrivalsGenerator,
     Client,
-    Edge,
     Endpoint,
     EventInjection,
+    LinkEdge,
     LoadBalancer,
+    NetworkEdge,
+    NodesResources,
     Server,
-    ServerResources,
+)
+from asyncflow.enums import (
+    Distribution,
+    EndpointStepCPU,
+    EndpointStepIO,
+    EndpointStepRAM,
+    EventMetricName,
+    LbAlgorithmsName,
+    SampledMetricName,
+    StepOperation,
 )
 from asyncflow.settings import SimulationSettings
-from asyncflow.workload import RqsGenerator, RVConfig
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from collections.abc import Iterable
 
 
-
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
 def _assert_all_equals(module_name: str, expected: Iterable[str]) -> None:
     """Assert that a module's __all__ exactly matches `expected`."""
     mod = importlib.import_module(module_name)
@@ -38,46 +58,124 @@ def _assert_all_equals(module_name: str, expected: Iterable[str]) -> None:
     )
 
 
+# --------------------------------------------------------------------------- #
+# Root facade                                                                 #
+# --------------------------------------------------------------------------- #
+def test_root_public_symbols() -> None:
+    """`asyncflow` exposes the expected facade symbols."""
+    _assert_all_equals(
+        "asyncflow",
+        ["AsyncFlow", "SimulationRunner", "Sweep"],
+    )
+
+
+def test_root_symbols_are_classes() -> None:
+    """Facade symbols are importable classes."""
+    for cls, name in [
+        (AsyncFlow, "AsyncFlow"),
+        (SimulationRunner, "SimulationRunner"),
+        (Sweep, "Sweep"),
+    ]:
+        assert isinstance(cls, type), f"{name} should be a class"
+        assert cls.__name__ == name
+
+
+# --------------------------------------------------------------------------- #
+# Enums
+# --------------------------------------------------------------------------- #
+def test_enums_public_symbols() -> None:
+    """`asyncflow.enums` exposes the expected enum types."""
+    expected = [
+        "Distribution",
+        "EndpointStepCPU",
+        "EndpointStepIO",
+        "EndpointStepRAM",
+        "EventMetricName",
+        "LbAlgorithmsName",
+        "SampledMetricName",
+        "StepOperation",
+    ]
+    _assert_all_equals("asyncflow.enums", expected)
+
+
+def test_enums_symbols_are_enum_types() -> None:
+    """All public symbols in enums are Enum subclasses."""
+    for enum_type, name in [
+        (Distribution, "Distribution"),
+        (EndpointStepCPU, "EndpointStepCPU"),
+        (EndpointStepIO, "EndpointStepIO"),
+        (EndpointStepRAM, "EndpointStepRAM"),
+        (EventMetricName, "EventMetricName"),
+        (LbAlgorithmsName, "LbAlgorithmsName"),
+        (SampledMetricName, "SampledMetricName"),
+        (StepOperation, "StepOperation"),
+    ]:
+        assert isinstance(enum_type, type), f"{name} should be a type"
+        assert issubclass(enum_type, Enum), f"{name} should be an Enum"
+        assert enum_type.__name__ == name
+
+
+# --------------------------------------------------------------------------- #
+# Analysis                                                                     #
+# --------------------------------------------------------------------------- #
+def test_analysis_public_symbols() -> None:
+    """`asyncflow.analysis` exposes the expected names."""
+    _assert_all_equals(
+        "asyncflow.analysis",
+        ["MMc", "ResultsAnalyzer", "SweepAnalyzer"],
+    )
+
+
+def test_analysis_symbols_are_classes() -> None:
+    """All analysis symbols are classes."""
+    for cls, name in [
+        (MMc, "MMc"),
+        (ResultsAnalyzer, "ResultsAnalyzer"),
+        (SweepAnalyzer, "SweepAnalyzer"),
+    ]:
+        assert isinstance(cls, type), f"{name} should be a class"
+        assert cls.__name__ == name
+
+
+# --------------------------------------------------------------------------- #
+# Components                                                                   #
+# --------------------------------------------------------------------------- #
 def test_components_public_symbols() -> None:
     """`asyncflow.components` exposes the expected names."""
     expected = [
+        "ArrivalsGenerator",
         "Client",
-        "Edge",
         "Endpoint",
         "EventInjection",
+        "LinkEdge",
         "LoadBalancer",
+        "NetworkEdge",
+        "NodesResources",
         "Server",
-        "ServerResources",
     ]
     _assert_all_equals("asyncflow.components", expected)
 
 
 def test_components_symbols_are_importable_classes() -> None:
     """All public symbols are importable and are classes."""
-    # Basic type sanity (avoid heavy imports/instantiation)
     for cls, name in [
+        (ArrivalsGenerator, "ArrivalsGenerator"),
         (Client, "Client"),
-        (Edge, "Edge"),
         (Endpoint, "Endpoint"),
         (EventInjection, "EventInjection"),
+        (LinkEdge, "LinkEdge"),
         (LoadBalancer, "LoadBalancer"),
+        (NetworkEdge, "NetworkEdge"),
+        (NodesResources, "NodesResources"),
         (Server, "Server"),
-        (ServerResources, "ServerResources"),
     ]:
-        assert isinstance(cls, type), f"{name} should be a class type"
-        assert cls.__name__ == name
-
-def test_workload_public_symbols() -> None:
-    """`asyncflow.workload` exposes RVConfig and RqsGenerator."""
-    _assert_all_equals("asyncflow.workload", ["RVConfig", "RqsGenerator"])
-
-
-def test_workload_symbols_are_importable_classes() -> None:
-    """Public symbols are importable and are classes."""
-    for cls, name in [(RVConfig, "RVConfig"), (RqsGenerator, "RqsGenerator")]:
         assert isinstance(cls, type), f"{name} should be a class"
         assert cls.__name__ == name
 
+
+# --------------------------------------------------------------------------- #
+# Settings                                                                     #
+# --------------------------------------------------------------------------- #
 def test_settings_public_symbols() -> None:
     """`asyncflow.settings` exposes SimulationSettings."""
     _assert_all_equals("asyncflow.settings", ["SimulationSettings"])
@@ -85,5 +183,5 @@ def test_settings_public_symbols() -> None:
 
 def test_settings_symbol_is_importable_class() -> None:
     """Public symbol is importable and is a class."""
-    assert isinstance(SimulationSettings, type), "SimulationSettings should be a class"
+    assert isinstance(SimulationSettings, type), "must be a class"
     assert SimulationSettings.__name__ == "SimulationSettings"
diff --git a/tests/unit/pybuilder/test_input_builder.py b/tests/unit/pybuilder/test_input_builder.py
index fa49fda..68ad909 100644
--- a/tests/unit/pybuilder/test_input_builder.py
+++ b/tests/unit/pybuilder/test_input_builder.py
@@ -1,12 +1,13 @@
 """
 Unit tests for the AsyncFlow builder.
 
-The goal is to verify that:
-- The builder enforces types on each `add_*` method.
-- Missing components produce clear ValueError exceptions on `build_payload()`.
-- A valid, minimal scenario builds a `SimulationPayload` successfully.
+Goals:
+- Enforce types on each `add_*` method.
+- Missing parts raise clear ValueErrors on `build_payload()`.
+- Minimal valid scenario builds a SimulationPayload.
 - Methods return `self` to support fluent chaining.
 - Servers and edges can be added in multiples and preserve order.
+- New features: LinkEdge-only topologies and homogeneous edge enforcement.
 """
 
 from __future__ import annotations
@@ -14,34 +15,32 @@
 import pytest
 
 from asyncflow.builder.asyncflow_builder import AsyncFlow
+from asyncflow.config.enums import EventDescription, SystemEdges
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.events.injection import EventInjection
 from asyncflow.schemas.payload import SimulationPayload
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.endpoint import Endpoint
 from asyncflow.schemas.topology.nodes import Client, Server
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
 
 # --------------------------------------------------------------------------- #
-# Helpers: build minimal, valid components                                    #
+# Helpers: minimal, valid components                                          #
 # --------------------------------------------------------------------------- #
-def make_generator() -> RqsGenerator:
-    """Return a minimal valid request generator."""
-    return RqsGenerator(
-        id="rqs-1",
-        avg_active_users={"mean": 10},
-        avg_request_per_minute_per_user={"mean": 30},
-        user_sampling_window=60,
-    )
+
+
+def make_generator() -> ArrivalsGenerator:
+    """Minimal valid request generator."""
+    return ArrivalsGenerator(id="rqs-1", lambda_rps=10, model="poisson")
 
 
 def make_client() -> Client:
-    """Return a minimal valid client."""
+    """Minimal valid client."""
     return Client(id="client-1")
 
 
 def make_endpoint() -> Endpoint:
-    """Return a minimal endpoint with CPU and IO steps."""
+    """Endpoint with CPU and IO steps."""
     return Endpoint(
         endpoint_name="ep-1",
         probability=1.0,
@@ -53,7 +52,7 @@ def make_endpoint() -> Endpoint:
 
 
 def make_server(server_id: str = "srv-1") -> Server:
-    """Return a minimal valid server with 1 core, 2GB RAM, and one endpoint."""
+    """Server with 1 core, 2GB RAM, and one endpoint."""
     return Server(
         id=server_id,
         server_resources={"cpu_cores": 1, "ram_mb": 2048},
@@ -61,21 +60,21 @@ def make_server(server_id: str = "srv-1") -> Server:
     )
 
 
-def make_edges() -> list[Edge]:
-    """Return a valid edge triplet for the minimal single-server scenario."""
-    e1 = Edge(
+def make_net_edges() -> list[NetworkEdge]:
+    """Network edges for a single-server scenario."""
+    e1 = NetworkEdge(
         id="gen-to-client",
         source="rqs-1",
         target="client-1",
         latency={"mean": 0.003, "distribution": "exponential"},
     )
-    e2 = Edge(
+    e2 = NetworkEdge(
         id="client-to-server",
         source="client-1",
         target="srv-1",
         latency={"mean": 0.003, "distribution": "exponential"},
     )
-    e3 = Edge(
+    e3 = NetworkEdge(
         id="server-to-client",
         source="srv-1",
         target="client-1",
@@ -84,10 +83,18 @@ def make_edges() -> list[Edge]:
     return [e1, e2, e3]
 
 
+def make_link_edges() -> list[LinkEdge]:
+    """Link-only edges for a single-server scenario."""
+    e1 = LinkEdge(id="gen-to-client", source="rqs-1", target="client-1")
+    e2 = LinkEdge(id="client-to-server", source="client-1", target="srv-1")
+    e3 = LinkEdge(id="server-to-client", source="srv-1", target="client-1")
+    return [e1, e2, e3]
+
+
 def make_settings() -> SimulationSettings:
-    """Return minimal simulation settings within validation bounds."""
+    """Minimal simulation settings within validation bounds."""
     return SimulationSettings(
-        total_simulation_time=5.0,  # lower bound is 5 seconds
+        total_simulation_time=5.0,
         sample_period_s=0.1,
         enabled_sample_metrics=[
             "ready_queue_len",
@@ -100,19 +107,21 @@ def make_settings() -> SimulationSettings:
 
 
 # --------------------------------------------------------------------------- #
-# Positive / “happy path”                                                     #
+# Positive / happy path                                                       #
 # --------------------------------------------------------------------------- #
+
+
 def test_builder_happy_path_returns_payload() -> None:
-    """Building a minimal scenario returns a validated SimulationPayload."""
+    """Minimal scenario builds a validated SimulationPayload."""
     flow = AsyncFlow()
     generator = make_generator()
     client = make_client()
     server = make_server()
-    e1, e2, e3 = make_edges()
+    e1, e2, e3 = make_net_edges()
     settings = make_settings()
 
     payload = (
-        flow.add_generator(generator)
+        flow.add_arrivals_generator(generator)
         .add_client(client)
         .add_servers(server)
         .add_edges(e1, e2, e3)
@@ -131,13 +140,13 @@ def test_builder_happy_path_returns_payload() -> None:
 
 
 def test_add_methods_return_self_for_chaining() -> None:
-    """Every add_* method returns `self` to support fluent chaining."""
+    """Every add_* method returns `self` for fluent chaining."""
     flow = AsyncFlow()
     ret = (
-        flow.add_generator(make_generator())
+        flow.add_arrivals_generator(make_generator())
         .add_client(make_client())
         .add_servers(make_server())
-        .add_edges(*make_edges())
+        .add_edges(*make_net_edges())
         .add_simulation_settings(make_settings())
     )
     assert ret is flow
@@ -145,18 +154,17 @@ def test_add_methods_return_self_for_chaining() -> None:
 
 def test_add_servers_accepts_multiple_and_keeps_order() -> None:
     """Adding multiple servers keeps insertion order."""
-    flow = AsyncFlow().add_generator(make_generator()).add_client(make_client())
+    flow = AsyncFlow()
+    flow.add_arrivals_generator(make_generator()).add_client(make_client())
     s1 = make_server("srv-1")
     s2 = make_server("srv-2")
     s3 = make_server("srv-3")
 
     flow.add_servers(s1, s2).add_servers(s3)
-    e1, e2, e3 = make_edges()
+    e1, e2, e3 = make_net_edges()
     settings = make_settings()
     payload = (
-        flow.add_edges(e1, e2, e3)
-        .add_simulation_settings(settings)
-        .build_payload()
+        flow.add_edges(e1, e2, e3).add_simulation_settings(settings).build_payload()
     )
 
     ids = [srv.id for srv in payload.topology_graph.nodes.servers]
@@ -164,19 +172,21 @@ def test_add_servers_accepts_multiple_and_keeps_order() -> None:
 
 
 # --------------------------------------------------------------------------- #
-# Negative cases: missing components                                          #
+# Negative: missing components                                                #
 # --------------------------------------------------------------------------- #
+
+
 def test_build_without_generator_raises() -> None:
     """Building without a generator fails with a clear error."""
     flow = AsyncFlow()
     flow.add_client(make_client())
     flow.add_servers(make_server())
-    flow.add_edges(*make_edges())
+    flow.add_edges(*make_net_edges())
     flow.add_simulation_settings(make_settings())
 
     with pytest.raises(
         ValueError,
-        match="The generator input must be instantiated before the simulation",
+        match="The arrivals generator must be instantiated before the simulation",
     ):
         flow.build_payload()
 
@@ -184,9 +194,9 @@ def test_build_without_generator_raises() -> None:
 def test_build_without_client_raises() -> None:
     """Building without a client fails with a clear error."""
     flow = AsyncFlow()
-    flow.add_generator(make_generator())
+    flow.add_arrivals_generator(make_generator())
     flow.add_servers(make_server())
-    flow.add_edges(*make_edges())
+    flow.add_edges(*make_net_edges())
     flow.add_simulation_settings(make_settings())
 
     with pytest.raises(
@@ -199,9 +209,9 @@ def test_build_without_client_raises() -> None:
 def test_build_without_servers_raises() -> None:
     """Building without servers fails with a clear error."""
     flow = AsyncFlow()
-    flow.add_generator(make_generator())
+    flow.add_arrivals_generator(make_generator())
     flow.add_client(make_client())
-    flow.add_edges(*make_edges())
+    flow.add_edges(*make_net_edges())
     flow.add_simulation_settings(make_settings())
 
     with pytest.raises(
@@ -214,7 +224,7 @@ def test_build_without_servers_raises() -> None:
 def test_build_without_edges_raises() -> None:
     """Building without edges fails with a clear error."""
     flow = AsyncFlow()
-    flow.add_generator(make_generator())
+    flow.add_arrivals_generator(make_generator())
     flow.add_client(make_client())
     flow.add_servers(make_server())
     flow.add_simulation_settings(make_settings())
@@ -229,10 +239,10 @@ def test_build_without_edges_raises() -> None:
 def test_build_without_settings_raises() -> None:
     """Building without settings fails with a clear error."""
     flow = AsyncFlow()
-    flow.add_generator(make_generator())
+    flow.add_arrivals_generator(make_generator())
     flow.add_client(make_client())
     flow.add_servers(make_server())
-    flow.add_edges(*make_edges())
+    flow.add_edges(*make_net_edges())
 
     with pytest.raises(
         ValueError,
@@ -242,20 +252,22 @@ def test_build_without_settings_raises() -> None:
 
 
 # --------------------------------------------------------------------------- #
-# Negative cases: type enforcement in add_* methods                           #
+# Negative: type enforcement in add_* methods                                 #
 # --------------------------------------------------------------------------- #
+
+
 def test_add_generator_rejects_wrong_type() -> None:
-    """`add_generator` rejects non-RqsGenerator instances."""
+    """`add_arrivals_generator` rejects non-ArrivalsGenerator instances."""
     flow = AsyncFlow()
     with pytest.raises(TypeError):
-        flow.add_generator("not-a-generator") # type: ignore[arg-type]
+        flow.add_arrivals_generator("not-a-generator")  # type: ignore[arg-type]
 
 
 def test_add_client_rejects_wrong_type() -> None:
     """`add_client` rejects non-Client instances."""
     flow = AsyncFlow()
     with pytest.raises(TypeError):
-        flow.add_client(1234) # type: ignore[arg-type]
+        flow.add_client(1234)  # type: ignore[arg-type]
 
 
 def test_add_servers_rejects_wrong_type() -> None:
@@ -263,19 +275,135 @@ def test_add_servers_rejects_wrong_type() -> None:
     flow = AsyncFlow()
     good = make_server()
     with pytest.raises(TypeError):
-        flow.add_servers(good, "not-a-server") # type: ignore[arg-type]
+        flow.add_servers(good, "not-a-server")  # type: ignore[arg-type]
 
 
 def test_add_edges_rejects_wrong_type() -> None:
     """`add_edges` rejects any non-Edge in the varargs."""
     flow = AsyncFlow()
-    good = make_edges()[0]
+    good = make_net_edges()[0]
     with pytest.raises(TypeError):
-        flow.add_edges(good, 3.14) # type: ignore[arg-type]
+        flow.add_edges(good, 3.14)  # type: ignore[arg-type]
 
 
 def test_add_settings_rejects_wrong_type() -> None:
     """`add_simulation_settings` rejects non-SimulationSettings instances."""
     flow = AsyncFlow()
     with pytest.raises(TypeError):
-        flow.add_simulation_settings({"total_simulation_time": 1.0}) # type: ignore[arg-type]
+        flow.add_simulation_settings({"total_simulation_time": 1.0})  # type: ignore[arg-type]
+
+
+# --------------------------------------------------------------------------- #
+# New features: LinkEdge support and homogeneous enforcement                   #
+# --------------------------------------------------------------------------- #
+
+
+def test_linkedge_topology_builds_payload() -> None:
+    """A LinkEdge-only topology is accepted and preserved."""
+    flow = AsyncFlow()
+    payload = (
+        flow.add_arrivals_generator(make_generator())
+        .add_client(make_client())
+        .add_servers(make_server())
+        .add_edges(*make_link_edges())
+        .add_simulation_settings(make_settings())
+        .build_payload()
+    )
+    assert all(
+        e.edge_type is SystemEdges.LINK_CONNECTION
+        for e in payload.topology_graph.edges
+    )
+    assert {e.id for e in payload.topology_graph.edges} == {
+        "gen-to-client",
+        "client-to-server",
+        "server-to-client",
+    }
+
+
+def test_add_edges_rejects_mixed_types_in_single_call() -> None:
+    """Mixing NetworkEdge and LinkEdge in the same call is rejected."""
+    flow = (
+        AsyncFlow()
+        .add_arrivals_generator(make_generator())
+        .add_client(make_client())
+        .add_servers(make_server())
+    )
+    n1 = make_net_edges()[0]
+    l1 = make_link_edges()[0]
+    with pytest.raises(TypeError, match="Cannot mix (LinkEdge|NetworkEdge)"):
+        flow.add_edges(n1, l1)
+
+
+def test_add_edges_rejects_mixed_types_across_calls() -> None:
+    """Once kind is fixed, subsequent calls with other kind fail."""
+    flow = (
+        AsyncFlow()
+        .add_arrivals_generator(make_generator())
+        .add_client(make_client())
+        .add_servers(make_server())
+    )
+    n1, _, _ = make_net_edges()
+    flow.add_edges(n1)
+    with pytest.raises(TypeError, match="Cannot mix LinkEdge with NetworkEdge."):
+        flow.add_edges(make_link_edges()[0])
+
+    flow2 = (
+        AsyncFlow()
+        .add_arrivals_generator(make_generator())
+        .add_client(make_client())
+        .add_servers(make_server())
+    )
+    l1, _, _ = make_link_edges()
+    flow2.add_edges(l1)
+    with pytest.raises(TypeError, match="Cannot mix NetworkEdge with LinkEdge."):
+        flow2.add_edges(make_net_edges()[0])
+
+
+def test_add_edges_noop_on_empty_call() -> None:
+    """Calling add_edges() with no args is a no-op and does not fix kind."""
+    flow = AsyncFlow()
+    flow.add_arrivals_generator(make_generator())
+    flow.add_client(make_client())
+    flow.add_servers(make_server())
+    flow.add_simulation_settings(make_settings())
+
+    ret = flow.add_edges()  # no edges
+    assert ret is flow
+
+    with pytest.raises(ValueError, match="You must instantiate edges"):
+        flow.build_payload()
+
+
+# --------------------------------------------------------------------------- #
+# Events helpers                                                               #
+# --------------------------------------------------------------------------- #
+
+
+def test_add_network_spike_is_in_payload() -> None:
+    """add_network_spike wires a NETWORK_SPIKE event into the payload."""
+    n1, n2, n3 = make_net_edges()
+    flow = (
+        AsyncFlow()
+        .add_arrivals_generator(make_generator())
+        .add_client(make_client())
+        .add_servers(make_server())
+        .add_edges(n1, n2, n3)
+        .add_network_spike(
+            event_id="ev1",
+            edge_id=n2.id,
+            t_start=1.0,
+            t_end=2.0,
+            spike_s=0.25,
+        )
+        .add_simulation_settings(make_settings())
+    )
+    payload = flow.build_payload()
+    assert payload.events is not None
+    assert len(payload.events) == 1
+    ev = payload.events[0]
+    assert isinstance(ev, EventInjection)
+    assert ev.event_id == "ev1"
+    assert ev.target_id == n2.id
+    assert ev.start.kind is EventDescription.NETWORK_SPIKE_START
+    assert ev.end.kind is EventDescription.NETWORK_SPIKE_END
+    assert ev.start.spike_s == 0.25
diff --git a/tests/unit/queue_theory_analysis/test_base.py b/tests/unit/queue_theory_analysis/test_base.py
new file mode 100644
index 0000000..6d11ce1
--- /dev/null
+++ b/tests/unit/queue_theory_analysis/test_base.py
@@ -0,0 +1,90 @@
+"""Unit tests for QueueTheoryBase base class.
+
+Covers:
+- is_compatible() truthiness for compatible/incompatible analyzers
+- validate_or_raise() no-op vs ValueError with exact message
+- Abstract method enforcement (cannot instantiate without override)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import pytest
+
+from asyncflow.queue_theory_analysis.base import QueueTheoryBase
+
+if TYPE_CHECKING:
+    from asyncflow.schemas.payload import SimulationPayload
+
+
+class AlwaysCompatible(QueueTheoryBase):
+    """Dummy analyzer that is always compatible."""
+
+    def explain_incompatibilities(
+        self,
+        _: SimulationPayload,
+    ) -> list[str]:
+        """Return an empty list → compatible."""
+        return []
+
+
+class AlwaysIncompatible(QueueTheoryBase):
+    """Dummy analyzer that always reports the provided reasons."""
+
+    def __init__(self, reasons: list[str] | None = None) -> None:
+        """Store reasons to be returned by explain_incompatibilities()."""
+        self._reasons = reasons or ["incompat-1", "incompat-2"]
+
+    def explain_incompatibilities(
+        self,
+        _: SimulationPayload,
+    ) -> list[str]:
+        """Return a copy of the stored reasons."""
+        return list(self._reasons)
+
+
+def test_is_compatible_true_and_validate_noop() -> None:
+    """When no reasons, compatible=True and validate_or_raise is no-op."""
+    payload = cast("SimulationPayload", object())
+    an = AlwaysCompatible()
+
+    assert an.is_compatible(payload) is True
+    assert an.explain_incompatibilities(payload) == []
+
+    # Must not raise
+    an.validate_or_raise(payload)
+
+
+def test_is_compatible_false_and_validate_raises_with_message() -> None:
+    """validate_or_raise must raise with bullet-formatted reasons."""
+    payload = cast("SimulationPayload", object())
+    reasons = ["topology must include at least one edge.", "c must be >= 1."]
+    an = AlwaysIncompatible(reasons)
+
+    assert an.is_compatible(payload) is False
+
+    with pytest.raises(
+        ValueError,
+        match=r"^Payload is not compatible with this queueing model:",
+    ) as exc:
+        an.validate_or_raise(payload)
+
+    msg = str(exc.value)
+    expected = (
+        "Payload is not compatible with this queueing model:\n"
+        " - topology must include at least one edge.\n"
+        " - c must be >= 1."
+    )
+    assert msg == expected
+
+
+def test_abstract_enforcement_prevents_instantiation() -> None:
+    """A subclass without explain_incompatibilities cannot be instantiated."""
+
+    class BrokenAnalyzer(QueueTheoryBase):
+        """Intentionally missing explain_incompatibilities()."""
+
+
+    with pytest.raises(TypeError, match="Can't instantiate"):
+        BrokenAnalyzer()  # type: ignore[abstract]
diff --git a/tests/unit/queue_theory_analysis/test_mmc.py b/tests/unit/queue_theory_analysis/test_mmc.py
new file mode 100644
index 0000000..0990089
--- /dev/null
+++ b/tests/unit/queue_theory_analysis/test_mmc.py
@@ -0,0 +1,415 @@
+"""Basic golden test for the MMc analyzer (RR split model).
+
+This file intentionally contains both helpers and the first test,
+so you can copy-paste a single file and extend incrementally.
+
+It uses only public facades (like a pip-installed user would),
+plus `LatencyKey` which MMc reads from `get_latency_stats()`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import pytest
+
+# Public facades (end-user API)
+from asyncflow import AsyncFlow
+from asyncflow.analysis import MMc
+from asyncflow.components import (
+    ArrivalsGenerator,
+    Client,
+    Endpoint,
+    LinkEdge,
+    LoadBalancer,
+    Server,
+)
+from asyncflow.config.enums import LatencyKey  # used by get_latency_stats()
+from asyncflow.enums import Distribution
+from asyncflow.schemas.payload import SimulationPayload
+from asyncflow.schemas.topology.graph import TopologyGraph
+from asyncflow.schemas.topology.nodes import NodesResources, TopologyNodes
+from asyncflow.settings import SimulationSettings
+
+if TYPE_CHECKING:
+    # Types used only for static checking (mypy), not imported at runtime.
+    from collections.abc import Iterable, Mapping
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+
+
+
+class _FakeResultsAnalyzer:
+    """Minimal, typed stub of ResultsAnalyzer for unit testing MMc.
+
+    Provide exactly what MMc calls:
+      - process_all_metrics()
+      - get_throughput_series()
+      - get_server_event_arrays()
+      - get_latency_stats()
+    """
+
+    def __init__(
+        self,
+        *,
+        lambda_rate: float,
+        mu_rate: float,
+        w_mean: float,
+        wq_mean: float,
+        server_ids: Iterable[str],
+    ) -> None:
+        self._lambda_rate = float(lambda_rate)
+        self._mu_rate = float(mu_rate)
+        self._w_mean = float(w_mean)
+        self._wq_mean = float(wq_mean)
+        self._server_ids = list(server_ids)
+
+    def process_all_metrics(self) -> None:
+        """No-op in the stub; real analyzer would pre-compute metrics."""
+        return
+
+    def get_throughput_series(self) -> tuple[list[float], list[float]]:
+        """Return a constant-RPS series with mean equal to lambda."""
+        times = [float(i) for i in range(10)]
+        rps = [self._lambda_rate for _ in times]
+        return times, rps
+
+    def get_server_event_arrays(self) -> Mapping[str, Mapping[str, list[float]]]:
+        """Return arrays per server for service and waiting times.
+
+        Means are set so the observed mu and Wq match the theoretical ones.
+        """
+        es = 1.0 / self._mu_rate if self._mu_rate > 0.0 else 0.0
+        out: dict[str, dict[str, list[float]]] = {}
+        for sid in self._server_ids:
+            out[sid] = {
+                "service_time": [es] * 50,
+                "waiting_time": [self._wq_mean] * 50,
+            }
+        return out
+
+    def get_latency_stats(self) -> Mapping[LatencyKey, float]:
+        """Expose the mean latency using the LatencyKey expected by MMc."""
+        return {LatencyKey.MEAN: self._w_mean}
+
+
+def _build_payload_mmc_split(
+    *,
+    users_mean: int = 120,
+    rpm_per_user: int = 20,
+    cpu_mean_s: float = 0.01,
+    c: int = 2,
+) -> SimulationPayload:
+    """Build a minimal payload compatible with MMc split (RR/random) assumptions.
+
+    - c identical servers
+    - 1 exponential CPU step per server
+    - deterministic tiny latencies (≤ 1 ms)
+    - load balancer with algorithms="random" (matches current MMc check)
+    """
+    gen = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=20,
+        model="poisson",
+    )
+
+    client = Client(id="client-1")
+
+    endpoint = Endpoint(
+        endpoint_name="/api",
+        probability=1.0,
+        steps=[
+            {
+                "kind": "initial_parsing",
+                "step_operation": {
+                    "cpu_time": {"mean": cpu_mean_s, "distribution": "exponential"},
+                },
+            },
+        ],
+    )
+
+    servers = [
+        Server(
+            id=f"srv-{i+1}",
+            server_resources={"cpu_cores": 1, "ram_mb": 2048},
+            endpoints=[endpoint],
+        )
+        for i in range(c)
+    ]
+
+    lb = LoadBalancer(
+        id="lb-1",
+        algorithms="random",
+        server_covered={s.id for s in servers},
+    )
+
+    edges = [
+        LinkEdge(
+            id="gen-client",
+            source="rqs-1",
+            target="client-1",
+        ),
+        LinkEdge(
+            id="client-lb",
+            source="client-1",
+            target="lb-1",
+
+        ),
+    ]
+
+    for s in servers:
+        edges.append(
+            LinkEdge(
+                id=f"lb-{s.id}",
+                source="lb-1",
+                target=s.id,
+
+            ),
+        )
+        edges.append(
+            LinkEdge(
+                id=f"{s.id}-client",
+                source=s.id,
+                target="client-1",
+            ),
+        )
+
+    settings = SimulationSettings(
+        total_simulation_time=60,
+        sample_period_s=0.05,
+    )
+
+    return (
+        AsyncFlow()
+        .add_arrivals_generator(gen)
+        .add_client(client)
+        .add_servers(*servers)
+        .add_load_balancer(lb)
+        .add_edges(*edges)
+        .add_simulation_settings(settings)
+    ).build_payload()
+
+
+def _theory_kpis(payload: SimulationPayload) -> dict[str, float]:
+    """Ask MMc once for its closed-form KPIs and return a numeric snapshot."""
+    mmc = MMc()
+    res = mmc.evaluate(payload)
+    return {
+        "lambda": float(res["lambda_rate"]),
+        "mu": float(res["mu_rate"]),
+        "W": float(res["W"]),
+        "Wq": float(res["Wq"]),
+    }
+
+
+def test_mmc_compare_matches_theory() -> None:
+    """When Observed == Theory, compare_against_run deltas must be zero."""
+    payload = _build_payload_mmc_split(c=2)
+
+    # Build a stub RA that feeds back the theoretical values.
+    k = _theory_kpis(payload)
+    server_ids = [f"srv-{i+1}" for i in range(2)]
+    ra = _FakeResultsAnalyzer(
+        lambda_rate=k["lambda"],
+        mu_rate=k["mu"],
+        w_mean=k["W"],
+        wq_mean=k["Wq"],
+        server_ids=server_ids,
+    )
+
+    mmc = MMc()
+    assert mmc.is_compatible(payload), "Payload should be MMc-compatible."
+
+    rows = mmc.compare_against_run(payload, cast("ResultsAnalyzer", ra))
+    assert len(rows) == 7, "Expected 7 KPI rows."
+
+    # All absolute deltas should be 0.000000 (printed as strings).
+    zero = pytest.approx(0.0, abs=1e-9)
+    for r in rows:
+        msg = f"Non-zero delta for {r['symbol']} ({r['name']})"
+        assert float(r["abs_diff"]) == zero, msg
+
+# ---------------------------------------------------------------------------
+# Extra tests for MMc
+# ---------------------------------------------------------------------------
+
+def test_mmc_instability_returns_infinities() -> None:
+    """If rho >= 1, closed-form KPIs must be +inf (W, Wq, L, Lq)."""
+    # c = 1, mu = 100 rps (service = 0.01 s) -> capacity = 100 rps.
+    # For instability set lambda >= 100.
+
+    client = Client(id="client-1")
+    endpoint = Endpoint(
+        endpoint_name="/api",
+        probability=1.0,
+        steps=[
+            {
+                "kind": "initial_parsing",
+                "step_operation": {
+                    "cpu_time": {"mean": 0.01, "distribution": "exponential"},
+                },
+            },
+        ],
+    )  # 0.01 s -> mu = 100 rps
+    srv = Server(
+        id="srv-1",
+        server_resources=NodesResources(cpu_cores=2),
+        endpoints=[endpoint],
+    )
+
+    # Minimal LinkEdge topology (MMc expects LinkEdge, not NetworkEdge).
+    edges = [
+        LinkEdge(id="gen-client", source="gen", target="client-1"),
+        LinkEdge(id="client-srv", source="client-1", target="srv-1"),
+        LinkEdge(id="srv-client", source="srv-1", target="client-1"),
+    ]
+
+    nodes = TopologyNodes(servers=[srv], client=client, load_balancer=None)
+    graph = TopologyGraph(nodes=nodes, edges=edges)
+
+    # λ = 200 rps (>= capacity 100) -> rho >= 1
+    arrivals = ArrivalsGenerator(
+        id="gen", lambda_rps=200.0, model=Distribution.POISSON,
+    )
+
+    settings = SimulationSettings(total_simulation_time=5)
+    payload = SimulationPayload(
+        arrivals=arrivals, topology_graph=graph, sim_settings=settings,
+    )
+
+    mmc = MMc()
+    res = mmc.evaluate(payload)
+
+    assert res["rho"] >= 1.0
+    for key in ("W", "Wq", "L", "Lq"):
+        assert res[key] == float("inf")
+
+
+def test_mmc_incompatible_server_model_requires_single_cpu_step() -> None:
+    """Each server endpoint must have exactly one CPU step."""
+    gen = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=20,
+        model="poisson",
+    )
+    client = Client(id="client-1")
+
+    # Valid endpoint (1 CPU step)
+    endpoint_ok = Endpoint(
+        endpoint_name="/api",
+        probability=1.0,
+        steps=[
+            {
+                "kind": "initial_parsing",
+                "step_operation": {
+                    "cpu_time": {"mean": 0.01, "distribution": "exponential"},
+                },
+            },
+        ],
+    )
+    # Invalid endpoint (2 CPU steps)
+    endpoint_bad = Endpoint(
+        endpoint_name="/api",
+        probability=1.0,
+        steps=[
+            {
+                "kind": "initial_parsing",
+                "step_operation": {
+                    "cpu_time": {"mean": 0.01, "distribution": "exponential"},
+                },
+            },
+            {
+                "kind": "initial_parsing",
+                "step_operation": {
+                    "cpu_time": {"mean": 0.01, "distribution": "exponential"},
+                },
+            },
+        ],
+    )
+
+    srv1 = Server(
+        id="srv-1",
+        server_resources={"cpu_cores": 1, "ram_mb": 2048},
+        endpoints=[endpoint_ok],
+    )
+    srv2 = Server(
+        id="srv-2",
+        server_resources={"cpu_cores": 1, "ram_mb": 2048},
+        endpoints=[endpoint_bad],
+    )
+    lb = LoadBalancer(
+        id="lb-1",
+        algorithms="random",
+        server_covered={"srv-1", "srv-2"},
+    )
+    edges = [
+        LinkEdge(
+            id="gen-client",
+            source="rqs-1",
+            target="client-1",
+        ),
+        LinkEdge(
+            id="client-lb",
+            source="client-1",
+            target="lb-1",
+        ),
+        LinkEdge(
+            id="lb-srv1",
+            source="lb-1",
+            target="srv-1",
+        ),
+        LinkEdge(
+            id="lb-srv2",
+            source="lb-1",
+            target="srv-2",
+        ),
+        LinkEdge(
+            id="srv1-client",
+            source="srv-1",
+            target="client-1",
+        ),
+        LinkEdge(
+            id="srv2-client",
+            source="srv-2",
+            target="client-1",
+        ),
+    ]
+    settings = SimulationSettings(
+        total_simulation_time=60,
+        sample_period_s=0.05,
+    )
+    payload = (
+        AsyncFlow()
+        .add_arrivals_generator(gen)
+        .add_client(client)
+        .add_servers(srv1, srv2)
+        .add_load_balancer(lb)
+        .add_edges(*edges)
+        .add_simulation_settings(settings)
+    ).build_payload()
+
+    mmc = MMc()
+    assert not mmc.is_compatible(payload)
+    reasons = mmc.explain_incompatibilities(payload)
+    assert any("exactly one step" in r for r in reasons)
+
+
+def test_mmc_compare_and_format_smoke() -> None:
+    """compare_and_format() should return a readable ASCII table."""
+    payload = _build_payload_mmc_split(c=2)
+    k = _theory_kpis(payload)
+    server_ids = [f"srv-{i+1}" for i in range(2)]
+    ra = _FakeResultsAnalyzer(
+        lambda_rate=k["lambda"],
+        mu_rate=k["mu"],
+        w_mean=k["W"],
+        wq_mean=k["Wq"],
+        server_ids=server_ids,
+    )
+    mmc = MMc()
+    table = mmc.compare_and_format(payload, cast("ResultsAnalyzer", ra))
+    assert "MMc (Random split) — Theory vs Observed" in table
+    assert "Arrival rate" in table
+    assert "Mean waiting (s)" in table
+
+
diff --git a/tests/unit/resources/test_registry.py b/tests/unit/resources/test_registry.py
index 6581ae0..3b76c67 100644
--- a/tests/unit/resources/test_registry.py
+++ b/tests/unit/resources/test_registry.py
@@ -5,21 +5,21 @@
 import pytest
 import simpy
 
-from asyncflow.config.constants import ServerResourceName
+from asyncflow.config.enums import ServerResourceName
 from asyncflow.resources.registry import ResourcesRuntime
 from asyncflow.schemas.topology.endpoint import Endpoint
 from asyncflow.schemas.topology.graph import TopologyGraph
 from asyncflow.schemas.topology.nodes import (
     Client,
+    NodesResources,
     Server,
-    ServerResources,
     TopologyNodes,
 )
 
 
 def _minimal_server(server_id: str, cores: int, ram: int) -> Server:
     """Create a Server with a dummy endpoint and resource spec."""
-    res = ServerResources(cpu_cores=cores, ram_mb=ram)
+    res = NodesResources(cpu_cores=cores, ram_mb=ram)
     dummy_ep = Endpoint(endpoint_name="/ping", steps=[])
     return Server(id=server_id, server_resources=res, endpoints=[dummy_ep])
 
diff --git a/tests/unit/resources/test_server_containers.py b/tests/unit/resources/test_server_containers.py
index b7a8243..2741fec 100644
--- a/tests/unit/resources/test_server_containers.py
+++ b/tests/unit/resources/test_server_containers.py
@@ -2,14 +2,14 @@
 
 import simpy
 
-from asyncflow.config.constants import ServerResourceName
+from asyncflow.config.enums import ServerResourceName
 from asyncflow.resources.server_containers import build_containers
-from asyncflow.schemas.topology.nodes import ServerResources
+from asyncflow.schemas.topology.nodes import NodesResources
 
 
 def test_containers_start_full() -> None:
     env = simpy.Environment()
-    spec = ServerResources(cpu_cores=4, ram_mb=2048)
+    spec = NodesResources(cpu_cores=4, ram_mb=2048)
     containers = build_containers(env, spec)
 
     cpu = containers[ServerResourceName.CPU.value]
diff --git a/tests/unit/runtime/test_simulation_runner.py b/tests/unit/runner/test_simulation.py
similarity index 58%
rename from tests/unit/runtime/test_simulation_runner.py
rename to tests/unit/runner/test_simulation.py
index 9ec9299..30be498 100644
--- a/tests/unit/runtime/test_simulation_runner.py
+++ b/tests/unit/runner/test_simulation.py
@@ -1,4 +1,4 @@
-"""Unit-tests for :pyclass:`app.runtime.simulation_runner.SimulationRunner`.
+"""Unit-tests for :class:`SimulationRunner`.
 
 Purpose
 -------
@@ -8,36 +8,37 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import pytest
 import simpy
 import yaml
+from tests.unit.helpers import make_min_ep
 
-from asyncflow.config.constants import Distribution, EventDescription
-from asyncflow.runtime.simulation_runner import SimulationRunner
+from asyncflow.config.enums import Distribution, EventDescription
+from asyncflow.runner.simulation import SimulationRunner
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.events.injection import EventInjection
 from asyncflow.schemas.payload import SimulationPayload
 from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 from asyncflow.schemas.topology.graph import TopologyGraph
 from asyncflow.schemas.topology.nodes import (
     Client,
     LoadBalancer,
+    NodesResources,
     Server,
-    ServerResources,
     TopologyNodes,
 )
 
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from asyncflow.runtime.actors.arrivals_generator import (
+        ArrivalsGeneratorRuntime,
+    )
     from asyncflow.runtime.actors.client import ClientRuntime
-    from asyncflow.runtime.actors.rqs_generator import RqsGeneratorRuntime
-    from asyncflow.schemas.settings.simulation import SimulationSettings
-    from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
 
 
 # --------------------------------------------------------------------------- #
@@ -49,6 +50,25 @@ def env() -> simpy.Environment:
     return simpy.Environment()
 
 
+@pytest.fixture
+def payload_base() -> SimulationPayload:
+    """Minimal SimulationPayload: arrivals + client, no servers."""
+    arrivals = ArrivalsGenerator(
+        id="gen",
+        lambda_rps=5.0,
+        model=Distribution.POISSON,
+    )
+    client = Client(id="cli")
+    nodes = TopologyNodes(servers=[], client=client, load_balancer=None)
+    graph = TopologyGraph(nodes=nodes, edges=[])
+    settings = SimulationSettings(total_simulation_time=5)
+    return SimulationPayload(
+        arrivals=arrivals,
+        topology_graph=graph,
+        sim_settings=settings,
+    )
+
+
 @pytest.fixture
 def runner(
     env: simpy.Environment,
@@ -59,16 +79,16 @@ def runner(
 
 
 # --------------------------------------------------------------------------- #
-# Builder-level tests (original)                                              #
+# Builder-level tests                                                         #
 # --------------------------------------------------------------------------- #
-def test_build_rqs_generator_populates_dict(runner: SimulationRunner) -> None:
+def test_build_arrivals_populates_dict(runner: SimulationRunner) -> None:
     """_build_rqs_generator() must register one generator runtime."""
     runner._build_rqs_generator()  # noqa: SLF001
-    assert len(runner._rqs_runtime) == 1  # noqa: SLF001
-    gen_rt: RqsGeneratorRuntime = next(
-        iter(runner._rqs_runtime.values()),  # noqa: SLF001
+    assert len(runner._arrivals_runtime) == 1  # noqa: SLF001
+    gen_rt: ArrivalsGeneratorRuntime = next(
+        iter(runner._arrivals_runtime.values()), # noqa: SLF001
     )
-    assert gen_rt.rqs_generator_data.id == runner.rqs_generator.id
+    assert gen_rt.arrivals.id == runner.arrivals.id
 
 
 def test_build_client_populates_dict(runner: SimulationRunner) -> None:
@@ -76,7 +96,7 @@ def test_build_client_populates_dict(runner: SimulationRunner) -> None:
     runner._build_client()  # noqa: SLF001
     assert len(runner._client_runtime) == 1  # noqa: SLF001
     cli_rt: ClientRuntime = next(
-        iter(runner._client_runtime.values()),  # noqa: SLF001
+        iter(runner._client_runtime.values()), # noqa: SLF001
     )
     assert cli_rt.client_config.id == runner.client.id
     assert cli_rt.out_edge is None
@@ -99,32 +119,52 @@ def test_build_load_balancer_noop_when_absent(
 
 
 # --------------------------------------------------------------------------- #
-# Edges builder (original)                                                    #
+# Edges builder                                                               #
 # --------------------------------------------------------------------------- #
-def test_build_edges_with_stub_edge(runner: SimulationRunner) -> None:
-    """
-    `_build_edges()` must register exactly one `EdgeRuntime`, corresponding
-    to the single stub edge (generator → client) present in the minimal
-    topology fixture.
-    """
+def test_build_edges_with_stub_network_edge(runner: SimulationRunner) -> None:
+    """Register exactly one EdgeRuntime for a NetworkEdge (gen → cli)."""
+    arrivals_id = runner.arrivals.id
+    client_id = runner.client.id
+    stub_edge = NetworkEdge(
+        id="gen-cli",
+        source=arrivals_id,
+        target=client_id,
+        latency=RVConfig(mean=0.001, distribution=Distribution.POISSON),
+    )
+
+    # Tipizza esplicitamente la lista come list[NetworkEdge]
+    net_edges: list[NetworkEdge] = [stub_edge]
+    runner.edges = cast("list[NetworkEdge] | list[LinkEdge]", net_edges)
+
     runner._build_rqs_generator()  # noqa: SLF001
-    runner._build_client()  # noqa: SLF001
-    runner._build_edges()  # noqa: SLF001
+    runner._build_client()         # noqa: SLF001
+    runner._build_edges()          # noqa: SLF001
+
     assert len(runner._edges_runtime) == 1  # noqa: SLF001
 
+def test_build_edges_with_stub_link_edge(runner: SimulationRunner) -> None:
+    """Register exactly one EdgeRuntime for a LinkEdge (gen → cli)."""
+    arrivals_id = runner.arrivals.id
+    client_id = runner.client.id
+    stub_edge = LinkEdge(id="gen-cli", source=arrivals_id, target=client_id)
+
+    # Tipizza esplicitamente la lista come list[LinkEdge]
+    link_edges: list[LinkEdge] = [stub_edge]
+    runner.edges = cast("list[NetworkEdge] | list[LinkEdge]", link_edges)
+
+    runner._build_rqs_generator()  # noqa: SLF001
+    runner._build_client()         # noqa: SLF001
+    runner._build_edges()          # noqa: SLF001
+
+    assert len(runner._edges_runtime) == 1  # noqa: SLF001
 
 # --------------------------------------------------------------------------- #
-# from_yaml utility (original)                                                #
+# from_yaml utility                                                           #
 # --------------------------------------------------------------------------- #
 def test_from_yaml_minimal(tmp_path: Path, env: simpy.Environment) -> None:
-    """from_yaml() parses YAML, validates via Pydantic and returns a runner."""
+    """from_yaml() parses YAML, validates and returns a runner."""
     yml_payload = {
-        "rqs_input": {
-            "id": "gen-yaml",
-            "avg_active_users": {"mean": 1},
-            "avg_request_per_minute_per_user": {"mean": 2},
-            "user_sampling_window": 10,
-        },
+        "arrivals": {"id": "gen-yaml", "lambda_rps": 3.0, "model": "poisson"},
         "topology_graph": {
             "nodes": {"client": {"id": "cli-yaml"}, "servers": []},
             "edges": [],
@@ -138,90 +178,107 @@ def test_from_yaml_minimal(tmp_path: Path, env: simpy.Environment) -> None:
     runner = SimulationRunner.from_yaml(env=env, yaml_path=yml_path)
 
     assert isinstance(runner, SimulationRunner)
-    assert runner.rqs_generator.id == "gen-yaml"
+    assert runner.arrivals.id == "gen-yaml"
     assert runner.client.id == "cli-yaml"
 
 
+# --------------------------------------------------------------------------- #
+# Helpers for richer payloads                                                 #
+# --------------------------------------------------------------------------- #
 def _payload_with_lb_one_server_and_edges(
     *,
-    rqs_input: RqsGenerator,
+    arrivals: ArrivalsGenerator,
     sim_settings: SimulationSettings,
 ) -> SimulationPayload:
     """Build a small payload with LB → server wiring and one net edge."""
     client = Client(id="client-1")
-    server = Server(id="srv-1", server_resources=ServerResources(), endpoints=[])
+    server = Server(
+        id="srv-1",
+        server_resources=NodesResources(),
+        endpoints=[make_min_ep()],
+    )
     lb = LoadBalancer(id="lb-1")
     nodes = TopologyNodes(servers=[server], client=client, load_balancer=lb)
 
-    e_gen_lb = Edge(
+    e_gen_lb = NetworkEdge(
         id="gen-lb",
-        source=rqs_input.id,
+        source=arrivals.id,
         target=lb.id,
         latency=RVConfig(mean=0.001, distribution=Distribution.POISSON),
     )
-    e_lb_srv = Edge(
+    e_lb_srv = NetworkEdge(
         id="lb-srv",
         source=lb.id,
         target=server.id,
         latency=RVConfig(mean=0.002, distribution=Distribution.POISSON),
     )
-    e_net = Edge(
+    e_net = NetworkEdge(
         id="net-edge",
-        source=rqs_input.id,
+        source=arrivals.id,
         target=client.id,
         latency=RVConfig(mean=0.003, distribution=Distribution.POISSON),
     )
     graph = TopologyGraph(nodes=nodes, edges=[e_gen_lb, e_lb_srv, e_net])
 
     return SimulationPayload(
-        rqs_input=rqs_input,
+        arrivals=arrivals,
         topology_graph=graph,
         sim_settings=sim_settings,
     )
 
 
+# --------------------------------------------------------------------------- #
+# Additional builder tests                                                    #
+# --------------------------------------------------------------------------- #
 def test_make_inbox_bound_to_env_and_fifo(runner: SimulationRunner) -> None:
     """_make_inbox() binds to runner.env and behaves FIFO."""
     box = runner._make_inbox()  # noqa: SLF001
     assert isinstance(box, simpy.Store)
 
-    # Put two items and consume them in order using `run(until=...)`.
     env = runner.env
     env.run(until=box.put("first"))
     env.run(until=box.put("second"))
     got1 = env.run(until=box.get())
     got2 = env.run(until=box.get())
-    assert got1 == "first"
-    assert got2 == "second"
+    assert (got1, got2) == ("first", "second")
 
 
-def test_build_load_balancer_when_present(
-    env: simpy.Environment,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
+def test_build_load_balancer_when_present(env: simpy.Environment) -> None:
     """_build_load_balancer() should create `_lb_runtime` if LB exists."""
+    arrivals = ArrivalsGenerator(
+        id="gen",
+        lambda_rps=5.0,
+        model=Distribution.POISSON,
+    )
+    settings = SimulationSettings(total_simulation_time=5)
     payload = _payload_with_lb_one_server_and_edges(
-        rqs_input=rqs_input, sim_settings=sim_settings,
+        arrivals=arrivals,
+        sim_settings=settings,
     )
-    sr = SimulationRunner(env=env, simulation_input=payload)
 
+    sr = SimulationRunner(env=env, simulation_input=payload)
     sr._build_load_balancer()  # noqa: SLF001
+
     assert sr._lb_runtime is not None  # noqa: SLF001
     assert sr._lb_runtime.lb_config.id == "lb-1"  # noqa: SLF001
 
 
 def test_build_edges_populates_lb_out_edges_and_sources(
     env: simpy.Environment,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
 ) -> None:
     """_build_edges() wires generator→LB and populates `_lb_out_edges`."""
+    arrivals = ArrivalsGenerator(
+        id="gen",
+        lambda_rps=5.0,
+        model=Distribution.POISSON,
+    )
+    settings = SimulationSettings(total_simulation_time=5)
     payload = _payload_with_lb_one_server_and_edges(
-        rqs_input=rqs_input, sim_settings=sim_settings,
+        arrivals=arrivals,
+        sim_settings=settings,
     )
-    sr = SimulationRunner(env=env, simulation_input=payload)
 
+    sr = SimulationRunner(env=env, simulation_input=payload)
     sr._build_rqs_generator()  # noqa: SLF001
     sr._build_client()  # noqa: SLF001
     sr._build_servers()  # noqa: SLF001
@@ -230,19 +287,23 @@ def test_build_edges_populates_lb_out_edges_and_sources(
 
     assert "lb-srv" in sr._lb_out_edges  # noqa: SLF001
     assert len(sr._edges_runtime) >= 2  # noqa: SLF001
-    gen_rt = next(iter(sr._rqs_runtime.values()))  # noqa: SLF001
+    gen_rt = next(iter(sr._arrivals_runtime.values()))  # noqa: SLF001
     assert gen_rt.out_edge is not None
 
 
-def test_build_events_attaches_shared_views(
-    env: simpy.Environment,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """_build_events() attaches shared `edges_affected` and `edges_spike` views."""
+def test_build_events_attaches_shared_views(env: simpy.Environment) -> None:
+    """_build_events() attaches shared `edges_affected` & `edges_spike`."""
+    arrivals = ArrivalsGenerator(
+        id="gen",
+        lambda_rps=5.0,
+        model=Distribution.POISSON,
+    )
+    settings = SimulationSettings(total_simulation_time=5)
     payload = _payload_with_lb_one_server_and_edges(
-        rqs_input=rqs_input, sim_settings=sim_settings,
+        arrivals=arrivals,
+        sim_settings=settings,
     )
+
     spike = EventInjection(
         event_id="ev-spike",
         target_id="net-edge",
@@ -270,11 +331,10 @@ def test_build_events_attaches_shared_views(
     sr._build_events()  # noqa: SLF001
 
     assert sr._events_runtime is not None  # noqa: SLF001
-    events_rt = sr._events_runtime # noqa: SLF001
+    events_rt = sr._events_runtime  # noqa: SLF001
 
     assert "net-edge" in events_rt.edges_affected
     for er in sr._edges_runtime.values():  # noqa: SLF001
         assert er.edges_spike is not None
         assert er.edges_affected is events_rt.edges_affected
 
-
diff --git a/tests/unit/runner/test_sweep.py b/tests/unit/runner/test_sweep.py
new file mode 100644
index 0000000..137df05
--- /dev/null
+++ b/tests/unit/runner/test_sweep.py
@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from itertools import pairwise
+from typing import TYPE_CHECKING, ClassVar, cast
+
+import pytest
+
+from asyncflow.config.enums import TimeDefaults
+from asyncflow.runner.sweep import Sweep
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.payload import SimulationPayload
+from asyncflow.schemas.settings.simulation import SimulationSettings
+from asyncflow.schemas.topology.graph import TopologyGraph
+from asyncflow.schemas.topology.nodes import Client, TopologyNodes
+
+if TYPE_CHECKING:
+    import simpy
+
+    from asyncflow.metrics.simulation_analyzer import ResultsAnalyzer
+    from asyncflow.runner.simulation import SimulationRunner
+
+
+def _make_min_payload(
+    *,
+    sim_time: int = TimeDefaults.MIN_SIMULATION_TIME,
+    lambda_rps: float = 20.0,
+) -> SimulationPayload:
+    """Return a minimal, validated payload (client only, no servers)."""
+    arrivals = ArrivalsGenerator(id="gen", lambda_rps=lambda_rps, model="poisson")
+    client = Client(id="cli")
+    nodes = TopologyNodes(servers=[], client=client, load_balancer=None)
+    graph = TopologyGraph(nodes=nodes, edges=[])
+    settings = SimulationSettings(total_simulation_time=sim_time)
+    return SimulationPayload(
+        arrivals=arrivals, topology_graph=graph, sim_settings=settings)
+
+
+class _DummyAnalyzer:
+    """Trivial object we return as analyzer surrogate in the fake runner."""
+
+    def __init__(self, tag: int) -> None:
+        self.tag = tag
+        """instance for the analyzer"""
+
+
+class FakeSimulationRunner:
+    """Test double: records calls and returns a dummy analyzer."""
+
+    run_calls: ClassVar[list[tuple[simpy.Environment, SimulationPayload]]] = []
+
+    def __init__(
+        self,
+        *,
+        env: simpy.Environment,
+        simulation_input: SimulationPayload,
+    ) -> None:
+        """Instance for the fakerunner"""
+        self.env = env
+        self.payload = simulation_input
+
+
+    def run(self) -> ResultsAnalyzer:
+        """Function to return the resultanalyzer after the simulation"""
+        FakeSimulationRunner.run_calls.append((self.env, self.payload))
+        tag = int(self.payload.arrivals.lambda_rps)
+        return cast("ResultsAnalyzer", _DummyAnalyzer(tag))
+
+
+@pytest.fixture(autouse=True)
+def _reset_fake_runner() -> None:
+    FakeSimulationRunner.run_calls.clear()
+
+
+def test_sweep_on_user_inclusive_grid_and_preserves_payload() -> None:
+    payload = _make_min_payload(lambda_rps=7.0)
+    sweeper = Sweep(
+        simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner),
+    )
+
+    res = sweeper.sweep_on_lambda(
+        payload=payload, lambda_lower_bound=2, lambda_upper_bound=6, step=2,
+    )
+
+    assert [u for (u, _a) in res] == [2, 4, 6]
+    assert sweeper._last_lambda_grid == [2, 4, 6]  # noqa: SLF001
+
+    assert payload.arrivals.lambda_rps == 7.0
+
+    seen = [int(p.arrivals.lambda_rps) for (_e, p) in FakeSimulationRunner.run_calls]
+    assert seen, "Expected at least one sweep point."
+    assert min(seen) >= 2
+    assert max(seen) <= 6
+
+    diffs = [b - a for a, b in pairwise(seen)]
+    assert all(d % 2 == 0 for d in diffs)
+
+    for (_e, p) in FakeSimulationRunner.run_calls:
+        assert p is not payload
+
+
+def test_sweep_on_user_creates_fresh_env_per_run() -> None:
+    """Test to assert new sweep on a new env"""
+    payload = _make_min_payload()
+    sweeper = Sweep(
+        simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner),
+    )
+
+    _ = sweeper.sweep_on_lambda(
+        payload=payload, lambda_lower_bound=1, lambda_upper_bound=3, step=1,
+    )
+
+    env_ids = [id(e) for (e, _p) in FakeSimulationRunner.run_calls]
+    assert len(set(env_ids)) == 3
+    assert all(e.now == 0 for (e, _p) in FakeSimulationRunner.run_calls)
+
+
+@pytest.mark.parametrize(
+    ("lo", "hi", "step", "msg_substr"),
+    [
+        (1, 5, 0, "step must be > 0"),
+        (0, 5, 1, "strictly bigger than 0"),
+        (1, 0, 1, "strictly bigger than 0"),
+        (5, 1, 1, "lambda_upper_bound must be >= lambda_lower_bound"),
+    ],
+)
+def test_sweep_on_user_invalid_inputs_raise(
+    lo: int, hi: int, step: int, msg_substr: str,
+) -> None:
+    """Test to assert return of error on invalid input"""
+    payload = _make_min_payload()
+    sweeper = Sweep(
+        simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner),
+    )
+
+    with pytest.raises(ValueError, match=msg_substr):
+        sweeper.sweep_on_lambda(
+            payload=payload,
+            lambda_lower_bound=lo,
+            lambda_upper_bound=hi,
+            step=step,
+        )
+
+
+def test_sweep_on_user_returns_pairs_with_analyzers() -> None:
+    """Test to assert correct pairs are returned"""
+    payload = _make_min_payload()
+    sweeper = Sweep(
+        simulation_cls=cast("type[SimulationRunner]", FakeSimulationRunner),
+    )
+
+    res = sweeper.sweep_on_lambda(
+        payload=payload, lambda_lower_bound=2, lambda_upper_bound=4, step=1,
+    )
+
+    users_list = [u for (u, _a) in res]
+    assert users_list == [2, 3, 4]
+
+    tags = [getattr(a, "tag", None) for (_u, a) in res]
+    assert tags == [2, 3, 4]
diff --git a/tests/unit/runtime/actors/test_arrivals_generator_rt.py b/tests/unit/runtime/actors/test_arrivals_generator_rt.py
new file mode 100644
index 0000000..9d229f6
--- /dev/null
+++ b/tests/unit/runtime/actors/test_arrivals_generator_rt.py
@@ -0,0 +1,123 @@
+"""Unit tests for :class:`ArrivalsGeneratorRuntime` with the new arrivals API."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import pytest
+import simpy
+
+from asyncflow.runtime.actors.arrivals_generator import ArrivalsGeneratorRuntime
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterator
+
+    from numpy.random import Generator as NpGenerator
+
+    from asyncflow.runtime.actors.edge import EdgeRuntime
+    from asyncflow.runtime.rqs_state import RequestState
+    from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+    from asyncflow.schemas.settings.simulation import SimulationSettings
+
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+class _DummyEdgeRuntime:
+    """Minimal stub capturing transported :class:`RequestState`."""
+
+    def __init__(self) -> None:
+        self.received: list[RequestState] = []
+
+    def transport(self, state: RequestState) -> None:
+        """Collect every state passed through the edge."""
+        self.received.append(state)
+
+
+def _make_runtime(
+    env: simpy.Environment,
+    edge: _DummyEdgeRuntime,
+    arrivals: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
+    *,
+    seed: int = 0,
+) -> ArrivalsGeneratorRuntime:
+    """Factory returning a fully wired :class:`ArrivalsGeneratorRuntime`."""
+    rng: NpGenerator = np.random.default_rng(seed)
+    return ArrivalsGeneratorRuntime(
+        env=env,
+        out_edge=cast("EdgeRuntime", edge),
+        arrivals=arrivals,
+        sim_settings=sim_settings,
+        rng=rng,
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Tests                                                                        #
+# --------------------------------------------------------------------------- #
+def test_event_arrival_generates_expected_number_of_requests(
+    monkeypatch: pytest.MonkeyPatch,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
+) -> None:
+    """Given deterministic gaps, exactly that many requests are sent."""
+    gaps = [1.0, 2.0, 3.0]
+    called = {"count": 0}
+
+    def _fake_general_interarrivals(**_: object) -> Iterator[float]:
+        called["count"] += 1
+        yield from gaps
+
+    # Patch the *bound* symbol used inside the runtime module.
+    monkeypatch.setattr(
+        "asyncflow.runtime.actors.arrivals_generator.general_interarrivals",
+        _fake_general_interarrivals,
+        raising=True,
+    )
+
+    env = simpy.Environment()
+    edge = _DummyEdgeRuntime()
+    runtime = _make_runtime(env, edge, arrivals_gen, sim_settings)
+
+    env.process(runtime._event_arrival())  # noqa: SLF001
+    env.run(until=sum(gaps) + 0.1)
+
+    # Sampler called once and exactly len(gaps) states delivered.
+    assert called["count"] == 1
+    assert len(edge.received) == len(gaps)
+
+    # IDs are 1..n, and initial_time equals cumulative gaps (exact in SimPy).
+    cumul = 0.0
+    for i, st in enumerate(edge.received, start=1):
+        cumul += gaps[i - 1]
+        assert st.id == i
+        assert st.initial_time == pytest.approx(cumul, rel=0, abs=1e-12)
+
+
+def test_start_returns_process_and_runs(
+    monkeypatch: pytest.MonkeyPatch,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
+) -> None:
+    """`start()` returns a SimPy process and triggers transports."""
+    gaps = [0.05]
+
+    def _fake_general_interarrivals(**_: object) -> Iterator[float]:
+        yield from gaps
+
+    monkeypatch.setattr(
+        "asyncflow.runtime.actors.arrivals_generator.general_interarrivals",
+        _fake_general_interarrivals,
+        raising=True,
+    )
+
+    env = simpy.Environment()
+    edge = _DummyEdgeRuntime()
+    runtime = _make_runtime(env, edge, arrivals_gen, sim_settings)
+
+    proc = runtime.start()
+    assert isinstance(proc, simpy.events.Process)
+
+    env.run(until=sum(gaps) + 0.01)
+    assert len(edge.received) == 1
diff --git a/tests/unit/runtime/actors/test_client.py b/tests/unit/runtime/actors/test_client_rt.py
similarity index 98%
rename from tests/unit/runtime/actors/test_client.py
rename to tests/unit/runtime/actors/test_client_rt.py
index d78c848..cf3dc96 100644
--- a/tests/unit/runtime/actors/test_client.py
+++ b/tests/unit/runtime/actors/test_client_rt.py
@@ -4,7 +4,7 @@
 
 import simpy
 
-from asyncflow.config.constants import SystemEdges, SystemNodes
+from asyncflow.config.enums import SystemEdges, SystemNodes
 from asyncflow.runtime.actors.client import ClientRuntime
 from asyncflow.runtime.rqs_state import RequestState
 from asyncflow.schemas.topology.nodes import Client
diff --git a/tests/unit/runtime/actors/test_edge.py b/tests/unit/runtime/actors/test_edge_rt.py
similarity index 80%
rename from tests/unit/runtime/actors/test_edge.py
rename to tests/unit/runtime/actors/test_edge_rt.py
index 1800a12..4131303 100644
--- a/tests/unit/runtime/actors/test_edge.py
+++ b/tests/unit/runtime/actors/test_edge_rt.py
@@ -4,20 +4,24 @@
 * connection-counter bookkeeping
 * public properties (`enabled_metrics`, `concurrent_connections`)
 """
-
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, cast
 
 import simpy
 
-from asyncflow.config.constants import SampledMetricName, SystemEdges, SystemNodes
+from asyncflow.config.enums import (
+    Distribution,
+    SampledMetricName,
+    SystemEdges,
+    SystemNodes,
+)
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.rqs_state import RequestState
 from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import NetworkEdge
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     import numpy as np
 
     from asyncflow.schemas.settings.simulation import SimulationSettings
@@ -26,34 +30,32 @@
 # --------------------------------------------------------------------------- #
 # Dummy RNG                                                                   #
 # --------------------------------------------------------------------------- #
-
-
 class DummyRNG:
-    """Return preset values for ``uniform`` and ``normal``."""
+    """Return preset values for ``uniform`` and ``exponential``."""
 
-    def __init__(self, *, uniform_value: float, normal_value: float = 0.0) -> None:
-        """To complete"""
+    def __init__(self, *, uniform_value: float, exp_value: float = 0.0) -> None:
+        """Instance for the RNG for tests"""
         self.uniform_value = uniform_value
-        self.normal_value = normal_value
+        self.exp_value = exp_value
         self.uniform_called = False
-        self.normal_called = False
+        self.exp_called = False
 
-    def uniform(self) -> float:  # called by EdgeRuntime
-        """To complete"""
+    # EdgeRuntime uses .uniform() for drop decision
+    def uniform(self) -> float:
+        """Uniform rng"""
         self.uniform_called = True
         return self.uniform_value
 
-    def normal(self, _mean: float, _sigma: float) -> float:  # called by sampler
-        """To complete"""
-        self.normal_called = True
-        return self.normal_value
+    # Latency sampler calls .exponential(scale)
+    def exponential(self, scale: float) -> float:  # noqa: ARG002
+        """Exp rng"""
+        self.exp_called = True
+        return self.exp_value
 
 
 # --------------------------------------------------------------------------- #
 # Minimal stub for SimulationSettings                                         #
 # --------------------------------------------------------------------------- #
-
-
 class _SettingsStub:
     """Only the attributes required by EdgeRuntime/build_edge_metrics."""
 
@@ -65,24 +67,22 @@ def __init__(self, enabled_sample_metrics: set[SampledMetricName]) -> None:
 # --------------------------------------------------------------------------- #
 # Helper factory                                                              #
 # --------------------------------------------------------------------------- #
-
-
 def _make_edge(
     env: simpy.Environment,
     *,
     uniform_value: float,
-    normal_value: float = 0.0,
+    exp_value: float = 0.0,
     dropout_rate: float = 0.0,
 ) -> tuple[EdgeRuntime, DummyRNG, simpy.Store]:
     """Create a fully wired :class:`EdgeRuntime` + associated objects."""
-    rng = DummyRNG(uniform_value=uniform_value, normal_value=normal_value)
+    rng = DummyRNG(uniform_value=uniform_value, exp_value=exp_value)
     store: simpy.Store = simpy.Store(env)
 
-    edge_cfg = Edge(
+    edge_cfg = NetworkEdge(
         id="edge-1",
         source="src",
         target="dst",
-        latency=RVConfig(mean=1.0, variance=1.0, distribution="normal"),
+        latency=RVConfig(mean=1.0, distribution=Distribution.EXPONENTIAL),
         dropout_rate=dropout_rate,
     )
 
@@ -103,15 +103,13 @@ def _make_edge(
 # --------------------------------------------------------------------------- #
 # Tests                                                                       #
 # --------------------------------------------------------------------------- #
-
-
 def test_edge_delivers_message() -> None:
     """A request traverses the edge when `uniform >= dropout_rate`."""
     env = simpy.Environment()
     edge_rt, rng, store = _make_edge(
         env,
         uniform_value=0.9,
-        normal_value=0.5,
+        exp_value=0.5,
         dropout_rate=0.2,
     )
 
@@ -132,7 +130,7 @@ def test_edge_delivers_message() -> None:
 
     # RNG calls
     assert rng.uniform_called is True
-    assert rng.normal_called is True
+    assert rng.exp_called is True
 
     # counter restored
     assert edge_rt.concurrent_connections == 0
@@ -160,14 +158,14 @@ def test_edge_drops_message() -> None:
 
     # RNG calls
     assert rng.uniform_called is True
-    assert rng.normal_called is False
+    assert rng.exp_called is False
 
     # counter unchanged
     assert edge_rt.concurrent_connections == 0
 
 
 def test_metric_dict_initialised_and_mutable() -> None:
-    """`enabled_metrics` exposes the default key and supports list append."""
+    """`enabled_metrics` exposes the key and supports list append."""
     env = simpy.Environment()
     edge_rt, _rng, _store = _make_edge(
         env,
@@ -182,4 +180,3 @@ def test_metric_dict_initialised_and_mutable() -> None:
     # Simulate a collector append
     edge_rt.enabled_metrics[key].append(5)
     assert edge_rt.enabled_metrics[key] == [5]
-
diff --git a/tests/unit/runtime/actors/test_lb_algo.py b/tests/unit/runtime/actors/test_lb_algo.py
new file mode 100644
index 0000000..7a0ebb7
--- /dev/null
+++ b/tests/unit/runtime/actors/test_lb_algo.py
@@ -0,0 +1,103 @@
+"""Unit tests for LB algorithms (FCFS picker, RR, LC, Random).
+
+Covers:
+- FCFS 'picker' semantics (no mutation, respect of busy map).
+- Side-effects on the OrderedDict for RR (rotation).
+- Deterministic behavior of random_choice via monkeypatch.
+- LB_TABLE wiring (FCFS is handled outside the table).
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import TYPE_CHECKING, cast
+
+from asyncflow.config.enums import LbAlgorithmsName
+from asyncflow.runtime.actors.routing.lb_algorithms import (
+    LB_TABLE,
+    least_connections,
+    random_choice,
+    round_robin,
+)
+
+if TYPE_CHECKING:
+    import pytest
+
+    from asyncflow.runtime.actors.edge import EdgeRuntime
+
+
+class _DummyEdge:
+    """Minimal stub exposing only what algorithms read."""
+
+    def __init__(self, cc: int) -> None:
+        self.concurrent_connections = cc
+
+    def __repr__(self) -> str:
+        return f"DummyEdge(cc={self.concurrent_connections})"
+
+
+def _mk_edges(pairs: list[tuple[str, int]]) -> OrderedDict[str, _DummyEdge]:
+    """Build an OrderedDict of dummy edges from (key, concurrent_conns)."""
+    return OrderedDict((k, _DummyEdge(cc)) for k, cc in pairs)
+
+
+# ----------------------------- Other algorithms ----------------------------- #
+
+def test_round_robin_rotates_and_returns_first() -> None:
+    """RR returns first edge and rotates it to the end."""
+    od = _mk_edges([("a", 0), ("b", 0), ("c", 0)])
+    first = next(iter(od.values()))
+    edges = cast("OrderedDict[str, EdgeRuntime]", od)
+
+    e = cast("_DummyEdge", round_robin(edges))
+    assert e is first
+    assert list(od.keys()) == ["b", "c", "a"], "must rotate order"
+
+
+def test_least_connections_picks_minimal() -> None:
+    """LC must choose the edge with the smallest concurrent connections."""
+    od = _mk_edges([("a", 3), ("b", 1), ("c", 2)])
+    edges = cast("OrderedDict[str, EdgeRuntime]", od)
+
+    e = cast("_DummyEdge", least_connections(edges))
+    assert e is od["b"]
+
+
+def test_least_connections_tie_prefers_first_minimal() -> None:
+    """On ties, min() returns the first minimal by insertion order."""
+    od = _mk_edges([("a", 2), ("b", 1), ("c", 1), ("d", 3)])
+    edges = cast("OrderedDict[str, EdgeRuntime]", od)
+
+    e = cast("_DummyEdge", least_connections(edges))
+    assert e is od["b"], "first minimal should be selected"
+
+
+def test_random_choice_monkeypatched_index(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """random_choice should pick edge at the patched index."""
+    od = _mk_edges([("a", 0), ("b", 0), ("c", 0)])
+    edges = cast("OrderedDict[str, EdgeRuntime]", od)
+
+    def _fake_randrange(n: int) -> int:
+        assert n == 3
+        return 1  # pick key 'b'
+
+    monkeypatch.setattr(
+        "asyncflow.runtime.actors.routing.lb_algorithms.random.randrange",
+        _fake_randrange,
+    )
+
+    e = cast("_DummyEdge", random_choice(edges))
+    assert e is od["b"]
+
+
+# ------------------------------ LB_TABLE wiring ----------------------------- #
+
+def test_lb_table_wiring_has_no_fcfs() -> None:
+    """FCFS is handled by the LB runtime; it must not be in LB_TABLE."""
+    table = LB_TABLE
+    assert LbAlgorithmsName.FCFS not in table
+    assert table[LbAlgorithmsName.ROUND_ROBIN] is round_robin
+    assert table[LbAlgorithmsName.LEAST_CONNECTIONS] is least_connections
+    assert table[LbAlgorithmsName.RANDOM] is random_choice
diff --git a/tests/unit/runtime/actors/test_load_balancer.py b/tests/unit/runtime/actors/test_load_balancer_rt.py
similarity index 53%
rename from tests/unit/runtime/actors/test_load_balancer.py
rename to tests/unit/runtime/actors/test_load_balancer_rt.py
index 94c372d..55e9284 100644
--- a/tests/unit/runtime/actors/test_load_balancer.py
+++ b/tests/unit/runtime/actors/test_load_balancer_rt.py
@@ -2,16 +2,19 @@
 
 from __future__ import annotations
 
+import math
 from collections import OrderedDict
 from typing import TYPE_CHECKING, cast
 
 import simpy
 
-from asyncflow.config.constants import LbAlgorithmsName, SystemNodes
+from asyncflow.config.enums import LbAlgorithmsName, SystemNodes
 from asyncflow.runtime.actors.load_balancer import LoadBalancerRuntime
 from asyncflow.schemas.topology.nodes import LoadBalancer
 
 if TYPE_CHECKING:
+    from collections.abc import Generator as TypingGenerator
+
     from asyncflow.runtime.actors.edge import EdgeRuntime
 
 
@@ -129,3 +132,121 @@ def test_no_edges_is_noop(env: simpy.Environment) -> None:
     lb.start()
     # No events in the env; this should simply return without error.
     env.run()
+
+
+
+# --------------------------------------------------------------------------- #
+# New FCFS (FIFO tokens) tests                                                #
+# --------------------------------------------------------------------------- #
+
+def test_fcfs_immediate_edge_means_zero_wait(env: simpy.Environment) -> None:
+    """If an edge is already available, no waiting time is recorded (only >0)."""
+    edge = DummyEdge("srv-A")
+    lb = make_lb_runtime(env, LbAlgorithmsName.FCFS, [edge])
+
+    # Immediate request: token is already primed, so Wq=0 (not recorded)
+    lb.lb_box.put(DummyState())
+    env.run()
+
+    assert len(edge.received) == 1
+    # LB only records times > 0: no wait ⇒ no entry
+    assert list(lb.lb_waiting_times) == [0.0]
+
+
+def test_fcfs_wait_until_edge_added(env: simpy.Environment) -> None:
+    """
+    No edge at startup: the request waits until we add an edge,
+    then LB measures Wq ≈ Δt.
+    """
+    lb_cfg = LoadBalancer(
+        id="lb-1",
+        algorithms=LbAlgorithmsName.FCFS,
+        server_covered=set(),
+    )
+    inbox: simpy.Store = simpy.Store(env)
+
+    # Start with no edges
+    od: OrderedDict[str, EdgeRuntime] = cast(
+        "OrderedDict[str, EdgeRuntime]",
+        OrderedDict(),  # initially empty
+    )
+
+    lb = LoadBalancerRuntime(
+        env=env,
+        lb_config=lb_cfg,
+        lb_out_edges=od,
+        lb_box=inbox,
+    )
+    lb.start()
+
+    # One request arrives at t=0
+    inbox.put(DummyState())
+
+    # After 5s we add an edge and notify LB
+    edge = DummyEdge("srv-A")
+
+    def add_edge_after_5s() -> TypingGenerator[simpy.events.Event, None, None]:
+        yield env.timeout(5.0)
+        lb.lb_out_edges["srv-A"] = cast("EdgeRuntime", edge)
+        lb.on_edge_added("srv-A")
+
+    env.process(add_edge_after_5s())
+    env.run()
+
+    assert len(edge.received) == 1
+    waits = list(lb.lb_waiting_times)
+    assert len(waits) == 1
+    assert math.isclose(waits[0], 5.0, rel_tol=1e-6, abs_tol=1e-6)
+
+
+def test_fcfs_stale_token_is_discarded(env: simpy.Environment) -> None:
+    """
+    If a token exists but the edge is removed before a request arrives,
+    that token becomes stale and must be discarded. The request waits until
+    a valid edge is re-added and notified.
+    """
+    # Start with one edge (it will be removed, leaving a stale token in the FIFO)
+    first_edge = DummyEdge("srv-old")
+    lb = make_lb_runtime(env, LbAlgorithmsName.FCFS, [first_edge])
+
+    # Remove the edge before the request arrives (stale token left behind)
+    lb.lb_out_edges.pop("srv-old", None)
+
+    # Request arrives at t=0 → consumes stale token (discarded)
+    lb.lb_box.put(DummyState())
+
+    # At t=7s add a new edge and notify LB
+    new_edge = DummyEdge("srv-new")
+
+    def readd_after_7s() -> TypingGenerator[simpy.events.Event, None, None]:
+        yield env.timeout(7.0)
+        lb.lb_out_edges["srv-new"] = cast("EdgeRuntime", new_edge)
+        lb.on_edge_added("srv-new")
+
+    env.process(readd_after_7s())
+    env.run()
+
+    assert len(new_edge.received) == 1
+    waits = list(lb.lb_waiting_times)
+    assert len(waits) == 1
+    # The waiting time should be ~7s
+    assert math.isclose(waits[0], 7.0, rel_tol=1e-6, abs_tol=1e-6)
+
+
+def test_fcfs_fifo_order_preserved(env: simpy.Environment) -> None:
+    """
+    With two initial edges, two requests must use the tokens in the
+    same order as insertion (FIFO).
+    """
+    e0 = DummyEdge("srv-0")
+    e1 = DummyEdge("srv-1")
+    # OrderedDict in make_lb_runtime preserves order: srv-0, then srv-1
+    lb = make_lb_runtime(env, LbAlgorithmsName.FCFS, [e0, e1])
+
+    lb.lb_box.put(DummyState())
+    lb.lb_box.put(DummyState())
+    env.run()
+
+    # First request → first edge, second request → second edge
+    assert len(e0.received) == 1
+    assert len(e1.received) == 1
diff --git a/tests/unit/runtime/actors/test_rqs_generator.py b/tests/unit/runtime/actors/test_rqs_generator.py
deleted file mode 100644
index fef5987..0000000
--- a/tests/unit/runtime/actors/test_rqs_generator.py
+++ /dev/null
@@ -1,151 +0,0 @@
-"""Unit-tests for the :class:`RqsGeneratorRuntime` dispatcher and event flow."""
-from __future__ import annotations
-
-from collections.abc import Iterator
-from typing import TYPE_CHECKING, cast
-
-import numpy as np
-import simpy
-
-from asyncflow.config.constants import Distribution
-from asyncflow.runtime.actors.rqs_generator import RqsGeneratorRuntime
-
-if TYPE_CHECKING:
-
-    import pytest
-    from numpy.random import Generator
-
-    from asyncflow.runtime.actors.edge import EdgeRuntime
-    from asyncflow.runtime.rqs_state import RequestState
-    from asyncflow.schemas.settings.simulation import SimulationSettings
-    from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-import importlib
-
-# --------------------------------------------------------------------------- #
-# Helpers                                                                     #
-# --------------------------------------------------------------------------- #
-
-
-class DummyEdgeRuntime:
-    """Minimal stub capturing transported :class:`RequestState`."""
-
-    def __init__(self) -> None:
-        """Definition of the attributes"""
-        self.received: list[RequestState] = []
-
-    def transport(self, state: RequestState) -> None:
-        """Collect every state passed through the edge."""
-        self.received.append(state)
-
-
-def _make_runtime(
-    env: simpy.Environment,
-    edge: DummyEdgeRuntime,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-    *,
-    seed: int = 0,
-) -> RqsGeneratorRuntime:
-    """Factory returning a fully wired :class:`RqsGeneratorRuntime`."""
-    rng: Generator = np.random.default_rng(seed)
-    return RqsGeneratorRuntime(
-        env=env,
-        out_edge=cast("EdgeRuntime", edge),
-        rqs_generator_data=rqs_input,
-        sim_settings=sim_settings,
-        rng=rng,
-    )
-
-
-# --------------------------------------------------------------------------- #
-# Dispatcher behaviour                                                        #
-# --------------------------------------------------------------------------- #
-
-
-RGR_MODULE = importlib.import_module("asyncflow.runtime.actors.rqs_generator")
-
-def test_dispatcher_selects_poisson_poisson(
-    monkeypatch: pytest.MonkeyPatch,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Default (Poisson) distribution must invoke *poisson_poisson_sampling*."""
-    called = {"pp": False}
-
-    def _fake_pp(*args: object, **kwargs: object) -> Iterator[float]:
-        called["pp"] = True
-        return iter(())  # iterator already exhausted
-
-    monkeypatch.setattr(RGR_MODULE, "poisson_poisson_sampling", _fake_pp)
-
-    env = simpy.Environment()
-    edge = DummyEdgeRuntime()
-    runtime = _make_runtime(env, edge, rqs_input, sim_settings)
-
-    gen = runtime._requests_generator()  # noqa: SLF001
-    for _ in gen:
-        pass
-
-    assert called["pp"] is True
-    assert isinstance(gen, Iterator)
-
-
-def test_dispatcher_selects_gaussian_poisson(
-    monkeypatch: pytest.MonkeyPatch,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Normal distribution must invoke *gaussian_poisson_sampling*."""
-    rqs_input.avg_active_users.distribution = Distribution.NORMAL
-    called = {"gp": False}
-
-    def _fake_gp(*args: object, **kwargs: object) -> Iterator[float]:
-        called["gp"] = True
-        return iter(())
-
-    monkeypatch.setattr(RGR_MODULE, "gaussian_poisson_sampling", _fake_gp)
-
-    env = simpy.Environment()
-    edge = DummyEdgeRuntime()
-    runtime = _make_runtime(env, edge, rqs_input, sim_settings)
-
-    gen = runtime._requests_generator()  # noqa: SLF001
-    for _ in gen:
-        pass
-
-    assert called["gp"] is True
-    assert isinstance(gen, Iterator)
-
-# --------------------------------------------------------------------------- #
-# Event-arrival flow                                                          #
-# --------------------------------------------------------------------------- #
-
-
-def test_event_arrival_generates_expected_number_of_requests(
-    monkeypatch: pytest.MonkeyPatch,
-    rqs_input: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Given a deterministic gap list, exactly that many requests are sent."""
-    gaps = [1.0, 2.0, 3.0]
-
-    def _fake_gen(self: object) -> Iterator[float]:
-        yield from gaps
-
-    monkeypatch.setattr(
-        RqsGeneratorRuntime,
-        "_requests_generator",
-        _fake_gen,
-    )
-
-    env = simpy.Environment()
-    edge = DummyEdgeRuntime()
-    runtime = _make_runtime(env, edge, rqs_input, sim_settings)
-
-    env.process(runtime._event_arrival()) # noqa: SLF001
-    env.run(until=sum(gaps) + 0.1)  # run slightly past the last gap
-
-    assert len(edge.received) == len(gaps)
-    ids = [s.id for s in edge.received]
-    assert ids == [1, 2, 3]
diff --git a/tests/unit/runtime/actors/test_server.py b/tests/unit/runtime/actors/test_server_rt.py
similarity index 53%
rename from tests/unit/runtime/actors/test_server.py
rename to tests/unit/runtime/actors/test_server_rt.py
index f5ff2ef..b05ea4c 100644
--- a/tests/unit/runtime/actors/test_server.py
+++ b/tests/unit/runtime/actors/test_server_rt.py
@@ -19,22 +19,28 @@
 
 from typing import TYPE_CHECKING
 
+import pytest
 import simpy
+from numpy.random import Generator as NpGenerator
 from numpy.random import default_rng
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     EndpointStepCPU,
     EndpointStepIO,
     EndpointStepRAM,
+    EventMetricName,
     SampledMetricName,
     StepOperation,
 )
+from asyncflow.metrics.server import ServerClock
 from asyncflow.resources.server_containers import build_containers
+from asyncflow.runtime.actors import server as server_mod
 from asyncflow.runtime.actors.server import ServerRuntime
 from asyncflow.runtime.rqs_state import RequestState
+from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.settings.simulation import SimulationSettings
 from asyncflow.schemas.topology.endpoint import Endpoint, Step
-from asyncflow.schemas.topology.nodes import Server, ServerResources
+from asyncflow.schemas.topology.nodes import NodesResources, Server
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
@@ -96,7 +102,7 @@ def _make_server_runtime(
     steps: Iterable[Step] | None = None,
 ) -> tuple[ServerRuntime, simpy.Store]:
     """Return a (ServerRuntime, sink) ready for injection tests."""
-    res_spec = ServerResources(cpu_cores=cpu_cores, ram_mb=ram_mb)
+    res_spec = NodesResources(cpu_cores=cpu_cores, ram_mb=ram_mb)
     containers = build_containers(env, res_spec)
 
     endpoint = _mk_endpoint(steps if steps is not None else _default_steps())
@@ -319,7 +325,7 @@ def test_ram_gating_blocks_before_ready() -> None:
     """When RAM is scarce, blocks on RAM and must NOT inflate ready."""
     env = simpy.Environment()
 
-    # Respect ServerResources(min RAM = 256).
+    # Respect NodesResources(min RAM = 256).
     # Endpoint needs 256 MB → second request waits on RAM (not in ready).
     steps = (
         Step(
@@ -366,3 +372,244 @@ def test_enabled_metrics_dict_populated() -> None:
         SampledMetricName.EVENT_LOOP_IO_SLEEP,
     }
     assert mandatory.issubset(server.enabled_metrics.keys())
+
+
+# --------------------------------------------------------------------------- #
+# CPU step: RVConfig is sampled via general_sampler                           #
+# --------------------------------------------------------------------------- #
+
+def test_cpu_step_uses_rvconfig_sample(monkeypatch: pytest.MonkeyPatch) -> None:
+    """CPU step duration follows the (patched) sampler result."""
+    # Patch sampler: return 7 ms when mean=0.123 (CPU sentinel)
+    def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float:
+        return 0.007 if cfg.mean == 0.123 else 0.0
+
+    monkeypatch.setattr(server_mod, "general_sampler", fake_sampler)
+
+    env = simpy.Environment()
+    steps = (
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 64},
+        ),
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: RVConfig(mean=0.123)},
+        ),
+        Step(
+            kind=EndpointStepIO.WAIT,
+            step_operation={StepOperation.IO_WAITING_TIME: 0.010},
+        ),
+    )
+    server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1)
+    cpu = server.server_resources["CPU"]
+
+    server.server_box.put(RequestState(id=100, initial_time=0.0))
+    server.start()
+
+    # During CPU (7 ms)
+    env.run(until=0.004)
+    assert cpu.level == 0  # 1 core, held
+    # After CPU finished
+    env.run(until=0.008)
+    assert cpu.level == 1  # released
+
+
+# --------------------------------------------------------------------------- #
+# IO step: RVConfig is sampled via general_sampler                            #
+# --------------------------------------------------------------------------- #
+
+def test_io_step_uses_rvconfig_sample(monkeypatch: pytest.MonkeyPatch) -> None:
+    """IO step duration follows the (patched) sampler result."""
+    # Patch sampler: return 15 ms when mean=0.456 (IO sentinel)
+    def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float:
+        return 0.015 if cfg.mean == 0.456 else 0.0
+
+    monkeypatch.setattr(server_mod, "general_sampler", fake_sampler)
+
+    env = simpy.Environment()
+    steps = (
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 64},
+        ),
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: 0.002},
+        ),
+        Step(
+            kind=EndpointStepIO.DB,
+            step_operation={StepOperation.IO_WAITING_TIME: RVConfig(mean=0.456)},
+        ),
+    )
+    server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1)
+
+    server.server_box.put(RequestState(id=200, initial_time=0.0))
+    server.start()
+
+    # After CPU (2 ms), inside IO (15 ms total)
+    env.run(until=0.010)
+    assert server.io_queue_len == 1
+    # After IO finished
+    env.run(until=0.020)
+    assert server.io_queue_len == 0
+
+
+# --------------------------------------------------------------------------- #
+# Helpers: _compute_latency_cpu/_io dispatch to sampler and accept ints/floats #
+# --------------------------------------------------------------------------- #
+
+def test_helpers_sample_and_deterministic(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Helpers use sampler for RVConfig and accept int/float deterministics."""
+    # Patch sampler to a fixed value
+    def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float:
+        return 0.123
+
+    monkeypatch.setattr(server_mod, "general_sampler", fake_sampler)
+
+    # Minimal runtime just to call methods
+    env = simpy.Environment()
+
+    # Call unbound methods with a real ServerRuntime instance to be safe
+    # (we can build one via the existing factory)
+    server, _ = _make_server_runtime(env)
+
+    # RVConfig paths
+    assert server._compute_latency_cpu(RVConfig(mean=1.0)) == pytest.approx(0.123) # noqa: SLF001
+    assert server._compute_latency_io(RVConfig(mean=1.0)) == pytest.approx(0.123) # noqa: SLF001
+
+    # Deterministic int/float paths
+    assert server._compute_latency_cpu(2) == pytest.approx(2.0) # noqa: SLF001
+    assert server._compute_latency_io(0.5) == pytest.approx(0.5) # noqa: SLF001
+
+
+def test_server_clock_and_cumulative_metrics_default_pipeline() -> None:
+    """
+    Single request on default pipeline:
+    - SERVICE_TIME should equal CPU(5ms)
+    - IO_TIME should equal I/O(20ms)
+    - WAITING_TIME should be ~0 (2 cores, no contention)
+    - RQS_SERVER_CLOCK has start/finish with finish > start
+    """
+    env = simpy.Environment()
+    server, _ = _make_server_runtime(env)  # default: 2 cores, default steps
+
+    req_id = 301
+    server.server_box.put(RequestState(id=req_id, initial_time=0.0))
+    server.start()
+    env.run()
+
+    bucket = server.server_rqs_clock[req_id]
+    # Clock present and well-formed
+    assert EventMetricName.RQS_SERVER_CLOCK in bucket
+    clock = bucket[EventMetricName.RQS_SERVER_CLOCK]
+    assert isinstance(clock, ServerClock)
+    assert clock.finish is not None
+    assert clock.finish >= clock.start
+
+    # Accumulators
+    assert bucket[EventMetricName.SERVICE_TIME] == pytest.approx(0.005, abs=1e-9)
+    assert bucket[EventMetricName.IO_TIME] == pytest.approx(0.020, abs=1e-9)
+    assert bucket[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-12)
+
+    # Server-side elapsed time should be at least the sum (avoid approx on RHS of >=)
+    elapsed = clock.finish - clock.start
+    assert elapsed >= (0.005 + 0.020) - 1e-9
+
+def test_waiting_time_accumulates_under_contention() -> None:
+    """
+    With 1 core and two overlapping requests on a CPU-only endpoint:
+    - The second request's WAITING_TIME ~= (first CPU time - overlap).
+    """
+    env = simpy.Environment()
+
+    steps = (
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 64},
+        ),
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: 0.008},
+        ),
+    )
+    server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1)
+
+    first_id, second_id = 401, 402
+
+    # First arrives at t=0.0
+    server.server_box.put(RequestState(id=first_id, initial_time=0.0))
+
+    # Schedule the second to actually arrive at t=0.001 (creates 1ms overlap)
+    def _arrive_later() -> Generator[simpy.Event, None, None]:
+        yield env.timeout(0.001)
+        yield server.server_box.put(RequestState(id=second_id, initial_time=0.001))
+
+    env.process(_arrive_later())
+
+    server.start()
+    env.run()
+
+    b1 = server.server_rqs_clock[first_id]
+    b2 = server.server_rqs_clock[second_id]
+
+    # First: no waiting, service time = 8ms, no IO
+    assert b1[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-9)
+    assert b1[EventMetricName.SERVICE_TIME] == pytest.approx(0.008, abs=1e-9)
+    assert b1[EventMetricName.IO_TIME] == pytest.approx(0.0, abs=1e-12)
+
+    # Second: expected wait ≈ 0.007 (first CPU 8ms - 1ms overlap)
+    assert b2[EventMetricName.WAITING_TIME] == pytest.approx(0.007, abs=2e-4)
+    assert b2[EventMetricName.SERVICE_TIME] == pytest.approx(0.008, abs=1e-9)
+    assert b2[EventMetricName.IO_TIME] == pytest.approx(0.0, abs=1e-12)
+
+
+def test_metrics_follow_rv_samples(monkeypatch: pytest.MonkeyPatch) -> None:
+    """
+    With RVConfig on CPU and IO, SERVICE_TIME and IO_TIME must match
+    the (patched) sampler outcomes.
+    """
+    # 6ms for CPU sentinel, 13ms for IO sentinel
+    def fake_sampler(cfg: RVConfig, rng: NpGenerator) -> float:
+        if cfg.mean == 0.321:
+            return 0.006
+        if cfg.mean == 0.654:
+            return 0.013
+        return 0.0
+
+    monkeypatch.setattr(server_mod, "general_sampler", fake_sampler)
+
+    env = simpy.Environment()
+    steps = (
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 64},
+        ),
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: RVConfig(mean=0.321)},
+        ),
+        Step(
+            kind=EndpointStepIO.DB,
+            step_operation={StepOperation.IO_WAITING_TIME: RVConfig(mean=0.654)},
+        ),
+    )
+    server, _ = _make_server_runtime(env, steps=steps, cpu_cores=1)
+
+    req_id = 501
+    server.server_box.put(RequestState(id=req_id, initial_time=0.0))
+    server.start()
+    env.run()
+
+    bucket = server.server_rqs_clock[req_id]
+    assert bucket[EventMetricName.SERVICE_TIME] == pytest.approx(0.006, abs=1e-9)
+    assert bucket[EventMetricName.IO_TIME] == pytest.approx(0.013, abs=1e-9)
+    assert bucket[EventMetricName.WAITING_TIME] == pytest.approx(0.0, abs=1e-12)
+
+    clock = bucket[EventMetricName.RQS_SERVER_CLOCK]
+    assert isinstance(clock, ServerClock)
+    assert clock.finish is not None
+
+    # Elapsed server-side time must be at least the sum of CPU+IO
+    elapsed = clock.finish - clock.start
+    assert elapsed >= (0.006 + 0.013) - 1e-9
diff --git a/tests/unit/runtime/events/test_injection_edges.py b/tests/unit/runtime/events/test_injection_edges.py
index 1bb76a6..2fd08b9 100644
--- a/tests/unit/runtime/events/test_injection_edges.py
+++ b/tests/unit/runtime/events/test_injection_edges.py
@@ -7,7 +7,7 @@
 
 import pytest
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.events.injection import (
     END_MARK,
@@ -16,7 +16,7 @@
 )
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
 
 if TYPE_CHECKING:
     import simpy
@@ -24,9 +24,10 @@
 
 # ----------------------------- Helpers ------------------------------------- #
 
-def _edge(edge_id: str, source: str, target: str) -> Edge:
+def _edge(edge_id: str, source: str, target: str) -> NetworkEdge:
     """Minimal edge with negligible latency."""
-    return Edge(id=edge_id, source=source, target=target, latency=RVConfig(mean=0.001))
+    return NetworkEdge(
+        id=edge_id, source=source, target=target, latency=RVConfig(mean=0.001))
 
 
 def _spike_event(
@@ -294,3 +295,44 @@ def test_zero_time_batch_draining_makes_first_event_visible(
     env.step()
     assert env.now == pytest.approx(1.0)
     assert inj.edges_spike[e.id] == pytest.approx(0.1)
+
+def _link_edge(edge_id: str, source: str, target: str) -> LinkEdge:
+    """Minimal LinkEdge without latency."""
+    return LinkEdge(id=edge_id, source=source, target=target)
+
+
+def _spike_event_on_edge(edge_id: str) -> EventInjection:
+    """Simple spike event targeting the given edge."""
+    return EventInjection(
+        event_id="ev-link",
+        target_id=edge_id,
+        start={
+            "kind": EventDescription.NETWORK_SPIKE_START,
+            "t_start": 1.0,
+            "spike_s": 0.2,
+        },
+        end={
+            "kind": EventDescription.NETWORK_SPIKE_END,
+            "t_end": 2.0,
+        },
+    )
+
+
+def test_edge_events_rejected_for_linkedge_topology(
+    env: simpy.Environment,
+    ) -> None:
+    """
+    If any event targets an edge, but edges are LinkEdge,
+    a ValueError must be raised.
+    """
+    edges = [_link_edge("link-1", "A", "B")]
+    ev = _spike_event_on_edge("link-1")
+
+    with pytest.raises(ValueError, match="Edge events are present.*NetworkEdge"):
+        EventInjectionRuntime(
+            events=[ev],
+            edges=edges,
+            env=env,
+            servers=[],
+            lb_out_edges=OrderedDict[str, EdgeRuntime](),
+        )
diff --git a/tests/unit/runtime/events/test_injection_servers.py b/tests/unit/runtime/events/test_injection_servers.py
index 7347fb3..9c5c6ec 100644
--- a/tests/unit/runtime/events/test_injection_servers.py
+++ b/tests/unit/runtime/events/test_injection_servers.py
@@ -7,14 +7,15 @@
 
 import pytest
 import simpy
+from tests.unit.helpers import make_min_ep
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.events.injection import EventInjectionRuntime
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.topology.edges import Edge
-from asyncflow.schemas.topology.nodes import Server, ServerResources
+from asyncflow.schemas.topology.edges import NetworkEdge
+from asyncflow.schemas.topology.nodes import NodesResources, Server
 
 if TYPE_CHECKING:
     from asyncflow.schemas.settings.simulation import SimulationSettings
@@ -24,9 +25,11 @@
 # Helpers                                                                     #
 # --------------------------------------------------------------------------- #
 
-def _edge(edge_id: str, source: str, target: str) -> Edge:
+
+
+def _edge(edge_id: str, source: str, target: str) -> NetworkEdge:
     """Create a minimal LB→server edge with negligible latency."""
-    return Edge(
+    return NetworkEdge(
         id=edge_id,
         source=source,
         target=target,
@@ -38,8 +41,8 @@ def _srv(server_id: str) -> Server:
     """Create a minimal, fully-typed Server instance for tests."""
     return Server(
         id=server_id,
-        server_resources=ServerResources(),  # uses defaults
-        endpoints=[],                        # empty list is valid
+        server_resources=NodesResources(),  # uses defaults
+        endpoints=[make_min_ep()],
     )
 
 def _srv_event(
diff --git a/tests/unit/runtime/events/test_injection_servers_edges.py b/tests/unit/runtime/events/test_injection_servers_edges.py
index 966a9f5..9451f00 100644
--- a/tests/unit/runtime/events/test_injection_servers_edges.py
+++ b/tests/unit/runtime/events/test_injection_servers_edges.py
@@ -7,14 +7,15 @@
 
 import pytest
 import simpy
+from tests.unit.helpers import make_min_ep
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
 from asyncflow.runtime.actors.edge import EdgeRuntime
 from asyncflow.runtime.events.injection import EventInjectionRuntime
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.events.injection import EventInjection
-from asyncflow.schemas.topology.edges import Edge
-from asyncflow.schemas.topology.nodes import Server, ServerResources
+from asyncflow.schemas.topology.edges import NetworkEdge
+from asyncflow.schemas.topology.nodes import NodesResources, Server
 
 if TYPE_CHECKING:
     from asyncflow.schemas.settings.simulation import SimulationSettings
@@ -24,14 +25,17 @@
 # Helpers                                                                     #
 # --------------------------------------------------------------------------- #
 
-def _edge(edge_id: str, source: str, target: str) -> Edge:
+def _edge(edge_id: str, source: str, target: str) -> NetworkEdge:
     """Create a minimal edge with negligible latency."""
-    return Edge(id=edge_id, source=source, target=target, latency=RVConfig(mean=0.001))
+    return NetworkEdge(
+        id=edge_id, source=source, target=target, latency=RVConfig(mean=0.001))
 
 
 def _srv(server_id: str) -> Server:
     """Create a minimal, fully-typed Server instance for tests."""
-    return Server(id=server_id, server_resources=ServerResources(), endpoints=[])
+    return Server(
+        id=server_id, server_resources=NodesResources(), endpoints=[make_min_ep()],
+        )
 
 
 def _spike_event(
diff --git a/tests/unit/runtime/test_rqs_state.py b/tests/unit/runtime/test_rqs_state.py
index eaf752b..b153777 100644
--- a/tests/unit/runtime/test_rqs_state.py
+++ b/tests/unit/runtime/test_rqs_state.py
@@ -1,7 +1,7 @@
 """Unit-tests for :class:`RequestState` and :class:`Hop`."""
 from __future__ import annotations
 
-from asyncflow.config.constants import SystemEdges, SystemNodes
+from asyncflow.config.enums import SystemEdges, SystemNodes
 from asyncflow.runtime.rqs_state import Hop, RequestState
 
 # --------------------------------------------------------------------------- #
diff --git a/tests/unit/samplers/test_arrivals_gen_samplers.py b/tests/unit/samplers/test_arrivals_gen_samplers.py
new file mode 100644
index 0000000..8d07bb9
--- /dev/null
+++ b/tests/unit/samplers/test_arrivals_gen_samplers.py
@@ -0,0 +1,298 @@
+"""Unit tests for inter-arrival samplers (arrival gap generators).
+
+Covers:
+* Horizon truncation (sum of gaps never exceeds the horizon).
+* Families that ignore variability: EXPONENTIAL, POISSON, DETERMINISTIC,
+  UNIFORM.
+* Families that require variability: LOG_NORMAL, WEIBULL, PARETO, ERLANG.
+* EMPIRICAL timestamps path, including validation errors.
+* Determinism with seeded RNG where applicable.
+
+All tests use minimal, observable properties (positivity, bounds, horizon)
+rather than tight statistical checks, to keep them stable and fast.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+
+from asyncflow.config.enums import Distribution, VariabilityLevel
+from asyncflow.samplers.arrivals import (
+    _build_empirical_from_timestamps as build_empirical,
+)
+from asyncflow.samplers.arrivals import (
+    general_interarrivals,
+)
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+
+def _collect_all(gaps: Iterable[float]) -> list[float]:
+    """Materialize a finite generator/sequence into a list of floats."""
+    return [float(x) for x in gaps]
+
+
+def _mk_gen(
+    *,
+    model: Distribution,
+    lambda_rps: float = 10.0,
+    variability: VariabilityLevel | None = None,
+    empirical: Iterable[float] | None = None,
+) -> ArrivalsGenerator:
+    """Small factory for ArrivalsGenerator respecting schema constraints."""
+    return ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=lambda_rps,
+        model=model,
+        variability=variability,
+        empirical_data=empirical,
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Horizon truncation & positivity                                             #
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize(
+    ("model", "var"),
+    [
+        (Distribution.EXPONENTIAL, None),
+        (Distribution.POISSON, None),
+        (Distribution.DETERMINISTIC, None),
+        (Distribution.UNIFORM, None),
+        (Distribution.LOG_NORMAL, VariabilityLevel.MEDIUM),
+        (Distribution.WEIBULL, VariabilityLevel.MEDIUM),
+        (Distribution.PARETO, VariabilityLevel.MEDIUM),
+        (Distribution.ERLANG, VariabilityLevel.MEDIUM),
+    ],
+)
+def test_horizon_truncation_and_positivity(model: Distribution,
+                                           var: VariabilityLevel | None) -> None:
+    """Sum of gaps never exceeds horizon; all gaps are strictly positive."""
+    rng = np.random.default_rng(123)
+    horizon = 3  # small to force truncation with moderate λ
+    gen = _mk_gen(model=model, lambda_rps=5.0, variability=var)
+    it = general_interarrivals(
+        simulation_time_s=horizon,
+        rng=rng,
+        arrivals=gen,
+    )
+    gaps = _collect_all(it)
+
+    assert all(g > 0.0 for g in gaps)
+    total = sum(gaps)
+    assert total <= float(horizon) + 1e-12  # numerical tolerance
+
+
+# --------------------------------------------------------------------------- #
+# Deterministic model                                                         #
+# --------------------------------------------------------------------------- #
+
+def test_deterministic_interarrivals_are_constant() -> None:
+    """D(R=λ) produces constant period 1/λ and respects horizon."""
+    rng = np.random.default_rng(0)
+    lam = 4.0
+    horizon = 5
+    gen = _mk_gen(model=Distribution.DETERMINISTIC, lambda_rps=lam)
+    gaps = _collect_all(
+        general_interarrivals(simulation_time_s=horizon, rng=rng, arrivals=gen),
+    )
+    assert gaps  # at least one
+    period = 1.0 / lam
+    assert all(abs(g - period) < 1e-12 for g in gaps)
+    assert sum(gaps) <= float(horizon) + 1e-12
+
+
+# --------------------------------------------------------------------------- #
+# Uniform model (bounded gap check)                                           #
+# --------------------------------------------------------------------------- #
+
+def test_uniform_interarrivals_are_within_band() -> None:
+    """Uniform gaps stay within [mu*(1-w), mu*(1+w)] and respect horizon."""
+    rng = np.random.default_rng(1)
+    lam = 8.0
+    mu = 1.0 / lam
+    # The code uses Tuning.UNIFORM_REL_HALF_WIDTH, but we do not import it.
+    # Check using a relaxed band around mu to avoid coupling on constants.
+    loose = 0.5
+    a = mu * (1.0 - loose)
+    b = mu * (1.0 + loose)
+
+    gen = _mk_gen(model=Distribution.UNIFORM, lambda_rps=lam)
+    gaps = _collect_all(
+        general_interarrivals(simulation_time_s=4, rng=rng, arrivals=gen),
+    )
+    assert gaps
+    assert all(a <= g <= b for g in gaps)
+
+
+# --------------------------------------------------------------------------- #
+# Families that ignore variability                                            #
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize(("model", "var"), [
+    (Distribution.EXPONENTIAL, None),
+    (Distribution.POISSON, None),
+])
+def test_models_ignore_variability_do_not_require_it(
+    model: Distribution,
+    var: VariabilityLevel | None,
+) -> None:
+    """EXPONENTIAL and POISSON work with variability=None per schema."""
+    rng = np.random.default_rng(2)
+    gen = _mk_gen(model=model, lambda_rps=6.0, variability=var)
+    gaps = _collect_all(
+        general_interarrivals(simulation_time_s=5, rng=rng, arrivals=gen),
+    )
+    assert gaps
+    assert all(g > 0.0 for g in gaps)
+
+
+# --------------------------------------------------------------------------- #
+# Families that require variability                                           #
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        Distribution.LOG_NORMAL,
+        Distribution.WEIBULL,
+        Distribution.PARETO,
+        Distribution.ERLANG,
+    ],
+)
+def test_models_require_variability_and_generate_positive_gaps(
+    model: Distribution,
+) -> None:
+    """Models with tunable SCV require a level and produce positive gaps."""
+    rng = np.random.default_rng(3)
+    gen = _mk_gen(
+        model=model,
+        lambda_rps=5.0,
+        variability=VariabilityLevel.LOW,
+    )
+    gaps = _collect_all(
+        general_interarrivals(simulation_time_s=5, rng=rng, arrivals=gen),
+    )
+    assert gaps
+    assert all(g > 0.0 for g in gaps)
+
+
+# --------------------------------------------------------------------------- #
+# EMPIRICAL timestamps path                                                   #
+# --------------------------------------------------------------------------- #
+
+def test_empirical_builds_gaps_from_timestamps_sorted() -> None:
+    """First gap is t0-origin; remaining are consecutive differences."""
+    ts = [0.5, 1.0, 2.2, 3.0]
+    gaps = _collect_all(
+        build_empirical(timestamps_s=ts, origin_s=0.0, assume_sorted=True),
+    )
+    assert gaps == pytest.approx([0.5, 0.5, 1.2, 0.8])
+
+
+def test_empirical_discards_before_origin_and_sorts() -> None:
+    """Timestamps < origin are discarded; input need not be sorted."""
+    ts = [-1.0, 2.0, 1.0, 4.0, 3.0]
+    gaps = _collect_all(
+        build_empirical(timestamps_s=ts, origin_s=1.0, assume_sorted=False),
+    )
+    # Remaining timestamps: [1.0, 2.0, 3.0, 4.0]
+    assert gaps == pytest.approx([0.0, 1.0, 1.0, 1.0])
+
+
+def test_empirical_clamps_nonpositive_gaps_to_min() -> None:
+    """Non-positive gaps are clamped to `clamp_min_s`."""
+    ts = [1.0, 1.0, 1.000000001, 0.999999999, 2.0]
+    gaps = _collect_all(
+        build_empirical(
+            timestamps_s=ts,
+            origin_s=1.0,
+            assume_sorted=True,
+            clamp_min_s=0.01,
+        ),
+    )
+    # first gap 0; second ~1e-9 (clamped); third negative (clamped)
+    assert gaps[0] == pytest.approx(0.01)
+    assert gaps[1] == pytest.approx(0.01)
+    assert gaps[2] == pytest.approx(0.01)
+    assert gaps[-1] > 0.01  # the 2.0 - 0.999999999 part
+
+
+def test_empirical_errors_on_empty_sequence() -> None:
+    """Empty empirical sequence is invalid."""
+    with pytest.raises(ValueError, match="sequence is empty"):
+        _ = _collect_all(build_empirical(timestamps_s=[], origin_s=0.0))
+
+
+def test_empirical_errors_on_non_finite() -> None:
+    """Non-finite values in empirical timestamps raise a ValueError."""
+    ts = [0.1, float("nan"), 0.3]
+    with pytest.raises(ValueError, match="non-finite value"):
+        _ = _collect_all(build_empirical(timestamps_s=ts, origin_s=0.0))
+
+
+def test_empirical_errors_when_all_before_origin() -> None:
+    """If no timestamps are at/after origin, it raises a ValueError."""
+    ts = [-2.0, -1.0, -0.5]
+    with pytest.raises(ValueError, match="no timestamps at or after origin"):
+        _ = _collect_all(build_empirical(timestamps_s=ts, origin_s=0.0))
+
+
+def test_general_interarrivals_empirical_path_is_finite() -> None:
+    """general_interarrivals returns a finite generator on EMPIRICAL model."""
+    rng = np.random.default_rng(7)
+    ts = [0.3, 0.9, 1.2]
+    gen = _mk_gen(
+        model=Distribution.EMPIRICAL,
+        empirical=ts,
+        lambda_rps=10.0,  # ignored for empirical
+    )
+    gaps = _collect_all(
+        general_interarrivals(simulation_time_s=100, rng=rng, arrivals=gen),
+    )
+    assert gaps == pytest.approx([0.3, 0.6, 0.3])
+
+
+# --------------------------------------------------------------------------- #
+# Determinism (seeded RNG)                                                    #
+# --------------------------------------------------------------------------- #
+
+@pytest.mark.parametrize(
+    ("model", "var"),
+    [
+        (Distribution.EXPONENTIAL, None),
+        (Distribution.POISSON, None),
+        (Distribution.UNIFORM, None),
+        (Distribution.LOG_NORMAL, VariabilityLevel.HIGH),
+        (Distribution.WEIBULL, VariabilityLevel.LOW),
+        (Distribution.PARETO, VariabilityLevel.MEDIUM),
+        (Distribution.ERLANG, VariabilityLevel.MEDIUM),
+    ],
+)
+def test_seeded_rng_reproducibility(model: Distribution,
+                                    var: VariabilityLevel | None) -> None:
+    """Same seed and inputs → identical gap sequences."""
+    seed = 4242
+    g1 = _mk_gen(model=model, lambda_rps=9.0, variability=var)
+    g2 = _mk_gen(model=model, lambda_rps=9.0, variability=var)
+
+    gaps1 = _collect_all(
+        general_interarrivals(
+            simulation_time_s=6, rng=np.random.default_rng(seed), arrivals=g1,
+        ),
+    )
+    gaps2 = _collect_all(
+        general_interarrivals(
+            simulation_time_s=6, rng=np.random.default_rng(seed), arrivals=g2,
+        ),
+    )
+    assert gaps1 == pytest.approx(gaps2)
diff --git a/tests/unit/samplers/test_gaussian_poisson.py b/tests/unit/samplers/test_gaussian_poisson.py
deleted file mode 100644
index 657fae9..0000000
--- a/tests/unit/samplers/test_gaussian_poisson.py
+++ /dev/null
@@ -1,110 +0,0 @@
-"""Unit-tests for `gaussian_poisson_sampling`."""
-
-from __future__ import annotations
-
-import itertools
-from types import GeneratorType
-from typing import TYPE_CHECKING
-
-import pytest
-from numpy.random import Generator, default_rng
-
-from asyncflow.config.constants import TimeDefaults
-from asyncflow.samplers.gaussian_poisson import (
-    gaussian_poisson_sampling,
-)
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-if TYPE_CHECKING:
-
-    from asyncflow.schemas.settings.simulation import SimulationSettings
-
-# ---------------------------------------------------------------------------
-# FIXTURES
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture
-def rqs_cfg() -> RqsGenerator:
-    """Minimal, valid RqsGenerator for Gaussian-Poisson tests."""
-    return RqsGenerator(
-        id= "gen-1",
-        avg_active_users=RVConfig(
-            mean=10.0,
-            variance=4.0,
-            distribution="normal",
-        ),
-        avg_request_per_minute_per_user=RVConfig(mean=30.0),
-        user_sampling_window=TimeDefaults.USER_SAMPLING_WINDOW,
-    )
-
-
-
-# ---------------------------------------------------------------------------
-# BASIC BEHAVIOUR
-# ---------------------------------------------------------------------------
-
-
-def test_returns_generator_type(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-    rng: Generator,
-) -> None:
-    """The function must return a generator object."""
-    gen = gaussian_poisson_sampling(rqs_cfg, sim_settings, rng=rng)
-    assert isinstance(gen, GeneratorType)
-
-
-def test_generates_positive_gaps(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """
-    With nominal parameters the sampler should emit at least a few positive
-    gaps, and the cumulative time must stay below the horizon.
-    """
-    gaps: list[float] = list(
-        itertools.islice(
-            gaussian_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(42)),
-            1000,
-        ),
-    )
-
-    assert gaps, "Expected at least one event"
-    assert all(g > 0.0 for g in gaps), "No gap may be ≤ 0"
-    assert sum(gaps) < sim_settings.total_simulation_time
-
-
-# ---------------------------------------------------------------------------
-# EDGE CASE: ZERO USERS
-# ---------------------------------------------------------------------------
-
-
-def test_zero_users_produces_no_events(
-    monkeypatch: pytest.MonkeyPatch,
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """
-    If every Gaussian draw returns 0 users, Λ == 0 and the generator must
-    yield no events at all.
-    """
-
-    def fake_truncated_gaussian(
-        mean: float,
-        var: float,
-        rng: Generator,
-    ) -> float:
-        return 0.0  # force U = 0
-
-    monkeypatch.setattr(
-        "asyncflow.samplers.gaussian_poisson.truncated_gaussian_generator",
-        fake_truncated_gaussian,
-    )
-
-    gaps: list[float] = list(
-        gaussian_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(123)),
-    )
-
-    assert gaps == []  # no events should be generated
diff --git a/tests/unit/samplers/test_poisson_poisson.py b/tests/unit/samplers/test_poisson_poisson.py
deleted file mode 100644
index c5d4a18..0000000
--- a/tests/unit/samplers/test_poisson_poisson.py
+++ /dev/null
@@ -1,126 +0,0 @@
-"""Unit tests for `poisson_poisson_sampling`."""
-
-from __future__ import annotations
-
-import itertools
-import math
-from types import GeneratorType
-from typing import TYPE_CHECKING
-
-import pytest
-from numpy.random import Generator, default_rng
-
-from asyncflow.config.constants import TimeDefaults
-from asyncflow.samplers.poisson_poisson import poisson_poisson_sampling
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-if TYPE_CHECKING:
-
-    from asyncflow.schemas.settings.simulation import SimulationSettings
-
-
-@pytest.fixture
-def rqs_cfg() -> RqsGenerator:
-    """Return a minimal, valid RqsGenerator for the sampler tests."""
-    return RqsGenerator(
-        id="gen-1",
-        avg_active_users={"mean": 1.0, "distribution": "poisson"},
-        avg_request_per_minute_per_user={"mean": 60.0, "distribution": "poisson"},
-        user_sampling_window=TimeDefaults.USER_SAMPLING_WINDOW,
-    )
-
-# --------------------------------------------------------
-# BASIC SHAPE AND TYPE TESTS
-# --------------------------------------------------------
-
-
-def test_sampler_returns_generator(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-    rng: Generator,
-) -> None:
-    """Function must return a generator object."""
-    gen = poisson_poisson_sampling(rqs_cfg, sim_settings, rng=rng)
-    assert isinstance(gen, GeneratorType)
-
-
-def test_all_gaps_are_positive(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Every yielded gap must be strictly positive."""
-    gaps = list(
-        itertools.islice(
-            poisson_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(1)),
-            1_000,
-        ),
-    )
-    assert all(g > 0.0 for g in gaps)
-
-
-# ---------------------------------------------------------------------------
-# REPRODUCIBILITY WITH FIXED SEED
-# ---------------------------------------------------------------------------
-
-
-def test_sampler_is_reproducible_with_fixed_seed(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Same RNG seed must produce identical first N gaps."""
-    seed = 42
-    n_samples = 15
-
-    gaps_1 = list(
-        itertools.islice(
-            poisson_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(seed)),
-            n_samples,
-        ),
-    )
-    gaps_2 = list(
-        itertools.islice(
-            poisson_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(seed)),
-            n_samples,
-        ),
-    )
-    assert gaps_1 == gaps_2
-
-
-# ---------------------------------------------------------------------------
-# EDGE CASE: ZERO USERS
-# ---------------------------------------------------------------------------
-
-
-def test_zero_users_produces_no_events(
-    sim_settings: SimulationSettings,
-) -> None:
-    """If the mean user count is zero the generator must yield no events."""
-    cfg_zero = RqsGenerator(
-        id="gen-1",
-        avg_active_users=RVConfig(mean=0.0, distribution="poisson"),
-        avg_request_per_minute_per_user=RVConfig(mean=60.0, distribution="poisson"),
-        user_sampling_window=TimeDefaults.USER_SAMPLING_WINDOW,
-    )
-
-    gaps: list[float] = list(
-        poisson_poisson_sampling(cfg_zero, sim_settings, rng=default_rng(123)),
-    )
-    assert gaps == []
-
-
-# ---------------------------------------------------------------------------
-# CUMULATIVE TIME NEVER EXCEEDS THE HORIZON
-# ---------------------------------------------------------------------------
-
-
-def test_cumulative_time_never_exceeds_horizon(
-    rqs_cfg: RqsGenerator,
-    sim_settings: SimulationSettings,
-) -> None:
-    """Sum of gaps must stay below the simulation horizon."""
-    gaps: list[float] = list(
-        poisson_poisson_sampling(rqs_cfg, sim_settings, rng=default_rng(7)),
-    )
-    cum_time = math.fsum(gaps)
-    assert cum_time < sim_settings.total_simulation_time
diff --git a/tests/unit/samplers/test_sampler_helper.py b/tests/unit/samplers/test_sampler_helper.py
index 349a5fd..1896a82 100644
--- a/tests/unit/samplers/test_sampler_helper.py
+++ b/tests/unit/samplers/test_sampler_helper.py
@@ -8,7 +8,7 @@
 import numpy as np
 import pytest
 
-from asyncflow.config.constants import Distribution
+from asyncflow.config.enums import Distribution
 from asyncflow.samplers.common_helpers import (
     exponential_variable_generator,
     general_sampler,
@@ -166,13 +166,6 @@ def test_general_sampler_uniform_path() -> None:
     assert general_sampler(cfg, dummy) == 0.42
 
 
-def test_general_sampler_normal_path() -> None:
-    """Normal branch applies truncation logic (negative → 0)."""
-    dummy = cast("np.random.Generator", DummyRNG(normal_value=-1.2))
-    cfg = RVConfig(mean=0.0, variance=1.0, distribution=Distribution.NORMAL)
-    assert general_sampler(cfg, dummy) == 0.0
-
-
 def test_general_sampler_poisson_path() -> None:
     """Poisson branch returns the dummy's preset integer as *float*."""
     dummy = cast("np.random.Generator", DummyRNG(poisson_value=4))
diff --git a/tests/unit/schemas/test_arrivals_generator.py b/tests/unit/schemas/test_arrivals_generator.py
new file mode 100644
index 0000000..46dbce6
--- /dev/null
+++ b/tests/unit/schemas/test_arrivals_generator.py
@@ -0,0 +1,238 @@
+"""Validation tests for RVConfig, ArrivalsGenerator and SimulationSettings."""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from asyncflow.config.enums import (
+    Distribution,
+    SystemNodes,
+    TimeDefaults,
+    VariabilityLevel,
+)
+from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
+from asyncflow.schemas.common.random_variables import RVConfig
+from asyncflow.schemas.settings.simulation import SimulationSettings
+
+# ──────────────────────────────────────────────────────────────────────────────
+# RVCONFIG
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def test_log_normal_sets_variance_to_mean() -> None:
+    """If variance is omitted for log-normal, it defaults to the mean."""
+    cfg = RVConfig(mean=5.0, distribution=Distribution.LOG_NORMAL)
+    assert cfg.variance == pytest.approx(5.0)
+
+
+def test_poisson_keeps_variance_none() -> None:
+    """If variance is omitted for Poisson, it remains None."""
+    cfg = RVConfig(mean=5.0, distribution=Distribution.POISSON)
+    assert cfg.variance is None
+
+
+def test_uniform_keeps_variance_none() -> None:
+    """If variance is omitted for Uniform, it remains None."""
+    cfg = RVConfig(mean=1.0, distribution=Distribution.UNIFORM)
+    assert cfg.variance is None
+
+
+def test_exponential_keeps_variance_none() -> None:
+    """If variance is omitted for Exponential, it remains None."""
+    cfg = RVConfig(mean=2.5, distribution=Distribution.EXPONENTIAL)
+    assert cfg.variance is None
+
+
+def test_explicit_variance_is_preserved() -> None:
+    """An explicit variance value is not modified."""
+    cfg = RVConfig(
+        mean=8.0,
+        distribution=Distribution.LOG_NORMAL,
+        variance=4.0,
+    )
+    assert cfg.variance == pytest.approx(4.0)
+
+
+def test_mean_must_be_numeric() -> None:
+    """A non-numeric mean triggers a ValidationError."""
+    with pytest.raises(ValidationError):
+        RVConfig(mean="not a number", distribution=Distribution.POISSON)
+
+
+def test_missing_mean_field() -> None:
+    """Omitting mean raises a 'field required' ValidationError."""
+    with pytest.raises(ValidationError):
+        RVConfig.model_validate({"distribution": Distribution.POISSON})
+
+
+def test_default_distribution_is_poisson() -> None:
+    """If distribution is missing, it defaults to 'poisson'."""
+    cfg = RVConfig(mean=3.3)
+    assert cfg.distribution is Distribution.POISSON
+    assert cfg.variance is None
+
+
+def test_explicit_variance_kept_for_poisson() -> None:
+    """Variance is kept even when distribution is Poisson."""
+    cfg = RVConfig(
+        mean=4.0,
+        distribution=Distribution.POISSON,
+        variance=2.2,
+    )
+    assert cfg.variance == pytest.approx(2.2)
+
+
+def test_invalid_distribution_literal_raises() -> None:
+    """An unsupported distribution literal raises ValidationError."""
+    with pytest.raises(ValidationError):
+        RVConfig(mean=5.0, distribution="not_a_dist")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# ARRIVALSGENERATOR  (new API: lambda_rps, model, variability, empirical_data)
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def test_type_defaults_to_generator() -> None:
+    """`type` defaults to SystemNodes.GENERATOR."""
+    ag = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=10.0,
+        model=Distribution.POISSON,
+    )
+    assert ag.type is SystemNodes.GENERATOR
+
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        Distribution.EXPONENTIAL,
+        Distribution.DETERMINISTIC,
+        Distribution.POISSON,
+        Distribution.UNIFORM,
+        # EMPIRICAL is handled by dedicated tests below.
+    ],
+)
+def test_forbids_variability_models_reject_variability(model: Distribution) -> None:
+    """Models with intrinsic/non-configurable variability must use variability=None."""
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=5.0,
+            model=model,
+            variability=VariabilityLevel.LOW,
+        )
+
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        Distribution.LOG_NORMAL,
+        Distribution.WEIBULL,
+        Distribution.PARETO,
+        Distribution.ERLANG,
+    ],
+)
+def test_requires_variability_models_need_variability(model: Distribution) -> None:
+    """Models that require a variability level must receive one."""
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=5.0,
+            model=model,
+        )
+
+    # Now it should pass when variability is provided.
+    ag = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=5.0,
+        model=model,
+        variability=VariabilityLevel.MEDIUM,
+    )
+    assert ag.variability is VariabilityLevel.MEDIUM
+
+
+def test_empirical_requires_data() -> None:
+    """EMPIRICAL model requires `empirical_data` and forbids variability."""
+    # Missing empirical_data → error
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=5.0,
+            model=Distribution.EMPIRICAL,
+        )
+
+    # Provided empirical_data → OK
+    ag = ArrivalsGenerator(
+        id="rqs-1",
+        lambda_rps=5.0,
+        model=Distribution.EMPIRICAL,
+        empirical_data=[0.1, 0.3, 0.8],
+    )
+    assert list(ag.empirical_data or []) == [0.1, 0.3, 0.8]
+
+    # With any non-EMPIRICAL model, empirical_data must be None → error
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=5.0,
+            model=Distribution.POISSON,
+            empirical_data=[0.1, 0.3],
+        )
+
+
+def test_lambda_rps_must_be_positive() -> None:
+    """lambda_rps is PositiveFloat: zero or negative raises."""
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=0.0,
+            model=Distribution.POISSON,
+        )
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=-1.0,
+            model=Distribution.POISSON,
+        )
+
+
+def test_invalid_distribution_literal_at_arrivals_raises() -> None:
+    """An invalid distribution literal in ArrivalsGenerator raises."""
+    with pytest.raises(ValidationError):
+        ArrivalsGenerator(
+            id="rqs-1",
+            lambda_rps=10.0,
+            model="not_a_dist",
+        )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# SIMULATIONSETTINGS  (unchanged semantics)
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def test_default_total_simulation_time() -> None:
+    """If total_simulation_time is missing it defaults to the constant."""
+    settings = SimulationSettings()
+    assert settings.total_simulation_time == TimeDefaults.SIMULATION_TIME
+
+
+def test_explicit_total_simulation_time_kept() -> None:
+    """An explicit total_simulation_time is preserved."""
+    settings = SimulationSettings(total_simulation_time=3_000)
+    assert settings.total_simulation_time == 3_000
+
+
+def test_total_simulation_time_not_int_raises() -> None:
+    """A non-integer total_simulation_time raises ValidationError."""
+    with pytest.raises(ValidationError):
+        SimulationSettings(total_simulation_time="three thousand")
+
+
+def test_total_simulation_time_below_minimum_raises() -> None:
+    """A total_simulation_time below the minimum constant raises."""
+    too_small = TimeDefaults.MIN_SIMULATION_TIME - 1
+    with pytest.raises(ValidationError):
+        SimulationSettings(total_simulation_time=too_small)
diff --git a/tests/unit/schemas/test_edge.py b/tests/unit/schemas/test_edge.py
new file mode 100644
index 0000000..0d8a1c6
--- /dev/null
+++ b/tests/unit/schemas/test_edge.py
@@ -0,0 +1,274 @@
+"""
+Unit tests for the Edge schema.
+
+Covers:
+- Required fields and defaults
+- Source/target validator
+- Dropout rate bounds
+- Latency validator for both deterministic (PositiveFloat) and RVConfig cases
+"""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from asyncflow.config.constants import NetworkParameters
+from asyncflow.config.enums import SystemEdges
+from asyncflow.schemas.common.random_variables import RVConfig
+from asyncflow.schemas.topology.edges import LinkEdge, NetworkEdge
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+
+
+def _rv(mean: float, variance: float | None = None) -> RVConfig:
+    """Build a minimal RVConfig with mean and optional variance."""
+    return RVConfig(mean=mean, variance=variance)
+
+
+# --------------------------------------------------------------------------- #
+# Basic construction and defaults                                             #
+# --------------------------------------------------------------------------- #
+
+
+def test_edge_minimal_construction_uses_default_edge_type() -> None:
+    """Minimal valid Edge uses NETWORK_CONNECTION as default edge_type."""
+    e = NetworkEdge(
+        id="e1",
+        source="a",
+        target="b",
+        latency=_rv(mean=0.01),
+    )
+    assert e.edge_type is SystemEdges.NETWORK_CONNECTION
+
+
+def test_edge_requires_id_source_target() -> None:
+    """Omitting required fields raises ValidationError."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(  # type: ignore[call-arg]
+            source="a",
+            target="b",
+            latency=_rv(mean=0.01),
+        )
+    with pytest.raises(ValidationError):
+        NetworkEdge(  # type: ignore[call-arg]
+            id="e1",
+            target="b",
+            latency=_rv(mean=0.01),
+        )
+    with pytest.raises(ValidationError):
+        NetworkEdge(  # type: ignore[call-arg]
+            id="e1",
+            source="a",
+            latency=_rv(mean=0.01),
+        )
+
+
+# --------------------------------------------------------------------------- #
+# Source != Target                                                            #
+# --------------------------------------------------------------------------- #
+
+
+def test_edge_source_equals_target_fails() -> None:
+    """Validator forbids identical source and target."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="loop",
+            source="x",
+            target="x",
+            latency=_rv(mean=0.01),
+        )
+
+
+# --------------------------------------------------------------------------- #
+# Dropout rate bounds                                                         #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.parametrize(
+    "bad_rate",
+    [-0.001, NetworkParameters.MAX_DROPOUT_RATE + 1e-6],
+)
+def test_edge_dropout_rate_out_of_bounds(bad_rate: float) -> None:
+    """Dropout rate outside configured bounds is rejected."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="ed",
+            source="a",
+            target="b",
+            latency=_rv(mean=0.01),
+            dropout_rate=bad_rate,
+        )
+
+
+@pytest.mark.parametrize(
+    "ok_rate",
+    [
+        NetworkParameters.MIN_DROPOUT_RATE,
+        NetworkParameters.MAX_DROPOUT_RATE,
+        (NetworkParameters.MIN_DROPOUT_RATE + NetworkParameters.MAX_DROPOUT_RATE) / 2,
+    ],
+)
+def test_edge_dropout_rate_in_bounds(ok_rate: float) -> None:
+    """Boundary and mid-range dropout rates are accepted."""
+    e = NetworkEdge(
+        id="ed",
+        source="a",
+        target="b",
+        latency=_rv(mean=0.01),
+        dropout_rate=ok_rate,
+    )
+    assert e.dropout_rate == ok_rate
+
+
+# --------------------------------------------------------------------------- #
+# Latency validation: deterministic (PositiveFloat)                           #
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.parametrize("good_latency", [0.001, 0.1, 5.0])
+def test_edge_deterministic_latency_positivefloat_ok(good_latency: float) -> None:
+    """Deterministic latency validates as PositiveFloat when > 0."""
+    e = NetworkEdge(
+        id="dt",
+        source="a",
+        target="b",
+        latency=good_latency,
+    )
+    # pydantic casts PositiveFloat to float at runtime
+    assert isinstance(e.latency, float)
+    assert e.latency == good_latency
+
+
+@pytest.mark.parametrize("bad_latency", [0.0, -0.001, -5.0])
+def test_edge_deterministic_latency_non_positive_fails(bad_latency: float) -> None:
+    """Non-positive deterministic latency is rejected by PositiveFloat."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="dt-bad",
+            source="a",
+            target="b",
+            latency=bad_latency,
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Latency validation: RVConfig branch                                         #
+# --------------------------------------------------------------------------- #
+
+
+def test_edge_rvconfig_latency_ok_with_zero_variance() -> None:
+    """RVConfig with mean>0 and variance==0 is accepted."""
+    e = NetworkEdge(
+        id="rv0",
+        source="a",
+        target="b",
+        latency=_rv(mean=0.02, variance=0.0),
+    )
+    assert isinstance(e.latency, RVConfig)
+    assert e.latency.mean == 0.02
+    assert e.latency.variance == 0.0
+
+
+def test_edge_rvconfig_latency_ok_with_none_variance() -> None:
+    """RVConfig with mean>0 and variance=None is accepted."""
+    e = NetworkEdge(
+        id="rvn",
+        source="a",
+        target="b",
+        latency=_rv(mean=0.02, variance=None),
+    )
+    assert isinstance(e.latency, RVConfig)
+    assert e.latency.mean == 0.02
+    assert e.latency.variance is None
+
+
+@pytest.mark.parametrize("bad_mean", [0.0, -1e-9, -1.0])
+def test_edge_rvconfig_latency_non_positive_mean_fails(bad_mean: float) -> None:
+    """RVConfig with non-positive mean is rejected by the field validator."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="rv-bad-mean",
+            source="a",
+            target="b",
+            latency=_rv(mean=bad_mean, variance=0.0),
+        )
+
+
+def test_edge_rvconfig_latency_negative_variance_fails() -> None:
+    """RVConfig with negative variance is rejected by the field validator."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="rv-bad-var",
+            source="a",
+            target="b",
+            latency=_rv(mean=0.02, variance=-0.0001),
+        )
+
+# --------------------------------------------------------------------------- #
+# LinkEdge: required fields and defaults                                      #
+# --------------------------------------------------------------------------- #
+
+def test_link_edge_minimal_construction_uses_default_edge_type() -> None:
+    """Minimal LinkEdge uses LINK_CONNECTION as the default edge_type."""
+    e = LinkEdge(id="l1", source="a", target="b")
+    assert e.edge_type is SystemEdges.LINK_CONNECTION
+
+
+def test_link_edge_requires_id_source_target() -> None:
+    """Omitting required fields raises ValidationError."""
+    with pytest.raises(ValidationError):
+        LinkEdge(  # type: ignore[call-arg]
+            source="a",
+            target="b",
+        )
+    with pytest.raises(ValidationError):
+        LinkEdge(  # type: ignore[call-arg]
+            id="l1",
+            target="b",
+        )
+    with pytest.raises(ValidationError):
+        LinkEdge(  # type: ignore[call-arg]
+            id="l1",
+            source="a",
+        )
+
+# --------------------------------------------------------------------------- #
+# LinkEdge: source != target                                                  #
+# --------------------------------------------------------------------------- #
+
+def test_link_edge_source_equals_target_fails() -> None:
+    """Validator forbids identical source and target in LinkEdge."""
+    with pytest.raises(ValidationError):
+        LinkEdge(id="loop", source="x", target="x")
+
+# --------------------------------------------------------------------------- #
+# LinkEdge: edge_type must be LINK_CONNECTION                                 #
+# --------------------------------------------------------------------------- #
+
+def test_link_edge_wrong_edge_type_fails() -> None:
+    """Setting edge_type to anything other than LINK_CONNECTION is rejected."""
+    with pytest.raises(ValidationError):
+        LinkEdge(
+            id="lbad",
+            source="a",
+            target="b",
+            edge_type=SystemEdges.NETWORK_CONNECTION,  # invalid
+        )
+
+# --------------------------------------------------------------------------- #
+# NetworkEdge: edge_type must be NETWORK_CONNECTION                           #
+# --------------------------------------------------------------------------- #
+
+def test_network_edge_wrong_edge_type_fails() -> None:
+    """NetworkEdge rejects edge_type values other than NETWORK_CONNECTION."""
+    with pytest.raises(ValidationError):
+        NetworkEdge(
+            id="nbad",
+            source="a",
+            target="b",
+            latency=0.01,
+            edge_type=SystemEdges.LINK_CONNECTION,  # invalid
+        )
diff --git a/tests/unit/schemas/test_endpoint.py b/tests/unit/schemas/test_endpoint.py
index 080f55a..caeed15 100644
--- a/tests/unit/schemas/test_endpoint.py
+++ b/tests/unit/schemas/test_endpoint.py
@@ -5,12 +5,13 @@
 import pytest
 from pydantic import ValidationError
 
-from asyncflow.config.constants import (
+from asyncflow.config.enums import (
     EndpointStepCPU,
     EndpointStepIO,
     EndpointStepRAM,
     StepOperation,
 )
+from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.topology.endpoint import Endpoint, Step
 
 
@@ -129,3 +130,97 @@ def test_wrong_operation_name_for_io() -> None:
             kind=EndpointStepIO.CACHE,
             step_operation={StepOperation.NECESSARY_RAM: 64},
         )
+
+
+# --------------------------------------------------------------------------- #
+# CPU: RVConfig branch                                                        #
+# --------------------------------------------------------------------------- #
+
+def test_cpu_step_rvconfig_positive_ok() -> None:
+    """CPU step with RVConfig(mean>0, variance=0) is accepted."""
+    s = Step(
+        kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+        step_operation={StepOperation.CPU_TIME: RVConfig(mean=0.05, variance=0.0)},
+    )
+    assert isinstance(s.step_operation[StepOperation.CPU_TIME], RVConfig)
+
+
+def test_cpu_step_rvconfig_zero_mean_fails() -> None:
+    """CPU step with RVConfig(mean==0) is rejected by model validator."""
+    with pytest.raises(ValidationError):
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: RVConfig(mean=0.0)},
+        )
+
+
+def test_cpu_step_deterministic_zero_fails() -> None:
+    """Deterministic CPU time must be PositiveFloat (>0)."""
+    with pytest.raises(ValidationError):
+        Step(
+            kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+            step_operation={StepOperation.CPU_TIME: 0.0},
+        )
+
+
+# --------------------------------------------------------------------------- #
+# IO: RVConfig branch                                                         #
+# --------------------------------------------------------------------------- #
+
+def test_io_step_rvconfig_negative_variance_fails() -> None:
+    """IO step with negative variance is rejected."""
+    with pytest.raises(ValidationError):
+        Step(
+            kind=EndpointStepIO.WAIT,
+            step_operation={
+                StepOperation.IO_WAITING_TIME:
+                    RVConfig(mean=0.02, variance=-1.0)},
+        )
+
+
+def test_io_step_rvconfig_positive_ok() -> None:
+    """IO step with RVConfig(mean>0, variance=None) is accepted."""
+    s = Step(
+        kind=EndpointStepIO.WAIT,
+        step_operation={StepOperation.IO_WAITING_TIME: RVConfig(mean=0.02)},
+    )
+    assert isinstance(s.step_operation[StepOperation.IO_WAITING_TIME], RVConfig)
+
+
+# --------------------------------------------------------------------------- #
+# RAM: type discipline                                                        #
+# --------------------------------------------------------------------------- #
+
+def test_ram_step_rejects_float_and_rvconfig() -> None:
+    """RAM step must use a positive integer; float and RVConfig are rejected."""
+    # float rejected
+    with pytest.raises(TypeError):
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 64.0},
+        )
+    # RVConfig rejected
+    with pytest.raises(TypeError):
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: RVConfig(mean=128.0)},
+        )
+
+
+def test_ram_step_zero_fails() -> None:
+    """RAM step with 0 is rejected by model validator."""
+    with pytest.raises(ValidationError):
+        Step(
+            kind=EndpointStepRAM.RAM,
+            step_operation={StepOperation.NECESSARY_RAM: 0},
+        )
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/unit/schemas/test_event_injection.py b/tests/unit/schemas/test_event_injection.py
index 5593fd7..840ba56 100644
--- a/tests/unit/schemas/test_event_injection.py
+++ b/tests/unit/schemas/test_event_injection.py
@@ -17,7 +17,7 @@
 import pytest
 from pydantic import ValidationError
 
-from asyncflow.config.constants import EventDescription
+from asyncflow.config.enums import EventDescription
 from asyncflow.schemas.events.injection import End, EventInjection, Start
 
 # ---------------------------------------------------------------------------
diff --git a/tests/unit/schemas/test_generator.py b/tests/unit/schemas/test_generator.py
deleted file mode 100644
index 608adc4..0000000
--- a/tests/unit/schemas/test_generator.py
+++ /dev/null
@@ -1,219 +0,0 @@
-"""Validation tests for RVConfig, RqsGenerator and SimulationSettings."""
-from __future__ import annotations
-
-import pytest
-from pydantic import ValidationError
-
-from asyncflow.config.constants import Distribution, TimeDefaults
-from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.settings.simulation import SimulationSettings
-from asyncflow.schemas.workload.rqs_generator import RqsGenerator
-
-# --------------------------------------------------------------------------- #
-# RVCONFIG                                                                    #
-# --------------------------------------------------------------------------- #
-
-
-def test_normal_sets_variance_to_mean() -> None:
-    """If variance is omitted for 'normal', it defaults to mean."""
-    cfg = RVConfig(mean=10, distribution=Distribution.NORMAL)
-    assert cfg.variance == 10.0
-
-
-def test_log_normal_sets_variance_to_mean() -> None:
-    """If variance is omitted for 'log_normal', it defaults to mean."""
-    cfg = RVConfig(mean=5, distribution=Distribution.LOG_NORMAL)
-    assert cfg.variance == 5.0
-
-
-def test_poisson_keeps_variance_none() -> None:
-    """If variance is omitted for 'poisson', it remains None."""
-    cfg = RVConfig(mean=5, distribution=Distribution.POISSON)
-    assert cfg.variance is None
-
-
-def test_uniform_keeps_variance_none() -> None:
-    """If variance is omitted for 'uniform', it remains None."""
-    cfg = RVConfig(mean=1, distribution=Distribution.UNIFORM)
-    assert cfg.variance is None
-
-
-def test_exponential_keeps_variance_none() -> None:
-    """If variance is omitted for 'exponential', it remains None."""
-    cfg = RVConfig(mean=2.5, distribution=Distribution.EXPONENTIAL)
-    assert cfg.variance is None
-
-
-def test_explicit_variance_is_preserved() -> None:
-    """An explicit variance value is not modified."""
-    cfg = RVConfig(mean=8, distribution=Distribution.NORMAL, variance=4)
-    assert cfg.variance == 4.0
-
-
-def test_mean_must_be_numeric() -> None:
-    """A non-numeric mean triggers a ValidationError."""
-    with pytest.raises(ValidationError):
-        RVConfig(mean="not a number", distribution=Distribution.POISSON)
-
-
-def test_missing_mean_field() -> None:
-    """Omitting mean raises a 'field required' ValidationError."""
-    with pytest.raises(ValidationError):
-        RVConfig.model_validate({"distribution": Distribution.NORMAL})
-
-
-def test_default_distribution_is_poisson() -> None:
-    """If distribution is missing, it defaults to 'poisson'."""
-    cfg = RVConfig(mean=3.3)
-    assert cfg.distribution == Distribution.POISSON
-    assert cfg.variance is None
-
-
-def test_explicit_variance_kept_for_poisson() -> None:
-    """Variance is kept even when distribution is poisson."""
-    cfg = RVConfig(mean=4.0, distribution=Distribution.POISSON, variance=2.2)
-    assert cfg.variance == pytest.approx(2.2)
-
-
-def test_invalid_distribution_literal_raises() -> None:
-    """An unsupported distribution literal raises ValidationError."""
-    with pytest.raises(ValidationError):
-        RVConfig(mean=5.0, distribution="not_a_dist")
-
-
-# --------------------------------------------------------------------------- #
-# RqsGenerator - USER_SAMPLING_WINDOW & DISTRIBUTION CONSTRAINTS         #
-# --------------------------------------------------------------------------- #
-
-
-def _valid_poisson_cfg(mean: float = 1.0) -> dict[str, float | str]:
-    """Helper: minimal Poisson config for JSON-style input."""
-    return {"mean": mean, "distribution": Distribution.POISSON}
-
-
-def _valid_normal_cfg(mean: float = 1.0) -> dict[str, float | str]:
-    """Helper: minimal Normal config for JSON-style input."""
-    return {"mean": mean, "distribution": Distribution.NORMAL}
-
-
-def test_default_user_sampling_window() -> None:
-    """If user_sampling_window is missing it defaults to the constant."""
-    inp = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=_valid_poisson_cfg(),
-        avg_request_per_minute_per_user=_valid_poisson_cfg(),
-    )
-    assert inp.user_sampling_window == TimeDefaults.USER_SAMPLING_WINDOW
-
-
-def test_explicit_user_sampling_window_kept() -> None:
-    """An explicit user_sampling_window is preserved."""
-    inp = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=_valid_poisson_cfg(),
-        avg_request_per_minute_per_user=_valid_poisson_cfg(),
-        user_sampling_window=30,
-    )
-    assert inp.user_sampling_window == 30
-
-
-def test_user_sampling_window_not_int_raises() -> None:
-    """A non-integer user_sampling_window raises ValidationError."""
-    with pytest.raises(ValidationError):
-        RqsGenerator(
-            id="rqs-1",
-            avg_active_users=_valid_poisson_cfg(),
-            avg_request_per_minute_per_user=_valid_poisson_cfg(),
-            user_sampling_window="not-int",
-        )
-
-
-def test_user_sampling_window_above_max_raises() -> None:
-    """user_sampling_window above the max constant raises ValidationError."""
-    too_large = TimeDefaults.MAX_USER_SAMPLING_WINDOW + 1
-    with pytest.raises(ValidationError):
-        RqsGenerator(
-            id="rqs-1",
-            avg_active_users=_valid_poisson_cfg(),
-            avg_request_per_minute_per_user=_valid_poisson_cfg(),
-            user_sampling_window=too_large,
-        )
-
-
-def test_avg_request_must_be_poisson() -> None:
-    """avg_request_per_minute_per_user must be Poisson; Normal raises."""
-    with pytest.raises(ValidationError):
-        RqsGenerator(
-            id="rqs-1",
-            avg_active_users=_valid_poisson_cfg(),
-            avg_request_per_minute_per_user=_valid_normal_cfg(),
-        )
-
-
-def test_avg_active_users_invalid_distribution_raises() -> None:
-    """avg_active_users cannot be Exponential; only Poisson or Normal allowed."""
-    bad_cfg = {"mean": 1.0, "distribution": Distribution.EXPONENTIAL}
-    with pytest.raises(ValidationError):
-        RqsGenerator(
-            id="rqs-1",
-            avg_active_users=bad_cfg,
-            avg_request_per_minute_per_user=_valid_poisson_cfg(),
-        )
-
-
-def test_valid_poisson_poisson_configuration() -> None:
-    """Poisson-Poisson combo is accepted."""
-    cfg = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=_valid_poisson_cfg(),
-        avg_request_per_minute_per_user=_valid_poisson_cfg(),
-    )
-    assert cfg.avg_active_users.distribution is Distribution.POISSON
-    assert (
-        cfg.avg_request_per_minute_per_user.distribution
-        is Distribution.POISSON
-    )
-
-
-def test_valid_normal_poisson_configuration() -> None:
-    """Normal-Poisson combo is accepted."""
-    cfg = RqsGenerator(
-        id="rqs-1",
-        avg_active_users=_valid_normal_cfg(),
-        avg_request_per_minute_per_user=_valid_poisson_cfg(),
-    )
-    assert cfg.avg_active_users.distribution is Distribution.NORMAL
-    assert (
-        cfg.avg_request_per_minute_per_user.distribution
-        is Distribution.POISSON
-    )
-
-
-# --------------------------------------------------------------------------- #
-# SIMULATIONSETTINGS - TOTAL_SIMULATION_TIME                                  #
-# --------------------------------------------------------------------------- #
-
-
-def test_default_total_simulation_time() -> None:
-    """If total_simulation_time is missing it defaults to the constant."""
-    settings = SimulationSettings()
-    assert settings.total_simulation_time == TimeDefaults.SIMULATION_TIME
-
-
-def test_explicit_total_simulation_time_kept() -> None:
-    """An explicit total_simulation_time is preserved."""
-    settings = SimulationSettings(total_simulation_time=3_000)
-    assert settings.total_simulation_time == 3_000
-
-
-def test_total_simulation_time_not_int_raises() -> None:
-    """A non-integer total_simulation_time raises ValidationError."""
-    with pytest.raises(ValidationError):
-        SimulationSettings(total_simulation_time="three thousand")
-
-
-def test_total_simulation_time_below_minimum_raises() -> None:
-    """A total_simulation_time below the minimum constant raises ValidationError."""
-    too_small = TimeDefaults.MIN_SIMULATION_TIME - 1
-    with pytest.raises(ValidationError):
-        SimulationSettings(total_simulation_time=too_small)
diff --git a/tests/unit/schemas/test_nodes.py b/tests/unit/schemas/test_nodes.py
new file mode 100644
index 0000000..bb63298
--- /dev/null
+++ b/tests/unit/schemas/test_nodes.py
@@ -0,0 +1,222 @@
+"""
+Unit tests for node schemas:
+- NodesResources
+- Client
+- Server
+- LoadBalancer
+- TopologyNodes
+"""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from asyncflow.config.constants import NodesResourcesDefaults
+from asyncflow.config.enums import (
+    EndpointStepCPU,
+    LbAlgorithmsName,
+    StepOperation,
+    SystemNodes,
+)
+from asyncflow.schemas.topology.endpoint import Endpoint, Step
+from asyncflow.schemas.topology.nodes import (
+    Client,
+    LoadBalancer,
+    NodesResources,
+    Server,
+    TopologyNodes,
+)
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+
+
+def _dummy_endpoint() -> Endpoint:
+    """Return a minimal valid endpoint with one CPU step."""
+    step = Step(
+        kind=EndpointStepCPU.CPU_BOUND_OPERATION,
+        step_operation={StepOperation.CPU_TIME: 0.01},
+    )
+    return Endpoint(endpoint_name="/ping", steps=[step])
+
+
+def _one_server_topology() -> TopologyNodes:
+    """Build a minimal topology with one client and one server."""
+    cli = Client(id="cli-1", type=SystemNodes.CLIENT)
+    srv = Server(
+        id="srv-1",
+        type=SystemNodes.SERVER,
+        server_resources=NodesResources(),
+        endpoints=[_dummy_endpoint()],
+    )
+    return TopologyNodes(servers=[srv], client=cli)
+
+
+# --------------------------------------------------------------------------- #
+# NodesResources                                                               #
+# --------------------------------------------------------------------------- #
+
+
+def test_nodes_resources_defaults_match_constants() -> None:
+    """Defaults match NodesResourcesDefaults constants."""
+    res = NodesResources()
+    assert res.cpu_cores == NodesResourcesDefaults.CPU_CORES
+    assert res.ram_mb == NodesResourcesDefaults.RAM_MB
+    assert res.db_connection_pool is NodesResourcesDefaults.DB_CONNECTION_POOL
+
+
+def test_nodes_resources_minimum_constraints() -> None:
+    """Values below minimum bounds raise ValidationError."""
+    with pytest.raises(ValidationError):
+        NodesResources(cpu_cores=0, ram_mb=NodesResourcesDefaults.RAM_MB)
+    with pytest.raises(ValidationError):
+        NodesResources(
+            cpu_cores=NodesResourcesDefaults.CPU_CORES,
+            ram_mb=NodesResourcesDefaults.MINIMUM_RAM_MB - 1,
+        )
+
+
+# --------------------------------------------------------------------------- #
+# Client                                                                       #
+# --------------------------------------------------------------------------- #
+
+
+def test_client_type_must_be_client() -> None:
+    """Client.type must equal SystemNodes.CLIENT."""
+    cli = Client(id="c1", type=SystemNodes.CLIENT)
+    assert cli.type is SystemNodes.CLIENT
+
+    with pytest.raises(ValidationError):
+        Client(id="bad", type=SystemNodes.SERVER)
+
+
+def test_client_ram_per_process_requires_resources() -> None:
+    """If ram_per_process is set, client_resources must be provided."""
+    with pytest.raises(ValidationError):
+        Client(id="c1", ram_per_process=64)
+
+    ok = Client(
+        id="c2",
+        client_resources=NodesResources(ram_mb=2048),
+        ram_per_process=64,
+    )
+    assert ok.client_resources is not None
+
+
+# --------------------------------------------------------------------------- #
+# Server                                                                       #
+# --------------------------------------------------------------------------- #
+
+
+def test_server_type_must_be_server() -> None:
+    """Server.type must equal SystemNodes.SERVER."""
+    srv = Server(
+        id="s1",
+        type=SystemNodes.SERVER,
+        server_resources=NodesResources(),
+        endpoints=[_dummy_endpoint()],
+    )
+    assert srv.type is SystemNodes.SERVER
+
+    with pytest.raises(ValidationError):
+        Server(
+            id="bad",
+            type=SystemNodes.CLIENT,
+            server_resources=NodesResources(),
+            endpoints=[_dummy_endpoint()],
+        )
+
+
+def test_server_requires_at_least_one_endpoint() -> None:
+    """Endpoints list must be non-empty."""
+    with pytest.raises(ValidationError):
+        Server(
+            id="s1",
+            server_resources=NodesResources(),
+            endpoints=[],
+        )
+
+
+# --------------------------------------------------------------------------- #
+# LoadBalancer                                                                 #
+# --------------------------------------------------------------------------- #
+
+
+def test_load_balancer_type_and_defaults() -> None:
+    """LB.type and default algorithm validate."""
+    lb = LoadBalancer(id="lb1", type=SystemNodes.LOAD_BALANCER)
+    assert lb.type is SystemNodes.LOAD_BALANCER
+    assert lb.algorithms is LbAlgorithmsName.ROUND_ROBIN
+
+
+def test_lb_ram_per_process_requires_resources() -> None:
+    """If ram_per_process is set, lb_resources must be provided."""
+    with pytest.raises(ValidationError):
+        LoadBalancer(
+            id="lb1",
+            ram_per_process=64,
+        )
+
+    ok = LoadBalancer(
+        id="lb2",
+        lb_resources=NodesResources(ram_mb=2048),
+        ram_per_process=64,
+    )
+    assert ok.lb_resources is not None
+
+
+# --------------------------------------------------------------------------- #
+# TopologyNodes                                                                #
+# --------------------------------------------------------------------------- #
+
+
+def test_topology_nodes_unique_ids_validator() -> None:
+    """Duplicate node IDs are rejected."""
+    topo = _one_server_topology()
+    dup_srv = topo.servers[0].model_copy(update={"id": "cli-1"})
+    with pytest.raises(ValidationError):
+        TopologyNodes(servers=[dup_srv], client=topo.client)
+
+
+def test_topology_lb_references_unknown_server_fails() -> None:
+    """LB must only cover servers present in the topology."""
+    topo = _one_server_topology()
+    lb = LoadBalancer(id="lb-1", server_covered={"missing"})
+    with pytest.raises(ValidationError):
+        TopologyNodes(
+            servers=topo.servers,
+            client=topo.client,
+            load_balancer=lb,
+        )
+
+
+def test_topology_lb_with_valid_coverage_passes() -> None:
+    """LB covering an existing server validates."""
+    topo = _one_server_topology()
+    lb = LoadBalancer(id="lb-1", server_covered={"srv-1"})
+    ok = TopologyNodes(
+        servers=topo.servers,
+        client=topo.client,
+        load_balancer=lb,
+    )
+    assert ok.load_balancer is not None
+    assert ok.load_balancer.server_covered == {"srv-1"}
+
+
+def test_topology_server_ram_per_process_total_lt_ram() -> None:
+    """Total per-process RAM must be strictly less than node RAM."""
+    srv = Server(
+        id="s1",
+        server_resources=NodesResources(cpu_cores=2, ram_mb=1024),
+        endpoints=[_dummy_endpoint()],
+        ram_per_process=200,
+    )
+    topo = TopologyNodes(servers=[srv], client=Client(id="c1"))
+    assert topo.servers[0].ram_per_process == 200
+
+    # Now violate the constraint: 2 cores * 600 >= 1024 → invalid
+    bad_srv = srv.model_copy(update={"ram_per_process": 600})
+    with pytest.raises(ValidationError):
+        TopologyNodes(servers=[bad_srv], client=Client(id="c2"))
diff --git a/tests/unit/schemas/test_payload.py b/tests/unit/schemas/test_payload.py
index 8547f83..9a7d8cb 100644
--- a/tests/unit/schemas/test_payload.py
+++ b/tests/unit/schemas/test_payload.py
@@ -6,10 +6,6 @@
 - Event times inside the simulation horizon.
 - Kind/target compatibility (server vs. edge).
 - Global liveness: not all servers down simultaneously.
-
-All tests are ruff- and mypy-friendly (short lines, precise raises, and
-single statements inside raises blocks). They reuse fixtures from
-conftest.py where convenient and build custom topologies when needed.
 """
 
 from __future__ import annotations
@@ -17,22 +13,19 @@
 from typing import TYPE_CHECKING
 
 import pytest
+from tests.unit.helpers import make_min_ep
 
-from asyncflow.config.constants import Distribution, EventDescription
+from asyncflow.config.enums import Distribution, EventDescription
 from asyncflow.schemas.common.random_variables import RVConfig
 from asyncflow.schemas.events.injection import End, EventInjection, Start
 from asyncflow.schemas.payload import SimulationPayload
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import NetworkEdge
 from asyncflow.schemas.topology.graph import TopologyGraph
-from asyncflow.schemas.topology.nodes import (
-    Client,
-    Server,
-    TopologyNodes,
-)
+from asyncflow.schemas.topology.nodes import Client, Server, TopologyNodes
 
 if TYPE_CHECKING:
+    from asyncflow.schemas.arrivals.generator import ArrivalsGenerator
     from asyncflow.schemas.settings.simulation import SimulationSettings
-    from asyncflow.schemas.workload.rqs_generator import RqsGenerator
 
 
 # ---------------------------------------------------------------------------
@@ -82,7 +75,7 @@ def _mk_server_window(
 def _topology_with_min_edge() -> TopologyGraph:
     """Create a tiny topology with one client and one minimal edge."""
     client = Client(id="client-1")
-    edge = Edge(
+    edge = NetworkEdge(
         id="gen-to-client",
         source="rqs-1",
         target="client-1",
@@ -96,10 +89,18 @@ def _topology_with_two_servers_and_edge() -> TopologyGraph:
     """Create a topology with two servers and a minimal edge."""
     client = Client(id="client-1")
     servers = [
-    Server(id="srv-1", server_resources={"cpu_cores": 1}, endpoints=[]),
-    Server(id="srv-2", server_resources={"cpu_cores": 1}, endpoints=[]),
-]
-    edge = Edge(
+        Server(
+            id="srv-1",
+            server_resources={"cpu_cores": 1},
+            endpoints=[make_min_ep()],
+        ),
+        Server(
+            id="srv-2",
+            server_resources={"cpu_cores": 1},
+            endpoints=[make_min_ep()],
+        ),
+    ]
+    edge = NetworkEdge(
         id="gen-to-client",
         source="rqs-1",
         target="client-1",
@@ -115,7 +116,8 @@ def _topology_with_two_servers_and_edge() -> TopologyGraph:
 
 
 def test_unique_event_ids_ok(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """Different event_id values should validate."""
     topo = _topology_with_min_edge()
@@ -126,7 +128,7 @@ def test_unique_event_ids_ok(
         "ev-b", "gen-to-client", start_t=2.0, end_t=3.0, spike_s=0.002,
     )
     payload = SimulationPayload(
-        rqs_input=rqs_input,
+        arrivals=arrivals_gen,
         topology_graph=topo,
         sim_settings=sim_settings,
         events=[ev1, ev2],
@@ -136,7 +138,8 @@ def test_unique_event_ids_ok(
 
 
 def test_duplicate_event_ids_rejected(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """Duplicate event_id values must be rejected."""
     topo = _topology_with_min_edge()
@@ -148,7 +151,7 @@ def test_duplicate_event_ids_rejected(
     )
     with pytest.raises(ValueError, match=r"must be unique"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev1, ev2],
@@ -161,7 +164,8 @@ def test_duplicate_event_ids_rejected(
 
 
 def test_target_id_must_exist(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """Target IDs not present in the topology must be rejected."""
     topo = _topology_with_min_edge()
@@ -170,7 +174,7 @@ def test_target_id_must_exist(
     )
     with pytest.raises(ValueError, match=r"does not exist"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev],
@@ -183,7 +187,8 @@ def test_target_id_must_exist(
 
 
 def test_start_time_exceeds_horizon_rejected(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """Start time greater than the horizon must be rejected."""
     topo = _topology_with_min_edge()
@@ -197,7 +202,7 @@ def test_start_time_exceeds_horizon_rejected(
     )
     with pytest.raises(ValueError, match=r"exceeds simulation horizon"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev],
@@ -205,7 +210,8 @@ def test_start_time_exceeds_horizon_rejected(
 
 
 def test_end_time_exceeds_horizon_rejected(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """End time greater than the horizon must be rejected."""
     topo = _topology_with_min_edge()
@@ -219,7 +225,7 @@ def test_end_time_exceeds_horizon_rejected(
     )
     with pytest.raises(ValueError, match=r"exceeds simulation horizon"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev],
@@ -232,7 +238,8 @@ def test_end_time_exceeds_horizon_rejected(
 
 
 def test_server_event_cannot_target_edge(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """SERVER_DOWN should not target an edge ID."""
     topo = _topology_with_min_edge()
@@ -244,7 +251,7 @@ def test_server_event_cannot_target_edge(
     )
     with pytest.raises(ValueError, match=r"regarding a server .* compatible"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev],
@@ -252,7 +259,8 @@ def test_server_event_cannot_target_edge(
 
 
 def test_edge_event_ok_on_edge(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
     """NETWORK_SPIKE event is valid when it targets an edge ID."""
     topo = _topology_with_min_edge()
@@ -260,7 +268,7 @@ def test_edge_event_ok_on_edge(
         "ev-edge-ok", "gen-to-client", start_t=0.0, end_t=1.0, spike_s=0.001,
     )
     payload = SimulationPayload(
-        rqs_input=rqs_input,
+        arrivals=arrivals_gen,
         topology_graph=topo,
         sim_settings=sim_settings,
         events=[ev],
@@ -275,31 +283,20 @@ def test_edge_event_ok_on_edge(
 
 
 def test_reject_when_all_servers_down_at_same_time(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
-    """
-    It should raise a ValidationError if there is any time interval during which
-    all servers are scheduled to be down simultaneously.
-    """
+    """Raise if there exists an interval during which all servers are down"""
     topo = _topology_with_two_servers_and_edge()
+    sim_settings.total_simulation_time = 30
 
-    # --- SETUP: Use a longer simulation horizon for this specific test ---
-    # The default `sim_settings` fixture has a short horizon (e.g., 5s) to
-    # keep most tests fast. For this test, we need a longer horizon to
-    # ensure the event times themselves are valid.
-    sim_settings.total_simulation_time = 30  # e.g., 30 seconds
-
-    # The event times are now valid within the new horizon.
-    # srv-1 is down [10, 20), srv-2 is down [15, 25).
-    # This creates an overlap in [15, 20) where both are down.
+    # Overlap: both down on [15, 20).
     ev_a = _mk_server_window("ev-a", "srv-1", start_t=10.0, end_t=20.0)
     ev_b = _mk_server_window("ev-b", "srv-2", start_t=15.0, end_t=25.0)
 
-    # Now the test will bypass the time horizon validation and trigger
-    # the correct validator that checks for server downtime overlap.
     with pytest.raises(ValueError, match=r"all servers are down"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev_a, ev_b],
@@ -307,24 +304,19 @@ def test_reject_when_all_servers_down_at_same_time(
 
 
 def test_accept_when_never_all_down(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
-    """Payload is valid when at least one server stays up at all times."""
+    """Valid when at least one server stays up at any time."""
     topo = _topology_with_two_servers_and_edge()
+    sim_settings.total_simulation_time = 30
 
-    # --- SETUP: Use a longer simulation horizon for this specific test ---
-    # As before, we need to ensure the event times are valid within the
-    # simulation's total duration.
-    sim_settings.total_simulation_time = 30 # e.g., 30 seconds
-
-    # Staggered windows: srv-1 down [10, 15), srv-2 down [15, 20).
-    # There is no point in time where both are down.
+    # Staggered windows: never both down at once.
     ev_a = _mk_server_window("ev-a", "srv-1", start_t=10.0, end_t=15.0)
     ev_b = _mk_server_window("ev-b", "srv-2", start_t=15.0, end_t=20.0)
 
-    # This should now pass validation without raising an error.
     payload = SimulationPayload(
-        rqs_input=rqs_input,
+        arrivals=arrivals_gen,
         topology_graph=topo,
         sim_settings=sim_settings,
         events=[ev_a, ev_b],
@@ -334,18 +326,18 @@ def test_accept_when_never_all_down(
 
 
 def test_server_outage_back_to_back_is_valid(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
-    """Back-to-back outages on the same server (END==START) must be accepted."""
+    """Back-to-back outages on the same server must be accepted."""
     topo = _topology_with_two_servers_and_edge()
-    sim_settings.total_simulation_time = 30  # ensure timestamps are within horizon
+    sim_settings.total_simulation_time = 30
 
-    # srv-1: [10, 15] followed immediately by [15, 20] → no overlap
     ev_a = _mk_server_window("ev-a", "srv-1", start_t=10.0, end_t=15.0)
     ev_b = _mk_server_window("ev-b", "srv-1", start_t=15.0, end_t=20.0)
 
     payload = SimulationPayload(
-        rqs_input=rqs_input,
+        arrivals=arrivals_gen,
         topology_graph=topo,
         sim_settings=sim_settings,
         events=[ev_a, ev_b],
@@ -355,19 +347,19 @@ def test_server_outage_back_to_back_is_valid(
 
 
 def test_server_outage_overlap_same_server_is_rejected(
-    rqs_input: RqsGenerator, sim_settings: SimulationSettings,
+    arrivals_gen: ArrivalsGenerator,
+    sim_settings: SimulationSettings,
 ) -> None:
-    """Overlapping outages on the same server must be rejected by validation."""
+    """Overlapping outages on the same server must be rejected."""
     topo = _topology_with_two_servers_and_edge()
-    sim_settings.total_simulation_time = 30  # ensure timestamps are within horizon
+    sim_settings.total_simulation_time = 30
 
-    # srv-1: [10, 15] and [14, 20] → overlap in [14, 15]
     ev_a = _mk_server_window("ev-a", "srv-1", start_t=10.0, end_t=15.0)
     ev_b = _mk_server_window("ev-b", "srv-1", start_t=14.0, end_t=20.0)
 
     with pytest.raises(ValueError, match=r"Overlapping events for"):
         SimulationPayload(
-            rqs_input=rqs_input,
+            arrivals=arrivals_gen,
             topology_graph=topo,
             sim_settings=sim_settings,
             events=[ev_a, ev_b],
diff --git a/tests/unit/schemas/test_topology.py b/tests/unit/schemas/test_topology.py
index 0ef53e0..edb3306 100644
--- a/tests/unit/schemas/test_topology.py
+++ b/tests/unit/schemas/test_topology.py
@@ -1,27 +1,26 @@
-"""Unit-tests for topology schemas (Client, ServerResources, Edge, …)"""
+"""Unit-tests for topology schemas (Client, NodesResources, Edge, …)"""
 
 from __future__ import annotations
 
 import pytest
 from pydantic import ValidationError
 
-from asyncflow.config.constants import (
+from asyncflow.config.constants import NetworkParameters, NodesResourcesDefaults
+from asyncflow.config.enums import (
     EndpointStepCPU,
-    NetworkParameters,
-    ServerResourcesDefaults,
     StepOperation,
     SystemEdges,
     SystemNodes,
 )
 from asyncflow.schemas.common.random_variables import RVConfig
-from asyncflow.schemas.topology.edges import Edge
+from asyncflow.schemas.topology.edges import NetworkEdge
 from asyncflow.schemas.topology.endpoint import Endpoint, Step
 from asyncflow.schemas.topology.graph import TopologyGraph
 from asyncflow.schemas.topology.nodes import (
     Client,
     LoadBalancer,
+    NodesResources,
     Server,
-    ServerResources,
     TopologyNodes,
 )
 
@@ -43,22 +42,22 @@ def test_invalid_client_type() -> None:
 
 
 # --------------------------------------------------------------------------- #
-# ServerResources                                                             #
+# NodesResources                                                             #
 # --------------------------------------------------------------------------- #
 
 
 def test_server_resources_defaults() -> None:
     """All defaults match constant table."""
-    res = ServerResources()
-    assert res.cpu_cores == ServerResourcesDefaults.CPU_CORES
-    assert res.ram_mb == ServerResourcesDefaults.RAM_MB
-    assert res.db_connection_pool is ServerResourcesDefaults.DB_CONNECTION_POOL
+    res = NodesResources()
+    assert res.cpu_cores == NodesResourcesDefaults.CPU_CORES
+    assert res.ram_mb == NodesResourcesDefaults.RAM_MB
+    assert res.db_connection_pool is NodesResourcesDefaults.DB_CONNECTION_POOL
 
 
 def test_server_resources_min_constraints() -> None:
     """Values below minimum trigger validation failure."""
     with pytest.raises(ValidationError):
-        ServerResources(cpu_cores=0, ram_mb=128)  # too small
+        NodesResources(cpu_cores=0, ram_mb=128)  # too small
 
 
 # --------------------------------------------------------------------------- #
@@ -80,7 +79,7 @@ def test_valid_server() -> None:
     srv = Server(
         id="api-1",
         type=SystemNodes.SERVER,
-        server_resources=ServerResources(cpu_cores=2, ram_mb=1024),
+        server_resources=NodesResources(cpu_cores=2, ram_mb=1024),
         endpoints=[_dummy_endpoint()],
     )
     assert srv.id == "api-1"
@@ -92,7 +91,7 @@ def test_invalid_server_type() -> None:
         Server(
             id="bad-srv",
             type=SystemNodes.CLIENT,
-            server_resources=ServerResources(),
+            server_resources=NodesResources(),
             endpoints=[_dummy_endpoint()],
         )
 
@@ -118,7 +117,7 @@ def _single_node_topology() -> TopologyNodes:
     """Helper returning one server + one client topology."""
     srv = Server(
         id="svc-A",
-        server_resources=ServerResources(),
+        server_resources=NodesResources(),
         endpoints=[_dummy_endpoint()],
     )
     cli = Client(id="browser")
@@ -142,7 +141,7 @@ def test_edge_source_equals_target_fails() -> None:
     """Edge with identical source/target raises ValidationError."""
     latency_cfg = RVConfig(mean=0.05)
     with pytest.raises(ValidationError):
-        Edge(
+        NetworkEdge(
             id="edge-dup",
             source="same",
             target="same",
@@ -155,7 +154,7 @@ def test_edge_missing_id_raises() -> None:
     """Omitting mandatory ``id`` field raises ValidationError."""
     latency_cfg = RVConfig(mean=0.01)
     with pytest.raises(ValidationError):
-        Edge(  # type: ignore[call-arg]
+        NetworkEdge(  # type: ignore[call-arg]
             source="a",
             target="b",
             latency=latency_cfg,
@@ -169,7 +168,7 @@ def test_edge_missing_id_raises() -> None:
 def test_edge_dropout_rate_bounds(bad_rate: float) -> None:
     """Drop-out rate outside valid range triggers ValidationError."""
     with pytest.raises(ValidationError):
-        Edge(
+        NetworkEdge(
             id="edge-bad-drop",
             source="n1",
             target="n2",
@@ -189,7 +188,7 @@ def _latency() -> RVConfig:
 
 def _topology_with_lb(
     cover: set[str],
-    extra_edges: list[Edge] | None = None,
+    extra_edges: list[NetworkEdge] | None = None,
 ) -> TopologyGraph:
     """Build a minimal graph with 1 client, 1 server and a load balancer."""
     nodes = _single_node_topology()
@@ -200,14 +199,14 @@ def _topology_with_lb(
         load_balancer=lb,
     )
 
-    edges: list[Edge] = [
-        Edge(  # client -> LB
+    edges: list[NetworkEdge] = [
+        NetworkEdge(  # client -> LB
             id="cli-lb",
             source="browser",
             target="lb-1",
             latency=_latency(),
         ),
-        Edge(  # LB -> server (may be removed in invalid tests)
+        NetworkEdge(  # LB -> server (may be removed in invalid tests)
             id="lb-srv",
             source="lb-1",
             target="svc-A",
@@ -222,7 +221,7 @@ def _topology_with_lb(
 def test_valid_topology_graph() -> None:
     """Happy-path graph passes validation."""
     nodes = _single_node_topology()
-    edge = Edge(
+    edge = NetworkEdge(
         id="edge-1",
         source="browser",
         target="svc-A",
@@ -235,7 +234,7 @@ def test_valid_topology_graph() -> None:
 def test_topology_graph_without_lb_still_valid() -> None:
     """Graph without load balancer validates just like before."""
     nodes = _single_node_topology()
-    edge = Edge(
+    edge = NetworkEdge(
         id="edge-1",
         source="browser",
         target="svc-A",
@@ -249,7 +248,7 @@ def test_topology_graph_without_lb_still_valid() -> None:
 def test_edge_refers_unknown_node() -> None:
     """Edge pointing to a non-existent node fails validation."""
     nodes = _single_node_topology()
-    bad_edge = Edge(
+    bad_edge = NetworkEdge(
         id="edge-ghost",
         source="browser",
         target="ghost-srv",
@@ -292,7 +291,7 @@ def test_lb_missing_edge_to_covered_server() -> None:
         load_balancer=lb,
     )
     edges = [
-        Edge(
+        NetworkEdge(
             id="cli-lb",
             source="browser",
             target="lb-1",