{ "cells": [ { "cell_type": "markdown", "id": "783d657e", "metadata": {}, "source": [ "# Usage scenarios\n", "\n", "These scenarios show complete `%%there ai` workflows: generated cells, remote\n", "state retrieval, file download and a `--fix` iteration." ] }, { "cell_type": "code", "execution_count": 1, "id": "4fc7152d", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:49.897418Z", "iopub.status.busy": "2026-06-08T18:49:49.897280Z", "iopub.status.idle": "2026-06-08T18:49:53.550841Z", "shell.execute_reply": "2026-06-08T18:49:53.549734Z" } }, "outputs": [], "source": [ "%load_ext pythonhere\n", "%connect-there" ] }, { "cell_type": "markdown", "id": "d5d3aa88", "metadata": {}, "source": [ "## App Usage Chart" ] }, { "cell_type": "code", "execution_count": 2, "id": "c84acc43", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:53.555850Z", "iopub.status.busy": "2026-06-08T18:49:53.555263Z", "iopub.status.idle": "2026-06-08T18:49:53.572912Z", "shell.execute_reply": "2026-06-08T18:49:53.572104Z" }, "tags": [ "remove-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "herethere AI generation is not configured. Set THERE_AI_MODEL. For hosted providers, also set THERE_AI_API_KEY. Optionally set THERE_AI_BASE_URL.\n" ] } ], "source": [ "%%there ai\n", "Show a chart of foreground app usage statistics in last 24 hours.\n", "Save the results in a `usage` variable and in a `usage.csv` file.\n", "Print instructions for drawing a usage pie chart locally with pandas and matplotlib.\n", "UI should be optimised for the Android Portrait mode." ] }, { "cell_type": "code", "execution_count": 3, "id": "561954a9", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:53.576349Z", "iopub.status.busy": "2026-06-08T18:49:53.576190Z", "iopub.status.idle": "2026-06-08T18:49:54.454331Z", "shell.execute_reply": "2026-06-08T18:49:54.453975Z" }, "tags": [ "hide-input" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "%there download usage.csv\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Local pie chart instructions with pandas and matplotlib:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1. Download usage.csv from this PythonHere session.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2. Put usage.csv in your local working directory.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "3. Run this code locally:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "import pandas as pd\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "import matplotlib.pyplot as plt\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "df = pd.read_csv(\"usage.csv\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "df = df[df[\"foreground_seconds\"] > 0].copy()\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "if df.empty:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " print(\"No usage rows found in usage.csv\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "else:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " top = df.sort_values(\"foreground_seconds\", ascending=False).head(10)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " other_seconds = df.loc[~df.index.isin(top.index), \"foreground_seconds\"].sum()\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " if other_seconds > 0:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " top = pd.concat([\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " top[[\"app_label\", \"foreground_seconds\"]],\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " pd.DataFrame([{\"app_label\": \"Other\", \"foreground_seconds\": other_seconds}]),\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " ], ignore_index=True)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " ax = top.set_index(\"app_label\")[\"foreground_seconds\"].plot.pie(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " autopct=\"%1.1f%%\",\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " startangle=90,\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " counterclock=False,\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " figsize=(7, 7),\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " )\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " ax.set_ylabel(\"\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " ax.set_title(\"Foreground app usage, last 24 hours\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " plt.tight_layout()\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " plt.show()\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "%%there\n", "# Generated locally by %%there ai. Review before running.\n", "from pathlib import Path\n", "from csv import DictWriter\n", "\n", "from jnius import autoclass\n", "from kivy.lang import Builder\n", "from kivy.logger import Logger\n", "from kivy.metrics import dp, sp\n", "from kivy.uix.boxlayout import BoxLayout\n", "from kivy.uix.label import Label\n", "from kivy.uix.progressbar import ProgressBar\n", "from kivy.uix.popup import Popup\n", "\n", "usage = []\n", "usage_status = {\n", " \"ok\": False,\n", " \"stage\": \"starting\",\n", " \"message\": \"Starting usage statistics view.\",\n", " \"error\": None,\n", "}\n", "usage_label_cache = globals().get(\"usage_label_cache\", {})\n", "usage_label_errors = []\n", "usage_csv_path = \"usage.csv\"\n", "\n", "\n", "def _show_usage_error_popup(message):\n", " content = Label(\n", " text=str(message),\n", " font_size=sp(15),\n", " halign=\"left\",\n", " valign=\"top\",\n", " text_size=(dp(300), None),\n", " )\n", " popup = Popup(\n", " title=\"Usage statistics error\",\n", " content=content,\n", " size_hint=(0.9, None),\n", " height=dp(240),\n", " )\n", " popup.open()\n", "\n", "\n", "def _format_duration(seconds):\n", " seconds = int(max(0, seconds))\n", " hours = seconds // 3600\n", " minutes = (seconds % 3600) // 60\n", " secs = seconds % 60\n", " if hours:\n", " return f\"{hours}h {minutes}m\"\n", " if minutes:\n", " return f\"{minutes}m {secs}s\"\n", " return f\"{secs}s\"\n", "\n", "\n", "def _get_android_context_and_activity():\n", " PythonActivity = autoclass(\"org.kivy.android.PythonActivity\")\n", " activity = PythonActivity.mActivity\n", " if activity is not None:\n", " return activity, activity\n", "\n", " try:\n", " PythonService = autoclass(\"org.kivy.android.PythonService\")\n", " service = PythonService.mService\n", " if service is not None:\n", " return service, None\n", " except Exception as exc:\n", " Logger.info(f\"PythonHere: PythonService fallback unavailable: {type(exc).__name__}: {exc}\")\n", "\n", " return None, None\n", "\n", "\n", "def _check_usage_access(context):\n", " VERSION = autoclass(\"android.os.Build$VERSION\")\n", " AppOpsManager = autoclass(\"android.app.AppOpsManager\")\n", " Context = autoclass(\"android.content.Context\")\n", "\n", " sdk_int = int(VERSION.SDK_INT)\n", " package_name = str(context.getPackageName())\n", " uid = int(context.getApplicationInfo().uid)\n", "\n", " app_ops_service = Context.APP_OPS_SERVICE or \"appops\"\n", " app_ops = context.getSystemService(app_ops_service)\n", " if app_ops is None:\n", " return {\n", " \"granted\": False,\n", " \"sdk_int\": sdk_int,\n", " \"package_name\": package_name,\n", " \"mode\": None,\n", " \"mode_name\": \"app_ops_unavailable\",\n", " \"error\": \"AppOps service is unavailable.\",\n", " }\n", "\n", " op_name = AppOpsManager.OPSTR_GET_USAGE_STATS or \"android:get_usage_stats\"\n", " mode = int(app_ops.checkOpNoThrow(op_name, uid, package_name))\n", "\n", " mode_names = {\n", " int(AppOpsManager.MODE_ALLOWED): \"allowed\",\n", " int(AppOpsManager.MODE_IGNORED): \"ignored\",\n", " int(AppOpsManager.MODE_DEFAULT): \"default\",\n", " int(AppOpsManager.MODE_ERRORED): \"errored\",\n", " }\n", " mode_foreground = getattr(AppOpsManager, \"MODE_FOREGROUND\", None)\n", " if mode_foreground is not None:\n", " mode_names[int(mode_foreground)] = \"foreground\"\n", "\n", " return {\n", " \"granted\": mode == int(AppOpsManager.MODE_ALLOWED),\n", " \"sdk_int\": sdk_int,\n", " \"package_name\": package_name,\n", " \"mode\": mode,\n", " \"mode_name\": mode_names.get(mode, str(mode)),\n", " \"error\": None,\n", " }\n", "\n", "\n", "def _resolve_app_label(package_manager, package_name, sdk_int, application_info_flags_class):\n", " if package_name in usage_label_cache:\n", " return usage_label_cache[package_name]\n", "\n", " try:\n", " if sdk_int >= 33 and application_info_flags_class is not None:\n", " app_info = package_manager.getApplicationInfo(\n", " package_name,\n", " application_info_flags_class.of(0),\n", " )\n", " else:\n", " app_info = package_manager.getApplicationInfo(package_name, 0)\n", " label = package_manager.getApplicationLabel(app_info)\n", " label_text = str(label) if label is not None else package_name\n", " except Exception as exc:\n", " label_text = package_name\n", " error_text = f\"{package_name}: {type(exc).__name__}: {exc}\"\n", " usage_label_errors.append(error_text)\n", " Logger.info(f\"PythonHere: Could not resolve app label: {error_text}\")\n", "\n", " usage_label_cache[package_name] = label_text\n", " return label_text\n", "\n", "\n", "def _write_usage_csv(rows):\n", " output_path = Path(usage_csv_path)\n", " fieldnames = [\n", " \"rank\",\n", " \"app_label\",\n", " \"package\",\n", " \"foreground_seconds\",\n", " \"foreground_minutes\",\n", " \"foreground_hours\",\n", " \"percent\",\n", " \"foreground_ms\",\n", " \"first_time_stamp_ms\",\n", " \"last_time_stamp_ms\",\n", " \"last_time_used_ms\",\n", " ]\n", " with output_path.open(\"w\", newline=\"\", encoding=\"utf-8\") as csv_file:\n", " writer = DictWriter(csv_file, fieldnames=fieldnames)\n", " writer.writeheader()\n", " for row in rows:\n", " writer.writerow({name: row.get(name, \"\") for name in fieldnames})\n", " return output_path.name\n", "\n", "\n", "def _load_usage_stats():\n", " context, activity = _get_android_context_and_activity()\n", " if context is None:\n", " output_name = _write_usage_csv([])\n", " return [], {\n", " \"ok\": False,\n", " \"stage\": \"android_context\",\n", " \"message\": \"Android context is unavailable. Usage statistics cannot be queried.\",\n", " \"error\": \"Android context is unavailable.\",\n", " \"output_path\": output_name,\n", " }\n", "\n", " access = _check_usage_access(context)\n", " end_ms = int(__import__(\"time\").time() * 1000)\n", " begin_ms = end_ms - (24 * 60 * 60 * 1000)\n", "\n", " if not access[\"granted\"]:\n", " output_name = _write_usage_csv([])\n", " return [], {\n", " \"ok\": False,\n", " \"stage\": \"usage_access\",\n", " \"message\": (\n", " \"Usage access is not enabled for this app. Tap Open Settings, \"\n", " \"enable usage access for this app if it is listed, return here, \"\n", " \"then tap Refresh. If the app is not listed, the manifest must \"\n", " \"declare android.permission.PACKAGE_USAGE_STATS.\"\n", " ),\n", " \"error\": None,\n", " \"access_granted\": False,\n", " \"app_ops_mode\": access[\"mode\"],\n", " \"app_ops_mode_name\": access[\"mode_name\"],\n", " \"sdk_int\": access[\"sdk_int\"],\n", " \"package_name\": access[\"package_name\"],\n", " \"window_start_ms\": begin_ms,\n", " \"window_end_ms\": end_ms,\n", " \"rows\": 0,\n", " \"output_path\": output_name,\n", " }\n", "\n", " VERSION = autoclass(\"android.os.Build$VERSION\")\n", " Context = autoclass(\"android.content.Context\")\n", " UsageStatsManager = autoclass(\"android.app.usage.UsageStatsManager\")\n", "\n", " sdk_int = int(VERSION.SDK_INT)\n", " usage_service = Context.USAGE_STATS_SERVICE or \"usagestats\"\n", " usage_manager = context.getSystemService(usage_service)\n", " if usage_manager is None:\n", " output_name = _write_usage_csv([])\n", " return [], {\n", " \"ok\": False,\n", " \"stage\": \"usage_manager\",\n", " \"message\": \"UsageStatsManager is unavailable on this device.\",\n", " \"error\": \"UsageStatsManager is unavailable.\",\n", " \"access_granted\": True,\n", " \"sdk_int\": sdk_int,\n", " \"window_start_ms\": begin_ms,\n", " \"window_end_ms\": end_ms,\n", " \"rows\": 0,\n", " \"output_path\": output_name,\n", " }\n", "\n", " package_manager = context.getPackageManager()\n", " application_info_flags_class = None\n", " if sdk_int >= 33:\n", " application_info_flags_class = autoclass(\"android.content.pm.PackageManager$ApplicationInfoFlags\")\n", "\n", " interval_daily = int(UsageStatsManager.INTERVAL_DAILY)\n", " stats_list = usage_manager.queryUsageStats(interval_daily, begin_ms, end_ms)\n", "\n", " aggregate = {}\n", " queried_count = 0\n", " if stats_list is not None:\n", " queried_count = int(stats_list.size())\n", " for index in range(queried_count):\n", " stat = stats_list.get(index)\n", " package_name = stat.getPackageName()\n", " if package_name is None:\n", " continue\n", " package_name = str(package_name)\n", "\n", " foreground_ms = int(stat.getTotalTimeInForeground())\n", " if foreground_ms <= 0:\n", " continue\n", "\n", " record = aggregate.setdefault(\n", " package_name,\n", " {\n", " \"package\": package_name,\n", " \"foreground_ms\": 0,\n", " \"first_time_stamp_ms\": None,\n", " \"last_time_stamp_ms\": None,\n", " \"last_time_used_ms\": None,\n", " },\n", " )\n", " record[\"foreground_ms\"] += foreground_ms\n", "\n", " first_ts = int(stat.getFirstTimeStamp())\n", " last_ts = int(stat.getLastTimeStamp())\n", " last_used = int(stat.getLastTimeUsed())\n", "\n", " if record[\"first_time_stamp_ms\"] is None or first_ts < record[\"first_time_stamp_ms\"]:\n", " record[\"first_time_stamp_ms\"] = first_ts\n", " if record[\"last_time_stamp_ms\"] is None or last_ts > record[\"last_time_stamp_ms\"]:\n", " record[\"last_time_stamp_ms\"] = last_ts\n", " if record[\"last_time_used_ms\"] is None or last_used > record[\"last_time_used_ms\"]:\n", " record[\"last_time_used_ms\"] = last_used\n", "\n", " total_ms = sum(item[\"foreground_ms\"] for item in aggregate.values())\n", " rows = []\n", " for package_name, item in aggregate.items():\n", " app_label = _resolve_app_label(\n", " package_manager,\n", " package_name,\n", " sdk_int,\n", " application_info_flags_class,\n", " )\n", " seconds = item[\"foreground_ms\"] / 1000.0\n", " rows.append(\n", " {\n", " \"app_label\": app_label,\n", " \"package\": package_name,\n", " \"foreground_seconds\": round(seconds, 3),\n", " \"foreground_minutes\": round(seconds / 60.0, 3),\n", " \"foreground_hours\": round(seconds / 3600.0, 4),\n", " \"percent\": round((item[\"foreground_ms\"] / total_ms * 100.0), 3) if total_ms else 0.0,\n", " \"foreground_ms\": int(item[\"foreground_ms\"]),\n", " \"first_time_stamp_ms\": item[\"first_time_stamp_ms\"],\n", " \"last_time_stamp_ms\": item[\"last_time_stamp_ms\"],\n", " \"last_time_used_ms\": item[\"last_time_used_ms\"],\n", " }\n", " )\n", "\n", " rows.sort(key=lambda item: item[\"foreground_ms\"], reverse=True)\n", " for rank, row in enumerate(rows, start=1):\n", " row[\"rank\"] = rank\n", " row[\"duration\"] = _format_duration(row[\"foreground_seconds\"])\n", "\n", " output_name = _write_usage_csv(rows)\n", " message = f\"Loaded {len(rows)} apps with foreground usage in the last 24 hours. Saved {output_name}.\"\n", " if not rows:\n", " message = (\n", " \"Usage access is enabled, but Android returned no foreground usage rows \"\n", " \"for the last 24 hours. The device may have no accessible records.\"\n", " )\n", "\n", " return rows, {\n", " \"ok\": True,\n", " \"stage\": \"complete\",\n", " \"message\": message,\n", " \"error\": None,\n", " \"access_granted\": True,\n", " \"app_ops_mode\": access[\"mode\"],\n", " \"app_ops_mode_name\": access[\"mode_name\"],\n", " \"sdk_int\": sdk_int,\n", " \"package_name\": access[\"package_name\"],\n", " \"window_start_ms\": begin_ms,\n", " \"window_end_ms\": end_ms,\n", " \"query_rows\": queried_count,\n", " \"rows\": len(rows),\n", " \"total_foreground_seconds\": round(total_ms / 1000.0, 3),\n", " \"output_path\": output_name,\n", " \"package_visibility_note\": (\n", " \"On Android 11 and newer, package label lookups can be affected by package visibility. \"\n", " \"UsageStats rows reflect accessible usage records.\"\n", " if sdk_int >= 30\n", " else \"\"\n", " ),\n", " \"label_errors\": list(usage_label_errors),\n", " }\n", "\n", "\n", "def _make_chart_row(row, max_seconds):\n", " container = BoxLayout(\n", " orientation=\"vertical\",\n", " size_hint_y=None,\n", " height=dp(82),\n", " padding=(0, dp(4), 0, dp(4)),\n", " spacing=dp(3),\n", " )\n", "\n", " header = BoxLayout(\n", " orientation=\"horizontal\",\n", " size_hint_y=None,\n", " height=dp(28),\n", " spacing=dp(8),\n", " )\n", "\n", " name_label = Label(\n", " text=f\"{row['rank']}. {row['app_label']}\",\n", " font_size=sp(15),\n", " halign=\"left\",\n", " valign=\"middle\",\n", " shorten=True,\n", " shorten_from=\"right\",\n", " text_size=(dp(210), dp(28)),\n", " size_hint_x=0.72,\n", " )\n", " time_label = Label(\n", " text=row.get(\"duration\", _format_duration(row.get(\"foreground_seconds\", 0))),\n", " font_size=sp(14),\n", " halign=\"right\",\n", " valign=\"middle\",\n", " text_size=(dp(90), dp(28)),\n", " size_hint_x=0.28,\n", " )\n", " header.add_widget(name_label)\n", " header.add_widget(time_label)\n", "\n", " progress = ProgressBar(\n", " max=100,\n", " value=(row[\"foreground_seconds\"] / max_seconds * 100.0) if max_seconds else 0,\n", " size_hint_y=None,\n", " height=dp(18),\n", " )\n", "\n", " detail = Label(\n", " text=f\"{row['percent']:.1f}% {row['package']}\",\n", " font_size=sp(12),\n", " halign=\"left\",\n", " valign=\"middle\",\n", " shorten=True,\n", " shorten_from=\"right\",\n", " text_size=(dp(320), dp(20)),\n", " size_hint_y=None,\n", " height=dp(20),\n", " )\n", "\n", " container.add_widget(header)\n", " container.add_widget(progress)\n", " container.add_widget(detail)\n", " return container\n", "\n", "\n", "def _update_usage_ui():\n", " ui = globals().get(\"usage_ui\")\n", " if ui is None:\n", " return\n", "\n", " state = globals().get(\"usage_status\", {})\n", " rows = globals().get(\"usage\", [])\n", "\n", " message = state.get(\"message\", \"\")\n", " if state.get(\"package_visibility_note\"):\n", " message += \"\\n\" + state[\"package_visibility_note\"]\n", " ui.ids.status_label.text = message\n", "\n", " ui.ids.chart_box.clear_widgets()\n", "\n", " if rows:\n", " top_rows = rows[:20]\n", " max_seconds = max(row[\"foreground_seconds\"] for row in top_rows) or 1\n", " for row in top_rows:\n", " ui.ids.chart_box.add_widget(_make_chart_row(row, max_seconds))\n", " else:\n", " empty_label = Label(\n", " text=\"No usage rows to chart yet.\",\n", " font_size=sp(17),\n", " halign=\"center\",\n", " valign=\"middle\",\n", " text_size=(dp(320), None),\n", " size_hint_y=None,\n", " height=dp(140),\n", " )\n", " ui.ids.chart_box.add_widget(empty_label)\n", "\n", " ui.ids.summary_label.text = (\n", " f\"Rows: {state.get('rows', len(rows))} File: {state.get('output_path', usage_csv_path)}\"\n", " )\n", "\n", "\n", "def refresh_usage_stats(*args):\n", " global usage, usage_status\n", " try:\n", " usage_status = {\n", " \"ok\": False,\n", " \"stage\": \"loading\",\n", " \"message\": \"Loading foreground usage statistics.\",\n", " \"error\": None,\n", " }\n", " _update_usage_ui()\n", "\n", " rows, state = _load_usage_stats()\n", " usage = rows\n", " usage_status = state\n", " globals()[\"usage\"] = usage\n", " globals()[\"usage_status\"] = usage_status\n", " globals()[\"usage_label_cache\"] = usage_label_cache\n", " globals()[\"usage_label_errors\"] = usage_label_errors\n", " _update_usage_ui()\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not load usage statistics\")\n", " usage = []\n", " usage_status = {\n", " \"ok\": False,\n", " \"stage\": \"exception\",\n", " \"message\": f\"Could not load usage statistics: {type(exc).__name__}: {exc}\",\n", " \"error\": f\"{type(exc).__name__}: {exc}\",\n", " \"output_path\": usage_csv_path,\n", " }\n", " globals()[\"usage\"] = usage\n", " globals()[\"usage_status\"] = usage_status\n", " try:\n", " _write_usage_csv([])\n", " except Exception as csv_exc:\n", " Logger.exception(\"PythonHere: Could not write empty usage CSV after error\")\n", " usage_status[\"csv_error\"] = f\"{type(csv_exc).__name__}: {csv_exc}\"\n", " _update_usage_ui()\n", " _show_usage_error_popup(usage_status[\"message\"])\n", "\n", "\n", "def open_usage_access_settings(*args):\n", " global usage_status\n", " try:\n", " context, activity = _get_android_context_and_activity()\n", " if activity is None:\n", " usage_status = {\n", " **globals().get(\"usage_status\", {}),\n", " \"stage\": \"settings\",\n", " \"settings_opened\": False,\n", " \"message\": \"A foreground Android activity is required to open Usage Access Settings.\",\n", " \"error\": \"Foreground activity unavailable.\",\n", " }\n", " globals()[\"usage_status\"] = usage_status\n", " _update_usage_ui()\n", " return\n", "\n", " Intent = autoclass(\"android.content.Intent\")\n", " Settings = autoclass(\"android.provider.Settings\")\n", "\n", " action = Settings.ACTION_USAGE_ACCESS_SETTINGS or \"android.settings.USAGE_ACCESS_SETTINGS\"\n", " intent = Intent(action)\n", " activity.startActivity(intent)\n", "\n", " usage_status = {\n", " **globals().get(\"usage_status\", {}),\n", " \"stage\": \"settings\",\n", " \"settings_opened\": True,\n", " \"settings_action\": action,\n", " \"message\": (\n", " \"Usage Access Settings opened. Enable usage access for this app if it is listed, \"\n", " \"return here, then tap Refresh.\"\n", " ),\n", " \"error\": None,\n", " }\n", " globals()[\"usage_status\"] = usage_status\n", " _update_usage_ui()\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not open Usage Access Settings\")\n", " usage_status = {\n", " **globals().get(\"usage_status\", {}),\n", " \"stage\": \"settings_exception\",\n", " \"settings_opened\": False,\n", " \"message\": f\"Could not open Usage Access Settings: {type(exc).__name__}: {exc}\",\n", " \"error\": f\"{type(exc).__name__}: {exc}\",\n", " }\n", " globals()[\"usage_status\"] = usage_status\n", " _update_usage_ui()\n", " _show_usage_error_popup(usage_status[\"message\"])\n", "\n", "\n", "KV = \"\"\"\n", "#:import dp kivy.metrics.dp\n", "#:import sp kivy.metrics.sp\n", "\n", "BoxLayout:\n", " orientation: \"vertical\"\n", " padding: dp(12)\n", " spacing: dp(8)\n", "\n", " Label:\n", " id: title_label\n", " text: \"Foreground app usage\"\n", " size_hint_y: None\n", " height: dp(44)\n", " font_size: sp(22)\n", " bold: True\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " Label:\n", " id: status_label\n", " text: \"Preparing usage statistics.\"\n", " size_hint_y: None\n", " height: dp(112)\n", " font_size: sp(14)\n", " halign: \"left\"\n", " valign: \"top\"\n", " text_size: self.width, None\n", "\n", " BoxLayout:\n", " orientation: \"horizontal\"\n", " size_hint_y: None\n", " height: dp(52)\n", " spacing: dp(8)\n", "\n", " Button:\n", " id: refresh_button\n", " text: \"Refresh\"\n", " font_size: sp(16)\n", "\n", " Button:\n", " id: settings_button\n", " text: \"Open Settings\"\n", " font_size: sp(16)\n", "\n", " Label:\n", " id: summary_label\n", " text: \"Rows: 0 File: usage.csv\"\n", " size_hint_y: None\n", " height: dp(28)\n", " font_size: sp(13)\n", " halign: \"left\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " ScrollView:\n", " do_scroll_x: False\n", " do_scroll_y: True\n", "\n", " GridLayout:\n", " id: chart_box\n", " cols: 1\n", " spacing: dp(8)\n", " padding: 0, dp(4)\n", " size_hint_y: None\n", " height: self.minimum_height\n", "\"\"\"\n", "\n", "try:\n", " usage_ui = Builder.load_string(KV)\n", " if usage_ui is None:\n", " raise RuntimeError(\"Builder.load_string returned None for usage UI.\")\n", "\n", " usage_ui.ids.refresh_button.bind(on_release=refresh_usage_stats)\n", " usage_ui.ids.settings_button.bind(on_release=open_usage_access_settings)\n", "\n", " root.clear_widgets()\n", " root.add_widget(usage_ui)\n", "\n", " globals()[\"usage_ui\"] = usage_ui\n", " globals()[\"refresh_usage_stats\"] = refresh_usage_stats\n", " globals()[\"open_usage_access_settings\"] = open_usage_access_settings\n", "\n", " refresh_usage_stats()\n", "\n", "except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not build usage statistics UI\")\n", " usage_status = {\n", " \"ok\": False,\n", " \"stage\": \"ui_exception\",\n", " \"message\": f\"Could not build usage statistics UI: {type(exc).__name__}: {exc}\",\n", " \"error\": f\"{type(exc).__name__}: {exc}\",\n", " \"output_path\": usage_csv_path,\n", " }\n", " globals()[\"usage_status\"] = usage_status\n", " _show_usage_error_popup(usage_status[\"message\"])\n", "\n", "\n", "print(f\"%there download {Path(usage_csv_path).name}\")\n", "print(\n", " \"\"\"\n", "Local pie chart instructions with pandas and matplotlib:\n", "\n", "1. Download usage.csv from this PythonHere session.\n", "2. Put usage.csv in your local working directory.\n", "3. Run this code locally:\n", "\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "df = pd.read_csv(\"usage.csv\")\n", "df = df[df[\"foreground_seconds\"] > 0].copy()\n", "\n", "if df.empty:\n", " print(\"No usage rows found in usage.csv\")\n", "else:\n", " top = df.sort_values(\"foreground_seconds\", ascending=False).head(10)\n", " other_seconds = df.loc[~df.index.isin(top.index), \"foreground_seconds\"].sum()\n", " if other_seconds > 0:\n", " top = pd.concat([\n", " top[[\"app_label\", \"foreground_seconds\"]],\n", " pd.DataFrame([{\"app_label\": \"Other\", \"foreground_seconds\": other_seconds}]),\n", " ], ignore_index=True)\n", "\n", " ax = top.set_index(\"app_label\")[\"foreground_seconds\"].plot.pie(\n", " autopct=\"%1.1f%%\",\n", " startangle=90,\n", " counterclock=False,\n", " figsize=(7, 7),\n", " )\n", " ax.set_ylabel(\"\")\n", " ax.set_title(\"Foreground app usage, last 24 hours\")\n", " plt.tight_layout()\n", " plt.show()\n", "\"\"\"\n", ")" ] }, { "cell_type": "markdown", "id": "463d3385", "metadata": {}, "source": [ "Check the remote usage query status and preview the first row before downloading\n", "the CSV:" ] }, { "cell_type": "code", "execution_count": 4, "id": "ee177d7f", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:54.458799Z", "iopub.status.busy": "2026-06-08T18:49:54.458540Z", "iopub.status.idle": "2026-06-08T18:49:55.127398Z", "shell.execute_reply": "2026-06-08T18:49:55.126226Z" } }, "outputs": [ { "data": { "text/plain": [ "{'status': {'ok': True,\n", " 'stage': 'complete',\n", " 'message': 'Loaded 25 apps with foreground usage in the last 24 hours. Saved usage.csv.',\n", " 'error': None,\n", " 'access_granted': True,\n", " 'app_ops_mode': 0,\n", " 'app_ops_mode_name': 'allowed',\n", " 'sdk_int': 34,\n", " 'package_name': 'me.herethere.pythonhere_dev',\n", " 'window_start_ms': 1780858194115,\n", " 'window_end_ms': 1780944594115,\n", " 'query_rows': 659,\n", " 'rows': 25,\n", " 'total_foreground_seconds': 36424.255,\n", " 'output_path': 'usage.csv',\n", " 'package_visibility_note': 'On Android 11 and newer, package label lookups can be affected by package visibility. UsageStats rows reflect accessible usage records.',\n", " 'label_errors': []},\n", " 'first_row': [{'app_label': 'PythonHereDev',\n", " 'package': 'me.herethere.pythonhere_dev',\n", " 'foreground_seconds': 19520.28,\n", " 'foreground_minutes': 325.338,\n", " 'foreground_hours': 5.4223,\n", " 'percent': 53.591,\n", " 'foreground_ms': 19520280,\n", " 'first_time_stamp_ms': 1780825004193,\n", " 'last_time_stamp_ms': 1780944487605,\n", " 'last_time_used_ms': 1780944488943,\n", " 'rank': 1,\n", " 'duration': '5h 25m'}]}" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%there get {\"status\": usage_status, \"first_row\": usage[:1]}" ] }, { "cell_type": "code", "execution_count": 5, "id": "08d68aaf", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:55.131568Z", "iopub.status.busy": "2026-06-08T18:49:55.131177Z", "iopub.status.idle": "2026-06-08T18:49:55.880993Z", "shell.execute_reply": "2026-06-08T18:49:55.879912Z" } }, "outputs": [], "source": [ "%there download usage.csv" ] }, { "cell_type": "markdown", "id": "4a9b35cf", "metadata": {}, "source": [ "After the remote cell writes `usage.csv`, download it and analyze it locally in\n", "the notebook." ] }, { "cell_type": "code", "execution_count": 6, "id": "f182d26b", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:55.885224Z", "iopub.status.busy": "2026-06-08T18:49:55.884819Z", "iopub.status.idle": "2026-06-08T18:49:56.814019Z", "shell.execute_reply": "2026-06-08T18:49:56.813587Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "df = pd.read_csv(\"usage.csv\")\n", "df = df[df[\"foreground_seconds\"] > 0].copy()\n", "\n", "top = df.sort_values(\"foreground_seconds\", ascending=False).head(5)\n", "\n", "ax = top.set_index(\"app_label\")[\"foreground_seconds\"].plot.pie(\n", " labels=None,\n", " autopct=\"%1.1f%%\",\n", " startangle=90,\n", " counterclock=False,\n", " figsize=(3, 3),\n", ")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c1920d15", "metadata": {}, "source": [ "## Accelerometer Maze" ] }, { "cell_type": "code", "execution_count": 7, "id": "1b2f40ee", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:56.815650Z", "iopub.status.busy": "2026-06-08T18:49:56.815476Z", "iopub.status.idle": "2026-06-08T18:49:56.819071Z", "shell.execute_reply": "2026-06-08T18:49:56.818694Z" }, "tags": [ "remove-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "herethere AI generation is not configured. Set THERE_AI_MODEL. For hosted providers, also set THERE_AI_API_KEY. Optionally set THERE_AI_BASE_URL.\n" ] } ], "source": [ "%%there ai\n", "A maze game controlled by accelerometer.\n", "- portrait mode\n", "- screen should be blocked from rotation" ] }, { "cell_type": "code", "execution_count": 8, "id": "e40931b3", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:56.820762Z", "iopub.status.busy": "2026-06-08T18:49:56.820630Z", "iopub.status.idle": "2026-06-08T18:49:57.410207Z", "shell.execute_reply": "2026-06-08T18:49:57.409847Z" }, "tags": [ "hide-input" ] }, "outputs": [], "source": [ "%%there\n", "# Generated locally by %%there ai. Review before running.\n", "from math import floor\n", "from random import shuffle\n", "\n", "from kivy.clock import Clock\n", "from kivy.factory import Factory\n", "from kivy.graphics import Color, Ellipse, Line, Rectangle\n", "from kivy.lang import Builder\n", "from kivy.logger import Logger\n", "from kivy.metrics import dp\n", "from kivy.uix.label import Label\n", "from kivy.uix.popup import Popup\n", "from kivy.uix.widget import Widget\n", "\n", "from plyer import accelerometer\n", "\n", "\n", "def _maze_show_error(title, message):\n", " globals()[\"maze_game_last_error\"] = str(message)\n", " try:\n", " Popup(\n", " title=title,\n", " content=Label(\n", " text=str(message)[:900],\n", " text_size=(dp(280), None),\n", " halign=\"center\",\n", " valign=\"middle\",\n", " ),\n", " size_hint=(0.88, 0.45),\n", " ).open()\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not show maze error popup\")\n", "\n", "\n", "def _make_accel_maze(cols=15, rows=21):\n", " if cols % 2 == 0:\n", " cols += 1\n", " if rows % 2 == 0:\n", " rows += 1\n", "\n", " maze = [[1 for _ in range(cols)] for _ in range(rows)]\n", " start = (1, rows - 2)\n", " goal = (cols - 2, 1)\n", "\n", " stack = [start]\n", " maze[start[1]][start[0]] = 0\n", "\n", " while stack:\n", " c, r = stack[-1]\n", " choices = []\n", " for dc, dr in ((2, 0), (-2, 0), (0, 2), (0, -2)):\n", " nc, nr = c + dc, r + dr\n", " if 1 <= nc < cols - 1 and 1 <= nr < rows - 1 and maze[nr][nc] == 1:\n", " choices.append((nc, nr, dc, dr))\n", " if choices:\n", " shuffle(choices)\n", " nc, nr, dc, dr = choices[0]\n", " maze[r + dr // 2][c + dc // 2] = 0\n", " maze[nr][nc] = 0\n", " stack.append((nc, nr))\n", " else:\n", " stack.pop()\n", "\n", " maze[start[1]][start[0]] = 0\n", " maze[goal[1]][goal[0]] = 0\n", " return maze, start, goal\n", "\n", "\n", "class AccelMazeBoard(Widget):\n", " def __init__(self, **kwargs):\n", " super().__init__(**kwargs)\n", " self.maze = []\n", " self.cols = 0\n", " self.rows = 0\n", " self.start_cell = None\n", " self.goal_cell = None\n", " self.cell = 0\n", " self.board_x = 0\n", " self.board_y = 0\n", " self.ball_x = None\n", " self.ball_y = None\n", " self.ball_radius = 8\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.won = False\n", " self.bind(pos=self._on_layout_change, size=self._on_layout_change)\n", "\n", " def configure(self, maze, start_cell, goal_cell):\n", " self.maze = maze\n", " self.rows = len(maze)\n", " self.cols = len(maze[0]) if self.rows else 0\n", " self.start_cell = start_cell\n", " self.goal_cell = goal_cell\n", " self.won = False\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.ball_x = None\n", " self.ball_y = None\n", " self._update_metrics()\n", " self._ensure_ball_position()\n", " self._redraw()\n", "\n", " def reset_ball(self):\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.won = False\n", " self.ball_x = None\n", " self.ball_y = None\n", " self._ensure_ball_position()\n", " self._redraw()\n", "\n", " def _on_layout_change(self, *args):\n", " old_cell = self.cell\n", " old_rel_x = None\n", " old_rel_y = None\n", " if self.ball_x is not None and old_cell:\n", " old_rel_x = (self.ball_x - self.board_x) / old_cell\n", " old_rel_y = (self.ball_y - self.board_y) / old_cell\n", "\n", " self._update_metrics()\n", "\n", " if old_rel_x is not None and self.cell:\n", " self.ball_x = self.board_x + old_rel_x * self.cell\n", " self.ball_y = self.board_y + old_rel_y * self.cell\n", " self.ball_radius = max(6, self.cell * 0.30)\n", " else:\n", " self._ensure_ball_position()\n", "\n", " self._redraw()\n", "\n", " def _update_metrics(self):\n", " if not self.cols or not self.rows or self.width <= 0 or self.height <= 0:\n", " self.cell = 0\n", " return\n", " self.cell = min(self.width / self.cols, self.height / self.rows)\n", " self.board_x = self.x + (self.width - self.cell * self.cols) / 2\n", " self.board_y = self.y + (self.height - self.cell * self.rows) / 2\n", " self.ball_radius = max(6, self.cell * 0.30)\n", "\n", " def _cell_center(self, cell):\n", " c, r = cell\n", " return (\n", " self.board_x + (c + 0.5) * self.cell,\n", " self.board_y + (self.rows - r - 0.5) * self.cell,\n", " )\n", "\n", " def _cell_at_point(self, x, y):\n", " if not self.cell:\n", " return None\n", " c = int(floor((x - self.board_x) / self.cell))\n", " bottom_row = int(floor((y - self.board_y) / self.cell))\n", " r = self.rows - 1 - bottom_row\n", " if 0 <= c < self.cols and 0 <= r < self.rows:\n", " return c, r\n", " return None\n", "\n", " def _ensure_ball_position(self):\n", " if self.ball_x is None and self.start_cell and self.cell:\n", " self.ball_x, self.ball_y = self._cell_center(self.start_cell)\n", " self.ball_radius = max(6, self.cell * 0.30)\n", "\n", " def _circle_hits_wall(self, x, y):\n", " if not self.cell or not self.maze:\n", " return True\n", "\n", " radius = self.ball_radius\n", " c0 = int(floor((x - radius - self.board_x) / self.cell))\n", " c1 = int(floor((x + radius - self.board_x) / self.cell))\n", " b0 = int(floor((y - radius - self.board_y) / self.cell))\n", " b1 = int(floor((y + radius - self.board_y) / self.cell))\n", "\n", " for c in range(c0, c1 + 1):\n", " for bottom_row in range(b0, b1 + 1):\n", " r = self.rows - 1 - bottom_row\n", " if c < 0 or c >= self.cols or r < 0 or r >= self.rows:\n", " return True\n", " if self.maze[r][c] == 1:\n", " left = self.board_x + c * self.cell\n", " bottom = self.board_y + bottom_row * self.cell\n", " right = left + self.cell\n", " top = bottom + self.cell\n", " closest_x = min(max(x, left), right)\n", " closest_y = min(max(y, bottom), top)\n", " dx = x - closest_x\n", " dy = y - closest_y\n", " if dx * dx + dy * dy < radius * radius:\n", " return True\n", " return False\n", "\n", " def step(self, dt, accel_x, accel_y):\n", " if self.won:\n", " return\n", "\n", " self._update_metrics()\n", " self._ensure_ball_position()\n", " if self.ball_x is None or not self.cell:\n", " return\n", "\n", " dt = min(max(dt, 0.0), 0.05)\n", "\n", " dead_zone = 0.04\n", " if abs(accel_x) < dead_zone:\n", " accel_x = 0\n", " if abs(accel_y) < dead_zone:\n", " accel_y = 0\n", "\n", " force = self.cell * 36.0\n", " self.velocity_x += accel_x * force * dt\n", " self.velocity_y += accel_y * force * dt\n", "\n", " friction = max(0.0, 1.0 - 2.1 * dt)\n", " self.velocity_x *= friction\n", " self.velocity_y *= friction\n", "\n", " max_speed = self.cell * 7.5\n", " speed_sq = self.velocity_x * self.velocity_x + self.velocity_y * self.velocity_y\n", " if speed_sq > max_speed * max_speed:\n", " scale = max_speed / (speed_sq ** 0.5)\n", " self.velocity_x *= scale\n", " self.velocity_y *= scale\n", "\n", " next_x = self.ball_x + self.velocity_x * dt\n", " if not self._circle_hits_wall(next_x, self.ball_y):\n", " self.ball_x = next_x\n", " else:\n", " self.velocity_x *= -0.25\n", "\n", " next_y = self.ball_y + self.velocity_y * dt\n", " if not self._circle_hits_wall(self.ball_x, next_y):\n", " self.ball_y = next_y\n", " else:\n", " self.velocity_y *= -0.25\n", "\n", " current_cell = self._cell_at_point(self.ball_x, self.ball_y)\n", " if current_cell == self.goal_cell:\n", " self.won = True\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", "\n", " self._redraw()\n", "\n", " def _redraw(self, *args):\n", " self.canvas.clear()\n", " with self.canvas:\n", " Color(0.06, 0.07, 0.09, 1)\n", " Rectangle(pos=self.pos, size=self.size)\n", "\n", " if not self.maze or not self.cell:\n", " return\n", "\n", " board_w = self.cell * self.cols\n", " board_h = self.cell * self.rows\n", "\n", " Color(0.13, 0.15, 0.18, 1)\n", " Rectangle(pos=(self.board_x, self.board_y), size=(board_w, board_h))\n", "\n", " if self.goal_cell:\n", " gc, gr = self.goal_cell\n", " Color(0.12, 0.72, 0.30, 1)\n", " Rectangle(\n", " pos=(self.board_x + gc * self.cell, self.board_y + (self.rows - 1 - gr) * self.cell),\n", " size=(self.cell, self.cell),\n", " )\n", "\n", " Color(0.82, 0.84, 0.88, 1)\n", " for r, row in enumerate(self.maze):\n", " for c, value in enumerate(row):\n", " if value == 1:\n", " Rectangle(\n", " pos=(self.board_x + c * self.cell, self.board_y + (self.rows - 1 - r) * self.cell),\n", " size=(self.cell, self.cell),\n", " )\n", "\n", " Color(0.02, 0.03, 0.04, 1)\n", " Line(rectangle=(self.board_x, self.board_y, board_w, board_h), width=max(1, self.cell * 0.05))\n", "\n", " if self.ball_x is not None:\n", " Color(0.08, 0.38, 0.95, 1)\n", " Ellipse(\n", " pos=(self.ball_x - self.ball_radius, self.ball_y - self.ball_radius),\n", " size=(self.ball_radius * 2, self.ball_radius * 2),\n", " )\n", "\n", "\n", "Factory.register(\"AccelMazeBoard\", cls=AccelMazeBoard)\n", "\n", "\n", "class AccelerometerMazeController:\n", " def __init__(self, ui, previous_orientation=None, orientation_locked=False):\n", " self.ui = ui\n", " self.board = ui.ids.board_widget\n", " self.status_label = ui.ids.status_label\n", " self.previous_orientation = previous_orientation\n", " self.orientation_locked = orientation_locked\n", " self.event = None\n", " self.paused = False\n", " self.accelerometer_enabled = False\n", " self.calibration = None\n", " self.last_status_update = 0\n", " self.last_error = None\n", " self.state = {\n", " \"ok\": True,\n", " \"stage\": \"starting\",\n", " \"message\": \"Starting maze game.\",\n", " \"error\": None,\n", " \"orientation_locked\": bool(orientation_locked),\n", " \"accelerometer_enabled\": False,\n", " \"paused\": False,\n", " \"won\": False,\n", " }\n", " globals()[\"maze_game_state\"] = self.state\n", "\n", " def start(self):\n", " self.restart()\n", " try:\n", " accelerometer.enable()\n", " self.accelerometer_enabled = True\n", " self.state[\"accelerometer_enabled\"] = True\n", " self._set_status(\"Ready. Hold the phone normally, then tilt to move.\")\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not enable accelerometer\")\n", " self.last_error = f\"{type(exc).__name__}: {exc}\"\n", " self.state.update(\n", " ok=False,\n", " stage=\"enable_accelerometer\",\n", " error=self.last_error,\n", " message=\"Accelerometer could not be enabled.\",\n", " )\n", " self._set_status(\"Accelerometer error: \" + self.last_error)\n", "\n", " self.event = Clock.schedule_interval(self._tick, 1 / 60.0)\n", " self.state[\"stage\"] = \"running\"\n", "\n", " def cleanup(self, restore_orientation=False):\n", " if self.event is not None:\n", " self.event.cancel()\n", " self.event = None\n", " try:\n", " if self.accelerometer_enabled:\n", " accelerometer.disable()\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not disable accelerometer\")\n", " self.accelerometer_enabled = False\n", " self.state[\"accelerometer_enabled\"] = False\n", "\n", " if restore_orientation and self.previous_orientation is not None:\n", " try:\n", " from jnius import autoclass\n", "\n", " PythonActivity = autoclass(\"org.kivy.android.PythonActivity\")\n", " activity = PythonActivity.mActivity\n", " if activity is not None:\n", " activity.setRequestedOrientation(int(self.previous_orientation))\n", " self.state[\"orientation_locked\"] = False\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not restore previous orientation\")\n", "\n", " def restart(self, *args):\n", " maze, start, goal = _make_accel_maze()\n", " self.board.configure(maze, start, goal)\n", " self.paused = False\n", " self.calibration = None\n", " self.state.update(\n", " ok=True,\n", " stage=\"running\",\n", " message=\"New maze started.\",\n", " error=None,\n", " paused=False,\n", " won=False,\n", " rows=len(maze),\n", " cols=len(maze[0]) if maze else 0,\n", " )\n", " self.ui.ids.pause_button.text = \"Pause\"\n", " self._set_status(\"New maze. Tilt to move the blue ball to the green goal.\")\n", "\n", " def calibrate(self, *args):\n", " raw = self._read_acceleration()\n", " if raw is None:\n", " self._set_status(\"Waiting for accelerometer data. Try again in a moment.\")\n", " self.state[\"message\"] = \"Calibration waiting for accelerometer data.\"\n", " return\n", " self.calibration = (raw[0], raw[1])\n", " self.state[\"calibration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", " self._set_status(\"Calibrated. Tilt gently to move.\")\n", "\n", " def toggle_pause(self, *args):\n", " self.paused = not self.paused\n", " self.state[\"paused\"] = self.paused\n", " self.ui.ids.pause_button.text = \"Resume\" if self.paused else \"Pause\"\n", " self._set_status(\"Paused.\" if self.paused else \"Running. Tilt to move.\")\n", "\n", " def _set_status(self, message):\n", " self.status_label.text = str(message)\n", " self.state[\"message\"] = str(message)\n", "\n", " def _read_acceleration(self):\n", " raw = accelerometer.acceleration\n", " if not raw or len(raw) < 2:\n", " return None\n", " if raw[0] is None or raw[1] is None:\n", " return None\n", " return float(raw[0]), float(raw[1])\n", "\n", " def _tick(self, dt):\n", " try:\n", " if self.paused:\n", " return\n", "\n", " raw = self._read_acceleration()\n", " if raw is None:\n", " if Clock.get_time() - self.last_status_update > 1.5:\n", " self.last_status_update = Clock.get_time()\n", " self._set_status(\"Waiting for accelerometer data.\")\n", " return\n", "\n", " if self.calibration is None:\n", " self.calibration = (raw[0], raw[1])\n", " self.state[\"calibration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", "\n", " accel_x = raw[0] - self.calibration[0]\n", " accel_y = raw[1] - self.calibration[1]\n", " self.state[\"last_acceleration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", " self.board.step(dt, accel_x, accel_y)\n", "\n", " if self.board.won and not self.state.get(\"won\"):\n", " self.state[\"won\"] = True\n", " self.state[\"stage\"] = \"won\"\n", " self._set_status(\"You reached the goal. Press Restart for a new maze.\")\n", "\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Maze game loop failed\")\n", " self.last_error = f\"{type(exc).__name__}: {exc}\"\n", " self.state.update(\n", " ok=False,\n", " stage=\"game_loop\",\n", " error=self.last_error,\n", " message=\"Maze game loop error.\",\n", " )\n", " self._set_status(\"Game error: \" + self.last_error)\n", " self.paused = True\n", " self.state[\"paused\"] = True\n", "\n", "\n", "def _install_accelerometer_maze_game():\n", " try:\n", " old_cleanup = globals().get(\"maze_game_cleanup\")\n", " if callable(old_cleanup):\n", " try:\n", " old_cleanup(restore_orientation=False)\n", " except Exception:\n", " Logger.exception(\"PythonHere: Previous maze cleanup failed\")\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not inspect previous maze cleanup\")\n", "\n", " previous_orientation = None\n", " orientation_locked = False\n", "\n", " try:\n", " from jnius import autoclass\n", "\n", " PythonActivity = autoclass(\"org.kivy.android.PythonActivity\")\n", " ActivityInfo = autoclass(\"android.content.pm.ActivityInfo\")\n", " activity = PythonActivity.mActivity\n", " if activity is not None:\n", " try:\n", " previous_orientation = int(activity.getRequestedOrientation())\n", " except Exception:\n", " previous_orientation = None\n", " activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT)\n", " orientation_locked = True\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not lock screen orientation\")\n", " globals()[\"maze_game_orientation_error\"] = f\"{type(exc).__name__}: {exc}\"\n", "\n", " KV = \"\"\"\n", "#:import dp kivy.metrics.dp\n", "#:import sp kivy.metrics.sp\n", "\n", "BoxLayout:\n", " orientation: \"vertical\"\n", " padding: dp(10)\n", " spacing: dp(8)\n", "\n", " Label:\n", " id: title_label\n", " text: \"Accel Maze\"\n", " size_hint_y: None\n", " height: dp(40)\n", " font_size: sp(24)\n", " bold: True\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " Label:\n", " id: instruction_label\n", " text: \"Tilt the phone to move the blue ball to the green goal.\"\n", " size_hint_y: None\n", " height: dp(48)\n", " font_size: sp(15)\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " AccelMazeBoard:\n", " id: board_widget\n", " size_hint_y: 1\n", "\n", " GridLayout:\n", " cols: 3\n", " spacing: dp(8)\n", " size_hint_y: None\n", " height: dp(56)\n", "\n", " Button:\n", " id: calibrate_button\n", " text: \"Calibrate\"\n", " font_size: sp(16)\n", "\n", " Button:\n", " id: restart_button\n", " text: \"Restart\"\n", " font_size: sp(16)\n", "\n", " Button:\n", " id: pause_button\n", " text: \"Pause\"\n", " font_size: sp(16)\n", "\n", " Label:\n", " id: status_label\n", " text: \"Starting.\"\n", " size_hint_y: None\n", " height: dp(54)\n", " font_size: sp(14)\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\"\"\"\n", "\n", " try:\n", " ui = Builder.load_string(KV)\n", " if ui is None:\n", " raise RuntimeError(\"Builder.load_string returned None\")\n", "\n", " root.clear_widgets()\n", " root.add_widget(ui)\n", "\n", " controller = AccelerometerMazeController(\n", " ui,\n", " previous_orientation=previous_orientation,\n", " orientation_locked=orientation_locked,\n", " )\n", "\n", " ui.ids.calibrate_button.bind(on_release=controller.calibrate)\n", " ui.ids.restart_button.bind(on_release=controller.restart)\n", " ui.ids.pause_button.bind(on_release=controller.toggle_pause)\n", "\n", " globals()[\"maze_game_ui\"] = ui\n", " globals()[\"maze_game_controller\"] = controller\n", "\n", " def maze_game_cleanup(restore_orientation=False):\n", " controller.cleanup(restore_orientation=restore_orientation)\n", "\n", " globals()[\"maze_game_cleanup\"] = maze_game_cleanup\n", "\n", " controller.start()\n", "\n", " if orientation_locked:\n", " controller.state[\"orientation_message\"] = \"Portrait orientation locked.\"\n", " else:\n", " controller.state[\"orientation_message\"] = \"Portrait lock was not confirmed.\"\n", "\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not load accelerometer maze game\")\n", " globals()[\"maze_game_state\"] = {\n", " \"ok\": False,\n", " \"stage\": \"install\",\n", " \"error\": f\"{type(exc).__name__}: {exc}\",\n", " \"message\": \"Could not load accelerometer maze game.\",\n", " }\n", " _maze_show_error(\"Maze error\", f\"{type(exc).__name__}: {exc}\")\n", "\n", "\n", "_install_accelerometer_maze_game()" ] }, { "cell_type": "markdown", "id": "e7379ffc", "metadata": {}, "source": [ "The first generated game works, but the next prompt asks for a visual direction\n", "and a performance improvement. `--fix` uses the previous `%%there` cell as\n", "context and inserts a replacement cell." ] }, { "cell_type": "code", "execution_count": 9, "id": "f2ce6229", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:57.412190Z", "iopub.status.busy": "2026-06-08T18:49:57.411963Z", "iopub.status.idle": "2026-06-08T18:49:57.415199Z", "shell.execute_reply": "2026-06-08T18:49:57.414903Z" }, "tags": [ "remove-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "herethere AI generation is not configured. Set THERE_AI_MODEL. For hosted providers, also set THERE_AI_API_KEY. Optionally set THERE_AI_BASE_URL.\n" ] } ], "source": [ "%%there ai --fix\n", "Apply style: bright paper map\n", "- off-white paper background\n", "- thin blueprint-style maze lines\n", "- small colored player marker\n", "- dotted trail like a route map\n", "- goal marked with a flag\n", "- subtle grid texture\n", "UI controls should match the paper map style: buttons and HUD as paper cards\n", "with light fills, thin blueprint-blue outlines, rounded corners and subtle shadows.\n", "Keep gameplay smooth: don't redraw the full board every frame; cache the static map and only update the moving marker/trail." ] }, { "cell_type": "code", "execution_count": 10, "id": "b9ed00f2", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:49:57.416645Z", "iopub.status.busy": "2026-06-08T18:49:57.416484Z", "iopub.status.idle": "2026-06-08T18:50:00.104694Z", "shell.execute_reply": "2026-06-08T18:50:00.104251Z" } }, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%there -d 1 screenshot -w 250" ] }, { "cell_type": "code", "execution_count": 11, "id": "9f3d0dda", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:50:00.106934Z", "iopub.status.busy": "2026-06-08T18:50:00.106785Z", "iopub.status.idle": "2026-06-08T18:50:00.919625Z", "shell.execute_reply": "2026-06-08T18:50:00.918521Z" }, "tags": [ "hide-input" ] }, "outputs": [], "source": [ "%%there\n", "# Generated locally by %%there ai. Review before running.\n", "# AI mode: fix\n", "# Fix: restyle the maze as a bright paper map and cache the static board so only the marker and route trail update each frame.\n", "from math import floor\n", "from random import shuffle\n", "\n", "from kivy.clock import Clock\n", "from kivy.factory import Factory\n", "from kivy.graphics import Color, Ellipse, Line, Rectangle, RoundedRectangle\n", "from kivy.graphics.instructions import InstructionGroup\n", "from kivy.lang import Builder\n", "from kivy.logger import Logger\n", "from kivy.metrics import dp\n", "from kivy.uix.button import Button\n", "from kivy.uix.label import Label\n", "from kivy.uix.popup import Popup\n", "from kivy.uix.widget import Widget\n", "\n", "from plyer import accelerometer\n", "\n", "\n", "PAPER_BG = (0.985, 0.965, 0.905, 1)\n", "PAPER_CARD = (1.0, 0.988, 0.94, 1)\n", "PAPER_CARD_DOWN = (0.955, 0.975, 0.985, 1)\n", "BLUEPRINT = (0.075, 0.275, 0.55, 1)\n", "BLUEPRINT_LIGHT = (0.42, 0.62, 0.78, 1)\n", "TRAIL_BLUE = (0.08, 0.36, 0.70, 1)\n", "PLAYER_RED = (0.92, 0.22, 0.18, 1)\n", "FLAG_RED = (0.84, 0.16, 0.14, 1)\n", "\n", "\n", "def _maze_show_error(title, message):\n", " globals()[\"maze_game_last_error\"] = str(message)\n", " try:\n", " Popup(\n", " title=title,\n", " content=Label(\n", " text=str(message)[:900],\n", " text_size=(dp(280), None),\n", " halign=\"center\",\n", " valign=\"middle\",\n", " ),\n", " size_hint=(0.88, 0.45),\n", " ).open()\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not show maze error popup\")\n", "\n", "\n", "class PaperCanvasMixin:\n", " paper_radius = dp(14)\n", "\n", " def _setup_paper_canvas(self, fill=PAPER_CARD, outline=BLUEPRINT, shadow_alpha=0.14):\n", " self._paper_fill_rgba = fill\n", " self._paper_outline_rgba = outline\n", " self._paper_shadow_alpha = shadow_alpha\n", " with self.canvas.before:\n", " self._paper_shadow_color = Color(0.06, 0.12, 0.18, shadow_alpha)\n", " self._paper_shadow = RoundedRectangle(\n", " pos=(self.x + dp(2), self.y - dp(2)),\n", " size=self.size,\n", " radius=[self.paper_radius],\n", " )\n", " self._paper_fill_color = Color(*fill)\n", " self._paper_fill_rect = RoundedRectangle(\n", " pos=self.pos,\n", " size=self.size,\n", " radius=[self.paper_radius],\n", " )\n", " with self.canvas.after:\n", " self._paper_outline_color = Color(*outline)\n", " self._paper_outline = Line(\n", " rounded_rectangle=(self.x, self.y, self.width, self.height, self.paper_radius),\n", " width=dp(1.2),\n", " )\n", " self.bind(pos=self._update_paper_canvas, size=self._update_paper_canvas)\n", "\n", " def _update_paper_canvas(self, *args):\n", " self._paper_shadow.pos = (self.x + dp(2), self.y - dp(2))\n", " self._paper_shadow.size = self.size\n", " self._paper_fill_rect.pos = self.pos\n", " self._paper_fill_rect.size = self.size\n", " self._paper_outline.rounded_rectangle = (\n", " self.x,\n", " self.y,\n", " self.width,\n", " self.height,\n", " self.paper_radius,\n", " )\n", "\n", "\n", "class PaperButton(PaperCanvasMixin, Button):\n", " def __init__(self, **kwargs):\n", " super().__init__(**kwargs)\n", " self.background_normal = \"\"\n", " self.background_down = \"\"\n", " self.background_color = (0, 0, 0, 0)\n", " self.color = BLUEPRINT\n", " self.bold = True\n", " self._setup_paper_canvas()\n", " self.bind(state=self._on_paper_state)\n", "\n", " def _on_paper_state(self, *args):\n", " if self.state == \"down\":\n", " self._paper_fill_color.rgba = PAPER_CARD_DOWN\n", " self._paper_shadow_color.rgba = (0.06, 0.12, 0.18, 0.06)\n", " self._paper_shadow.pos = (self.x + dp(1), self.y - dp(1))\n", " else:\n", " self._paper_fill_color.rgba = PAPER_CARD\n", " self._paper_shadow_color.rgba = (0.06, 0.12, 0.18, self._paper_shadow_alpha)\n", " self._paper_shadow.pos = (self.x + dp(2), self.y - dp(2))\n", "\n", "\n", "class PaperCardLabel(PaperCanvasMixin, Label):\n", " def __init__(self, **kwargs):\n", " super().__init__(**kwargs)\n", " self.color = BLUEPRINT\n", " self.padding = (dp(10), dp(6))\n", " self._setup_paper_canvas()\n", "\n", "\n", "def _make_accel_maze(cols=15, rows=21):\n", " if cols % 2 == 0:\n", " cols += 1\n", " if rows % 2 == 0:\n", " rows += 1\n", "\n", " maze = [[1 for _ in range(cols)] for _ in range(rows)]\n", " start = (1, rows - 2)\n", " goal = (cols - 2, 1)\n", "\n", " stack = [start]\n", " maze[start[1]][start[0]] = 0\n", "\n", " while stack:\n", " c, r = stack[-1]\n", " choices = []\n", " for dc, dr in ((2, 0), (-2, 0), (0, 2), (0, -2)):\n", " nc, nr = c + dc, r + dr\n", " if 1 <= nc < cols - 1 and 1 <= nr < rows - 1 and maze[nr][nc] == 1:\n", " choices.append((nc, nr, dc, dr))\n", " if choices:\n", " shuffle(choices)\n", " nc, nr, dc, dr = choices[0]\n", " maze[r + dr // 2][c + dc // 2] = 0\n", " maze[nr][nc] = 0\n", " stack.append((nc, nr))\n", " else:\n", " stack.pop()\n", "\n", " maze[start[1]][start[0]] = 0\n", " maze[goal[1]][goal[0]] = 0\n", " return maze, start, goal\n", "\n", "\n", "class AccelMazeBoard(Widget):\n", " def __init__(self, **kwargs):\n", " super().__init__(**kwargs)\n", " self.maze = []\n", " self.cols = 0\n", " self.rows = 0\n", " self.start_cell = None\n", " self.goal_cell = None\n", " self.cell = 0\n", " self.board_x = 0\n", " self.board_y = 0\n", " self.ball_x = None\n", " self.ball_y = None\n", " self.ball_radius = 8\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.won = False\n", "\n", " self.static_group = InstructionGroup()\n", " self.trail_group = InstructionGroup()\n", " self.marker_group = InstructionGroup()\n", " self.canvas.add(self.static_group)\n", " self.canvas.add(self.trail_group)\n", " self.canvas.add(self.marker_group)\n", "\n", " self.max_trail_dots = 80\n", " self.trail_points = []\n", " self.trail_refs = []\n", " self._last_trail_point = None\n", " self._build_dynamic_instruction_cache()\n", "\n", " self.bind(pos=self._on_layout_change, size=self._on_layout_change)\n", "\n", " def _build_dynamic_instruction_cache(self):\n", " for _index in range(self.max_trail_dots):\n", " dot_color = Color(TRAIL_BLUE[0], TRAIL_BLUE[1], TRAIL_BLUE[2], 0)\n", " dot = Ellipse(pos=(-100, -100), size=(0, 0))\n", " self.trail_group.add(dot_color)\n", " self.trail_group.add(dot)\n", " self.trail_refs.append((dot_color, dot))\n", "\n", " self.marker_shadow_color = Color(0.08, 0.10, 0.12, 0)\n", " self.marker_shadow = Ellipse(pos=(-100, -100), size=(0, 0))\n", " self.marker_fill_color = Color(*PLAYER_RED)\n", " self.marker_fill = Ellipse(pos=(-100, -100), size=(0, 0))\n", " self.marker_outline_color = Color(0.48, 0.04, 0.03, 0)\n", " self.marker_outline = Line(circle=(-100, -100, 1), width=dp(1.2))\n", "\n", " self.marker_group.add(self.marker_shadow_color)\n", " self.marker_group.add(self.marker_shadow)\n", " self.marker_group.add(self.marker_fill_color)\n", " self.marker_group.add(self.marker_fill)\n", " self.marker_group.add(self.marker_outline_color)\n", " self.marker_group.add(self.marker_outline)\n", "\n", " def configure(self, maze, start_cell, goal_cell):\n", " self.maze = maze\n", " self.rows = len(maze)\n", " self.cols = len(maze[0]) if self.rows else 0\n", " self.start_cell = start_cell\n", " self.goal_cell = goal_cell\n", " self.won = False\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.ball_x = None\n", " self.ball_y = None\n", " self.trail_points = []\n", " self._last_trail_point = None\n", " self._update_metrics()\n", " self._ensure_ball_position()\n", " self._record_trail_point(force=True)\n", " self._redraw_static_map()\n", " self._update_trail_instructions()\n", " self._update_marker_instruction()\n", "\n", " def reset_ball(self):\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", " self.won = False\n", " self.ball_x = None\n", " self.ball_y = None\n", " self.trail_points = []\n", " self._last_trail_point = None\n", " self._ensure_ball_position()\n", " self._record_trail_point(force=True)\n", " self._update_trail_instructions()\n", " self._update_marker_instruction()\n", "\n", " def _on_layout_change(self, *args):\n", " old_cell = self.cell\n", " old_rel_x = None\n", " old_rel_y = None\n", " if self.ball_x is not None and old_cell:\n", " old_rel_x = (self.ball_x - self.board_x) / old_cell\n", " old_rel_y = (self.ball_y - self.board_y) / old_cell\n", "\n", " self._update_metrics()\n", "\n", " if old_rel_x is not None and self.cell:\n", " self.ball_x = self.board_x + old_rel_x * self.cell\n", " self.ball_y = self.board_y + old_rel_y * self.cell\n", " self.ball_radius = max(dp(4), self.cell * 0.22)\n", " else:\n", " self._ensure_ball_position()\n", "\n", " self._redraw_static_map()\n", " self._update_trail_instructions()\n", " self._update_marker_instruction()\n", "\n", " def _update_metrics(self):\n", " if not self.cols or not self.rows or self.width <= 0 or self.height <= 0:\n", " self.cell = 0\n", " return\n", " padding = dp(8)\n", " available_w = max(1, self.width - padding * 2)\n", " available_h = max(1, self.height - padding * 2)\n", " self.cell = min(available_w / self.cols, available_h / self.rows)\n", " self.board_x = self.x + (self.width - self.cell * self.cols) / 2\n", " self.board_y = self.y + (self.height - self.cell * self.rows) / 2\n", " self.ball_radius = max(dp(4), self.cell * 0.22)\n", "\n", " def _cell_center(self, cell):\n", " c, r = cell\n", " return (\n", " self.board_x + (c + 0.5) * self.cell,\n", " self.board_y + (self.rows - r - 0.5) * self.cell,\n", " )\n", "\n", " def _cell_at_point(self, x, y):\n", " if not self.cell:\n", " return None\n", " c = int(floor((x - self.board_x) / self.cell))\n", " bottom_row = int(floor((y - self.board_y) / self.cell))\n", " r = self.rows - 1 - bottom_row\n", " if 0 <= c < self.cols and 0 <= r < self.rows:\n", " return c, r\n", " return None\n", "\n", " def _ensure_ball_position(self):\n", " if self.ball_x is None and self.start_cell and self.cell:\n", " self.ball_x, self.ball_y = self._cell_center(self.start_cell)\n", " self.ball_radius = max(dp(4), self.cell * 0.22)\n", "\n", " def _circle_hits_wall(self, x, y):\n", " if not self.cell or not self.maze:\n", " return True\n", "\n", " radius = self.ball_radius\n", " c0 = int(floor((x - radius - self.board_x) / self.cell))\n", " c1 = int(floor((x + radius - self.board_x) / self.cell))\n", " b0 = int(floor((y - radius - self.board_y) / self.cell))\n", " b1 = int(floor((y + radius - self.board_y) / self.cell))\n", "\n", " for c in range(c0, c1 + 1):\n", " for bottom_row in range(b0, b1 + 1):\n", " r = self.rows - 1 - bottom_row\n", " if c < 0 or c >= self.cols or r < 0 or r >= self.rows:\n", " return True\n", " if self.maze[r][c] == 1:\n", " left = self.board_x + c * self.cell\n", " bottom = self.board_y + bottom_row * self.cell\n", " right = left + self.cell\n", " top = bottom + self.cell\n", " closest_x = min(max(x, left), right)\n", " closest_y = min(max(y, bottom), top)\n", " dx = x - closest_x\n", " dy = y - closest_y\n", " if dx * dx + dy * dy < radius * radius:\n", " return True\n", " return False\n", "\n", " def _record_trail_point(self, force=False):\n", " if self.ball_x is None or not self.cell:\n", " return\n", " rel = (\n", " (self.ball_x - self.board_x) / self.cell,\n", " (self.ball_y - self.board_y) / self.cell,\n", " )\n", " if self._last_trail_point is not None and not force:\n", " dx = rel[0] - self._last_trail_point[0]\n", " dy = rel[1] - self._last_trail_point[1]\n", " if dx * dx + dy * dy < 0.16:\n", " return\n", " self.trail_points.append(rel)\n", " self.trail_points = self.trail_points[-self.max_trail_dots:]\n", " self._last_trail_point = rel\n", " self._update_trail_instructions()\n", "\n", " def step(self, dt, accel_x, accel_y):\n", " if self.won:\n", " return\n", "\n", " self._update_metrics()\n", " self._ensure_ball_position()\n", " if self.ball_x is None or not self.cell:\n", " return\n", "\n", " dt = min(max(dt, 0.0), 0.05)\n", "\n", " dead_zone = 0.04\n", " if abs(accel_x) < dead_zone:\n", " accel_x = 0\n", " if abs(accel_y) < dead_zone:\n", " accel_y = 0\n", "\n", " force = self.cell * 36.0\n", " self.velocity_x += accel_x * force * dt\n", " self.velocity_y += accel_y * force * dt\n", "\n", " friction = max(0.0, 1.0 - 2.1 * dt)\n", " self.velocity_x *= friction\n", " self.velocity_y *= friction\n", "\n", " max_speed = self.cell * 7.5\n", " speed_sq = self.velocity_x * self.velocity_x + self.velocity_y * self.velocity_y\n", " if speed_sq > max_speed * max_speed:\n", " scale = max_speed / (speed_sq ** 0.5)\n", " self.velocity_x *= scale\n", " self.velocity_y *= scale\n", "\n", " next_x = self.ball_x + self.velocity_x * dt\n", " if not self._circle_hits_wall(next_x, self.ball_y):\n", " self.ball_x = next_x\n", " else:\n", " self.velocity_x *= -0.25\n", "\n", " next_y = self.ball_y + self.velocity_y * dt\n", " if not self._circle_hits_wall(self.ball_x, next_y):\n", " self.ball_y = next_y\n", " else:\n", " self.velocity_y *= -0.25\n", "\n", " self._record_trail_point()\n", " current_cell = self._cell_at_point(self.ball_x, self.ball_y)\n", " if current_cell == self.goal_cell:\n", " self.won = True\n", " self.velocity_x = 0\n", " self.velocity_y = 0\n", "\n", " self._update_marker_instruction()\n", "\n", " def _add_static_line(self, points, width=None, color=BLUEPRINT):\n", " self.static_group.add(Color(color[0], color[1], color[2], color[3]))\n", " self.static_group.add(Line(points=points, width=width or max(dp(0.8), self.cell * 0.035)))\n", "\n", " def _redraw_static_map(self):\n", " self.static_group.clear()\n", "\n", " self.static_group.add(Color(*PAPER_BG))\n", " self.static_group.add(Rectangle(pos=self.pos, size=self.size))\n", "\n", " if not self.maze or not self.cell:\n", " return\n", "\n", " board_w = self.cell * self.cols\n", " board_h = self.cell * self.rows\n", " shadow_offset = dp(3)\n", "\n", " self.static_group.add(Color(0.08, 0.12, 0.16, 0.10))\n", " self.static_group.add(\n", " RoundedRectangle(\n", " pos=(self.board_x + shadow_offset, self.board_y - shadow_offset),\n", " size=(board_w, board_h),\n", " radius=[dp(16)],\n", " )\n", " )\n", "\n", " self.static_group.add(Color(1.0, 0.988, 0.94, 1))\n", " self.static_group.add(\n", " RoundedRectangle(\n", " pos=(self.board_x, self.board_y),\n", " size=(board_w, board_h),\n", " radius=[dp(16)],\n", " )\n", " )\n", "\n", " grid_width = max(dp(0.45), self.cell * 0.012)\n", " self.static_group.add(Color(0.38, 0.56, 0.72, 0.18))\n", " for c in range(self.cols + 1):\n", " x = self.board_x + c * self.cell\n", " self.static_group.add(Line(points=[x, self.board_y, x, self.board_y + board_h], width=grid_width))\n", " for r in range(self.rows + 1):\n", " y = self.board_y + r * self.cell\n", " self.static_group.add(Line(points=[self.board_x, y, self.board_x + board_w, y], width=grid_width))\n", "\n", " self.static_group.add(Color(0.12, 0.32, 0.58, 0.045))\n", " for r, row in enumerate(self.maze):\n", " for c, value in enumerate(row):\n", " if value == 1:\n", " self.static_group.add(\n", " Rectangle(\n", " pos=(self.board_x + c * self.cell, self.board_y + (self.rows - 1 - r) * self.cell),\n", " size=(self.cell, self.cell),\n", " )\n", " )\n", "\n", " line_width = max(dp(1.0), self.cell * 0.045)\n", " self.static_group.add(Color(*BLUEPRINT))\n", " for r, row in enumerate(self.maze):\n", " for c, value in enumerate(row):\n", " if value != 1:\n", " continue\n", "\n", " left = self.board_x + c * self.cell\n", " bottom = self.board_y + (self.rows - 1 - r) * self.cell\n", " right = left + self.cell\n", " top = bottom + self.cell\n", "\n", " if r == 0 or self.maze[r - 1][c] == 0:\n", " self.static_group.add(Line(points=[left, top, right, top], width=line_width))\n", " if r == self.rows - 1 or self.maze[r + 1][c] == 0:\n", " self.static_group.add(Line(points=[left, bottom, right, bottom], width=line_width))\n", " if c == 0 or self.maze[r][c - 1] == 0:\n", " self.static_group.add(Line(points=[left, bottom, left, top], width=line_width))\n", " if c == self.cols - 1 or self.maze[r][c + 1] == 0:\n", " self.static_group.add(Line(points=[right, bottom, right, top], width=line_width))\n", "\n", " self.static_group.add(Color(0.02, 0.16, 0.34, 0.82))\n", " self.static_group.add(\n", " Line(\n", " rounded_rectangle=(self.board_x, self.board_y, board_w, board_h, dp(16)),\n", " width=max(dp(1.1), self.cell * 0.035),\n", " )\n", " )\n", "\n", " if self.goal_cell:\n", " cx, cy = self._cell_center(self.goal_cell)\n", " pole_bottom = cy - self.cell * 0.34\n", " pole_top = cy + self.cell * 0.36\n", " flag_w = self.cell * 0.48\n", " flag_h = self.cell * 0.24\n", " self.static_group.add(Color(0.08, 0.24, 0.43, 1))\n", " self.static_group.add(Line(points=[cx, pole_bottom, cx, pole_top], width=max(dp(1.2), self.cell * 0.045)))\n", " self.static_group.add(Color(*FLAG_RED))\n", " self.static_group.add(\n", " Rectangle(\n", " pos=(cx, pole_top - flag_h),\n", " size=(flag_w, flag_h),\n", " )\n", " )\n", " self.static_group.add(Color(0.55, 0.05, 0.04, 1))\n", " self.static_group.add(\n", " Line(\n", " rectangle=(cx, pole_top - flag_h, flag_w, flag_h),\n", " width=max(dp(0.8), self.cell * 0.025),\n", " )\n", " )\n", "\n", " def _update_trail_instructions(self):\n", " visible = self.trail_points[-self.max_trail_dots:]\n", " dot_radius = max(dp(1.7), self.cell * 0.075) if self.cell else dp(2)\n", "\n", " for index, (dot_color, dot) in enumerate(self.trail_refs):\n", " if index < len(visible) and self.cell:\n", " rel_x, rel_y = visible[index]\n", " px = self.board_x + rel_x * self.cell\n", " py = self.board_y + rel_y * self.cell\n", " age = index / max(1, len(visible) - 1)\n", " alpha = 0.16 + 0.58 * age\n", " dot_color.rgba = (TRAIL_BLUE[0], TRAIL_BLUE[1], TRAIL_BLUE[2], alpha)\n", " dot.pos = (px - dot_radius, py - dot_radius)\n", " dot.size = (dot_radius * 2, dot_radius * 2)\n", " else:\n", " dot_color.rgba = (TRAIL_BLUE[0], TRAIL_BLUE[1], TRAIL_BLUE[2], 0)\n", " dot.pos = (-100, -100)\n", " dot.size = (0, 0)\n", "\n", " def _update_marker_instruction(self):\n", " if self.ball_x is None or not self.cell:\n", " self.marker_shadow_color.rgba = (0.08, 0.10, 0.12, 0)\n", " self.marker_fill_color.rgba = (PLAYER_RED[0], PLAYER_RED[1], PLAYER_RED[2], 0)\n", " self.marker_outline_color.rgba = (0.48, 0.04, 0.03, 0)\n", " return\n", "\n", " radius = self.ball_radius\n", " self.marker_shadow_color.rgba = (0.08, 0.10, 0.12, 0.18)\n", " self.marker_shadow.pos = (\n", " self.ball_x - radius + dp(1.3),\n", " self.ball_y - radius - dp(1.3),\n", " )\n", " self.marker_shadow.size = (radius * 2, radius * 2)\n", "\n", " self.marker_fill_color.rgba = PLAYER_RED\n", " self.marker_fill.pos = (self.ball_x - radius, self.ball_y - radius)\n", " self.marker_fill.size = (radius * 2, radius * 2)\n", "\n", " self.marker_outline_color.rgba = (0.48, 0.04, 0.03, 1)\n", " self.marker_outline.circle = (self.ball_x, self.ball_y, radius)\n", " self.marker_outline.width = max(dp(1.0), self.cell * 0.035)\n", "\n", "\n", "Factory.register(\"PaperButton\", cls=PaperButton)\n", "Factory.register(\"PaperCardLabel\", cls=PaperCardLabel)\n", "Factory.register(\"AccelMazeBoard\", cls=AccelMazeBoard)\n", "\n", "\n", "class AccelerometerMazeController:\n", " def __init__(self, ui, previous_orientation=None, orientation_locked=False):\n", " self.ui = ui\n", " self.board = ui.ids.board_widget\n", " self.status_label = ui.ids.status_label\n", " self.previous_orientation = previous_orientation\n", " self.orientation_locked = orientation_locked\n", " self.event = None\n", " self.paused = False\n", " self.accelerometer_enabled = False\n", " self.calibration = None\n", " self.last_status_update = 0\n", " self.last_error = None\n", " self.state = {\n", " \"ok\": True,\n", " \"stage\": \"starting\",\n", " \"message\": \"Starting paper map maze.\",\n", " \"error\": None,\n", " \"orientation_locked\": bool(orientation_locked),\n", " \"accelerometer_enabled\": False,\n", " \"paused\": False,\n", " \"won\": False,\n", " \"style\": \"bright paper map\",\n", " \"static_map_cached\": True,\n", " }\n", " globals()[\"maze_game_state\"] = self.state\n", "\n", " def start(self):\n", " self.restart()\n", " try:\n", " accelerometer.enable()\n", " self.accelerometer_enabled = True\n", " self.state[\"accelerometer_enabled\"] = True\n", " self._set_status(\"Ready. Hold the phone normally, then tilt to move.\")\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not enable accelerometer\")\n", " self.last_error = f\"{type(exc).__name__}: {exc}\"\n", " self.state.update(\n", " ok=False,\n", " stage=\"enable_accelerometer\",\n", " error=self.last_error,\n", " message=\"Accelerometer could not be enabled.\",\n", " )\n", " self._set_status(\"Accelerometer error: \" + self.last_error)\n", "\n", " self.event = Clock.schedule_interval(self._tick, 1 / 60.0)\n", " self.state[\"stage\"] = \"running\"\n", "\n", " def cleanup(self, restore_orientation=False):\n", " if self.event is not None:\n", " self.event.cancel()\n", " self.event = None\n", " try:\n", " if self.accelerometer_enabled:\n", " accelerometer.disable()\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not disable accelerometer\")\n", " self.accelerometer_enabled = False\n", " self.state[\"accelerometer_enabled\"] = False\n", "\n", " if restore_orientation and self.previous_orientation is not None:\n", " try:\n", " from jnius import autoclass\n", "\n", " PythonActivity = autoclass(\"org.kivy.android.PythonActivity\")\n", " activity = PythonActivity.mActivity\n", " if activity is not None:\n", " activity.setRequestedOrientation(int(self.previous_orientation))\n", " self.state[\"orientation_locked\"] = False\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not restore previous orientation\")\n", "\n", " def restart(self, *args):\n", " maze, start, goal = _make_accel_maze()\n", " self.board.configure(maze, start, goal)\n", " self.paused = False\n", " self.calibration = None\n", " self.state.update(\n", " ok=True,\n", " stage=\"running\",\n", " message=\"New paper map maze started.\",\n", " error=None,\n", " paused=False,\n", " won=False,\n", " rows=len(maze),\n", " cols=len(maze[0]) if maze else 0,\n", " trail_dots=0,\n", " )\n", " self.ui.ids.pause_button.text = \"Pause\"\n", " self._set_status(\"New map. Tilt to move the red marker to the flag.\")\n", "\n", " def calibrate(self, *args):\n", " raw = self._read_acceleration()\n", " if raw is None:\n", " self._set_status(\"Waiting for accelerometer data. Try again in a moment.\")\n", " self.state[\"message\"] = \"Calibration waiting for accelerometer data.\"\n", " return\n", " self.calibration = (raw[0], raw[1])\n", " self.state[\"calibration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", " self._set_status(\"Calibrated. Tilt gently to follow the route.\")\n", "\n", " def toggle_pause(self, *args):\n", " self.paused = not self.paused\n", " self.state[\"paused\"] = self.paused\n", " self.ui.ids.pause_button.text = \"Resume\" if self.paused else \"Pause\"\n", " self._set_status(\"Paused.\" if self.paused else \"Running. Tilt to move.\")\n", "\n", " def _set_status(self, message):\n", " self.status_label.text = str(message)\n", " self.state[\"message\"] = str(message)\n", "\n", " def _read_acceleration(self):\n", " raw = accelerometer.acceleration\n", " if not raw or len(raw) < 2:\n", " return None\n", " if raw[0] is None or raw[1] is None:\n", " return None\n", " return float(raw[0]), float(raw[1])\n", "\n", " def _tick(self, dt):\n", " try:\n", " if self.paused:\n", " return\n", "\n", " raw = self._read_acceleration()\n", " if raw is None:\n", " if Clock.get_time() - self.last_status_update > 1.5:\n", " self.last_status_update = Clock.get_time()\n", " self._set_status(\"Waiting for accelerometer data.\")\n", " return\n", "\n", " if self.calibration is None:\n", " self.calibration = (raw[0], raw[1])\n", " self.state[\"calibration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", "\n", " accel_x = raw[0] - self.calibration[0]\n", " accel_y = raw[1] - self.calibration[1]\n", " self.state[\"last_acceleration\"] = {\"x\": raw[0], \"y\": raw[1]}\n", " self.board.step(dt, accel_x, accel_y)\n", " self.state[\"trail_dots\"] = len(self.board.trail_points)\n", "\n", " if self.board.won and not self.state.get(\"won\"):\n", " self.state[\"won\"] = True\n", " self.state[\"stage\"] = \"won\"\n", " self._set_status(\"You reached the flag. Press Restart for a new map.\")\n", "\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Maze game loop failed\")\n", " self.last_error = f\"{type(exc).__name__}: {exc}\"\n", " self.state.update(\n", " ok=False,\n", " stage=\"game_loop\",\n", " error=self.last_error,\n", " message=\"Maze game loop error.\",\n", " )\n", " self._set_status(\"Game error: \" + self.last_error)\n", " self.paused = True\n", " self.state[\"paused\"] = True\n", "\n", "\n", "def _install_accelerometer_maze_game():\n", " try:\n", " old_cleanup = globals().get(\"maze_game_cleanup\")\n", " if callable(old_cleanup):\n", " try:\n", " old_cleanup(restore_orientation=False)\n", " except Exception:\n", " Logger.exception(\"PythonHere: Previous maze cleanup failed\")\n", " except Exception:\n", " Logger.exception(\"PythonHere: Could not inspect previous maze cleanup\")\n", "\n", " previous_orientation = None\n", " orientation_locked = False\n", "\n", " try:\n", " from jnius import autoclass\n", "\n", " PythonActivity = autoclass(\"org.kivy.android.PythonActivity\")\n", " ActivityInfo = autoclass(\"android.content.pm.ActivityInfo\")\n", " activity = PythonActivity.mActivity\n", " if activity is not None:\n", " try:\n", " previous_orientation = int(activity.getRequestedOrientation())\n", " except Exception:\n", " previous_orientation = None\n", " activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT)\n", " orientation_locked = True\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not lock screen orientation\")\n", " globals()[\"maze_game_orientation_error\"] = f\"{type(exc).__name__}: {exc}\"\n", "\n", " KV = \"\"\"\n", "#:import dp kivy.metrics.dp\n", "#:import sp kivy.metrics.sp\n", "\n", "BoxLayout:\n", " orientation: \"vertical\"\n", " padding: dp(10)\n", " spacing: dp(8)\n", " canvas.before:\n", " Color:\n", " rgba: 0.985, 0.965, 0.905, 1\n", " Rectangle:\n", " pos: self.pos\n", " size: self.size\n", "\n", " PaperCardLabel:\n", " id: title_label\n", " text: \"Paper Map Maze\"\n", " size_hint_y: None\n", " height: dp(46)\n", " font_size: sp(24)\n", " bold: True\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " PaperCardLabel:\n", " id: instruction_label\n", " text: \"Tilt the phone to move the red marker to the flag.\"\n", " size_hint_y: None\n", " height: dp(50)\n", " font_size: sp(15)\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\n", " AccelMazeBoard:\n", " id: board_widget\n", " size_hint_y: 1\n", "\n", " GridLayout:\n", " cols: 3\n", " spacing: dp(8)\n", " size_hint_y: None\n", " height: dp(58)\n", "\n", " PaperButton:\n", " id: calibrate_button\n", " text: \"Calibrate\"\n", " font_size: sp(16)\n", "\n", " PaperButton:\n", " id: restart_button\n", " text: \"Restart\"\n", " font_size: sp(16)\n", "\n", " PaperButton:\n", " id: pause_button\n", " text: \"Pause\"\n", " font_size: sp(16)\n", "\n", " PaperCardLabel:\n", " id: status_label\n", " text: \"Starting.\"\n", " size_hint_y: None\n", " height: dp(56)\n", " font_size: sp(14)\n", " halign: \"center\"\n", " valign: \"middle\"\n", " text_size: self.size\n", "\"\"\"\n", "\n", " try:\n", " ui = Builder.load_string(KV)\n", " if ui is None:\n", " raise RuntimeError(\"Builder.load_string returned None\")\n", "\n", " root.clear_widgets()\n", " root.add_widget(ui)\n", "\n", " controller = AccelerometerMazeController(\n", " ui,\n", " previous_orientation=previous_orientation,\n", " orientation_locked=orientation_locked,\n", " )\n", "\n", " ui.ids.calibrate_button.bind(on_release=controller.calibrate)\n", " ui.ids.restart_button.bind(on_release=controller.restart)\n", " ui.ids.pause_button.bind(on_release=controller.toggle_pause)\n", "\n", " globals()[\"maze_game_ui\"] = ui\n", " globals()[\"maze_game_controller\"] = controller\n", "\n", " def maze_game_cleanup(restore_orientation=False):\n", " controller.cleanup(restore_orientation=restore_orientation)\n", "\n", " globals()[\"maze_game_cleanup\"] = maze_game_cleanup\n", "\n", " controller.start()\n", "\n", " if orientation_locked:\n", " controller.state[\"orientation_message\"] = \"Portrait orientation locked.\"\n", " else:\n", " controller.state[\"orientation_message\"] = \"Portrait lock was not confirmed.\"\n", "\n", " except Exception as exc:\n", " Logger.exception(\"PythonHere: Could not load accelerometer maze game\")\n", " globals()[\"maze_game_state\"] = {\n", " \"ok\": False,\n", " \"stage\": \"install\",\n", " \"error\": f\"{type(exc).__name__}: {exc}\",\n", " \"message\": \"Could not load accelerometer maze game.\",\n", " }\n", " _maze_show_error(\"Maze error\", f\"{type(exc).__name__}: {exc}\")\n", "\n", "\n", "_install_accelerometer_maze_game()" ] }, { "cell_type": "code", "execution_count": 12, "id": "f3e8a21f", "metadata": { "execution": { "iopub.execute_input": "2026-06-08T18:50:00.922643Z", "iopub.status.busy": "2026-06-08T18:50:00.922478Z", "iopub.status.idle": "2026-06-08T18:50:04.215694Z", "shell.execute_reply": "2026-06-08T18:50:04.215287Z" } }, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAHrCAIAAABpcxfgAADBbUlEQVR4Ae2dB4AdVdXHX6/bd9N7D2kkhJ4AoXfpin6AiooiKkWaWFBBFAWlKShFEWyAFOm9JhAglCQkpPeebN/Xy/c7d957+/btm3mzkLKbzLC8zMw999xzzj23zNz/nGuPhzbYrMOywJ5hAceeoaalpWUBsYDl7pYf7EEWcJnUNZ22pfjfOiwLdD8LOOwcpsQq4e44eCqZdjjsbrfD5naaYmkRWRbYyRaIJ+PxVCqVdjhLuL2Ru5Pf6bS7y7y2ZHLzttDKDa1pW9pcK9rJ6lrF7aEWoDu22+xD+5X1rg3YnM5kJJZUvbOeOXTdnWzegDseS/7r6U/vfHzB/OX1zU1RPS7WfcsCu9ACFZXeCcNrLjx13JeOHOHxu6KhON10UXnsRV9E0q97gp65i7acf8Mbc+ZuGDO61+mHjRg3rNaWTpUYLYoWYt20LLBjLCCPk3bHghXbHn192aLFW6ZO6nffNYdOGtMr1hZjBt65zCLunkylvUHPczNXnfGjF4JBz62XHHbWkaNcLk/nzNYdywLdxAKJROzhl5dcfMvrbW2x//76mOOmDYm2xZydPL7Q3aVf97nmLa0/+FuP9esVfO7W04cPrLMlI4lkqpsoZolhWaCzBVxOh83pW75263EXP7phS9usu0+bOLImFkkU9PGF7g6jtN0+7TtPrNnY+va9Xxo6oDoejbhd1juZzha27nQvC8QTSbfXt3Jdw0Hf+M+gvmUz7zrF3unVeYdlpmQy5fJ7Hnll2Xsfbbjt8sOGDqizfL17Vakljb4F6JRxV5wW18WBcWOcGZfOz9Ghd0+n0w6P67ALn9jaFFv473PSvMgsMt3Pz26dWxboXhZIpXl2te919oN1lZ7X7zwlFUvkL0G19+50/G63s6E+zDvHM2aMsDs8zOO7lyqG0tBWOx6G1DsmEXtlZSgsAPNqSYUJn+k6x61zDWUF6JzymUrqaZlwWlwXB567bNvWrW1ujxOD5JRof+8uGAG3Y+WmFt6vjx9Woyig6zHdu10eMJBWk1kwDwxk5peXcxb5PCf0Kza7es5JpxAgn5XdRc+ijJlK4fj5SZ/h3IBbux06juOfoZSemUVsiwO3NEWXrm3s07c8FU3m3sK3u3tON8jjiQ4znlxStz2hTW+pb8XBtHdPLA5Ulnk9Xp8tHbdR6ztpscAeDscbW6M4c3nAw59qe8pmdntjYzgUlYG1tsLrcWP2z+Px9samcDiSoPnUVvo90s7buW3e2pZMpZwOR68qX/443m3rbkcIpjlwJBorYF7E3aHYSe5RIMtnumSooj/b0tB6yHcfbQnF0JN3pjj9wN5lXzhk+NXn7hvwucH9UPEMX1qvmt/lq1viFaw2UH5+EpfQa8A4CEjSBNS4kIcsufuJZNrl8T41c8m3bnyFl2LTJvZ7/LcnS341lQxF4sdc+sSqTS10+k/ceOJBew9KxmUdhKcjSoVv7n2ZygFbOxlJzE/SSqdQp9vz07tff/C5TxH5J1/d94rzDkrGwtQZ99+dv/bkK5+GcmCv4Ot/PL0s6EknRS89LTSe2V8pVjugRxKuGK+y97JUPeFfPaHb5+49QQtdGambcDTRGo6PHVJ14IR+e4/stXpT6/V3vf2tX7+Mz1DheInD5XK6vfiE3WXPPJYw9XC51MTAxn1S7U5pFVoxahYoPsR98may4AEup5owSBaHy50vE07fGorjH298vH7Rim12p0vWKxzuNz9a/9HSrfg6EiYVf2GOl/O0BHO3MMm0IqedsqgtpNKStPv5pXAeiydbw/BO//f15Yl41OFyKDLHY68t39IYjkYT0verQwpy6mmB7qKL+uNcHBvpsAB6qdI93CoqgMa8x/0W7917nBoI7HbZE4nUHZfOmLzXQNz72ZlLv3r9S6wtvzNv7cGTh9DBrVnfsGJDi9vlmDC8trzcn04yEKQ3Nzb7PK7qKv/7n6wLRRL779XbF/CmE+IreGEiFvtw8UbujxxYNaBvVToZpz9mJKHL61UdmD13bVW5Z8yQ2jSOrA7cFFCe1+Oq39b2xMwVY0f01Xzl8TeWk5GiwXKoDibt9rp5tpi7aGNDc7SuyjdhVC/xtWSqtS3W3BLtUxcMtUXe/3RzXaV/4ujetk7TffphGFUEPPOXb5uzcOMBkwY5nfFIOPTc7FXlfjdjhTZc4LtOj6e1NTR/+cZoPDm0b/mQATU2FE+nGhpCWpNjiEBIfslYFnDTNux219JV29Zubq0u9+49phfDBgZp7/k1VXvm7+7j7lqnzPw4kYzbU/Hjpw0f3r/i3Xkbl61rPnhv+6W3vPa3pxc21rfZXM6Rg6tuvfTQE6aNWbpqw2Hfe3RgrzJ897k3ltm9rimje/3j58eOGVKDv7w7f/13b3ptzsJNtniyui541TlTrzrvgIbmlhkXPUa/euCEvg8+Ou/rZ02+76fHp2IRrfZxsng0OWZwlcNho6Vd/pV9PF53U1Pr02+vGjukOuh3z1m0RU2a3POXrrvoptfemrshFYm7A54TDh76l6uO6F1b9cf/fvCLu985fvqwj5dsXbZ0q7/a/42Txt1yyWHSkDp6GBi+fffq/dw7qx57Y/kBkwYzkrwzf+38ZdtmTB346aoGJBRvdrgffmnhj+6atWxVgy2Zrqzxf//MvX95wcHhcOyAbz68nhcXLgdTr4qgZ2tT+PyTxt162dFtobYf3v7qg89+2tYcsXvdxx4w+J4fHdm/V3kqleiZ85oOViuwYYe0nniBS7mcTD9873+ygepk4WDs4Kq/P/3xLbe9yWz+0d+f/rNv7L9sXdPFf3gjHAnTEzP9mL+inrn19T+YceD4vh/M23jlH9+yO5xbtrX+3y+en7Ng09dPGnf99w+tDHquvu3NF95exgMosyY4P/768rHj+uDZjBvSMatDTmKJIX3L8ZI58zZ+uGhT2uZ/ec7aNavqTz10eFWZl/FHHqbTya9e9+Ibry399qkT/nfrWYdNGfDEs5/e9M85DFEwDydSr85Ze9yBg6/59kH033f856NHXlnscLJikpllUQjtinZy8IS+44fXPPrG8lAoZLM5H3ltOUmnHDJMZjk2Gw8ty9ZsPfunzy5f33THlTP+feOJ9NbX3zP75fdWBgLew6b0P+6AwSccPHzyqLrGligj2NTRdTab6xf3vvPnf3wwenD1DRcffvL0oc+9tvTy29/cPbp2jLNb9e4et/Oy29+sCHrj8eQHi7dsWN90+IFDJo/tU1nue//Jb9RW+Qb3r548oupvz366sT60YUszLzXoAqvLvP/55XF9e/c74YABR/7g8ZnzNjY1t70we9XSJVu/cPTo+356gs3mG9w7cP5Pn2NOcsTUgfSINJK/XDXjK8eNd6R48xOn2fARDNaUw26PxpLnHjfmnv98/PgbK/YdP+LhV5bSf580bdjL76+VaYY8RiXuvGKG2+kY1r8iGCxftWHbq2+v/GRFPbMZr8dpjyS+cMLYO644Xj3Epn99z+wn31r5pWPGaa8xtUJk+S+WxH1POWT4L26fOefTzdP2HvD4G8v2Gdt76pjeDS3R2gof72GZa836y1llfjfNMmV30URXrWz4aMnWow4Yee9PjqaFwO2sHz3Z2BC6+P/2Oe+kKVu2bXno5aUVdcG//eSoSaOHh0PbJi6vf/WDdes2NQ7oW7kbTGl2K3fHmd5bsImZqcth71sbvPDsKdd+4wB6+9FDa/782Ny/PD5/xfomB0T0jrxXwUFd8ljGkyG/iWTL6MFV/eqCi1c3btja9unqBofXtXBl/T5ffYCpbUTmSGkmCXw/gIvQQzMU4PcpeS5tP8TlnXYmBodMHjBoaPWzs1dfdObml99ffdDe/ScOr8ULmTnE5cWod1Dviuv+OvupWStbQzFaqSvQ3nlTHLP/ZCoKemn/cX0YoDY2hGzphPaOtb0wu403UV88fMQvbn/r+dmreeBct7z+4i/ujXPT3tCSyXptVeWSNU1X3zXr7Xkb0dELkd+tjRLhUMwf8F9x22uPPLPw8OlDf33h9LQtuXJDC0L6fK6v/+oleQVE0fVtba2xNZvbBvStZsjIvcBuF6NHne0+7s50mWp+6LrjJo/ty2NoTbk3WBa0pXjz6rj5wXcv//XLk/cZeM81x3hd9gtvejXSHM0foDWfZfavPVnitVQ2BwPF2CE1vL7F/6ZN6jdyYGUOgxGKxjXiwup22BtaYsFg4AvTh9371MKf3f3Olobwz84fiU8zUaFnpymCVj35yifnfLDu21+ZfOaRE16fs+xX976rmmGGWa4NMfgU8s9d2+2bG8LjRvYbs1cfpu8LVjZ4yr2sJq7bwsSGh9t0wO/+ZOnGwy96lEKv//ZBU8cO+P0/3/3fK0vUpw8pfyDw7+fn3/yPDwYOrvrzlUd4vaw+is78T1+Aptormv326k07Z61A5mw5sXIy9LST3cfdpTLS6QF1wYG9qxjpOU/G+fyKt9SpV+asdfndV3xlyumH7x0JbeMtn+bruBJVG4uLT7mc5YtWbdywNVRV7uWl9YgBlel4iinBg79gMuNn5W3Vuk1DBtQ1NDTLyqkj84a+szPCGY/BOc46fOR9Ty185NVlddX+U6YPbQ1nljz8XtfajfULV9QPG1l7x2WHuTzVGzbXp1kAllFHHXYbD9xOB6tUjtkLN8OuP1+m2envOwC4mRWFogw13rMOH/HrB+as3NC83979hg/qvWDFIkwhGrmdb368LtIaPeu4sZd95TBY//XJj+GmxPN8tGjVxX94s6rc98C1x4wa0t9mCzMw8dRRGfQ2t0Uv+eLkg/YeQ5bGps28ufL5eVsVV9MwTcSe+rv7uDudENMYJhspJibxhMvhYCxW6+jOAb3LeEa87+mFDW3px16TiTtfmvM85+XzRoe9LZL40s+eO+aA4c/OWta4re3M48aUl5edePCwUaPqXpi54sjvPXT41CFL19Tf/8S8h2486bRDh0fjrGRp74EKa13GhwRdZDqViB80sf+4YdUfLNh88qHDB/WvXb+pAT9jIhFLJKsrKnnlx/Pu1Xe+3ac2eNtDHzm9buZLNE4BPgQ8z8xaeeGNz1aX+/761AJmZqcdOkLm8Xlti/IpCHra1amHDL/jv/OaWqOnTB+etnnkOZX/KCyV5s0jT7WzF2y65V9vrNrYzCDAhAYZEono+b96ub45MrBP+V+emH/HI3N5WOdd08++edhXjh79u3tnn/XT5849diUj0h//+zHPss/dcrqjJ609FtZL7no3cXf6s/KAOxTxuHBzu12WJVVfKf1cKvmj8/ZdsEIeuV6etXLGAUP2H9eb7xJZ45w0ojaWSNUwUqdtP7vzDYfbddDUgb/93iF4a99eZQ9fd/wP/vA6K0SvzFrp9HtOOXL0PmP70px4bdcmvW+2M87ZUt79O8rKPGUBD4u7Xl/gzBkjP1205ctHj2bSCxVvdULlCZIqKyp+892Dr/7TrJsfeD9Q5j3+wCHvLNi0rSmSTER50kjHk6MHVb347uply+uDVf4rzt331BmjUolY/veXPGRTkCwY2+KTx/TmFQ2vOGmKdlsCH2UxFSFDodjRBwz73pcn3/fkgktvfHXY8Bqes1+avXpzfai5pZXi+vcqSySTz7y9iodmsA+81GIS98sLDqSl3P/Mwt/cN5shbNTQmm+cPF4GtLzGlqdxDzttBwDTKXiD7vfnbdrv64/e//Njzjtp70QsLB+J9ISDzoxnLH6ZiuBz+SLTD7J0mojFcQjUmbpX71A43tQcLa8MbNzUvP+3HqKjnXPflzY0RFpbI/vt1UcWgNQyk50V01Ri3tJtTa2xPrX+UUNq6WKJ8IBnUBBvRToZh3cyiaa2GE2OVDyEDw6Qqq7Sx/Mxr8FFwnSa15EQsM65flPj0rVNQ/uVD+5ftXVbKw2vb6+q3z04++qbXvv+V/f9zUWHvjd/Xe+awF7De7EwlK8RYvCQGo7EcXeEp9vleVceTCv9TOE4QWAeSjEF5dK7L1y2dVtzeO+RdeVB7ybetbsdAIoYDahxegV6BzoFBEMfjZvNwXSrYdXGFp/bOX54rc/vtyUzM7GOYnTHKwY3l8f/96c+/uq1z79023FHThuR/xWfbu/esxozXXptTUDMzzy840SDysR9ARAcMJHVVvqvOM9wAcFvOalj3IKuncnJpJH9eD8oUXWyK4ipeBy2E0f3YQ4tfBNxctPF1lZrBQFsFH55R9rrdfWWPlIedZlp4Fi964LaeYGEqXisf5/y/n2qIWXyVVfLUzVwAwoi2ImDMSTg8x2271AuKVf8scORLi/zlJczKMmKP79052XQqKkbT9W967IyyJwnsdeIXkqFBAR9epfLFCiVqtG06MBWxJapfTI2sG/lwL7IBm0iBUih2FBWkLX7XBZWS55k7e4uc4B4kpXImmo/y9fnnQRVgZXz8nW/U5xGJC70DBFUPJ56VF2U1FySqW3S4XFQs3TGzC44SaViqQRTFOnsNOU4xXDpeJxfbmWqXGbn4so5Mo048yvuRWomUdpdQtBpWmp+RmEus2xS5amXc67cXnm5lGyN4u5IFI9FGQYy5XYohjk+rPMKUpe5UvNl4CbtFmpKETVk4BJCzVwducp99WfHFFqnQa6iAnTM2K2u0MDGSE40jkG9fLYEIPB28drdHap4LFVTEzh0cr/H31zxu++HZR7JTCCPuj1f9zvLVLaOYGjRHmEKD6MOU8nBfcqf+/0XmIXLfMNGDKoOsyA4oTqDfQFLZZDCmzmafDGEKM98BRmhzL3G5lymRqn4uceNPXCvPgP7ltMCmFLn5c6VICedWMm9HEW+DNzs4K9ZjgU0ubzaSaZtFNzt9pc0USoxGgnjwPuNrRnQK5iId4B/d6hgei4Mec4xI9esqOedgMPp5VGm2+v4WQSUSk+nAwH34fsNP3TqUCYAMjHYpYf4Xzo1bGD1MdNGjRvR2wrp8xlqA3fFae976pPVqxvPOGRgwOelUtu7ATWla2fLUB4Px04+dNhRhwy9/JY3F63c6PYGeN7a1Z7QLuF2PmMyAaQrLi/ptzPnz8qOWUQyFuU95mdlsIfmowJVJILAohUbL79t5hH79z1t+qB4Sj2Z5Zmk/c2MdpNprMvjWrO59dBvP8485rlbTxs3vK/gMwSn3V18Ik9+69SyADMSXnTxqtezYNmG4y99IpVM/uunB+47biAf3BR0ZIXujvFY6fCWed/8cMP//eylTY3hX11w0Pknj6+pKus4LFhWtizQfSyQ3tbYet+Tn/zsnndryty3XDTphAOHevxl8tKt41HE3SHQPH79xtZLbp318POL63qXHzF10KGT+wd8u36O21F+62rPtoDdDnT5zY83vPrB2s2bW06YPuDac8aNG1aHr3d6xSCGKu7uJLDUDGyImO5vvL+OCMBvz9+0mk8tYzzn7tn2tbTvVhbg3YrH0a/GP31C3VmHDZ4xuS+4QBcfYXbq1zWpdd2dZN5Gk4tQwLSKaFtk6ZrGzQ1tlrd3q+rew4XhUbMs4BpQ5+dVssfj4eMZeXGs/5Bp5O6aKVkL4YS3wk428BBee7iFLfW7kwXofemVEyysiV+W9M72ZSZjJeRFNRwVU2NKK9WywE62AO8MeRvDC5qiuL18YYzcnZGC9kKsd5pNa1N4S2NEVkKs3j3fftb5LrWA5pAEkCoDHmdLx0IsoXRcRe4onq674+ser4uV91ffXcuj6sy5GzfWh73WbmQdzWdd7XILgADtW+OfNqkvm9Ucvt8AAFGxaGFY95yQxefu8iIy6F26quHS299+6pXl/QZUHrXf4L2GVk8aXuvxgC7JZbdOLAvsOgvYbbFYau7ybQtXNrz03uoN65pOOmL4H75/0Mgh1dG2KMDSzpIVcXfp1wOeOQs2H3/p022x5K++c/D5J46rKA/Kk4Cg8KzDskC3soCgpptb2v769IJr7poV9Lie/cMJU8f1ZmLTARunRC50d3zd5XUtWtl4+EVPELnzsd+dPHWvwbZUOMl7eMGPWe8hu1VNW8LwMCmgXSdxYe3+DxetPfXyJ/jw5fW7Th0zpCrRaVZT6O74NPCDYy99+u2PN77z1y9NGNkvFg25+ajB8nPLtbqxBfDbeDLp8QY+WrT+iO88ss+43i/eemIiJp8T5B8d5je8YncH3M/OWvXSW6tuvvTQCSP7x6Mh4ikX5MnPb51bFugOFsBFcdR4JDR5zMA//PCwl99a9czMVTiztmqUk7CDu5OHj9dufWT+4CHV5588LpWM8s1bjtQ6sSzQzS1ArJFUMnz20aMHD62+9ZFPiFTbsXPPi7PJcMC3lc2N4Tmfbj19xnC325dKtkc/7OZ6WuJZFsACODf9tdfrP+PwEe/M37hpU4vHyxfJ7bZp791Zi7W7ncs3tjQ2RvYd01vR5BG2Z7HOLAt0ZwvQb9umjunV0hxdtq4R9Ev+dxrt7q5pwFxHMAhJCbZvHZYFeqIFcF2+LEfyaKzwo7BCd9e8/PM/m9KkpJXpHyUJimaFZwm+RbN1m5vbS/7Pz+ez2d+MIQVIa+6AkhffpsnNMVVUmgN3Zq0LIjDJG3Gh5H+tnfBinzJ4PU8kI7nNYCFv69uZ5Sj58l7uqtAo7cmlzuTbfba22x4fjBcIVqrkz5uuKa5tjNNVrTuXrTaW+Vx26Kr9S5orR8BmO8ygSy694ydqqx9gWIT3ES/aCUdh7961IglCwuOtbDDk0U4kmgna2h3rNjY3NBJlk3BZec5OqwBCLDfsGza3bCOOM8HYzGkqVHZ7S2t0zfom87l01ZHPGzsIpku5XRKkA6A4e31DaP2mls8jv7KWnShoazc0YRCT1stXQmVxbNzcuq0+ZJ6D6mjy2RSea/bEiVesaYgT7sLwQAv8ZNGKrbPnrWV/ng49omHGz5n4Gd1dhgmHc82mlm9c//wFN7xw3s+f+davXvjmr15YvrbpqjveJLLzTf/68H9vrWBnICqmXRm7PRJJtIXiNqfv9//+6N8vLbY5veBzhJt09PLLqYwI2YMzNUCovS8d7rc+3sDWK2mnh5vawJIZDbNb55EvN+BofLTL3H1hbLez3wGbQqrKVnyIPQR1e7FCJRl5M0u0Au2EdEWgyZkjENLcoei1q1y5lEJ4gZbWGFqzg82ND85Ba0I56Yqn8mvZxRpSuuzyx20uie2KVV98b83P733XlrfVsyITW2nSirBK3A7SKs58sY8Atzwk9k/b1WbR0mwyduhML5ns9jbwJARv0gyl+OQoNYKWthjJ6HXBb18lDCXx1oReq1ClQkZhVdF2p+f+pz65+JY3/vHCorN+8izroLwEVJJnNCWjuhSNNLOrMj/vz2d0d+mr0qleVf6rztv3gi9MYKPtb31h/JXnTu1XG/jyUaO9Xi9SAp9sbWk597oXiS4rVZ7kHZHnDw999Mf/zk2lXChBbGXEB7NAQ+eSrd5QTMILyXZ2GdcDwsyl5PRCTFivNOH6tbBIjCfk4pcsEGjZYehwe2SQURkVgVzyx30uMWLK5n7olSU/+cs7iRQDkdzHHR188ZUfXFLRw5ZUOMuJi4Jkgzsuxerwd3vY1UuYa9M1tr4hZhWlA05SbHPFPfHmiivvnJlIuqh3td8q78BEr87iCWcOlV3+JcKrEo/xUy6ddrdXmjrxXzsAQhQ9/gRPNurhBJPKMIuYbp+4C1/5yP5+dFJ2j09YsVAu1rY7nS5HjJ3UMXumIKWdZkalF9ziKcd3b379rY/X01DE4E6HsFT1BSsOAlx+/fqXFq+uZ6HGQ1zYgJtc7IJGEjJrnPnVYlTBFWd45JWlP/7qvrf98EiiuBH92OHAzh66IdFUlZtvdlXIdvj5HHP3dJrI36MH94qEwn1qAmxnFwgGU/HIvU998ocf1FGd9PG3PvzR7E82/uE/H/34vH2dLs/b89aiJLV17EEj66r8/31t2az5m7Y0hG76/vQh/WsffGbu07NWuJzOq87dd8KIXsRaISLUZX94A8uu29wyuG/F735wOCUSt/+aP736waLNl549+diDxsyet+q2hz/CiQ8a3/fiLx/41BsL6UFrK70LVzZee/7++00Y8sI7i+9/eiFfu9AgjzpgKL3H0tVbiby+dkvrYVOWsy/SNXe9RDhcVPjFtw6sLGMj0hSzzytuf4POiZjUg/uWs7vTC7NXs6fFb787vXddxYPPzHtq1grC5n3zCxMOntj3B797mTDtPr/nwhtfvvbr+y/fsPWOR5An9bUTxx1/8HBGjVXr6+/53yeL1jS+OHsRyOz/vLj4ittf/mT5NsQ7YOKQF2cv/dtTCxDvm18Yd/QBw+PRqNvjJTDq7E82Delb8dPz9//lfbPXbmoFjvqLbx1ED3rZrS/Hk7bWULQ/0SelC0zh0NfdN4sOtbEtxh5S++7V56X31tCF33jhtCH9q//08Ptvz9/Aq7bvnDphxtRhV97x2pI1jTP2GYSdCfnb0Nz2jV89+5sLD6mp9P/8nplb6sPjR9T+7JvT73jovdc/WIdNbvr+NK/X96/nFrz+4brmttjEkX0+Wb7lj4/Opbc75oAhXz95IjFinS7XXY98+Pb8jYzYv7lwGk36F399j4iqBFi+9lsHtYViv7h35qr1zSMGVV77jQPpUvgu7qk3lyxcVX/bIx/TJyKGx+NavGrLbx+Yw3fWwwdU/Oz8AwCfX3/frI8WbR7SryIcTd526aG032wf+Nn9/jP27lqBdE7pdDwcxbYpfjnH7T5YtIU+lG6YuP1ExZ84ou6HZ0+mvSYTsQMnDWIvoTMOGzFx1CCCixOU+bpvH9Gnxv/wK0sWrdyMC95xxbHEF7/6TzPpG2SK73DMWbR5n9G9/nTVieyo+PirC9mTg61Jv3fW1AtPm3Drfz4OhSOX3/HmN08e98crjmHjlzc+WAb6edHqhivOPYTNwO58bF5jc+t19717/XcOuv6CA35x3+yGphDTjVFDep13/Ngj9hl40iHjrvzj63zm+OcfnUyH9LO737Y7PAoK5/ho8Vb2yvvjlce/PW/DvGXb/nT1yXj/E28uW7JqK6PT7y8+/Kdf3+/Hf56F4vy9t3DT6vWNG7eFqLkf3zWTHXJ+e9H0X/3tvc3bWqmioQNq2M9sxpT+xx44Bo+h9V5xzrSTDh5656PzmppDePN13z7ohm8f+Mv73q1vbKOvpT9ktMTVrjzvkJ/95W3Eu/enpyxZ2/Toa0v+/Pg8ogf//pJjkQ0nyFS73YFx2Dzw1stOWLel7fl3VnEyqHf5PU9+QsXUN0X+eMWR55+413V/fY8nJ+x5wPg+554whcnU5obQVbe/evqMkaOH9rvmzjdGDay6+yenfLRky4vvLNlUL7r86OsHA5ci9NT/HTeebXMuO3syu3le8ce3rvq/qbdceiRBsd/8YDWdMaGgvnvGRCIMQ1Bd6atviRy6d/+7rjqaGlm/qfn3//rA7bTf89NTtzZG7np0rtPtT8RjJx8ycvLoXpd+afKUMb1wcR4AP16y5eTpw/78oxPeW7j57Xnr35izhpDfd159PPEvMK/Eit0ex+fo3VXx6hlMnvlyJ0EJOp55CiTKpAq5nLlUz7Hy7obhH4eeMWVAbWVw0sg69hb9aPFmNo249i8zW8MRxtlYlB2CZPBlY9EDx/epqwqyuRd7aA3oVQZ9/14144a2EZd90cpNTKgIfMfQ+n/HjH7jo/UTh9ccsveA3tUVE0fUsrMSfUZ9S/QP//6YV7B0JE0tEeoDaRl8iIvNHB43+sU3D6gss190+sTzb3iZD2K4TblErD5oQt/ayjK2njx0yoCaisCkkbU05lnz1h17wJD+var4Y7ulDxdtPvfYMZTbt1Z2p1m3pXVDfeiP/51HD0BxDc3h3oT2VcVp9onEUgeM64N4E0bUzl22bfHqLTT7Wx76OBoV8RpbwjVViCfD5hcOGYbHQ4P8V97+0rbmyNamCFHqaec1Fb7pe/d/7LVlqgbkB5tPm9AXIdl6oHd1oLYysM+YXrPmbfR4AhR07d2zmHSpD9tkD5+Tpw2DsszvYUfLI/YffM7xkxPx5oWrGtjF5NM7XmQAqW8mXrbj+IOGDOhVlYy1wp+8GItp2Pxlm0cOqJoiO9c66Lle+3DdIfuMSKWjzKGgUUWkEY8xs7qqYuSAyg3b2tj7khZ+5R0vrt/Wxu4gPBNpDEFiUQWwxdzMYQ6bMui2hz58a97mprYos6z3P910+owRvaorDprQr19dAG9hvsazi5rmiMqf7fi87q6VqmTOCIBuHIjFn3xDKF9FeeXNlDqIbVsddGtCsyULo4Psm2W3V5V5BvYpu/Wyw8LhCOHJfV6ZzcMjEkswKcK4dLFsRINB2TCadTB6ceZ8vauD9BnRaMTrrWZUmSJbJcr22ZQLW5koB7047g3fOYhuaUt9iAlAKs403UN2ZWmvz+Ngy7u+vfrBn13vmCwTCphXpMy42NWDYQrKjJzxVFk6PaRP+dOzVuEAzFdXbmzmQWLSqN53/2/Buws23XvNkfVNYfzpum8dEPA66SB5kqHnY2rEjh04kPJ4mxbdF/FQkL2fqst8BK7yuu3MRtgITYlHO7c1t8YgCPicpx4y7Iwj92Lzj5qqchbGF61u3G+CY1tTGO1yB6dKWgnujsXISJeJ4ktXrbvh7+/P/MtXPl2+8Yd3zKRa8KTmkHCmmf30mwe0tEV/efdrP/vWkTS2Lx456viDR6zd1Ni7tuLHd8r7BuycKwLOPo+zttK3ZjNvlli+CX68dOthkwfQOKkmphnRBBs9eKl11inbwvGqStm4gRE+6HfRAX3t5Embtzax1QJhX1WrEBeRhwp1EKj+q9c9e9K0oV87+YAv/+RhJglEM2X7CeqdwRzVxJ2cUi3M3nIifYaT7eDuCM2jRk50tekK7TWNvQBk8k7qunvfZg6qmkRyyqi6X94z+6TpowW/xuM4T/rp9KaG0BH7H3D/s4uYMfME3K9X2RXn7EeYZrp5Un/3zw/791o2c+6Gx37zhY8Wb2TyoLUuuj22g8NG5/3yhcF9KnG+31w045/Pz2M6Kz2Bzba1MbzX8H7779XnklteZyO+GJ+qXHiwUyaASaL03/TPD5lMX3Mek5x3Xn5v4/uL1v3ka/ujhfxn05xSFhBoXUxjRM5UelN9+Dun73/PkwsuvvlZ9lrae1SvKWP7suMpXTtbI9XVVNZWBWbsM+CSW94Y0KcsFIr/+rvT2GyA6NTsZ/aL+9595b3Ffo8zEgeVKuKxm/uYYX0PGN/3klte61dXxlYIN3xnmgqyzXIgk3kp9Idf3ud3//xg/ormpWu38WB32ZenXPCbV7h895O1owZVwUQ7cvR4mGYf2joTpzq2xQl6rrrjjS2NbWyeiiZ4LfqJXgSVlzcN06Zd8OAhUxZf89UDbnzwvfcWblu0eutvvjud9iAr66pbUj5p32tozQ9ve+vf159w2JSB5/38udoqP5b54lFj6BBkLLc76Yyu+tOsWy89RIspSl6aNH8/+OI+V/7xzZWbwivX13/7lAkH7z2I0QD9aZYyZVXdE9KyVc6jry9fubGNTTNPPHjoGUfs9bdnPv3ub//H3hMw4bH1+ntnsYfm8dNHEdYz02Cy6pv/tx3vTpGfZfcOnrITKYbCvYZU81ROy2YeyWMr1e/3ufrWVqzZ1Lh6Y8u0vfvLWzQOh33mR+tHDqygj6a769+rcgP7MkaTwwfWsFUGe4YxwB08sR9zICzOe4mzfvTMBaeMB9k2dXRtXU0FQztjOrtah8KxFRuaxw+rAdj/8acbaTCH7zPQ7fVuIMxfLDl8QHVjc4g9mMYOraXEd+aua2mLT9+7n9/nRkKpRKfjgwWb6DvHDu+3flP9R4u37DOmd9/elelETOrYbmersIG9g+VB/5I123iD1LumHEWoniH9qlmifnXOOrq6g/bmy0hGLTt9LXXft05Gajqhd+etx7dQORhgJ3itOOeHn25kF3YGevbwGDGwprElxFw/Jx6uecje/ZV4KTYxXrKmvqbch0vxWLdhcxMegLeNGFTN5HvthkYeTvB16mtY/0peH0LPKxGm+DWVZbgUE8gBvSs3bWtuCcVHDqnDYsx9ad7MUthdlckbHSd6rVzfwPxjUJ/qjduamMRPGj1g9fqtc5dupe6GDqxZunobL3/61JTBH29WvpuYNXcDM/hgWeDdeWvZPuTIfQfxcMWTPbVKEPjm1ghR1dk2h12aRwys9HrcC1duY3yrqizfvLURGUYNqmbHT+gxv1h4ZT1bvrGxDw4zbkgNL3RmfbSWtzo8hOAoA3pVbG1oXd8Qa2kN3XD/+y/cevrClVsZr/rWikiqGYo3dT5o7Qa7d3xud6dAxHewkJZQ3SKe5JLNVWToYVWVN1cMIA72zGiXzMlgnZnbKAIoeenKuMlHKfLqStsaBZ2ZDB510aN/vHzGmGEDbOmQWErWYhU3nglkeVV6QYeLXARHj4khhEBxk08VIeABmhkKBPSyceYomhjqJmLIngHqDR1CxmUiIRN3dSB2OslLbyV/ThFky8lJB6jaBuTaZ5Gq4lUrVfKkY3nF0XS5Sek4R754MvHoLF7WevJy3iGfwyMqe2/I/Ee9XuSOMmBudbmDtTVpxQ6yE4kYRGWnXOqImsrTiz5cM2meHQjaQi4MIoviGWvwDy7mcGNDpqfK4GghkyJtBBAyeSHL9j5xmqhaVeVDIZjwLA+9JoO2M0qWZcbCiiyVkG5ITMSBak528mGsOGjSoJffW0FH9r0vTlX3O4qU5ZT/r7G7I9DnPlgKUfu6aIy0c+asqlMQi+Nb7W5Ehcc1LxHPw1gyaoqtxM/YF4VfjVhdp3/17YPoIZIJopfJaKDC58hcH09KpWQzGc7ZpksrQnHDozVK7sneiEJLSGvKkmyZQ7vJL/saICE70VBZHYWMK3rZxyKniDBRPPLl5Gb+thwQUJxo1KE4uamyytIBKbJBX0Y8SRLOefTZQoUJ9mGlS3xJHcqeMpfNGY28WXpNWs2qOTvQZCJk10zE611hw6sC0Stnf9p5ux1IzzKEd+bAs9GaWQRiagKLgkoljYJxjAcxbuacgRMIlLIZGfLps5JknIckYavVUDrJTj43fvfgV+asYXvQAycNZP8caVoZ82dl6vq/28Pdsw6qlY7CnOTqDjXybCIkGgGm1ujz07NJWgp+lD5g0sAspkLopaKyGXPEUlaGWTtBUcosX/k3lx0BOuMJcqn5iuSy51K1O0rBrAR5nHP0HYpTshqLlyuUjAXiiblUUe3l5Vk7lzHHnxPtazQtV44gd5Ll16GgXGpOBYrLzZgL1NdopERVRi41d5KTIceNk1wRObLcCRaiB8HjzzlhMp26Nopm1M5n0fXzQndnbtB1Jjswh3SKOcPswHIs1t3LArQQPD6VDtPM2ptBF2Xs7Msd3Z03X2w36GRXRIaOLvLeMeSfWdUdI47FdedZoOiYYKZ4XFee6Jx23jLLnC/vkDdi2kEfmoomRw6qGty//MX31zC93C7DR5a99a9lgZ1hAZmb2dMvvb+2b+/AsL4BFvrV5DpTdLu705h4E+oLeE84aNCTb65oaGrhDVd3m9vsDINZZfRYC+CuOG1DY8vTM1cdPrk3C8zyHgTPzh7t7s4dmSQnk+efMIbXR0As2MRMvfvK0lr/WhboxhZgDoO74rTX/e295ubwl2YMdipobbuz4+H58jNRjkbi+0zo+4OzJ/3h/vcfeOZDtzfIizMFSc8ntM4tC3QjCyhHlxevuOvfn/rwDw9+eMGpow6d1BdUeL6vI3HHR1X1FMxek9d+YyoA1PN+9Gx9c/TiL+3D59yyviD7QVuHZYFuZwGHy+F0+eiWb/3XO5f87vXp+/S54qzRHl+Qd3qZtfysyO2rqtk78vkMcfNw9Itufuvhpz496IDBV5+339H7DfL71dpkjs46sSzQLSyQBlHy0rur+Uxs1ntrT5wx6LqvjR8ztI/HK9jSAgGLuDsUrOjyEQ9z/L8+/enP7/tg9dqm/v0rJwyrsV4LFpjPutzlFmAm88nKhrXrm/r3CfzgtJH/d+TQ2uoqQLhFX6UXd3fxeNiAgQh42loiT81c/fy7q+cs2hqKxFg7K2wyu1xjS4A90gLMy3kVA1Zv3JCKQyb2Pna/fnzyZnf5JbK7eG+RQ9fdNVoedT1uh90LxsiejkbDEYEuFGFj3bIssIsswOtEv9ehvgRXHw51msDky1XC3SHFvZnNcwL6HCBRfmbr3LJAd7AAGDrclLfo+GreS/YiohW+melMQn4cXbvPG8nOBNYdywK71gLi4spDjX0dIUu7e74mJdnlE1vnlgW6mwWsyUl3qxFLnh1oAcvdd6BxLdbdzQJmJzM8BMg7mcwcvqMW1quajvawrnaUBXTcT6EgTZVp1t35YtrGHx7f+VDf1Xe+bd2xLLCdLUC8w84HD5Qq/kLnlM53Srs7Hg5SnigRhAAgGhH+zh2+FFVRGHnpmU4loqzCduj4tUZRtC12FgFi85Rk312Ju2q0nmiKz1x3+BefybpYKyUCCotLoNgFvws/gtKoKAzsraSCPnR2sLw7Ztw9TRDAi/4w65HXVxAlh++YiRAUDHhS8XBb09ZI4zZCAAiwUqstjbW8wWH2k1eOwSnERQeNzlk0Y5llq/L3IOLdWztqo2sV3dErMA49u8Pjq6oNVtY53H5CT0rQAZeEIj3zsGEPXX90Un113tlr8u+UdncmRqyortjQctJBgy/78kTiJRF58PYHXpn9wZIJg2qmnzJt6oThddVlxGPQ+l0aXUsk4XGyFGvq65BINOnzEpihxCH6pghVRWAqQtCUIpboNxK1gDBGJb9QQWAJNmSzmREY4lAs6XE6CHVRWgxiBsVSPjcxQkoILMlEp4qn/B4ZP40PKoSIG0RJC+wA7YjSQ9hA4o+W1s5OwLaUl8B3hZ/IFRffZEVr1UGQtXIfAZOVMWR+4SDszJz5y996f9GyNUv222ev7597JBF1iEb8+3/NwzlxUXHUUkdpdxcOTFnStgF1gRn7jti0cdMVv31kzeq1v7rklDOO3b93r2rV7vLryN4ailHHLjfM8+8Xl4U4634/IAUTB1/qxpJEazJBSiwKwsakvAJ/KCmDPU7EZ7vNnMD2CPEc2Ws2u/RmLEw4kmBINOnudFQmtSPKBUHqfOa0I3od1ef2mKkOO9EqVTBuU6/sRDughPmfx+mbw3RF2xGYlk/EpY51Zz/nlGmbtzT89/l3//jgS/9+7KXfXXlmn759/vPisvVbZV8G/ZLbU0y5DuS8lsFr2tpaz7j4HqIcPnDzhVPGDwND09zcIuXklUXrJPIy7u73ZFtne3FFzggCmEiUdndKYK2YnjWZIHxkET75t9CdAJ+4e1ncbaZ3JwokWcwIjHYtEXF3gk6WFsNmY6CLx1xm6gJubbhw3FVKOalZHBjacnPahSVqpI2P7s2YojUi7g5QqrR2dltLOBHzSDDUkjJTOyYrGgsjsOxvQI+VL4SaHVeW+S4855gDp4z61k/+his+f9/FFG0ex2XW3XFoj9t1/e2PbW1oe+G+Hw4eWNfU1MIknr98P+MccQl5p/2V9giJXiLEBUw6X6oGleZRGeJ8I3Sm5A4OgVw8P0NcUgZNYJXFLLGSuSRj6QQUJSUUFbPDTZTSiEu6DtxSYgcxRUkhNO005iaJM2KUkkOzmCI25e4a2w46F7vI+k/xukskk5Gmlinjhzx6+0XHnH8zDulxD8jvbYuxbL9nzt2TqfKA78WZCxyhNTdf/ZXBA3s1NbUyc2pnY51ZFtgpFmCCjuM1NbXhhDdf/aUrfvOPVLCpb79+HeL76UtSultV8ycCCaaXLl168D6jjz9sUmtLyPJ1fZNaKTvcArgfTogrHjx19JIlS1gQUvPpUuNRwafZumLaHclYKJUIn33SgbzvND9V0mVoJVgW+HwWwAmZ9nz5pINsyUgy1kaoMTP8TBHBK9zaNLhfzb4ThkYiEvbSDGuLxrLAjrMAThiJxPYdP3RIv5rWpvrSr9+UKObc3W6LRkJ96iory4NqswDL3XdcPVqcTVmASTyuWFkR6FVX2dbWnIhEuVPyHYY5dwckkIxq34yYksUisiyw4y0gryntziH9auOxSCwuGwiUfANmzt2V6FaXvuNr0CqhCxaQvtzuqCgjwgw72ma2vjHOb+5FpDGPTqlgePimm78OywSdyLQbEqxfNjQocdDYiJevEZccs2jlUrr6xLYEX5WsUZoRmJD6kKWdYmkznDWBS/Y6sEKpjHal+Ip2GE3ZraSFRWCIVEA5k8S8zBcdS9WJJkZJMk0bmGkCl1JOdjbrUt1BrKxXSlxVcBfdnfmRRK03kFkI2KO0IsDeyjAvLQT73XlkT0kzR9ofTbLBrBlSrBuKsnsEXom4umJo2rCHKPEbMju0lODOvtUO9lZhjU9U1eUsSbw6YEdBFY6qBFMt2Sebt5nTjj1sE0m3thF2Cd52Nj9BXDYA1Jc2x8Lu9Tll6dDciw6XOy47CIk/lDAFWypUlXn9ggsoeYjAzSETdSflmkQwZAo1Z1xFTHtnw62o2i4vk7vzP+k070TZYXnTtjb21ivZncCAfdVkh8dSB6rBjeVwgnaX7FF4dcQC9KDeZQdP7M8oZ9ARoxS7H875dMviNQ3sg0UPZCwILwQIKsuGW+ymjTVUTRfPQRI7R704Z204nDCDDkUpicDM6n1xfu13hXOSIIZpn9tZshOmTdIwYI6aZohBywEKABNkxsi0iqOmDmRzP2YS7fJ1OsNoRChiL28RpCNfQRZKh95+0EeA/ujbq5wtmRKJpEHnSqAAQJFUdHvmUmfm3J1HAh6E2a0zmlDwknzx8kpgGdxpr2+NXfjbV+kd2DxRwSR1iLP50F91k9lrw39NEUsoe+fSNQ1s1PryradhOwOWTGPAMPzyr+/OnLd+IjvTZ3GdellwhXfnbvjZBQdecc5UQCC5GA0F9MjJVsDLNzR/7boXB/YuryovHtSqc67tbAqtAOViJjkrC5OtRK2RzlSV3Qvv/enRZx4xqiUcy21lU6AUFgbs9eHiref+4oXxI+oAzClxtALSgWAg6WI7ROpISqRfAFOyemNTvC00864zgj6XzFV0ZMHdvTFaRGmYe04kc+4u2OO02+FgPAKrq2c42i27fbucUTrsWy855P9O2AcAbMmVrHgs7vaYncwkgKcKss/4wHaBn/zpxSfeXFlX4dPAvXoZqIxAmZf+4czDRz7w89OUwDrWFRYkpUee8Vd6yrKAj/lSZ8iQVhADEfXaUOYFP3XPj444bOpIhrGSPpSIJUxop5XA1u3sNmoK76k2twK+g91KdoTgsuJEGC1Va/BxRiLhAV+4Dy/nYZFnGb2WLxYOeiqCHrZBf/zXx48c0lftQiyWtNk8s16b1TtcX1YRFHi3GrXYdf6Zt+qvfSXKJt3VQQ87xeoNoXTtZX7ZCLrjgKHZp/hvSdfpmI3t1+iMO97LXVEquvGLHmyWy0aMUn+dMGQ5eu0E1Kval73gdpFLmLMDaxkTH8NaE9S/h5JFFu2vCK/sLQhgx4FZZevcWEKv2qCjncMR/qKk9G7yl+XU4V8tSX7Z9i4qpmCTb73+T8sJJ0xRZuZVmULz04yDnSLcdhBCu5DtfGXu7vOKokUI8m+BRowm3An23jTCsKO+3ZUG/Zud+4kd9GBiYiIxsJiC6sMUqXiC7z35GmlrS+u/v3bR0FULnCCZs/uqC7Y9Gj/8wLNabRdUyVRFz9tlcqvqLl+BEudddPcS3NqTaRKIqf213y12ZoZGy7fdGRaIU5I/BHoDawGr/MscW8lueGiUhiQqMWvYkgyFWnsYV9WxHTmbFbVjkVou+UUehyOZCFekIvsM6jOgqhpkNzfxX7fLPW/NCke0jUl8KYN15G7iake5u4miLZI93QI4NPsaE4vRz2iiAjIyDfXwQZ7DmWSP6B1wWO6+A4xqsTRnAb6YZOK9duOGddvqmRdpvTuvGUKtYd9Qw3c95vh3prLcvbNNrDs7yQK8jH+8br/UwUededI08LZ8/wEMxuH2vv3+8lkfpfzpWFr6+FLPG10R1nL3rljLot2eFrB7bKnFnl7hgw+f/JXTlFtr/bv9w97z18x/iafXtMQwtdx9exrd4rXLLIAje9MJe1sLXXsi1sZLPPVWzZduavSkWZvb/ofVu29/m1oczVtA1pB4SOXxNEUwE5ZfiZ3k4h2+7tqSedbFKM285i2Wz7pnWaAHWsBy9x5YabuLyLJcpY6dptAunsywLsZ0jT8zCrMsB4KCKd12X30wU/qOpqHuzZqCVVXw1aahUWI3tRhsZlUVGXhhsqOVhT/6ulwuVnyjMb7M0FuT3c6CdMHdxQZMrfSbI47I5AsCRSg/XBoBNJmgOW3VlX6eWMyplfL4EhK0LAMoKp7JIS9wMytyMhc0rjwlrMgqzBSxzpe4mlZatWgqGjPPM4XIU8oUaYfbWVVJdZiByBLwLOWzyfc7Zt5bKNgtb/RMAWwq3DGxMLF29e2mjNCxog3sjPZZr1B1kTVFOlVREfjv7746dECNzRYjlpOQFdSdyqgniMZNL1WM0+nogrsDX2iLxEMRgMjKNzrxouN1xR2EoSIFnHA8EQ+HjCAoYEhCkcQf/zu3viki+IfiXNuLAWfRry747dMmgtSlb2hP6HhG/xQMEAZPej8ifgHT7Zje4Yqez85jEp1fCthMPByJ6yFbpDHb7cjJCSHKCJ3XGgERVFxoyJS5aJy2SCzBp2URA86gcz2ONRub//LEfJAwCGNsClWkfeSgyq+fOB7wXgd9Ol4ghtfjfvbt5S+/t4b2JkY2PFAQ/U49dMT0yQMi0ZjypyIZYON0pVCftEgsFRZT6IJDRR0qmjhtRKGLSl8ei8al8cuROPHwiclEsq0tpHU4jN7+QBznIQ2eeBq1qeNuMi9weaWi9QhUER1+uuDu5MMWBnWBFSDQTCq/Ehc7rdprhyK1C6xAYOGla7de+5d3jj1oSN/aYFwfPg43tjX+dGXD3KVbvnz06LrqAEhdg1anUGpSDhnF6/UPUjWBxW2U8JnLTllIpxK0VKWcUKulwE6kigxKTQw5MeTMTIM29/HSrb+9793TjhkNElDquAhXuYXAXo/r3QUbH3l16XnHjXXyEoPcesR003bn355Z+OK7q7945Kho1AigDw++Vbj/mYUUMW3ykGQyphcHM6uOZlm5IovedIQk9MvYTVlbGSQjcVNzmHrMtStpkIqGZM1uwllHu3w+OiSFt7vg7uAWAS6D+zfwM9n1QEkHLJNvbSqCCd4uFZapXaOH013udxMP9abvT58wcqAhRBbL+h97de43fv1ydbknQAjVFAUVtwMtweHyMAKQzEdVdCXFBVB3aXVwo7Ohn3a7PRV2wBrF2Qo5JSoH9xIB0+tJBnTxnlQbAOAy9ZUWwRm9Ho/HmaZWi0oijcaJrTzl1YG/XHVEXU1VFiJblJxGF7zl32/d9tDHlWVeOs5MEyxGS+RUu8uDJIdOHnjfT75AX6x1osVotXvOj5dsBWXucbtdQbdu3eFoDiefh5KHr8ACPg8fmzhdxbUTCwc98KQKy3wuwrhKTFsdU6i648syqbJy+SauBADY7yXS644BAEtbZhsD6qa4XmJ2UvmDkHN+OOfDR846H5LkpKLlKWpbE4FD21rbYtkxrpCcMa68ItXYEiWXekRT/aqOGMKZ8lWxnPNXyC7vWqUqWeWmEOt5O0QoLv1YnnYpPe0QkKKVEOpXcc4rN/9UCsUU6mmSbSOoZlC4uQ4vn5JzHlIrKmzNbTHopZ2IMAa9e5q43FDCkClDa0uJGEGE/Aa5Db1x3UmJDmGLPJmK5o5MQIocQtbJFHo9EMQFdccdPX9TAmQqukjBxW51oXcvln373GO6zIoaf3rujpsZpG4fIboHl3ZT6FWyTb4p0WsMekrAzNjCWkZodPoQPcY97L5eM+thaljiWhYwYwHL3c1YyaLZTSxguftuUpGWGmYsYLm7GStZNLuJBSx3300q0lLDjAUsdzdjJYtmN7GA5e67SUVaapixgOXuZqxk0ewmFugWy0w9zpYsJbKkp5Y1ZWWx8yFJ2aXEzqm70x1WNTVNddaXBTDTfUzRBXeX9bbtBwBWw0oGGyRrhArqqbdYqFbJM1AdRSNy6GFmCkGkusuTyuuUVqKZXCl5dBYWNfX5ZUkz4CMWircymLCzeXbRAwCtQyAfBM3TBJYFYx3Omik09SCGUn51xNa4aYmSheviLU7EcsjCfo6REVtNCa1QlSEL09USOv6qEpWcDjvBk5UpUmwM2ZEqe0UEDacX3JsYQhnRyBRS0+0VrZkip0CWY+bffFMUJOldmnN3UGnEZU2lmtqibeFYRpxOLOnz3E57SziO74SiyWgsBgyGdelOhHKDFu/1pptUXGOyNLVEW0M5XGhhDjAzfHQQigDokz2KcTJQo3piACcsLwP7QQnphjbQpiUAwDAChwNUJBqLtoV0Q3viVNgd5hDf/M8P/vfWCgXhlArsfIDq4yMJim5tDDeHYuFoNByO4vmdKbkDw4Df1haWEM9NoVhDC5tRsK1xcc7EAQVxwU7OdKtiCgXZLU6qOAcDDlSjiJa2GEgbcTX9A8wMRsN0sXi0pVW37iiaqNjbmtnJOHX1nW/f/t+5Cf240BDjA42tRA5NtEWSbWHMnNATA4ZlQSfOgwuhnaoXXcyMmMIdkw2HjXTqoK05dxfUndQfEZaTAl4qzl7c3eWIEaRY/F4wMMDldBHhqbTL7QBaCDGgNigT8aSeFZKONDWhNqqWE6/HoQ+IxCPpaJwAIjmIH43sHTTueCGtTvod6SVdTif0ejEiyQcjr9t1+6WHrtvSlrGBHm+xGOOA7YJTJkyb2I8o1nav7t7ZVKpLtuEWZB/aqRifiFTcyJifgKwMLjQ+0U42EtaFiNFNoBSsUBA1odezsGYVqgOjYToMiBh6XZU2YvSpCdx91ZENzRFtZNQ1szIF2hD1f/ywGirc6dX9XopOjELlUw8xhXiFUx/OnnCI5yjka8dK1b8y5+4qP5YAaZ0ilp9OTWjuTmxRyHFNp9Pl98jn5cVLByjncqESDsOW5HBOxlN6lUG1sWe3oIvBAbP9gdtlc+hG/nYDAAZKr/yFfd/Vv8VF4C7uDjc0omglMHIX97MMC7v9C4cOtxEiJVPJupyzCXFx/DS4Ll1TC7DRCeZWtMPdkZnK1hOb/s/NR2+q7RBTWyZI8Nc5BAAsTQP9aCRUh26HojGgdJQXd5e6c+nWnaIGpfulo0fb7HwkZWixnGxpYiBrEEpdeq3uqBAIEYA/vr3RcTcZacUUpXcOz0kgYWu6cgjmVLcvwezyXKKsr/1wrgdGliQZM6R0+dUy6lSc4pkhzp7ripHhrNTiXNHr6qhxyyYLsexDY3gwJfC4Ejicbn+Wl701nGAGr2Yxunyl0HZTiAxKqjwueacqKWc3ibtr0LtrnLO5FVtdKYRKK1eRCLFe3WUYpmxNrTG/R3cKmi038y+mYC8TdaErhBSaNQXn2p9e4yBV852Cggwuu+juBpz2mKQsRteUuzM063VOu4HBNFPojckFChrMEgsod9ylzkxjxxVocbYssOssYLn7rrO9VfJOt4Dl7jvd5FaBu84ClrvvOttbJe90C1juvtNNbhW46yxgufuus71V8k63gOXuO93kVoG7zgLWe/cu215b21BLHKXzQiaUhodGU4rKkMX2TsyIVEomk2SadCXtsL2VKMLPcvciRjG+BeBD4Aw6UMiCvCy+Olh/1VsYVNQuUBd2FuwNiQr47shLhTlgVwF7CTwFcAMgF2hnSnKACYKk3LVKdtndEddA4oJUY0qqLJ+gIG9+hRaQFWTMpyxIMuCp5crnXJC3gG3mUuEcgTq63aZWVdvCSQHuFRTTkTUQMZyGXXm12xAbiJ3PSTvPv9ORcQfzkmTAVjJmGQHyA7eYiOsiInOloB3RycysqtK1h2NJ0MIAFXLZO59kRZAUTVoDmfOJO7MqesecuysAMIic+tZoyBAADP4xBwAmhCwgUgB5RQsGm+XzpRs1AHAo3lAKAJx02NsiAoutb42pAIW6SDXkrCxXwd/S6W2tsZIRgBM2OxA0kG2RaBSUrF4vKz0Tu5in0uf8/PkFK+qBJWaQK0XVy96kmo19PUsoe1sDo28Oxbc2A5020o69XDQAMNrREwMd0at4pC0POlANBZtaYs3Q6/fEqMOoVVHmueephf97axVfp2Rl0/3XtHaCgynze/5z/XEDe5cbAKfpGgBvawBgKpqt1wkSqGdAKtrmAgCMrXQlLEgw5+6CugOk6qgMeNyGIVGhEXumBbdIqGVHkIDXuu4OsrHc78JkQb+rMuhhdqBXGdQW3wf4veJhlQF3edCd0schYwWP2+NVaBWIY6VCopYF3YyzkBO41JFO6kE7cHfxrVQKXz/x4KHfOnVSa1tYgLiGRyiW9AMzNFEf2IEddccOqoJfwK07VUK7oN8j0EW7He2wmJG7J9NugsMCS3XaMRrS61mYQlEQyruumEEsTg2NbKiZdL/4pXzoot+E4EC/RtDZj5Zs+dZvXo1GE2VBb5Iq0cmCu7s9bpwHaaSiCYZsAAAWU7ipaExn8jDn7ooZVUbPxx9HUe6UKthRpQkkkGn0RYlxEyFQrGCJ/hDrWQHlSYIMVhqZUOqIQYxndUixyMOwUFQA7SZpWqGawNDrykAGAY6DArcPH1A5deyAZCwEutaAOUlt4UTQC0zXmEqlpmzNYeYP4NeNiOnKkVBTHWlpggKh1jmYLOdMQS4jC8NBTaKG9adPc/Epgg7LvNt2W1soITGhDSHTAkJ2CxCS3o8/kV3qW6dS8uoOaVGQmLq69SwxlXVT8wRtP+2Cu2uZ9G0r3YP2l2NvTIzG+QQFeXNMOCkg0+7oGKyQOD9vPk/tvCC14DKfniQRWL1pifKdTSrWEioxu4W+JcJMosTcPSNJ2haKJdx+t4EMUOanZkRSguWLmjvPJ9byFtzJUcqJmncxp0omGB5LgH8hxwtbwhDL9yMGbOndy4I2NsLQTKfKEUsWPfL5cK79FaXkZj6xHk3B/S64u14jK+C4J1xiCrop7c9AXypVozFjOryBvsqA285Jks5XqWY8yCBMvhGMPU8YdgPVkNnEmJU1M7Oo7Kn1r2WBHmkBc+7Ox8vJVN9elTxMqU9IeqSqltCWBcy5u3q+Fnfnuch43LIsalmgG1vArLujgjWZ6cb1aIlmygJdcPfu8bBhSiuLyLJAUQt0wd2L5rduWhboQRaw3L0HVZYl6ue1QBfeu3/eovbI/LzIYp3FzDyQdwBQ8mf8LiBDU4Lqs9samEa2iBJMUKqktCVY7PTkLrs7CyEGayEFqcaUKJtPUJA33xQFZAUZ8ykLkgx4arnyORfkLco2n740c7st4AX44e6gZwHf3KVgZhzAh3I3ip7wRtjh8BB0DW/TWlG+SAVZCpJKCKyo4SwgAkKEGTc7SgJJxZqUKrKgoHwx8pO08/w7+ZSKZfsNyHJ/7Xfzzgz45FF1OC1h3Hxa6X7Urr96+4FDAF4JFB65+KGfSPCPzgIzHQPv8LPEcgKx3tSKVOlyVJeWOdfvMoUPZava4lxk0D+0nox06DWB9QAgcMG9EEIjJqMIr6MdNFQGPOct35ZSmD4lhJEkuFc4ngSCYkgkkMyyoG/Zuiaggrwro4VgFr2Kh9idNQUCG1hYsxCIneXrmxqaowTM0xTV7nf6FeVYKI0mUhOG1hD8UUyhc2iGyq87iPUqWqs7jRlkWvVprbozewhgq1V059Sid8y5O9VqtwOmCBGqNxQHN1eUFwXnAMAgVKOxeEtb3AAR6fMJpARlwFERic4oAjDO7XKEowKLRQAiQAKz1gMHCQDYQZRZrCERhksCgFnoB3EJObjbFpjroJeoTypY2TcN3p1IyIamSLMt/OoNLadc9ZREOfUC/NR1iKLG1LuJo0ldxJPjh9c0KGlhbODu5XYnqqEgdQG6mPV8Pc60d2KRXvi71z5ZUd+nOgAqSI9Suw+nFRta/nzVEWcdMZLoeXp2kw5FQeWoaKo7FIlHIrpiCADY7sJ5UAnz4vfGAGCnJ05F67WHzvKbc3cFAKbaygKedEIApZ0ZcQe7AxyVqJppBnHqGLQweFodYjzY7a4K0PvYKgLu6nIi1OqiEamtsjJv0CdOU1PmqSz3SJxfHS0xmdPjJVgx3llb5ikZ8DpYTpxZ+UDJ5/V67PSXug4hJcqoYicybXnQa0sm9UxBq/D7XI3NET7a+OuPjzpy/2HJuK5DaMbEDm3gY30masRhi8ekB6yq8DF9LloX2k0GFiY+qIaCGI1QqwbujodRtWDiv3nSXtdfOCMRC+tpRy0AmG5qDu/1lX9Q3ZXlPoYkPeA07h4MeqhiFKS6cSGQyHqISFV3HpwHF6KiCa8JWF+nniUkKghhKhrOJg8Txu3ICc56zLWk/NT8845shAlupRHkfvXo8+/niPW8soA4/7JABi4LUgsu8+lJygms3eeOHr0kqTR+/F5XwOexgXQ0aEhKFHzRHzBVI2lPmrEuU0a+lB3PC8QTqToSdLjKpuH0CJx2JRhROxDkLtDN7kzGM59fcduAs8a14Nd83WWFypXdfmKQ1E7U8cyUcTtmsa66ZgGZVPHMkywRWxgXYuBOJ0xUIrsqJDJPMl0TxRy1NmFDGAm8XexQvbt8Z1QssVvfs9x9h1cPPRnDsfZnXJgZGuGgcTPm9flSSwpsVtTPJ8Z2z60zWm33ciyGlgW6gQUsd+8GlWCJsLMsYLn7zrK0VU43sIDl7t2gEiwRdpYFLHffWZa2yukGFrDcvRtUgiXCzrKA5e47y9JWOd3AAtZ790wlsHSisCUszhdf8mNNBfiAiUhyn7FW1TJTChlK55fNu2XdSoi1xVudPNAIkM2QRifr7nm7C+6uvEAChvBX1Bg4RC5VkShKHWIFVcqgvIREsdXlLAVmiBUN51n8aydRMgTqfk6eTlTZGxnOdpb6XU6/yy+iZNM6/0uSBFLUijBmTqoIKXLLj2RRZ52Zqjtptn+uqvSzAbMOQYfbLnfa508qYqOlTbUs6kM1JYlR3WnclV6a/kYCKwMpgjzttLwdpNQuoM5YorQpFBPNbBlf4o6e2TLERYrUvWXa3elRUsQNTYRjCX3kEDQOCCgtnqD7SQBtczmLd1cgh1w2e5QN7W22WBw0onDWAzDRS7njCW0/bgLJ+jgzRA75HGBjpU+DZ0mImDPmJPLj87NXf/26xwnXq2dczYRICPiWMJzKFPraUbjdphWNdsTaisUSephBaAHS1TeHbnv4o9UbW8BaleyOIcCAeqisXG0rzk5UGzuk2tjCWhZtIMB0qu6MKtrhSlMRqqJTsbjUnZ4wIqfbgRGoaKobuyX0K5pRi7rDeeAMT3oWY4iYF276UPCcHXIn5txd6s7OqEjZSKwXXgnjQgMB1PGkjMvK3Ys/HmAFrx1LCXGM6LuxZMRwk3ifeJigEfGhaCyVNAQAuz0EfmMMT8NT5NE/EMMRjs+YMhDVlq9rkDZi1F0K7m/63v3HD60Jh3FgaXRFeVM0YGFgujQeaZuJZCSW0nN3oLZ+v3fm3PU33D17/8n9vR6any6EXSsOGZFUH8ybFUpiSNpHDKhEQcDbBhbOsqWlCcocyDACu3QCs0JDJ0ZFUB1UCmrC2aljCnRxxZLYSioad5euTTcyKz7jcqdwHoipOLyCIMB6HRDwSVUFhhWWtYT2rzl3zwCAHQDlUkFDALBbheVXAGAC6rodSa47lpi9YpLsdGu40HK/u7LcK7BQnQqkdw8GvAFwpul0VdBTHvTYUroAYGIyOlwAgGXKUR0sAQDGrA6b/cr/2+dH504FS2o8FRbR7fa2UJQ9CmgWtRVevbZBswEAXN/kwSmJUgu0mLioDP9Z5Tv8C9rL7vQCdi2r8j/26xP696mypYjCXZxYyWADSRZNJHwALSnA+AAcz2BEF2u3a5F1DcjBeGM0TOdxe6vL9etOmppTnh7SaSqlLOC1A4DTwXvi7oEyD1VMJqo74PcEPNIKi4qh6i4DAKaiK4IemoeeJWgbQR+V1oXYR+bcXYmmDCtAPOkCix3cRjctNUNM36nzvQ+UWEwjll8tY3HG8hWVdGcqNXOuP4QJ5zxirYhi8mpa4cESsBPz+xNk1ZEgmx9vaI3EcQuvoZXhk2cKEZ5Lnb5Sm5aIKeiumkOxXtEomwlQULbMwn9JoU+NQm0CFwkfZgVIUOZzl9ROI1A2EIH16o6aoL13IOaOjuWELOsVKoviXKhT5loKza87lVHPEBq3UjXWoaQuuHuHfLvXBT6BD8nYolNnOXWhhMzAF3OUn+0kw9+wCCWqzZFSg6E5gbvkE59N8h6RS2em0SNkt4S0LNBFC1ju3kWDWeQ92QKWu/fk2rNk76IFLHfvosEs8p5sAcvde3LtWbJ30QKWu3fRYBZ5T7aA5e49ufYs2btoAcvdu2gwi7wnW8Byd6k9FvN61kKMyNuzJO4ejaQLq6pqVVutKeoAHrC/rDiq1ByxHjpCtbPM8qQsUqqMWt7OllEoc1n45FA0AhfWQ5U4BF7VTqzHM1cKmBkJ6plMAQ1Q69K5lCIncGNPVXZqdrN9uD72DD5OARo4QY8qZJgyi47dCkxBEfKnaVtEBG6lgyBF4nbZqJ51YMOFVViptmHTkGfF+WXvOj0isCraSGCFF+hY0fp4J+GdVack5851J9LooAjyibMalPjXtLsrOFskGpegoTqoL9ydiIEt4ThlgqeLx+Nt+vFT6VA9Xhv4E3QBstJqHBJVdl52gI+DswjgcoG31DODIIeCMcB3uAFBQEsCgAM+19+f/fQvT8ynv5Q8ht4DwEZ1q6pwfUp8kHoCnNrSEGpqi0Xj8UhYN9gq+C2fzx6Kit0wSHNbPBIjUmzxSsZuCDz7k7U/v/fdxtaoVK++GJKaEVh1AMaUbDLucsxduOmo/QbF4rGQft1hAYcrRUXAnkoJRWLNaKcPEaNb0FBJaIcLYQ6MI7J1OqTuAoRElY5E+KeB1hohIp1uQt7qYsg6sbeZdnfpMDN/OqKK2akkrZrkV7rszGXngrPcRG2IoIStLmcpWnHMEGsbwXfmKneEs/pPO9fjmclst7Eh+n9eXtIWjp911NhkPC5yGB5UieAGRZ4Sh3A6dMTeI+vsaQG76+UQgdUBO01R7uhJwfdLBDl97cN17y3cdNnZU0oOR/CUWL4KUl9CXPV1zpH7DvzikSPtaaD8ugIjJuJlk0V0LvUEzrqBmEtIJaP8FT0wkjKBJCoyOOu6O4hj4aPDqih/0+6uovsS0xdgncHnHW7BCUofAmDQ7XI7AwljAHCQSNA2wgW7AsT8Bw2nYzOgpn6v20eMfUH2ufwgdUsAgN1EKMcO5T53VGcs0syhOkv8x3nI5P6/+e7R9Fal7AdXejXQjSbNDLEgRZl4FK0AbjKm2J1oJ3VBlGO2P0B2qfhiB6hNn8cNqHhI3/LffO9wJYZxpw0fLXYp/I0pKQ9i+lRG0bTb7SlWvron01ZnXH3HQ6VQNSkfoZ6LCywWBverKprqxoWI76vXOBQA2I3zUAyehimMAcCYgopWHqcrbH6CaXfHAGIrgX3q9SgQoJuWmiHWB5FC2R0AwEpakRnMbSIZTsbCetWWsRp497AAgF2u0vBJsrSGE4C8pRnr1wmmcAqSX+yLJDkbZkrs+A+pUgvqU5t4NCS9H+DbjjQdrvggBgBw2kaMeQMZMlnsduKvox0TfQNiKdECAHewck+7YJRl1LLzZKnTS+UcAjL1Z8rdhadOP/35LSTMTbh70in9H8QGHpyvnd7A8vkF3uUc1FuBXS6FJYBlgZ1iAcvdd4qZrUK6hwUsd+8e9WBJsVMsYLn7TjGzVUj3sIDl7t2jHiwpdooFLHffKWa2CukeFrDcvXvUgyXFTrFAF5aZdoo8PaMQWROS1Z7S0irKEnQajVplKs0wn0KE4L9SORV/RVaKEuYlueUL0OPOLXf/LFXGyrVJDIHXnWZjZeMy2BzZZneBHDAmK0hl8UpxZsFWH5kpeRzIICU4qWtjSiH2EHxJFm53z6ML7q4WBwXLobfqhpFyqTliPTSQQsdkWGm4oVzezpZWq+SZ1UlVOue6OKMsgbAx4JkpRdbfs/+biNML/pgM6za1sMm3ib4SJGCSPaCVNTIFdv5HQATuRH1LRC3BZmRWWnSmlVQEBpVA6Vu2hgj5hy8bgwiI4QixMS6AkmBCaMZ4IjmgV5lNML66XFVCru4kq5GdoZbqkkwZ4btSd2TRs57GTS+1iO2AfBa9W3iTvkGgF6m2cLShNWoIAHa0hGMYKhQlcGm0pTUGsK6Qm7qmjr2+VFMohrgtoVhjS7Q1FNOFiNHjOOy4DmI0tMbwOUKe6ukJYrGizAmIFPxJfWu0JAAY/BQQXFDsCNzaBqKsuMBaj4dDfPe3rzw9awWwcLlT0uWRsiQNfOyCFoa2oSVW3xI1AACDlrM5CaibXLWqYfSXHwCmX9S8HW8KzLC0GMqxQKfd+N1p5xw/ri0U0TUFIrgcVAQ5qJSWtmijvt2oBna0p4rRjurGhaIRAwBwurzMgfMgMJ5GQGDCW+pVtOju8lDRegQdjSBX5txdqiyN43o9LqBtRu7ucmhwU3Bqbhebo8vnAp1L5Q5WcHlcPo9saM8vGG5Bw+m4GnUMwkmFZUzTWRJt1Bjv7nKBxpTaE2l1eGpSIQbc6CcgE4FFO113hwwTz5q34ZRDhp915JhQKKonsMYcRkQjBXFV1AL5N6FkBoFhR/avQAC+3shP7XBO15NOf+mIUUP7VgCfpKF2SO10gcwxvIbe3cTHK9BcdPPr85ZtAw7p9xoEvAbv7oxGBddGpVA1gaiu3bAwlZuraFwI9Jme3eiqqAWch2cS6oKMBgGvqQtgpFS0mf5EM4w5d1e0OAS+Q1RfPQ+mVMDBUYXepG04HMwaQVwVd3cmiLiYKEZQfhdsJcionhWSDjYRoOWIIyKATHMZbXUaNQU6pFhJhqfxEyWVIXBbgWsjsJJBx93FBnY7IXIRY8ro3qceNs6WatPmNpKkc0QixOk1a2RiUtMyFEgT2fX8WJKG9asYMbAS4LI+WU4gBx/aUDVOD8QlhwInX40QKJixC9fXa/kyUChPoAysQdWoipba6XxgYSpXezKhunEewr0z++lMyR1Vd2JhzqloZIBQp55tCYfg3oTC9GG2JmComR9N+St6qCR5KhLi3K8+MWLmkUlG7bIzc3W/kLOelhlixcWAp1ZKxxJVEXoC4+0isNDw5VEyGWluoU8r3pg15tC3RBLBmER5L3nwKWBbLFEVcGuW06eXzx0oP9yWLPfjSzriZvPTMYSJF0xn6ZGtbbK3i//L2MbkQeMpeuo8FJCiTCFMVPmKVoe3ECijZYkli164YMVN4ym/kk+HbTs3kcLs0QV3N8tyD6BjKKDno18x7lrwCY3GlLvbhdik8ZinaQLo+U2Oj4ialOEe+pLEQpPLuTueGHVOu6O+lk57tAUsd9+jq39PU95y9z2txvdofS1336Orf09T3nL3Pa3G92h9LXffo6t/T1Pecvc9rcb3aH138/furLEbL7OzpgKBwVrG5/QOjb+Zt9nIoEmrv66SkQVuGiW/JZeZWCnSFDRDDM3n1LebZ9+d3Z1VG4/P6/FKZEndgwpmrbqL4Ftdbp0SAj53RZl+OK58ekLBuNmoWR8tkyMGwtSVbYS9MQFvEpsrs1yZ49P5hMUr00tdnXN3/zu7rbtTwcQifeXdFbIPvf5Bx+4PuLc0hmorvSx26xN2OQUBnC77x4s3N7VEaU5cGh+kE140AGbOmE6QOzYNKgi4pSRbiHMQsZLEwFQwWkmyUgJ233Rz7i5wLDs4DTC6wD51UV+5CMAKAByJxpoFAFz88YBR3udLN4Xi1AdxekG9toZ0caEgIhUAWOLiKgCwM2kYAbg86Kit8q/b0vqFq542HqBZMwfBHo4m9x/XNxSJsgE86Kii1YUXUrqAONJp/LK5DSy0rinoRwFObdjWetZPnq1vEiB7SSemUIQxQ6ZR8guoRGUqKm/uJtMZQQaYIaZrj0QTmC4cibS06dYdFgCvlwUAJ5pao41iiuL4AyoaADBVTEVT3bhQxAgALODtLABY2qlxBGC7KwbmFM4mD3PurgDA4NqIxJmMU486DqHCpkpi2kbHQ/DL6jIJJFtUFKzgcLsr/HxpYyv3Q+lxA0vUGUlx9/KgB0Qohq4KeirL3ITU1VNSXMBhu+j0iScePKQ84CFLUQFyN3Fiwj72qvb7PXafy1tcXOWI4u6yOb0dpJ5wTuhrx6Dhddc3h3Ga+645atrkQamELpo/I4kgz5JBn7nePZGOJVLgY81oJ4h/9XmHGWKA6UCLfR4bgGtdU9D9MV5RK2nw2K6KoMdOVGT9ii4Leqhi6oHqxoX8Lt2Kxr9dHjfOg8BVQXdFwGMAAAYtXOZnjlZ6iMvVtTl3V+QoT01rRy5/wUkuFV9U5/JbQKNd5gi4zJ5LDpPEdFi6xIoF1TB+WK3DZQb1yudvSQ5NwaICaDelRCVgVmAjGaChqVPHA3sFh/WvNRFb2JaIJcB6GwiQl5ROxpNOCdJrNFVT9A5bSgKl25xmTOFIJeLSpFVd5xVXcCptXqurrCmy1wWE7ZUrCSaI8zmrQnQZi/H1EzvJoW6YNG7xzN35Lj1PLJoIUG+lenfMxgiuQI7bWSGtZDpX4vUm4xLi3aAAiEPRRFnxgbNjPubuPKrGk0EYmtAuGwHYlCnANvMBhlNr1h2L3Q2udlt3x7Pkiw2tCzKuKEVmhtCYjV4qPRBi0GsZC0P/a1pgKM0Tq9Iz34nqyZi9r5kie7X7/WumM9n9tLY02kMtYLn7Hlrxe6balrvvmfW+h2ptufseWvF7ptqWu++Z9b6Ham25+x5a8Xum2pa775n1vodq3fPeu7N0zB+wXd5n61aagKiEjD8zCzGQwcxpSCzYBAUi0C308yXAPyNwST4KItYl7ViM6oIp0JRuEIF0DrADmEIY9rSjy+6OWxi5WTZV80Sh1PFJjUn7r8qoxzlLJqFA66oDNrsf39RlrerA5U75ZYGdlXP9esvUlr3MbXKjXZQheGBmvQipdAWWtpFJzQpvKC8wZIe9qtKvBC7tRC532ufHAqa0c5nVjnLtFW72PcbZjYd9TOqsq5bq0DqdnLKdRRf1TZsiYyvFReNZgnPn8gzvdMHd+ZJAVsOJSKWzcK1upyCgRCgBgRkQkwpMEEgQxPwSEBRiHTCijWiABLdi2bypNfaLe2cTZ1BCKuo0JE1f+CMDcDYz7k5HBTOF9DRuG1K5G7a1ISryGGknITVRKqNdShHrIOtojhIzkYh5f3t6oYKFlm6gbPuOACa1w3rIoYB9xtphOYkATHNGHs2MxX9h45DdiakOKkWZQiB/RYlJoHJzFY0sSf2KhszulIqDFeYFH8av1gY6M4cYypIfuORnNO3uwKhE7iSgTAmwWezgNjpDQGJCvC2pbFGcGG4eB8TiZ2gVjaeI96pnZYgj4TiBEUcNqrr/mU+RwNjXRTqtWMNaa1fCNDHxJHtXBwb1LiOyMGLrm0I8OGMKNafCFHqYGerM5/O+8dHqH/z21YEDKoEWEkCvhIKmBd5RplBhyagOKoWqIX6yHqKfunPHnQJstIG8T4kLxXUrmn7H6Sa6s6iH9aJkNIwATOPEenrtob1+s2em3V2w7A4wvexUbwwA1vp+YmS6Xe5yf4KQldmyOv6LSi434XzRzO8VaLGdtmLUqaSnT+z32h9Prwwwgpc40J+vOrAU0pZs/QzIYLPI4ve4ShPb7I2hGGzRqjKo+5kSfPwSwFZEJfitx+1GPcArReUWBKLL7XE6yip8r9x+2oj+FeGYQNaKEnOTFPo8eodyc9rBjZ4IiGhp7ez21kiciuY7D50+rYNQ4NerAhghXSm/xQ/cPQDoV1U01Y0LebGdjikkCrQLTK/4DEYGNiztRMcStA2fR+xmRlRNONPunukuZezQs5rq3TOpSgI515NFkniKVL2U/Gps1WVRs6GyNH01WdRyFSXrdFPHVB3ocjS5kw7JHS5UcEa6H+ZdBmJoVtLUU2RiCj0kuyQpZmoQl09pVInGwmiWMqbRBM/R5E46KNTxIkeTO+mYnneFmFQH7ig4Z/35F9pJPecq2qZ5RR6jvFOIc17BufanJ4pwNqqEPL7Z0y64ezbLLvsX+zIkoKRmOwM5MJCiFGJlFANaSYJYZekCcQmOnzUZ1ZTM5Ndt+p9BuyxbXZ45eXN2M2lkva43x7BbnfQkd8dw1DR/JQ+NLPdrTJ8j007MEBvTfM7UnDx6fHIEXRLYPLEZSmQzSaanxS65rzOx3iWyWIVaFtjBFrDcfQcb2GLfnSxguXt3qg1Llh1sAcvdd7CBLfbdyQKWu3en2rBk2cEWsNx9BxvYYt+dLGC5e3eqDUuWHWyBbvHenXVmFhT5M1gF4S2vRiNkBnTKXqx9QAZbk9YTSi1LKdZaQF2YOwyRxcjYJQFycrabAoV1Dk07+EsR5gSGyjwxG9BDXIqxLP5qMiCmgaE1jczXhY7S2+d2F9xd2V+ClujBOdA5l6oW2xSlOussrAJNCAEL0ZVlXqfLV1nBHqD6lSxGTftiSa/XnMyJZDiW1BM1Xx7KLAu42eGWIH6GFadlsns8bIrr1EN9ZDljDFd1eQS8lwICmTAF21Y67dXlhCz2ebwAkg1NIWjTpFt2BjbwtIzAAZCZAIzd2K00sdejNjrXQzpl1dP+dbsT0JesNZudOIdeKlpVh7Ep0FrDFGd8iSx6TqFxMzRTR3HNbhJPLj4pEBMnwBsZhURNOiCAHAxTMpkIR3U3Gqe5u232tkgiHIl/7/ev1VT4gInqaqbEpsOhF8ZqhUp0ugbQggDEiPzaieOjwL/0p2yIAYDp0VeX/fPFRUDfzHRCdGmIUEJUG/BmB+q3NkUIQJlIJhBDT3IYeu1OyCA+55cvgi0DUksJndRqv2HeFOSREUDh6dvz65+Z0S6X2wwxorpcjvrmCBVNdeNCcWK26VQisCi/AxppljgSNWKMiPQk8JodgYjMqbidTmjjNIjhA6q+d9beKzc0Ux96QMtcgQKeEpS8kR9ATO06HK5Plm9cvanlq8fvZeDrGmda731PL/hoyZbDpgyypU2FkzXocrLSypa9BOw885gxIwdWEoNSdUXZxI7/SlIqCRnE1Dc+xEjTkaTwSj4nAlhWyhRaNm33YAMBOnBX7cwsMeN5aVIi+9mqyrxUNNVNpVP1HUrciRfmJgYIhDs67G6XC5Ssnl/SiRDInAqD3O1iaHYBOtUFAIuS6dpq3+2XHWZz6MJHhar9wIUA05eUGQEC1/75hUdfWw6IFKB5O4NOZ3TnfCxClX1h+rC//ewM+pQSswjpdPneh69GzNVZOi6EKWCDxmKnx4+se/iGE2z20vBmpYRmClOTGbCkKoupyYzSjsZWor1lDQln06ZIxWQGyJcp+qYTALDThfPAH0/Df4wBwDgjlVfyMSMrbWnXyVHi8BzybCSDY7GD27lURSKUegBgjUE6kWoKxcr90kJKHrgmIaHLAi5NFD162pvL4whF4powetJq2VWqyEmI92QqkozJbFuPs9xX0bEJsuyiSoqboUPu1nCi3E9nDc8S1MDzW8KJMvkkr9SRC4kKsU5dtLMgML/Cu/t45jFBjN3Au7tBnJeQV5y2NZQAwq43M2mXQZ21hOPA4tVEXJc1FbE7A4BRnhHZ7KBMT6IR65pL7MpAD5nx3LqgJrjUJKH7KSGMerY2I4ZWhHlJEDjDtrNwBXdoaA5TppB8ii1+LnoZ2i1HbFa7bN2ZdHdligJNdvalyTFrZ4tllWdZYEdYwHL3HWFVi2c3tYDl7t20YiyxdoQFLHffEVa1eHZTC1ju3k0rxhJrR1jAcvcdYVWLZze1gOXu3bRiLLF2hAWMl/p2RIlFeJZ8HazlMUlWpIDtfQtJTArTVcouse2JxMZVYd5cxnz0Unexu2swU7UkVLruWDtiuQQ6w2VPPU23231kML+KxdqOrKiakBgSKNWiYylRFc8uEYvRTMiAnJrA25/YnHailDlJS9moeHoX3F2ZS9Cb/BVlhk1zqYpEUeoQKw6sfwLQYgf4tIINGXs8OzMnweQAqDXGXSjxMqXm5CkqsNwUVXLqlBYYDQkoB2LRKVgRY4F1y7QSDC0gziDIs+xmmnoelF/RhgzbE027O3EJk6loLE4MQQOIGEkQwJ4Qp/FEPBwGLZxzpvZSOaOPBN2zqb7t/F+9uAJEZKkDLjjXhOG1d199ZHnQDX6mOF8VWy9olyCd0LdE4gTgNOAtfFyC+4VcBI7EZbFd54AhPfuVd7zx7Nur0AsVSh7Q6NVW57w7iFiT06QYIgOS6dqgg9TbXWAY4uj1TWEQPsCNcGiJCawjjICjvFLRegQdZFUXpt1dyYGDAh80cHd632hcHn/phYEO0RESQLBzqdzBw4gUurVh6ytz1n7ntAmD+5THYoBvdYjTaa/P9cHCzc/PXkVWj8dFqGwdWsAhmAwgpqSDyDTGRSEGcCjK5X8EFgSnjsD4NlTsJf/0zJWjB1cdtd+QCKrqCZHVmcoAcVVcqyyN9i/86VAI8NnxdrErLRozWE6XMQBP8iIgbGmmVI3m98U4Zu5BTJBeMQVGKNmYFbEynhn9JKIv+3EblK4lMXgD1xs3rKZXlT8eT3rduswxK0ph3ZJ65Qo17e5qooJDUICxu0MAd4TA5xQMuHj9aRMYPmXweVzfPW3ixNEDCXGs36tge99/X5770vurFQIZE+jO8agzitYcEWFKICIBl6uWoeWC3qHj7mIyOyMBO6jbTzh46GVfmW6zhbBKzpRFT/hUATxr0aTON7tCTJT0JFBZExMqGkdCfFcQyKVdOJWIC2a75FcCSnolsFkAcCIWc3nMIL1F4OZQXPiqUMCdDaXdocpwyJI9Tn52szWRy0NL0mtMWpKWqtlVznUsTBI+iy/yV98STcRDrW0xZM8VlH9CQPfyilRzW4xcmvtq2fNpcudSaPbgPP8ye7v934JUuczL3k6nbiMcz9bQsOlAIhlqbg7ptXwtI/QtkUTQ66JiSh6wbYsmyn0unfLbGcCtOwS8RgwQywEPT1/aByTtEhY9aw3Hy/wa8r5oeuYm7st3TNFEuq7cW1A7BdmMUwuItcsuu3tRLp/zJvbCb/jTc3dGVoPUz1n6Z8iOnJrA/Bpkx8k1MpPurhGbcXfaHDspQG88diEb3gMZnmGeOCNGKTlQSqM06e4asYG5tCRN4IR8BbL9D6Pa2v6lWRwtC+xSC1juvkvNbxW+cy1gufvOtbdV2i61gOXuu9T8VuE71wKWu+9ce1ul7VILWO6+S81vFb5zLWC5+861t1XaLrVAt3jvvkstsGML54U3r8ZNrDLJchiU/JV6392+PKfRl1RAeGaZmyHOiFFKDpTSKFlkKkUrxZqUVqMsbYWSmhQjsNy9mFW20z3qDFRCANiHiWVH8Uiin3nNrao604AdTO4MzHoQcDmTxKxegdsxs40wbBMpm/lVVUB4yFDStCwzwZmdxneEx5cuvrN8Bn1VQVLBZT6rzknc6XxTy9L5fuc7Oeb5SZznX+ZocicFqQWXOTJOtKQCgoLLfHo6PHx9zZa29ZtbJeRYqYPaDcWSBMot2VPiDYAIAJ8BTyg5GOA70VgSnmzebYaYDcSB95l099ZI0u9WIK1S2pFOPNSgr7S/4e4CNwh6qsu8QDVKG85E0TmS0sVnSMXEKQlpG9YN6kuFUa8QkEUAwPFEmwCAiz8eAEX0pNTu7MRlFLZxAXzqYWYIuuuORxSUFzK3h5C6uvBJcKFlDgoXAHBzOFESAMxSOMIANI3H40rg4haGGzUBJSfABoEKG5nClla+3nrqj55esb4ZtchV8gD1Zm5eIJy6QqxpZEaELrHdIcQYGQjnvmN6P/yrE4DfUovF60Mhvd1eUGo7BgBM/YFepIECfihaczgCNDgEqXQPbrcRMWQAJoE3Qq3YukGB6Lp7Mu33uYnMCGcECICjSqgxr5gcuLvbReHSdMp8rqgBwpEJJSOsT2I4AlR2u91lPn2APh7GpETh7MUUXnfQpwv9p1H4fa6N29pWbmi5/oIDp47tl0yWRgtHYkn64GI6dbzH5CQpvTt2K4GAIx/ekyCUpM2N9aSpGh4qoCT1axIAHIkC0JXZhyHTTCLh9v2ltKM6nG7Pc7OW3vPkQpC1FUFPPK7rzVQ0FqAuSqqVE890765yoJf2l8tfcJJL1QyQuywg4zKfVe6ck6JHhkClaefSsegT55hkiHPXnU4KCAouC8ilRFWo/GtoCo1Qa3IHju87fcpIBrxM5gKm+ZcgdR0ma4RhIKnCBZfyYJFYwyHC2QwxX+fQnRXv0fKFlXMR2CwA2JaKs6dCIYfCa55f/Bs2N9lsCyW2b9bOhVTq2riyimYxadyiea2bJSyg9TqghfkOLBmPghw0yAAxs9suRgA23DFHK6w9ArCpcME7NAJwyVDP8oES0Zuj8kGc+T7bwKoFSZa7Fxhk+18yUxJHLxVbmNqFzLhJZITjSaBnRgAuqZ0WvZnp0favBsXR3Ji1gwq32FoW2LkWsNx959rbKm2XWsBy911qfqvwnWsBy913rr2t0napBSx336XmtwrfuRaw3H3n2tsqbZdawHL3XWp+q/CdawHrvfvOtbdhaWAGiahjSKISgSJKXE0TlIocZFgyaRPOJbMIFFG2enQ4TIB3FDFsS3LVNDKjHdwIBarhUErboesUlrt33WY7JgdLK5VlHpM7KjvdaXccVIKpg32S7RJCjL+SLcReLoG7wAWYGvYr3Sx/wtbUqlCVB54loog5BQTtZ7dxFNsRa01dcHcaMQ3ZAKQPQS61JDGUxPbTuqh2tjrVobHVepHsue43ExCoQ1xBIzZwihwBJWti6EHTIaBWoYGbGe3aOStpuNTjDEMAOCA4iYAZiydYetQ01RObeJZgs0YNqpo8unc6pYug0uQEnrt8XeP7n24myCjm1uOZuW+3AyCVxV1zMSIj0ZSCiJXgqiWbAcAp4KBn1vyNCCqYVuVReo2JZHWYKl0jMu3uMoASAThJuEqnDiQb4dwCEpaIu0BkE8SViyRdOsQo5kk7MAHK8BuKJNgR2wAR6Y4miKkJZ/h7I6D/jQDAQSeFS93Cs+Qm8U43w6fMIhIJkUFvoRtugojkULFLI7GEoSmgs6MXAiMAThyJ6HJGUp/P8/oHa06+4knp2KRVabVT/BcrET9w8qi6V/94huaXeg6hODt/+df3/v7E/MqagMxnSh6lSu/AYLsTqwDzTNX2H9eH+msOSZhEvcGDbc69MZDgRg2+g7RqJCq4o3OpwL30EGX+EgBgbdLnUwDg8gABRIsPi/Q0dpcghFEHCG5ZwI0rGbh7wOf2KQAwAgT9LhvNRGe0wwrECtXQiGzQzkiuo5LcxtHhRrkaALjcljAOicp4ATtw2H6vO+E3BAB7RTuKAOTs9RBmOKWnnXRpLg8GQceXbjt1SN9y2okenAxXKC/z3/LvOf98YVFVwG2TbljXicEJO9weuslD9x/yyG9OaGslCqeBMZjB2IlTCQAYo+kyzTLADvJ5h8SING6emQx8SyAVZ3xIoGlHazgGvrpXpV8+79CvPRydkLo7EACMqNhWz7xakpaqGUvOdcxGEopkiBUZ59plZ4NkyFRCLoueHfKZcJ5/qcc5d1+I9QTOTGZytMJZj7mWpKVq/ORcj7PcJ4q5DB29q/19e5XFIrrgeOrYFwgyCEgRiKRkMDYFgz4+0auqrNIb0WtymlZgswjPT4Ruk18z8fVM0HRI1JZwvFxNytstWOwMGcJxL5/OJPg0MOshxQh1jV+UWLtZqrUZZLWSdoAFYvEUkzbmP3qoQNzdy7TLzLQkTzw1zVVs9UYNRUyhFM1oI41Ip3HmuNLvMtFn7JSHjdxd/ROIoyoYuj6JpIgMTFsZRY3GLWMeuqmWu+uaZpckUMd089pRVADDxKI5MjezGfVGAiHL0XBixEullRS1gIPGvOBm58usDGZaUOfcJe4YTuVK5LWSLQv0MAtY7t7DKswS9/NYwHL3z2M9K28Ps4Dl7j2swixxP48FLHf/PNaz8vYwC1ju3sMqzBL381jAcvfPYz0rbw+zgPXevYdV2GcTlzUjVm74c+gi64QxSzzQ8ModrIGZZSbFk8VgU8tMmgAl5ddkUIinkrRdJuiyu6vFBd1icqnaKoUsVuisV0iSrGtkf42DcuXIOmYpKkeGp0rjXLssSsnNglS5VGV1ppfbWW4aiQFzYZMjVtRGnHME2Vy5vEXE0IhVgsZT3ehMKHeEgB+7nVh8LmegqqpkxC97wN+FbYT9PjZJLskzI1uAGIOeklHEROCyVKIlFBcjZLIW/0dpV4KmIGcX3J2lZRooq9x6W16qpWcWlgXqAHgTOs5dclXkYKXaaU8RyZY0fgkFCLEeooO2DoJCWzmHjPOUBMIsbg2E9DoBR0n3BDF/RYrP3kIMrwKaQq4J7JTercgBN0rUMLQij6EpsBV7noLNghHasS6PgnpYS7gBIMuaQgTmj06uiBAqDihFa50fZICBkbw4qU0+6XA7CRqa/GDx5h/96eUoYFU9UlUYDhZPCn7BDC4ATuBeAdggqZklUKwBdKeoUrmb8IQd0ST3Hln35WNGU9EG8mIHMUXJYSjHvQuISMJwpvjURQrQ003KVThh+EOF98RFluLehp9JEG81dOK9IDX40xtqBZ2brWOcXmAdfPaiM4RC6aZsVazGNk/fwlPEgAaICP8rgclX3MI5d+eEHJSCJHra4YKw1donwuKeIrOOW8LNKdqJxJp2YhYdd8+ZAjHgaZevBnT4Ct7T5kwmDp08YNGqhqdnroSSXMYHFDolF8m3/Ykp3eHY3ND28CtLjjlgcGXAQ+RXPXmAvoptqbDiNVZEYNO9OwBgp93rJuyt20wEYFD/LpcE1OXzgiLFcgv/crn9Kpw5IFKwrzbDCMAgQuFJPlC1gG9tLjqq4lpiAwcAYKckl/k40RFAiYUPwk3rzzSB7QYRg2GpAYDdBEN2J4wjAHuRU8zLRILYwi679MSqzMIfhYV2a7F/yYLMyC59ZrGDlkDRIBZJpi7oDEvMsu32H5w16bunTVQTiZLebk/EFarZGCicFSwWTXi8Zicz0WjcS8UZH2mc1//g0x9cevtMkN4APxkTdCwhTyM4JMYq3YizhZp29wx8laqRv2z2Dv9yO5eqSIRSLxqxJGVhd0KssS3OWNgKhUrNnut3aRpnJRrEir6DnPkXGrfsHSHW+RxFoW2zQuS002POff40iXPEepyl0Kx2ZNHyZkUq/JfUrBSSRwGAdU2hZSZ8PrMUV8pUSFRwi0jgdit4cWHhHa81RKSD59riLbMjtcAnvaUmM3iwy5NkjkQ3hKKaKfS4Z0xRUIzhpVHPZ5jRSuwxFtAbKHqMAttPUMvdt58tLU7d3gKWu3f7KrIE3H4WsNx9+9nS4tTtLWC5e7evIkvA7WcBy923ny0tTt3eApa7d/sqsgTcfhaw3H372dLi1O0tYLl7t68iS8DtZ4EurKp2qVBZHRTYTBpUR9GMJLFophbGiqZbN0tbABuy4ihrqwa0AnZSK5SCDCpeF+25FTFVJrVTihZsEWRCae4AGkT5eogAczw+L1UX3F3ZVLAceqt06K2l8gucw+HwenzAnooPICrQmrsi4AFRJ6vQiq0uZyk7A5pSNJxLlqLaZwhUGud6PDN5FecsH0WswzYjgipTkRiZAoaUK0KK3PIjYqizbFnt/6o1eI1WlNRk1hNb3Rca0IVOj1dAeSUc0+53AWvhoK5Luqa9rIz60v7aJdQ7qyhzmt5GOF2J0OCXBAmnjFiMqaadZifOtT8ds4mFM9YtxqroPdPurmKKE9ozpGIIFuVF23UlCfAXpxX/9J7Zf3lyIVDATDV2yqAaur0tEg+HYoCbI9EE0Ql1IbLJtMub0KC8COCRgKu6nMFdBBwJBca0wROoRqfC22/QOTk8TvodBXJMIIYEGS12aI0Zek7ALUUNTQEVtUrYVDgRlyueSEQNtAOEbHNCBjFZkBkxVF0WkQPtPL44YbaWrmw48nsPafIUlzibW0SW2IvGVBlqGFJleh6WZdllYlxiWP/KG787jaDegDr1+ANy9DkIoybgUCqa8JOCAdYRXJlCKlqPoEBaLk27O5Us3ZM0OD1jUCrQnqpy7xXn7CMRlt2OpIhtdFAHk4bXDutXjlYCnNYR3E6sTlU6vKASVxDa4mZQqUKvEeuRaWJBJsUKO+lzMsy1tI6/YgApWsi0E8moFdORkivpHrOp2r9GnKV4JUGGs5GRgaMCYP/CtGErNzTT6qTxGR5IS0uGBPOWohXVYKnGWk5LHxDTOegZQcuPo4Oh3dIY+ttTCwBmTh7bN5XUjYCpcM9aVWh1Icx1bJyxMKkljZDTxLS70zIcDKBOr3wXU3x+goUwKODV754+idC7Nidoz5IWTkfDhKW14+4BApDn5Op4Qn/gcRPrVerA6yFgJ2OoIKM7UmWu3ElmRy6khRposZ6xNGo6M7hBA7nT6RJ6nd5d6KFTriPhgl3E9XUQ4DhTasd/cENYaYhlwgW7sJkHsYr7EE8wbDcAGTzIQkZcRInfkam6UizS44bV3n31kW4PuwPo2SyXl002GG+BRJqpDnsyHnMiib24Xjmm2kk8Fnd7cKHiemWJkdAzb/Ha1z5cD3ibORhhizF3NrXDv8C6nU5ntqKdBE/mKxm9GmSAxyGp6A4sDC+64O7KrlSEHEV5anfp0JvaYozdfo+JzoegyeF4RdCDSnpsKUslZdJV4XKu9w0Nrpb70pLzTLaiEmc5ZxPl0VkPpot22FXjlpNBjzn3VdHCWCM24CxJWe0hVhlVpqxY+f+KGCBviS4fS5b75PEvP7XzOc0mHEtAFdC+2upMkXcH4i5FAG4JJ3j4Mh436FCCwUR9S5QTTVp+6ayKHkqbjFGzNtQhzdadbnKxArrg7sWyF7+H/syA+Ss9fDIaQNaF9lm8xD3tLiYzaWE1askHEGaqQyPWOJdqR9LqNEpjd4eMLhqa7lBHxecD3UEySwbLAtvdApa7b3eTWgy7rwUsd+++dWNJZsYCXZq7W+5uxqQWTfe1gNPcV+SaApa7d9+KtCQztoC84UinmlvDPGEbU+ZSLXfPmcI66WEWEC9PJVas3coii94b4QKVLHcvMIh12cMsYBIcoWm1Q967w5q3ttpfSeOZIctwK8mr5xPk7Gb8BNZOZkxHReTVBbmMjy4Rw6okQ+Pidn7q9nd3zQQss/NnBhyqURprztRMFlZMT9GMuXXnVBZuNIMYzEcxA0YGGWXGwvCBDHrzxJoAJV0ZMWSBSejMTp13ueW74O5KJ7xODl2502lBqyhoADvjsmysS5lNkK3WSy25gZlxemXfdyhV4epXR4z8NM7VZbawTv9q3LK3FbEeW4iyzHIy6DHHAkKbMVk2px5nIZP/GZejsSRIQANEpOIlYVajCfY0xcIlemwMpoEIKMAUcTQBMFXCdZZgjCC2SDxZEfASr1OWWHUOSemiKbJ2UybM5i3OXr/covSm3R2cRjIVicWBuOhBxLRmTozRb//2lVnzNuD2Znr3omIV3IQzjg5OGARVUxuwpHjSEAActMeQllzs1FwSAGx3OYBzQB6Px0LhOP1rQenaJdxwHSg5AYocjsbY2dnlLN6eoQIwFIoIAJj2HIvHwpG4XquGp9dnR4C2lujh33vMTGz1ohLu5Jv4YXnA/ecrD99vXN8QOD8dz0M7AKKhaBKzhiLJSDQei8X1JtwAgAO2eCQmVsXTYJlI6OJ7BVRjkxoxr7hpd2c0dDgAqKlI4cUfcHEE8G4NLZE3P1p/0rShB+89KJnQreOciPQQxADNXeqdYCwC3g6oK+tTEwSRaXe49IZQGgI4OaQlC+hC45FDXA0UJJ+YMOi7BBFp4O5UsKAXFc7H63YZmAJ3h5UgN0EDKkSk36M7iGE3eobDpgz467XHhNge3lhiZSDahkKJFq+IAhsyKmpVU3C/6CVYcyaNekbQsuBngE5x3CvumLlsXdOMfQcnyaXTTWBhn8dFdEi8kkiu2MRp041sLnXnyiAiMS+IyLg+IhIxMLIezrSodqbdXUYkGW21iV1RXtiUHt1L9TrsJx489EvH7EvXprDfRclzN2PYIXdheAJcME57LgV61QZB4YS0KqS2Llfih8sESWlHNugdOtUmLCCEVHXzxqagxxFDKceFv0bMr2Queghi0fW1k8bZ7KZNYWPoMAcAtsVVmaYAwAxdNOdStYbr4rShX/71Pa26UVbX3TUkmdIdg2AEeQjTNYXUnTZQiAHlqYMbRU0mDzAUqpNYPEsX3F1jQBn8FT0kSZ7WOWwtbXxwE0rEwnoznxwH5hvlfhn0Sx70E+FYqrLMbezu+eKJSDrSasUVpMqlDj23sWw+Pef5l/nya0kap8wv/2hn+XR551ituTkWNGMKNcTz9ZMQ60mQ42zneUAAwD5v3Awxwwshwt3EFteXFlHxxMamMDUila3MoieI3FeOIWRKKu7oQWXzmXCu/eVUKTgRYo1jQYL+ZZfdXZ9VhxTVnznoOUu6OwQlaTTWfDLs1ANKdyi8p17QV5kyhWp2zFCEON9BiupttzOLgsokMWTan4EnibubrrWiQu2qm6Ymf7tKOKtcywLb1wKWu29fe1rcurUFLHfv1tVjCbd9LWC5+/a1p8WtW1vAcvduXT2WcNvXApa7b197Wty6tQUsd+/W1WMJt30tsKPeu5uXkpUKVivM0EOm/Rm8EoaPRlPyfbSZErcLjaYgUhmv/yFwRruSpWZjkUJv4r27sNWYmyQuGRJV3rt3JRhqSYV2GsGud3dwEQ63mcVwgEbpMr5MdJWQ2eMGYOQBnrHTjKhXkObf7AwM2sjhRSpjh7eVscZeSjutLI+LrU+J5mMKF+An+hr9iR27lexW7GUBAASYzth68HGW+RNZUIWeAbrd/RKus8PldTiWrK1PxAEYYd8SlUEvFYmnAj5CbhnJJWhhj2/jthAru9oStxH1jkxj4RMPX7KmsbZqQzIRM0ar0QETGCwgm1CXOgiDl0iD5fL7XCY6bLvsDJwm2KCEKivB2m4HeyyrqloL0aFWq6rO1rYopgb4qUPVHW+bdne7hL0NRw0BwKxUuyQCMIpG46l4PN4W1g+om7K5Pc5laxuOvvjx+uZIBgdkbDqtczSmoWwV8JGtosEYNofi4CgNOlWakAYATiQBACOwaQBwBFPgGcV5IyNAFTyhrtJ34e9eU1CnUtVvUjuNzS4nVmFccffygAe/b40Aki+uoMy4HHa1c7cE9cWFYlFd1CcMg/Y4zgMvBQCW4KF6KDBaHQBg6VNMH6bdXYF7/V533E8YyuKa0XcAANY6VIDpbFfPeKdHjBWgSCaT9c3Ru644fNLIOsG+6mmm5gH0URiC/q90J+WwhSPJfnVBwswDf9XnKvPaoJ9Q9AK+Q2DAanrIPoxKm9QAwMyU/D43UHo97bA/Qo4cUPHoDSfShIjxWVJmCMBCE3KxZO2hDo0TQH+AOU0pvsgsobRV726GmG9BmHuZEliFC953dC/Go4qgu3i7V49SZX43Mzr0AvWJC3n195WnslxutxZKllzlfjedrF71oQ51ZzxmFjQE0+5ekG87XWq9I74+ddyAdDxmFH0XB0qmQ7FkMMAIXrp4egWCx2MRPWOVZvH5KMQpE+lRg6oqgwrTq+cOuVLStrZIIkjk5JKHiunL10wBP+DQUraw22NRQUR6zc18wjROJjMeI0RkRkA7uNcMyrKkciV12jkEJoy7IwXRKgu/ZGrbFpLI13qlkcCwhbsTWsREFctsKplKeTMbV+hx3bH38Xg6SyTXV6tdAJRiIwMZbtrvFT+DrfbxnpndfhgwtY/3+FCopOEgzkQAjpf+eA8xmKyW0Yp6ztEtZMXK2jcQxu6OH0DAnxl3h2GpV387o5Y01fCMkgdKZbQrRQo33p1oxCUHOgTQLMavSeKMGKWanRLDhGKl1NmZ6cVn4TtTAqssywI7zQKWu+80U1sF7XoLWO6+6+vAkmCnWcBy951maqugXW8By913fR1YEuw0C1juvtNMbRW06y1gufuurwNLgp1mgW7x3t28tqw0aTGxjLPwShj0hQCYSq2tsGW5GYYFxbFeQy74s0ZekJR/KUtjSgaT79014lLvuyW4UzKZ4Wxm5Qi2vNQvaQok5yU9xCyoJhwlGWtiYAeYGy2EaBbuErIl34bb97zL7k4VGiwtFKQaU6KJRpD7NaCXynDYq8u9Ph+oVxNHKgWOwOUpCZHFu7xgYDSPNBAgIyQYFLsNKI7LGaiuAvBYYnj0ehMer1kj+6OmidMA2pLu0tphKHsQ/CRrWAItLt2UiL4Ezk/WsUwcXg8CA5kxMBtcxMJVZV6xnLKyZuqi7PMZcZ77K0r8GW6arQmRWu1wK4BPnRhQELCSqSFCoaLNGxCzou1UgUjhTAch3TagMX0NiI7WFo3/762VoMpK2Vc6HnodeHrdsgO1PlcR0ud3r1jfXBGoBWCHDDoYR6k01iVZioftzLkb6qo+CKv9vg2YU1sglqUtGRBlk+BPpFWfu3TgKLSjD44Te7GUdvDGw+LYgi8AXCVMoRGDJ2NB2gyEEzGIXepxSYw7AxNjYa/XtWxtI2IQ35hRQwYQnZoWH6AaFDvOtT+95gFnYZc1oJl/Tbs7DpRKgZyOxJLYrShrSoYGAlIBshGgmnOnDjHu7rE58AZcAXxLJJaAWBa6ix1oVVHmfeadVd/85Qt1vYJdU7EYw/x7FMpAv9+4PgCAQZzrISLJQrm06GmT+j/3zqo3P15v3JDyi7DOscDkUXUV5b5oNJ6IJ/ViRNKbOJxJnAd6/MHtShhHAIbYBMio3fym3T1tI5guoVzL/IRoLd428QbGeM0JfB7gva4yQrXpEQvQ3BX0SWsA0xv0ewA86bp7Mq3Qf7bqmsDH93+5ssLHnFEbGdtVyT8DRAXgPgVa2BRmEIxubaXP6bJ7XIYzJWR1Ou+++gh6KR8wVqN5e0YagOBBL3HY84Urfo71gIiZQlwprCWISOZU0gSNj/YYkaa+BQlF4+ChjWNEZgq0A0mXTeL1aq1dLm04SqZqqwMA/fAkvWkV7k78X5yHvHhaud/DmKBnPTwt4McZTRg3K4ppd88KKD2cjoVVUqbL02jkV58YMfPIJKN2mZWt/d/cfcauiqAn6PeCBpYpi/7BQMiHHR7cXU+C9rx25jz0KNIydaRtp03JcFRb4bPpTXraSeWM+Nk+MINGkmYzyMcxTp8ZADA5kkD/k155jCkpsZ3I0RjQ5aGuSxPzxYJAyJm+mzjY/N3H3N2cw7W1xTKdVK46OxWhpeR+8Ql9WuUtJRXqWEQX3L1jxl12hV/K7E5Q//pOpL69wt3dLqJjlzKJzG6JON4FjaAXFy7FGI5QevQ/UMgvEjEh9qpxPP9+kXPVuwtnekpz2kHlZOcFc8ToJR9rlNROGdlNiHBz7s6M1KjKiui5/W/tVHfHgPoealY3nFz8XPvVy6RSM5R6NLn7xqxyZHknZjnLk2LmLy+37qlZtlme0Jc+stqZJ94hYihTlJZ2B1N0pU/7nKJgd3PdwOcsx8puWUDPAjvL3fmuJ8oGx9o2EnrCWPctC+xYC+wkd2cas6E+umpLhDd9xo+YO1Zdi/uebYGdNHdnklkZdPHyTqIdlXxg2rOrxNJ+x1lgJ7k7j/m1Fbw1w+1lqcY6LAvsEgvsLHdHOfFyy9N3SS1bhWYssJPm7pa9LQt0BwvsqN4dJANAFP70lITA4RC4lR6B3n0ARrAFHGS0ZiEQMSldBCj5qGAXzAwvm8FfmCSWhWsymJBdk8HMO2/EzAisp3nuvmiXNa857TTmJrWTVQ26wZLaZYxsd5SIbZyR24x20IAy6BIMJmcVMyddcHe1poGPyaHHWkslvbIMBF7A5YdSbwDBnG5W41mTk2U58R85inLWboO8A79VW+232f34pnoSKEouN13ulF9ALaaW2cvc2sauWKN0JVe6eZ1aEvWaEazKA2ezRq7ymiV2uQFyYgFT2rm6ol2FaEeV6dVaB4NXVSKwWVNUe+CMwEaHS6rMj/NQ45o/6DuF4qPjMHplmK0J8tOlJpJJoBp6XTJdCOv7YBshvu2RuS99sCGVTGSA5J3Khxg3b2gOR8ISiBREF5z1lqPp0VldJ6xmfUP4G796CWxJyY5KIQ1kF+9OJRe5oWlkEmxEzwqlSTtDrAUGLFJqp1vmibEeMpvk3DXtGHVVTNlO0hW50SVTCKZDBy+YY02tOZyuBcu3cAdH0rBMeqYGT+NyqU9XcvlLnZh2d0Loq3j72M4A3oyIhIT9+ol7vTxn7dzFmxTqvbgIGR3stpMOGd6/LogroyoRXYseTDKikdjUsb2PPnDI/OX1dMEyfup3xDAXcJGKy8Wv8QExRUMjuG0zxGIB6XtKE/OxkwSpNNXkEACJRQZjcdVqfLfQTu2qIKbQ+wCioyLIXNIUcKOx4Qu4EI6EO0kWHYvAEG/USexYdvbKtLsLuNfucbuAs+oBgDWe9NA//tr+13/rQMHrlRQmnSauMZ8pCHpRgvMbHOmJw2sJqFsWMCZTHJhWAgBOEgHdhAxAZKMSmd8DZrCkwHZ7KByn1wEtrFcN+ToQRTFoGhHZhZCoCUFEmg2JqjaJ5xsLM9qF1SbxLsNN4jMKEiMylAC8bRIb0haKB03VnT0aiYflSxcn4OJ8Yxac4+6yVQQ1Z/ow7e7S98BV4pGWaFEpItkSj9RByytBqWbfraG4PaC1YaOGik7RWKKNT0Ak6HQJ/bCA4N2VBCVlwF4Sfdxu8/FxSil3h5igofG4k4D/pWhllQG8O09eZmoEboQ/FwOXUE4ekvnoAbw7VWJGYPpImDMHNUNM3THlAO9eWjuFd0/yPQxVUkpm0pmymllzwcIILO7uKvHBLO5eugF3FKwL7l5yJMpxRmIOfnN3DE4YDcwRyvwhw9mAnUqCoUhgTgaNJ1nMCJwlFklK1jH6azKYURBuGnFptqJdhriUJUQpDsi2v3ZZGcyYAgE07UwKbEbakqw6ExgNFgXUsTh9T8m6KMhkXVoW2LEWUB5p1i3NuTsTd49n+ZotfENk8vXFjlXR4m5ZQLOACpWudlkzN5UwZTe73e31Nza3RSKxHTTKmBLDIrIskGcBXJEPvZtaQjinTO9MvDow17vzjXOwcvX6bSvXbSG2Cc9eeYVap5YFdoEFcEJccdGKjavWb/MHK00uxJpydzbRc/kreIPy7OtzXW6nSda7wAZWkXuMBXBCNi17+vWPQ9GUx1/OG0uHic+NS7m7ejZ1eKv55nxo77r/PPPOnCWbysv8vNXaYwxrKdrtLID7lZX55y1c9cizs/v2G8Ayt5dVIRMLf4YvIvF1tnF2e168/rpR//7bxGR0azx9v7NpzN9vhjvhcfRiyHQ781gC7UYWwNeJQ8h7wqt//9/eNYHR48ctXtfmDfhYhyj5wteod+c1vssfePzSK5/+6a+ODyROqfOfVesOPHLvLV/7ftThLg96KZg/yKz3k7uRO3VHVXAwnEzzt7Kgj+if3/7p/R9+suIXF52AH8rKAhEwTXihbu8OHMEdLFv55ltv3nHPORNHTaypZBnP43SW+33/euiBC4ODLrn8vH33GsDqQSJOeDyOzPSGV6CqAWR+ShpPoytJBkEe29LkecQlXspqAuf4G7PO086MeTMyG/PUUrUaFbFNUHdVuxxzY9552pmSIyuGiXci2eozFoDUjjJkjME8wsVCtlvc9cMFq6648T9LV2/87Q9PGT+yX8ujKwziHBYUp+/uWMju2bBkWS+XY3R1RVMkSs5YMjm6smJ0hf/1FYu/9qO7Tzhg1JHTJo4e1q+2KlhR5pf1b7XSFk3ZCO1JhD0zNmOfb8F+lDp4z8RAAu6XOGklPYJBzeXKYGZKykDXIMGFARGYEBhigrixXauZfaVFZruDraJLDrJoLx7pcAR8sru08QE39lV1JpIggsxoxy6eMJd9q0sZDu0APAAi4JPiUrQyc0jaHATNMwkiMFvRCEEcPlfK7/eIwDKhtje3hjdsaeQ9zCtvf/LMax8N6V/z0E1fHTagllBuVRWB1IawscVyqbrurijStCgQlsxXxBD8cpddmOPRjaHyT6LBT+5563d3veIIeuqqy+pqynNvbPBLQbCbqWS1ibge7jcnZe4EGUy++FeGMkusqWZWYGUNMYWJw7zAMDNPrHWBpk0hrmuSWJnCpCW6ILBopx8DtMCQeLn0bFnwNu6xpb5lW2NbKhS1uf2uqt6pyj7fvX1eayhaFvAuWNW439hecEDJkh6n6+40qXQyMmzqlCaX+/0NWw4Z1C8eT7hcrjeWrWrwVxx28qGHVvd3pfZPxMMtTY3hUAuwqZyRcIWSXVROwx1HnCtiF55Y2uWM/9lNwTOku5/XF2Q5yeHyp+0O4qTiihoyd7+9ep152DC1FITTUYjRYY+HNuil8xzqKat69cbfPX71L8YEvYOrK1fVNy0JRY++6foTf3ipzRZS37zwMUvKlkoQnBzIXYnS9Eqy7lsWMLSANlanUym6fAc4bbdX+V42D58RRRKlXF2IjdydZIYVd6Ds06efeeveBzcvXloxdPC+55095ZQTJYhotiw6dRlEZJZlpsRsNutfywKfwQJqvoJbyvws43EyZTU5Hy7h7sKS1dpgBZ6cDLc4/QF10mZ+rvIZNLKyWBbYQRYo7e4UzKyGX9nch49GeSAw/MZkBwlqsbUs8PktoPuoms/a4WSCLjMbeWGXn2CdWxboURYwWlXtUYpYwloWKG0BU70772Ll0Vjeu/ekzl09YMiKAWNSV+VGZQ3m3NWMpU2+Iym0ZyqggV3VmIy8F5dqLv3yekcq0HXemsQm13lKuLu2ciR7Z8qunFrVaybtuly7IIcmcDIZBuZAABNTTq/WyOyyGapM4eDQg/TFxErgZDIeFTBTbqXGwPaol1LBcNxB1rbVrLUnqhxPsD8cyhtPt43cXYIZESnBYV+zvuXDRVtWb2qdt7w+GkuZiqhmYOAdn4Rfx5Pp/rWBkQMrJwyrOmB8H6/fJdteyo6eWhsoIoQ2gnmDHuAKi1c1zlm8bdGqhuXrW8xsMlqE3c69hco06eH9y8cMqZ46unb0kCqWJWNtscxrYh1h6M4AnLjLvKlY4u0PN8xf0bh0bdP6bSF2XJKOvpsfEk3INn5o9ZghlfuO6d2/XzkNNxpOGDRy3TczdA7eoHfuoi03/P3DJ95aGWmNlVX6g4BbKEHXYbqReZh30b1t3hbiTeqEkXWXnT3xK0eP8noc0UhxczCOA/5weF0vvr36V3//iG1TU4l0TbU/s/tu91dZltDtsUSSQGsOl/2Qvfv/+LzJRx80mBAWMgstNrBJFftc9F//fHHJ7/89b/7SrcBTetcGmAipRZRuVJvFRaFBEvYnEm9pCJdX+047dNgPvzRx0tje0baonscXd3cavSfoveuReRfe9FZ5wH3OcXudPH3o1DG9OZdWX8x2xQXapXdx9xUbWt5fuOWux+a+8+7qQw8ecs81h40aVBkNxQswdKKTw874f82d79724EfDh9dedNakw/YeMHJgBRGUsssZu1SZ0oVL5RNraena5tc/XvfHh+cuX77t4nMn3/z9g2XppFMEWW3oXrKm6Zs3vP7GrFUH7j/4O6dN2nevXsP6lXd13l9atB1EodpxSyj+waItT7y5/MHnPiWUzZ8un/6dMyfG2qJFh/Ei7q76dc/t/577g9+8cfKRI2+9bMawAXWCFLD1tMAb0iXjrASUTDzw7MLv/PaVSr/7pdtPGjesJhaJ58yhDdp07Sdc/uzzb6z8xfemXXHOvn6fHzij/NEUetAhPZGoTOjN3z7w/s/vnHXc9CH//fUxhOPC53N9vHRnPveCFfVHff+ppnD8riuPOPf4vdT3/JrKPUhh6eBV0FnHinVbL/79a0++vPS2qw/9/tmTom2xzn18obtLoy/zPPrSsjMueeoHX9vv1suPxssTMYF/qUlv9x/UO1QV7Z8Dz7a7ArPnrzru+4+NGlz54m0nE+oNOJ82SqmhzHPJzW/d+o+P7//lseedtI8tFeIDAjLl/KMD0+59gb4May72AXYE/v70B1/98XM/OGfvWy8/NNfhaUNZWzR59A+eXLK66bnbTztgwpB0IoQdlMY9rIpl3V+9NnR5eNR2XXzTi7f97b3/3nLS6UeNiLbGCobxDu4unuF0ENZw4rkPD+hd/tqdZ0mo3RSxZXr863kAbB5f2XOzPj3+O4/+6pKDrzl//0hrCEidDGUBz0tvrz76wid++YPpP/3GobFoGw9qPdHR85shVcnDuscbvP6+N35661sv3nnKUQcNjoakwyOGuq/Mf8N97/34llnP3nX6cQePjUVaPTJn69mHIBQdfAVgm3Hhw+s2t8x74Kyg31Uwi+vgx9Q937je9/Snq9c1//7i6R6Pm++ldgNfpxqpzkSs7biDR51x4thb/jNv06YmXjUKqJpvFJKp6/7+4YiRdVefu28yEZYt0nvIw4mBe6ICiqDOVefsi2ooiJooi8ooXr+t9ZaH5mEKDIJZdgNfxxQ4Ku6K0+K6ODBujDPj0vlW6uDu9HaJWOLepxfNOHDIgZMG8vKWGW0+dY8+xwPo8y4/e8qWzW1PzVpN2E/6OZfPtXxV48yPN5x3/Fi3x6cmuD1ay3bhabOog1KoNvOjDaiJsji9w+16bvaaLVtCPzx7CgbZDdp2TmfcFafFdXFg3DgZSxREq273ZqZuLq9z5bqmJasaTzxoCB0ftsgx2g1OVKedmDy614CBlbPmbxQMEPo5nO9+uiUZSx2z3yDi1+9OdU+VSQu3pY7Zf1Aynnr7k40oSy2j82sfbhjQv2LK6F68rMcsu0Hl5lSgUnFdHHjxyoalqxtwaaVyJr3d3cW1HfZtzdFoJNmvLrBb2UApS7WmEimf38ebmXlLtyZj2pO7vaElWlnlGzWois+3drO6lxaeTo4aWFVV7d+wpYUWzqNbOhHng7e9hlZjCgyye3m71DSuiwPHIsn1qMwMR9W+9tPu7tq17O6iwofn0exupwxwW2nV4fYXVQGfm/2A1Pv13U1ZlKoo8wQCzNwExS3DVyq1tSlichufHmoO4t/jxp2jOxa6u9YUdr8WX1BtNGre1uVucl7wTJNL2g1OUI1dgMTdU5m9XwQWsRsopq+CngMXurs+h908ZfebvOUqrLNqeS09R7VHnOxUd5deRlk6Z24eI3bvbmaPcKKeo6QRIrKrWmTmA/gvW/IWAx7K538cyaSdNT/g5KzUOol1xiBryufhL89enTurrgq6vel5GZDTgHNeAJsRUntjkMMy6Allkkwv+46+3z4JVFiqkursaHmM+W9Pd3dKOASckT82dRboaYey7fYVaxsAKYwcVN3aGiW2FkFVF6/ZAkY36POwDNyRukNWuSC2lJunyQTo3E5pu/gGAQqdglTJaRA3IyQv/kXupGxDa3CYJDPgsAOTHGzsjBbaHAH1E7z2Kaz3HVh8l1lvB3fXemY+Gfrns/P/88oSIITfOGncsQcPT4M7UXgVXnADxXZ7fRfd9DpwzVf/dNa4r/zje2dO+sL0YZPP+ecbd505feqQeDTqoctXL0foKukkpFdT24OxGOR0Otl88N2F68YNra6rDvKpOIUygOzy/h4BnC7Pk28svvt/C6ht1rH326vPD86aXF3h6yikvBIRYoJVqaEAjT5Zuhlow5QxvVkMQleSZGaX/R5Ym+U5HM55sj1teu9RvboVWA0t7E7Xuk3NV/1pJvtjsilir+rAhadPPHDiAHYDyKsd9S6ok1tqpsjpmxvBpEJNDY2dOJq7sR3m7shqd3pu+Nu7//fz5+sq/dTrcT94/O9Pf2LnFb/bI/u6E3feS8ds44WAKGN3/PrCg06cNpztHR1uZ1W5h7mPBwI1Gkh8QEYJoue4PQ6XBy9webxi2a1th33n4dc/Wp92uHECGUlwGTdJuT7VnMbblYpaBzq8cGXDky8vGdS7bEi/ql8/MOf8G17CfYnhqYR0iJD0/rRPkdmBNWSYcrivuWvWN3/zCnSA75xuH0moSl8uTzO0c7Y2Ze7ncF96+1t0E5xoPrFdxf/szJSQdvbE/cfzi9ibcsLIPotWNxz5vUff/2SDw+0TBdkRQCkuvWFuZqudyEAtplD6SiBItKa6MxVaMCn47DIWyfl5e3dkdbqcTc2tv33wgyvPmXrj949lRHM6nnhq5oovHzPuxgdmP/TykjK/++pzp37hsHFE7ZCRzp56+JWlOMTkUXU+j/P6++d8uuqlaRP73nbZUQ+9tOC+pxfWVnqH9688efqIK//4JmtAZ8wYcdU5U7/3+zcqK/0/vP2tIX0rBvWpuPB3r3yyfOuR+w668aLpsrFwFt5YRMUdfwvMSXVt8I4rZ9hsFX1rfL95YE4kCsQ4dektb7wzf8P+4/v+4QeH1FYFbrhv1qOvL8Phr/3GgQ3NkTc+3oAxLv3Dq9d/e9qP/vTiK3PW9qsN3nDhwfuO7XXi5U/2rQlsrg8P6VexcEU9+61ecdurv/v+YclEnOw7XiGzJRAX1u12XfLFySdMn5RONJYf9efnZ6/sXVvxvZteWra2cZ8xvW+5dMamrS1f+tlzD157zN6jex924SNfOnLUBadOvur2V155f21F0HPNefsee/CoDxauu/rOmas3Nn/pyNE/Of8AGebVk4BZOUzTfd7eXbVyx7rNrc2h2L5jeydT1HPbAz87+p/Xnfjq+yvueWL+Td+fvs+YXl++9vlYNJz5Mshmo2qXrWlkW2Q+taoIuL996oQ7//PR35+Zy+j28pvLtzZGhvev+NGdbx00AUeZft2f33nyrRWXf3kKgyZ7h+81rO6Ma55ct6X15ouPfObtVT+/5x3CqHVeUDBtge1CmI7Ek4+9suyldz999LVle4+sCwQCX7/+xXc+2XjzxUfx8cHP75n9/Dsrf/KH12/49kGnHTbid/+YM21S331G98KnLzh1nwef++T52av/fPXRbLb+jRteYobz6cqG/721on/vsvNOGDtiYOWwfhVfPXEC0NTu9iDI6waaH19+vfL+Mhp5W1Nk4ojam/8xGxXu+fGxT85c8dsH3mOkmr9gMx9ecDJn0ZZQJPHP5+f//v45d1x++NSxvf/06Lz6xtbTf/R0ZdBz4/cOu/Whj+9+fJ7d6d1BQ9nn7d01Z9HGHxm21OEETZpMHbbPwFsuOfTt+Zu2sYbndDS1hHOrGxUBj9cLJod40LaLzpg0eeyIf7246LUP1x293+CK2uDTN53s85cxCX7u3dWvf7g+WOnb3BA67dDhPAtMn9Q/Ho99sGjrMfsPfnfBZrpVPP7mixPglrOF74J/maDxGdEP73hrzeaWgb3Ln7r5FIa7d+ZvpO7fXbCJEezJWSsvOHX86LF9fnX/e4dPHXTnFTOGDezfu9pPrr2G1QyocxON+oV3V+M9fE/LJvRY5sJTJ/7yO3xsEK8uf59+YcKIPql4uPu5e5r44397ZuE/XljEuH3thQefMG3klDF9Hntt6XPvrKgu926sD7HC5eQjOJCnqTRfw6nnkD79+pb/8t53Dp0y4Kpz91+0auvaLa2HTx1ItaLgkzNXfvesfWkbO+L4vO4ujp5O9e9Vhgd/uGjzF4/ex+lzfOUnT7Bwje+e98sX77zqcEIHy5xHTdy1sZhc/McvwHKsgGJ8Rk6TkPtOAmonW0INX7jyKXz6lEOH3/HIXD5WaAnFyMMJLo7J3C5Hv1rPxWft3afWzwe5O8Y4Zg2Od+Kv79591j9fXPyTu94WHKLLo54+EdJ9/kl7VZf7+lQH//6zYxatbrr7ibn3P7Pw039/VRQXub2/+8frf358/p+uPGrpmm1rN7fSdMWq4h8RfrCGU0b3Xdme9QxBndJb/+aSQ750zHivM+n1EeM/cf6vXqIvv/qrBz388mLVwQHLTZUTB97hQzEe2Gjo/7r+uEWrWm75z/svv7fmum8dgAF5w8E88JffPGDkoCpbOq5MoFfsZ7//eY2IzyYTycqKsiv+bx+Gs/Ovf/zMHz32r6cWHnfg0I3b2kJt0abW+NxlW1uaeeuYag3Fm9piCMuMHDPxyiXZGr3mz29/73dPvvfh+i8cMiwSSxA9GxgnRlmzuRXKT1bUN29tbWmLBfweXt1c/aeZG7aFzjx8xKz5G0KR5Bsfr49Ekzzoam3ms5vh8+UMxxJtrQKW/u4Zk9li4JxfvBAIlJ05Y8T7iza3hBJvz9uI7m/OXX/U9x/Dj5mcYAROeKyfNWftX598j4kZc6HNDWG+pmtsZZOUFL+8wsLt2U2urtL3KlOdx97n2VeejLvTwZQj0him66ngo33Q44kozrBifRNSrtrQtGJDMwN739qg2+287La3Lvrtc+tX1QNPeuTlT868+pmKMu+QvuXU5oSRfQ8Y1+ft+RsisdRL76/x0rbt0qPtCEU/b++OTAxA6WTsx1/fnynmf19b6vU4n7/z9GMOGtHWFtnWFH35vVWHTh4Q9LkZpo+YOhBH54XaF48cNWlkbZnfc+4ZExnx3/x4wy1XHX7qjLHPvLX4K8ePpTMY3L/6yd+e9OfH5vXvFfzO/+1TWeZlNvyXK4946KXFTS3Rv/3kuF//ffaL7y4fObCKOQ89yg7qDEpaXEaodGrc0Jqzjx1D3bNt25+umPHAs5+u37T1jsuPGDO46vl3Vw2oK2M2P3ls39ZQ7D8vfVpX5X/l9tO8Xs9lX57c0hJZv6Xpd987BG+Z+dGqs48azfuNeDx11hGjQOfCGSzPz76+H7jFrQ0SXlzN/koKtTMIZPxJMznxnH78WLw2nZIJGE/RgOkf/fUJ1//t/aVrtl72pSkEQa+rKfv3L4+9/+mFA3uXfeecqQN6Bb98zHgG878/PXdov4pbLzmsstz32I0n3fzPD55/Z9mU0b1HD6nZcRXa/vEeHaQ36H5/3qb9vv7o/T8/5ryT9k7EmG13pft38rZRo1fLTOS1c0cMI3+pOHhrNUjH6Y95SU112uwsUqiRm0+/kzEVyYivSGOSQ9Yv5P2d+io8yVps9k5MVmQd2pIWqazpCNbPzIFH8sLrhEsfW7xqy0f3neb1eN0B7x3//uj6v3+0+tGv8plPOsm7IzOcOtJIACbEjsvXIS617IIu8GkXktWxhNJasw+XGIG+hj9WzZBfswNqq2D5Di6VypQjzCHD1WVg7NKBCzI5jEYTw8584NsnDrn22wfFImk+TZzwtf8O6l3+3K1npOKxz/U8gINLDeav/bGCwB1V0aIa1apVN3eUG2h6Oak+DmwUZ31GvajFJbQjxjQue97lf+WTHY//7099/NVrn3/ptuOOnDYi/xvt7dC75yRKxqIZ31YgAlwnlYrIHXUwNLMAwSn25ZMTvIquMZWis88SCBSblalMHJhkXDm9yg4x/bd2R6sePksjuzwSkPBZPDRT6Hb5Jye2aJRdZMHVUjFRHyGRWckv+1tlekGsgbIpmaQiPtO6nBJopNmHJOhzZJ/LL7eLnp2ZpECSRsXnc9LzmhkLpOU9DDXLbVXdnaqyo2VYhkymQjBRFarp3bmw7XBne7o7Dy75EqFqwZ1chVGjGmXuRLtE4RyPgiQI8u9kh50OJeaXvjPP88XO6YhkWfWLK0utEsdPk1MtQ7WLnK9pPlk7Rbc5yxdVEypngZyMnWkKLIMBeahV9BmD5PJu35OuzFW2b8kWN8sCO90ClrvvdJNbBe46CxS6uzaWML/cvY+C91zMuxhPd1eVUa1AOdTfbbVVtag5cGcdC92dR0WeMLJTq93QAeQJMpUGfswUU2vUuALvxXnlr14U7H4q21ENBTMdGfrZ7UEicODyu2+nJg7Mqyy1gplfo+3uLuZIpesqfD6/q7kttvvZAo1AH8ai0U9XN44aUO73SAgxXh943a5t20Ir1rcA7NzNXAB1UGrF+uYt20I+ItaznxyxUT0ugkR/uqoxHotikN2yolmXZFOCqjKFHczz9zx35yVaLDmwb1n/3sH/zVzJ1Q58IZQnwU47pTtL2VzL1zet29QyeWQVSGMZ41PJaRN6uz3O1z5cy0uzgknOTpNtBxWkJi0OUNO8+dlvbB2f0Kg+3s420+s3tSxf14RBdjOVpVLtqSdnrepV5x/Yy5/uGFkk391lTPf6PWccNoxV66WrtwK57jwc7KCK2Qls6ekAm//5ifnMYo7Zt286Ja8B45HEmBG1U/fqfdvDc2PRCED63aa3k9HM6USpOx6eO2FE1cRhVQRXoo2nk4kvTB8CnP4uMQXw+t1nToO74rRLV2959b01J+zXt1dVUD4EyntwaXd3HE6ms/Hk988Y73E7fnjbW0JHS+k0AdoJrrndi5BtxT3+OQtW3/nwvC8ePnjC8FqZzUr4DXzCcfGZ45ct3fqnRz92OL2se2/30ncJQxRBnT/+9+Mly+u/dszQqoqgKOuwxyKJwQOrvnHy2D/++6MPFqzGLBhnl0i4fQsVR1Uee9ltM1nQ//pxw/kqqOCj0A7uzjAQiyUGDaz69UUH/O/5RZff+ipfpoFMkuU/mQbKimCP+6PF802d2xvYuLXp7J8837vae8kZo8DuiWXU0lUsFD37uNFnnzT20pten/nRCqLmoixz3B6qck54FHnrw+WX/eGtkw4b+OUjhjBvkcc3OjXWp2OJa8+fCojliz9+dtO2ZoyDuhiqx1WuJjCC46Ly+ZjL88NbXnnypaWXnz124og6oMcFLaodM6MlyLNbWmLdX3jjG3f9/cNvf3Xf31x0SFV5UKApAoHAQ3rK2KeJyq8ATl55f9W3f/1yS2v0b1fvN23SAH8AjTIH+vKFISjF0696bua8TX+66ogLTp0E1kSgID1SZbowie/w58c+/v7Nr08ZWX33D6eOGtLH7fVKX6UOmjJVPG9Z/bE/eDIY8PzlmqMP33eISkFlaHpcLaOyu7G57eo/vvHnf3z0f6eM/N23966preXrzpzKmuKF7s5dbMJmYwzxP79nznV/eXfIkOrvnTX55GlD6Qx4h5c3EdI4dNNfVbF2Pnv7eOm2P/137mOvLB3YN3j3ZVP5QsofqCgIWC/VTxjolui5v3jlmVeX77/voB9+eZ+DJ/StLge31GNeUWsq17fEANP+4d8fvvPBusP37/eHC/ceOaQ3o1lBxTOpZd+KeYu3nnzFc6vWNp1+9OgLT580eWSdn40eepDK6Oywr93UyrMptbxidcP3zhpzxRfH9K6rdQlWT5kkz0OLuLvyePmo1OX3vPQO+3J9+NrsNU6fu5bPrkmT/3vCgabMzeLJhvq22hrf2YcPvuCk4cMH1DJwq5eyhYbA44Flk+Xvzy+58cEPFy7e6q/wA3DtcSq3hmN8RDdyaMV3Th7xxRmDa6srPR5f54qnCsXj/a765uivH/jo7v8tbGoIV1YH5H2lmK4nVDEyqlqubw7HQ7EDJvX+3qkjTjxwkD9Qzhe0MjPrdBR3d40P223SAfCyfvb8zXyK9sFiAkWwPVMnHt3zhnrILve79t+r5uDxvUDGO1xeFcVJVwFlILs74Am3xd6cu/G1OWtXbmiiUyxquG6oND0U8Nc+1b6Dx9cdNL6uf68Km8PDgG4gvwxrNHKPa/OW1plzN778/pptjWE+me05tSwNc+zgiimjag7cq1d1ZTBlJ1CFwFCLVpCuu2vU8maHfSACTH8Z44Bi8whfnFFR7t3gpmieTtgSQOtFmtLC0+fxgb3Dx1DIjJAIZz3wrQUg84S8dNKeTY1rAfNAyUc5NreCxxLUjfWJHneYU7mEu2sOwmOv5vf0Hz3ODgispMbRzYovHpCiZciMTr2/6WlKZ4TmqcOs+KhMFStb9TyVqSk6ZW3Z0LiqVIPWJ2GwI9HPRtLyIVLprlGfk5ViWWDHWUBWx2MqgoPMZPQPXXdn8kOL9xCxyG6fu3DLW/M2zlm0lRcdNCN9blaKZYGdagHeuIP2mzqmbvrEvpP2kriCsZAEqdRz0uKTGRydr81cPs87H63/+V8/eH72GpQY0LvM8vSdWplWYSYswJSDqF4QHnvAoJ9/fZ8DJ/dPRGI8jhR1+SLuLg+1+LXDccP9H/78L+/W1AQuPXvKWUeMHNYPd7cc3kQNWCQ70QLMQlZsaCUMI0sN9fWhn1+w/zVfnSIf73cAy2QEKuLuDBAev+eCX79294Mff/OcKTd8Z1qvmgp5R8Ezu3VYFuiGFpAlcOeW+uZr7pp5z4Mffuucvf/yoxmxcKzzxLtw7q4W27x3Pzr/7v/Mu+Z7B//quzOADxCBg5xFR4duqLsl0p5mAQIfpNKxXjX+u685vneV/4Y/vwPC+VunT4hKrKsO85EOvTv9OstRfA0w+byHjz5w6H9vPEUiQMi8pkOePc2alr49wgK8RWQaTijtM696YuaHa2fefdqwARXxWIeXKx0QkWSwu4lwuYjwZTdfPI1XsZav94iatoTEAnTKuCtOe9PF07a1xHBjdlXR3qTn7NPB3SXMXyz+2Jsrjzxw8ND+taAqrX49ZynrpPtbAHfFaXFdHBg3xplx6Xyx2y9oB06vc8XapsUrG0+ZNoxPf9TgkE9snVsW6O4WwGlx3VOmD1u0omHpqgZcOr+Db3d3WTJ12AHBxqJJ9tvQe1Hf3dW15NvjLYDrlvnc8Whyw1Zzm8Szq8webzTLAD3YAuLAAAt4+97xaO/dtfuam1svYjpaybrqYRbQc+BCd+9halniWhboigV6sLsXnW8VvdkVg3SgZUjkgwmefTrc3X4XPEXt8vcB8mi3o/TbfpbaTpx6sLsDYssYIfsvl+03cwaCTKZxWcdSl7lE4xPCb7s8AV7f7hjws9pPdHszb9fUWLdsKtrZ1QbO2RvyL40w/4VGflKPPu+p7k6PFIkkNMQaFaP1T5mb4HsItsHTiuq02kLxRDzFJiqyt5EtHQrFkwlxfXJBk+tcJQtNop0VVW5vbo3e/u/ZS1Zus9lddPPS0avalry59pO7IyVm+kmNeVYqJY/6cgBaaCiX7Ox7MWfB+k+WboG53MlmpxBNEoizfIQt93PlwjlfeI1MY57RVJUNH/70ZFaptjUbmhrkgz3ZE07JIBJiK/ho6mRlgH2PP3qqu/Mt3ndvem3lhhZ2Mfz+79944LlP044KNr77w38+sjll12anxy9bIzjs3GFH3w8+3bRw2Va7M/jHR+ctXtvocPnZqRka2Zla6jfN4jNbV7OVjdbV8VAPzS/ufZfNtMrK/Hga4Ycg0N7PSl63l4BVuV6fjFIiwemEmWyJoy4dnCOG001e2Z5FLl0ukthMjxXsJ95czhaznDj5plSyi4fBVpi7ZW/RLB/tvksu3cjsRkjoOYFesqji4A9oe84nGz5dvo0tywmVo5SSfcxJKpCZXE7RovKW/3zMBmBpvmpVBoEzI9ryNQ1vf7wObsSfQRJNF6Tv6f5eCBHrEfrQCVEB7Fc6b9nWoQNq35q7ni7svJNsb8/feNiUAXjJk28sIqrr6YeNCAa90yb2W7kpfO0971QGvbf/sOrAcX1AEc1fsp7QWfOXbztk8oCh/StxiFffW04W9q1mr/d+vcqcLtdHi9e8+sG6S8+ezAao9K2PvboQzqceOoKlu/fnr+MD/n61gUmjZCM0wtS8+cGqxasbjj9oaP8+FTjXG3NWrdzQfOqhwysqguFQ+PE3FtVW+o45aCjtb9nqba9/sGb63gNHDxvk87jYYJGYD58sWT/7k/VH7T9kcP/aeUs2sJEy64OH7Tt8zoK185ZuPWq/wQP71SxYtpHtCpeuaZg0qhe79j0zc/5Bk/qNGVaHk7/z8ZqFK+vPPHJUazjx07tn11T4fn/J4b1r/C+8vZQN/dj4jcXF9+atq2+JDO5dPm5EL+LmsYfUa++tagwlQ9E4Ix+Czfxw5cKV2447iHhj5Tf8fQ7y//nqihH9y158Z9maTS2nHDK8tibImmWPRgr21N6dZsmey0vWNC1ctpGd/djWtKllKz3x4fsM+MtjcxavaeTDq4tvfZP+8baHPw6HQ/gHUZ6dDhe9O5sb0uX//j8fbWmKffPXLxMx7p/PLrz5Xx9ubkx+/YaXP1i8hZ4Qz4ba63HQBojIcPEtb875dPMnK7Z996ZXGVguufWt+5/9tC0Kley89fhry56auTLg91908+vhSPLeJ+b99ekF9a2J8657cf2Wtu/e9Pq6rW2Pvr78dw+8v3R1A+7ocgd+du/sTdu24YVIvmDZul8/+D43r/zTrIam8L1PLvjRXW/Xt9oee3XRr/8+py3q+OZvXlm/uQUOP/7LOw1tdi5/cd+7DW3pC258tak58vhrSx54YRGDyA9vfwv4Kr7O1r4up/uOhz54/cN1rWxxeuesRNqGbP9+aUkIbZhHOT3/fn7hTf/6cEtDZNa8jRjnzQ9XPPzq0rJg8JJb3mxuaaVxstTocXkefO5TNsVmj8/v/f519jcGmNIjOkQ9IXtk707UJ+bnbLL+92c/ffad1awYL1xV/8Try8sC7pqK4LEHDGHX1ZbW2OLVjYlYlMASRIScOqY39VdRVi4PZk57wOf69nHj958weta8des2NT7/7urrvnXglL1GfrJ8IwEC6S+ZJrNR9YgBVV89fuy6zc10df+76XTwdl/+yWNzFmwYObDy9ksPragoT8Vls7FDJvdn29hwPLmlMbxszbaX3ltz8/en9+/T++CJfd+euxoM6uXnHBYO1c9d0XTv/+axc/SIQXXhVxe+8M6ysoAHef714kJ8dMTAuobmea++L5tN//z8/Y6bNv60K//5828csPeYEXZ7/JFXPmUb9bOPGvX1k/f7ZPmGQ/bu/6Vj9l2wYtPcpVsefmUJ2o0e0uuORz4KR2Iz9unvcTlrKr3/fGHRD87au1+v8rv/98mSVfWjB1XdfdURbq8vGYswHD3+xnL27N1n3MiFKzZvawoftf+ItZtb0IKWyS6QR+83yO9xDepbfdiU/nzyHEkkV21q3dbQNqBvJZbpuUiqHtlYBfqWSrC9+pamCDOZgyf1mzyqF1uVjxxQ6XD52Iid+cGMqQOrK7zSkTns1B+bbmsdkzYW4/GEV0gkI3gGHTTTD3Z+pQ0xrOdW4lLpODT07tFYnJGB2S/NgHbC6M8MBIZgrOnd7Q73nx+ft3Rt00ETBvevC7JDON4AGQ2S7dKhZNLFXMgf8Ewc0bstKvsKLl+35ZRDhh0yZRhMnA5HLC6Lf8vXb2Zf1f3GD2RcogOWPQltduI6kYSjs68ybEngj4C1yMlmdewhjvBM7diwYPm6rcy7aqsqNjWEuU/pTLTZjphNfa/56n701lwqmeVTTu2Rg/avqVwR9D700gJmTQdOGMJcjkDQTa0xHutR+db/fLy1KTxt0uA+1X6kcjh4qOjBH+n3SHenktid2ecL8rzFfuSBQDnxLz9cspUOjIrc3IBDJt9fuInJNJRNrVHqqbLM8+Ls1S1tIaa/VGdziAhRKWJo1jdHmLTQYH75t/eenvnpGx+t51NfzRtoVPgHkwECLOJV9z4x58FnP2hsje03rt+azS04jQKcUoKNqTbuuHrjtncXbKIgdgD+1f3vPz1z2Vd++tSowXUbt4Uee3Xeb+5/75Z/zWZ/4OZQfPywulgiFfQ5yYX8xx44tKUtPmF4b7w2qPaSYMtlh8PDrsvwef6dJUycTpo+cmtjOBZDZkdza4yMCN/QHMXvj9x3UEsoPnFEH1omHsw+Dc/MWtnUmjp0cn/4TBhR19wWZRihC8fPkVm9qnFOm9Tv+vvfg/lTs1Yw/mxtirD399rNDe9/uhnZ2NV+1twNm7Y1NbZFkYptaD9eupWm++ysRUtX1bMtBAbpiUdPdXfpolKJC0+d8KNz92X/3qoK7x2XHXrA+L62dOLOyw9ftk72Kb/mvH3x6a+fOA4XOfe4sWOHVLe2NX79hL14huMpdlj/Cls6fv6JexFR6JtfmHjCQUOaWtvY05kmRLcqdZlOf/WEvWorfA5H+s4rD6fDYyJ+15WHs8P1eceNrSAYidrVld1Tr7vgQC5Xrqu/7lsHINflX9mXfbQ//HT9ry44aMzQut//YDqPgExXLvnSlEOmDP7aCWMfe3UBfsmjMw49fljNEfsNZ9v7R1/5BBqc9eRpw9hJ3JZu+/6XJiPV2x8v//n5+48f0QcHPWgiCkZPnzGC0cyWjnz56NF9agLfOm3vccNqHntl4aiBlezWet5xYyi9sanx19+Z7nU7nnxj6bgh1TwhfO2EvfhVMjvSyej3z5o8Y8rARSs3YEAGpUu+tM+AXmVLVm3+xTcPINdh+ww69oDBG7ZsYVfrcDS5paHt2vP3J55eJMITvmafHunv7V8z0QV+3l2zd3Z7l8dEKZN9mXFQ2Ymb7ZvZXJvRlrd+zBC0rbqpYwLbQsJNNp4mlUuZbChictmff3vpvKXbBvapfOSVRX+68oheVX7eeMuYD3/yMr8RnjKvEA4827q8sgl4rouTpSuY4wH8qS2kZVdo8mtbQlOWemXJ5IeY6y74qPkA0xWHjCTyugOGMllCYG5CrG2ZrSklAqcTMbUfN3MXbfdtFTVLbT7OHry8MVTFcZOdxylXaUqg+owYcFNbV+fLjCqZVGSOi44OLZRkTgUu0ZEn86xqsu+5JhsGVD2Cski3+mGyt5N2zd7pardvw03RfGfISM2htmBuk+6fCpUdqJkfyw5E7MvMRJm1FMiIR6JoJZU58RFTB7HgtGZz658un9G7JpB73aal4svseUJ2xVAKoSx45vRlf3Bt02fuKBkQJiKvw9Vm2XBLpuIwYbcQUtmXXWb8KuqVbCOuJhgwhD57E9kyEc+0++SCVY4YDhqBiKfUyBSnyNIJEQZNoeGplCm4JkaBzIhKqqigBOA3GQtRrHZJ3kQMJujI8pPsZ01LRP6UGNl0NDbh3r0OepcefFCROelz/kfdZLdglkTtPvXFlEYuOaMO1W8ulaCQx00bpfrXWM7Xc6mKPpOdc45cWdpljrl2mSXIyFYgjzgfPqWOnPyaYxXcLOCTI86d5MTIz54vjPowOVNWjlgrRZh3/GxZs08uNXeZO8nKkyPpeSc92923m71l1kP/qr53zLaE7cbcYtRtLGC5e6Yqcl1mt6kaS5Dtb4Hib2Zyz2Dbv0CLo2WBHW8BPQcu4u7M9Xibu+NFskqwLLCjLIADZx5ZOpbQ7tbyJB9PDe1TXlHp/WRFvSIrmqUjA+vKskD3soA47YKV9YFyz4A6H/tY5Dt+u7uLt8eT1TX+CcNr/vvasnRK3tB1L0UsaSwLlLIATptOxoDTjRlU3rfGz7cN+UsE7e4OHwB+TpfzotPGLVq85ZFXloA/2T02mC1lIit9N7EA7orTPvzKYnaSO/fooZXlfsBH+W/aOri7kyhi4diZR4zYb3K/H9z0+sp1WwHQWR6/m/jC7q4Gjoq7rli35eLfvzlpbM1p0wfxWUSB0u0gAi2BDt7jc81bWn/wtx7r1yv43K2nDx9YZ0uCABXUnnVYFuieFpC1MKdv2Zotx1/y+IatbQ9de+CMfYe63Rosol3kQncnRYFnPM/NXHXGj14IBj2AhM46cpRLkB7WYVmgm1ogkYg99PKSy259o6UtdscPppx52DBvoLzzs2cRd0ch6eODnrmLtpx/wxtz5m4YM7rXGTNGArsDhZ0/E+qmqlti7TEW4P06cKIFK+ofe2P5wsVbJo6p+c03Jxwyqb8vUF7UUYu7O+biowFvwB2PJf/z8rI7H18wd+m21mY+OLAOywLdzAJ2WyDoHjOogmfT0w4Z1Ke2Uj5s13mnqOvu6CQvaviK3sfG2cmNm1uXrG2MRGMK9arDrJvZwRJnj7CA3Taw1sdn8ryHSdhcCrzJy8fih5G7k4N8fJjMu0y322GTr7asw7JA97MA8Gw+MZaPMHUdXRO6BESMblyDibIClYpZW5F1v5q2JJJvDLBCDtNtZJES7p7LCrOO6OhcinViWaDHWKDDMlOPkdoS1LLAZ7KA5e6fyWxWpp5pgf8HFg65PRxa1sAAAAAASUVORK5CYII=", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%there -d 1 screenshot -w 250" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "there-ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 5 }