From 05a76279cbf9e21ddddf3f6b2dfe94c078a6ac49 Mon Sep 17 00:00:00 2001 From: Dreamer431 <113128214+Dreamer431@users.noreply.github.com> Date: Sun, 26 Jul 2026 17:17:45 +0800 Subject: [PATCH] Quantify Jacobian Lens causal swap success --- demos/Jacobian_Lens_Demo.ipynb | 1298 ++++++++++++++++++++++++++++---- 1 file changed, 1154 insertions(+), 144 deletions(-) diff --git a/demos/Jacobian_Lens_Demo.ipynb b/demos/Jacobian_Lens_Demo.ipynb index 4f1a35497..5e97ec0a6 100644 --- a/demos/Jacobian_Lens_Demo.ipynb +++ b/demos/Jacobian_Lens_Demo.ipynb @@ -34,8 +34,9 @@ "\n", "1. loads a published lens from the Hub,\n", "2. reads J-lens vs logit-lens tokens on a two-hop prompt with an *unspoken intermediate*,\n", - "3. causally swaps one concept for another (France → China) in lens coordinates, and\n", - "4. steers with a J-lens direction.\n", + "3. causally swaps one concept for another (France → China) in lens coordinates,\n", + "4. quantifies that intervention over all 48 ordered country trials, and\n", + "5. steers with a J-lens direction.\n", "\n", "**Note**: `google/gemma-2-2b` is a gated Hugging Face model — accept its license and authenticate\n", "(`hf auth login` / `HF_TOKEN`) before running. The demo uses ~6 GB of GPU memory\n", @@ -56,10 +57,10 @@ "id": "ae487ba2", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:11.958584Z", - "iopub.status.busy": "2026-07-11T09:06:11.958352Z", - "iopub.status.idle": "2026-07-11T09:06:12.029888Z", - "shell.execute_reply": "2026-07-11T09:06:12.029521Z" + "iopub.execute_input": "2026-07-26T08:09:54.389362Z", + "iopub.status.busy": "2026-07-26T08:09:54.389176Z", + "iopub.status.idle": "2026-07-26T08:09:55.209865Z", + "shell.execute_reply": "2026-07-26T08:09:55.208587Z" } }, "outputs": [ @@ -103,17 +104,17 @@ "id": "fe86001d", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:12.031375Z", - "iopub.status.busy": "2026-07-11T09:06:12.031092Z", - "iopub.status.idle": "2026-07-11T09:06:27.807249Z", - "shell.execute_reply": "2026-07-11T09:06:27.806799Z" + "iopub.execute_input": "2026-07-26T08:09:55.211867Z", + "iopub.status.busy": "2026-07-26T08:09:55.211738Z", + "iopub.status.idle": "2026-07-26T08:12:10.124915Z", + "shell.execute_reply": "2026-07-26T08:12:10.121831Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8b9855cb054f4b06803233534b78ddf9", + "model_id": "8e53e944f78141bdaac00c2aa4a587f7", "version_major": 2, "version_minor": 0 }, @@ -139,6 +140,9 @@ "from transformer_lens.model_bridge import TransformerBridge\n", "from transformer_lens.tools.analysis import JacobianLens\n", "\n", + "MODEL_ID = \"google/gemma-2-2b\"\n", + "MODEL_REVISION = \"c5ebcd40d208330abc697524c919956e692655cf\"\n", + "\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "model_dtype = (\n", " torch.bfloat16\n", @@ -147,9 +151,14 @@ ")\n", "# Raw HF weights (the Bridge default) — the published lenses are fitted on raw\n", "# activations, and JacobianLens refuses compatibility mode or process_weights.\n", - "model = TransformerBridge.boot_transformers(\"google/gemma-2-2b\", dtype=model_dtype, device=device)\n", + "model = TransformerBridge.boot_transformers(\n", + " MODEL_ID,\n", + " revision=MODEL_REVISION,\n", + " dtype=model_dtype,\n", + " device=device,\n", + ")\n", "model.eval()\n", - "print(f\"loaded gemma-2-2b: {model.cfg.n_layers} layers, d_model={model.cfg.d_model}, {device=}\")" + "print(f\"loaded gemma-2-2b: {model.cfg.n_layers} layers, d_model={model.cfg.d_model}, {device=}\")\n" ] }, { @@ -170,10 +179,10 @@ "id": "f961d030", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:27.824146Z", - "iopub.status.busy": "2026-07-11T09:06:27.823519Z", - "iopub.status.idle": "2026-07-11T09:06:28.209427Z", - "shell.execute_reply": "2026-07-11T09:06:28.208823Z" + "iopub.execute_input": "2026-07-26T08:12:10.133725Z", + "iopub.status.busy": "2026-07-26T08:12:10.133060Z", + "iopub.status.idle": "2026-07-26T08:12:19.284997Z", + "shell.execute_reply": "2026-07-26T08:12:19.283932Z" } }, "outputs": [ @@ -190,13 +199,20 @@ ], "source": [ "# NBVAL_IGNORE_OUTPUT (download progress)\n", + "LENS_REPO = \"neuronpedia/jacobian-lens\"\n", + "LENS_FILE = (\n", + " \"gemma-2-2b/jlens/Salesforce-wikitext/\"\n", + " \"gemma-2-2b_jacobian_lens.pt\"\n", + ")\n", + "LENS_REVISION = \"a4114d7752d11eb546e6cf372213d7e75526d3a1\"\n", + "\n", "lens = JacobianLens.from_pretrained(\n", - " \"neuronpedia/jacobian-lens\",\n", - " filename=\"gemma-2-2b/jlens/Salesforce-wikitext/gemma-2-2b_jacobian_lens.pt\",\n", - " revision=\"a4114d7752d11eb546e6cf372213d7e75526d3a1\",\n", + " LENS_REPO,\n", + " filename=LENS_FILE,\n", + " revision=LENS_REVISION,\n", " model=model,\n", ")\n", - "lens" + "lens\n" ] }, { @@ -218,10 +234,10 @@ "id": "1b19ec1a", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:28.217489Z", - "iopub.status.busy": "2026-07-11T09:06:28.217204Z", - "iopub.status.idle": "2026-07-11T09:06:29.114425Z", - "shell.execute_reply": "2026-07-11T09:06:29.113969Z" + "iopub.execute_input": "2026-07-26T08:12:19.289064Z", + "iopub.status.busy": "2026-07-26T08:12:19.288868Z", + "iopub.status.idle": "2026-07-26T08:12:27.284271Z", + "shell.execute_reply": "2026-07-26T08:12:27.283384Z" } }, "outputs": [ @@ -275,10 +291,10 @@ "id": "2e0887dd", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:29.118703Z", - "iopub.status.busy": "2026-07-11T09:06:29.118453Z", - "iopub.status.idle": "2026-07-11T09:06:29.588577Z", - "shell.execute_reply": "2026-07-11T09:06:29.588189Z" + "iopub.execute_input": "2026-07-26T08:12:27.286619Z", + "iopub.status.busy": "2026-07-26T08:12:27.286483Z", + "iopub.status.idle": "2026-07-26T08:12:35.541193Z", + "shell.execute_reply": "2026-07-26T08:12:35.539875Z" } }, "outputs": [ @@ -336,10 +352,10 @@ "id": "b2359547", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:29.590963Z", - "iopub.status.busy": "2026-07-11T09:06:29.590451Z", - "iopub.status.idle": "2026-07-11T09:06:30.101969Z", - "shell.execute_reply": "2026-07-11T09:06:30.101589Z" + "iopub.execute_input": "2026-07-26T08:12:35.547418Z", + "iopub.status.busy": "2026-07-26T08:12:35.546068Z", + "iopub.status.idle": "2026-07-26T08:12:42.047356Z", + "shell.execute_reply": "2026-07-26T08:12:42.046235Z" } }, "outputs": [ @@ -389,10 +405,10 @@ "id": "cdc8c44e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:30.105260Z", - "iopub.status.busy": "2026-07-11T09:06:30.104879Z", - "iopub.status.idle": "2026-07-11T09:06:30.422053Z", - "shell.execute_reply": "2026-07-11T09:06:30.421595Z" + "iopub.execute_input": "2026-07-26T08:12:42.051286Z", + "iopub.status.busy": "2026-07-26T08:12:42.051130Z", + "iopub.status.idle": "2026-07-26T08:12:49.313426Z", + "shell.execute_reply": "2026-07-26T08:12:49.312040Z" } }, "outputs": [ @@ -434,12 +450,1006 @@ "$\\alpha=1$ is the better default here.)" ] }, + { + "cell_type": "markdown", + "id": "4adfabca", + "metadata": {}, + "source": [ + "## 4. Quantifying causal-swap success across the country subset\n", + "\n", + "The qualitative France → China example is one cell of the paper's\n", + "`flexible-generalization.json` country subset. We now run all four functions over\n", + "the twelve ordered source-target pairs: **48 trials per alpha**. Each condition\n", + "applies the same concept swap at every token position and simultaneously clamps it\n", + "across block outputs 10–24.\n", + "\n", + "The protocol was fixed before the measured run:\n", + "\n", + "- base model: `google/gemma-2-2b` at `c5ebcd40d208330abc697524c919956e692655cf`;\n", + "- published lens: `neuronpedia/jacobian-lens/gemma-2-2b/jlens/Salesforce-wikitext/gemma-2-2b_jacobian_lens.pt` at `a4114d7752d11eb546e6cf372213d7e75526d3a1`;\n", + "- country configuration:\n", + " [`anthropics/jacobian-lens:data/experiments/flexible-generalization.json`](https://github.com/anthropics/jacobian-lens/blob/581d398613e5602a5af361e1c34d3a92ea82ba8e/data/experiments/flexible-generalization.json)\n", + " at `581d398613e5602a5af361e1c34d3a92ea82ba8e`;\n", + "- layers 10–24 inclusive; `alpha=1` primary and `alpha=2` double-strength diagnostic;\n", + "- success means the exact target-answer token is the deterministic argmax of the\n", + " swapped next-token logits; failures are never filtered.\n", + "\n", + "The protocol fingerprint is `05dedbde47a22b11189d03b16c93b676c8a9de29a4b5f641bc1a24d5f9fd61f9`. Exact maximum-logit ties are\n", + "retained as deterministic-argmax failures when another token wins the argmax order;\n", + "rank and tie metadata are measured separately. Executable assertions reject\n", + "duplicate, missing, or alpha-mismatched trial matrices.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f12cc675", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:12:49.316772Z", + "iopub.status.busy": "2026-07-26T08:12:49.316640Z", + "iopub.status.idle": "2026-07-26T08:12:53.613547Z", + "shell.execute_reply": "2026-07-26T08:12:53.612572Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "protocol_sha256=05dedbde47a22b11189d03b16c93b676c8a9de29a4b5f641bc1a24d5f9fd61f9\n" + ] + } + ], + "source": [ + "import hashlib\n", + "import json\n", + "from itertools import permutations\n", + "\n", + "import pandas as pd\n", + "\n", + "CONFIG_REPO = \"anthropics/jacobian-lens\"\n", + "CONFIG_PATH = \"data/experiments/flexible-generalization.json\"\n", + "CONFIG_REVISION = \"581d398613e5602a5af361e1c34d3a92ea82ba8e\"\n", + "SWAP_LAYERS = list(range(10, 25))\n", + "SWAP_ALPHAS = [1.0, 2.0]\n", + "COUNTRY_CONFIG = {'name': 'countries', 'args': ['France', 'Canada', 'China', 'Egypt'], 'funcs': [{'name': 'capital', 'template': 'The capital of {arg} is the city of', 'answers': {'France': 'Paris', 'Canada': 'Ottawa', 'China': 'Beijing', 'Egypt': 'Cairo'}}, {'name': 'language', 'template': 'Most people in {arg} speak', 'answers': {'France': 'French', 'Canada': 'English', 'China': 'Chinese', 'Egypt': 'Arabic'}}, {'name': 'continent', 'template': '{arg} is a country on the continent of', 'answers': {'France': 'Europe', 'Canada': 'North', 'China': 'Asia', 'Egypt': 'Africa'}}, {'name': 'currency', 'template': 'The single-word name for the currency now used in {arg} is the', 'answers': {'France': 'Euro', 'Canada': 'Dollar', 'China': 'Yuan', 'Egypt': 'Pound'}}]}\n", + "protocol_manifest = {\n", + " \"model_id\": MODEL_ID,\n", + " \"model_revision\": MODEL_REVISION,\n", + " \"lens_repo\": LENS_REPO,\n", + " \"lens_file\": LENS_FILE,\n", + " \"lens_revision\": LENS_REVISION,\n", + " \"config_repo\": CONFIG_REPO,\n", + " \"config_path\": CONFIG_PATH,\n", + " \"config_revision\": CONFIG_REVISION,\n", + " \"country_config\": COUNTRY_CONFIG,\n", + " \"layers\": SWAP_LAYERS,\n", + " \"alphas\": SWAP_ALPHAS,\n", + " \"success_definition\": \"target token id equals deterministic argmax token id\",\n", + " \"baseline_definition\": \"source answer token id equals deterministic argmax token id\",\n", + " \"rank_definition\": \"1 + count(logits strictly greater than target logit)\",\n", + "}\n", + "protocol_fingerprint = hashlib.sha256(\n", + " json.dumps(protocol_manifest, sort_keys=True, separators=(\",\", \":\")).encode()\n", + ").hexdigest()\n", + "\n", + "print(f\"protocol_sha256={protocol_fingerprint}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "swapmetricintro", + "metadata": {}, + "source": [ + "### Metric and completeness checks\n", + "\n", + "The helpers below keep deterministic argmax success separate from rank-1\n", + "maximum ties. They also reject duplicate, missing, or alpha-mismatched trial\n", + "matrices before any rate is reported.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "swapmetrichelpers", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:12:53.616575Z", + "iopub.status.busy": "2026-07-26T08:12:53.616456Z", + "iopub.status.idle": "2026-07-26T08:12:57.919222Z", + "shell.execute_reply": "2026-07-26T08:12:57.918064Z" + } + }, + "outputs": [], + "source": [ + "def _target_metrics(logits, target_token_id):\n", + " if logits.ndim != 1 or logits.numel() < 2:\n", + " raise ValueError(\"expected one-dimensional next-token logits\")\n", + " if not 0 <= target_token_id < logits.shape[0]:\n", + " raise ValueError(\"target token id is outside the vocabulary\")\n", + " if not torch.isfinite(logits).all():\n", + " raise ValueError(\"logits must be finite\")\n", + "\n", + " target_logit = logits[target_token_id]\n", + " top_logit = logits.max()\n", + " top1_token_id = int(logits.argmax().item())\n", + " top_logit_tie_count = int((logits == top_logit).sum().item())\n", + " competitors = torch.cat(\n", + " (logits[:target_token_id], logits[target_token_id + 1 :])\n", + " )\n", + " return {\n", + " \"top1_token_id\": top1_token_id,\n", + " \"target_rank\": int((logits > target_logit).sum().item()) + 1,\n", + " \"target_is_top1\": top1_token_id == target_token_id,\n", + " \"target_tied_for_top\": (\n", + " bool(target_logit == top_logit) and top_logit_tie_count > 1\n", + " ),\n", + " \"target_logit_margin\": float(\n", + " (target_logit - competitors.max()).item()\n", + " ),\n", + " }\n", + "\n", + "\n", + "def _aggregate_trials(trials, expected_trials_per_alpha):\n", + " frame = pd.DataFrame(trials)\n", + " key_columns = [\"function\", \"source\", \"target\", \"alpha\"]\n", + " if frame.empty or frame.duplicated(key_columns).any():\n", + " raise ValueError(\"trial matrix is empty or contains duplicates\")\n", + "\n", + " matrices = {}\n", + " for alpha, subset in frame.groupby(\"alpha\", sort=True):\n", + " keys = set(\n", + " subset[[\"function\", \"source\", \"target\"]].itertuples(\n", + " index=False, name=None\n", + " )\n", + " )\n", + " if len(keys) != expected_trials_per_alpha:\n", + " raise ValueError(\n", + " f\"alpha={alpha:g} has {len(keys)} trials; \"\n", + " f\"expected {expected_trials_per_alpha}\"\n", + " )\n", + " matrices[float(alpha)] = keys\n", + "\n", + " if set(matrices) != set(SWAP_ALPHAS):\n", + " raise ValueError(\"trial matrix does not contain every configured alpha\")\n", + " reference_keys = matrices[SWAP_ALPHAS[0]]\n", + " if any(keys != reference_keys for keys in matrices.values()):\n", + " raise ValueError(\"alphas do not contain the same trial matrix\")\n", + "\n", + " aggregates = []\n", + " for alpha, subset in frame.groupby(\"alpha\", sort=True):\n", + " successes = int(subset[\"success\"].sum())\n", + " baseline_top1s = int(subset[\"baseline_source_is_top1\"].sum())\n", + " baseline_correct = subset[subset[\"baseline_source_is_top1\"]]\n", + " conditional_successes = int(baseline_correct[\"success\"].sum())\n", + " conditional_trials = len(baseline_correct)\n", + " aggregates.append(\n", + " {\n", + " \"alpha\": float(alpha),\n", + " \"trials\": len(subset),\n", + " \"baseline_top1s\": baseline_top1s,\n", + " \"baseline_top1_rate\": baseline_top1s / len(subset),\n", + " \"successes\": successes,\n", + " \"failures\": len(subset) - successes,\n", + " \"success_rate\": successes / len(subset),\n", + " \"conditional_trials\": conditional_trials,\n", + " \"conditional_successes\": conditional_successes,\n", + " \"conditional_success_rate\": (\n", + " conditional_successes / conditional_trials\n", + " if conditional_trials\n", + " else None\n", + " ),\n", + " \"tied_max_trials\": int(\n", + " subset[\"target_tied_for_top\"].sum()\n", + " ),\n", + " }\n", + " )\n", + " return aggregates\n", + "\n", + "\n", + "# Pin deterministic-argmax semantics for exact maximum ties.\n", + "_tie_probe = _target_metrics(torch.tensor([3.0, 1.0, 3.0]), 2)\n", + "assert _tie_probe[\"target_rank\"] == 1\n", + "assert not _tie_probe[\"target_is_top1\"]\n", + "assert _tie_probe[\"target_tied_for_top\"]\n" + ] + }, + { + "cell_type": "markdown", + "id": "swapsweepintro", + "metadata": {}, + "source": [ + "### Run the complete country sweep\n", + "\n", + "This is the only expensive cell: four functions × twelve ordered pairs × two\n", + "intervention strengths. Baseline logits are cached per function-source prompt.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "swapsweeprun", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:12:57.921473Z", + "iopub.status.busy": "2026-07-26T08:12:57.921353Z", + "iopub.status.idle": "2026-07-26T08:13:14.610862Z", + "shell.execute_reply": "2026-07-26T08:13:14.609596Z" + } + }, + "outputs": [], + "source": [ + "# NBVAL_IGNORE_OUTPUT (96 real-model intervention conditions)\n", + "condition_rows = []\n", + "evaluated_trials = []\n", + "baseline_cache = {}\n", + "hook_cache = {}\n", + "\n", + "for function_spec in COUNTRY_CONFIG[\"funcs\"]:\n", + " function = function_spec[\"name\"]\n", + " for source_value, target_value in permutations(COUNTRY_CONFIG[\"args\"], 2):\n", + " prompt = function_spec[\"template\"].format(arg=source_value)\n", + " tokens = model.to_tokens(prompt)\n", + " baseline_key = (function, source_value)\n", + " if baseline_key not in baseline_cache:\n", + " with torch.inference_mode():\n", + " baseline_cache[baseline_key] = model(tokens)[0, -1].float()\n", + " baseline_logits = baseline_cache[baseline_key]\n", + "\n", + " source_answer = f\" {function_spec['answers'][source_value]}\"\n", + " source_answer_id = model.to_single_token(source_answer)\n", + " baseline_source_metrics = _target_metrics(\n", + " baseline_logits, source_answer_id\n", + " )\n", + " target_answer = f\" {function_spec['answers'][target_value]}\"\n", + " target_answer_id = model.to_single_token(target_answer)\n", + " baseline_target_metrics = _target_metrics(\n", + " baseline_logits, target_answer_id\n", + " )\n", + "\n", + " for alpha in SWAP_ALPHAS:\n", + " hook_key = (source_value, target_value, alpha)\n", + " if hook_key not in hook_cache:\n", + " hook_cache[hook_key] = lens.swap_hooks(\n", + " model,\n", + " f\" {source_value}\",\n", + " f\" {target_value}\",\n", + " layers=SWAP_LAYERS,\n", + " alpha=alpha,\n", + " )\n", + " with torch.inference_mode():\n", + " with model.hooks(fwd_hooks=hook_cache[hook_key]):\n", + " swapped_logits = model(tokens)[0, -1].float()\n", + " swapped_metrics = _target_metrics(\n", + " swapped_logits, target_answer_id\n", + " )\n", + " evaluated_trials.append(\n", + " {\n", + " \"function\": function,\n", + " \"source\": source_value,\n", + " \"target\": target_value,\n", + " \"alpha\": alpha,\n", + " \"baseline_source_is_top1\": baseline_source_metrics[\n", + " \"target_is_top1\"\n", + " ],\n", + " \"success\": swapped_metrics[\"target_is_top1\"],\n", + " \"target_tied_for_top\": swapped_metrics[\n", + " \"target_tied_for_top\"\n", + " ],\n", + " }\n", + " )\n", + " condition_rows.append(\n", + " {\n", + " \"function\": function,\n", + " \"source\": source_value,\n", + " \"target\": target_value,\n", + " \"alpha\": alpha,\n", + " \"prompt\": prompt,\n", + " \"source_answer\": source_answer,\n", + " \"target_answer\": target_answer,\n", + " \"baseline_top1\": model.tokenizer.decode(\n", + " [baseline_source_metrics[\"top1_token_id\"]]\n", + " ),\n", + " \"baseline_source_rank\": baseline_source_metrics[\n", + " \"target_rank\"\n", + " ],\n", + " \"baseline_source_is_top1\": baseline_source_metrics[\n", + " \"target_is_top1\"\n", + " ],\n", + " \"baseline_target_rank\": baseline_target_metrics[\n", + " \"target_rank\"\n", + " ],\n", + " \"swapped_top1\": model.tokenizer.decode(\n", + " [swapped_metrics[\"top1_token_id\"]]\n", + " ),\n", + " \"swapped_target_rank\": swapped_metrics[\"target_rank\"],\n", + " \"success\": swapped_metrics[\"target_is_top1\"],\n", + " \"target_tied_for_top\": swapped_metrics[\n", + " \"target_tied_for_top\"\n", + " ],\n", + " \"target_logit_margin\": swapped_metrics[\n", + " \"target_logit_margin\"\n", + " ],\n", + " }\n", + " )\n", + "\n", + "assert len(evaluated_trials) == 96\n" + ] + }, + { + "cell_type": "markdown", + "id": "swapsummaryintro", + "metadata": {}, + "source": [ + "### Aggregate baseline and swap success\n", + "\n", + "The unconditional swap rate uses all 48 trials. The conditional rate keeps only\n", + "trials where the unperturbed model already puts the source-appropriate answer\n", + "top-1.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "swapsummarytable", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:13:14.613588Z", + "iopub.status.busy": "2026-07-26T08:13:14.613441Z", + "iopub.status.idle": "2026-07-26T08:13:20.741457Z", + "shell.execute_reply": "2026-07-26T08:13:20.740144Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
scopealphabaseline_top1baseline_top1_rateswap_successswap_success_rateconditional_swap_successconditional_swap_rate
0overall1.033/4868.75%16/4833.33%13/3339.39%
1overall2.033/4868.75%0/480.00%0/330.00%
2capital1.012/12100.00%5/1241.67%5/1241.67%
3capital2.012/12100.00%0/120.00%0/120.00%
4language1.09/1275.00%7/1258.33%4/944.44%
5language2.09/1275.00%0/120.00%0/90.00%
6continent1.012/12100.00%4/1233.33%4/1233.33%
7continent2.012/12100.00%0/120.00%0/120.00%
8currency1.00/120.00%0/120.00%0/0n/a
9currency2.00/120.00%0/120.00%0/0n/a
\n", + "
" + ], + "text/plain": [ + " scope alpha baseline_top1 baseline_top1_rate swap_success \\\n", + "0 overall 1.0 33/48 68.75% 16/48 \n", + "1 overall 2.0 33/48 68.75% 0/48 \n", + "2 capital 1.0 12/12 100.00% 5/12 \n", + "3 capital 2.0 12/12 100.00% 0/12 \n", + "4 language 1.0 9/12 75.00% 7/12 \n", + "5 language 2.0 9/12 75.00% 0/12 \n", + "6 continent 1.0 12/12 100.00% 4/12 \n", + "7 continent 2.0 12/12 100.00% 0/12 \n", + "8 currency 1.0 0/12 0.00% 0/12 \n", + "9 currency 2.0 0/12 0.00% 0/12 \n", + "\n", + " swap_success_rate conditional_swap_success conditional_swap_rate \n", + "0 33.33% 13/33 39.39% \n", + "1 0.00% 0/33 0.00% \n", + "2 41.67% 5/12 41.67% \n", + "3 0.00% 0/12 0.00% \n", + "4 58.33% 4/9 44.44% \n", + "5 0.00% 0/9 0.00% \n", + "6 33.33% 4/12 33.33% \n", + "7 0.00% 0/12 0.00% \n", + "8 0.00% 0/0 n/a \n", + "9 0.00% 0/0 n/a " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overall = _aggregate_trials(evaluated_trials, 48)\n", + "summary_rows = []\n", + "scopes = [\n", + " (\"overall\", evaluated_trials),\n", + " *[\n", + " (\n", + " function_spec[\"name\"],\n", + " [\n", + " trial\n", + " for trial in evaluated_trials\n", + " if trial[\"function\"] == function_spec[\"name\"]\n", + " ],\n", + " )\n", + " for function_spec in COUNTRY_CONFIG[\"funcs\"]\n", + " ],\n", + "]\n", + "for scope, subset in scopes:\n", + " expected = 48 if scope == \"overall\" else 12\n", + " for aggregate in _aggregate_trials(subset, expected):\n", + " summary_rows.append(\n", + " {\n", + " \"scope\": scope,\n", + " \"alpha\": aggregate[\"alpha\"],\n", + " \"baseline_top1\": (\n", + " f\"{aggregate['baseline_top1s']}/{aggregate['trials']}\"\n", + " ),\n", + " \"baseline_top1_rate\": (\n", + " f\"{aggregate['baseline_top1_rate']:.2%}\"\n", + " ),\n", + " \"swap_success\": (\n", + " f\"{aggregate['successes']}/{aggregate['trials']}\"\n", + " ),\n", + " \"swap_success_rate\": f\"{aggregate['success_rate']:.2%}\",\n", + " \"conditional_swap_success\": (\n", + " f\"{aggregate['conditional_successes']}/\"\n", + " f\"{aggregate['conditional_trials']}\"\n", + " ),\n", + " \"conditional_swap_rate\": (\n", + " f\"{aggregate['conditional_success_rate']:.2%}\"\n", + " if aggregate[\"conditional_success_rate\"] is not None\n", + " else \"n/a\"\n", + " ),\n", + " }\n", + " )\n", + "\n", + "summary_table = pd.DataFrame(summary_rows)\n", + "summary_table\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "swapreportbuild", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:13:20.743194Z", + "iopub.status.busy": "2026-07-26T08:13:20.743069Z", + "iopub.status.idle": "2026-07-26T08:13:24.938453Z", + "shell.execute_reply": "2026-07-26T08:13:24.937282Z" + } + }, + "outputs": [], + "source": [ + "conditions = pd.DataFrame(condition_rows)\n", + "assert len(conditions) == 96\n", + "shared_columns = [\n", + " \"function\",\n", + " \"source\",\n", + " \"target\",\n", + " \"prompt\",\n", + " \"source_answer\",\n", + " \"target_answer\",\n", + " \"baseline_top1\",\n", + " \"baseline_source_rank\",\n", + " \"baseline_source_is_top1\",\n", + " \"baseline_target_rank\",\n", + "]\n", + "\n", + "\n", + "def alpha_report(alpha):\n", + " suffix = str(int(alpha))\n", + " return conditions.loc[\n", + " conditions[\"alpha\"] == alpha,\n", + " shared_columns + [\"swapped_top1\", \"swapped_target_rank\", \"success\"],\n", + " ].rename(\n", + " columns={\n", + " \"swapped_top1\": f\"alpha{suffix}_top1\",\n", + " \"swapped_target_rank\": f\"alpha{suffix}_target_rank\",\n", + " \"success\": f\"alpha{suffix}_success\",\n", + " }\n", + " )\n", + "\n", + "\n", + "report_table = alpha_report(1.0).merge(\n", + " alpha_report(2.0),\n", + " on=shared_columns,\n", + " validate=\"one_to_one\",\n", + ")\n", + "assert len(report_table) == 48\n", + "for column in [\n", + " \"source_answer\",\n", + " \"target_answer\",\n", + " \"baseline_top1\",\n", + " \"alpha1_top1\",\n", + " \"alpha2_top1\",\n", + "]:\n", + " report_table[column] = report_table[column].map(repr)\n" + ] + }, + { + "cell_type": "markdown", + "id": "swapvisualintro", + "metadata": {}, + "source": [ + "### Visual summary\n", + "\n", + "The bars separate model capability from intervention success. The heatmaps show\n", + "the target-answer rank for every trial; lower is better.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "swapratechart", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:13:24.941551Z", + "iopub.status.busy": "2026-07-26T08:13:24.941420Z", + "iopub.status.idle": "2026-07-26T08:13:29.718995Z", + "shell.execute_reply": "2026-07-26T08:13:29.718188Z" + } + }, + "outputs": [ + { + "output_type": "display_data", + "metadata": {}, + "data": { + "text/plain": "
", + "image/png": "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" + } + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "scope_order = [\"overall\", \"capital\", \"language\", \"continent\", \"currency\"]\n", + "alpha1_summary = (\n", + " summary_table.query(\"alpha == 1\")\n", + " .set_index(\"scope\")\n", + " .loc[scope_order]\n", + ")\n", + "alpha2_summary = (\n", + " summary_table.query(\"alpha == 2\")\n", + " .set_index(\"scope\")\n", + " .loc[scope_order]\n", + ")\n", + "\n", + "\n", + "def _percent_values(series):\n", + " return pd.to_numeric(\n", + " series.str.rstrip(\"%\").replace(\"n/a\", np.nan),\n", + " errors=\"coerce\",\n", + " )\n", + "\n", + "\n", + "x = np.arange(len(scope_order))\n", + "width = 0.2\n", + "baseline_values = _percent_values(alpha1_summary[\"baseline_top1_rate\"])\n", + "alpha1_values = _percent_values(alpha1_summary[\"swap_success_rate\"])\n", + "conditional_values = _percent_values(alpha1_summary[\"conditional_swap_rate\"])\n", + "alpha2_values = _percent_values(alpha2_summary[\"swap_success_rate\"])\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 4.8))\n", + "baseline_bars = ax.bar(\n", + " x - width,\n", + " baseline_values,\n", + " width,\n", + " label=\"Baseline source top-1\",\n", + ")\n", + "alpha1_bars = ax.bar(\n", + " x,\n", + " alpha1_values,\n", + " width,\n", + " label=\"α=1 swap (all trials)\",\n", + ")\n", + "conditional_bars = ax.bar(\n", + " x + width,\n", + " conditional_values,\n", + " width,\n", + " label=\"α=1 swap (baseline-correct)\",\n", + ")\n", + "alpha2_markers = ax.scatter(\n", + " x,\n", + " alpha2_values,\n", + " marker=\"x\",\n", + " s=55,\n", + " color=\"black\",\n", + " label=\"α=2 swap (all trials)\",\n", + " zorder=3,\n", + ")\n", + "for bars, values in (\n", + " (baseline_bars, baseline_values),\n", + " (alpha1_bars, alpha1_values),\n", + " (conditional_bars, conditional_values),\n", + "):\n", + " ax.bar_label(\n", + " bars,\n", + " fmt=\"%.1f\",\n", + " padding=2,\n", + " fontsize=8,\n", + " color=bars.patches[0].get_facecolor(),\n", + " )\n", + " for bar, value in zip(bars, values):\n", + " if pd.isna(value):\n", + " ax.annotate(\n", + " \"n/a\",\n", + " (bar.get_x() + bar.get_width() / 2, 0),\n", + " xytext=(0, 3),\n", + " textcoords=\"offset points\",\n", + " ha=\"center\",\n", + " fontsize=8,\n", + " color=bar.get_facecolor(),\n", + " )\n", + "ax.set(\n", + " ylabel=\"Top-1 rate (%)\",\n", + " xticks=x,\n", + " xticklabels=[label.title() for label in scope_order],\n", + " ylim=(0, 108),\n", + ")\n", + "ax.grid(axis=\"y\", alpha=0.25)\n", + "fig.suptitle(\"Country causal-swap success versus baseline capability\", y=0.98)\n", + "fig.legend(\n", + " handles=[baseline_bars, alpha1_bars, conditional_bars, alpha2_markers],\n", + " ncol=2,\n", + " frameon=False,\n", + " loc=\"upper center\",\n", + " bbox_to_anchor=(0.5, 0.92),\n", + ")\n", + "fig.tight_layout(rect=(0, 0, 1, 0.86))\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "swaprankintro", + "metadata": {}, + "source": [ + "#### Per-trial target-answer ranks\n", + "\n", + "These heatmaps retain every trial while keeping the exact ranks in the ", + "collapsible table below.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "swaprankheatmap", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABUYAAAHmCAYAAAC/ElScAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdUFFcbBvBnlt6LNEUF7AUUu6DYFXtLNGq+iDXW2EvQqGCJvfcWMUYTSyyJxq7Ye+/GiiKg0nvb+f4grK4U2RXYwvM7Z85xZ+/ceXecXe6+e4sgiqIIIiIiIiIiIiIioiJEouoAiIiIiIiIiIiIiAobE6NERERERERERERU5DAxSkREREREREREREUOE6NERERERERERERU5DAxSkREREREREREREUOE6NERERERERERERU5DAxSkREREREREREREUOE6NERERERERERERU5DAxSkREREREREREREUOE6NERKQwZ2dntG/fvsDPs2XLFlSqVAl6enqwtLQs8PMRERERFVVs3xFRUcTEKJEaefToEUaPHg1PT08YGhpCEAS8ePHii+pMSEiAn58fAgMD8yXGgqZp8VLBefjwIfr06YOyZcti/fr1WLduHe8PIiLSOLt378Y333yDMmXKwNjYGBUrVsTYsWMRFRWldJ2a9vdQ0+KlgsP2HRGpG11VB0BEH1y4cAHLli1DlSpVULlyZdy8efOL60xISIC/vz8AoEmTJl9cX0HTtHip4AQGBkIqlWLp0qUoV64cAOD9+/e8P4iISKN8//33KFGiBP73v/+hdOnSuHPnDlasWIF//vkH169fh5GRkcJ1alp7SdPipYLD9h0RqRsmRonUSMeOHREVFQUzMzMsWLAgXxKjBSU+Ph4mJiaqDqNIUfSaa/r/0du3bwGgUIZYafq1IiIi9bVr164syZ5atWrBx8cHW7duxYABA1QTWDb497DwsX1XcDT9WhFR4eBQeiIFnDlzBvXr14eRkRFcXFywcuVKAEDnzp3x7bfffnH91tbWMDMzy1PZkJAQPHz4EKmpqTmWefHiBWxtbQEA/v7+EAQBgiDAz88PAHD79m306dMHZcqUgaGhIRwcHNCvXz+Eh4fL1ePn5wdBEHD//n306tULVlZWaNiwIQBAKpXCz88PJUqUgLGxMZo2bYr79+/D2dkZffr0kasnKioKo0aNQqlSpWBgYIBy5cph7ty5kEqleYo3J2fOnEG3bt1QunRpGBgYoFSpUhg9ejQSExPlyvXp0wempqYIDg5G586dYWpqCltbW4wbNw7p6elyZf/44w/UqlULZmZmMDc3h5ubG5YuXSp7HTo6Oli2bJms/Pv37yGRSFCsWDGIoijbP2TIEDg4OMjVfenSJbRu3RoWFhYwNjZG48aNce7cuTxf8+wEBARAEAScOnUKQ4cOhZ2dHUqWLAkAePnyJYYOHYqKFSvCyMgIxYoVQ7du3bJM05BZx7lz5zBmzBjY2trCxMQEXbp0wbt373L9PwCAzZs3Q1dXF+PHj8+13L59+9CuXTuUKFECBgYGKFu2LGbMmCH3f+Ds7Ixp06YBAGxtbSEIAvr06fPZ++Phw4f4+uuvYW1tDUNDQ9SuXRt//fVXnq9VTpYvX46qVavC2NgYVlZWqF27NrZt2wYg430kCILcea5duwZBEFCzZk25etq0aYN69eopdC2AjN4Trq6uuHbtGjw9PWWfQWvWrMk1biIi+ryCbt9l1wOuS5cuAIAHDx7I7Wf77gO279i+y8T2HREVJPYYJcqj8+fPo0WLFnBzc8P8+fNx/vx5DB8+HMWLF8eRI0fwyy+/yMomJycjNjY2T/Xa2NgoFY+vry82b96M58+fw9nZOdsytra2WL16NYYMGYIuXbqga9euAIBq1aoBAI4ePYpnz56hb9++cHBwwL1797Bu3Trcu3cPFy9ehCAIcvV169YN5cuXx88//yxrHPr6+mLevHno0KEDvL29cevWLXh7eyMpKUnu2ISEBDRu3BjBwcEYNGgQSpcujfPnz8PX1xchISFYsmTJZ+PNyc6dO5GQkIAhQ4agWLFiuHz5MpYvX47Xr19j586dcmXT09Ph7e2NevXqYcGCBTh27BgWLlyIsmXLYsiQIbLr0rNnTzRv3hxz584FkPHF5dy5cxg5ciQsLS3h6uqK06dPY8SIEQCAs2fPQhAERERE4P79+6hatSqAjEa9l5eX7PwnTpxAmzZtUKtWLUybNg0SiQSbNm1Cs2bNcObMGdStW/ez1zw3Q4cOha2tLaZOnYr4+HgAwJUrV3D+/Hn06NEDJUuWxIsXL7B69Wo0adIE9+/fh7GxsVwdP/zwA6ysrDBt2jS8ePECS5YswfDhw7F9+/Ycz7tu3ToMHjwYkyZNwsyZM3ONMSAgAKamphgzZgxMTU1x4sQJTJ06FTExMZg/fz4AYMmSJfj111+xZ88erF69GqampnBzc0P9+vVzvD/u3buHBg0awNHRET/++CNMTEywY8cOdO7cGX/++afsS2hu1yo769evx4gRI/D1119j5MiRSEpKwu3bt3Hp0iX06tULrq6usLS0xOnTp9GxY0cAGf/vEokEt27dQkxMDMzNzSGVSnH+/Hl8//33Cl2LTJGRkWjbti26d++Onj17YseOHRgyZAj09fXRr1+/XK85ERFlT1Xtu9DQ0GzLsX33Adt3H7B9x/YdERUgkYjypFmzZqKpqakYEREhiqIoSqVS0d3dXXRwcBB1dXXFyMhIWdlNmzaJAPK05WT+/PkiAPH58+fZPu/j45Pr85nevXsnAhCnTZuW5bmEhIQs+37//XcRgHj69GnZvmnTpokAxJ49e8qVDQ0NFXV1dcXOnTvL7ffz8xMBiD4+PrJ9M2bMEE1MTMTHjx/Llf3xxx9FHR0dMSgo6LPx5iS71zF79mxREATx5cuXsn2Z12z69OlyZWvUqCHWqlVL9njkyJGiubm5mJaWluM5hw0bJtrb28sejxkzRmzUqJFoZ2cnrl69WhRFUQwPDxcFQRCXLl0qimLGPVO+fHnR29tblEqlcvG7uLiILVu2lO3L6ZrnJPOea9iwYZa4s7s+Fy5cEAGIv/76a5Y6WrRoIRff6NGjRR0dHTEqKkq2z8nJSWzXrp0oiqK4dOlSURAEccaMGXmKNbt4Bg0aJBobG4tJSUmyfZnX4N27d7J9ud0fzZs3F93c3OTqkEqloqenp1i+fPksrzO7a5WdTp06iVWrVs21TLt27cS6devKHnft2lXs2rWrqKOjIx48eFAURVG8fv26CEDct2+frFxer0Xjxo1FAOLChQtl+5KTk0V3d3fRzs5OTElJ+ezrICKirAq7fZepf//+oo6OTpZ2Edt3ub8Otu8+YPuO7Tsiyh8cSk+UB6mpqTh79izat28PKysrAIAgCGjfvj1CQ0Ph5eUlN0+Ot7c3jh49mqdNWQEBARBFMcfeBHnx8WT/SUlJeP/+PerXrw8AuH79epbygwcPlnt8/PhxpKWlYejQoXL7f/jhhyzH7ty5E15eXrCyssL79+9lW4sWLZCeno7Tp0/ny+uIj4/H+/fv4enpCVEUcePGjc++Di8vLzx79kz22NLSEvHx8bn+/3h5eSEsLAyPHj0CkPELcqNGjeDl5YUzZ84AyOhlIIqirEfBzZs38e+//6JXr14IDw+XXYP4+Hg0b94cp0+flg07yynWzxk4cCB0dHTk9n18fVJTUxEeHo5y5crB0tIy2//n77//Xq43iZeXF9LT0/Hy5cssZefNm4eRI0di7ty5+Omnn/IU48fxxMbG4v379/Dy8kJCQgIePnyYpzo+FRERgRMnTqB79+6yOt+/f4/w8HB4e3vj33//RXBwsNwx2V2r7FhaWuL169e4cuVKjmW8vLxw/fp1Wc+Es2fPom3btnB3d5fdD2fOnIEgCHJD5hS5Frq6uhg0aJDssb6+PgYNGoS3b9/i2rVrn30dREQkT1Xtu23btmHjxo0YO3YsypcvL/cc23fZvw6279i+Y/uOiAoKh9IT5cH79++RkpKCChUqyO2vUaMGAKBDhw5y+4sXL47ixYsXWnzKioiIgL+/P/744w/ZROiZoqOjs5R3cXGRe5zZkMpcUTKTtbW17AtGpn///Re3b9+WzSH0qU/P/6nExMQsMWXO7RQUFISpU6fir7/+QmRkZK6vw9DQMEsMVlZWcscNHToUO3bsQJs2beDo6IhWrVqhe/fuaN26taxMZmP4zJkzKFmyJG7cuIGZM2fC1tYWCxYskD1nbm6O6tWry64BAPj4+OT4OqOjo+Wu3afX/HOyK5+YmIjZs2dj06ZNCA4Olhuyld3/c+nSpeUeZ8bz6bU9deoUDhw4gIkTJ3523qmP3bt3Dz/99BNOnDiBmJgYueeyiycvnjx5AlEUMWXKFEyZMiXbMm/fvoWjo6PscV6v7cSJE3Hs2DHUrVsX5cqVQ6tWrdCrVy80aNBAVsbLywtpaWm4cOECSpUqhbdv38LLywv37t2TazhXqVIF1tbWsuMUuRYlSpTIsoBA5mfSixcvZF96iYgob1TRvjtz5gz69+8Pb29vzJo164vqygnbdxnYvpPH9p08tu+IKBMTo0R5YGhoCABZ5mTK7EXQqFEjuf3ZNfJy8unE7YWpe/fuOH/+PMaPHw93d3eYmppCKpWidevWWX7ZBuR//VSUVCpFy5YtMWHChGyf//RLyae2b9+Ovn37yu0TRRHp6elo2bIlIiIiMHHiRFSqVAkmJiYIDg5Gnz59sryOvPyCbGdnh5s3b+Lw4cM4ePAgDh48iE2bNqF3797YvHkzgIxGjIuLC06fPg1nZ2eIoggPDw/Y2tpi5MiRePnyJc6cOQNPT09IJBLZNQCA+fPnw93dPdtzm5qayj1W9JpnV/6HH37Apk2bMGrUKHh4eMDCwgKCIKBHjx7Z/j/ndI0+bnADQNWqVREVFYUtW7Zg0KBBeWqIRkVFoXHjxjA3N8f06dNRtmxZGBoa4vr165g4cWK28eRF5nHjxo2Dt7d3tmU+/YKX12tbuXJlPHr0CPv378ehQ4fw559/YtWqVZg6dSr8/f0BALVr14ahoSFOnz6N0qVLw87ODhUqVICXlxdWrVqF5ORknDlzRm4erIK6FkRElDeF3b67desWOnbsCFdXV+zatQu6ugXzVYztu+yxfcf23cfYviOiTEyMEuWBlZUVTExMEBQUJLf/77//BgAEBwejVq1asv3ZNfJy8mljJL992tjPFBkZiePHj8Pf3x9Tp06V7c/81TsvnJycAGT8mvtxoyk8PDzLr89ly5ZFXFwcWrRooVS8mcPXPnXnzh08fvwYmzdvRu/evWX7v2SaAiBjGEuHDh3QoUMHSKVSDB06FGvXrsWUKVNkDTAvLy+cPn0aLi4ucHd3h5mZGapXrw4LCwscOnQI169flzWsgIxrAADm5uafvQ75adeuXfDx8cHChQtl+5KSkhAVFfVF9drY2GDXrl1o2LAhmjdvjrNnz6JEiRK5HhMYGIjw8HDs3r1b7gvn8+fP83TOnO6PMmXKAAD09PQK5NqamJjgm2++wTfffIOUlBR07doVs2bNgq+vLwwNDaGvr4+6devizJkzKF26tKzHiZeXF5KTk7F161aEhYXJvWZFr8WbN28QHx8v16vg8ePHAPBFQy6JiIqqwmzfPX36FK1bt4adnR3++eefLIkyRbF9pxy27z6P7Tu274iKGs4xSpRHjRs3xt69e2XDIeLj47F161YAwKVLl+TKFsYcoyEhIXj48CFSU1NzLZe5IuWnjaTMX40/bbgvWbIkzzE0b94curq6WL16tdz+FStWZCnbvXt3XLhwAYcPH87yXFRUFNLS0nKNt3jx4mjRooXcltPrEEURS5cuzfPr+FR4eLjcY4lEIlsZMzk5Wbbfy8sLL168wPbt22UNJYlEAk9PTyxatAipqalyK5bWqlULZcuWxYIFCxAXF5flvO/evVM65tzo6Ohk+X9evnw50tPTv7jukiVL4tixY0hMTETLli2zXLvsYgHk/79SUlKwatWqPJ0vp/vDzs4OTZo0wdq1axESEpLluC+5tp++Jn19fVSpUgWiKMq9/7y8vHDp0iWcPHlS9v9uY2ODypUry1a//fh+UPRapKWlYe3atXJl165dC1tbW7kv7kRElHeF0b4LDQ1Fq1atIJFIcPjw4RyHnQNs37F9l3ds37F9R0T5gz1GifJowoQJaNq0KZo0aYJ+/fph3759iImJQbt27bB69Wo4OzujV69eMDExUXoOqujoaCxfvhwAcO7cOQAZjVBLS0tYWlpi+PDhsrK+vr7YvHkznj9/nuuviUZGRqhSpQq2b9+OChUqwNraGq6urnB1dUWjRo0wb948pKamwtHREUeOHMnzL7sAYG9vj5EjR2LhwoXo2LEjWrdujVu3buHgwYOwsbGR+/V3/Pjx+Ouvv9C+fXv06dMHtWrVQnx8PO7cuYNdu3bhxYsXsLGxyTXe7FSqVAlly5bFuHHjEBwcDHNzc/z5559ZejQoYsCAAYiIiECzZs1QsmRJvHz5EsuXL4e7uzsqV64sK5fZCHr06BF+/vln2f5GjRrh4MGDMDAwQJ06dWT7JRIJNmzYgDZt2qBq1aro27cvHB0dERwcjJMnT8Lc3FzWSyU/tW/fHlu2bIGFhQWqVKmCCxcu4NixYyhWrFi+1F+uXDkcOXIETZo0gbe3N06cOAFzc/Nsy3p6esLKygo+Pj4YMWIEBEHAli1b8txzOrf7Y+XKlWjYsCHc3NwwcOBAlClTBmFhYbhw4QJev36NW7duKfX6WrVqBQcHBzRo0AD29vZ48OABVqxYgXbt2sHMzExWzsvLC7NmzcKrV6/kGsiNGjXC2rVr4ezsjJIlSyp9LUqUKIG5c+fixYsXqFChArZv346bN29i3bp10NPTU+q1EREVdYXRvmvdujWePXuGCRMm4OzZszh79qzsOXt7e7Rs2VL2mO27DGzffR7bd2zfEVE+KdhF74m0y++//y5WqVJF1NPTEx0cHMSdO3eKb968ERs1aiQKgiA+f/78i+p//vy5CCDbzcnJSa6sj4+PCCBP5zx//rxYq1YtUV9fXwQgTps2TRRFUXz9+rXYpUsX0dLSUrSwsBC7desmvnnzRq6MKIritGnTRADiu3fvstSdlpYmTpkyRXRwcBCNjIzEZs2aiQ8ePBCLFSsmDh48WK5sbGys6OvrK5YrV07U19cXbWxsRE9PT3HBggViSkrKZ+PNyf3798UWLVqIpqamoo2NjThw4EDx1q1bIgBx06ZNctfMxMQky/GZry/Trl27xFatWol2dnaivr6+WLp0aXHQoEFiSEhIlmPt7OxEAGJYWJhs39mzZ0UAopeXV7bx3rhxQ+zatatYrFgx0cDAQHRychK7d+8uHj9+PEtM2V3z7GzatEkEIF65ciXLc5GRkWLfvn1FGxsb0dTUVPT29hYfPnwoOjk5iT4+Pp+t4+TJkyIA8eTJk7J9Tk5OYrt27eTKXbp0STQzMxMbNWokJiQk5BjruXPnxPr164tGRkZiiRIlxAkTJoiHDx/Oco6crkFu98fTp0/F3r17iw4ODqKenp7o6Ogotm/fXty1a1eerlV21q5dKzZq1Ej2/1W2bFlx/PjxYnR0tFy5mJgYUUdHRzQzMxPT0tJk+3/77TcRgPjdd98pfS0aN24sVq1aVbx69aro4eEhGhoaik5OTuKKFSvy9BqIiChnBd2+y6ltB0Bs3LixXFm27z5g+47tu0xs3xFRQRJEsYAnOCSiIicqKgpWVlaYOXMmJk+erOpwiDRekyZN8P79e9y9e1fVoRARURHF9h1R/mL7jkg9cI5RIvoiiYmJWfZlzmPVpEmTwg2GiIiIiL4Y23dERFRUcI5RIvoi27dvR0BAANq2bQtTU1OcPXsWv//+O1q1aoUGDRqoOjwiIiIiUhDbd0REVFQwMUpEX6RatWrQ1dXFvHnzEBMTI5uwf+bMmaoOjYiIiIiUwPYdEREVFZxjlIiIiIiIiIiIiIoczjFKRERERERERERERQ6H0hcgqVSKN2/ewMzMDIIgqDocIiIiUnOiKCI2NhYlSpSARMLfr9UR23dERESUV2zbqT8mRgvQmzdvUKpUKVWHQURERBrm1atXKFmypKrDoGywfUdERESKYttOfTExWoDMzMwAADNP1oOhqWZc6gr6oaoOQSFeRpo1Re7G6OKqDkEh/S1CVB0CqQneuwXrTKJm9TrbE1lL1SEoJDjRUtUh5FlafApOfB0ga0OQ+sn8vynp9xMkhoYqjiZvBJtkVYegkIqOYaoOQSEpbTQr3qfrqqs6hDyztY5VdQgKMf/6mapDUMizOXVUHYJCild8q+oQFGLU5aWqQ1BI0OS6qg5BISklUlUdQp5IE5PwZtwctu3UmGZk6zRU5vAqQ1NdGGlIYtTEQEfVISjE3Eiq6hAUYpSuGfdBJnMzdvWnDLx3C5aJrmbFq5+qr+oQFKIn0ax4AXCIthrL/L+RGBpqTmLUWLPuJz0TzXrPSgU9VYegEImRZty3AKBjkqLqEBSiq2n3goZ8hmXSNTFQdQgK0bT7QUfD7geJkWblLti2U1+a9U2MiIiIiIiIiIiIKB8wMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERERFDhOjREREREREREREVOQwMUpERERERERERER5tnr1alSrVg3m5uYwNzeHh4cHDh48mOsxO3fuRKVKlWBoaAg3Nzf8888/hRRtzpgYJSIiIiIiIiIiojwrWbIk5syZg2vXruHq1ato1qwZOnXqhHv37mVb/vz58+jZsyf69++PGzduoHPnzujcuTPu3r1byJHLY2KUiIiIiIiIiIiI8qxDhw5o27YtypcvjwoVKmDWrFkwNTXFxYsXsy2/dOlStG7dGuPHj0flypUxY8YM1KxZEytWrCjkyOXpqvTsRERERERERERElC+SkpKQkpKi1LGiKEIQBLl9BgYGMDAwyPW49PR07Ny5E/Hx8fDw8Mi2zIULFzBmzBi5fd7e3ti7d69SseYXJkaJiIiIiIiIiIg0XFJSEiyMrJCCJKWONzU1RVxcnNy+adOmwc/PL9vyd+7cgYeHB5KSkmBqaoo9e/agSpUq2ZYNDQ2Fvb293D57e3uEhoYqFWt+YWKUiIiIiIiIiIhIw6WkpCAFSWgotIcu9BQ6Ng2pOBu3H69evYK5ublsf269RStWrIibN28iOjoau3btgo+PD06dOpVjclQdMTFKRERERERERESkJfQk+tAVFEuMCqIApEO2ynxe6Ovro1y5cgCAWrVq4cqVK1i6dCnWrl2bpayDgwPCwsLk9oWFhcHBwUGhOPMbF18iIiIiIiIiIiLSFoJEue0LSaVSJCcnZ/uch4cHjh8/Lrfv6NGjOc5JWljYY5SIiIiIiIiIiEhLCBIhyyJKnz1GVKy8r68v2rRpg9KlSyM2Nhbbtm1DYGAgDh8+DADo3bs3HB0dMXv2bADAyJEj0bhxYyxcuBDt2rXDH3/8gatXr2LdunUKnTe/MTFKREREREREREREefb27Vv07t0bISEhsLCwQLVq1XD48GG0bNkSABAUFASJ5EMvVE9PT2zbtg0//fQTJk2ahPLly2Pv3r1wdXVV1UsAwMQoERERERERERGR9hAEJYbGK9ZjdOPGjbk+HxgYmGVft27d0K1bN4XOU9CYGCUiIiIiIiIiItIWEiEjOaoIBYfSa4sisfiSn58f3N3d1aYeIiIiIiIiIiKiAiEIym1FkMp7jIaGhmLWrFk4cOAAgoODYWdnB3d3d4waNQrNmzfPl3OMGzcOP/zwg+xxnz59EBUVhb179+ZL/YVtef/biHmfAkECGJrooNukcihVxUzVYWUrJVmKGSNC8PLfFBgYCrAspotRM+zg6Kyv6tC0gibdC0Sf4v1bMDTxc3drhz3Q0ZNA1zCjWeLepyrKtXJWbVA5SIlOxKXR+2SP05NSkRASgxb7+kPf3FCFkZGmCV29DukxsYAgQGJoAOuunWFQ0hHhf+5Fwt17SI+MRPFxo2FQ0lHVoSJ8834kXHuAtPdRKPHzMBg4l0B6bAJCf/4whE6anIq0t5EovcYXOqbGKoxWnrq8Z/UM9DD591FwqlISyYkpiHobg2VD1+PN01AsOOEHOydbJEQnAACO/BqI3UsOyI79blo3NOvZEKnJaYh+H4Pxzf0BAFuerYRfl/l4eutFob2OiF//RsKNB0h/H4XiM4dD36kEACDx5iNE7ToKURSB9HSYt2sEU6+ahRZXTl6uPoqoi/8i5W0Mqq7oC+Oy9gCApOAIPFt4AGkxCdAxNkCZse1g5GRbKDFpy72QSZM+yz4VeeU5XgacgZiWDomBHsqNbAWTsnaFGoO23Q8AEH39Mt7u2Y7iPfvAtIobXm9chdSoSEgMMz5zzWvUhpVnY5XElklMTcX7Nb8j9c1bCHq60DE3hdV3naFnb4Po/ScRf+4a0t6Gw2bY/2Bcs6pKY1WWIJFAUHAovSAWib6TWag0MfrixQs0aNAAlpaWmD9/Ptzc3JCamorDhw9j2LBhePjwYb6cx9TUFKampvlSlzrov7gKjM0z/utuHn2PLZMeYdLe2iqOKmfte1igbhMTCIKAvb9GYqFvGBb9XkrVYX1WVHQ6+ox8ixkTreFW2UDV4WRL0+6Fj2nC9f0Y481/mnr/asK11cTP3RazvWBT0VrVYXyWvoURvH7pIXv89PfriLj1hklRUpitz3fQMTYCAMTfvoP32/6A44SxMHF3g0XzJghZulLFEX5gXLcqLNp7IcT/w6qxOmbGcJz9oeNB9P4zSHzwXK2SooB6vWf/WX8Mlw/eAAB0GtYaY9YPxrhmfgCANWMCcH7flSzHdBnRFmXcnDDQbSzSUtNgZW9ZeAFnw7iuK8zbN0LojLWyfaIo4v2aHbCfNAD6pYsj7V0kgicuhnHtqpAYqfbvpHXDiij+dT08GPeb3P4Xyw/Brk112LSshogzD/Fs4QFUXdan0OLShnshkyZ9ln0sLTYJj+fsh9vCnjB2tkH0ndd4POcAaqzvW+ixaNP9kBoZgZirF2FYykluv22bjjCt4qaiqLJn2rguDN0qQhAExB4/j4iAP2E/cRAMq5SDSd1qCN+0S9UhfhmleoAWzR6jKk0HDx06FIIg4PLly/jqq69QoUIFVK1aFWPGjMHFixcBAIsWLYKbmxtMTExQqlQpDB06FHFxcbI6AgICYGlpib1796J8+fIwNDSEt7c3Xr16JSvz8RB4Pz8/bN68Gfv27YMgCBAEQTYh7MSJE1GhQgUYGxujTJkymDJlClJTUwvteuRVZiIBABLj0tT63tU3kKBeU1MI/70hK7sbIfS1+l3TT4miiO+Gh6Gmm4HaJj4AzboXPqYp1zcT4y0Ymnj/asK11dTPXU316sADlGpXRdVhkAbKTCQAgDQxCZkfgoZly0LX0lI1QeXAqLILdItZ5FomNvAazJqo/49bqnrPpianyhIfAPDg4mPYO3++h2K3cR2xwXcr0lLTAACRYVHZlus0vDWWnJkBCxvzfIk3J4aVXKBrnc29IADShCQAGfezjqkxBD2dAo0lL8zcSkPfVv6apEbFI/5xKIo1y1gF2aphRaS8j0XSm8hCiUlb7oVMmvRZ9rHEkCjomhvB2NkGAGDhVhLJ72IQ929YocahTfeDKJUibO8O2LbrAkFH5YOTcyXo6cGoWiVZe1m/TGmkvc/4DDAoUwq6dsVUGR4VMpXdrRERETh06BBmzZoFExOTLM9b/vchKpFIsGzZMri4uODZs2cYOnQoJkyYgFWrVsnKJiQkYNasWfj111+hr6+PoUOHokePHjh37lyWeseNG4cHDx4gJiYGmzZtAgBYW2f0UDEzM0NAQABKlCiBO3fuYODAgTAzM8OECRPy9JqSk5ORnJwsexwTE5Pn66GozRMf4vHlKADA0LWuBXae/LY7IBKeLdW/9+7C1VEQBGDKGCtVh/JZmngvaNL1BRhvQdK0+1eTrm0mTfncPTntPCACtlWLod4PNWBkpf49MCPuhCAtLhl2Hs6qDoUKUEG279799juSnjwBANh/PyDf6i1sSY9fQhqfCOOaFVUdSq7U6T3bZUQ7XPjrquxx/9nfos/0Hnh5/zU2TtqK0OdvYWxmBCt7C3h2qgOvr+oDAP5cvB+ndpyXHSdIBAxa6AMHZztMaDkDKUkphf5aBEGAzbCeeLd0KwQDfUjjE2E78lsIuuqZGEl5Fwt9a1MIOhl9hARBgIGtOVLeRsOwROH/fdeGe0ETP8uMHK2QFpOImHvBMK/qiPALT5CekILksGiYlrdXWVyafD9EnT8Fo9LOMHTMOkrp/dEDCD9+CPp29rBp2Q561uqVeIw9dg5GNbTsh26JRPFV6TmUvnA9efIEoiiiUqVKuZYbNWqU7N/Ozs6YOXMmBg8eLJcYTU1NxYoVK1CvXj0AwObNm1G5cmVcvnwZdevWlavP1NQURkZGSE5OhoODg9xzP/30k9y5xo0bhz/++CPPidHZs2fD398/T2W/lM/cjOt2cW8o9i54jmHr1Ktbena2rgxH8MtULJiluj80uYmLl+LMxUQ4ldTDui0xuHSwpOwXJHWmKfeCpl1fxls4NOH+1dRrC6j/526mjutbwczBBOlpUlxZdRMnp51H22XNVB3WZ706cB+O3hUh0S2ajciioiDbd7b/6wkAiLt8BZF/H4D9IM1IKHwqNvAaTL1qQNBRfQ/B3KjLe7anbxeUKOeACS0y7qu5vZfj3etwABnDaGf+7YsBrqOho6sDXT1dGBjpY4THJNg72WLpuZl49TAYz26/BACMXjsIT24+x/SvF2TM76kCYno6ovedhO3Ib2FYyQXJz17j3aItKD57BHTMsnaAoQ+05V7QxM8yXRMDVJzSCS9/OY30xFSYVSkBI6digI7qPh80+X5IDgtB3P07KNl/WJbn7L/uCT0LK4iiiOhL5/Dmt41wGpG3HEthiN5/Emlvw2E3Tv3vW4VwKH2eqexdn9c357Fjx9C8eXM4OjrCzMwM3333HcLDw5GQkCAro6urizp16sgeV6pUCZaWlnjw4IFCMW3fvh0NGjSAg4MDTE1N8dNPPyEoKCjPx/v6+iI6Olq2fTycv6DU7+yAfy9HIS5SvYdJ7lgfgbOH4zBnkyMMjdTzC+Ste8noPjAU3w4Nxaq5trCyVO/G/afU/V7QtOvLeAuXOt+/mnptNeFzN5OZQ8YXZx1dCdx6VULozbcqjujz0hJSEHLyCUq11bLeBZRFYbTvTOvWQdKTJ0iPj8/3uguaNCkZ8RfvwLRxLVWHkit1ec9+PbYDGnaph0ltZyE5MaMHV2biAwD2rTyE4mXsYGZtitjIOCTEJuLYb6cBAGEv3+HeuUeoWKesrPzt0/dRqW55WDtYFurr+FjKyxCkR8XAsJILAMCgTEnoWJsj5cUblcWUG31bM6RExEFMlwLI+F6a/C4G+na5TxeR37TxXtC0zzJL99JwW9gT7qt6w+X7JkgJj4NxadX0ZNT0+yHx5XOkRkbgxZLZeL5wJpJev8Tbv3Yh6vJ56Flk9MQWBAGW9RsiNTIc6QnqcY/EHDqNxGt3YTe6LyQG6rtQqVIEAZAouGlI54/8prJvSuXLl4cgCLkusPTixQu0b98e1apVw59//olr165h5cqMyZtTUvK3K/iFCxfw7bffom3btti/fz9u3LiByZMnK3QeAwMDmJuby235LSEmDVFvPwznunXsPUwsdWFiqZ5DVQBg54ZInPg7FvO2lISpufomFOrXMoS9rQ6aNTRCi0bqtXBAdjTtXtC068t4C5Ym3b+adm0BzfncBYDUxDQkx374W/v00AsU04BFmN6ceALzcjYwddKcaRVIOQXRvktPSERadLTscfztu5AYm0BirBmfMR+Lv3AH+qWLQ9+xcFb0VpY6vGe/Gt0eTXs0xMRWMxD/3yrTEh0JLD9KyDXsWg+RYdGIjchYU+HkH+dQp7U7AMDMyhQV65bDs9sfOm4c23Iav83YhXnHp8HBuXBX086kW8wC6VGxSA3O+FErNSwcaW8joFdcPe8JPUsTmJSzR/iJuwCAyLOPoG9jVqjD6LXlXtD0z7KU8A9rl7zaegGW7qVh5Fj4nxHacD9Y1vVEmYl+cBn7E1zG/gTDkk6w6/g1LGrVQ1pcrKxc7L3b0DExg46x6nuTxxw+g/hLt2A3rj8kH82Vqy0EQaLUVhSp7BuotbU1vL29sXLlSowYMSLLPKNRUVG4du0apFIpFi5cCIkk4z9ox44dWepKS0vD1atXZcPmHz16hKioKFSuXDnbc+vr6yM9PV1u3/nz5+Hk5ITJkyfL9r18+fKLXmNBSIxNw8bR95GaJIUgAUyt9DB4tZvaDut8F5KKNT+/Q/HSehjb6zUAQE9fwMo9pVUcWVY6OgKeXHJWdRh5pmn3gqZdX8ZbsDTp/tW0a6tJn7sAkBieiCMTTkOUioAImDmaopm/p6rD+qxXB+6jdAf2FiXliEmJeBuwBWJqKiAI0DE1hd3AfhAEAe+370Li/QdIj41F2Jr1kBgaoORPviqN9/2GvUi4+QjpUXEInRMAiZEBSi0eC+C/RZeaasKiS6p9z9o4WmPwQh+8eRqKBSf8AAApyamY0Nwfs/b7Qs9AD1KpFDHvYzG101zZcRt9t2L8L8PQYYg3AGD7vL14dOWJXN1n/ryI5MQUzDn8E6Z0nINXjwqup2b4L3uQePMR0qPjEDZvEySGBnBcOA7F+nXBuxW/Z/Q2EkVY9+4AXRvLAosjr14sO4Soy0+RGhmHRz9th46RPqr9MhhOI1rj+cIDeLP9AnSMDeAyum2hxaQt9wKgeZ9lnwr69Rxi7ryGKJXCrHIJlBvTutBj0Kb7ITtiehrebNkAMS0t4x4xMUGJb/sVehyfSouIRtT2A9C1tUbYvPUAAEFXFw5ThiH67+OIC7yE9Nh4pAb/icit++AwbQR0zNV/zn45mb1AFaJ+38UKgyCqajIaAM+ePUODBg1gbW2N6dOno1q1akhLS8PRo0exevVq/PHHH3B3d8eSJUvQoUMHnDt3Dr6+vggODkZkZCQsLS0REBCA77//HjVq1MCyZcugq6uL4cOHA8joBQpkrES/d+9e3Lx5EwDw888/Y+3atThy5AiKFSsGCwsLHDx4EF999RW2bNmCOnXq4MCBA/D390d6ejqioqKyredzYmJiYGFhgQVXGsDIVP16QWWnkkGIqkNQSBMjqapDUMiaKEdVh6CQwZbBqg6B1ATv3YIVmKhZv87uiKj7+UJq5HWCpapDyLPU+BQcabMO0dHRBTLyhL5cZvuu9JyZkBiq/yJhACDYJX++kBqpUlKz2qPJjUNVHYJC/v21pqpDyDM7m4JbzLYgWLR98vlCauTJ4vqqDkEhjlUKd8X4L2Xk/VzVISjk5XQPVYegkGRH9ZuCKzvSxCS8HuZXaG27zHZKC9v+0JUoNj1AmjQFx95tLHLtUJV+EytTpgyuX7+Opk2bYuzYsXB1dUXLli1x/PhxrF69GtWrV8eiRYswd+5cuLq6YuvWrZg9e3aWeoyNjTFx4kT06tULDRo0gKmpKbZv357jeQcOHIiKFSuidu3asLW1xblz59CxY0eMHj0aw4cPh7u7O86fP48pU6YU5MsnIiIiIiIiIiIiFVFpj9H8EBAQgFGjRsl6daoT9hgteOwxWrA0rdcdFRzeuwWLPUYLFnuMUn5ij9GCxx6jBYs9RgsOe4wWLPYYLVjsMVowVNZj1G6Acj1G324ocu1QzcjWERERERERERER0edJJBmbYgcVSCjqjolRIiIiIiIiIiIibSEIGZuixxRBGp8O7tOnj1oOoyciIiIiIiIiIip0Aj4kR/O8qTpo1WCPUSIiIiIiIiIiIm3BHqN5pvE9RomIiIiIiIiIiIgUxR6jRERERERERERE2kIiZGwKKZo9RpkYJSIiIiIiIiIi0hYcSp9nTIwSERERERERERFpC0GSsSl6TBHExCgREREREREREZG24FD6PGNilIiIiIiIiIiISFtwKH2eMTFKRERERERERESkNZRIjLLHKBEREREREREREZF6io6ORmhoKADAwcEBFhYWX1Rf0ZxZlYiIiIiIiIiISBtlDqVXdFNjGzZsQJUqVWBtbY0qVarI/Xvjxo1K18seo0RERERERERERNpCmcWXRPVNjM6fPx9+fn4YMWIEvL29YW9vDwAICwvDkSNHMHLkSERGRmLcuHEK183EKBERERERERERkbbQssWXVqxYgU2bNqF79+5y+ytXrowmTZqgevXqGD9+PBOjRERERERERERERZkoCBAVTHQqWr4wvX37Fm5ubjk+7+bmhvfv3ytVN+cYJSIiIiIiIiIi0hYSJTc1VadOHcyZMwdpaWlZnktPT8fcuXNRp04dpepmj1EiIiIiIiIiIiJSSytWrIC3tzccHBzQqFEjuTlGT58+DX19fRw5ckSpupkYJSIiIiIiIiIi0hZaNsdotWrV8PjxY/z222+4ePEinj17BgBwcHDAzJkz0atXL5ibmytVNxOjRERERERERERE2kLLEqMAYGZmhiFDhmDIkCH5Wi8To0RERERERERERNpCCxOjABAaGopLly4hNDQUAFC8eHHUrVsXDg4OStfJxCgREREREREREZGW0LZV6ePj4zFo0CD88ccfEAQB1tbWAICIiAiIooiePXti7dq1MDY2VrhuNV5zioiIiIiIiIiIiBSiZavSjxw5EpcvX8aBAweQlJSEsLAwhIWFISkpCf/88w8uX76MkSNHKlW3Gr9sIiIiIiIiIiIiUkjmUHpFNzX1559/IiAgAN7e3tDR0ZHt19HRQatWrfDLL79g165dStXNxCgRERERERERERGpJalUCn19/Ryf19fXh1QqVapuJkaJiIiIiIiIiIi0hQAleoyqOuictW/fHt9//z1u3LiR5bkbN25gyJAh6NChg1J1MzFKRERERERERESkJTIXX1J0U1crVqyAvb09atWqhWLFiqFy5cqoXLkyihUrhtq1a8POzg4rVqxQqm6uSk9ERERERERERKQtBCjeFVLBkeizZ8/G7t278fDhQxgZGcHT0xNz585FxYoVczwmICAAffv2ldtnYGCApKSkXM9lZWWFgwcP4sGDB7h48SJCQ0MBAA4ODvDw8EClSpUUC/4jTIwSERERERERERFpC2UWU1Kw/KlTpzBs2DDUqVMHaWlpmDRpElq1aoX79+/DxMQkx+PMzc3x6NGjj06b9/Nm9hTNT0yMEhERERERERERaQllhsZnlo+JiZHbb2BgAAMDgyzlDx06JPc4ICAAdnZ2uHbtGho1apTjeQRBgIODg0KxAUBKSgr27t2LCxcuyPUY9fT0RKdOnXJdnCk3nGOUiIiIiIiIiIiIUKpUKVhYWMi22bNn5+m46OhoAIC1tXWu5eLi4uDk5IRSpUqhU6dOuHfv3mfrfvLkCSpXrgwfHx/cuHEDUqkUUqkUN27cQO/evVG1alU8efIkT3F+ij1GiYiIiIiIiIiItIUAxVeZ/6/8q1evYG5uLtudXW/RT0mlUowaNQoNGjSAq6trjuUqVqyIX375BdWqVUN0dDQWLFgAT09P3Lt3DyVLlszxuCFDhsDNzQ03btyQiw3I6OHau3dvDBs2DIcPH/5srJ9iYpSIiIiIiIiIiEhbfMEco+bm5lmSj58zbNgw3L17F2fPns21nIeHBzw8PGSPPT09UblyZaxduxYzZszI8bhz587h8uXL2cZlbm6OGTNmoF69egrFnIlD6YmIiIiIiIiIiLSEKFFuU8bw4cOxf/9+nDx5Mtden9nR09NDjRo1PjsM3tLSEi9evMjx+RcvXsDS0lKhc2diYpSIiIiIiIiIiEhbZPYYVXRTgCiKGD58OPbs2YMTJ07AxcVF4TDT09Nx584dFC9ePNdyAwYMQO/evbF48WLcvn0bYWFhCAsLw+3bt7F48WL06dMH33//vcLnBziUnoiIiIiIiIiISGuIQsam6DGKGDZsGLZt24Z9+/bBzMxMtlK8hYUFjIyMAAC9e/eGo6OjbAGn6dOno379+ihXrhyioqIwf/58vHz5EgMGDMj1XNOnT4eJiQnmz5+PsWPHQvgviSuKIhwcHDBx4kRMmDBBsRfwHyZGiYiIiIiIiIiItMUXzDGaV6tXrwYANGnSRG7/pk2b0KdPHwBAUFAQJJIPg9UjIyMxcOBAhIaGwsrKCrVq1cL58+dRpUqVz55v4sSJmDhxIp4/fy5Lwjo4OCjVU/VjTIwSERERERERERFRnomi+NkygYGBco8XL16MxYsXf9F5XVxcvjgZ+jEmRgtBf4sQmJtxOlcCBlsGqzoEhQQmas5928RIquoQtJqm3btUsLpbX1Z1CApZl9JY1SHkWapuiqpDoDwq8+MV6Ap6qg5DK4V3U25VWVWZ9fSIqkNQSBOjm6oOIc+qLRyq6hAU0uf+BVWHoJA9VS6qOgSt5vv0tqpDUMjssqqOQDGacn3jY9PRURUnFv7bFD1GQ7169QrTpk3DL7/8ovCxmpP1ICIiIiIiIiIiolyJgqDUpqkiIiKwefNmpY5lj1EiIiIiIiIiIiJtIYHiXSHVuOvkX3/9levzz549U7puJkaJiIiIiIiIiIi0hDI9QNW5x2jnzp0hCEKu85oKSsavxvlgIiIiIiIiIiIiUoig5Kamihcvjt27d0MqlWa7Xb9+Xem6mRglIiIiIiIiIiIitVSrVi1cu3Ytx+c/15s0NxxKT0REREREREREpCVEIWNT9Bh1NX78eMTHx+f4fLly5XDy5Eml6mZilIiIiIiIiIiISFsIQsam6DFqysvLK9fnTUxM0LhxY6XqZmKUiIiIiIiIiIhIS4hQosdogUSi/pgYJSIiIiIiIiIi0hbKLKakvh1GCxQTo0RERERERERERNpCImRsih5TBHFVeiIiIiIiIiIiIipymBglIiIiIiIiIiLSEpmr0iu6qbvTp08jLS0ty/60tDScPn1aqTqZGCUiIiIiIiIiItIWgpKbmmvatCkiIiKy7I+OjkbTpk2VqpNzjBIREREREREREWkJZXqAakKPUVEUIQhZAw0PD4eJiYlSdTIxSkREREREREREpC0EIWNT9Bg11bVrVwCAIAjo06cPDAwMZM+lp6fj9u3b8PT0VKpuJkaJiIiIiIiIiIi0hLb1GLWwsACQ0WPUzMwMRkZGsuf09fVRv359DBw4UKm6mRglIiIiIiIiIiLSFsrMGarGidFNmzYBAJydnTFu3Dilh81nh4lRIiIiIiIiIiIiUmvTpk3L9zqZGCUiIiIiIiIiItIS2jaU/mO7du3Cjh07EBQUhJSUFLnnrl+/rnB9kvwKjIiIiIiIiIiIiFQsc/ElRTc1t2zZMvTt2xf29va4ceMG6tati2LFiuHZs2do06aNUnUyMUpERERERERERKQlMnuMKrqpu1WrVmHdunVYvnw59PX1MWHCBBw9ehQjRoxAdHS0UnUyMUpERERERERERKQtBCU3NRcUFARPT08AgJGREWJjYwEA3333HX7//Xel6mRilIiIiIiIiIiISEuIEuU2defg4ICIiAgAQOnSpXHx4kUAwPPnzyGKolJ1asDLJiIiIiIiIiIioqKsWbNm+OuvvwAAffv2xejRo9GyZUt888036NKli1J1clV6IiIiIiIiIiIibaHM0HgNGEq/bt06SKVSAMCwYcNQrFgxnD9/Hh07dsSgQYOUqpOJUSIiIiIiIiIiIi2hzGJKmrD4kkQigUTyYfB7jx490KNHjy+qk4lRIiIiIiIiIiIibSEIGZuixxRBTIwSERERERERERFpEU3oAaoOmBglIiIiIiIiIiLSFlo6x2hBYGKUiIiIiIiIiIhIS2jrHKMFQfL5IkRERERERERERETahT1GiYiIiIiIiIiItIUWDaWvUaMGhDwuDHX9+nWF62dilIiIiIiIiIiISEto01D6zp07y/6dlJSEVatWoUqVKvDw8AAAXLx4Effu3cPQoUOVqp+JUSIiIiIiIiIiIm2hRT1Gp02bJvv3gAEDMGLECMyYMSNLmVevXilVP+cYJSIiIiIiIiIi0hKZPUYV3dTdzp070bt37yz7//e//+HPP/9Uqk4mRomIiIiIiIiIiLSFoOSm5oyMjHDu3Lks+8+dOwdDQ0Ol6uRQeiIiIiIiIiIiIlJro0aNwpAhQ3D9+nXUrVsXAHDp0iX88ssvmDJlilJ1MjFKRERERERERESkJURBgJjHldw/Pkbd/fjjjyhTpgyWLl2K3377DQBQuXJlbNq0Cd27d1eqTg6lJyIiIiIiIiIi0haFMJR+9uzZqFOnDszMzGBnZ4fOnTvj0aNHnz1u586dqFSpEgwNDeHm5oZ//vlHofN2794d586dQ0REBCIiInDu3Dmlk6IAE6NERERERERERERaozAWXzp16hSGDRuGixcv4ujRo0hNTUWrVq0QHx+f4zHnz59Hz5490b9/f9y4cQOdO3dG586dcffu3TyfNyoqChs2bMCkSZMQEREBALh+/TqCg4MVewH/4VB6IiIiIiIiIiIibaHMYkoKlj906JDc44CAANjZ2eHatWto1KhRtscsXboUrVu3xvjx4wEAM2bMwNGjR7FixQqsWbPms+e8ffs2WrRoAQsLC7x48QIDBgyAtbU1du/ejaCgIPz666+KvQiwxygREREREREREZH2+IKh9DExMXJbcnJynk4ZHR0NALC2ts6xzIULF9CiRQu5fd7e3rhw4UKezjFmzBj06dMH//77r9wq9G3btsXp06fzVMenFOox2qdPH0RFRWHv3r1KnYyIiq6UZClmjAjBy39TYGAowLKYLkbNsIOjs76qQyPSKpr2XtO0eAEgPSUdN5dfROil19DR14FluWKo79dU1WGRGqnbpgb6zOgBiUQCia4EOxf8haO/noKlrTkmbP4BJcraIyU5FcuHbcCdMw+yHO/gbIcpO8dCRyfj+FcPgrF40FrERcWjWuMqGLq4LwbXHJ+vMesZ6GHy76PgVKUkkhNTEPU2BsuGrsebp6FYcMIPdk62SIhOAAAc+TUQu5cckB373bRuaNazIVKT0xD9Pgbjm/sDALY8Wwm/LvPx9NaLfI31U6P7NINXrbIobmeB3hM249+X7wAAu5cPREpaOpJT0gAAv+69hOMXMuY+83B3waAeDSEIAnR0JNj21xX8c/pegcaZF5r4majOLIwNsXHQV7LHhnp6KGltgUb+a6ArkeDnnq1RytoCKenpmLn7BK49V24YZkFZ3v82Yt6nQJAAhiY66DapHEpVMSvUGIYu7QuPDrXh4GyHwTXGy97Pevq6GLTQB7VbVUdKUiqe3nqBub2X53oMAByV7kRnKx/E//d5Uthxf8y7TxN0GdFO9timpDXunH4A/68XFNhnrbLU7bNhy7OVSE1OQ0piCgDg9zl7cGrH+SzlnF1LY/iyfrCytwAAbPrpd5zdcxmtfJrAs1Md+HWdX6hx50Tdrm9+UGZofGb5UqVKye2fNm0a/Pz8cj1WKpVi1KhRaNCgAVxdXXMsFxoaCnt7e7l99vb2CA0NzVOMV65cwdq1a7Psd3R0zHMdn+JQeg0WFZ2OPiPfYsZEa7hVNlB1OJ/FeAuWJsTbvocF6jYxgSAI2PtrJBb6hmHR76U+f2AhGvnTO/x9OB4vX6fh2tFScHf9cC2bdX2NqeOs0cTTWIUR5o0m3A+ZNClWQDPi1YT32sc0Ld7bqy8DAtB2e3cIgoDE8IL9ckeaZ+KWERjXdBqe3wmCvZMtfnmwBGd3X0L/Od/iwaXHmNR2FirULgu/3ePxXZlhSE9Llzs+/E0ERntNQUpSxhfOoUv6ordfd6watalA4/5n/TFcPngDANBpWGuMWT8Y45r5AQDWjAnA+X1XshzTZURblHFzwkC3sUhLTYOVvWWBxpidk5ce47e/LmOtf88sz01Z8rcsUfoxvx/aYqj/djwNeg8HW3P8sagfAi8/RkJSamGEnCt1/0zUpLZSdEISvl68Vfa4T+NaqF2mJGISkzGjW0vcfhmCwRv2wLWkPZb4dEDr2b8gTSpVYcTy+i+uAmPzjK/sN4++x5ZJjzBpb+1CjeHMrovYMW8fFp+ZIR/bnG8hiiL6VBwBAHLv/ZyOKUx5ieFwQCAOBwTKHq+7vRDHt50phOiUo26fDbN6LM71hy8DI31M3zsBc31W4N65h5BIJDCzNi28ABWkbtdXlV69egVzc3PZYwODz3/nGTZsGO7evYuzZ88WZGgwMDBATExMlv2PHz+Gra2tUnXm21D6RYsWwc3NDSYmJihVqhSGDh2KuLg42fMBAQGwtLTE4cOHUblyZZiamqJ169YICQmRlUlLS8OIESNgaWmJYsWKYeLEifDx8UHnzp1lZZydnbFkyRK5c7u7u8tlrz8XCwCsX78epUqVgrGxMbp06YJFixbB0tJSrsy+fftQs2ZNGBoaokyZMvD390daWtoXX6v8IIoivhsehppuBmr7xfxjjLdgaUK8+gYS1GtqCkHI+BmqsrsRQl+r/svHp75qZ4rT+0rCqaTm/m6kCfdDJk2KFdCMeDXlvZZJ0+JNS0zFs78fodqgOrKYjYqpRwKA1IgowtTSBABgbG6EmPA4pCanoXE3T+xfcxQA8PjqU4S/iUS1xlWyHJ6akiZLikokEhiaGEAUxSzljM2MMOfQT/jflK+/OOTU5FRZUhQAHlx8DHvnz3/B6DauIzb4bkVaakYbOTIsKttynYa3xpIzM2BhY57t81/i5oPXeBcR9/mCHxFFwMwkYwieiZE+YuISkZKa/pmjCp4mfCZqclupa52q2H05Y4EP7+oVsP3ibQDA3ddheBcTj9plS6oyvCwyk6IAkBiXpvh8gfngzpkHeB8cIbfP0NgArfs1w6bJv8v2ffzez+6Y7AyY8y2m750IA6P875WX1xgyVapbDpZ2Frjw19Usz+XnZ62yNOGz4VPNejXEg4v/4t65hwAyehRGv8+a0CpW3AorLs2Gd1/Vjb7RxOv7WV8wlN7c3Fxu+1xidPjw4di/fz9OnjyJkiVz/xx1cHBAWFiY3L6wsDA4ODjk6WV17NgR06dPR2pqxv+PIAgICgrCxIkT8dVXX33m6Ozl218ziUSCZcuWwcXFBc+ePcPQoUMxYcIErFq1SlYmISEBCxYswJYtWyCRSPC///0P48aNw9atGb/izZ07F1u3bsWmTZtQuXJlLF26FHv37kXTpoq9QT4Xy7lz5zB48GDMnTsXHTt2xLFjxzBlyhS5Os6cOYPevXtj2bJl8PLywtOnT/H9998DyOhGnJ3k5GS5uReyy2Lnl4WroyAIwJQxVgV2jvzEeAuWpsULALsDIuHZUv1+MWzkYZRl35AJb3HpehKePE/F92PfwdREwLoFdqjtbphNDaqnSfeDJsUKaF68gPq+13Ki7vHGBcdA39wA9zffRNjVYOgY6MC1fy3Y13ZUdWhUQJRp383ssRjT/hyHpPhkmFqZwP+rBTAyM4SOno5c8iDsxVvYlbbJtg5dPV2suDQbdk42eH47CFM6zZV73rZkMfjtmYA9yw7g2Bbl5tTKTZcR7eQSBP1nf4s+03vg5f3X2DhpK0Kfv4WxmRGs7C3g2akOvL6qDwD4c/F+ueGUgkTAoIU+cHC2w4SWM2QJ38IydVhbCAJw/0koVm07jajYRADAlKV/Y/aYjkhMToO5iQF8F+1DWrr69BTMpI6fiZraVnJ3Kg5zY0OcevAMFsaG0NWRIDz2Q4//4MgYFLcs3GHqebF54kM8vhwFABi6NufhqYWpeFl7xEbEoeekrqjZ3A3JiSnY4r8DN07kbVVpPQM9TNo2CrERsfDrOh9SNeil27p/cxz/7XSWHvwF/VmrLHX4bJiweTgEQcDDK0+w8cetWZKepauUQmpyKmb89SNsSxbDs9svsXbcr3LlnF1LY/Lvo7BmTACuHb1d2C8hR+pwfb/Ulwylz3N5UcQPP/yAPXv2IDAwEC4uLp89xsPDA8ePH8eoUaNk+44ePQoPD488nXPhwoX4+uuvYWdnh8TERDRu3BihoaHw8PDArFmzFHsB/8m3xOjHL8rZ2RkzZ87E4MGD5RKjqampWLNmDcqWLQsgI6s8ffp02fPLly+Hr68vunTpAgBYsWIF/vnnn3yPZfny5WjTpg3GjRsHAKhQoQLOnz+P/fv3y47z9/fHjz/+CB8fHwBAmTJlMGPGDEyYMCHHxOjs2bPh7++vcLx5FRcvxZmLiXAqqYd1W2Jw6WBJ2S8a6ojxFixNi/djW1eGI/hlKhbMsv98YTWwep4dAPUbHvYxTbofNClWQPPi/Zimvdc0IV5puoiE0DiYu1ii+tC6iHz0HoGj/kGbrV/D0Fr9PhvoyynavpPoSPDt5K/g/9UC3DnzABVql8X0fRMxuIZi89SlpaZhcM3x0NXTxbDl/dB+UAvsmP8XAMDS3gILT03H4oGr85yIUERP3y4oUc4BE1pkvO65vZfj3etwABlD7Gf+7YsBrqOho6sDXT1dGBjpY4THJNg72WLpuZl49TAYz26/BACMXjsIT24+x/SvF2Tb67UgDfH7A2HhsdDRkWDQNw0xZVgbjJ2zGzoSAX26eMB30V+4+eA1Kpd1wLzxnfG/8ZsR/V/iVB1owmdiJk1oK3Wt64q/rj1AurRw78Mv5TO3EgDg4t5Q7F3wHMPWuak4IkBHVwcOznZ4ef8VNvpuRVl3Z8w9MgUDXMcg6m30Z4+ftd8X5/+6gq0z/yyEaD/P0NgATb7xxAiPyXL7C/qzVlnq8NkwpvE0vHv1Hjq6Oug7swcmBAzD5Paz5cro6EpQo4UbRnhMRvibCPT7uRdGrBqIGd0XAgCcq5bC9H0T4ddlnuxvhjpQh+ubLwphVfphw4Zh27Zt2LdvH8zMzGRzfFpYWMDIKONHtN69e8PR0RGzZ2fcHyNHjkTjxo2xcOFCtGvXDn/88QeuXr2KdevW5emcFhYWOHr0KM6ePYvbt28jLi4ONWvWzLKgkyLybSj9sWPH0Lx5czg6OsLMzAzfffcdwsPDkZDw4Vc4Y2NjWVIUAIoXL463b98CyFi9KiwsDHXr1pU9r6Ojg1q1auV7LI8ePZI7D4Asj2/duoXp06fD1NRUtg0cOBAhISFyr+ljvr6+iI6Olm2vXr1SOPbc3LqXjO4DQ/Ht0FCsmmsLK0udfK0/vzHegqVp8WbasT4CZw/HYc4mRxga5dtHUJGnSfeDJsUKaF68mTTtvaYp8ZrYm0KQCHBqVQ4AYFXRBibFzRD1NFLFkVFBUbR9V87dGcVKWMkWVXp89Snevw5HmWpOSE9Ll5uHz97ZDm+D3udaX1pqGo5sOokW/2ss2xcfFY8Xd4NQr73i7eTP+XpsBzTsUg+T2s5C8n+LamQmRQFg38pDKF7GDmbWpoiNjENCbCKO/ZbRiyrs5TvcO/cIFet8aO/fPn0fleqWh7WDZb7H+jlh4bEAgPR0Kbb/cw3VK2UM7yvvbAcbKxPcfPAaAPDgaSjeRsShgrNdoceYE035TNQURvp68K5WAXv+G0YfnZCENKmIYmYfEriOVuYIiYpVVYifVb+zA/69HIW4SNUP730b9B7p6VKc2Joxl+DTmy8Q+vwtXNxK5+n4GyfvomaLajA2y9r7WBUadfPAy3uvEfTfZ0KmgvysVZa6fDa8e5Xxtys9LR27lxyAq1flLGXeBr3HrZP3EP4mY0qD47+dRuX65WXPh7+JRFRYFNybqUdPaEB9rm9+yOwxquimiNWrVyM6OhpNmjRB8eLFZdv27dtlZYKCguSm0PT09MS2bduwbt06VK9eHbt27cLevXtzXbApOw0bNpSNDv+SpCiQT4nRFy9eoH379qhWrRr+/PNPXLt2DStXrgQApKR8GC6jp6cnd5wgCAr/ciyRSLIckzm3gCKxfE5cXBz8/f1x8+ZN2Xbnzh38+++/MDTMfkiIgYFBlrkY8lP9Woawt9VBs4ZGaNFI/X6F/RTjLViaFi8A7NwQiRN/x2LelpIwNdeM5JKm0KT7QZNiBTQvXkDz3muaFK+BpSHsapVA6KWML09xb2IQHxILc2dL1QZGBUbR9t3bV+GwLm6F0pUyplcoUdYBxcs64NWjNziz8yLaD24JAKhQuyxsHK1x+9T9LHXYlbaRzbknCAIadfOQ602TmpwG/68WoFhxa4xZPzjferF/Nbo9mvZoiImtZshWjJboSGBpZyEr07BrPUSGRSP2vzk9T/5xDnVauwMAzKxMUbFuOTy7HSQrf2zLafw2YxfmHZ8Gh0JMPBoa6MHU+MOcaC0bVMLjFxlzmoWFx6KYlSmcHK0BACXtLVHS3gJBb/I+H2FB0qTPRE3RpnoFPAp5h+fvPvyIdeT2Y3xTvxoAwLWkPewsTHH16eucqih0CTFpiHr7YRqPW8few8RSFyaWqp/bNSY8FjeP30Ft7+oAAAdnOzi42CHoQXCejv/95904u+cS5h6dqhaL8bTu1wyHfjmeZX9BfdYqS10+GwyNDWBi8aFN3LRnQzy58TxLuVM7LqBinbKyBHjdtjXx7NaHv2WxkXGY2GoGGnSqq9L5WzOpy/XNV0rML6oIURSz3fr06SMrExgYiICAALnjunXrhkePHiE5ORl3795F27ZtFTrv8ePH0b59e5QtWxZly5ZF+/btcezYMcVfwH/y5VP12rVrkEqlWLhwISSSjFzrjh07FKrDwsIC9vb2uHLlCho1agQASE9Px/Xr1+Hu7i4rZ2trK5dtjomJwfPnH96EeYmlYsWKuHJFflXNTx/XrFkTjx49Qrly5RR6HQVJR0fAk0vOqg4jzxhvwdK0eN+FpGLNz+9QvLQexvbKaHTq6QtYuSdvvyxT7jTpftCkWAHNi1fT3muaFi8A1J7QEFdmn8btVZcBiYDaE7xgbGui6rBITUS9jcaSQWvx0/YxkEqlkEgkWPHDRrx79R7rf/wNP/76AwIeLUNqShrmfLdMNp+dj/83CH8Tgf1rj6JMNSf0nZmxwrogEfDk+nOsHPmL3HnS09Ix+9ulGLN+MHx/G4E5vZdD+gVzZNo4WmPwQh+8eRqKBSf8AAApyamY0Nwfs/b7Qs9AD1KpFDHvYzH1o/lON/puxfhfhqHDEG8AwPZ5e/HoyhO5us/8eRHJiSmYc/gnTOk4B68evVE6zuxMHNgSnjXKwNrSBEsmfY2EpBSMnLULs8d0hEQigSAAwWHRmL7yIAAgMjoBc9cdwaxRHSAVRUgEAQt/OS7rYapKmviZqAm61nXFrkt35PYtPnAWs3u2xoEJfZCaLsWPvx9UqxXpE2PTsHH0faQmSSFIAFMrPQxe7VboybmRa75HvbY1Ye1gidmHJiMhNgl9KvyAJUPWYeyGIRgw53+QSqVYMnidrGdgTsd8bM/Sf5AUn4z5x6fBt/WsHBduy++4x6wfjAt/XcWFvzPmUC5ZoQTKujtjcrvz2daT35+1ylKnzwZLewtM2zUOEh0JBEFAyLMwzPNZAQBy1/fdq/f4ffYeLDk3E6JUxPvgCCwZtFaursS4JPi2mQW/3eMxcN53WD9hS6G/HkC9ri/lbtWqVRg5ciS+/vprjBw5EgBw8eJFtG3bFosXL8awYcMUrlMQFeiy2adPH7x8+RKLFy+W25/ZdXbJkiXo0KEDzp07B19fXwQHByMyMhKWlpYICAjAqFGjEBUVJTtu79696NKli6wH6KxZs7B48WJs3LgRlSpVwvLly7FlyxY0a9YMe/bsAZAxnCkgIAA7duyApaUlpk6dimPHjmHs2LHw8/PDrVu34O7unmss586dQ6NGjTB//nx06NABJ06cwOTJk5Geno7IyIxfEQ8fPoz27dvjp59+wtdffw2JRIJbt27h7t27mDlzZp6uV0xMDCwsLBD5uAzMzTS7GzYVTYGJmnPfNjHKnwbK4PFv8c/xeIS+TUcxKx2YmUrw+IITAPWeN4s0mya91zTRutDGny+kJlLjU7C75WZER0fn+8gTyh+Z7bsm6ARdQe/zB5DC4rrVU3UICpk1Z72qQ1DIl7aZCrOtVG3h0Hypp7AM7b9P1SEoZE8VW1WHoNV8n6rPYkJ5MbtsNVWHoBBNub7xsenoWP1pobXtMtspVQf/DB0DxRbAS09Owr01k9S6HVqyZEn8+OOPGD58uNz+lStX4ueff0ZwcN56rn9M4W9igYGBqFGjhty2ZcsWLFq0CHPnzoWrqyu2bt0qm1hVERMnTkTPnj3Ru3dveHh4wNTUFN7e3nJD1319fdG4cWO0b98e7dq1Q+fOneXmLa1evfpnY2nQoAHWrFmDRYsWoXr16jh06BBGjx4tdx5vb2/s378fR44cQZ06dVC/fn0sXrwYTk5OCr8uItIca+bbIei6C1Jel0PIHRdZQx8Ayrrow9SYCSwiIiIquthWIiJSf4Uxx6gqREVFoXXr1ln2t2rVCtHRn1/8LTsK9RgtbFKpFJUrV0b37t0xY8aMAj3XwIED8fDhQ5w5cybf6mSPUdJ0mtSLLb96jBKpgia91zQRe4xSfmKP0YLHHqMFS5PaTOwxWrDYY7RgaUqPxkzsMVowVNVjtMpQ5XqM3l+l3j1Ge/XqhRo1amD8+PFy+xcsWICrV6/ijz/+ULhO1c/c/JGXL1/iyJEjaNy4MZKTk7FixQo8f/4cvXr1yvdzLViwAC1btoSJiQkOHjyIzZs3Y9WqVfl+HiIiIiIiIiIiosIi/rcpeoy6q1KlCmbNmoXAwEB4eHgAyJhj9Ny5cxg7diyWLVsmKztixIg81alWiVGJRIKAgACMGzcOoijC1dUVx44dQ+XKlfP9XJcvX8a8efMQGxuLMmXKYNmyZRgwYEC+n4eIiIiIiIiIiKjQKLPSvAYMpd+4cSOsrKxw//593L9/X7bf0tISGzdulD0WBEEzE6OlSpXCuXPnCuVcn65UT0REREREREREpPG0NDH6/PnzfK+Tk5oRERERERERERGRxhBFEfmxbBITo0RERERERERERFpCW1elBzKG07u6usLQ0BCGhoZwdXXFhg0blK5PrYbSExERERERERER0RfQ0qH0U6dOxaJFi/DDDz/IFl+6cOECRo8ejaCgIEyfPl3hOpkYJSIiIiIiIiIi0hLK9ADVhB6jq1evxvr169GzZ0/Zvo4dO6JatWr44YcfmBglIiIiIiIiIiIq0rS0x2hqaipq166dZX+tWrWQlpamVJ2cY5SIiIiIiIiIiEhbCEpuau67777D6tWrs+xft24dvv32W6XqZI9RIiIiIiIiIiIiUnsbN27EkSNHUL9+fQDApUuXEBQUhN69e2PMmDGycosWLcpTfUyMEhERERERERERaQltnWP07t27qFmzJgDg6dOnAAAbGxvY2Njg7t27snKCkPcXw8QoERERERERERGRttDSOUZPnjyZ73UyMUpERERERERERKQttDQxWhCYGCUiIiIiIiIiItIS2jSUvmvXrggICIC5uTm6du2aa9ndu3crXD8To0RERERERERERNpCi3qMWlhYyOYMtbCwyPf6mRglIiIiIiIiIiIitbNp06Zs/51fmBglIiIiIiIiIiLSEto0lL6gMTFKRERERERERESkLbRoKH2NGjVkQ+k/5/r16wrXz8QoERERERERERGRNlHTRKeiOnfuXKD1MzFKRERERERERESkJbRpKP20adMKtH5JgdZOREREREREREREhUdQclNzV65cwaVLl7Lsv3TpEq5evapUnUyMEhERERERERERkVobNmwYXr16lWV/cHAwhg0bplSdTIwSERERERERERGRWrt//z5q1qyZZX+NGjVw//59pepkYpSIiIiIiIiIiEhLZM4xquim7gwMDBAWFpZlf0hICHR1lVtGiYlRIiIiIiIiIiIibaGlc4y2atUKvr6+iI6Olu2LiorCpEmT0LJlS6Xq5Kr0RERERERERERE2kKZRKcGJEYXLFiARo0awcnJCTVq1AAA3Lx5E/b29tiyZYtSdTIxSkREREREREREpC2UGRqvAYlRR0dH3L59G1u3bsWtW7dgZGSEvn37omfPntDT01OqTiZGiYiIiIiIiIiItIWW9hgFABMTE3z//ff5Vh/nGCUiIiIiIiIiIqIihz1GiYiIiIiIiIiItIQyq8xrwqr0BYGJUSIiIiIiIiIiIm2hxUPp8xsTo0RERERERERERNpCEDM2RY8pgpgYJSIiIiIiIiIi0hIcSp93XHyJiIiIiIiIiIhIWwhKbhrMxcUF/fv3x5s3bxQ6jolRIiIiIiIiIiIibVEEE6M+Pj5IT09HgwYNFDqOQ+mJiIiIiIiIiIhIY/n5+Sl1HHuMEhERERERERERaYnMOUYV3RR1+vRpdOjQASVKlIAgCNi7d2+u5QMDAyEIQpYtNDRUuReaD9hjlIiIiIiIiIiISFsoMzReicRofHw8qlevjn79+qFr1655Pu7Ro0cwNzeXPbazs/vsMVKpFKdOncKZM2fw8uVLJCQkwNbWFjVq1ECLFi1QqlQpxV8AmBglIiIiIiIiIiLSHl+QGI2JiZHbbWBgAAMDg2wPadOmDdq0aaNweHZ2drC0tMxT2cTERCxcuBCrV69GREQE3N3dUaJECRgZGeHJkyfYu3cvBg4ciFatWmHq1KmoX7++QrEwMVoIziQKMNHVjFkLHiYXV3UICqlkEKLqEBTSxEiq6hCIlBKYqBmfYZk07b22I6KuqkNQSDWTV6oOQSHfO5xSdQh5Fh+bjt2qDoLyRGJoAImgr+ow8uT1iJqqDkEhJeadV3UICpm9s5qqQ1DIbFUHoIDi0Kx74c+rrVQdgkIkuKHqELTa7LKa9dmgaTTl+qaJqQCeFv6JBTFjU/QYIEvPy2nTpik9f2dO3N3dkZycDFdXV/j5+eW6YFKFChXg4eGB9evXo2XLltDT08tS5uXLl9i2bRt69OiByZMnY+DAgXmOhYlRIiIiIiIiIiIiLSFC8TlDM9Oor169khvmnlNvUWUUL14ca9asQe3atZGcnIwNGzagSZMmuHTpEmrWzP6H3CNHjqBy5cq51uvk5ARfX1+MGzcOQUFBCsXExCgRERERERERERHB3NxcLjGanypWrIiKFSvKHnt6euLp06dYvHgxtmzZku0xHydFU1NTs+0xCgDv37+HjY0NypYtq1BMmjU2koiIiIiIiIiIiLRC3bp18eTJkzyV7dGjB0Qx6xQBYWFhaNKkiVLnZ2KUiIiIiIiIiIhIWwhKbipw8+ZNFC+et/VugoKCMGDAALl9oaGhaNKkCSpVqqTU+TmUnoiIiIiIiIiISEuIghJzjCqRGI2Li5Pr7fn8+XPcvHkT1tbWKF26NHx9fREcHIxff/0VALBkyRK4uLigatWqSEpKwoYNG3DixAkcOXIkT+f7559/0KhRI4wZMwaLFi3Cmzdv0LRpU1SvXh1//PGH4i8ATIwSERERERERERFpjy9YlV4RV69eRdOmTWWPx4wZAwDw8fFBQEAAQkJC5BZDSklJwdixYxEcHAxjY2NUq1YNx44dk6sjN7a2tjhy5AgaNmwIANi/fz9q1qyJrVu3QiJRblA8E6NERERERERERETaQpmh8Ur0GG3SpEm2c35mCggIkHs8YcIETJgwQfETfaRUqVI4evQovLy80LJlS2zZsgWCoPw8AEyMEhERERERERERaYtCSowWBisrq2wTnwkJCfj7779RrFgx2b6IiAiF62dilIiIiIiIiIiIiNTOkiVLCrR+JkaJiIiIiIiIiIi0hRb1GPXx8SnQ+pkYJSIiIiIiIiIi0haFtPiSKkilUjx58gRv376FVCqVe65Ro0YK18fEKBERERERERERkbbQoh6jH7t48SJ69eqFly9fZln0SRAEpKenK1wnE6NERERERERERERaQhQyNkWPUXeDBw9G7dq1ceDAARQvXvyLVqPPxMQoERERERERERGRttDSofT//vsvdu3ahXLlyuVbnZJ8q4mIiIiIiIiIiIioANSrVw9PnjzJ1zrZY5SIiIiIiIiIiEhbaOkcoz/88APGjh2L0NBQuLm5QU9PT+75atWqKVwnE6NERERERERERERaQhAyNkWPUXdfffUVAKBfv36yfYIgQBRFLr5ERERERERERERU5GnpHKPPnz/P9zqZGCUiIiIiIiIiItIWWjqU3snJKd/rZGKUiIiIiIiIiIhIW2hpYjTT/fv3ERQUhJSUFLn9HTt2VLguJkaJiIiIiIiIiIhIrT179gxdunTBnTt3ZHOLAhnzjAJQao5RSb5GSERERERERERERCokKrmpt5EjR8LFxQVv376FsbEx7t27h9OnT6N27doIDAxUqk72GCUiIiIiIiIiItIWWjqU/sKFCzhx4gRsbGwgkUggkUjQsGFDzJ49GyNGjMCNGzcUrpM9RomIiIiIiIiIiLSEIIhKbeouPT0dZmZmAAAbGxu8efMGQMaiTI8ePVKqTvYYJSIiIiIiIiIi0iYa0ANUUa6urrh16xZcXFxQr149zJs3D/r6+li3bh3KlCmjVJ1MjBIREREREREREWkJZXqAakKP0Z9++gnx8fEAgOnTp6N9+/bw8vJCsWLFsH37dqXqZGKUiIiIiIiIiIhIW2jpHKPe3t6yf5crVw4PHz5EREQErKysZCvTK4pzjBIREREREREREZHaSk1Nha6uLu7evSu339raWumkKMAeo0RERERERERERFpDEDI2RY9RZ3p6eihdujTS09PztV72GCUiIiIiIiIiItIWgqjcpuYmT56MSZMmISIiIt/qZI9RIiIiIiIiIiIiLaGtiy+tWLECT548QYkSJeDk5AQTExO5569fv65wnUyMEhERERERERERaQltHEoPAJ07d873OpkYJSIiIiIiIiIi0hZK9BjVhKH006ZNy/c6OccoERERERERERERFTnsMUpERERERERERKQthP82RY8pgpgYJSIiIiIiIiIi0hLauvhSQWBilIiIiIiIiIiISEuww2jecY5RIiIiIiIiIiIiLZHZY1TRTd1Nnz4dCQkJWfYnJiZi+vTpStXJxCgREREREREREZGWEARlkqOqjvrz/P39ERcXl2V/QkIC/P39laqTQ+mJiIiIiIiIiIi0REZiVPFj1J0oihCyCfTWrVuwtrZWqk4mRomIiIiIiIiIiEgtWVlZQRAECIKAChUqyCVH09PTERcXh8GDBytVt8YlRgMDA9G0aVNERkbC0tJS1eEUupRkKWaMCMHLf1NgYCjAspguRs2wg6OzvqpDy9Hy/rcR8z4FggQwNNFBt0nlUKqKmarDykITr60m4fWlj/F+KFhbO+yBjp4EuoYZf+bd+1RFuVbOqg0qF5rydwLgvUvKq+NdHT7TvoZEIkBHRwc7lxzAsa1nMXbtQJRzd4YoikhLTccvU7bjZuB9AEDF2mUwZMF30DPQhb6BHo5sOYOdiw+oJH49HR1MaNcIDSo4ITktHY9C3uHH7Ydkz3euVQWzunnjh1//won7TwssDjNrU8w/Nk322MBYH8XL2KOb/QDM+mcS9A30AAASXQlcXEvj++pj8fxOUJZ6WvZujG5jO0KaLoUoitj00++4fPAGAOCodCc6W/kgPjrrHGbK0jPQw+TfR8GpSkkkJ6Yg6m0Mlg1djzdPQ7HghB/snGyR8N/5jvwaiN1LPvw/fzetG5r1bIjU5DREv4/B+OYZQwW3PFsJvy7z8fTWi3yLU9Nire3tjr4zekBXXxfJCclYMngdnt1+iXEbh6Jqg4pITkxBUlwSVo0OwOOr2d+XU3aMRVXPCihWwlru/93eyRZrbsxHF+s++Rrzx/T0dDBlamc4OdkgOSUNUZEJWLL4EN68iQQA9PbxQvPmVZCSmo6Y6ESMHbMVAFCxUnEM/6EV9PR0oK+vi8OHbmP7HxcLLM5MOV1vuTKtqmPAnP/JHlvamSMiNApDa08snGuay/3b07cLWvZuAsfyDvD/agHO77vyIU5bc0zY/ANKlLVHSnIqlg/bgDtnHgAouPv3c/Gq2/tN0+LVpFgLgkQQIVFwzlBRjecYXbJkCURRRL9+/eDv7w8LCwvZc/r6+nB2doaHh4dSdSudGA0NDcWsWbNw4MABBAcHw87ODu7u7hg1ahSaN2+ubLVymjRpAnd3dyxZskS2z9PTEyEhIXIXoTAEBARg1KhRiIqKKtTzZqd9DwvUbWICQRCw99dILPQNw6LfS6k6rBz1X1wFxuYZt9rNo++xZdIjTNpbW8VRZU/Tru3HoqLT0WfkW8yYaA23ygaqDidbvL6FRxPi1dT7QROuLQC0mO0Fm4rKDScpbJr0dwLQ3HuXVGvixsEY3/pnPL/7CvalbbDh5lyc23cVayZslSViylZ3wtwDP6JbqaEQRREjV/TDrzP+xMUDN2BmZYINN+bh0sEbCHr4ptDjH9OmIUSIaLsgAABgY2ose66ElTm+ruuGmy8LPq7YiDgMrjle9vjrsR1QrVEVxEbGYYTHJNl+r6/q47up3bJNippZmWLYsn7oW3EkIsOiULVBJUz7cxy6Owwo0Nj/WX9MlnztNKw1xqwfjHHN/AAAa8YEyCVpMnUZ0RZl3Jww0G0s0lLTYGVvWaAxalKsppYm8P1tBMY0noqX91/DtWEl/PjbCHxfbSzO7b2MRd+vgTRdinrtamLKjjH4rsywbOvZv/YIlg9bj51hGws03pzs338Tly9lJG07da6FsePbYuzorej6VR2UKWOH/v3WIy1NCisrE9kxY8a2RcCm07hw/l+YmRli0+ZBuHjhCV6+fF9gceZ2vT929cgtXD1yS/Z4xl8/4lbg3QKLKzs53b/Xj93ByT/OYdzGoVmO6T/nWzy49BiT2s5Chdpl4bd7PL4rMwzpaekqixdQn/ebpsarSbHmN2UWU1LnxZd8fHwAAC4uLmjQoAF0dfOvn6dSiy+9ePECtWrVwokTJzB//nzcuXMHhw4dQtOmTTFsWPZ/cPKLvr4+HBwcsp1ToCjQN5CgXlNT2euv7G6E0NepKo4qd5lfdgEgMS4NUNP/Ok28tplEUcR3w8NQ081AbRM1vL6FRxPi1dT7QROurSbSlL8TgObeu6R6oijCxCIjmWhsboSYiDikJqfK9Uo0MTfKcozpf8cYGhsgNTUNsZHxhRf0f4z0dNG1dlUsPXxetu99XEbcggBM79oSP/91EinpBZ9A+FSbfs1w6JcTWfa37tcMB385nu0xgiRjKJ6xmSEAwNTSGO9fh2dbdsCcbzF970QYGH1Zr/DU5FTZl3MAeHDxMeydbT97XLdxHbHBdyvSUtMAAJFhUdmW6zS8NZacmQELG/MvilOTYi1R1h4x4bF4ef81AODu2YewK22DcjVccOHvq5CmS/+L/1/YOFpDopP9V98bx+8g6l1MrufS1dPFxF9/wMg130Miyb/1i1NT02VJUQB4cD8YDg4ZHYC6f1MPG9afRFpaxuuI/Oi9L4oiTE0z2iGGhnpIS0tHTExivsWVndyud06KFbdCjeZuOLbldJbnCuya5nL/PrryBKHP32Z7XONunti/5igA4PHVpwh/E4lqjatkKZef77XPxZsbVXw2aFq8mhRrQdDWVekbN26Mly9f4qeffkLPnj3x9m3Ge/rgwYO4d++eUnUq9Qk0dOhQCIKAy5cv46uvvkKFChVQtWpVjBkzBhcvZnThDwoKQqdOnWBqagpzc3N0794dYWFhsjr8/Pzg7u6OLVu2wNnZGRYWFujRowdiY2MBAH369MGpU6ewdOlS2TwCL168QGBgIARBkPXcDAgIgKWlJQ4fPozKlSvD1NQUrVu3RkhIiFzMGzZsQOXKlWFoaIhKlSph1apVsudevHgBQRCwe/duNG3aFMbGxqhevTouXLgAIGP4ft++fREdHS2Lxc/PL8t1SU5ORkxMjNxW0HYHRMKzpWmBn+dLbZ74EJObXsT+ZS/gM7eSqsPJE025tgCwcHUUBAGYMsZK1aHkGa9vwdG0eAHNuR806dqenHYeO7/Zj8DpF5AYmaTqcD5LE/9OAJpz75Ly8qt993PvlZj6+0j8+nAxFh6bggUD1yEtNSOR2G96d2y6uwBTfx+JGb2WQRQzvpgsHLQevad+jS2PFmPj7fkImLYDkWHR+fba8qpUMUtEJybh+6Z1sX14L/w6qDvqlc3oJe3TsBZuvHyD+8HZJxsKUhWPCjC1MsXF/dfk9tuWLIZqjavg+G9nsj0uJjwWS4esw6pr8/Db81UYu3Eo5vddKVdGz0APk7aNgpGpIfy6zkdyYkq+xt5lRDtc+Ouq7HH/2d9i3a2FmPz7aDi42AEAjM2MYGVvAc9OdbDsws9YduFnNO7uKVePIBEwaKEP3Ju6YULLGYh+n//fP9Q11tf/hsK8mBmqeFQAAHh0qA0Tc2M4fJL46DKyLS7/c0OWKFWUiYUxfj44GUEPXmPp4HWQSpWrJy+6flUH58/9C2NjfVhZmcCzQXmsWOWDFat80KRpZVm5+XP3o2/fxtj2xzBs3jIYGzcEyiVOC0Jer/fHWvVpgsv/XM+SeC7Ma/rp/ZsdM2tT6OjpyCXAwl68hV1pG9njwnivZRevurzftCFeTYo1P2QuvqTopu5OnToFNzc3XLp0Cbt375atUH/r1i1MmzbtM0dnT+G+pxERETh06BBmzZoFExOTLM9bWlpCKpXKkqKnTp1CWloahg0bhm+++QaBgYGysk+fPsXevXuxf/9+REZGonv37pgzZw5mzZqFpUuX4vHjx3B1dcX06dMBALa2tnjx4kWWcyYkJGDBggXYsmULJBIJ/ve//2HcuHHYujVjDpatW7di6tSpWLFiBWrUqIEbN25g4MCBMDExkXXHBYDJkydjwYIFKF++PCZPnoyePXviyZMn8PT0xJIlSzB16lQ8evQIAGBqmvVL0OzZs+Hv76/oJVXa1pXhCH6ZigWz7AvtnMrK/JJ7cW8o9i54jmHr3FQcUe404drGxUtx5mIinErqYd2WGFw6WFJjelLz+uY/TYv3Y+p+P2jite24vhXMHEyQnibFlVU3cXLaebRd1kzVYeVK0/5OAOp/71L+yI/2nURHgp4TO2F6z6W4e+4RKtRygd/OMRhcxxcx4XH4ZeoO/DJ1B2o0rYr+s3pgTLPpSEtNxzdjO2DT1B04ueMCHJxtseDIZDy+/rzQh9LrSCRwtLLA07fhWHzoLCqVsMWG/l9h1G9/o6VrOfis3Vmo8WRq3b85jm45lSXh1apPE1zafw0x4bHZHmdsbowuI9rhh3q+CHoYjPrta8Fv93j0rzJa1kNo1n5fnP/rCrbO/DPf4+7p2wUlyjlgQouM+2pu7+V491+P1U7DWmPm374Y4DoaOro60NXThYGRPkZ4TIK9ky2WnpuJVw+DZfM6jl47CE9uPsf0rxfIEupFJdaEmARM77YQ/X/+Foamhnhw8TFe3HuF9LQP90Pzb73QuJsnxjSeqtQ5dPV1seTsTGyftzfbXo/5qde3nnB0tMK4sdugr68LXV0dGBjoYfjQzbC3t8CyFb0RFBSOZ0/fomcvT2zYcBInjt9H8eKWWLTkf3j8KLRAh9Ln5Xp/yrtvM6wa+YvcvsK8pp/ev1+ioN9rgHq/3zQ9Xk2KNb9o2xyjmX788UfMnDkTY8aMgZnZhzUJmjVrhhUrVihVp8I9Rp88eQJRFFGpUs69OY4fP447d+5g27ZtqFWrFurVq4dff/0Vp06dwpUrH+ZwkEqlCAgIgKurK7y8vPDdd9/h+PGMIS8WFhbQ19eHsbExHBwc4ODgAB0dnWzPl5qaijVr1qB27dqoWbMmhg8fLqsHAKZNm4aFCxeia9eucHFxQdeuXTF69GisXbtWrp5x48ahXbt2qFChAvz9/fHy5Us8efIE+vr6sLCwgCAIsliyS4z6+voiOjpatr169Uqha6uIHesjcPZwHOZscoShUf4NPSho9Ts74N/LUYiLVN9hh5pybW/dS0b3gaH4dmgoVs21hZVl9u8PdcPrWzA0Ld5MmnA/aOK1NXPI+OFSR1cCt16VEHqz8HtyKUsT/k4AmnHvUv7Ij/Zd2epOKFbcEnfPZfzA/vjac7wPjkC56s5y5W6cvAdjU0M4u5aCeTFTeHashZM7MkYwhb54hweXn6Lqf721ClNIVAzSpVLsv/EQAPDwzTsER0SjQnFbOFpZ4J/xfXBkYj9UL1Ucfl1b4Jt61Qo8JkMTQzTu5oHD2Qyj9+7TNNvh9ZlqtayG+Kh4BD0MBgBc3H8NxubGsHf60Dvsxsm7qNmiGozNjHKqRilfj+2Ahl3qYVLbWbJeqO8+Gsa/b+UhFC9jBzNrU8RGxiEhNhHHfstIHoW9fId75x6hYp2ysvK3T99HpbrlYe1gma9xakqstwLvYWzTaRhWZyLWjt2MYiWsZEO9G3f3xHdTu2FiqxmIeqtcT+v01HTcPfcQHu1rQ0e34P7+d+teDw29KuLHiduRnJyG2NgkJCQk49jRjLk5w8Kice/ua1SqWBzm5kZo0LACThzPWKQtJCQKD+4Ho6pryQKLL1Nu1/tT1RpXgb6hHq4eviW3v7CuaXb3b05iI+KQnpYuN5ekvbMd3gZ9SDQX5Hstp3jV7f2mqfFqUqya6PTp0+jQoQNKlCiRMf/+3r2fPSYwMBA1a9aEgYEBypUrh4CAgDyf786dO+jSpUuW/XZ2dnj/XrkfhxRuyeclI/7gwQOUKlUKpUp9WIigSpUqsLS0xIMHD2T7nJ2d5TK8xYsXl80PoAhjY2OULfvhRv24nvj4eDx9+hT9+/eHqampbJs5cyaePpVfmbBatWpydQBQKB4DAwOYm5vLbQVh54ZInPg7FvO2lISpuXp/QU+ISUPU22TZ41vH3sPEUhcmlvk3UW5+0qRrW7+WIextddCsoRFaNDL+/AFqgNe34GhavIDm3A+adm1TE9OQHPvhC8DTQy9QTI0XYdK0vxOA5ty7lD/yo3337nU4rB0sUapiCQBAiTJ2KOFih9f/hqBEGTtZuYq1y8DS1hyhz98iLjIeyfHJqP7fHHfmxUxRqU4ZvLiXfRKiIEUlJOHik1doUMEJAOBoZQ5Hawscu/svmvy8Dq3m/oJWc3/BrVch8Nt9DNsv3S7wmJp844lnt17i1SP53rM1mrlCR1cH147mHEPIszCUcXeWJUEq168AHV0J3r768EX595934+yeS5h7dCrMrPNnuoyvRrdH0x4NMbHVDNncshIdCSztPiwq27BrPUSGRSM2ImNo4Mk/zqFOa3cAGYtGVaxbDs9uf1hQ6tiW0/htxi7MOz4NDs4f7qWiEuvHiYlvp3yNmyfu4s3TUDTq5oG+M3pgQsvpePdK+V6Uoihi6eB1ePs6HP57JkDf8Mvmms3O193qolnzKpgw7nfEx3/4e3jixH3UqVsGAGBmZohKlUrg6bO3iItLQlJSKtxrZLwfzc2NUKlyCbx4/i7fY/tUTtc7O236NceRzYFZhskXxjXN7v79nDM7L6L94JYAgAq1y8LG0Rq3T92XPV9Q77Wc4lXH95smxqtJsea3wppjND4+HtWrV8fKlSs/XxjA8+fP0a5dOzRt2hQ3b97EqFGjMGDAABw+fDhPx1taWmaZOhMAbty4AUdHR4Viz6Twt47y5ctDEAQ8fPhQqRN+TE9PT+6xIAhKzS+SXT2ZCdzM+QbWr1+PevXqyZX7tAfqx/VkDpMsyPlOlPEuJBVrfn6H4qX1MLZXRsNYT1/Ayj2lVRxZ9hJj07Bx9H2kJkkhSABTKz0MXu2mlsNQNe3a6ugIeHLJWdVh5Bmvb8HStHg16X7QtGubGJ6IIxNOQ5SKgAiYOZqimb/n5w9UEU36OwFo1r1L6iPqbQyWDv8Fk7cMhygVIUgErBzzK6Lfx2L2/okwMTdGeno6kuKTMePb5YiLyvjyNuu7FRj4cw/o6OhAR08He1YcxoPLT1TyGqbvPY4ZX7XEmDZeEEUR/nuO4W1M4S8Elal1v2Y4uOFYNvub43DAySydOdoPaoliJayxedp2PLnxHL//vBvzj09DWmoa0tOkmPnNYqQmy/dU37P0HyTFJ2P+8WnwbT0rxwU48sLG0RqDF/rgzdNQLDjhBwBISU7FhOb+mLXfF3oGepBKpYh5H4upnebKjtvouxXjfxmGDkO8AQDb5+3Foyvy98CZPy8iOTEFcw7/hCkd52RJFmtzrD7Tv4Frw8rQ0dXBgwuPsXDAagCA728jEBEahel7J8rKjm/hj9iIOLl7AQBm/u2LMtUzkowb7i5G8L8hslWrM60duxk+07/BrAO+mNJxLpLi82fubhsbMwwZ2gJvgiOxcPG3AIDU1DQMH7oZG9cHYvyEdujYqRYA4I8/LuDRw4xkwAz/PRg0uBl0dCTQ1dHB7j+v4P794HyJKTc5XW8f/28Q/iYC+9dmLF5kbG6MBl3rZlmx/mMFdk1zuH9HeExCr8ld0X5QK1jYmmOMaykMX94fQ2pOQPT7GKz/8Tf8+OsPCHi0DKkpaZjz3bIsK9Ln9/2bW7zq+H7TtHg1KdaCIIEICRQcSq9geQBo06YN2rRpk+fya9asgYuLCxYuXAgAqFy5Ms6ePYvFixfD29v7s8f36NEDEydOxM6dO2U5xHPnzmHcuHHo3bu3wvEDgCAqMSlCmzZtcOfOHTx69CjLPKNRUVG4cuUK2rRpg+fPn8t6jd6/fx9Vq1bFlStXULt2bfj5+WHv3r24efOm7NglS5ZgyZIlsnlEW7VqhYoVK2L58uWyMoGBgWjatCkiIyNhaWmJgIAAjBo1SrYYEwDs3bsXXbp0kTWIHB0dMXjwYEyZMiXb1/PixQu4uLjgxo0bcHd3l70OKysrnDx5Ek2aNMG2bdswaNAg2eJQeRETEwMLCwv8dassTMw0o0fJw+Tiqg5BIZUMsv5SoM6aGKlXov1zAhM1Z3iopl1bTaNJ9wKgeffD0OD6qg5BIdVMCm6qmIKgSX8r4mPT0bH6U0RHRxfYyBP6Mpntu2aG3aEr5H9Pp4LwekRNVYegkBLzzqs6BCKlSBvXUHUICpGcuvH5QkT0RdLEVARiX6G17TLbKTV3jYGOiYFCx6bHJ+P614vw6tUruVgNDAxgYPD5ugRBwJ49e9C5c+ccyzRq1Ag1a9bEkiVLZPs2bdqEUaNGITr689OepKSkYNiwYQgICEB6ejp0dXWRnp6OXr16ISAgIMcpOHOj1Di1lStXokGDBqhbty6mT5+OatWqIS0tDUePHsXq1atx//59uLm54dtvv8WSJUuQlpaGoUOHonHjxqhdu3aez+Ps7IxLly7hxYsXMDU1hbW1ckMB/f39MWLECFhYWKB169ZITk7G1atXERkZiTFjxuQ5lri4OBw/fhzVq1eHsbExjI3Vf0glEREREREREREVHYISiy9J/yv/8bSYQMa6PX5+fvkSV2hoKOzt5Rcutbe3R0xMDBITE2FklPvc3vr6+li/fj2mTJmCu3fvIi4uDjVq1ED58uWVjkmpxGiZMmVw/fp1zJo1C2PHjkVISAhsbW1Rq1YtrF69GoIgYN++ffjhhx/QqFEjSCQStG7dWq7nZ16MGzcOPj4+qFKlChITE/H8+XNlwsWAAQNgbGyM+fPnY/z48TAxMYGbmxtGjRqV5zo8PT0xePBgfPPNNwgPD8/XG4OIiIiIiIiIiCg/KDNnaGb57HqMqpvSpUujdOn8mcpKqaH0lDccSl/wNGl4JKB5w3s1afi0pl1bTaNJ9wKgefcDh9IXLE36W8Gh9OqPQ+kLHofSk6biUHoi+pSqhtLX3TMSugoOpU+LT8blLkuVjrUwhtLnNOpbEAQYGhqiXLly6NSpk0IjztV3yVciIiIiIiIiIiLSCh4eHvjnn3/k9h09ehQeHh55Ov7GjRu4fv060tPTUbFiRQDA48ePoaOjg0qVKmHVqlUYO3Yszp49iypVquSpTs3qAkREREREREREREQ5yhxKr+imqLi4ONy8eVO2sPrz589x8+ZNBAUFAQB8fX3lVosfPHgwnj17hgkTJuDhw4dYtWoVduzYgdGjR+fpfJ06dUKLFi3w5s0bXLt2DdeuXcPr16/RsmVL9OzZE8HBwWjUqFGe6wOYGCUiIiIiIiIiItIakv8WX1J0U9TVq1dRo0YN1KiRMZXImDFjUKNGDUydOhUAEBISIkuSAoCLiwsOHDiAo0ePonr16li4cCE2bNgAb2/vPJ1v/vz5mDFjhtxQfwsLC/j5+WHevHkwNjbG1KlTce3atTy/Bg6lJyIiIiIiIiIi0hISiJBAsUSnouUBoEmTJsht6aKAgIBsj7lxQ7k5jqOjo/H27dssw+TfvXuHmJgYAIClpSVSUlLyXCd7jBIREREREREREWmJwhpKX9g6deqEfv36Yc+ePXj9+jVev36NPXv2oH///rJFny5fvowKFSrkuU72GCUiIiIiIiIiItISygyNV2YofWFbu3YtRo8ejR49eiAtLQ0AoKurCx8fHyxevBgAUKlSJWzYsCHPdTIxSkRERERERERERGorPT0d169fx7x587B48WI8e/YMAFCmTBmYmprKyrm7uytULxOjREREREREREREWkIbe4zq6OigVatWePDgAVxcXFCtWrV8qZdzjBIREREREREREWmJwlqVvrC5urrKeormFyZGiYiIiIiIiIiItIS2JkZnzpyJcePGYf/+/QgJCUFMTIzcpgwOpSciIiIiIiIiItISAgAJFEt0CgUTSr5q27YtAKBjx44QhA8Ri6IIQRCQnp6ucJ1MjBIREREREREREWkJbZxjFABOnjyZ73UyMUpERERERERERKQltDUx2rhx43yvk4lRIiIiIiIiIiIi0ggJCQkICgpCSkqK3H5lVqpnYpSIiIiIiIiIiEhLaGuP0Xfv3qFv3744ePBgts8rM8coV6UnIiIiIiIiIiLSEtq6Kv2oUaMQFRWFS5cuwcjICIcOHcLmzZtRvnx5/PXXX0rVyR6jREREREREREREWkICUeFV6RUtrwonTpzAvn37ULt2bUgkEjg5OaFly5YwNzfH7Nmz0a5dO4XrZI9RIiIiIiIiIiIiLaGtPUbj4+NhZ2cHALCyssK7d+8AAG5ubrh+/bpSdTIxSkREREREREREpCUkglSpTd1VrFgRjx49AgBUr14da9euRXBwMNasWYPixYsrVSeH0hMREREREREREZFaGzlyJEJCQgAA06ZNQ+vWrbF161bo6+sjICBAqTqZGCUiIiIiIiIiItIS2roq/f/+9z/Zv2vVqoWXL1/i4cOHKF26NGxsbJSqk0PpiYiIiIiIiIiItITw3+JLimyCBiy+NH36dCQkJMgeGxsbo2bNmjAxMcH06dOVqpOJUSIiIiIiIiIiIi0hgRKLL2lAYtTf3x9xcXFZ9ickJMDf31+pOjmUnoiIiIiIiIiISEsos5iSJiy+JIoiBEHIsv/WrVuwtrZWqk4mRomIiIiIiIiIiLSEjiBCR8E5QxUtX5isrKwgCAIEQUCFChXkkqPp6emIi4vD4MGDlaqbiVEiIiIiIiIiIiJSS0uWLIEoiujXrx/8/f1hYWEhe05fXx/Ozs7w8PBQqm4mRomIiIiIiIiIiLRE5oJKih6jrnx8fAAALi4uaNCgAXR18y+dycQoERERERERERGRltCmOUbj4+NhYmICAGjcuLFC5fOCq9ITERERERERERFpCYkAxVelz7qmkVooV64c5syZg5CQkBzLiKKIo0ePok2bNli2bJlC9bPHKBERERERERERkZbQgQgdBYfGK1q+sAQGBmLSpEnw8/ND9erVUbt2bZQoUQKGhoaIjIzE/fv3ceHCBejq6sLX1xeDBg1SqH4mRomIiIiIiIiIiLSEoMRQekFNh9JXrFgRf/75J4KCgrBz506cOXMG58+fR2JiImxsbFCjRg2sX78ebdq0gY6OjsL1MzFKRERERERERESkJTKHxyt6jDorXbo0xo4di7Fjx+ZrvZxjlIiIiIiIiIiIiIoc9hglIiIiIiIiIiLSEjqCCB0Fe4AqWr6w3b9/HytWrMCFCxcQGhoKAHBwcICHhweGDx+OKlWqKFUvE6NERERERERERERaQgIpJFBszlBFyxemgwcPonPnzqhZsyY6deoEe3t7AEBYWBiOHj2KmjVrYt++ffD29la4biZGiYiIiIiIiIiItIS2zTH6448/YuLEiZg+fXqW5/z8/ODn54fx48crlRjlHKNERERERERERERaQgdSpTZ19fjxY3z77bc5Pt+zZ0/8+++/StXNxCgREREREREREZGWyOwxquimrpydnXHgwIEcnz9w4ACcnJyUqptD6QvBxHX9oWNgqOow8sSidYiqQ1CIZImNqkNQiHTUe1WHoBAD3TRVh5BnPxwspeoQFOLQ5pWqQ1DIu32adX1149X3j3p2jLuHqjoEhRw/VEPVISgk1VJ9f/3+lDQxCcAUVYdBeSBNSoZU0Ix7q9RuzWrfpas6AAWltK6j6hAUon/oiqpD0FqSUzdUHQIRkVaaPn06evXqhcDAQLRo0UJujtHjx4/j0KFD2LZtm1J1MzFKRERERERERESkJXQEKXQU/AFX0fKFqVu3bnB0dMSyZcuwcOHCLKvSBwYGwsPDQ6m6mRglIiIiIiIiIiLSEgJESKDYKDpBwfKFzdPTE56envleLxOjRET/b+++w6K4ujCAv0PvVQVFBAsq9l7AWLCgRmPvBYkae9dYYsSGvUdjS+wmsfcSFUtiwYZYsYAIqIBKkaaU3fP9wbcjSxMIsDtwfnl8njBl993ZuzNn787MZYwxxhhjjDHGioiidsZoQeLBlxhjjDHGGGOMMcYYKyI0BHme/kmVn58fKlSokKd1+YxRxhhjjDHGGGOMMcaKCE0Amrm8NF6zYKIUiqSkJAQFBeVpXe4YZYwxxhhjjDHGGGOsiMjLGaB5PWN0w4YNWL58OcLCwlC7dm388ssvaNSoUabL7tixA+7u7krTdHV18fnz52yfY/LkydnOf//+fe5Cp8Edo4wxxhhjjDHGGGOMsVzZt28fJk+ejE2bNqFx48ZYs2YNXF1d8ezZM5QqVSrTdUxMTPDs2TPxb0EQvvo8a9euRZ06dWBiYpLp/Li4uLy9AHDHKGOMMcYYY4wxxhhjRYYmKA+X0qcuHxMTozRdV1cXurq6ma6zatUqDB8+XDwLdNOmTTh16hS2bduGGTNmZLqOIAiwtrbOVbZKlSph0qRJGDhwYKbzfX19Ub9+/Vw9pgIPvsQYY4wxxhhjjDHGWBHxXwZfsrW1hampqfhv8eLFmT5HUlIS7t69izZt2nx5Xg0NtGnTBjdu3MgyW1xcHOzs7GBra4suXbrg8ePHX309DRo0wN27d7OcLwgCiHLXEazAZ4wyxhhjjDHGGGOMMVZEaEAOTeTyHqP/Xz4kJETpkvWszhb98OEDZDIZrKyslKZbWVnh6dOnma5TpUoVbNu2DbVq1cLHjx+xYsUKODk54fHjxyhbtmyW2VauXInExMQs59euXRtyed7ukcodo4wxxhhjjDHGGGOMFREaAkFDyN0ZlIrlTUxMsryX53/VtGlTNG3aVPzbyckJjo6O2Lx5MxYsWJDlerm99D43uGOUMcYYY4wxxhhjjLEiQjMPZ4zmdvkSJUpAU1MT4eHhStPDw8Nz3JGpra2NunXrwt/fP1fPnZ/4HqOMMcYYY4wxxhhjjLEc09HRQf369eHl5SVOk8vl8PLyUjorNDsymQwPHz5E6dKlc7S8ubk5LCwsMvyztLSEjY0NWrRoge3bt+fqdfAZo4wxxhhjjDHGGGOMFRGaghyaQi7PGM3l8gAwefJkuLm5oUGDBmjUqBHWrFmD+Ph4cZT6wYMHw8bGRhzAaf78+WjSpAkqVaqE6OhoLF++HEFBQRg2bFiOnm/OnDnw9PREhw4d0KhRIwDArVu3cPbsWYwZMwaBgYEYNWoUUlJSMHz48Bw9JneMMsYYY4wxxhhjjDFWRGiAoIFc3mM0l8sDQJ8+ffD+/XvMmTMHYWFhqFOnDs6ePSsOyBQcHAwNjS8Xq0dFRWH48OEICwuDubk56tevj+vXr6NatWo5er6rV69i4cKFGDlypNL0zZs349y5czh06BBq1aqFdevWcccoY4wxxhhjjDHGGGPFTWGdMQoAY8eOxdixYzOdd/nyZaW/V69ejdWrV+fpeQDg77//xtKlSzNMb926NaZMmQIA6NixI2bMmJHjx+R7jDLGGGOMMcYYY4wxVkRoQJ6nf+rOwsICJ06cyDD9xIkTsLCwAADEx8fD2Ng4x4/JZ4wyxhhjjDHGGGOMMVZEaADQFHJ7Kb36+/nnnzFq1ChcunRJvMfo7du3cfr0aWzatAkAcP78ebRo0SLHj8kdo4wxxhhjjDHGGGOMFRGakEMTQq7XUXfDhw9HtWrVsH79ehw+fBgAUKVKFVy5cgVOTk4AIF5Sn1PcMcoYY4wxxhhjjDHGGFN7zs7OcHZ2zrfH445RxhhjjDHGGGOMMcaKCA1BDg0hd2eMauRx8KXCJpPJcPToUfj5+QEAqlevju+++w6ampp5ejzuGGWMMcYYY4wxxhhjrIgoqpfS+/v7o2PHjnjz5g2qVKkCAFi8eDFsbW1x6tQpVKxYMdePKYV7qzLGGGOMMcYYY4wxxnJAU6A8/VN348ePR8WKFRESEgIfHx/4+PggODgY5cuXx/jx4/P0mHzGKGOMMcYYY4wxxhhjRYQG5NDI5RmjGhI4Y/TKlSvw9vaGhYWFOM3S0hJLlizJ831HuWOUMcYYY4wxxhhjjLEiQlOQQzOX9xjVlMA9RnV1dREbG5thelxcHHR0dPL0mHwpPWOMMcYYY4wxxhhjTK116tQJP/zwA27evAkiAhHB29sbI0eOxHfffZenx+SOUcYYY4wxxhhjjDHGiggNyP8/AFPO/0nhUvp169ahYsWKaNq0KfT09KCnpwdnZ2dUqlQJa9euzdNj8qX0jDHGGGOMMcYYY4wVERogaCB3gynldnlVMDMzw7Fjx/DixQs8ffoUAODo6IhKlSrl+TG5Y5QxxhhjjDHGGGOMsSKiqN5jVMHBwQEODg758ljcMcoYY4wxxhhjjDHGWBGhCYJmLs8Aze3yhWXy5Mk5XnbVqlW5fnzuGGWMMcYYY4wxxhhjrIhIvZQ+d2eAquul9Pfu3cvRckIuz5BV4I5RxhhjjDHGGGOMMcaY2rl06VKBPj53jDLGGGOMMcYYY4wxVkSk3mM09+sUR9wxyhhjjDHGGGOMMcZYEVGU7jFa0LhjlDHGGGOMMcYYY4yxIkIQCBpC7jo6hVwuX1RwxyhjjDHGGGOMMcYYY0WEJuTQzMM6xRF3jDLGGGOMMcYYY4wxVkTwpfQ5xx2jjDHGGGOMMcYYY4wVERp5uJQ+t8sXFRqqDsAYY4wxxhhjjDHGGGOFjc8YZYwxxhhjjDHGGGOsiOBL6XOOO0YZY4wxxhhjjDHGGCsiuGM057hjlDHGGGOMMcYYY4yxIkJDSP2X23WKo3ztGA0LC4OnpydOnTqFN2/eoFSpUqhTpw4mTpyI1q1b5+dTFRumBnr4bWQP8W89HW2UtTBFC49NmPZdC1QrWwpyIqTI5Fhz+ipuvghRYdqMom4HImjHv6AUGTR0tVFpQjsYViylsjw62prwmP4d7MtZIjExBVEfE7Bqwzm8CY3GwN5N0L51DZQtY47Znkdw1dtfXM/M1AA/TekIG2tzJCWnYPWv53H/8WuVvQ4Fddu+X/PBOxAvt10HiEAyOcr1qY/SrtVVHUukramJHzs1h3MVOyQmy/As9D1m/HUW31S1x3hXJ2gIAjQ1NLD9yl0cu/tE1XEzUPft28zRHuM6OkHQEKCloYEdF+/i+O0nsDDSh+eA9ihbwhTJKTJ4HriIuy/fFHq+aX1boUXtCihTwhR95+/G85D3AADbUmaY794eZsb6iPuUCI/tf+Pl2wgAgFN1e4zu6gRtLU18TkrBwt3n8eL1h0LPnp5U9g0xd2/h3ZF9sO4/BEbVaorTEwJe4O2OzSjR4TuYOTVXYcJUlJyM99v3Ijk0HIKONjSNjGDRtzu0S5ZA4qtgRB48BkpJASWnwKhJA5i2baXqyEyFtHW18dOfE2FXrSwSPyUh+l0M1o3eircBYajSsBLGrHWHtq42dPS08feOS9i//Himj/Pz/imo7lQZlmUs0NXcDfEfEwAAVnYlsenecnSzGFIor6dt9waYsqQ35o3eiRsXHqNyLVuMmv0dtHW0oKOrhXOH7uDgb1fE5Tv1b4rvBjlBliIHEWFCz/VITkrJ91yj17qjaecGsLYvhZF1pyHg/isAQAPXOnBf0BdaOlpITEjEmpFb8PJBEABg3Y1F0NHVBgBoaGmgfI1y+KH2FAQ+DMaKi3NxeO0pXD92O9+zpqejrYk5M77Uo9EfE7Bq/Zd61LVNaj36s+cRXL3xpR6t6mCNsSNcoK+nAyLCht8u4d794HzPl10bXnFxLkrZlUTC/9vjuV2XcXjNKXHdQR694NKvGZITU/DxQwymtZ4HANj9cgPmdlsuvk/5Lav2sPvlBiQnpiDpUxIA4M8lR3Bl/3UYWxhh+QUPcX1dAx2UrmCFXlbDEBsVV2B5s8qp4DqkJaZuGwOPbsuybIslbUtg3PqhKFu5DOQyOU5s+hvH1p9FrRbVMHq1O0bWm1YomdVt234tb3bbPrt55+UHlPbB+U1Kn7dGHepiyIK+0NDQgIaWBg6sOI7zu66g38xuaDu4JWwcrDGvx4oc7UenbRuDdkNaitu2II5t/2XbAkCdVjWw5NzP2Dx1J46sPQ0AhXqs+K808nDGqAafMfrfvHr1Cs7OzjAzM8Py5ctRs2ZNJCcn4++//8aYMWPw9OnTXD8mEUEmk0FLSzlmUlISdHR08iu6WvuY8Bm9Vu0V/3ZrWR8NKpRFzKdELDt2BbGfEwEAVW1K4reRPfHNnI0gNWnLKbGf8XzJSdRc2Q8G9iXw8eFrPF9yCnW3uqs014mz9+F95yUAoHunuvhxfHtMmPkX7vq+gtc/fpgxoUOGdUYMaY4nT0Mxbc5BVHWwxsLZ3dDn+82QyeSFHV+krts3K0SEJ4vPoN6qXjCqWBKfwj7ipttOlPzGAVoG6vF5ntyxGQiEjst2AABKGBkAAJb27YAhmw7gedgHlDE3wcmpbjj/6AUSEpNVmFaZFLbv4oEd8P36A3gR+gFlLExwbKYbLjx4gQmdm+FBUChGbT6C6rZWWDO0MzrM34YUeeF+vrzuPsfOv29j2499lKbPHtQGh/99gBPXn6B1PQfMc3fFIM8/YGygi4XDOmDY8v14+TYCdR1s4DmsI3rP3VWoudOTyr4hOSoSMXe8oWtrpzRd9vkTIs6dgkFlRxUly5yxc2PoVasKQRAQc+UaIvYegPXEUYj48yDMvnWFQa3qkMUn4O2CZdCvUQ06pa1UHZmp0OmtF3DrzD0AQJcx7TF560hMdZmLSZtHYKfHPtw4cQfG5kb43W8NvE/6INgv44+tJzefwy9jtuJA+O+FnP4LKxtzdOjdCH73gsRpExb0wO615+B98QmMTPXx29lpuHXJD8EB79CkdTW06lwXE3ttQELcZ5iaG0KWIiuQbP8e9Mb+Zcew+t8F4jQjM0PM3DMek1vMQdCT16jRrCpm7BmPH2pNAQCMbzpLXPabHk0waE4vBD7M/47FnDhx5j5u/r8e7dapLqZNaI+JM/7Cnf/Xo9MnZqxHF/zcDUtWncZd3yCUtTHHKs8+GPjDb0gqgI7nrNowAGyavCPTToFu4zuiQk07DK85BSnJKTC3Msv3XFnJrD0oePZdnaGDKDYyTqkDseeUzqjVvBpio+JUltPKriQ6DGuDJzeeZ/sYcw9Pw76lR/DPQW8AgFkp0wLJqiCVbauQVd7sXkd28wqDVD5v03ePx9RWHgh8GAwru5LY5rcGVw/fhM+Fh7j01zVM/X10jh6nWbdGSEnJ//1WZvKybQHAwMQAQxcPwK3TPoWSsyBoIPejrRfX0dnz7XWPHj0agiDg1q1b6NGjBypXrozq1atj8uTJ8Pb2xqtXryAIAnx9fcV1oqOjIQgCLl++DAC4fPkyBEHAmTNnUL9+fejq6uLq1ato2bIlxo4di4kTJ6JEiRJwdXUFADx69AgdOnSAkZERrKysMGjQIHz48OVMnZYtW2L8+PH48ccfYWFhAWtra8ydO1cpd3R0NEaMGAErKyvo6emhRo0aOHnyJOLj42FiYoKDBw8qLX/06FEYGhoiNjY2vzZdrnRvVB1Hbj0CALFTFACM9HRVkic7n0KjoWWiDwP7EgAA05plkfg+BnEvwlWWKSlZJnaKAsDjp6GwtkotJvyehyE07GOm67X6piqOnfEFADx9EYaIiDjUqWlb4Hmzo47b96sEAclxqe1WFp8ELRM9aGhrqjhUKn1tLXRvWB1rz14Xp32IS/0FkYhgrJ/6GTPS1UF0wmckF9AXvf9EjbcvABAIJv/fjoa6OoiO/4ykFBlc61TG/msPAACPQ8Lx7mM86lcqW+j5fF68wbt0Rbu5sT4c7axw2tsPAODl8wJW5sawLWmGsiXN8DH+s3j26L0Xb2BtYYyq5VR7ZqYU9g0kl+Pdkf0o0akbBE3lHz8/nDgCi5ZtoGlgoKJ0GQna2tCv7ghBSL2+SNe+HFIio/4/U4D80ycAACUlQdDSgqahvqqiMjWQnJgsfgkDAD/v57CyLwkg9XhiaJbatvUMdZGSlILYyMw7C+55PUT0+5hsn0tLWwvTd43DhE0/QEMjf7/OCIKAiZ498euCY0pnfBIRDE30AAB6+jpITk5B7P/PuOk1rAX2rj+PhLjPAICPUfGQywvmF/uH//rhw5tIpWllKlohJiIWQU9SO5ofXX2KUuVKoFLd8hnWb/+9C85s88r0sZt1b4xN95ajdIWC+YEjKVkmdooCwJNnX+rRp1nUo6Ym+jAz1cdd39RO6tdvohAX/xmNG2R8bf9Vdm04O72mfoffZu5FSnJqe4kKj850uS5j22PNvwtgWsIkX/ICmbeH3OjwvQvObruY6bz8zJtVTkEQMHnrSGwYvw3J2fzwXrd1TSQnJoudogAQ/S5jezEw1seSs7Mx8OeeBZY5pwpr2ypklTe715HT1zhsyQDMPzoduvr5d9KBpD5vRDAyMwQAGJjoIyYiDsmJKXh22x9hge9y9BBmpUzRb2Z3bJq8M8tl8uvYltdtCwDjfhmKPzwPITYi6w79gj5WsMKTL2eMRkZG4uzZs/D09IShoWGG+WZmZoiOjs7x482YMQMrVqxAhQoVYG5uDgDYuXMnRo0ahWvXrgFI7dB0cXHBsGHDsHr1anz69AnTp09H7969cfHilx3vzp07MXnyZNy8eRM3btzAkCFD4OzsjLZt20Iul6NDhw6IjY3Fnj17ULFiRTx58gSampowNDRE3759sX37dvTs+eWAovjb2Ng4Q+7ExEQkJn7prIyJyb6Yza3a9qVhoq+HK0++FFITv22GdrUcYGKgh0k7TqjN2aIAoG9jjpSYT4h5/AYm1W0QccMfsoQkJIZ/hJGDeuw8enapj2veL7JdxsRYD1paGoiMihenhb77CKuS+XcAzwspbN+0BEFAjZ874pHHCWjoaSMlLhE153VSm447W0szfEz4jB9cGqGJQzkkJqdgw/kbuOkfgil7T2Pt4M74lJQME31dTNh1EskqPFs4M+q+fQFg2s7TWPX9/7ejgS4mbTsJQ10daGlqICL2y+VJbyNjUNo84z5WFazNjfHhYzxkab7Yh0XGwtrSGH5B4TA11EOtiqXxICAUzWtXgJG+LspYmuBpcM6Kw4IghX1D9PUr0LOzh56N8g9McY/uA4IAQ8caiHvyUEXpvi728lUY1Eq9TUWJgb3xbvMORJ/8G/K4OFj07QFNE9UeH1j++q/1Xbfx3+LG8TsAgBXf/4p5R3+E+4J+MC1pgjUjN2f5ZfZrDE0N4HFoGu55PcCfi4/k6TGy0939Gzz2eQX/x8q3Nlk1cz88fh0Ct4muMLUwwro5hxD1IfWLY7mKVnCoWRYDxraFto4WvI7exbHd1/I9W1ZevwiDiaUxqjWtjCc3nqNp5wYwNDGAtX1J+N8LFJcrWdYStVpUw9LBv2R4jB6TOsG5ayNMaz0vy07r/JaTevRjzCdERMaj1TdVcOnfZ6jqYA3bshYobVWwZwsCym0YAIYuHoAh8/si6Mlr/D5rL8IC38HAWB/mVqZw6tIQ3/RoAgA4tPokruz/8oOzoCFgxEo3WNuXwo9tFyDpc1KBZweAH3eOhSAIeHrbH7/P2IuPH5Q/w9WaVoaRuRG8T95Vml6YeXtM7oTH15/hhc/LbJezq1YWH9/HYNYfE2FbpQzCXr3H5qk7lTqlSpa1xNwjP+LIulO4sPufAssMSGPb5gdtXW3M+mMiYiNjMbf7csgL8Komdf68Ley7Gh6HpuJzfCKMzA0xr8cKsWM2pyZvGYmt0/fg0/9/QEuvII9tOdm2QOoVBXK5HDdO3EGzbo0zfSxVHCtyS1NI/ZfbdYqjfOkY9ff3BxGhatWq+fFwmD9/Ptq2bas0zcHBAcuWLRP/XrhwIerWrYtFixaJ07Zt2wZbW1s8f/4clStXBgDUqlULHh4e4mOsX78eXl5eaNu2LS5cuIBbt27Bz89PXL5ChQri4w0bNgxOTk4IDQ1F6dKl8e7dO5w+fRoXLlzINPfixYsxb968fNkGmeneqAaO3/VT+oK+5tRVrDl1FU0cymFyp28waP0+pKhJh42WoS6q/NwFQdv+gexTMoyrlYG+nSWgqR4naA/s3QQ2pc0waf3fqo6SJ+q+fdOTy+R4tecWaszrDPPaZRHzNAwPZh9Do98HQ8dU9WdXaWpqwMbCFAHhEVh95iqqlimJ34b3QJeVuzCidSNM2HUCdwPfoEZZK6wf0gVdV+1CdELmB3RVUPvtqyHgh3aNMHnbCdx9+QbVba2wblgX9Fq+R9XR8izuUxJ+3HQS47p9AwM9bTwICEXA2w+FfguA9NR935AYHoq4xw9RdtgYpekpsTGIvHwBNkNzdhmWqnz82wvJ7z/Aqt+I1L/PXYL5dx1h2LAukj9EIHzNRuiUs+VL6YuQ/1Lf9ZvZDWUqWePHNqnr95neFb/P+gOX/rwK6/KlsPLyPDy/8zLTS+mzo6WjhTVXF2LfsqMF0vFh52CFZq41MXXAxgzzev/QCttXnsHlk76wtrXA8j0j8eLhawQHvIOGlgasy1pg2oCNMDLVx/I9IxEaEolbl/3yPWNmEmISML/XSgxdNAB6Rnrw836OV49DIEtR3i+3G9ISN0/eRUyE8hVgA37qgajwj5jebkG2Z+3lJ0U9uuKXr9ejP80/jBHuLTCgdxMEBn3Aw8dvCvy2Tunb8NLBv+D969QrJbqMaY+FJ2ZiWI1J0NTShJa2FnT1dTC+6SxY2ZXE2msLEfL0jXiP10mbR8DfNxDze64AFdLZHJNbeOB9yAdoamnCfWFf/LhjDH7qtFhpmfZDW+P87iuQp9uWhZXXvrotvuneBJNbzPnqsppamqjjUgPjm85C0JPX6DSiLX7eNxljGs0AAJhZmWLllflYPXwj7l18VGCZAWls2/zieXImrh+/jb0LDxXo86jz501DUwMDfuqBeT1W4OG/fqjcoCLmH5uOH2pNybAvzUqHoS54F/IBvpcyb5sFeWzL6bY1tzLDgJ96YEorjywfSxXHirzQhABN5K6nM7fLFxX58i0pv3dmDRo0yDCtfv36Sn/fv38fly5dgpGRkfhP0TEbEBAgLlerVi2l9RQdnADg6+uLsmXLip2i6TVq1AjVq1fHzp2pp3nv2bMHdnZ2aN4884EgZs6ciY8fP4r/QkLybyAkfR1tuNaujKO3Mt+JeL8IhqGeDiqXLpFvz5kfzOqUQ82V/VDn18Eo/0NLJEXEwaCcpapjoW/3hmjuVBk/ehxEYmL2v3LFxH6GTCaHhfmXs6FLlzJF+FcubysM6rp9MxPn/w6JEXEwr516ibRJVWvoljRG3AvVnVmXVmhUDGRyOU7eS70f8tO37/Em8iM613NEKRMj3A1MPWPm0etwhH+MhaONeg1ko+7bt4pNKZQ0MRIHVXockrodK5cpAZmMYGn85bLpMhYmCI1Sze1K0guLikUJU0Nophmi0drCGGH/LwDvPAvB8BX7MWDhXqw6cAUlTY0Q+Dbvl5vlF3XeN3x+FYiUqEgErV6MVysWIvF1EN4fO4i4xw8gi41ByIaVeLViIeIeP0DkpXOIOH9a1ZFFHy9cRoLvI1iNHgYNHR3I4uKR8OARDBvWBQBol7CEbnk7JL58pdqgLF/ltb7rOaUzmnVrjFkdPZH4KQkmlsZw7tYIl/68CgAIC3yHp94vUN25Sq4zyZJleHTtKZp2agBNrfy/MqBGg/KwsjHHtnM/YufFGahapxwmLOiB/qNbw6ltDVw+6QsACAuJxFPfYFSrbw8AeP82GpdP+kIuJ8REJeD2lWdwrFMu3/Nl5/7lx5jSygNjGk7H5ik7YVnGXLy0XsF1SKtML+19eusFylYuXWiXRfbp3hDfOFfGj3O+Xo8CQEDge/w45yCGjdsJzxWnUMLCCIFBBTfgX/o2DEDsSACAYxvOonSFUjC2MEJsVBwSYj/hwp7UzozwoPd4fO0ZqjSsKC7/4J8nqNrIARbWZgWWOb33IanbR5Yiw+E1p1DjG+X7V+sZ6qFFr6b4O5P2UFh5a3zjCCv7ktjxfB12v9wAxyYOmLh5BDqNbJdh2XfBH+B/L1Bs0xd2/4NK9cqL+4H46Hi8ehSMxp3qZ1g3v0lh2+aXe5ceoV6bWjAwLriTDdT981apjj0sy5jj4b+pP3Q9vxOAD68jMr1VSVZqt6yBpt81wO6XG7D75QYAwJb7K1Gxjj2Agju25WbbOtSvAIvSZth0bzl2v9yAb3o2wcCfe8F9YT9x+cI+VuSVRh7/FUf58rodHBxST6HPZoAlxb0h0naiJidn3rue2eX46afFxcWhc+fO8PX1Vfr34sULpY5LbW1tpfUEQRBPfdfX//qObdiwYdixYweA1Mvo3d3dxXuMpaerqwsTExOlf/mlfZ3KeBb6HoHvUu9ppqWhAVvLL5fO1LC1goWRAV5HZH6PTFVJSnNPjpC9N2BWpxz0bcxVmAjo3bUBWrdwxOTZ+xAXn/j1FQBcvvoMXTrUAZA6ImgJSyP4Psy/ju+8UsftmxW9ksZIiohHfFDqQSjhTTQ+vY2Gga165I1O+Axv/xA4V0kdCMbG3AQ2Fqb4+8FzlDQxRIVSFgCAcpamsLU0w6v3UaqMm4G6b9+wqFiUNDFEeavU7Whb4v/b8V0Uzt1/jt7OqT9iVbe1QilTI9z1z93ZUwUlKvYTnga/Q8cmqcV+63oOeBcVi5D30QCAEqZfjk3DOzXG7ach4jxVUud9g2ljJ5SfMRf2U2fDfups6Ja1Q8kuPWHWpBnKz5wnTjeqXgsWrdrBsm1HVUcGAMR4XUHCXV+UGjccGgap9YOGgT40dHTw6VnqqNGyuHgkvgrms0WLmLzUdz0mdUKrvs0wvd0CcSTjuKh4fI5PRJ1WNQAAJpbGqNrYAa8e5b6eICKsHbkF715HYN6RH6Gjl7+D7J360xv9my2Em8sSuLkswVPfYKz9+RD+2nQRiQlJqN0k9cu3ibkBqtS2RdDzMADApZP30OCb1I5eHV0t1GpcAS+fvs3XbF+TthNgwM894XvxEd4GhInT6rrUgKaWJu6ef5Bh3bvnH2DF0F+x4Pj0XH3Zz4ve3VLr0Sk/5bweTfsjfSfXWviUmAyfAhiVHsi8DWtoaigN9NOse2NEhX8ULyO99Nc1NGxfBwBgbG6EKo0q4eWDL/ku7P4HexYcxDIvD1jbF/wPzHoGujA0/fLDa6t+zZRuqQAALfs44eX9IIQ8y9hOCyvvyU3n0NfmBwyqMAaDKoyBn/cLrBmxGSc3ncuw7O0z91CyrCUsy6TWU4061kWw3xtxkLPkxBTM67EClqUtMHnryCy/t/5XUtm2+eXPRYdx9chNLD0/B8YWRvn++FL4vL0LiYBFaXOUq2oDAChT0RqlK1pn+v5mZcmgdRhgN0ps6wDwQ+0pCPB9BaBgjm253ba3Tvugd+nhYsZ/D3pjz4ID2D77T3H5wjxW/BeagpCnf8VRvlxKb2FhAVdXV2zYsAHjx4/P0IkZHR2NkiVTb3IbGhqKunVTz6xIOxBTbtWrVw+HDh2Cvb19hlHrc6pWrVp4/fq10qX36Q0cOBA//vgj1q1bhydPnsDNzS3Pmf+L7o1r4JD3l/utaWlqwLNfexjp6UAml+NTUgom7zyJmE85K6wKS/Cua4h5+Bokl8PYsQwqTW6v0jwlLY0wdrgL3oRGYe3ivgCA5GQZRk7eg8F9muK7jnVgZqqP8nbtMXGUDEPH7cDHmE/YtP0KZk/5Fn9sGY7kFBkWrjyl0hHpFdRt+2ZHx8IQVSa3waP5pyAIAogIlce7QM9Kfe7FN/+wFxb0aovJHb4BEWHeoQsIjY7F3EMXsHLAtyAiCIIAz6MXERqtHmc0Kqj79o2MS8D8/Rewwu1byImgIQhYfOgiwqJjsfr4VSwa2B4nfhqC5BQ5Zu05o5LL0X8a2AbNapWHpYkhNkzsjoTPyejy0zZ47r6Aee6u+L5jY8R/SsTcHV++qIz8zgl1HWygpamBBwFvMW9nxi8xqiClfYMUpERFI+rISWiVsED42k0AAEFLC6WnjUeJ7wci+uhJRMnlgEwGk5bNoFvBXrWBmUqVsLHAyJVueBsQhhUX5wIAkhKTMb7pLCzsswrDlw2CppYGtLS1cHjtKfh5p45A3WlEW1iWscBOj30AgIUnZqJC7dQf6357tBpvXoSKI+kqbJ6yE27z+8Dz1Ez8/N1SfI4v2Fu8yOWERRP3YNiP30JTSwOaWpo4uvMq/HxTv4wf3vYvxi/ojs2npwBEuPr3I/x7tmDuFzxh0w9o3LEeLKzNsPjsT0iI/YwhlcfBbX4f1GjmCE0tTfjdeI6Vw5RvB9D++9b4e8elLK94e3T1KTz7rcGcA1OwdPAveHz9Wb5nL2lphDH/r0fXKOrRFBlGTdqDQX2V69EJo2QYNja1Hu3coTbatqoGAQKCQiIwe0H+31sWyLoN/9h6HjxPzoS2rjbkcjliPsRiTpel4nq/z9yLadvGoPOo1IFy9y07ime3/ZUe+99D3kj8lIQlf8/Gz98tyVWnSnYyaw8zXBfA4+BUaGhqQBAEhL4MxzK39Urrtf/eBWd+y/w2aQWRN6t2mx23eX0Q8TYSJzefx+eERKwdtQWeJ2cCAhD/MQGe/dYoLS9LkWHxgLWYvHUkZu4ZjyWDf8lwKft/zayO2za7vEMqj8t22+fkfTmy9jQ+xydiuZcHZrb3zPP9odOTyuct+t1HrBmxGbP3TYZcLoeGhgbWj/sd70M+oP9P3dFpRDuYljTB5Bq2GPvLUIyq9yM+fohRar85lV/Htrxu25wojGPFf6UBARq5vDQ+t8sXFQLl03XwL1++hLOzMywsLDB//nzUqlULKSkpOH/+PDZu3Ag/Pz80bdoU2tra2Lx5M969e4cff/wRt27dwqVLl9CyZUtcvnwZrVq1QlRUFMzMzMTHbtmyJerUqYM1a9aI096+fYs6deqgRYsW4qjz/v7++Ouvv/Dbb79BU1Mz0/W6du0KMzMz8SzQVq1a4cOHD1i1ahUqVaqEp0+fQhAEtG//5UvkgAEDcPDgQbi4uODMmTM53iYxMTEwNTWF45hF0NTVy+umLVSm7UNVHSFXNNao160DvkY+seAudyoIulq5u5m2KoWdsf36QmrEuoPqzzjOjffHpLV9teLV/35VaRn0Dvv6Qmok/Ja1qiPkSrKZ6n/Iyin5p88ImfYzPn78mK9XnrD8o6jvWqILtATtr6+gBjQrqe8ZLZmR+Qd+fSE1ktS+oaoj5IrO2duqjsAYY8VGCiXjMo4VWm2nqFOCnpaBiXHuLhKPiZXDrurbYleH5tstBCpUqAAfHx+0atUKU6ZMQY0aNdC2bVt4eXlh48bUX2q3bduGlJQU1K9fHxMnTsTChQvz/HxlypTBtWvXIJPJ0K5dO9SsWRMTJ06EmZmZeNl+Thw6dAgNGzZEv379UK1aNfz444+QyWRKywwdOhRJSUn4/vvv85yXMcYYY4wxxhhjjDGmPvLlUnqF0qVLY/369Vi/fn2m8x0dHXH9+nWlaWlPWG3ZsmWml7Vcvnw508dzcHDA4cOHs8yT2XpHjx5V+tvCwgLbtm3L8jEA4M2bN7C0tESXLl2yXY4xxhhjjDHGGGOMMVXiS+lzLl87RouahIQEhIaGYsmSJRgxYgR0dPL3xvaMMcYYY4wxxhhjjOWnvAymVFwHX8q3S+mLomXLlqFq1aqwtrbGzJkzVR2HMcYYY4wxxhhjjLFsaeTxv+KoeL7qHJo7dy6Sk5Ph5eUFIyMjVcdhjDHGGGOMMcYYYyxbikvpc/svLzZs2AB7e3vo6emhcePGuHXrVrbLHzhwAFWrVoWenh5q1qyJ06dP5+l58wt3jDLGGGOMMcYYY4wxVkRoChp5+pdb+/btw+TJk+Hh4QEfHx/Url0brq6uePfuXabLX79+Hf369cPQoUNx7949dO3aFV27dsWjR4/+60vOM+4YZYwxxhhjjDHGGGOM5cqqVaswfPhwuLu7o1q1ati0aRMMDAyyHOR87dq1aN++PaZNmwZHR0csWLAA9erVy3IQ98LAgy8xxhhjjDHGGGOMMVZExMUSNEC5XgcAYmJilKbr6upCV1c3w/JJSUm4e/eu0pg8GhoaaNOmDW7cuJHpc9y4cQOTJ09Wmubq6oqjR4/mKmt+4o5RxhhjjDHGGGOMMcYkTkdHB9bW1rCr/ypP6xsZGcHW1lZpmoeHB+bOnZth2Q8fPkAmk8HKykppupWVFZ4+fZrp44eFhWW6fFhYWJ7y5gfuGGWMMcYYY4wxxhhjTOL09PQQGBiIpKSkPK1PRBAE5UGYMjtbtCjhjlHGGGOMMcYYY4wxxooAPT096OnpFfjzlChRApqamggPD1eaHh4eDmtr60zXsba2ztXyhYEHX2KMMcYYY4wxxhhjjOWYjo4O6tevDy8vL3GaXC6Hl5cXmjZtmuk6TZs2VVoeAM6fP5/l8oWBzxhljDHGGGOMMcYYY4zlyuTJk+Hm5oYGDRqgUaNGWLNmDeLj4+Hu7g4AGDx4MGxsbLB48WIAwIQJE9CiRQusXLkS3377Lf766y/cuXMHW7ZsUdlr4I5RxhhjjDHGGGOMMcZYrvTp0wfv37/HnDlzEBYWhjp16uDs2bPiAEvBwcHQ0PhysbqTkxP++OMPzJ49G7NmzYKDgwOOHj2KGjVqqOolcMcoY4wxxhhjjDHGGGMs98aOHYuxY8dmOu/y5csZpvXq1Qu9evUq4FQ5x/cYZYwxxhhjjDHGGGOMFTvcMcoYY4wxxhhjjDHGGCt2uGOUMcYYY4wxxhhjjDFW7HDHKGOMMcYYY4wxxhhjrNjhjlHGGGOMMcYYY4wxxlixwx2jjDHGGGOMMcYYY4yxYoc7RhljjDHGGGOMMcYYY8UOd4wyxhhjjDHGGGOMMcaKHe4YZYwxxhhjjDHGGGOMFTvcMcoYY4wxxhhjjDHGGCt2uGOUMcYYY4wxxhhjjDFW7HDHKGOMMcYYY4wxxhhjrNjhjlHGGGOMMcYYY4wxxlixwx2jjDHGGGOMMcYYY4yxYoc7RhljjDHGGGOMMcYYY8UOd4wyxhhjjDHGGGOMMcaKHe4YZYwxxhhjjDHGGGOMFTvcMcoYY4wxxhhjjDHGGCt2uGOUMcYYY4wxxhhjjDFW7HDHKGOMMcYYY4wxxhhjrNjhjlHGGGOMMcYYY4wxxlixwx2jjDHGGGOMMcYYY4yxYoc7RhljjDHGGGOMMcYYY8UOd4wyxhhjjDHGGGOMMcaKHe4YZYwxxhhjjDHGGGOMFTtaqg5QlBERAECW9FnFSXIuJT5R1RFyRSNZOtsWAOQS276aWimqjpBjskRptQWpfdaktn2FJFJ1hFyRWnuQf5ZWe5B/kqs6Qo4ptq2ihmDqR/HepCAZkMjbRDJp7WNklKzqCLmSIrF6VENi25cxxqQsBan7XK7t1JdA/O4UmNevX8PW1lbVMRhjjDEmMSEhIShbtqyqY7BMcH3HGGOMsdzi2k59ccdoAZLL5Xj79i2MjY0hCEK+PW5MTAxsbW0REhICExOTfHvcgsJ5CxbnLVict+BIKSvAeQsa501FRIiNjUWZMmWgocF3PFJHXN+l4rwFS0p5pZQV4LwFjfMWLM5bcLi2K774UvoCpKGhUaC/CJiYmKj9ziUtzluwOG/B4rwFR0pZAc5b0DgvYGpqmq+Px/IX13fKOG/BklJeKWUFOG9B47wFi/MWHK7tih/urmaMMcYYY4wxxhhjjBU73DHKGGOMMcYYY4wxxhgrdrhjVIJ0dXXh4eEBXV1dVUfJEc5bsDhvweK8BUdKWQHOW9A4LyvupNamOG/BklJeKWUFOG9B47wFi/MWHCllZfmLB19ijDHGGGOMMcYYY4wVO3zGKGOMMcYYY4wxxhhjrNjhjlHGGGOMMcYYY4wxxlixwx2jjDHGGGOMMcYYY4yxYoc7RhljjDHGGGOMMcYYY8UOd4wyxhhjjDHGGGOMMcaKHe4YZawYkcvlqo7A1AS3BcYYY0z6+HjO0uL2wBhjuccdo4wVYTKZDABw+/ZtxMfHQ0ODP/LFlaItXLlyBTExMdwWijn+4sQYY9LEtR1Li+s7lhbXd4zlDe85mdogIlVHyFb6A4265yUiaGpqIjw8HB06dMDFixdVHSlP1H07K9pFfHy8ipNkTdEW3r17h1atWuHkyZOqjpRrinagzgWfImNYWJiKk2RPLpdDQ0MD4eHh2LNnj6rjMMaKMHU/hgPSqu+KSm0HqPd2lkJtB0i/vpNCbQdwfcdYccAdo8WEOhYf6TMJgpDlPHWg+AX2999/R1BQkJhXHbMSkZjvwIED6Ny5Mzp37qziVF+XkpICILUQDQwMhEwmU2oX6khDQwO3bt1C//79cevWLSQnJ6s6UgaKbXj58mUMHToU/fv3V3GinElbKCs+Z+p8JoQgCHjw4AHc3Nxw4MABxMbGqjpSphTbsFevXti4caNattmvUfcvUVnlU8fjBZMudWxPUqvtAOnUd1Kt7QDp1XdSqO0AadZ3UqvtAK7vChPXd0xVtFQdgOUfxa9E7969g7+/P8zNzVGmTBmYmpqqZfGRnJwMHR0dnD59GhcuXIC+vj5q1aqFPn36QBAEpQJQ1RRZfHx8sGbNGhw9ehTjx49H27ZtIQiCuO3VhWK7eXl54erVq7CyshLnqVtW4Mv21dLSQmJiInr27IkXL14gJiYGU6ZMQY8ePVCpUiVVx1SSdjvGxMTgxIkTePv2LSZMmIBOnTrBzMxMZdnSfnbi4+NhaGiIEydOYPPmzbC0tBSXU8e2oCCTyaCpqYmUlBR4enri0aNHiIiIwIIFC9CkSRNoamqqOqIo7XYMDAyEl5cXXr58iWfPnqFPnz5wcHBQccKMgoKCUL9+fQwfPhza2tqqjpOttNtXLpcjMjISJUqUUHGqrCUlJUFHRwcAcO7cOSQmJqJs2bKoWbMmtLS47GK5w7VdwZJSfSe12g6QXn2nzrUdIP36Tkq1HcD1XUHj+o6pFWJFQkpKChERPXz4kOrXr0/29vakq6tLvXv3pmPHjlFsbKy4rFwuV1VMIiLy8fER///27dtkYmJCLi4uVL9+fWrUqBENHjyYnj9/Li4jk8lUEVOUnJxMREQhISE0c+ZMqlq1Kunq6lKNGjVo/vz5FB0drdJ86Y0ZM4YuXLhACQkJ1LFjRzI2NqaKFSuSr6+vuIyqt2laFy9epP3794tttF+/ftS4cWM6evQozZ8/n0xMTKhDhw50/vx5io+PV3HajL7//nsaO3YstW/fnlxcXEgQBPrhhx/o6dOnKtvOis/4iBEj6I8//qCkpCQaO3YsVaxYkSwsLOjixYvisurUFjLTq1cvatCgAc2ePZv69u1LGhoaNGHCBAoPD1d1tAwGDRpE7u7u1L9/f+rbty8ZGhpSjx496Pz58/T582dVxxP3q6GhoVSvXj2ysbGhf/75h4i+7OfU2dKlS6lDhw5UokQJ6t+/P926dYs+ffqk6lii9McCNzc3qlSpEmlqapKTkxNNnTqV/Pz8xPmqPhYz9ce1XcGSUn0ntdqOSNr1nTrWdkRFp76TUm1HxPVdQeP6jqkD7hgtAtJ++BwdHWnkyJGUkJBAf/zxBwmCQJUrV6ZFixZRQECAClOm2rt3Lzk6OtKaNWsoJSWFZsyYQdOnTyciorCwMFq1ahW1atWKnJ2d6Y8//lBxWmWVK1emMWPG0L///kve3t70/fffU/369alfv350+/ZtcTlV7gz37dtHgiDQy5cviYgoNjaWVq1aRRUqVKBOnTrRwYMHxS9a6mLQoEEkCAJNnz6dHj58SH379lU6uDx+/JgaNmxI5cqVozVr1lBgYKDqwqZz4sQJMjY2ppcvX4qF0aFDh8jU1JQaNmxIJ0+epLi4uELNpHh/FW1B8blPSEigffv2UePGjalhw4a0Zs0aSkpKEtdTp4O4Istff/1FVlZW9PbtWyIi6tmzJ9WtW5esrKyoXr16YtGnDv7++28yNjam4OBgMf/FixfJ3t6e7O3taf369RQcHKyyfEePHqVWrVpRTEwM3blzh/r27UsWFhbUsWNHioqKEpdTty9Sivb8xx9/UKlSpcjT05OuX79O2tra5ODgQL/88otafJFKTEyk/v3704YNG0gul5OPjw9ZW1vTvXv3KCAggGbPnk1OTk7UtWtXOnDggKrjMgng2q7wqHt9J8Xajki69Z061nZE0q/vpFjbEXF9V1C4vmPqhjtGi5CVK1dS/fr1xb9r1KhBs2bNookTJ5KWlha5ubnRmTNnVHqAvH79Orm7u1OjRo1o+PDh5O7uTnv27FFa5syZM+Tm5kY1a9akESNGqMUvXUePHqVy5cpRZGSkOC02NpYWLlxIOjo61KhRI9qwYYNKC9OPHz+SgYEBbd26VZyWkJBAycnJdP78eXJxcSFnZ2datGgRvXr1SmU5M7Nt2zbS1dWlVq1aUePGjenMmTNEpFzMzZgxgwRBoCVLlqgqpphH8T4vXbqUGjduTJ8+faKUlBRxure3N2lqalKJEiVo2bJlhZ5P0RY2b94szouOjqbY2Fi6d+8eDR06lBo3bkzDhw+nhw8fFlq+3EhMTKQxY8aI22/Lli1kY2NDb9++pStXrpAgCCQIAu3cuVMl+dK3hS1btpCjoyO9e/eOZDKZOP3t27dkbm5OdnZ2NGnSJJWcgfT582cyMjKi5cuXi9NCQkJozZo15OjoSE2bNqVz586J89TtC3ZMTAzZ29vTli1biIjo8OHDZG1tTUOHDiVBEGjUqFF08+ZNlRb9AQEB1Lx5c2rcuDFNnz6dVq1aRTNmzFBa5ujRo/Ttt99Sy5YtafLkyfT+/XsVpWVSwrVdwVL3+k7KtR2RNOo7da/t0maUen2n7rUdEdd3hYnrO6ZOuGO0iJDL5bR9+3b69ddfiYjoxx9/JCcnJ3EHWLFiRdLT06MNGzaoMiYRpe4EV69eTe3atSNLS0v6/vvvMyzz8uVLmjp1Km3cuFEFCb9QHByvX79OFhYWdOHCBSJS/tWtbdu25OLiQs2bN6f9+/erJCcRUatWrahXr15K05ycnGjTpk1ElHp5xZgxY6hBgwbUpUsXevHihSpiEtGX7SqTycT/f/v2rXi50ogRI+j169cZ1vvnn38oIiKiULOmlfaXV6LUs2RMTEwoNDSUiL68ntDQUOrbty/NnDmTBEEQC5bC+uLasmVL6tOnj9K0mjVr0qJFi4iIKCIigpYtW0atW7emOnXqKF0CqQppt4visyWTyejEiRN0+fJliouLo/r164v7r6CgIOrZsyf98ssv9OHDh0LNqsiXvujx8vIiS0tLunPnDhGlFp/JyckUGxtL/fr1o59//pn09PRoypQphZqXiMjV1ZXatWunNO306dNERHTs2DHq3bs3ValShTw8PNTmzJK0Ll68SIMHD6aYmBgKDw+n0qVL0/bt24ko9XI8xdlzCQkJKs356dMnmjdvHjVu3Jjq1atHTk5OGZZ59eoVjRw5kpo1a6bSfRmTBq7tCo5U6jsp1XZE0qzvpFLbEUmrvpNSbZc2I9d3hYfrO6ZOuGNUwsLDw8nHx0e8LOXNmzcUEBBAcXFx1LJlS1q/fj0Rpe7oR48eTd7e3irJqTjQhIWF0e3bt8XLDS5cuEB9+/alsmXL0rhx4zJcQqPKX7UOHz6sdN+msLAwaty4MY0aNSrDzm706NG0efNm6tatG1WuXJk+fvxY2HHp77//JkEQyMPDQ7wny5QpU6hq1aoUHR2tdDDcuHEjDRkypNAzKqTNsm/fPurdu7fSr9rLly8nQRDou+++o9u3b6vNWSVERE2aNBELDoVmzZpR1apVycvLS5z24cMHqlGjBr1+/ZpGjRpFzZs3L7SM165dI01NTRo6dKh4X6+pU6dS9erVM/yaffTo0Qy/eha2tO1h69at9O2339Ldu3fFaTKZjD5+/EgNGjSgI0eOEFHqr+G1a9cmf39/lWUtX748/fnnn0rzu3btSsbGxnT8+HFxWmRkJFWpUoVCQ0NpyZIl5OjoWKj7NsXZOmnNmjWLrKysxEvtHj16RHPnzqVy5crRDz/8UGjZshMXFydeqvju3Ts6fvw4yeVy8vT0pHbt2olte9WqVbR9+3a6ceMGEanuksG0+9kzZ86Qq6srlShRgqZNm5ZpO1VMU7dL25jqcW1XsKRU30mptiOSbn0nhdqOSFr1nZRqOyKu7woT13dMXXHHqEQFBwdTjx49Mpwir+Dq6koTJkygt2/f0tmzZ8nIyEgll9godgpBQUFiXsVlNESpvyJ7eHhQs2bN6Ntvv6Vjx44Vesb0Xr9+TYIg0MGDB5WmHzp0iPT19cnFxYUuXrxI3t7edPDgQdLW1qa3b9/S9evXqWrVquI9cwrTgwcPaOjQoeTs7EzDhw+njRs3kpmZGd28eVNcJu3BOu29hwqb4uAyadIkat++PU2dOjXDvZru379PDg4OZG1tTTt27FDJL8fpubm5Ua1atTJM9/X1pf79+5ONjQ0NGDCAfvzxR6pZsya1bt2aiIjWrl1Lzs7OhfbrYWBgIHl6epKTkxO1atWKli9fTubm5kr3SUt7sFb1FxNFe1AMcuDh4ZHhRvaxsbFUu3ZtqlevHq1evZpq1apFXbp0UVlWd3d3qlu3bob5MTExNHr0aNLS0qK2bdtSv379qGrVquTi4kJERDt37qQ6deqIZ6EUtMTEROrduzcJgkB79+4lotR7upmYmND58+eVlo2OjqZdu3aJ9yxT5ZkFO3fupN69e9OkSZPEATkUbXbp0qXUokULiomJISKiLl260Pz581WSU7GNFHnHjRsn5o2IiKDJkydT3bp1adCgQUrHPcaywrVdwZJafSel2o5ImvWdVGo7ImnVd1Kq7Yi4vissXN8xdcYdoxLVqFEjGj16NN2/f19puuKD7OnpSfr6+lS1alWysLAgT09PVcQUZZY37Y75wIED1LVrV3JycqJJkyapdIS/unXrkru7u9I0xS/1/v7+1KxZM7KysqJSpUpR+fLlaeHChUSUeumNvb19oR0U04uNjaV169ZR69atydTUlDp06CDOk8vl4j9VUhz8Dh48SObm5nTv3j0xkyJf2iJ/9OjRJAiCSi5PSev48eOko6NDT58+FaedP3+eLl26REREz549o61bt1KLFi2oefPmNGXKFPEA2qZNGxo2bFih5v38+bN4CY25ubnSJR+KS8JU3RYUWYhSv5SamZkpnVmS/pfWly9fUocOHahq1ark5uZW6F8AFe1S0RbSDiBx9OhRsTCNjIykixcvUp8+fahPnz60YMECcf/Rrl07cnNzK7TMipvET5s2jczMzKhv375UoUIF8Xig2Mbp24Iq28bZs2epfPny9Ouvv9Ljx48zzFcMOtG5c2fxkl1FEV2YFO1BkXfDhg1i3rT7sD179pCzszO1adOGlixZwvedYtni2q5gSbG+k0JtRyTN+k5qtR2RNOo7KdV2RFzfFRau75i6445RCVqwYAE5ODiIp5oTZb6ju3TpEq1du1Zlv2QoMs2fPz/LvGl3MAEBATR06FCaOHFi4QZNY/bs2WRra6t0LxN3d3dyd3dX+uVVMXLps2fPiIjoyZMnVLFiRbGILmxpC41Lly7RoEGDqGHDhjRq1Ch6/vy5OE/VxRJR6peQOnXqZHnj+vQZjx8/TtevXy+MaJn6/PkzmZiYiDcGJ0q9j4yhoWGGS6+ISGzn4eHhNG3aNLK2tqbExMRCy5t2+92/f59+/vlnqlWrFrVv357u3bsnzlOXSzw+f/5MjRo1yvILfvqc79+/L/Qv14ptqmgLv//+uzjv1atXZGRkREePHs2wnuJ9Dw0NpQkTJlCZMmUKtS0ofPjwgfbu3UtOTk4kCAIdPnxYnKfqM4bTSkxMJGtra1q9enW2y505c4aaN29OEydOpKtXrxKRal7H58+fs8yb/tg2ePBgqlSpEj158qQQEzIp4dquYEmxvpNSbUckrfpOarUdkbTqOynUdkRc3xUWru+YFHDHqMRERUVR27Ztac2aNZnOVxxovL29VX5JDVFq3jZt2uQob3JyMiUmJqrsjAJfX18SBEHpl81jx46Rubm5ePPyzHbO/v7+1KdPH/r2228LLevXvHv3jhYsWEDNmzenb7/9Vvy1Ux34+flR9erV6e+//86ymI+OjqZhw4YpfeFSlREjRpCpqanS5VJNmjQRfxnO7DXI5XK6cuUKTZ8+Xbw3jqrEx8fTnj17qGPHjlSrVi1asWKFSvOkJZfLKTg4mGrUqEEHDhzIcrnY2FgaPHiwym9mPnHiRBIEQemsoazaQtr/9/X1pRUrVtCtW7cKLWt6iYmJdOPGDRoyZAgZGxvTuHHjxHnq8CWKKPX+c82bN1caHVpBsT3TXpap6tw5yZt2H3blypVCy8akhWu7glVU6jt1ru2IpFXfSb22I1Lf+k5qtR0R13cFjes7JgUaYJKir6+PkJAQJCYmAgDkcrnSfA0NDURGRmL27Nm4d++eKiIq0dfXx+vXr3OU986dO9DR0YGurq4qouL48eMAgEuXLonTfvjhB3h4eKBu3bogImhpaSE6Ohp79+4VX5OdnR0WLVqEffv2qSQ3AERGRsLPzw/Hjx/HgQMHULJkScyePRtTpkyBnp4eFixYgIcPH6osX1oaGhrw8/NDiRIlIAgCiCjDMkFBQfD390d0dHThB0wjISEBurq6cHR0xA8//ABfX194enoiOjoay5YtU1p23rx56NevHwBAEAQ0b94cs2bNQpMmTQo1c3BwMG7cuIFff/0Va9asgZaWFgYMGAAPDw+0atUKK1asgLe3d6FmyoogCNDU1IS/vz/MzMwAINP2EBYWhsDAQISHhxdywi8SExNhZ2eHFi1aoFOnTjh37hwWL16MmJiYDG1h2rRpaNGihfh37dq1MXbsWDRs2LDQ8qbfjjo6OmjSpAmWL1+OpUuX4vTp06hduzZu3rwJDQ3VlgKKrBEREdDR0YG+vn6GZQRBAACsWLEC69evBwCV5VYcx3KSd+XKlfjll18AAM2bNweQeRtnxRvXdgVLqvWdlGo7QDr1nRRrO0A69Z2UajuA67uCxPUdkxItVQdgOUdESE5Ohra2tngQ0dDQgFwuz7AD0dLSQkxMjCpiinKbNy4uThUxRSNGjICxsTFmzpyJU6dOISUlBc2aNcPYsWNBROKOsEePHkhOTsaAAQMApGavUKGCynI/f/4crq6uMDU1xYMHD6ChoQF7e3s0bNgQ3333HSpXrowHDx6gZs2aKsuYlp2dHRwcHLBq1SqsW7cOFhYWAKDULoKCgvDp0yfo6OioMioMDAywevVq/PHHH/jrr7/w/fffw9fXF8ePH0epUqXEzLdu3cL8+fNx5coVAIBMJoOmpiZMTEwKNW9AQAA6d+4MY2Nj3L59GwDg6OgIV1dXNGrUCGXLlkWXLl1UUtBnpUyZMqhbty4WLlyIypUro1y5cgC+bEMAePHiBWJjY8UCWxV0dXUxYcIE1KpVC3v37sXo0aPx8uVLHDlyBKVKlRLz3rp1C+vWrcO5c+eUXkdhdwoIgoDY2FgcOHAAr1+/RnBwMJydneHu7o4hQ4agevXq+Omnn7B582Y0bty4ULNllhUAoqOjERUVBT09PQBQ2u8qJCUlISIiQql9FDbFfio6OhrR0dFfzRsZGamUN/0yrHjj2q7gSbG+k1ptB0invpNabQdIr76TSm0HcH1X0FkBru+YRBTm6aksf8yfP5/09PRo69at4rS0lwCtXLmSHB0dle6BoUpSypuSkkLXrl0jFxcXEgSBVq5cqTR/06ZNZGpqKt4MWh0yExHduXOHjhw5Qrq6uqStrU2HDh0iIvW575SCIs/kyZNJS0uLli9fTmFhYeIlEzKZjF6/fk3ly5fP8h5VhSntpRx3796l0aNHU7Vq1Wjw4MFKo8JWqFCBpk6dmmEdVQgMDKQLFy6Qjo4OmZqaivfPUre2QPQl0+rVq0lXV5fGjBmT4Sb9AQEBZGdnR0uWLFFVTCJS3n4vX76kZcuWUf369embb75RGj1aXdpCcnIyzZgxg9q0aUPlypUjQRCoVatWSvusoKAgcV+s6nZLRHTq1CnS0tKilStXijnT5oqJiaGGDRvS5s2bVRVRiSLvihUrJJGXqTcp1UpE0ssrxfpOKrUdkbTqOynWdkTSqe+kVNsRcX1XGLi+Y1LAHaMSothx+/n5UbNmzcjOzo5mzJhBwcHBRJR6A+g9e/aQoaGhym7Kn5bU8qYVFBREM2fOJE1NTerduzfJZDL68OED6erqivfLUYebWqfNYGNjQ56entSzZ0/xwK3Ohg8fTlpaWtSlSxfavXs3PXnyhNauXUvt2rWjli1bqjqeKG2hERcXR+vXr6fWrVtTy5Ytaffu3TRs2DCqVq2auIyqCtS0baFMmTK0ZMkSGj58OA0aNEgleXJr9uzZJAgCNWzYkBYsWED//vsveXh4kIuLC7Vu3VrV8YhIuS18/vyZTp48Sb1796YqVarQ4sWLadiwYVS9enVxGVV/WVEMMmJra0t16tShevXqqTRPduRyOYWFhZGrqyvZ2NjQsmXLKCgoSJwfFhZGAwYMoAYNGqgw5RdyuZxCQ0Opffv2ksjL1JfUaiWp5U1PCvWdlGs7ImnUd1Kp7YikXd9JobYj4vquIHF9x6SCO0Yl6uHDh9SxY0cyNzcnKysrcnV1JVtbW2rUqBEtWLBA1fEykFpexa9CJ0+eJAcHB7Kzs6MyZcpQ//79iUj1B0QFRY5+/fpRnTp1KD4+nhYtWkQbNmwgIvX4lTArycnJtG3bNrK1tSUdHR0SBIHKlClDEydOzPRm16oik8koNjaWnj9/Lp5J4uXlRUOGDCEHBwcSBIECAgKISLVfptK3hYSEBPr9999p27ZtSvPV2eXLl6lOnTpkYWFBGhoaZG9vTz///DNFRUWpOhoRpd5o/d27d3T37l16/PgxEaWODOvh4UGVKlVSm7aQ9vnd3d2pXr165OPjQzY2NmJudRUSEkLNmjUjQRDIxcWFpk+fTh4eHtS6dWuqUqUKBQYGEpF6nM1FJL28TL1JrVaSWl4iadR3Uq7tiKRR30mltiOSfn2n7rUdEdd3hUFq9ZLU8rL/TiDiu8RKBf3//haKezsBwK5du/D48WMEBASgcuXK6NGjB+rXr6/ipKmklFcmk2Hnzp2IiYnB48ePYWZmhuXLl4OIEBQUBA8PDzx8+BA+Pj4AkOm9tApbSkoKtLS0sH//fgwaNAg3b95EnTp1AACfPn3K9IbRqhYZGYnw8HD4+/sjJSUF3bp1AwCcP38elpaWsLKygo2NjYpTfrFnzx7s3bsXL1++xOvXrzF8+HCsWbMGAPDu3TusX78eDRs2ROfOnVV6TxwptgUgdSCBN2/e4N69e0hOTsaECRMAAPfu3YO5uTlMTU1hbm6u4pSp/vrrL6xatQoREREICQlB7969sWfPHgBATEwMDh48CHt7e7i4uIjvh6oonv/UqVPo2rUrLl++jJo1a2Lfvn3o06ePSu6PlhXK5L5NAPDLL7/g4MGDePXqFQRBwMCBA9GtWzfUr19fpZ+17PIeOnQIgYGBEAQBgwYNQteuXVWel6k/KdVKgPTySq2+k+rxXEr1nVRqO0Ca7UFKtR3A9V1B4fqOSQ13jErIqlWr8ODBA9y6dQuamprYs2cPateurepYWVq1ahXu37+P27dvq33ew4cPY8WKFQAAb29v2NrawtfXVzxwR0dHQxAEmJqaqvygCHy54XdMTAzKlCmD+fPnY/LkyVnu1NVBZgMJ3Lhxo1BHcsytvXv3QltbG+vWrcP169dRt25d3L17V9WxlKRtCzY2Npg3b57atwUg84EETp06hQ4dOojLKA5P6vA6zpw5A319fSxduhTnz5+Hvb09Xrx4oRbZ0lK0h8TERFhZWWHq1KmYPXu2qmNlK+0gAoGBgXBxccGgQYMQFRUFAwMDfPr0SeWDM6Sl+KKUPm9kZCQMDQ3VLi9Tb1zbFSwp1XdSrO0A6dV3UqjtAGnWd1Kr7QCu7woS13dMUgr3BFWWV+Hh4TRq1ChavHgxGRoakiAItHDhQiKiTG8KrGpSy/vx40ciImrXrh05OjpSpUqV6O3btypO9XWtWrUiV1dXtdqW2bl7926mAwmoI8WlKr6+vqShoUGLFi2iypUrU1BQEMnlcrW4dClthhYtWlDbtm0l0xaIsh5IQN0o2sL9+/dJEARav3492dvb0927d9WmLRApt4dvv/2WmjdvrvJLvr4ms0EEWrRooZRbndp0cnIyzZw5UzJ5mXqTWq0ktbxE0qzvpFbbEUmnvpNCbUck7fpOKrUdEdd3BYnrOyY1qr0WmOVYqVKl8Ouvv8La2hoGBgbo1q0bAgMDAUA8hVvVl3anJaW8SUlJMDExwaZNm+Dt7Y0DBw5AEAScP39e1dGydfDgQdy+fRubNm1Sm22ZlZSUFABAvXr1MHbsWMyZMwddunTBjRs3VJwsc3K5XDxr5LvvvsPIkSPRu3dv6Orqir/Uq+KXZLlcrvS3IoOXlxeCg4OxdetWtW8LwJf2YG9vj8GDB2P+/Pno3bs3/v33XxUnyyhtW+jcuTNGjRqFnj17omLFijA3N1dZW1BkS0uRY+vWrTh//jx+++03lZ/d/jVaWlqYM2cOzp8/DyJC7dq1ERsbq5Rbndq01PIy9SalWgmQXl4p1ndSqu0AadV36lrbKbKlJcX6Tkq1HcD1XUGTWr0ktbysAKiyV5blTFJSEhERPX36lDQ1Nen06dP066+/Us+ePenz588qTpeRlPIqznB4/fo1aWtr0+bNm0kul9Off/5JoaGhKk6n/AthZGQkPX78mN6/fy9O8/X1VUWsXJPaQAKKvEOHDqVq1aqJN+YPCwsT/19VmYiITp8+TQsXLqTz58/Thw8fiIiURkxUd1IaSCBtW3B0dBTf/4iICIqNjVVlNNH+/fvFm8DLZDLq2bMn7dq1S7Whckhqgwgojm/u7u5Ut25dMe+jR49UnIxJjZRqJSLp5VXn+q6o1HZE0qrv1LG2S5uLSNr1nZRqOyKu7woa13dMarhjVM2lPYhUr16dBg4cSESpI6U9f/5cVbGyJKW8abPWq1ePevbsmeV8VVEU9lu3bqUmTZpQ1apVycbGhtavXy8uo05FZ2YUB8Z9+/aRjo4O3bt3T5yXkJCgolRZU+Q9efIkaWlpkbe3NxGprj0kJCRQXFyc+PfcuXOpZMmSVLlyZRIEgTp06EBXrlxR2pbq0HazIqX2oG5tIS1FhocPH5IgCDRgwAC6du0aEZFajfSanfTb9+rVq/Tx40fasmWLePmrOpFaXqa+pFQrEUk7rzrWd0WhtiPi4/l/VZTqOym1BSL1bA8KXN8VPqnlZQWDO0bVWEpKilgYTZkyhezs7MRfD9WRuudNX2QqdoIeHh5UpkwZCgsLU0WsLCkKZx8fHzIxMaH169fT/fv3ycXFRbzvSXBwsIpTZk/xGj5+/EiGhoa0cuVKIlKPwiMzijby+fNnMjMzowULFqg4EVGzZs1o3Lhx9PbtWwoODqZKlSrR6dOniYjoyZMnVK9ePbKzs6NffvmFXr9+reK02UvbHoyMjNS6PaRtCyYmJuTp6aniRF8o9l0vX76k7du3k6OjIxkZGVHJkiVpw4YNFBERoeKEX6doC58/fyZTU1O1+KxlJ31exX0VGcstda+V0pNCXinVd0WhtiOSVn2njrUdUdGp76RU2xFxfVfQuL5jUsUdo2okq1+H//nnH9LS0qLz588XcqLsSSlv2oPzTz/9JF5G5ePjQ4Ig0IkTJ1QV7atat25NkyZNIiKi27dvk5mZGa1du5aqVatGpUuXpp07d6o44dep80ACaduG4v87dOhAzZo1U+mNzRVZVq9eTQYGBtS0aVM6ffo0jRw5MsMlXxMnTiQLCwvq3r270q/06kRqAwko8vbv31+tbnKfdjtWrVqVxo4dS1evXqWgoCAaN24cCYJAAwcOJF9fX7XJnJ7UBhGQWl6mXqRUKxFJL69U67uiUNsRqW99p661Xdo8RaG+k1ptR8T1XUGSWr0ktbysYHHHqBpRfDgnTJhAS5cuFaeXLl2aJk6cqKpYWVLknTRpktrnVWSdN28e1apVS7yX07x58+jnn39WZbRMKS6tef36Nbm5udH9+/eJKPWSsNmzZxMR0dq1a0kQBBIEQW3v10JEdODAATIyMhLvkaMu0hduaS+V2LRpEwUEBBR2JFH6X9k/fvxIzs7OpKmpSQYGBnT16tUM6/z9999UqlQpunv3bmHFzFZWhfGFCxeofPny9OrVq0JOlDXFfYWSkpLo8ePH5OPjQ4mJiUSUelmNOp69c/LkSSpVqhSFhIQoTVeMCty0aVM6evSoOF2VZ25k1Ra2bNlCOjo6ancprtTyMvXGtV3BklJ9V5RqOyL1rO/UubYjkn59J6Xajojru4ImtXpJanlZ4eKOUTWh+KA+ePCAbG1tycfHh4iIHj9+TPPmzaNPnz6pMl4GirwPHz5U+7yKLOHh4TR69Gj6888/xXkfPnxQu1+GfvnlF/r2229pxowZRETk7e1NERER5OXlRXXq1BF32tevX6exY8eqvMgjkt5AAmnzrlq1inr16kUtW7akuXPnqjBVRmvXrqV27dqJX05XrlxJgiBQu3bt6O7duxnaruJyEFWTykACioJZoUePHlS1alUSBIFatmxJp0+fVhpURNWXhW3btk38kufr60ulS5cWvzh//vyZ5HI5JSYmkouLCzk6OpKWlhb98ccfqoysRGqDCEgtL1M/XNsVLCnVd1Ks7YikVd9JpbYjkmZ9J5Xajojru8ImtXpJanlZ4eCOUTXw9OlTIkr9YG7YsIHc3d2V7umUfueuKoqDslTyEhGtWbOGRo0aRTKZjEaMGEFVqlShZcuWqTpWln799VeqU6cObd++PcMv8F5eXmRmZib+ujl58mRq27atClJmpGgbv/32myQGElDkXb58OVWsWJHGjRtH69atI0EQxJETFQo7t+L5FG1h27Zt5O/vL8738fGhChUqkI2NDe3atYuio6MLNV92pDSQwJs3b2jUqFFi4bljxw6ytbWlCxcukI+PD7Vu3ZpKlixJ8+bNU9r+qrJhwwaytbUVC+eYmBiqWbMmtWjRQulLKlHqfQBv3LhB06ZNo7Jly1J4eLgqIhOR9AYRSJ+3f//+ap2XqS+p1EpSrO2IpFXfSbW2I5JWfafOtV3a55RafSel2o6I67vCwvUdK2q4Y1TFnj59SoIg0KtXr2jhwoVka2tLFStWVLpRvKp/xSL6cjD38/MjQRAoMDCQPD091TYvUepoqRoaGrRr1y5KSEigvn37UpkyZahGjRp05swZcTl1yfvy5UvS19enI0eOiNPSFm6xsbHUpEkTMjAwoGbNmpGhoaFa/FKvKETv3bsnqYEEXr58SZaWlnT8+HEiIlq8eDHZ2dlRy5YtSUtLizZu3FjomRRtUdEWDh8+LM5LTk5WOmNg2LBhpKmpSYMHDxa/0KqalAYSuHHjBgmCQNWrV6fTp0/TsmXLaMuWLUrLLF26lExNTalLly50+vRplXUMhISEkJaWFu3fv1+cJpPJ6NKlS9SsWTOqXbs27du3j/z9/en3338nTU1Nun//Pp07d44qVaqkssscpTaIgCJvYGAgbd++napVq6bWeZn64tquYEmpvpNqbUckzfpOHWs7ImnXd1Kq7Yi4visMXN+xoog7RlWsRo0aNHz4cCJKLTwGDBhA5cuXp759+9KtW7fE5dShuCOSVt7atWuTm5ub0rQhQ4ZQ06ZNqU2bNrRx40a1+oVoxIgR1K9fv0znKQqmu3fv0vbt22nWrFlqNwCC1AYSWL9+Pbm7uxNR6mWOlpaWdOrUKQoODiZ7e3sSBIE6d+6skmyKtpDZ50hxbySi1O0sCALt2bOnMONlIKWBBNJu08TERBoyZAjp6+tT9erVadSoURmWf/jwIVWqVIkaNGigskvZateuTYMHD1aa1qtXL7py5QpdunSJRowYQYaGhmRqakoVK1akxYsXE1Hq/agqV65Mb9++LfTMUhtEQGp5mXqTUq1EJL28UqrvpF7bEUmrvlPn2o5IWvWdlGo7Iq7vCovU6iWp5WWqwx2jKjRx4kRydHSkT58+iR/a5cuX0+DBg6levXrUpUsX2rt3r9I9UFRB8ct2ZnlXrFihdnmJiObPn0/W1tZK00aNGkWjRo2i27dvU69evahBgwY0ZcoU8vb2VlHKVIpt2bt3bxo5cqTStPR69uxJx44dK7RsmUmbTUoDCSQnJ9P+/ftp0KBB9OHDB3r8+LFYzA8ePJgGDx4svrYxY8bQ2rVrxeKusL4Mpm0LI0aMyPa5u3btSt7e3iq/vFFKAwkosiYlJdHevXtp3LhxRJR6iaChoSGVKVOGzp07J963Lu1rS3uZaWHKbF/m7u5OtWrVErNER0dTeHg4eXt7i2d4PXv2jMqWLUuenp6Fmjc9dR5EILPnyirv4cOHVZ6XSQPXdgVLKvWd1Go7ImnWd1Ko7dI+l1TqOynVdkRc36kC13esqOGOURW5e/cuCYKgdGDZvn07lS9fnqKjo+ny5cvUvn17atasGU2fPp1evHihwrTSyvv+/XuqWLEiOTk5iXnPnDlDhoaG4sE6OTmZlixZQtWqVaMePXoo3RdHFeRyOTk7O1O3bt2yXObTp080YsQItfllXjGQwPTp04kodSCBDx8+qO1AAsOHD6fvvvuOJk2aJBabisKjf//+NHnyZCJKLapcXFxUdhPunLSFz58/0w8//EDbtm0rxGTZk9JAAoq2MHbsWLEtvH37lho3bkwmJia0evXqDPdtUkWBlNW+zMLCQrzUUpHr3r174hfTu3fv0pgxY6hHjx6FnplIeoMI5DRv69at1SIvU19SqpWIpJdXavWdFGs7ImnVd1Kp7YikWd9JqbYj4vquoHF9x4oy7hhVkcWLF5ONjQ398MMP9OzZM5LJZFSyZElat26duExUVBRNnTqV7O3tVX5Wo9Tyenl5UefOnal58+a0cOFCKlmyJP32229EpHypytmzZ8nLy4uIVP/L0KpVq8jU1JT+/vtvpcIi7X2JqlWrRufOnVNVxExvHC+FgQS2bNlCpUuXJj8/P3Fa2l+GZ8+eTZqamjRp0iTq3r07lStXThUxRVJoC0TSGkhAkVXRFp48eSLOS7tP8PDwIEEQqFu3bnTz5k2VF/nZ7csU2SIiIsjExET8IpWcnEy+vr4UHx9f6HmlMoiAoj2kzxsbG6uWeZk0SK1WklpeIunVd1I+nqt7fSe12o5IGu1BSrUdEdd3hYXrO1bUcceoishkMjp06BC5uLhQu3btqFKlStSzZ09xXtpf4O7cuaOqmCKp5SVKPZhMnDiRHBwcqEyZMkq50h4o1YWfnx/Z2NiQo6MjnTx5Uun+WKGhodSyZUuV/UJIlP2N49V5IIHIyEhycHAQi43MxMfH05IlS6h+/frUu3dvevDgARGRyu41o+5tgUiaAwlERERQpUqVMm0Lad/rJ0+eUOXKlalEiRIUGRlZmBEzlX5fdvv2baX5nTp1IhcXFxWl+0Iqgwgo2m5wcHC2eevUqUMHDhxQeV4mHVKrlaSWV0FK9Z3Uj+fqWt9JsbYjUv/2IMXajojru4LG9R0rDrhjVMWCgoLIzc2NbGxsyN3dXemDqG7FHZH08spkMjpy5Ai1atWKXFxcaOvWrUrz1M2zZ8+oUaNGpK+vT4MGDaIFCxbQzJkzqXnz5lS7dm2V30+SKPsbx6vjQALe3t5UrVo1unXrVpZnjYSFhdG0adPo8+fP4q+wqm4fUmgLRNIaSCAnbSEoKIhWrFhBRKlnHBGp/mxyooz7MsUIq7t27SIjIyOKjY0lItVexia1QQSklpdJh9RqJanlJZJWfVcUjufqVt9JtbYjkkZ7kFJtR8T1XUGTWr0ktbxMPXDHqBpITk6mTZs20TfffEMdOnSgQ4cOqTpStqSWlyj1YKgYsXT06NEqv09WdsLDw8nT05PKlStHNjY2VLZsWVq8eDE9e/ZMpblyc+N4dRlIgCi1WBIEgd68eUNEmWf+559/qFWrViq/HCg9dW0LRNIbSIAo523hm2++EQeeyGo5VVHsy5ycnGjAgAEkCAIdOHCAiFR7FoxUBhFQvJdSycukS2q1ktTyKkilvisqx3N1qe+kXNsRqW97kGJtR8T1XUGSSr3E9R37r7hjVI08ePCAunfvTs7OzjRu3DiV3D8kN6SWNykpiTZt2kRVq1YVf41TZ7GxsRQdHS3eG0UdSHEggQ8fPpCVlRVNnjxZ/NWVSPmsgd27d1PLli0pJiZGFRG/Sh3bApH0BhIoCm2B6Mu+zNbWVhx5VZXFvdQGEZBaXiZtUquVpJaXSFr1nZSP5+pU3xWV47k6tgep1XZERac9cH1XvPIy9cIdo2omPj6eZsyYQe7u7qqOkiNSy0tE4miaLG+kcON4BblcTklJSdSvXz8yNjambdu2Kd1TSCaTUUBAAJUuXZp+//13cRrLOam0h6LYFtIOhqDqrFIbREBqeZm0Sa1WklpeBa7v/hs+njMFqbQFoqLZHri+Kz55mfoQiIjA1M6nT5+gr6+v6hg5JrW8AEBEEARB1TEk5+nTp2jTpg1MTEywfPlyODs7w8zMDAAQFhaGfv36wdLSEgcPHlRt0DRSUlLQq1cvnD59GgMHDkTHjh3RqFEjHD58GEePHoWxsTGOHz+u6piSJLX2UBTbgrrsyyIjI7FgwQKcOnUK8fHxOHbsGBo0aCDO79y5MxISEuDl5aXClF9ILS+TPqnVSlLLq6Au+0Sp4eM5U5BaWwCKZntQl32Z1OolqeVl6oE7Rhljufb8+XMMGjQIDx8+RM+ePVG5cmUkJCTg2rVr+PjxI27fvg1tbW1Vx1QSGxuLjRs3YvHixfj06ROSkpJga2uL7t27Y/HixdDT04NMJoOmpqaqo0qO1NoDt4WCI5fLcfz4caxbtw6CIKBv374YPnw4du/ejdGjRyM0NBRGRkZqs32llpcxxgoSH8+ZgtTaAsDtoSBJrV6SWl6metwxyhjLk3fv3uG3337D5s2bIZPJIAgCxowZg+7du6Ny5cqqjpel+Ph4XLp0CZaWlihfvjysrKwgCAIfGP8jKbYHbgsFJzg4GB4eHnj+/DnKly+PP/74A/v370fPnj2RkpICLS0tVUdUIrW8jDFWUPh4zhSk2BYAbg8FSWr1ktTyMtXhjlHG2H8SFxcnFksmJiaqjpNr6nKZSlEh5fbAbSF/JScnY9u2bfD09ETXrl2xbt06td7GUsvLGGMFiY/nTEHKbQHg9pDfpFYvSS0vUw3uGGWMMcZYgQkICEDFihUBpF7apKGhoeJE2ZNaXsYYY4yxwia1eklqeVnh4o5RxhhjjBU4qf06L7W8jDHGGGOFTWr1ktTyssLBHaOMMcYYY4wxxhhjjLFih88fZowxxhhjjDHGGGOMFTvcMcoYY4wxxhhjjDHGGCt2uGOUMcYYY4wxxhhjjDFW7HDHKGOMMcbyrGXLlpg4caKqY+TKjh07YGZmlqt1/uvrvHz5MgRBQHR0dJ4fgzGWM0Xl85Yf+1dBEHD06NF8yZNTQ4YMQdeuXQv1OVlGeTnWMcZYccQdo4wxxhgrNOrwRa1Pnz54/vx5rtY5fPgwFixYkKNlM+vMcHJyQmhoKExNTXP1vAqFvd0eP36MHj16wN7eHoIgYM2aNYX23FJmb2+PHTt2qDpGgZs7dy7q1Kmj6hhZ+q+ft8KWVUdubvY7hUHd33fGGGMsL7hjlDHGGJO4kJAQzJw5Ex8+fFB1lEIjk8kgl8vztK6+vj5KlSqVq3UsLCxgbGycp+cDAB0dHVhbW0MQhDw/RmFKSEhAhQoVsGTJElhbW6s6DmO5IrXPW1b+636nuEtKSlJ1hEJRkK8zOTm5wB6bMcbUBXeMMsYYYxIWFRWFVq1aISYmBiVKlCjQ54qPj8fgwYNhZGSE0qVLY+XKlRmWSUxMxNSpU2FjYwNDQ0M0btwYly9fBpB6VpS7uzs+fvwIQRAgCALmzp371fWAL2dMHj9+HNWqVYOuri6Cg4Nhb2+PhQsXirns7Oxw/PhxvH//Hl26dIGRkRFq1aqFO3fuZHgsBcVZULt374a9vT1MTU3Rt29fxMbGisukPwv0119/hYODA/T09GBlZYWePXsCSL2E9MqVK1i7dq34Gl+9epXpGWHXrl1Dy5YtYWBgAHNzc7i6uiIqKirDNs1uu0VFRWHw4MEwNzeHgYEBOnTogBcvXmR4rUePHhXzurq6IiQkJNv3umHDhli+fDn69u0LXV3dbJdVCAoKQufOnWFubg5DQ0NUr14dp0+fznSbA8DRo0czdFydOHECDRs2hJ6eHkqUKIFu3bqJ8xITEzF9+nTY2tpCV1cXlSpVwu+//y7Of/ToETp06AAjIyNYWVlh0KBBSj8WHDx4EDVr1oS+vj4sLS3Rpk0bxMfHi9u4UaNGMDQ0hJmZGZydnREUFJSj171jxw7xfQkKCoK7uzsEQUDLli1ztH5eZPdaL1++DB0dHfz777/i8suWLUOpUqUQHh4OADh79iyaNWsGMzMzWFpaolOnTggICFB6jtevX6Nfv36wsLCAoaEhGjRogJs3b2LHjh2YN28e7t+/L77urM6SVVxSvWjRIlhZWcHMzAzz589HSkoKpk2bBgsLC5QtWxbbt29XWm/69OmoXLkyDAwMUKFCBfz8889iBw0RoU2bNnB1dQURAQAiIyNRtmxZzJkzR9wGaT9vivZ38uRJVKlSBQYGBujZsycSEhKwc+dO2Nvbw9zcHOPHj4dMJhNzZHYZupmZmfh6X716BUEQsH//fnzzzTfQ19dHw4YN8fz5c9y+fRsNGjSAkZEROnTogPfv32e6jV69eoVWrVoBAMzNzSEIAoYMGQIg437na/vJnHj48CFcXFzEz8EPP/yAuLg4cX5Wn4XcvO8K8+bNQ8mSJWFiYoKRI0eKHXi7du2CpaUlEhMTlZbv2rUrBg0alOXjZdcugC/78t9++w3ly5eHnp4eAODp06do1qwZ9PT0UK1aNVy4cEHpvc3r+3j79m20bdsWJUqUgKmpKVq0aAEfHx+lbfm1z2JmDh06hOrVq0NXVxf29vYZjrX29vZYsGABBg8eDBMTE/zwww8AUtt5uXLlYGBggG7duiEiIiLDYx87dgz16tWDnp4eKlSogHnz5iElJUWcLwgCNm7ciO+++w6Ghobw9PTMMidjjBUZxBhjjDHJ6ty5MzVq1IgSExO/uqynpycZGhpm+y8oKCjL9UeNGkXlypWjCxcu0IMHD6hTp05kbGxMEyZMEJcZNmwYOTk50T///EP+/v60fPly0tXVpefPn1NiYiKtWbOGTExMKDQ0lEJDQyk2Nvar6xERbd++nbS1tcnJyYmuXbtGT58+pfj4eLKzsyMLCwvatGkTPX/+nEaNGkUmJibUvn172r9/Pz179oy6du1Kjo6OJJfLxccyNTUVM3t4eJCRkRF1796dHj58SP/88w9ZW1vTrFmzxGVatGghvs7bt2+TpqYm/fHHH/Tq1Svy8fGhtWvXEhFRdHQ0NW3alIYPHy6+xpSUFLp06RIBoKioKCIiunfvHunq6tKoUaPI19eXHj16RL/88gu9f/8+w3bPbrt999135OjoSP/88w/5+vqSq6srVapUiZKSkpS2W4MGDej69et0584datSoETk5OX21vSjY2dnR6tWrv7rct99+S23btqUHDx5QQEAAnThxgq5cuZLpNiciOnLkCKUtRU+ePEmampo0Z84cevLkCfn6+tKiRYvE+b179yZbW1s6fPgwBQQE0IULF+ivv/4iIqKoqCgqWbIkzZw5k/z8/MjHx4fatm1LrVq1IiKit2/fkpaWFq1atYoCAwPpwYMHtGHDBoqNjaXk5GQyNTWlqVOnkr+/Pz158oR27NghfhYCAwMJAF26dCnT152QkCC+L2XLlqU1a9ZQaGgoRUREZLmtvvY5HDFiRJbrfu21EhFNmzaN7OzsKDo6mnx8fEhHR4eOHTsmzj948CAdOnSIXrx4Qffu3aPOnTtTzZo1SSaTERFRbGwsVahQgb755hv6999/6cWLF7Rv3z66fv06JSQk0JQpU6h69eri605ISMg0q5ubGxkbG9OYMWPo6dOn9PvvvxMAcnV1JU9PT3r+/DktWLCAtLW1KSQkRFxvwYIFdO3aNQoMDKTjx4+TlZUVLV26VJz/+vVrMjc3pzVr1hARUa9evahRo0aUnJxMRJTh86b4HLRt25Z8fHzoypUrZGlpSe3ataPevXvT48eP6cSJE6SjoyO2KSIiAHTkyBGl12Rqakrbt28noi9to2rVqnT27Fl68uQJNWnShOrXr08tW7akq1evko+PD1WqVIlGjhyZ6TZKSUmhQ4cOEQB69uwZhYaGUnR0NBEp73eIvr6fzEza1xAXF0elS5cW93VeXl5Uvnx5cnNzIyLK9rOQ2/fdyMiI+vTpQ48ePaKTJ09SyZIlxX1qQkICmZqa0v79+8V1wsPDSUtLiy5evJjla/lau/Dw8CBDQ0Nq3749+fj40P379yklJYWqVKlCbdu2JV9fX/r333+pUaNGStslr++jl5cX7d69m/z8/OjJkyc0dOhQsrKyopiYGHGZr30W07tz5w5paGjQ/Pnz6dmzZ7R9+3bS19cX2xxR6j7ZxMSEVqxYQf7+/uTv70/e3t6koaFBS5cupWfPntHatWvJzMxMab/7zz//kImJCe3YsYMCAgLo3LlzZG9vT3PnzhWXAUClSpWibdu2UUBAQLY1AWOMFRXcMcoYY4xJ1IYNG8jS0jLHX1wiIiLoxYsX2f5TdCykFxsbSzo6OkpfZCMiIkhfX1/84h4UFESampr05s0bpXVbt25NM2fOJKLMO8hyuh4A8vX1VVrGzs6OBg4cKP4dGhpKAOjnn38Wp924cYMAUGhoaKYZPDw8yMDAIMOX2caNG4t/p+2gOHToEJmYmCgtn1b6zgyijB01/fr1I2dn50zXz0xm2+358+cEgK5duyZO+/DhA+nr64vvk2K7eXt7i8v4+fkRALp582aOnjunHaM1a9ZU+oL9tfzpO0abNm1KAwYMyHT9Z8+eEQA6f/58pvMXLFhA7dq1U5oWEhIidjbdvXuXANCrV68yrBsREUEA6PLly5k+9uvXr6lKlSo52l52dnZKHRhZ+drnMDw8PMt1v/ZaiVI70+vUqUO9e/ematWq0fDhw7PN8/79ewJADx8+JCKizZs3k7GxcZadux4eHlS7du2vvk43Nzeys7MTO1yJiKpUqULffPON+HdKSgoZGhrSn3/+meXjLF++nOrXr680bf/+/aSnp0czZswgQ0NDpc7BzDpGAZC/v7+4zIgRI8jAwED8kYGIyNXVValTOqcdo7/99ps4/88//yQA5OXlJU5bvHgxValSJcvXlz6vQtp9SU72k5lJ+xq2bNlC5ubmFBcXJ84/deoUaWhoUFhY2Fc/C7l53y0sLCg+Pl6ctnHjRjIyMhLbwqhRo6hDhw7i/JUrV1KFChXEH7ByIn278PDwIG1tbXr37p047cyZM6SlpSXu/4mIzp8/n2nH6H99H2UyGRkbG9OJEyfEabn9LPbv35/atm2rNG3atGlUrVo18W87Ozvq2rWr0jL9+vWjjh07Kk3r06eP0n63devWSj82ERHt3r2bSpcuLf4NgCZOnJhtRsYYK2q0CvJsVMYYY4zlr4iICGhqaiIyMhI//vgj/vzzT5QrVy5H61pYWMDCwiJPzxsQEICkpCQ0btxY6fGqVKki/v3w4UPIZDJUrlxZad3ExERYWlpm+dg5XU9HRwe1atXKsH7aaVZWVgCAmjVrZpj27t27LO+XaW9vr3Qvv9KlS+Pdu3eZLtu2bVvY2dmhQoUKaN++Pdq3b49u3brBwMAgy9eYnq+vL3r16pXj5TPj5+cHLS0tpffE0tISVapUgZ+fnzhNS0sLDRs2FP+uWrUqzMzM4OfnB2tra1SrVk2cN2vWLMyaNStPecaPH49Ro0bh3LlzaNOmDXr06JHp+5UVX19fDB8+PMt5mpqaaNGiRabz79+/j0uXLsHIyCjDvICAALRr1w6tW7dGzZo14erqinbt2qFnz54wNzeHhYUFhgwZAldXV7Rt2xZt2rRB7969Ubp0aQCAjY0Nnj59muPXkROVKlXK87pfe62VK1eGjo4O9u7di1q1asHOzg6rV69WWu7FixeYM2cObt68iQ8fPoj36w0ODkaNGjXg6+uLunXr5nl/kVb16tWhofHl7l1WVlaoUaOG+LempiYsLS2VPm/79u3DunXrEBAQgLi4OKSkpMDExETpcXv16oUjR45gyZIl2LhxIxwcHLLNYWBggIoVKyrlsLe3V9qOVlZWWX7us5OTfVBeHjetvO5f0/Lz80Pt2rVhaGgoTnN2doZcLsezZ8/QvHnzbD8LuVG7dm2lfWLTpk0RFxeHkJAQ2NnZYfjw4WjYsCHevHkDGxsb7NixA0OGDMn2vrA5aRd2dnYoWbKk+PezZ89ga2urtO9v1KhRpo+f2/cxPDwcs2fPxuXLl/Hu3TvIZDIkJCQgODhYXOZrn8X0/Pz80KVLF6Vpzs7OWLNmDWQyGTQ1NQEADRo0yLBe2luPAKnb/OzZs+Lf9+/fx7Vr15Quj5fJZPj8+TMSEhLE9yv9YzPGWFHHHaOMMcaYhDRv3hzNmjVDYGAgevXqhc6dO+d43UWLFmHRokXZLvPkyZMcd7SmFxcXB01NTdy9e1f88qaQWSdObtfT19fP9Euztra2+P+K+ZlNy26wprTLK9bJanljY2P4+Pjg8uXLOHfuHObMmYO5c+fi9u3bOR45Xl9fP0fLFbQyZcrA19dX/Pu/dIQNGzYMrq6uOHXqFM6dO4fFixdj5cqVGDduHDQ0NMT7QSqkH9Qju23yte0VFxeHzp07Y+nSpRnmlS5dGpqamjh//jyuX7+Oc+fO4ZdffsFPP/2Emzdvonz58ti+fTvGjx+Ps2fPYt++fZg9ezbOnz+PJk2a5GIL5Fx2nwcAGDhwIDZt2pTpvK+9VoXr168DSL3/ZmRkpFJnWOfOnWFnZ4etW7eiTJkykMvlqFGjhngPyPxsn5l9trL7vN24cQMDBgzAvHnz4OrqClNTU/z1118Z7rOYkJAg7jPS3lc3v3Io/v5au03/2Fntg/I6WJxCXvevuVVYn4W6deuidu3a2LVrF9q1a4fHjx/j1KlTWS6f03aRtp3nVm7fRzc3N0RERGDt2rWws7ODrq4umjZtmmEwpOw+i3mVl8eIi4vDvHnz0L179wzzFPdjzetjM8aYlHHHKGOMMSYhtWvXxpYtW1C2bFkcOHAgV+uOHDkSvXv3znaZMmXKZDq9YsWK0NbWxs2bN8WO06ioKDx//lw8i69u3bqQyWR49+4dvvnmm0wfR0dHR2lwk5yup260tLTQpk0btGnTBh4eHjAzM8PFixfRvXv3TF9jerVq1YKXlxfmzZuXo+fL7DEdHR2RkpKCmzdvwsnJCUDqGcXPnj1TOgs0JSUFd+7cEc+SevbsGaKjo+Ho6AgtLa3/dPZiera2thg5ciRGjhyJmTNnYuvWrRg3bhxKliyJ2NhYxMfHi1+603bIAl+2ibu7e4bHrVmzJuRyOa5cuYI2bdpkmF+vXj0cOnQI9vb20NLKvLwVBAHOzs5wdnbGnDlzYGdnhyNHjmDy5MkAUtth3bp1MXPmTDRt2hR//PFHgXWMpn/t6aU/Cy6tnLzWgIAATJo0CVu3bsW+ffvg5uaGCxcuQENDQ2wjW7duFT9vV69eVVq/Vq1a+O233xAZGZlpZ3lO2nheXb9+HXZ2dvjpp5/EaZkNhDVlyhRoaGjgzJkz6NixI7799lu4uLjka5aSJUsiNDRU/PvFixdISEjI1+cAUrcngGy3aX7sJx0dHbFjxw6lz+G1a9egoaGhdPZ/Vp+F3Lzv9+/fx6dPn8ROdm9vbxgZGcHW1lZcZtiwYVizZg3evHmDNm3aKM1LL6ftIr0qVaogJCQE4eHh4lmgt2/fztFr+Jpr167h119/RceOHQEAISEhSgO+Adl/FjPj6OiIa9euZXieypUrZ+gQT7/ezZs3laZ5e3sr/V2vXj08e/YsX/f5jDFWFPCo9IwxxpiEjBo1Svxya2pqmqt1LSwsUKlSpWz/ZdXRYmRkhKFDh2LatGm4ePEiHj16hCFDhih9uatcuTIGDBiAwYMH4/DhwwgMDMStW7ewePFi8Uwge3t7xMXFwcvLCx8+fEBCQkKO1lMnJ0+exLp16+Dr64ugoCDs2rULcrlc7Fiwt7fHzZs38erVK6XLlNOaOXMmbt++jdGjR+PBgwd4+vQpNm7cmOFLtUJm283BwQFdunTB8OHDcfXqVdy/fx8DBw6EjY2N0qWY2traGDduHG7evIm7d+9iyJAhaNKkSZaXkwJAUlISfH194evri6SkJLx58wa+vr7w9/fPcp2JEyfi77//RmBgIHx8fHDp0iU4OjoCABo3bgwDAwPMmjULAQEB+OOPPzKMaO3h4YE///wTHh4e8PPzw8OHD8WzIu3t7eHm5obvv/8eR48eRWBgIC5fvoz9+/cDAMaMGYPIyEj069cPt2/fRkBAAP7++2+4u7tDJpPh5s2bWLRoEe7cuYPg4GAcPnwY79+/h6OjIwIDAzFz5kzcuHEDQUFBOHfuHF68eCFmLwhf+xyWKlUqy3W/9lplMhkGDhwIV1dXuLu7Y/v27Xjw4IF4Zp25uTksLS2xZcsW+Pv74+LFi2LnsEK/fv1gbW2Nrl274tq1a3j58iUOHTqEGzduAEh9PwIDA+Hr64sPHz5kGF38v3BwcEBwcDD++usvBAQEYN26dThy5IjSMqdOncK2bduwd+9etG3bFtOmTYObmxuioqLyLQcAuLi4YP369bh37x7u3LmDkSNHZjjLND/Y2dlBEAScPHkS79+/VxolXiE/9pMDBgyAnp4e3Nzc8OjRI1y6dAnjxo3DoEGDYGVl9dXPQm7e96SkJAwdOhRPnjzB6dOn4eHhgbFjxyodM/r374/Xr19j69at+P7777PNnpN2kZm2bduiYsWKcHNzw4MHD3Dt2jXMnj0bALK9bD8nHBwcsHv3bvj5+eHmzZsYMGCA0tnWX/ssZmbKlCnw8vLCggUL8Pz5c+zcuRPr16/H1KlTs82iOMt3xYoVePHiBdavX690GT0AzJkzB7t27cK8efPw+PFj+Pn54a+//hK3B2OMFVuqvskpY4wxxqQhNjaWBg4cSAYGBmRlZUXLli3LMNBQUlISzZkzh+zt7UlbW5tKly5N3bp1owcPHojLjBw5kiwtLQkAeXh45Gi9zAbvIcp8YCCkGzBFMbDGvXv3Mn2szAYUWb16NdnZ2Yl/p32d//77L7Vo0YLMzc1JX1+fatWqRfv27ROXffbsGTVp0oT09fUJAAUGBmY6uMrly5fJycmJdHV1yczMjFxdXTMMvpJWZtstMjKSBg0aRKampqSvr0+urq5Kg9AoXuuhQ4eoQoUKpKurS23atPnqgF2KbZb+X4sWLbJcZ+zYsVSxYkXS1dWlkiVL0qBBg+jDhw/i/CNHjlClSpVIX1+fOnXqRFu2bKH0peihQ4eoTp06pKOjQyVKlKDu3buL8z59+kSTJk2i0qVLk46ODlWqVIm2bdsmzn/+/Dl169aNzMzMSF9fn6pWrUoTJ04kuVxOT548IVdXVypZsiTp6upS5cqV6ZdffiEiorCwMOratav4uHZ2djRnzhxxkJivjUqfVk4HX/qvsnut8+bNo9KlSytt+0OHDpGOjo44eNn58+fJ0dGRdHV1qVatWnT58uUMn5tXr15Rjx49yMTEhAwMDKhBgwbiAFSfP3+mHj16kJmZGQHI8jW7ublRly5dlKZlNjhZ+s/xtGnTyNLSUhzZfPXq1eJn9t27d2RlZaU0iExSUhLVr1+fevfuTUSZD76Ufv+R2ec+fd43b95Qu3btyNDQkBwcHOj06dOZDr6k2Ldk9txZPX968+fPJ2traxIEQRwlPi/71/TSv68PHjygVq1akZ6eHllYWNDw4cPFAai+9lnI7fs+Z84c8X0cPnw4ff78OcOygwYNIgsLi0znpZdduyDKenAoPz8/cnZ2Jh0dHapatSqdOHGCANDZs2eJKO/vo4+PDzVo0ID09PTIwcGBDhw4oNSWc/JZzMzBgwepWrVqpK2tTeXKlaPly5crzc9qQLzff/+dypYtS/r6+tS5c2dasWJFhnZ39uxZcnJyIn19fTIxMaFGjRrRli1bxPnp2wtjjBUHAlG6G+cwxhhjjLEiYceOHZg4cSKio6NVHUWyLl26hO7du+Ply5cwNzfPdll7e3vMnTsXQ4YMKZxwjElc69atUb16daxbt67QnvPatWto1qwZ/P39lQbkYowxVjzxPUYZY4wxxhjLwunTpzFr1qyvdooCqfcuzM+BcBgrqqKionD58mVcvnwZv/76a4E+15EjR2BkZAQHBw/lmUkAAADsSURBVAf4+/tjwoQJcHZ25k5RxhhjALhjlDHGGGOMsSwtX748x8uWLFmyAJMwVnTUrVsXUVFRWLp0qdLATwUhNjYW06dPR3BwMEqUKIE2bdpke59PxhhjxQtfSs8YY4wxxhhjjDHGGCt2eFR6xhhjjDHGGGOMMcZYscMdo4wxxhhjjDHGGGOMsWKHO0YZY4wxxhhjjDHGGGPFDneMMsYYY4wxxhhjjDHGih3uGGWMMcYYY4wxxhhjjBU73DHKGGOMMcYYY4wxxhgrdrhjlDHGGGOMMcYYY4wxVuxwxyhjjDHGGGOMMcYYY6zY+R/SkIq0bOunIwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pair_values = list(permutations(COUNTRY_CONFIG[\"args\"], 2))\n", + "pair_order = [f\"{source}->{target}\" for source, target in pair_values]\n", + "pair_labels = [f\"{source[:2]}→{target[:2]}\" for source, target in pair_values]\n", + "function_order = [spec[\"name\"] for spec in COUNTRY_CONFIG[\"funcs\"]]\n", + "rank_data = conditions.assign(\n", + " pair=conditions[\"source\"] + \"->\" + conditions[\"target\"]\n", + ")\n", + "\n", + "\n", + "def _compact_rank(rank):\n", + " if rank >= 100_000:\n", + " return f\"{rank / 1000:.0f}k\"\n", + " if rank >= 1_000:\n", + " return f\"{rank / 1000:.1f}k\"\n", + " return str(rank)\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(18, 4.8), sharey=True)\n", + "last_image = None\n", + "for axis, alpha in zip(axes, SWAP_ALPHAS):\n", + " subset = rank_data.query(\"alpha == @alpha\").set_index(\n", + " [\"function\", \"pair\"]\n", + " )\n", + " ranks = np.array(\n", + " [\n", + " [\n", + " subset.loc[(function, pair), \"swapped_target_rank\"]\n", + " for pair in pair_order\n", + " ]\n", + " for function in function_order\n", + " ],\n", + " dtype=float,\n", + " )\n", + " last_image = axis.imshow(\n", + " np.log10(np.clip(ranks, 1, 1000)),\n", + " cmap=\"viridis_r\",\n", + " vmin=0,\n", + " vmax=3,\n", + " aspect=\"auto\",\n", + " )\n", + " for row, function in enumerate(function_order):\n", + " for column, pair in enumerate(pair_order):\n", + " trial = subset.loc[(function, pair), :]\n", + " rank = int(trial[\"swapped_target_rank\"])\n", + " if trial[\"success\"]:\n", + " annotation = \"✓\"\n", + " elif trial[\"target_tied_for_top\"]:\n", + " annotation = f\"{_compact_rank(rank)}†\"\n", + " else:\n", + " annotation = _compact_rank(rank)\n", + " axis.text(\n", + " column,\n", + " row,\n", + " annotation,\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=8,\n", + " color=(\"white\" if ranks[row, column] >= 50 else \"black\"),\n", + " )\n", + " axis.set(\n", + " title=f\"α={alpha:g}: target-answer rank after swap\",\n", + " xticks=np.arange(len(pair_labels)),\n", + " xticklabels=pair_labels,\n", + " yticks=np.arange(len(function_order)),\n", + " yticklabels=[name.title() for name in function_order],\n", + " )\n", + " axis.tick_params(axis=\"x\", rotation=55)\n", + "\n", + "colorbar = fig.colorbar(last_image, ax=axes, shrink=0.82, pad=0.02)\n", + "colorbar.set_label(\"log10(target rank), clipped at 1000\")\n", + "fig.text(\n", + " 0.5,\n", + " -0.04,\n", + " \"✓ = deterministic top-1 success; † = exact maximum tie lost by argmax order\",\n", + " ha=\"center\",\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b4a1184a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:13:29.721608Z", + "iopub.status.busy": "2026-07-26T08:13:29.721486Z", + "iopub.status.idle": "2026-07-26T08:13:33.635954Z", + "shell.execute_reply": "2026-07-26T08:13:33.635035Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
Full 48-trial matrix (top-1 tokens and target ranks)
function source target prompt source_answer target_answer baseline_top1 baseline_source_rank baseline_source_is_top1 baseline_target_rank alpha1_top1 alpha1_target_rank alpha1_success alpha2_top1 alpha2_target_rank alpha2_success
capital France Canada The capital of France is the city of ' Paris' ' Ottawa' ' Paris' 1 True 849 ' Montreal' 3 False ' Canada' 31 False
capital France China The capital of France is the city of ' Paris' ' Beijing' ' Paris' 1 True 2036 ' Paris' 2 False ' China' 17 False
capital France Egypt The capital of France is the city of ' Paris' ' Cairo' ' Paris' 1 True 5133 ' Cairo' 1 True ' Egypt' 7 False
capital Canada France The capital of Canada is the city of ' Ottawa' ' Paris' ' Ottawa' 1 True 99 ' Ottawa' 3 False ' Canada' 255978 False
capital Canada China The capital of Canada is the city of ' Ottawa' ' Beijing' ' Ottawa' 1 True 192 ' Beijing' 1 True ' China' 18 False
capital Canada Egypt The capital of Canada is the city of ' Ottawa' ' Cairo' ' Ottawa' 1 True 3109 ' Cairo' 1 True ' Egypt' 10 False
capital China France The capital of China is the city of ' Beijing' ' Paris' ' Beijing' 1 True 205 ' Paris' 1 True ' China' 255952 False
capital China Canada The capital of China is the city of ' Beijing' ' Ottawa' ' Beijing' 1 True 1502 ' Beijing' 3 False ' Canada' 31 False
capital China Egypt The capital of China is the city of ' Beijing' ' Cairo' ' Beijing' 1 True 2114 ' Cairo' 1 True ' Egypt' 9 False
capital Egypt France The capital of Egypt is the city of ' Cairo' ' Paris' ' Cairo' 1 True 112 ' Cairo' 2 False ' Egypt' 255973 False
capital Egypt Canada The capital of Egypt is the city of ' Cairo' ' Ottawa' ' Cairo' 1 True 824 ' Cairo' 5 False ' Canada' 45 False
capital Egypt China The capital of Egypt is the city of ' Cairo' ' Beijing' ' Cairo' 1 True 1002 ' Cairo' 7 False ' China' 21 False
language France Canada Most people in France speak ' French' ' English' ' French' 1 True 2 ' English' 1 True ' France' 80318 False
language France China Most people in France speak ' French' ' Chinese' ' French' 1 True 348 ' Chinese' 1 True ' France' 255996 False
language France Egypt Most people in France speak ' French' ' Arabic' ' French' 1 True 163 ' Arabic' 1 True ' Egypt' 158 False
language Canada France Most people in Canada speak ' English' ' French' ' English' 1 True 2 ' French' 1 True ' France' 2 False
language Canada China Most people in Canada speak ' English' ' Chinese' ' English' 1 True 137 ' English' 2 False ' China' 1 False
language Canada Egypt Most people in Canada speak ' English' ' Arabic' ' English' 1 True 216 ' English' 1 False ' Egypt' 70 False
language China France Most people in China speak ' Chinese' ' French' ' Mandarin' 2 False 549 ' French' 1 True ' France' 3 False
language China Canada Most people in China speak ' Chinese' ' English' ' Mandarin' 2 False 4 ' English' 1 True ' Canada' 161213 False
language China Egypt Most people in China speak ' Chinese' ' Arabic' ' Mandarin' 2 False 376 ' Arabic' 1 True ' Egypt' 1694 False
language Egypt France Most people in Egypt speak ' Arabic' ' French' ' Arabic' 1 True 17 ' Arabic' 2 False ' France' 2 False
language Egypt Canada Most people in Egypt speak ' Arabic' ' English' ' Arabic' 1 True 2 ' Arabic' 2 False ' Canada' 5604 False
language Egypt China Most people in Egypt speak ' Arabic' ' Chinese' ' Arabic' 1 True 730 ' Arabic' 6 False ' China' 2 False
continent France Canada France is a country on the continent of ' Europe' ' North' ' Europe' 1 True 9 ' Europe' 2 False ' Canada' 838 False
continent France China France is a country on the continent of ' Europe' ' Asia' ' Europe' 1 True 16 ' Europe' 3 False ' China' 64 False
continent France Egypt France is a country on the continent of ' Europe' ' Africa' ' Europe' 1 True 11 ' Europe' 2 False ' Egypt' 77770 False
continent Canada France Canada is a country on the continent of ' North' ' Europe' ' North' 1 True 12 ' Europe' 1 True ' Canada' 255822 False
continent Canada China Canada is a country on the continent of ' North' ' Asia' ' North' 1 True 7 ' North' 2 False ' Canada' 255907 False
continent Canada Egypt Canada is a country on the continent of ' North' ' Africa' ' North' 1 True 20 ' Africa' 1 True ' Egypt' 92146 False
continent China France China is a country on the continent of ' Asia' ' Europe' ' Asia' 1 True 8 ' Europe' 1 True ' France' 268 False
continent China Canada China is a country on the continent of ' Asia' ' North' ' Asia' 1 True 11 ' Asia' 2 False ' Canada' 9747 False
continent China Egypt China is a country on the continent of ' Asia' ' Africa' ' Asia' 1 True 7 ' Africa' 1 True ' Egypt' 210195 False
continent Egypt France Egypt is a country on the continent of ' Africa' ' Europe' ' Africa' 1 True 10 ' Africa' 5 False ' Egypt' 255947 False
continent Egypt Canada Egypt is a country on the continent of ' Africa' ' North' ' Africa' 1 True 3 ' Africa' 3 False ' Egypt' 255859 False
continent Egypt China Egypt is a country on the continent of ' Africa' ' Asia' ' Africa' 1 True 2 ' Africa' 2 False ' Egypt' 255965 False
currency France Canada The single-word name for the currency now used in France is the ' Euro' ' Dollar' ' franc' 6 False 437 ' Canadian' 73 False ' Canada' 28076 False
currency France China The single-word name for the currency now used in France is the ' Euro' ' Yuan' ' franc' 6 False 1027 ' franc' 9 False ' China' 486 False
currency France Egypt The single-word name for the currency now used in France is the ' Euro' ' Pound' ' franc' 6 False 310 ' franc' 210 False ' Egypt' 197295 False
currency Canada France The single-word name for the currency now used in Canada is the ' Dollar' ' Euro' ' Canadian' 17 False 171 ' franc' 9 False ' France' 219 False
currency Canada China The single-word name for the currency now used in Canada is the ' Dollar' ' Yuan' ' Canadian' 17 False 414 ' Canadian' 8 False ' Canada' 255822 False
currency Canada Egypt The single-word name for the currency now used in Canada is the ' Dollar' ' Pound' ' Canadian' 17 False 228 ' Egyptian' 68 False ' Egypt' 156564 False
currency China France The single-word name for the currency now used in China is the ' Yuan' ' Euro' ' ren' 5 False 143 ' yuan' 8 False ' France' 14565 False
currency China Canada The single-word name for the currency now used in China is the ' Yuan' ' Dollar' ' ren' 5 False 203 ' Canadian' 80 False ' Canada' 156717 False
currency China Egypt The single-word name for the currency now used in China is the ' Yuan' ' Pound' ' ren' 5 False 1284 ' ren' 109 False ' Egypt' 111377 False
currency Egypt France The single-word name for the currency now used in Egypt is the ' Pound' ' Euro' ' Egyptian' 7 False 136 ' ' 9 False ' Egypt' 255870 False
currency Egypt Canada The single-word name for the currency now used in Egypt is the ' Pound' ' Dollar' ' Egyptian' 7 False 148 ' Canadian' 44 False ' Canada' 81404 False
currency Egypt China The single-word name for the currency now used in Egypt is the ' Pound' ' Yuan' ' Egyptian' 7 False 5618 ' ' 28 False ' Egypt' 253675 False
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import HTML, display\n", + "\n", + "full_table_html = report_table.to_html(index=False, border=0).replace(\n", + " \"\\n\", \"\"\n", + ")\n", + "display(\n", + " HTML(\n", + " \"
\"\n", + " \"Full 48-trial matrix \"\n", + " \"(top-1 tokens and target ranks)\"\n", + " \"
\"\n", + " f\"{full_table_html}\"\n", + " \"
\"\n", + " )\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cda35de3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-26T08:13:33.637767Z", + "iopub.status.busy": "2026-07-26T08:13:33.637647Z", + "iopub.status.idle": "2026-07-26T08:13:37.545416Z", + "shell.execute_reply": "2026-07-26T08:13:37.544380Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " function source target prompt source_answer target_answer baseline_top1 baseline_source_rank baseline_source_is_top1 baseline_target_rank alpha1_top1 alpha1_target_rank alpha1_success alpha2_top1 alpha2_target_rank alpha2_success\n", + " capital France China The capital of France is the city of ' Paris' ' Beijing' ' Paris' 1 True 2036 ' Paris' 2 False ' China' 17 False\n", + " language France China Most people in France speak ' French' ' Chinese' ' French' 1 True 348 ' Chinese' 1 True ' France' 255996 False\n", + "continent France China France is a country on the continent of ' Europe' ' Asia' ' Europe' 1 True 16 ' Europe' 3 False ' China' 64 False\n", + " currency France China The single-word name for the currency now used in France is the ' Euro' ' Yuan' ' franc' 6 False 1027 ' franc' 9 False ' China' 486 False\n" + ] + } + ], + "source": [ + "france_to_china = report_table.query(\n", + " \"source == 'France' and target == 'China'\"\n", + ")\n", + "print(france_to_china.to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "554972b9", + "metadata": {}, + "source": [ + "The unperturbed model puts the source-appropriate answer top-1 on\n", + "**33/48 trial rows (68.75%)**, equivalently 11/16 unique function-source prompts:\n", + "capital 12/12, language 9/12, continent 12/12, and currency 0/12. Trial-row and\n", + "unique-prompt rates are identical because every source prompt occurs with three\n", + "targets.\n", + "\n", + "The primary `alpha=1` intervention succeeds unconditionally on **16/48 trials\n", + "(33.33%)**: capital 5/12, language 7/12, continent 4/12, and currency 0/12.\n", + "Conditioned on the baseline source answer already being top-1, it succeeds on\n", + "**13/33 trials (39.39%)**: capital 5/12, language 4/9, continent 4/12, and\n", + "currency 0/0 (not applicable). Target-answer rank improves on 45/48 trials and\n", + "never worsens.\n", + "\n", + "For France → China, the baseline is correct on 3/4 templates. `alpha=1`\n", + "succeeds on 1/4 trials unconditionally, or 1/3 baseline-correct trials: only\n", + "the language template flips top-1 (`French` → `Chinese`). The capital,\n", + "continent, and currency targets move to ranks 2, 3, and 9. The language prompt\n", + "exactly extends the qualitative demo. The companion configuration intentionally\n", + "uses the longer capital prompt `\"The capital of France is the city of\"`, so its\n", + "ranks should not be compared directly with the shorter capital prompt above.\n", + "\n", + "The double-strength diagnostic succeeds on **0/48 trials**, and on 0/33\n", + "baseline-correct trials. Every `alpha=2` top-1 is instead a country token: the\n", + "target country on 35 trials and the source country on 13. This is systematic\n", + "overshoot on the 2B base model, not evidence that `alpha=2` improves this\n", + "model. Two conditions have target rank 1 but fail deterministic argmax because\n", + "another token shares the exact maximum: language/Canada→Egypt at `alpha=1` and\n", + "language/Canada→China at `alpha=2`.\n" + ] + }, { "cell_type": "markdown", "id": "7020c7b5", "metadata": {}, "source": [ - "## 4. Steering along a J-lens vector\n", + "## 5. Steering along a J-lens vector\n", "\n", "`steering_hooks` adds a token's unit-normalized lens direction, scaled by the activation's median\n", "residual norm times `alpha` (the paper's directed-modulation protocol). `ablation_hooks`\n", @@ -452,10 +1462,10 @@ "id": "89692d80", "metadata": { "execution": { - "iopub.execute_input": "2026-07-11T09:06:30.427385Z", - "iopub.status.busy": "2026-07-11T09:06:30.427165Z", - "iopub.status.idle": "2026-07-11T09:06:30.640333Z", - "shell.execute_reply": "2026-07-11T09:06:30.639945Z" + "iopub.execute_input": "2026-07-26T08:13:37.547587Z", + "iopub.status.busy": "2026-07-26T08:13:37.547472Z", + "iopub.status.idle": "2026-07-26T08:13:41.825538Z", + "shell.execute_reply": "2026-07-26T08:13:41.824391Z" } }, "outputs": [ @@ -480,7 +1490,7 @@ "id": "00df913e", "metadata": {}, "source": [ - "## 5. Fitting your own lens\n", + "## 6. Fitting your own lens\n", "\n", "For models without a published artifact, `JacobianLens.fit` reproduces the reference estimator on\n", "a raw `TransformerBridge` — one forward and `ceil(d_model / dim_batch)` backward passes per\n", @@ -527,38 +1537,48 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.13" + "version": "3.12.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { - "1902af979017484c8d9c5a0fe643e833": { + "0823fa85a33042f2b84a2b9926882509": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", + "model_name": "HTMLStyleModel", "state": { - "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", + "_model_name": "HTMLStyleModel", "_view_count": null, - "_view_module": "@jupyter-widgets/controls", + "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_292c5280a9cd49a89d0c2a77ffd4e936", - "max": 288.0, - "min": 0.0, - "orientation": "horizontal", - "style": "IPY_MODEL_99333fe6d4aa485bac5b5ec104cc5537", - "tabbable": null, - "tooltip": null, - "value": 288.0 + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null } }, - "292c5280a9cd49a89d0c2a77ffd4e936": { + "0b188b73a4ca4235b673eb4a5a5134c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0d7dd3809a9f40c784afa5e7f4948253": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -611,65 +1631,7 @@ "width": null } }, - "8b9855cb054f4b06803233534b78ddf9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_c2743d998e5841b3b35e40721586659a", - "IPY_MODEL_1902af979017484c8d9c5a0fe643e833", - "IPY_MODEL_ef3400c12a834c5db3f95519c0b9e78f" - ], - "layout": "IPY_MODEL_c357c3f6dcb342fa90b16ca6949bcd3e", - "tabbable": null, - "tooltip": null - } - }, - "969321ee62ed49049d01ab89c6724577": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "99333fe6d4aa485bac5b5ec104cc5537": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "aca2228a9ea14b069bc2d6a5fe9d5bcb": { + "18896d768cf049c3a4e02b1d9d350dc2": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -722,30 +1684,73 @@ "width": null } }, - "c2743d998e5841b3b35e40721586659a": { + "56418781a0e74548a54c90d31236f244": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLModel", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8e53e944f78141bdaac00c2aa4a587f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", + "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "HTMLView", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ead86bce277c431591a6ebf48a1a340f", + "IPY_MODEL_a8903983473e472782a2f69182910a66", + "IPY_MODEL_e026eac248ca453fb1ef07d6c2cc12cc" + ], + "layout": "IPY_MODEL_f0f0895a5c5d4c92b860c54087a40782", + "tabbable": null, + "tooltip": null + } + }, + "a8903983473e472782a2f69182910a66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_aca2228a9ea14b069bc2d6a5fe9d5bcb", - "placeholder": "​", - "style": "IPY_MODEL_969321ee62ed49049d01ab89c6724577", + "layout": "IPY_MODEL_ae81df533acb4b948ad50b1a6956cef4", + "max": 288.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_56418781a0e74548a54c90d31236f244", "tabbable": null, "tooltip": null, - "value": "Loading weights: 100%" + "value": 288.0 } }, - "c357c3f6dcb342fa90b16ca6949bcd3e": { + "ae81df533acb4b948ad50b1a6956cef4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", @@ -798,25 +1803,30 @@ "width": null } }, - "e6e8ba2cc68e4d6491d62a406a3d4816": { + "e026eac248ca453fb1ef07d6c2cc12cc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", + "model_name": "HTMLModel", "state": { + "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", + "_model_name": "HTMLModel", "_view_count": null, - "_view_module": "@jupyter-widgets/base", + "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0d7dd3809a9f40c784afa5e7f4948253", + "placeholder": "​", + "style": "IPY_MODEL_0823fa85a33042f2b84a2b9926882509", + "tabbable": null, + "tooltip": null, + "value": " 288/288 [00:26<00:00, 17.29it/s]" } }, - "ef3400c12a834c5db3f95519c0b9e78f": { + "ead86bce277c431591a6ebf48a1a340f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", @@ -831,15 +1841,15 @@ "_view_name": "HTMLView", "description": "", "description_allow_html": false, - "layout": "IPY_MODEL_f3617aa9615142548cfdcf87b0aaccda", + "layout": "IPY_MODEL_18896d768cf049c3a4e02b1d9d350dc2", "placeholder": "​", - "style": "IPY_MODEL_e6e8ba2cc68e4d6491d62a406a3d4816", + "style": "IPY_MODEL_0b188b73a4ca4235b673eb4a5a5134c6", "tabbable": null, "tooltip": null, - "value": " 288/288 [00:01<00:00, 125.60it/s]" + "value": "Loading weights: 100%" } }, - "f3617aa9615142548cfdcf87b0aaccda": { + "f0f0895a5c5d4c92b860c54087a40782": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel",