diff --git a/notebooks/3-lsib-demo.ipynb b/notebooks/3-lsib-demo.ipynb index 839bfef..1dead17 100644 --- a/notebooks/3-lsib-demo.ipynb +++ b/notebooks/3-lsib-demo.ipynb @@ -6,8 +6,6 @@ "metadata": {}, "source": [ "# Demo: matching LSIB data and Overture's divisions data\n", - "**Workshop demo for NGA + Esri, May 2026**\n", - "**~15 min runtime.**\n", "\n", "This notebook steps through the process of matching LSIB and Overture data and building a crosswalk file that links LSIB IDs and Overture's GERS IDs.\n", "\n", @@ -32,8 +30,8 @@ "\n", "| LSIB ID | GERS ID | match_class | \n", "| ----- | ----- | ----- | \n", - "| UUID 1 | UUID 2 | match | \n", - "| UUID 1 | UUID 2 | review | \n", + "| LSIB UUID | Overture UUID | match | \n", + "| LSIB UUID | Overture UUID | review | \n", "\n", "A few framing notes that will help orient the rest of the notebook:\n", "\n", @@ -74,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "322d4e18-2ad3-4993-9dfa-5a7384e12748", "metadata": {}, "outputs": [], @@ -97,22 +95,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "cf18a867-c065-4091-add2-cdd72e80db45", "metadata": {}, "outputs": [], "source": [ - "# Load LSIB\n", + "# Set paths for LSIB\n", "# Download DoS_LSIB_v11_4_24Feb2025.gpkg from geodata.state.gov and place it in the data/ directory before running this cell.\n", - "LSIB_PATH = DATA / \"DoS_LSIB_v11_4_24Feb2025.gpkg\"" + "LSIB_PATH = DATA / \"DoS_LSIB_v11_4_24Feb2025.gpkg\"\n", + "LSIB_LAYER = \"Department of State LSIB v11.4 24Feb2025\"\n", + "\n", + "# Set paths for Overture\n", + "# division_boundary: the linear features we'll match against LSIB\n", + "# division: filtered to subtype='country', used as a UUID -> country-code lookup\n", + "OVT_BOUNDARY_S3 = f\"s3://overturemaps-us-west-2/release/{OVERTURE_RELEASE}/theme=divisions/type=division_boundary/*\"\n", + "OVT_DIVISION_S3 = f\"s3://overturemaps-us-west-2/release/{OVERTURE_RELEASE}/theme=divisions/type=division/*\"\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "1073e433-d008-4a82-a56d-02856c240f7d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using Overture release: 2026-04-15.0\n" + ] + } + ], "source": [ "import pystac\n", "\n", @@ -126,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "6d13865a-b19d-4cc1-b732-c183e3738995", "metadata": {}, "outputs": [], @@ -137,10 +150,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "ff860c5e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DuckDB ready.\n" + ] + } + ], "source": [ "# DuckDB with anonymous S3 access for Overture's public bucket.\n", "con = duckdb.connect()\n", @@ -197,10 +218,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "95a39a10", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LSIB rows: 395\n", + "CRS: EPSG:4326\n", + "LSIB after dropping Q2: 381\n", + "Unique LSIB pair keys: 357\n" + ] + } + ], "source": [ "# Load LSIB\n", "lsib = gpd.read_file(LSIB_PATH, layer=LSIB_LAYER)\n", @@ -241,10 +273,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "72610dc9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45ad561ff7e24a9a9370bc64dbf0e351", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overture country divisions: 219\n" + ] + } + ], "source": [ "# Load Overture `division` data for the country subtype to create the id->country lookup\n", "countries_sql = f\"\"\"\n", @@ -258,10 +312,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "bb1a41d5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fa776d20d53f4689b92c1bf03b9030f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Country-to-country Overture boundaries: 363\n", + "Unique Overture pair keys: 338\n" + ] + } + ], "source": [ "# Pull all is_land=true boundary features from Overture `division_boundary` data.\n", "# This includes boundaries at every administrative level: country-to-country,\n", @@ -326,10 +403,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "8c331ccf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reprojected to EPSG:6933 for metric computation.\n" + ] + } + ], "source": [ "# Reproject both to metric CRS for length and buffer math\n", "lsib_m = lsib.to_crs(METRIC_CRS)\n", @@ -376,10 +461,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "4ffee043", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== LSIB v11.4 ===\n", + "Rows: 381\n", + "Geometry: ['MultiLineString']\n", + "\n", + "Columns and dtypes:\n", + "CC1 str\n", + "CC1_GENC3 str\n", + "CC1_WPID str\n", + "COUNTRY1 str\n", + "CC2 str\n", + "CC2_GENC3 str\n", + "CC2_WPID str\n", + "COUNTRY2 str\n", + "RANK str\n", + "LABEL str\n", + "STATUS str\n", + "NOTES str\n", + "ID str\n", + "ANTECIDS str\n", + "PREVIDS str\n", + "PARENTID str\n", + "PARENTSEG object\n", + "geometry geometry\n", + "cc1_iso str\n", + "cc2_iso str\n", + "pair_key str\n", + "\n", + "First row (transposed for readability):\n", + "CC1 AF\n", + "CC1_GENC3 AFG\n", + "CC1_WPID 5c56cf7d-c485-4659-9399-5c17e9003112\n", + "COUNTRY1 AFGHANISTAN\n", + "CC2 CN\n", + "CC2_GENC3 CHN\n", + "CC2_WPID 422131df-82bc-4f1b-9a1f-ee89cc970e19\n", + "COUNTRY2 CHINA\n", + "RANK 1\n", + "LABEL NaN\n", + "STATUS International Boundary\n", + "NOTES NaN\n", + "ID 4990410a-4158-4932-8445-90397c840a87\n", + "ANTECIDS NaN\n", + "PREVIDS 4990410a-4158-4932-8445-90397c840a87\n", + "PARENTID NaN\n", + "PARENTSEG None\n", + "geometry MULTILINESTRING ((74.88986200000005 37.2340899...\n", + "cc1_iso AF\n", + "cc2_iso CN\n", + "pair_key AF|CN\n" + ] + } + ], "source": [ "# LSIB columns and types\n", "print(\"=== LSIB v11.4 ===\")\n", @@ -395,10 +536,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "44e32a3b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Overture division (subtype='country') ===\n", + "Rows: 219\n", + "\n", + "Columns and dtypes:\n", + "id str\n", + "country str\n", + "\n", + "First few rows:\n", + " id country\n", + "0 a92c1621-fad0-4bdd-963b-9623f7514df2 WS\n", + "1 fef8748b-0c91-46ad-9f2d-976d8d2de3e9 TO\n", + "2 577750a0-cfee-454d-996c-dd5867f185ee EC\n", + "3 449b9525-0be3-4a9a-bf19-d65f07f7e81e PE\n", + "4 1b152fd1-e23c-497e-befe-b3c1e8644ed5 NI\n" + ] + } + ], "source": [ "# Overture `division` (filtered to subtype='country') — the lookup table\n", "print(\"=== Overture division (subtype='country') ===\")\n", @@ -413,10 +575,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "af29296d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Overture division_boundary (filtered to is_land, country-to-country) ===\n", + "Rows: 363\n", + "Geometry: ['LineString', 'MultiLineString']\n", + "\n", + "Columns and dtypes:\n", + "id str\n", + "division_ids object\n", + "is_disputed bool\n", + "is_land bool\n", + "is_territorial bool\n", + "cc_left str\n", + "cc_right str\n", + "pair_key str\n", + "geometry geometry\n", + "\n", + "First row (transposed for readability):\n", + "id ce592c92-7c1f-3e07-92f7-afbe10114a5b\n", + "division_ids [fc20aaf8-7a12-4cb2-9b0b-ebb1a4b652aa, 388f999...\n", + "is_disputed False\n", + "is_land True\n", + "is_territorial False\n", + "cc_left MX\n", + "cc_right GT\n", + "pair_key GT|MX\n", + "geometry LINESTRING (-92.2283178 14.5310748, -92.227722...\n" + ] + } + ], "source": [ "# Overture division_boundary columns and types\n", "print(\"=== Overture division_boundary (filtered to is_land, country-to-country) ===\")\n", @@ -482,10 +676,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "9efe8fc7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bucket\n", + "clean_1_to_1 301\n", + "lsib_only 38\n", + "overture_only 19\n", + "fragmented 14\n", + "both_fragmented 4\n", + "Name: count, dtype: int64\n", + "\n", + "Total pairs: 376\n" + ] + } + ], "source": [ "# Count features per pair on each side\n", "lsib_counts = lsib_m.groupby(\"pair_key\").size().rename(\"n_lsib\")\n", @@ -548,10 +758,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "a066cd8e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LSIB features for AR|BR: 1\n", + "Overture features for AR|BR: 2\n", + " overlap_lsib: 0.9846\n", + " overlap_ovt: 0.9791\n", + " length_ratio: 0.9958\n", + " len_lsib_m: 1,282,040.4927\n", + " len_ovt_m: 1,287,422.3779\n" + ] + } + ], "source": [ "def overlap_metrics(lsib_geom, ovt_geom, tolerance_m=250):\n", " \"\"\"Compute bidirectional overlap and length ratio between two geometries.\n", @@ -652,10 +876,124 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "5fc9a92c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scoring 319 pairs...\n", + "Scored 319 pairs.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pair_keybucketoverlap_lsiboverlap_ovtlength_ratiolen_lsib_mlen_ovt_m
0AD|ESclean_1_to_10.9542920.9405330.98731566291.34708467143.064109
1AD|FRclean_1_to_11.0000001.0000000.98651461418.81298060590.493463
2AE|OMclean_1_to_10.9193140.9006020.973507611390.572083628029.209635
3AE|SAclean_1_to_10.6950480.6957730.999559445127.424700444930.971054
4AF|CNclean_1_to_10.9656960.9853120.97961494400.99297292476.491563
\n", + "
" + ], + "text/plain": [ + " pair_key bucket overlap_lsib overlap_ovt length_ratio \\\n", + "0 AD|ES clean_1_to_1 0.954292 0.940533 0.987315 \n", + "1 AD|FR clean_1_to_1 1.000000 1.000000 0.986514 \n", + "2 AE|OM clean_1_to_1 0.919314 0.900602 0.973507 \n", + "3 AE|SA clean_1_to_1 0.695048 0.695773 0.999559 \n", + "4 AF|CN clean_1_to_1 0.965696 0.985312 0.979614 \n", + "\n", + " len_lsib_m len_ovt_m \n", + "0 66291.347084 67143.064109 \n", + "1 61418.812980 60590.493463 \n", + "2 611390.572083 628029.209635 \n", + "3 445127.424700 444930.971054 \n", + "4 94400.992972 92476.491563 " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "def score_pair(pair_key, lsib_df, ovt_df):\n", " lsib_geoms = lsib_df[lsib_df.pair_key == pair_key].geometry.values\n", @@ -696,10 +1034,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "17ed24e5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bidirectional overlap (min of the two directions) percentiles:\n", + "count 319.000000\n", + "mean 0.869211\n", + "std 0.204357\n", + "min 0.006549\n", + "10% 0.619115\n", + "25% 0.845916\n", + "50% 0.964235\n", + "75% 0.996889\n", + "90% 1.000000\n", + "95% 1.000000\n", + "max 1.000000\n", + "Name: overlap_min, dtype: float64\n", + "\n", + "Length ratio percentiles:\n", + "count 319.000000\n", + "mean 0.961382\n", + "std 0.107750\n", + "min 0.000527\n", + "10% 0.920163\n", + "25% 0.969884\n", + "50% 0.988914\n", + "75% 0.997949\n", + "90% 0.999560\n", + "95% 0.999834\n", + "max 0.999998\n", + "Name: length_ratio, dtype: float64\n" + ] + } + ], "source": [ "# Quick distributional view: percentiles of the two metrics\n", "# Using min(overlap_lsib, overlap_ovt) since that's what the classifier uses\n", @@ -715,10 +1087,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "e3466d99", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Histograms of the two metrics, with the 0.95 match threshold marked\n", "import matplotlib.pyplot as plt\n", @@ -775,10 +1158,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "4e9bb92c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "match_class\n", + "match 169\n", + "geometric_disagreement 100\n", + "review 45\n", + "unmatched 5\n", + "Name: count, dtype: int64\n" + ] + } + ], "source": [ "def classify_match(row, match_thresh=0.95, length_thresh=0.95, floor=0.10):\n", " if pd.isna(row.overlap_lsib) or pd.isna(row.overlap_ovt):\n", @@ -818,10 +1214,140 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "a612964e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bucketmatch_classlen_lsib_mlen_ovt_mlength_ratiooverlap_lsiboverlap_ovt
pair_key
AR|BRfragmentedmatch1.282040e+061.287422e+060.9958200.9846090.979073
NO|SEclean_1_to_1match1.910568e+061.854913e+060.9708700.9710181.000000
DE|LUclean_1_to_1unmatched6.627805e+031.389564e+050.0476971.0000000.053010
MY|SGclean_1_to_1unmatched8.291065e+044.368652e+010.0005270.0065491.000000
IN|PKfragmentedgeometric_disagreement3.158016e+063.120645e+060.9881660.9198690.930455
KE|SSboth_fragmentedunmatched3.105996e+054.212717e+050.7372900.0314590.022859
\n", + "
" + ], + "text/plain": [ + " bucket match_class len_lsib_m len_ovt_m \\\n", + "pair_key \n", + "AR|BR fragmented match 1.282040e+06 1.287422e+06 \n", + "NO|SE clean_1_to_1 match 1.910568e+06 1.854913e+06 \n", + "DE|LU clean_1_to_1 unmatched 6.627805e+03 1.389564e+05 \n", + "MY|SG clean_1_to_1 unmatched 8.291065e+04 4.368652e+01 \n", + "IN|PK fragmented geometric_disagreement 3.158016e+06 3.120645e+06 \n", + "KE|SS both_fragmented unmatched 3.105996e+05 4.212717e+05 \n", + "\n", + " length_ratio overlap_lsib overlap_ovt \n", + "pair_key \n", + "AR|BR 0.995820 0.984609 0.979073 \n", + "NO|SE 0.970870 0.971018 1.000000 \n", + "DE|LU 0.047697 1.000000 0.053010 \n", + "MY|SG 0.000527 0.006549 1.000000 \n", + "IN|PK 0.988166 0.919869 0.930455 \n", + "KE|SS 0.737290 0.031459 0.022859 " + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "EXAMPLES = [\"AR|BR\", \"NO|SE\", \"DE|LU\", \"MY|SG\", \"IN|PK\", \"KE|SS\"]\n", "examples_df = scored[scored.pair_key.isin(EXAMPLES)].set_index(\"pair_key\").loc[EXAMPLES]\n", @@ -886,10 +1412,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "2f4648b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAMWCAYAAABlXCWxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtCxJREFUeJzs3Qd4U2XbB/B/dtqmu1DK3nsIgjJFGaKC+jpQcYDzU8Qt7tct4l6vinvvPRGUKaAge+9ZCt27zc75rvtI0qYD2tI2o//fdYWS55wkT56T5NznmRpFURQQERERHaH1/oeIiIiIwQERERFVwpoDIiIi8sPggIiIiPwwOCAiIiI/DA6IiIjID4MDIiIi8sPggIiIiPwwOCAiIiI/DA5CxCOPPIL27dsHOhsh659//oHRaMT+/fvr7TldLhfuvvtutGnTBlqtFv/5z3/QlG3ZsgV6vR6bNm0KdFaoAX311VdISEhAcXFxvT2nPNe1116LFi1aQKPR4LbbbkO4ysnJQVRUFGbPno1gxuCggX3wwQfqh33VqlV+J3pJS05ORmlpaaXHSBAwYcKEGj+392Y2m9G1a1fcdNNNyMjI8O23aNEidfs333zj93iHw6G+jpzY3nvvvXp5b1XJysrCrbfeiu7duyMiIgLNmzfHSSedhHvuucfvB+bKK6+ExWLxe+ypp57q9x7lBN+hQwf83//9H1JTU2uc1wceeACTJk1Cu3bt1Psej0fN/znnnKOe3OXL2rt3bzzxxBOw2Ww1ek4ps2effRYXXnghPvzwQ9x+++1oCJ999hleeuklBLuePXti/PjxeOihhxDsDhw4gBtuuEH9rplMJvUzKcHdsmXLAh5gye/Dvn37EIzcbjcefvhh3HzzzX7f1d9//x3XXHON+h3S6XS1vpB58skn1e/j1KlT8fHHH+OKK65ogNwDr7/+uvo6gZSYmKgGQg8++CCCmT7QGWjKMjMzMWvWLNx5553H9TyPPfaYesKUk9rSpUvV55SoVK7gIiMjq3yM0+lUT2qy39tvv42rr74aDSE3NxcDBw5EYWGh+hoSIEjkvGHDBjWf8mNQMSCoqHXr1pg5c6YvoJEf0DfeeANz587F1q1bq32PXuvWrcO8efPw119/+dIkKLvqqqswePBg9SQhJ4e///5b/eGbP38+FixYoAYjRyP7tGrVCi+++CIakgQHcixD4WpKyvKss87C7t270alTJwQjCQAkj0J+pCWoSU9PV08aI0aMwMsvv6ye/AJBPtuPPvqoGhQHY03hzz//jO3bt6vBecXP6JdffokBAwagZcuWtX5e+S7Jd1G+fw1JgoOkpCT1QiTQ35NXXnlFfd+jRo1CMGJwEEAnnHCCeuV54403qlfUdXXmmWeqJ2Dvj51Epi+88AJ+/PFH9Wq5qsDgoosuwi+//II333xTjfgbyrvvvqtepckP8tChQ/22ScAgNQHHEhsbi8svv9wvTYIhqSGR5x07duxRH//++++jbdu26o+Pl7xuxTxdd9116g+yN0AYM2bMMYO7uLg4hCoJkI4VWNWWlFl8fLxakyJBa7DJy8tTg2L5vsnxLx/A3HHHHRg3bpwahJ144omVPq8NSQL7mnwX6qqkpEStHTte8l0aNmyYGhRXvPKXiwyDwaDWRta2aUm+SxKkhSJFUdTjV5vf8B49eqi1LBKQBmtwwGaFAJLqV6n+lyvo+uT9sO3du7fKdvJLLrlEDRzkdeWEWNG2bdvUE3p9kCtIqWYsf2L2iomJUZtC6kLaJoW0cR/LDz/8oJZJ+ZoA+SGu6sf/vPPOU/9KjUR1pMpXnmvhwoXYvHmzr8lDmm+8TRbSDNCrVy/1/Unz0fXXX6+emMqTYyDV8HKlJVXbcqJ6/PHH1apbL7mC/PXXX9W+Et7X8V5Rept1KlZBe5uRvPnxPo/8GK1evRqnnHKKGhTcf//96ja73a4GRJ07d1bzIc0s0pdC0sv7448/MHz4cDUgktqebt26+Z7DS04O8lry3o5Gmrgkj4sXL660TQJW2eY9wchVvdTySA2S5C8lJQXnnntunare5bnl+SQor1izIT/uEtTIa3sDG2kyk/uSXpHUXMk2CbK90tLS1BoyOeaSV/kMVGyy8x6fL774Av/973/VE60cD7mSnDhxorrPaaedVulzJf+XJoeK5PNQ/krY+7mQspULD6kVk7Lz+u2339QaEgkWoqOj1c+gfI6PRU6Ac+bMqTJols+wHPva8paF/FbJ59z7nr3HtqafTQla5Dsu71X2k0Cj4u+qlJO8TykX7+vIZ7V8U29FH1TxHfM2+8rxl4sy+dzI50rk5+erwaXkU/Ih+X766afV34SK5KJGamKCdWFk1hwEkHxB5QP9zDPPqNXrx1N7UPGELKQGoWJgIDUJ33//PV577TX1hFVdVDty5Ei/k0tdSRu/nOykHXHKlCl1eg55fHZ2tq/WQ07c3h8MuYo5GvmxlkBHqjtrQk4cQqoeq9OsWTP1/cyYMUPtM+Ft8pByE1Ku8qMiJ7RbbrlF/eF79dVXsXbtWvVq1fsjKvvISVauWOWvVDFKwCg1KnLy8vaVKCgowMGDB33NF8dqhqmONOdILZMEh1ITIycw+dGSfhfSHCVVxfIeNm7cqL7Wjh071MBKyI+q/CD27dtXPXHKD9+uXbuqbKOXq24JDuR9SABYFTkhyfuQzm3yWStPqqflpCrBjLjgggvU15eqfvlhlqtMCVTkuNa26l1+jCVgk5qzqkiNlARAciysVqv649+xY0c1nxU/v5JPqSWR2gYhgb4EwXIykVot+ZzIiVhq5qQsKjYLSSAoQer06dPVk93pp5+ufl4kSJCgy/t58v6tLQkMJA/ymZKaA+H9Hkqe5aQltUdyEpX3LJ/Po5WnBJbSrFfT71JNyHuTPEl/HQlgvE2sku+afjaFvAf5zMj+csEgx1nevzzHtGnT1H0kYPf2lZDvlZDvQF1s375d/S2V77pcYEmgLGUpn2X5zZF0qa2Upsz77rsPhw8frtRvSL4n8l7ks+39rAcVhRrU+++/L2GhsnLlSl/aww8/rKZlZWUpixcvVv//wgsv+La3a9dOGT9+vN/zyGMkvarnnjdvnvpcqampyhdffKEkJiYqERERysGDB9X9Fi5cqO4nj5e/r7322lHzLPuMHDmyTu+tovT0dKVZs2bqft27d1duuOEG5bPPPlPy8/Mr7TtlyhQlKirKL03yIY+teOvRo4eyZ8+eY+ZRykb2//nnn5WaGDNmjBITE6Pk5eUdc1/JW69evfzSlixZor7ep59+6pc+Z86cSumlpaWVnvP6669XIiMjFZvN5kuTz0LFY1++/Pfu3euX7j3e8rd8XiXtjTfe8Nv3448/VrRarZrv8mQ/2X/ZsmXq/RdffNH3mT0WOb6y74oVK46636RJk5TmzZsrLpfLl3b48GE1P4899ph6X46DPNezzz6r1Ie4uDilX79+R93nlltuUV9zw4YN6v377rtPMRgMSm5urm8fu92uPtfVV1/tS7vmmmuUlJQUJTs72+/5LrnkEiU2NtZ3vL3Hp2PHjpU+A19//XWlY+cl6fI7UJF8NuS7U/FzMXz4cL+yLSoqUvN83XXXVfqOSv4qplf0zjvvqM+7cePGo+5X3ef1aKr6zavpZ7O679K4cePUMi5Pvq9V/bZ5f5Nr8h1rd+R3VL7T5T3++OPq79eOHTv80u+9915Fp9MpBw4c8Ev/66+/1Of58ssvlWDEZoUAkypeqUKU2gO5UqkLqeaTSFuqsuSqUCJjqR2o2C4oVzYSVcvV0dHI71B91Bp4I/P169erHXCkWl06El566aVq9Z9cOdWkSk2uZuRKUW5yJSYRuFxNy1WwjIQ41tWykCu8Y5F2U+m4+NRTT9W5L8HXX3+t9pGQKkOp7fDe5CpBjos0RXiVrykqKipS95PaJLkCkaad+iZX+1KbUTG/ckUmHUXL59fbNOXNr7c8pEagqirS8rxl7a3tqc7FF1+s1gKU/6xJc4M8v2zzlpFcXcs+FZtl6kLKWarSj8a7Xa72vfmUGqvvvvvOr3e+VCF78ymf42+//RZnn322+v/yZSlX6fJ5XbNmjd/ryBV8fdUWVkWuaKVJz0u+P5JnueItnz/Z5+STT/b7bB7vd6k+1PSzKcqXo5S17CdX8Xv27FHv17cOHTr4aozK51e+v1I+5fMrv89S+/nnn3/W6XsSKGxWCALS3iUfZDlx1mU4nDQRyBBGOfHLyViquGR4YkUSgMiJVTpkyY/bsark64u0EUu1n/QU3rlzp9pWJ1WaUt0p26QT5dFI22j5ds4zzjhDrQaVKl85kT///PPHzMOxghCpIpb2X6kCliaeupL3Jz9GEvxURU6GXlKdKK8pVdjeE5FXQ/ygSbBYsdOb5FeaaSS4PFp+5ST4zjvvqMfq3nvvxejRo3H++eern6WKnzVvWR9rtIccRwmkpOzl+YT8XzrqyufZG9DIZ0Wqm+WzLdX20rwxefJkX7+T2pATvwQIR+Pd7g0S+vXrp56gJG/ezrvyf2l68p6oJEiVE+9bb72l3o517MWxgvTjVfH55ViL6jrAVdcEVFFjtZHX9LMppHlLmhplxFHF4eHyXZLPWX3qUMWxk/zKKKya5Lc235NAYXAQJLUH0jFGTt5yhV1bMmeAd7TC0ciJ2NupTNp8pWOO/PA1FvkSyI++3OT1u3Tpgk8//fSYwUFV5EpcvvAVo/GKvP0ujnbVKWUiJxvJkwRox0OueiUwkPdVFe8Ph5xIJCCUH2Rpw5fOcdIWLleXMv/Dsa7Oj/ajUr5DY3lVXaXK6/Tp00cd3VIVqY3yPlbKWq7WpOOYdEyTE6ScaCTQLH+F6i3ro/Xb8J74ZW4BqeWSwFFqtuRHXmpwypO2erkilzZmCSxlfLj085Cgqn///qgNuRKVtnVp45fXr4r8wEu/EPl8eklwJH1M5CpPgoaffvpJvQL3doj1Hi/py1Fd3xrpr1FefdUa1PR4e/MobfxVBVbH6txb/rtUvoNjQ6npZ1P6WElwKQGc7CvpEgTLMG1p02/M79LYsWPVDpNV8Qa8tf2eBAqDgyCqPZAAwdvrtaFI5yr5gZUTk1SLLVmyxO9HsLFIPqRaTTrq1JV8cY81S5v8YFQ3ckOsWLFCHaEgwZV0OqvJ6IejkZO8NE1IrczRfvylmlyqaaWqWoJDr6ryWd0Pl7daUgKN8mozC6TkV5p95Mf1WFcwUkMg+8lNfoTlJC4duyRgKF+zI+9B9q34Y1gVOenKSAAZOipXiXI15a2qr5hPqT2Qm1yhSe2C1Bh98sknqA2pdZCrS6kCrjg8VkivdPlOyPspf/wkTzL/gDQdSA2G1PRIE175oE+CBvlMHmsI7NEc7RjI8a54rKWDYE2/Q97RGRK81iWP5b9LctJuaDX9bErnQwn2JGCTToBeVTWT1OS7VL5JcX8tv0vye1TTsvV+1+va4bShsc9BkJCTtQQHUoVa0xn66kq+2HL1Jx9kiXSld21DDWWUk6+3p3TF6Yzl5ChNIHUhX3zJ/7FqPqQqXa4kqprFUU5GUlsgfRpkOFp9XMlJL3g5QUh/iopktIj3x917pV2+ilZ+6OUKuqpmlaqaGbw/9uVrT+S1q6vWri6/cvxljHpF0gfGe+xkMquK5AQtKg4rk17t0nO8JlW58kMqU/FKLYTcpBasfJWtVBFX/D7I+5YTcfnXlROkfG6lb8DRSC9yOTneddddant0efI60idDjknFWR7lB1y+N958Si1c+aBOjqeMqpDgoaox/sfqG+PlnYugYhDgfd8Va8rkWFd3dVuRXAxITZUEdVWV07HyKLV1ckV+rBlR60tNP5tVfZfk+yLDG6sq3+rKVpQv35KSkiqHsB4tvxJ4ysVXRfKa8v2v+D2R74h8V4IRaw6CiLSZSefExjBkyBD1qlWqayVAkKslb7VhbYcyyjhuqWauSKZMlipMqWKXq3Pvj4uclOUxUo1ecZx8VeSL7r1ClC+YDCOSPgxyMpf272ORMfFSdS0/Ht4rB2lXlh9LqdqTE4UESxV/LKSMakvKTU5AUu0tMzPK8DSpoparXblaldn3pJ1e5liQqxWpgpbha5IvKauq2nOl3OSEJEMeBw0apHZslOMmPyrSBi9DpeTkLSdZGTtf8UfoaGSaWqkxkeYsCbikxkNONnKilXTvWG5p+pAfTgmmZHiqtJ9KICPVy9JM5SUnHe/4+pqQspG+C5Jv+TF+7rnn/LbLkDW5cpQfXhm7LjU7ciylCaL8lbuUgfyQy9XY0YbjyWdcOj3K+5AheRVnSJThmXKMqpoDQ2oPJGiQz630PajY10L6v0gZSuc+6QwozyvHRZqKpDapqgCrqoBLTnZykSCfe2n68I7fl7zKcZIgRL6zclUtx6em1dISGMj3Ro65vHcpP6nxkAsB+fzLsZcht9WR9y2fZ3kvFSe4kqYYuXIXUoaSd5mKXEgAL5/X2qrpZ1PyJL8r8hry3ZOLBgkopMwq1qrId0nKQPImQ6FlHylfeQ6pdZDjKr8HOp1O/Y3ylk9NyOOkDKR2SuadkNeSz7QMv5TPnNRKlT9W0pwpeQ7WPgccyhjgoYwVeYec1WYo49GGEpYfOiXDpCqSYTQyXGjQoEFKYWFhnYYyVneToZUyHOyuu+5SBgwYoCQkJCh6vV4d7jVx4kRlzZo1tR7KqNFo1Oc555xzlNWrVys1Ia8jjy0/JEqGJh0t7+WHhtVmKKPXW2+9pZx44onqkNLo6GilT58+yt13360cOnTIt48MxRo8eLC6T8uWLdXtc+fOrTSUrbi4WLn00kvVYWjeIaleu3fvVodfmkwmJTk5Wbn//vuVP/74o8qhjNXl1eFwKE8//bS6XZ4nPj5ezfujjz6qFBQUqPvMnz9fOffcc9V8Go1G9a8MRaw4bOu3335TX3vnzp1KTXnzK8dWPjPlybDAadOmqcNg5bMhQ+5OPvlk5auvvvLbT45XVcM6qyP7ydC9tm3bqsMUk5KS1M9UxWFz5cl78n4+li5dWuU+GRkZan7btGmjPm+LFi2U0aNHq5+Hmnwfxdtvv60OwZPhb+WPo9vtVu655x41rzLcVYbq7dq1q9qhjNX9LsjzyWOlLM1ms9KpUyflyiuvVFatWnXMcvvuu+/U41RxWN7Rfgtq8l2qaihjTT+b4qefflL69u2rvp/27durj3nvvfcqfSZk2Ka8jnwnK/7Oye+JfLbk8922bVt1eHl1Qxmryqt3uKgMfe3cubP6PHKshg4dqjz33HPqe/HaunWrbxh6sNLIP4EOUKhmfRLkyiZYF2QJdnL1KbO4ydU5NRzpYChXQnJ1T+FHrtylRkRqcqpqOqOakU62UhMnTQvBWnPAPgfUJEg7q1TN1+eSzeRPmouk7wZPGuFLqtulSUGGT9fnks1NSU5OjjosWJo2gjUwEKw5CBGsOSAiosbCmgMiIiLyw5oDIiIi8sOaAyIiIvLD4ICIiIj8MDggIiIiPwwOiIiIyE+TDg5kEgqZvlImx5HxprLqW23JHFIy5assMiNTncpc/rJ6GxERUahq0msryLzXMu/31Vdfrc7vXheyfoAsWSsBgizMIvOn12QOdSIiomDFoYzegjgy5atM/+olq77JkrSff/65uqpW79691QVRZPVE74xwska7rMJW19UFiYiIgk2TblY4lptuukldglNWjJNVxyZOnIgzzjhDXWHPu454x44d1SljZZlZWQ1OVk5jzQEREYUyBgfVkGU6ZT1wWWZ3xIgR6hK+06dPV5en9a4TLuvBy1z9ss9HH32kLowkC2nIkrxEREShqkn3OTgaWYNbViCTjoblSVODrAkvPB6Pel8CA+9+7777rrqO9/bt29nUQEREIYnBQTVkxTFZgUxqAuRveRaLRf2bkpICvV7vF0D06NHDV/PAfghERBSKGBxUo3///mrNQWZmptqsUJVhw4bB5XJh9+7darOD2LFjh/q3Xbt2DXXMiIiIGlSTHq0gtQO7du3yBQMvvPACTjvtNCQkJKBt27a4/PLLsWzZMjz//PPq9qysLMyfP18doTB+/Hi1WWHQoEFqTcJLL72k3p82bRpiYmLU4Y1EREShqEkHB4sWLVKDgYqmTJmidi50Op144okn1D4FaWlpSEpKwuDBg/Hoo4+qcxqIQ4cO4eabb1aDgaioKJx55plqMCEBBhERUShq0sEBERERVcahjEREROSHwQERERE17eBAWlEKCwvVv0RERE2FUovzX5MbyigFExcXh9TUVHVUARERUVM5/7Vp00ZdKyg2Nvao+za54KCoqEj9KwVERETUFM+DsQwO/EVHR6t/WXNARERNseYg+sh58Gj0TXFpZiFNCmxWICKipnoePJom1yGRiIiIjo7BARERETXtZgUioqZIFpKTKeEpfBkMhkqrCNcVgwMiojAmY9rT09PV4WsU/uLi4tCiRYsa9Ss4GgYHRERhzBsYNG/eHJGRkcd90qDgDQJLS0uRmZmp3k9JSTmu52NwQEQUxk0J3sAgMTEx0NmhBhYREaH+lQBBjvnxNDGwQyIRUZjy9jGQGgNqGiKPHOvj7V/C4ICIKMyxKaHp0NRTsxGDAyIiIvLD4ICIiIj8MDggIqKgc+WVV+I///lPldvWr1+Pc845R+10Zzab0b59e1x88cW+nvr79u1Tq9fXrVvnd997MxqN6Ny5M5544okaLV/cFHG0AhERhYysrCyMHj0aEyZMwNy5c9Vx/XLy/+mnn1BSUnLUx86bNw+9evWC3W7H0qVLce2116pD/q655ppGy3+oYHBARNQEZTz9TKO+XvI9d9fL8yxbtgwFBQV45513oNf/ewrr0KEDTjvttGM+VoZzygRBol27dnj//fexZs0aBgdVYHBARNQEOfbuRSiSk7vL5cL333+PCy+8sM6981etWoXVq1dj8uTJ9Z7HcMA+B0REFDIGDx6M+++/H5deeimSkpJw5pln4tlnn0VGRsYxHzt06FBYLBa1z8GgQYNw0UUXMTioBoMDIiIKKTNmzFCnhX7jjTfUPgTyt3v37ti4ceNRH/fll1+qnRSlQ+NXX32FH3/8Effee2+j5TuUMDggIqKQI/0HJk6ciOeeew5bt25Fy5Yt1f8fTZs2bdRRCj169FAfe9ttt+H555+HzWZrtHyHCvY5ICJqgowdOiBcSDNBp06djjlaoSJZe0D6LzgcDnVIJJVhcEBE1ATV1+iBhiSjErxzFXhJ04EMYbzkkkvQtWtXdZ6Cn3/+GbNnz1ZHHxxNTk6O2hwhAYE8z8svv6yOcoiJiWngdxJ6GBwQEVFQWrRoEfr37++XJidzaRq48847kZqaCpPJhC5duqhDG6+44oqjPt+YMWN8NQYyv8FZZ52l9l+gyhgcEBFR0Pnggw/UW13IjInlZz6seJ+OjR0SiYiIyA+DAyIiIvLD4ICIiIj8MDggIiIiPwwOiIiIyA+DAyIiIvLDoYxERET1qMTuQm6JA/GRRthcbjjdHqTERoRUGTM4ICIiqkcH86xQoCCv1KHejzSG3qmWzQpERET1SK/TwOHy+O7bnO6QK18GB0RERPWoVZx/E4JHUVDqcIVUGTM4ICKioCRrJ1x99dXqcsyy8mK7du1w6623qgsoNYYPPvgAcXFxtX5cVVM1l9jrVnvw559/4uyzz1bLQKPR4IcffkBjYHBARERBZ8+ePRg4cCB27tyJzz//HLt27cIbb7yB+fPnY8iQIcjNzW3Q13c6nXV+bFq+rVKaSVe3tR1kGep+/frhtddeQ2NicEBEREFn2rRpam3B77//jpEjR6Jt27Y488wzMW/ePKSlpeGBBx5Q97v//vtx8sknV3q8nFAfe+wx331ZtbFHjx4wm83o3r07Xn/9dd+2ffv2qVflX375pfpaZrMZn376Ka666ip12WjZJrdHHnlE3b+qK3ipYfAuFLVn7x70axOPOT99h6svHI9BnVvg6y8+O2Y+qiLv+YknnsB5552HxhR6XSiJiOi4ZRfb1eF2jSUhyogki6lG+0qtwNy5c9XllCMi/NvvW7Rogcsuu0w9kcuJVf4/c+ZM7N69G506dVL32bx5MzZs2IBvv/1WvS8n+oceegivvvqqugT02rVrcd111yEqKgpTpkzxPfe9996L559/Xt1Hq9XipZdeUh+3fft2dbvFYqlR/t1H+iK+/NSjuPPBJ9C9V1+0iI+ucT6CAYMDIqIm6OO/9+Pl+Tsb7fVuHd0Ft4/tWqN9pSlB2u3lCrsqkp6Xl4esrCz06tVLrSX47LPP8OCDD6rb5SQstQmdO3dW7z/88MPqSf/8889X73fo0AFbtmzBm2++6XdSvu2223z7iNjYWLWWQAKS2mgd/29Ac/k1UzHmzLN96TXNRzBgswIREQWlqjr2VUVqDyQ48D5G+ihImrfNXmoVrrnmGvXK33uTqnpJL0/6ONSHaLNB/duz7wm+tNLSmucjGLDmgIiIgopc8csV+9atW6tsa5f0+Ph4NGvWTL0/adIk3HPPPVizZg2sVqs6yuHiiy9WtxUXF6t/33777Up9E3Q6nd99qd6vCY1GUylwqaoDY9fWSdBAo06IZC0pUdNem/UGRgwbetR8BAMGB0RETdAVQ9phfN+URu1zUFOJiYkYO3as2qfg9ttv9+t3kJ6erjYbTJ48WT1Ji9atW6sdCSVdggN5bPPmzdVtycnJ6jBAGf3grU2oKaPRCLe78hBECUoOHz7s1wxSWlpaab8Igx7NY0zIKLQhsVlzNEtOwaZtuzBl8hWwOz0w6jXQaYOzAp/BARFREySdA2vaQTAQpNPe0KFDMW7cOLXqXdrnpaPhXXfdhVatWqmdFcuTE7+06TscDrz44ot+2x599FHccsstah+CM844A3a7HatWrVL7Ldxxxx3V5qF9+/ZqzYMMn5R+DZGRkept1KhRav5kSKUED1JrYTD825RQUWKUUQ0OxI133ounH7oX+ogoDDt1NJx2O/Zt2wg4SnDnnXdW+Xh5fRnG6bV3716sW7cOCQkJ6giOBqM0MQUFBVIXpP4lIgpnVqtV2bJli/o3FO3bt0+ZMmWKkpycrBgMBqVNmzbKzTffrGRnZ1faNy8vTzGZTEpkZKRSVFRUafunn36qnHDCCYrRaFTi4+OVU045Rfnuu+/UbXv37lXPC2vXrq30uBtuuEFJTExUtz/88MNqWlpamnL66acrUVFRSpcuXZTZs2crsbGxyvvvv1/p+Twej7IjvVBZn5qn3ma+8pbSrVcfxWA0KjGxccqJJw9V3vzwM3W/qixcuFB9roo3KZfaHvPanP808g+akMLCQjV6lLGrMTExgc4OEVGDsdls6pWmXHXLuHoKDLvTjd1ZJXB5ytZbqKoTY/vESF9TSUMc89qc/4KzsYOIiChMmAw6dGluQaLFhAiDDmZD5Q6IRTYnbM7qg4fGxj4HREREDcyg1/otyOT2eLD5UKHfPrLEc4TRf9KnQGHNARERUSPTabXo3NxSadbKAmvd13SoTwwOiIiIAsBcRfOCBAjBgMEBERFRAFgdledQiDIGR2s/gwMiojDXxAalhYyCKpoQkmNMQXGsGRwQEYUp78Q8Vc3eR4FnNlQ+BR/vUEbvsa5uUqaaCo76CyIiqncyZ39cXBwyMzPV+zK73/GefKj+RGgVKC7/ZbMP5xQiyqSDUa+rdY2BBAZyrOWYH+96DQwOiIjCmHe5YW+AQMGlqNgOa7n5DbxHyazXIi7KAH0t116QwKC2S0xXhcEBEVEYk5qClJQUdSGiqlYOpMCKK3Hg8ndXwOas3Dnx1G7N8OCEXjV+LmlKqK8VHhkcEBE1AXLSCMalgZu6FLMZr1x+El5dsAsr9+Uiu7ismWHDYWvApr1mh0QiIqIA6tUyFrMuPxEvXnyCX7o2gN1DGBwQEREFgRiz/wiD9QcLsGJPTtMODp566im1bey2226rdp+3334bI0aMQHx8vHobM2YM/vnnn0bNJxERUUPo2zq2Uto9325Akw0OVq5ciTfffBN9+/Y96n6LFi3CpEmTsHDhQvz9999o06YNTj/9dKSlpTVaXomIiOrbrswiXDDrr0rp+3JKsSOjCI0t4B0Si4uLcdlll6m1Ak888cRR9/3000/97r/zzjv49ttvMX/+fEyePLmBc0pERFR/cksc+GdvLj5asgt/7S+odj+Hy9P0goNp06Zh/PjxahPBsYKDimTCBxmak5CQ0GD5IyIiOl7u4hJY165V/6/r2BGzNhfhlQW7jvm4Xi1j0DMlBk0qOPjiiy+wZs0atVmhLu655x60bNlSDSyqY7fb1ZtXYaH/+tlEREQNRfF4YF2zBjnvvOtLm2tohVei+h/1ccM7J6nzHFxyUltoAzBsIWDBQWpqKm699Vb88ccfdRrHKR0YJbiQfghHe/zMmTPx6KOPHmduiYiIas55+DAKfvwR6eu3wAUtirQWtPaUQA8Fn5k7Vdq/k7sQ59v34RzHAfV+m2tnIZA0SoCW6/rhhx9w3nnn+U3K4Xa71RELWq1WvdqvbsKO5557Tm2CmDdvHgYOHHjU16mq5kA6MhYUFCAmpvGraoiIKHx5rFbkvPceSjZuwk2Wodik92/27u3KrZT2W/4cWODyS2vzRv0HB3L+i42NrdH5L2A1B6NHj8bGjRv90q666ip0795dbS6oLjB45plnMGPGDMydO/eYgYEwmUzqjYiIqKEVzp6N4o2bcVrchCq3VwwMRjnSKgUGrWe9jkALWHAQHR2N3r17+6VFRUUhMTHRly4jEFq1aqU2DYinn34aDz30ED777DO0b98e6enparrFYlFvREREgaK4XChZ9hf+MLSq0f4mxY3p1k2V0oNh5cygmOegOgcOHMDhw4d992fNmgWHw4ELL7xQXUjEe5NmBiIiokByZWXBU1qKJ6P8p0Ee6MzCIGdWpf0fLVmNaMV/MayoEcMRDAI+lLE86Vx4tPv79u1r5BwRERHVkEYDRxXX3C+WrIChTRskXj0Oywp12JxWgJORh1YLFbgqxAwJl12GYBBUwQEREVGoMrRogWKN/2n1DEeqGhi0eOB+9f6pKbIUc/N/N446Ca7sbNh37YK5dx/oLFEIFgwOiIiCnDqoTFGg0QZ1S3DYcmZmIv2RRwGPB3EXXYToUadVeYwKf/kFuRr/DvD9XLkwtmlT7XPrk5LUW7BhcEBEFIQK5/6Ogu+/90vTGPRQnP492y2nnoroMaOhi4+HpppRXlQ37qIiHLrrbrgBfG3qgBKNAVd89Q3yv/oKKTOfhD4+3revddUqZP86B7fFjPZ7jliPA/qUFiF3CBgcEBEFEbkCLfjuOxyY9ydeiuyPaMWF1fpEWDV6RCkumE0u7NNFo6u7AHkaE25euhknL1qsTq6jjY5Wq7Ytp45ExIABQdHrPZSPw6G77sYzEX3ws6mdL/0Dc1fcVroJF9z3bzOB0MXGwFVQiGujT0GB1gStosBzpOxPdGXD2KpmoxeCScAmQQqU2kwCQUTUmBSHAzkffIjt63fg7shBSNOVtUGXP+FUZFZcsCguJHps6O4uwKX2Xeh8Yi8kXHUVmyJqWVPg2H8AztQDKPjxJzUou80ypNr9L7Htxm/G1ujkLkIbTzF+NLX32z7AmY1ZLTLR/LbboDEYEErnPwYHREQBpjidKFm+HIVz5mBtvoL7ogahUGus8/NJVfZrxcvQvX83JEyeDC0ngqu2j0DpqtVwZWSozTLuokLkuXXYoYvFVl0c3o3oVudjEKG48FPcTnS6bRq0EREIBgwO6qlwiIjqozZAY6z+RG/duBF5n3+B7flO/GBqh1+MbeHWVO54eKF9L5zQVLo6rU6Cx4aHStfipGgPLKNOQ+SJJ0LfhFawlZO/p7gYuujoKrfnfvQxdixfh5cjeiFTG4Eu7gLkaM1YrUuqtoamNj4qXIQRr8yERh88rfcMDuqpcIiI6sq+Zw8yn3m28ga9DnBJF7d/WaHDaxE98LOxXaWT0nj7AUy3blT7E5SXrTFBDw8KNEb1hJaqjUKpRo8lhhbYWG56Xo2iYIwzDeMcaWrbtzyPqXMnGNr924ZePH8BdAkJcOfmIqJ/f0T06a0GMqbOnaGLiwvJg180bx4K58yFYrfD43RCHxeH6HGnI/q0shEG9r17sf/p5zEh9nQ4NDXrxHmRbQ+usW3HWbHjqgzeyuvjysUnI+MQe/bZCCYMDuqpcIiI6sKxbx/Sn3oa/4voia9NHX3pJzkzMdKZjkPaSPV0v9zQHCUaPTK0kZWe42rrdlytS0PSDdfD3LWrX02EbetW9STuzs+Hu6AQit0GZ3oGCteuw2OR/bHI2LLKfHVz5eMEVw6SPTbEKXYc1kYiR2tCkcaoLgjU1lOiVod3cxfAYDIi4copMPfqpfZbsG3ZAuv6DbCuXQNPqRVRQ4eoeZDx+eaePYKib0PqDVORoTHj9Yie2KSPV4cVnuTKwgOl6xADF1KeeBwFP/+M0uUrsESfjPstg475nH1dObjBug193HlqWdg2b1bTl+qT8aW5Iwo1BuzRlZ1LhjvT8VjJarR/4TloIysf10BicFBPhUNEVJf59Q/edDNeN/fA5+ZOMChuOI9cncpc+vajXKnKlf5ZjlSMd6TihHgtmk2bBkNKSo1fW5ooct5/H1+7kvF6RA/f69ZWO7WDXQmmWbegtadUTTusjVDb4WXExFJDsrr8cH9XDrq4C+Gt74gcNFA9gUYNHozG5MzIUOchKIJevbKvyqtFf6GvOxdzDK2xzJCMxcaUKgMB6Vx4uuMg2mpsSGrdAqYunWHs0EGtWfGO/pAmi4NTb/Q9TuqBFGh8NTwVhzkGCwYH9VQ4RES1lfnyy/hnRyZuih5a68e+UbQUfWO1iB49ClEjRkB7lL4K1ZEZ93LeeRc7DmTjR1M7LDSkqE0PRyNBiXKUdvYerjxs1R/9ZJfiLsUExwG1GaOlx9ogSw5XpWj+fGR9/S0WG1LwZkR3pFdRC1MT3xXMQ3OjgriLJsLYtq0alNW0v4As0yydGo3ta9YfJFAYHNRT4RAR1aVq+4KY0Wont9p4t+hPdHUXovXrrx13Fb3UXpSuXImS5StQumMHNugSsEj6I+gS4NBo1b4KhRqj2sfBojhhVNzIPUYAURuzC+agxYghSLj0UjQUuXov+u03HPz5N9wddVKlpZBrKlJx4vbSTTjDmaYulRzOc0MU1uL8FzzdKImIQpyclEWWxv9E+3nhArV6vhQ6bNbHY48uGr8Z22C3LgZxHrva0U0NDP73Sr203csVb9SQIerNXVCAxNVrMHTnTth3rIGnuMRXFW6HDia4IY0PdmjVTo0fmbvgG1OH43r9t8zdceefSxB3wQUNMoxSVj7M//Y77PlrNe62DPVr8xcd3IV4sXgFPNDg/NgxVT6HdPa82L4HHaN1MLRJRMKVj4Z1YFBbnOeAiKieuPLycOC+BzA29ky/Hu3PFy/HKd2S1ZkLi5csgW3jJnWthPIz7CVNndpo1dLSqdFdUqL26NeazfDY7YDbDVdmJrLfeBP5GgPOrtB239xjxWmOQ2jlKUVHdxFcGg0+NHXBBn1Clb33z7fvw+3WTer/66uJQfIpoxGK58/HKkckZkSe4FdDI50pr7LtwAX2fTCZDOqIi71ZxXjT3N2vj8FdpRtwjuMAkqbdqI7M0JjNTSIwKOQkSPVTOEREta052HHTbRgXd2albUvyf2m0dvjjlffFFyhetBh5GiPyNUa09JTCBI+6zdSli9rp0FNSrI5esGVm4bS48dU+lwQJMudCx+RoDEceTBoFexCJ3YhEL5MTrc0KNDo9NHrdv238Or06aZCpU0eYunXzTSAkgVfWK69gTaYdb0d0xzp9YqXhgzNLViJWccIy8hTE/uc/0JhM6kRHhbN/U/fxLqdshActn32m2jkQwhWDg3oqHCKi2rBt347/vf4TXovoGdLBgVfJin+gi4uFNsoCY+tW1XbAXLMjHTdEDz/m88mVvYx2yC7Xv0FmcxzrTINB8cAIt7q4UQn06O7Ox3+cB2BM+jcIcGVl43tjO7wY0btS58lTHIfxkHUdWlx6MSwjRlT52h6HA/atW6GNioKxU6cmUVNQEYODo2BwQEQNwVNSgrQ7p2NE3IRK2+4pXY/zkoEWD5Qt1hNOUz9n/e9V2HfsQJFGhhKeUW/PLUM/e7ny0M5TjPX6hEp9C2I8Dlxq341LPKlIvu4aRPTtW2+vHY7YIZGIqJFJYPCXvnmVY+fPNuej+Z2PheUxkQWFmt9xu2+kxm/5c3BmXP0ECDInxBpDEtYgyS9dp3gwxbYTF9n3IrFnV8RdcDcMIbjyYTDjaAUiouPkXdz2HstJfulDnRl4umQlmt97j9rxL9xJs4kMoVzy7nv4wtQRCwwtEaU4McyVqXZyXGRIwX5dtNq8IHq68tTOjE7ITQOXRqvOHmnTVH9qkmGXj5aswWnJesRfdjtMHctmoKT6w+CAiKgeetDLNLoVPVKyRu0RH+yT49SnyEGDYOrRE5dMn45JmkPQWqL+7XBoNOJGY6q6j+J0A24XFLdLHSWhOOX/R9JsLjidLqzWJ2GbLhb7dRakai04qItCnMeBe0vX46QO8Ui68cagm544nDA4ICKq43DAtDvvhNvpggtazIwaUGmfCLgR0adPkytfnSWqzp0vpRbGmXYISdu3YVTaIbgyM+BM3wVPQTEgkzadMkKdP+FoK13S8WNwQERUhyGL0kt/nScGN8VVPU3yzdbN0B3paU81J6MIZGRExdERHptNHeoYTEsghzOWMhFRHRZW2q6LxZ2WqgMDmaHvDMdBJF79b0c9On5Noc9GMAn8GptERCFEAoMV+ma4NnqEr2NdeZNsu/Fh0Z9o3qMzjG1aBySPRMeLNQdERDUks/TJuITplpPV+/nasnUDZHnjYc4MtPSUYIesmbB1L2w334LEa65WO+kRhRIGB0RENZT10stYW2HaXi+ZFTFScWFyxEh1SJ44z74Pt7z7PlJiYmHu1pXlTCGDzQpERDUUNWwokjy2arc/G9nXFxiI703t8a65K7Jff51lTCGFwQERUQ1J80ArTwmaeaw1LrNPzF3U1Q9dubksZwoZDA6IiGpIHx+P2FNH4o2iZdCWW3L5WH4wtsXh+x9A6erVLGsKCexzQERUC3EXX4xOej0Wz/tV7Zwoa/vJ7Igr9UlI00ZhtPMQLokZ5feY5yP74k9DCl54+x11cSBZj4AomDE4ICKq5SQ9cRdeiNjzz4d17VoYWrdGs9xctNq8Ga6cXFjXluJi2258ae7k97iVhmbYrotB5CefIvGqK1nmFNQYHBAR1YFGq0XkiSeq/zckJ8Pco4f6f9v2HbjhxZdQrDHgV1Nbv8e8FNEbs1b8xeCAgh77HBAR1SMZspj8f9fhXttGLMn/xW/bJn2C3yqORMGKwQERUT0zdmgvEQD+0jevtM0OLVxZWSxzCmpsViAiqmeH77sfH5k64+2I7pW2lWj0UKw1HwpJFAisOSAiqkcFv/47iqGqwGCIMwMJigOGlBSWOQU11hwQEdWT4j//ROHPv+DM2HGVtl1l26HeEqZMhsZoZJlTUGNwQERUD9yFhcj77HM8HNkfJRr/eQxkaOPVth1o8eijMCRX7odAFGzYrEBEVA8O3X0PtujisMDYqtK2m2xbkTLzSb/AQEYslK5aBUdqKsufgg5rDoiI6slsY5tKae8XLlb/Zr3yClyH0/22lUIHIzzQQ4GxQwdEjxkNY9u20DdrxmNCAcXggIioHhjbtUXL9JJK6Z09RVhgSMHighbIsHTCZn089IrHb/VG8f7+xej49jvqdMxyi7vwAkSPGcNjQwHB4ICIqB449h/ApsiBldJHxE2olFYxMBBXxYz0u7/km2+htUQjavDJPD7U6NjngIioHkSefDJut26qt7K82jICuR98AHdx5doIoobG4ICIqB7IYkrNFBu+KZhXL+W5Ux+rrvR4aPr0enk+otpgswIRUT1pPet14MZp+KBwMWZEnqCe4Mv7vuAPmBU3LHD50jI1ZsyK6IF5VYxyuMMyGIvzf4G7qAi66GgeJ2o0GqWJrQBSWFiI2NhYFBQUICYmJtDZIaIwIz+p+d98g+L5C9T7Nmhhhse3PfmB+9Vlnr2K5s1DwbffVdtH4d2iP9GvTwck3XBDo+Sfwldtzn+sOSAiqkcajQbxEyeqN8XhgG37duiTkqqdMjlm7Fj1JlJvmFppe4YmAtZ163mMqFGxzwERUQORaZIj+vQ5rrUUvjO1r9c8EdUEgwMiogBzZWertQY5GlOlbckeruBIjY/NCkREjchjs8FjtcKxdy+sGzagdPkKNf1Nczd8Yu5Saf9TnOkwde/GY0SNisEBEVEjsG3fgawXX1T/b4cWJRo9Dmsj8ae5Oz4zd67yMS3dJRjqykTSdXfzGFGjYnBARNTAiubPR/7X3+CpiL741dT2mPuPcKRjunUDEhQHEq+5GtqoKB4jalQMDoiIGpDMUZD39Tc4pYpplKtaY0E8UroGCSOHI+6SS9TRD0SNjcEBEVED8djtSH/4EfxorLq2oHxgEOux4wzHQXV556hTRiB+0iQeFwoYBgdERA0k6+VXsNVuwPPRfSttG+TMQnt3ES5w7EMrT6kvPeXJGdAnJPCYUEAxOCAiagC5H36Ioj37cG3cWX7p/Vw5eLX4b/X/xnbtoDG2RLObb1bnRCAKFgwOiIjqmXXTZhxavhoTKgQG4sXi5Wh26y0w9+jBcqegxUmQiIjqmXX1KnxnrDyz4WW2XTBZohgYUNBjcEBEVM8UlxvuKkYZXGfbhqSpXECJgh+DAyKiehbRtw/GO1Kr/tG1WFjeFPQYHBAR1bOIgQORUsWaCFbo4Uw7xPKmoMfggIionnknLmpeIUDYro9F7vvvQVEUljkFNQYHREQNwNS5E8Y60vzSZkSeAJfThYNTb/x3FcZ334XidLL8KegwOCAiagAx48djsm0n4j12X1qWNgKnxk3AiCO3dWt24ODNtyDviy9Ym0BBhcEBEVEDkHkM4rt0xKziZYhQXFXuc030Kbg4+jTsW7wc6Y89xuNAQYPBARFRA2l2x+3o2KkVHixZW+0+h3RROC92LLLSc5H/zTc8FhQUGBwQETVgx0RZcvkUbR6mWbfA4nFUu+85saejaN58HgsKCgwOiIgakC4uDs3vvgtT2mrxW+HvWJL/Cxbm/4p7StdXub8zI4PHgwJOozSxMTWFhYWIjY1FQUEBYmJiAp0dImqCXHl5OHzf/WqnxPKmWrdgckIpWjzwADR6Ln1DgTv/seaAiKiR6ePjYWjVCs8Vr/BLnxXREwcyCmHftYvHhAKKwQERUQA0u+1WnOzKqmKLAk9xcQByRFSGwQERUQDooqOrTJdplw1t2jR6fojKY3BARBREZOJlfWJioLNBTRyDAyKiAOriKvC7b9Ub4crJCVh+iASDAyKiACrV+I9KUFxuwOMJWH6IBIMDIqIAKJwzF3ZokaaL8kuPgJvNChRwHEhLRNSIZGoZWZVRjKkwz0GCx6b2OdAYjTwmFFAMDoiIGpjicqmrL+LInHN7tNGYEjOy0n6fFC1CwpVX8nhQwDE4ICJqQLYdO5D1wovYoovD9dHDq93vFMdhRCsuRJ58Eo8HBRyDAyKiBuKxWtXA4GrLCOzUx1a73wX2vbjNuhnxl12mLtZEFGgMDoiIGkja7Xdgmb75UQODq63bcZV9J5JunIqIvn15LCgoMDggImpA91qqbyb4qnC+OiNiy6dmqqs3EgULBgdERI1sRslKnOL8d2nmNm/MYvlT0AmaeQ6eeuopta3ttttuO+p+X3/9Nbp37w6z2Yw+ffpg9uzZjZZHIqLaOtVxqFLaA1GDcGX0Ker/U2+YCk9JCQuWgkpQBAcrV67Em2++ib7HaG/766+/MGnSJFxzzTVYu3Yt/vOf/6i3TZs2NVpeiYhqKvaC83GXdWOV23brYjAibgK+M7ZD2p3T4TiYxoKloBHw4KC4uBiXXXYZ3n77bcTHxx9135dffhlnnHEG7rrrLvTo0QOPP/44BgwYgFdffbXR8ktEVFMxY8ciRnHio8JFaOEprXKfFyP74B1zV2Q88QQ8djsLl4JCwIODadOmYfz48RgzZswx9/37778r7Tdu3Dg1nYgoGLWe9Tq6d2uNrwsXYGH+rxjgzK60z4fmrvjV2AZptx69WZWoSXRI/OKLL7BmzRq1WaEm0tPTkZyc7Jcm9yW9Ona7Xb15FRYWHkeOiYhqR/pSNb/1VvX/xcuW4eWPP8FSfTLuswzy2++pyH4Y70iFMyMThuTmLGYKqIDVHKSmpuLWW2/Fp59+qnYubCgzZ85EbGys79amTZsGey0ioqOxDBuGVi+9iOGuDCzJ/6XS9inRpyD94Ydh37OXBUlNMzhYvXo1MjMz1T4Der1evS1evBivvPKK+n+3213pMS1atEBGxr/Df7zkvqRX57777kNBQYHvJkEJEVGgaM1m3/DF20r9O1Pv0cXgC1MHHHrmWXUUw6EHHoDz0CF1bQaixqRRZImwACgqKsL+/fv90q666ip1mOI999yD3r17V3rMxRdfjNLSUvz888++tKFDh6qjHN54440ava40K0gNggQKMTEx9fBOiIhqr+DnX7B39jz8J3ZstfvMKlqKru5CGOFB4vX/h8j+/VnUVGe1Of8FrM9BdHR0pQAgKioKiYmJvvTJkyejVatWatOAkGaIkSNH4vnnn1c7MUqfhVWrVuGtt94KyHsgIqqr6LFjkPjrr+jpysMWfdUjtaYeWahplCMNj7z1Nlo+OQP6Y4zqIgqL0QpHc+DAARw+fNivluCzzz5Tg4F+/frhm2++wQ8//FBlLQMRUbA3LyRedy3eKF6GadYtR913gbEVdmhjYN++o9HyR01bwJoVAoXNCkQUTFx5eTh83/3q/63QYUbkCVhsTKl6ymVXJtrMej0AuaRwEBLNCkREBLWZwNtBsWT5CjzxwQdAKbBSn4Q7LIN9RZSpiYCpU0cWGTUKBgdEREEiavDJ6k1qEwYdqU3wWmFohgt3rYTidEJjMAQsj9Q0MDggIgoypcuXY4vOfwnn5YZk/KNPAm6+xTfzokywRNTkOiQSETVFzvQMrNA3q5R+p2WwuljTJl0cDk69EU2syxg1IgYHRERBpnTFCmRoI6rdLkMcU7VRsK5Z06j5oqaDwQERUZBpftd03GvdcNR95hhbw7Z121H3kZoFx4EDKPzjD5Ss+Aee0qpXhiSqiH0OiIiCjKlTJ0SNGI4lS36BCxrooODuqEFqvwOvHI0J1g3rAVxW6fHuoiJkv/Y6HPv2IVdjxBp9EpI9VvRv/pu6CJQuzr8/A1FFDA6IiIJQwmWXqTdXTg6KlyzBs3PmYmLMKKRrI9Xt+3TR8BQWqbUB2sh/04SMdMh87jnMLzTiwbgJfs85I3slzl6+AjFnjGv090Ohhc0KRERBTJ+YiLj//Af6Zklo6y72pW/Wx+NPbRIyX3jBb/+CH3/Er4UReDBqYKXnWqdPhKPCmjZEVWFwQEQUAsy9euF85wG/tAdiBqP47+XqCo5F8+cj7/PPUbp8BV6P6FnlczigheJwNFKOKZQxOCAiCgExE87GMEc6OrkL/dLH9JmK26NOxoFvfsSiZVuQpzEiT2uq8jlGODOgS+DCTXRs7HNARBQCdJYoGDt1xLS/5uKObhP9tq0yNMP42KP3IxjrOIghETbEX3xxA+eUwgFrDoiIQkTz22/HgEgXpqQuq/Vjz3AcROw5Z0Oj5zUhHRuDAyKiECEn9tavv4arTRl4pGR1rR57gisX5u7dGyxvFF4YHBARhRB9bCzavvM2RjsP49eCuUj02Crtc4ltt999i8cBIzzQJSU1Yk4plGmUJjY5d23WsyYiCmYFv/yKwl9+qZRepDHgrAp9ED4qXISOJhdav/hiI+aQQvX8x8YnIqIQFTthvHorz2O14uDtd6CrKx879GUzIU6OORXz8mfDmZkJQ/PmAcgthRI2KxARhRGN0QhZyLl8YOBVqtHDU1AQkHxRaGFwQEQURg4/+BA26KqeyyBeccDYvn2j54lCD4MDIqIw4s7NxXTLyZXSvy/4A6YunaExGAKSLwotDA6IiMKMVePfnWyYMx1Jih3N77wzYHmi0MLggIgozC0ztIAdWjjT0wOdFQoRDA6IiMKIsV07vFv0Z6X0Pw0tkPPee777itMJj91+zOdrYqPd6QgOZSQiCiPN7rgdXW69rVL6e+ZuGHtgIXLe/wC2jRvhKS2t/Njbb4O5Wzf1/46Dacj7+GPfEs+GNm2QfP990GhkLASFOwYHRERhRGsywdSxI97avwT/Fz3Cl35QF4U92mjYV22DWdFictwEv8eNcqThvhdfgRkeRA4aiNJVq/GpsSPeOLLfx2mL4Jx6o/r/yIEnIuGqq6DR6Rr53VFj4QyJRERhRnE4cPCWWzGiQgBQU68XLYMGCqZGD6+0LcFjwzMlK9HNXYA2b8yqh9xSMM6QyD4HRERhOBHS8bgxeliVgYHI1ZpxbfQIuAGk3jAVmc+/AI+t8voOFNoYHBARhSO9Di8WL2+wp58SPRLvm7pg6d48pN12O3I/+rjBXosaH5sViIjCkIwyOHikj8B2XQzeNHdHtOJCG08xkjw2ZGvNONt+ACa48bq5J34ztan2uS617cJn5s5Hfb0l+b/A3LMnEiZfAV1c5ambKbSaFRgcEBGFef+DovnzUfDjT740ffPmMKS0QET/AVCcDuR9+pmavkqfhNstg/0e/3bREnR3/7sew7H6MDxWshqnOg8jomcPJN18M0c2BBkGB/VUOERETYW7uARZL7wA56FDlbZJx0PpX3C9ZRi26Ktet6G87wrmoUVCJFrOmNFAuaW6YHBQT4VDRNTUeCdGkiGR5ZUsX46sDz7ErZYh2KSLh1tz9C5r8/Nnw2yJRMsnZxx3B0mqHwwO6qlwiIioTMnffyP/u+/hKSpS76/XJeCm6KHVFtFrRctwQpQLrZ55hsUYYuc/ToJEREQ1EjVkiHqTzo6KzQbLjz9hyaJfUAw9JsaMQrHWv4ZgWvQwLMz/Fc6MDBiSk1nKIYRDGYmIqFZkCmVtRATiL7lY7Y/QdvIk/Fb4uzqqoaIvTR2R/vAjVU7XTMGLwQERER2XqKFD0eLRRzHVtq3StjcieuBrYwek3cHlokMJgwMiIjpuhuTm0Ccn4wxHaqVtr0T2Qq7GCNvWrSzpEMHggIiI6kXsuefi1tLNVW7L0EbAU1zMkg4RDA6IiKheaExGRMGFW6oIEDq4i6Bv0YIlHSI4WoGIiI6b4nQi+3+v4hrLCOzS+Q+Ts3gc6lLQ0uxAoYHBARERHTfrpk04qI3ETn1spW2DXNnQmM3QcjKkkMHggIiIjovi8SDnzbewwFR5caaJ9j2YZt2CpNtvZymHEAYHRERUp7UYiubORema1XDn5KqzJb4d0d1vn+us2zDZvgvJ994DY/v2LOUQwuCAiIhqRWZIzHr5ZSw9bMO3pk6Ij2iN2aa2lfabZN+NFg89CEPLlizhEMPggIiIfMs7Q6OBxmCoFAw4Dx5ExownfWml0GF63JnVltxPBb8jqlMHBgYhisEBEVET5i4owKH7HwDcbr90fUoLNLvlFmQ+/zzc2TmQrb8bWqsTGnVyF2K9PrHa5xxvP4B4xYHm06c3wjughsDggIioiSr8/XcUfPc9fjS2xXPRff22PZP1Dwbfdz/2aS2YHDfBb9vRAgNxrW074q+4XF2DgUITgwMioibIcTBNDQxGVDjxe91tOanWz5ngseH9oj+RoDjU9RYodDE4ICJqYjx2OzKeeAJ3RtU+AKjIojjxZtFSNPPYEAG3GhQkTL6iXvJJgcPggIioicmYORNL9cn4x9C81o/t48rF4yWrUarRI09jRC93HqJ69ULc+eepMyBq9DythAMeRSKiJkBGHNg2bED2rDfUzoX3VdGc8HrRMvR05+E7Ywe146HXMGc6ppduRJJiV+/rEhOQcMUVcBcWwty9O3Qx/tMlU+hjcEBEFMYUlwsZTz4J56HDyNSYsczYDi9E9qm03/+K/kIfdx6SH7gfl332OSbu/cVve8JVVyHypEHsZNhEMDggIgpDzvR0pD/yqPr/Dbp4TKum46F4rWgZ+rrz0Pq1V6HR6ZB8z92+2gYoCjRaLuDb1DA4ICIKM6Vr1iLrrbdwVfQp2FNhhcSKEj02tcag5XPPqYFBeepQRA5HbJIYHBARhQnH/v3IeecduLKyMfIoNQXlvVC8AtGjR0FniWrw/FHoYHBARBQGPA4HMmY+hY9MnfF23OCj7vtQyRqMdR5S/29s1w5xF17YSLmkUMHggIgoDKTddju26WIrrYxY3sMlazDmSFAgzQjaqEh2MKQqMTggIgpxpStXwuVRcF3ciCq3L8z/FXoo0MXHI/n+Z6CLjm70PFJoYXBARBTi8n/8EY9EDqiU3s+Vg/8V/43Ifn2RNHVqQPJGoYnBARFRCPPYbHBl52Bx3BC/9BeLl2OgKxtJN05FRF//RZWIjoXBARFRCEt/9DHMNrbxS0txl6iBQauXX4LWZApY3ih0cWYLIqIQ5S4qgjsvD09F9vNLn2TfA43ZzMCA6ow1B0REIci6cROyXnsNf+srL540znEQSbffEpB8UXhgcEBEFGJc2dnIfu01XBw9Cod1kZW2m+CGIaVFQPJG4YHNCkREIebwQw/jPXPXKgODkY7DkEmQuVIiHQ/WHBARhRqPB++bu1ZKnmbdjIvte5E07caAZIvCB2sOiIhC0FTrlkppORozNAAi+lRekpmoNhgcEBGFmBaPPIxL7XsqpX9h7qT+9djtAcgVhRMGB0REIcbQ4t/OhnPy51TatksbjdyPPgpAriicMDggIgpBbd6YhSi4cL11q1/6VTEjYV29BtZ16wKWNwp9DA6IiEJUy6dm4jL77krpI+ImIPuNN+EuKAhIvij0MTggIgpRurg4tQNid1d+pW0fmLrg0D33MkCgOmFwQEQUwuKvuBwvlKyolP5uRDd1LgQJEIhqi8EBEVEIswwbhmjFid+q6JxY1VwIRDXB4ICIKMSlzHhC7ZxIVF8YHBARhbjDD/wXt0edXCl9vP2A+ldRlADkikIZgwMiojCw2tCsUtqvprY4qI3EwamcTplqh8EBEVEY6FrFiAUxKWaU+pe1B1QbDA6IiEJc8n334t3ipRjjSKtye77GANfhw42eLwpdDA6IiEKcsV07aCMjcZt1U5XbndDBsX9/o+eLQheDAyKiECdNBp7SUkyIHVfl9v06C1yZmY2eLwpdDA6IiEKY4nCoHQ6zNaZq9+npyoO5T99GzReFNgYHREQh7NAD/8WfhmScFzu2yu1PF/+DSI0Hpo4dGj1vFLoCGhzMmjULffv2RUxMjHobMmQIfvvtt6M+5qWXXkK3bt0QERGBNm3a4Pbbb4fNZmu0PBMRBVVzQlERHogaVGnbvPzZWJL/C4a6MtH69dcCkj8KXfpAvnjr1q3x1FNPoUuXLuqH/MMPP8S5556LtWvXolevXpX2/+yzz3Dvvffivffew9ChQ7Fjxw5ceeWV0Gg0eOGFFwLyHoiIAkWaExYZWlRKv7t0PUzwqMs6E4VccHD22Wf73Z8xY4Zam7B8+fIqg4O//voLw4YNw6WXXqreb9++PSZNmoQVKyovOkJE1BQ8GDXQ7360x4GzHalo9SIvmCgM+hy43W588cUXKCkpUZsXqiK1BatXr8Y///yj3t+zZw9mz56Ns846q5FzS0QUnN4sXoaooUOgjYgIdFYohAW05kBs3LhRDQak34DFYsH333+Pnj17Vrmv1BhkZ2dj+PDhajOEy+XCDTfcgPvvv7/a57fb7erNq7CwsEHeBxFRY49SqEpzjxUx48fzYFBo1xxI58J169apTQNTp07FlClTsGXLlir3XbRoEZ588km8/vrrWLNmDb777jv8+uuvePzxx6t9/pkzZyI2NtZ3k06MREShzpmZhSKNoVK69DXQJSQEJE8UPjRKkE24PWbMGHTq1AlvvvlmpW0jRozA4MGD8eyzz/rSPvnkE/zf//0fiouLodVqa1RzIAFCQUGBOkKCiCgU2bZtw8GX/ocxcWXNqt1c+XineCk7IlKV5PwnF8k1Of8FvFmhIo/H43cyL6+0tLRSAKDT6dS/1cU4JpNJvRERhZOS5cux0JDil7ZdHxew/FB4CWhwcN999+HMM89E27ZtUVRUpA5VlKaDuXPnqtsnT56MVq1aqU0D3tENMmSxf//+OPnkk7Fr1y48+OCDaro3SCAiagq0JhP6uvMCnQ0KUwENDjIzM9UA4PDhw2pVh0yIJIHB2LH/zvR14MABv5qC//73v+qcBvI3LS0NzZo1UwMDGQJJRNSUFP+5BN+buqv/1ykeuDVatHMXqfdt27dD37w5NDqduiCTRh90lcQU5IKuz0EwtbkQEQWr1BumYkTcBL+0bwrmIVmxwQUNdFDgOdLrXAOoIxhiJoxXL7CoaSoM5T4HRERUN4uNKfhfROUJ5AY5MzH9twVot2EDWjxQ/dBvoqAZykhERHUT5/HvvF1VYCBWGprj4pjRcKamwp2fz+KmY2JwQEQUgqLHjsFd1o21esxvhtbInsX1FujYGBwQEYWg6NGjcaqpGK8U/VXjx+zWRUNxOhs0XxQeGBwQEYUgXVwcUmY8gf7uXJzqOFSjx5zgyoUuKanB80ahj8EBEVEIz3UgOh4Zwngsg12ZiDvvvAbOFYUDBgdERCHKXVQEGYv+nan9UfdLcZfii8IFiD6hHwwp/rMqElWFQxmJiEKMdcMGZL/+b8fCfVoL8rWVp4hv7S5BZ3cBursLcI7jAFqOGYnY888PQG4pFDE4ICIKETJn3cGpN8IGLWZF9K6yxuA66zac5UhFkmKHoU0bGNu3Q+Sgc2Du2jUgeabQxOCAiCgEuPLycPi++5GjMeE/sf9OMV+VIa5MtDmhJxKvuZrTJlOdsc8BEVEIkMBgrqFVtYGBxePAk8Ur0c3sRuJVVzIwoOPCmgMioiDmsdmQ9fIr6noJT0T1r3KfFp5SvFb0F9r164b4y6+Axmhs9HxSeGFwQEQUxH0Mst98EytSC3FL3PhK23u7cvG/4r+hh4L4SZfAMnJkQPJJ4YfBARFRkMr94EPkbt2F+2NGVbl9VvFfSJp6A8w9erC2gOoVgwMioiCU//0PyF2xEufFng6rpvJP9btFf8Lctw8i+vULSP4ovDE4ICIKMq6sLOTO/R1jq2hKEEvyf0HEgAFIvPqqRs8bNQ0MDoiIgszhBx/CD8YOVW5r6y5W/yb933WNnCtqSjiUkYgoiBQvWwYPgFcie1W5/b2iPxF/2WWNni9qWlhzQEQUJIoXL8aeL77D/Zahfult3MV4u2gpouBC9NgxsIwYHrA8UtPA4ICIKAgoHg8KfvoZj0f2xyZ9gt+20x1pamDQetbr0Gg0AcsjNR1sViAiCgK2zZvhKSnBHl10pW0jnYeRcPVVDAyo0TA4ICIKMOfhw8h87XVcHj0SOVqz37axjjR08BQjcsCAgOWPmh4GB0REAZb+6GN43dwD+6uoNejkLkREv75cK4EaFYMDIqIAsu3YAQXAl+ZOVW6f4DgAy+jRjZ4vatrYIZGIKADcxcXIfPpp2LJy8HxE30rb7yjdiHMc+xHZrRvMXbvyGFGjYnBARNTICn78EQW/zcE+rQW3xoxBntbkt/2Hgj+QqNjR/K7pMHWqukaBqCExOCAiakR5X3yJjEVLcUbchCq33126Xg0MOGyRAonBARFRI7Ft33EkMDijyu2vFP+N/p48pDz+GIctUkAxOCAiaiT533yDj8ydq9z235K16O/KQev/vQKNwcBjQgHF4ICIqBHYtm6FMzUVf0WPrLTtl4K5iFWcaP3aq9DodDweFHrBQX5+Pr7//nssWbIE+/fvR2lpKZo1a4b+/ftj3LhxGDrUf05wIqKmzL5zJzKffwGl0OEnU0fsqzCXwZeF85GYFKc2JRCF3DwHhw4dwrXXXouUlBQ88cQTsFqtOOGEEzB69Gi0bt0aCxcuxNixY9GzZ098+eWXDZtrIqIQYNu+XQ0MXozohXFxZ+K1iJ6V9mnpsSL5vw8EJH9Ex11zIDUDU6ZMwerVq9UAoCoSMPzwww946aWXkJqaiunTp9f06YmIwoKiKChdvhz5330PV1ER7ow6GasMzarc92rrdugSEqA1+Q9lJAo0jSKf5BrIyclBYmJijZ+4tvs3lsLCQsTGxqKgoAAxMTGBzg4RhZnipcuw89Ov8b65K34ytat2v2iPA58XLUSnm65HRK9ejZpHapoKa3H+q3HNQW1P9MEYGBARNbS8Tz7B41GDscaQdNT97rJuRPMuHWCupiaWKCRHK0gfhKVLlyIzMxMej8dv2y233FIfeSMiCikeu11dJ6GqwGC4Mx03W7fAoHgQr9ihh4JmN9/H+QwofIKDDz74ANdffz2MRqNaQ6DRaHzb5P8MDoioKfKUlsKNst/D8qZat6J92+aIPf88GJo3hy4urtHzR9SgwcGDDz6Ihx56CPfddx+0Wi7sSEQkFIcTVk3V8xSkaaPQb9hQLqJEIaFOZ3aZ2+CSSy5hYEBEVE7h7NkwKv7NrF59XbkwtmnD8qLwDQ6uueYafP311/WfGyKiEJX78Sc4/M8anBFbed2Ee0rXI75TWxjbtw9I3ogapVlh5syZmDBhAubMmYM+ffrAUGEe8BdeeKEuT0tEFJLcxSUoXLYMF8WOg0vjf831YMlajNNmI/HqBwOWP6JGCw7mzp2Lbt26qfcrdkgkImpKHLt3IUMbiVKNATrFA/eRAOEi2x6c7kxDylMz2QGRQkqdgoPnn38e7733Hq688sr6zxERUYjRJyUhxuNAc48VmdoIX/p2fSzs0Ko1CxydQGHf58BkMmHYsGH1nxsiohCkb9kSyUNPwivFf6O3K9eXvl6fiJ+M7VD4yy8BzR9RowQHt956K/73v//V5aFERGFHmlPjL78MPcadgqdKViLFXeLb9pW5A/LXbYDj4MGA5pGowZsV/vnnHyxYsAC//PILevXqValD4nfffVeXpyUiClkarRax554Ld34+/m/VdjwaNUBNT9dG4ntTe1w9Zw4Sr7020NkkarjgIC4uDueff35dHkpEFNZiJkzAqFWP4AtXPrbr/50F8XdDK1y6ZZW6YiM7bVPYBgfvv/9+/eeEiCgM6BMTETNsGM74a78vODioi4K72ApPSQl0Fkugs0h0TJz7mIionukSE9HKU+q7b9Xoka8xwp2Tw7Km8AoOzjjjDCxfvvyY+xUVFeHpp5/Ga6+9drx5IyIKOe6iIhR8+x0ytWa/9EPaSLiyswOWL6IGaVaYOHEiLrjgAsTGxuLss8/GwIED0bJlS5jNZuTl5WHLli3qEs6zZ8/G+PHj8eyzz9YqI0REoc6Zloas11/HH4aWeD6ij982IzzQGI0ByxtRgwQHsp7C5Zdfrq6p8OWXX+Ktt95CQUGBuk062PTs2RPjxo3DypUr0aNHj1plgogo1FnXr0fWu+/hPW17fBDV1W/bRPsedI/WwtSpU8DyR1QbGkW6z9aRBAdWqxWJiYmVhjMGq8LCQrX2Q/IeExMT6OwQUYiTn9Ci337D4Z9mY0bkCfjTmOK3/XrrVlyhT0ezm6bB1KFDwPJJVFiL81+dRit4yYvIjYioKVIcDuR8+CF2r92K+6KHYY+u7AfXqLhxf+k6jItzIummu2BITg5oXolq47iCAyKiphoU2HfvRtarr2EzonGPZQQKtGX9CZp5rHiyZBX6dUhC4vXXQxcdHdD8EtUWgwMioho0HThTU2HbshW2bVvh2L0b6S49lhla46WI3lDKrUbb05WHJ0pWo/3QExE/6RJo9PyZpdDDTy0RURVkGmTrps2wbd0C+7btKCi1Y60+Cav0SVhpHo6DusqTGZ3hSMV022YkTzwfltNO5WyI1DSCg5KSEkRFRTVcboiIAlxDYN+xA8ULF6F4/Xps0sZjpUECghOwNSYOnnI1BBUNc6bjAc92NLtlGszduzdqvokCGhz07dsXH374IYYPH17vGSEiChSP1YqS5ctRvHgxsjLy8IuxDX6MPg0Z2shjPraLqwCnOg9jkmMPEq+9moEBNb3gQCZBGjVqlLpk84wZM2DkhB5EFMKchw6haNEilKz4B5tdEfjO1B4LYwbAqdFV+5gUdylOdGVjkCsLA1zZiDfrYO7RHZbTboG5W7dGzT9R0MxzIFMoX3311dBqtfj444/Rv39/hBLOc0BEMmFR0fwFKNyxC/OMLfGdsT12HFkkqSKL4sSJzmwMdGVhoCsbrbV2mDp0VAMCU/ceMLZrC42u+mCCqEnMczB48GCsXbsW//3vfzF06FCMHTsW+gq9cb/77rva55qIqBHkff019i1Yhq9MHfFrzBgUlhuCWN4gZybOt+/HYFcmIlq2gKlHD5i7nw1T1y7Qmkw8VhTW6jRawW63IzMzU+2JK1FIxeCAiChY1z7InL8Y18WchuwKCyN5awnOdKTiP/b9aG/RwnL6cEQNHw59QkJA8ksUKLU+q//xxx9qs0JKSgpWr17NdRSIKGRYN2zACkPzSoFBR3chLrDvw1hHGmI7tUP0qRcjon9/zlFATVatgoPrr79eHa1w//3344EHHoCO7WxEFEJs27djjT7RL+3Vor/QV1MAy8mDYTn1chjbtAlY/ohCMjhYtmwZ/vrrLwwYMKDhckRE1AAUpxOO3Xuw1jzUlzbBfgD93Llo9fxz0HIOF6K6BQdr1qzh8EUiCkn2vXuR5dJiv65snQMZihgzYQIDA6IKtKgFzmtARKHKvmMn1lZoUhjgyoG5W9eA5YkoLIIDIqJQZVf7GyT57rdzFyFJ74GxQ4eA5osoGDE4IKKmscTy3j1+NQdSa2Ds3IkjEoiqwOCAiMKefdcuZLgNSNOVLRzXX5oUurJJgaheggOZbXnv3r1wuVzqfYfDgS+//BIfffQRsrOza/t0REQNTqZKXm0oa1IQ/V3ZMHXj6olExz1aYfv27Rg3bhxSU1PRsWNH/P7775g4cSK2bdumBg2RkZHqUMcuXbrU5mmJiBqU8+BBrNJ38FtJMU5xqusiENFx1hzcc8896NevH9atW4cJEyZg/PjxaN26NfLy8pCbm4shQ4bgscceq81TEhE1KE9JCVwFBVhdrjOirKoouGASUT0EB1Ir8Oijj6JPnz544okn1BqD6dOnw2AwwGQy4d5778Wff/5Zm6ckImrwWRH3aqORW27KZFldMXrsGJY8UX0EB8XFxUg4sgBJVFSUepM1FrzatGmDjIyM2jwlEVGDsm3eghWGZr77BsWNvq5cRA0tmymRiI4jOGjZsiUOHDjgu//MM8+gefPmvvtZWVmIj4+vzVMSETUY6Qtl27oVK/VlwYEEBpb4GOhbtGDJE9VHcDBmzBi1KcFr6tSpiI4um4pUOihy3QUiChaujAyU5uZjvb5syeVBrmyYe/RQl5wnonoYrfDGG28cdfvFF1+MKVOm1OYpiYgajG3LFqzTJ8Kh0fnSTnZmwtzrNJY6UX0FB8fSgdOQElGQ9Tf4p1yTQoLHhk5KMec3IKrvSZC2bt2K999/39e8IH+leeHqq6/GggULavt0REQNN2Xyzp1YWW7yo5NcWTC1bw+dpWymRCI6zpqDOXPm4Nxzz4XFYkFpaSm+//57TJ48WZ37wOPx4PTTT1f7HYwaNao2T0tEVO+kI+JBlx57I2N8aQOd2TD37MfSJqrPmgOZ4Oiuu+5CTk6OWntw6aWX4rrrrsMff/yB+fPnq9ueeuqp2jwlEVGDKF66FIsMZUOtdYoHQ1zS36A3S5yoPoODzZs348orr1T/f9FFF6GoqAgXXnihb/tll12GDRs21OYpiYjqnWPfPuRt3IqvTGVTJvd05yMu0ghjh/YscaL67nPgHf6j1WphNpsRGxvr2ybDGgsKCmr8XLNmzULfvn0RExOj3mT65d9+++2oj8nPz8e0adPUyZdkVsauXbti9uzZtX0bRBTGCn7+Bd+Z2vvNiniFbReihg3jEEai+u5z0L59e+zcuROdOnVS7//9999o27Zs4RKZIKn8jInHIusySDOELNQkk5V8+OGHap+GtWvXolevXpX2lxUgx44dq0689M0336BVq1bYv38/4uLiavM2iCiM2ffsQe7mbfg8ZrQvrZcrD0N0BYg+fWxA80YUlsGBjEpwu92++717+7fdyVV/bTojnn322X73Z8yYodYmLF++vMrg4L333lMXeJI1HmQ9B2/AQkTkVfDzz/jG1AEFWqMv7VrbNsScPgo6i4UFRVTfwcENN9xw1O1PPvkk6kqCjq+//holJSVq80JVfvrpJ3WbNCv8+OOPaNasmdopUlaL1OnKJjkpz263qzevwsLCOueRiIKbDF3M2boLX8SUXaT0c+VgkLEU0aPLahKIqBEnQaqLjRs3qid8m82mDpGU4ZE9e/asct89e/aocylIx0fpZ7Br1y7ceOONcDqdePjhh6t8zMyZM9WVJIkovEnTZMFPP+Mrc0cUlas1uMa6HdFnjYY2inMbEDVYh8T169ercxt07NgRERER6sqMsoTzgw8+WKer8m7dumHdunVYsWKF2mwh0y9v2bKlyn1lLgXpb/DWW2/hxBNPVKdrfuCBB446rfN9992ndpL03lJTU2udRyIKfvYdO5C1a5/fCIUBzmycaLYjmnOvEDVccDB37lz1Kl8mQBo2bJg6YkFmRhw/fjy++OILddGl9PT0WmXAaDSic+fO6slervJlQqWXX365yn2ls6OMTijfhNCjRw/1NaWzYlVkRIN3NIT3RkThV2tQ+PPP+MLUESWaf/sjiWts2xE9dgy0EREBzR9RWAcH9957L1544QV1pMDHH3+MH374AfPmzVNHHMjVvnQOlCv14yG1A+X7CJQnAYk0Jcg+Xjt27FCDBgkyiKhpsm/diozdB9Thi14nOTNxQoQTltO4yBJRgwYHso7CGWec4beE8+7du3H48GF19IC0+//66681fj4JJP7880/s27dP7Xsg9xctWqT2KRDSfFE+2JBmBxmtcOutt6pBgbyWdIKUDopE1IT7Gvz8C74wdfKrNbjStlMduqg1mQKaP6Kw75Ao8wps377dN3xQAgO5ik9MTPTNW1BcXFzj58vMzFQDAAkuZDIlmRBJmi5kLgPvvAnSdOHVpk0bdfvtt9+u7iv5kUBBRisQUdNk27QZ6fvS8G25EQpDnBnoF+mC5ZRTApo3oiYRHMiJ/Nprr1U7AUpbvjQxnHPOOb4qfelYWJtlm999992jbpdahIqkz4PMg0BEpPY1+OVnfGbqBJtG79fXIOb8cdCay2ZIJKIGCg7uv/9+dR6Cxx9/XO0XMG7cOL/Og3IlL5MYERE1BtuGDTh0IAPfl6s1GOFIR0+LBpYRI3gQiOpIo0jo3YTIcEtpwpBhjRy5QBS65KcrY8aTeCYnFt+VG774fuFiDJx4JqLZEZGozue/Ws9zUJHUIEjfg+pGGBARNQTr2rU4mJaNn41l67uc5jiEbrF6WIYPZ6ETHYdaBQcffPCButiSkBkNr7nmGnUSJJl7QGY3lOmVGSQQUeP0NfgVH5s7w6n5d94TjaLgKtsOxJx1JjRH1l4hokYIDh577DHf6AGZEVGmMpb1EDZv3qzOfbBw4UI1nYioIRX+9BN2pRfg13K1BmOch9A53oioatZmIaIG6pB46NAh35LMsgiSdD70znvQvXt3xMfH44orrsAzzzxTm6clIqqxkn/+QdqcebjfMhwuzb8XK1pFwZW2HYideAE0+oAvGUPUtGoOWrRoofYvEDJqISkpyW+7rJKYk5NTvzkkIjrCvmcvsj7+BA9HDsABXdnyy+c79qFjUhQiTzqJZUXU2MGBzFwocxzk5+erNQTSzOCd9EjWW3jkkUfUKY6JiOqbKy8POW++gVf1XbHS0NyXfoIrB9Oc25EwZTI01SzdTkS1U6v6N5keedOmTeqKjAMHDsSSJUuQnJyszm8gTQ4yU+Iff/xRyywQER27A2Lu+x/ge2scvoksG7aY4i7B4yWr0OzyS2Dq1InFSBSI4EBmQvzxxx8xZ84c/Pzzz+rqiDJ9svRDkBqDSy+9VB29QERUnxx79yF75x68GjPGlxapOPF0yUq0HjUCFtZYEtWrOvXckU6I5RdgIiJqSCVLl+B3Q2tYy02R/FDJWvTo0Q5xF1zAwieqZ8c9CRIRUUPylJaiZOUq/GQqG7bY25WL4boCJFx1FTTlFmcjovpR52/V1VdfrXZOrLj2gqQTEdWXkuUrsMkThT26sulez7EfQNTQodBZ2IxJ1BDqPCB47969an+D8tLS0pCamlof+SIiUjsiFi/5Ez+Y/l0mXlg8DpzmPATL8CtZQkTBFhzIbIgVffjhh8ebHyIilbuwELkffYzc9BwsjOnvK5UznGmI7dwBhlatWFJEDYRTiRFRUHEcOICiBQtQvGoV/kECnoseAceR9RPEufb9iBp+YUDzSBTuahUcSDOCrKPQp08f9f4bb7wBh8Ph2y5DG6dOnepbf4GIqCYUtxvW9etRvHAh8nbuxRxja3wTMQKp5WZBFP1cOegYoSByQFlNAhEFODj44osv1IDgzz//VO/fddddiIuLg/7IXObZ2dkwm83qao1ERMfiKSlB8V9/oXjhIqTmW/G9sT1+iR2DYk3lVRWjPQ7cat0My+kjoDEaWbhEwRIcvP/++5g2bZpf2uLFi9UZE4UEDp988gmDAyI6KsXhQMHPP6Pwj3lYr0vA16YOWBrdAh6NptK+iR4bzrfvwzmO/WjRsyuizzyTpUsUTMHBtm3b1GmTqzNy5Eh1OCMRUXVs27cj68WX8I8+CY/HjEW+1lTlfj1c+Zho34NTXemI7tML0aOnwdS1KzRVBBBEFMDgICsry+/+nj171PUUvAwGg7paIxFRVaMP8r/9DlkrVuPdiJ742vRvjWN5OsWDkc7DmGjfi94GGyzDh8By2vUwNC9baImIgiw4kEWWtm/fjk5HFjiRJZrL27p1q7qsMxFR+bkKSpYuRf7332OBMw6vxJyKbK25UgFdbtuJ8+z70TIpGpYJYxE1ZAi0EREsSKJgDw5Gjx6NGTNm4KyzzqryB2DmzJnqPkREwnnoEHI//RT79h7GixF9sDyqcg3AePsB3GbdhOi2rRA74SqY+/Rh0wFRgGkUOavX0O7duzFgwAB0794d06dPR9euXdV0qU147rnn1L+rV69G586dEawKCwsRGxuLgoICxMSUTcdKRPXb4bBwzhzk/v4HvtK1xXvmbrCXm6tADHBm407rRnRuk4iYCWcjok9vHgKiIDn/1armQJoT/vjjD1x55ZW4+OKLfdG9xBcSMPz+++9BHRgQUcOzbduGvE8/w/pcJ56PGIKd+li/7fEeO26ybsHpuhzEXXgOLKeO5OJJRKE+Q+JJJ52ELVu2YN26ddixY4ea1qVLF/Tvz0lJiJoyx8GDKJo7F1kr1+GtiG743tIeSoWRBefY9+MG2zY0H9AH8RNvgi4uLmD5JaJ6alaojsvlgs1mg8XiP5tZMGKzAlH9kZ8P24YNKFqwEAXbd+I3Yxt8ZO5SqcNhe3cR7irdgP5xGsRPuhQRvXvxMBAF8fmvVvMc//zzz/jggw/80qSDogQFMlPi6aefjry8vLrlmohCbsrj3Pc/wLY33sfL+zW4IGYMXojs4xcYGBU3rrNuw7vFSzFs1EC0ePhhBgZEIaBWwcELL7zgN4/BX3/9hYceeggPPvggvvrqK3W55scff7wh8klEQSb/m2+xadVWTIkeiU/NnVGo9Z/S+ERnFj4o+hPXprjQ5v57EHfB+dBy2mOi8OtzIIsuSYDg9c0332Ds2LF44IEH1PuyrsKtt97qtw8RhZ+iRYuQumgZ7okeXiko6ObKx2X23ThNl4e4iefAMpIdDonCOjgoKirymxFx6dKlmDhxou9+r169cOjQofrNIREFFdv2Hcj48hvcFzUY6dpIX/ogZxYm23biBH0JLMOHImbc6exwSNQUgoNWrVqpsyC2bdsWxcXFWL9+PV588UXf9pycHERGlv1YEFF4cRcXI/f99/E/cw9s1sf70gc7M/GUbTUSxp8Fy6mnQsvfAaKmExxILcFtt92mLq40e/ZsdarkwYMH+7avWrUK3bp1a4h8ElEQjEyQDojzSiLwY1R7X3pHdyEeKVmD5tdeicijLMxGRGEaHEjnw7S0NNxyyy1qYCDLM+t0ZbOeff755zj77LMbIp9EFGBFc3/Hzq378FT0cF9apOLEkyWr0PKcMxkYEDXV4CAiIgIfffRRtdsXLlxYH3kioiDjKS1FwW+/4fHIQSjVGHzpd5VuRKfu7RB95pkBzR8RBXiGxOXLl6vzHTgcDnWRpTPOOKOes0REwca2bTv2OI3YGlE2o+G59n0YF1mChKtu40JJRE05OJChi7KmgtQgGAwGdcji008/rS7CREThy7ZtK1Yaknz39YoHN1i3If6q66CLjg5o3ogowJMgyZLM1113nTr1osyE+MQTT+DJJ59sgGwRUTCxb9+BtfqyYcx9XLmIjY1Sl1cmoiYeHMiSzFJL4O2EeOedd6pzH2RmZjZU/ogowFw5ObBmZPoFB/1dOTB1787mBKIwVavgoLS01G+xBqPRqM6KKHMeEFF4sq7fgHX6RL+OiCe5smDuzmHLROGq1h0S33nnHb/VF2VFRlmMKSmprD1ShjoSUXiwrl+PpYZk3/0Ejw09PAUw9+4d0HwRUZAEBzIz4ttvv+2XJvMdfPzxx777Go2GwQFRmPCUlMC2cyeWWk7zpQ1xZsLcoQM7IhKFsVoFB/v27Wu4nBBR0LFu2owdGgsytRG+tBHOdET0GxbQfBFREPU5IKKmxbphPZYZWvjumxUXBrqyEXFCv4Dmi4iCKDg466yz1GGMXk899RTy8/P9Fl7q2bNn/eaQiAJCcblg27wFS/Vl/Q0GObMRldwMhuSyNCJq4sHB3LlzYbfbffdljoPc3Fy/zoky3JGIQp991y5k2oGd+lhf2jBXOiL69g1ovogoyIIDWZXtaPeJKHzYNm/GckMzvzS1M2IfjlIgCnfsc0BE1QYHK/TNffe7u/KRFKGDqVMnlhhRmKtVcCDDFOVWMY2Iwovz8GFYD6VjVbn1FE52ZcLUowc05ZZpJ6LwVKuhjNKMcOWVV8JkMqn3bTYbbrjhBkRFRan3y/dHIKLQpDgcyP3oY8w2tkFJ+VkRnVkw9zwpoHkjoiAMDqZMmeJ3//LLL6+0z+TJk48/V0QUEHIBkPf551h7IA8vWYb4zYrYU2ZF5GgkoiahVsHB+++/33A5IaKAK1myBPuXr8UD0SPg1JQ1H9xdugExJw2CPj4+oPkjosbBDolE5JsNMfvrb/BI1ADkaM2+UrnGuh0j4xXEX3wRS4qoiaj1wktEFH6KFixExtff4smIvlhfbmnmkY7DuFKTiqQb74Y2MjKgeSSixsPggKgJUzwe5H/7LVIXLMU9UUOwVR/n29baXYz7S9chaep1MKSkBDSfRNS4GBwQNVEeux25772HLRv34B7LMBzW/TvqyNsBcUbJaiSPPQ0R/biOAlFTw+CAqAlyFxUh+9XXsDytGA9ED0NxuSGLnd0FeKp4JToOPgGx//lPQPNJRIHB4ICoiXEXlyDzuecxO1ePmVEnw6Up65d8sjMTj5WsRsp/zkb0uNM5yRlRE8XggKiJyf/yCyzOUfC4pb9f+nn2fbjVtR3Nr70SkQMHBix/RBR4DA6ImpDS1auRtmoDno4e6Zc+1boFlxky0ezm22Dq2DFg+SOi4MDggKiJcBcUIPezz/F8RB/kaf+dAl3cVboB58dakXTzXTA0L1toiYiaLk6CRNRUpkX+7DP87ojFYmPZsMQRjnScq89GsztuZ2BARD4MDoiagNLly5G6YTtejOjtS4v12HGXdQMSJl3CaZGJyA+DA6ImUGtQOHs2Xo7ohSKt0Zc+3boRLQf0RgQ7HxJRBQwOiMKcOzsb1qwcLDG08KWNchzCKHMJ4idN4nBFIqqEwQFRmHOmp+OgNgrucvMZXGDfi+jRo6GzWAKaNyIKThytQGFNcbth374dpWvXwnkgFdDrYGzTFqbOnWDu2bNJLCYkwcF+nX8Q0MldBHPvsv4HRETlMTigsBuuV7pqFZwHD8KZmQnX4cPIsCpYZEjBen0SNFDQL3Uf+i5Zg656O2LGjEb0mDHQRkQgXLkOp2O/tiw4SPLYEKVxw9C8WUDzRUTBi8EBhQ3HwTRkvfwy1pXqsdLQDGnaWOzTtsLO2Fi//RYZW6p/e7ryMHXOcgz8ZyWa33N32FaxOzOk5iDGd7+tuxj6pERojGWdE4mIymOfAwqfhYRmvY53nCmYFj0MH5i74g9jK+zU+wcG5W3Rx+NWyxAszZMphb9CuHJlZuFguZqDtp5i6JPLOicSEVXE4IBCnuJwIHvWG5hTaMb75q5V7qNRFPR25aKHKx9Gxe1L92g0eD6yD9JWrUfRvHkIN+78fDVwOlBuOea27hLokzkTIhFVj80KFPJj+HM//gRr9ufiKcsQv239XDno6C5CJ3chhjkzkKR1QaPXo7TYhacj+2K+sZW6X7o2EtOjTsLL3/yINuYIWIYPQ6hz5eWhePFiFM2Zi1X6JJSUW5K5jacYhuTkgOaPiIIbgwMKWc6MDOR99jl270zF/ZZhcGh0vm2PlqzGKOdhmHv1gqFlV5h7nw9Tly6ARgPrqlX477vvI0drxjp9orr/Dn0c7rEMwvOffo5WZlNIrkoogZJ9504UL1qM4nXrsEzXDF9bhvjeo1dbj9QcMDggouoxOKCQbEYo+Pln5C1YhB90rfFu9AgUl7syvsa6HafHOdH8nmer7GQYOWgQmrtceOrDz3C7ZTC26uPU9A36RNwfeSKe/uBDtG7RAsbWrREq5VGyciWKFyxE9qFM/GJsix8sp6o1IhXJlMktdA4YWoXGeyOiwGBwQCFFcbmQ9b9XsXJPNp6LHIq95Xrhi7GOg7hSm4qkG48++iBqyBC0strw7Nff4xbLEOw58jwrDc0xz9ECE5csgXHSJDQmT2kpPCUl6twMitMJHJm0SLHb4Cm1QnE5AY8HissNeNxQ3B51yKYM3dxZqsE3pg74PaavXw2Kl1lxYagzAxPtexEzcgR0lrI+CEREFTE4oJCS99VXWLcnE7dZhsJZ4SQogcF9jk1oNu1GGFLKVh6sTvSo09DWZsXzP/+O82LH+tI36+NwXm4uGpq7uBj2HTth37ED9h3b4Th0GC5o4IIWDo32SG9hBaXQqzUjTo0WTmjhhgZujQYeaJCjMWGOsRdWx1Q9Z0GypxTn2/fhbEcqElo2R/TosxE5xL9vBhFRRQwOKGSU/PMPMv78G/+NGekXGLRzF+E262acFGFHwtQbYO7Ro8bPGX3mmUj66WcMcmaqtQbCrtFBcdgaZOSAffdutV+Afecu2NPSsFcbjbX6RKwytMK62L5+HQePxwBnNi5w7MNQdxaiT+iH6FHnwdipE9dRIKIaYXBAIcG6YQPSP/wED0adiExthN8aATfZtiJu1KmIHT++1tMhazQaGFq1gi5f8aXJlblU39dXJ0Hbpk0omjsXJbv2YK8uGut0iVivb4F1Mb1QUG6VxONlUtwY5ziIC+170SkSiBo9DJaRI7kcMxHVGoMDCnq2rVuR/tbbeNTUD6sMZdXnA51ZuNW9E81vuxXmblXPb1ATElDE5jl99/M1Rriy9h13UGBdswYFv/yC9PQ8fGXqiJ9jT/frOFlfmnus+I99H85xHEBS6xaIHnU+Ik88kTMgElGdMTigoCZV8dlvv4OZxt7401jWj6C1uxgPlq5FwmUXHVdgIHTx8WiWWuC7v1Ufj5L8QrUJwNSpU+2DgrVrUfjrbKQdylEnZZob079S/4jy9IoHvdx5GOjMRkdPkXrfCA+8dReRigtRigsmeKBTPNBDgRaK+lfuR2gVRPbpDcvom9ThmlIbQkR0PBgcUFArnDMHfzjj8HtUa78r5ZeKl6Pd6afVy4RFhpYt0W3tAd99ubr/0NwFN335JZLvu69GJ1u1+WDjRhT+NgcH9x3GJ+bO+CWmb5VBgUFxo6c7Hye4cnCCK1eduTEyJgrmvt1gbN8PGoNBvSlHmja0JhM0ERH/put06g1y02ih0WmhS0hQ9yEiqi8MDii4x+8vX4EvTWUTEsV57Gpg0OmUkxD7n3Pr5XUiTz4Jw3/5Bb1cedisj1fTpBng7IOLEP3334gaOrT6PHo8KF25CoVzflObD742dcC3MaepnRorTt88wpmudhKU14mMtcDUvQtMXQbA1LUr9C1a8IqfiIIGgwMK6r4GqQ4ttpn/naRIXGPbjq59uyDukkvq7WSqj49H4oQJuPPnBbjGMgKKRqPOFfC6uSee/OYbddIkuWovT+YiKPl7OQp+/BGpJW58bOqMuTED4DoyN0H5oGC08xCusu1AhxgDos8aDXOfPtA3b85ggIiCVkCDg1mzZqm3ffv+7fzVq1cvPPTQQzjzzDOP+dgvvvgCkyZNwrnnnosffvihEXJLgRi6uMDw7/LKQtrX5UQbfXr9BQZe0aNHoceyZZhQfAA/m9qpaYuNKdhatBOem29Raw/0KS2gT0yCOy8XxX8uwcHMQrX54bfo1nBXCArEGEcaJtt2onO8EbETL/g3yNAzHiei4BfQX6rWrVvjqaeeQpcuXdQ22w8//FA92a9du1YNFKojwcT06dMxYsSIRs0vNe5sgTJ8ca55uC9tkCsbcXHRMHZoX++vJzUDcRecj2ve/ACzjW18J/tro09RT/IdVmeirWcPWnlKUQw95hhbY27MiZWCAm/zwWT7LvSM1SHmvHMRNWQwgwIiCikBDQ7OPvtsv/szZsxQaxKWL19ebXDgdrtx2WWX4dFHH8WSJUuQn5/fSLmlxmRdtw7bPFE4oCubAvkMRyoiR5zUYNXx5n79kJwUgzOKD+JXU1tf+rwjqzcejdRqyBwDl9t3o32sEdHjx8IyYgSHExJRSAqaOk456X/99dcoKSnBkKNM7/rYY4+hefPmuOaaa9Tg4Fjsdrt68yosLKy3PFPDkfUC5pdrUohQXBjuzEDUySc32GtK0BF/2aW4/aX/YYcuFjv1sTV6XF9XDm61bkbPpAjEnDkRkQNPZE0BEYW0gAcHGzduVIMBm80Gi8WC77//Hj179qxy36VLl+Ldd9/FunXravz8M2fOVGsZKHS4CwtRum075ltO86VJVb2ldcsarZlwPMzduyP5ogvwylffY5ExBbt0MdintWCfLlpd4tnLqLgxVvoU2HehpWJF9LjTETthAoMCIgoLAQ8OunXrpp7sCwoK8M0332DKlClYvHhxpQChqKgIV1xxBd5++20kJSXV+Pnvu+8+3HHHHX41B23atKnX90D1q/Sff7BOG4+sctMkj3EcQuTA6ocU1qfoUaPQqWNHpKxdB+fhQ3Ad3g1Xdg5KFB0O6SJhVtxo4SlFREoyYsZegMiTTmJQQERhJeDBgdFoROfOndX/n3jiiVi5ciVefvllvPnmm3777d69W+2IWL6fgufIJDF6vR7bt29HpypmszOZTOqNQoN0TC1etgy/GMva/GM9dgxyZSFyUNl8Bw3N2L69evPly+GAMzML7fLyoNHr1KGIMvkQZyMkonAU8OCgIjnhl+8j4NW9e3e1CaK8//73v2qNggQTrA0ID47du5GTnoPFMf19aWc6DiKqW1foExMDli+N0Qhj61aA3IiIwlxAgwOp8pc5Ddq2baue5D/77DMsWrQIc+fOVbdPnjwZrVq1UvsNmM1m9O7d2+/xcXH/To5TMZ1CV/HSpfjd0FqdhMhrguMALMMvDmi+iIiakoAGB5mZmWoAcPjwYcTGxqJv375qYDB27Fh1+4EDB6DVVp5chsKTbcsWdbrkH6NH+tL6uXLQIQKI6NcvoHkjImpKNIo08jYh0iFRAhHpABkTExPo7NCRfgYlS5Yg84uv8IKpF34pN8fAAyVrceEp3RA/cSLLioiokc5/QdfngJpeYJD/1dfYv+gvPBR1Ejboy/oVxHgcOM15GJbh1wQ0j0RETQ2DAwpoYJD30UfYvmIDbo8ehnRtpN+kRw+WrkX8SQMbfG4DIiLyx+CAAqZ40SLsWLEB0yxDkVtugqF27iI8WbIKXbq2VmcsJCKixsXggAK2sFLhL7/ihYjefoHBEGcGHi5Zi5TxpyNm/Hho2CGViKjRMTiggCic+ztW2s34x9Lcl3aq4xAedmxA8v9dhcgBA3hkiIgChOMEqdE5Dx9G3vz5+F9E2cqb0R4H7rZuQPLVVzMwICIKMAYH1Kg8Nhty3nsfX+raYbeubCiNLGDUrGc3RA4omxmRiIgCg8EBNRp3QQEyn3seSw/b8La5my+9rbsYFzj3I/a883g0iIiCAPscUKNwZmYi+3+v4pd8I56KGgS35t+4VKsouLd0PRJGnfrv2gVERBRwDA6owdl370bWa6/hU3cKZkX5L8U91bYVA5IjEHvOOTwSRERBgsEBNSjHgQPIeOV/eF7bFT9GtPOlaxQFt1g3Y6I5B4k3TFdXPSQiouDA4IAaTMmKf5D7+ed4VdMJP5rKAgOd4sF/S9fhjAQ3mt1yT0CXYiYiosoYHFC9U1wu5H32OQ7+vQpPRvbDckOy35BFmf3wpNYWJN10G3TR0TwCRERBhsEB1ft6CTJUce363bg3+hTklJv9UNZLeLFkOU7o2wkJV10JLZsSiIiCEoMDqlcFP/6IXeu24Q7LcBRpy/oRNPNY8WjJGvTr3gaJ11wNjZ4fPSKiYMVfaKo3JX//jbS5CzDdMswvMBjuTFeHK7YcMgjxl1zMwICIKMgxOKB6Ydu+A5mffoYHIwfioM7iSz/DkYoHPNuReO0URJ54IkubiCgEMDig4+5jUDRvHnJ+/AlPG3thjSHJt22AMxt3Ozaj2c03wdytbEZEIiIKbgwO6LgUfPc9ds1bggejTsZWfbwvvbW7BE+UrkbylMsYGBARhRgGB1Rn9r17kf7HQtwcfQoO6yJ96XEeO2aWrETLMSMRNXgwS5iIKMRw4SWqs5KlyzDH2NovMOjgLsSrxX+h58CeXEiJiChEseaA6kRxOGBduwa/Gwf40tq5i/B20VI0O2scYiZMgEbL2JOIKBTx15vqxLppM/bbtNhSrp/Bhfa9iD95kLqIEgMDIqLQxeCA6qT0n3/wh7FsiWW94sEo52FYThnBEiUiCnEMDqjWPCUlKN20Eb8byoKDIc5MJCTFwtixI0uUiCjEMTigWitdswZblGik6aJ8aWOdaYg86SRoNBqWKBFRiGNwQHVqUvjd2Np336I4MdSZoQYHREQU+hgcUK24cnJQsnM35htSfGkjHYcR3a4NDMllSzMTEVHoYnBAta41WKFvhgKtyZc2TpoUTj6ZJUlEFCYYHFCt2Pfswd+GZL+lmPu5chA5aCBLkogoTDA4oFrxFBYiT1O2HHN3VwGMLZKhi45mSRIRhQkGB1Qr7vx8ZGnNvvvNFSv7GhARhRkGB1RjiscDd2ERcsoFB0keG3RxcSxFIqIwwuCAatWkoCgKcjVlnRETFDu0MTEsRSKiMMLggGrMXViIAo0BLk3ZxybRY4culjUHREThhMEB1Zi7oAA5mrImBV+zQixrDoiIwgmDA6oxd0Ehssv1NxCJigQHsSxFIqIwwuCAasyVkY5D2kjffaPiRqziZIdEIqIww+CAasyxbx+26sr6F3R0F0EXFQUt5zggIgorDA6oRmSUgiP1ILbry5oQerrzYWzfnisxEhGFGQYHVCOK3Q7FZkOGNsKX1tJTwv4GRERhiMEB1YjGaITGoFeHLnqt0yeidOVKtVaBiIjCB4MDqhGNVgtzz54Y5TzkS1tqaIFDbj0OP/BfOPbvZ0kSEYUJBgdUY1FDhuBMx0G/tEuiR+Hjkjjsm/kssmfNgiM1lSVKRBTiGBxQjZl790brSC36O7N9aR6NBrMieuLimFF4f1sx9s94CtlvvAHHQf8ggoiIQgeDA6oxjV6P6DFjcJd1I3q7cv225WlNeO1IkPDh1kIceGImst98C46DaSxhIqIQo1GaWG+ywsJCxMbGoqCgADFcMKjW5ONS9PsfKPjtN6x0WfCeuSs26RMq7ZfoseFy2y6c7TiAuBP6Iu7ii6CPj6+fg0hERA16/mNwQHXiLi5B8fx5KFywECvcMXjX3BVb9ZVP/nEeO26wbcXZ5gI0u+VWGFu3YokTEQUAg4N6KhyqWZBQNO8PFC1chL/dsWpNwjZ95VUaL7PtwlTtfjS76WaYOnZg0RIRNTIGB/VUOFRz7qIiFP0xD0WLFmGZJw4fVBEknGffh9td2xB3zjmI6NcP+mbNfLMrekpL4Tx8GM5Dh9QRD879++HKy4POYoGpazeYunaFuWcPaM3+Cz8REVHNMDiop8KhOgYJv/+OosV/4k8lAU9EngCrRu/bPtyZrtYidHUXwmQyQGuJgmKzw11SgmyNGXt00epN1nA4oLOghacUA53ZGODKQSezC3HnngvLyJE8NEREtcTgoJ4Kh+rOXVyMnHffxZod6ZgedRKKtUa/7TrFg3aeYsR6HCjWGJCujUBRhX0qkiGUj5SuQeuBfRE/aRK0kWUrRBIR0dExOKinwqHjozidyHnnHazbtA93RA1G4TFO/jWR4LHh7tINGJmoQfM774COx5CIqN7Pf5zngBqMxmBA4nXX4YQTOuPN4qU4w5GKSMV5zMdZFKdaSyD793XlqLUMXrlaM+61nIS5uVoU/PILjx4RUQMoawwmaqCJkxKvvRYRy5fjkQULUZK6EXt10dipi8EuXQzs0CFacSJBsaODu0i9NVNs6pwIGpMRnqJi5BU61L4Lyw3JvuedbWyDcdt38JgRETUABgfU4GREgqzLIDdXTg5S9u/HIBmRcOgQFJcb2sgoaC0tYGiRDEPLlupNGxXlm3QpdulSPPPpZ5hmGYqNRyZcStdGwpWTrW73jnggIqL6weCAGpU+MVG9YcCAGu0vJ37LiBGw79qNMWvTygUHEfC43PAUFbHfARFRPWOfAwoJpk4d0cpT6rvv0OiQoY2AMz09oPkiIgpHDA4oJEgzQ6zi8EtzysfX7Q5YnoiIwhWDAwoJruwcHNT+2w9BaBQFzT1W6BIqL/pERETHh8EBhQR3YQFytSbf/TjFATM80DM4ICKqdwwOKDS4XLBB57trgEd6KwJafoSJiOobf1kpJOji4pBSrkNilsYMu6JRh0YSEVH9YnBAIUGflISW5YIDRaNRhzO6GRwQEdU7BgcUEhS3G274T3ak3uMESERE9Y7BAYUEx/4D6nTLXgbFrdYk6JPLplQmIqL6weCAQoJt21as0jfz3e/mLoDREqX2RSAiovrF4ICCnruoCLbDGVhjSPSlDXRlw9S1K9dVICJqAAwOKOh5Sq3q6o0lGoMvrYXHCq2lbFIkIiKqPwwOKOjp4uMQpVOQXG60wn6tBZ7CooDmi4goXDE4oKCnNRqhT4hHZ3ehL22vzsI5DoiIGgiDAwp6iqJAcThQVK5ZQaZP1prNAc0XEVG4YnBAQc+xdx/yC63YpisbmdDJXQRDq5YBzRcRUbhicEBBr3TFciw0pMChKVtbYbAzE6YuXQKaLyKicMXggIKau7gEJctXYI6xtS+thysfHUwuRPTpE9C8ERGFKwYHFNQKvv0GS92x2KhP8KWNcxxE5IAToTEaA5o3IqJwxeCAgpZ14yakL1+F5yL7+tIsihNjnWmIGjokoHkjIgpnDA4oKHlKS5H36ad41dwT2dqyUQk3Wbegec+uMHbsGND8ERGFMwYHFJQKf/sNG4uA2aa2vrSTnJkYr8tC/OWXcdpkIqIGxOCAgpJty1bMLdcJ0ai4cXfpBsSffwH08fEBzRsRUbhjcEDBSatFabmhi7IKY7JiQ9TwYQHNFhFRU8DggIKSLjoasR6H774NOugSE9icQETUCBgcUFDSxkQjUbH77qfqotQ5D4iIKMyDg1mzZqFv376IiYlRb0OGDMFvv/1W7f5vv/02RowYgfj4ePU2ZswY/PPPP42aZ2ocuphYxHvKggObRo8cB+Cxl6UREVEYBgetW7fGU089hdWrV2PVqlUYNWoUzj33XGzevLnK/RctWoRJkyZh4cKF+Pvvv9GmTRucfvrpSEtLa/S8U8PSRluQVK7mQCgyxLGIyzQTETU0PQLo7LPP9rs/Y8YMtTZh+fLl6NWrV6X9P/30U7/777zzDr799lvMnz8fkydPbvD8UuPRRccgRinrcyCKNQa4CwqgT0rioSAiagp9DtxuN7744guUlJSozQs1UVpaCqfTiYSEsql1KTzoYmOQUK5ZQchkSM5DhwKWJyKipiKgNQdi48aNajBgs9lgsVjw/fffo2fPnjV67D333IOWLVuqfQ+qY7fb1ZtXYWFhveSbGpYuNhbxil2d38C7GuM8Q0sMWbQYUcOGQaMNmriWiCjsBPwXtlu3bli3bh1WrFiBqVOnYsqUKdiyZcsxHyd9FaSmQYIJs7lset2KZs6cidjYWN9N+ilQ8NO3aAFjbAxOcab70mYb22BTehFKlv0V0LwREYU7jaIo0s8raEgtQKdOnfDmm29Wu89zzz2HJ554AvPmzcPAgQOP+nxV1RxIgFBQUKCOkKDgVTR/PrZ8+yuuiD7VV3twgisHr2o2oeVjj0IbERHoLBIRhQw5/8lFck3OfwGvOajI4/H4ncwreuaZZ/D4449jzpw5xwwMhMlk8g2V9N4oNFhGjkTbZjG4xL7Hl7ZOn4hFtigUzpkb0LwREYWzgAYH9913H/7880/s27dP7Xsg92W44mWXXaZulxEIkub19NNP48EHH8R7772H9u3bIz09Xb0VFxcH8F1QQ9Ho9Yi78AJcZtuFRI/Nlz7L3AO5c3+HrQbNT0REFGLBQWZmphoASL+D0aNHY+XKlZg7dy7Gjh2rbj9w4AAOHz7s21+GOTocDlx44YVISUnx3aSZgcKTuXdvxPfogmtt231pabooPBvRF4dfnwXr+vUBzR8RUTgKuj4HwdTmQsHBcTANh2bMwJWWU7BPF+1LH+5Mx+P2dUi55WaYu3YNaB6JiIJdSPc5IKrI2LoVYoYPw63WzdArHl/6UkMLvGTogdz3P4CntJQFR0RUTxgcUEiIu/BCDG0Xg7eLliDZUxYI/Ghqh7+K9Mj/9ruA5o+IKJwwOKCQoDWZ0Pz229Fv+Al4oXgFIhSXb9vTkX2RvWw5nJmZtX5eWcjJU1KCJta6RkQU3DMkEtVm9EL8pEnokpWFabu34LnIvmp6ljYCfxuaI+GHH5F43bXQaDRHfR7F7UbJ8uUoXrAQTu+iXTodTB07IO6ii2DkRFlE1MSxQyKFHKkhOPzQw7goZhTStZFqWhdXAWaWrESrZjGwnHoqooYMVk/4rowMuLKz1T4JitUKV1YWrJs2YW+eHR+bO2OpPhlujVZdHvosRyomaw4i5a7pMLRqFei3SUQUsA6JDA4oJGU8/QyeSo/C96b2vjSd4sEo52FcYN+Lnu58SP1BkUaPQ9ooFGoM6qqOdmix2pCE3w2t4amihuEa63Zc38aD5tOnN/I7IiIKnuCAzQoUkiIHDcIF3/yKucZWKNUY1DSpAfjD2Eq9JRyZNClXW/26G1X53NwRE3fNR9z+/TC2a9cgeSciCnbskEghyTJiOLp1b4e3i5ZitCMN2godCiUoOFZgIDUNZ9v3Y7Jtpy9NAg3pv2DbXjbpEhFRU8OaAwpJGoMBSdNuhHnxn3h8/jyk5m3HN8b2mG1qg5IjNQnVMSlujHIcwpX2nWhtVuCxWvG1qQOsmn+/DkUaA+dNIKImjcEBhSyNTofoUafBMvIUxK1bh/YLFuDa3fOwypCELbp4RCoutPcUo627GHGKHZYjwx81UGBu1QrRYyfC1KULUh94EC61h8K/DPBAo+NXg4iaLv4CUlgECZEnnqje4g+mIWXzZpyZka6OVjC0aAF9cgvoYmOgjYyUZT+hiYiEzhKlPtZx8CBKNXo4jywJLZp5bNDFxQbwHRERBRaDAwq7qZblVnOacnUGREQk2CGRmjTFWoriI30NvCyKE9qof2sWiIiaIgYH1KQpHg9cFb4GerXPQVkzAxFRU8PggJo0xeGEo9LXQAPHvn0ByhERUeAxOKCmTfHAVWGmxDnG1rDv3RuwLBERBRqDA2rSDK1bo5272C9NhjVqjMaA5YmIKNAYHFCTpk9IgBkexHnsvrRYxQEdOyQSURPG4ICaNI/936BAKTegMc7jgMZUuzUZiIjCCYMDatIUux2yKkOBtqwZwQQ3NCZTQPNFRBRIDA6oSVPc7kqTIEUobmijIgOUIyKiwGNwQE2ap6QUVugqzXOACiMYiIiaEgYH1KQ509KwTR/nl+aADkVz5kKpsAw0EVFTweCAmjSNXodoj8Mv7bWIHki1Ksj/8isGCETUJDE4oCYtom9fdIsz4BLbbl9artaMWy2DsfPPFSj86aeA5o+IKBAYHFCTpjEYkHT9/+FGz26MdqT50jO0kbgjajCyfp8PZ0ZGQPNIRNTYGBxQk2ds1w7Nrv8//NexEcOd6b7yOKiLwt/aRFjXrmvyZURETQuDAyJpXujVC8lXX41HS9bAUq4PwmZdPOw7d7KMiKhJYXBAdETkgP6IatkCg11ZvjJZZkhG6ebNcKSmspyIqMlgcEBUjql7N/Rx5frup+oseMvcHdmvvgZXXh7LioiaBAYHROVEnXQSxjoPIdFj86V9au6Mb62xyHrlFXhKSlheRBT2GBwQlWNs3x4thp2Mp0v+gVlx+dJfjOiDhVkKst98C4qrLJ2IKBwxOCCqIP6Si9G3S4raOVF7ZJZEj0aDR6MGYMPuDOR99jknRyKisMbggKgCjV6PpP/7P4xMNuBO60Zful2jw91Rg7Br+VpOjkREYY3BAVFVX4zISCTdNA3nRRXhcttOv9kTp0edjP1zFqB48WKWHRGFJQYHRNXQx8cjado0/J+yD6Mch3zpB3QWPBA1EHk//ABPaSnLj4jCDoMDoqMwtm6FZtddhwdsG9Dfme1L36hPwE6HEbZt21l+RBR2GBwQHUNE715ofv65eLR0jV/6Xm00XBll0y0TEYULBgdENWA57TTEKw608JQ1I6RpI+HKzGT5EVHYYXBAVAManQ76Zs3Q2l3iN3uik8EBEYUhBgdENaRvkYy2nmLf/X1aC1yH0znnARGFHQYHRDVkaJGC9u6y4GC/1ByUlsJTUMAyJKKwwuCAqIYMLVPQwV3ku+/Q6JCmjYLjYBrLkIjCCoMDohoytGmDzu5Cv7Qdulg4Uw+wDIkorDA4IKohQ4sWiDbAr1PiFn0c7Lv3sAyJKKwwOCCqxZoLhjZt0dud60tbq0+EfdcuKG43y5GIwgaDA6JaMHXtgv6uHN/9XbpY5No9cOzbx3IkorDB4ICoFszdu+PEctMoixX6ZihZupTlSERhg8EBUS2YOnZEC70bHcp1THwrojvSl6+CddNmliURhQUGB0S1oDEaEXHiAFxoL2tGyNJGYJa5B/I+/wweu53lSUQhj8EBUS3Fjh+PszUZGOQsW1fhZ1M7rM1XUDRnDsuTiEIegwOiWpI1FhIuvADTrRthUspGKbwa0QuFCxbCXeg/FwIRUahhcEBUB1HDh6NDx5a4yrbDl7ZVH4cl7jgU/fEHy5SIQhqDA6I60Gg0iLv4Ylxo34skj82X/rG5CwoX/wlXXh7LlYhCFoMDojoytmmDuAEn4DLbLr/ag8VKAoc2ElFIY3BAdBxizjwD4x2pSChXe7DQkILSNWu4lDMRhSwGB0THW3vQvTPOdBz0pS0ztED+4Ww49+9n2RJRSGJwQHScooYMxemOsmWb7RodFhhbomT5cpYtEYUkBgdExymi/wnoZHSimyvflzbX2Aoly5ZxWCMRhSQGB0TH+yUyGhE5YADOKNe0sEGfiHlohuxZb0BxOlnGRBRSGBwQ1YPIwSdjtPOQ36RIT0T2x6YDOShdvYZlTEQhhcEB0XFSPB4oViviFQcuse/2pbs0WvylT4Zt21aWMRGFFH2gM0AUytzFJch5800c2JWK783d8am5s9/2Tu5CGFr0Clj+iIjqgsEB0XHI//prLNhbgAdjToNTo/Pb1t+ZjeHaPESefBLLmIhCCpsViOrIcTAN2StW4anIfpUCg+HOdDxZsgoJEydCHx/PMiaikMKaA6I6Klm6VJ3PIF9r8qXFeBx4qHQtBmvyEX/l5YgafDLLl4hCDoMDojpy7N2DNfpE332z4sLPhb8jeshgxJ57LnRxcSxbIgpJDA6I6khriUZkpst3v427RG2nS5gyhWVKRCGNfQ6I6khj0MOilAUHO/WxvqGNREShjMEBUR1JEJCrKetvIFK1UbCuW8cyJaKQxuCAqI70zZphpPOwX9oqfRKcqaksUyIKaQwOiI5jNcaTXFl+adGKExqTf20CEVGoYYdEojpyHkqr1KyQqNhRunIVtNHR0MXEwNSpE7SRkSxjIgopDA6oySldswaFv82BuVdPRPTtB1PHDnV6Huv69VhuaO6XJkMbnRm50Hw+BymeUrQ1AwlXTkFE3771lHsioobH4ICaBI/NhtLVq5H38SfI0xjxiakzOi7YjJFzF6DZCb2RcMXltb7CN3ftii7r9vilfWDu6nd/lCMN9856G22m3YCI3lxjgYhCA4MDClvu/HxYN26EY+8+lKxejR0uE36K6I0fTe19+7zhsePejetx2quvofld06HRaGr8/MZOndHOXawu02yvMH2y1wJjK8gzPvHll4jo/Vi9vC8ioobG4IDCjruwEHlffoniNWuxQRuPzfp4LDEMxJaIymscyNTHD0WdiF/2/I6EQ4dgaNWqxq9jaNUSsSlJeCFzOb4ydcQSQwt4qgguNunj4c7fdNzvi4iosTA4oJDnysuDdc0a2LZtU2sJPMXFmG9IwWvRo5CljTjm4x0aHRSZt0D+qcVSzYW//grH4XTodHG4xrYdt1o34zbLYBzQWfz27eIuhC4hoS5vjYgoIBgcUEjy2O2wb9uGkr/+QtGGTVijS8BKfTMc1HXHwego7NNFV/k4Wf/ApvH/2I90HEYk3GpNQE04MzKQ8eRMbHRF4CXLcGzXV7+GQnOPFVOtWxF1xrhavkMiosBhcBCC7Lt2Ie/Lr+ApLISxY0fEjB8PY+uy6nBFUWrVdh4qPKWlcKSmonjBAlg3b0ahW4ufjG3xXfRpR60hsHgc6tX7cFcGJtgPYFLMacjVmn3bz3fsQ+y559SozErXrEXOW2/hXXNXfBDt3/mwPI2iqKszjnCmI3HUSESPGVOHd0xEFBgMDkKInBjzv/kW9u3bfWnWtWth3bgByffcA/uOHShe/CfcRYWIPOEExE+aBI3R2KB5kkDEuX8/nJmZ0EVHw9S9e70GJu6CAhTOmasOG3Tn5qJAY8Cvxjb4JvLUYzYZ6BQPpls34gzHQZgS42Fs3Rql691wq10Ey/R35SBq+PBj5iXjqadRum8/Lo4ZjcxjvPZVth0Y4zyEFo8+AkNycg3fLRFRcGBwECLse/Yi68UXoDjLFvrxcbmRMeNJHNBGYVZED+TozLjpn8042fYBkq7/P99Vt8z5L8GCqXPnKpcTdhcVqcGFffcuKKVWmLp0hqlLF2gMBti2boNj3z71/xEnDoAhpSVsGzfAunETctMysFkXh47uIrTt3RmJ110HbT0EJdKXIP2JGfjDEYvZxi7YEhuHEo2h2v0TPDYke6xwQYue7nxcZN+Dzm2SkPh/j0Of+O/SyhkzZ2JoZiZ+M7VR7yd6bP8GC273UfOS9dprOLA/AxPjxlfa1tuVCze02HqkeeFm62ZcZN+LFg8/xMCAiEISg4MQUTR/XtWBwRH/3959QEdVdXsA35NMeiMJLZAAJnQCiCAtFHkEooT2fAIPReqHwGIpXT8QZEkxFD99qFRBwAWI0pReREE6RIp0QlVC6Eh6mZnz1t4649w0Uib9/1trCHPntjkzc+++5+x7zk6HqvSxayPLLXX/dnuRVp/eR66nTpHxyZ/05Lvv6Df7v5LiGuqekkfzFuTRuRM5VK4sV/1xP/5ICUeO0lFVjnY7+pOBXKlpTBQ1/ukY6clEv+l9ZNwAD2WgHpd+IF+VTMf1FaQToP2eDWW73J4/5+IJarV4CZUfMZx0+vx9vWK3b6ftqd70kdvz2c7nZ0ykEckXqV1aDPG7t3N1Ib2fH3l06EMuTZpo9sOxRg1qeueaJTh4ZOdMp/S+5HPgAHl165blNpLPnqNe5bpqptkpRe8knaf/Sb2pmc4Blc+A6aQvXz6P7xwAoAwHBwsXLpTHzZt/HVwbNGhAH3zwAb3yyitZLrNu3TqaMmWKLFOrVi2aPXs2denShUo7U3xClq9ds/OgCNfnNbfRxdk50pfOdejdxUsokexphEc7um7vKa9VN8bR/0Zep86Hp5MjmSiNdLTXoQp949zKMg/72THzBL2NVv0EWONEv/fcXqR5l47QC8uXk++QIaSzy9vwHSo1lRIjI2mTU7NMX29seCT5AwGmBKqjiyePxo3Iu9c7mdaIWNM5u1BNY6xm2gM7ZzIlJWW9L1nUKvRLuSqBgd/MGXI3gkpLs0mNCQBAmQ4O/P39adasWXKS57brlStXUo8ePejUqVMSKKR3+PBh6tu3L0VERFDXrl1pzZo11LNnTzp58iQFBwdTaZbdSW+LU7VM76/f5ehPLxgeSVODdRv5LXsPmu3aWIKHKqZEirFzlStoW0jS6Wm8Wwv64tRhCl61mrzf7JenHATOMbieoqeLnv+874aGx9Q95RbVMT6lIBdFriEvStMHJ2XqvTP2YZAZU1ys9Dtg7YHOmeJ++lnyG9JuR5ND5UqSO8FNDaaEBEqJiqKbdtrbE9l6pxqSW6Bzcpb3WND5HQAAhUWn+KxcjPj4+NDcuXNpyJAhGV7r06cPJSQk0NatWy3TWrZsSc8//zwtWrQoR+uPjY0lLy8vevr0KXl6/nOVXNw9XrWaEg4ezPQ1vq69ZedB5/Xl6IadB61zDszXtrxMqeShUiVoMOr+ufKvYkyQIMNgNY1rIV40PKRbdu50wqGCZTq35S+IP0x1OrYmr1dfzXWA8OCzz+jT64rWONeU547KSN/H7qGKjeqTa/Pm5NKwYZ5Oxg8XLqTZVwy0zikwQ97Af6XG0H07Z3rOFCdlwP0fxOocZHCl9U7PUaydY4Ychw2xeykgYmaOgxMAgKKSm/Nfsck5MBqN0mTAJ/9WrVplOs+RI0do7NixmmlhYWH0/fffU2lnSkrM8jVuZw80xVFgapx05nPQoRLF2LtlmK+R4ZFk5nNPftbNB2bS3JBynTqnRktzQzzp6Ya9B9mRkhoGb5VKcToHumBfjgykk5NoVXuDtPEbnsbSHJdGtNWpmqyLayLGuLWg+T8eoCAXF/LMRdMPJ1/GX7hEuzw7WqbxLYHelXzJd/jwfN0N4VSnLnU8tztDcHBO7yOPnPI3JtCEpN/IvVEwAgMAKHWKPDg4e/asBAPJycnk7u5OmzZtovr162c67927d6lSutvC+DlPz0oKd5aTkqKJnEoilU2buDU+bYalRdMK+9qaxLmhyZfojZRr8voQwzU6Sr60xjmIztp7U7DxCfVJvk4h9PDvRMXBpK9UidJu36bq9+4R2dmRfTlvcqwWINOq/fEHkclE+ooVpUrfzslJ+l6YMO8zStTp6ae/cxXu2LvRWPcW9MWWneS5eQs5BAQ8+30a0sgQc5dWOtfWNHW8knqb3FqG5Ps2SbeQ1tTgu+9oUdxB+sQlmK5k04FRZgKNsdQ3+RqFmu5RubYhVO7VV/O1PwAAxVGRBwd16tSh06dPSzXH+vXracCAAbR///4sA4Tc4vyEDz/8kEo6TtDLqYHGm+SSZKBj+orkSgbqnXydXvTVU/kRH5CDn5+MPRD2888U8ssBSnuaQA5ubuTWsQ15dHhJk9vgGBAgD2uc7c+P9Pj2yIrDhtHkRYsoQaenY38PZXzD3pPCvcKoVdo9snucsxasp+6Bmqv48qZkamZ8SG4tW1B+cSDj/8Xn5LljBy3btl2SNbc5VqOfHP0yrTlwVWnkrIwUZIyjrqm/U4e0GHJt+gKV++/huBsBAEqtYpdzEBoaSkFBQbR48eIMr1WrVk2aFUaPHm2ZNnXqVGlWOHPmTI5rDgICAkpczsG92XMo9caNbOex9/Kk8m+/Lf+P27WLUm/eIp2DXm7n8+jcWU6M1vij55ELOSCwVcdFPCxy9NLlNM6tOf2m/6tvgfww9zTY/fkqcveDrXHfDXH79lHi0WPyPIXsJNfCS6WSu0ojB2moIbL39SHXJk3IvWNHNCMAQIlUInMOzEwmk+Zkbo2bH/bu3asJDvbs2ZNljgJzcnKSR0mnjBn7OHAMCiSvrl3lBMcneOeGDcne/a+s+pycSDkgsHUinWvTpuSXlEyzV62ld9xbUZTeK8/r4uaQiYmn6WVvg/T2WBC4FsR34EDyGTCATAmJZLh/n6omJJC9hzvZubnJgxMf89tnAwBASVKkR7yJEydKnwZcIxAXFye3Ju7bt4927dolr/fv35+qVq0qTQNs1KhR1L59e/rPf/5D4eHhtHbtWoqMjKQlS5ZQacf30KfHJy3nevXkUZy4twmhqkmJ9H8bt9BqpyDpRyDX61AG6px6m5pU8aAKI8eQnasrFSQOlOzd3cje/bkC3Q4AQElQpMHB/fv3JQCIiYmRqo5GjRpJYNCpUyd5/ffffyc7q050WrduLQHE5MmTadKkSdI/AjcplPY+DphKyZhzUJw73PHs1IkCK1emsUePkik2LtfL8x0QTrVDya1t22L9PgEASqNil3NQ0EpqPwfR48ZLhzzWXF98kXyHDC6yfQIAgNJ5/stb37ZQLO5W0JWCXAoAACh+EByUAMpgyDznwAnV7QAAYHsIDkoAU3Lmd28UdJIeAACUTQgOCpgymSj1drTcbpjX9A6VRdfJdi7/DKYEAABgK7h5uwClRUfTgwULyPjosWY6jySojCbuheifh1B/BRD81Go6ryczyDkAAICCgOCggBjj4uj+/80jU1zG2/hSoq7aZBt2zrYZZhkAAMAaggMbM8Yn0JNVqyjp9GkqaDonBAcAAGB7CA5siJsEHi1ZQilXrlBhcKj01+BGAAAAtoSERBtKOHCg0AIDHkxJX6FCoWwLAADKFtQc2KiDoqdbtlDcnh9zvIxj9epE3DU0j4b494CIMjKijI5omfD3878n6XTSlbBjzZrk0aGDLXYdAAAgAwQHNrhVkRMPU69fz/Eylad9SA4V0SQAAADFE4KDfEo+dy7HgYFX927kERoqoykCAAAUVwgO8in1xo0czee/cMFfzQYAAADFHIKDfEq7ey/b1+19fKj8sLcQGAAAQImB4CCfTHGxmZSqPVWeMoVUmoEcqviRjhMPAQAASggEB/ns1yDl6rUM0x0qViKHSpXys2oAAIAig0vafEg8ejTT6aaEhPysFgAAoEghOMhHrcHTrVszL1Q3t/x8JgAAAEUKwUEemeLjM4y2aObWJiQ/nwkAAECRQnCQRyolJdPpnIDojt4LAQCgBENwkEf2Xl5yV0KGAnVzw22LAABQoiE4yCOdgwO5t2lDDv7+mumpN2+RMhpt8dkAAAAUCQQH+eDVvTuVHzFck4Co0tJIJSfb4rMBAAAoEggO8lN4rq6k9/Uln0GDLKMn2nl6kM7V1VafDwAAQKFDcGADLsENyLNruPzfKzwcOQcAAFCioYdEG/Hs0kV6RXRp2tRWqwQAACgSCA5shEdcdG3WzFarAwAAKDJoVgAAAAANBAcAAACggeAAAAAANBAcAAAAgAaCAwAAANBAcAAAAAAaCA4AAABAA8EBAAAAaCA4AAAAAA0EBwAAAKCB4AAAAAA0EBwAAACABoIDAAAA0EBwAAAAABoIDgAAAEADwQEAAABoIDgAAAAADQQHAAAAoIHgAAAAADQQHAAAAIAGggMAAADQQHAAAAAAGggOAAAAQAPBAQAAAGggOAAAAAANBAcAAACggeAAAAAANPRUxiil5G9sbGxR7woAAEChMZ/3zOfB7JS54CAuLk7+BgQEFPWuAAAAFMl50MvLK9t5dConIUQpYjKZ6M6dO+Th4UE6na5IIjcOTP744w/y9PQs9O2XVSh3lHtZgu87yj0zfLrnwKBKlSpkZ5d9VkGZqzngAvH39y/q3ZDAAMEByr2swPcd5V6WeBbj4/uzagzMkJAIAAAAGggOAAAAQAPBQSFzcnKiqVOnyl9AuZd2+L6j3MsSp1J0fC9zCYkAAACQPdQcAAAAgAaCAwAAANBAcAAAAAAaCA5sLDo6mvr160e+vr7k4uJCDRs2pMjIyGyXSUlJoffff5+qV68uiSw1atSgr776yta7VqrlpdxXr15NjRs3JldXV/Lz86PBgwfTo0ePCm2fSzr+nnJHYukfI0eOzHKZdevWUd26dcnZ2Vk+o+3btxfqPpfFcv/yyy+pbdu25O3tLY/Q0FA6fvx4oe93Wf3Om61du1bm7dmzJ5UEZa4TpIL05MkTCgkJoQ4dOtCOHTuoQoUKFBUVJT/I7PTu3Zvu3btHy5Yto5o1a1JMTIz05AgFV+6HDh2i/v3706effkrdunWT4GL48OE0dOhQ2rhxI4o+B06cOEFGo9Hy/Ny5c9SpUyfq1atXpvMfPnyY+vbtSxEREdS1a1das2aNHChPnjxJwcHBKPMCKvd9+/ZJubdu3VqCstmzZ1Pnzp3p/PnzVLVqVZR7AZa92c2bN2n8+PESpJUYfLcC2MZ7772n2rRpk6tlduzYoby8vNSjR4/wMRRiuc+dO1cFBgZqpn322WeqatWq+BzyaNSoUSooKEiZTKZMX+/du7cKDw/XTGvRooUaNmwYyrwAyz09g8GgPDw81MqVK1HuhVD2BoNBtW7dWi1dulQNGDBA9ejRo0SUO5oVbGjz5s3UrFkziSIrVqxITZo0kSq9nCwzZ84cieJr164tEWZSUpItd61Uy0u5t2rVSsa34GptvpuXa27Wr19PXbp0KbT9Lk1SU1Np1apV0jST1ZglR44ckSpta2FhYTIdCq7c00tMTKS0tDTy8fFBsRdC2U+bNk2OS0OGDClZ5V3U0Ulp4uTkJI+JEyeqkydPqsWLFytnZ2e1YsWKLJcJCwuTZfiK6tixY2rbtm2qevXqauDAgYW672Wt3Nl3332n3N3dlV6v574+VLdu3VRqamqh7Xdp8u233yp7e3sVHR2d5TwODg5qzZo1mmnz589XFStWLIQ9LLvlnt6IESOk1iwpKalA9620+zYHZX/gwAGpjXzw4IE8L0k1BwgObIgPfq1atdJMe/vtt1XLli2zXKZTp05yIvvzzz8t0zZs2KB0Op1KTEy05e6VWnkp9/Pnzys/Pz81Z84cdebMGbVz507VsGFDNXjw4ELY49Knc+fOqmvXrtnOg+CgaMrdWkREhPL29pbvPBRs2cfGxqoaNWqo7du3W6aVpOAACYk2xBnv9evX10yrV68ebdiwIdtluDnBeqQsXoYDt9u3b1OtWrVsuYulUl7KnZPiOIlxwoQJ8rxRo0bk5uYmCUMzZsyQdULO3Lp1i3788cdnJnJWrlxZmm+s8XOeDgVX7mYff/wxzZo1S5bh7zsUbNlfu3ZNEhE54dnMnGiu1+vp8uXLFBQUVGw/BuQc2BCfbPgDt3blyhW5RTG7Ze7cuUPx8fGaZYrL0NKltdy53TX9eOb29vbyFz2K587y5culTTU8PPyZeR579+7VTNuzZ49Mh4Ird8Y5TdOnT6edO3dKfg4UfNnXrVuXzp49S6dPn7Y8unfvLndV8f8DAgKK98dQ1FUXpcnx48el/XrmzJkqKipKrV69Wrm6uqpVq1ZZ5vn3v/+t3nzzTcvzuLg45e/vr1577TWp6t6/f7+qVauW+te//lVE76JslPvy5ctlmQULFqhr166pgwcPqmbNmqnmzZsX0bsomYxGo6pWrZrcMZIelzeXu9mhQ4ekzD/++GN18eJFNXXqVGlqOHv2bCHvddkq91mzZilHR0e1fv16FRMTY3nwsQcKtuzTK0nNCggObGzLli0qODhYEuTq1q2rlixZkuHL0b59e800PlCGhoYqFxcXCRTGjh2LfINCKHe+dbF+/fpS7px/8MYbb6jbt2/ndtNl2q5duySZ8/Llyxle4/Lmck+fBFq7dm05WTVo0EAScKFgy50TnHne9A8OzqBgy74kBwcYlREAAAA0kHMAAAAAGggOAAAAQAPBAQAAAGggOAAAAAANBAcAAACggeAAAAAANBAcAAAAgAaCAwAAANBAcAAAQCTjPvCAXUajMc/lkZqaSjVq1KDIyEiUKeTaL7/8IgM1ValShXQ6HX3//fe5Xgf3fMyDbNWuXZucnJxkYL+ZM2fmej0IDgCKiYEDB8oBIf3j5ZdftszDJx7zdB5F8oUXXqB169ZpBpSaOHGijPbm7OxMFSpUoPbt29MPP/yg2dbVq1dp8ODBVK1aNcsBpGPHjrR69WoyGAzZ7mdKSgq9//77MrAVL8v79NVXX1leT0tLo2nTpln2oXHjxjLgj7WFCxfKyICenp7y4MGXduzYoZln2LBhsg4XFxd5Hz169KBLly5luV8JCQky/9ixYzXTeWQ83saXX36Z7ft69913afLkyZYBuPLC0dGRxo8fT++9916e1wFlV0JCgvxe5s+fn+d1jBo1ipYuXSoBAv9eNm/eTM2bN8/9ioq6/2YA+Kff9ZdfflkzOA4/Hj9+rOknf9q0aTKd+3Z/6623lE6nk0GNzAO/8NgFPGbBjRs3VGRkpIwhsWzZMss6jh07pjw8PFTLli3V5s2b1ZUrV+SxZs0aFRISok6fPp3tR9K9e3fVokULtWfPHtnG4cOHZeAqs3fffVdVqVJF9oEHteLBrZydndXJkyct8/B2+XXeLr+PSZMmySBM586ds8yzePFiGYiMt/Hrr7+qbt26qYCAAGUwGLLcN56fB3f65Zdf5LnJZFIvvfSSlGt2Dhw4oLy8vFRSUlK+v478efHYEdbvBSC3+PS8adMmzbTk5GQ1btw4+X3x4HI8UNzPP/9sef3ChQvy/b906VL+t5/vNQCATeRkUBYODj799FPL87S0NDlImEeC4xPcihUrslyeT5b16tVTTZs2ldHlsponKzt27JBtPHr0KMt5eBCrL774QjPt1VdflYGtsuPt7a2WLl2a5etnzpyRA+bVq1ezXc+YMWNUUFCQio+Pl7IqV67cMwfUGjlypIyMao0HJmrcuLEEVhyUuLm5qREjRkhwMnv2bFWpUiVVoUIFNWPGjAzr69Chg5o8eXK22wTIbXDAo/W2bt1agl/+HcydO1cGm+Mgm/H3ki8OeOTTGjVqyPFiyJAh2f5es4JmBYASTK/Xk4ODg7R1s8qVK9P27dspLi4u0/l5HPmLFy9K1bedXeY/f26yMHvppZekucOMqyibNWtGc+bMkaYIbtfkdSUlJWmaHbg5wRo3DRw8eDDT7XEb/9q1a6VKlZsXMsOvLV++nJ577jkKCAjItky4fZXLpV+/fjRp0iT6/PPPZV+zc+DAAXlf6V27dk2aO7hZ5JtvvqFly5ZReHg43b59m/bv30+zZ8+Wpohjx45pluNqXF4ngK38/vvv8hvgZsS2bdtKExr/9tq0aSPT2fXr1+nWrVsyz9dff00rVqygX3/9lV577bXcbzDX4QQAFFjNgb29vVyhWj9mzpyZac1BSkqK+uijj+QKY+vWrZZqdR72m6vomzVrpkaPHq2p8l+7dq3Mb13Ff+/ePc325s+fn+X49GFhYXKlEh4eLs0T3DTA+zRw4EDLPH379pWhsPlqhmsndu/eLcNic1W7td9++022x++ZayMyG76Z94Xn4X2uU6fOM2sNzHbu3CnLvPLKKzman7f/9ddfZ6g54FqZ2NhYzfvnKzLrWhfer4iICM2y8+bNk/kAbFVzwL9xnpb++MDNCL1795Z5hg4dmmE4aW6S42m5bWrQ2yysAYB869ChgyTrWfPx8dE852Q3vlpNTk4md3d3mjVrllzNsnbt2snVw9GjR+nw4cOSgT9v3jz68MMPacqUKZlu09fXV2oUzDUF5loIxlcf1kwmk9QscOKil5eXTPvkk0/kymTBggVSQ8DbGzp0KNWtW1fm5SucQYMGaZIWWZ06dWS7T58+pfXr19OAAQPkarx+/fqWed544w3q1KkTxcTESIJV79696dChQxlqJtLjK3xXV1c6e/asrN+8r1nhmo/M1snJlh4eHpbnlSpVkoRF61oXnnb//n3NclwOnBwKYCvx8fHy3eOagPRJs3wcYH5+flJrxjV6ZnwHjrnmgX9zOYVmBYBihO9AqFmzpuaRPjiYMGGCnFS5avvJkycZMuO5mYGrHXn67t275c6B6dOny0m/Vq1aMs/ly5ct8/OBxrwtPrBkhw8+XEVvfbLlgw9f6PD+ML6zgG/B4qYAruLkjGk+eAUGBmbI7OdtNm3alCIiIiRLmwMLa7wd3mcOejiA4HVt2rQp23389ttvaevWrRIc8Yl9zJgx9Czly5eXskyPy9IaBzuZTeOgydrjx4+lHABspUmTJtIEx4Fo+mMENyeykJAQuduIm8PMrly5In/57qLcQHAAUMLwicx8QLDOD8gKX4nzAYNrGvgAw1f0fBWe/oSWE3zwuXPnjlzFWB98+Era399fMy9fiXMgwdvesGGD3IqYHd4fzlfIyt8J1NnOc+/ePRo5ciTNmDFDgg1uc+Xaj/S3SabH5XLhwgWylXPnzsk6AXKDf1cc+Jtr8m7cuCH/56t+rg3gmrT+/fvTxo0b5bXjx49LYL1t2zaZPzQ0VG5v5tuUT506JbUMfEsw175Z1ybkBIIDgGKET3x3797VPB4+fJjj5blZYPHixXJQ4Pv7OTmRk/K4uYLv9edggpOXuOaAT/ScYBgVFSUnxkWLFtGDBw80VZZ8IOJ+E8xef/11aYbgZgJehjtt4ZoMPhhxVTrj5Dw+eHHzBiflcT8NfOLnfgTMeJ28LO8jV/3z83379snBj/GyfNDj98EHRq4F6NWrl2yjS5cuWb7/t956S2oyRo8ebUkM5P3j6dy8kJWwsLAsEybzgt93586dbbY+KBsiIyMlqDQHltxnB///gw8+kOf82+Xf5Lhx46SJoGfPnnTixAnpr4RxkL5lyxa5gODaNm5u5N8DJ/zmWp6zJQDA5gmJ/JNM/+CEt6xuZUyPExRbtWqlfHx8pG+BwMBA9c4776iHDx9q5uOEJd4eJy9yQhMn5LVr1076FuDbI83at28v81m7ePGiCg0NlSRDXn7s2LEqMTHR8vq+ffvkdklOXPT19ZWkxujoaM06Bg8eLO+FkxT5dsCOHTtK4qIZz8/JhBUrVpTkSt7O66+/nm1S1cqVKyWBMCoqSjOdEzeDg4PVoEGDslyWb/Xi8rJev/lWxmfdbsplNGrUKMtz7veBb5+0LhOAkkbH/9g29gEAKHm4hiE2NlZqXvKjT58+0qTBNTYAJRWaFQAAiCxdQuclF8OMkz4bNmyYoyRIgOIMNQcAAACggZoDAAAA0EBwAAAAABoIDgAAAEADwQEAAABoIDgAAAAADQQHAAAAoIHgAAAAADQQHAAAAIAGggMAAADQQHAAAAAAZO3/AQzgfd1cFdPgAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -965,10 +1502,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "ab9fe914", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Crosswalk: 376 rows, 14 columns\n", + "\n", + "match_class distribution:\n", + "match_class\n", + "match 169\n", + "geometric_disagreement 100\n", + "review 45\n", + "unmatched_lsib 38\n", + "unmatched_overture 19\n", + "unmatched 5\n", + "Name: count, dtype: int64\n" + ] + } + ], "source": [ "# Build the output table from `scored` plus the unmatched rows\n", "output_rows = []\n", @@ -1032,10 +1587,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "4f85f981", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wrote output/lsib_overture_crosswalk_demo.parquet (53.8 KB)\n", + "Wrote output/lsib_overture_crosswalk_demo.csv (71.5 KB)\n", + "Read-back OK.\n" + ] + } + ], "source": [ "# Write to Parquet and CSV\n", "out_path_parquet = Path(\"./output/lsib_overture_crosswalk_demo.parquet\")\n", @@ -1076,10 +1641,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "beae6744", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wrote output/lsib_overture_examples.geojson (2735.6 KB)\n", + " 17 features across 6 country pairs\n", + " Upload to kepler.gl, then filter or color by `pair_key`, `source`, or `match_class`.\n" + ] + } + ], "source": [ "# Export the six example pairs as a single GeoJSON for kepler.gl\n", "# (https://kepler.gl) or any other GeoJSON-capable tool.\n", @@ -1157,6 +1732,22 @@ " both sides' metadata in the output so downstream users can read the\n", " findings in context." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3350668b-3280-4587-a93f-d562c5615bd9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56c6b763-02d3-4636-acfc-41aa535a1f1a", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/4-buildings-matching.ipynb b/notebooks/4-buildings-matching.ipynb index ace2b9a..4220a6a 100644 --- a/notebooks/4-buildings-matching.ipynb +++ b/notebooks/4-buildings-matching.ipynb @@ -346,8 +346,8 @@ "## Compare MGCP and Overture polygon coverage\n", "\n", "Side by side, here's what's in the demo cell from each source. The two\n", - "datasets break down naturally along different axes \u2014 Overture by theme and\n", - "type, MGCP by feature code \u2014 so we look at each on its own terms before\n", + "datasets break down naturally along different axes — Overture by theme and\n", + "type, MGCP by feature code — so we look at each on its own terms before\n", "comparing." ] }, @@ -393,7 +393,7 @@ "source": [ "### A note on density\n", "\n", - "A 1\u00b0 \u00d7 1\u00b0 cell over the Bahamas is mostly ocean, and MGCP captures at\n", + "A 1° × 1° cell over the Bahamas is mostly ocean, and MGCP captures at\n", "1:100K. The lesson's \"Demo data\" section discusses why feature density\n", "here is much lower than what you'd see from a dense ML-derived dataset.\n" ] @@ -427,7 +427,7 @@ "id": "360cb72e", "metadata": {}, "source": [ - "The points total is meaningfully larger than the polygons total \u2014 a hint\n", + "The points total is meaningfully larger than the polygons total — a hint\n", "that the bulk of MGCP's feature coverage in this cell is captured as\n", "points, not polygons. Matching points to Overture polygons is a different\n", "methodology (point-in-polygon) and out of scope for this demo, but it's\n", @@ -441,7 +441,7 @@ "source": [ "## Schema comparison: MGCP buildings vs. Overture buildings\n", "\n", - "We focus on the `MGCP AL015 (Building)` \u2194 `Overture buildings/building`\n", + "We focus on the `MGCP AL015 (Building)` ↔ `Overture buildings/building`\n", "pair: the most central case. The matching pipeline produces a link\n", "between identifiers; attributes stay on whichever side captured them.\n", "The comparison below orients downstream users on what each side has.\n", @@ -479,22 +479,22 @@ "mgcp_buildings_schema = pd.DataFrame([\n", " (\"UID\", \"100%\", \"MGCP Feature universally unique identifier (UUID per ISO/IEC 9834-8)\"),\n", " (\"FCODE\", \"100%\", \"Feature code (always 'AL015' for buildings in this shapefile)\"),\n", - " (\"FUN\", \"100%\", \"Functional Use \u2014 the general categories of function or use that a facility or site serves\"),\n", + " (\"FUN\", \"100%\", \"Functional Use — the general categories of function or use that a facility or site serves\"),\n", " (\"WID\", \"100%\", \"Width perpendicular to the feature's primary alignment, in meters\"),\n", - " (\"ACC\", \"100%\", \"Horizontal Accuracy Category \u2014 a general categorical evaluation of horizontal accuracy\"),\n", - " (\"ACE\", \"100%\", \"Absolute Horizontal Accuracy \u2014 circular error at 90% probability, in meters\"),\n", - " (\"SRC_DATE\", \"100%\", \"Source Date and Time \u2014 when the source data was collected\"),\n", - " (\"SRC_INFO\", \"100%\", \"Source Description \u2014 a description of the data set used\"),\n", + " (\"ACC\", \"100%\", \"Horizontal Accuracy Category — a general categorical evaluation of horizontal accuracy\"),\n", + " (\"ACE\", \"100%\", \"Absolute Horizontal Accuracy — circular error at 90% probability, in meters\"),\n", + " (\"SRC_DATE\", \"100%\", \"Source Date and Time — when the source data was collected\"),\n", + " (\"SRC_INFO\", \"100%\", \"Source Description — a description of the data set used\"),\n", " (\"CPYRT_NOTE\", \"100%\", \"Commercial Copyright Notice\"),\n", " (\"TIER_NOTE\", \"100%\", \"Commercial Distribution Restriction\"),\n", " (\"CIT\", \"28%\", \"Corrections Facility Type\"),\n", - " (\"PPO\", \"22%\", \"Product \u2014 principal product(s) of a production, mining, or agricultural activity\"),\n", + " (\"PPO\", \"22%\", \"Product — principal product(s) of a production, mining, or agricultural activity\"),\n", " (\"DDC\", \"21%\", \"Dwelling Type\"),\n", " (\"ICF\", \"14%\", \"Manufacturing Facility Type\"),\n", " (\"PAF\", \"14%\", \"Public Accommodation Facility Type\"),\n", - " (\"TXT\", \"11%\", \"Associated Text \u2014 narrative or other textual description\"),\n", + " (\"TXT\", \"11%\", \"Associated Text — narrative or other textual description\"),\n", " (\"NAM\", \"6%\", \"Name\"),\n", - " (\"HGT\", \"1%\", \"Height Above Surface Level \u2014 base-to-top height in meters\"),\n", + " (\"HGT\", \"1%\", \"Height Above Surface Level — base-to-top height in meters\"),\n", "], columns=[\"Field\", \"Populated\", \"Description\"])\n", "mgcp_buildings_schema" ] @@ -669,7 +669,7 @@ " \"iou\", \"centroid_contained\", \"tier\",\n", " ])\n", "\n", - " # sjoin keeps the left geometry. We need both \u2014 pull the right geometry\n", + " # sjoin keeps the left geometry. We need both — pull the right geometry\n", " # back in by joining on the index sjoin recorded.\n", " mgcp_geom = joined.geometry.reset_index(drop=True)\n", " ovt_geom = overture_gdf.geometry.iloc[joined[\"index_ovt\"].values].reset_index(drop=True)\n", @@ -769,11 +769,11 @@ "matters is the *pattern* of matches per MGCP polygon. We classify each\n", "MGCP polygon's match cardinality, separately per pass:\n", "\n", - "- **1:1** \u2014 one MGCP polygon, one Overture match\n", - "- **1:many** \u2014 one MGCP polygon, several Overture features\n", - "- **many:1** \u2014 multiple MGCP polygons matched the same Overture feature\n", - "- **1:0** \u2014 MGCP has it, Overture doesn't (this pass)\n", - "- **0:1** \u2014 Overture has it, MGCP doesn't (tracked separately;\n", + "- **1:1** — one MGCP polygon, one Overture match\n", + "- **1:many** — one MGCP polygon, several Overture features\n", + "- **many:1** — multiple MGCP polygons matched the same Overture feature\n", + "- **1:0** — MGCP has it, Overture doesn't (this pass)\n", + "- **0:1** — Overture has it, MGCP doesn't (tracked separately;\n", " not a property of any MGCP UID)\n", "\n", "See the lesson's \"Cardinality reporting\" section for what the unmatched\n", @@ -791,7 +791,7 @@ " \"\"\"Per (MGCP UID, pass) classification of match cardinality.\n", "\n", " Returns a long-form DataFrame with one row per (mgcp_uid, pass_name)\n", - " combination \u2014 including passes where the MGCP polygon found no match\n", + " combination — including passes where the MGCP polygon found no match\n", " (1:0 case). The 0:1 case (Overture features with no MGCP match) is\n", " summarized separately by the caller.\n", " \"\"\"\n", @@ -855,7 +855,7 @@ "\n", "per_pass_cardinality = classify_cardinality_per_pass(matches, mgcp_m, overture_m)\n", "print(f\"Cardinality rows: {len(per_pass_cardinality):,}\")\n", - "print(f\"({len(mgcp_m):,} MGCP polygons \u00d7 {len(overture_m)} passes)\")\n", + "print(f\"({len(mgcp_m):,} MGCP polygons × {len(overture_m)} passes)\")\n", "per_pass_cardinality.head(10)" ] }, @@ -867,7 +867,7 @@ "### Per-pass cardinality breakdown\n", "\n", "How does the cardinality distribute across passes? The shape of this table\n", - "is the diagnostic \u2014 different passes have very different signatures, and\n", + "is the diagnostic — different passes have very different signatures, and\n", "those differences drive different integration choices downstream." ] }, @@ -1123,6 +1123,7 @@ }, { "cell_type": "markdown", + "id": "855fdf3b", "metadata": {}, "source": [ "## GERS adoption decision matrix\n", @@ -1137,6 +1138,7 @@ { "cell_type": "code", "execution_count": null, + "id": "583ec8b5", "metadata": {}, "outputs": [], "source": [ @@ -1147,7 +1149,7 @@ "CLEAN_RATE_HIGH = 80 # clean_rate >= this counts as \"high clean\"\n", "MIN_SAMPLE = 5 # feature codes with fewer polygons than this are\n", " # flagged as \"insufficient sample\" rather than\n", - " # categorized \u2014 the rates are too noisy to trust.\n", + " # categorized — the rates are too noisy to trust.\n", "\n", "def classify_adoption(row):\n", " if row[\"total\"] < MIN_SAMPLE:\n", @@ -1170,6 +1172,7 @@ }, { "cell_type": "markdown", + "id": "1ffe607d", "metadata": {}, "source": [ "### Reading the matrix\n", @@ -1181,6 +1184,7 @@ }, { "cell_type": "markdown", + "id": "99b3ce25", "metadata": {}, "source": [ "## What the buildings result means\n", @@ -1196,6 +1200,7 @@ }, { "cell_type": "markdown", + "id": "15e96012", "metadata": {}, "source": [ "## Summary\n", @@ -1219,7 +1224,7 @@ "\n", "The methodology so far produces:\n", "\n", - "- A match table (`matches`) \u2014 one row per matched MGCP/Overture pair, with\n", + "- A match table (`matches`) — one row per matched MGCP/Overture pair, with\n", " IoU and tier.\n", "- A global cardinality classification per MGCP polygon.\n", "- A per-feature-code diagnostic showing match rate and clean rate.\n", @@ -1243,7 +1248,7 @@ "notebook_metadata_filter": "-all" }, "kernelspec": { - "display_name": "lsib", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1257,9 +1262,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.11" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +}