From 4aaa0e4abdfcb09b19c7265e30653ac9a6c176c7 Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Thu, 3 Aug 2023 18:59:50 -0700 Subject: [PATCH 01/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 1594 ++++++++++++++++++++++++++++ 1 file changed, 1594 insertions(+) create mode 100644 tutorials/LLama2-Captum-Demo.ipynb diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb new file mode 100644 index 0000000000..80cf4b35cd --- /dev/null +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -0,0 +1,1594 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 262, + "id": "inside-current", + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import bitsandbytes as bnb\n", + "from functools import partial\n", + "import os\n", + "#from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, AutoPeftModelForCausalLM\n", + "import torch\n", + "from typing import Callable, List, Dict, Union, Iterable, Any, Optional\n", + "from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed, Trainer, TrainingArguments, BitsAndBytesConfig, \\\n", + " DataCollatorForLanguageModeling, Trainer, TrainingArguments\n", + "#from datasets import load_dataset\n", + "import random\n", + "import math\n", + "import sys\n", + "from copy import copy\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "sys.path.append(\"/home/aoboyang/local/captum\")\n", + "from captum.attr import FeatureAblation, Attribution\n", + "\n", + "from captum.attr._core.dataloader_attr import _convert_output_shape" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "driven-privacy", + "metadata": {}, + "outputs": [], + "source": [ + "def load_model(model_name, bnb_config):\n", + " n_gpus = torch.cuda.device_count()\n", + " max_memory = f'{10000}MB'\n", + "\n", + " model = AutoModelForCausalLM.from_pretrained(\n", + " model_name,\n", + " quantization_config=bnb_config,\n", + " device_map=\"auto\", # dispatch efficiently the model on the available ressources\n", + " max_memory = {i: max_memory for i in range(n_gpus)},\n", + " )\n", + " tokenizer = AutoTokenizer.from_pretrained(model_name, use_auth_token=True)\n", + "\n", + " # Needed for LLaMA tokenizer\n", + " tokenizer.pad_token = tokenizer.eos_token\n", + "\n", + " return model, tokenizer\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pleasant-tracy", + "metadata": {}, + "outputs": [], + "source": [ + "def create_bnb_config():\n", + " bnb_config = BitsAndBytesConfig(\n", + " load_in_4bit=True,\n", + " bnb_4bit_use_double_quant=True,\n", + " bnb_4bit_quant_type=\"nf4\",\n", + " bnb_4bit_compute_dtype=torch.bfloat16,\n", + " )\n", + "\n", + " return bnb_config\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "exclusive-ministry", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3dd4b2ff9fd54d57ba6aad6298ac0bdf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading (…)fetensors.index.json: 0%| | 0.00/33.4k [00:00', '▁Dave', '▁lives', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁F', 'L', '▁and', '▁is', '▁a', '▁lawyer', '.', '▁His', '▁personal', '▁interests', '▁include', '▁playing', '▁guitar', ',', '▁h', 'ik', 'ing', ',', '▁and', '▁sp', 'ending', '▁time', '▁with', '▁his', '▁family', '.']\n" + ] + } + ], + "source": [ + "eval_prompt = \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\"\n", + "\n", + "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + "\n", + "model.eval()\n", + "with torch.no_grad():\n", + " print(model_input[\"input_ids\"])\n", + " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=15)[0]\n", + " print(output_ids)\n", + " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", + " print(response)\n", + " print(tokenizer.convert_ids_to_tokens(output_ids))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "01927246", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "device(type='cuda', index=0)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.device" + ] + }, + { + "cell_type": "markdown", + "id": "2fb6070e", + "metadata": {}, + "source": [ + "Vizualize" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "id": "13bbacd6", + "metadata": {}, + "outputs": [], + "source": [ + "class LLMAttrViz:\n", + " def __init__(self, seq_attr, token_attr, input_tokens, output_tokens):\n", + " self.seq_attr = seq_attr\n", + " self.token_attr = token_attr\n", + " self.input_tokens = input_tokens\n", + " self.output_tokens = output_tokens\n", + " \n", + " @property\n", + " def seq_attr_dict(self):\n", + " return {k: v for v, k in zip(self.seq_attr.cpu().tolist(), self.input_tokens)}\n", + " \n", + " def plot_token_attr(self):\n", + " token_attr = self.token_attr.cpu()\n", + " \n", + " # maximum absolute attribution value\n", + " # used as the boundary of normalization\n", + " # always keep 0 as the mid point to differentiate pos/neg attr\n", + " max_abs_attr_val = max([\n", + " token_attr.max().abs().item(), \n", + " token_attr.min().abs().item()\n", + " ])\n", + " \n", + " fig, ax = plt.subplots()\n", + " \n", + " # Plot the heatmap\n", + " data = token_attr.numpy()\n", + " \n", + " im = ax.imshow(\n", + " data,\n", + " vmax=max_abs_attr_val,\n", + " vmin=-max_abs_attr_val,\n", + " cmap=\"RdYlGn\",\n", + " aspect=\"auto\"\n", + " )\n", + "\n", + " # Create colorbar\n", + " cbar = ax.figure.colorbar(im, ax=ax)\n", + " cbar.ax.set_ylabel(\"Token Attribuiton\", rotation=-90, va=\"bottom\")\n", + "\n", + " # Show all ticks and label them with the respective list entries.\n", + " ax.set_xticks(np.arange(data.shape[1]), labels=self.input_tokens)\n", + " ax.set_yticks(np.arange(data.shape[0]), labels=self.output_tokens)\n", + "\n", + " # Let the horizontal axes labeling appear on top.\n", + " ax.tick_params(top=True, bottom=False,\n", + " labeltop=True, labelbottom=False)\n", + "\n", + " # Rotate the tick labels and set their alignment.\n", + " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", + " rotation_mode=\"anchor\")\n", + " \n", + " # Loop over the data and create a `Text` for each \"pixel\".\n", + " # Change the text's color depending on the data.\n", + " for i in range(data.shape[0]):\n", + " for j in range(data.shape[1]):\n", + " val = data[i, j]\n", + " color = \"black\" if 0.2 < im.norm(val) < 0.8 else \"white\"\n", + " im.axes.text(\n", + " j, \n", + " i, \n", + " \"%.4f\" % val,\n", + " horizontalalignment=\"center\",\n", + " verticalalignment=\"center\",\n", + " color=color,\n", + " )\n", + " \n", + " plt.show()\n", + " \n", + " def plot_seq_attr(self): \n", + " fig, ax = plt.subplots()\n", + "\n", + " data = self.seq_attr.cpu().numpy()\n", + " \n", + " ax.set_xticks(range(data.shape[0]), labels=self.input_tokens)\n", + " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", + " rotation_mode=\"anchor\")\n", + " ax.tick_params(top=True, bottom=False,\n", + " labeltop=True, labelbottom=False)\n", + " \n", + " # Example data\n", + " people = ('Tom', 'Dick', 'Harry', 'Slim', 'Jim')\n", + "\n", + " # pos bar\n", + " ax.bar(range(data.shape[0]), [max(v, 0) for v in data], align=\"center\", color=\"g\")\n", + " # neg bar\n", + " ax.bar(range(data.shape[0]), [min(v, 0) for v in data], align=\"center\", color=\"r\")\n", + "\n", + " ax.set_ylabel(\"Sequence Attribuiton\", rotation=90, va=\"bottom\")\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1b152e3d", + "metadata": {}, + "source": [ + "`SampleBaselines` class define the case that there are multiple possible baselines over certain data distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "id": "85edaa91", + "metadata": {}, + "outputs": [], + "source": [ + "class SampleBaselines:\n", + " \"\"\"\n", + " Abstract class for baselines from samples of training data\n", + " \"\"\"\n", + " def sample(self):\n", + " pass\n", + " \n", + "\n", + "class IterableBaselines(SampleBaselines):\n", + " \"\"\"\n", + " Baselines defined in an iterable\n", + " \"\"\"\n", + " \n", + " def __init__(\n", + " self, \n", + " iterable_baselines: Iterable[Any], \n", + " weights: Optional[Iterable[float]] = None,\n", + " ):\n", + " self.baseline_list = list(iter(iterable_baselines))\n", + " if weights is not None:\n", + " weights = list(iter(weights))\n", + " \n", + " self.weights = weights\n", + " \n", + " def sample(self):\n", + " return random.choices(self.baseline_list, weights=self.weights)[0]\n", + " \n", + " \n", + "\n", + "class ProductBaselines(SampleBaselines):\n", + " \"\"\"\n", + " Sample product of feature baselines\n", + " \"\"\"\n", + " \n", + " def __init__(\n", + " self, \n", + " feature_baselines: Union[List[List[str]], Dict[str, List[str]]], \n", + " feature_weights: Union[List[List[float]], Dict[str, List[float]]] = None, \n", + " ):\n", + " self.feature_baselines = feature_baselines\n", + " \n", + " self.feature_weights = feature_weights\n", + " \n", + " def sample(self):\n", + " feature_baselines = self.feature_baselines\n", + " feature_weights = self.feature_weights\n", + " \n", + " if type(feature_baselines) is list:\n", + " return [\n", + " random.choices(\n", + " l, \n", + " weights=(None if feature_weights is None else feature_weights[i])\n", + " )[0]\n", + " for i, l in enumerate(feature_baselines)\n", + " ]\n", + " else:\n", + " return {\n", + " k: random.choices(\n", + " l, \n", + " weights=(None if feature_weights is None else feature_weights[k])\n", + " )[0]\n", + " for k, l in feature_baselines.items()\n", + " }\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "7a447635", + "metadata": {}, + "source": [ + "`InterpretableFeature` defines the feature type and tells Captum how to perturb the input data" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "2580cf27", + "metadata": {}, + "outputs": [], + "source": [ + "class InterpretableFeature:\n", + " \"\"\"\n", + " Interpretable feature adapter for different kinds of model inputs\n", + " to make Captum understand how to perturb the inputs\n", + " \"\"\"\n", + " def to_model_input(perturbed_tensor=None):\n", + " \"\"\"\n", + " Convert perturbed interpretable tensor into the perturbed input in the format required by the model\n", + " if perturbed tensor is not provided, return the orignal input\n", + " \"\"\"\n", + " pass\n", + " \n", + " def to_input_shape(interpretable_attr):\n", + " \"\"\"\n", + " Convert attribution of intepretable feature shape to raw input shape\n", + " \"\"\"\n", + " pass\n", + " \n", + "\n", + "class TextTemplateFeature(InterpretableFeature):\n", + " def __init__(\n", + " self,\n", + " template: Union[str, Callable],\n", + " inputs: Union[List[str], Dict[str, str]],\n", + " baselines: Union[List[str], Dict[str, str], \"SampleBaselines\", None] = None,\n", + " mask: Union[List[int], Dict[str, int], None] = None\n", + " ):\n", + " self.dict_keys = list(inputs.keys()) if type(inputs) is dict else None\n", + " \n", + " n_features = len(inputs)\n", + " \n", + " if baselines is None:\n", + " # default baseline is to remove the element\n", + " baselines = [\"\"] * len(inputs) \n", + " elif type(baselines) is dict:\n", + " # convert dict to list\n", + " baselines = [baselines[k] for k in self.dict_keys]\n", + " \n", + " if mask is None:\n", + " n_interpretable_features = n_features\n", + " else:\n", + " if self.dict_keys:\n", + " # convert dict to list\n", + " mask = [mask[k] for k in self.dict_keys]\n", + " \n", + " mask_ids = set(_ for _ in mask)\n", + " mask_id_to_idx = {mid: i for i, mid in enumerate(mask_ids)}\n", + " \n", + " # internal compressed mask of continuous interpretable feature indices from 0\n", + " # cannot replace original mask of ids for grouping across inputs externally\n", + " self.formatted_mask = [mask_id_to_idx[mid] for mid in mask]\n", + " \n", + " n_interpretable_features = len(mask_ids)\n", + " \n", + " # number of raw features and intepretable features\n", + " self.n_features = n_features\n", + " self.n_interpretable_features = n_interpretable_features\n", + " \n", + " # Init Interpretable representation in shape(1, n_interpretable_features)\n", + " self.interpretable_tensor = torch.tensor([[1.0] * n_interpretable_features])\n", + " \n", + " self.format_fn = template.format if isinstance(template, str) else template\n", + " \n", + " \n", + " if type(inputs) is dict:\n", + " # convert dict to list\n", + " inputs = [inputs[k] for k in self.dict_keys]\n", + " \n", + " self.inputs = inputs\n", + " \n", + " self.baselines = baselines\n", + " self.mask = mask\n", + " \n", + " \n", + " def to_model_input(self, perturbed_tensor=None):\n", + " inputs = [_ for _ in self.inputs] # clone\n", + " \n", + " if perturbed_tensor is not None:\n", + " baselines = self.baselines\n", + " if isinstance(baselines, SampleBaselines):\n", + " baselines = self.baselines.sample()\n", + " if self.dict_keys:\n", + " baselines = [baselines[k] for k in self.dict_keys]\n", + " \n", + " for i in range(len(inputs)):\n", + " interpretable_idx = i\n", + " if self.mask:\n", + " interpretable_idx = self.formatted_mask[i]\n", + " \n", + " interpretable_val = perturbed_tensor[0][interpretable_idx]\n", + " \n", + " if not interpretable_val:\n", + " inputs[i] = baselines[i]\n", + " \n", + " \n", + " if self.dict_keys:\n", + " inputs = {k: v for k, v in zip(self.dict_keys, inputs)}\n", + " input_str = self.format_fn(**inputs)\n", + " else:\n", + " input_str = self.format_fn(*inputs)\n", + " \n", + " return input_str\n", + "\n", + " def to_input_shape(self, interpretable_attr: torch.Tensor):\n", + " if self.mask is None:\n", + " return interpretable_attr\n", + " \n", + " device = interpretable_attr.device\n", + " \n", + " formatted_attr = _convert_output_shape(\n", + " interpretable_attr, # shape(*output_dims, n_interpretable_features)\n", + " (torch.zeros([1, self.n_features], device=device),), # fake input tensor\n", + " (torch.tensor([self.formatted_mask], device=device),)\n", + " )\n", + " return formatted_attr[0]\n", + " \n", + "class IdFeature(InterpretableFeature):\n", + " pass\n", + "\n", + "\n", + "class TextFeature(IdFeature):\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "id": "urban-insight", + "metadata": {}, + "source": [ + "We see that the first predicted interest is \"playing golf\". We would like to better understand the cause of this. For instance, is it related to the city, state, name or pronoun? \n", + "\n", + "We will use Captum and the LLM Attribution wrapper defined below to better understand this question." + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "theoretical-cassette", + "metadata": {}, + "outputs": [], + "source": [ + "class LLMAttribution(Attribution):\n", + " def __init__(\n", + " self, \n", + " attr_method, \n", + " tokenizer, \n", + " init_kwargs=None, \n", + " attr_kwargs=None, \n", + " max_new_tokens=15,\n", + " attr_type: str = \"log_prob\", # or prob\n", + " ):\n", + " \"\"\"\n", + " attr_method: perturbation attribution instance crteated with a llm model huggingface style interface\n", + " tokenizer: required\n", + " \"\"\"\n", + "# assert (\n", + "# type(attr_method) in SUPPORTED_METHODS\n", + "# ), f\"LLMAttribution does not support {type(attr_method)}\"\n", + "\n", + " super().__init__(attr_method.forward_func)\n", + "\n", + " # shallow copy is enough to avoid modifying original instance\n", + " self.attr_method = copy(attr_method)\n", + "\n", + " self.attr_method.forward_func = self._forward_func\n", + " \n", + " # alias\n", + " self.model = self.forward_func\n", + " \n", + " self.tokenizer = tokenizer\n", + " self.device = self.model.device\n", + " \n", + " # only when attr target is not given\n", + " self.max_new_tokens = max_new_tokens\n", + " \n", + " self.attr_type = attr_type\n", + " \n", + " \n", + " def _forward_func(self, perturbed_feature, input_feature, target_tokens, log_trials):\n", + " perturbed_input = self._format_model_input(input_feature.to_model_input(perturbed_feature))\n", + " \n", + " init_model_inp = perturbed_input\n", + " \n", + " model_inp = init_model_inp\n", + " \n", + " log_prob_list = []\n", + " for target_token in target_tokens:\n", + " output_logits = self.model.forward(model_inp)\n", + " new_token_logits = output_logits.logits[:, -1]\n", + " log_probs = torch.nn.functional.log_softmax(new_token_logits, dim=1)\n", + " \n", + " log_prob_list.append(log_probs[0][target_token].detach())\n", + " \n", + " model_inp = torch.cat((model_inp, torch.tensor([[target_token]]).to(self.device)), dim=1)\n", + " \n", + " total_log_prob = sum(log_prob_list)\n", + " \n", + " # 1st dim is the total prob, rest are the target tokens\n", + " target_log_probs = torch.stack([total_log_prob, *log_prob_list], dim=0)\n", + " target_probs = torch.exp(target_log_probs)\n", + " \n", + " if log_trials:\n", + " prompt = self.tokenizer.decode(init_model_inp[0], skip_special_tokens=True)\n", + " response = self.tokenizer.decode(target_tokens, skip_special_tokens=True)\n", + " print(prompt)\n", + " print(response, \"[prob:\", target_probs[0].item(), \"]\")\n", + " \n", + " return target_probs if self.attr_type != \"log_prob\" else target_log_probs\n", + " \n", + " def _format_model_input(self, model_input):\n", + " \"\"\"\n", + " Convert str to tokenized tensor\n", + " \"\"\"\n", + " # return tensor(1, n_tokens)\n", + " if type(model_input) is str:\n", + " return self.tokenizer.encode(model_input, return_tensors=\"pt\").to(self.device)\n", + " return model_input.to(self.device)\n", + " \n", + " def attribute(\n", + " self, \n", + " input_feature: Union[\"TextTemplateFeature\", \"TextFeature\", \"IdFeature\"], \n", + " target: Union[str, torch.Tensor, None] = None, \n", + " num_trials: int = 1, \n", + " log_trials=True,\n", + " **kwargs,\n", + " ):\n", + " if type(target) is str:\n", + " # exclude sos\n", + " target_tokens = self.tokenizer.encode(target)[1:]\n", + " elif type(target) is torch.Tensor:\n", + " target_tokens = target\n", + " else:\n", + " # generate when None\n", + " model_inp = self._format_model_input(input_feature.to_model_input())\n", + " output_tokens = self.model.generate(model_inp, max_new_tokens=self.max_new_tokens)\n", + " target_tokens = output_tokens[0][model_inp.size(1):]\n", + " \n", + " attr = torch.zeros(\n", + " [1 + len(target_tokens), input_feature.n_interpretable_features], \n", + " dtype=torch.float, \n", + " device=self.device\n", + " )\n", + " \n", + " for i in range(num_trials): \n", + " attr_input = input_feature.interpretable_tensor.to(self.device)\n", + " \n", + " cur_attr = self.attr_method.attribute(\n", + " attr_input, \n", + " additional_forward_args=(input_feature, target_tokens, log_trials),\n", + " **kwargs\n", + " )\n", + " attr += cur_attr\n", + " \n", + " attr = (attr / num_trials) \n", + " \n", + " attr = input_feature.to_input_shape(attr)\n", + " \n", + " return {\n", + " \"seq_attr\": attr[0],\n", + " \"token_attr\": attr[1:], # shape(n_output_token, n_input_features)\n", + " \"input_tokens\": input_feature.inputs,\n", + " \"output_tokens\": self.tokenizer.convert_ids_to_tokens(target_tokens)\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "adaptive-crazy", + "metadata": {}, + "source": [ + "We will first construct an LLMAttribution object using FeatureAblation, and ablate each of the aspects of this string to see how it affects the predicted probability of the target string. For ablation, we define a set of baseline tokens which we use to compare with the original." + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "hairy-seeking", + "metadata": {}, + "outputs": [], + "source": [ + "fa = FeatureAblation(model)\n", + "\n", + "llm_attr = LLMAttribution(fa, tokenizer)" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "lined-eating", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + "Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + "Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n" + ] + } + ], + "source": [ + "inp_feature = TextTemplateFeature(\n", + " \"{} lives in {}, {} and is a {}. {} personal interests include\", \n", + " inputs=[\"Dave\", \"Palm Coast\", \"FL\", \"lawyer\", \"His\"],\n", + " baselines=[\"Sarah\", \"Seattle\", \"WA\", \"doctor\", \"Her\"],\n", + ")\n", + "\n", + "attr_result = llm_attr.attribute(inp_feature, target=\"playing golf, hiking, and cooking.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "id": "fecae221", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Dave': 0.09586238861083984, 'Palm Coast': -0.5810728073120117, 'FL': -0.17151927947998047, 'lawyer': -0.519902229309082, 'His': 1.2632627487182617}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHCCAYAAAAkUSetAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVhUyxvA8e/SiHSDIKBI2VjY3e312p3X7tZrd2B3t167u7uwO1FKupQ8vz/4sbgCBqCE83mefe7d2Tmzc46H3XffmTNHJkmShCAIgiAIgvDTlDK7A4IgCIIgCNmVCKQEQRAEQRDSSARSgiAIgiAIaSQCKUEQBEEQhDQSgZQgCIIgCEIaiUBKEARBEAQhjUQgJQiCIAiCkEYikBIEQRAEQUgjEUgJgiAIgiCkkQikhDQRC+ILgiAIggikhDSSyWQAxMfHZ3JPBEEQBCHziEBK+Gnjx49n48aNACgpKSFJkshQCYIgCH8kEUgJP+XQoUPs3r2bDh06YGdnx6lTp5DJZPIMlSAIgiD8SUQgJfyw4OBgduzYgZWVFY8ePeKff/6hefPmjBkzhpiYGJGVEgRBEP44IpASftiOHTt4+vQp1atXx9HRkaFDh7J06VK2bdvG69evRVZKEARB+OOIQEr4Ia9fv+bAgQPY2dkxcOBAebm2tjZeXl5cu3ZNXiYyU4IgCMKfQiWzOyBkD5s3b+bmzZuoq6vz/Plz7O3tCQ8P5+bNm8THx1OwYEF5XZlMRlxcHEpKSiJLJQiCIORoIpASvuvy5cucOXOGmjVrYmxsTPHixSlevDiqqqpcuXKFdu3aUaxYMRYuXIifnx8DBw7EwMAASMhOiWBKEARByKnE0J7wTbGxsWzbto34+Hj69OnD7NmzuXfvHoUKFcLc3Jz58+cza9YsPnz4gLKyMrdu3cLOzo758+cDKARRUVFRnDx5MrN2RRAEQRAynEwSE1qEb7h06RLdu3enfv36zJgxQ+G1qKgo1NXVk22ze/duhg8fzoYNG3Bzc5OXnz59murVq3P8+HGqV6/+y/suCIIgCL+aCKSE77p16xYWFhaYm5vLVzJXUkpIZoaGhtKvXz8+ffqEuro6I0aMwNnZmSpVqlC9enVGjx4NJCyd0Lx5c2QyGcePH8+0fREEQRCEjCTmSAnf5erqKv//xAAqce5Thw4duHXrFl26dOHdu3eUKVOG1q1b8+rVK1RUEk6v+Ph49u3bx+nTp7l37558+/j4eJSVlX//DgmCIAhCBhEZKSHNfH19sbS0ZPv27TRr1gyAO3fu0KhRIyRJ4v79++jp6fH27VuqV69O1apVWb58OdHR0aipqcnbERPSBUEQhOxKTDYX0kxVVZUqVapw4sQJAEJCQoiNjSUsLIyePXuip6dHbGwsq1ev5uPHj8yePRtIuAqwcePGvHr1CkhaLkHE9IIgCEJ2IwIpIc0MDAwYOHAge/bsoXz58vTr149y5cphZWVFz549AXj48CHu7u6MHz8ebW1t/P39OXr0KPv37+fMmTMMGzaMly9foqysLLJSgiAIQrYjAikhXerWrYuvry9DhgyhUaNGxMbGMm7cOAwNDfn06RMzZszA0tKSAQMGAHDjxg0WLVpEpUqVCA8P5+PHj7i6unL06FGFdmNjYzNhbwQhibu7O/v27cvsbgiCkMWJyeZChmjcuDGhoaFMmjSJBg0aAHD+/Hl27drF/v37AXj79i3Lly/H3t6eM2fOyLf18PDg5s2bVKlShSdPnlCkSBH5RHVByAze3t4sX76chg0b0qhRo8zujiAIWZiYbC78EqGhobi6upInTx7OnDlDdHQ0W7ZsoV+/fhw5coRy5coB4OnpScOGDYmNjcXR0RFvb2+CgoLYuXMnzs7OmbwXwp+qc+fOBAcHM2nSJFxcXIiLixNXmAqCkCIxtCf8Ejo6OowfP561a9cC8PTpU1auXEn9+vXlQRTA0aNH8fb2pmfPnixYsIDTp09ja2vLrFmzMqvrwh/u5s2b3Llzh9q1a+Pi4gKAsrIycXFxmdwzQRCyIjF+Ivwybdq0ASA6Opq9e/dy5coV/vvvP/nrd+/eZf/+/bi5udG7d295ubq6Oj4+PsTHxyOTycQkdOG3iYuLY+TIkRQuXJi///6bd+/e8fbtWypUqICysrL8ylJxTgqCkEgEUllEQEAA+vr68gUvcxI1NTW6du1KgQIFMDc3BxKCqyNHjvD8+XPWrFkjr/vs2TMiIiIoXLgw8fHxPzxXSgRdQkbYuXMnERERNG3alNy5c7Ns2TL2799PZGQk8+fPp1KlSpndRUEQspic962dDcXHx9O9e3csLCxwd3fP7O78Eubm5rRo0UL+/PTp0+zYsYPatWtTtmxZefmWLVsICQmhUqVKqKiopLq21N27dzl69CibN2/m8ePHKCkpIZPJ5LewEYSfFR4ezuzZsylbtiw1atRARUWFXr16sWvXLho1akTbtm3ZvHmzwjZiiqkgCCKQygJOnz6Nn58fVatWZcGCBTg4OHDx4sXM7tYvpaOjg6amJoMGDZKXnT9/nnPnzlGsWDHq1asHJA2hJM5P8fT0pH///ri5udG8eXOWLVtGhQoVaNOmDaGhoTkyoyf8HjNnzkRPT48uXbrg6+vLvn37OHz4MObm5kyYMIEqVapw5swZheBJZEAFQRDfOpns06dPLFy4EBMTE7Zs2cKrV69o3rw5Xbt2Zc2aNUiSlCN/9ZYtW5bz589jbW0NJAz17dixA5lMRpcuXQAUskuJV0z16tWLHTt2MGTIEN69e8fWrVs5ePAgkZGRVKlShTt37vz+nRGyvVevXnHo0CHq1KnD58+fKVKkCOPGjWPWrFnky5eP//77Dzc3N65evSoP6ocPH57sB09O/FsVBOHbRCCVyTZu3Iivry9t27YFEoKH8ePH06lTJ1asWEFgYGCO/dX75eXkV69e5fTp05QpU0Z+k+TE7FLiF9fWrVs5dOgQ3bt3Z8KECejr65MnTx7KlCnD9u3bKVq0KLt37/79OyJkeytXrkRbW5uWLVuycOFCHB0dOXfuHIcPH2bAgAEMGjSI3r1706hRI1RUVHj37h03btzg1KlTClfzieFlQfjziEAqE/n4+MgDgCZNmgAJwYOKigotW7bkxYsXrF69OpN7+XtUrFiR9evXy1dATykbNWfOHNzc3GjVqpX8/nyJ1NTUaNu2rTzDJQg/Y9q0aaxcuRJLS0tiY2OxtrZGT08PU1NT+vbtS4sWLciTJw/du3cHkK/K7+DggLKyMk+fPmXOnDmEhISI4WVB+MOIq/Yykbu7OzExMXTu3BlQvPIsb968KCsrExERobBNXFycfGJ1TlOyZEn5/3/9ZfTs2TOCgoJo0KABjo6OAMkWSKxSpQpubm7J2o2NjRUrpQupSlxs097eHkA+sbxXr15UqVKFQ4cOsWXLFqZOnSoP1C9fvoyfnx8tW7YEEoacz5w5Q0hICBMnTsy0fREE4fcTP50yyb1797h48SKVK1emVKlSgGLwcPDgQQCMjIyQJIkLFy4QFhYmv7nvn7Y4oKWlJYGBgRQvXhwgxf2Pj49HQ0ODyMhIHj9+zNmzZwG+efWfIHwdkDdr1oxbt27h4+ODp6cnGzZsoGLFinTu3Fn+A2bTpk306NGDFy9e0L9/f+7cuUPVqlWpVauWvJ3r16/L/z+nznXMLGL4VMhKRCCVCeLi4hgzZgy5cuVi8ODB8rLEjFR4eDi7d+9GTU2NatWqce3aNRYtWkShQoWYMGECkPzDPyeLi4tDVVWVwoULs23bNsLDwxX2P/FDVUlJiefPn9O4cWNq1KhBly5dyJ8/P+fPn8+RGTwh40mSRFxcHM7OzuzevZtu3brh6OhIt27dMDAwAODWrVuYmpqipKTErFmzCAoKYvLkyRQoUAADAwNCQkKYNGkSZcqU4fXr1wQFBYk1zjLIx48fiY+PF8OnQpYizsZMEBUVha6uLidPnmTXrl3ExsairKws/3BYsGABR48epVmzZjg7O+Pi4sLy5cuZP38+u3fvplWrVoSEhCi0mZN/oSkrK6OmpsbgwYPx9fWV3wQ5UeJxCwwMpEmTJsTFxTF//nyuXbtGkyZN6Nu3L15eXpnRdSGbkclkKCsry/+etLW1efToEX///be8Tnh4OG/fvmXevHkoKyszfvx4tLW1efXqFU5OTsyYMYN9+/axdu1abG1tadWqFRs2bMisXcox4uPj6dmzJ3///Tfh4eGZ3R1BSCIJmWbHjh2Subm5VLBgQcnd3V2aMGGC1KNHD0lZWVlq3ry55OvrK928eVPatm2b9Pz5c0mSJOn69euSra2t9Pjx40zufeaYNm2apKmpKbVt21Y6efKktHLlSik0NFSSJEmaMWOGZGhoKHl5ecnr+/j4SObm5tKGDRtSbC82Nva39FvInmJiYpKVjR07VpLJZFKZMmWksLAwSZIkqXDhwtKGDRukefPmSYUKFZIWL14sr6+lpSVt27ZNkiRJiouLU2grPj7+F/Y+Zzl58qRUrlw5afbs2Sm+/vWxFYTfRWSkMlHz5s3x8vKic+fOnDp1irNnz3L9+nXmzZvH2LFjmTNnDiVLlmTJkiVUrlyZnj17kitXLvT19fHw8ADg/v37DBgwIEdnpL40YsQInj9/jkwmY8GCBRw5cgQfHx8AFi1aRO/evTE3Nyc6OhoAfX19YmJiyJ07t7yNK1eucOLECQD5/dMkMX8lXQICAnLkOZjSRQotW7akd+/eLF26lNy5c3PlyhXU1NTw8PBg8ODBTJgwQX4ByenTp8mfPz9OTk5AUvb0zZs3gFjQ80clrrdnYWFBp06dAMV5kpGRkWK4T8g8mR3JCQmioqKkyMhI+XMPDw9JJpNJ+/fvlwIDA6WrV69KVatWlVRUVCQtLS0pKChIkiRJmjx5slSoUCEpMDAwWZs5PdsSEBAgffr0SZIkSXr37p3k6OgorVq1SpKkpF/6ixcvlkqUKCEdPHhQkiRJCg8Pl7p37y4VLFhQKlq0qHTlypXM6XwOEhcXJzVt2lQyNTWV5s2bl9nd+aVSyiBt27ZNUlFRkaytreX7n5gduXjxomRnZyc9ePBAkqSEDNeqVaskY2NjaePGjQptioxK6latWiXlz59f2rNnjyRJCZ9tiZ9vDx8+lExNTaVLly5JPj4+8uMqCL+LCOGzCDU1NTQ0NOTP/f39MTU1xdnZGX19fUqXLs28efNQU1NjxIgR6OnpER8fjyRJmJiYoK6unqzNnD4h3cDAQH7MrKyssLe3l2fqZDIZL1++ZOfOnTg7O1OuXDkAtLS0mDVrFleuXKFKlSp06NCBS5cuZdYu5Ahf3uJo/vz55MuXj5MnT2Z2t36JlBbc1NLSQkdHhwEDBiRbB+3cuXPkzp0bFxcXoqKiGDduHOPGjWPIkCHUrFlT3iYkX4BWSODj48PGjRsJDAykT58+bNq0CWVlZZSVlfn06RNLly4lPj4eNzc3VFVVWbJkCUeOHMnsbgt/ksyO5ISU+fj4SBUqVJCcnJyk3bt3SzNnzpRKlCghmZmZybMwkiRJ5cqVk3r37i1//vnzZ2nz5s1SixYtpIiIiMzo+m+X+It+06ZNko6OjtSqVStp6NChkpGRkVStWjXp2rVrkiRJ0okTJ6SFCxdKa9eulW9bpkwZacyYMSm2m9MzehkhMjJSatSokfTXX39J0dHRkiRJ0oQJEySZTCaNGzfuj8myhIeHy//eEvc5JiZG6tu3r9S/f3/pxYsXUoMGDaRixYrJ50/Fx8dLJ06ckIYMGSK1b99eWr58eab1PysbPny4VLFiRenixYvSxo0bJUtLS6lkyZLStWvXpGfPnkmqqqrS7t27M7ubwh9MrFKYRZmamnL+/HlGjx7N1q1bgYTLrrdt2ybPwrx+/ZqQkBAqVqwo327EiBFcvnwZS0tLcuXKlazdxMUHc5LEX/Rt2rShZMmSjBo1ig8fPtChQwcmT56MhoYGs2fPZs6cORQoUIDw8HCmTp3K2LFjKVCgAJIkER0djZqaGp8/fyYwMBALCwuFq7fE/IuUbdmyhYcPHzJr1ixUVVWJj49n3LhxdOvWjdjYWJYsWUKuXLnkc4ZyGkmSiI+PR0tLS16mpKREfHw8KioqxMfHc/jwYfz9/Xny5AmHDx/G1tYWgH79+nHnzh2srKwoXLgwEydOZPv27WzZsgVTU9PM2qUsJXG9vWrVqlGuXDnKlStHrVq1mDFjBnXq1CEyMpLy5cvTpEkTZs2axdu3b1mwYIF8uQlJksQ8NOHXy+RATvgB0dHR0sqVKyUHBweF8idPnkiOjo7SxYsXJS8vL2nYsGGSurq6tG3bNvl8q9u3b0unTp2SDhw4IN/uT7hS6Murrd69eydVrFhR6tq1qxQdHS35+flJixYtkvT09CRTU1Np/vz5kiRJ0qNHj6QKFSpIJUqUkMqXLy/dvn07s7qfLXh7e0uVKlWSDAwMJAsLi2RzU+7duydVrVpVqlOnTopXv+VEX/5tRUZGSgULFpRkMpk0atQo6fr16/LXzp8/L8lkMqlUqVLShw8fJElKyGpVqlRJWr9+fbJ2/5TM3pdiYmKkBg0aSLVr15bevn0rL0s0ffp0SSaTSY8fP5aePn0q2dvbS61bt06xLZFdFn4l8TM7G1BVVaVr167cvHkTgJiYGCAhI+Xt7Y2zs7N8rs+6deto0aIFISEhzJkzh1q1ajFp0iT69etH4cKFuX379h/xC+3Lq63y5MlDbGwsRkZGqKqqYmxsTIsWLahcuTJ2dnbybEnifdQmT56Mq6srVatWZfLkyfI5KxcuXGDu3LlERUX9/h3Kgtzd3ZEkif379zNjxgyGDRuGm5sb7969A2Dz5s1ER0czePBgeXYmp5PJZERERCBJEmPGjCE6Opq+ffsyZcoUhVsgjRo1igoVKmBlZYWjoyOjRo1CS0sLW1tb7ty5I7+K9Nq1a8CfOX8qOjoae3t76tati7W1tTzLB+Dl5cW6devo0aMHjo6OLFu2jIiICFatWgXApUuXWLNmDceOHQNQyC4LQobL5EBOSIcRI0ZIBgYGUpkyZaSiRYsq/OKdOHGiZGFhIS1atEiSpIRftP/8849Us2ZN6fPnz5nV5d8uMUMwb948SUNDQ+rdu7c0a9YsqWzZspKJiYk8ixIUFCRVrVpV6tWrl3zbdevWSe7u7pKfn5906NAhafjw4ZKFhYX06tWrTNmXrOTu3btSuXLlpHHjxsnL/Pz8pGnTpklPnz6VLl68KFWoUEEaOHBgJvby91u1apUkk8mk0qVLSzo6OtK+ffuSzZ3y8/OTihQpIp+rd+zYMalYsWKShYWF5OzsLD8Hvby8JJlMJi1YsEB6+fJlpuxPVpD4N5yYVYqNjZUmT54saWtrSwEBAdLZs2clY2Njyd3dXZIkSdq5c6eko6MjValSRTIxMZHKly8vPXnyJNP6L+R8IpDKxrZs2SIpKytLderUkfz8/OTlN2/elCpWrCjZ2dlJurq68snUUVFRUt68eaVz585lVpcz1e3bt6X+/ftLvXv3lrS0tKSWLVsqvH7ixAnJ2dlZmjx5shQRESGFh4dLvr6+UnBwsFSmTBlJJpNJ7du3z6TeZx0pDbl8OfQUGRkpde3aVapcubL08OHDZK/ndMeOHZM2btwo3/evxcTESBUqVJC6dOkiL4uOjpaWLVsmH6qXJEnq16+fJJPJpLp160pubm5SkSJFpDdv3vyWfcjK7ty5I2lra0sLFy6UPn/+LDVr1kwqWrSo/PUOHTpIrVq1kiIjI6XIyEipXbt2UtWqVaX3799nYq+FnEwEUtncx48f5R8QifMHzp8/LxkZGUl3796VLl68KBUvXlyytbWVFi5cKOXOnTvVD/g/xdu3b6XatWtLp06dkiQp4XiFhIRIkiRJq1evlsqWLSvt27dPXt/Hx0dq3769ZGdnJ2lra0tFixaVz2v5E0VEREiDBg2SFixYIElSUsYg8b/r1q2TypQpI82aNSvT+pjVrVmzRnJzc0u2jlniKv3Xrl2TlJWVpaFDh0pXrlyR3r9/L82cOVN+BeqfbP369ZKVlZUUHx8vbdmyRdLX15dOnjwpSVJCtmrx4sWShoaGfF6ol5eXdOjQISk4ODgzuy3kYCKQyoH27Nkj5c6dWwoICJAkKSETtXDhQsnU1FQqVaqU9O7du0zuYdbx/v17qUGDBtLOnTvlZd27d5ecnZ3ly0wkZgr27t0rSZIkjRo1Sjp+/Him9Dcr+TKASsw4vX37VmratKnUsGFD6ePHj5Ik/VnZqB8VHR0t9ezZU9LQ0JA6duworV27Vrp586b89cqVK0vVqlVT+PKPjY39Yybtf094eLgUGBgo2dvbS9WrV5ckKeFzLtH48eOlxo0bS7du3Ur2miBkNDHZPAeqUaMGRYoUYcuWLUDCYp99+vThwYMHLF68GAsLi0zuYdZhbGyMs7Mz//zzD0OHDuXWrVs8ffoUW1tbJEni7t277N+/H0dHRxo1agTAlClTqFatWib3PPMlXrQgk8nkk6G3bt2Kr68vrVu3xsjIiPj4eLF0xFckSUJVVZWlS5dy8+ZNJEni4cOHfP78GYAdO3Zw8eJFpkyZgq6urnw7ZWXlFG9Z8yfS0tJCX1+fuXPnsmbNGgAWL17MoUOHAOjUqRNqamr07t2bkJAQ1NTUMrO7Qk6XyYGckMESswTu7u6Sjo6O1LNnT+nOnTvS1atXM7lnWdulS5ekkiVLSiVLlpRq1KghvxXFtGnTJCcnJ/kQjMgIpM7T01MqUaKEZGxs/EdPjv4RcXFxCpm6xKHlT58+SWZmZlKfPn0yq2vZUnBwsNSkSROpQYMG8nNv586dkouLi/z2PILwq8gkSdytNae6f/8+gwYN4uPHj9SoUYPx48crLBwoJPf69Wvy5s2LkpISvr6+1KtXjxIlSrBs2TKxuN8PePDgAW3btsXT05MhQ4bQq1cvhayKoOjrjN3Vq1f566+/OH/+PHZ2dpnYs+wnICCAnj17cvToUZo0acK1a9cwNzdn48aNWFlZZXb3hBxMBFJ/gPv372NgYIClpWVmdyVbCQgIoHjx4ixevJj69euLYaqfsH79egYPHoy2tjYrVqygRo0amd2lbCNxlX0hbS5evMiePXtwcXHB1dWVIkWKiB9Bwi8lAilBSEVUVBTDhg1j2bJlzJ49m759+2Z2l7KdkSNHEhkZybx580QQ+gNy4i2cBCGnE4GUIHzHoUOHuH79On369MHY2Dizu5PtxMTEoKqqKrICgiDkSCKQEgRBEARBSCORaxcEQRAEQUgjEUgJgiAIgiCkkQikBEEQBEEQ0kgEUoIgCIIgCGkkAilBEARBEIQ0EoFUDhcVFcX48eOJiorK7K5kS+L4pZ04dmknjl36iOMn/E5i+YMcLjQ0FF1dXUJCQtDR0cns7mQ74vilnTh2aSeOXfqI4yf8TiIjJQiCIAiCkEYikBIEQRAEQUgjlczuQHYXHx+Pl5cX2traWfL2F6GhoQr/FX6OOH5pJ45d2oljlz5Z+fhJkkRYWBgWFha/9P6Tnz9/Jjo6OkPaUlNTQ0NDI0PayonEHKl0ev/+PVZWVpndDUEQBCEb8fT0JE+ePL+k7c+fP6NpqAORMRnSnpmZGa9fvxbBVCpERiqdtLW1AVhxoROaudUyuTfZT2mzIpndhWxNVUk9s7uQbemrixtQp1WRDSsyuwvZVvynGDyHH5N/d/wK0dHRCUFU26KgppzOxuLw2eRBdHS0CKRSIQKpdEocztPMrUYubfGl9rO0dTQzuwvZmpqS+GBLKx11rczuQralpKma2V3I9n7LVBANFWRq6fual5Sy3pSVrEYEUoIgCIKQA8mUZMjSGwgpyRDzf75NXLUnCIIgCIKQRiIjJQiCIAg5kEyWARkpmchIfY8IpARBEAQhB8qooT3h28TQniAIgiAIQhqJjJQgCIIg5EAymSz9VwdmwYWmsxqRkRIEQRCEHChxaC+9j59x/vx5GjRogIWFBTKZjL17936z/tmzZ+UB35ePJ0+epGPPfy+RkRIEQRAEIUNERERQpEgROnXqRLNmzX54u6dPn6KjoyN/bmycfRbMFYGUIAiCIORAmTHZvE6dOtSpU+en38bExAQ9Pb2f3i4rEIFUFnN00z32rbpNkF8EVvYGdBpTEeeSlinWfXD1Pf+23Z2sfP6xtuTJZwBAbEwcu5fd5OzuxwT6RmBhp0+7oWUpVskm6T033+PYlvt8fJ9wg08re0Oa9y1F8S/qbJ9/lYuHnhPgHYaKqjJ2BU1oPciNAkXNMm7n02nditMscT+Cn08wBZwsmTizNWXKFUixrq93MBNGbuOex1tevfClyz/VmTSrtUKdmJhYFs4+xI7Nl/DxCiKfvTmjJzWnas1C8jolnYbw/l1AsvY7dq/KtHnt5M+fPfFiytidXLn4lPh4CQcnC5Zv7EUeK8MM2vv0Wb38OIvmHcTXJxhH5zxMmdket/KOKdb18Q5i3IhNeNx5zasXPnTvVYupszuk2vbuHZfp1mEhdeqXYNPOwfLyyxcfs2jeQTxuv8LXJ5gN2wdRr2FJhW3Dwz8zccxWDh+4SVBgGFZ5jeneqzadu9fImB3PIEuW7GP27B14ewfg4mLDvHm9qFChcKr1z527y+DBS3n48A0WFkYMHdqCnj0bKNTZtes848at5eVLb/LlM2fy5C40aVJe/vr58/eYPXs7t249x9s7gN27J9C4cXmFNiRJYsKEDaxceYigoDBKl3Zi0aJ+uLjYZOj+p1VJM2e6F25EQcN8mGoZ0OPEdE68vZ5q/Vo2pWnjVBsnAxvUlFV5HuTJ/NvbufDBQ16nmX0VZlXqm2xbx7UtiI5LuPdcG6datHGqhWVuEwCeB3my8M4Ozr2/I69vpKnLsJLtqGBZFB11La57P2LClVW8CfXOoL3/9TIykPr6BtDq6uqoq2fc3TyKFSvG58+fcXZ2ZsyYMVSpUiXD2v7VMm2OVOK4aHBwcIa1OX78eIoWLZph7f1ulw49Y+2U8zT7pwSz97fCqaQlU7rs56NX2De3W3iiHauudJE/zG305K9tnXeVE9se0OXfyrgfbUvNVgWZ2esQrx76yesYmuWm7dByzNzbkpl7W1LQLQ8zeh7k3bOkAMHCVp+u/1Zi7qE2TN72FyaW2kzquJeQgMgMPw5pse+/a4wbtoX+w+pz/PIESpctQJsmc3nvmTzIAYiOjsXASJt+Q+vjUijlm07PmLCbjavPMmV2G87dmkL7rpXp0moh9z3eyuscOT+Ouy/d5Y/tB4YA0KBJUkDw5pUfjWtMJX8Bc3YdGc6pqxMYOKIhGupZ4zYbe3ZeYfTQDQwa3pgzV6dRpqwDLRpP5/07/xTrR0fHYmikw6DhjSlY2PqbbXu+/ci4kZtxK5c8KIuMiMKlkDUz5nVKdfsxwzZw+sRdlq3tzRWPOfzTty4jBq3j8IGbP7eTv9D27WcYOHAJo0a15vbt5ZQvX4i6dUfy7p1vivVfv/amXr1RlC9fiNu3lzNyZCv691/Erl3n5XWuXHlIy5aTaNu2Bh4eK2jbtgYtWkzk2rXH8joREZ8oXDgfCxcmDxoSzZy5jXnz/mPhwr5cv74EMzN9atYcRlhY1vi7zaWizuOAN4y/svKH6pcyc+Hih7t0OTaFRnuHctX7AStrjsTZ0FahXlh0BKU2d1Z4JAZRAN4RAcy8vonGe4fSeO9QrnjfZ3mNEdjrJX0WLKs+AmttU3qcmE79PYP5EP6RjXXGo6mSfW4FlpFzpKysrNDV1ZU/pk2bliF9NDc3Z8WKFezatYvdu3fj4OBAtWrVOH/+/Pc3ziJyVEZqyJAh9O2b+odKVndgzR2qNneheouCAHQeUxGPC285tvkebYeWS3U7XcNcaOmk/Md9bu8Tmv1TAtfKNgDUblMYjwvvOLD6Dv3n1gKgZDU7hW3aDC7L8S33eebhg3WBhIxJhYYOCnU6jqrAqZ2PePs0gMJlc6VpfzPS8oXHadWhIm06VgJg0qzWnD31gPUrTzN6YvNk9a3yGjF5dhsAtm28kGKb/229Qv9h9alWO+HGyh26VeXMyQcsW3CUxWt6AGBkrKOwzcI5h7CxM8GtQtLxmj5hF1VrFmbslL/lZXltTdKxtxlryYJDtOlYhXadqgIwdXYHTp+8x5qVJxg3qVWy+tZ5jZk2JyEDtWX92VTbjYuLp0enxYwY+xdXLj0hJFjxy7t6raJUr1X0m327ce05LdtWpHxFZwA6dKnG+tWn8Lj9iroNSvzEXv468+b9R+fOdejatR4A7u69OX78JkuXHmDatK7J6i9bdgBraxPc3XsD4OSUl5s3nzFnzg6aNasIwPz5u6lRw5WRIxOypCNHtub8+XvMn7+LLVvGAFCnTmnq1Cmdar8kSWL+/N2MGtWapk0rALBu3XDMzP5iy5ZT9OjRINVtf5dz7+8oZIG+Z9LVNQrPZ9/cTPW8JalmXYJHAa/l5ZIE/p+CU23n9DvFQHzOzS20caxFMZMCPA/2xFbHnOKmDtT6rz/Pgz0BGHd5BTfarKVBvgrseHryh/ucU3h6eirMYcqobJSDgwMODkmfl25ubnh6ejJ79mwqVqyYIe/xq+Woq/Zy586NoWHWGCr5WTHRcbx84EfR8oq/8IuUt+bp7W+nkoc03EoXt1WMb7eb+1c8k7Wrqq4YL6tpqPD4lleKbcXFxXPx4DM+R8bgUCzlYbuY6DhObH9ILm01bByNvrdrv1x0dCz37ryhUjUXhfJKVV24ee1lOtqNQV1DMWukqaHG9SvPU+3Hru1XaNm+gvyS4/j4eE4evYedvRktG86mYN5+1K00iSMHbqe5XxkpOjqWu3deU6Wa4jBUlWqFuXH1WbranjV1F4ZG2rTtmPYUfZmyDhw5eAuvD4FIksSFcw958dybqtVTHzb7naKjY7h16xk1ayoGdTVquHLlysMUt7l69RE1argqlNWqVZKbN58RExMLwJUrj6hRQ7HNmjVLcPlyym2m5PVrb3x8AhX6pq6uRqVKRVLtW3YjQ0ZuVU2Co8IVynOpanChxXIutVrJqpqjkmWsvqQkU6K+XTk0VTW47fcUADXlhL/7qLhoeb14KZ6Y+FhKmKY85J0VZWRGSkdHR+GRkcN6XytTpgzPn6f8OZsV/ZJA6s2bN8hkMrZt20bZsmXR0NDAxcWFs2fPprpNQEAArVq1Ik+ePOTKlYtChQqxdetW+esbNmzA0NCQqKgohe2aNWtG+/btgeRDex07dqRx48bMnj0bc3NzDA0N6d27NzExX6R4vb2pV68empqa2NrasmXLFmxsbHB3d0+xn1FRUYSGhio8MkJY0Cfi4yR0jRSzO3qGuQj2TzkNr2+iRc/JVRm6qC7DFtfDwlafCe338PD6B3mdohWsObDmDl5vgomPl7h78R03Tr4iyC9Coa23T/1pU3gpLZ0Xs3zsaYYtrY+VvWJQevP0a9oUXkorl8UcXHuHf9c3QcdAM0P2Pz0CA8KIi4vH2EQxO2RsqstH35A0t1u5WkGWLzzGqxc+xMfHc+7UQ44euoOfT8ptHj1wm9DgSFq0Tcoe+vuFERH+mUVzDlGlRiG27R9CnQbF6dJqEZcvZP7lvQH+ocTFxWNioqtQbmyqi286jt21y0/ZtO4s7ku6pat/0+Z0xMHJkkL5e2Om046/G05n1vzOlElhqDAz+PuHEBcXj6mpvkK5qak+Pj6BKW7j4xOYYv3Y2Dj8/UO+WcfHJ+iH+5ZY9+t2TEx+rp2srGuhhmiqaHD41WV52cvgDww9v5BuJ6Yx4PRcouJi2NlgKjY65grbOuhbc7/DZp502s7kcj3558QMXgS/l7fxPsyPoSXboqOmhaqSCj0LN8Eklz4muRSPZ1aWGcsfZIQ7d+5gbm7+/YpZxC8d2hs6dCju7u44Ozszd+5cGjZsyOvXr1PMGn3+/BlXV1eGDx+Ojo4Ohw4dol27dtjZ2VG6dGmaN29Ov3792L9/P82bJwzV+Pv7c/DgQY4ePZpqH86cOYO5uTlnzpzhxYsXtGjRgqJFi9KtW8IHfPv27fH39+fs2bOoqqoyaNAg/Pz8Um1v2rRpTJgwIZ1HJnVfn7ISpLogmqWdPpZ2SX/UDsXN8fcOY/+q27iUSpig3nlMRZaOPk3/mhtBBmbWulRt5sTpXY8V2rKw1Wf2/lZEhEVx9egLFg09zsQtzRSCqYJl8jB7fyvCgj5xYvtD5vQ7wvRdf6NrmPlDe0CyheckSUp+QH/CxFmtGdJnHRWKjUImk2FjZ0LLduXZtvFiivW3rD9P1ZqFMDNP+jeJl+IBqF2vGD36JgylFixizc1rL9i46ixlK2SNgODrU0ySpDQv5BcW9omenRfjvqQbhkY639/gG1YsPsrN6y/Y/N8QrKyNuHzxCUP7r8HUTI/KVQt9v4HfJPnxS34+KtZP4Vz9qjylOmn5J0m5ney/yGIDu/L0L96CHiemE/A5Kej3+PgMj49J2dSbvk840GQ27V3qMvHKann5qxAv6u8ZjI6aFrVtyjCrUl9aHRrLi+D3xEpx9Do5k+kVe+PRfiOx8XFc+nCPs563fus+Zkfh4eG8ePFC/vz169d4eHhgYGCAtbU1I0eO5MOHD2zYsAEAd3d3bGxscHFxITo6mk2bNrFr1y527dqVWbvw035pINWnTx/5OhJLly7l6NGjrF69mmHDhiWra2lpyZAhQ+TP+/bty9GjR9m5cyelS5dGU1OT1q1bs3btWnkgtXnzZvLkyUPlypVT7YO+vj6LFi1CWVkZR0dH6tWrx6lTp+jWrRtPnjzh5MmT3LhxgxIlEtLfq1atwt7ePtX2Ro4cyaBBg+TPQ0NDsbJKebLyz9DW10RJWZYs+xQSEIme4Y9nfQoUM+f8vqRMh65hLkYsq090VCxhQZ8xMNVi06zLmORR/IJTVVOWT1LPX8iUF/f9OLT+Lj0nV5XX0cilirmNHuY2ehQoZk7vaus5teMhTf9RvNLqdzMw1EZZWQm/rzIo/n6hGH+VafkZRsY6rNvej8+fYwgKDMfMXI8pY3dibZN8ONPznT8Xzjxi9dY+yfqmoqKMvZOFQrm9g3mqQ4S/k6GRDsrKSsmyT/5+oZiYpC0IevPKl3dvP9K62Sx5WXx8QqBgkrsN1+7NxdbO9LvtfPoUzeR/t7Fh+yBq1ikOgEuhvDy495bF7gezRCBlZKSLsrJSsgyPn19QskxQIjMzg2TZKj+/YFRUlDE01PlmndTaTPl9Eur6+ARibp70g+jjx2BMTfV+uJ2sqJ5dOaZX7E2fU7O55HXvm3UlJO59fJEsIxUTH8vbUB8A7vu/pLBxfjq61GfMpWUAPAh4Rf09g9FWzYWqsgqBn0PZ3XA69/3TPl3gd8uM5Q9u3rypcMVd4vdlhw4dWLduHd7e3rx7907+enR0NEOGDOHDhw9oamri4uLCoUOHqFu3bvr6/Rv90jlSbm5u8v9XUVGhRIkSPH78OMW6cXFxTJkyhcKFC2NoaEju3Lk5fvy4wgHv1q0bx48f58OHhKGrtWvX0rFjx2/+unJxcUFZWVn+3NzcXJ5xevr0KSoqKhQvXlz+ev78+dHXT/3DSl1dPdlYcUZQVVMmX0ET7l58p1B+7+I7HIr/eIrz9UM/9I21kpWrqatgaJabuNh4rh59Qanqdils/QVJIiY67jt1+H6d30BNTYXCxWw4f1px3sf5M48oUTpfutvX0FDF3CJh6OXQvlvUqlcsWZ3tGy9iZKxD9f9PTP+yb0VdbXj5zEeh/OUL3yyx9IGamgpFitly9rTil9HZ0/cpWSblpSO+x97Bgos3Z3Lu2nT5o3Y9V8pXcubctelY5vmx/Y6JiSUmJg4lJcWPKWVlJXlgltnU1FRxdS3AiROKmYqTJ2/h5uaS4jZlyjhz8qRi/ePHb1KiRAFUVRN+27q5Ja9z4sRNypZNuc2U2NqaY2ZmoNC36OgYzp27m2rfsoMGduWZVbEPA87M48wPZoicDW35GPnt4UwZMtSUk+cWwmIiCfwcio2OOYWM8n1zeYasRkbyFcN/+vGTaf3KlSsjSVKyx7p16wBYt26dwjSfYcOG8eLFCz59+kRgYCAXLlzIVkEUZMJVe6kFPXPmzGHevHm4u7tTqFAhtLS0GDBgANHRSZP9ihUrRpEiRdiwYQO1atXi/v37HDhw4Jvvp6qqOFlYJpMRH58w3JKYTv9aauW/WoPOxVgw5Dj5CpngUMycE9se4O8dTs3WCb+8N826RKBvBP1m1wTg4No7GOfRwcrekNjoOM7ve8LVYy8ZujjpJHzm4UOgbzg2TsYE+oazY8E14iWJxt2TJrtunn2ZYpXyYmSuzaeIaC4efMbDax8Ys6YRAJ8jY9i15AYlq9miZ6JFeNBnjm6+R4BPOG51Us/e/U49+takb9eVFClmg2vp/Gxac44PngG075rwy2jKuJ34eAWzcFXSnJ0HdxOC1ojwKAL8w3hw9x2qaso4OCUMi96+8RJvryAKFrbG2yuYOVP2Eh8v0Xug4h95fHw82zZe5O825VBRUeZr/wyoQ8/2SylT3oFyFR05c+I+Jw57sOvo8F91OH5Kr371+KfLYooVt6NE6QJsWH2KD57+dOpaHYCJY7fi7RXE0tW95Nvcv/sGgPCIzwT4h3H/7htU1VRwdMqDhoYaTi6KWVpdvYTh3y/Lw8M/8/plUoD57s1H7t99g75+bvJYG6Gjk4tyFZz4d9RmNDTVsLI24tKFx2zffJ5JM9qRVQwc+Bft20+nRIkCuLk5s2LFId6985OvCzVy5Cq8vPxZv34EAD17NmDx4n0MGrSEbt3qceXKI9asOcKWLaPlbfbr15RKlQYwY8ZWGjUqx759lzh58jYXLsyX1wkP/8SLF0nzIV+/9sHD4wUGBtpYW5sik8no378p06Ztwd4+D/b2lkybtoVcuTRo3brabzo635ZLRYO8OkkXtVhpm+BkYENIVDheEf4MLdEGUy1DhpxbACQEUbMr92PSlTXc8XuGkaYeAFGx0YTFJGTz+xX7mzt+z3gT6k1uVU06utTDydCGcZdXyN9nSIk2nPO8jVeEP7lVNamfrzylzV3odGyyvE4dWzcCP4fiFe6Pg74149y6cOLtdS5+uPsbjoyQnfzSQOrq1avyyxdjY2O5desWffr0SbHuhQsXaNSoEW3btgUSvpyeP3+Ok5OTQr2uXbsyb948Pnz4QPXq1dM1rObo6EhsbCx37tzB1TUhsHjx4kWGrm31M8rVK0BY0Gd2LrpOkF8E1gUMGbWqISaWCVmvoI+R+H+xplRsTDwbpl0k0DccNQ0VrOwT6icudQAQExXL1rlX8PUMRUNLleKVbOg3u6bCcgnB/pEsGHKcIL8Icmmrk9fRiDFrGlHk/1cQKinL+PAqiLN7HhMa+AltfU3yFzJh8ra/5MsjZLZGf5UmKDCCudP34+cTgoOzJZt2D8TKOmEYzs8nhA/vFdeUqlH2X/n/37vzhj07rpLH2pAbj2cD8PlzDDMm7uHdaz9y5dagWs3CLFzdTR4UJDp/+hEfPANo2b5Cin2r29CVGfPbs3DOIcYO2Uw+ezNWbelN6bJpy/hktCbN3QgMDGPW1N34+gTj5GLFtr3DscqbcIsGX59gPngqrilVucxI+f/fvf2a/7ZfwsraCI+nC3/4fT1uv6JRrUny52OGbwSgZduKLF75DwArN/Rj0rht9Oi4iOCgcPJYGzN6fAs6daue5v3NaC1aVCEgIJRJkzbi7R1IwYI2HDo0jbx5E4YvfXwCePcuad6lra05hw5NZdCgJSxZsh8LC0Pmz+8jX/oAoGxZF7ZuHcPYsWsZN24d+fJZsG3bWEqXTvo8vHnzKVWrJi1wOnjwUgA6dKjJ2rUJQfqwYS359Cma3r3nyxfkPHZsBtraWWNeYyHjfGyt98U5UKYzAP89O82w84swzqWPRe6kofRWTjVRVVJhYrnuTCzXXV6eWB9AR02LqeX/wSiXHmHRkTwKeEXLg2O49zFp3o6Rpi5zKvfHOJc+YdGRPA18Q6djkxWCJJNc+owu3QkjTV0+Rgaz+8VZFt3Z+cuOxa+QGUN7fyKZ9AvSL2/evMHW1hZra2vc3d1xcnJi3rx5bNmyhdevX2NkZMTZs2epUqUKQUFB6OnpMXDgQHbt2sW2bdvQ19dn7ty57NixgypVqijc9DA0NBRzc3NiY2PZsGEDLVq0kL82fvx49u7di4eHB5Bw1V5wcLDC9gMGDMDDw0OeWqxRowaBgYEsXboUVVVVBg8ezNWrV5k2bRr9+/f/7r6Ghoaiq6vLxjs9yKWdfRZqyyrKmicfJhN+nJqSRmZ3IdvSV886a3llN/lWL8rsLmRb8Z9ieNvvICEhIRk2NeRrid9LOmOqItNIX75E+hxL6OTTv7S/2d0vnSM1ffp0ZsyYQZEiRbhw4QL79u3DyCjldYfGjh1L8eLFqVWrFpUrV8bMzIzGjRsnq6ejo0OzZs3InTt3iq//rA0bNmBqakrFihVp0qQJ3bp1Q1tbGw0N8QUlCIIgCMK3/dKhPScnJ65evZria4kT0hIZGBgoZI6+xdvbmzZt2iRbEGz8+PGMHz9e/jxxctuXvl4fytzcnMOHD8ufv3//Hj8/P/Lnz/9DfREEQRCErEgM7f0e2eoWMYGBgRw/fpzTp0+zaFHGpJZPnz5NeHg4hQoVwtvbm2HDhmFjY5NtlqYXBEEQhJSIQOr3+OFAKnHe04/Q0kp++X1GKF68OEFBQcyYMUPh3jzpERMTw6hRo3j16hXa2tqULVuWzZs3J7vaTxAEQRCyE5kSGRBIZUxfcrIfDqRUVVV/OHgpUKAA+/fvT3OnUvPmzZsMb7NWrVrUqlUrw9sVBEEQBCHn++FAytLSkidPMv/eYIIgCIIg/IAMGNqTxNDed2WrOVKCIAiCIPyYjJgjlRk3Lc5uxOinIAiCIAhCGomMlCAIgiDkQCIj9XuIQEoQBEEQcqDEGw+ntw3h28TQniAIgiAIQhqJjFQG+RAejbipzM+reelQZnchW7vcqk1mdyHbiomPzuwuZFszK+fJ7C5kW5Fh0XT4Te8lk2XA0J7ISH2XCKQEQRAEIQcSc6R+DxFICYIgCEIOJAKp30PMkRIEQRAEQUgjkZESBEEQhBxISSnhkb5GMqQrOZoIpARBEAQhB1KWyVASyx/8ciLWFARBEARBSCORkRIEQRCEHEhZSYaSmGz+y4lAShAEQRByIDG093uIoT1BEARBEIQ0EhkpQRAEQciBlJRAWVy198uJQCqLubjjIafX3yXUPxKzfPo0GVKWfMXNU6y7edwZbhx4lqzczE6fEbv+BuDa/qds/fdssjqzrnZBVT3hn//IspscW35L4XVtQ00mnWwvfy5JEkeX3+LKrsd8CovCuqAJf40sj3k+g7TuaoZyNXGio0tDnAztMMllQP8zMznjeSPV+tWsS/F3gVo4GNigpqTCy5D3LL27g8tedxXqVbcuTe+iLbHSNsUzzJeFd7Zy2vN6im12KdiY/sXbsOnRIWbeXJdinbFlutO8QA1m3ljLpseH07y/GW3lsiPMn7sXH+8gnJytmD6nC+XKO6da/+L5B4wcupbHjzwxtzBgwODGdOleW/56TEwsc2bsYsumM3h9CMS+gCUTp7ajRq3i8jpTJ25j2uTtCu2amOrx0nOt/LmfbzBjR23g9EkPQoIjKFfBhVnzupLf3iID9z79li09yNw5/+HjHYizS15mz+lB+QoFU61//tw9hg1dyaOHbzG3MGTwkL/o3qNeinV3bD9LuzYzaNDQjf92j1N47cMHf0aPXMOxozf59Cka+wKWLF8xgOKu9gCoq9RJsc2p07sweMhfadzbjHVs8z32rbpDsF8EeewN6DS6Ak4lLVOtHxMVx87F17mw7ynBHyMwNMtN039KUrV50vl69egLtrlfxfddCKbWurQa5EbpmvkU2gnwCWfzrMvcOf+W6M+xmNvo8c+0auQraJLsPZePOc3J7Q/pOKoC9ToVzbB9/9WUZTKU0zs0J4b2vuuPD6QqV65M0aJFcXd3ByAyMpJ27dpx4sQJwsLCCAoKQk9P77f05faxF+yZdZm/RpbHtqgZl3c9Ynmfw4zc9Tf65trJ6jcdWpYG/UrLn8fHxTOzxX8UqWGnUE8jtxqj9rRQKEsMohKZ5dOn17L68udfT1A8te4uZzfdo/WEypjk1eP4ytss7XmIUXtboKGlltZdzjCaKuo8DXrL3pdnmFd56Hfru5o4c9X7LgvubCEsOoLG+auwsMoI2hwZyZPANwAUNirAzIoDWeyxjVPvrlPNuhSzKg2k49Gx3Pd/odCei2E+/rKvwdP/b5uSKlYlKWRkj29kYHp2NcPt2nGR4YPXMHdhd8q4ObJ21XGaNZjEjbsLsLI2Tlb/zWtfmjWcTMcuNVi5bgBXrzxhUN8VGBnp0qipGwATx21h+9ZzLFzaiwIOlpw64UHr5jM4eW4aRYolnZ9OzlYcODpB/lzpi5/PkiTR8q9pqKqqsG3XSLS1c7Fo/n4a1hnPjbsL0NLKGne33LnjHEMGLWfBot64lXVm1crDNKw/Fo/7y7G2Tv6l/Pq1D40ajKNz19qsXT+UK5cf0a/PYoyNdWnStLxC3bdvfRkxbBXlyycPyoKCwqhScTCVKhdh/8FJGJvo8eqlF7p6Wknbv9+ssM2xozfp0c2dJk3LZdDep8+lQ89YO+UC3cZXxqG4OSe2PWBK1wPMO9IGY4vkn3kAc/sfIcQ/kn+mVsUsrx4hAZHEx0ny15/e8WbegKO0HFCGUjXsuH7iFfP6H2XS1mbYFzUDIDzkM2Nb/odL6TyMWtUAXcNc+L4LQUtbPdn7XT/xkud3fdE31Ur2miCASNols379ei5cuMDly5fx9vZGV1f3t7332U33Kd3YEbemTpjZ6dN0aDn0zHJzceejFOtraqujY5RL/nj36COfQqMo3dAhWd0v6+kY5Ur2upKyksLruQ005a9JksT5Lfep0aU4RarZYZ7fgDaTqhD9OZZbR14kayszXPTyYNH/A54fMfPmOtY+3M/DgJe8C/NhwZ2tvA3zplKeEvI6bZ3rcdX7Hqsf7OVNqBerH+zluvcD2jopZg40VTSYVqEf468uIzQ6IsX3M9E0YFSpLoy8MJ/Y+Ni07+gvsGj+ftp3qkbHzjVwdLJixpwuWOYxZNXyoynWX73iGHmsjJgxpwuOTlZ07FyDdh2rMn/eXnmdbVvOMmR4M2rVccXWzoyuPWpTrUZRFrrvU2hLRUUZUzN9+cPYOOnv7cVzL25ce4b7wh64lrCngIMl8xZ2Jzz8Ezu3X/glxyIt5s/bQ8fONencpTZOTtbMmduTPFbGrFiW8g25Vy4/hJW1CXPm9sTJyZrOXWrToVNN5s3ZpVAvLi6Oju1mMvbfdtjamSVrZ/bMneTJY8zK1YMoWcoBGxtTqlYrRr58Sdk6MzMDhceB/VepVLkwdnYpZ7l/t4NrPKj6lzPV/nYhT34DOo2piJFZbo5vuZ9i/Tvn3/Lo+gdGrmpI4XLWmOTRwb6IGQ5fZO0PrfOgcDkrmvQsgWU+A5r0LEFBtzwcWuchr7N3xS0MzXPTe0Z17IuYYZJHh0JlrTDLq/h5H+ATzuoJ5+g/tyYqKtnv6zIxI5Xeh/Bt2e/M+MVevnyJk5MTBQsWxMzM7LddsRAbE8f7xx9xdFO8q7pjmTy8uev7Q21c2/uEAqXzYPDVL7noTzFMqLOZf2ttYkW/I7x/4p9sW/93IYyrsZGJ9bawfvhJ/N+Hyl8L+BBGqH+kQt9U1JTJ72r+w33L6mTI0FLVJCQqXF5WxLhAsqG+S14eFDFWDFRHl+7Chfe3uead8oe/DBlTy/dl3cP9vAx5n/GdT4fo6Bju3H5J1epFFcqr1SjKtatPUtzm+rWnVKvxdf1i3Ln1kpiYhCAxKioGdQ3FTKWmphpXLj9WKHv5whv7vJ0pWKAHHdvM4fUrn6S+RSW0pa6hKi9TVlZGTU2VK5cU28ks0dEx3L79nBo1iiuUV69RnKtXUv4BdO3qE6p/Vb9mzeLcuvVcfvwApkzagpGxLp0610qxnYMHr1Lc1Z5WLaaQx7wlpUr0ZvWqI6n21dc3iCOHr6fa3u8WEx3Hq4d+FClvrVBeuLw1T297p7jNzVOvyVfIhH0rb9G9/Br61djIhukXifqcdNye3fFJ1mbRCtY8veOj2E5BU+b0PUKX0qsY2nArJ7c/UNgmPl5i4dATNOxaHCt7w/TubqZQVpJlyEP4tmwdSF2+fJmiRYuioaFBiRIl2Lt3LzKZDA8PD3mdc+fOUapUKdTV1TE3N2fEiBHExqacEahcuTJz5szh/PnzyGQyKleu/Ht2BIgI+kx8nIT2F5kgSJirFBoQ+d3tQz5G8PiSJ2WaOCqUm9ro0XpCZbq616b9tGqoqikzv9M+Pr4NkdfJW9CENpOq0HNJXVqMrUhoQCTzO+4lIvgzAGH+Ce+f1r5lBx1cGqCpos7xt5flZUYaegR+DlGoF/g5BCNNPfnz2jZlcTKwY/7tLam23blgI2KlODY/yTpzohIF+IcRFxePiameQrmxiR6+PsEpbuPrE4SxiWJ9E1M9YmPjCPBPCMCr1yjGIvf9vHjuRXx8PKdPenDowHV8vIPk25QoZc+KNf3Ze/BfFi7tha9vENUrjSQgIKGNAo6WWOc1ZvyYTQQFhRMdHcOcmbvw9QnC1yeIrMDfPzTh+JnoK5Sbmujh45tyH318gzD9+viZ6BMbG4f//4/f5UsPWbf2GEuX90/1vV+/8mHF8kPkz2/JwcOT6da9HoMGLGPTxpMp1t+44STa2po0bpI1hvXCgj4RHyeh91WGXM9Ik2D/lD9XfD1DeHLTG89ngQxdXJeOoytw9egLVo8/K68T7B+JrqFim7qGuQj+mJQt9vMM5fiW+5jb6DJmTSNqtirEmknnObcnKUDft+IWysoy6nYokgF7mzmUAWVZOh+ZvRPZQLadIxUWFkaDBg2oW7cuW7Zs4e3btwwYMEChzocPH6hbty4dO3Zkw4YNPHnyhG7duqGhocH48eOTtbl7925GjBjBgwcP2L17N2pqyef+REVFERUVJX8eGhqarE66fBX8S9KPreNxff8zNLXVKVTFRqHcprApNoVN5c9ti5oxu9Uuzm97QLPhCR+ozl/+erMHmyKmTG6wlesHnlGlXeHv9O2H9ipLq2NTjn8KN6ff2ZkEflb895QkKVl9iYQy01yGDC/ZiR4nJxMdH5Ni204GdrRxqkeLg8MyvuMZKNm/oyR987z7+rXE45RYPmNuF/r2XIJrob7IZGBrZ0bbDlXZtP60fJuatV3l/+9CXkqVcaCw4z9s2XiGvgMaoaqqwqbtw+ndfRHWpu1QVlaiSrUi1KytmM3JClI6Hmk7fhAWFknHDrNYsqw/RkapTy2Ij5dwdbVn0pSOABQtlp9Hj96yYtkh2rarnqz++nXHadm6ChoamT+nUcFPfK5I8RLIoN/cmvL5TB1Glk/ILI2vjLpGwldasmP/1edovCSRr6AJrQeXBcDWxRjP5wEc2/KASk2cePnAj0Pr7zJzbwuxjpLwXdk2kNq8eTMymYyVK1eioaGBs7MzHz58oFu3bvI6S5YswcrKikWLFiGTyXB0dMTLy4vhw4czbtw4lL66m6OBgQG5cuVCTU0NM7PkcxIApk2bxoQJE1J8LT209DVQUpYRFvBJoTw88FOyTNDXJEni2r4nlKhnj4rqt38/KCnJsHYx5uO7kFTrqGuqYp7fQF5H+/+/GMMCPqFrnDThMqFvyedbZSe1bMoyvuw/DDk3N9nQnP/nYAy/yD4BGGjoEvAp4bg4G9phqKnHtnoz5K+rKCnjaupES8falNjcGldTRww0dDjWbKlCncGuHWjjVI86u3v/up37AYZG2igrKyXLPn38GIKJacpf4qZm+vh9lW356BeCiooyBoYJw8rGxrps2zWSz5+jCQwIw9zCgHGjNpLXxjSlJgHQ0tLApWBeXr5IGtYpVjwfl2/OIyQkgujoWIyNdalSbhjFXPOl2s7vZGSkk3D8fBUvIPD7GJIs65TIzFQ/Wbbq48dgVFSUMTTU4dHDt7x940vTxuPlr8fHJwRaudTrcf/RSvLls8Dc3AAnZ8UhLEdHK/buvpTsPS9eeMCzp+/ZvGVkGvby19DW10RJWUbwR8XsU0jAp2QZpUT6JloYmOZWmBRumc8ASYJAn3DMbfTQM8pFsL/iXMWQwEh0v8h86RtrkSe/4hXHlvkMuHr8JQBPbngRGhDJP5XWyV+Pj5NYP/0ih9Z7sORsx7Ts8m+XIUNzYmjvu7JtIPX06VMKFy6MhkbSlTulSpVSqPP48WPc3NwUflGUK1eO8PBw3r9/j7W14ofQjxg5ciSDBg2SPw8NDcXKyioNe6BIRVWZPE7GPL36nsJVbeXlT6++p2Blm29u++KWN/6eoZRp7PjNepAQdH14GoC5ferLFsRGx+H7Ohi7YgkTOA0ttdExysXTq+/J42iUUCcmjhe3vGnQv3Sq7WR1dWzKMaFsL4ZfcOfCh9vJXr/78Rlu5oXZ9Dhp0nBZiyLc/fgUgGve92m6f5DCNhPL9uJ1iBdrH+4lXornwKvzXP0qQFtafQwHX51n34szv2Cvfo6amirFiufjzKm7NGxcRl5++uRd6jUoleI2pUo7cOSQ4tISp096UMw1H6qqih8pGhpqWFgaEhMTy/69V2jSLPVhpaioGJ4+eU/Zck7JXtPVTQjgXzz34vatl4wZ3/qH9/FXUlNTpXhxe06evEOjxkn7durkbRo0cEtxm9JlHDl06JpC2YkTt3F1tUdVVQUHRytueyxVeP3fcRsIC4tk7ryeWFklXEnpVtaZZ08V59w9f/YhxSsF1609RnFXewoXsUv2WmZRVVPGzsWEe5c8FZYmuHfpHSWrp9xPh+LmXDnygk8R0Wj+/2ph7zfByJRkGJjlBqBAMTPuXfKkfqdi8u3uXnyHQzEzhXa8XisGs95vguVXClZs7EChcoqf65M776NiIweqNEt9WZCsRikDJotLIiP3Xdk2kEopdf71MMy36qQ1Xauuro66evJLZDNC5baF2DzmDFbOxtgUNuXK7scE+YRT7q+EP9wDC64R4hdB28lVFba7tvcJeQuZYJ4/eXB0dPlN8hYyxdhal88R0Zzf+oAPzwL4a2TSZdb75l7BpWJe9M1zExb4iROrbvM5IppSDQoACceqYutCnFh9B2NrXYytdTmx+g5qGiq41sn/S47Fz9JU0cBaO+mD0jK3CQ76NoREh+MT4U+/Yq0xzWXA6EuLgIQganL5Psy8sZZ7H59jqKEHQFRcNOExCb+QNz8+xNpaE+nk0ogznjeoYlWS0uaF6Hh0LACRsZ95Eeyp0I9PsVGERIXJy0OiwhUmsAPExscS8CmIN6Fev+RY/Kw+/RvSrdN8irnmo1RpB9atPsF7T3+6dE+YlPzv6I14ewWyYm3CfJ0u3WuxYulhRgxdQ8fONbh+7Skb1p5i7cakoPLG9Wd4fQigcBFbvLwCmTZpG/HxEgOGNJHXGTV8HXXrlSCPlTEfP4Ywc+pOwkIjad2uirzOnv8uYWSsSx4rIx4+eMvwwaup37BUssnuman/wCZ06jAbV1d7SpdxYvXKI3i++0i3HnUBGDNqLV5eAaxZNwSAbj3qsXTJAYYOXkHnrrW5dvUx69YcZ+Pm4UBC8OlS0EbhPfT+v6TBl+X9+jemUoXBzJi2jWbNK3LzxlNWrzrCkmX9FLYNDY1g138XmDGrG1lN/c5FWTj0BPkKmlCgmBkntz/E3zucmq0SlnvYPPsygb7h9J1VE4DyDQqwa/ENlow4xd/9ShMW9ImNMy5R9S8n+bBevQ5FGdd6F3uX36JkdVtunHzN/cvvmbS1WdL7dirKmBb/sXvpDdzq2vPiri8ntz+gx6SEz1ZtfU209RVHAlRUlNA30sLSTnE+nCBk20DK0dGRzZs3ExUVJQ9sbt68qVDH2dmZXbt2KQRUly9fRltbG0vL1Bd8yyzFa+UnMiSKYytuEeofiXl+A3osrCO/Ci/UP5IgH8Uv5U9hUdw99ZqmQ8um2OansGh2TDpPaEAkmrnVsHQ0ou+qBuT9YtG5YN8INow8RUTwZ3Lra5C3kCkD1zdRuPqvWscixETF8t+0i0SGRpG3oAn/LK2XJdaQAnAxtGNNraQh12ElOwKw78VZxl5ejLGmPmZaRvLX/ypQA1UlFUaX7sbo0klfMIn1ISEjNfy8O32KtaRP0ZZ4hvkw7Py8ZGtIZXfN/i5PYGAYM6bswMc7CGcXa/7bPwbrvAnniI9PEJ6eH+X1bWxN2bV/DCOGrGXl0iOYWxgwa14X+RpSAFGfo5n07xbevPZFK7cGtWq7snLtAHlAAOD1PoBO7eYS4B+GkbEOJUsV4PSFGfL3TXzvkcPW4ucbgpm5Pq3aVGb46Oa/4aj8uOZ/VyIgIIypk7fg7R2IS0Eb9h2YSN68CcOYPj6BeL7zk9e3tTVj34GJDB2ygmVLD2BuYchc957J1pD6nhIlHdjx31jGjlnHlMlbsLE1Y/bcHrRqrfhDa8f2c0gStGhZOd37mtHK1StAePBn/lt8nSC/CKwKGDJqZQOMLXUACPKLwN8r6TNPU0uNsesasXrieUY03Y62ngZudfPTcmDSuedQ3JwB82qzzf0K2+ZfxcxKl4HuteRrSAHkL2zK0MV12TznCv8tuoFJHh06jq5AhUbJl47JzjJiaE8SQ3vfJZNSmk2bDYSGhmJra0v9+vUZMWIE7969Y8CAATx58gQPDw+KFCnChw8fKFCgAJ06daJPnz48ffqUrl270rt3b/lk868X5BwwYAAeHh6cPXv2h/uhq6vL9Aud0MidNYKK7GT1vYDM7kK2drlVm8zuQralppQ1FvTMjva/znpXoGYXkWHRdCi+nJCQEHR0dH7JeyR+L5Vb9xcquVS/v8E3xEbGcKnjf7+0v9ldtl3+QEdHhwMHDuDh4UHRokUZPXo048Yl3D4hcd6UpaUlhw8f5vr16xQpUoSePXvSpUsXxowZk5ldFwRBEAQhh8i2Q3sAZcuW5e7dpAUTN2/ejKqqqsIk8kqVKnH9euqrXX+deUrMTAmCIAhCdiaG9n6PbB1IbdiwATs7OywtLbl79y7Dhw/n77//RlPz28sFCIIgCEJOlxG3eBFX7X1flhrae/PmDTKZ7IceBQsWxMfHh7Zt2+Lk5MTAgQNp3rw5K1asyOzdEARBEAThD5GlMlKqqqo4OPzYVRN2dnYMGzaMYcOy9orRgiAIgpAZEm7zkt6MVAZ1JgfLUoGUpaUlT56kfKNUQRAEQRB+nJISKKdz3Ck+S41bZU1ZKpASBEEQBCFjZMQcqXgxR+q7RKwpCIIgCIKQRiIjJQiCIAg5UEYsfxAvlj/4LhFICYIgCEIOJIb2fg8xtCcIgiAIQoY4f/48DRo0wMLCAplMxt69e7+7zblz53B1dUVDQwM7OzuWLVv26zuagURGKoM0ylcMbR2xEOjP6l7Q7PuVhFRFxUVmdheyLXGvvbRrkq9hZnch2woNjQCW/5b3Us6Eq/YiIiIoUqQInTp1olmzZt+t//r1a+rWrUu3bt3YtGkTly5dolevXhgbG//Q9lmBCKQEQRAEIQdSJgOG9vi57evUqUOdOnV+uP6yZcuwtraW357NycmJmzdvMnv27GwTSImhPUEQBEEQMsWVK1eoWbOmQlmtWrW4efMmMTExmdSrnyMyUoIgCIKQAyllwFV7cf/fPjQ0VKFcXV0ddXX1dLUN4OPjg6mpqUKZqakpsbGx+Pv7Y25unu73+NVERkoQBEEQcqDEq/bS+wCwsrJCV1dX/pg2bVqG9VP21fCjJEkplmdVIiMlCIIgCMI3eXp6oqOjI3+eEdkoADMzM3x8fBTK/Pz8UFFRwdDQMEPe41cTgZQgCIIg5EAZcdVe4vY6OjoKgVRGcXNz48CBAwplx48fp0SJEqiqqmb4+/0KYmhPEARBEHKgjBza+1Hh4eF4eHjg4eEBJCxv4OHhwbt37wAYOXIk7du3l9fv2bMnb9++ZdCgQTx+/Jg1a9awevVqhgwZkmHH4VcTGSlBEARByIGUZQmP9LbxM27evEmVKlXkzwcNGgRAhw4dWLduHd7e3vKgCsDW1pbDhw8zcOBAFi9ejIWFBQsWLMg2Sx+ACKQEQRAEQcgglStXlk8WT8m6deuSlVWqVInbt2//wl79WiKQEgRBEIQcSEkmQymdV76ld/s/gQikBEEQBCEHUsqAob10LkP1RxCTzbOY9SvO4OYygnyG/1Cn/CSuXXqWat3D+27TqsFcCucdiKN5XxpWncbZkw8U6mxee56mNWbgkqc/Lnn607L+XO7cfJ1qm4tmHyZP7m78O2xbsteeP/Gm09+LcLLoh4NZHxpUmcoHz4C072wGW770EE72XdDP3ZSypQZw6eLDb9a/cP4+ZUsNQD93U5wLdGXl8iPJ6gQHhzOg71Jsrdqjn7spxQr9w9EjN1Nsb9aMneRSbcDQQSsVyiVJYvLELdhZd8BAuxm1qo3k0cO3ad/RX2DV8mMUceiDmW5bKruN4PLFx6nW9fEOomv7BZQsNAADzZaMHLIuWZ0De69RpexI8pp2wtKgPRVKDWPb5vPJ6nl9CKR7x4XYWXTBQr8dFUoNw+P2K/nrfr7B9Oq6BCfbnljot+OvBlN5+cI7Q/Y5Iy1bepAC+Tuio9WQMqX6cvHCg2/WP3/uHmVK9UVHqyEO9p1YsfxQqnV3bD+Lukod/mo6UaF80oRNqKvUUXhYW7ZWqPP164mPObP/S/vOZrClS/aT364dWpp1KVWiFxcu3P9m/XPn7lKqRC+0NOtin68dy5cpXvH18OEbmv81gXy2bVFRqsF8993J2oiNjWPsmLXkt2tH7lz1sM/XjkkTNxIfHy+v4+sbROdOM7GybIG2Vn3q1hnJ8+fvM2anhRxFBFJZyP7/bjB++Hb6Dq3H0UvjKFXWnnZNF6QarFy79IwKVZ3ZsLsfhy+MoWxFBzo1X8SDu0kT+a5ceEqj5qXYcXgw+06NwNLKgDaN5uHtFZSsPY9br9m89jxOBfMke+3NKz+a1JxBvgJm7DwyhONX/mXA8Pqoq2eNy1P/23GBYYNXMWzE31y5MZ9y5V1oXH88nu/8Uqz/5rUPTRpMoFx5F67cmM/Q4c0ZMnAFe3dfkteJjo6hfu2xvH3rx5ZtI7j7cBmLl/bBwiL52iY3bzxjzaqjFCpkk+y1ubN3sdB9L3Pn9+DClbmYmulTv844wsKyxg2Hd++8zKgh6xk8vAnnrk3HrZwjfzeahuc7/xTrR0fFYGSsw+DhTShYOG+KdfT1czN4eBOOn5vExRszadO+Mn26L+XUCQ95neCgcGpXGYeqqjI7943k6p05TJ7eDl3dXEBCANr279m8ee3L5p1DOHdtBnmsjWhcZzIREZ8z/Dik1c4d5xgyaDkjRrbk2s1FlCvvQsP6Y3mXyrn3+rUPjRqMo1x5F67dXMTwES0YNGAZe3ZfTFb37VtfRgxbRfnyBVNsy9klL2/fb5Y/bnksUdz+i9fevt/MilUDkclkNGlaLv07ngF2bD/LoIFLGTmqFTdvL6V8+YLUrzvqG8fOmwb1xlC+fEFu3l7KiJGtGNB/Cbt3XZDXiYyMwtbWnKnTumBmZpBiOzNnbGPF8oPMX9iHB49WM31GN+bM3smihXuBhHOvaZN/efXKh917J3Lz9lLyWptSq8ZwIiI+Zfhx+FWUZBnzEL5NJn1rVpjwXaGhoejq6vLYawHaOprpaqt+5akUKmLNtPlt5WWVi4+lVoNijJzQ9IfaqFpiHA2alWTgyAYpvh4XF49Lnv5MntOKv1qXlZdHhH+mdvlJTJ3XhvkzDuFS2IoJM1vKX+/VYQUqqsosWNUljXuXMgN1swxpp2LZwRQtlo8Fi3vJy4oV+ocGDcswcUqHZPXHjFzHoYPXuHN/qbysb6/F3L/3mrMXZwOwcvkR3OfuxuPBUlRVUx8FDw//RNlSA3Bf+A8zpm6ncBE7Zs3tBiR8INtZd6BPv4YMHvoXAFFRMdhYtmPS1A507f7jN/dMSVRc+oOx6hVGU7ioLXMXdpWXlS4ykLoNSvLv5Nbf2BLq15hAoSJ5mTa743ffp1KZ4dSsXZzR41sAMH7MFq5dfsqR0xNSrP/iuRclCw3k8u3ZODlbAQnnr71VN8ZPbk37ztV+cA9TlkslY9bEKe82gKLF87FocV95WeGC3WnY0I3JUzslqz9qxGoOHrzGvQcr5GW9ey3k/t1XnL80T14WFxdH9SrDaN+xJpcuPiA4OIL/do+Tvz5pwib277/CjVuLf7ivfzWdSFhYJMdOTP/Z3VSgrJQxs0LcyvSleLH8LF7aX15W0LkzDRuVY+q05J81I4av5OCBKzx4tEZe1qunO3fvveLS5QXJ6uezbUu//k3pP0Dx87NhgzGYmuizcvVgeVnzvyaQK5c66zeM4Nmz9zg7duLu/ZW4uNgACf8e5qbNmTa9K1261k3zPoeGRmCg15iQkJBfsi5TwnskfC/1OdIedS21dLUVFRHNojobfml/szuRkcoioqNjuX/nLRWrOSuUV6zmws2rL3+ojfj4eMLDo9DT10q1zqfIaGJi4pLVGT1oC9VqFaZCFedk28THx3Pq2D3s8pvSptE8itgMon7lqRw9cOeH+vWrRUfHcOf2C6rVKKZQXq16Ma5eSXmI6trVJ1Srrli/es3i3L71gpiYWAAOHbxG6dKODOi7DBvLdpQo2puZ03cQFxensN3AvsuoXacEVasVTfY+b1774usTpPBe6uqqlK9YkGtXnqRldzNUdHQsHrdfUbV6YYXyKtWLcP1q6sPKP0OSJM6dvs+LZ96ULe8kLz968CbFXO3o2Hou9lbdqFh6OOtXn5K/HhWV8O+g8UXWU1lZCTU1Fa5efpohfUuv6OgYbt9+To0axRXKq9coztUrj1Lc5trVJ1T/qn7NmsW5deu5/NwDmDJpC0bGunTqXCvV93/x/AM2Vm0okL8jbVtP49Wr1Ic9fX2DOHL4+jfb+52io2O4fesZNWq6KpTXqOHKlSspD8tfvfqYGjUU69esVYJbN58pHLvvKVeuIKdP3+HZs4Shurt3X3Lp4gPq1CkFJPzYAdDQSApClJWVUVNT5dKlbw/bCn8eEUj9pKioKEJDQxUeGSEwIJy4uHiMTRQjfmMTbT76hfxQG8sXnCAyMooGTUukWmfauF2YWehR/ouAad/O69z3eMeIVLJe/h/DiAiPYvHcI1SuUZAt+wdQu0ExurVeypULmf+F5u8fSlxcPKYmegrlJqZ6+PoGp7iNr28QJqaK9U1N9IiNjcPfP+Hf9M1rH/bsvkRcXDy79//L8JEtWDBvLzOm7ZBvs3P7eTzuvEwx6wXg6xMk74tC30z08PVNPrz6uwX8/9gZm+gqlBub6OKXyrH7USEhkeQxbI+JdhtaNJnBjLmdqPJFwPbmtR9rVpzALp85uw6MolPX6owYvJZtm84BUMDBAitrYyaO20pwUDjR0bHMm7UXX59g+XHNbInnnomJvkK5qYkePqn8+/r4BiU/V030Fc69y5cesm7tMZYu759CCwlKlnJgzbohHDw8maXL+uPrE0TlCoMJCEj5M2njhpNoa2vSuEnWGNbz9w9JOHamisfOxFQ/1X9fX5/AFOsnHLsf+5wEGDa8BS1aVsHFqTMaarUpUfwf+vVvSstWVQFwdLQib15TRo9aTVBQGNHRMcyYvg0fn0C8vQN/ck8zj5KSLEMewreJq/Z+0rRp05gwIeWhiIyQ/OaNIOP7J/LeHdeYO3U/a7b3xsgk5fTrknlH2fvfdXYeGYqGRsKvfK/3gfw7bBtb9g+Ul30tPj5h9LdmvaJ061MDAJfC1ty69pJNq8/hVsHhh/fvV0rpxpffunL3ezfKjI+XMDbRZfGy3igrK1PcNT/eXoHMm7ubUWNa8d7zI0MHrWT/4YkKv1x/+L2y0GXFKR+79PVPW1uD89dnEhH+mXNn7jN6+AZsbE0oX8kFSMh0FnXNx7hJrQAoXNSWJ4/fs2blCVq2rYSqqgobtg2ib89l2Jp3QVlZicpVC1G9VtF09etX+Nnjl/q5B2FhkXTsMIsly/pjZKSb0uYA1K5TUv7/BQtBGTcnnAp0ZuOGkwwYmPxH0fp1x2nZusp3z9XfLeOO3Y+frzu2n2XL5lNs2jwSZxcb7nq8YNDApVhYGNK+Q01UVVXY8d84unedg7FhU5SVlahWvbjCMc8OMmNBzj+RCKR+0siRI+UrtULCWLSVlVW62zUwzI2yshJ+voq/qvw/hqUaGCXa/98NhvTewPKNPVIcmgNYNv8Yi2YfZuuBQTh/MZn83p23+H8Mo075yfKyuLh4rl16zrrlZ3gVuBQDw9yoqChTwNFcoc38DmbcuPLiZ3c1wxkZ6aCsrJQsA/DRLwSTr375JzJN4Vev38cQVFSUMTTUBsDMTB9VVRWUlZXldRyc8uDrE/T/IZ0X+PkFU670APnrcXHxXLzwkGVLDhIcsRtTs4Rfz74+QZibJ018/fgxJFlWIjMY/v/YfZ198v8YmixL9bOUlJSwy5cwB65QERuePfnAvFl75YGUqZk+jo6WCtsUcLTkwN5r8udFi9tx4fpMQkIiiYmOxchYh+oVRlO0uF26+pZREs89X1/FLIXfN/59zUz1k5+rH4P/f+7p8OjhW96+8aVp4/Hy1xN/zORSr8f9RyvJl88iWbtaWhq4FLThxYsPyV67eOEBz56+Z/OWkT+5h7+OkZFuwrHzUTx2H/2Ck2VwE5maGaRYP/HY/ajhw1bKs1IAhQrZ8vatHzOmb6N9h5oAuLoW4Nad5YSERBAdHYOxsR5uZfpSwtX+J/ZS+BOIob2fpK6uLr95Y0bexFFNTYVCxfJy4bTinJ4Lpx9Roky+VLfbu+MaA3uuZdGarlSrXTjFOkvdjzF/xiE27ulPkeI2Cq+Vr+zEyWvjOXZ5nPxRpHhemrQozbHL4+RzUoq42vDyua/Ctq+e+2Jplfl351ZTU6VY8fycPqk4Z+v0KQ/KuDmluE3pMo6cPuWhUHbqxB2Ku+aXTywvU9aZly+9FS6JfvHMCzNzA9TUVKlStQg37izi6s0F8kdx1/y0bFWJqzcXoKysjI2tKaZm+grvFR0dw8XzDyjt5pgxByAd1NRUKFrcjjOn7imUnz11j1JlCmToe0lS0rwngNJuDjx/pjin5+Vzb/JYGyfbVlc3F0bGOrx84c2dWy+pWz/14evfSU1NleLF7Tn51bl36uRtyril/KOmdBlHTp1UXMX5xInbuLrao6qqgoOjFbc9lnLj1mL5o36DMlSqXJgbtxZjZZX8+ABERUXz9Mk7zFO4Um3d2mMUd7WncJGsEYDC/4+dawFOnlA8FidP3sbNzSXFbcqUceLk18fu+C1cSxT45gUhX4uM/IySkuLXn7KyksLfeiJdXS2MjfV4/vw9t24+o0GjssnqZFXiqr3fQ2SkspDufWrQv9tqChfPi2upfGxee54P7wNp16USANP+3Y2PVxDzVyZczbJ3xzUGdF/LhJktKF7KTp7N0tBQRef/l5AvmXeU2ZP2sXBNV6zyGsnraGmpo5Vbg9zaGji6KGYFNHOpo2+gpVDes39NenVYQely9pSt6MjZEw84eeQeO49kjRtL9hvQmC4d51Lc1Z7SZRxZs+oonu8+yq+KGzd6PV4fAli1LiGb2LV7bZYtOcjwIavo1KUW164+Yf3aE6zflLQ/3XvUYdnigwwZuJJ/etfnxQsvZs3YyT996gOgrZ0Ll4KKl/9raWlgYKgjL5fJZPTp15BZ03eSL78F+fNbMGvGDjRzqdOiVaXfcWi+q1e/evTsvIhixfNRsow961ef4r2nP526JQzjThizBW+vQJat6SPf5v7dNwBERHzG/2Mo9+++QVVNBUenhGzn3Jl7KFY8H7Z2pkTHxHLi6B22bT7PnAVdvnjfutSqPI45M/bQ5C83bt14wfrVp5i3uJu8zt5dVzAy0iGPlRGPHr5jxOD11GtYkqo1ivyGI/Nj+g9sQqcOs3F1tad0GSdWrzyC57uPdOuRcGXXmFFr8fIKYM26hHOrW496LF1ygKGDV9C5a22uXX3MujXH2bh5OJAwwdmloI3Ce+jpJVwc8mX58KErqVe/NFbWJnz0C2ba1K2EhkbStn11hW1DQyPY9d8FZszqRlYzcGAzOrSfgWuJApRxc2LlisO8e+dHj54Jf2OjRq7Gy8ufdesTjk2PnvVZsng/gwcto2u3Oly98pg1a46yecsoeZvR0TE8evRW/v8fPvjj4fGC3Lk1yZ8/4TOtfoMyTJu6BStrE1xc8uJx5wXu83bRsVPSRPz/dp7DyFgPa2sTHtx/zcABS2jUuCw1a2aNIP5HiKG930MEUllIw79KEhQYjvv0g/j5hODgbMGGXf3IY52Q9fHzCeaDZ1Jae9Oa88TGxjF60BZGD9oiL2/exo15yzsDsGHlWaKjY+nRdpnCew0c2YDBoxv+cN/qNCzOtPltWTTnCOOGbiOfvSkrNv9DqbJZI839198VCAgIZdqUbfh4B+Lskpc9B/7FOq8JAD7egXh6fpTXt7E1Y8+Bfxk2eBXLlx7C3MKA2fO60/iL9XXyWBlz4PBEhg1ZRanifbGwNKRX3wYMHvpzN9McNKQZnz5FM6DvUoKDwilZqgAHDk9EWztXxux8OjVtXpbAwDBmTt2Fr08QTi5WbN87Auu8CZkPX59g3n+1llnF0sPl/+9x+xX/bb+ElbUx954tAiAyIooh/Vfj9SEADU017B0sWb62D02bJ/2aL14iPxt3DGbi2K3MmrqLvDbGTJ3Vgb9bVZDX8fUJZvSwjXz0C8bUTJ+WbSoydFTWuplp878rERAQxtTJW/D2DsSloA37Dkwkb15TAHx8AhXWM7O1NWPfgYkMHbKCZUsPYG5hyFz3njRpWv6n3vfDB3/at52Bv38oxsa6lCrtyIVL8+Tvm2jH9nNIErRoWTnd+5rR/m5RmYCAUCZP2oS3dyAFC9pw4NCUL45dgMKaUra25hw4NJkhg5axdMl+LCwMcZ/fi6bNks4ZL68AShT/R/587pydzJ2zk4qVCnP6zBwA5i/ow79j19G39wL8/IKxsDCkW/d6jB2XtPSMt3cgQwYvx9c3YVi+bbsajBnb5lcfkgwlbhHze4h1pL6ybt06OnXq9M2bLn4pI9eR+hNl1DpSf6qMWEfqT5VR60j9iTJqHak/0e9cR2rEqY4Zso7U9GrrxDpS3yD+Gr7y5s0bKlXKGkMugiAIgpBWSmTAvfYypCc5mwikvnLs2DHmz5+f2d0QBEEQhHTJiMniYrL594lA6itXrlzJ7C4IgiAIgpBNiEBKEARBEHIgZZkM5XROFk/v9n8CEUgJgiAIQg4khvZ+DzGPTBAEQRAEIY1ERkoQBEEQciCxIOfvIQIpQRAEQciBlJQSHultQ/g2cYgEQRAEQRDSSGSkBEEQBCEHElft/R4ikBIEQRCEHEiWAVftiTjq+0QglUHMbj1ER0s9s7uR7WyrOiuzu5CttTxfP7O7kH2ZGWV2D7ItmYF5Znch21IK+/Tb3ktMNv89xBwpQRAEQRCENBIZKUEQBEHIgcSCnL+HCKQEQRAEIQcSk81/DzG0JwiCIAiCkEYiIyUIgiAIOZAY2vs9RCAlCIIgCDmQuGrv9xBDe4IgCIIgCGkkMlKCIAiCkAMpyWQopXOyeHq3/xOIQEoQBEEQciClDBjaE3Okvk8M7QmCIAiCIKSRyEhlMZIkMXH9NVYeekhQ2GdKO5mxsF9lXGwNU91m3dFHdJl5Mll5xNFeaKgl/BMv3XeP5Qfu88YnFAAXG0PGtCtFndI28vqdZpxgw7HHCm2UdjLl8uIW8uc9557m1K13eAVEkFtTFTcXc6Z3L4ejtUF6djtD5GlSA/seLdB3LYiGkT6HizYi+O6T726nqqtNkSkDsWpaAzV9XcJfv+fO4Ol4HTkPgHGFEjgP7YK+a0FyWZhwvnEv3u879VPvraavS6EJfTGvWZ5cVmZE+Qfxfu9J7o2dT0xoeMYeiDSSJImJa6+w8sD9hHPP2ZyFA6viYpv6rVTWHXlIl2nHkpVHnOiHhnrSx8vSPR7M3noT78AIXGwMmdu3MhWK5JG/7hsYwYhlFzhx4y3B4VFUKGLJgv5VsbfSl9eJio5l6JLzbDv1hE9RsVQtbs3iQdXIY6KdQUcg7SRJYuLCU6zccYOgkE+ULmLFwn8b4mJvmuo2u489YPryc7x4G0BMbBz2eY0Y2Lk87RoXk9eZsOAkExedVtjO1Cg3XpdHyZ/7+ocxYtYxTlx6TnDoZyqUtGHB2AbY2yT/d5MkiXpd13PswjN2LW5L4xrOGbD36SNJEhNm7mPlhnMEhURQurgdi2a2w8XRMtVtHj75wL/T93Dr7hveegYwd3IrBvSsqVAnLOwTY6fvYe+h2/j5h1KskDXuU1pTsridQr3Hz7wYMWEn5y4/JT5ewsXRgu2re2Gdx5DAoHD+nbGXE2ce4ukViJFBbhrVLc6kkU3Q1cn1S45HRhJDe7+HCKSymFnbbjHvvzusGVaDAlb6TNl0nVrD9vJ4fTu0c6mlup2OlhqP17dTKEsMogDyGOdmatdy5LfUBWDD8cc0GXuQW8tbKQRptUrlZc2w6vLnairKCm0WL2BC62oOWJtqExj6mQnrr1F72F5ebu6IsnLmJjhVtHLx8dId3u08SulVU35oGyVVVaqeWMtnvwAu/NWfyPc+aFmZExOWFNyoaOUi6O5TXq7dTcXdi9L03poWJmhamHBnyAxCHr1AK68lJZeNR9PChIvN+6dthzPYrC03mLfjNmtG1ko49zZco9agXTze3On7596mTgplXwZR2089ZeDCsywaVI1yBS1Ysf8e9Ybt4cGGDlib6iBJEk1H70dVWYk9Uxuho6XGvO23qDnoPx5s6IiWpioAAxee5eDlV2z5tx6GOpoMXXyOhiP2cmNlm0w/92atPM+8tZdYM70ZBWyNmLLkDLU6reHx0UFo5075HpwGerkY2bMyjnbGqKkpc+jME7qM3IWJoRa1KhSQ13OxN+H4ui7y58pfjNVIkkTTXptQVVFmz5J26ORWZ97ai9TsuIYHhweg9dW/2/x1l7LcTWhnLjzMvKXHWLuoCwXymTFlzgFqNpvNk6tT0dbWTHGbyMgobPMa81fDkgwaszXFOt0GrOXBkw9sWNINCzM9Nu28Qo1ms3l4eQqW5gkB+svXflSoN5XObSoyfnhjdHU0efzMGw31hHPOyycYb59gZk1ogbODBW89/flnyAa8fYLZubb3rzkgGUgEUr/HHx1IvXnzBltbW+7cuUPRokUzuztIksT8XR6MalOSphXzA7BueA3Mm61iy6mn9GhQKNVtZYCZgVaqrzcoq/grbHKXsizbf5+rj30UAil1VeVvttO9fkH5/9uY6TCpsxvFum3hjU8o+Sz1vrOHv9abTfsA0Mqb+i/Zr9l1boaagS7Hy7ZEio0FIPKdl0Id76Pn8T56Pl3vHfLwORf/6id/Hv7Kk7uj3Sm7aRYyZWWkuLgf7vOvIEkS83feYVS7UjStZA/AulG1MG+8nC0nntCjUeFUt5XJZJgZpn7OuO+4Red6BelaP+H8ndevCsevv2XZ3rtM7VGB5++DufrQm3vr28uzX4sHVcOs0TK2nnpC1/qFCAmPYs2hB6wfXYfqJfICsGFsHfL+tZKTt95Rq5RNBh2JnydJEvPXX2bUP5VpWivh72PdzOaYu01ly0EPerQsneJ2lUsr/k3261CODXvucOnWW4VASkVZGTPjlLNuz98EcNXDk3uH+suzX4vHN8LMbQpbD96l698l5XXvPvZm3tpLXNvVC8ty09K1zxlFkiTmLzvBqEH1aVq/BADrFnfFzKk/W3ZdpUfHKiluV7K4nTyzNHLSzmSvf/oUza6Dt9i7sR8VyzoAMH54Y/Yduc3StaeZPKoZAGOm7KJu9cLMHP+3fFs7GxP5/xd0ysN/6/rIn+ezNWHy6Ga0+2cFsbFxqHz1QzOrUSIDAilEIPU9Yo5UFvLaOxSfwEhqlLCWl6mrqVCxiCVXHnp/c9vwTzHYtlyL9d+raTBqP3ee+6VaNy4unm2nnxHxOQY3ZzOF1855vMes6Uoc22+g++xT+AVFptpOxKcY1h19hK25DlZZYHglLfI0rIr/FQ9KLh5HE59L1L1/AOeRPZAp/fo/DTXd3MSEhmd6EAXw2jsEn8AIapS0kZclnHt5uPLAK/UNgfBP0dg2X4l1sxU0GL6HO8+Szr3omDhuPfOlRsm8CtvUKJlX3m5UdEIA+2UGVVlZCTUVZS7d+wDArae+xMTGU7NUUjsWRrkpaGv43f79aq89g/D5GEaN8vbyMnU1FSqWsuXK7Xc/1IYkSZy6/IKnrz9S4Yt/A4Dnb/3JU34a+arOotWArbx6Fyh/TX7s1L86dqoqXLr1Vl4W+SmaNoO2sWBcg1SDsszw+u1HfPxCqFk56Qeauroqlco6cOXGizS3GxsbR1xcPBoaqgrlmhpqXLr6HID4+HgOnbiHfT4zajefjaljP8rUnMTew7e/2XZIaCQ62hpZPogSfh8RSGUhPoEJQYupvuLYu6l+LvlrKXG01mfN8BrsnVKfzWNqo6GmTIV+//H8fbBCvfuv/NGpuxTNWovpNe80uybUx9kmKRtVu1ReNo6uxck5TZnVszw3n/pSffBu+Yd1oqX77qFTdyk69ZZy7MZbjs1sjJpq9vxQ0bKzwvqvWsiUlTlbtzsPJy/FaXAnXEb/80vfV81Aj4Jje/Fi+fZf+j4/yifg/+eewVfnnkEufAIjUt3O0VqfNSNrsXdaYzaPq4uGmgoVem/juWcQAP4hn4iLkzDVV8xYJbSb8J6OeQ3Ia6bDqBUXCQr7THRMHDM2XccnMALvgIT39gmMQE1VGX1tDYV2TPS18AlIvX+/g49/GACmhrkVyk0Nc+Pj/+35byFhn9EpOh4Nl7E06L6B+WMbUKNcUkBWqogV62Y258jqTiyf1ARf/3DKt1xGwP9/4DjaGZPXUo9Rc44RFPKJ6OhYZiw/h8/HMLw/hsnbGTT1EG7F8tKoeubPifqSj18IAKbGOgrlJsa68tfSQltbE7eS+Zg8ez9e3kHExcWzacdlrt16hbdvQrt+H8MIj/jMjAWHqFW1EMd2DqFxveI067CIc5dSnlsZEBjO5DkH6N6hcpr79jslDO0ppfMhMlLf80cP7SV69eoVAwcO5Nq1a9jb27Ns2TLc3NxSrBsVFUVUVJT8eWhoaJrfd/PJJ/wz94z8+YFpDYCEoZIvSRLfnNdQxtmcMs7m8uflClpQosdWFu25y/y+leTlDlb63F7ZiuDwKHaff0GnGcc5M6+ZPJhqUSVpOKGgrSElHEyxbbWWQ1ffyIcaAVpXc6C6qzXeARHM2XGblhOPcGFhc4WMwq9m07oBJZdPkD8/W6cbHy/e+ul2ZEoyPvsFcL37WKT4eIJuP0TTwgSnoV14MGlxRnZZTkVbi8qHlhPy6CX3J6Q85+pX23z8Mf/MSbpA4cCMxgDJkviSJH373HOxoIyLhfx5uUKWlOi6iUW77zC/f1V5+ddtfHlOq6oos3NSA7rNOI5RvSUoK8uo5mpN7S8uhEiNhJTs7+VX27zfg3/G7ZU/P7CiPZDSPn772AFoa6lxe19fwiOiOH3lJUOmHcbOykA+7FenkoO8biEHcCtmjX312WzYc5uBncujqqrMzoVt6DZqN0YlJ6GsrES1svmoXTHpb3n/qcecufqKW3v7JHv/323zziv0HLJe/vzglgFASp956f933bCkO136rSFPoUEoKytRvHBeWjcrze17CVnC+Ph4ABrVLsbAf2oBULSQNVeuv2D5urNUKueo0F5o2Cfqt5qHs4MF/w5tlK6+/S5ijtTvIQIpYPTo0cyePRt7e3tGjx5Nq1atePHiBSoqyQ/PtGnTmDBhQgqt/LyGZe0o7ZQ0tBYVnTDE4xMYgfkXc078giOTZam+RUlJRgkHU55/CFYoV1NVJv//5zGVcDDl5lM/Fuy+y7JBVZM3ApgbapHXVJsXX7Wjm1sd3dzq2OfRo4yzGYaNlrPnwktaVXNIsZ1f4f3+0/hfuyt//umDb5ra+eT9ESkmFun/H6oAIY9foWlugpKqKvExMenu65dUcmtR5egqYsMjOd+kt3xe1u/WsHw+Sn8xrBsVk3juRWJulJRZ8Qv6lCyb9C1KSjJKOJrKs6FGupooK8uSZbX8ghTPaVcHU26vaUdIeBTRsXEY6+XCrccWXB0S5v2YGWgRHRNHUNhnhazUx6BIyha04HdqWNWJ0kWs5M8TM7Y+/uGYmyRlVvwCI5Jlqb6mpKRE/rwJP2SKOlvw+OVHpi8/l2z+VCKtXGoULGDG87f+8jLXgpbc3t+XkLDPRMfEYmyQG7e/luBaMGG+3pmrL3n5LhCDEpMU2mredzMVSthwelO3n9j79GlYuyilXZP2TX7s/EIwN9OTl3/0D02WpfpZ+WxNOHtgBBERUYSGfcLcTI+WXZZga50wD8/IUBsVFWWcHBTPH8cC5ly69lyhLCzsE3X+nkNuLQ12r++Lqqr46hSSiKE9YMiQIdSrV48CBQowYcIE3r59y4sXKY/Pjxw5kpCQEPnD09Mzze+rnUuN/JZ68oezjQFmBrk4eSupzeiYOM7f/YCbi/k3WlIkSRJ3X37E/BuTxhPrJX6BpiQg5BOefuHfnEic0A7fbOdXiA2PIPzlO/kj7nPU9zdKgf+l2+TOb62QTtApYEOkl1/GB1HaWlQ9vpr46BjONfyH+KjoDG3/Z2jnUiN/Hn35w9nGEDMDLU7eTJpXk3DuvcftJwIVSZK4++Kj/IeAmqoyrgVMOXlTca7QyZtvU2xXN7c6xnq5eO4ZxM2nvjQsnw9ICLRUVZQ4cSOpf97+4Tx4HfBT/csI2rnVyZ/XUP5wzm+CmbE2Jy8lfWZER8dy/vpr3Ipbf6Ol5CQkoqNTD66jomN58tIP8xTmOelqa2BskJvnb/y5+eADDf8/jDe8eyU8DvTl9r4+8gfA3FH1WD2t2U/1L720tTXJb2cqfzg7WGBmosuJsw/ldaKjYzl3+SluJfN/o6Ufp6WljrmZHkHBERw784CGdRKWl1BTU6FkMRuevfBRqP/8pS958yRNeQgN+0St5nNQU1Vh36Z+yeZdZWWJGan0PoRvE2E1ULhw0hVJ5uYJAYufnx+Ojo7J6qqrq6OunvLlzOklk8no36wo0zbfIL+lHvZ59Ji2+Qa5NFRp/UW2p8O041gaaTG1WzkAJq6/RmlnM+wt9QiNjGbh7rt4vPBnYb/K8m1Gr7pM7VJ5sTLRJiwymu1nnnH27gcOT09IUYd/imbCums0rZgfc0Mt3viEMmbVZYx0NWjy/y+zV14h7Dj7jBol8mKsq8kH/3BmbruFproKdX9gGOZXU9PXJZe1ObksEq660XGwBeCzjz+ffRN+wbutn0HkB1/ujpoLwPOlWynQtx2u80fzbOEmtO3z4jyqB88WbJS3q6KVKyHY+j8t2zzoFXEkOjCESE/vH3pvldxaVD2+BuVcmlxuOxRVndyo6iRkK6I+BipkxDKDTCajf/NiTNt0nfx59LDPo8+0TdfIpa5C6xpJfwcdphzB0ig3U3tUAGDi2iuUdjHHPo8eoRHRLNx1B4/nH1k4ICnLOeBvVzpMOYKrgyluLuasPHCfd35h9GhURF5n55lnGOtpYm2qzf2X/gxceJZG5fNR8/9X4+nmVqdzvYIMXXwOQ11NDLQ1GLbkHIXsjKju+nPBSkaTyWT071CWacvOkj+vIfY2hkxbdpZcmqq0rl9UXq/D0J1YmuowdUjCMNL0ZWdxLWRJPitDomNiOXLuGRv33mHx+KRho6HTD1O/qiPW5nr4BUYwZckZQsOjaN+kuLzOziP3MTbQwtpcj/vPfBg45SCNqjtT8/+T382MtVOcYG5lroetVeau/yaTyejfswbT3A9in88UeztTps07SC5NdVo3KyOv16HXSizM9Zg2tjmQEGw9eur1//+P44N3EB7335FbS538dglZzGOn7yNJ4JDfjBev/Rg2fjsO+c3p1Lq8vN0hferQsutSKrg5UKW8I0dP3+fAMQ/O7BsOJGSiav01m8hP0Wxc2p3QsM+Ehn0GwNhIO9OX3fgeMbT3e4hAClBVTfqFkTguH59JX2xDW7ryKSqWPvPPEBQWRWknU47ObKywjo+nXxhKX6zbHxweRc85p/EJikBXS52i+Y05696MUl8MG/oGRdJh2nG8AxPqFLYz4vD0RvIrBJWVlLj/OoCNJ54QHB6FuYEWlYvlYeu4OvL31lBT5sI9L+bv8iAoLApT/VxUKGzJxQXNMfmJocdfxbJhVdzWTZc/L7/dHYD74xfK5yLlsjZXCFoi3/twpmZnis8bSd17+4n84MvT+Rt4PGOlvI5BiYJUP5sUWLnOS1gM8dW63VztNPKH3tvA1QWjMkUBaPhScfHUfTZViXj7IZ17n35DW5dMOPfmniYoPGEx2KNzmimee75hCh+sweFR9Jx1Ap/ASHS11Chqb8LZhX9T6os5ey2qORAY+onJ66/iHRBBQVtDDs5oQl6zpKEbn4Bwhiw6i29QJOaGWrSr5cyYDklfpABz+1RGRVmJlv8eTFiQ09WafSNrZ4kvs6HdKvLpcwx9Juz//4KceTi6ppPCGlKe3sEKf7cRn6LpM34/731C0NRQxdHOmA2z/qZFvaQfdu99QmgzaDv+QZEY62tRuqgVl3f2JK9l0kKlPh/DGDLtML4B4Zgba9OucTHG9Ep52YCsaFjfunz6FEPvoRv/vyBnPo79N1hhDal37wMUjp2XTzDFq/wrfz5n8VHmLD5KpbIOnNk/AoCQ0E+Mmvwf772CMNDTomkDV6aMbqYwLNeknitLZ7dnuvsh+o/ajEN+M/5b25vyZRLmmN26+5Zrt14BYF9yuEK/X92ehY116ovVCn8OmSRJUmZ3IrOktI5UcHAw+vr6nDlzhsqVK3+3jdDQUHR1dQk60AMdrV+TqcrJtlU9mtldyNZanq+f2V3IvszEl2BayQx+fKqBoCg07BN6tr0ICQlBRyd988BSfY//fy/tvNeXXNrp+16KDIuieeGFv7S/2Z3ISAmCIAhCDiTLgKG9331VbHaU+TlxQRAEQRByjCVLlmBra4uGhgaurq5cuHAh1bpnz55FJpMlezx58v37pGYVf3RGysbGhq9HNvX09JKVCYIgCEJ2kxmTzbdv386AAQNYsmQJ5cqVY/ny5dSpU4dHjx5hbZ36hSFPnz5VGDo0NjZOc59/N5GREgRBEIQcKP2rmic8fsbcuXPp0qULXbt2xcnJCXd3d6ysrFi6dOk3tzMxMcHMzEz+UFbOPnfLyHGB1Js3b1JME6b0KFiw4PcbFARBEIRsKCPXkQoNDVV4fHmHj0TR0dHcunWLmjVrKpTXrFmTy5cvf7OvxYoVw9zcnGrVqnHmzJlv1v0d/Pz8UPrBe67muKE9VVVVHBx+bIVtO7uUVw8WBEEQBCGJlZWVwvN///2X8ePHK5T5+/sTFxeHqampQrmpqSk+PooLnyYyNzdnxYoVuLq6EhUVxcaNG6lWrRpnz56lYsWKGboPP+tHJ9rnuEDK0tIyW01SEwRBEIRfISPnSHl6eirMYfrWwtQ/c+9EBwcHheSHm5sbnp6ezJ49O9MDqR+dL53jAilBEARBEDI2kNLR0fnuOlJGRkYoKysnyz75+fkly1J9S5kyZdi0adPPd/YnrF+//puvh4SE/HBbIpASBEEQBCHd1NTUcHV15cSJEzRp0kRefuLECRo1avSNLRXduXNHfru2X2XgwIHffP1nrt4XgZQgCIIg5EBpueoupTZ+xqBBg2jXrh0lSpTAzc2NFStW8O7dO3r27AnAyJEj+fDhAxs2bADA3d0dGxsbXFxciI6OZtOmTezatYtdu3alq9/fExgY+M3XP378+MNZNBFICYIgCEIOpIQMJdI5tPeT27do0YKAgAAmTpyIt7c3BQsW5PDhw+TNmxcAb29v3r17J68fHR3NkCFD+PDhA5qamri4uHDo0CHq1q2brn6n189kpP7oe+1lhMR7GgUH70dHRyuzu5P9SJlzc+gcI52/Nv9o4txLO3HepVloaAR6eg1/y732jj8djlY677UXERZFTYcZOfJee/v27WPWrFk8fvwYACcnJwYPHkyTJk3w8/PD3NycuLi477Yj/hoEQRAEIQfKyHWkcprly5fTokULChYsyPz583F3d6dQoUK0bNmSpUuXoqmpSYcOHX6oLTG0JwiCIAg5UMJNi9OXL8mpNy2ePXs28+fPp0ePHvKydu3aUbRoUWbNmsU///zDmjVrfqgtkZESBEEQBOGP4unpSbVq1ZKVV6tWDU9Pz59qSwRSgiAIgpADiaG91Nna2rJ///5k5QcOHPjpu56IoT1BEARByIEyckHOnGbs2LF07NiRa9euUbZsWWQyGZcuXWL37t2sXbv2p9oSgZQgCIIg5ECZsY5UdtG6dWusrKyYNWsWixYtQpIknJycOHnyJJUqVfqptkQgJQiCIAjCH6dChQpUqFAh3e2IQEoQBEEQciAxtPd7iEBKEARBEHKgzFjZPLtQVlb+4dXL4+O/vXivCKQEQRAEQfij7NmzR/7/+/fv5/jx48ybNw9VVdWfbksEUoIgCIKQAymRAUN7OTQj1bBhQyDhNjFbt27F0tKSvXv3snHjxp9uK2dOx/+OypUrM2DAAABsbGxwd3fP1P58SZIkxo9fj6Xl3+TKVYcqVQbx8OGb7263a9d5XFw6oaFRGxeXTuzZczFZnSVL9mFn1wZNzdqUKNGTCxfupdpejx5zUVKqhru74h24o6Ki6dt3IcbGTcidux6NGo3h/fuPP72fv4IkSYyfsAHLPC3IpVWPKlUH/+Cxu4BLwS5oaNbFpWCXZMfu/Pl7NGw4Fss8LVBSrsHevZeStaGkXCPFx6zZOwAIDAylb79FODp1Qit3ffLatKZf/8WEhERkyL6n18+cGwDnzt2lRImeaGrWJl++tixbdiBZnYw4J9P69/C7Zea596UePd1RUq6B+/zdCuUrVhyiStXB6Oo1Qkm5BsHB4T+9j79KZp17iaZN24KSUjUGDFgsL4uJiWX48BUULtyV3LnrYWn5Nx06TMfLyz/tO5oJEq/aS+8jp9q1axetWrVi5cqVXL16ldu3b9O/f/+fbifnHqFv2L17N5MmTcrsbqRo5sxtzJv3HwsX9uX69SWYmelTs+YwwsIiU93mypWHtGw5ibZta+DhsYK2bWvQosVErl17LK+zffsZBg5cwqhRrbl9eznlyxeibt2RvHvnm6y9vXsvcv36EywsDJO9NmDAEvbuvcjWrWO4cMGd8PBPNGgw+odu7PirzZy1nXnzdrFwQR+uX1uEmakBNWsN/86xe0TLVpNp27Y6HneW0bZtdVq0nKxw7CIiPlO4iB0LF/RJtR2vD9sVHqtXDUYmk9GsacIVIV5eAXh7BTBrZnfu3V3B2jVDOXbsBl27zsm4A5BGP3NuALx+7U29eqMoX74Qt28vZ+TIVvTvv4hdu87L62TUOZmWv4fMkJnnXqK9ey9x/frjFP9uIz9FUatWSUaObJW2HfxFMuvcS3TjxhNWrjxE4cKKCzBGRn7mzp3njBnTllu3lrFr13iePXtPo0ZjM/YACJlm586dtG/fnrVr19K6dWsMDAw4efIk+/fvZ+LEiT/Vlkz60dlWOZSNjQ0DBgyQZ6h+VuJdtoOD96Ojo5WuvkiShKXl3/Tv35ThwxM+8KKiojEz+4vp07vRo0eDFLdr2XISoaER/K+9uw6rKukDOP6lkZSQVEEFAzAQFLAL7F673TXWRMXAbtS1u3Otd+0OXHUNLBB17cDFQkQJMcj7/nHl6vXSLc7nfc7zLnNn5sz5ee69c+bMmXvkyCxZWuPGYzAw0GHbtvEAuLoOxNHRlhUrPGV57Ox60bJldXx8fpOlvXjxBlfXQRw7NptmzcYydGhbPD3bAhAZGY2JSVs2bx5Dhw51AXj5MozixTtx+PBMGjaskomDTn0SX7qrkUiwLNqRoUNbM3pUR+BL7MzbM8vnN/r1a5ZsuY4dpxMV9ZEjR2bK0ho39v4Su3EK+ZVV3NmzezKtWlVPtT2tW0/iffRHfE/+kWKev/46S7fus4l+fxBVVZX0HKaibLhaTO+5kWT06NUcPOjHnTtfF63r338BN28+5uLFpUD2nJOZfT+kWwE69168CMPVbTDHjvrQrPl4hg5tg+fQNgr5zpy5Qb36Xrx7u5fChXUye8jZct5B3p17ANHRn3By6seyZUOZMWMrFSuWYuHCgSm29erVe7i4DOTp020UL26a6WOOivpA4cItiIyMRE9PL9P1pL4P6feS/3/T0NHTzFJd0VGfcbKakKPtzQva2tps3ryZtm3byqU/efKE6tWr8+rVq3TX9VOOSH17a+97GzZsQF9fn5MnT+Zuo5BebYWEvMPDw1mWpqGhTu3aFfHzu51iOT+/O7i7O8uleXg4c/GitExsbBz+/g/k6gVwd3eSqzcxMZHu3Wfh5dUee3trhf34+z8kLi5erh4LC2McHKxl+8orQUEh0ti5fxe7WhXw87uTYjm/S3dw93CSS/No6MzFVMqk5fXrcA4fuUzvXo1TzRcZ+QE9Pa3Md6KyQXrPjW9dunQHd3f5mDVsWIVr1x4QFxcPZM85mdn3Q27L63MvMTGR7j1m4+XVLtn3bX6VV+dekkGDFtGkiSsNGsjXl5LIyA8oKSllrQOay5SUlLNlK4i2bt2q0IkCKFmyJMePH89QXQUzQpk0d+5cvLy8OH78OO7u7rm+/5CQcABMTQ3k0k1MDGSvJV/unUIZU9OvZcLCIklISEwhzzvZ37Nn70BVVYUhQxSvZJP2o66uhoGBbqr15IWk/ZuaFpZLN0mjbSEh4ZiafBeXNOKdlk2bT6Crq0WbNjVSzPP2bRTTZ2ylb9+mmd5PdkjvufGtlM63+PgEwsIiU82TkXMys++H3JbX597sOTtRVVFmyODWGSqX1/Lq3APYseNvAgIeJTvqlZzPn2Px9l5L5871snznQcgfWrVqxa1bt+jatSt2dnY4ODjQo0cPbt26RYUKFTJUl+hIfeHt7c38+fM5c+YMrq6uKeaLiYkhKipKbsusrVt90dVtKtuSrqiUvnvKQiKRKKR9L/ky3+fhuzxfy/n7P2Dx4j1s2DAqzX19Lz3ty25bt55CV6+5bMta7OT/Ti52GbFhw3E6d66HpqZ6sq9HRX2gWfNx2JWzYtLEbpnfUTZK7dxIPr9inL9Pz+o5mXo9efckUX4696Tv271s2DAyT2OSFbl97j17Foqn5zK2bPFO8T36rbi4eDp1mkZiYiLLlmV8InJeUkI5y/9TKqDdBH9/f9zc3Hj9+jUeHh48fvwYLS0tqlevzsWLFzNUl1j+AJg3bx4fPnzg2rVraf7qs4+PD1OmTMmW/bZoUQ0Xl3Kyv2Ni4gDpFZW5+dcJo2/eRChc7X7LzMxQ4QouNDRCdlVmbKyPioqywpVuaGi4LM+5c7cIDY3AyurrZNSEhES8vFayaNFugoK2YWZmSGxsHOHh7+VGpUJDI3Bzs8/g0WdNixZuuLiUlf39NXbh8rH7Jg7JMTMzIOT1d3F5k3qZ1Jw7d4v795+xY7viHBeA9+8/0rjJWHR0CrFnz2TU1PL2LZiec+N7KZ1vqqoqGBnppZonI+ekmZn0/zP6fshp+encO3f+X+n71rqLLE36vl3FokV7CHryZ7rrym15de75+z8gNDQCZ+f+stcTEhL555+bLFu2j8+fj6GiIr3dHhcXT4cOUwkKCuHUqbk/3GhUdtyaK6i39saNG0fPnj1ZunQpQUFBrFu3jhUrVmBnZ4e3tzdnz55Nd10FM0IZVLNmTRISEvjf//6XZl5vb28iIyNl27NnzzK9X11dLWxsLGWbnZ0VZmaGnDzpL8sTGxvH2bM3Uu2ouLnZ4evrL5d28uQ1qlWTllFXV8PJqbRcvQC+vv6yert1a8CNG2u4fn21bLOwMMLLqz3Hjs0GwMnJFjU1Vbl6Xr16y7//PpXtK7ekGDvf72L3z03c3OxSrMfN1Q7f7+Jy8oQ/1VIpk5r164/i5GRLxYqlFF6LivpAw0ZjUFdXZf++qem6Gs5p6Tk3vufqqni+nThxDWfn0rKOYXackyVKmGfq/ZDT8tO5161rA24EruJ6wErZJn3ftuPYUZ+MH1wuyqtzr379yty8uVbus87ZuQxdutTn+vXVCp2ohw9fcPLkHxgZ6WfLcecm6U/EZHX5gx9zpDMtfn5+9OnTB0BuhfOmTZty9erVDNUlRqSAqlWrMnjwYBo2bIiKigojR45MMa+GhgYaGho50g4lJSWGDm2Dj882bG2LYmtriY/PNrS0NOncub4sX48es7CwMJbd3x8ypA21a3sye/Z2Wraszv79F/D1DeDcuUWyMsOG/UL37rNwdi6Nm5sdq1cfJjg4lP79pU8+GRnpK3xQqKmpYmZmSJkyxQDQ19ehd+/GeHmtxMhID0NDXUaOXEX58iVo0KByjsQkvaSxa42Pz3ZsbSy/xG47WloadO5cT5avR4/ZWFga4zPzVwCGDGlN7TrDmT1nBy1bVGP/gYv4ngrg3D8LZGWioz/x6NEL2d9BT0MIDHyEoaEexYubyNKjoj7w165zzP2jr0L73r//SMNGY/j4MYYtm8cQFfWRqCjpo/FFiujLPrzzQlrnhrf3Wl6+DGPTpjEA9O/fnGXL9jN8+HL69GmKn98d1q8/KvekWXack+l9P+S1vDz3jIz0ZCMxSb5/34J0VC8k5J2srlu3gtDVLUTx4iYYGubdk1h5ce7p6mrh4FBCrh3a2poYGurJ0uPjE2jXbgoBAQ85eHAGCQmJslEuQ0Nd1NUzvvq1kL9IJBK0tRVHGENDQylSpEiG6hIdqS/c3Nw4evQojRo1QlVVlWHDhuVJO0aN6sinT7EMHLiI8PD3uLiU4/jx2ejqasnyBAeHoqz89SqhWjV7tm8fz4QJG5g4cSOlSlmwY8cEuduGHTrU5e3bKKZN28KrV+9wcLDm8GEfrKwy9hjvggUDUFVVoUOHqXz6FEv9+o5s2DA9TzsCSUaN7CCN3aAlX2JXluPHZsnH7lkysds2jgkTNzJx4iZKlTJnx/ZxcrG7du0B9ep7yf4eMWIlAD26u7NhwyhZ+o4dZ5BIJHTq9PXLM4m//0MuX74HgG3pHnKvPXm8BWtrsywefealdW6EhLwlODhUlr9ECXMOH57J8OHLWb78ABYWRixaNIi2bWvJ8mTXOZme90N+kNfnXlpWrjrE1KlfV2yuXWc4AOvXedGzZ8OMH3A2yatzLy3Pn7/hwAHpPBlHR/kLo7//nkedOpWycNS5Rykb5jgV1DlSpUqV4s6dO9jY2ADSjtX58+fx9PSkVatWGarrp1xHqk6dOlSqVImFCxcqrCP1zz//0KRJE2bOnMmQIUPSrCs715H6KWXTWj4/rQI6fyFXiHMv88R5l2m5uY7U7Rfz0dUrlKW63kd9wt5yeIFbR2rWrFm8fPmSxYsX8+TJE0qXLg1Ajx49WLJkCVpa6b9Y+ylHpM6cOSP776dPn8q9VqtWLaKj88/PJwiCIAiCkL3GjBkj++/ixYtz+/ZtSpQogbp6xueu/pQdKUEQBEEo6MStvfRRVVWlTJkymS+fjW0RBEEQBCGfyI4fHS6oP1pcsmRJUpvZFBQUlO66REdKEARBEISfyvc/ExcXF8etW7c4fPgww4cPz1BdoiMlCIIgCAWQWJAzZSk9TLZy5coMryNVMCMkCIIgCD+5rP9AjPR/PxMPDw/++uuvDJX5uSIkCIIgCIKQgr/++gsDg4z9RJi4tScIgiAIBZC4tZeyypUry002l0gkhISEEBYWxooVKzJUl+hICYIgCEIBJJ7aS9n3q5crKytjYmJCnTp1ZItzppfoSAmCIAhCASRdRyprP99VUNeRmjhxYrbVVTAjJAiCIAiCkAvEiJSQtwrosLHwAxDnnlDAKWXDrb2COkcqO4mOlCAIgiAUQOInYnKHiJAgCIIgCEImiY6UIAiCIBRASU/tZXUriFq0aMG+fftISEjIcl0FM0KCIAiC8JNLWkcqq1tB1alTJ4oWLcqoUaO4f/9+puspuBESBEEQBEFIxoEDBwgNDWXMmDHMmzeP8uXLU6NGDdavX8/Hjx8zVJfoSAmCIAhCASR+ay91urq6uLu7o6yszIsXL+jYsSOrVq3C3NycPn364Ofnl656Cm6EBEEQBOEnJm7tpV+RIkUYNGgQly9f5tq1a+jq6lKzZs10lRXLHwiCIAiC8NNLSEjg2LFjbN26lUOHDuHh4ZGucj9HV1MQBEEQfjLiqb30Gzx4MBYWFgwePBg7Ozvu3LnDkSNH0lVWjEgJgiAIQgEkFuRM2fXr19m9eze7d+9GTU2N8PBwtm/fTr169TJcl+hICYIgCEIBpKyklOURJWUlpWxqTf7i7OxMxYoVGTx4MF26dEFfXz/TdRW4rmadOnXw9PTM62Zk2vLl+ylZsguFCjXC2bk/587dTDX/2bM3cHbuT6FCjShVqisrVx5UyLN79z/Y2/dCU7MR9va92Lv3fIb3K5FImDx5E5aW7dHSakzdusO5fftplo41u4nYZZ6IXdZktp25FaOYmFgGD15CkSKt0dFpSsuW43n+/E1WDjnbiHNPyAv+/v4EBAQwYMAAuU7U58+f2bRpU4bqKnAdqT179jBt2rS8bkam7Nx5mmHDljN2bGcCAlZRo0Z5mjTxJjj4dbL5g4Je0bTpWGrUKE9AwCq8vTsxdOhSdu/+R5bHz+82HTtOo2tXdwIDV9O1qzsdOkzl8uW7GdrvnDk7WLBgF0uWDObKleWYmRng4TGK9+8ztt5GThGxyzwRu6zLTDtzM0aensvZt+8827eP59y5hURHf6J583HZsqpzVohzL2cl3drL6pZRy5cvp0SJEmhqauLk5MS5c+dSzX/27FmcnJzQ1NSkZMmSrFy5MrOHnG52dnZs374dHx8fpkyZItsmTJhAr169ZH+nh5JEIpHkcHsLtKioKPT19YmIOICennaW6nJ1HYijoy0rVnjK0uzsetGyZXV8fH5TyD969GoOHvTjzp0NsrT+/Rdw8+ZjLl5cCkDHjtOIivrAkSOzZHkaNx6DgYEO27aNT9d+JRIJlpbtGTq0DaNHdwKkV7hmZr8wa1Yf+vVrnqXjzg4idpknYpc1mW1nbsUoMjIaE5O2bN48hg4d6gLw8mUYxYt34vDhmTRsWCUnwpIuP+O5FxX1gcKFWxAZGYmenl6m60l9H9LvpfCI/Vn+XoqK+oBB4Zbpbu/OnTvp1q0by5cvp3r16qxatYq1a9dy584dihcvrpA/KCgIBwcH+vTpQ79+/bhw4QIDBgxg+/bttG3bNkttT0379u05duwYJUqUQEVFRZYeHx/P7du3qVixIhKJhOvXr6dZV4Ebkfr21p61tTUzZ86kd+/e6OrqUrx4cVavXi2X/+LFi1SqVAlNTU2cnZ3Zt28fSkpKBAYG5mq7Y2Pj8Pd/gIeHs1y6u7sTfn63ky1z6dId3N2d5NIaNqzCtWsPiIuLB8DP7w7u7vJ1eng4c/Hi7XTvNyjoFSEh7+TyaGioU7t2xRTblptE7DJPxC7rMtvO3IqRv/9D4uLi5fJYWBjj4GAt21deEOdewTR//nx+/fVXfvvtN8qVK8fChQspVqwYK1asSDb/ypUrKV68OAsXLqRcuXL89ttv9O7dm7lz5+ZoO319fTl37hw3btwgICBAtp06dQqJREJAQEC6OlFQADtS35s3bx7Ozs5cv36dAQMG8Pvvv3Pv3j0A3r9/T/PmzSlfvjwBAQFMmzaN0aNHp1pfTEwMUVFRclt2CAuLJCEhEVNTA7l0U1MDQkLeJVsmJORdsvnj4xMIC4tMNU9ISHi695uU9/s8JiZf68lLInaZJ2KXdZltZ27FKCTkHerqahgY6KZYT14Q517Oy84FOb//3ouJiVHYX2xsLP7+/grrL3l4eHDx4sVk2+jn56eQv2HDhly7do24uLhsioSiyMhIihYtqpAukUhQyuAE+wLfkWrSpAkDBgzAxsaG0aNHY2xszJkzZwDYunUrSkpKrFmzBjs7Oxo3bszIkSNTrc/Hxwd9fX3ZVqxYsWxt7/f/fhIJqf6jfv9a0p3ab9OTy/N9lenZb/L15J8nOkTsMk/ELv22bvVFV7epbEsaCclMO/MyRnkdxyTi3Ms5SpLs2QCKFSsm993n4+OjsL+wsDASEhIwNTWVSzc1NSUkJCTZNoaEhCSbPz4+nrCwsOwJRDI2bNiArq6uQrq+vj4bNmxIpkTKCnxHqkKFCrL/VlJSwszMjNDQUADu379PhQoV0NTUlOWpWrVqqvV5e3sTGRkp2549e5Yt7TQ21kdFRVnhaic0NFzhqiiJmZmhwpVbaGgEqqoqGBnppZonqc707NfMTPr/39fz5k0EpqaFM3CUOUPELvNE7DKuRYtqXL++WrYZG0uf+MloO3MrRmZmhsTGxhEe/j7FfeUFce79WJ49eyb33eft7Z1i3ox2QNPTOc5u3bt3R11dXSH9/fv3TJo0KUN1FfiOlJqamtzfSkpKJCYmAsn/46Y1915DQwM9PT25LTuoq6vh5FSakyf95dJ9ff1xc7NPtoyrqx2+vvL5T5y4hrNzadTUpEuEubkp5jl58hrVqtmne78lSphjZmYolyc2No6zZ2+k2LbcJGKXeSJ2Gaerq4WNjaVss7OzylQ7cytGTk62qKmpyuV59eot//77VLavvCDOvVwgScyeDRS+9zQ0NBR2Z2xsjIqKisLoU2hoqMKoUxIzM7Nk86uqqmJkZJRNgVB06NAhypQpg4aGBsrKyrLNxMSE//77T/Z3evzUC3KWLVuWrVu3EhMTIzsprl27lmftGTbsF7p3n4Wzc2nc3OxYvfowwcGh9O8vfULE23stL1+GsWnTGAD692/OsmX7GT58OX36NMXP7w7r1x9l27ZxsjqHDGlD7dqezJ69nZYtq7N//wV8fQM4d25RuverpKTE0KFt8PHZhq1tUWxtLfHx2YaWliadO9fPxQilTMQu80Tssia97ezRYxYWFsayp9FyK0b6+jr07t0YL6+VGBnpYWioy8iRqyhfvgQNGlTOxUgpEudeDvumI5SlOtJJXV0dJycnTp48SevWrWXpJ0+epGXLlsmWcXNz4+BB+bXATpw4gbOzs8JASHYaMWIE7u7u1K9fX+6pvcjISHr06MG+ffvSXddP3ZHq3Lkz48aNo2/fvowZM4bg4GDZkwJ5cR+8Q4e6vH0bxbRpW3j16h0ODtYcPuyDlZW0Jx8S8pbg4FBZ/hIlzDl8eCbDhy9n+fIDWFgYsWjRINq2rSXLU62aPdu3j2fChA1MnLiRUqUs2LFjAi4u5dK9X4BRozry6VMsAwcuIjz8PS4u5Th+fDa6ulq5EJm0idhlnohd1qWnncHBoSgrf/1cyc0YLVgwAFVVFTp0mMqnT7HUr+/Ihg3T5b5A8oI49wqe4cOH061bN5ydnXFzc2P16tUEBwfTv39/QDo95sWLF2zevBmA/v37s3TpUoYPH06fPn3w8/Nj3bp1bN++PUfbGRQUxIQJExRGypKm/rRo0SLddRW4daTq1KlDpUqVWLhwIdbW1nh6esqtdF6pUiVatWrF5MmTAenyB0lP8pUvX54RI0bQuXNn7t27R5kyZdLcX3auIyUIgiAUbLm5jlTk293Zso6UvlHbDLV3+fLlzJkzh1evXuHg4MCCBQuoVUva2e3ZsydPnz6VPfQF0gU5hw0bxu3bt7GwsGD06NGyjldOKVmyJAEBARQuXFgu/e3bt1SpUoUnT56ku64C15HKqq1bt9KrVy8iIyMpVKhQmvlFR0oQBEFIr1ztSIXtQk8vayNoUVEf0Tf+JUfb+6P7qW/tAWzevJmSJUtiaWnJjRs3GD16NO3bt09XJ0oQBEEQ8q3EROmW1ToKoNR+/kX6O4uT013XT9+RCgkJYeLEiYSEhGBubk67du2YMWNGXjdLEARBEIQcsn//frm/P3z4wH///Yeamho2NjaiI5URo0aNYtSoUXndDEEQBEHIXrn81N6PJCAgQCHt3bt3dO3alXbt2mWorgK/jpQgCIIg/JSycR2pn4GhoSE+Pj5Mnz49Q+VER0oQBEEQBAFQUVHhv//+Iz4+Pt1lfvpbe4IgCIJQIIlbexnm4OCQoU4UiI6UIAiCIBRM4qm9FNWrVy/Fn4STSCScOXOGiIgIWrduzenTp1OtS3SkBEEQBEH4qVSqVCnNPGpqajg6OqaZT3SkBEEQBKEgErf2UjR//vw082hra6crn+hICYIgCEJBJDpSuUJ0pLLJp/gPqMWLX9vJKBVlcQpmxZtPz/O6CT8sS43ied2EH1aCinjgO7MSJBmbyCzkjJIlS6Y4R+p7QUFBqb4uvsUEQRAEoSASI1Ip6t27N/PmzaN69eq4uroC4Ofnx4ULF/Dy8srQ7wqKjpQgCIIgFEASSSISSUKW6yiIbt++zbhx4/Dy8pJL/+OPPwgMDGTr1q3prkuMzwqCIAhCQZS0/EFWtwLo4MGDtGzZUiG9devWHDhwIEN1iY6UIAiCIAg/FT09PU6cOKGQfuzYsQzd1gNxa08QBEEQCqjs+K28gjkiNXbsWIYNG8aFCxfk5kjt2rWLBQsWZKgu0ZESBEEQhIJITDZP0aBBgyhbtiwLFy5k8eLFSCQSypUrx7Fjx6hfv36G6hIdKUEQBEEQfjoNGjSgQYMGWa5HdKQEQRAEoSASI1Jp+vz5M2/evCHxu0n1VlZW6a5DdKQEQRAEoSASHakU3bt3j969e3Pp0iW5dCUlJSQSiULHKjWiIyUIgiAIwk/l119/RV1dnSNHjmBubo6SklKm6xLLH+Qzq1cewa50Hwx1f6G6y3AunL+dav5z//xLdZfhGOr+gn2ZvqxdfVTu9UYNxqGt3lJha9Nyqly+ly/e0rvHfIqZdcVYvx2uzp5cD3gEQFxcPOO9N1HFcQhFCrenlFVPfuu1gFcv32bvwWfRqhWHKGPTG33tVrhVHcL5c/+mmv+fs7dwqzoEfe1WlLXtzZpVR+Re37zpJJqqTRW2z59jZXmmTdmq8LqVZRfZ63Fx8Ywbsx6nSgMw1GtDiWLd6N1zHi/zWew2rTlDNYex2BgPpEnNGVy+8DDFvEf3B9C5xUIqWo+gnMVQWtabxRnf2wp5mtSagX1RT0qbDqZhtWns3n4phRph6dyjFNPtx+TROxXq6dJqERWshlNMtx+3bz7L2oHmEIlEwuSpf2Jp1QUtvZbUbTCK27f/S7Pc7j3nsa/QF02d5thX6MvefRdSzOszeyfK6o3xHLEyxTz9BixGWb0xCxfvlUuPiYllsOdyiph3QKdwK1q2nszz52/Sf4A5aMWKg9iW6o6OVjOqVhnI+XO3Us3/z9mbVK0yEB2tZpS26cGqlYfkXt+75zwuVQdhbNgGfd0WOFX+nT+3+CrU8+JFGN27zca0yC/o6Ujz+ft/Pe+nTtmCg92v6Ou2oIhRWxp6jOby5XvZc9C5RawjlaIbN26wYsUKGjVqRMWKFalQoYLclhGiI5WP7PrfOUaNWMeoMe24eGUB1WrY0br5VJ4FJ/+B9zToNW1aTKVaDTsuXlnAyNG/4DVsLfv2XJTl2fa/MTwO3ijbrl5fgoqKMq3bVpflCQ+Ppn6dMaipqbD34ET8byzFZ04v9PW1Afj4MYbAwMeMGdueC5fns/1/3jx6+JJ2bWbkbEAy4K///YPX8DWM9u7A5WuLqV7DgZbNJhEcHJps/qCgEFo1n0T1Gg5cvraYUWM6MNxzFXv3yH+R6elp8fT5FrlNU1NdLo+dvZXc69cCl8te+/gxhuvXH+M9rhOXri5mx1/jePTgBb+0lu/I5qUDu68yZfT/GOzVhKPnx1O1mg3d2y7hxbN3yea/fPEhNeuWY9PuwRz5ZyxutcrQu/0y/r0RLMtT2FCbwV5N2Oc7mhN+E2nftRojft+k0OECCPR/yraN5yjnUFThtY8fY6niWgrvKW2y74BzwJy5f7Fg0R6WLBzAlYuLMDM1wKPJWN6//5hiGb9Ld+nYxYeuXeoTeG05XbvUp0NnHy5fUfyyvnrtPmvWHaVC+RIp1rdv/0WuXLmPhYWRwmueI1axb/9Ftv85hnOn5xL94TPNW00mISFrq15n1f92nmHEsJWM8e7EVf/l1KjhQLOm41N93zZvNp4aNRy46r+c0WM6MsxzBXt2n5PlMTTUxdu7E+cuLCQgcCU9enrw26/zOHH8mixPePh7atccjpqaCgcPT+fmv6v544++FC6sLctja2vJosUDuX5jFWf+mYeVlRlNGnnz5k1EjsUj2yXd2svqVgCVKVOGN2+y52JCSZLeX+0TkhUVFYW+vj6vwrajp6eVpbpqV/eikmMpFi39XZZWufxAmrVwYeqM7gr5x3tv4sihKwTcWiZLGzJwObduPuX0uTnJ7mPp4gNMn7KNx8Eb0dbWBGDC2E1c8rvHydM+6W6r/7WH1Krmxb1HaylWvEi6y30vu360uKbbMCpVtmHJsoGytIoO/Wjewo3pM3sq5B83Zj2HDl3mxr+rZGmDBizl1o0gzl6YB0hHpEYOX8Prt/9Lcb/Tpmzl4AE/rvgvTXdbr119QA23YTx4soHixU3SXS452fGjxc3r+uBQsTg+C7+OpNV1mkTDZpUYM6V1uuqoX2Uyzds64zmmWYp5GteYTr2G5Rk54etqwh+iP9O4xgxmLOjM4jlHsK9QlMmzOyiUffZfGNUcxnHswnjsKxTLwNGlLLt+tFgikWBp1YWhg1sxemR7QDoCZFa0M7Nm9qZfnybJluvY2Yeo9x85cnCaLK1xs/EYFNZh259jZGnR0Z9wqjqYZUsGMsNnOxUrlmThvP5ydb14EYZrDU+OHZpBs1YTGTq4FZ5DpP92kZEfMLHoyOYNXnRoXxuAly/fUrxkdw4fmEpDD6cMH3N2/WhxNbchODrasGz5EFlaefvfaNGyGjNm9lbI7z1mLYcOXuLW7bWytAG/L+LmzSDOX1iY4n6qOA+kSZOqTJnaA4Cx3uu4ePE2Z87OT3dbo6I+YGTQhuMnZlGvvmO6y6VUT2RkZIYXfkz/PqTfSxH356KnWyhrdb3/ROEyXjna3rxw6tQpxo0bx7Rp03B0dERNTU3udX19/XTXJUak8onY2DiuBzymfoNKcun13Ctx+VLyw8lXLt+jnrt8/gbujgT4PyIuLvlfGN+0wZdf2teUdaIAjhy6gqNTKbp2nI2VZXfcqniyYZ3iiq/fioz8gJKSEvrfXMHlldjYOAICHtHAXf7DrYF7ZS753U22zKVL92jgXlkuzd2jMv7+D+ViFx39CduSPSll1Z3WLSYTeP2xQl2PHr6kRLFulLHpTbfOs3ny5FWq7U2KXeHCOuk9xBwTGxvPrevB1KpnJ5deq74d1y4rHmtyEhMTiY7+TGGD5M8FiUTC+TN3efzwNS7VbeVeGz98O/Ualadm3XKZO4B8ICgohJCQcDwafD2fNDTUqV2zPH5+d1Is53f5Lu4N5M9BD3cnLl6SP2cHDVlGkyZVaJDCl3diYiLde83Fa/gv2NsrPmnkHyA9pz2+Od8tLIxwsLfiYirty2mxsXEE+D/E3V2+I9fA3SnFuF26dJcG3+X38HDG/9qDZD/zJBIJf5+6zoP7z6hZ00GWfujgJZycStOx/XQszNrj7DSAtWuOKJT/tq1r1xxBX1+bChVLZuQw85YYkUqRh4cHV69epVGjRpiYmGBgYCC3ZYSYbJ5PvA2LIiEhERPTwnLppiaF8Q0JT7bM65AITE3k85uYFiY+PoGwsCjMzQ3lXrt29QF3bv/HitWD5NKDgl6zdtUxBg9tidfodvhfe4DXsDWoq6vSpVs9hf1+/hzLxHGbad+xVpZH4bJDWFLsvo+FSWFev04hdq/Dk83/bezKlCnGmvXDcHCwJirqI8uWHKBurZFcDViCja0lAFWrlmHdxhHY2lry+nU4s2bupG5NLwJursDISPHq7fPnWCaM20iHTrXzRezevY0mISGRIibybTUuosub11HpqmP14pN8/BBLszbyX3BRkZ+oUmY0sTFxqKgoM31+Z7kO2/5dV7l1I5hDZ8dm/UDyUMiXc8zUVP7D18S0cIq3qABCQsIV3r+mJoUJCfl6S3XHzjMEXH/MFb9FKdYz+4+/UFVVZsggxd8NS9qPuroqBga68vsyLSxre14IS+kzz7Qwr1P8zAvH9Lv8Xz/zIjE3l97WjIz8gFWxzsR8OfeWLB0s1wF78uQVq1YewnNYG0Z7d+TqlfsM81yBhoYa3bq7y/IdPnSJLp19+PgxBnNzQ44e98HYOP0jFXlOIsmGp/YK5k2r06dPZ1tdoiOVQTExMcTExMj+jopK35dNen3/5IBEIkn9aQKF/MnXA9LRKDt7K5yrlJZLT0yUUNmpFFOmdwOgkmNJ7t4JZu3qYwodqbi4eHp0mUtiooSFS+RvL+S1jMZOMX9SuvT/XVzL4uJaVvZ6tep2uFYZwvJlB5m/UHrsDRs7y153KG+Nq1s57Er/yp+bTzF0mPxtsbi4eLp1nk1iooTFSweSn3wfJkkyacnZ99cV5vscYt2OARgXke+M6ehqcOzCeD5+iOH8mXtMG/sXViWMcatZhpfP3zF51E627h+KpqZaCrXnT1u3/U3/gUtkfx/aPwVI/nxK60mg1M7ZZ8/e4DliFccPz1CYl5fEP+Ahi5fux//ykgw/dZSe9uWG5GOQkfyK6bq6hbgWsJzo6M+c/vs6I71WUbKkGbXrVASkn3lOzrZMnyG9fejoaMOdO/+xatVhuY5UnbqVuBawnLCwKNatPUrnjjO44LdY4SIs38qOyeIFdLJ5rVq1sq0u0ZHKIB8fH6ZMmZLt9RoZ66GioqxwJRb6JlLhii2JqZniiMub0AhUVVUwMpK/+vz4MYZd/zvH+EmdFeoxMzegbDn5eSdlyhZj314/ubS4uHi6dZrD06evOXJiWr4YUQEwTord97F4E5niB56pqUEy+ZNil/w8AGVlZZycS/Po4csU26KtrYm9gzWPHsnniYuLp0vHWTx9+ppjJ2fmm9gZGumgoqJM6HejT2/fvMfYJPX5EAd2X2XkwM2s3Nwv2VtzysrKlCglnQNmX6EYj+6/Yum8Y7jVLMPN68GEvXlPk5ozZfkTEhK5fOEhG1ed4fHbZahk0zyc7NaiuSsuVb92sGNi4gAICXknNwr8JlRxxPhbZmYGCiNCoW8iZSNb/gEPCQ2NwNl1sOz1hIRE/jn3L8uWH+Rz9AHOnf+X0NAIrEp1l8vjNWoti5bsI+jhJszMDIiNjSc8/L3cqFRoaARurnl3S9U4pc+80EhMTJO/tWJqZkBISEqfeV/PV2VlZWxspKPGlSqV4u7dZ8yetVPWkTI3N6RcOfnboGXLFmPvnvNyadramtjYWGJjY4mraznKlenFhvXHGD2mY+YOWsg3zp49m+rrtWvXJj4+ngsXLlC7du1U84qOVAZ5e3szfPhw2d9RUVEUK5b1ya/q6mo4Vi7F36du0KKVmyz9tG8gTZu7JFumqktZjh6+Ipd2yjeQyk42qKnJ/9Pu3nWemJg4OnZWPCFc3crx8IH8F//Dhy8o/s0k8qRO1KNHrzh6cnqKnY28oK6uRuXKNpzyvU7LVtVk6ad8r9OsuWuyZVxdy3L4u9j5nryOk5OtQuySSCQSbt54gr2DdYptiYmJ4/69Z1SvYS9LS+pEPXr0kuO+PvksdqqUdyzOudN3adzi6xycc3/fxaNpxRTL7fvrCl4DNrN0/W/Ub1Q+XfuSSCA2RjqPpUadspy8PFHu9RG/b8KmtBm/D2uYbztRALq6Wujqfu0ISyQSzMwMOHnqOo6ONoB0Ts3Zc7eYlcyE6SRuLuXwPRXAsKFfRy5P+gZQ7Uvnpn69StwMWCFXpnef+ZQtU4xRXu1QUVGhW5f6NKgnP3eqUbPxdO1cj149PABwqiw9p0/6Xqd9O+lV+KtX7/j39n/M9vk1C5HIGnV1NSo72eLrG0Cr1l+fIj7lG0DzFm7JlnF1LcfhQ5fl0k6e9MfJuXSK71uQ/hvFxMbJ/q5WzY4HD+SX0nj48AXFrVJ/+EMikcg6zj8EsSBniurVq5fiXYukBTnfvXtHvXr10ny6VXSkMkhDQwMNDY0cqXvw0Jb81mshjk42uLiUYf264zx7FsZvfRsBMHHcZl6+fMvaDcMA+K1vI1atOMzokevo1duDy5fvs2mDLxu3jFCoe/MGX5q3cEn2S3zw0BbUqzWaP2b9RZtfanDt6gM2rD3BkuUDAIiPT6BLh9kEBj5m194JJCQkyq4KDQ11UFfP+1szQ4a1pnePeVR2ssXVtSzr1hzjWfAb+vSTPjE1fuxGXr58y/qN0tj81q8JK5YfYtSINfT+rSGXLt1j4/oTbN46Slbn9KnbcHEpQylbC95HfWTZ0oPcCHzCwsVfn6ocM3ItTZq5UKx4Ed6ERjBr5k6ioj7Stbv095vi4xPo1H4m168/Zu/+SSQkJMjmwBga6uaL2PUZ1ADPPhuo4GiFU9WSbN14jhfP39H1V+mX7qxJewl5FcHC1b0AaSdqWN8NTJ7TgcpVSxD6OhIATU119PSlTwgtnXuUCpWtsCpRhLjYBP4+cYvd2/2YuUD6ZKCOriZl7Szl2qGlpYGBobZcevi7D7x8/o7XryIAePwwBIAipnqYmOaPuSpKSkoMHdwKn9k7sbWxwNbGEp/ZO9HS0qBzxzqyfD16zcXCwgifGdI4Dhncktr1RjL7j//Rsrkb+w/64XvqOufOzAWkHTaH7zrt2tqaGBrpytKNjPQU3tNqaiqYmRlQpox0OQl9fW169/LAa/QajIx0MTTQZeSYtZR3sKZB/Uo5EpP08vRsQ88ef+DkVBpXt3KsXXOE4OBQ+vZrCsC4set58SKMjZuk78u+/ZqxfNkBvEas4tffGnPJ7y4b1h/nz61fn3KcPWsHTk62lCxlQWxsHEePXuXPLb4sXfZ1ZG+IZxtq1RjGLJ/t/NKuFlev3GftmiOsWOkJwIcPn/GZuY1mzd0wNzfk7dsoVq44xPPnYbT9pWbuBSirREcqReHhac8PNDExSVc+0ZHKR35pX5N3794za8ZOQl69w87eij0HJsqukkJCwnn+LEyW37qEKXsOTGS01zpWrziCuYUhcxf8Rqs21eTqffjgBRcv3OHAkeRvSTo527LjL28mjt+Cz4ydWFubMmfeb3TsXAeAF8/DOHxIOnrjVsVTruzRk9OpVTt9IxI5qV37Wrx7G8XM6dsJefUOewcr9h2cgpUsdu/k1uMqUcKMfQenMMprDStXHMLcwoj5C/vRus3XK+PIiGgG/L6E1yHh6OtrU7FSKXxPz6ZK1TKyPC9evKVH1zmEhUVRpIg+VV3K8M+F+bL9Pn8exqGD0ivoqk5fP8gBjvv6ULtOxhZ+ywkt2lYh/N0HFs0+TGhIJGXsLNi0axBFi0sn7r4OiZRbU2rr+nPExycyfvh2xg/fLkv/pbMbC1b1BKS3kscN386rF+FoFlLDxtaMRWt706JtlQy17eSRG4z4fZPs74E9pY+9D/NuxvCxzTN7yNlulFc7Pn2KZeCQZYSHR+NStQzHD8+QG7kKfhaKsvLXq99qbnZs/3MMEyZtZuLkLZQqac6Ord5ytw2zy4K5/VBVVaFDZx8+fYqlft2KbNg7AhUVlWzfV0a071CHt+/eM2P6Vl59ed8ePDQdKytTQDpy9uyZ/Pv24KHpjBixihXLD2JhYciChb/Tpu3Xzs2HD58ZPGgpz5+HUaiQOmXKFmPT5lG071BHlqdKlTLs2j2RceM2MH3aVkqUMGPe/P507iKdE6qiosz9e8/ZsnkaYWFRGBnp4uxcmtNn52Fvb50rsRFyVkpLOcTFxXHx4kXZ7bz0LPkg1pHKouxcR+pnlF3rSP2ssmMdqZ9Vdq0j9TPKrnWkfka5uo7UjSno6WqmXSC1ut5/pnDFSQVuHSkAPz8/nj59Smzs11+riIyMxNPTk/Xr16OkpESPHj3SrEd8i31n48aN9OrVC9G/FARBEH5oiRLpltU6CqCBAweycuVKdHR05EZmk+ZNDR8+HIlEIjpSmfH06dM0Z+gLgiAIgvDj+t///sfJkyepV09+iZ83b95gamrKu3fJ/0RWckRH6jvHjx9n0aKUF78TBEEQhB+CJBvWkSqgk83fvXtHxYqKTyanuXZjMkRH6jt+fn5pZxIEQRCE/E4syJmiSZMmoaWlOK9ZR0eHSZMmZagu0ZESBEEQBOGnMnGidB27R48ecefOHZSUlChXrhw2Njay19JLdKQEQRAEoSASk81TFBERQa9evThw4ACqqtKuUFxcHM2bN2fTpk0ULlw43XWJZ1gFQRAEoSBKurWX1a0A8vT05NGjR1y4cIHPnz/z+fNn/Pz8ePz4MUOGDMlQXWJEShAEQRAKokRJNsyRKpgjUgcOHODgwYO4un79GTEXFxdWr15Ns2bNMlSXGJESBEEQBOGnEhsbi46OjkK6rq4uMTExGapLdKQEQRAEoSBKmiOV1a0Aql27NmPGjOHt27eytHfv3jFq1KgMryUpbu0JgiAIQkEklj9I0eLFi2natCnFixendOnSKCkpcf/+fSwtLTly5EiG6hIdqWxSKEG6CRlUMC92co2lpnVeN+HHlRif1y34YcWJ2GVaXGJcXjdBAEqVKsXt27c5cOAAd+7cQSKRUK5cOVq1apXhH/MWHSlBEARBKIjE8gepUlFRoXXr1rRu3TpL9YiOlCAIgiAUROLWXoo2bdqU6uvp+bHiJKIjJQiCIAhCrgsPD2fIkCEcOHAAgBYtWrBkyZJUF8Ps2bOnQifIxcWFS5cuZWjfw4YNk/s7Li6Ojx8/oqqqipaWluhICYIgCMJPL5//aHHnzp15/vw5x44dA6Bv375069aNgwcPplquUaNGbNiwQfa3urp6hvf97t07hbSnT5/Sr18/RowYkaG6REdKEARBEAogiUSCRJK1OU5ZLZ+Su3fvcuzYMS5duoSLiwsAa9aswc3Njfv371OmTJkUy2poaGBmZpbtbbK2tmbWrFl06dKFO3fupLucWEdKEARBEIRc5efnh76+vqwTBeDq6oq+vj4XL15MteyZM2cwMTGhdOnS9OnTh9DQ0Gxrl5KSEs+ePctQGTEiJQiCIAgFUTZONo+KipJL1tDQQENDI9PVhoSEYGJiopBuYmJCSEhIiuUaN25Mu3btsLKyIigoiAkTJlCvXj38/f0z1J79+/fL/S2RSHj16hVLly6lRo0a6T8QREdKEARBEAqmbOxIFStWTC550qRJTJ48WSH75MmTmTJlSqpVXr16FZCO/nxPIpEkm56kQ4cOsv92cHDA2dkZKysrDh8+TJs2bVLd77e+z6ukpISJiQn169dn7ty56a4HREdKEARBEAqmbFxH6tmzZ+jp6cmSUxr9GTRoEB07dky1Smtra27evMnr168VXnvz5g2mpqbpbp65uTlWVlY8fPgw3WUAEhKybwVt0ZESBEEQBCFVenp6ch2plBgbG2NsbJxmPjc3NyIjI7ly5QpVq1YF4PLly0RGRlKtWrV0t+vt27c8e/YMc3PzdJfJbmKyuSAIgiAUREm39rK65YBy5crRqFEj+vTpw6VLl7h06RJ9+vShWbNmck/slS1blr179wIQHR2Nl5cXfn5+PH36lDNnztC8eXOMjY2zvDp5VoiOVD4jkUiYPH07liV6omXQjroe47h9JzjNcrv3XsTecSCa+m2xdxzI3v1+cq+XKNMH5UItFbaBnitleaKjPzHIcxXFSvVGy6AddpUGsmL1Ubl6Vq87Tl2PceibdES5UEsiIqKz58CzgUQiYfK0rVhad0NLvzV13cdw+85/aZbbvfcC9hX7o6nbEvuK/dm7X/GJkRcvwujW8w+MzTuiXbgNjlUG4R8gHUqOi4tn9Nj1VKg8AB2DNlhad6NH73m8fPlWro7Va49S130M+sa/oKzRNF/FDr7Eb+oWLIt3Qku3OXXrj+T27adpltu95xz2Ffqgqd0M+wp92LvvgtzrK1YepKJjf/QNW6Nv2JpqNTw5euyq7PW4uHhGe6+lQqV+6Oi3wLJ4J3r0nKMQv7r1R6Ks1lBu69RlZrYce1bl1Lk3edpWlDWaym3mxbvI5dmz7wKNmk6giEUnlDWaEnjjscJ+6rqPUainU9fZWTvobLJqxWHK2f6KgU4bqlX15ML526nmP/fPLapV9cRApw12pX9jzSr5z6iG9b3RUmuusLVukfy8nT9m/4WWWnNGDl+j8Nq9u8/4pfU0zIw6YGLQntrVvXgWnH1PiOW4REk2dKRy7iditm7dSvny5fHw8MDDw4MKFSqwZcsWuTz3798nMjISkP6ky61bt2jZsiWlS5emR48elC5dGj8/P3R1dXOsnWkRHalk1KlTB09PzzzZ95x5e1iweD9LFvTjyvm5mJkWxqPpRN6//5hiGb9L9+jY7Q+6dq5L4JVFdO1clw5d/+DylfuyPFfOz+Vl0EbZduKw9EOlXZvqsjzDRq3j+MkAtmwYxp3ApXgObsGQ4avZf/CyLM/HjzE0dHfEe+QvOXD0WTNn3i4WLNrLkoX9uXJxAWamBng0GZ9G7O7SscssunapR+DVpXTtUo8OnWdx+co9WZ7w8PfUqDsSNTVVjhyYwu3AFcyd/RuF9XUAaUyuX3/M+LGd8L+0mN07x/Hg4Qtatp0qt6+PH2No6FEZ79HtcyYAWTRn7v9YsHAPSxYN5IrfEszMDPBo7J16/Pzu0LHzTLp2qU+g/3K6dqlPh04zuHz5a/yKFi2Cz8zeXL20hKuXllC3bkVatZks66RJ4/eI8eM6439lGbv/N1Eav9aTFPb326+Neflsu2xbuXxodochU3Lq3AOwt7Pi5X9bZNtN/+Vyr3/4EEO1auXwmd4z1Tb+1ruhXD0rlw3K9PFml13/O8eoEWsZNaY9flcXUb2GPa2aTU6xs/I0KITWzadQvYY9flcXMXJ0O7yGrWbfnq+d9+1/jeXJs82y7VrgUlRUlGnTtrpCfdeuPmD92mOUL2+t8NqTx69oUGc0ZcoU5ZjvTC77L2bMuA5oaGZ88UcheYaGhvz5559ERUURFRXFn3/+qbCquUQioWfPngAUKlSI48ePExoaSmxsLP/99x8bN25UmAif25QkObXa1g+sTp06VKpUiYULF6aZNyoqCn19fSJeb0dPTytL+5VIJFiW7MXQgc0Z7dUWgJiYOMysejBrenf6/dYo2XIdu84h6v0njuz/+sXTuMVkDArrsG2zV7JlPL3WcvjoVR78u1L2hER5p8G0/6UGE7y/PhXhXG04jRs6MW2S/FXwmX9uUa/heN692krhwjqZP2jl7JmmJ5FIsLTuxtDBLRnt1Q74ErtiXZg1oxf9+jROtlzHLrOIivrIkYNfOz2Nm03AwECHbVtGAzBm3AYu+t3ln7/npLs9V689wKX6MJ4+3EDx4vKP+J45e5N6Ht68e70za7GD7I1f8c4MHdKK0SOl//4xMbGYWXZk1sxf6de3abLlOnaeIY3foRmytMZNx2JgoMu2P71T3J+RSVvmzOrDr72TP6evXr2PS7UhPH28RRa/uvVHUrFiSRbO/z2zhykvMT5bqsnJc2/ytK3sP+DH9atL02zH06evKVmmNwFXFlOpYim51+q6j6FihZIsnNc3s4cp57Ny9tzuqVVtBJUcS7F42QBZmmP532newpWpMxR/omO890YOH7rM9VsrZGmDByzj1s0gzpxP/kmrpYv2M23KVp4824y2tqYsPTr6E9WqerJwye/MnrmTChVL8sf8PrLXu3eZg5qqCus2ZWyV67RERX3EzKgDkZGR6ZpzlLl9SL+Xwvf1RU87ax2/qA+xGLRanaPt/dGJEal8JOjpa0JCwvFo4ChL09BQo3ZNe/wu3UuxnN/l+7jXrySX5tHAkYsplImNjWPrjjP06tFA7jHT6tXKcfDQFV68eItEIuH02Zs8ePiCht+0J78KCgr5ErvKsjRp7Bzwu3Q3xXJ+l+/h/t3xebhX5uI3ZQ4euoxTZRvad5qJadHOVK46mDXrjqXansjIDygpKWW9o5RLpPF7h0cDJ1mahoY6tWuVx88v5RV+/S7dxf2bMgAe7s5cTKFMQkICO3ae4cOHGNxcy6VYb2RUUvy05dK3bT9NEbN2OFTsg9eo1amO+OSWnDz3AB4+eomldTdKlu5Np66zefLkVabauW3HaYpYdMKh0u94jV6b57GLjY3jesAj6rvLx6B+A0cu+SUft8uX7lH/u5g18KhMgP8j4uKS7xhv2nCSX9rXkutEAQwbvJJGjZ2p991nJ0BiYiLHjlzDprQlLZpMxMqiK7WqjeDAd1Mm8r18PEeqIPmhO1KjR4+mdOnSaGlpUbJkSSZMmEBcXJzs9cmTJ1OpUiW2bNmCtbU1+vr6dOzYkffv38vyfPjwge7du6Ojo4O5uTnz5s1LdZ8xMTGyYcikLbuEhIQDYGqiL5duYlKYkNfhKZd7HYGpSWG5NNNUyuw7cJmIiA/07FpPLn3xvD7YlStGMZveaOi1pXGLKSxb1J8a1e0ycTS5K+lYv4+DiUlhWVyTLRcSjqmpgVyaqamBXJknQSGsXH0EGxtLjh2aRr8+TRg6fBWb/zyVbJ2fP8fiPX4jnTvWzvIoZW4JCZH+7tT3sTAxMUj93AsJx9S0sFyaqalizG/dCkK3cEs0tZvx+8DF7Nk1ETs7q2Tr/Pw5Fu+x6+ncsS56el87Up071WXbn2M47fsH48d2Yc/e87RtNzXZOnJTTp57LlXKsGn9CI4dmsbqFYMJeR1O9TpevH2bsc+dzh3rsG3zKE6f9GH82I7s2XuRtu1npF0wB4WFRZGQkKgYN9PCvH4dkWyZ16/DMfn+fDMpTHx8AmFhijG5euUBt2//R8/eHnLpf+38h8Drj5Md9QIIDY0kOvoT8+bswt2jMgeOTKVFK1c6tfPh3D+30n2Mws/hh17+QFdXl40bN2JhYcGtW7fo06cPurq6jBo1Spbn8ePH7Nu3j0OHDhEeHk779u2ZNWsWM2ZIP0RGjhzJ6dOn2bt3L2ZmZowdOxZ/f38qVaqU7D59fHzSXGwsvbZuP0P/wV+HqA/tnQAoLlKW1gJlGS2zftNJGjd0wsLCSC598bJDXLpyn/27xmFV3IR/zt9m4NCVmJsZ0KBepfQeVq7Yuv00/Qd+vd1xaN9kIJk4AGmETuH172OXmCjB2cmGmdOkH7qOlUpx+85/rFx9hO5d68uVjYuLp1PX2SQmSli2eGDGDioXbd32N/0HLJL9fejANCClWKRel+K5p1hPmTJFuX5tORERH9i99zw9e8/lzKk/FDpTcXHxdOoyUxq/pfJzePr81kT23w4O1tjaWFLFdRABAQ+pXNk29UZmo9w89xo3cpb9d3kHa9xcy2FT7lc2bTnFcM/0P6XU59evt1Ad7K2xtbGgipsnAdcfUdnRJt315ITkP7sylj+5dIBNG05gb29FlaqlZWnPn71h5PA1HDgyFc0U5jslfhmFadbChcGerQCoWKkkl/zusXb1MWrWKp/mceUL2bggp5CyH7ojNX78eNl/W1tbM2LECHbu3CnXkUpMTGTjxo2yGf3dunXj1KlTzJgxg+joaNatW8fmzZtxd3cHYNOmTRQtWjTFfXp7ezN8+HDZ31FRUZme6NaiWVVcqn59zDMmRjqaFvI6AnNzQ1n6mzeRCldt3zIzVRx9Ck2hzH//heL790127xgjl/7pUwzjJv3Jnp3eNG0s/fCuUN6awJtPmLdwX77rSLVo5oJLlW9iF5sUu3D52IVGKFz1f8vMzEBh1CA0NEJulMXc3IBy5YrL5SlXthh79sk/YRUXF0+HzrMIevqaU8dn5uvRqBbNXZM/90LCMTf/2sF+8yYCU5PMxE++jLq6GjY2lgA4O5fm2rX7LFqyj1Urvk4Wj4uLp0OnGQQFhXDq5By50ajkVK5sg5qaKg8fvcjVjlRunnvf09bWpLy9NQ8fvcxk66UqOybF7mWedaSMjfVQUVFW+Ox6ExqJSQqfd6amBrz+PmZvIlFVVcHISP6prY8fP7Prf+eY8N38zoCAR4SGRlDdxVOWlpCQyPlzt1m5/BARH/ZgbKyHqqoKZb9735ctW4yLF9L/Y7Z5TpINC3KKadRp+qFv7e3atYsaNWpgZmaGjo4OEyZMIDhYfqkAa2truccizc3NZT9w+PjxY2JjY3Fzc5O9bmhomOavTictTJbeBcpSoqurhU0pc9lmV64YZmYGnDwVKMsTGxvH2XO3cXMtm2I9bi5l8P37hlzayVOBVEumzIYtpzAx0Zd1lpLExSUQFxePsrL8VZ2KigqJOfj4a2bp6mphY2Mh2+zKFZfGzve6LI80dv+mOhfHzaUsvt/EG+Ck73WqfVOmupsdDx68kMvz4OELrIoXkf2d1Il6+OglJ4/OwMgof0/KlMbPUrbZ2VlhZmbIyVMBsjyxsXGc/ecWbm4p39p1cy2H7zdlAE76+lMtlTIg/WyOjfl6Gz6pE/Xw0QtOHp+Vrvjdvv0fcXHxch2/3JCb5973YmLiuHv/GebmKXfQ0uP2nS+xMzNMO3MOUVdXw7GyDX9/EzeAv08F4uqWfAxcXMvy93cxO3XyOpWdpB3Db+3+6zwxMXF07FJHLr1uvYpcvb6US9cWy7bKTjZ07FSbS9cWo6Kigrq6Gk7Otjy8/1yu7MOHLyhuVQRB+NYPOyJ16dIlOnbsyJQpU2jYsCH6+vrs2LFDYY6Tmpqa3N9KSkqyYdv89sCikpISQwc2x+ePXdjamGNrY4HPnF1oFVKnc4dasnw9fl2AhYURPtO6AzBkYHNqu49l9tzdtGzuwv6Dl/H9+wbnTvnI1Z+YmMjGzafo3qUuqqoqcq/p6WlRu6YDo8ZupFAhdayKm3D23L9s2XqaebN7y/KFhIQT8jqcR4+lE15v/fsfurqFKF6sCIaGebeOh5KSEkMHt8Rnzv+wtbWQxm72/9DS0qBzx9qyfD16z5PG7suj4kMGtaB2/dHMnvsXLZu5sv/QJXz/DuTc6a9P6HkOaUX12l7MnL2T9m1rcuXaA9asO8aq5YMBiI9PoF3HmQQEPubg3kkkJCTI5hwZGuqiri49B0NC3n0Xu6dfYmeSp7GDL/Eb0gqfWTuwtbHE1sYSn9nbpfHrVFeWr0fPOVhYGuMzQ3pODBnUitr1vJj9x05aNndj/0E/fE9d59yZ+bIyY8evp3GjKhQrWoT37z+x439nOHP2JkcPTwe+xK/DNAKuP+LgvqkkJCQqxO/x45ds3f43TRpVxdhYjzt3g/EatRrHSjZUr5a3c/hy8tzzGr2W5k1dKF6sCKFvIpjhs5OoqI/06NpAlufdu/cEPwvl5UtpzO5/6fSbmRpgZmbI48ev2LrjNE0aVcHY6EvsRq/FsVIpqldLudOWG4Z4tuLXnvOp7GSLi2tZ1q89xrPgN/zWV/qk48Rxm3j54i1rN0rvAvzWtxErlx9itNdaev3akMuX7rFpw0k2/an4dPKmDSdp3tJVoVOuq6uFvYP8LWVtbU0MjfTk0j1HtKF75zlUr+lA7TrlOXE8gCOHrnDcN3+sXZYu4tZervhhO1IXLlzAysqKcePGydL++y/tBfC+ZWNjg5qaGpcuXaJ4cekQbnh4OA8ePKB27dpplM4Zo0a04dPnWAZ6riI8PBqXKqU5fmgKurpfbxMFPwtDWfnrYGI1t3Js3+zFhClbmTh1G6VKmrFjy0i5WzcAvn/fIPjZG3r3aEBytm/2YuzEzXTtOZ934dFYFS/C9Mld6d/n6/yKlWuPMXXGDtnftd3HArB+9RB6dquvUGduGjXiFz59imXgkOXS2FUtw/HD076L3Ru5UbdqbnZs/3M0EyZtYeLkP6Wx2zoal6pfR/OqOJdmz//GM3bCRqbN2E4Ja1MWzO1Lly8djOfPwzhwSLrWlmOVwXJt+vuED3VqVwBg5ZqjTJ2+TfZa7frSR9zXr/GkZ3f3bI5Gxo3yai+N3+ClhIe/x6VqWY4f8Ukmft+ce9Xs2b51LBMmbWTipM2UKmXOjm1jcXH5Gr/XryPo3vMPXr16h76+FhXKl+Do4emyp/2eP3/DgYOXAHB0/voYPMDfvnOoU7si6uqq/P13IIuX7CM6+jPFihnTpLELkyZ0QUVF/qIgL+TUuffixVs6d59DWFgURYro41q1DH7n5mNl9XVJjQOHLtG7z0LZ30kLbU4c35nJE7pIY3f6BouXHiA6+hPFihahSeMqTBrfOc9j90v7mrx9G4XPjB2EvHqHnb0Vew9OoviX4wt59Y5nz97I8luXMGPvwUmMGrGWVSsOY25hyNwFfWnVRn6NqIcPXnDxwh0OHs38wwgtW7mxeNkA5s75C69hq7Etbcm2/3lTrYZ9puvMdaIjlSt+2HWk9u/fzy+//MKWLVuoUqUKhw8fZsqUKSQkJBAREQFIn9rbt28fgYGBsnILFy5k4cKFPH36FIDff/+dI0eOsH79ekxNTRk3bhx///03v/76a66vI/VTyqZ1kH5aIn6Zl03rSP2MsmsdqZ9Rrq4jtbUrelpZXEfqYywGXf4U60il4oedI9WyZUuGDRvGoEGDqFSpEhcvXmTChAkZruePP/6gVq1atGjRggYNGlCjRg2cnJzSLigIgiAIwk/vhx2Ryi/EiFQWiRGVrBHxyzwxIpVpYkQq83J1RGpL5+wZkeq2TYxIpUJ8CguCIAhCASRJkCBJyNpYSVbL/wzy1a29p0+foqSklK7NwcEhr5srCIIgCMJPLl+NSKmpqaW6htO3SpYsmcOtEQRBEIQfWGI2LMiZD9cRzG/yVUfK0tKSe/dS/nFeQRAEQRDSKUEi3bJah5CqfHVrTxAEQRAE4UeSr0akBEEQBEHIHhKJBEkWb82JB/vTJjpSgiAIglAQJZANt/aypSUFmuhICYIgCEJBlJAo3bJah5AqMUdKEARBEAQhk8SIVDb5OHU1qhoinBlVqLtrXjfhh6ZkapHXTfhxaRXO6xb8sDSuXszrJvywND7E5tq+JInZMEdKLH+QJvHNLwiCIAgFkVj+IFeIW3uCIAiCIAiZJEakBEEQBKEgEiub5wrRkRIEQRCEAkj8aHHuELf2BEEQBEEQMkmMSAmCIAhCQSRJhMQsrgMlEetIpUV0pARBEAShIBJP7eUKcWtPEARBEAQhk8SIlCAIgiAUQGJBztwhOlKCIAiCUBCJW3u5QnSk8hmJRMJMvydsuPWciM/xOJvrM79eWeyMdVIsE5eQyNwrQWy784qX0THYGmgxraYt7iWMZXnW3HjG2hvPCY76BEA5Ix3GuJbE40ueuIREpl54zPGgMJ5GfkRPQ5W6xY2YWtMGcx1Nuf1dfhnBlAuPuPYqEjUVZcoX0WVva0cKqankQETSTyKRMHXlP6zZE0B41GdcHCxZ4t0IexuTdJXfcexfuozZS4s6pdm7sIMsfda68+w9dY97T99SSEMVt4pFmeVZnzLWX+OrUmlasnXO9qyPV89qCu1sOmg7xy88Zvf8drSqVzYTR5v9JBIJU+YdZs2f5wmP/IiLozVLfTpiXybln6FZ8+d5tvx1iX/vvwTAqUJxZni3oqqjdbL5fRYfY5zPfob8VpeF09rL0qM/fGbMjH3sP3aDt+EfsC5qxODf6vB7j9oAvAv/wKS5hzh59g7PXoRjbKhDy8YVmTaqBfp6hbIvCJkkkUiYMms3azaeIjziAy7ONiyd2wv7csVSLHP77jMmzdiF/40n/BccxnyfbngOaCKXZ8Xak6xcf5KnwWEA2JctyoTRbWjsXkmW53VoBGMmbefE3zeJiPxIrWplWfxHT2xLmQPw9L83lKwwJNk27Nw4lHat8/ZnmiQSCVM3X2HNkduEv/+MS1kzlgypjb21UYplNh6/y69/+CqkfzjyO5rqil9rs7ZdY9x6P4a0qciCAbVk6dGfYvFee5H9F57wNuoz1mZ6DGpVkd9blJcr73fnFRPWX+LyvRDUVJSpVKoIh31aUCi//yyY6Ejlinx+Fvx8Flx9ytKA/1jZ0B4bA23mXH5Ci93+XO9VHd1kPiAApl54zI67r1jqXo7Shtr4/veWTgducKpTFSqa6AFgqaPJ1Bo2lDTQAmDr7Vd02B/Iha6u2Bnr8DE+gcDQKEa7lqB8EV0iPscx+swD2u8P5FyXrx+0l19G0HrPdUZUtWZu3bKoqyhx6000ykpKOR+cNPyx8SIL/rzE+qktKG1lxIw152j4+1bu7huArrZGqmX/exnBqPm+1KxcXOG1s/7B/N6hClXszYlPSGT80jM0+n0b/+7pj3YhdQBe+A6TK3P0/CP6TDlImwblFOpb9OdllMj7eH1vzrITLFh1ig0Lu1O6lAkzFh7Fo8Ni7p2fjO53nekkZy8+oGPrKlRzLommhhpzlp+gYcfF/HtmIpbmheXyXg18ypo/z1PBzlKhnmETd3Hm4gO2LO2FdTEjTpy5w0DvHViYFqZlo4q8fB3Bq5AI/pjYFrvS5vz3/C2/j97Oq5BI/lrbNyfCkSFzFh5kwbIjbFjen9I25sz4Yy8erWZy79p8dHWT7+h9/BhLCWsTfmnlwvCxW5LNU9TSEJ/JnbApaQbApm3/0KrTXALO+WBfrhgSiYTWneejpqbCvm1e6OkVYv7SI7i3nMnty3+gra1JsaJGvHywQq7e1RtP8ceig3Idsrzyx84AFuy+zvqRDShd1IAZW6/ScPR+7m7oiq6Weorl9LTUubuxq1xacp2oq/des+bIbSqUVOyYDV9+jjM3XrB5jAfWZnqcuBbMoMVnsDDSpmX1koC0E9VkzAHGdHJi0aBaqKuqcONJWL74zBPyh59+svnkyZOpVKlSXjcDkF6ZLbsezMiqJWhpa4q9sQ6rGzrwKT6R/90LSbHc9rsv8XIpQcOSRShRWIs+FYvRwNqIxdf+k+VpUqoIDUsWwdZAG1sDbSbXsEFHTYWrryIB0NdQ4+AvTrQtY0ZpQ22qWhRmbr0yXH/9nmdfRrEAxpx5QH/HYoyoWgI7Yx1sDLRpXdoUDdW8PZUkEgmLtl5h7G81aFO/HA42Jmyc1pKPn+LYdvTfVMsmJCTSbew+Jv1emxKWhRVeP7q8Mz1bVsTexoSKZcxYP6U5wa8i8b/zSpbHzFhHbjtw5j51q1hTsqiBXF037oew4M/LrJvSPFuOO7tIJBIWrfmbsUMb0aapIw5lLdm4qAcfP8Wybc/VFMv9ubw3A3rWppJDMcramrFmblcSEyWcOndPLl/0h890HbiB1XO7YKCvpVDPJf8ndG/nSp1qpbEuZkTfbjWpaGfJtRvSc9ihrCW71vWjuUcFSlkXoV6Nskwf04KDJ28RH5+QvcHIIIlEwqIVRxk7ohVtWlTFwa4YG1f+Lo3dXxdSLFfFqRR/TO9Cx1+qoZHCyEbzxk408XCktI25tIM2sQM62ppcuvoIgIePQ7h09SHL5/emilMpythasHx+b6KjP7N9l/SHhVVUlDEzLSy37Tt4lfat3dBJoYOcWyQSCYv2BDK2cxXa1LTBoYQRG0e58/FzHNv+fpBqWSUlMDPUltu+F/0plm4+J1g1rC4GyRzrpbshdPcoS51KRbE206NvMwcqljLG/0GoLM+I5ecY3Loiozs5Y29thG3RwvxSywYN9bwdgU+PpDlSWd2E1P30Han85GnkJ15/iKX+N0PaGqrK1ChqwOWXESmWi02QoKki/0+pqaqMXwplEhIl/HUvhA/xCVS10E+x3qiYeJSQdrIAQj/GcjUkkiJa6tTffoUSK8/ScOdVLr4IT/cx5pSgFxGEhEXj7lZSlqahrkotZyv8Ap+nWnbaqn8wNtDi19aO6dpXZHQMAIb6yY80vH4bzZHzj+jVqpJc+sdPcXTx3sviMY0wS+VWbV4ICg4jJDQKj9p2sjQNDTVqu9nid+1xuuv5+CmWuPgEDA3kv9QGee+gSX0HGtRSHKEDqF7VhoMnbvLiVQQSiYTTF+7z4EkoDevYJZsfIDLqE3o6mqiq5u0XWtDTUEJeR+BR7+vtIA0NNWpXL4ffldQ7AxmRkJDIjl0X+fAxBreqtgDExMQBoKnxdeRGRUUZdXVVLly6n2w9/tefEHjrP37tXjfb2pZZQa+iCHn3EXenryPBGuoq1Kpgid/tV6mUhOhPcZTovJHiHdfTfNxBrj98o5Bn0OKzNHGxpoGT4kgzQHUHCw5eDOJFWLT0vAt8zoPnEXg4S/OHhn/k8r3XmBQuRI0hf2H+y1rqDt/N+Vsvs3DUuSghMXs2IVXi1l4+8vpjLAAm3w1nF9FS51nU5xTL1bcyYknAf1QvWpiShbU4E/yOw4/fkCCRv5L498176u+4yuf4RHTUVdjevCLljJL/Qv8cn8DE8w9pX9YMvS9Xy08jPgLg4/eEGbVsqWCiy7Y7r2i2y58r3d2wMVC8IswtIWHRAJgayh+PqaE2/30ZdUvOhevPWL8vkICd6bs9JJFIGDHvBDUci+GQwtyrzQduoqulTpv68p2G4XNP4FaxKC3rlknXvnJTSGgUAKZFdOXSTYz1CH7+Nt31jJmxF0uzwjSo+XXe1459Vwm49YwrR8ekWG7x9Pb09fqTYpW9UVVVRllZmTVzu1LDxSbZ/G/fRTN9wVH6dquR7rbllJBQ6fllaiJ/UWJSRJ/gZ2FZrv/W7WCquU/k8+c4dHQ02bN1OHZliwJQtrQFVsWNGTtlOysX/oa2tibzlx4m5Mut0OSs23KacmUsqeZSOstty6qQcOlniqmB/EWJqYEW/71+n2K5ssUMWD+qAeVLGBH1MZbFe25Q03MX11d1wrZoYQB2nH7A9YdvuLy8fYr1LBpYi77z/6Z4xw2oqiijrAyrh9enRnnpvMAnr6TviymbrzCnX3UqlSrClpP3cB+1l5trusj2Jfzc8v2I1PPnz+nYsSOGhoZoa2vj7OzM5cuXZa+vWLGCUqVKoa6uTpkyZdiyRX6uQXBwMC1btkRHRwc9PT3at2/P69evU9xfUFAQNjY2/P777yQmsyJsTEwMUVFRcltm7bz7CtMlf8u2uC89f4X5MxJSnVEzp24ZbAprUXnjRQwWnmLE3/foam+Bynf38EsbanOxqyunO1XhtwpF6Xv8NnffRivUF5eQSM/Dt0iUwIJvOgNJ0ehdwZJuDpZUNNFjdp0y2Bpos+Xf3L1C23r4Fnpus2RbXPyX2H0fOgkopTCX4f2HGLqP28eqic0wNlC83ZScwT7HuPUglK2z2qSYZ8P+QDo3KY/mN7drDpy5z+krT1kwsmG69pPTtu6+gm4pT9kWFye9PfZ9rCQSSYrx+96cZSfYse8au9f1RVNTOor57MU7PCf8xZalvWRpyVm87jSXAoLYv+l3rh33Zu6ktgz03o7vP3cV8ka9/0SzbsuwK23GpBHN0nvI2Wbr/86ja9FTtsXFxQMpxS7r+ytja8H1c7Pw851K/94N6Nl/BXfuSUdZ1dRU2bV5GA8eh2Bk3Qdtsx6cPX+Hxu6VUFFR/Hj/9CmW7bsu0rtbnaw3LBO2nrqPXrOVsu3r+zZjsXO1M6Nrg7JULFWEmuUt2TmhMaWLFmbpvhsAPAt9z7Bl/7DZ2z3ZeVNJluy9weW7Ieyb1oyrKzowt18NBi0+g69/MACJXy5G+zazp1cjOxxtizB/QE3KFDVgw7E7WQlFrpBIsuHWnkTc2ktLvh6Rio6Opnbt2lhaWnLgwAHMzMwICAiQdXD27t3L0KFDWbhwIQ0aNODQoUP06tWLokWLUrduXSQSCa1atUJbW5uzZ88SHx/PgAED6NChA2fOnFHY37///ouHhwc9evTAx8cn2Tb5+PgwZcqUbDm+JqWK4Gz29So25ktH6vXHGMx0vk6OfvMpFhPtlCddFtFSZ0fLSnyOT+DdpzjMdTSYeO4RVt/delJXUabUlw5DZTN9/F9HsTwgmCXuX2+fxCUk0u3QTZ5GfuJwOyfZaBSA2ZcJ22W/G/UpY6jNs/cpj5jlhBZ1SuNS/uuk5ZhY6ZdZyNtozL8ZVQkN/4BpMnMnAB4/C+fpywhaDt0hS0v8Mh9A3Wk6d/cNoFQxQ9lrQ2Yd4+DZB5xZ352ipnrJ1nkuIJj7T9+yfbZ8R+v0lac8fv4Ow5pz5NLbee2ipmNx/l7XPT2HnW1aNKyAS2Vr2d+y+IVGYW769Zx88/a9wihVcuauOInP4mOc3DmUCnZFZen+N4MJDXuPc8Ov76eEhET+ufSIZRvO8vm/JcTGxjPOZz971vejaQPp7bEKdkUJvP2MeSt85W4Hvo/+TOPOS9HR1mDP+v6o5cGToi0aO+Hi9HWkLCZWenst5HUE5mZf58S9CYtSGKXKDHV1VWxKSSebO1cuxbWAJyxacYxVi34DwMmxJNfPzyIy8iOxcfEUMdbDtd54nBxLKtS1a/9lPn6MoXunWgqv5YYWbiVwKWsq+zvmSwc+5N1HzI2+vk9DIz5hms6LGwBlZSWcS5vw8EUEAP4PQwmN+ESV33fK8iQkSvjn1guW7bvJp6MDiI1PZNx6P3ZPbkJT1xIAVChpTODjMOb9dZ0GTsUxN5S2oZyVodz+yhY3IDg05RGzfEM8tZcr8nVHatu2bbx584arV69iaCg9kW1svn6AzZ07l549ezJgwAAAhg8fzqVLl5g7dy5169bF19eXmzdvEhQURLFi0seQt2zZgr29PVevXqVKlSqyuvz8/GjWrBne3t54eXml2CZvb2+GDx8u+zsqKkpWd0bpqqvKPYknkUgw1Vbn7//eyZ62i01I5PzzcKbWtE2zPk1VFSx0VYhLSGT/w9e0KWOaan6JRFp/kqRO1OOIjxxp54xRIfnOm5WeJubaGjwI/yCX/ij8Ix4lUn5UOSfoamvIPYknkUgwM9bB1y8Ix7LSx75j4xL459p/+HjWT7aOsiWMubGrn1zahKWnif4Yy4JRDSn2pZMrkUgYMusY+/6+z99ru1HC0iC56gBYv/c6TnbmVCxjJpc+und1fm0jPwer4i+rmO/lQbPaaf/bZjddHU25J/EkEglmJnqc/OcujuWl53NsbDxn/R4ya1zrVOv6Y/kJZiw8yrHtg3GuZCX3Wv2aZbl5erxcWm/PLZS1MWXUIA9UVJSJi08gLi5B4SkoFWVlWccWpCNRjTotQUNdlf0bB6Q6wpWTdHULyT2JJ5FIMDMtzMnTt3CsKP1Cjo2N5+yFu8ya3Cnb9y+RSIj90nn7lv6XSfwPH7/i2vUnTB2neEtr/ZbTtGjsRBHj5C8Ecpqulrrck3gSiQQzQy18A4JxtC0CfHnf3nyBT5/q6a5XIpFw43EYDl8+h+o7FuPGms5yeX79w5cyxQ0Y1cFJet59jicuPhFl5e/POyXZSJS1mR4WRto8eBYhl+fh8wgaVZU/14WfV77uSAUGBuLo6CjrRH3v7t279O0rP7elevXqLFq0SPZ6sWLF5Do6dnZ2FC5cmLt378o6UsHBwTRo0IDp06czbJj8Y+zf09DQQEMj9UfpM0tJSYmBjsWZeyWIUoW1KGWgxdzLQRRSVaZ92a9fzH2O/ouFjgZTvnSurr6K5GX0ZyoU0eVldAwz/Z6QCHg6W8vKTD7/EHdrY4rqavI+Np5d919z7vk79rWpDEB8YiJdD90k8HUUu1o7kiiR8PqDdFK1gaYa6irKKCkp4VnFihkXn1C+iC4Viuiy9c5LHrz7wJ/NK+RITNJLSUmJoV2q4rPuPDZWhtgWN8Rn7Xm0CqnRubGDLF+P8fuwNNFl5pD6aGqoKsxzKqwr7Vx8mz5o5lG2H/2XvQs7oKutIZuPpa+jQaFvvsyjomPYdfIuf4xwV2hf0tN83ytmppdqxyy3KCkpMbRPPXwWH8O2hAm2JYvgs/gYWoXU6dzm6wVHj8EbsTArjM+4VoD0dt7EOQfZuky6bEHSfCEdbQ10tKWdNYey8ssdaGupY2igLUvX0y1EbTdbRk3bQ6FC6lgVNeSs30O27LrMvMltAelIVMOOi/n4KY4tS3sRFf2JqGjp06RFjHSTvY2VW5SUlBj6e2N85u/HtpQ5tqXM8Jm3Txq7dl87Az36LcfC3ACfL52r2Nh42S262Nh4XrwMJ/DmU3S0NWUjUGOn7KCxeyWKWRrxPvoTO3b7ceb8HY7u/jrf7K+9lyhirEfxokbcuvMMzzGbaNW0Ch715d+Tjx6H8M+FexzeNSqnQ5JuSkpKDG1TCZ9t17CxLIytZWF8tl1DS1ONzvW+zuHqMesElsY6zPxNuibb1M2XcSlnhq1lYaI+xrJk7w0CH4exZIh03TFdLXVZpyqJtqYaRnqasnQ9bXVqV7Bk9OoLFFJXxcpUl7M3X7Ll5D3m9q8pa59X+8pM3nSZCqWMqVTKmM0n7nHvWTj/myS/5le+lCiRblmtQ0hVvu5IFSqU9kJ7qc3pSGl+x/fpRYoUwcLCgh07dvDrr7+ip5c3V2sAw6pY8yk+kWF/35UuyGmmx/62TnIjV8/ef+bbi6jP8QlMvfCYp5Gf0FZToWEJY9Y2tqfwN1/yoR9i6XPsX0I+xKCnropDEV32talMPSvph8qL9zEcfix96sVtyyW5Nh1p50StL7e4Bla24nN8ImPO3Cf8cxzli+hy4JfKlCyc/mH4nDKyZzU+fY5n0MyjhEd9wqW8JcdWdJEbuXr2KirD67+s/MsfgHq/bZZLXzelBT1bVpT9vePYbSRI6NTIPgtHkXdGDfTg0+c4Bnpv/7IgZwmO7xgsN3IV/OKd3BX8io1niY2Np12fNXJ1TRzRlMle6Z+/tH3lr4yduZ+uA9fzLuIjVpaGTB/dgv7dpbeg/G8GczngKQC2bhPlyj65Mh3rYrk7Ivq9UZ7N+fQ5loEj1n9ZkLMUx/eOlRu5Cn4eJhe7l6/CqVzTW/b3vCWHmLfkELVrlOP0Yekxvg6NpHu/ZbwKiUBfT4sK9sU5unsM7vW+dpJevY5gxLgtvA6NxNzMgG4dazJhlOIcvvV/nsHSwgCPenl70fO9kR0q8ykmnkGLzxD+PgaXcqYcm9VSbuTqWWi0XOwiomPpv+A0IeEf0NfWoFKpIpxZ0IaqZc2S20WKto1vyNh1fnTzOcG795+xMtVlem83+jf/evE1tG0lPsfGM2LFOd69/0zFksYcn92KUqk88ZxfSBJAksVbc5K8XV3kh6AkycczyTZt2sSQIUMICgpKdlSqevXq2Nvbs3r1alla+/bt+fjxI4cOHeLkyZM0btxY7tbenTt3ZLf2nJ2dmTx5Mvv27ePChQs0adKE2NhYTpw4ga5u2vNCQHprT19fn5cD68rNJxLSp1D3vF1V+UenZJryquNCGrQK53ULfliSqxfzugk/rKgPsRi0XEVkZGSOXbQnfS+98myQ5e+lqJh4zBf65mh7f3T5+qm9Tp06YWZmRqtWrbhw4QJPnjxh9+7d+Pn5ATBy5Eg2btzIypUrefjwIfPnz2fPnj2yOU4NGjSgQoUKdOnShYCAAK5cuUL37t2pXbs2zs7OcvvS1tbm8OHDqKqq0rhxY6KjFZ9mEwRBEIQfRtKtvaxuQqrydUdKXV2dEydOYGJiQpMmTShfvjyzZs1CRUX6pE6rVq1YtGgRf/zxB/b29qxatYoNGzZQp04dQHrbb9++fRgYGFCrVi0aNGhAyZIl2blzZ7L709HR4ejRo0gkEpo0acKHDx+SzScIgiAI+Z5YkDNX5Otbez8CcWsva8StvawRt/ayQNzayzRxay/zcvPW3svf62TLrT2LFWfErb1U5OsRKUEQBEEQhPws1ztST58+RUlJKV2bg4ND2hUKgiAIgqAoUfJ1Uc7MbmKOVJpy/V6UmpoaZcqk77fGSpZUXJlXEARBEIS0Jf3MS1bryCkzZszg8OHDBAYGoq6uTkRERNrtkUiYMmUKq1evJjw8HBcXF5YtW4a9fd4tO5PrHSlLS0vu3buX27sVBEEQBCEfiY2NpV27dri5ubFu3bp0lZkzZw7z589n48aNlC5dmunTp+Pu7s79+/fTvWxRdhOzowVBEAShAJIkSLJhQc6cG5FK+t3ajRs3pq8tEgkLFy5k3LhxtGkjXXR206ZNmJqasm3bNvr165dGDTlDTDYXBEEQhAIo6dZeVjeQPgn47RYTE5PrxxMUFERISAgeHh6yNA0NDWrXrs3Fi3n3JKnoSAmCIAiCkKpixYqhr68v23x8fHK9DSEhIQCYmprKpZuamspeywvi1p4gCIIgFECJCRISs3hrLqn8s2fP5NaR0tDQSDb/5MmTZbfsUpL0E22Zldpv7OYF0ZESBEEQhAIoO5/a09PTS9eCnIMGDaJjx46p5rG2ts5UW8zMpD9KHRISgrm5uSw9NDRUYZQqN4mOVDbRmjEMLT3tvG6GIAhCjlOq1yqvm/DDUor6AKzK62bkGGNjY4yNjXOk7hIlSmBmZsbJkydxdHQEpE/+nT17ltmzZ+fIPtNDzJESBEEQhAJIkpiYLVtOCQ4OJjAwkODgYBISEggMDCQwMJDo6GhZnrJly7J3715AekvP09OTmTNnsnfvXv7991969uyJlpYWnTt3zrF2pkWMSAmCIAhCQZQNyx+Qg8sfTJw4kU2bNsn+ThplOn36NHXq1AHg/v37REZGyvKMGjWKT58+MWDAANmCnCdOnMizNaRA/GhxliX9OGRExAH0xK09QRAEIRVRUR8oXLhFrvxo8ZN2VdFVy9p4yfu4eEr+dUX8aHEqxK09QRAEQRCETBK39gRBEAShAJIkSJAo59+VzQsK0ZESBEEQhAIov/9ocUEhbu0JgiAIgiBkkhiREgRBEIQCKDFRQmIWR5SyWv5nIDpSgiAIglAASRLIhjlS2dSYAkzc2hMEQRAEQcikAteRqlOnDp6ennndjExbvnw/JUt2oVChRjg79+fcuZup5j979gbOzv0pVKgRpUp1ZeXKgwp5du/+B3v7XmhqNsLevhd7957P8H4lEgmTJ2/C0rI9WlqNqVt3OLdvP83SsWY3EbvME7HLmsy2M7diFBMTy+DBSyhSpDU6Ok1p2XI8z5+/ycohZxtx7uWcpMnmWd2E1BW4jtSePXuYNm1aXjcjU3buPM2wYcsZO7YzAQGrqFGjPE2aeBMc/DrZ/EFBr2jadCw1apQnIGAV3t6dGDp0Kbt3/yPL4+d3m44dp9G1qzuBgavp2tWdDh2mcvny3Qztd86cHSxYsIslSwZz5cpyzMwM8PAYxfv3H3MuIBkgYpd5InZZl5l25maMPD2Xs2/febZvH8+5cwuJjv5E8+bjSEjI2/s24tzLWaIjlTvEyuZZlJ0rm7u6DsTR0ZYVKzxlaXZ2vWjZsjo+Pr8p5B89ejUHD/px584GWVr//gu4efMxFy8uBaBjx2lERX3gyJFZsjyNG4/BwECHbdvGp2u/EokES8v2DB3ahtGjOwHSK1wzs1+YNasP/fo1z9JxZwcRu8wTscuazLYzt2IUGRmNiUlbNm8eQ4cOdQF4+TKM4sU7cfjwTBo2rJITYUmXn/Hcy82Vze82dERXTSVLdb2PS6Dc8etiZfNUFLgRqW9v7VlbWzNz5kx69+6Nrq4uxYsXZ/Xq1XL5L168SKVKldDU1MTZ2Zl9+/ahpKREYGBgrrY7NjYOf/8HeHg4y6W7uzvh53c72TKXLt3B3d1JLq1hwypcu/aAuLh4APz87uDuLl+nh4czFy/eTvd+g4JeERLyTi6PhoY6tWtXTLFtuUnELvNE7LIus+3MrRj5+z8kLi5eLo+FhTEODtayfeUFce7lPMmX39rL6iakrsB1pL43b948nJ2duX79OgMGDOD333/n3r17ALx//57mzZtTvnx5AgICmDZtGqNHj86TdoaFRZKQkIipqYFcuqmpASEh75ItExLyLtn88fEJhIVFpponJCQ83ftNyvt9HhOTr/XkJRG7zBOxy7rMtjO3YhQS8g51dTUMDHRTrCcviHMv50kkiUgSs7hJEvP6MPK9At+RatKkCQMGDMDGxobRo0djbGzMmTNnANi6dStKSkqsWbMGOzs7GjduzMiRI1OtLyYmhqioKLktOykpyf8tkYDS94ly+eVfS7pT+216cnm+rzI9+02+npTblttE7DJPxC79tm71RVe3qWxLGgnJTDvzMkZ5Hcck4tzLOWJEKncU+I5UhQoVZP+tpKSEmZkZoaGhANy/f58KFSqgqakpy1O1atVU6/Px8UFfX1+2FStWLFvaaWysj4qKssLVTmhouMJVURIzM0OFK7fQ0AhUVVUwMtJLNU9SnenZr5mZ9P+/r+fNmwhMTQtn4Chzhohd5onYZVyLFtW4fn21bDM21gcy3s7cipGZmSGxsXGEh79PcV95QZx7QkFR4DtSampqcn8rKSmRmCgdqkzu6iKtuffe3t5ERkbKtmfPnmVLO9XV1XByKs3Jk/5y6b6+/ri52SdbxtXVDl9f+fwnTlzD2bk0amrStVbd3BTznDx5jWrV7NO93xIlzDEzM5TLExsbx9mzN1JsW24Sscs8EbuM09XVwsbGUrbZ2Vllqp25FSMnJ1vU1FTl8rx69ZZ//30q21deEOdezhNP7eWOn3pl87Jly7J161ZiYmLQ0NAA4Nq1a6mW0dDQkOXNbsOG/UL37rNwdi6Nm5sdq1cfJjg4lP79pU+IeHuv5eXLMDZtGgNA//7NWbZsP8OHL6dPn6b4+d1h/fqjbNs2TlbnkCFtqF3bk9mzt9OyZXX277+Ar28A584tSvd+lZSUGDq0DT4+27C1LYqtrSU+PtvQ0tKkc+f6ORKLjBKxyzwRu6xJbzt79JiFhYWx7Gm03IqRvr4OvXs3xstrJUZGehga6jJy5CrKly9BgwaVczFSisS5l7PET8Tkjp+6I9W5c2fGjRtH3759GTNmDMHBwcydOxdI/R59TunQoS5v30YxbdoWXr16h4ODNYcP+2BlZQpASMhbgoNDZflLlDDn8OGZDB++nOXLD2BhYcSiRYNo27aWLE+1avZs3z6eCRM2MHHiRkqVsmDHjgm4uJRL934BRo3qyKdPsQwcuIjw8Pe4uJTj+PHZ6Opq5UJk0iZil3kidlmXnnYGB4eirPz1cyU3Y7RgwQBUVVXo0GEqnz7FUr++Ixs2TEdFJWuPxmeVOPeEgqDArSNVp04dKlWqxMKFC7G2tsbT01NupfNKlSrRqlUrJk+eDEiXP0h6kq98+fKMGDGCzp07c+/ePcqUKZPm/rJzHSlBEAShYMvNdaQC3ezQVc3iOlLxCVTyuyPWkUpFgRuRSnoiD+Dp06cKr3+/PlS1atW4ceOG7O+tW7eipqZG8eLFc6iFgiAIgpDzsmOOk5gjlbYC15HKqM2bN1OyZEksLS25ceMGo0ePpn379hQqVCivmyYIgiAIQj7303ekQkJCmDhxIiEhIZibm9OuXTtmzJiR180SBEEQhCyRJEiQKGVxREqsI5Wmn74jNWrUKEaNGpXXzRAEQRCE7CXJhuULCtY06hxR4NeREgRBEARByCk//YiUIAiCIBREksRsuLUnJpunSXSkBEEQBKEAkiRIkCDmSOU00ZESBEEQhAIoMVFCYhZHpMTK5mkTc6QEQRAEQRAySYxICYIgCEIBlJgIiVn8tbPExOxpS0EmOlKCIAiCUACJjlTuEB0pIU8lIt6lWaEs7s4LeUC8bzNPxK7gER0pQRAEQSiAxIhU7hAdKUEQBEEogBIl0i2rdQipE/cFBEEQBEEQMkmMSAmCIAhCASRu7eUO0ZESBEEQhAIoUZL1jpC4tZc2cWtPEARBEAQhk8SIlCAIgiAUQJJEsrzYgkTc2kuT6EgJgiAIQgGUmA0dKTFHKm2iIyUIgiAIBZDoSOUOMUdKEARBEAQhk8SIlCAIgiAUQGJEKneIEal8RiKRMHnyJiwt26Ol1Zi6dYdz+/bTNMvt3v0P9va90NRshL19L/buPa+QZ/ny/ZQs2YVChRrh7Nyfc+duyr0+efImypXriY5OUwwNW+LuPpLLl+/K5enXbz42Nl3R0mqMiUkbWrWawL17wVk65uyyYvkBbEp2Q7tQE6o6D+DcuVup5j979gZVnQegXagJtqW6sWrlQbnXb99+SrtfplCqRFdUld1ZtHCPQh1TJm9GVdldbrM0by+Xp3evOQp5qrkNzvoBZ6O0zo3vnT17A2fn/hQq1IhSpbqy8rvYQdrn5Pv3H/H0XIa1dSe0tBpTvfpgrl69l+I++/Wbj7JyfRYu3J25g8xBefm+/VZqMfLzu039+iPQ0WmKgUEL6tYdzqdPMRk6zpyQF+/blSsO4lixLwb6LTHQb0n1akM4evSKXJ7o6E8MGbQEq2Kd0NFqioNdb1auUDzP87PExOzZhNSJjlQ+M2fODhYs2MWSJYO5cmU5ZmYGeHiM4v37jymW8fO7TceO0+ja1Z3AwNV07epOhw5T5TpBO3eeZtiw5Ywd25mAgFXUqFGeJk28CQ5+LctTunRRliwZzM2bazh3bhFWVqY0bDiaN28iZHmcnEqzfv0o7tzZwLFjs5BIJDRsOJqEhIQciUd6/W/nGYYPW4H32E5cC1hBjRoONGsyluDg0GTzBwW9onnT8dSo4cC1gBWM8e6E59Dl7Nl9Tpbn48cYSpQwZ6bPr5iZGaa4b3t7a56/3CnbAm+uVsjTsFEVuTyHDs/I+kFnk/ScG98KCnpF06ZjqVGjPAEBq/D27sTQoUvZvfsfWZ70nJN9+szD19efzZu9uXlzLe7uzri7j+LFizcK+9y37zxXrtzDwsIo+wOQDfLyfZsktRj5+d2mcWNv3N2duXx5GVeuLGfgwJYoK2dxtcYsyqv3rWVRY2b4/Mrlq8u4fHUZdetWok2rSXKd3xHDVnD8+DU2bRnDv3fWMdSzLUOHLOXA/ovZGgPhx6ckkUjEcltZEBUVhb6+PhERB9DT085SXRKJBEvL9gwd2obRozsBEBMTi5nZL8ya1Yd+/ZonW65jx2lERX3gyJFZsrTGjcdgYKDDtm3jAXB1HYijoy0rVnjK8tjZ9aJly+r4+PyWwrF9oHDhFpw8+Qf161dONs/Nm4+pVKkvDx9uoVQpiwwfc3b9Erqb62AqO9qwbMVQWZqDXW9atKzOTJ9fFfKPGb2GQwf9+PfOelnagP4LuXHzCRcuLlbIX6pEV4YMbcNQzzZy6VMmb+bA/gv4X1+VYtt695pDRMQH9uydkplDS5VyNlwLZfTcGD16NQcP+nHnzgZZWv/+C7h58zEXLy4F0j4nP32KQU+vGfv2TaNpU1dZHkfHvjRt6sr06b1laS9evMHVdRDHjs2mWbOxDB3aFk/Ptlk+7uySH963acXIzW0QDRo4MW1ar2w55h/9fZucIkZtmD2nD71/bQxAxfJ9aNe+NuMndJXlqeo8gEaNqzJ1Ws+MHKacqKgPGBZuRWRkJHp6epmuJ/V9SL+XDprYoK2skqW6PiQm0Dz0UY6290cnRqTykaCgV4SEvMPDw1mWpqGhTu3aFfHzu51iOT+/O7i7O8uleXg4c/GitExsbBz+/g/k6gVwd3dKsd7Y2DhWrz6Mvr42FSuWSjbPhw+f2LDhOCVKmFOsWJF0HWNOiI2NI8D/Ae4eTnLpqR3fpUt3cXeXz+/R0Bn/aw+Ii4vP0P4fPnxJMcsO2JTsRudOM3jy5JVCnrNnbmBu2o5yZXrSr898QkPDM7SPnJKZc+PSpTsKsWvYsArXvoldWudkfHwCCQmJaGqqy+UpVEidCxf+lf2dmJhI9+6z8PJqj729daaOMafl9fs2rRiFhoZz+fJdTEwKU736YMzM2lKnzjDOn0/9FlpOy+v3bZKEhAR27jjNhw+fcXWzk6VXr27PoYN+vHgRhkQi4fTpQB48eI5HQ+dUastfJBJJtmxC6kRHKoNiYmKIioqS27JLSIj0y9XU1EAu3cTEQPZa8uXeKZQxNf1aJiwskoSExBTyvJNLO3TID13dphQq1JiFC3dx4sQcjI315fIsX74fXd2m6Oo24/jxq5w4MQd1dbWMHWw2Sjo+k+/jZmrA6xTi9jrkXbL54+MTCAuLTPe+q7qUZeOmURw5NouVq4cREvKOmtWH8vbt1/OiUaOqbP7Tm5On5jBnbj+uXbuPe/1RxMTEZuAoc0ZGzo0kKZ1v38YurXNSV1cLNzc7pk//k5cvw0hISODPP09y+fI9Xr16Kysze/YOVFVVGDIk7RGFvJLX79u0YpTUsZ8yZRO//daUo0dn4ehoS4MGI3n48Hk6jzL75eX7FuDWrSD0dZujpdmEAb8vYteeSdjZWcleX7h4IOXsrLAq1olCGo1p2ngsS5cNpkYNhwztRyj4REcqg3x8fNDX15dtxYoVy3RdW7f6fumQSLekKyolJfl5CxKJRCHte8mX+T4P3+VRLFe3biWuX1/NhQuLadiwCh06TFMYPenSpT4BAas4c2YBtraWdOgwlc+f875TkNG4JZc/ufTUNG5clTZta1K+fAkaNKjMwUPTAdi86YQsT/sOdWja1AUHhxI0b+7GoSMzefDgOUcOX073fnJaes4N+fxpxy6tc3LzZm8kEglFi3ZAU7MRS5bspXPneqioSD+W/P0fsHjxHjZsGJWhf5Oclp/et+mJUeKXH0vr27cZvXo1wtHRlgULBlCmTFHWrz+WavtyQ168bwHKlCmK//WVXPBbTL/+zend8w/u3PlP9vqSxfu4fOkue/dP5cq15fwxty+DBi7B1zcgQ/vJS/l9svmMGTOoVq0aWlpaFC5cOF1levbsiZKSktzm6uqadsEcJJY/yCBvb2+GDx8u+zsqKirTnakWLarh4lJO9ndMTBwgvVI1N/86YfTNmwhMTQunWI+ZmaHC6EFoaITsStbYWB8VFWWFq+PQ0HCFq11t7ULY2FhiY2OJq6sdpUt3Z926o3h7d5bl0dfXQV9fB1vbori6lsPQsBV7956nU6d6GQtANkk6vtffxeBNaAQmKcTN1Mww2fyqqioYGWV+HoC2diEcypfg0cMXKeYxNzfCysqEh6nkyS0ZOTeSpHS+fRu7tM5JgFKlLDhzZgEfPnwiKuoj5uZGdOw4jRIlzAE4d+4WoaERWFl1kpVJSEjEy2slixbtJihoW+YPPAvy0/s2PTEyN5dOuP52tAWgXDkrnj1LflJ3bsjr9626uho2NpYAODuX4dq1+yxZtJcVqzz59CmG8ePWs2vPZJo2dQGgQoWS3Ah8zPx5f9GgQfJzRvOb/L78QWxsLO3atcPNzY1169alu1yjRo3YsOHrHE11dfVUcuc8MSKVQRoaGujp6cltmaWrqyXrtNjYWGJnZ4WZmSEnT/rL8sTGxnH27A3c3OxTrMfNzQ5fX3+5tJMnr1GtmrSMuroaTk6l5eoF8PX1T7VekF7tJX1RpJ4n70ak1NXVqOxUGt+T8leKvr4BKR6fq2s5hSvLkyf8cXIujZpa5q8vYmJiuXc3GDPzlJ/ye/s2imfP3sh96eaVzJwbrq6K59uJE9dw/iZ2aZ2T39LWLoS5uRHh4e85GVKmsgAABzNJREFUfvwqLVpUA6BbtwbcuLGG69dXyzYLCyO8vNpz7NjsTB9zVuWn9216YmRtbYaFhRH378vfxnvw4DnFi5tkPhBZlJ/et/DlcyxW+jkWFxdPXFy8wlONKioqJIr1ALLNlClTGDZsGOXLl89QOQ0NDczMzGSboWHKn7e5QYxI5SNKSkoMHdoGH59t2NoWxdbWEh+fbWhpadK5c31Zvh49ZmFhYSx7amfIkDbUru3J7NnbadmyOvv3X8DXN4Bz5xbJygwb9gvdu8/C2bk0bm52rF59mODgUPr3lz5R9OHDJ2bM2EqLFtUwNzfi7dtIli8/wPPnb2jXrjYAT568ZOfOM3h4OFOkiD4vXoQxZ84OChVSp0kTl1yMlKJhw9rSo/tsnJxL4+pWjjWrjxAcHEq//s0AGOu9jpcvw9i4aTQA/fo3Y/myA4wYvpLf+jTmkt9d1q8/xtZtY2V1xsbGyYb6Y2PjePEijMDAR+joFJJdyY70WkWz5q4UL25CaGgEM2dsIyrqI917eADStWimTN5Mm7Y1MTc35OnT14wftx5jY31ata6emyFKUVrnhrf3Wl6+DGPTpjEA9O/fnGXL9jN8+HL69GmKn98d1q8/yrZt42R1puecPH78KhKJhDJlivHo0QtGjVpNmTLF6NWrEQBGRvoYGcnPz1NTU8XMzJAyZTJ/Sz275eX7Nj0xUlJSwsurA5Mnb6JixZJUqmTDpk0nuHcvmL/+mpTT4UlVXr1vx41dR6PGVSlWrAjv339i547TnD1zk8NHZwKgp6dNrdoVGDNqDYUKaWBlZcI/Z2+yZctJ5s7rn5shypJESdZHlL7cGVaYD6yhoYGGhkbWKs+kM2fOYGJiQuHChalduzYzZszAxCTvLgpERyoZS5cuZe/evZw6dSrX9z1qVEc+fYpl4MBFhIe/x8WlHMePz0ZXV0uWJzg4VO5KqVo1e7ZvH8+ECRuYOHEjpUpZsGPHBLnbDx061OXt2yimTdvCq1fvcHCw5vBhH6ysTAHpldb9+8/45ZfJhIVFYWSkR5UqZfjnn4WyJ4E0NdU5f/4WixbtJjw8GlNTA2rVqsCFC0swMUn+NlBuad+hDm/fRjF92p+y4zt4eIbs+EJC3sqtTVOihDkHD0/Ha/hKViw/gIWFEQsXDaBN25qyPC9fvsW58u+yv+fP+4v58/6iVu0K/H16HgAvXoTRtfNMwsKiKFJEHxfXclzwW/xNXJX5998g/tziS0RENObmhtSpW5HtO8bJ/ZvmpbTOjeRid/jwTIYPX87yL7FbtGgQbdvWkuVJzzkZGfmBsWPX8vx5GIaGurRpU5MZM3pneWQhL+TV+za9PD3b8vlzLMOHr+Ddu/dUrFiSEyfmZGrJkuyUV+/b0NcR9Ow+m1ev3qGvr035CiU4fHSm3BOB27aPY9zYdXTv6sO7d++xsjJl2vResk7ej0CSCIlZnF6Y9NDe91NYJk2axOTJk7NWeSY0btyYdu3aYWVlRVBQEBMmTKBevXr4+/vnWcdOrCOVjMmTJ7Nx40aePn2aZt7sXEfqZ5Rd69H8rLJjHSlByCjxvs283FxHaqdOKbSUsraO1EdJAh2iH/Ps2TO59qY0IjV58mSmTEl9zbyrV6/i7Px1GYmNGzfi6elJREREhtv36tUrrKys2LFjB23a5M3TvT/epV8umDx5cp70tAVBEAQhP0rvnOBBgwbRsWPHVPNYW1tnU6vA3NwcKysrHj58mG11ZpToSAmCIAhCAZSYDbf2EjN4z8rY2BhjY+Os7TQD3r59y7NnzzA3N8+1fX5P3BcQBEEQhAIov68jFRwcTGBgIMHBwSQkJBAYGEhgYCDR0dGyPGXLlmXv3r0AREdH4+XlhZ+fH0+fPuXMmTM0b94cY2NjWrdunXMNTYMYkRIEQRAEIddNnDiRTZs2yf52dHQE4PTp09SpUweA+/fvExkpXbVeRUWFW7dusXnzZiIiIjA3N6du3brs3LkTXV3dXG9/EtGREgRBEIQCKFGSDQty5uDjaBs3bmTjxo2p5vn2ebhChQpx/PjxnGtQJomOlCAIgiAUQHkxR+pnJOZICYIgCIIgZJIYkRIEQRCEAkiMSOUO0ZESBEEQhAJIdKRyh7i1JwiCIAiCkEliRCqLkp4oiIr6mMct+TGJn5rIGvETMUJeEO/bzEv6rsiNX2f7IEnM8ojSJ/FvnSbRkcqi9+/fA1C8eOpL4guCIAhCkvfv36Ovr58jdaurq2NmZsaQkKBsqc/MzAx1dfVsqasgEj9anEWJiYm8fPkSXV1dlJSyeDNaEARBKNAkEgnv37/HwsICZeWcG1H+/PkzsbGx2VKXuro6mpqa2VJXQSQ6UoIgCIIgCJkkJlgIgiAIgiBkkuhICYIgCIIgZJLoSAmCIAiCIGSS6EgJgiAIgiBkkuhICYIgCIIgZJLoSAmCIAiCIGSS6EgJgiAIgiBk0v8BU8I1rQ7On3sAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz = LLMAttrViz(**attr_result)\n", + "print(attr_viz.seq_attr_dict)\n", + "attr_viz.plot_seq_attr()\n", + "attr_viz.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "collectible-thomas", + "metadata": {}, + "source": [ + "We can also perform a similar attribution experiment with a dictionary of inputs / baselines. Additionally, we omit the attribution target, so we will attribute w.r.t what the model will generate in the default setting. As we can see, the result is generally more positive than above. This is expected, since the target, \"playing guitar, hiking, and spending time with his family.\", is what the model feel confident to generate given the input tokens." + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "id": "massive-french", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 0.0009605777449905872 ]\n", + "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 2.644512824190315e-05 ]\n", + "Dave lives in Mountain View, FL and is a lawyer. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 0.0007114586187526584 ]\n", + "Dave lives in Palm Coast, CA and is a lawyer. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 0.0006647087284363806 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 0.0008365382091142237 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 8.822518680062785e-07 ]\n" + ] + } + ], + "source": [ + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", + " baselines={\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"}\n", + ")\n", + "\n", + "\n", + "attr_result_2 = llm_attr.attribute(inp_feature)" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "a6457ff6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_2 = LLMAttrViz(**attr_result_2)\n", + "attr_viz_2.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "533e607c", + "metadata": {}, + "source": [ + "Another way to ablate the input text is to directly remove the corresponding tokens, which can also be viewed as replacing them with emptry string. This is also the default baselines for `TextTemplateFeature`. Let's try this, but please note removing tokens is likely to create out-of-distribution text input and therefore may not give you meaningful results." + ] + }, + { + "cell_type": "code", + "execution_count": 273, + "id": "15cfe4a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.074411481269635e-05 ]\n", + "Dave lives in , FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4309290893143043e-05 ]\n", + "Dave lives in Palm Coast, and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.252655218006112e-06 ]\n", + "Dave lives in Palm Coast, FL and is a . His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.487737664429005e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.5998193652631016e-06 ]\n" + ] + } + ], + "source": [ + "target = \"playing golf, hiking, and cooking.\"\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", + ")\n", + "\n", + "attr_result_3 = llm_attr.attribute(inp_feature, target=target)" + ] + }, + { + "cell_type": "code", + "execution_count": 274, + "id": "85c744ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Dave': 0.09586238861083984, 'Palm Coast': -0.5810728073120117, 'FL': -0.17151927947998047, 'lawyer': -0.519902229309082, 'His': 1.2632627487182617}\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_3 = LLMAttrViz(**attr_result_3)\n", + "print(attr_viz.seq_attr_dict)\n", + "attr_viz_3.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "scheduled-disclaimer", + "metadata": {}, + "source": [ + "One issue we notice from the test results is that there are correlated aspects of the prompt which should be ablated together to ensure that the input remain in distribution, e.g. Palm Coast, FL should be ablated with Seattle, WA. We can accomplish this using a mask as defined below, which will group (city, state) and (name, pronoun)" + ] + }, + { + "cell_type": "code", + "execution_count": 278, + "id": "breathing-sound", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", + " baselines={\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"},\n", + " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "attr_result_4 = llm_attr.attribute(\n", + " inp_feature, \n", + " target=target,\n", + ")\n", + "\n", + "attr_viz_4 = LLMAttrViz(**attr_result_4)\n", + "attr_viz_4.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "french-armstrong", + "metadata": {}, + "source": [ + "We have only chosen one baseline, but ideally, we could define a distribution of baselines so the attribution method will sample from it for perturbations. Here, we define a list of baselines with `IterableBaselines` and specify `num_trials` in `attribute` to average over multiple trials " + ] + }, + { + "cell_type": "code", + "execution_count": 281, + "id": "04338091", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in New York, NY and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2415995115588885e-05 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n" + ] + } + ], + "source": [ + "baselines = IterableBaselines([\n", + " {\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"},\n", + " {\"name\":\"John\", \"city\": \"Boston\", \"state\": \"MA\", \"occupation\":\"engineer\", \"pronoun\":\"His\"},\n", + " {\"name\":\"Martin\", \"city\": \"Menlo Park\", \"state\": \"CA\", \"occupation\":\"teacher\", \"pronoun\":\"His\"},\n", + " {\"name\":\"Rachel\", \"city\": \"New York\", \"state\": \"NY\", \"occupation\":\"plumber\", \"pronoun\":\"Her\"},\n", + "])\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " baselines=baselines,\n", + " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "attr_result_5 = llm_attr.attribute(\n", + " inp_feature, \n", + " target=target,\n", + " num_trials=10,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 282, + "id": "4f861e63", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_5 = LLMAttrViz(**attr_result_5)\n", + "attr_viz_5.plot_seq_attr()\n", + "attr_viz_5.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "6a79b8f3", + "metadata": {}, + "source": [ + "We can also independently define the baseline distribution of each attribute with `ProductBaselines`." + ] + }, + { + "cell_type": "code", + "execution_count": 287, + "id": "dominant-leave", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", + "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + "Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", + "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.841361260332633e-06 ]\n", + "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + "Dave lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", + "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + "Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n" + ] + } + ], + "source": [ + "baselines = ProductBaselines(\n", + " {\n", + " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", + " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", + " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", + " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", + " }\n", + ")\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " baselines=baselines,\n", + " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "attr_result_6 = llm_attr.attribute(\n", + " inp_feature, \n", + " target=target,\n", + " num_trials=10,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 292, + "id": "bd2df29a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_6 = LLMAttrViz(**attr_result_6)\n", + "attr_viz_6.plot_seq_attr()\n", + "attr_viz_6.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "documented-harvard", + "metadata": {}, + "source": [ + "One potential issue with the current approach is using Feature Ablation. If the model learns complex interations between the prompt features, the true importance may not be reflected in the attributio scores. Consider a case where the model predicts a high probability of playing golf if a person is either a lawyer or lives in Palm Coast. By ablating a feature one at a time, the probability may appear to be unchanged when ablating each feature independently, but may drop substantially when perturbing both together.\n", + "\n", + "To address this, we can apply alternate perturbation-based attribution methods available in Captum such as ShapleyValueSampling, KernelShap and Lime, which ablate different subgroups of features and may result in more accurate scores." + ] + }, + { + "cell_type": "code", + "execution_count": 290, + "id": "iraqi-gibson", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sarah lives in Boston, WA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.6855415146419546e-06 ]\n", + "Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "John lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.949759270151844e-06 ]\n", + "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Martin lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.284733586246148e-05 ]\n", + "John lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.2905325042520417e-06 ]\n", + "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Dave lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", + "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + "Rachel lives in Palm Coast, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2611800457307254e-06 ]\n", + "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + } + ], + "source": [ + "from captum.attr import ShapleyValueSampling\n", + "\n", + "svs = ShapleyValueSampling(model) \n", + "baselines = ProductBaselines(\n", + " {\n", + " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", + " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", + " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", + " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", + " }\n", + ")\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " baselines=baselines,\n", + " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "llm_attr = LLMAttribution(svs, tokenizer)\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " baselines=baselines,\n", + " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "\n", + "attr_result_7 = llm_attr.attribute(\n", + " inp_feature, \n", + " target=target,\n", + " num_trials=2,\n", + " n_samples=3 # arg to ShapleyValueSampling.attribute\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 293, + "id": "0690ca18", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_7 = LLMAttrViz(**attr_result_7)\n", + "attr_viz_7.plot_seq_attr()\n", + "attr_viz_7.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "objective-america", + "metadata": {}, + "source": [ + "Let's now consider a more complex example, where we use the LLM as a few-shot learner to classify sample movie reviews as positive or negative. We apply FeatureAblation to measure the relative impact of the few shot examples. Since the prompt changes slightly in the case that no examples are needed, we define a prompt function rather than a format string in this case." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "african-accessory", + "metadata": {}, + "outputs": [], + "source": [ + "def prompt_fn(*examples):\n", + " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\"\n", + " subset = [elem for elem in examples if elem is not None]\n", + " if len(subset) == 0:\n", + " return main_prompt\n", + " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative.\"\n", + " return prefix + \" \".join(subset) + \" \" + main_prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "spread-newark", + "metadata": {}, + "outputs": [], + "source": [ + "input_examples = [\"'The movie was ok, the actors weren't great' Negative\", \"'I loved it, it was an amazing story!' Positive\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "powered-seating", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Here are some examples of movie reviews and classification of whether they were Positive or Negative.'The movie was ok, the actors weren't great' Negative 'I loved it, it was an amazing story!' Positive Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", + "Positive prob 0.9633355209875647\n", + "Here are some examples of movie reviews and classification of whether they were Positive or Negative. 'I loved it, it was an amazing story!' Positive Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", + "Positive prob 0.9553138707461544\n", + "Here are some examples of movie reviews and classification of whether they were Positive or Negative.'The movie was ok, the actors weren't great' Negative Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", + "Positive prob 0.9397858287019841\n" + ] + }, + { + "data": { + "text/plain": [ + "tensor([[0.0080, 0.0235]])" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "llm_attr = LLMAttribution(FeatureAblation, model, tokenizer)\n", + "llm_attr.attribute(prompt_fn, \n", + " inputs=input_examples, \n", + " baselines=[\"\", \"\"], \n", + " target_str=\"Positive\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From cbc16cf90b8bfd8f3cc8cad15945e7600999d970 Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Fri, 4 Aug 2023 01:31:06 -0700 Subject: [PATCH 02/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 216 ++++++++++++++++++++++------- 1 file changed, 165 insertions(+), 51 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index 80cf4b35cd..050815ec49 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -267,10 +267,50 @@ " print(tokenizer.convert_ids_to_tokens(output_ids))" ] }, + { + "cell_type": "code", + "execution_count": 315, + "id": "a34c4461", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INST] Dave lives in Palm Coast, FL and is a lawyer. His personal interests include [/INST] Sure, here are some personal interests that Dave, a lawyer living in Palm Coast, Florida, might have:\n", + "\n", + "1. Golfing: Palm Coast has several golf courses, and Dave might enjoy playing golf in his free time [INST] Anything else? [INST] Sure, here are a few more ideas for Dave's personal interests:\n", + "\n", + "1. Fishing: With its proximity to the Atlantic Ocean and numerous waterways, Palm Coast offers ample opportunities for fishing. Dave might\n", + "['', '▁[', 'INST', ']', '▁Dave', '▁lives', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁F', 'L', '▁and', '▁is', '▁a', '▁lawyer', '.', '▁His', '▁personal', '▁interests', '▁include', '▁[', '/', 'INST', ']', '▁', '▁Sure', ',', '▁here', '▁are', '▁some', '▁personal', '▁interests', '▁that', '▁Dave', ',', '▁a', '▁lawyer', '▁living', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁Florida', ',', '▁might', '▁have', ':', '<0x0A>', '<0x0A>', '1', '.', '▁G', 'olf', 'ing', ':', '▁Pal', 'm', '▁Coast', '▁has', '▁several', '▁golf', '▁courses', ',', '▁and', '▁Dave', '▁might', '▁enjoy', '▁playing', '▁golf', '▁in', '▁his', '▁free', '▁time', '', '', '▁', '▁[', 'INST', ']', '▁An', 'yth', 'ing', '▁else', '?', '▁[', 'INST', ']', '▁', '▁Sure', ',', '▁here', '▁are', '▁a', '▁few', '▁more', '▁ideas', '▁for', '▁Dave', \"'\", 's', '▁personal', '▁interests', ':', '<0x0A>', '<0x0A>', '1', '.', '▁Fish', 'ing', ':', '▁With', '▁its', '▁proxim', 'ity', '▁to', '▁the', '▁Atlantic', '▁Ocean', '▁and', '▁numerous', '▁water', 'ways', ',', '▁Pal', 'm', '▁Coast', '▁offers', '▁am', 'ple', '▁opportun', 'ities', '▁for', '▁fish', 'ing', '.', '▁Dave', '▁might']\n" + ] + } + ], + "source": [ + "eval_prompt = \"[INST] Dave lives in Palm Coast, FL and is a lawyer. His personal interests include [/INST]\"\n", + "\n", + "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + "\n", + "model.eval()\n", + "with torch.no_grad():\n", + " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=50)[0]\n", + " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", + " \n", + " eval_prompt = response + \" [INST] Anything else? [INST]\"\n", + " \n", + " model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + " \n", + " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=50)[0]\n", + " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", + " \n", + " print(response)\n", + " print(tokenizer.convert_ids_to_tokens(output_ids))" + ] + }, { "cell_type": "code", "execution_count": 6, - "id": "01927246", + "id": "e15f4073", "metadata": {}, "outputs": [ { @@ -290,7 +330,7 @@ }, { "cell_type": "markdown", - "id": "2fb6070e", + "id": "b9a7fc24", "metadata": {}, "source": [ "Vizualize" @@ -298,8 +338,8 @@ }, { "cell_type": "code", - "execution_count": 247, - "id": "13bbacd6", + "execution_count": 328, + "id": "7fa408b4", "metadata": {}, "outputs": [], "source": [ @@ -330,6 +370,7 @@ " # Plot the heatmap\n", " data = token_attr.numpy()\n", " \n", + " fig.set_size_inches(data.shape[1], data.shape[0] / 2.5)\n", " im = ax.imshow(\n", " data,\n", " vmax=max_abs_attr_val,\n", @@ -377,11 +418,12 @@ " data = self.seq_attr.cpu().numpy()\n", " \n", " ax.set_xticks(range(data.shape[0]), labels=self.input_tokens)\n", - " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", - " rotation_mode=\"anchor\")\n", + "\n", " ax.tick_params(top=True, bottom=False,\n", " labeltop=True, labelbottom=False)\n", - " \n", + "\n", + " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", + " rotation_mode=\"anchor\")\n", " # Example data\n", " people = ('Tom', 'Dick', 'Harry', 'Slim', 'Jim')\n", "\n", @@ -397,7 +439,7 @@ }, { "cell_type": "markdown", - "id": "1b152e3d", + "id": "7556cec4", "metadata": {}, "source": [ "`SampleBaselines` class define the case that there are multiple possible baselines over certain data distribution" @@ -406,7 +448,7 @@ { "cell_type": "code", "execution_count": 286, - "id": "85edaa91", + "id": "8cc4c5db", "metadata": {}, "outputs": [], "source": [ @@ -478,7 +520,7 @@ }, { "cell_type": "markdown", - "id": "7a447635", + "id": "d9b3a1c7", "metadata": {}, "source": [ "`InterpretableFeature` defines the feature type and tells Captum how to perturb the input data" @@ -487,7 +529,7 @@ { "cell_type": "code", "execution_count": 206, - "id": "2580cf27", + "id": "198eeaef", "metadata": {}, "outputs": [], "source": [ @@ -627,7 +669,7 @@ }, { "cell_type": "code", - "execution_count": 134, + "execution_count": 318, "id": "theoretical-cassette", "metadata": {}, "outputs": [], @@ -639,7 +681,7 @@ " tokenizer, \n", " init_kwargs=None, \n", " attr_kwargs=None, \n", - " max_new_tokens=15,\n", + " max_new_tokens=50,\n", " attr_type: str = \"log_prob\", # or prob\n", " ):\n", " \"\"\"\n", @@ -814,7 +856,7 @@ { "cell_type": "code", "execution_count": 256, - "id": "fecae221", + "id": "bd74ecf5", "metadata": {}, "outputs": [ { @@ -899,7 +941,7 @@ { "cell_type": "code", "execution_count": 222, - "id": "a6457ff6", + "id": "ea9f254a", "metadata": { "scrolled": true }, @@ -922,7 +964,7 @@ }, { "cell_type": "markdown", - "id": "533e607c", + "id": "e1634197", "metadata": {}, "source": [ "Another way to ablate the input text is to directly remove the corresponding tokens, which can also be viewed as replacing them with emptry string. This is also the default baselines for `TextTemplateFeature`. Let's try this, but please note removing tokens is likely to create out-of-distribution text input and therefore may not give you meaningful results." @@ -931,7 +973,7 @@ { "cell_type": "code", "execution_count": 273, - "id": "15cfe4a3", + "id": "e3c417a7", "metadata": {}, "outputs": [ { @@ -967,7 +1009,7 @@ { "cell_type": "code", "execution_count": 274, - "id": "85c744ab", + "id": "560e4dfa", "metadata": {}, "outputs": [ { @@ -1061,7 +1103,7 @@ { "cell_type": "code", "execution_count": 281, - "id": "04338091", + "id": "1065afbf", "metadata": {}, "outputs": [ { @@ -1176,7 +1218,7 @@ { "cell_type": "code", "execution_count": 282, - "id": "4f861e63", + "id": "7d649e75", "metadata": {}, "outputs": [ { @@ -1208,7 +1250,7 @@ }, { "cell_type": "markdown", - "id": "6a79b8f3", + "id": "fabd0e57", "metadata": {}, "source": [ "We can also independently define the baseline distribution of each attribute with `ProductBaselines`." @@ -1334,7 +1376,7 @@ { "cell_type": "code", "execution_count": 292, - "id": "bd2df29a", + "id": "1e4f6af4", "metadata": {}, "outputs": [ { @@ -1468,7 +1510,7 @@ { "cell_type": "code", "execution_count": 293, - "id": "0690ca18", + "id": "6c073aa3", "metadata": {}, "outputs": [ { @@ -1508,66 +1550,138 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 333, "id": "african-accessory", "metadata": {}, "outputs": [], "source": [ "def prompt_fn(*examples):\n", - " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\"\n", + " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", " subset = [elem for elem in examples if elem is not None]\n", " if len(subset) == 0:\n", " return main_prompt\n", - " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative.\"\n", - " return prefix + \" \".join(subset) + \" \" + main_prompt" + " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative:\\n\"\n", + " return \"[INST] \" + prefix + \" \\n\".join(subset) + \"\\n \" + main_prompt + \"[/INST]\"" ] }, { "cell_type": "code", - "execution_count": 79, - "id": "spread-newark", + "execution_count": 334, + "id": "powered-seating", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.48403507471084595 ]\n", + "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n" + ] + } + ], "source": [ - "input_examples = [\"'The movie was ok, the actors weren't great' Negative\", \"'I loved it, it was an amazing story!' Positive\"]" + "llm_attr = LLMAttribution(fa, tokenizer)\n", + "\n", + "input_examples = [\n", + " \"'The movie was ok, the actors weren't great' Negative\", \n", + " \"'I loved it, it was an amazing story!' Positive\",\n", + " \"'Total waste of time!!' Negative\", \n", + " \"'Won't recommend' Negative\",\n", + "]\n", + "inp_feature = TextTemplateFeature(\n", + " prompt_fn, \n", + " inputs=input_examples,\n", + ")\n", + "\n", + "attr_result_8 = llm_attr.attribute(\n", + " inp_feature, \n", + "# target=\"Positive\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 80, - "id": "powered-seating", + "execution_count": 335, + "id": "37df2834", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Here are some examples of movie reviews and classification of whether they were Positive or Negative.'The movie was ok, the actors weren't great' Negative 'I loved it, it was an amazing story!' Positive Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", - "Positive prob 0.9633355209875647\n", - "Here are some examples of movie reviews and classification of whether they were Positive or Negative. 'I loved it, it was an amazing story!' Positive Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", - "Positive prob 0.9553138707461544\n", - "Here are some examples of movie reviews and classification of whether they were Positive or Negative.'The movie was ok, the actors weren't great' Negative Decide if the following movie review enclosed in quotes is Positive or Negative. Output only either Positive or Negative. 'I really liked the Avengers, it had a captivating plot!'\n", - "Positive prob 0.9397858287019841\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAokAAAGACAYAAADBMPh0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADaVUlEQVR4nOzdZUBUW9cH8P+hQQlBxUCkFATFAAQFQSzE7m5sxbwGdqAX69pY2F0gFjYGdoAYSCMhKEhKz8x6P/DOkQG88agw6P598c6Zc457z8x11uy919ocEREYhmEYhmEYphiZim4AwzAMwzAMI31YkMgwDMMwDMOUwoJEhmEYhmEYphQWJDIMwzAMwzClsCCRYRiGYRiGKYUFiQzDMAzDMEwpLEhkGIZhGIZhSmFBIsMwDMMwDFMKCxIZhmEYhmGYUliQyDAMwzAMw5TyQ4LE+Ph4vHnzhn8sEonAdvtjGIZhGIapvH5IkOjp6Qk3NzdERkYiMzMTMjIy4DgOQqHwR9yeYRiGYRiGKWffHSQ+fPgQ0dHRaN++PapVqwZzc3MMGTIEAoEAsrKyAIpGFhmGYRiGYZjK47uDxAMHDgAAOnfuDE1NTZw4cQKJiYlQU1PDzp07i/4SGRkQEZuCZhiGYRiGqSQ4+s7ILTIyEuHh4ejcubPE8SVLlsDd3R1NmjTB+vXr0bFjRwBFo4oyMixfhmEYhmEYRpp9V7RGRDA0NOQDRIFAAABIS0sDEaFJkyZwcHBA7969YWdnh+TkZMjIyCAvL+/7W84wDMMwDMP8NN8VJHIcJ/FYTk4OAODv748LFy5g8ODB2LJlC969ewddXV2sWbMGb9++RZMmTeDn5/c9fzXDMAzDMAzzE333dLMYEYHjOLx//x6LFy9GZGQkbt68CSUlJf6c1NRUeHl5YfHixfj06RPU1dV/xF/NMAzDMAzD/GA/bHGgeFTxypUrePr0KVxdXaGkpMRPQQNAXFwc3N3dsW7dOqirqyM/P58lszAMwzAMw0ihHxIkigO9oKAgnD9/Ho0aNcKgQYMAgC+Dk5WVhR07dqB69eoYPHgwMjMzoaioCI7jWKDIMAzDMAwjZb47SBRPM+fn58PPzw+RkZGYP38+gKJEFvEI44MHD3D48GEUFBRg5cqVqFevHtasWQOg9NpGhmEYhmEYpmLJfe8NxAHerVu3cPToUTg7O6Nly5YgIj6R5fPnz1i+fDmsra2xdu1aNG7cGA4ODpg6dSo6dOgACwuL720GwzAMwzAM8wN9d5Aopq+vDyMjI8yePRtAUT1EWVlZEBHOnDmDp0+fIiQkBEZGRgCAFi1aQFlZGQ8ePCgzSBQKhfxUNcMwDMMwDFO+fliQaGJignPnzgGQDPDev3+PVatWYfr06TAyMuKLaaenp+P9+/cwNzfn7/H582ckJydDT0+Pz4pmxbcZhmEYhmHK3w8rgVPWyF9hYSGmTZsGHx8fvH//HoqKigCK1ir27dsXSUlJePz4MdLT07F7925s374d9evXR2hoKObMmYM//vjjRzSNYRiGYRiG+Y9+2EhiWVPDQqEQMTExWLx4MRQVFfkkl4sXL+LixYvw9/cHACxYsAB3797Fpk2b4OTkhPPnz8Pd3R0cx/HT1wzDMAzDMEz5+WEjif9WRkYGHB0d0ahRIxw9ehSPHj1C69atUbVqVdjb28PT0xO6urpYv349Ll++jOvXr7O1iQzDMAzDMOXspy72EwqFpY7t3bsXQUFB8PDwAAAcPHgQ7dq1w5UrV6ChoQEzMzPMnj0bhoaGyM3NxYcPH755f1ZfkWEYhmEY5uf4qUFiWSOAI0aMwLlz51CvXj0AgKamJrKzs9G6dWscOXIEly5dwrNnz9C3b18UFhby54mJRCL+v1khboZhGIZhmJ+jXNOGiQjVq1dHjx49+GPm5ubIy8tDdHQ0AMDe3h537tzB4cOHcfjwYQCSI5LiTOctW7YgPDycr9MoFApZwMgwDMMwDPODlPuaxJI+ffqEAQMGIC8vD+vXr0fDhg2hqqoKZWXlUueKE19u3bqFKVOmoFGjRhg7diwsLS1Rs2bNCmg9wzAMwzDMr6nCCxDWrFkTt27dgoWFBfr164epU6diw4YNEtPKwNcAMSsrC0eOHEFcXByys7Ph6+uLWrVqYceOHfx5QNnrIRmGYRiGYZh/p8JHEovXV0xISEBAQACaNm0KExMTPjAsbt++fdi2bRu6du2KlStXAgBWrVqFCxcu4OHDh8jJyUGVKlUAsELcDMMwDMMw/6sfVifxfyXeuk8kEqFu3boYOHAg/5w4QBQHe9HR0bhw4QL09fUxc+ZM/jwlJSU8efIES5cuRWxsLKKjo7F582Y0a9asvLvDMAzDMAzzS5CKYTaO4/hgsSzi0cBTp04hKSkJAwcOhKamJgAgKysLly5dgrGxMYyNjTF9+nTo6+tj7NixiI+PL7c+MAzDMAzD/EoqfCSxuJJTy8U9fPgQp06dQosWLTBgwAD+uKenJ3JycjB//nwMHToUADBv3jw0b94c8fHx0NHRKTVtXdYWggzDMAzDMMxXUjGS+G8YGRnB0dERw4YN449FRETAx8cHFhYW6NmzJ3/8/v37UFNTg4GBAYCi4LOwsBBxcXEAiqa4SybGMAzDMAzDMF9VeOLK95g4cSIiIiLg5uaG9u3bAwCys7NhZWWFdu3aYePGjSgsLMSuXbtw7NgxZGZmonbt2ti1axeMjY0ruPUMwzAMwzDSq9KMJJYc+YuLi0NQUBCaNm0KR0dH/vjKlSshIyODoUOHQiQSwd3dHStWrICTkxM2btwIExMTdO3aFc+ePZO4HyuZwzAMwzAM85VUrUn8OyVL2dSrVw+3bt1Camoq/1xYWBhOnjyJMWPGwMbGBt7e3rh9+zbmzJmDBQsWAADs7OxgY2ODJ0+ewNLSEnl5eVBSUmJrFBmGYRiGYYqpNCOJJQmFQqioqEBHR4c/NnXqVNSoUQPdunUDx3G4ffs2OI7D5MmTAQACgYBfq/j06VMAwJs3b2Bra4vU1FS2rR/DMAzDMMz/qzQjiSWVNfI3bdo0ZGZmokmTJgCAx48fo1WrVtDQ0IBAIICcnBxyc3Nx69YtbNmyhT8nMjKSL6lTnPiagoIC5OXlQU1N7ed2imEYhmEYRkpU2pHEsnTr1g1DhgyBnJwcBAIBzMzM8PHjRwCAnFxRPDx79mzUqVMHzs7OEIlEiI2NhYODAzIyMvh1iV++fJG4JjY2FhYWFvD29q6AXjEMwzAMw5S/SjuS+E/k5OTQq1cvjB07FitWrECjRo1w7do17N27F2fPnoW2tjZkZGQQFhYGRUVFqKur89fOnTsXISEh2Lt3LwwMDGBkZIRTp06xHVwYhmEYhvlt/LJBIgD07NkTqqqqmD17Ns6cOQNdXV3s3bsXvXv3BgDk5ubi0aNH2LRpEwAgOjoaHh4euHTpEmbPng0DAwM8efIE8vLyaN68OVuzyDAMwzDMb+OXDRLFAV27du0QGBiI9+/fo379+hLnBAUFQVdXF3Xr1kVsbCxmzpyJ0NBQHDt2DPb29vj48SNmz56N9PR0vHr1SmLXFvF+0r+bhIQEpKenw8zMrKKbwjAMwzDMT/TLRjkcx4HjOH6doThAJCK+5qKcnByioqKQmJiIfv36IS8vD9u3b4e9vT3y8/Nx+fJlvH37Fjt27Ch1f3GA+LvVV9y+fTsWLFiAN2/eSBxno6wMwzAM82v5ZUcSxUpmQYuDRwDw8/NDSkoK9u7dC2VlZZw/fx4KCgoAimouenp6omPHjrCzs0NeXh5CQkJw8eJFfPz4EW3atMHAgQN/q/qKDx8+RHR0NBwdHWFqagoAuHDhArp27fpbjqoyDMMwzK/st/5md3Z2RsOGDWFnZ4eDBw/yAeKXL19w7tw5REVFYePGjQCABQsWwM3NDXfv3oWqqiqmTp2K7t27IyUlpSK7UK4OHDgAAOjYsSM4jsOtW7cwefJkrF27tmIbxjAMwzDMD1ep927+UYRCocSI4IMHDzB06FAMGzYMK1euxP3799GmTRvY2trCx8cH1atXR1paGrp164aJEydi+PDhFdj68hMZGYnQ0FB06dIFADBo0CDk5ORgyZIlsLS0BBFJrNtkGIZhGKby+q1HEgUCAQDJKenk5GRs3rwZ8vLyWLlyJQDAzc0NrVq1gpKSEho2bIg///wT1apVQ/PmzfHo0SMIhcJffk0eEcHQ0BDOzs4AgEOHDiEsLAwdOnSApaUlAPABovi1yMzMRFZWVsU0mGEYhmGY7/JbB4niYtnFKSsrQyAQYNGiRQCAjx8/guM49O/fH9evX4eXlxcOHToEExMT3Lp1C9nZ2ZCVlf3mCJo4SaayEycBcRyH9PR0HDx4EKampujVqxcAycQV8Wtx8uRJtG7dGs+fP6+IJjMMwzAM8x1+6yCxLFWrVsXZs2cxYsQIAICmpiZycnLw9u1bAECfPn3w/PlzjBkzBp8/f4arqyuA0sFgZGQkYmJifqmEDnFftm/fji9fvqB79+7Q1dUFUHoUMSwsDLdu3YKmpiYsLCwqpsEMwzAMw/zPfp0I5gcpWdJGXl4erq6uCAkJwYsXLwAAKioqmDt3LkJDQ2FhYQEiKlUSZ+7cuRgyZMg/3r+yEIlE4DgOISEhOH/+PGxsbPi1iSVHEYkIly9fRmBgINzc3ABU3n4zDMMwzO+KBYkllFXSpm/fvtDX14e9vT2mT5+O48ePIzAwEBoaGgAgMdUsKyuLtLQ0REZGYuTIkfzxly9ffvP+lUHxUcQqVaqgV69eUFVVlUhWEQeLjx8/xoULF2BtbY3OnTsD+PoasWCRYRiGYSoHFiT+AyJClSpVcOjQIdy4cQMJCQm4ffs2cnNzv3nNs2fPoK6ujoYNG6KgoADnzp1D8+bNMW7cOOTn5/PnVbb1ileuXMGFCxfQrl07ODo6ApCcZuY4DllZWTh//jySkpIwb948/lpxACkOklmwyDAMwzDS7Zcvpv29OI7jgzkbGxucOXMGKSkpqF69eqlzxYFSXFwcX3B7+/btePfuHQCgSpUqUFRUhEgkQkFBAZSUlMq1L9+rWbNmGDt2LLp37w4AEqOI4j9v376Na9euoWfPnjA1NUVGRgb8/Pxw+fJlfP78GaNGjUL//v0r7YgqwzAMw/wu2EjivyAjIwMZGRl+9KusALG4gwcPolevXrh69SrOnDkDMzMzaGlp8ckwp06dQp8+feDr6ytxnbSPrtWqVQuLFy9G06ZNAZROVklISMD58+chIyPDjyKOGjUKS5cuRXJyMlq0aIGJEydi3LhxKCgoqJhOMAzDMAzzr7Ag8T/4u9Ev8ahaeHg4YmJiIBAIMHr0aMydOxfq6upwdnaGsbExgoODsWrVKmhra6Nx48YAgA8fPvD3F4lEUjsN/a1akOJg8caNG3jw4AHGjRsHdXV1HD16FJcuXcLGjRtx4cIFrFy5EsePH8fDhw8RFhZWnk1nGIZhGOY/YkHiDyIOlF68eIG4uDjcuHEDM2bMQPfu3ZGeno6qVavi5cuX6NevH8zNzbFixQoYGhoiPj4ekydPRrdu3fDw4UN+1FIa/d1uKq9evcL+/fuhp6eHcePGAQCWLFmC8ePHo1OnTnxNymbNmiE0NBSfP38GAGzYsAHe3t4/v/EMwzAMw/wn0hmNVGL16tWDjo4Opk6diunTpwMA7t27hzdv3uDAgQPQ0tLC0aNHUa9ePQBAYWEhhg0bBjMzM3Tq1AkLFizgd4KpTGrXro369etjxowZAICgoCAAQNeuXSEnJ8ePQgYEBMDU1JRP/ImIiMCBAwfw5cuXUveU1hFVhmEYhvkdsMSVH6x169b8dLOCggJCQ0Nx9uxZGBoaolGjRvD09ARQtP4wMzMTsrKy6NevH/r164cOHTpg9uzZGDFiBExMTCTuKxKJpHaEEShap3nw4EH+sY6ODoRCIWJiYgAUjUJ++vQJN2/ehIaGBr+u8d27dzA1NUXVqlVL9VGa+8swDMMwvzr2LfyDCYVCyMjIQEFBAQAQEhICIoKZmRlcXV3RvHlzFBYWYu/evWjZsiX69++P5s2b4/Lly2jatCmysrKQkJBQ6r4yMjJSvV6xZNKNmpoa2rVrB19fX4SEhCAsLAzz5s3Dw4cPMXToUNSuXRvR0dGIjIxE165dART1sbCwEMuXL8fq1asrohsMwzAMw/w/NpL4g5VMbunVqxf8/f1haWmJKlWqAADu37+P/fv3o02bNpg4cSL8/f0xZswYaGhooEaNGigsLAQAhIeH49q1awgNDcW4cePQpEkTAJKlZ6RFyX4rKChg3bp1GDlyJGxsbKCjo4OsrCysW7cOAwYMAAAkJiaiRo0a/IhhUlIS3N3dcejQIaxatQr5+flQVFTk70lEErvbMAzDMAzz83D0rZRV5ruVDObE06kPHz6Es7Mz7ty5w0+73r17Fy4uLmjUqBHOnz8PAKhbty60tbWhq6uLGzduYNiwYdi8ebNE4CStik8dv3r1CgUFBahXrx5q1qzJn3Pp0iUMGzYMHz9+RH5+PpycnKCgoICxY8di2LBhyMvLQ0JCAoKDg6Gnp4fmzZuXujfDMAzDMD8HG0n8iUqO9okDmxo1aqBOnTrYvn073NzckJKSAi8vLwiFQkyaNAlA0dZ2AoEAJ06cQMOGDfHy5UtMnDgRx48fx6hRo8q7K/+ZuK6kjIwMPwJa0oULF9CvXz/cuXMHGzduREpKCq5fv4769etDJBJhwIABiImJgYqKCiIiImBvbw8vLy9oamqWc28YhmEY5vfDRhIryKtXrzBmzBhUr14dX758wf379zF+/Hjs3LkTAJCamgpnZ2eoqalh165dMDAwwOPHj1G3bl3o6OhUcOu/X15eHqZPn45Hjx7h/fv3GDhwICZNmoRmzZrh48eP2Lp1K1avXo0PHz6gVq1aeP/+PVxcXGBpaQkPD4+Kbj7DMAzD/PLYnF0FEIlEaNKkCZ4+fYpNmzahX79+0NDQwMyZMwEAGRkZ0NTUxKFDh6ClpcUHjtbW1qhbt+7f3ruyxPwKCgpQUVHBq1evMGLECGzbtg3NmjUDAMTExMDT0xO1atWCnZ0d9u/fj/r162PRokXYt28fUlJSSt1PKBTyST1paWnl2RWGYRiG+SWxkcQKIhQKJZI9/P394ejoiGfPnuH06dNYsGAB1NTUcPfuXfTq1Qvu7u6YMmVKqft8a31eyftLq3fv3qFBgwaQlZWFQCCAnJwcVq1aBS8vL0RHR2Pbtm34888/YWxsDAsLCzx//hwXL16EiooKcnNzERERAWVlZRgZGQEAPn36hD/++AMCgQDHjh2r4N4xDMMwTOXFRhIriDiAE49+OTo6AgCSk5Ph7e2NP//8E4WFhWjTpg0aNWqE5OTkMu8jDhDPnTuHdevW4fDhwxL3B6RzdFEoFIKIYGJiwrdVvCtLTk4OtLW1kZeXh6lTpyIwMBBmZmbw8vKCoqIilJSUcPPmTTg7O6Nnz55o0qQJRo0ahdzcXDx79gxXrlyBg4MDAOnsO8MwDMNUBmwkUQo9efIELi4uyM7ORvXq1ZGZmYmFCxdi+PDh/DnizOlXr17Bw8MDp0+fRps2bRAeHg5NTU2cPHkSxsbG/Ijix48fsW3bNgwdOrRUoW5p8+zZM4waNQpeXl6wsbHhj7958wZVqlRBeno6RowYgfr162PWrFlQU1ODu7s72rZti0ePHiEuLg4BAQEV2AOGYRiGqfxYdrMUEcfrLVu2xKtXr3Du3Dmkp6ejdevW0NfXlziH4zhkZmZiz549CAwMxP3799GiRQsIhUJ069YNXl5eWLduHT9K5+3tjdOnT6NmzZpSHSQSERo1aoTWrVuje/fuWLhwIezs7FCjRg2YmZkBAJydnWFiYoJly5bB1NQUANC3b18sWLAAnz9/xs2bNwGUPeUujTUmGYZhGEYaselmKcJxHDiO43cv6dWrF0aNGoWGDRvyU7Hic4CifZCfPn0KFxcXWFlZgeM4KCgowMLCAvfv38fnz58BFO36cunSJVhaWmLs2LEApHcaluM4VKlSBbt378a2bduwb98+/PHHH7hy5QpycnLw8OFDJCYmonPnznyACBQlwsTHx8PFxQU2NjYgojLXZG7fvh1t27blC5YzDMMwDFM2NpIohcTBTfFRr7KKcicmJiI+Ph6TJ08GABQUFEBJSQny8vL4/PkztLS0AADHjh3D58+fMXHiRCgrK/MJItJalFo8Ajhw4EAMHDgQjx8/hp6eHlRUVKCmpob379/zRciBomzmJ0+eQFNTE0uXLgXw7RHDUaNGQVdXF/Ly8vwxaX0dGIZhGKYisW9GKfataVFxQPP+/XsoKytDWVkZIpEISkpKKCgogKenJ4YNGwYAuH79Ou7duwcLCwt069YNwNcEEWkNjMRBsnhE1draGtra2gCKXhN1dXWJMjjXrl3DsWPHMHPmTGhpafFFvEsKCAhA1apV0aNHDwDgk4Gk9XVgGIZhmIrEvh0rsV69ekFGRgbXrl2DjIwMoqOjMWrUKKipqcHFxQUFBQXw9vYGx3EYO3YscnNzcfr0afz5558YO3Ys8vLyKroLf6us6WIDAwM4ODhgyJAh2LBhA1xdXTF58mRUq1YNCxcuBFB20Pfs2TPY29vDz8+PPzZu3Dj069fv53WAYRiGYSoxNt1ciTVr1gzdu3dH9+7dYW9vj7CwMABF08t16tTB8ePHERwcjBcvXmDt2rW4ePEijIyMYGVlBW1tbURERKBx48YV3Iv/RklJCQcPHsThw4cREBCArKwspKWl8TURxVPpJS1cuBDt27dHp06dcPv2bUyePBnh4eF48uQJAKCwsFBiCpphGIZhfnesBM4vICQkBGfOnIGpqSmMjY3RuHFjxMfHY9asWUhPT8fz588xePBguLq6wsjIqFIU2f6WkhnLvr6+2LJlC5/RXJYzZ85g0KBBuHfvHlq1aoWoqCiYmpryI6ybN29mU84MwzAMUwILEisxkUj0zSzeNWvWwNfXF/PmzUN0dDRu3bqF8+fP88//m1IwJc+RpvIxxZNNxIFjWSVvcnNz0aRJE7Rr1w67d+8GEWHXrl2YNm0azpw5g5UrV0JeXh6nT5/+xy0PGYZhGOZ3woZPKjEZGRnIysryu7aIpaSk4MGDB6hWrRqcnZ3RsGFDvHnzBunp6fw5/yXYu3DhAgoKCqQmQASK+k5EEkFyWcHypk2bkJaWhgULFgAAoqOj4e7ujunTp6NHjx54+vQpPD09WYDIMAzDMCWwkcRfVE5ODmJjY2FiYoLY2FhYWVnB19dXYgeTbxGPGKampiI+Ph59+vTBkCFDsGjRIigoKJRD63+MmJgYmJiYYPXq1Zg1axYEAgHmzp2Lo0ePIi4uDgoKCv96dPTvRisZhmEY5lfERhJ/QSKRCCoqKvzOKrq6ujA2NsalS5cAfC2kXXIEUkwcNG3atAnt27eHhoYGhg0bBgUFBb4szfPnz3Hv3r2f3ZXv8vTpU+jr62PUqFEAikoG7dy5E+vXr+f78m9HR8WBoaOjI3bu3PmzmswwDMMwUoMFib+g4kkY4oBw9uzZ+PTpE/Lz8/nA6FvJGuLg0dzcHLKysnj79i1cXFwQGRkJWVlZZGRkYOLEiZg5c+ZP7sn36d+/P168eAFNTU0ARUkuqqqqGD58+DfXcn6L+HVctmwZmjRpUuo4wzAMw/xqWJD4ixMHhD179sSuXbugqKiInTt3YtmyZWWeT0SQkZFBTk4O9u7diw4dOuDOnTvQ1tbGokWLIBKJcP78ebx69QoHDhzgr5E2RASRSARlZWX+mI6ODtTU1ODj4/OvRxCL75UdGhqKdu3awdbWFgCQmpoqVes0GYZhGOZHYkHib0QoFOLYsWNYsGABEhMT/7aY9q5du5CSkoIOHTrAysoKZ86cwf79+5GYmIgVK1bAxcWFr7EoDsikCcdxpUZKBwwYgLFjx2LkyJHYtm2bxHPfCnTF0+tubm4wNzfHx48f+ecMDQ3h7e39g1vOMAzDMNKBBYm/kYyMDMTHx2Pp0qXYtWsXlJSUJJ4XiUTgOA4xMTE4c+YMLCws+C3sgKJ1ecePH0dkZCQaN24MV1dX3L59GzIyMlJfZ1AcBM6bNw8fPnxA9+7dIRQKcf36dQBlZ3uLRCLIyckhIyMDW7duxaJFi6CtrY2FCxeiWbNmUFZWRq9evfhzGYZhGOZXIt3f7MwPpampiblz52Lq1KkASgc24kDv8OHD4DgOffv2haamJh9ghYSE4M8//4SNjQ2ys7OhpaWFbt26YcuWLeXbkf8Bx3EgIhQWFqJq1aqoW7cu9u3bBycnJ4n6kWWZPHky9PT0MHToUABFiUDBwcEoKCiAr68vALb/M8MwDPPrYdvy/UbE5V7ECRvfCmwKCgogLy+Pjh07AigKsHJzc7F27VrUqFED/v7+UFRUBADEx8fj3r17mDJlCmRkZCRG5IoXvJYGHMfxW+9t374dfn5+cHd3lxgtFROXunnx4gWOHz+OI0eOoH79+gCAa9euwdraGj179sSoUaNw48YNbN26Var6yjAMwzDfiwWJv5F/m2RhYGCAHTt2YMOGDZg9ezYA4O7duzh+/DguX77MB4gAoK6ujvv374PjuFL3l5GR4UcrpS2Amj59OoYNGwYtLS0ApQNacSA9fvx4ODs7o2PHjpCVlYWfnx/OnTuH69evo127dpg8eTJCQ0P54t7SHCQzDMMwzH/BimkzZbp48SJGjRqFCxcuwMTEBL169YKamhouXLjAn5OQkAALCwtMnjwZS5YsQXJyMp48eYIXL14gPj4e48ePh4WFRQX2omz/VEBbHNx5eXlh2rRpuHz5Mtq2bQsigrm5OczNzXH48OEyA0BWbJthGIb5VbCRREaCOHmlW7duSElJAQDs378f9+7dQ3h4uMS5f/31FziOw9y5cwEAY8aMQX5+PmrUqAFlZWXY29tj+vTpWLFiBeTkpOej9k8jquLgz9fXF/3790fTpk0BAHv27EFsbCy8vb2/OUIoDhAnT56M2bNnw9DQkH9Omva+Lg/x8fHIyMiAmZkZgK+frd/pNWAYhqnM2FwYI0G8rlAgEPDHBg8eDG9vbxgaGvLTx8HBwdi+fTtWrFgBJSUleHh44NKlSzAwMMDRo0fh5eWFa9euwc/PD+/evauo7nyXCxcuYMuWLahWrRoAwMvLCz179kSDBg3+tjZkYGAgHj16hICAAInj4uSZ34Wnpyfc3NwQGRmJzMxM/rMlLivEMAzDSDcWJDJlEo/8ERGUlJT4Ui8yMjIQCASYNWsWWrRogXHjxiE9PR0bNmzAgAEDcO/ePTRo0ADnz59H69atUbVqVbx48aICe/K/EQfJ6urqAIC8vDzY2dkhKioKnz9//tvRsOTkZOTm5vIjaLdv38b27dsB/Pt1oZXdw4cPER0djfbt26NatWowNzfHkCFDIBAI+NFWVjaIYRhGurEgkflbZQU1qampiIuLg7u7OwAgIiIC2tramDJlCt68eYNx48bBxcUFdnZ2CA0N/cdgQBpH10pOjyspKcHNzQ1KSkpo0qQJnj17Vuoa8QjZ2bNnUb16dVhaWiIxMREuLi5wdXUtVWrnVw6SxLvxdO7cGZqamjhx4gQSExOhpqbG730tTvaRxvefYRiGYYkrzA8QExMDMzMz7N27F4MGDQJQlNSyZMkS3Lt3D2FhYf/qPtKc9FF8PeGzZ89gZmYmseWfWGZmJiwtLbFkyRKYm5tj+fLlePDgAaysrLBt2zbo6uoCAN68ecOPNP6KIiMjER4ejs6dO0scX7JkCdzd3dGkSROsX7+eL7PEMsEZhmGkD/tXmfnPiq9XBID69etj7Nix8PHxwefPnwEAdevWxd69e/H48WMAKHMdWkhICNzd3flRJ2kNEAHwa+mICJaWlmUGiEDR1LKFhQXCwsKwZcsWaGhoYMWKFdDR0UHVqlWRkJCAIUOGoE2bNsjKypK49ldZq0dEMDQ05ANE8eclLS0NRIQmTZrAwcEBvXv3hr29PZKSkliAyDAMI4XYv8zMf1ZyKpbjOEydOhUxMTFo2rQp1qxZg6NHjyIxMZFP+igZAAoEAmRkZKCwsBAeHh4wMzPDo0ePyq0P/wtZWdlvrikUD8inp6fj7du3/KjhmjVrEBERASUlJSgrK2P58uUIDQ3F5cuXoaqqiujoaNy9e5e/P1D5p6FLvkbiz4u/vz8uXLiAwYMHY8uWLQgNDUWdOnWwbt26UgEzwzAMU/HYdDPz3YpPxR45cgQnT56EiYkJ/vjjD2hra5d5HiA5xThu3DjExsbi3Llz3xylqwycnZ1x9epVDBkyBEeOHEFOTg50dHRw+/ZtbNq0CVFRUXB1dUXfvn2Rm5uLffv24fz584iKisKqVaswYMCAiu7CDyV+z9+/f4/FixcjIiICt27dktg3XHyOQCCoFPuAMwzD/C5YkMj8ECXXE6ampvL7PosDQ/E5Z86cwZ07d5CQkIDmzZtj8eLF+PLlC+rVqwc/Pz/Y2NiUCiileb1icdevX4efnx/c3NxQo0YNnDhxAn/99RdatGiBI0eOwN/fHy1atOD7kp2djfz8fBw9ehTr16/H1KlTMWfOnAruxY+3a9cubNq0CQsWLMDw4cMRGRmJa9eu4fbt28jPz4ebmxusra3LvPZ3Wa+YkJCA9PT0X3qtKsMwlcuv/y8vUy5KTpVqamoC+Dr1SESQlZVFYmIixo0bh5iYGJibm8PPzw96enpYunQpAEBPT0/iuszMTP7+IpGo1FSstP3G6dixI/766y/UqFEDBQUFiIyMxLNnz3Dr1i2cOnUKVlZWkJWVRWRkJPz8/ODt7Q0lJSW4urpi5MiR8Pf3R2FhYal+Vcb1iuI+BAUF4fz58zAxMcHw4cMBAH379sW2bdugpKQEHR0dtGvXDhs2bCh1j9zc3N8iQASK9hOfN28e3r9/X+mXHDAM82uQnm0wmF/Ct77QxUGfr68vVFRUsG7dOpiYmGDx4sU4dOgQXFxcMHLkSFSpUgVA0Yjczp07kZ6eDhkZGSxduhR2dnb8/cQjjdJWd7D4qJeCggKUlZVRp04dLF++HF26dAEAREdHo23btlBWVoampiYWLFiAuXPnwtbWFl5eXkhLS0PNmjUBFCV7VKtWjQ/CK8uIqvj9yc/Ph5+fHyIjI7F3714AwMyZM5GSkoLz58+jRYsWAIAGDRrgzJkzGD58ON/38PBwNGvWDC9evICxsXGF9aU8iOtKdurUCfXr18f27duRk5ODOXPm/HY79TAMIz1+j5/ojNQQj6QV3+IvLS0NtWvXRp8+faCqqorjx4+jT58+yM/PR4cOHdCsWTN07twZCxcu5DNlAwMDsXDhQuTk5EjVaGLJIHnWrFl49eoV+vXrxx/bt28fhEIh7t+/D19fX6xduxY7d+6Es7Mz7OzsULNmTSQkJGDp0qUYMGAAWrVqxe+ZXRkCRODrj4Jbt27h6NGjcHJygq2tLVJTU7Fjxw4sW7YMzZs3589v1KgRnj17xl/XpUsXdO3aFW3atIGxsTFEIpFUvc8/mjjDv3379gCABw8eYN++fQBKJwL9yq8DwzDShY0kMuWqRYsWGDhwIPr27YvRo0fjxYsXCA4OxtixY+Ho6IiIiAjs3LkTHTp0gI+PD39dx44d8eDBA8TExODdu3e4e/cuNm7ciIULF0rtKIt4r2JxhrcYEUFfXx+ampqQlZXF4MGDkZmZiVmzZmH+/PkAgKNHj+L8+fPo1asXFBQUMGLECPTo0QPbtm2DqqpqRXTnf6Kvrw8jIyN+naW/vz/q1asHW1tbifctODgYjRs3RnJyMmrUqIGqVasiJiYGcnJyePXqFZo0aVJRXSgXc+fORWhoKL8e0c/PDytWrADwdXQ6KysLqqqqUvt5Zxjm18OCRKZccRyHdevWYeLEifj06RPCwsJgYmKCAQMGoGrVqggKCkJwcDAePHgA4Ov0atu2bVGvXj3UrFkTgwYNwosXLzB69GioqKhUcI++7VtT7126dIGnpycGDhyIYcOG4cqVKzhx4gRGjRrFT7+qq6sjOzsbc+fOhbKyMjp37oyDBw8iMjISzZo1K8defB8TExOcO3eOf6yvr4/k5GSkpqbyx4KCgvD48WPo6+vD1NQUeXl5ePr0KUaPHg1ZWVm+EPnYsWP5ayrLtPu/Ia4raWhoCKDoB4KGhgbMzc0BFH2OXrx4gREjRsDe3h6bN2+GvLx8RTaZYZjfBJtuZsqVSCSCUCiEoaEhWrVqBXd3d0yfPh0WFhYAgMePH8PIyAiNGjXik12AovV9jRo1gkAggJGREXR1deHt7Q1zc3PExMRUYI/+u9atWyMkJATKysoICQmBt7c3ateujXnz5vHndO/eHZqampgwYQKioqLQrFkzuLi4VLrM15IJNzo6OmjRogUOHjyI2NhYPHv2DAsXLkRsbCwmTZoEAFi5ciWys7OxZMkSeHp64s2bN3BycgJQNOIIFE27E9EvkeDBcRw/hSwUChEWFoYaNWqgdu3aAAAfHx/s2bMHsbGxCAoKKrPPbAqaYZifghhGihw6dIgMDAwoIiKi1HMCgYAOHTpEqqqq9PDhQyIiWrlyJZ0/f77UuYWFhT+9rf8rgUDA/3d+fj516NCB3N3diYgoMDCQ4uLiiIjozp071LNnT1qyZMl/urdIJPqxDf7BXr16Rc2aNaNatWpR/fr1qVWrVnTp0iUiIoqOjiZlZWXavHmzxDV5eXl0/vx5cnZ2JgsLC7p8+XJFNP2nEgqFRETUtm1bGjhwIBERxcfHk4GBAe3du5fq1q1L69evlzg/ISGhQtrKMMzvgQWJTIUqGdBERkZS06ZNafz48ZSYmEgZGRn8c+/evaPWrVtTnz59St0nMjKSzp49SydOnPjpbf4RxAGBmEAgoMLCQpoxYwZt2LCBP37o0CHS1NSkgICAb94rNzeXXrx4QZ8/f5a4nzQq/n7fv3+fXr16RV++fOGPDRkyhCwsLCgrK6vUNWlpafTq1StavXo1Va9enZYvX86fI/5RsH37dho0aBDl5+f/7K78UOI+JiQkEMdx5O/vT+Hh4WRvb0/jxo2j58+fk42NDb19+5a/xtfXl+rXr0+zZs2qqGYzDPOLY9PNTIUquQjfwMAAx44dQ1BQEKysrLBr1y5ERUVBIBDgwoULCAkJwV9//SVxze7du9GmTRvMmTMHixYtQv369XHv3r3y7MZ/Jl6vKM7WlpWVhZycHCwtLbFhwwYMHz4cr169Qm5uLgQCQan9sot79uwZ9u3bhxYtWvBT1tK6Xk+8BzZQNO3euHFjvuxRamoqfH19MX78eFStWhUFBQUAgOTkZLx+/RpPnz6FmZkZ3NzcsHLlSly/fh1paWkQiUT81n+LFy9GlSpV/vb1kkbi/w8OHDiAjh07IjQ0FKtWrYKOjg48PT2RkJAAfX19/nMTEBCAJUuWoGHDhpgxYwaAyllLk2EYKVfRUSrDFFd8hO3mzZt09+5dKigooOzsbDIwMKAZM2bw54lEIrpy5QopKiqSh4cHhYWFkVAopAkTJpCTkxMVFBRI3FtaR9dKio6OJicnJzI0NCQ7OzsaOnRoqXOKj8jl5+dTcnIy+fn5kZWVFbVv356Sk5PLs8k/RHJyMjk5OdHIkSMljtvb21ODBg2oRYsWZGBgQCdOnKDw8HBSUFCgpKQk/rzZs2dTvXr1JEbbKpPs7GxydXUlR0dHqlOnDi1atIhevnxJREQLFy6kAQMGEBFRWFgY6ejoUPfu3enJkydEJPn/TWX5nDMMI/1YkMhInbK+5BISEkhPT49fuyYSiSg3N5ecnJzI0dFR4twHDx6QmpoaPX78mIiKpiKLB1Ulp3qlhUgkkuj7u3fv6PPnz/zUaVmvy9OnT8nb25vevXtHRERRUVFkYmJCd+/eLXVuZQgenj59SkZGRtSyZUsqKCigjRs3kra2Nl28eJGioqJo586dZGBgQAoKCtSpUydKT08nIqLY2FiSkZGhrVu3lvpxUFmkp6eTmZkZcRxHAwcOpJycHP45bW1tunbtGr18+ZJatWpF5ubmlJaWRkREd+/epc2bN5Ofnx9/vrSvS2UYpnJgQSJTKRQUFND8+fOJ4zh+8X50dDRxHEePHj0iIuK/VB8+fEjKysoUGxtLRET+/v7UqlUrevr0KX8/af4S/adgThzkzpo1izQ0NKhly5akq6tLQ4cOpfz8fDIwMKCdO3fy54eGhkqs7ZTWpJ7i78nt27eJiGjXrl1kamoqMWLo7e1NNWvWpN27d/MBYefOncna2pri4+PLt9E/mJ+fH02YMEFiJPjcuXPk5ORE9+7do6ZNm1Lbtm0pMjKSsrOzqW/fvqSqqkpWVlZUvXp1atu2LUtmYRjmh2FrEplKQV5eHn/++Sdu376NjIwMpKamIjY2Ftra2vz6O2VlZQDAli1b0LZtW8jLyyMzMxNXrlzBo0ePcPPmTYwfPx4XL16U2FOapKx8yD+tJ5SRkUFiYiI2btyIzZs348SJEzh9+jTy8vKgpKSE1NRUvmRMQUEBevbsiQkTJuD9+/cAwK/fkzYcx/FrCR0cHAAAzZs3R0pKCubNm4cHDx5g27ZtmDZtGqysrNCmTRvIy8vj+vXruHr1KhYsWIA6depUZBe+W+fOnbFz505Ur16d/2yK37e+ffuievXqWL9+PXR1dbF06VLcuXMHd+/exc2bNxEREYG8vDx++8Pi2HpFhmH+FyxIZCoFkUgEkUgEe3t7rFixApqammjevDl0dHRw//59/rwDBw7g2bNn6NGjB2rVqoVHjx5h69at6NixI5SUlFClShUsXLgQGRkZAMDv/1zZEh0+ffqE+vXrQ0tLC/r6+mjZsiVOnz4NVVVVjB07FlpaWgCAY8eOITQ0FOHh4ZgzZw4MDQ1x6dKlCm79t5UMYK2srPDw4UMkJibi8uXLWLNmDZSUlDBmzBiYmJgAAKZMmYKBAwfC3t6+zN1IYmJi4O/vD0D66wkWr4HIcRxEIhGeP3+Oa9euoUaNGjh48CAsLCzw+PFjXLhwAQsXLkSzZs2goqICdXV12Nvb49KlS8jKygJQtOUl8PWHx69QV5JhmPIjnUMKDFOCOKuTiPgvT1VVVYwaNQp//PEHrl69ioKCAvj7+2P+/PkYNGgQUlNTsXXrVhgZGeHq1asS9/Px8cHr168hKyuLBQsWSO3o2rcYGhrC1NQUM2bMQGFhIWJjY3H58mUoKSlhyJAhUFVVRXp6Otzc3DB8+HCMGTMGlpaWWLlyJebOnYsWLVrwxZqlmVAohIGBAa5evYovX77g9evX0NTUhJWVFQBg8+bNSEpKwvTp06GhoVHqWllZWTx9+hQDBw5Ebm4uFBUVSz0vTUru0iMrK4u5c+dCVlYWkyZNQt26dQEAT58+RWZmJp/ZXFhYCFlZWRQUFKCgoACqqqooLCzEpk2b8PbtW3h6eqJGjRqQkZGRyn4zDCOlKnKum2F+hOjoaJo6dSqtWrWKTp06RURF6/r27dtHqqqqfI1BcQLItWvXiOM4Gjx4MDVt2pRq165daeorlrR06VIaPnw4TZgwgTiOo40bN1Jubi4REc2cOZPq1asnsU7v+fPnpKGhQVevXq2oJv9nJddoivuTl5dHSkpKtGjRIr7PZenVqxdfnFooFNLbt28pMzPz5zX4B/rW2tlZs2aRhYUFERG/LjM1NZW0tbXJw8ODiIoSuOzt7UlLS4vWrVtHffv2paioqP/8dzEM8/tiQSJTaZXMBi4uKCiIWrVqRUOGDOHPFZs1axZ16tSJf7xu3Tpq06YNRUdH/9T2/kjF+y0SiWjv3r1kYmLCZzmHhISQgoICeXl5EdHXZJdz586RoqJipSyRU/K9PnHiBOno6PxtyZuwsDBycHCgvXv3EhHRxYsXqU6dOmRsbFwqyUVas97Latfdu3epQYMG9OzZMyIqStrq1asXtWjRgkJCQignJ4dmz55NioqKtHDhQrp48SKNHDmSdHV1JRK4iIp29mEYhikLCxKZSq+s3UvWrVtHHMfRhw8fSp1z8eJFqlKlCq1bt44KCgooLS2NAgICKC8vr8z7S+sIi0gkkmhbeno6309HR0dq06YNZWdnS1xjZGRELi4u/+r+lWGLv4yMjL8N7u7cuUPm5ub09u1b8vX1pSFDhpCZmRm1b9+e3+nl48eP5dXcHyYnJ4dGjx5NKioq1K1bN2rYsCFpaWnxWeEXLlygpk2b0rJly/hrPn/+TDo6OnTs2DH+2KNHj6ht27bk6ekpcX9pf98ZhikfLHGFqfTKWsc1Y8YMXL16FbVr14ZQKISMjAy/mL9r167w9PTErVu3cPXqVWhoaMDW1lZivVrJBAJpJE66EYlEICKoq6tDRkYGSUlJiIqKwoIFC6CiosIna6xfvx4pKSn8OrayZGVl4cKFC/jw4QNkZWUldkiRJkQEkUgENTW1Uu8/8DWbNzAwEFlZWVBVVYWLiwv69OkDgUAABwcHVKlSBYGBgRg2bBhWr14t8Z5LY5+LU1ZWxr59+3D16lUYGxtj0aJFuHnzJhwcHBAbG4vTp09DRUUFc+fO5a+JiYmBtrY2Pn78yB87e/YsjI2N+TWe9+7dQ1BQkNR+5hmGKWcVHKQyzA9XcmRJPCqyfft2OnDgABERZWVl0fz586lWrVp/O828bt06fleLkverTFJTU6latWrk7u7+t3UYfXx8aOjQoVSrVi2aOnVqpexrca1atSIbGxsaMmQIubq60vv378na2prCwsJIIBBQkyZNqH///nTt2jUiIkpMTJSoIymtBcjFOw6VZceOHdSkSRM6evQofywnJ4fWrl1L+vr6/PT8pUuXyM7Ojh9ZzMrKInNzc+rVqxc/As8wzO+NjSQyv5ySI0scxyE/Px9hYWHYsGEDLly4gKpVq6JVq1ZQU1Pjy4SUlJaWhoCAAOzdu1eidIp49E5alVXOZ8qUKVBQUMDo0aNLZbYW71vXrl1x6NAhnDx5Es+fP8egQYOQmZn509v8Mzx//hxBQUGIj4+Hrq4u1q9fj+fPn8PKygqvXr3C6NGjkZuby5dIysrKwrp169CqVSts3rwZgPTugS0jI1Pm5zApKQnnz59HtWrVMGTIEP748+fPceLECXTt2hWNGjUCADg7O8PNzQ329vZ48uQJ6tati4SEBIwZM6ZSZL4zDFMOKjpKZZjy5OHhQVWqVCEHBwfS1tamPn36UFhYWJnnpqSkkK6uLh06dIiIipIg9u3bJ7FdWmXx6NGjv81ozs7OppMnT9L27dv5xIYHDx6QgYEBhYeHlzpfWpM8ivv06RO1adOGli5dyu/Ysn37drK3t6f+/fuTo6MjBQUF8ednZ2fTrVu3aP/+/aSvr09t27aV2Omlsvjw4QOFhobyjz9//kyzZ88mIyMjSk1NJaLSu+7k5eWRjo4O1ahRg2rUqMHv2FPZR5IZhvk+LEhkfgvFg5r09HTauXMnXbx4scwgQHzugQMHqEaNGvzx/v37E8dx5ObmJnG+tH+R/lP7Pnz4QD169CAVFRXq3Lkz1a1bl/r37093794lMzMzunjxIhEVBVF+fn6UkpLCXyutW/wVV7z/zZo1I47jaOjQoXy/CgsLKSsri4KDg+nz589EVDQ9b2VlJZHkISbNAXJZbTt+/DjVrl2btm3bRkSSU+ji811dXcnKyooePnxIe/fuJV1d3Ur5Y4hhmB+LBYnMb+PvSuaUpX///jRjxgxKSEigqVOnkpaWFrVr1468vb35c169evUzmlqu7ty5QxzH0cuXLyknJ4dCQkKoT58+xHEc1a5dmz/v/v37pKOjQ6NGjZIYqZJWJQPYiIgIUlJSoho1avBrEomI9u3bRzY2NtS4cWMyMjKiuXPnEhGRjY0NLV++/Jv3l9b1iiXduHGD2rdvzz8WB83i9gcFBVHdunXJw8ODDwzFtRfL+hEgzUEywzA/FluTyPw2OI6DrKzsv9qaLSIiAoqKivxeuMHBwdi3bx+qV6/O73qxfv16mJub48WLFwC+ZkRL83rFsuTk5KBevXpQUVGBsrIyTExMMGvWLMjIyGD58uUAgJSUFJw+fRqfPn1CbGwsFixYgOrVq+PKlSsS95KmvpfcRcfQ0BDv37+Hv78/GjRoAFlZWcTFxeHAgQNo0KABtm/fjg0bNuD+/fvQ0NBAdnY2atWqBQDIz8/H2rVrMXHiROzfvx8Ayvws/ZvPVnlr3749rl+/DqAoa1ucuSxeb7lkyRKYmZmhS5cuUFZWhkgkgry8PICvr2HxbO/iux8xDPNrY0Ei89v5u/Ie4i++goICPHnyBFeuXEFKSgq2bNmCvLw8REREoGXLlti2bRu2bNmCXbt2oUWLFgC+fnmK/5T2MipiLVq0gIGBATp27AgvLy/Mnj0bQ4cOhYmJCcaNGwcAePLkCfbt2wd3d3ccPnwYZ86cQZ8+fbB27VoAX5NlxNu+SSOhUIiaNWvC1NQUQNF7raysjLS0NDRp0gT29vbo0aMHbt26haZNm0JdXR2tW7cGALi4uGDFihVQUlLC4sWL0bJlS7x8+ZL/LIWFhSE8PFwqS8eIRKJSgaHYzZs38fLlSwwbNgyNGzcGUDrxq/h1nTt3xrt37wBIfwIXwzDfjwWJDFOM+MvU29sb4eHh0NbWxsyZM9G0aVNs27YNCxYswI4dO3D06FGMHj0a48aNg1AoxL59+zBx4kT07t0bO3fuBCC9mbEl1axZE/7+/pg+fTpevHiBuLg4xMbGYtu2bQCA9+/fw8vLCw0bNsScOXNQp04dAECNGjUQHh6OtWvXYvbs2Rg9ejQyMzOltt/idonfY47joKqqigYNGuDkyZN4+vQpHjx4ADc3N8TFxaFr165o3LgxCgsL8fjxY3h6emLTpk2Ijo5Gw4YNsXfvXgiFQuTm5uLAgQMYMGAAgoODK7KLZSor6BPLzs6GhoYGmjdv/s2amOIfAEePHsW1a9dw9uxZLFu2DO/evfvbezMM8wuoyLluhpFWQUFBNGDAAHr+/DkREQUGBlLPnj1p0qRJpKCgQLt27aKsrCwiIho0aBBZW1vTH3/8QRs2bCAdHR1ycnLikyCkXckt/nbt2sWvYSsoKKCDBw+SqqqqxPZtsbGxNGDAAH5fYD8/P+rYsSPZ29tXuh1MBAIBjR07luzs7KhLly6kqqpK3bp1o0+fPvHnzJw5k3R1denSpUtERPT69WsKDQ2lmJgYsrKyojp16tCsWbP486U9mUns3bt3ZGhoSL169aK4uLhSz4vXHwoEAqpWrRpVr16dZsyYQSNHjiR9fX26f/++xPmVIZGJYZh/jwWJDPMv+Pv7k4qKCikqKtKaNWv44wcPHiSO48jBwYHfDzktLY1sbW3p/Pnzpe4jzYv+iwc24sSFwMBAMjU1pcGDB0ucu2fPHjI1NeWLkxMR3bp1i9TU1CgiIqLUvYVCoVT2vXiAnJaWRidOnKDGjRvTwYMHiaiouDZRUTHqefPmUb9+/ST2fC4sLKSuXbuSiooKVa9enY4cOVK+HfgBUlNTydbWlubNm1fqOfHrM3nyZKpbty75+/vzz719+5ZSUlIoMzOTXr58yR8vuV0kwzCVF5srYJgylJx2+/LlCwoKCjBjxgyJrc7WrFmD3r17Q0dHBwYGBliwYAE0NDSgpKSE169fAwDy8vJw48YNAF+n/soqeF3Rim/xJ05cUFVVhbKyMr/2EACCg4Ph6+sLIyMjjBw5kj/+/PlzGBsbIzc3F0DRus6AgADExcVBRkZGKtcrysrKQiQSQSQSQUNDAwMHDsSJEycwdOhQJCYmYsuWLQgMDISysjKmTZuGDx8+YMqUKSgoKABQNAWbnp6OlStXYt26dZg7dy7u378P4Ov6VqFQKLVJHkKhENWqVUNAQAA8PDwAfE0+EgqFkJWVRUREBHbs2IHFixejVatW/LUZGRn4888/YWJigjFjxsDExAQ3b97kt4tkGKbyY0Eiw5Sh5Lq6bt264dOnT5g/fz5/LDo6Gunp6Zg6dSqOHDmCM2fO4OrVq6hevTpiY2P5QCswMBCdOnXCgQMHEBUVBaB05q20EO/kIWZoaIhnz55BR0cHQFHgd/HiRURHR2PevHn8eaGhobhz5w6MjY1haGgIAHjw4AGOHz+O1q1bY8KECSgoKJDK9YriAFYcyJmZmUFWVhZ5eXl48OAB5s2bh9evX6NOnTowMjJCTk4OFBQUEBMTg/Pnz0NTUxMjRozAqFGjEBYWBltbWwBFr1V+fr5U74EtKyvLt0vc/5IJWFOmTEGbNm3Qo0cPif3NJ06ciPj4eJw9exbXr1/HoEGD4OrqCn9//3LuBcMwPwsLEhnmHxARP+KioaHBH9fW1kadOnVw7do1AECnTp3w+PFjeHh4oF69eujUqRMAYOvWrQAAPz8/9OvXD2ZmZvjw4YNEyRxpHmkqLjo6GmfOnEGLFi34zF8AOH78OJKTk9G7d28oKysDAOzs7LBu3TqcPHkS4eHhcHJyQmJiosT9pKnfJUe/9PX1cfnyZdSuXRutW7eGo6Mjzpw5g169egEAzp49i/j4eAwaNAjVq1cHAKioqCAqKgrdu3dH7969YWFhgVWrVgGQ3kSmkgk9YhzH4dKlS7h+/TrmzZsnsVXf0qVLERwcDD8/P/j6+qJatWpYtmwZ6tati9u3bwMoXQ5JGoNkhmH+HkfS9K80w1QyGzZsgLe3NzZt2gQrKysQETiOQ15eHpSUlHDmzBkMGDAAW7duhaOjIzQ0NODr64s+ffpAW1sbAoFAohadtAYSxYWGhkJTUxM1atQAAAQEBGDp0qUwNjaGp6cnAODatWtITk5GgwYN0LJlS8THx8PR0RF79+6Fvb29xP2EQmGpEUxpUPz9CAkJQXBwMExMTNC0aVO8f/8e48ePh46ODry8vPi2X716FR4eHtDS0oKrqysSEhKwevVqmJmZYf/+/VBRUanILv1nKSkpOHv2LAYOHMj/QMrJyYGdnR06d+4MBwcHLFu2DDExMXB3d0dsbCyioqKwb98+fiQ9MzMTampqAL4GjiwrmmEqiQpaC8kwv4SCggIaP348KSsr0/Dhw2nHjh30+vVrIipKejA3N6cBAwaUuu7gwYM0bdo06tOnD61ataq8m/0/K5mQUFBQQEOGDCEbGxt+z+dp06aRnJwc2dvbk56eHnXr1o0iIyOpcePGtGXLFiIiSk5OpuXLl1N0dDR/L2nMjP1Wwk14eDjp6+vT2bNn+WPJyck0ePBgqlq1KrVt25ZPZHr9+jU1bdqU3r59W27t/hHKSj4RiUSUl5dHrVu3pgULFhBR0fu2e/duMjQ0JI7jaO3atUREdOXKFerTpw+1a9eOOnToQPfu3SvX9jMM8/3YzzmG+R+Jd6bYtWsXnj9/DmVlZaSmpvKjJMeOHUNYWBg2b97MXyMUCrF48WK4u7tDTk4Ojo6OOHz4MCwtLREbG1tRXfnXSo72ycvLo0OHDujcuTMsLS2RmJiIrVu34ujRozh79iz8/Pygrq4OIyMjhIeHY8iQIQCKpmWTk5NhYGCAKVOmAPi6TlOc1HPz5s1y7FnZSq5XFKtatSo0NTVx5MgRfPjwAQAQExODwMBAzJkzBw0bNoS+vj6mTJkCMzMzpKam8kWoKwuO40r1m+M4KCoqwtzcHDExMSgsLIScnBzGjRuHR48eYefOnZg5cyZOnTqFvn37Ij8/Hx06dEDz5s3h7OyMBQsWSGXSFsMw31DRUSrDVGYlR5rEe9++efOGqlSpQu7u7kT0tZTI1atXSVVVlRo2bEiRkZH8dc7OzrRz584y718ZiEedXrx4QXp6euTn58c/l5KSQtWrV+dLrBQfoXr06BHZ2tqSlpYW7du3jz8uEAioW7dutHDhQsrPzy+nXvw3KSkpZG9vT4MGDSKior4oKChQdnY2EREFBASQnZ0dcRxHysrK9O7du3+8Z2V5vwMCAkhXV5dGjBhBYWFhlJSUxD/39u1bcnBwoJ49e0pcc+3aNVq8eDElJCSUul9l2QebYX43LEhkmB+g5Jf7zZs3qUGDBvxj8Zdg586dydbWlqZMmUJVq1alsWPHEhHRyJEjafz48URUNH13584dieBIGqdiiUpPSX758oX69etHtWrVov3795OHhwfZ2tqStrY2P7UsEokkgoKIiAiyt7cnjuPo+vXrEvcrXtBamhRvf3p6OgkEAoqOjqYGDRrQsWPHJM49ceIErVu37l8XGRcIBJWizmB4eDg5OjqSgYEBjRo1ik6cOEFERGfPnqVq1arx0+vi1yovL4/evHnDX//+/Xt69eoV/7iyBMgM8zthQSLD/CTiwE785ZeWlkbGxsa0f/9+IioaeWrbti2pqalRgwYN6I8//iCiopEYJSUlWrx4MUVFRVVI27/Xli1baPDgweTq6kocx5UaJf38+TNdunSJOnbsSBoaGtS9e3d+1PXp06c0Y8YMys3N5c+XxpGmsto0efJksrCwoLt375JQKORHlkueWzwIvHv3Lm3cuJFmz55NsbGxP7fRP0jxgO7Ro0d09uxZSktLIyKiOXPmkIWFxTevDQwMpEmTJlGdOnWofv36ZGVlJREsMgwjPViQyDA/QclREfEuFN27d6ehQ4dKPHfq1Clq3749XblyhYiKtoDjOI66detGHTt2JENDQwoICODvI81KBkM+Pj5kbGxMubm5lJeXR3fv3qXBgweTjo4OmZiY0OjRo0tt7dapUydq2bIlBQcHl7q/tPefiGjGjBmkpqZGvXr1opkzZ1JKSorE8+I+ZGdn0/Lly6lKlSpkY2ND7dq1I0VFRT65R3ye+E9pG1X9VuB++PBhMjAwoPDwcP6YuA+pqalkb29PdnZ2tGfPHnrz5g1NmDCBLC0tJZZfELGRRYaRBixIZJhydPjwYWrRogUfEIq/aMXb4N2/f5/k5eVp7dq19Pr1axIIBDRixAhydHSUmH5+9uwZbdiwgTIyMkoFE9KgrHWac+bM4YNfHx8f+vLlS6nzjx07RvXr15fY3q5Lly4S275J6xZ/xdsUHx9PK1euJB8fn1Lnid+nzZs3k7W1Na1YsYJ/bu/evdSsWTOJrf+Iil4XS0tLMjMzo82bN/+cDvwgkZGR1KxZMxo3bhx9+PCBMjIy+OfmzZtHtra2dPnyZf5YXFwcaWlp0blz58q8nzR9rhnmd8OymxmmHA0bNgzOzs7o1asX+vTpgx07duDJkyeQl5dHRkYGVq5ciZYtW2LOnDn8zh+Ojo4IDw9HREQEACArKwu3bt3CwYMHkZeXx2ccS1OdQXFGsEgk4otrd+nSBSYmJggJCUG1atVQpUoVAEBhYSFkZGQgEong4eGB9u3b87uW+Pj48AWbly9fjuDgYD7jWNqI+ywUClG3bl0sWrSIL7xdHMdxSExMxJUrV9C0aVNMmjSJf87U1BSfPn1CVFQUiAgeHh7YuHEjVqxYAWtra0yZMgXHjh1DfHx8OfbsvzEwMMDRo0fx8uVLtGzZEjt37kRUVBRSU1Px6NEjtGrVCm3atOHPl5WVhaGhIRISEvhjo0ePRmhoKADwu9UQK+nLMOVO+v6lZZhflPhLzt3dHVFRUdDV1UVSUhIf8Fy5cgVXr17Fli1bAHwtPCwOGExNTQEUbXd348YNzJ49GzVr1kRSUhJcXFz4nS6kBcdxEsFc27Zt8fbtWwwdOhROTk7o1KkTwsLC+KLLq1atQmFhIfr27Qs9PT0AwKRJk6CtrY2MjAxkZWWhRYsW2LhxY0V051/hOA6ysrL/GNAIhUJERETA3t4e1atX53cjqVKlCtLS0iAUCvmi7LNnz0ZKSgqWLl2KSZMm4eHDh/w2idJIJBLB1NQUjx8/xqFDh9CqVSvUq1cP1apVQ1JSErS1tVG1alUARa9DaGgo3r59C11dXQBFO9kcPHgQe/bswYYNGxAeHs5vbcgwTDmrwFFMhvntlMzsFU/FfvjwgerVq0cuLi78eUREYWFhpK6uzq9Ty8nJoS1btlDbtm2JqGg9o6urK1lYWNDRo0clrpU2xTO0MzMzydnZmZycnIioaMrR0NCQFi1axK/h++OPP0hbW1uiCPOyZcuobdu2fJJEcdI4Bf0tERERJCsrS/7+/hLHJ0yYQMbGxvzjU6dOUe3atcnKyoo4jiNvb++/va+0vPdlrVfMycmhTp068UW4iYqmpp2cnMjKyoqIijKgmzRpQtWrV6eJEyfStGnTiOM42rFjxz/en2GYH48FiQxTAUoGNMHBwVS/fn1+lw6ioi/84cOHk6mpaalageIs2OXLlxPHcaSnp1dqHZs0EolEEsGieL1anz59qEmTJvTw4UMiKlrTJysrSxs3bqS8vDz+/M2bN5O6uvo3g4TKUj4mLy+P+vbtS2PHjiWBQEDv378nLy8v4jiOX8cYHBxMnTp1oh49ehAR0YMHD+jz58/8PcT9zM/PrzRZ8Pv37ydVVVWaNWsWrVmzhlq2bEl6enoUFBRERETz588nExMTOnnyJH/N5MmTqVevXiQUCikxMZE/XhneZ4ap7FiQyDBSRvzld/v2bVJUVKSLFy/yz5UMLt3c3MjCwoLatWtHHMfRxo0by7Op/zOhUCjxJX/16lU6dOgQX/amZ8+e1LJly1IlYUxMTPjRVqKios7Lly8nFxcXCg0Nlbi/tLt37x7Vr1+fjI2NqWHDhmRkZMSXQcrOzqZ169ZR3bp16fnz59+8h1AopOjoaNLV1aW//vqrvJr+Xe7fv0/29vbUoUMHmjZtGp+5HxYWRrq6urRs2TKJZJdFixYRx3E0efJk/seE+BqGYX4uFiQyjBQoOTKWn59PTZo0IXt7+1LnigOgixcvkq2tLbm5uRFRUb29ixcvVvqpuNu3bxPHcXT27Fm+dBAR0bp166h27dr04MEDEgqF5O7uTtWqVSMbGxvq1KkTaWlp0ZkzZyq49f/d4cOH6cCBAxQaGsq/d7dv3yYLCwuaOnUqEZUd9AqFQlq+fDkZGBiQtrY2f1w88nr//n1+9xdpIBKJJPpRcsnA0KFDycHBgZ49eyZxjZaWFvXu3Ztu3rxJycnJNGbMGGrdurVEdjwRm4JmmJ+BBYkMI6X8/f1L1Y4TB0wZGRk0cuRIat++/b/a7q0ySU9PJ09PT4mp1YyMDKpRowa/td/hw4epZcuWEuvbjh49SlOmTCEHBwe6c+dOubf7v/rWLjofP36k2bNnk7GxMaWmphLRt0dGDx8+TBzHkYqKCm3YsEHiuTFjxtC4ceMoKyvrxzb8O5UVzN24cYPk5ORox44dEs/PmDGDdHV1JUog+fj4UM2aNfkp6pJLMSrDKDLDVBYsSGSYSujgwYNka2vL18z7L+uzpHWLP6Jv92PYsGHUvHlzevv2LWVlZVHPnj1pxIgRFBcXx5/z+PFjkpOTI0VFRakrPP1f3L9/nzQ0NGjNmjVE9O0Rsg8fPtCIESPI3Nycrl27Rnp6ejRlyhSJ17CyvA4pKSm0ceNGCgsL44+9f/+eOI6jrVu38nVEiYhWrVpFtWvX5h/7+fmRjY0Nvw0gUenlDAzD/G9YCRyGqWTy8vLw+PFjEBFGjhwJAH9bciUuLg7nz5/HsWPHAABycnIAvpbYkSYcx5XqS3p6Oh4/fowhQ4ZAX18feXl5iIyMROvWraGjo8Ofn5OTA5FIhA0bNqBGjRpS2b9/o3Xr1jh37hzmzp0LAGXWhBSJRLhz5w7OnTuH1atXo2PHjggJCcGyZcvw8eNHjB8/Hunp6ahRowYA8CV2pJWWlhZmzJiBBg0a8MdGjBgBOzs79O7dmy+TlJiYiLVr12LGjBn840uXLuHx48e4efMmhg0bhgcPHkBGRoaVzGGYH4AFiQxTySgpKUEkEkFdXR3q6uoAyg4kAODChQvo3LkzJk6ciPnz56N+/foIDw//22sqWskvdw0NDYSFhWHs2LFQUlJCdnY2QkJC+Lp6HMchLS0N+/fvh76+PqZMmQJAsn9lBdHSHDg5ODgAKGp3WcFOVFQUdu7cCTs7O3Tt2hVCoRCKioqoXr065s+fjzt37uDt27f8+bKysvz9pFHJdn348AGvX7+Gq6sr6tSpwx9fvHgxtLW1MWHCBABFNUN37dqFAQMGQE1NDfXq1UPnzp3h6+srcT+BQPDzO8Ewv6KKG8RkGOZ/df/+fapfvz4ZGRl9s/RNaGgoqaur07Rp0+jZs2ckEAho6dKlNHfuXFq2bJnEVKQ0T82VnB4vKCigbt260dChQ+nLly8UFRVFa9asIY7j+K3dylqXlp+fT/fu3aPbt2/zx8qalpTm10Js9+7dpKqqyq9ZFWeF37lzh+rWrUs7duzgjw0cOJBu3rzJX1sygURaCQQCvg9ERE+ePCFFRUW+PE5UVBS1a9eOrxkqZm5uTkuXLqXk5GS6detWubaZYX41HJGU/rRkGOYf7d69G05OTqhfvz5/TCQSQUZGBqNHj8bz58/x4sULfor50aNH6N69OzQ1NbF48WIMGzZM4n70jZGriibu08ePH6Guro6XL19i6NCh0NTUhI6ODs6dO4fu3buXGkESi4iIwMqVK3H37l1wHAdVVVV4eXnBysqK73Nubi6/haC069mzJwDA19cX+fn5UFRUBFC0q42mpibc3d1hamqKR48eoXXr1pg6dSqqVauG9u3bw97eviKb/q8IBAL+MyvWvHlzKCkp4eHDhygoKMDu3buxYMECPHz4EGZmZgCK3ufevXtDKBSiUaNGSE9PR2hoKM6cOQMbG5uK6ArDVGrSOd/EMMzfEk+fjR8/XiJABIqmWTMyMnD8+HEsXrwYcnJyyM/PB1A0VZ2WloYePXqgR48eAIA//vgD165dA/B1TaC0/XYUTx3v2rULJ06cgLW1NSIiIvDXX3/Bzs4OHMdh/fr1AMqeUv38+TMCAgLg5eWFkJAQdOjQAUOGDMHly5f5oLhnz57YuHGj1K9lJCIYGRkhPj4eQUFBfIC4b98+vH//HgMHDuS3cBw3bhzU1dUhEAjAcRw6duyIJUuWSLxG0jgVWzJABIB169Zhz549AIBXr17By8sLw4cP5wNEIsKlS5eQkpKCZcuW4dChQ7h58yZsbGywffv2cm0/w/wqSv+fyDCM1CvrS7S4qKgo1KpVC1WqVAEAPpD466+/YGVlhe7du0NNTQ0hISHw9PREXFwcQkJC0KJFC7Rp0+ant/9/pa2tjdmzZ8Pf3x9DhgzBuXPn4Ofnh9mzZ6NBgwb8iGNZ4uLiEBcXB0VFRWzYsAEGBgYwNjbGpUuXcOLECYSEhGDs2LHgOO5v71PROI7Dhg0bMG7cOHTr1g3nz5+HqakpNm3aBGdnZ9ja2gIAtm/fjqioKJw5cwbOzs4AgPz8fDx//hwZGRnIzs5G3bp1//GzJC06dOgAACgsLISPjw+Cg4Nx//59/vknT57gwoUL6NixIwYMGMAfz8/PR2FhIQoLCyErK1vqfS1r1JJhmCLS+a8gwzDfxczMDJqamggKCuKPnT59Gvfu3UO3bt34KceFCxdCKBTiy5cviI2NRZ8+fbBp0yaJe0lTgseECRMQEBCApKQkLFq0CC9evMCoUaOwdu1aAF+TXsQjZeK2W1tbw9PTEwcPHsTx48cBAMOHD4ehoSHq1KmDs2fPIiUlBSkpKeA4TmoDROBrVvqePXsQFBSEZs2aYdmyZUhLS0OfPn2go6MDoVCIBQsWwNXVVWJ6uWbNmrh27RqGDRsGNzc36Ojo4MyZMxXVlf+JvLw83NzccPPmTf5HUHZ2Ni5fvowPHz7wWeEAEBgYiNzcXDRu3BhycnKQkZHB+/fvce/ePVy8eBHAP//gYpjfWgWthWQY5icRF2DeuXMnycjI0PDhw6lnz56koqJCHTp0oNevXxMR0alTp6hOnTq0atUqPpEhKiqKIiIi+P8uTtqSHeLi4iT2dS6rfX5+fnTp0iUqLCyk1NRUWrBgAZmYmFBISAh/zoYNG8jY2JimTJlCVapUoSZNmlB+fj5/P2lMZBEKhRL9ffjwIe3atYsvQD5lyhQyMDCQ6Gd2djY1aNCAevfuTf7+/pSbm0vLli0jExMTSklJKfc+/K/Kep+9vb3JxMSEFi1aJHF8zpw51KpVK34bvy1btlCjRo2oadOmZGpqSgYGBnTjxo1yaTfDVEYsSGSYX0hhYSH5+PjwO45ER0fTtWvXaOjQodS8eXPy8vLiz23evDmNGDGCoqOj+WOfPn2iAwcOUP369cnBwYF0dXUlrqlMCgsLycvLi9q3b0/379/nj5uYmNCSJUuIqKggtZ6eHs2fP5+EQiHl5ubS2bNnv3m/yiAyMpI4jiNPT0+JNq9atYq0tLQoPDycP3bhwgWqV6/eN/dCrix9DgwMpO7du/M/kIiKfiDY2dnR3LlziagokFRTUyMPDw/+nPnz55OdnR0lJydL3I9t8ccwRViQyDC/kIKCAnJzcyMdHR06efIkffjwga5cuUL16tWjadOm8eVyPDw8yMTEhC5duiRx/fTp08na2pr27NlDiYmJtGvXLmrQoEGpLd8qi5ycHJo4cSJVrVqVxowZQxMnTiSO4+jq1atEVLR1nbW1NT18+FDiutTUVPrzzz9p6tSp/K420kw82ikUCqmgoIC2bdtGCQkJ/PPx8fGkqqpK69at448JhULatm0bqaurU2ZmJn/806dPFBwcXOb9K4uMjAwaNWoUderUid+Jxd7enrS0tEhDQ4NcXV35XVxq1apFJ06cICKS2NmFSPpGzxmmvLEgkWF+QVu2bKE6deqQoaEhVa1alYYOHcrX1EtMTCRlZWWaM2cOpaWl8dfcvHmTatSoQSoqKjRkyBBKT08noqKA0tnZuczRFWkecSke2Dx79owGDhxIM2bMoF27dhFRUd09XV1d2rp1q8S09dmzZ8nR0ZFUVVVpwoQJZGBgQM2bNy+1j3Zl0q9fPzI3N5d4vyMjI0lHR4dmzZpFREWjcQsWLKDatWuTjY0N6enpkbe39zfvKU0BVMm23L17lxo3bkwrV64kIqLw8HDiOI4CAwMpODiYWrduTbVr16bly5eTtbU1X0fy1q1bZGNjQy9evODvVVnqSjLMz8CCRIb5RRUUFNCNGzckppOJiqYQt27dSg8ePJA4/scff1C7du3I19eXevbsSWpqauTu7k537tyhBg0aUGxsLBEVTWGLp7PFpPVLtOTaveKB48KFC8nKyopfo0lElJ6eTpaWljR06FB+WjYjI4McHBz4vZSL30cag+SSo37p6elkYmJCx44d44/l5+fT7NmzqXr16vzomZ2dHTk7O5O/vz9lZmbSunXryNjYmC9QXvKe0i4iIoKysrKIqChorF27Nr/sQCgU0v79+6lBgwakq6tLAQEBlJubS7NnzyaO42jTpk00cuRIiSLkDPM7kt4UPoZhvou8vDzat28PPT09ieNycnKYOnUqWrVqBeBrtqy8vDwyMzPRo0cPnDt3DseOHYO3tzfatm2LGjVqoF69esjLy8Ply5exevVqGBkZ4eTJkwC+vb9wRZORkYGMjAzfluKFwsXFllVVVfljO3bsAMdxGDVqFIyMjAAAampqUFdXR3BwMAoKCgAA8fHxEIlE/HZ30pQBXrIYurq6OkJCQjBo0CD+WFBQEPbs2YPVq1dDXl4eW7Zswf379xEQEIDTp09DXl4ef/zxB5o1a8bX0KT/zxj/+PEj6tWrh6tXr5Zfp/4jIoKhoSGqVq0KAGjTpg3Mzc1x/fp1AEWfi1GjRuHp06c4cOAAbG1tcefOHWzfvh09e/aEsrIyDAwM0KdPH+zevbsiu8IwFYoFiQzzm6ESxabFAZ6ZmRkEAgGio6MBAF27dsWjR4/g5eWFjRs3Aigqxj1y5EgcO3YMM2bMwNy5c/nyM+L7FhYWIjk5WarKyJTVlh49esDS0hJ6eno4deoUACA1NRXa2toSZWO+fPkCdXV1ZGRkQEFBAQDQr18/TJo0CZGRkQC+7o0sDYFxSeJi2eLgMT8/H0uXLoWmpibGjRsHoVAIb29vTJw4EefPn8e7d+9Qt25dbN68GdbW1oiPj0dubi5//erVq1GtWjU0b968wvr0T4oHyuLP5YgRI7B582YMGzYMT548QXBwMNTV1eHo6Ij4+Hhs3boVTZo0gY+PD8aPH48lS5agbdu2ePLkCYDS761QKJTK95thfqgKHcdkGEZqJCUlUevWral9+/YUFBREGRkZlJ+fzz8fFRVFly9fpkOHDtGXL1+IiGjp0qXk5OTEnycSiSg2Npbk5OTI39+/IrrxrxSfkvX396ePHz8SUVEii5WVlcS5d+/eJRUVFTp06BARFZUOkpOTI2NjY+rfvz+1aNGCnj17Vn6N/wGCg4P5afb8/Hzq0qULjRs3jn/+2LFjZGpqShzH0ZQpU/jjL1++JDk5OTpy5AgRfX0d4+PjJabtpVVUVBR169aNzMzMaO7cuRQSEkJCoZC8vLxIVVVVIoHpy5cvNGrUKOrYsaPEsgLxZ19MKBTSihUrpPrzzjD/KxYkMgzDy8rKoiFDhlDNmjWpX79+tHz5ciIiiomJIV1dXTIyMiJra2vS0dGhzZs307Vr16hWrVqUlJREREQuLi7UsGFDatSoEREVBRHSuG6PSHK9ojjYuXjxIpmZmdH169cpPz+ffHx8qF27dtSyZUsiKlrP2bRpU7K0tKR9+/ZRcHAwrV+/nlxcXGjJkiWUnZ1dYf35t8rKVF64cCF17dqVX8NHVPRZ2LFjh8SxTp06Udu2bSUSfcTXN2rUqFSWuLSsVS35OXzz5g29e/eOiIjevn1LLVu2pOHDh0tc8/jxY9LU1OSz28PCwmjz5s3UuXNn6tChA9/Xy5cvU7NmzSSC6cqWDc4w38KCRIZhiEgyCSMkJIR27drFlw9ZtGgR1apViz59+kRJSUl0/PhxMjMzI47jqF+/fvx1S5YsIY7jSFtbmy5fvswfj4+Pp1evXpVfZ77D7NmzSVFRkWxsbKhKlSrUr18/vij1okWLqFGjRqWSOQICAsjY2LhUSSEi6UxuKenly5fUsGFD6t27N71+/ZoP+om+BjzXrl0jJSUlPuFJfPzBgwfk5OREY8eOLf+G/0cl3wuBQEAeHh7EcRw/mkxUlJgzbNgw0tfX54+Zm5tT48aNycXFhSZNmkTm5uZ0/vx5vtSO+DNSMoBmmMqMBYkMw/BKZgOLLV68mGxsbCSKK+/Zs4eUlZXp6dOnRFQ0XW1ra0vdu3enrVu3UrVq1WjVqlVEROTm5kY9evTgg05pVHz05/3793To0CF68OABn8kbHR1Nurq6tGjRIsrIyCCir3X1bt++TVWrVqWcnBwi+ufAUBpHmj58+EDdunUjXV1dGj58OO3du1fi+Xr16tHo0aMljgmFQpo+fTrZ2dlJZMs/fPiQLC0tKTExsVza/j3y8/Pp+vXrRPT1fbl06RLJyMjQxYsXiYjI1dWVdHR0KDAwkL9u8eLF1KFDB2rfvj1fRzQtLY0mTpzIpp6ZXwYLEhmGKaVkEPPw4UPS1NSkPn36kI+PD02cOJE0NDRo/Pjx/Dnbt28neXl5vuROSkoKffz4kd68eUMDBw6kTZs2lWcX/id/Nz3ev39/cnBwKHP94eLFi8nZ2ZmfbhYIBPTq1Svq0qULJSUl8ff09fWVyhHV4n0ODAykU6dOSYwm5uTkUHR0NP8jQfxDwtfXl2xtbUtth9etWzcaM2aMRJFuaVTWD6K4uDgyNzenjh07EhFRcnIyKSgolNp56OzZsyQjI0N9+vTh6096eXlR9+7d+eLcDFPZSU/6IcMwUqNkGRUbGxuEhIRARUUFb9++hY+PD7S1teHm5gYAiI6OxurVqzF9+nTo6elBIBBAS0sLNWvWxNatW0FEcHJyAlA6u1qMin60/tyO/QOO4yArK1uqHUlJSXj16hW6du2Kpk2b8sfF2a0yMjKQlZWFkpISAGDjxo0YOXIkcnJyIBQKISsrC5FIhF69emHPnj18KZ2S96ko4vYREZo1a4b+/ftDW1sbABAbG4uGDRsiNTUVcnJyAIr6m5qaCj8/P2hra2Ps2LH8vfbt24d3795hxowZEuWFSqro9xooO+udiJCfn4/t27cDAK5fvw49PT20adNG4rybN29CV1cXY8aMgYaGBt69e4dLly7BysoKXbt25e/FMJWZXEU3gGEY6ScUClGzZk0cPnwYBQUFuHPnDhwcHFC/fn0AgJeXF0QiEf78808A4IMJAJgzZw7CwsJgYmIC4GsASkTgOA7Z2dlIS0uDjo5OOffq20oGybVq1UJwcDAyMzMhJyfHt10cZPj6+mLw4MGQkZHB8uXLsW3bNsycORPz58/nz5k2bRoMDQ0xceJEvpROWloaqlWrJhXlgr7VhmfPnkFFRQX6+voSx9PS0vD582d06tQJ9evXl3g/XVxcYGxs/Ld/X8nXWFrUq1cP79694x/r6+sjOTkZWVlZ/DF/f3+8fv0aTk5OfECYnp4OdXV12NraomrVqvzr8S3/9DzDSAOO2E8dhmH+BZFIJBFIFBYWQl5eHkSEBg0aYPDgwVi5ciV/HCj9RVjWF+PVq1fh4uKCLl26YNu2bZCXl5e6L0/xaGBZ4uLiMHHiRHTt2hW3bt1CSEgIFi1ahMGDB/PnREdHw9DQEJ6ennBxcYG8vDyys7Mxe/ZsZGRk4Pjx4+XVlf9Jbm4ulJWV+c9AQkICAKBGjRrgOI7/HIjft5KfleLHwsPDsWLFCvTr1w89e/Ys9778E4FAIPEjJzY2Fj169ICVlRXmzJmDmJgYzJs3D3Jycti+fTtatmzJ9734Z7+k/Px8nDhxAgKBAC4uLuXVHYb5PuU6uc0wTKVXPHmFiCgzM5OGDBlCnTt3ptTU1P90rw8fPtCMGTOI4ziqWbMmn/hRnDQmeRSXlZVFjRo1Io7jqEuXLnTlyhX+OXHbO3XqRG3atKGEhAT+uQcPHpCxsTFdu3aNiKSnXExx39q3eNq0aWRtbc1n9BY//5+4u7uTrKws1apVi6Kion5YW3+mwMBAatq0KfXq1YvMzMxIXV2dPDw8+Of/zf7OL168IDs7O+I4jvbt2/ezm8wwPwSbbmYY5j8pPsoCAKqqqtiwYQMGDBiAtm3b4tSpU/841QgUjSoGBATg+PHjsLW1Rc2aNSVGY8QjOtI2qghIjjb5+PggLCwM3bp1w7Fjx/it4MSjj5cuXcLjx49x9uxZ1KlTB0DRzi7Lly9H8+bN0bFjRwClp3vp/0enyhqVKy8cx5X5+nfo0AHy8vL8EoLi55dF3Ifbt2/j6dOnMDExQWJiImrWrPlT2v0j0f+v0wwKCkJ4eDj27NkDf39/DBkyBMDXvpXVd/F7mJmZiQsXLuDVq1cAwH8O/m6EmmGkAQsSGYb5LiKRCLVq1cLdu3fx5s2bUmvXviUqKgrbt2+HnZ0dJkyYgEmTJkFOTo4PvoYMGQIFBQUcOHCgVGBakQQCATw9PREUFARFRUUcPXoUy5cvh4uLC6pWrcp/8Yu//BMSEjBu3DjY2dnx91BTU0OLFi0wYcIEAJLTs+LAQhx0yMjI8AkQ0hIwd+/eHd26dQNQ9tRycUQEGRkZFBYW4vTp0/jy5Qvs7OwQGRmJwsJC/hw/Pz9ERkbC1dVVqtbrcRzHv6cNGjTA2rVr8fz5c9SrV4/v299dCwAvXrzArl274OLigqioKHz69AnA1+0cN2/ejOnTp//8zjDMf1VRQ5gMw/w6/mvB6Ly8PNq8eTOpqqpSVFQUrV+/nmxtbfnng4ODSU5OrlTZEWkhnn4cM2YMHTx4sNTz4in5K1eu/GOtwJJTtOJrN27cSLVr1yY/Pz/+OWmZkv4vSwDE5546dYpatmxJGzZsoFu3blHNmjX5epMJCQnUokULsrCw+Cnt/VH+l9f/48ePNHLkSGrSpAkVFhaSpqamxJKE9evXE8dxUl1DlPl9VXxKHcMwld5/nTJ78+YNdu3ahSFDhkBfXx9ycnLIycmBQCAAAEyZMgWOjo7o37+/xHUkJXl24unH3bt3Y8SIEQAky9jIyckhLy8Pzs7O2Lt3L4RCocT1xc8tPmImEokgJyeH/Px8LF26FLVr10b//v3Rrl07xMXFSUUWNPDvRzRFIhE4jsPHjx/h7e0NLS0tjB49GuHh4dDT04Oamhry8vLg4+ODV69ewdvbGwBKvV7S4r++/kSEu3fv4ty5c1ixYgUKCwtRo0YNvn8ZGRlwd3fHihUr0LBhw5/RZIb5LtLxLw7DML88cYCXkZGBkydPIi0tDX/99RcA4O3bt9DW1oacnBxOnDiBR48eYdGiRVBTU5O4h3iNXkXXFRQrHhwXDyBEIhGUlJTg6emJQYMGlQqivxVsiF+jqVOnQltbG5cvX0ZsbCxq164NJycnvHnz5if04ucR9/PkyZOIjo5Gz549Ua1aNSgqKiIlJQV5eXmIjY3F2rVrMXnyZOjq6pZapyetAeO/ERUVhZ07d6Jly5bo1asXCgoKEBsbCw0NDQDA7NmzUbNmTYwaNYrvs/gzUJn7zfw6pGehD8MwvzTx6NO9e/ewa9curF69GioqKgAAHR0dREREQCAQwM3NDSNHjoStrS2AohIkoaGhePXqFbp06cInS5AUrVsrSRwcTZw48V9fIw6O3r59i71792L37t1QU1ODsrIyPDw84ODgAD8/P5iZmf2sZv9Q4vcnKCgI165dQ4MGDTBy5EgART8KjIyM+DIymZmZ2LRpE4CiwDs7OxtJSUkwNDSUKG4ure93WfLy8nD58mUEBgYiICAAABAWFoa6detCXV0dL1++xL59+3Do0CHUrl2bvy4rKwtqamp80FiRiUsMwz55DMOUKzk5OTRq1AiTJ0/mj719+xbGxsbYtWsX0tLSMG/ePMjKyuLcuXPo3r073NzccO3aNVhZWWHatGkoLCyU+oDhv06Ni4OCOXPmoHHjxhg7diyUlZUBFBV4TklJQWpqqsS9pWX6vSzi9+fp06cIDw/HwIED+R1p9PX18enTJ9y9exf79u3DqlWrAACvXr3CunXrYGZmhmHDhsHMzAw3btz4Zpa1NPvw4QPWrFmDHj16oFGjRgCK3sf4+HhUqVIFCxcuhIODA/r37w8iwpMnT9CuXTsMGDAAzZo1w5EjRwD89yluhvmhKmYpJMMwvzNxAkBeXh4RES1YsIDs7e1JTk6O1qxZQ0REN27cIGtra2rSpAl/XVBQEDVp0oR8fX1L3VPa6yn+HXGyire3N3EcR6qqqtSnTx9KSUmhnJwcmjt3LqmoqPxtkow0CwoKknjs6upKLVu2pCFDhpCxsTF/vFu3buTk5ETnz5+n2NhYWr58ORkZGZGPj085t/jHuH//PuXm5vKP/f39ydramlasWEEyMjJ0584dIiI6dOgQmZub06xZs+j27du0bds2qlevHs2fP79Sf66Zyo8FiQzDlKuyMkQHDx7MF6NOTEykgoICmjlzJpmamlLdunXJ3Nyczp49S0REM2fOpH79+pV5L4FAUOm+VIu3t27dujR+/Hh6+vQp9evXjziOI0NDQ+I4jubMmUN5eXl09+5d2rJlC23evLkCW/3vlHx/xI/Xrl1LioqKxHEc3b17l4iINmzYQBoaGqSsrEyLFy/mrxk8eDBNnz69zPv916z6iiJud3h4OFWrVo04jqNp06YREdHbt2+pQ4cOJCsrS+PHj+d/OJ06dYpsbW0pNTWV/4yI/6ws/WYqPzaOzTBMuSpr+mz48OEwNDTEiBEjoKWlBXl5eTx9+hROTk6Ij49H3759MW7cOAwePBj+/v78wv/c3FxER0fj+PHjiI2NhaysLDiOk+pp2JLEbV24cCEEAgEmTpwIS0tLnD59Gu/evcOsWbPw/PlzuLi4YMWKFXBwcMDp06exa9cu1KlTB3fu3KngHnxbyfda/FhFRQUFBQUYOHAg2rRpg5ycHAQEBKB79+44cuQIrl27hlq1auHYsWOwt7fHs2fPUFBQwF//8eNHAJBYryjNxO1OS0tDeno66tSpg/HjxwMAQkJCEBkZiU2bNuHDhw/Q1tbGpk2b0KlTJwQHB+PTp0/8VHt+fj4AlEpyYZifpmJjVIZhmK/Eoyj5+fnUqFEjWrhwIf9cTEwMDR06lGrVqkUnTpwgIqJx48aRrq4uNWjQgGRkZMjd3b1C2v29BAIBNW/enNzc3PjpyZKjRe7u7mRiYkLHjh3jR5TGjx9PvXr1KnW/yjCa+vDhQ75OIhFRly5daPTo0UREVFBQQHv27CF9fX3iOI5mzpxJRES3b9+mQYMGUePGjcnS0pICAgL46yvL6FpISAhduHCB/6zv3LmTateuzT/v7e3Nb/Oor69PRESpqank5eVF3bt3J1tbWzp9+jR/vkgkqhTvN1M5cUTspwjDMBWrrO3Jtm/fjhMnTuD06dOoVasWfzw8PBwGBgbw8PDApk2bsGrVKvTo0QNRUVHYunUrzM3NYWNjA0dHx/LuxnfLysqCqqoq/1ic2fr8+XPMmzcPjRs35rOAAeDAgQNwd3fH5cuXy6yzV3z7QGkhLl9UcpRxwYIFePnyJU6cOMG/BikpKTh9+jScnZ2RlpYGR0dHtGrVCp07d0ZiYiKCgoKwYcMG6OjoQF1dvdz78l+V9Tn39/eHi4sLjh8/DmtrawBFmdEHDx4EEWHixIno1asX3r17B3NzcxgbG+PkyZNYunQpunTpgmrVqlVEV5jfRQUHqQzDMGV6//49OTg4UL169Wjv3r10/vx5iouLIyKixMREUlBQoJ07d0pcM2rUKKpRowY5ODhIjFIRSfd6xW8ln4jbe//+fapWrRq/K4d4tPHs2bNUpUoVSktLIyKiw4cP0+LFi0utVxTfJzo6+ie0/scIDAykBg0a0MiRIyk6OppSU1P55z59+kRdunQhS0tLiWtcXFyoVq1a5ODgwH82xKRld5p/kpWVRV27diVnZ2d69+4dFRYWSrT92LFjJC8vT9evX+dHSw8dOkS2trbUvn37UklclaXfTOXA1iQyDCOVdHV1cfv2bSxYsACenp7YuXMnv+ftli1bYGxsjL59+0qsy8rMzISioiJmzpwJNTU1fPnyBYGBgUhNTeXXK0pjkeJvjfaJ16IlJCSgsLAQ2traAMCXklm9ejW6dOkCDQ0NeHl5YcSIEYiJicH27dthZGSE69ev8/cRCAQ4cuQI2rZti9zc3HLo1X/TrFkz+Pn54f3793B0dMSkSZOwb98+AEWjx35+fti9ezeAr2vzGjVqhNzcXHTt2hWampoAioq1A0UjldJUeP1bqlatiiNHjkBFRQW2trYYOnQo/vzzTxQUFAAA5s+fD1dXVzg6OvKjkLa2tggODkZOTg709PQAgD9fvNe3NH7OmcqHBYkMw0gl8ZfcxIkT8fTpU2zcuBEtWrQAFVVlgJaWFlRUVCSKdCckJKBLly7o2bMnAOD58+fYu3cvWrRogfnz5wP49haCJMUrb9q0aYMGDRrg5MmTAIC4uDgsX74c7969w5w5cwAAN2/exMiRI3Ho0CGEhoaiX79++Ouvv5CSkgKgKBBdtGgRPDw8+PqLgPT0WyQSwdDQEP7+/jh8+DDat2+PHj16AAAuXbqEJk2aoHnz5hAKhVBUVAQAnDlzBs2aNUOPHj2goqKCxMRErF69GsOHD8fLly8hIyMj9XUGRSIRNDQ0cObMGdy4cQMmJiZwcHCAgoICnj17Bo7j0KNHD4kknQsXLqBKlSoYMWIEzM3NUVBQgEuXLmHq1Knw9/cHx3GVJqmHkXIVN4jJMAzzz8pKSNizZw81bNiQPn/+zB/r168ftWrViu7du8cfy8vLo0+fPtGlS5fIwsKCOnbsSCkpKUT0dQo2MzPzJ/fgx9i6dSspKSmRvb09GRoaUp06dejQoUP883v37qUqVarQ3r17SSQSUWJiIt2/f5+IiCIjI+nIkSNUUFDAn3/79m2pq7H4reSTvXv3UsOGDenDhw/8sQMHDpCWlhYdOXKEPxYeHk4nT56kCRMmUNWqVWnevHlS18eyCIXCMqeJ4+LiqE6dOnT8+HH+WEREBHXt2pV69erFLzP49OkT+fr60rRp00hLS4uvsckw34sFiQzDVBoCgYDy8/MpMTGRWrRoQQYGBrRw4UJq3bo1KSkp0dKlS/lzHz9+TGfPnqXQ0FAiKvpyNTExkciIJSrKqh0/fnylyI5NTk6mP//8kw4ePMgXqBYHCkREmzZtoq5du9KDBw8krtu2bRupqanRjRs3SCAQUEREBNnb25OLiwvl5+eXZxf+lZJrR9++fUu1a9emSZMm0ePHj2n9+vWkpqZGQ4cOpfj4eCIiysnJoS9fvvDX3L17l4yNjUu934cOHaLdu3f//E78D0oGivn5+dS5c2dycnKikJAQevDgAXXr1o0aNGhAx44dI6LSgXV8fDxZWFjQ2rVrJY5nZWXRhg0bfm4HmF8OCxIZhqk0Pn/+THv27OEfnzt3jjw8PKhNmzbUvn17ioqKIiKiKVOmULVq1ahly5akq6tLw4YNo/z8fNLT0+Ovv3XrFjVr1ozk5OTo8ePHRET8SFt0dDRlZWWVc+++TSQSlRnECgQCWr16Nb8jSVpaGo0ePZpMTEzo48ePRET0/PlzcnZ2pv79+xMRkaenJ9WtW5fMzMz4kUZxv2NiYujq1avl0KN/5/Pnz3zAGxQURK1ataIFCxZQnTp1yMzMjG7evElERMHBwWRjY0OOjo5kb29Pfn5+RETk4OBAGzduJKKivh05coQsLS2pR48eRCTdZXNiYmIoKyuLkpKSqG3btuTk5EQODg6kpKREEyZM4M9zdXWl/v37U+fOnWn//v1EVDTqbGNjw3+GX7x4QStXriSO4yg+Pp6EQqHUJnEx0kW6F2swDMMUk5CQAA8PD4wfPx4JCQlo3749YmJiAAD9+/eHvr4+4uLi4OnpiS1btuD48eM4efIksrOzoaSkhIyMDHTq1AkAoKenh+DgYMjLy8PX1xcAIC8vDwC4ceMGOnfujKioqArpZ0nfWmOWk5ODN2/ewMPDA3fv3oWGhgasra0hKyuLwsJC5Obm4uLFi4iOjsYff/wBoGjfZI7jEBkZiYULFyI2Npbv96NHj7B06VKpSWz5+PEjNm7ciCNHjqBp06Z48OABBg4ciMLCQgwYMAAWFhbIzc3F+PHjUVhYiMmTJ8PR0RHDhw+Ho6MjwsPD+SSfuLg4DB8+HK9fv+bXcYrXp/r5+aFHjx580ktFIyLs3bsXq1evhra2Nvz9/XHs2DEYGBigdevWGD58OABg/fr12LdvH+rXrw9bW1ssW7YM9vb28Pb2RtWqVVG1alXk5OSgQ4cOWLJkCWbOnIm6detCRkYGHMfh48ePmD59Ol6/fl3BPWakVkVHqQzDMP/F27dvydbWlmrWrEnGxsb8OjxxWZhnz55R/fr16fLly/w1QqGQVFVVae7cufwaRC8vL1JRUaHdu3dTw4YNqVmzZhJTtyEhIeXar+8xZ84cUlZWpg4dOpCWlhaNHDmSMjMz6fbt29SyZUt+W7usrCwaN24cdejQgfz9/alv377UpUsXiWna4usWpcHatWupatWq1KVLF+rfvz9VrVqVnJ2dKSIigoiIoqKiSF5enh9VJCJ69+4dGRgYkKGhIX/s2bNnVK9ePWrZsiVxHEeTJ0/mR9OysrLI09OTYmJiyrdzf+PMmTNUq1YtatOmDS1fvpxsbGzIyMhIoryRtbU1DRo0iH9cUFBAQ4cOJSUlJTp37hx/vE+fPqSjo0NycnLUtWtXic/55s2by9wTnGGI2HQzwzCV1L179yggIIAPFoiKpmUzMzOpc+fO1KBBA/Lx8aFNmzZRx44dqVatWhQYGEhERdOYNWrUIDc3N/7aJ0+ekEAgoE2bNknU3JPmxIfi06Xx8fHk6elJV69epezsbMrKyqIpU6ZQ8+bNKTExkYiKkj1sbGxo9erV/HVpaWlUUFBATk5O/D7KRNJVb+/Tp080Y8YMmjRpEq1atUoikE1KSiJHR0caPHgwpaamUlRUFO3Zs4cUFBRo3759RFRUV3Ps2LF80PjmzRtyc3Oj7Oxsfs2qNBLvYe7s7EyDBw+mO3fu8GtIBQIBrVixgpo0aUJJSUmUm5tLcXFxZGVlRc7OzpSQkEBERNevXyeO4+jevXsUHx9PQ4YMoQsXLkj8MBBjU9BMSSxIZBjml7R48WIaMWIEjRs3jjiOo82bN1NOTg4REU2fPp10dXUpKSlJYluzgwcPkr6+Pv31119EJN1r1sS+tV7Ry8uL9PX1acuWLURUVJy8f//+1LVrV0pKSiKirwHw7t27ieM4Cg4OJiLpHUUtHsQUD2KfP39OZmZmZGlpSX379iWO48jBwYG/xsfHh6pVqyaRJUxU9GNBVVWV1q9f/82/RxqIt/ArKTExkdq1a0fVq1enmTNnkpaWFmlpadG1a9f4c5o3b079+vUrNUI8depU6tmzp0TRcmn6YcBIBxYkMgzzSykeMIlEItq9ezeZmprygU9cXBwpKCjw5WPEX4wxMTHUp08f6tOnDyUnJ9OHDx/I2tqaXrx4Uf6d+B+IAxvxn7dv35bY13nPnj1kZWXFl4wRv07iUdVFixYREdGlS5dIS0uL3rx5U57N/58VD+iePHlC3t7exHEcPXr0iIiIYmNjqUuXLtS2bVv+PHHfp06dSlZWVvTw4UNKTU2l1atXl9qpR1oV7/eDBw8oPDycOI4jV1dXSk5OJqKifaFVVFTo1atXRPT1s3716lVydHSkSZMmERHRxYsXKTw8vJx7wFQGLEhkGOaXU3x0kIgoPT2d/4JcsWIF1atXj9LT0yXO+fPPP8na2poPop4+fUocx/GjbsVVxhGXv/76i0xNTfnH4kBpxowZVL9+fb6fV69epWbNmlWaIJGo9IjvyZMn+f++efMmcRxHz58/J6KvWxo+f/6c6tatS+vXr6ecnByKi4ujunXrStRdFJPW97tkv/fu3cuXRiIiqlmzJv3xxx9E9DWo/PLlC7m4uJCjoyO9fPmSiIicnJyoc+fOpe4vbSOqTPlj2c0Mw/xyOI4Dx3EQiUQgIqirq/M7b5iYmEBRUZHfzQIAnj59ips3b8LU1BRDhw4FULSDSYcOHfj7AEW7Y2RkZEj9Lh4ASm1HV6tWLXz+/BlbtmwBUJTZ++bNG2zfvh3Lli3jt/x7+PAhcnNzYWpqyl8rEAhw//798mv8fyTOUqb/z/4eMGAA/9yHDx9gaGgIMzMzAF+3NFy8eDHMzc3RqVMnKCsrIy4uDikpKejSpQsAoLCwkL+HtL7fJXcPGjNmDJo2bQoAiIyMRPXq1WFpaSlxzpkzZ/DmzRs4OzvD3NwcOTk5iI6ORq9evQB83d4P+LotJPP7ks5PPsMwzA8gLvVRXP/+/dG7d284Oztjz549AIBTp04hNzcXo0eP5s/Lzs5GXl4eNDU1+SBh4cKF6NChA27duiVxT2ncH7hkYDN48GDs2rULK1euhI+PDwBgwYIFaNWqFQYOHMif9/jxY3Tr1o1/HBwcjKlTp6JNmzZ8SSBxf4VCoVRt/VZWUGNvb4+aNWtCT08PAQEBAIoCpVevXmHw4MFo0qQJAODq1auws7Pj7yEvL4/k5GQMGTIEcXFx5deJH0RHRwf29vYYN24cDh8+DI7j8P79e/j6+kJbWxtjxowBAERERKB69epQV1cHACgoKAAANm3ahCdPnlRY+xnpwIJEhmF+G+KAZu3atXj//j06d+4Mf39/XL58GQ4ODmjTpg1/7sWLF2FlZQU5OTlERUVhxYoV+OuvvzB27Fg0btxY4r4yMjIQiURSGSwCX/vds2dPJCcno0uXLrh69SouXLiAFStW8Hs5Z2VlQSQS8QFDQkICBg8ejNjYWPj4+MDAwABAUX8LCwshKysLjuP4fbalka6uLu7fv4+FCxfyQe6KFSvg5OSEdu3a8ecVFBRAQUEBVapUAVC0P3KPHj0QGBiIpKSkUvcVCATl04H/kaKiInbs2IHt27fD29sbRIRjx47h06dPGDRoELS0tAAUvZcvXryAhYUFACA9PR0LFy7E8uXLcfr06VL3leb3mvkJKnKum2EYpryVzAaOiIigKVOmSJRCeffuHbVu3ZqOHz9O+fn51L59e2rdujXt2rWLiIgyMjLo2rVrtHz5cpowYYLEftHSrHg5n5ycnFL18dLT00lOTo5ev35N169fp9atW1Pr1q35re8yMjLIxcWF+vTpQ9bW1vTnn3+Wa/v/FyXX7d27d4/09PQk6ggSEZmamtKKFSuIqGhNY8OGDWnQoEGUnp5OREV9Dw4OlsgclmYl+52ZmUkdO3ak3r17Sxxfvnw5WVpaElFR8taYMWNIW1ubzp8/z5+TlJREb9++lfj8SOs6TebHYkEiwzDM/xMv1A8LCyMrKyuaN28eDR06lIyMjOjhw4f8ef369aNOnTpR3759aeLEiVSlShWaPn26VO6DXJZvJST4+PhQkyZNaN26dVSrVi2aMGECX2Px+fPn1LlzZ3JwcKDTp0/TgQMHyMTEhLp06VJpMoLFPn/+TNnZ2fzjN2/ekLW1NZ0+fZq2bt1K6urqtGjRIr7vfn5+5ODgQEZGRtS8eXPS0dHht0KUdsWDuYyMDAoLCyOioiCyoKCAFi5cSIMHD6a3b99Sy5YtqX379nypoKSkJFq9ejXVrVuX2rRpQ9ra2nxJJeb3wIJEhmF+a2WNiFy+fJk4jqMWLVpQ9+7dJcqDeHp6EsdxNGzYMP5YYGAgNW3alC+7UlkdP36cOI4jjuPIw8OD35kjPT2d5syZQ1WqVCF7e3u+tl5cXBxZWlry+ytXBmW932/fviVLS0vS09MjR0dHWrhwIf/cmzdvSE9Pj9/FhojIw8ODmjVrxpeWqQxK9lv8uGfPnlS3bl0aNmwYNW7cmJKSkvjnhg8fTs2bNydfX1/68uULHTx4kBo1akTbtm0r9/YzFYOtSWQY5rdWVuaqhYUFbG1t0aFDB2zZsgVGRkYAitatrV69Gr169cLr169Rv359HD9+HM2aNUPNmjXx7Nmz8m7+DzVo0CBs2LABmzdvxrx586ChoQEA+PLlC3x9fTFy5Eg0atQIurq6cHV1hY6ODr58+YKQkJCKbfh/UNb7LRKJ8Pz5cyQmJmLJkiVYuHAh/9yWLVuQlJQEX19fzJo1C1++fMG8efPAcRwuXLhQnk3/LiX7LSMjg9zcXISEhODDhw+oV68eTpw4AW1tbcjIyODWrVs4cuQIIiMjcfDgQWRlZWHEiBEYMGAALl26VEG9YMobCxIZhmFKqFmzJu7du4c1a9ZAT0+PPx4ZGYlq1aph/PjxCAwMxB9//IFZs2bB2toar1+/liibUtnQ/ye3zJw5E66urgC+JilkZGQgJiYGixYtws6dO+Hn54fAwEAoKCjg48eP0NXVrbB2/whmZmbIyMjA06dP0bZtW75MTn5+Po4dO4YdO3YgICAAUVFR0NfXx+rVq2FsbAwVFZUKbvn3UVZWRmhoKHx9fbF69Wq+TBAAHDp0CF26dIGfnx/k5OTQsGFDuLm5wdTUFJmZmWUm8zC/HhYkMgzDlPCtDE5NTU3ExcUhJiYGAODq6oqXL1/CysoK8vLyGD9+fDm28sfiOK5UORtZWVmIRCJUr14dDRo0wNmzZwEAdnZ2CAgIwKFDh/6vvfsOa+p64wD+TUJYEsISwhBFceKGKqDWCWoVcAMurKPanwPcolatWnG0jmrV2tbVKlrrrlYF98AFuFBxFASFCAgCsrLu749IMCRAAqg1vJ/nuU/l3HPPOW+w+HLuPedizJgxSon0p0gikYDH4ym2wyneBufly5ewt7eHWCyGi4sLTp8+jQ0bNmD37t3Yv38/DAwMPuawq6x4hbaPj4+irPjvgJmZGfLz8+Hp6Ym9e/fiwIEDOH/+PAICAqCnpweBQPBRxkw+LBZT+qcCIYSQMs2bNw/37t3Dpk2bYGdnpyjPzMyEhYUFZDLZf3bz5aoIDQ1FZGQk1q5diw4dOii2jBGLxeByuR97eO/Nl19+CS6Xiy1btijK8vPzcerUKfj6+urk9xoAtm/fjp9++gkHDx6Eg4MDAPlt+d9//x0dO3ZEgwYNwDAMbbit4yhJJIQQLSQnJ2PEiBF48OABJk2ahPr166NTp06f/C1XTUydOhVbtmxBz5490aJFC4wZM0Zn4y5OgE6fPo0RI0agffv2mDdvHng8Hho3bvyxh/fepaSkYNCgQeBwOFi5ciUaNGgAPp//yc+eEu3o5q9AhBDyHjAMgzp16uDcuXP46aefcP36ddy8efM/9daR96F4k/A1a9bg4cOHaNasGerXrw8ej/eRR/b+FM+Qde/eHTExMWCxWAgMDMSPP/6IyMjIjzy698/Ozg7nzp1DkyZNMGDAAEyZMgVr16792MMiHxjNJBJCiBakUqnSO3NfvXqleHuFLmMYBjKZTBF76c9BV70b58OHD5GTkwMXFxfFm1l01btxJyYm4tq1a3B1dYWzszPdZq5BKEkkhJBKqClJUmm6+sxleWQyGVgsVo1LjIpnkGva95uUoCSREEIIIWWimcOai349IIQQQkiZKEGsuShJJIQQQgghKihJJIQQQgghKihJJIQQQgghKihJJIQQQgghKihJJISQSigqKsKiRYtQVFT0sYfyQVHcFDepOWgLHEIIqYScnBzw+XxkZ2fD1NT0Yw/ng6G4KW5Sc9BMIiGEEEIIUUFJIiGEEEIIUaH3sQdACCGVJZPJkJKSAh6P98E3/M3JyVH6b01BcVPcHwrDMMjNzYWdnV2lXw1YWFgIkUik9py+vj4MDQ2rMkSdR88kEkI+Wc+fP0edOnU+9jAIIe9RcnIyHBwctL6usLAQRpamQL5Y7XmBQICEhARKFMtBM4mEkE8Wj8cDACQl7YGpqfFHHg0hpDrl5OTD0TFA8f+5tkQiEZAvBmtUW0CfU+qkFMLtMRCJRJQkloOSRELIJ6v4FrOpqTFMTWt95NEQQt6Hqj5KwjbigmWgnO4wHAmkVWq1ZqAkkRBCCCE6i8ViqSaaH/gZ5k8VJYmEEEII0VlsPTZYesoLXxgpbe6iCUoSCSGEEKKzKEmsPEoSCSGEEKKzWGwWWOxSt5dLf03UoiSREEIIITqLZhIrj5JEQgghhOgsNpsNFqdUkljJzblrGkoSCSGEEKKz6HZz5VEqTQipETZuPIz69YfByKgX3Nwm4OLFO+XWP3/+NtzcJsDIqBcaNBiOzZuPqtTZv/8CXFy+hKFhL7i4fImDBy9p3S/DMFi0aAfs7YfA2Lg3unadhri4xCrFqk3/pVHcn3bclW3/Q8VWVCTC5MnrUbt2f5iY9IGf33w8f55elZArxNZjqz1IxehTIoTovL17z2Lq1I2YO3coYmJ+RseOLfDFF6FISnqptn5CQir69JmLjh1bICbmZ4SGBiI4eAP277+gqBMVFYeAgCUYPtwLt25twfDhXvD3X4xr1x5o1e/KlXuwZs1fWL9+Mq5f3wiBwBze3rOQm5tPcVPcWqtM+x8ytpCQjTh06BLCw+fj4sW1ePOmAD4+8yCVvr+trVl6LJUEkaVHM4maoHc3E0I+WTk5OeDz+Xj9+ki5b1xxd5+INm0aYtOmEEVZs2Zfws+vA8LCxqrUnz17C44ejcL9+9sUZRMmrMGdO09x5coGAEBAwBLk5OTh+PHlijq9e8+BubkJdu+er1G/DMPA3n4IgoMHYPbsQADymRaBYBCWLx+H8eN9KvW5UNw1M+7Ktv+hYsvOfgNr64HYuXMO/P27AgBSUjLg6BiIY8eWoWfPz5TGlZOTBzMzX2RnZ8PU1FTrz6P454PFMm+wDblK52SFYmTOPVXptmsKmkkkhOg0kUiM6OhH8PZ2Uyr38nJFVFSc2muuXr0PLy9XpbKePT/DzZuPIBZLAABRUffh5aXcpre3G65cidO434SEVAiFmUp1DAz00blzqzLHpimKu2bFXZX2P1Rs0dGPIRZLlOrY2VmhefN6ir7eBzaHrfYgFaNPiRDyySgqKkJOTo7SUZGMjGxIpTLY2JgrldvYmEMozFR7jVCYqba+RCJFRkZ2uXWEwiyN+y2uW7qOtXVJO5VFcdesuKvS/oeKTSjMhL4+F+bmvDLbeR/YHDXPJFKSqBH6lAghn4ywsDDw+XzFUadOHY2vLf2qVoaB6vtcleornyt+MufdcnV1KnpFrLp+1bdTPc9MUdxl91/RWEqX/9fi3rUrEjxeH8VRPOtZmfY/ZmzV+X1Xp3h1c+mDVIySRELIJyM0NBTZ2dmKIzk5ucJrrKz44HDYKjMpaWlZKrMexQQCC5WZjbS019DT48DS0rTcOsVtatKvQCD/b+l20tNfw8bGrMLYykNx637cvr6eiI3dojisrPiVav9DxSYQWEAkEiMrK7fMvt4HLoel9qiMjRs3wsnJCYaGhnB1dcXFixfLrHvgwAF4eXmhdu3aMDU1hYeHB06ePFnZMD4KShIJIZ8MAwMDmJqaKh0V0dfnwtW1ESIiopXKIyOj4eHhovYad/dmiIxUrn/q1E24uTUClyvfXtbDQ7VORMRNeHq6aNyvk5MtBAILpToikRjnz98uc2yaorh1P24ezxjOzvaKo1mzupVq/0PF5uraEFyunlKd1NRXuHcvUdHX+6DPYas9tLV3716EhIRg3rx5iI2NRadOndC7d28kJSWprX/hwgV4eXnh+PHjiI6ORteuXeHj44PY2NiqhvTB0GbahBCdN3XqIIwcuRxubo3g4dEMW7YcQ1JSGiZMkK/2DA39FSkpGdixYw4AYMIEH/z002FMm7YR48b1QVTUfWzd+g92756naHPKlAHo3DkEK1aEw8+vAw4fvozIyBhcvLhO435ZLBaCgwcgLGw3GjZ0QMOG9ggL2w1jY0MMHdqd4qa4taJp+0FBy2FnZ6VY6f2hYuPzTTB6dG/MmLEZlpamsLDgYebMn9GihRN69Ghb5fjLwmYDKjlhJabIVq9ejTFjxmDsWPnntnbtWpw8eRKbNm1CWFiYSv21a9cqfb1s2TIcPnwYR48eRZs2bbQfwEdASSIhROf5+3fFq1c5WLLkd6SmZqJ583o4diwMdevaAACEwldISkpT1HdyssWxY8swbdpGbNx4BHZ2lli3bhIGDvxcUcfT0wXh4fPxzTfbsGDBdjRoYIc9e75B+/ZNNe4XAGbNCkBBgQgTJ65DVlYu2rdvipMnV4DHM6a4KW6tadJ+UlIa2O88k/chY1uz5n/Q0+PA338xCgpE6N69DbZtWwoOh1Mt8aujz2aDU+o1fNK3X5de/GZgYAADAwOVNkQiEaKjozFnzhylcm9vb1y5ckWjcchkMuTm5sLCwkKb4Ve7tLQ0CAQCyGSyCuvSPomEkE+WpvskEkI+PdW1T2LrLf3BMVbeJ1GaL8atrw6qXLNw4UIsWrRIpTwlJQX29va4fPkyPD09FeXLli3Djh07EB8fX+F4Vq1aheXLl+PBgwewtrbWOp7qkpaWBltbW402MKeZREIIIYToLA6bBU4Z725OTk5WSkDVzSK+q7Ir08PDw7Fo0SIcPnz4oyaIxTSdH6QkkRBCCCE6i8thQ6/UQ4mSt19rugDOysoKHA4HQqFQqTwtLQ02NjZlXCW3d+9ejBkzBvv27UOPHj20HL32duzYUe757OxsjduiJJEQQgghOkufw4JeqS1v2FpugaOvrw9XV1dERESgf//+ivKIiAj4+fmVeV14eDhGjx6N8PBw9OnTR7uBV9LUqVPLPa/NU4aUJBJCPqjExEQ4OTlpVNfFxQX37t17zyMihOgyDosFTunbxJXYvHvatGkYMWIE3Nzc4OHhgS1btiApKQkTJkwAIN/H9cWLF9i5cycAeYI4cuRIrFu3Du7u7opZSCMjI/D5/CpGVbbMzPLfXpOenl7h7GcxShIJIR8Ul8tF48aNNapbv3799zwaQoiu43Kgsnk2qxKLqf39/fHq1SssXrwYqampaN68OY4fP466desCAFJTU5X2TPz5558hkUgwceJETJw4UVEeFBSE7du3VyqW6qDNTCKtbiaEfLJodTMhuqu6Vjf33RsArrG+0jlxvgh/+++pdNv/dYcPH8aqVavw4MEDAEDTpk0xffp09O/fX6vVzfTGFUIIIYTorOLbzaUPXfXzzz/D398fzZs3x7p167B27Vq0aNECAQEB2LRpE4yMjBAUFKRRW3S7mRBCCCE6S5+t+q5mVuktcXTI999/j3Xr1mH8+PGKshEjRqB169ZYtWoVvv76a2zdulWjtmgmkRBCCCE6i6vmvc3cSry7+VORnJyM7t1VX/PYvXt3JCcna9WW7n5KhBBCCKnxOGz1h65ycnLCkSNHVMqPHj2q9WJAut1MCPnkLbj6Fwxq6VdcUYf4BF742EP4KOZ+3/ZjD+GjuHQu4WMP4cMTSaqlGX02C/plvHFFF33zzTcYNWoUrl27Bk9PT7BYLFy+fBkHDhzAtm3btGqLkkRCCCGE6Cw9NgvcUkmhTIeTxKFDh6JOnTpYtWoVNmzYAIZh0LRpU0RGRqJz585atUVJIiGEEEJ0FpulOnGowzkiAKBTp07o1KlTlduhJJEQQgghOovLUV3dLNPytXw1FSWJhBBCCNFZXLb8eJdMhxeucDgcjd+qIpPJyj1PSSIhhBBCdBaHJT9Kl+mqgwcPKv585MgRnDp1CmvWrAGXy9W6LUoSCSGEEKKz9FiqC1ekOvzGFV9fXwDyV/OFh4fD3t4ehw4dwu+//651Wzo84UoIIYSQmq544UrpQ5ft378fgYGB+OWXX3D16lXExMQgODhY63ZoJpEQQgghOourZgscqQ5nifv27cOoUaOwbds2+Pv7AwAiIyPh6ekJS0tLLFiwQOO2KEkkhNQIsQfv40b4Hbx5VQCremboNsUDDq0Eauu+ycjHuZ+uQRifgazn2XAd5IJuUzzKbPtB5FP8/e1ZOHesi/5hXopymUSGy9ti8CDiCfJeFaCWpTGa924Ij6A2infH5mXm4/ymG0i88QJFb4rg0MoWPUI8YF6HX22xO06dBMEwf+jxTZEbextP5y9G/qMnZdYXBA6G9aB+MG7UEADw5m4cEleuxptbdxV1bEcEwnZEIAwc7AEA+Y8eI2ntRmSdK9nku9HqMNgMHqDUdk7MLdz281d8bVi3Dpzmzwb/M1ew9PWRde4ini5YAnHGqyrF3M/ZC4GN+8LSyAyJ2c/xY+xO3MmIV1vX0tAME1sPR2NzJzjwBPjr8Umsj92pVIfD4mBEUz/0cvocVkbmSM5Nxabb4bguvK1xvxwWB+NaDIG7bWvYmVgjT1yAmy/vYvPtPXhVmFWleIt9/flAzPQaBlu+JeJSExCybw0uPbmttm7/1l3w9ecD0NqhIQz09BGX+i8W/f0rTj24plSPb2SC7/wmYEDrLjA35iEhIxXT96/DP3FRAAATA2Ms8f0K/Vt1hjXPHLHJjxC8bw1uPnugtt/NQ2djfKf+CNm3BuvO7K2WuMvD5ciPd0k56uvqglGjRmHnzp0YOHCgoszW1hanT59Ghw4dtEoS6XYzIUTnPTz9FGd+vAr3Ea0R9Fs/OLQS4K+ZJ5Dz8o3a+lKxFEZmhnAf2RrWzpbltp0tzMW5jdfUJpzXdt/G7cMP0D3EE6P/GITOX7fD9fC7iNkfBwBgGAYH50YiOzUX/cO8ELS1P0wFJvhz6j8QFYirHjgAh6/HwX7cl3g6fzFu9R0EcXoGmu/eBk6tWmVew/doj/TDx3DXfyRu9wtAUUoqWvyxFfoCa0WdolQhEsK+x60+A3Grz0C8vnIVzX77CcaNnJXayjx7AVfbdlAccUFfKc6xjYzQfNdWgGFwJyAItwcEgqXPhcu2zUAVnhnrVscdU1qPxO8PDmHMyVDczojHqs/nwNpY/feSy9bD66Ic7HxwCE9eJ6mtM67FEPg26I61Mdsx4p+ZOPwkEss6TENDs3oa92uop49G5k7Ycf8gxpyai3mXV6MOzxbLO82odKzvGuLaA2sHh+C7E9vRZlkQLj65hX8mrkEdcxu19T9v2BoRD67ji5+mwTVsFM4+isbR/32P1g6NSj4bjh4ipvyIeha2GLRlLhov8se4XWF48TpdUefX4XPh1aQdRmz/Fi2WDsepB9cRGbwedvzaKn36tfoc7eu54MXrtGqJWRMcFkvtoat27dqllCAWq1+/Pk6ePKlVW5QkEkKqhMViKQ4ejwc3NzccOHDgYw9Lyc2999CiTyO09GkCy3rm6DbFAzzrWrh1UP1MB9+Wh+7BHmjeqyEMapW9IlAmleHY4nPoMNoVfFueyvmUe2lw7lgXDTwdwbfloXFXJ9RrZw/hwwwAQFZyDlLj0uA1vQNsm9aGhaMZvKZ5QlQgxsPIp9USu/2YkUhevxmvTkQgP/4x4qfOBsfQELX79S3zmvgpM5C6czfy7j9EwdN/8XjWfIDNhlmHktnUzMizyDp7AQUJiShISMSzlWshzc8Hr01r5c9IJII4PUNxSF5nK86ZftYWhg72eDRtDvIfPkL+w0d4PD0UvNYtYdbBvdIx+zfug2MJZ/H3v2fxLDcF62N3Iq3gFfo38FJbX5ifgR9jd+Jk4kXkifPV1ulZrxN+f3AIV1NvITUvDYeeRuK68DYCGvfRuN88cQGmnV+Gs8lXkZybivuvnmBtzHY0sahfZgKrjWndA/HblaP47fIRPBQmYuq+tUjOSsPXnw9QW3/qvrVYFfEHbj57gCfpyZh3eDMepyXDp2VHRZ3Rnj6wqGWKfptn4cq/d5CUKcTlp7dx54V8JtqQa4CBbbpg1sENuPjkFp6mP8e3x35FQkYKvu6s3K8dvzY2+M/AsG0LIZZKqxyvpvTYJdvgFB96Opz99OvXD3fv3sXw4cPRrFkzNG/eHEFBQbh79y5atmypVVs6/DERQj6Ubdu2ITU1FTdu3ECrVq0wePBgREVFfexhAZDPCgofZaBeOwel8nqfOeDFvZdVavvK9lgYmRmiZd/Gas87tBTgWXQKMpPkiVHak1d4cUeI+h51FGMDAI5+yb0vNocNjh4bz+9UbWwAYOjoAH0ba2RduKQoY0RiZF+7AVPXNhq3wzEyAourp5TgKWGzUdv3C3CMjJEbE6t0ysy9HdrHXoHr+RNwXrEEXEuLksv09QGGgUwkUpTJiorASKUw/cxV4/G9S4/NQSNzJ1wX3lEqvyG8g+ZWjcq4qmJcth5EUuXZ3SKpGC1qN65Sv7W4xpAxMrwRqU9ONR4fRw+ujo1x6r7yreJTD67Bs34LjdpgsVjgGRojMy9HUebbshOi/r2HnwJmQrjiOO5+swuhvYLAZsnTBz02B3ocPRSKRUptFYiL0LFBK6W2f/9yIVZF/IH7qR/2PdTFzySWPnRVdHQ0PDw88PLlS3h7e+Pp06cwNjZGhw4dcOXKFa3aoiSREFJlZmZmEAgEaNKkCTZv3gxDQ0McOXIEAHD37l1069YNRkZGsLS0xFdffYU3b0pu8547dw7t2rVDrVq1YGZmhg4dOuDZs2fVNraC7EIwUga1zI2UymuZGyEvs6DS7T6/I8TdY/HoOavsV1+1G9YSTbs3wG/D9+GHLr9hx+iDcB3cHE17NAAAWNQ1g6nABBd/voHC3CJIxVJc++M28jILkPeqakkDAHBry2/3lX6+T5SeAX1rK43bqRc6HSLhS2RdUv4HxrhJI3g+jEHHp3fhvOxb3B83EfmPS2ZAM89ewMMpM3A3IAgJS1aA16oFWuzdAZa+fHY2N+YWpPkFcAqdCbahIdhGRnCaNwssDgf61qq3KjXB1zeFHpuDrELlhDarMBsWhpV/zvO68A78G/eBg4kALLDgZtMCHe1dYWloVul+9dlcTGgZiMhnV5AvqfzfRQCwMjGDHkcPL3Mzlcpf5mZCwNdslnJ6j6GopW+EP2NOK8rqW9lhUNuu4LDZ+OKnqVj6zzZM7z4U83qPAgC8KcrHlad38M0Xo2HLtwKbxcawdr3Qvp4LbN/pd7b3CEikUvx49s8qxVkZNW1187x58zBq1ChEREQgODgYenp62LRpE7777juEhoZq1RYtXCGEVCsulws9PT2IxWLk5+ejV69ecHd3x40bN5CWloaxY8di0qRJ2L59OyQSCfr164dx48YhPDwcIpEI169fB6uM54WKiopQVFSk+DonJ0dtPbVKNcmAqfRjb6J8EY4vPYeeszrB2MywzHoPT/+L+xFP0HdBV1g5mSPt8SucWX8VJlbGaN67ETh6bPgt7YETyy9g/Re/g8Vhoa6rPZzcHcpsszy1+/mg4fJvFV/HjRoPAKpvX2CxoOELGeAwYSxq+/XBncEjwRSVmi16moCYXv2gZ2oKq97eaLxmBe4MHq5IFDOO/qOomx//GLl37qFd1BlYdOuCVyciIM7MwoOvg+G8bBHsRo8AZDKkHT6G3Dv3wFTwJoiKqIbHAqOmVFM/xu7ALLdx+KP3D2DAIOXNSxxPOI8vnDpXql8Oi4NFHpPBZrHwQ/TWSo+rtNLfaxZYGr19I8DNC4v6jIXf5llIzy1ZRMNmsZGWm4Wvdi2HjJEhJikedvzamOk1DEuOy8c9Yvu32DpiHlKW/w2JVIKY5HjsvnEKbR3ls6xtHRsjuKs/2oYFVVuc2lA3cyjR4SwxKioKK1asAKD896FPnz6YPXu2Vm1RkkgIqTZFRUVYtWoVcnJy0L17d+zatQsFBQXYuXMnar1dKLFhwwb4+PhgxYoV4HK5yM7ORt++fdGggXx2rWnTpmW2HxYWhm+//bbM8+oY8Q3B4rBUZg3zswphXGp2UVNZL3KRnfoGB+acUpQxMvkP4++7/IYxuwbD3N4U5zddR7thrRQzh7UbWCDn5Rtc++M2mveW34IUNLbCqG0DUPRGBKlYCmNzI/zx1WHYNNF8pq9YZsQZxNwqWcnK1tcHAOjXtoI4rWShgb6VJcTpGRW2Zz9+NOpMGo+7Q79E/kPVlcGMWIzCRPlCjzd37sGkVQvYjR6JJ6EL1bYnTktH0YsUGDnVU5S9vnAZNzt6Qc/cHIxUAmlOLtpHX0J60nONYi4tW5QDiUyqMntnbmiKrEItfqko5XVRLuZeXg19NhemBibIKMjChJaBSM1L17pfDouDxZ7BsDWxRvDZpVWeRQSAjDevIZFKIDBVnjW05pnjZU5mGVfJDXHtgd9GzMPgX+bi9MMbSudSszMglkkhY0qS9gfCRNjyrcDl6EEsleDfjBfosuZ/MNY3hKlhLQhzXmHPmKVIyEgBAHRybg1rnjmSvjukaEOPo4cfBk5BSLcAOM3vX8Xoy6enJkkU63CSyDCM4uftu9LS0lC7tnYz9JQkEkKqLDAwEBwOBwUFBeDz+fj+++/Ru3dvTJs2Da1atVL6gdWhQwfIZDLEx8fj888/x6hRo9CzZ094eXmhR48eGDJkCGxtbdX2ExoaimnTpim+zsnJQZ06dcodG4fLgaCRFZ7deIFGn9dTlD+78QLOHetWKl5LRz5G7VB+KP/SL9EQ5YvRLdgdptbyeMWFEpXZShabpUgo32VgIk/ospKzIYzPQIex2j+TJ83LgzQvT6lM9DIN5p06IC9OvkiHxeWC3/4zJIR9X25b9uPHwHHK17g3fAze3LmnUf8sFgtsA/0yz+uZmcHA1haiNNWVrZIs+ewV39MdXCtLZEac0ahPlXZkUjzKSsBngpa4+OKmovwzmxa49CK6Um2+SyQTI6MgCxwWB50d2uFs8lWt+i1OEB14AgSfXYIckfoV9toSSyWIToqHV9N2OHT7vKLcq2k7HL59oczrAty8sHXEPARuXYDj91SfV7v87x0M/awnWKySGclG1nWQ8jodYqlEqW6+qBD5okKYGfPQs1l7zDq4AQDw+7V/EFkq+Tw5eS1+v3YC26L+rnTMmmKzWGCX+h+x9Ne6pEGDBrh//z6cneU7DTAMg0uXLiEkJAT9+vXTqi1KEgkhVbZmzRr06NEDpqamsLYu2SaFYZgybx0Xl2/btg1TpkzBiRMnsHfvXsyfPx8RERFwd1dd3WpgYAADAwOtx+fm3xzHlp6HoIkV7FyscftIPHLS3qBVvyYAgAubbyA3Iw995ndRXPPysfw5PlGBBPmvC/Hy8Stw9NiwcjKHnoEeate3UOqjOMl7t7yBpyOu/n4LpjYmsHIyx8vHrxQrrYvFn/0XRmaGMLUxQfrTLJz5MQrOnerCqV3lbjmX9uK3nagzaTwKEhNRkPAMdSaNh7SwEOmHSv5xbrRmBUTCl0hcsRqA/BZz3RnBeDh5OgqfvwC3tnxWU5qXD1m+/FnJurOnIuvsBRSlCMExqYXavl+A79EO90aMBQCwjY1Rd9okZBw/BVFaOgwd7FFv9lSIs7Lw6kSkom+bIQOQ//gpxJmZ4LVtgwbfzsWLX7ej4N/KL27YG38M89tPxMPMfxGX8Qi+DbrD2tgKh57K+x3fIgBWxub47tomxTXOZvJfGIz0DGFmwIOzWV1IZBIk5rwAADSzaAArIws8fv0MtY3MMbr5ILBZLOx+eFTjfjksNpZ0CEEjcyfMvrgSbBZbMfOYI3oDiaxqK35Xnw7H76MW4uazB4hKuIevOvrB0dwGmy/K3+W7zO9r2JvVRtCOxQDkCeLOUQsR/OcaXE24BxtT+d/dAlERcgrlv2xsunAAk7sMxrrB07D+3J9oaF0Hc3uNUnq20Ltpe7BYLMS/fAbn2nWwasAkxL9MwrYr8r9jmXk5SothAEAslUKY8wqPXqrfcqg66bHY0GNzVMp0lb+/PyIjIxWv5yssLESXLl0QFBSEsLAwrdqiJJEQUmUCgUDxW+u7mjVrhh07diAvL08xm3j58mWw2Ww0alSSKLVp0wZt2rRBaGgoPDw8sHv3brVJYmU16d4ABTlFuLI9Fnmv8mHlZI6BK3uCL5BvW/PmVT5yS+2ZuHP0QcWfX8Zn4EHEU5gKTDB+X4DG/faY6oFLv0YjcvUV5GcVoJaVMVr5NYHnqJKVxW9e5ePshmvIyyyAiaUxXHo5wyNI85XHFXm+6RewDQ3gvHQh9Ph85N66jXvDRivNOBrY2wLv3E60HRkItoE+mm1Zr9TWs9XrkbRGPjukb2WFxmtXQt/aGpLcXOQ9iMe9EWPx+uLb2SiZFLWaNIL1wH7QM+VBlJaO7KhrePC/qUp9G9V3Qr3Z06Bnxkfh8xdIXr8ZL37ZXqWYzyRfhakBD6NcBsDS0AwJ2cmYdXEFXubLb7FbGpnBxlj5dv62nssVf25iUR/edTsiNS8dQ/6eIo+Xo49xLYbA1sQaBZIiXE2NxZKrG/HmnS1zKuq3tpEFOtm7AQC291yh1P/kM4txK139lkya+jM6Epa1+FjQZwxsTS1xL/VffPHTNCRlCgEAtnwrOFqU7Oc5vlN/cDl62Bg4ExsDZyrKt0cdw5c7lwAAnmelwfvHYKwZHII78//Ai9fpWHd2L1acLHkPMN/IBGH9voaDmTUy83OwP/Ys5h3eXOWkt7rosdnQY7NVynTVnDlzFH92dHREXFwcnJycoK9f9ix/WViMJk+0EkJIGVgsFg4ePKj2NkZ+fj6cnZ3h6emJRYsWIT09HWPHjkWnTp2wfft2JCQkYMuWLfD19YWdnR3i4+MRGBiIpUuX4uuvv66w75ycHPD5fEw5MRIGtbT/Afgp8wks+xaiLpv7fduPPYSP4tK5D7ttzH+CSAJsjUZ2djZMTU21vrz458PeOxNhzFO+A5GfWwT/lj9Vuu2agmYSCSHvjbGxMU6ePIng4GB89tlnMDY2xsCBA7F69WrF+YcPH2LHjh149eoVbG1tMWnSJIwfP/4jj5wQois4LA70WByVMl1Vv379cle0JyRo/gsHJYmEkCqp6GZEixYtcOaM+kUINjY2OHjwoNpzhBBSHfTYHNVnEtm6mySGhIQofS0Wi3H37l0cO3ZMaeGfJihJJIQQQojOqmmrm6dMmaK2fPPmzbhx44bac2XR3Sc3CSGVkpiYqPQ+5vKO5s2bf+zhEkJIuYoXrpQ+ahpvb2/s27dPq2toJpEQooTL5aJxY/XvIi6tfv3673k0hBBSNXpqnkks/XVNsG/fPpibm2t1DSWJhBAl9vb2ePjw4cceBiGEVIuadru5bdu2Ss+KMwwDoVCIjIwMbNq0qZwrVVGSSAghhBCdxWGrbqbN0eHbzaW3I2Oz2bC2tkaXLl2U9qfVBCWJhBBCCNFZNW1184IFC6qtLUoSCSGEEKKzatrt5upESSIhhBBCdJYe2CrvatajzV00QkkiIYQQQnRWTbvdXJ0oSSSEfPIWuw+CqWmtjz2MDysp8GOP4KOomW+sBjDkYw/gw8vJyYPZVt8qt8NiscEqNZNY+muiHn1KhBBCCNFZbJYeOKUONkt358h8fX1x6NAhSKXSKrdFSSIhhBBCdBaHxVFJEjk6vpl2YGAgHBwcMGvWLMTHx1e6HUoSCSGEEKKz2Cy22kNXHTlyBGlpaZgzZw5++OEHtGjRAh07dsTWrVuRn5+vVVu6+ykRQgghpMZTnUWUH7qMx+PBy8sLbDYbL168QEBAAH7++WfY2tpi3LhxiIqK0qgdShIJIYQQorNqYpL4rtq1a2PSpEm4du0abt68CR6Ph06dOml0bc35lAghhBBS49DqZkAqleLEiRPYtWsX/v77b3h7e2t0Xc36lAghhBBSo8hnDrmljpozRzZ58mTY2dlh8uTJaNasGe7fv4/jx49rdG3N+ZQIIYQQUuOw1dxe1uUtcGJjY7F//37s378fXC4XWVlZCA8PR7du3bRui2YSCSE1wsaNh1G//jAYGfWCm9sEXLx4p9z658/fhpvbBBgZ9UKDBsOxefNRlTr791+Ai8uXMDTsBReXL3Hw4CWt+2UYBosW7YC9/RAYG/dG167TEBeXWKVYq6P9DxVbUZEIkyevR+3a/WFi0gd+fvPx/Hl6VULWuG91KO5PM+7y1LTVzW5ubjh+/DgmT56M1NRU/PHHH5VKEAFKEgkhGurSpQtCQkLKPL99+3aYmZl9sPFoY+/es5g6dSPmzh2KmJif0bFjC3zxRSiSkl6qrZ+QkIo+feaiY8cWiIn5GaGhgQgO3oD9+0ve9xEVFYeAgCUYPtwLt25twfDhXvD3X4xr1x5o1e/KlXuwZs1fWL9+Mq5f3wiBwBze3rOQm6vdVhVlqUz7HzK2kJCNOHToEsLD5+PixbV486YAPj7zqrwRMMVds+IuT01buBIdHY2YmBj873//A5/PV5QXFhZix44dWrXFYhiGqe4BEkJ0T2ZmJrhcLng8HurVq4eQkBClpLGgoAC5ubmwtrb+YGPKyckBn8/H69dHyn0tn7v7RLRp0xCbNoUoypo1+xJ+fh0QFjZWpf7s2Vtw9GgU7t/fpiibMGEN7tx5iitXNgAAAgKWICcnD8ePL1fU6d17DszNTbB793yN+mUYBvb2QxAcPACzZ8tfs1dUJIJAMAjLl4/D+PE+lfpcilW2/Q8VW3b2G1hbD8TOnXPg798VAJCSkgFHx0AcO7YMPXt+RnHX4LhzcvJgZuaL7OxsmJqaav15FP98eJn5J0xNjUudy4eNxRCt2964cSNWrVqF1NRUuLi4YO3ateWuFD5//jymTZuGuLg42NnZYdasWZgwYYLWsWhDJBJh//79SExMhEgkUpS/efMGP/zwAxYuXAgAiv+Wh2YSCSEasbCwAI/HK/O8kZHRB00QNSUSiREd/Qje3m5K5V5eroiKilN7zdWr9+Hl5apU1rPnZ7h58xHEYgkAICrqPry8lNv09nbDlStxGvebkJAKoTBTqY6BgT46d25V5ti0Udn2P1Rs0dGPIRZLlOrY2VmhefN6ir4qg+KuWXFXhAW22kNbe/fuRUhICObNm4fY2Fh06tQJvXv3RlJSktr6CQkJ+OKLL9CpUyfExsZi7ty5mDJlCvbv31/VkMo1fPhwjB8/Hnv27MHhw4cVx8mTJ8FisXD48GEcOnRIo7YoSSSEaKT4dnOXLl3w7NkzTJ06FSwWCywWC4Dy7eb4+HiwWCw8fPhQqY3Vq1ejXr16KL6Bcf/+fXzxxRcwMTGBjY0NRowYgYyMjGodd0ZGNqRSGWxszJXKbWzMIRRmqr1GKMxUW18ikSIjI7vcOkJhlsb9FtctXcfauqSdqqhs+x8qNqEwE/r6XJib88pspzIo7poVd0Wq67V8q1evxpgxYzB27Fg0bdoUa9euRZ06dbBp0ya19Tdv3gxHR0esXbsWTZs2xdixYzF69Gh8//33VQ2pXJGRkbh48SJu376NmJgYxXH69GkwDIOYmBjExsZq1BYliYQQrRw4cAAODg5YvHgxUlNTkZqaqlKncePGcHV1xa5du5TKd+/ejaFDh4LFYiE1NRWdO3dG69atcfPmTZw4cQIvX77EkCFDyuy7qKgIOTk5Soem3uayCgwDRYKrvr7yueLE9t1ydXVKN6lJv+rbKXtsZdm1KxI8Xh/FUTzrWZn2P2Zs2sZPcdesuLXFYeupPQCo/DwpKipS24ZIJEJ0dLTK/oLe3t64cuWK2muioqJU6vfs2RM3b96EWCyuhsjUy87OhoODg0p5ZT5nShIJIVqxsLAAh8MBj8eDQCCAQCBQW2/YsGHYvXu34utHjx4hOjoaw4cPBwBs2rQJbdu2xbJly9CkSRO0adMGW7duxdmzZ/Ho0SO1bYaFhYHP5yuOOnXqVDheKys+OBy2ykxKWlqWyqxHMYHAQmVmIy3tNfT0OLC0NC23TnGbmvQrEMj/W7qd9PTXsLExqzC20nx9PREbu0VxWFnxK9X+h4pNILCASCRGVlZumX1pguKuWXFri8WoPwCgTp06Sj9TwsLC1LaRkZEBqVQKGxsbpXIbGxsIhUK11wiFQrX1JRJJtd8xede2bdvUPhrE5/Oxbds2NVeUjZJEQsh7ERAQgGfPnuHq1asAgF27dqF169Zo1qwZAPkKvLNnz8LExERxNGnSBADw9OlTtW2GhoYiOztbcSQnJ1c4Dn19LlxdGyEiIlqpPDIyGh4eLmqvcXdvhshI5fqnTt2Em1sjcLnyGQgPD9U6ERE34enponG/Tk62EAgslOqIRGKcP3+7zLGVh8czhrOzveJo1qxupdr/ULG5ujYEl6unVCc19RXu3UtU9EVxU9xVJpOoPwAkJycr/UwJDQ0ttyltZ0o1uSNR3UaOHAl9fX2V8tzcXI0Wq7xLd9eAE0I+KltbW3Tt2hW7d++Gu7s7wsPDMX78eMV5mUwGHx8frFixQu216hgYGMDAwEDrsUydOggjRy6Hm1sjeHg0w5Ytx5CUlIYJE+SrPUNDf0VKSgZ27JgDAJgwwQc//XQY06ZtxLhxfRAVdR9bt/6D3bvnKdqcMmUAOncOwYoV4fDz64DDhy8jMjIGFy+u07hfFouF4OABCAvbjYYNHdCwoT3CwnbD2NgQQ4d21zrO0jRtPyhoOezsrBQrvT9UbHy+CUaP7o0ZMzbD0tIUFhY8zJz5M1q0cEKPHm0pboq7esikiqRQqQyAqampRqubrayswOFwVGYN09LSVGYLiwkEArX19fT0YGlpqUUA2vn7778xffp0JCYmqr2tzWbL5wdlMlmFbVGSSAjRmr6+vkb7mg0bNgyzZ89GYGAgnj59ioCAAMW5tm3bYv/+/ahXrx709N7vjyJ//6549SoHS5b8jtTUTDRvXg/HjoWhbl35D3eh8BWSktIU9Z2cbHHs2DJMm7YRGzcegZ2dJdatm4SBAz9X1PH0dEF4+Hx88802LFiwHQ0a2GHPnm/Qvn1TjfsFgFmzAlBQIMLEieuQlZWL9u2b4uTJFeDxlLfsqCxN2k9KSgObXTKz8SFjW7Pmf9DT48DffzEKCkTo3r0Ntm1bCg5H+4UFFHfNjbtcMpn8KF2mBX19fbi6uiIiIgL9+/dXlEdERMDPz0/tNR4eHjh6VHkT/lOnTsHNzQ1cLler/rUxffp0eHl5oXv37kqfa3Z2NoKCgjRe2QzQPomEEA116dIFrVu3xtq1a+Ht7Q0jIyNs3LgRBgYGsLKywvbt2xESEoLXr18rrsnJyYGNjQ0aN24MKysrREZGKs6lpKSgdevW6Ny5M2bOnAkrKys8efIEe/bswS+//KLRPxqa7pNICPn0VNc+idnC3Wr3SeQLhmrV9t69ezFixAhs3rwZHh4e2LJlC3755RfExcWhbt26CA0NxYsXL7Bz504A8i1wmjdvjvHjx2PcuHGIiorChAkTEB4ejoEDB2odj6b09fWRnJysMsOZlpYGgUCg0QxiMXomkRCitcWLFyMxMRENGjRA7dq1y6xnamoKHx8f3L59G8OGDVM6Z2dnh8uXL0MqlaJnz55o3rw5goODwefzFbdDCCGkyqQS9YeW/P39sXbtWixevBitW7fGhQsXcPz4cdStWxcAkJqaqrRnopOTE44fP45z586hdevWWLJkCX788cf3miACgIODg9rHcjgcDurVq6dVWzSTSAj5ZNFMIiG6q9pmEp9vVz+T6DCq0m3XFPRMIiGEEEJ01zurmZXKdNS3335b5jmGYbBo0SKN26IkkRBCCCE6i5FKwEjFKmW66vDhw0pf5+Xl4dmzZ+ByuXB2dqYkkRBCCCFETgYwpRdraLe6+VMSExOjUpaZmYnhw4dj8ODBWrVFT4cTQgghRHeVs5l2TWFhYYGwsDAsXbpUq+toJpEQQgghukvdamYdvt1cFg6Hg2fPnkEikWi8Ny0liYQQQgjRXYya280qt591X/PmzSGRaJccU5JICCGEEN1Vzmv5dFG3bt1Q1u6GDMPg3LlzeP36Nfr374+zZ8+W2xYliYQQQgjRXTXsdnPr1q0rrMPlctGmTZsK61GSSAj59BXkAlzdnRlQi1NDf3xz9D/2CD6OmvgWouq6JVzDbjevXr26wjq1atXSqF4N/SlDCCGEkBpBIpUfpctIhShJJIQQQojukkqA0gs2dPh2c/369ct8JrG0hISEcs9TkkgIIYQQ3SVj5EfpMh01evRo/PDDD+jQoQPc3d0BAFFRUbh8+TJmzJih1buqKUkkhBBCiO6SSFVnEnX4dnNcXBzmzZuHGTNmKJWvWrUKt27dwq5duzRuqwY+CUsIIYSQGqP4mcTSh446evQo/Pz8VMr79++PI0eOaNUWJYmEEEII0V3Ft5tLHzrK1NQUp06dUik/ceKEVreaAbrdTAghhBBdJpUAEo5qmY6aO3cupk6disuXLys9k/jXX39hzZo1WrVFSSIhhBBCdBYjlYKRSlXKdNWkSZPQpEkTrF27Fj/++CMYhkHTpk1x4sQJdO/eXau2KEkkhBBCiO6SyeRH6TId1qNHD/To0aPK7dAziYSQGoFhGCz6bg/sG4yGsaU/uvaaj7j7SRVet/9QFFxcJ8PQfDBcXCfj4JGrSucvXIqD76DvYN9gNNi1+uPQ0Wtq23nwMBl+g5fBzHYYTG0C4dFlNpKS05XqRF17iO69v4FJ7QCY2w1D117zUVBQVPmg8TbuJbth7xQEY7OB6OoVirj7zyq8bv/By3Bp/T8YmvaHS+v/4eDhKKXzFy7eg++AxbB3CgLb0AeHjiifF4slmD1vO1q6ToKJxSDYOwUhaPRqpKS8UqpXVCTG5Kk/o7b9UJhYDILfwCV4/jyjSjEr4l78O+wdA2HM80HX7jMRF5dYcdwHLsKl5TgY1uoLl5bjcPDQZZU6GzcdRf2GI2Fk0hdu7Sbi4qW7ZbY3/ut1YHN7Yu26A4qyxEQh2Nyeao99f12oVLzFGIbBom93wt7BH8a1+qBrt+maxb3/Ilyaj4Gh0RdwaT4GBw9eUqmzcdMR1G8wAkbGX8Dts//h4sWSuMViCWbP+QUtW42DCc8H9g7+CApagZQU5e/l06cpGDBgEaxtBoFv5gd//yV4+TKrSjFXqIYtXClWWFiI5ORkPHv2TOnQBiWJhJAaYeXqg1iz/gjWrx6H6xdWQmBjDm+fRcjNLSjzmqhrDxEw8nsMD+iCW1fXYHhAF/iP+B7XbjxS1MnLK0TLFvWwfvW4Mtt5+m8qOnnNReNG9jj7zxLcuroG8+cMhqEBV6mv3v2WwKt7a1w7vxLXL6zCxPFfgF3F17Gt/GE/1vx4COvXjMf1y6shEJjDu88C5Obmlx331YcIGL4Sw4d2xa0bP2L40K7wH7YC167Hl8SdX4iWLZywfs14tW3k5xchNvYp5of6I/rqWuzfE4pHT1LgN2ipUr2QGb/g0JEohO+chYtnVuDNm0L4DFgMaRVvB678/k+sWXsA69dNxPWo9fK4e4eWH3fUfQQMXYbhw7rjVvRGDB/WHf6B3+HatYeKOnv/PIep0zdj7pxAxNzYiI4dm+OLvvORlJSm0t6hw1dw/fpD2NlZKpXXqVMbKcnhSseihSNQq5Yhevf6rGpxr9qLNWv2Y/2Pk3D92gYIbCzg3XN2xXEHLsXw4T1wK3Yzhg/vAf+Apbh27UFJ3HvPYerUTZgbGoiY6E3yuPvMVcSdn1+E2JgnmD9vOKJvbsT+vxbi0ePn8Ou3QNFGXl4BevaaAxYLOB25CpcuroVIJIGv3zeQvc+ZPYlMTZKouzOJDx8+hKenJ4yNjVG3bl04OTnByckJ9evXh5OTk1ZtsRhNt+UmhJD/mJycHPD5fLxO3QVTU+My6zEMA/sGYxA8sS9mTx8AQD6DJXAaheVLRmL8mJ5qrwsY+T1ycvJx/FDJP3S9/RbD3KwWdu+YrlKfXas/DuyZg34+7ZXKA4N+AFePg52/hZQ5Ro8us9GjWyssWTC0vJBLaPDuZoZhYO8UhOBJvpg9YxCAt3E7jsDypUEYP6632usChq+Qx33kW0VZb5+FMDczwe7fZ6rUZxv64MCfc9HP16Pc8dy4+QjtO05H4qPf4OhojezsPFg7DMfOrdPgP7gTACAl5RUcnUfj2OGF6OnVVk3cFb+7mWEY2DsORfCUfpg90/9t3CII7AOwfNkYjP+qj/q4h34nj/vv70ri7jMX5uY87P4jFADg7jkFbdo4Y9NPUxR1mrUYCz9fT4R9N1pR9uJFBtw7BOPEse/Q128Bgif3Q0jwgDLH3Nbtf2jTxhm//TJNfQUNfllgGAb2DgEIDu6P2bMCSuK2HYLlYWMxfnxf9XEHLJXHfXxZSdy9Q2FuboLdu+fJ4/aYLI97Y3BJ3C6j4efXAWHLxqht98aNeLR3n4TEhF1wdLTGqVM38UWfech8dQCmprUAAFlZubC0GoBTJ1egRw/l73dOTh7MzPshOztb61W58uvlPx+yDoyFaS3lvzc5eSKYD/i10m3/l3Xo0AFcLhdz5syBra0tWCyW0vmWLVtq3BbNJBJCdF5C4ksIX2bBu3trRZmBARedO7og6urDMq+LuhYPr3euAQDvHq1x5Vq8+gvUkMlkOHbiJho2tEMv329hUzcI7p1nKd2WTkt7jWs3HsG6Nh8dus2BoN4odOk5D5eu3Ne4H3USEl5CKMyCd482ijIDAy46d2peftxXH8LrnWsAwNurDa5cfVDGFZrJzs4Hi8WCmZkJACA65gnEYonS+OzsLNHcxRFXoirfV0KCEEJhJrx7uCrKDAz00fnzFoiKKvszjbr6AF7vXAMA3l5uuPL2GpFIjOiYx/D2Uq7j1cNVqV2ZTIaRo1ZixrRBcHGpV+F4o6Mf49btpxjzpfpfVjSliNvLTVEmj7tlBXHfh5d3qbh7loo7+pFq3F6uiIqKK7Pd7Oy8t99veUJYVCQGiyX/O1jM0FAfbDYbly7f0zxQbUnV3GrW4YUrt2/fxqZNm9CrVy+0atUKLVu2VDq0QUkiIUTnCV++BgDY2JgplVtbmynOlXWdjbXyNTbWZhBq8QxVWlo23rwpxIofDqCnVxucPLII/XzaY2DgCpy/KP+H8d/ElwCAb5ftwdhRXvjn0AK0adUAPfosxOMnKRr3pTr+LMWY32VdQQzVEXdphYUihH6zA0P9OytmfYUvs6Cvrwdzc5Nq7UsozJS3Y2OuVG5tbV5+3MIslb8jNjZmEArl12Rk5EAqlal+NjbK412x6k/o6XEwZXI/jcb727YTaNrUEZ6eLhrVL0tJ3Mrjs7YxV5xTf10WbKyVPysba/N34s6Wx13q87SxKalTWmGhCKFzf8XQwG6KWUN396aoVcsQs+f8ivz8QuTlFWDmrC2QyWRITS17fFUmkag/dFTjxo2Rnp5ecUUNUJJICPlkFBUVIScnR+lQZ9ee8+BZByoOsVj+DwKrVD2GYVRuxZRW+rwm17xL9vaJHr8+7TB1si9at3LCnBkD0be3G37+9aS8ztuNfb8a3RNfjuyONq3rY83K0Wjc0B5bd57WuK9d4efAsxysOBRxVyIG1WtUyzQlFksQOGIlZDIZfvrx6wrra9vXrt1nwDPzUxzit4sSSjchj7v8ttTHXVGdknajox/jx/WHsO23GRrFUFBQhPA9ZzG6ErOIu3adBs/UR3FU7fut/LW6z0rTdsViCQIDv4NMxuCnnyYrymvXNsOfe7/B339fBc/UF2bm/ZCTnYe2bRuCw3mP6UgN20x75cqVmDVrFiIiIpCRkYHs7GylQxu0BQ4h5JMRFhaGb7/9tsJ6vn3aof1njRRfFxWJAchnyGxtLRTl6enZsLHml9mOwEZ1RistPVtlJqk8VpY86Olx0LRpHaXyJo0dcPntLVVbgXyGplkTB6U6TZs4IDlZ85W+vn3boX07dXFnqYm77BjUx606u6gJsVgC/2ErkJD4EqdPfKf07KjAxhwikQRZWW+UZhPT0l/Dw72Jxn34+rijfbvGiq8VcQuzYGtbsmgkPf21yozZuwQC1ZmxtLTXihk0KytTcDhs1c8mLVvR7sVLd5GW9hp16w9XnJdKZZgx6xesW38ICU92Kl371/6LyM8vwsjh2m9X4uvrgfbtSz6nMuN+JwZ1BALVGda09Hfj5svjLjUbKf9szJTKxGIJ/P2XIiFRiNORqxSziMW8vd3w5PFOZGRkQ0+PAzMzE9jaDYGTk0DzwLXEiKVgxFKVMl3l7e0NAOjVqxfULTvRZpEQzSQSQj4ZoaGhSr8RJycnq63H4xnBuYGt4mjWtA4ENuaIOHNbUUckEuP8pbhykxGP9o0R+c41ABBx+hY82zcu4wpV+vpcfObqjEePXiiVP36Sgrp1agMA6tW1hp2tBeIfK99afvQ4BY6OtTXui8czhnMDO8XRrKkjBAJzRJy+pagjEolx/uK98uN2b4LId64BgIjIWHi6N9V4LEBJgvj4SQoiji+FpaXyAgHXts7gcvUQcTpWUZaamol7cUnw9NC8Lx7PGM7O9oqjWbO6EAgsEHE6RlFHJBLj/IW78PBoVmY7Hu5NEfnONQAQERkNz7fX6Otz4dq2ISIiletEno5RtDtieA/cjtmM2JubFIednSVmTB+EE8e+Q2lbt52Er487atc20zjeCuOOjC4V950K4m6GyIhopbKIU6Xidm2kGndkDDw8Sm6RFyeIj5+8QMSpFSrf73dZWfFhZmaCM2dikZb2Gr4+5S96qhKxTP2ho86ePas4zp07p3Jog2YSCSGfDAMDAxgYGGh9HYvFQvDEvgj7/i80dLZFwwa2CFu1H8ZGBhg65HNFvaCx62BnZ4GwxSMAAFP+1xedvedhxQ8H4Ne3HQ7/fR2RZ+/gYmTJKtA3bwrw5KlQ8XVC4kvcup0ACwsTOL5NAmeE9EPAyB/QqWMzdP28BU5ExOLo8Rs4e2KJYnwzQvph0Xd70KpFPbRu6YQdu87i4aMX2LdLdTWxVnFP8kXYyn1o6GyHhs52CFvxJ4yNDTA0oHNJ3KNXw87OEmFLg+RxT/RF5x5zsOL7v+Dn0x6Hj15D5JnbuHhmRam4U0vF/S8szE3g6GgNiUSKwYHLERP7FEcPLoBUKlPM0llYmEBfnws+vxZGj/LCjNlbYWlhCgsLE8ycsxUtmtdFj26tqhb3lH4IW74HDZ3t0dDZHmErwuVxB3YtiXvUStjZWylWJU+Z1A+du83AilV74efjgcNHoxB5OhYXz61WXDM1ZABGjloFN9dG8HBvii2/HkdSUhomvF0xbWlpqpIccbl6ENiYo3Fj5dnkJ09e4MLFuzh2dEmlY1WJO7g/wsLC5XE3tEdY2Nu4h3YriTtohTzut6uSp0zpj85dpmHFyj3w8/XE4SNXEHk6BhcvlLzCbWrIQIwMWiGP26MptvzyNu63K6YlEikGD16MmNgnOHpkydvvt3zm0cKCB319+WKVbW+fv6xd2wxRUfcRMnUjQkIGqHw21YlhGDClbi/r8sYun3/+ecWVNERJIiGkRpg1rT8KCkWYGLIFWa/foP1nDXHyyELweEaKOknP08Fmlzxj5eneBOE7puObxbuxYEk4GtS3wZ6d05VuZd+MeYpuvb9RfD19zjYAQNCwrti2Rb5NSn9fd2xaNx7LfziA4Bm/oXFDO/y1exY6epbM7oRM8kFhoQjTZm9FZtYbtGpRD6eOLkSD+rZVi3v6QBQUiDAxeBOyst6g/WeNcPLvxeDxSm77JiWXitujKcJ/n4VvFv2OBd/uQoP6Auz5Y5bSLd2b0U/Qrefckrhn/SaPe3g3bPt1Kp4/z8CRv+UruNu0K9kuBgDOnFyGLp1bAADWrBoLPT0O/IevQEFBEbp3bYVtv4SAwyn1rl1t454xRB735A3IyspF+3ZNcPJ4mJq4S26oeXq6IHzXXHyzcDsWLNyJBg1ssWf3XKVbuv5DuuDVq1ws+W4XUlMz0dylLo4dXYq6dW20HuPW7Sdhb2+psmq4KmbN9JfHPWm9PO72TXDyxPJScacpf789XRC+ex6+WbAdCxbskMcdPg/t25fM5vr7d8GrzBwsWfqHPO7m9XDs7+8UcT9/no4jR+UbqrdpO0FpTGdOf48uXeRJf/yj55g7bysyM3NRr54N5s4diqkhA6stfrVEMoAjVS3TUefPny/3fOfOnSGRSHD58mV07ty53Lq0TyIh5D9lw4YNOHjwIE6frnjBhqb7JOokDfZJ1Eka7JOok6q4qfqnqLr2ScxYMwCmRlzlcwViWE09oJP7JHI4nDIXFTEMA5lMhrS0NNja2la4aX0N/SlDCPmvysjIwNOnTz/2MAghukLdamYdXt2clVXx9lHW1tYa1at5v5oQQv7TFi1ahMTExI89DEKIjmAkUsUKZ8Whw+9uNjU1VXsYGRkhNjZWqV5FaCaREEIIIbpLysiP0mU6LCoqComJiRCJRIqy7OxshISEYOvWrWCxWAgKCqqwHUoSCSGEEKKzGLEMDEemUqarJk6ciM2bN8PExERpAVjxc4rTpk0DwzCUJBJCCCGkZqtpSeKff/6JiIgIdOvWTak8PT0dNjY2yMzU/BWIlCQSQgghRHdJZfKjdJmOyszMRKtWqvuMavtKUYCSREIIIYToMEYiU5k5ZCS6myQuXLgQxsaqW4KZmJhg4cKFWrVFSSIhhBBCdBYjZsCwS99u1t2FKwsWLAAAPHnyBPfv3weLxULTpk3h7OysOKcpShIJIYQQortq2D6Jr1+/xpdffokjR45AT0+e5onFYvj4+GDHjh0wMzPTuC3aJ5EQQgghOktlj8S3h64KCQnBkydPcPnyZRQWFqKwsBBRUVF4+vQppkyZUnED76CZRELIp8+IBxjV+tijIIRUJ1b1zGMxEpnq7WYdfibxyJEjOHr0KNzd3RVl7du3x5YtW9C3b1+t2qIkkRBCCCE6i5EyYEptnl36a10iEolgYmKiUs7j8VBUVKRVW3S7mRBCCCE6SyqWqT10VefOnTFnzhy8evVKUZaZmYlZs2ahc+fOWrVFM4mEEEII0VkyiRQyNkulTFf9+OOP6NOnDxwdHdGoUSOwWCzEx8fD3t4ex48f16otShIJIYQQorvU3G7W5Xc3N2jQAHFxcThy5Aju378PhmHQtGlT9OvXT+k1fZqgJJEQQgghOksmkUHGkqmU6TIOh4P+/fujf//+VWqHkkRCCCGE6CypRAZpqSRRqsNJ4o4dO8o9HxQUpHFblCQSQgghRGcxUoBhl17d/H77zMrKwpQpU3DkyBEAgK+vL9avX1/mRtZisRjz58/H8ePH8e+//4LP56NHjx5Yvnw57OzstOp76tSpKm3n5+dDT08PxsbGWiWJtLqZEEIIITpLJpGpPd6noUOH4tatWzhx4gROnDiBW7duYcSIEWXWz8/PR0xMDL755hvExMTgwIEDePToEXx9fbXuOzMzU+nIzc3F06dP0aVLF+zdu1ertmgmkRBCCCE6SyaRonRK+D5XNz948AAnTpzA1atX0b59ewDAL7/8Ag8PD8THx6Nx48Yq1/D5fERERCiVrV+/Hu3atUNSUhIcHR2rNKZ69eph+fLlGDZsGO7fv6/xdTSTSAipETZuPIz69YfByKgX3Nwm4OLFO+XWP3/+NtzcJsDIqBcaNBiOzZuPqtTZv/8CXFy+hKFhL7i4fImDBy9p3e+BAxfRq9ds1K7dH2x2d9y69aRqgWrZf2kU9/uLWyyWYPbsLWjZcixMTPrA3n4IgoKWIyUlo+oBv8UwDBYt2gF7+yEwNu6Nrl2nIS4uscLrquN7qknfRUUiTJ68HrVr94eJSR/4+c3H8+fpVQm5QsWbaZc+ACAnJ0fp0HazaXWioqLA5/MVCSIAuLu7g8/n48qVKxq3k52dDRaLpdW7lsvDYrGQnJys1TWUJBJCdN7evWcxdepGzJ07FDExP6Njxxb44otQJCW9VFs/ISEVffrMRceOLRAT8zNCQwMRHLwB+/dfUNSJiopDQMASDB/uhVu3tmD4cC/4+y/GtWsPtOo3L68Qnp4uCAsbS3HreNz5+YWIjX2M+fOHIzp6M/bvX4RHj57Dz++baot95co9WLPmL6xfPxnXr2+EQGAOb+9ZyM3NL/Oa6vqeatJ3SMhGHDp0CeHh83Hx4lq8eVMAH595kErf38yeVCJTewBAnTp1wOfzFUdYWFiV+xMKhbC2tlYpt7a2hlAo1KiNwsJCzJkzB0OHDoWpqalW/R8+fFjpOHToEDZt2oRhw4ahY8eOWrXFYhhGdzcLIoR8EAUFBbC0tERMTAyaNGnywfrNyckBn8/H69dHYGpa9rub3d0nok2bhti0KURR1qzZl/Dz66A2SZk9ewuOHo3C/fvbFGUTJqzBnTtPceXKBgBAQMAS5OTk4fjx5Yo6vXvPgbm5CXbvnq91v4mJQtSvPwwxMT+jdWtnrT6HslDcFfcPfJy4i9248RDt209EYuJuODraVCVsMAwDe/shCA4egNmzAwHIZ+4EgkFYvnwcxo/3UXtddcSmSd/Z2W9gbT0QO3fOgb9/VwBASkoGHB0DcezYMvTs+ZnSuHJy8mBm5ovs7GytEyX59fKfD7Htm4Knp7w/YK5EijbXHiA5OVmpbQMDAxgYGKhtb9GiRfj222/L7fPGjRs4deoUduzYgfj4eKVzDRs2xJgxYzBnzpxy2xCLxRg8eDCSkpJw7tw5rWMvvRcii8WCtbU1unfvju+//x42Npr/PaOZREKI1rKysvDmzRvF1xEREahTp06FCWJhYSHS09/vraXSRCIxoqMfwdvbTancy8sVUVFxaq+5evU+vLxclcp69vwMN28+glgsAQBERd2Hl5dym97ebrhyJa7S/VYnivvTiDs7O+/tLUXVd+1qKyEhFUJhptIYDAz00blzq3LHUB2xadJ3dPRjiMUSpTp2dlZo3ryeoq/3obzbzaampkpHWQkiAEyaNAkPHjwo92jevDkEAgFevlSdtU5PT68wQROLxRgyZAgSEhIQERFRqeRYKpUqHRKJBCkpKfj999+1ShABShIJIRqSSCQ4duwYhgwZAltbWzx9+lRx7vDhw4pVeLdv30bXrl3B4/FgamoKV1dX3Lx5EwDw8uVL2Nvbo1+/fjh48CBEItF7H3dGRjakUhlsbMyVym1szCEUZqq9RijMVFtfIpEiIyO73DpCYVal+61OFPd/P+7CQhFCQ3/F0KHdyp0J11TxWEqPwdq6ZJzqr6t6bJr0LRRmQl+fC3NzXpntvA+MVHVlMyPVfnWzlZUVmjRpUu5haGgIDw8PZGdn4/r164prr127huzsbHh6epbZfnGC+PjxY0RGRsLS0rJS8VYnShIJIeW6e/cuZsyYAQcHB4wcORKWlpY4e/YsWrVqBQCQyWT4+++/4efnBwAYNmwYHBwccOPGDURHR2POnDngcrkAgLp16yIqKgp169bF+PHjYWdnhylTpiA6OlqjsRQVFak8aK4plvKrW8Ew8tswZddXPlf8ZM675erqlG5S236rG8WtWf8fOm6xWILAwCWQyWT46afgMsdVnl27IsHj9VEcxbOe6sdZ/mdfXbFVpm9N6lSFVCxTe7wvTZs2Ra9evTBu3DhcvXoVV69exbhx49C3b1+llc1NmjTBwYMHAch/CR80aBBu3ryJXbt2QSqVQigUQigUfpBfpstCW+AQQlS8evUKu3btwvbt2xEXF4fevXtj48aN6Nu3L/T19ZXqXr16FTKZTPEbclJSEmbOnKm49dywYUOl+q6urnB1dcUPP/yAf/75Bzt37kSHDh3QsGFDBAUFYcSIEWXeEgkLC6vwmaDSrKz44HDYKjMpaWlZKrMexQQCC5WZjbS019DT48DS0rTcOsVtVqbf6kRx/3fjFosl8PdfjIQEIU6f/r7Ss4i+vp5o376p4uuiIjEA+YydrW3JLFR6+mvY2JiV2U51xCYQmFfYt0BgAZFIjKysXKXZxLS01/DwcNE0bK3JZICMpVr2Pu3atQtTpkyBt7c3APlm2hs2bFCqEx8fj+xs+Uz18+fPFRtvt27dWqne2bNn0aVLl/c74DLQTCIhRMX69esRHBwMExMTPHnyBIcOHcKAAQNUEkRAfqu5b9++YLPlP06mTZuGsWPHKt4W8O5t6Xfp6enBx8cH+/btQ2JiImxtbTFz5sxyVxeGhoYiOztbcWiynYO+Pheuro0QEaE8WxkZGV3mP0zu7s0QGalc/9Spm3BzawQuV/67tYeHap2IiJvw9HSpdL/VieL+b8ZdnCA+fvwCERGrYGnJr1ygAHg8Yzg72yuOZs3qQiCwUBqDSCTG+fO3y/3sqyM2JyfbCvt2dW0ILldPqU5q6ivcu5eo6Ot9kEjUH++ThYUF/vjjD8Udjz/++ENlKxuGYTBq1CgA8n0MGYZRe3ysBBGgJJEQosZXX32FpUuXQigUolmzZhg1ahROnz4NmZpfv48cOaK41QzIVwDGxcWhT58+OHPmDJo1a6a4pfIuhmFw4cIFjBs3Dk2aNMHjx4+xYMECTJs2rcxxGRgYqDxorompUwfht9+OY+vWf/DgwTNMnboRSUlpmDBBvtozNPRXBAWVrOycMMEHz56lYdq0jXjw4Bm2bv0HW7f+g+nThyjqTJkyAKdO3cSKFeF4+DAJK1aEIzIyBsHBAzXuFwAyM3Nw69YT3L//DAAQH5+MW7eeVMszWhT3fytuiUSKwYO/xc2bj/DHH3MhlcogFGZCKMyESCSuctwsFgvBwQMQFrYbBw9ewr17Cfjyy5UwNjbE0KHdFfWCgpYjNPTXao1Nk775fBOMHt0bM2ZsxunTMYiNfYwRI8LQooUTevRoW+X4yyKRqj+IBhhCCCnH5cuXma+++orh8/mMg4MDM3v2bObevXsMwzDMo0ePGENDQyYvL6/M6wMCAhgfHx/F1/Hx8cz8+fOZevXqMSYmJsyoUaOYs2fPMjKZTOuxZWdnMwCY16+PMDLZ6XKPDRumMHXr2jD6+lymbduGzLlzaxTngoK8mc6dWynVP3t2NdOmjTOjr89l6tUTMBs3hqi0+eefC5jGjeswXK4e06SJI/PXX4u06lcmO81s3TqTAaByLFgwssKYNDko7v9O3P/+u0ttzACYM2d+qJa4pdJIZsGCkYxAYMEYGHCZzz9vydy586tSnc6dWzFBQd7V/j3VpO/8/H+YiRP7MRYWPMbIyIDp29edefYsXG0sr18fYQAw2dnZ2v/geufnw5n6zsx158ZKx5n6zlVqu6agfRIJIRopLCzEoUOHsGPHDkRERCA2NhYnT57E+fPncfSo/O0UBQUFmDlzJgYNGgQnJyc8f/4cQUFBGDhwIFasWIGkpCQ4OTmhS5cuivJatSq/qlPTfRIJIZ+e6tonMcLRGbXYynsH5smk8Ep6Uum2awpauEII0YihoSECAgIQEBCAlJQUmJiY4PDhwwgKClLU4XA4ePXqFUaOHImXL1/CysoKAwYMUCw2sbKyQkJCQpXfQ0oIIZqSSABJqYfrJO954YquoCSREKI1Ozs7ZGRk4OrVq9i3b5+iXF9fH+Hh4WVeZ2xsTAkiIeSDksmA0jnh+17drCsoSSSEVEpmZiZWr14NgUDwsYdCCCFlkkoZSEs9WSeV0ZN2mqAkkRBSKY0aNUKjRo0+9jAIIaRcdLu58ihJJIQQQojOkjGqt5dpIlEzlCQSQgghRGdJJYCk1BtXpJQkaoSSREIIIYToLImaJFFCSaJGKEkkhBBCiM6SMWpWN1OSqBFKEgkhhBCis2gmsfIoSSSEfLKKXxiVk5P/kUdCCKluxf9fV/XFcLlSGSSlygpU5haJOpQkEkI+Wbm5uQAAR8eAjzwSQsj7kpubCz6fr/V1+vr6EAgEmCJMUHteIBBAX1+/qsPTafTuZkLIJ0smkyElJQU8Hg8sFqviCwghnwyGYZCbmws7Ozuw2eyKL1CjsLAQIpFI7Tl9fX0YGhpWZYg6j5JEQgghhBCionKpOSGEEEII0WmUJBJCCCGEEBWUJBJCCCGEEBWUJBJCCCGEEBWUJBJCCCGEEBWUJBJCCCGEEBWUJBJCCCGEEBX/B3ZXiBlQUNdfAAAAAElFTkSuQmCC\n", "text/plain": [ - "tensor([[0.0080, 0.0235]])" + "
" ] }, - "execution_count": 80, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "llm_attr = LLMAttribution(FeatureAblation, model, tokenizer)\n", - "llm_attr.attribute(prompt_fn, \n", - " inputs=input_examples, \n", - " baselines=[\"\", \"\"], \n", - " target_str=\"Positive\")" + "attr_viz_8 = LLMAttrViz(**attr_result_8)\n", + "attr_viz_8.plot_seq_attr()\n", + "attr_viz_8.plot_token_attr()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c32fcfda", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From b1cf8683347593e4a3c6764cf52df745622335c1 Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Wed, 9 Aug 2023 01:22:03 -0700 Subject: [PATCH 03/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 1504 ++++++++++++++++++++++++++-- 1 file changed, 1441 insertions(+), 63 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index 050815ec49..9487ea98d4 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 262, + "execution_count": 408, "id": "inside-current", "metadata": {}, "outputs": [], @@ -25,7 +25,7 @@ "import numpy as np\n", "\n", "sys.path.append(\"/home/aoboyang/local/captum\")\n", - "from captum.attr import FeatureAblation, Attribution\n", + "from captum.attr import FeatureAblation, Attribution, LayerIntegratedGradients\n", "\n", "from captum.attr._core.dataloader_attr import _convert_output_shape" ] @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 174, + "execution_count": 346, "id": "suffering-reconstruction", "metadata": {}, "outputs": [ @@ -240,6 +240,10 @@ "name": "stdout", "output_type": "stream", "text": [ + "{'input_ids': tensor([[ 1, 17841, 12080, 297, 3793, 29885, 17700, 29892, 383, 29931,\n", + " 322, 338, 263, 25008, 29889, 3600, 7333, 20017, 3160]],\n", + " device='cuda:7'), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],\n", + " device='cuda:7')}\n", "tensor([[ 1, 17841, 12080, 297, 3793, 29885, 17700, 29892, 383, 29931,\n", " 322, 338, 263, 25008, 29889, 3600, 7333, 20017, 3160]],\n", " device='cuda:7')\n", @@ -256,7 +260,7 @@ "eval_prompt = \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\"\n", "\n", "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", - "\n", + "print(model_input)\n", "model.eval()\n", "with torch.no_grad():\n", " print(model_input[\"input_ids\"])\n", @@ -270,7 +274,7 @@ { "cell_type": "code", "execution_count": 315, - "id": "a34c4461", + "id": "bb032c18", "metadata": {}, "outputs": [ { @@ -307,10 +311,31 @@ " print(tokenizer.convert_ids_to_tokens(output_ids))" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "30205531", + "metadata": {}, + "outputs": [], + "source": [ + "eval_prompt = \"spending\"\n", + "\n", + "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + "\n", + "model.eval()\n", + "with torch.no_grad():\n", + " print(model_input[\"input_ids\"])\n", + " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=15)[0]\n", + " print(output_ids)\n", + " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", + " print(response)\n", + " print(tokenizer.convert_ids_to_tokens(output_ids))" + ] + }, { "cell_type": "code", "execution_count": 6, - "id": "e15f4073", + "id": "68a7c1ea", "metadata": {}, "outputs": [ { @@ -330,7 +355,7 @@ }, { "cell_type": "markdown", - "id": "b9a7fc24", + "id": "dd27aeb1", "metadata": {}, "source": [ "Vizualize" @@ -338,8 +363,8 @@ }, { "cell_type": "code", - "execution_count": 328, - "id": "7fa408b4", + "execution_count": 338, + "id": "1e648344", "metadata": {}, "outputs": [], "source": [ @@ -370,7 +395,7 @@ " # Plot the heatmap\n", " data = token_attr.numpy()\n", " \n", - " fig.set_size_inches(data.shape[1], data.shape[0] / 2.5)\n", + " fig.set_size_inches(max(data.shape[1] * 1.3, 6.4), max(data.shape[0] / 2.5, 4.8))\n", " im = ax.imshow(\n", " data,\n", " vmax=max_abs_attr_val,\n", @@ -439,7 +464,7 @@ }, { "cell_type": "markdown", - "id": "7556cec4", + "id": "180bdf46", "metadata": {}, "source": [ "`SampleBaselines` class define the case that there are multiple possible baselines over certain data distribution" @@ -448,7 +473,7 @@ { "cell_type": "code", "execution_count": 286, - "id": "8cc4c5db", + "id": "e6ef376e", "metadata": {}, "outputs": [], "source": [ @@ -520,7 +545,7 @@ }, { "cell_type": "markdown", - "id": "d9b3a1c7", + "id": "c95ac3e8", "metadata": {}, "source": [ "`InterpretableFeature` defines the feature type and tells Captum how to perturb the input data" @@ -528,8 +553,8 @@ }, { "cell_type": "code", - "execution_count": 206, - "id": "198eeaef", + "execution_count": 473, + "id": "d2798ec5", "metadata": {}, "outputs": [], "source": [ @@ -600,7 +625,8 @@ " if type(inputs) is dict:\n", " # convert dict to list\n", " inputs = [inputs[k] for k in self.dict_keys]\n", - " \n", + " \n", + " # need better naming\n", " self.inputs = inputs\n", " \n", " self.baselines = baselines\n", @@ -653,8 +679,75 @@ " pass\n", "\n", "\n", - "class TextFeature(IdFeature):\n", - " pass" + "class TextTokenFeature(IdFeature):\n", + " def __init__(\n", + " self, \n", + " text: str, \n", + " tokenizer, \n", + " baselines: Union[int, str] = 0, # usually UNK\n", + " skip_tokens: Union[List[int], List[str], None] = None,\n", + " ):\n", + " inp_tensor = tokenizer.encode(text, return_tensors=\"pt\")\n", + " \n", + " self.inp_tensor = inp_tensor\n", + " self.interpretable_tensor = inp_tensor\n", + " self.interpretable_mask = None\n", + " \n", + " if skip_tokens:\n", + " self.skip_tokens = set(skip_tokens)\n", + " interpretable_mask = torch.zeros_like(inp_tensor)\n", + " interpretable_mask.map_(inp_tensor, lambda _, v: v not in self.skip_tokens)\n", + " interpretable_mask = interpretable_mask.bool()\n", + " \n", + " interpretable_tensor = inp_tensor[interpretable_mask].unsqueeze(0)\n", + " \n", + " self.interpretable_tensor = interpretable_tensor\n", + " self.interpretable_mask = interpretable_mask\n", + " \n", + " self.inputs = tokenizer.convert_ids_to_tokens(self.interpretable_tensor[0])\n", + " \n", + " self.tokenizer = tokenizer\n", + " \n", + " # may diff in future if we allow filtering tokens\n", + " self.n_features = len(self.inputs)\n", + " self.n_interpretable_features = len(self.inputs)\n", + "\n", + " self.baselines = baselines if type(baselines) is int else tokenizer.convert_tokens_to_ids(baselines)\n", + " \n", + " def to_model_input(self, perturbed_tensor=None):\n", + " if perturbed_tensor is None:\n", + " return self.inp_tensor\n", + " \n", + " device = perturbed_tensor.device\n", + " \n", + " perturb_mask = (perturbed_tensor != self.interpretable_tensor.to(device))\n", + " \n", + " perturbed_tensor = perturbed_tensor * ~perturb_mask\n", + " perturbed_tensor[perturb_mask] = self.baselines\n", + " \n", + " perturbed_tensor = perturbed_tensor.detach()\n", + " \n", + " if self.interpretable_mask is not None:\n", + "# print(1, self.inp_tensor.shape)\n", + "# print(2, self.interpretable_mask.shape)\n", + " perturb_inp_shape = (perturbed_tensor.size(0), -1)\n", + " perturb_inp_tensor = self.inp_tensor.expand(*perturb_inp_shape).to(device)\n", + " interpretable_mask = self.interpretable_mask.expand(*perturb_inp_shape).to(device)\n", + "# print(3, perturb_inp_tensor.shape)\n", + "# print(4, interpretable_mask.shape)\n", + " \n", + "# print(5, perturbed_tensor.shape)\n", + " perturb_inp_tensor[interpretable_mask] = perturbed_tensor.view(-1)\n", + " \n", + " return perturb_inp_tensor\n", + " \n", + " return perturbed_tensor\n", + " \n", + " def to_input_shape(self, interpretable_attr: torch.Tensor):\n", + " return interpretable_attr\n", + " \n", + " \n", + " " ] }, { @@ -669,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 318, + "execution_count": 450, "id": "theoretical-cassette", "metadata": {}, "outputs": [], @@ -681,7 +774,7 @@ " tokenizer, \n", " init_kwargs=None, \n", " attr_kwargs=None, \n", - " max_new_tokens=50,\n", + " max_new_tokens=15,\n", " attr_type: str = \"log_prob\", # or prob\n", " ):\n", " \"\"\"\n", @@ -713,7 +806,6 @@ " \n", " def _forward_func(self, perturbed_feature, input_feature, target_tokens, log_trials):\n", " perturbed_input = self._format_model_input(input_feature.to_model_input(perturbed_feature))\n", - " \n", " init_model_inp = perturbed_input\n", " \n", " model_inp = init_model_inp\n", @@ -735,8 +827,8 @@ " target_probs = torch.exp(target_log_probs)\n", " \n", " if log_trials:\n", - " prompt = self.tokenizer.decode(init_model_inp[0], skip_special_tokens=True)\n", - " response = self.tokenizer.decode(target_tokens, skip_special_tokens=True)\n", + " prompt = self.tokenizer.decode(init_model_inp[0])\n", + " response = self.tokenizer.decode(target_tokens)\n", " print(prompt)\n", " print(response, \"[prob:\", target_probs[0].item(), \"]\")\n", " \n", @@ -784,6 +876,7 @@ " additional_forward_args=(input_feature, target_tokens, log_trials),\n", " **kwargs\n", " )\n", + "\n", " attr += cur_attr\n", " \n", " attr = (attr / num_trials) \n", @@ -808,7 +901,7 @@ }, { "cell_type": "code", - "execution_count": 135, + "execution_count": 451, "id": "hairy-seeking", "metadata": {}, "outputs": [], @@ -856,7 +949,7 @@ { "cell_type": "code", "execution_count": 256, - "id": "bd74ecf5", + "id": "05965f80", "metadata": {}, "outputs": [ { @@ -904,7 +997,7 @@ }, { "cell_type": "code", - "execution_count": 195, + "execution_count": 452, "id": "massive-french", "metadata": {}, "outputs": [ @@ -912,18 +1005,43 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", "playing guitar, hiking, and spending time with his family. [prob: 0.0009605777449905872 ]\n", - "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", "playing guitar, hiking, and spending time with his family. [prob: 2.644512824190315e-05 ]\n", - "Dave lives in Mountain View, FL and is a lawyer. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 0.0007114586187526584 ]\n", - "Dave lives in Palm Coast, CA and is a lawyer. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 0.0006647087284363806 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 0.0008365382091142237 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 8.822518680062785e-07 ]\n" + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing guitar, hiking, and spending time with his family. [prob: 0.00028119259513914585 ]\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [452], line 8\u001b[0m\n\u001b[1;32m 1\u001b[0m inp_feature \u001b[38;5;241m=\u001b[39m TextTemplateFeature(\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{name}\u001b[39;00m\u001b[38;5;124m lives in \u001b[39m\u001b[38;5;132;01m{city}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{state}\u001b[39;00m\u001b[38;5;124m and is a \u001b[39m\u001b[38;5;132;01m{occupation}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m{pronoun}\u001b[39;00m\u001b[38;5;124m personal interests include\u001b[39m\u001b[38;5;124m\"\u001b[39m, \n\u001b[1;32m 3\u001b[0m inputs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDave\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPalm Coast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFL\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlawyer\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHis\u001b[39m\u001b[38;5;124m\"\u001b[39m}, \n\u001b[1;32m 4\u001b[0m baselines\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSarah\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSeattle\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWA\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdoctor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHer\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[1;32m 5\u001b[0m )\n\u001b[0;32m----> 8\u001b[0m attr_result_2 \u001b[38;5;241m=\u001b[39m \u001b[43mllm_attr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minp_feature\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn [450], line 105\u001b[0m, in \u001b[0;36mLLMAttribution.attribute\u001b[0;34m(self, input_feature, target, num_trials, log_trials, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_trials): \n\u001b[1;32m 103\u001b[0m attr_input \u001b[38;5;241m=\u001b[39m input_feature\u001b[38;5;241m.\u001b[39minterpretable_tensor\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m--> 105\u001b[0m cur_attr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattr_method\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43mattr_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minput_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_tokens\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlog_trials\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m attr \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m cur_attr\n\u001b[1;32m 113\u001b[0m attr \u001b[38;5;241m=\u001b[39m (attr \u001b[38;5;241m/\u001b[39m num_trials) \n", + "File \u001b[0;32m~/local/captum/captum/log/__init__.py:42\u001b[0m, in \u001b[0;36mlog_usage.._log_usage..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:351\u001b[0m, in \u001b[0;36mFeatureAblation.attribute\u001b[0;34m(self, inputs, baselines, target, additional_forward_args, feature_mask, perturbations_per_eval, show_progress, **kwargs)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (\n\u001b[1;32m 332\u001b[0m current_inputs,\n\u001b[1;32m 333\u001b[0m current_add_args,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[38;5;66;03m# non-agg mode:\u001b[39;00m\n\u001b[1;32m 350\u001b[0m \u001b[38;5;66;03m# (feature_perturbed * batch_size, *initial_eval.shape[1:])\u001b[39;00m\n\u001b[0;32m--> 351\u001b[0m modified_eval \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strict_run_forward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward_func\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_target\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 355\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_add_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 356\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m show_progress:\n\u001b[1;32m 359\u001b[0m attr_progress\u001b[38;5;241m.\u001b[39mupdate()\n", + "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:599\u001b[0m, in \u001b[0;36mFeatureAblation._strict_run_forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 593\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_strict_run_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \u001b[38;5;124;03m A temp wrapper for global _run_forward util to force forward output\u001b[39;00m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m type assertion & conversion.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m Remove after the strict logic is supported by all attr classes\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 599\u001b[0m forward_output \u001b[38;5;241m=\u001b[39m \u001b[43m_run_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 600\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(forward_output, Tensor):\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_output\n", + "File \u001b[0;32m~/local/captum/captum/_utils/common.py:517\u001b[0m, in \u001b[0;36m_run_forward\u001b[0;34m(forward_func, inputs, target, additional_forward_args)\u001b[0m\n\u001b[1;32m 514\u001b[0m inputs \u001b[38;5;241m=\u001b[39m _format_inputs(inputs)\n\u001b[1;32m 515\u001b[0m additional_forward_args \u001b[38;5;241m=\u001b[39m _format_additional_forward_args(additional_forward_args)\n\u001b[0;32m--> 517\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mforward_func\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 519\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _select_targets(output, target)\n", + "Cell \u001b[0;32mIn [450], line 46\u001b[0m, in \u001b[0;36mLLMAttribution._forward_func\u001b[0;34m(self, perturbed_feature, input_feature, target_tokens, log_trials)\u001b[0m\n\u001b[1;32m 44\u001b[0m log_prob_list \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m target_token \u001b[38;5;129;01min\u001b[39;00m target_tokens:\n\u001b[0;32m---> 46\u001b[0m output_logits \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_inp\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m new_token_logits \u001b[38;5;241m=\u001b[39m output_logits\u001b[38;5;241m.\u001b[39mlogits[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 48\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mfunctional\u001b[38;5;241m.\u001b[39mlog_softmax(new_token_logits, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:806\u001b[0m, in \u001b[0;36mLlamaForCausalLM.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 803\u001b[0m return_dict \u001b[38;5;241m=\u001b[39m return_dict \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39muse_return_dict\n\u001b[1;32m 805\u001b[0m \u001b[38;5;66;03m# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\u001b[39;00m\n\u001b[0;32m--> 806\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 807\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 808\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 809\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 810\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 811\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 812\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 813\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 814\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_hidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_hidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 815\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_dict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 818\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 819\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpretraining_tp \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:693\u001b[0m, in \u001b[0;36mLlamaModel.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 685\u001b[0m layer_outputs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mcheckpoint\u001b[38;5;241m.\u001b[39mcheckpoint(\n\u001b[1;32m 686\u001b[0m create_custom_forward(decoder_layer),\n\u001b[1;32m 687\u001b[0m hidden_states,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 690\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 691\u001b[0m )\n\u001b[1;32m 692\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 693\u001b[0m layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 694\u001b[0m \u001b[43m \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 695\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 696\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 697\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 698\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 699\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 700\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 702\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m layer_outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 704\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:408\u001b[0m, in \u001b[0;36mLlamaDecoderLayer.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[1;32m 405\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[1;32m 407\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[0;32m--> 408\u001b[0m hidden_states, self_attn_weights, present_key_value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 409\u001b[0m \u001b[43m \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 410\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 411\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 412\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 413\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 414\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 416\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m residual \u001b[38;5;241m+\u001b[39m hidden_states\n\u001b[1;32m 418\u001b[0m \u001b[38;5;66;03m# Fully Connected\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:307\u001b[0m, in \u001b[0;36mLlamaAttention.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[1;32m 305\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_proj(hidden_states)\n\u001b[1;32m 306\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\n\u001b[0;32m--> 307\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 309\u001b[0m query_states \u001b[38;5;241m=\u001b[39m query_states\u001b[38;5;241m.\u001b[39mview(bsz, q_len, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_heads, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 310\u001b[0m key_states \u001b[38;5;241m=\u001b[39m key_states\u001b[38;5;241m.\u001b[39mview(bsz, q_len, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_key_value_heads, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/bitsandbytes/nn/modules.py:248\u001b[0m, in \u001b[0;36mLinear4bit.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 245\u001b[0m x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcompute_dtype)\n\u001b[1;32m 247\u001b[0m bias \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbias \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbias\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcompute_dtype)\n\u001b[0;32m--> 248\u001b[0m out \u001b[38;5;241m=\u001b[39m bnb\u001b[38;5;241m.\u001b[39mmatmul_4bit(x, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[38;5;241m.\u001b[39mt(), bias\u001b[38;5;241m=\u001b[39mbias, quant_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweight\u001b[38;5;241m.\u001b[39mquant_state)\n\u001b[1;32m 250\u001b[0m out \u001b[38;5;241m=\u001b[39m out\u001b[38;5;241m.\u001b[39mto(inp_dtype)\n\u001b[1;32m 252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\n", + "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1252\u001b[0m, in \u001b[0;36mModule.__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_is_full_backward_hook\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m:\n\u001b[1;32m 1250\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_full_backward_hook \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1252\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, name: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Union[Tensor, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mModule\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1253\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_parameters\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m:\n\u001b[1;32m 1254\u001b[0m _parameters \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_parameters\u001b[39m\u001b[38;5;124m'\u001b[39m]\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -941,7 +1059,7 @@ { "cell_type": "code", "execution_count": 222, - "id": "ea9f254a", + "id": "0c009685", "metadata": { "scrolled": true }, @@ -964,7 +1082,7 @@ }, { "cell_type": "markdown", - "id": "e1634197", + "id": "ea492d52", "metadata": {}, "source": [ "Another way to ablate the input text is to directly remove the corresponding tokens, which can also be viewed as replacing them with emptry string. This is also the default baselines for `TextTemplateFeature`. Let's try this, but please note removing tokens is likely to create out-of-distribution text input and therefore may not give you meaningful results." @@ -972,26 +1090,33 @@ }, { "cell_type": "code", - "execution_count": 273, - "id": "e3c417a7", + "execution_count": 442, + "id": "57402c26", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.074411481269635e-05 ]\n", - "Dave lives in , FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4309290893143043e-05 ]\n", - "Dave lives in Palm Coast, and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.252655218006112e-06 ]\n", - "Dave lives in Palm Coast, FL and is a . His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.487737664429005e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.5998193652631016e-06 ]\n" + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [442], line 8\u001b[0m\n\u001b[1;32m 1\u001b[0m target \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplaying golf, hiking, and cooking.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3\u001b[0m inp_feature \u001b[38;5;241m=\u001b[39m TextTemplateFeature(\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{name}\u001b[39;00m\u001b[38;5;124m lives in \u001b[39m\u001b[38;5;132;01m{city}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{state}\u001b[39;00m\u001b[38;5;124m and is a \u001b[39m\u001b[38;5;132;01m{occupation}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m{pronoun}\u001b[39;00m\u001b[38;5;124m personal interests include\u001b[39m\u001b[38;5;124m\"\u001b[39m, \n\u001b[1;32m 5\u001b[0m inputs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDave\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPalm Coast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFL\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlawyer\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHis\u001b[39m\u001b[38;5;124m\"\u001b[39m}, \n\u001b[1;32m 6\u001b[0m )\n\u001b[0;32m----> 8\u001b[0m attr_result_3 \u001b[38;5;241m=\u001b[39m \u001b[43mllm_attr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minp_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn [404], line 105\u001b[0m, in \u001b[0;36mLLMAttribution.attribute\u001b[0;34m(self, input_feature, target, num_trials, log_trials, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_trials): \n\u001b[1;32m 103\u001b[0m attr_input \u001b[38;5;241m=\u001b[39m input_feature\u001b[38;5;241m.\u001b[39minterpretable_tensor\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m--> 105\u001b[0m cur_attr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattr_method\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43mattr_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minput_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_tokens\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlog_trials\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m attr \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m cur_attr\n\u001b[1;32m 113\u001b[0m attr \u001b[38;5;241m=\u001b[39m (attr \u001b[38;5;241m/\u001b[39m num_trials) \n", + "File \u001b[0;32m~/local/captum/captum/log/__init__.py:42\u001b[0m, in \u001b[0;36mlog_usage.._log_usage..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:351\u001b[0m, in \u001b[0;36mFeatureAblation.attribute\u001b[0;34m(self, inputs, baselines, target, additional_forward_args, feature_mask, perturbations_per_eval, show_progress, **kwargs)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (\n\u001b[1;32m 332\u001b[0m current_inputs,\n\u001b[1;32m 333\u001b[0m current_add_args,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[38;5;66;03m# non-agg mode:\u001b[39;00m\n\u001b[1;32m 350\u001b[0m \u001b[38;5;66;03m# (feature_perturbed * batch_size, *initial_eval.shape[1:])\u001b[39;00m\n\u001b[0;32m--> 351\u001b[0m modified_eval \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strict_run_forward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward_func\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_target\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 355\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_add_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 356\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m show_progress:\n\u001b[1;32m 359\u001b[0m attr_progress\u001b[38;5;241m.\u001b[39mupdate()\n", + "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:599\u001b[0m, in \u001b[0;36mFeatureAblation._strict_run_forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 593\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_strict_run_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \u001b[38;5;124;03m A temp wrapper for global _run_forward util to force forward output\u001b[39;00m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m type assertion & conversion.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m Remove after the strict logic is supported by all attr classes\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 599\u001b[0m forward_output \u001b[38;5;241m=\u001b[39m \u001b[43m_run_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 600\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(forward_output, Tensor):\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_output\n", + "File \u001b[0;32m~/local/captum/captum/_utils/common.py:517\u001b[0m, in \u001b[0;36m_run_forward\u001b[0;34m(forward_func, inputs, target, additional_forward_args)\u001b[0m\n\u001b[1;32m 514\u001b[0m inputs \u001b[38;5;241m=\u001b[39m _format_inputs(inputs)\n\u001b[1;32m 515\u001b[0m additional_forward_args \u001b[38;5;241m=\u001b[39m _format_additional_forward_args(additional_forward_args)\n\u001b[0;32m--> 517\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mforward_func\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 519\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _select_targets(output, target)\n", + "Cell \u001b[0;32mIn [404], line 52\u001b[0m, in \u001b[0;36mLLMAttribution._forward_func\u001b[0;34m(self, perturbed_feature, input_feature, target_tokens, log_trials)\u001b[0m\n\u001b[1;32m 48\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mfunctional\u001b[38;5;241m.\u001b[39mlog_softmax(new_token_logits, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 50\u001b[0m log_prob_list\u001b[38;5;241m.\u001b[39mappend(log_probs[\u001b[38;5;241m0\u001b[39m][target_token]\u001b[38;5;241m.\u001b[39mdetach())\n\u001b[0;32m---> 52\u001b[0m model_inp \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat((model_inp, \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtarget_token\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 54\u001b[0m total_log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msum\u001b[39m(log_prob_list)\n\u001b[1;32m 56\u001b[0m \u001b[38;5;66;03m# 1st dim is the total prob, rest are the target tokens\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -1009,7 +1134,7 @@ { "cell_type": "code", "execution_count": 274, - "id": "560e4dfa", + "id": "8af32cb0", "metadata": {}, "outputs": [ { @@ -1103,7 +1228,7 @@ { "cell_type": "code", "execution_count": 281, - "id": "1065afbf", + "id": "2ac65d49", "metadata": {}, "outputs": [ { @@ -1218,7 +1343,7 @@ { "cell_type": "code", "execution_count": 282, - "id": "7d649e75", + "id": "63668488", "metadata": {}, "outputs": [ { @@ -1250,7 +1375,7 @@ }, { "cell_type": "markdown", - "id": "fabd0e57", + "id": "0a29a08b", "metadata": {}, "source": [ "We can also independently define the baseline distribution of each attribute with `ProductBaselines`." @@ -1376,7 +1501,7 @@ { "cell_type": "code", "execution_count": 292, - "id": "1e4f6af4", + "id": "0c9cec9c", "metadata": {}, "outputs": [ { @@ -1510,7 +1635,7 @@ { "cell_type": "code", "execution_count": 293, - "id": "6c073aa3", + "id": "c22f5569", "metadata": {}, "outputs": [ { @@ -1644,8 +1769,8 @@ }, { "cell_type": "code", - "execution_count": 335, - "id": "37df2834", + "execution_count": 339, + "id": "bc40b7a2", "metadata": {}, "outputs": [ { @@ -1660,9 +1785,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1675,10 +1800,1263 @@ "attr_viz_8.plot_token_attr()" ] }, + { + "cell_type": "code", + "execution_count": 405, + "id": "8fb5170d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9094561139354482e-05 ]\n", + " Dave in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.641148168753716e-06 ]\n", + " Dave lives Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.978511813329533e-06 ]\n", + " Dave lives inm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6035468181362376e-06 ]\n", + " Dave lives in Pal Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.203700766287511e-06 ]\n", + " Dave lives in Palm, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.904232926288387e-06 ]\n", + " Dave lives in Palm Coast FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.864713107759599e-06 ]\n", + " Dave lives in Palm Coast,L and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.113435913197463e-06 ]\n", + " Dave lives in Palm Coast, F and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2460433683590963e-05 ]\n", + " Dave lives in Palm Coast, FL is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.888166459859349e-06 ]\n", + " Dave lives in Palm Coast, FL and a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.247206096712034e-06 ]\n", + " Dave lives in Palm Coast, FL and is lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1111003914265893e-05 ]\n", + " Dave lives in Palm Coast, FL and is a. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.453636953869136e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.971460152271902e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.472557980581769e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His interests include\n", + "playing golf, hiking, and cooking. [prob: 6.2888325373933185e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal include\n", + "playing golf, hiking, and cooking. [prob: 5.19798902587354e-07 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests\n", + "playing golf, hiking, and cooking. [prob: 3.9929703987695575e-10 ]\n" + ] + } + ], + "source": [ + "llm_attr = LLMAttribution(fa, tokenizer)\n", + "\n", + "inp_feature = TextTokenFeature(\n", + " \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\", \n", + " tokenizer,\n", + " baselines=0, # UNK\n", + " skip_tokens=[1], # \n", + ")\n", + "\n", + "attr_result_9 = llm_attr.attribute(inp_feature, target=\"playing golf, hiking, and cooking.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 406, + "id": "a277e9a2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_9 = LLMAttrViz(**attr_result_9)\n", + "attr_viz_9.plot_seq_attr()\n", + "attr_viz_9.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 409, + "id": "fc8152a6", + "metadata": {}, + "outputs": [], + "source": [ + "emb_layer = model.get_submodule(\"model.embed_tokens\")" + ] + }, + { + "cell_type": "code", + "execution_count": 344, + "id": "c43bf44c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LlamaForCausalLM(\n", + " (model): LlamaModel(\n", + " (embed_tokens): Embedding(32000, 5120, padding_idx=0)\n", + " (layers): ModuleList(\n", + " (0): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (1): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (2): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (3): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (4): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (5): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (6): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (7): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (8): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (9): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (10): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (11): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (12): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (13): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (14): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (15): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (16): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (17): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (18): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (19): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (20): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (21): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (22): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (23): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (24): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (25): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (26): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (27): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (28): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (29): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (30): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (31): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (32): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (33): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (34): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (35): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (36): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (37): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (38): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " (39): LlamaDecoderLayer(\n", + " (self_attn): LlamaAttention(\n", + " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", + " (rotary_emb): LlamaRotaryEmbedding()\n", + " )\n", + " (mlp): LlamaMLP(\n", + " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", + " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", + " (act_fn): SiLUActivation()\n", + " )\n", + " (input_layernorm): LlamaRMSNorm()\n", + " (post_attention_layernorm): LlamaRMSNorm()\n", + " )\n", + " )\n", + " (norm): LlamaRMSNorm()\n", + " )\n", + " (lm_head): Linear(in_features=5120, out_features=32000, bias=False)\n", + ")" + ] + }, + "execution_count": 344, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 494, + "id": "ef832b1e", + "metadata": {}, + "outputs": [], + "source": [ + "class LLMGradientAttribution(Attribution):\n", + " def __init__(\n", + " self, \n", + " attr_method, \n", + " tokenizer,\n", + " max_new_tokens=15,\n", + " attr_type: str = \"log_prob\", # or prob\n", + " ):\n", + " \"\"\"\n", + " attr_method: gradients attribution instance crteated with a llm model huggingface style interface\n", + " tokenizer: required\n", + " \"\"\"\n", + "# assert (\n", + "# type(attr_method) in SUPPORTED_METHODS\n", + "# ), f\"LLMAttribution does not support {type(attr_method)}\"\n", + "\n", + " super().__init__(attr_method.forward_func)\n", + "\n", + " # shallow copy is enough to avoid modifying original instance\n", + " self.attr_method = copy(attr_method)\n", + "\n", + " self.attr_method.forward_func = self._forward_func\n", + " \n", + " # alias\n", + " self.model = self.forward_func\n", + " \n", + " self.tokenizer = tokenizer\n", + " self.device = self.model.device\n", + " \n", + " # only when attr target is not given\n", + " self.max_new_tokens = max_new_tokens\n", + " \n", + " self.attr_type = attr_type\n", + " \n", + " \n", + " def _forward_func(self, perturbed_feature, input_feature, output_tokens, target_token):\n", + " perturbed_input = self._format_model_input(input_feature.to_model_input(perturbed_feature))\n", + "# print(\"perturbed_feature\", perturbed_feature)\n", + "# print(\"perturbed_input\", perturbed_input.shape)\n", + "# print(\"output_token_tensor\", output_token_tensor.shape)\n", + " \n", + " if output_tokens:\n", + " output_token_tensor = torch.tensor([output_tokens] * perturbed_input.size(0), device=self.device) \n", + " new_input_tensor = torch.cat([perturbed_input, output_token_tensor], dim=1)\n", + " else:\n", + " new_input_tensor = perturbed_input\n", + " \n", + " output_logits = self.model(new_input_tensor)\n", + " \n", + " new_token_logits = output_logits.logits[:, -1]\n", + " log_probs = torch.nn.functional.log_softmax(new_token_logits, dim=1)\n", + " \n", + " token_log_probs = log_probs[..., target_token]\n", + " print(\"log_probs\", token_log_probs)\n", + " return token_log_probs\n", + " \n", + " \n", + " def _format_model_input(self, model_input):\n", + " \"\"\"\n", + " Convert str to tokenized tensor\n", + " \"\"\"\n", + " return model_input.to(self.device)\n", + " \n", + " def attribute(\n", + " self, \n", + " input_feature: Union[\"TextFeature\", \"IdFeature\"], \n", + " target: Union[str, torch.Tensor, None] = None, \n", + "# num_trials: int = 1, \n", + "# log_trials=True,\n", + " **kwargs,\n", + " ):\n", + " if type(target) is str:\n", + " # exclude sos\n", + " target_tokens = self.tokenizer.encode(target)[1:]\n", + " elif type(target) is torch.Tensor:\n", + " target_tokens = target\n", + " else:\n", + " # generate when None\n", + " model_inp = self._format_model_input(input_feature.to_model_input())\n", + " output_tokens = self.model.generate(model_inp, max_new_tokens=self.max_new_tokens)\n", + " target_tokens = output_tokens[0][model_inp.size(1):]\n", + " \n", + " init_model_inp = input_feature.interpretable_tensor.to(self.device)\n", + " \n", + " model_inp = init_model_inp\n", + " \n", + " log_prob_list = []\n", + " \n", + " attr_list = []\n", + " output_tokens = []\n", + " for target_token in target_tokens: \n", + " # attr in shape(batch_size, input+output_len, emb_dim)\n", + " attr = self.attr_method.attribute(\n", + " model_inp,\n", + "# target=target_token,\n", + " additional_forward_args=(input_feature, output_tokens, target_token),\n", + " **kwargs,\n", + " )\n", + " \n", + "# print(attr.shape)\n", + " \n", + " # the author uses sum \n", + " # https://github.com/ankurtaly/Integrated-Gradients/blob/master/BertModel/bert_model_utils.py#L350\n", + " attr = attr.sum(-1)\n", + " \n", + " # we may have the attr for previous output tokens, how to use them?\n", + " if output_tokens:\n", + " attr = attr[..., :-len(output_tokens)]\n", + "\n", + " attr_list.append(attr)\n", + " \n", + " output_tokens.append(target_token)\n", + " \n", + " \n", + " \n", + " # assume inp batch only has one instance\n", + " attr = torch.cat(attr_list, dim=0)\n", + " \n", + " if isinstance(input_feature, TextTokenFeature) and input_feature.interpretable_mask is not None:\n", + " interpretable_mask = input_feature.interpretable_mask.to(self.device)\n", + " interpretable_mask = interpretable_mask.expand_as(attr)\n", + " attr = attr[interpretable_mask].view(attr.size(0), -1)\n", + " \n", + " return {\n", + " \"seq_attr\": None, # TODO\n", + " \"token_attr\": attr, # shape(n_output_token, n_input_features)\n", + " \"input_tokens\": input_feature.inputs,\n", + " \"output_tokens\": self.tokenizer.convert_ids_to_tokens(target_tokens)\n", + " }\n" + ] + }, + { + "cell_type": "code", + "execution_count": 497, + "id": "8aff0685", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log_probs tensor([-2.0709], device='cuda:0')\n", + "log_probs tensor([-9.4683], device='cuda:0')\n", + "log_probs tensor([ -9.5406, -9.6553, -9.9278, -10.4854, -10.8005, -10.2532, -10.1805,\n", + " -14.0455, -12.1830, -11.2045, -9.9975, -11.8878, -12.6220, -11.6448,\n", + " -11.8720, -10.7416, -10.0644, -9.1234, -3.4986, -3.2085, -3.0359,\n", + " -3.0088, -2.6658, -2.2921, -2.1588, -2.1595, -2.2699, -2.2817,\n", + " -2.3294, -2.3406, -2.3513, -2.3412, -2.3305, -2.2634, -2.2051,\n", + " -2.1849, -2.1575, -2.1481, -2.1430, -2.1222, -2.1132, -2.1002,\n", + " -2.0928, -2.0770, -2.0843, -2.0725, -2.0786, -2.0701, -2.0715,\n", + " -2.0661], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.9615], device='cuda:0')\n", + "log_probs tensor([-5.6482], device='cuda:0')\n", + "log_probs tensor([-5.6477, -5.6869, -5.7107, -5.8108, -5.9896, -6.2228, -6.4274, -8.7211,\n", + " -4.8410, -4.5691, -5.5906, -5.6740, -7.5825, -7.0264, -8.0953, -8.7098,\n", + " -7.6135, -4.3560, -2.2461, -1.8300, -1.3981, -1.0928, -0.9956, -1.0341,\n", + " -1.0432, -1.0768, -1.4605, -1.8595, -1.8596, -1.8224, -1.6506, -1.4515,\n", + " -1.2607, -1.0950, -1.0314, -0.9947, -0.9811, -0.9794, -0.9668, -0.9546,\n", + " -0.9581, -0.9534, -0.9532, -0.9591, -0.9613, -0.9576, -0.9515, -0.9558,\n", + " -0.9591, -0.9535], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.4636], device='cuda:0')\n", + "log_probs tensor([-1.6449], device='cuda:0')\n", + "log_probs tensor([-1.6434, -1.6663, -1.7097, -1.7761, -1.8556, -1.9532, -2.0148, -6.3389,\n", + " -2.6998, -3.2949, -2.9760, -2.4610, -2.3910, -2.7350, -3.4769, -3.5385,\n", + " -3.5503, -1.6001, -0.2519, -0.3083, -0.4258, -0.4132, -0.4364, -0.4366,\n", + " -0.5266, -0.5890, -0.6069, -0.6105, -0.6382, -0.6220, -0.5920, -0.5321,\n", + " -0.5061, -0.4850, -0.4715, -0.4709, -0.4702, -0.4702, -0.4699, -0.4639,\n", + " -0.4638, -0.4695, -0.4634, -0.4635, -0.4632, -0.4632, -0.4636, -0.4691,\n", + " -0.4633, -0.4635], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-1.2316], device='cuda:0')\n", + "log_probs tensor([-7.7042], device='cuda:0')\n", + "log_probs tensor([-7.6972, -7.6542, -7.6036, -7.5507, -7.4936, -7.4577, -7.4766, -7.1102,\n", + " -7.4851, -6.5747, -5.7761, -6.2487, -5.8500, -6.2982, -6.4095, -6.3358,\n", + " -4.7494, -2.1934, -1.7727, -1.2845, -0.9165, -0.8639, -1.2729, -1.2650,\n", + " -1.2322, -1.2437, -1.4309, -1.4960, -1.4593, -1.3912, -1.3109, -1.3155,\n", + " -1.3039, -1.2470, -1.2205, -1.2294, -1.2508, -1.2543, -1.2551, -1.2584,\n", + " -1.2572, -1.2643, -1.2552, -1.2555, -1.2508, -1.2508, -1.2495, -1.2374,\n", + " -1.2409, -1.2387], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0061], device='cuda:0')\n", + "log_probs tensor([-3.4981], device='cuda:0')\n", + "log_probs tensor([-3.5210e+00, -3.5241e+00, -3.5458e+00, -3.5580e+00, -3.5840e+00,\n", + " -3.5486e+00, -3.6213e+00, -4.2026e-01, -1.4344e+00, -2.2248e+00,\n", + " -4.4411e+00, -3.5577e+00, -4.7194e+00, -4.5466e+00, -2.6148e+00,\n", + " -2.0950e+00, -6.8024e-01, -1.6951e-02, -9.5959e-03, -4.0313e-03,\n", + " -2.2748e-03, -3.2298e-03, -7.2201e-03, -9.8084e-03, -1.4193e-02,\n", + " -1.8943e-02, -2.6169e-02, -2.7008e-02, -2.3326e-02, -1.6971e-02,\n", + " -1.2437e-02, -1.2625e-02, -1.1336e-02, -8.4125e-03, -7.5415e-03,\n", + " -6.9929e-03, -6.9987e-03, -6.7954e-03, -6.6970e-03, -6.6936e-03,\n", + " -6.4946e-03, -6.4995e-03, -6.3989e-03, -6.2040e-03, -6.1161e-03,\n", + " -6.2124e-03, -6.0197e-03, -6.1128e-03, -6.1110e-03, -6.1146e-03],\n", + " device='cuda:0', grad_fn=)\n", + "log_probs tensor([-2.4676e-05], device='cuda:0')\n", + "log_probs tensor([-0.0080], device='cuda:0')\n", + "log_probs tensor([-7.8454e-03, -8.2549e-03, -7.9442e-03, -7.9829e-03, -8.3349e-03,\n", + " -8.0030e-03, -7.0472e-03, -6.7268e-03, -4.9508e-03, -5.0620e-03,\n", + " -6.4590e-03, -4.1252e-03, -4.7543e-03, -2.8470e-03, -4.9937e-03,\n", + " -2.6211e-03, -2.3967e-03, -2.5129e-03, -2.1773e-03, -1.0865e-03,\n", + " -8.3555e-04, -7.5812e-04, -5.7609e-04, -3.8164e-04, -3.8283e-04,\n", + " -4.4276e-04, -4.1178e-04, -3.4398e-04, -2.7986e-04, -2.1479e-04,\n", + " -1.4614e-04, -1.2540e-04, -9.8581e-05, -4.8517e-05, -3.8265e-05,\n", + " -3.4451e-05, -3.2424e-05, -3.1709e-05, -2.9802e-05, -2.7895e-05,\n", + " -2.8014e-05, -2.7299e-05, -2.6226e-05, -2.5868e-05, -2.5868e-05,\n", + " -2.4795e-05, -2.4914e-05, -2.4914e-05, -2.4795e-05, -2.4795e-05],\n", + " device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.2264], device='cuda:0')\n", + "log_probs tensor([-0.2352], device='cuda:0')\n", + "log_probs tensor([-0.2340, -0.2447, -0.2482, -0.2528, -0.2599, -0.2616, -0.2416, -0.1688,\n", + " -0.1987, -0.0651, -0.1450, -0.1208, -0.1878, -0.1472, -0.1953, -0.2304,\n", + " -0.2069, -0.1964, -0.2021, -0.7574, -1.0162, -0.7839, -0.4694, -0.2876,\n", + " -0.2679, -0.3055, -0.3308, -0.3179, -0.3181, -0.3062, -0.2871, -0.2760,\n", + " -0.2660, -0.2357, -0.2295, -0.2237, -0.2235, -0.2266, -0.2266, -0.2268,\n", + " -0.2297, -0.2296, -0.2296, -0.2265, -0.2232, -0.2295, -0.2294, -0.2263,\n", + " -0.2264, -0.2262], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.1152], device='cuda:0')\n", + "log_probs tensor([-1.6059], device='cuda:0')\n", + "log_probs tensor([-1.6050, -1.6326, -1.6575, -1.6559, -1.6843, -1.6950, -1.6140, -0.9357,\n", + " -1.4674, -1.7290, -1.7059, -1.0814, -1.3955, -1.1739, -1.0795, -1.1383,\n", + " -0.8868, -0.4796, -0.0696, -0.0616, -0.0702, -0.0802, -0.0811, -0.0601,\n", + " -0.0592, -0.0669, -0.1023, -0.1135, -0.1152, -0.1142, -0.1185, -0.1409,\n", + " -0.1582, -0.1455, -0.1355, -0.1335, -0.1297, -0.1316, -0.1267, -0.1248,\n", + " -0.1227, -0.1211, -0.1206, -0.1188, -0.1194, -0.1171, -0.1162, -0.1164,\n", + " -0.1153, -0.1146], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-1.5733], device='cuda:0')\n", + "log_probs tensor([-3.8375], device='cuda:0')\n", + "log_probs tensor([-3.8212, -3.6290, -3.4646, -3.2761, -3.1055, -2.9610, -2.9705, -2.8450,\n", + " -1.4860, -1.6356, -1.2170, -0.9426, -1.4574, -1.5975, -1.6965, -1.7592,\n", + " -1.7783, -1.3063, -1.2455, -1.4052, -1.4927, -1.2665, -1.4001, -1.3986,\n", + " -1.5204, -1.7205, -2.0572, -2.2677, -2.3425, -2.3839, -2.2673, -2.1256,\n", + " -1.9484, -1.7658, -1.7014, -1.6566, -1.6371, -1.5936, -1.6087, -1.5914,\n", + " -1.5949, -1.5832, -1.5908, -1.5817, -1.5770, -1.5811, -1.5802, -1.5716,\n", + " -1.5852, -1.5717], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-6.8185e-05], device='cuda:0')\n", + "log_probs tensor([-0.0003], device='cuda:0')\n", + "log_probs tensor([-3.1204e-04, -2.8964e-04, -2.7200e-04, -2.5841e-04, -2.4292e-04,\n", + " -2.2445e-04, -2.0550e-04, -5.8276e-04, -3.3731e-04, -1.7811e-03,\n", + " -2.8796e-03, -4.4035e-03, -3.7628e-03, -1.9863e-03, -2.3408e-03,\n", + " -2.1783e-03, -2.5642e-03, -2.4138e-03, -2.4013e-03, -1.2952e-03,\n", + " -9.3452e-04, -8.1161e-04, -8.1387e-04, -5.7502e-04, -4.6004e-04,\n", + " -4.2441e-04, -4.7565e-04, -4.7267e-04, -4.5575e-04, -3.5959e-04,\n", + " -2.2492e-04, -1.9405e-04, -1.4900e-04, -8.5469e-05, -7.5337e-05,\n", + " -7.7721e-05, -7.4622e-05, -7.4503e-05, -7.7364e-05, -7.3907e-05,\n", + " -7.2477e-05, -7.1285e-05, -7.3549e-05, -6.9497e-05, -6.9735e-05,\n", + " -7.0212e-05, -6.8781e-05, -6.9854e-05, -6.7828e-05, -6.9735e-05],\n", + " device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0004], device='cuda:0')\n", + "log_probs tensor([-0.0035], device='cuda:0')\n", + "log_probs tensor([-0.0035, -0.0034, -0.0036, -0.0036, -0.0036, -0.0036, -0.0035, -0.0013,\n", + " -0.0024, -0.0248, -0.0315, -0.0234, -0.0290, -0.0212, -0.0330, -0.0466,\n", + " -0.0565, -0.0553, -0.0352, -0.0147, -0.0093, -0.0095, -0.0079, -0.0044,\n", + " -0.0032, -0.0033, -0.0035, -0.0036, -0.0040, -0.0031, -0.0020, -0.0017,\n", + " -0.0014, -0.0008, -0.0007, -0.0006, -0.0006, -0.0006, -0.0006, -0.0005,\n", + " -0.0005, -0.0005, -0.0005, -0.0005, -0.0005, -0.0005, -0.0004, -0.0004,\n", + " -0.0004, -0.0004], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0107], device='cuda:0')\n", + "log_probs tensor([-0.2793], device='cuda:0')\n", + "log_probs tensor([-0.2726, -0.2580, -0.2491, -0.2366, -0.2276, -0.2251, -0.2300, -0.1019,\n", + " -0.0061, -0.0191, -0.0318, -0.0206, -0.0374, -0.0263, -0.0236, -0.0286,\n", + " -0.0279, -0.0316, -0.0175, -0.0109, -0.0117, -0.0149, -0.0223, -0.0177,\n", + " -0.0179, -0.0195, -0.0201, -0.0189, -0.0194, -0.0183, -0.0158, -0.0164,\n", + " -0.0163, -0.0134, -0.0123, -0.0121, -0.0120, -0.0117, -0.0121, -0.0112,\n", + " -0.0113, -0.0112, -0.0110, -0.0110, -0.0111, -0.0108, -0.0109, -0.0107,\n", + " -0.0107, -0.0106], device='cuda:0', grad_fn=)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log_probs tensor([-0.0596], device='cuda:0')\n", + "log_probs tensor([-1.3381], device='cuda:0')\n", + "log_probs tensor([-1.3258, -1.3262, -1.3034, -1.2795, -1.2711, -1.2623, -1.2526, -0.6327,\n", + " -1.2945, -1.1639, -1.4952, -1.4264, -1.2434, -1.5907, -1.3319, -1.5639,\n", + " -1.7715, -0.5916, -0.1001, -0.0836, -0.0882, -0.1100, -0.1221, -0.1155,\n", + " -0.1154, -0.1160, -0.1157, -0.0908, -0.0812, -0.0789, -0.0798, -0.0801,\n", + " -0.0825, -0.0757, -0.0720, -0.0719, -0.0677, -0.0686, -0.0676, -0.0655,\n", + " -0.0635, -0.0625, -0.0615, -0.0606, -0.0605, -0.0587, -0.0596, -0.0596,\n", + " -0.0587, -0.0587], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.2075], device='cuda:0')\n", + "log_probs tensor([-0.0851], device='cuda:0')\n", + "log_probs tensor([-0.0853, -0.0894, -0.0916, -0.0980, -0.0998, -0.0969, -0.0868, -0.1488,\n", + " -0.0432, -0.1149, -0.0989, -0.1055, -0.1507, -0.1588, -0.1008, -0.1406,\n", + " -0.0902, -0.1292, -0.1662, -0.1209, -0.1293, -0.1515, -0.1912, -0.1328,\n", + " -0.1340, -0.1825, -0.2248, -0.2551, -0.2556, -0.2477, -0.2363, -0.2483,\n", + " -0.2509, -0.2336, -0.2281, -0.2272, -0.2256, -0.2248, -0.2217, -0.2208,\n", + " -0.2165, -0.2171, -0.2134, -0.2111, -0.2112, -0.2080, -0.2091, -0.2084,\n", + " -0.2077, -0.2073], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0209], device='cuda:0')\n", + "log_probs tensor([-0.1763], device='cuda:0')\n", + "log_probs tensor([-0.1742, -0.1795, -0.1808, -0.1794, -0.1866, -0.1806, -0.1750, -0.0858,\n", + " -0.0326, -0.1616, -0.1693, -0.1404, -0.1806, -0.1811, -0.2330, -0.1810,\n", + " -0.1193, -0.0624, -0.0140, -0.0115, -0.0191, -0.0322, -0.0416, -0.0316,\n", + " -0.0285, -0.0323, -0.0317, -0.0315, -0.0269, -0.0249, -0.0239, -0.0259,\n", + " -0.0276, -0.0265, -0.0256, -0.0257, -0.0249, -0.0246, -0.0237, -0.0236,\n", + " -0.0224, -0.0224, -0.0212, -0.0212, -0.0215, -0.0210, -0.0207, -0.0206,\n", + " -0.0203, -0.0206], device='cuda:0', grad_fn=)\n" + ] + } + ], + "source": [ + "lig = LayerIntegratedGradients(model, emb_layer)\n", + "llm_grad_attr = LLMGradientAttribution(lig, tokenizer)\n", + "\n", + "inp_feature = TextTokenFeature(\n", + " \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\", \n", + " tokenizer,\n", + " baselines=0, # UNK\n", + " skip_tokens=[1],\n", + ")\n", + "\n", + "attr_result_10 = llm_grad_attr.attribute(inp_feature)" + ] + }, + { + "cell_type": "code", + "execution_count": 498, + "id": "3afde6fd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_10 = LLMAttrViz(**attr_result_10)\n", + "attr_viz_10.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 503, + "id": "af16b6f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log_probs tensor([-1.6702], device='cuda:0')\n", + "log_probs tensor([-11.6209], device='cuda:0')\n", + "log_probs tensor([-11.6196, -13.1850, -13.6289, -11.8115, -10.9584, -10.8725, -10.8887,\n", + " -11.0517, -12.4454, -12.3448, -11.4665, -13.3972, -12.4931, -10.5451,\n", + " -11.7205, -11.8162, -11.2747, -10.8822, -11.5802, -10.8118, -7.8154,\n", + " -7.5461, -8.7099, -8.8438, -6.2957, -0.9970, -0.4526, -0.4897,\n", + " -0.5069, -0.5451, -0.6533, -0.7891, -0.9134, -0.9663, -1.0652,\n", + " -1.1914, -1.2986, -1.4371, -1.5030, -1.5316, -1.5561, -1.5857,\n", + " -1.5955, -1.5967, -1.6409, -1.6452, -1.6422, -1.6383, -1.6367,\n", + " -1.6722], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0028], device='cuda:0')\n", + "log_probs tensor([-9.7633], device='cuda:0')\n", + "log_probs tensor([-9.6995e+00, -9.7178e+00, -9.6750e+00, -9.6096e+00, -9.5780e+00,\n", + " -9.5400e+00, -9.4322e+00, -8.9115e+00, -3.4575e+00, -2.8064e+00,\n", + " -2.8352e+00, -2.1759e+00, -1.5783e+00, -2.2325e+00, -1.1509e+00,\n", + " -1.6164e+00, -1.9960e+00, -2.7684e+00, -3.9720e+00, -1.8793e+00,\n", + " -1.0121e-02, -2.1858e-02, -3.9189e-02, -3.6149e-02, -2.8183e-02,\n", + " -2.2928e-02, -1.6638e-02, -1.0761e-02, -1.0007e-02, -1.0310e-02,\n", + " -1.0101e-02, -9.6416e-03, -8.9785e-03, -8.4362e-03, -7.3081e-03,\n", + " -6.0661e-03, -5.0096e-03, -4.3436e-03, -4.0257e-03, -3.6811e-03,\n", + " -3.3913e-03, -3.2756e-03, -3.1172e-03, -3.0715e-03, -2.9740e-03,\n", + " -2.9545e-03, -2.9082e-03, -2.7982e-03, -2.7951e-03, -2.8760e-03],\n", + " device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.1655], device='cuda:0')\n", + "log_probs tensor([-3.5733], device='cuda:0')\n", + "log_probs tensor([-3.5995, -3.5994, -3.6710, -3.7234, -3.7342, -3.7042, -3.6184, -3.6426,\n", + " -5.6745, -5.9610, -6.4531, -5.6245, -5.3044, -5.6563, -4.9139, -5.1317,\n", + " -5.0820, -5.3189, -3.0807, -0.5243, -0.0929, -0.0425, -0.0482, -0.0539,\n", + " -0.0427, -0.0270, -0.0288, -0.0390, -0.0500, -0.0693, -0.0964, -0.1072,\n", + " -0.1075, -0.1110, -0.1176, -0.1261, -0.1277, -0.1330, -0.1435, -0.1514,\n", + " -0.1525, -0.1577, -0.1594, -0.1598, -0.1588, -0.1610, -0.1600, -0.1599,\n", + " -0.1590, -0.1637], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-0.0236], device='cuda:0')\n", + "log_probs tensor([-6.9556], device='cuda:0')\n", + "log_probs tensor([-6.9536, -6.9546, -7.0525, -7.1391, -7.1825, -7.1824, -7.2133, -7.3497,\n", + " -6.2502, -6.4195, -7.1589, -7.0065, -7.2657, -7.5917, -6.6775, -7.0575,\n", + " -6.5688, -4.7888, -2.8797, -1.7950, -0.0873, -0.0646, -0.1366, -0.1431,\n", + " -0.1098, -0.0613, -0.0464, -0.0488, -0.0493, -0.0431, -0.0349, -0.0301,\n", + " -0.0267, -0.0263, -0.0250, -0.0229, -0.0210, -0.0203, -0.0208, -0.0218,\n", + " -0.0207, -0.0213, -0.0223, -0.0229, -0.0223, -0.0234, -0.0253, -0.0243,\n", + " -0.0239, -0.0244], device='cuda:0', grad_fn=)\n", + "log_probs tensor([-1.5348], device='cuda:0')\n", + "log_probs tensor([-2.1932], device='cuda:0')\n", + "log_probs tensor([-2.2013, -2.2331, -2.2460, -2.2333, -2.2063, -2.1883, -2.0798, -1.4750,\n", + " -1.6519, -2.0948, -1.9041, -1.5726, -1.5102, -1.6404, -1.7114, -1.8618,\n", + " -1.7982, -1.7944, -0.9950, -0.1761, -0.2472, -0.3988, -0.7632, -0.8285,\n", + " -0.6289, -0.4188, -0.3990, -0.4565, -0.4825, -0.5437, -0.6645, -0.8324,\n", + " -0.9454, -0.9994, -1.0593, -1.1560, -1.2525, -1.3226, -1.3594, -1.4042,\n", + " -1.4330, -1.4632, -1.5011, -1.5119, -1.5220, -1.5228, -1.5382, -1.5396,\n", + " -1.5343, -1.5558], device='cuda:0', grad_fn=)\n" + ] + } + ], + "source": [ + "inp_feature = TextTokenFeature(\n", + " \"Both Canada and France are beautiful countries. Their capitals are\", \n", + " tokenizer,\n", + " baselines=0, # UNK\n", + " skip_tokens=[1],\n", + ")\n", + "\n", + "attr_result_11 = llm_grad_attr.attribute(inp_feature, target=\"Ottawa and Paris.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 504, + "id": "dbd1a930", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_11 = LLMAttrViz(**attr_result_11)\n", + "attr_viz_11.plot_token_attr()" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "c32fcfda", + "id": "4aeea838", "metadata": {}, "outputs": [], "source": [] From dd66dbbce38d975e1094d098f02c3498e9ca23be Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Wed, 9 Aug 2023 01:24:55 -0700 Subject: [PATCH 04/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 725 +---------------------------- 1 file changed, 8 insertions(+), 717 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index 9487ea98d4..83d7e7c7cd 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -1803,7 +1803,7 @@ { "cell_type": "code", "execution_count": 405, - "id": "8fb5170d", + "id": "5fe58d05", "metadata": {}, "outputs": [ { @@ -1867,7 +1867,7 @@ { "cell_type": "code", "execution_count": 406, - "id": "a277e9a2", + "id": "7aab7567", "metadata": {}, "outputs": [ { @@ -1907,719 +1907,10 @@ "emb_layer = model.get_submodule(\"model.embed_tokens\")" ] }, - { - "cell_type": "code", - "execution_count": 344, - "id": "c43bf44c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "LlamaForCausalLM(\n", - " (model): LlamaModel(\n", - " (embed_tokens): Embedding(32000, 5120, padding_idx=0)\n", - " (layers): ModuleList(\n", - " (0): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (1): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (2): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (3): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (4): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (5): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (6): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (7): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (8): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (9): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (10): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (11): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (12): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (13): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (14): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (15): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (16): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (17): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (18): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (19): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (20): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (21): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (22): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (23): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (24): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (25): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (26): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (27): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (28): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (29): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (30): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (31): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (32): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (33): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (34): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (35): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (36): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (37): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (38): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " (39): LlamaDecoderLayer(\n", - " (self_attn): LlamaAttention(\n", - " (q_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (k_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (v_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (o_proj): Linear4bit(in_features=5120, out_features=5120, bias=False)\n", - " (rotary_emb): LlamaRotaryEmbedding()\n", - " )\n", - " (mlp): LlamaMLP(\n", - " (gate_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (up_proj): Linear4bit(in_features=5120, out_features=13824, bias=False)\n", - " (down_proj): Linear4bit(in_features=13824, out_features=5120, bias=False)\n", - " (act_fn): SiLUActivation()\n", - " )\n", - " (input_layernorm): LlamaRMSNorm()\n", - " (post_attention_layernorm): LlamaRMSNorm()\n", - " )\n", - " )\n", - " (norm): LlamaRMSNorm()\n", - " )\n", - " (lm_head): Linear(in_features=5120, out_features=32000, bias=False)\n", - ")" - ] - }, - "execution_count": 344, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model" - ] - }, { "cell_type": "code", "execution_count": 494, - "id": "ef832b1e", + "id": "250943a8", "metadata": {}, "outputs": [], "source": [ @@ -2757,7 +2048,7 @@ { "cell_type": "code", "execution_count": 497, - "id": "8aff0685", + "id": "4ad72605", "metadata": {}, "outputs": [ { @@ -2938,7 +2229,7 @@ { "cell_type": "code", "execution_count": 498, - "id": "3afde6fd", + "id": "e7699e5f", "metadata": {}, "outputs": [ { @@ -2960,7 +2251,7 @@ { "cell_type": "code", "execution_count": 503, - "id": "af16b6f8", + "id": "0050ebfc", "metadata": {}, "outputs": [ { @@ -3034,7 +2325,7 @@ { "cell_type": "code", "execution_count": 504, - "id": "dbd1a930", + "id": "8d730e3a", "metadata": {}, "outputs": [ { @@ -3056,7 +2347,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4aeea838", + "id": "fe09b4a3", "metadata": {}, "outputs": [], "source": [] From 18132b3097ed6d975c96842cfa950e36f82ba5db Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Wed, 9 Aug 2023 16:38:16 -0700 Subject: [PATCH 05/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 109 ++++++++++++----------------- 1 file changed, 43 insertions(+), 66 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index 83d7e7c7cd..a08c706048 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -1543,7 +1543,7 @@ }, { "cell_type": "code", - "execution_count": 290, + "execution_count": null, "id": "iraqi-gibson", "metadata": {}, "outputs": [ @@ -1551,53 +1551,37 @@ "name": "stdout", "output_type": "stream", "text": [ - "Sarah lives in Boston, WA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.6855415146419546e-06 ]\n", - "Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "John lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.949759270151844e-06 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.284733586246148e-05 ]\n", - "John lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.2905325042520417e-06 ]\n", - "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Dave lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", - "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + " Sarah lives in Boston, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5114422240003478e-05 ]\n", + "sv shape torch.Size([12, 5])\n", + " Dave lives in Boston, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4987554070321494e-07 ]\n", + " Dave lives in Seattle, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.2764603424293455e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2611800457307254e-06 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + " Martin lives in Boston, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.193209396267775e-06 ]\n", + " Sarah lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.763693166547455e-05 ]\n", + " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n" ] } ], "source": [ + "import importlib\n", + "import captum\n", + "\n", "from captum.attr import ShapleyValueSampling\n", "\n", - "svs = ShapleyValueSampling(model) \n", + "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", + "\n", + "svs = m.ShapleyValueSampling(model) \n", "baselines = ProductBaselines(\n", " {\n", " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", @@ -1607,40 +1591,33 @@ " }\n", ")\n", "\n", - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", - " baselines=baselines,\n", - " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", - ")\n", - "\n", - "llm_attr = LLMAttribution(svs, tokenizer)\n", + "sv_llm_attr = LLMAttribution(svs, tokenizer)\n", "\n", "inp_feature = TextTemplateFeature(\n", " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", " baselines=baselines,\n", - " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + "# mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", ")\n", "\n", "\n", - "attr_result_7 = llm_attr.attribute(\n", + "attr_result_7 = sv_llm_attr.attribute(\n", " inp_feature, \n", - " target=target,\n", - " num_trials=2,\n", - " n_samples=3 # arg to ShapleyValueSampling.attribute\n", + " target=\"playing golf, hiking, and cooking.\",\n", + "# num_trials=2,\n", + " n_samples=200 # arg to ShapleyValueSampling.attribute\n", ")" ] }, { "cell_type": "code", - "execution_count": 293, + "execution_count": 536, "id": "c22f5569", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1650,9 +1627,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHCCAYAAADhI708AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADYDklEQVR4nOzdeXxNx//48ddNcpOI7IlEdkGIJPatiao1FEUppar2qtpVUNqqrVKtiqi1Pl+U2mpXaZXYqhVUghK1h1hCJCKLrJLz+yM/V68kyCaL97OP+2ju3Jk5c07k3PeZmTNHpSiKghBCCCHEK06npBsghBBCCFEaSFAkhBBCCIEERUIIIYQQgARFQgghhBCABEVCCCGEEIAERUIIIYQQgARFQgghhBCABEVCCCGEEIAERUIIIYQQgARFooBkIXQhhBDljQRFokBUKhUAWVlZJdwSIYQQomhIUCTybdq0aaxZswYAHR0dFEWRniMhhBBlngRFIl+CgoLYunUr/fv3p2rVquzbtw+VSqXpORJCCCHKKgmKxAt78OABP//8M05OTpw7d46PP/6Ynj178vnnn5ORkSG9RUIIIco0CYrEC/v555+5cOECbdu2xd3dnQkTJrBkyRI2bNhARESE9BYJIYQo0yQoEi8kIiKCX375hapVqzJu3DhNuomJCbdv3+bYsWOaNOkxEkIIURbplXQDRNmwdu1aTpw4gYGBAZcuXcLNzY2kpCROnDhBVlYWXl5emrwqlYrMzEx0dHSk90gIIUSZIUGReK4jR45w4MAB2rVrR6VKlWjQoAENGjRArVYTEhLCBx98QP369fn++++Jjo5m3LhxWFpaAtm9RhIYCSGEKAtk+Ew806NHj9iwYQNZWVmMHDmSuXPn8s8//1C7dm3s7OwIDAzk22+/5datW+jq6hIaGkrVqlUJDAwE0AqI0tLSCA4OLqldEUIIIZ5JpcgEEPEMf/31F0OHDuWtt95izpw5Wp+lpaVhYGCQo8zWrVuZNGkSq1evxtvbW5O+f/9+2rZty549e2jbtm2xt10IIYTIDwmKxHOFhoZib2+PnZ2dZgVrHZ3sTsaEhARGjx5NSkoKBgYGfPrpp3h4eNCqVSvatm3LZ599BmTfzt+zZ09UKhV79uwpsX0RQggh8iJzisRzNWzYUPPz42Do8Vyh/v37ExoayuDBg4mMjOS1116jT58+XL16FT297H9eWVlZ7Nixg/379/PPP/9oymdlZaGrq/vyd0gIIYTIhfQUiQK7e/cuDg4ObNy4kXfeeQeAkydP0rVrVxRF4cyZM5ibm3P9+nXatm1L69atWbZsGenp6ejr62vqkcnYQgghSgOZaC0KTK1W06pVK/bu3QtAfHw8jx49IjExkWHDhmFubs6jR4/4v//7P+7du8fcuXOB7LvZ3n77ba5evQo8uYVf4nMhhBAlSYIiUWCWlpaMGzeObdu28frrrzN69GiaNWuGk5MTw4YNAyA8PJz58+czbdo0TExMiImJYffu3ezcuZMDBw4wceJErly5gq6urvQWCSGEKFESFIlC6dixI3fv3sXPz4+uXbvy6NEjpk6dipWVFSkpKcyZMwcHBwfGjh0LwN9//83ChQtp0aIFSUlJ3Lt3j4YNG7J7926teh89elQCeyPEE/Pnz2fHjh0l3QwhxEskE61FkXj77bdJSEhg5syZdO7cGYA//viDLVu2sHPnTgCuX7/OsmXLcHNz48CBA5qyp06d4sSJE7Rq1Yrz589Tt25dzSRtIUpCVFQUy5Yto0uXLnTt2rWkmyOEeElkorUoFgkJCTRs2BBHR0cOHDhAeno669atY/To0fz22280a9YMgBs3btClSxcePXqEu7s7UVFRxMXFsWnTJjw8PEp4L8SratCgQTx48ICZM2fi6elJZmam3CkpxCtAhs9EsTA1NWXatGmsXLkSgAsXLrB8+XLeeustTUAEsHv3bqKiohg2bBgLFixg//79uLq68u2335ZU08Ur7sSJE5w8eZI333wTT09PAHR1dcnMzCzhlgkhipuMUYhi8/777wOQnp7O9u3bCQkJYfPmzZrPT58+zc6dO/H29mbEiBGadAMDA+7cuUNWVhYqlUomYIuXJjMzk8mTJ1OnTh3effddIiMjuX79Os2bN0dXV1dzh6T8mxSifJKgqJSIjY3FwsJCszhieaKvr8+QIUOoUaMGdnZ2QHag9Ntvv3Hp0iVWrFihyXvx4kUePnxInTp1yMrKeuG5RRJAiaKwadMmHj58SPfu3TE2Nmbp0qXs3LmT5ORkAgMDadGiRUk3UQhRjMrfN3AZlJWVxdChQ7G3t2f+/Pkl3ZxiYWdnR69evTTv9+/fz88//8ybb76Jj4+PJn3dunXEx8fTokUL9PT08ly76PTp0+zevZu1a9fy77//oqOjg0ql0jyGRIj8SkpKYu7cufj4+ODr64uenh7Dhw9ny5YtdO3alb59+7J27VqtMjIlU4jyRYKiUmD//v1ER0fTunVrFixYQM2aNfnzzz9LulnFytTUlAoVKvDJJ59o0v744w8OHTpE/fr16dSpE/BkmOLxfI4bN24wZswYvL296dmzJ0uXLqV58+a8//77JCQklMueNvFyfPPNN5ibmzN48GDu3r3Ljh07+PXXX7Gzs2P69Om0atWKAwcOaAVC0jMpRPki3yAlLCUlhe+//x4bGxvWrVvH1atX6dmzJ0OGDGHFihUoilIur0Z9fHz4448/cHZ2BrKH037++WdUKhWDBw8G0Or1eXznz/Dhw/n555/x8/MjMjKS9evXs2vXLpKTk2nVqhUnT558+TsjyryrV68SFBREhw4dSE1NpW7dukydOpVvv/2WatWqsXnzZry9vTl69KgmQJ80aVKOi5fy+LcqxKtEgqIStmbNGu7evUvfvn2B7EBg2rRpDBw4kB9++IH79++X26vR/97ifPToUfbv389rr72meQDt416fx19C69evJygoiKFDhzJ9+nQsLCxwdHTktddeY+PGjdSrV4+tW7e+/B0RZd7y5csxMTGhd+/efP/997i7u3Po0CF+/fVXxo4dyyeffMKIESPo2rUrenp6REZG8vfff7Nv3z6tu9JkCFeIsk2CohJ0584dzZd5t27dgOxAQE9Pj969e3P58mX+7//+r4Rb+XK88cYb/Pjjj5qVr3PrJfruu+/w9vbmvffe0zwv7TF9fX369u2r6XkSIj/8/f1Zvnw5Dg4OPHr0CGdnZ8zNzbG1tWXUqFH06tULR0dHhg4dCqBZjb1mzZro6upy4cIFvvvuO+Lj42UIV4gyTO4+K0Hz588nIyODQYMGAdp3ULm4uKCrq8vDhw+1ymRmZmomFZc3jRs31vz89BfLxYsXiYuLo3Pnzri7uwPkWEyvVatWeHt756j30aNHskK2yNPjhRnd3NwANJOqhw8fTqtWrQgKCmLdunXMnj1bE3QfOXKE6OhoevfuDWQP6x44cID4+HhmzJhRYvsihCgcuaQpIf/88w9//vknLVu2pEmTJoB2ILBr1y4ArK2tURSFw4cPk5iYqHlw6qu2kJyDgwP379+nQYMGALnuf1ZWFoaGhiQnJ/Pvv/9y8OBBgGfexSbE08H1O++8Q2hoKHfu3OHGjRusXr2aN954g0GDBmkuRn766Sc++ugjLl++zJgxYzh58iStW7emffv2mnqOHz+u+bm8zg0sKTJEKYqLBEUlIDMzk88//xwjIyPGjx+vSXvcU5SUlMTWrVvR19enTZs2HDt2jIULF1K7dm2mT58O5DyRl2eZmZmo1Wrq1KnDhg0bSEpK0tr/xydIHR0dLl26xNtvv42vry+DBw+mevXq/PHHH+WyZ00UPUVRyMzMxMPDg61bt/Lhhx/i7u7Ohx9+iKWlJQChoaHY2tqio6PDt99+S1xcHLNmzaJGjRpYWloSHx/PzJkzee2114iIiCAuLk7W0Coi9+7dIysrS4YoRbGRf1klIC0tDTMzM4KDg9myZQuPHj1CV1dX84e+YMECdu/ezTvvvIOHhweenp4sW7aMwMBAtm7dynvvvUd8fLxWneX5yklXVxd9fX3Gjx/P3bt3NQ+Yfezxcbt//z7dunUjMzOTwMBAjh07Rrdu3Rg1ahS3b98uiaaLMkalUqGrq6v5ezIxMeHcuXO8++67mjxJSUlcv36dgIAAdHV1mTZtGiYmJly9epVatWoxZ84cduzYwcqVK3F1deW9995j9erVJbVL5UZWVhbDhg3j3XffJSkpqaSbI8orRZSYn3/+WbGzs1O8vLyU+fPnK9OnT1c++ugjRVdXV+nZs6dy9+5d5cSJE8qGDRuUS5cuKYqiKMePH1dcXV2Vf//9t4RbXzL8/f2VChUqKH379lWCg4OV5cuXKwkJCYqiKMqcOXMUKysr5fbt25r8d+7cUezs7JTVq1fnWt+jR49eSrtF2ZSRkZEj7YsvvlBUKpXy2muvKYmJiYqiKEqdOnWU1atXKwEBAUrt2rWVRYsWafJXrFhR2bBhg6IoipKZmalVV1ZWVjG2vnwJDg5WmjVrpsydOzfXz58+tkIUhPQUlaCePXty+/ZtBg0axL59+zh48CDHjx8nICCAL774gu+++47GjRuzePFiWrZsybBhwzAyMsLCwoJTp04BcObMGcaOHVuue4r+69NPP+XSpUuoVCoWLFjAb7/9xp07dwBYuHAhI0aMwM7OjvT0dAAsLCzIyMjA2NhYU0dISAh79+4F0DzPSpH5HoUSGxtbLv8N5jZBv3fv3owYMYIlS5ZgbGxMSEgI+vr6nDp1ivHjxzN9+nTNzRP79++nevXq1KpVC3jSq3nt2jVAFn98UY/Xc7O3t2fgwIGA9rzC5ORkGVITRaOkozKRLS0tTUlOTta8P3XqlKJSqZSdO3cq9+/fV44ePaq0bt1a0dPTUypWrKjExcUpiqIos2bNUmrXrq3cv38/R53lvRckNjZWSUlJURRFUSIjIxV3d3flf//7n6IoT67AFy1apDRq1EjZtWuXoiiKkpSUpAwdOlTx8vJS6tWrp4SEhJRM48uRzMxMpXv37oqtra0SEBBQ0s0pVrn17GzYsEHR09NTnJ2dNfv/uNfizz//VKpWraqcPXtWUZTsnqf//e9/SqVKlZQ1a9Zo1Sk9HXn73//+p1SvXl3Ztm2boijZ57bH57fw8HDF1tZW+euvv5Q7d+5ojqsQBSGhdSmhr6+PoaGh5n1MTAy2trZ4eHhgYWFB06ZNCQgIQF9fn08//RRzc3OysrJQFAUbGxsMDAxy1FneJ2NbWlpqjpmTkxNubm6aHjSVSsWVK1fYtGkTHh4eNGvWDICKFSvy7bffEhISQqtWrejfvz9//fVXSe1CufDfx9QEBgZSrVo1goODS7pZxSK3xRkrVqyIqakpY8eOzbHO1qFDhzA2NsbT05O0tDSmTp3K1KlT8fPzo127dpo6IedipSLbnTt3WLNmDffv32fkyJH89NNP6OrqoqurS0pKCkuWLCErKwtvb2/UajWLFy/mt99+K+lmi7KqpKMykbs7d+4ozZs3V2rVqqVs3bpV+eabb5RGjRoplStX1vSOKIqiNGvWTBkxYoTmfWpqqrJ27VqlV69eysOHD0ui6S/d4yvtn376STE1NVXee+89ZcKECYq1tbXSpk0b5dixY4qiKMrevXuV77//Xlm5cqWm7GuvvaZ8/vnnudZb3nvaikJycrLStWtXpUePHkp6erqiKIoyffp0RaVSKVOnTn1lej+SkpI0f2+P9zkjI0MZNWqUMmbMGOXy5ctK586dlfr162vmG2VlZSl79+5V/Pz8lH79+inLli0rsfaXZpMmTVLeeOMN5c8//1TWrFmjODg4KI0bN1aOHTumXLx4UVGr1crWrVtLupminJAV7UopW1tb/vjjDz777DPWr18PZN8KvGHDBk3vSEREBPHx8bzxxhuacp9++ilHjhzBwcEBIyOjHPU+XqiuPHl8pf3+++/TuHFjpkyZwq1bt+jfvz+zZs3C0NCQuXPn8t1331GjRg2SkpKYPXs2X3zxBTVq1EBRFNLT09HX1yc1NZX79+9jb2+vdReSzFfI3bp16wgPD+fbb79FrVaTlZXF1KlT+fDDD3n06BGLFy/GyMhIM8emvFEUhaysLCpWrKhJ09HRISsrCz09PbKysvj111+JiYnh/Pnz/Prrr7i6ugIwevRoTp48iZOTE3Xq1GHGjBls3LiRdevWYWtrW1K7VKo8Xs+tTZs2NGvWjGbNmtG+fXvmzJlDhw4dSE5O5vXXX6dbt258++23XL9+nQULFmiWQFAUReZtifwp4aBMvID09HRl+fLlSs2aNbXSz58/r7i7uyt//vmncvv2bWXixImKgYGBsmHDBs38pLCwMGXfvn3KL7/8oin3Ktzx8t+7hiIjI5U33nhDGTJkiJKenq5ER0crCxcuVMzNzRVbW1slMDBQURRFOXfunNK8eXOlUaNGyuuvv66EhYWVVPPLhKioKKVFixaKpaWlYm9vn2Muxz///KO0bt1a6dChQ653cZVH//3bSk5OVry8vBSVSqVMmTJFOX78uOazP/74Q1GpVEqTJk2UW7duKYqS3dvUokUL5ccff8xR76vS4/ZfGRkZSufOnZU333xTuX79uibtsa+//lpRqVTKv//+q1y4cEFxc3NT+vTpk2td0usrXpRc/pYBarWaIUOGcOLECQAyMjKA7J6iqKgoPDw8NHNjVq1aRa9evYiPj+e7776jffv2zJw5k9GjR1OnTh3CwsJeiSun/9415OjoyKNHj7C2tkatVlOpUiV69epFy5YtqVq1qqYX4/FzrWbNmkXDhg1p3bo1s2bN0szxOHz4MPPmzSMtLe3l71ApNH/+fBRFYefOncyZM4eJEyfi7e1NZGQkAGvXriU9PZ3x48drek3KO5VKxcOHD1EUhc8//5z09HRGjRrFV199pfUYmylTptC8eXOcnJxwd3dnypQpVKxYEVdXV06ePKm5G/LYsWPAqznfKD09HTc3Nzp27Iizs7Om9w3g9u3brFq1io8++gh3d3eWLl3Kw4cP+d///gfAX3/9xYoVK/j9998BtHp9hXimEg7KRCF8+umniqWlpfLaa68p9erV07oSnTFjhmJvb68sXLhQUZTsK82PP/5YadeunZKamlpSTX7pHl+5BwQEKIaGhsqIESOUb7/9VvHx8VFsbGw0vRtxcXFK69atleHDh2vKrlq1Spk/f74SHR2tBAUFKZMmTVLs7e2Vq1evlsi+lCanT59WmjVrpkydOlWTFh0drfj7+ysXLlxQ/vzzT6V58+bKuHHjSrCVL9///vc/RaVSKU2bNlVMTU2VHTt25JhrFB0drdStW1czt+33339X6tevr9jb2yseHh6af4O3b99WVCqVsmDBAuXKlSslsj+lweO/4ce9PY8ePVJmzZqlmJiYKLGxscrBgweVSpUqKfPnz1cURVE2bdqkmJqaKq1atVJsbGyU119/XTl//nyJtV+ULRIUlWHr1q1TdHV1lQ4dOijR0dGa9BMnTihvvPGGUrVqVcXMzEwzkTgtLU1xcXFRDh06VFJNLlFhYWHKmDFjlBEjRigVK1ZUevfurfX53r17FQ8PD2XWrFnKw4cPlaSkJOXu3bvKgwcPlNdee01RqVRKv379Sqj1pUduwxr/Hd5JTk5WhgwZorRs2VIJDw/P8Xl59/vvvytr1qzR7PvTMjIylObNmyuDBw/WpKWnpytLly7VDIcriqKMHj1aUalUSseOHRVvb2+lbt26yrVr117KPpRmJ0+eVExMTJTvv/9eSU1NVd555x2lXr16ms/79++vvPfee0pycrKSnJysfPDBB0rr1q2VmzdvlmCrRVkhQVEZd+/ePc0f++Px9j/++EOxtrZWTp8+rfz5559KgwYNFFdXV+X7779XjI2N8zxZvyquX7+uvPnmm8q+ffsURck+XvHx8YqiKMr//d//KT4+PsqOHTs0+e/cuaP069dPqVq1qmJiYqLUq1dPMw/kVfTw4UPlk08+URYsWKAoypMr+cf/X7VqlfLaa68p3377bYm1sbRbsWKF4u3tnWOdrMersx87dkzR1dVVJkyYoISEhCg3b95UvvnmG82dlK+yH3/8UXFyclKysrKUdevWKRYWFkpwcLCiKNm9SIsWLVIMDQ018yhv376tBAUFKQ8ePCjJZosyQoKicmjbtm2KsbGxEhsbqyhKdg/R999/r9ja2ipNmjRRIiMjS7iFpcfNmzeVzp07K5s2bdKkDR06VPHw8NAsffD4Cn779u2KoijKlClTlD179pRIe0uT/wZDj3uCrl+/rnTv3l3p0qWLcu/ePUVRXq1eoheVnp6uDBs2TDE0NFQGDBigrFy5Ujlx4oTm85YtWypt2rTR+iJ/9OjRKzNh/XmSkpKU+/fvK25ubkrbtm0VRck+zz02bdo05e2331ZCQ0NzfCbEs8hE63LI19eXunXrsm7dOiB7YciRI0dy9uxZFi1ahL29fQm3sPSoVKkSHh4efPzxx0yYMIHQ0FAuXLiAq6sriqJw+vRpdu7cibu7O127dgXgq6++ok2bNiXc8pL3eMK+SqXSTARev349d+/epU+fPlhbW8sTzXOhKApqtZolS5Zw4sQJFEUhPDyc1NRUAH7++Wf+/PNPvvrqK8zMzDTldHV1c33syKuoYsWKWFhYMG/ePFasWAHAokWLCAoKAmDgwIHo6+szYsQI4uPj0dfXL8nmirKkhIMyUcQeX73Pnz9fMTU1VYYNG6acPHlSOXr0aAm3rHT766+/lMaNGyuNGzdWfH19NY8T8Pf3V2rVqqUZ5pAr9bzduHFDadSokVKpUqVXemLwi8jMzNTqQXs8fJuSkqJUrlxZGTlyZEk1rUx68OCB0q1bN6Vz586af3ubNm1SPD09NY9YEeJFqBRFnoRZXp05c4ZPPvmEe/fu4evry7Rp07QWmRM5RURE4OLigo6ODnfv3qVTp040atSIpUuXykJwL+Ds2bP07duXGzdu4Ofnx/Dhw7V6O4S2p3vSjh49So8ePfjjjz+oWrVqCbas7ImNjWXYsGHs3r2bbt26cezYMezs7FizZg1OTk4l3TxRRkhQ9Ao4c+YMlpaWODg4lHRTypTY2FgaNGjAokWLeOutt2QoKB9+/PFHxo8fj4mJCT/88AO+vr4l3aQy4/Hq6qJg/vzzT7Zt24anpycNGzakbt26ckEjXpgERULkIS0tjYkTJ7J06VLmzp3LqFGjSrpJZc7kyZNJTk4mICBAAsoXUB4fwyNEWSJBkRDPERQUxPHjxxk5ciSVKlUq6eaUORkZGajVarlaF0KUehIUCSGEEEIA0p8thBBCCIEERUIIIYQQgARFQgghhBCABEVCCCGEEIAERUIIIYQQgARF5V5aWhrTpk0jLS2tpJtSJsnxKzg5dgUnx65w5PiJgpJb8su5hIQEzMzMiI+Px9TUtKSbU+bI8Ss4OXYFJ8eucOT4iYKSniIhhBBCCCQoEkIIIYQAQK+kG1DWZWVlcfv2bUxMTErlIwwSEhK0/i/yR45fwcmxKzg5doVTmo+foigkJiZib29frM8DTE1NJT09vUjq0tfXx9DQsEjqKu1kTlEh3bx5Eycnp5JuhhBCiDLkxo0bODo6FkvdqampVLAyheSMIqmvcuXKREREvBKBkfQUFZKJiQkAE37pg0FF/RJuTdkz66czJd0E8Yp6MO/Lkm5CmTU3bGtJN6HMSnuYzred12m+O4pDenp6dkDUtx7o6xayskzu/HSK9PR0CYrE8z0eMjOoqI+hsQRF+aYv/wRFyTA1rVjSTSiz5FxXeC9luoWhHqpCnmMVndI3LaQ4yTeSEEIIUQ6pdFSoChvU6Kh4lebYyN1nQgghhBBIT5EQQghRLqlURdBTpHq1eookKBJCCCHKoaIaPnuVyPCZEEIIIQTSUySEEEKUSyqVqvB3uZXCRYmLkwRFQgghRDkkw2f5J8NnQgghhBBIT5EQQghRLklPUf5JUFRKHNt8juNbz/EgKhEAG1cLWg1pQA0f51zzb5l+kJNBF3Ok27haMHpjTwDCdl1g64xDOfJ8eXgQaoPsX33aw3SCl53g3MFrPIxLwa6GNZ3Ge+PoYfPMbTl62TBsxdsF2teiFjFrG1Ws7HKkLzq0mZEb5uZIb+HWgIOfLM6R7j6tFxfuXgfAw86VGZ2H0tDZnSpWdozdFEDg/o1a+T9t34/u9VriXtmFlIw0jlw5w6Tti7h4N1KT58tOQ+jdqC1OFrakZ2YQGnmBz3Ys5fi18MLudpGR41d4iqIwffpqli8PIi4ukaZNa7Fw4Wg8Pas8s9yWLX8wdepKrlyJolo1O2bNGky3bq9r5Vm8eAdz5/5MVFQsnp5VCAgYTvPmdXKt76OP5rF8eRDz5g1n7Nh3NOlpaen4+S1jw4b9pKSk06ZNfRYtGoOjY6VC73tByTmv+ElQlH8lFhQdPHiQVq1aERcXh7m5eZHUOW3aNLZv386pU6eKpL6Xycy2Iu1GNMHK0RSAk0EXWeu3h+FrumNbzTJH/k7jfWg3oonmfVZmFgvf34JnG1etfAYV1Yzd1Esr7fHJAWDbV38QfSWOHtNaYVrJiFO/XWLliCDGbHwXU5snj0Fw83ai+xctNO911aVn5LXx1wPR/c/Tpr3sqxE85ns2he5/ZrkaX/YkIfWh5v29xAean430Dbkac4tNYfsI6DE21/It3Oqz6NAW/r5+Dj0dXb7qOow9owLxmPEeyempAFyMjmTkxu+4GnOLCmoDxrV5jz2jA6k+tQcxSQ9yrfdlk+NXeN98s4GAgM2sXDmRGjUc+eqrn2jXbiLnz6/CxMQo1zIhIeH07j2TGTMG0q3b62zb9ie9es3g8OFAmjatBcDGjQcYN24xixaNplkzL5Yt20XHjpMJD1+Bs7OtVn3bt//J8ePnsbe3yrGtsWMXs2tXCOvXf46VlSl+fkvp3PkzTpxYgq5uIZ+NVUByzit+EhTlX9n7LT+Dn58f+/btK+lmFIh7cxdqNnPG2sUcaxdzfIc3Qd9IzY2z0bnmNzTWx8TaSPO69W8MqYlpNOhcUyufSqXSymdi/eQEnZH6iHMHImg/qimuDeywcjKjzdBGWNibcmzLOa169NQ6WnUYmZWeBwPGJD3gbsJ9zeut2s24HH2DQ5fCnlkuOjFOq1yWkqX57MT1f5m4dSEbTwST9ij3J013WDiOH48GcS4qgn9uXWbg6lm4WNnR0Nldk2f933vYd/5vImJucy4qgk82z8esgjF1HKoXzc4XATl+haMoCoGBW5kypQ/duzfHy8uVVasmkZycyrp1eZ+PAgO34uvbkMmT++Du7szkyX1o06YBgYFbNHkCAjYzaFAHhgzpRK1aLsyfPwInJxuWLPlFq65bt+4xatT3/PTTFNRq7Wvd+PgkVqz4jblzh9G2bUPq13djzZrJnDkTQXDws3/HxUnOeaI0KlfDZ8bGxhgbG5d0MwotKzOLs/uukp6SgXNt2+cXAEJ3nqdqEwcs7LSfvJyeksG3XdahZCnYuVnRZlgj7Gtaa7aTlamg99RTlNUGulw/fUcrLSIsCv/2qzE0NqBKAzt8P26MsWWFQuxl8VDr6tG3yZvM27f+uXlPTlmNoVqfc1ERzPptJQcvFu4LwqxC9r+9+8kJebZt6Otv8yA5kdM3LxVqW8VFjl/+RUREcefOfdq1a6RJMzDQp0WLuoSEhPPRR51zLRcSck5riAugXbtGmqAoPT2D0NCLTJr0nlYeX9+GhIQ8GT7MysqiX7+v8fN7N9fhutDQS2RkPNJqn729NV5eVThyJJz27Rvne5+Lmpzziof0FOVfsfQUXbt2DZVKxYYNG/Dx8cHQ0BBPT08OHjyYZ5nY2Fjee+89HB0dMTIyonbt2qxf/+TEvHr1aqysrEhLS9Mq984779CvXz8ge/isXr16ms8GDBjA22+/zdy5c7Gzs8PKyooRI0aQkfHkyjUqKopOnTpRoUIFXF1dWbduHVWqVGH+/Pm5tjMtLY2EhAStV1G5c/k+M1qsYNrr/8fOr/+kzzftsKlq8dxyiTHJXAq5QaMu7lrplVzM6T61JX3ntufdma3RM9Bl+ZAdxETGA2BQUR+n2rYcWBFGwr2HZGVmceq3S9wMjyYpJllTTw0fJ3rOaM2gxW/RYexr3Dp3jxXDd/EoPbPI9r2ovF23BeYVjFkVEpRnnqiEGD78yZ93fphM92WfcuFuJPvGLKR59XqF2va8HmM4fPkU4bevaqV38mpGYsB+Uhf8wbg2vfFdMJrYh/GF2lZxkeOXf3fuxAFga6v9t2pjY6H5LPdy93OUsbV9UiYmJp7MzKw88tzXvJ8zZwN6erqMHt09z+3o66uxsNAOHp6upyTIOa94PQ6KCvt6lRRrT9GECROYP38+Hh4ezJs3jy5duhAREYGVVc4x79TUVBo2bMikSZMwNTUlKCiIDz74gKpVq9K0aVN69uzJ6NGj2blzJz17Zk+qi4mJYdeuXezevTvPNhw4cAA7OzsOHDjA5cuX6dWrF/Xq1ePDDz8EoF+/fsTExHDw4EHUajWffPIJ0dG5d98C+Pv7M3369EIemdxZu5gx4qd3SE1MJ/xABFumH2TI0s7PPUmE7bqAobE+tVpW0Up3qm2L03+uupzrVmbxB1s5+vNZ3vJrBkCP6a3YNvMQ33Rai46uCrua1tRpX53bF2I05Wr7VtP8bFvNEodalZjbZR0X/orEs5X2eH5JG9ysM7+FHyUqPibPPBfvRmpN5j0acRYnC1v8fN/n8OVTBdruwt5+1HGozutzh+b47MDFUOrN7oe1sRkfNuvKz0O+ouk3g7mXmPcXZkmR4/d8a9cGM2xYgOb9rl2zAXIskqcoynMXzsu9zNN5eCrPk3KhoRdZsGAroaFL871I34u0r7jJOU+UNsU6p2jkyJG888471KpViyVLlmBmZsb//d//5ZrXwcEBPz8/6tWrR9WqVRk1ahTt27dn06ZNAFSoUIE+ffqwcuVKTZm1a9fi6OhIy5Yt82yDhYUFCxcuxN3dnbfeeotOnTpp5h2dP3+e4OBgli9fTtOmTWnQoAH/+9//SElJybO+yZMnEx8fr3nduHGjAEcmd3pqXayczHDwqES7EU2o7GbFkY1nnllGURTCfrlAvQ5u6KmfPWFSR0eFg0clYm886d2ycjRlyLLOTD00kAm/vM/Hq7qR+SgLC3uTPOsxsTbC3M6Y2MjSc7UO4GxZmbbujfnfXzvyXfZoxFncKjkVaLsL3h1Pl9rNaRUwnFsP7uX4PDk9lSv3bnIsIpwhP83mUVYmg31yH1IpSXL8XkyXLj6cPPmD5mVtbQaQo9fl3r0H2Nqa51lP5cqWOcpERz/Q9AxZW5uhq6uTo7cpOjpOk+fw4TNERz/AxeU91Gpf1Gpfrl+/i5/fUlxd+2i2k56eQVxcYp7bKilyzite0lOUf8UaFHl7e2t+1tPTo1GjRvz777+55s3MzOSrr76iTp06WFlZYWxszJ49e4iMfHJF+uGHH7Jnzx5u3boFwMqVKxkwYMAzr3Y8PT217q6ws7PT9ARduHABPT09GjRooPm8evXqWFjkfaIwMDDA1NRU61VsFIXM9KxnZokIiyL2RgINu7o/M192dQp3LsZiYp1zXFy/ghoTayNSEtK4fPQmtd6okmc9yQ9Sib/7UGsCY2kw0PstohPjCDp7JN9l6zvVICoh796RvHzfazzd67eg9fyRXIuNeqEyKsBATz/f2ypucvxejImJEdWrO2heHh4uVK5syd69oZo86ekZHDp0Gm9vzzzr8fb2IDg4VCtt794T+Phkl9HXV9OwYQ2tegGCg0M19X7wQVtOn16uFaTZ21vh5/cuu3fPAaBhQzfUaj2teqKiYjl79ppmW6WGnPOKlAqV5lEfBX7xagVFL32idV4BzHfffUdAQADz58+ndu3aVKxYkbFjx5Kenq7JU79+ferWrcvq1atp3749Z86c4Zdffsm1vsfUanWO7WdlZf/RKYqSa5m80ovTnsXHqeHthJmtMWnJGZzZc5mIsCj6B3bI/nzRcRKiH9JjeiutcqE7z+PoZZPrLaz7l4fi5GWDlbMZaQ/TCdl4lqiLMXSe2EyT51LIDRTA2tmM+zcT2L3gGNYuZpo7OtKSM9i/PBTPVq6YWBsRF5XI3sV/Y2RuiMdTXdclSaVSMdC7Ez8e/ZXMLO1x/9ldP8bBvBL9f5wBwJjWvbgWG0X47Qj09bInFvdo0Jruyz7VlFHr6uFhl91Nrq+rh4N5Jeo6upGUlsKVezcBWNR7An0at6Pr0okkpj3E1jT7dxCf8pDUjDSM9A35rMMAdv5zmKj4WKwqmjG8xTs4WtiwKax03SUpx6/gVCoVY8Z0x99/HW5ujri5OeDvvw4jI0P69Gmjyde//9fY21vj7z8EgNGju9OixVjmzFlP167N2LHjL4KDwzh8OFBTZty4HvTr9zWNGtXA29uDH34IIjIymmHDsnvKrKzMsLIy02qPWq1H5cqW1KyZ3XNnZmbMoEEd8PNbipWVKZaWJkyYsIzatV1p27YBJUXOeaI0Ktag6OjRo7zxxhsAPHr0iNDQUEaOHJlr3sOHD9O1a1f69u0LZN9RcenSJWrVqqWVb8iQIQQEBHDr1i3atm2Lk1PBuuwB3N3defToESdPnqRhw4YAXL58mQcPHhS4zoJKik1h87QDJMYkY2isj211K/oHdqB6U0cge2Lhg7tJWmVSk9I5tz+CjuN9cq0zNTGN7f6HSYrNrtOuhjVDlnXB0dNGq449i7NPPhVMDfBs7Yrvx03Q1cvuRNTRUXH38n1O/XqR1MR0jK2NqNrQnl6z22BQsfT0drR1b4yLlR0rjuQMku3MrHG2rKx5r6+rZm73UTiYVyIlI43wqAg6LhzHb+Ehmjz2ZpU49dkazfsJvn2Z4NuXgxfDaBUwHIDhLbLvHDr0yRKt7Q34cSY/Hg0iMysLd9sq9B/aEeuK5sQ+jOfv6//S/LthnIuKKNL9Lyw5foUzcWJvUlLSGTEiULN44++/z9FaoygyMhqd/wxF+Ph4sn7953zxxUqmTl1FtWr2bNjwhWaNIoBevVoRG5vAzJlriIq6j5dXFYKC/HFxebE7tB4LCBiOnp4uvXrN0CzeuHLlrBJbowjknPcyyN1n+adSiqFb5Nq1a7i6uuLs7Mz8+fOpVasWAQEBrFu3joiICKytrXMs3jhu3Di2bNnChg0bsLCwYN68efz888+0atWK7du3a+pOSEjAzs6OR48esXr1anr1erJI19OLNw4YMIAHDx5olR87diynTp3S3Ann6+vL/fv3WbJkCWq1mvHjx3P06FH8/f0ZM2bMc/c1ISEBMzMzPt8/AEPjsvUHUxp8vuJ0STdBvKKyFs8u6SaUWbNPbHx+JpGr1KR0ZrVeRXx8fLFNv3j8vWT6eWtUhoXr+1BSH5Ewa3+xtrc0KdY5RV9//TVz5syhbt26HD58mB07dmBtbZ1r3i+++IIGDRrQvn17WrZsSeXKlXn77bdz5DM1NeWdd97B2Ng418/za/Xq1dja2vLGG2/QrVs3PvzwQ0xMTDA0lIW6hBBCiFdJsQ6f1apVi6NHj+b6WcuWLbXm7lhaWmr16DxLVFQU77//PgYGBlrp06ZNY9q0aZr3q1atylH26fWH7Ozs+PXXXzXvb968SXR0NNWrl54Vc4UQQoj8kuGz/CtTK1rfv3+fPXv2sH//fhYuXFgkde7fv5+kpCRq165NVFQUEydOpEqVKpq5UEIIIURZJEFR/r1wUPR4ntCLqFix4vMzFUCDBg2Ii4tjzpw51KxZ8/kFXkBGRgZTpkzh6tWrmJiY4OPjw9q1a3PctSaEEEKUJSodiiAoKpq2lBUvHBSp1eoXDkRq1KjBzp07C9yovFy7dq3I62zfvj3t27cv8nqFEEIIUba8cFDk4ODA+fPni7MtQgghhCgqRTB8psjwmRBCCCHKuqKYUySP+RBCCCGEeAVJT5EQQghRDklPUf5JUCSEEEKUQ48f6lrYOl4lMnwmhBBCiCJx69Yt+vbti5WVFUZGRtSrV4/Q0NCSbtYLk54iIYQQohxSqYpg+CwfPUVxcXE0a9aMVq1a8dtvv2FjY8OVK1cwNzcvVBteJgmKhBBCiHLoZc8pmjNnDk5OTqxcuVKTVqVKlUJt/2WT4TMhhBCiHHocFBX29aJ27txJo0aN6NmzJzY2NtSvX5/ly5cX4x4WPQmKhBBCCPFMCQkJWq+0tLQcea5evcqSJUtwc3Pj999/Z9iwYYwePZrVq1eXQIsLRoIiIYQQohzS0SmaF4CTkxNmZmaal7+/f47tZWVl0aBBA2bPnk39+vX56KOP+PDDD1myZMlL3vOCkzlFQgghRDmkq1KhU0S35N+4cQNTU1NNuoGBQY68dnZ2eHh4aKXVqlWLLVu2FKoNL5MERUIIIYR4JlNTU62gKDfNmjXjwoULWmkXL17ExcWlOJtWpCQoEkIIIcohXR0VOi/x7rNx48bh4+PD7Nmzeffddzl+/Dg//PADP/zwQ6Ha8DJJUCSEEEKUQ0U5fPYiGjduzLZt25g8eTIzZszA1dWV+fPn8/777xeqDS+TBEVCCCGEKBJvvfUWb731Vkk3o8AkKBJCCCHKIR0d0C3sPeav2D3qEhSVEsc2n+P41nM8iEoEwMbVglZDGlDDxznX/FumH+Rk0MUc6TauFoze2BOAsF0X2DrjUI48Xx4ehNog+1ef9jCd4GUnOHfwGg/jUrCrYU2n8d44etg8c1uOXjYMW/F2gfa1qEXM2kYVK7sc6YsObWbkhrk50lu4NeDgJ4tzpLtP68WFu9cB8LBzZUbnoTR0dqeKlR1jNwUQuH+jVv5P2/eje72WuFd2ISUjjSNXzjBp+yIu3o3U5Pmy0xB6N2qLk4Ut6ZkZhEZe4LMdSzl+Lbywu11k5PgVnqIoTJ++muXLg4iLS6Rp01osXDgaT88qzyy3ZcsfTJ26kitXoqhWzY5ZswbTrdvrWnkWL97B3Lk/ExUVi6dnFQIChtO8eZ1c6/voo3ksXx7EvHnDGTv2HU16Wlo6fn7L2LBhPykp6bRpU59Fi8bg6Fip0PteUHLOK366KhW6hX2g6yv2QNhXPihq2bIl9erVY/78+QAkJyfzwQcfsHfvXhITE4mLi3spz20xs61IuxFNsHLMnt1/Mugia/32MHxNd2yrWebI32m8D+1GNNG8z8rMYuH7W/Bs46qVz6CimrGbemmlPT45AGz76g+ir8TRY1orTCsZceq3S6wcEcSYje9ialNRk8/N24nuX7TQvNdVl57Lh8ZfD0RX50l7vOyrETzmezaF7n9muRpf9iQh9aHm/b3EB5qfjfQNuRpzi01h+wjoMTbX8i3c6rPo0Bb+vn4OPR1dvuo6jD2jAvGY8R7J6akAXIyOZOTG77gac4sKagPGtXmPPaMDqT61BzFJD3Kt92WT41d433yzgYCAzaxcOZEaNRz56qufaNduIufPr8LExCjXMiEh4fTuPZMZMwbSrdvrbNv2J716zeDw4UCaNq0FwMaNBxg3bjGLFo2mWTMvli3bRceOkwkPX4Gzs61Wfdu3/8nx4+ext7fKsa2xYxeza1cI69d/jpWVKX5+S+nc+TNOnFiCrq5u0R+QFyDnPFEayW/5KT/++COHDx/myJEjREVFYWZm9lK2697chZrNnLF2McfaxRzf4U3QN1Jz42x0rvkNjfUxsTbSvG79G0NqYhoNOtfUyqdSqbTymVg/OUFnpD7i3IEI2o9qimsDO6yczGgztBEW9qYc23JOqx49tY5WHUZmhkV/EAooJukBdxPua15v1W7G5egbHLoU9sxy0YlxWuWylCzNZyeu/8vErQvZeCKYtEcZuZbvsHAcPx4N4lxUBP/cuszA1bNwsbKjobO7Js/6v/ew7/zfRMTc5lxUBJ9sno9ZBWPqOFQvmp0vAnL8CkdRFAIDtzJlSh+6d2+Ol5crq1ZNIjk5lXXr9uVZLjBwK76+DZk8uQ/u7s5MntyHNm0aEBj4ZE2XgIDNDBrUgSFDOlGrlgvz54/AycmGJUt+0arr1q17jBr1PT/9NAW1WvtaNz4+iRUrfmPu3GG0bduQ+vXdWLNmMmfORBAc/OzfcXGSc17xe9xTVNjXq+SV7yl62pUrV6hVqxZeXl4l1oaszCzO7rtKekoGzrVtn18ACN15nqpNHLCwM9FKT0/J4Nsu61CyFOzcrGgzrBH2Na0128nKVNDT175SVBvocv30Ha20iLAo/NuvxtDYgCoN7PD9uDHGlhUKsZfFQ62rR98mbzJv3/rn5j05ZTWGan3ORUUw67eVHLxYuC8IswrGANxPTsizbUNff5sHyYmcvnmpUNsqLnL88i8iIoo7d+7Trl0jTZqBgT4tWtQlJCScjz7qnGu5kJBzWkNcAO3aNdIERenpGYSGXmTSpPe08vj6NiQk5MnwYVZWFv36fY2f37u5DteFhl4iI+ORVvvs7a3x8qrCkSPhtG/fON/7XNTknFc8dHVU6BbylnwKW76MKdNB0ZEjRxg+fDjnz5/Hy8uLzz//nG7dunHy5Enq1asHwKFDh5gwYQKnT5/G0tKS/v37M2vWLPT0cu56y5YtOXQoezxapVLRokULDh48+NL2587l+/wweDuP0jPRr6CmzzftsKlq8dxyiTHJXAq5Qc8ZrbXSK7mY031qS2yrWZL2MJ2QjWdZPmQHI9b2wNrZDIOK+jjVtuXAijAquZpjbFmBf/Zc4WZ4NFZOT3rIavg44dWmKuZ2xsTdTiR46QlWDN/F8NXdc5xcStrbdVtgXsGYVSFBeeaJSojhw5/8CY08j4Gemg+admDfmIW0DBjO4cunCrzteT3GcPjyKcJvX9VK7+TVjA2DZ2Kkb0hUQgy+C0YT+zC+wNspTnL88u/OnTgAbG21/1ZtbCyIjLz7jHL3c5SxtbXQ1BcTE09mZlYeee5r3s+ZswE9PV1Gj+6e53b09dVYWGgHD0/XUxLknFe8dAHdVyumKbQyGxQlJibSuXNnOnbsyLp167h+/Tpjx47VynPr1i06duzIgAEDWL16NefPn+fDDz/E0NCQadOm5ahz69atfPrpp5w9e5atW7eir6+fI09aWprWg/ASEnK/qi0IaxczRvz0DqmJ6YQfiGDL9IMMWdr5uSeJsF0XMDTWp1bLKlrpTrVtcfrPVZdz3cos/mArR38+y1t+zQDoMb0V22Ye4ptOa9HRVWFX05o67atz+0KMplxt32qan22rWeJQqxJzu6zjwl+ReLbSHs8vaYObdea38KNExcfkmefi3UitybxHI87iZGGLn+/7Bf5SX9jbjzoO1Xl97tAcnx24GEq92f2wNjbjw2Zd+XnIVzT9ZjD3EuMKtK3iJMfv+dauDWbYsADN+127ZgM513NRFOW5a7zkXubpPDyV50m50NCLLFiwldDQpflaT+ZF21fc5JwnSpsyGxStXbsWlUrF8uXLMTQ0xMPDg1u3bvHhhx9q8ixevBgnJycWLlyISqXC3d2d27dvM2nSJKZOnYqOjvaUKktLS4yMjNDX16dy5cq5btff35/p06cXyz7pqXU1VysOHpW4ee4eRzae4e3Jb+RZRlEUwn65QL0Obuipn30Fo6OjwsGjErE3ngRyVo6mDFnWmfSUDNIeZmBibcSGKcFY2JvkWY+JtRHmdsbERpaeq3UAZ8vKtHVvTPdln+a77NGIs/Rt8maBtrvg3fF0qd2cN+YN49aDezk+T05P5cq9m1y5d5NjEeFcnL6JwT6d+fr30vXkaDl+L6ZLFx/NRGiAtLTsOVN37tzHzu7JJOd79x5ga2ueZz2VK1vm6KmJjn6g6RmytjZDV1dH03P0JE+cJs/hw2eIjn6Ai8uTIbbMzCz8/JYSGLiFiIh1VK5sSXp6BnFxiVq9RdHRD/D29szn3hctOecVLxk+y78yO9H6woUL1KlTB0PDJ5PfmjRpopXn33//xdvbW+tqqFmzZiQlJXHz5s0CbXfy5MnEx8drXjdu3CjYDrwIRSEzPeuZWSLCooi9kUDDru7PzJddncKdi7GYWOccF9evoMbE2oiUhDQuH71JrTeq5FlP8oNU4u8+1JrAWBoM9H6L6MQ4gs4eyXfZ+k41iErIu3ckL9/3Gk/3+i1oPX8k12KjXqiMCjDQy9kLWdLk+L0YExMjqld30Lw8PFyoXNmSvXtDNXnS0zM4dOj0M4MOb28PgoNDtdL27j2Bj092GX19NQ0b1tCqFyA4OFRT7wcftOX06eWcPPmD5mVvb4Wf37vs3j0HgIYN3VCr9bTqiYqK5ezZa5ptlRpyzitSOkUwybqwK2KXNWW2pyi3rl9FUV44T0G7jQ0MDHJ9OnBh7Vl8nBreTpjZGpOWnMGZPZeJCIuif2CH7M8XHSch+iE9prfSKhe68zyOXja53sK6f3koTl42WDmbacbXoy7G0HliM02eSyE3UABrZzPu30xg94JjWLuYae7oSEvOYP/yUDxbuWJibURcVCJ7F/+NkbkhHk91XZcklUrFQO9O/Hj0VzKzMrU+m931YxzMK9H/xxkAjGndi2uxUYTfjkBfL3ticY8GrbV6SNS6enjYZXeT6+vq4WBeibqObiSlpXDlXnZAvaj3BPo0bkfXpRNJTHuIrWn27yA+5SGpGWkY6RvyWYcB7PznMFHxsVhVNGN4i3dwtLBhU1jedyWVBDl+BadSqRgzpjv+/utwc3PEzc0Bf/91GBkZ0qdPG02+/v2/xt7eGn//IQCMHt2dFi3GMmfOerp2bcaOHX8RHBzG4cOBmjLjxvWgX7+vadSoBt7eHvzwQxCRkdEMG5Y9edvKygwrK+07ZNVqPSpXtqRmTScAzMyMGTSoA35+S7GyMsXS0oQJE5ZRu7Yrbds2KO7Dkyc554nSqMwGRe7u7qxdu5a0tDRNkHLixAmtPB4eHmzZskUrODpy5AgmJiY4ODi89DY/S1JsCpunHSAxJhlDY31sq1vRP7AD1Zs6AtkTCx/cTdIqk5qUzrn9EXQc75NrnamJaWz3P0xSbHaddjWsGbKsC46eNlp17FmcffKpYGqAZ2tXfD9ugq5edieijo6Ku5fvc+rXi6QmpmNsbUTVhvb0mt0Gg4qlp7ejrXtjXKzsWHHklxyf2ZlZ42z5ZDhUX1fN3O6jcDCvREpGGuFREXRcOI7fwkM0eezNKnHqszWa9xN8+zLBty8HL4bRKmA4AMNbZN85dOiTJVrbG/DjTH48GkRmVhbutlXoP7Qj1hXNiX0Yz9/X/6X5d8M4FxVRpPtfWHL8CmfixN6kpKQzYkSgZvHG33+fo7VGUWRktNbDOX18PFm//nO++GIlU6euolo1ezZs+EJraK5Xr1bExiYwc+YaoqLu4+VVhaAgf1xcXuwOrccCAoajp6dLr14zNIs3rlw5q8TWKAI5570MRTF8prxiw2cq5enulTIiISEBV1dX3nrrLT799FMiIyMZO3Ys58+f59SpU9StW5dbt25Ro0YNBg4cyMiRI7lw4QJDhgxhxIgRmonWTy/eOHbsWE6dOvXCd50lJCRgZmbG5/sHYGhctv5gSoPPV5wu6SaIV1TW4tkl3YQya/aJjc/PJHKVmpTOrNariI+Px9TUtFi28fh7qdmqHugZqQtV16PkDP4asLlY21ualNk5Raampvzyyy+cOnWKevXq8dlnnzF16lQAzTwjBwcHfv31V44fP07dunUZNmwYgwcP5vPPPy/JpgshhBCiFCqzw2cAPj4+nD79pKdh7dq1qNVqnJ2fPDunRYsWHD9+PM86nu4RetxjJIQQQpRlMnyWf2U6KFq9ejVVq1bFwcGB06dPM2nSJN59910qVChbq44KIYQQRa0oHtOhvGJ3n5Wq4bNr166hUqle6OXl5cWdO3fo27cvtWrVYty4cfTs2ZMffvihpHdDCCGEEGVQqeopUqvV1KxZ8/kZgapVqzJx4kQmTpxYzK0SQgghyh5dFUXQU1REjSkjSlVQ5ODgwPnz50u6GUIIIUSZp6MDuoUcD8oqVeNJxa9UBUVCCCGEKBpFMacoS+YUCSGEEEK8eqSnSAghhCiHiuKW/Cy5JV8IIYQQZZ0Mn+WfDJ8JIYQQQiA9RUIIIUS5pCt3n+WbBEVCCCFEOaRLEQyfIcNnQgghhBCvHOkpEkIIIcohnSK4+yxT7j4TQgghRFlXFHefFbZ8WSPDZ0IIIYQQSE+REEIIUS4Vxd1nhS1f1khQJIQQQpRDMnyWfxIUCSGEEOWQrir7Vdg6XiWvWMeYEEIIIUTupKdICCGEKId0VCp0Cjn8VdjyZY0ERUIIIUQ5pFMEw2ev2DJFEhSVFsc2n+P41nM8iEoEwMbVglZDGlDDxznX/FumH+Rk0MUc6TauFoze2BOAsF0X2DrjUI48Xx4ehNog+1ef9jCd4GUnOHfwGg/jUrCrYU2n8d44etg8c1uOXjYMW/F2gfa1qEXM2kYVK7sc6YsObWbkhrk50lu4NeDgJ4tzpLtP68WFu9cB8LBzZUbnoTR0dqeKlR1jNwUQuH+jVv5P2/eje72WuFd2ISUjjSNXzjBp+yIu3o3U5Pmy0xB6N2qLk4Ut6ZkZhEZe4LMdSzl+Lbywu11k5PgVnqIoTJ++muXLg4iLS6Rp01osXDgaT88qzyy3ZcsfTJ26kitXoqhWzY5ZswbTrdvrWnkWL97B3Lk/ExUVi6dnFQIChtO8eZ1c6/voo3ksXx7EvHnDGTv2HU16Wlo6fn7L2LBhPykp6bRpU59Fi8bg6Fip0PteUHLOE6WRBEWlhJltRdqNaIKVoykAJ4MustZvD8PXdMe2mmWO/J3G+9BuRBPN+6zMLBa+vwXPNq5a+Qwqqhm7qZdW2uOTA8C2r/4g+kocPaa1wrSSEad+u8TKEUGM2fgupjYVNfncvJ3o/kULzXtddemZjtb464Ho6jxpj5d9NYLHfM+m0P3PLFfjy54kpD7UvL+X+EDzs5G+IVdjbrEpbB8BPcbmWr6FW30WHdrC39fPoaejy1ddh7FnVCAeM94jOT0VgIvRkYzc+B1XY25RQW3AuDbvsWd0INWn9iAm6UGu9b5scvwK75tvNhAQsJmVKydSo4YjX331E+3aTeT8+VWYmBjlWiYkJJzevWcyY8ZAunV7nW3b/qRXrxkcPhxI06a1ANi48QDjxi1m0aLRNGvmxbJlu+jYcTLh4StwdrbVqm/79j85fvw89vZWObY1duxidu0KYf36z7GyMsXPbymdO3/GiRNL0NXVLfoD8gLknFf8dFSF7+l51XqKyt5vuZxyb+5CzWbOWLuYY+1iju/wJugbqblxNjrX/IbG+phYG2let/6NITUxjQada2rlU6lUWvlMrJ+coDNSH3HuQATtRzXFtYEdVk5mtBnaCAt7U45tOadVj55aR6sOIzPDoj8IBRST9IC7Cfc1r7dqN+Ny9A0OXQp7ZrnoxDitcllKluazE9f/ZeLWhWw8EUzao4xcy3dYOI4fjwZxLiqCf25dZuDqWbhY2dHQ2V2TZ/3fe9h3/m8iYm5zLiqCTzbPx6yCMXUcqhfNzhcBOX6FoygKgYFbmTKlD927N8fLy5VVqyaRnJzKunX78iwXGLgVX9+GTJ7cB3d3ZyZP7kObNg0IDNyiyRMQsJlBgzowZEgnatVyYf78ETg52bBkyS9add26dY9Ro77np5+moFZrX+vGxyexYsVvzJ07jLZtG1K/vhtr1kzmzJkIgoOf/TsuTnLOK36P7z4r7OtVIj1FpVBWZhZn910lPSUD59q2zy8AhO48T9UmDljYmWilp6dk8G2XdShZCnZuVrQZ1gj7mtaa7WRlKujpa18pqg10uX76jlZaRFgU/u1XY2hsQJUGdvh+3BhjywqF2MviodbVo2+TN5m3b/1z856cshpDtT7noiKY9dtKDl4s3BeEWQVjAO4nJ+TZtqGvv82D5ERO37xUqG0VFzl++RcREcWdO/dp166RJs3AQJ8WLeoSEhLORx91zrVcSMg5rSEugHbtGmmCovT0DEJDLzJp0ntaeXx9GxIS8mT4MCsri379vsbP791ch+tCQy+RkfFIq3329tZ4eVXhyJFw2rdvnO99LmpyzhOlhQRF+ZSWlkZaWprmfUJC7ifwgrhz+T4/DN7Oo/RM9Cuo6fNNO2yqWjy3XGJMMpdCbtBzRmut9Eou5nSf2hLbapakPUwnZONZlg/ZwYi1PbB2NsOgoj5OtW05sCKMSq7mGFtW4J89V7gZHo2Vk5mmnho+Tni1qYq5nTFxtxMJXnqCFcN3MXx19xwnl5L2dt0WmFcwZlVIUJ55ohJi+PAnf0Ijz2Ogp+aDph3YN2YhLQOGc/jyqQJve16PMRy+fIrw21e10jt5NWPD4JkY6RsSlRCD74LRxD6ML/B2ipMcv/y7cycOAFtb7b9VGxsLIiPvPqPc/RxlbG0tNPXFxMSTmZmVR577mvdz5mxAT0+X0aO757kdfX01FhbawcPT9ZQEOecVLx0dFTqFHP8qTHl/f3+mTJnCmDFjmD9/fqHa8bJIUJRP/v7+TJ8+vVjqtnYxY8RP75CamE74gQi2TD/IkKWdn3uSCNt1AUNjfWq1rKKV7lTbFqf/XHU5163M4g+2cvTns7zl1wyAHtNbsW3mIb7ptBYdXRV2Na2p0746ty/EaMrV9q2m+dm2miUOtSoxt8s6LvwViWcr7fH8kja4WWd+Cz9KVHxMnnku3o3Umsx7NOIsTha2+Pm+X+Av9YW9/ajjUJ3X5w7N8dmBi6HUm90Pa2MzPmzWlZ+HfEXTbwZzLzGuQNsqTnL8nm/t2mCGDQvQvN+1azaQPWzzX4qi5Eh7Wu5lns7DU3melAsNvciCBVsJDV363G097UXaV9zknFe8SnLxxr///psffviBOnVyvymgtJI5Rfk0efJk4uPjNa8bN24UWd16al2snMxw8KhEuxFNqOxmxZGNZ55ZRlEUwn65QL0Obuipn30Fo6OjwsGjErE3nvRuWTmaMmRZZ6YeGsiEX97n41XdyHyUhYW9SZ71mFgbYW5nTGxk6blaB3C2rExb98b8768d+S57NOIsbpWcCrTdBe+Op0vt5rQKGM6tB/dyfJ6cnsqVezc5FhHOkJ9m8ygrk8E+uQ+plCQ5fi+mSxcfTp78QfOyts7uYXi61+XevQfY2prnWU/lypY5ykRHP9D0DFlbm6Grq6PpOXqSJ06T5/DhM0RHP8DF5T3Ual/Ual+uX7+Ln99SXF37aLaTnp5BXFxintsqKXLOK5+SkpJ4//33Wb58ORYWJftvLL8kKMonAwMDTE1NtV7FRlHITM96ZpaIsChibyTQsKv7M/NlV6dw52IsJtY5x8X1K6gxsTYiJSGNy0dvUuuNKnnWk/wglfi7D7UmMJYGA73fIjoxjqCzR/Jdtr5TDaIS8u4dycv3vcbTvX4LWs8fybXYqBcqowIM9PTzva3iJsfvxZiYGFG9uoPm5eHhQuXKluzdG6rJk56ewaFDp/H29syzHm9vD4KDQ7XS9u49gY9Pdhl9fTUNG9bQqhcgODhUU+8HH7Tl9OnlWkGavb0Vfn7vsnv3HAAaNnRDrdbTqicqKpazZ69ptlVqyDmvSD2++6ywL8ieKvLf13+nkTxtxIgRdOrUibZt276kPS06MnxWSuxZfJwa3k6Y2RqTlpzBmT2XiQiLon9gh+zPFx0nIfohPaa30ioXuvM8jl42ud7Cun95KE5eNlg5m2nG16MuxtB5YjNNnkshN1AAa2cz7t9MYPeCY1i7mGnu6EhLzmD/8lA8W7liYm1EXFQiexf/jZG5IR5PdV2XJJVKxUDvTvx49FcyszK1Ppvd9WMczCvR/8cZAIxp3YtrsVGE345AXy97YnGPBq3pvuxTTRm1rh4edtnd5Pq6ejiYV6KuoxtJaSlcuXcTgEW9J9CncTu6Lp1IYtpDbE2zfwfxKQ9JzUjDSN+QzzoMYOc/h4mKj8WqohnDW7yDo4UNm8LyviupJMjxKziVSsWYMd3x91+Hm5sjbm4O+Puvw8jIkD592mjy9e//Nfb21vj7DwFg9OjutGgxljlz1tO1azN27PiL4OAwDh8O1JQZN64H/fp9TaNGNfD29uCHH4KIjIxm2LDsnjIrKzOsrMy02qNW61G5siU1a2b33JmZGTNoUAf8/JZiZWWKpaUJEyYso3ZtV9q2bVDchydPcs4rfkU5fObkpN0T/OWXXzJt2rQc+Tds2EBYWBh///134TZcQiQoKiWSYlPYPO0AiTHJGBrrY1vdiv6BHaje1BHInlj44G6SVpnUpHTO7Y+g43ifXOtMTUxju/9hkmKz67SrYc2QZV1w9LTRqmPP4uyTTwVTAzxbu+L7cRN09bI7EXV0VNy9fJ9Tv14kNTEdY2sjqja0p9fsNhhULD29HW3dG+NiZceKI7/k+MzOzBpny8qa9/q6auZ2H4WDeSVSMtIIj4qg48Jx/BYeosljb1aJU5+t0byf4NuXCb59OXgxjFYBwwEY3iL7zqFDnyzR2t6AH2fy49EgMrOycLetQv+hHbGuaE7sw3j+vv4vzb8bxrmoiCLd/8KS41c4Eyf2JiUlnREjAjWLN/7++xytNYoiI6O1Jq36+Hiyfv3nfPHFSqZOXUW1avZs2PCFZo0igF69WhEbm8DMmWuIirqPl1cVgoL8cXF5sTu0HgsIGI6eni69es3QLN64cuWsElujCOSc9zIU5WM+bty4oTUyYmBgkCPvjRs3GDNmDHv27MHQsOwtYQCgUhRFKelGlCarVq1i4MCBvOhhSUhIwMzMjM/3D8DQuGz9wZQGn684XdJNEK+orMWzS7oJZdbsExufn0nkKjUpnVmtVxEfH19s0y8efy99um9AoQO5tIfpfN3mxdq7fft2unXrphVsZ2ZmolKp0NHRIS0trUQD8RchPUVPuXbtGi1atHh+RiGEEKIU06EInn2Wj7xt2rThzBntifIDBw7E3d2dSZMmlfqACCQoyuH3338nMDDw+RmFEEKIUuxlP+bDxMQELy8vrbSKFStiZWWVI720kqDoKSEhIc/PJIQQQohyR4IiIYQQohzSVanQLeRE68KWP3jwYKHKv2wSFAkhhBDl0MsePisPZPFGIYQQQgikp0gIIYQol0ry2WdllQRFQgghRDmko5P9Kmwdr5JXbHeFEEIIIXInPUVCCCFEOVQa7j4rayQoEkIIIcohVRHcffaKxUQSFAkhhBDlkUy0zj+ZUySEEEIIgfQUCSGEEOWSLN6YfxIUCSGEEOWQTLTOPxk+E0IIIYRAeoqEEEKIckmGz/JPgiIhhBCiHJK7z/JPhs+EEEIIIZCeIiGEEKJc0lGp0CnkROnCli9rJCgSQgghyiGdIhg+e9XmFMnwmRBCCCEE0lNUahzbfI7jW8/xICoRABtXC1oNaUANH+dc82+ZfpCTQRdzpNu4WjB6Y08AwnZdYOuMQznyfHl4EGqD7F992sN0gped4NzBazyMS8GuhjWdxnvj6GHzzG05etkwbMXbBdrXohYxaxtVrOxypC86tJmRG+bmSG/h1oCDnyzOke4+rRcX7l4HwMPOlRmdh9LQ2Z0qVnaM3RRA4P6NWvk/bd+P7vVa4l7ZhZSMNI5cOcOk7Yu4eDdSk+fLTkPo3agtTha2pGdmEBp5gc92LOX4tfDC7naRkeNXeIqiMH36apYvDyIuLpGmTWuxcOFoPD2rPLPcli1/MHXqSq5ciaJaNTtmzRpMt26va+VZvHgHc+f+TFRULJ6eVQgIGE7z5nVyre+jj+axfHkQ8+YNZ+zYdzTpaWnp+PktY8OG/aSkpNOmTX0WLRqDo2OlQu97Qck5r/jJ8Fn+SVBUSpjZVqTdiCZYOZoCcDLoImv99jB8TXdsq1nmyN9pvA/tRjTRvM/KzGLh+1vwbOOqlc+gopqxm3pppT0+OQBs++oPoq/E0WNaK0wrGXHqt0usHBHEmI3vYmpTUZPPzduJ7l+00LzXVZeeTsbGXw9EV+dJe7zsqxE85ns2he5/ZrkaX/YkIfWh5v29xAean430Dbkac4tNYfsI6DE21/It3Oqz6NAW/r5+Dj0dXb7qOow9owLxmPEeyempAFyMjmTkxu+4GnOLCmoDxrV5jz2jA6k+tQcxSQ9yrfdlk+NXeN98s4GAgM2sXDmRGjUc+eqrn2jXbiLnz6/CxMQo1zIhIeH07j2TGTMG0q3b62zb9ie9es3g8OFAmjatBcDGjQcYN24xixaNplkzL5Yt20XHjpMJD1+Bs7OtVn3bt//J8ePnsbe3yrGtsWMXs2tXCOvXf46VlSl+fkvp3PkzTpxYgq6ubtEfkBcg57ziJ0FR/pW933IRunbtGiqVilOnTpV0U3Bv7kLNZs5Yu5hj7WKO7/Am6BupuXE2Otf8hsb6mFgbaV63/o0hNTGNBp1rauVTqVRa+Uysn5ygM1Ifce5ABO1HNcW1gR1WTma0GdoIC3tTjm05p1WPnlpHqw4jM8OiPwgFFJP0gLsJ9zWvt2o343L0DQ5dCntmuejEOK1yWUqW5rMT1/9l4taFbDwRTNqjjFzLd1g4jh+PBnEuKoJ/bl1m4OpZuFjZ0dDZXZNn/d972Hf+byJibnMuKoJPNs/HrIIxdRyqF83OFwE5foWjKAqBgVuZMqUP3bs3x8vLlVWrJpGcnMq6dfvyLBcYuBVf34ZMntwHd3dnJk/uQ5s2DQgM3KLJExCwmUGDOjBkSCdq1XJh/vwRODnZsGTJL1p13bp1j1Gjvuenn6agVmtf68bHJ7FixW/MnTuMtm0bUr++G2vWTObMmQiCg5/9Oy5Ocs4rfjqoNIFRgV+8WkGR9BSVQlmZWZzdd5X0lAyca9s+vwAQuvM8VZs4YGFnopWenpLBt13WoWQp2LlZ0WZYI+xrWmu2k5WpoKevfaWoNtDl+uk7WmkRYVH4t1+NobEBVRrY4ftxY4wtKxRiL4uHWlePvk3eZN6+9c/Ne3LKagzV+pyLimDWbys5eLFwXxBmFYwBuJ+ckGfbhr7+Ng+SEzl981KhtlVc5PjlX0REFHfu3Kddu0aaNAMDfVq0qEtISDgffdQ513IhIee0hrgA2rVrpAmK0tMzCA29yKRJ72nl8fVtSEjIk+HDrKws+vX7Gj+/d3MdrgsNvURGxiOt9tnbW+PlVYUjR8Jp375xvve5qMk5T5QWEhSVIncu3+eHwdt5lJ6JfgU1fb5ph01Vi+eWS4xJ5lLIDXrOaK2VXsnFnO5TW2JbzZK0h+mEbDzL8iE7GLG2B9bOZhhU1Mepti0HVoRRydUcY8sK/LPnCjfDo7FyMtPUU8PHCa82VTG3MybudiLBS0+wYvguhq/unuPkUtLertsC8wrGrAoJyjNPVEIMH/7kT2jkeQz01HzQtAP7xiykZcBwDl8+VeBtz+sxhsOXTxF++6pWeievZmwYPBMjfUOiEmLwXTCa2IfxBd5OcZLjl3937sQBYGur/bdqY2NBZOTdZ5S7n6OMra2Fpr6YmHgyM7PyyHNf837OnA3o6ekyenT3PLejr6/GwkI7eHi6npIg57zild3bU7gBoVdt+EyCIuDq1auMGzeOY8eO4ebmxtKlS/H29s41b1paGmlpaZr3CQm5X9UWhLWLGSN+eofUxHTCD0SwZfpBhizt/NyTRNiuCxga61OrZRWtdKfatjj956rLuW5lFn+wlaM/n+Utv2YA9Jjeim0zD/FNp7Xo6Kqwq2lNnfbVuX0hRlOutm81zc+21SxxqFWJuV3WceGvSDxbaY/nl7TBzTrzW/hRouJj8sxz8W6k1mTeoxFncbKwxc/3/QJ/qS/s7Ucdh+q8Pndojs8OXAyl3ux+WBub8WGzrvw85CuafjOYe4lxBdpWcZLj93xr1wYzbFiA5v2uXbOB7GGb/1IUJUfa03Iv83QensrzpFxo6EUWLNhKaOjS527raS/SvuIm57ziJXOK8u+VnlP02GeffYafnx+nTp2iRo0avPfeezx69CjXvP7+/piZmWleTk5ORdYOPbUuVk5mOHhUot2IJlR2s+LIxjPPLKMoCmG/XKBeBzf01M++gtHRUeHgUYnYG08COStHU4Ys68zUQwOZ8Mv7fLyqG5mPsrCwN8mzHhNrI8ztjImNLD1X6wDOlpVp696Y//21I99lj0acxa1SwX6XC94dT5fazWkVMJxbD+7l+Dw5PZUr925yLCKcIT/N5lFWJoN9ch9SKUly/F5Mly4+nDz5g+ZlbZ3dw/B0r8u9ew+wtTXPs57KlS1zlImOfqDpGbK2NkNXV0fTc/QkT5wmz+HDZ4iOfoCLy3uo1b6o1b5cv34XP7+luLr20WwnPT2DuLjEPLdVUuScJ0obCYoAPz8/OnXqRI0aNZg+fTrXr1/n8uXLueadPHky8fHxmteNGzeKr2GKQmZ61jOzRIRFEXsjgYZd3Z+ZL7s6hTsXYzGxzjkurl9BjYm1ESkJaVw+epNab1TJs57kB6nE332oNYGxNBjo/RbRiXEEnT2S77L1nWoQlZB370hevu81nu71W9B6/kiuxUa9UBkVYKCnn+9tFTc5fi/GxMSI6tUdNC8PDxcqV7Zk795QTZ709AwOHTqNt7dnnvV4e3sQHByqlbZ37wl8fLLL6Ouradiwhla9AMHBoZp6P/igLadPL9cK0uztrfDze5fdu+cA0LChG2q1nlY9UVGxnD17TbOtUkPOeUWq0JOsi6CnqayR4TOgTp0na37Y2WWv1xIdHY27e84/OgMDAwwMDIq8DXsWH6eGtxNmtsakJWdwZs9lIsKi6B/YIfvzRcdJiH5Ij+mttMqF7jyPo5dNrrew7l8eipOXDVbOZprx9aiLMXSe2EyT51LIDRTA2tmM+zcT2L3gGNYuZpo7OtKSM9i/PBTPVq6YWBsRF5XI3sV/Y2RuiMdTXdclSaVSMdC7Ez8e/ZXMrEytz2Z3/RgH80r0/3EGAGNa9+JabBThtyPQ18ueWNyjQWu6L/tUU0atq4eHXXY3ub6uHg7mlajr6EZSWgpX7t0EYFHvCfRp3I6uSyeSmPYQW9Ps30F8ykNSM9Iw0jfksw4D2PnPYaLiY7GqaMbwFu/gaGHDprC870oqCXL8Ck6lUjFmTHf8/dfh5uaIm5sD/v7rMDIypE+fNpp8/ft/jb29Nf7+QwAYPbo7LVqMZc6c9XTt2owdO/4iODiMw4cDNWXGjetBv35f06hRDby9PfjhhyAiI6MZNiy7p8zKygwrKzOt9qjVelSubEnNmtk9d2Zmxgwa1AE/v6VYWZliaWnChAnLqF3blbZtGxT34cmTnPOKnwyf5Z8ERYBardb8/HiMPSvr2VcrRS0pNoXN0w6QGJOMobE+ttWt6B/YgepNHYHsiYUP7iZplUlNSufc/gg6jvfJtc7UxDS2+x8mKTa7Trsa1gxZ1gVHTxutOvYszj75VDA1wLO1K74fN0FXL7sTUUdHxd3L9zn160VSE9MxtjaiakN7es1ug0HF0tPb0da9MS5Wdqw48kuOz+zMrHG2rKx5r6+rZm73UTiYVyIlI43wqAg6LhzHb+Ehmjz2ZpU49dkazfsJvn2Z4NuXgxfDaBUwHIDhLbLvHDr0yRKt7Q34cSY/Hg0iMysLd9sq9B/aEeuK5sQ+jOfv6//S/LthnIuKKNL9Lyw5foUzcWJvUlLSGTEiULN44++/z9FaoygyMhqd/zwzwcfHk/XrP+eLL1YydeoqqlWzZ8OGLzRrFAH06tWK2NgEZs5cQ1TUfby8qhAU5I+Ly4vdofVYQMBw9PR06dVrhmbxxpUrZ5XYGkUg5zxROqkURVFKuhEl5dq1a7i6unLy5Enq1asHwIMHD7CwsODAgQO0bNnyuXUkJCRgZmbG5/sHYGgsfzD59fmK0yXdBPGKylo8u6SbUGbNPrHx+ZlErlKT0pnVehXx8fGYmpoWyzYefy9t+mcURiaFG9lITkyjZ53vi7W9pYn0FAkhhBDlkKoIhs9K+g7Fl00mWgshhBBC8Ir3FFWpUoWnRw/Nzc1zpAkhhBBljUy0zr9XOigSQgghyisdlU4RrGj9ag0olbu9ffyQ1xd5eXl5lXRzhRBCiGIh6xRlL6+jo/PioU656ylSq9XUrFnz+RmBqlWrFnNrhBBCCFGS8jNZvNwFRQ4ODpw/f76kmyGEEEKUKJlTlC0/84TLXVAkhBBCiFcjKPrxxx+f+Xl8fP6eVydBkRBCCCHKpHHjxj3z8/zeTS5BkRBCCFEOvey7z/z9/dm6dSvnz5+nQoUK+Pj4MGfOnBee51sQ9+/ff+bn9+7dw9b2xR+LU+7uPhNCCCEE6KAqkteLOnToECNGjODo0aPs3buXR48e0a5dOx4+fFiMe/ls+e0pkqBICCGEEIW2e/duBgwYgKenJ3Xr1mXlypVERkYSGhparNvdsWMHr7/+OlZWVlhZWfH666+zbds2zef5uftMgiIhhBCiHCrKdYoSEhK0Xmlpac/d/uNJzpaWlsW2j8uWLaNXr154eXkRGBjI/PnzqV27Nr1792bJkiVUqFCB/v37v3B9MqdICCGEKIeyHwhbuL6Px70sTk5OWulffvkl06ZNy7Ocoih88sknvP7668W6UPLcuXMJDAzko48+0qR98MEH1KtXj2+//ZaPP/6YFStWvHB9EhQJIYQQ4plu3LiBqamp5r2BgcEz848cOZJ//vmHP//8s9jb1aZNmxzpbdq0YfTo0fmuT4bPhBBCiHKoKIfPTE1NtV7PCopGjRrFzp07OXDgAI6OjsW6j66uruzcuTNH+i+//FKgp1ZIT5EQQghRDr3sxRsVRWHUqFFs27aNgwcP4urqWqhtv4gvvviCAQMGcOzYMXx8fFCpVPz1119s3bqVlStX5rs+CYqEEEKIcuhlr1M0YsQI1q1bx44dOzAxMeHOnTsAmJmZUaFChUK1Iy99+vTBycmJb7/9loULF6IoCrVq1SI4OJgWLVrkuz4JioQQQghRaEuWLAGgZcuWWukrV65kwIABxbbd5s2b07x58yKpS4IiIYQQohwqieGzsk6CIiGEEKIcyu+K1HnVUZrp6uq+cDCWlZX13DwSFAkhhBCiTPrvytU7d+5kz549BAQEoFarC1SfBEVCCCFEOaRDEQyflfKeoi5dugDZj/pYv349Dg4ObN++nTVr1hSovlcyKGrZsiX16tVj/vz5VKlShbFjxzJ27NgSbdOxzec4vvUcD6ISAbBxtaDVkAbU8HHONf+W6Qc5GXQxR7qNqwWjN/YEIGzXBbbOOJQjz5eHB6E2yP7Vpz1MJ3jZCc4dvMbDuBTsaljTabw3jh42z9yWo5cNw1a8XaB9LWoRs7ZRxcouR/qiQ5sZuWFujvQWbg04+MniHOnu03px4e51ADzsXJnReSgNnd2pYmXH2E0BBO7fqJX/0/b96F6vJe6VXUjJSOPIlTNM2r6Ii3cjNXm+7DSE3o3a4mRhS3pmBqGRF/hsx1KOXwsv7G4XGTl+hacoCtOnr2b58iDi4hJp2rQWCxeOxtOzyjPLbdnyB1OnruTKlSiqVbNj1qzBdOv2ulaexYt3MHfuz0RFxeLpWYWAgOE0b14n1/o++mgey5cHMW/ecMaOfUeTnpaWjp/fMjZs2E9KSjpt2tRn0aIxODpWKvS+F5Sc84rfy777rKRs2bKFDz74gP/973+8+eabNG/enDFjxhAYGJjvul7JoGjr1q0F7lorLma2FWk3oglWjtkrhp4Mushavz0MX9Md22o5nxvTabwP7UY00bzPysxi4ftb8GyjvS6EQUU1Yzf10kp7fHIA2PbVH0RfiaPHtFaYVjLi1G+XWDkiiDEb38XUpqImn5u3E92/eHJ7o6669PyhNP56ILo6T9rjZV+N4DHfsyl0/zPL1fiyJwmpT57efC/xgeZnI31DrsbcYlPYPgJ6jM21fAu3+iw6tIW/r59DT0eXr7oOY8+oQDxmvEdyeioAF6MjGbnxO67G3KKC2oBxbd5jz+hAqk/tQUzSg1zrfdnk+BXeN99sICBgMytXTqRGDUe++uon2rWbyPnzqzAxMcq1TEhIOL17z2TGjIF06/Y627b9Sa9eMzh8OJCmTWsBsHHjAcaNW8yiRaNp1syLZct20bHjZMLDV+DsbKtV3/btf3L8+Hns7a1ybGvs2MXs2hXC+vWfY2Vlip/fUjp3/owTJ5agq6tb9AfkBcg5TxSFTZs2MWDAAFauXEmvXtm/9+DgYHx8fLCysmLq1Kn5qu+V/C1bWlpiYmJS0s3Q4t7chZrNnLF2McfaxRzf4U3QN1Jz42x0rvkNjfUxsTbSvG79G0NqYhoNOtfUyqdSqbTymVg/OUFnpD7i3IEI2o9qimsDO6yczGgztBEW9qYc23JOqx49tY5WHUZmhkV/EAooJukBdxPua15v1W7G5egbHLoU9sxy0YlxWuWylCeT8E5c/5eJWxey8UQwaY8yci3fYeE4fjwaxLmoCP65dZmBq2fhYmVHQ2d3TZ71f+9h3/m/iYi5zbmoCD7ZPB+zCsbUcaheNDtfBOT4FY6iKAQGbmXKlD50794cLy9XVq2aRHJyKuvW7cuzXGDgVnx9GzJ5ch/c3Z2ZPLkPbdo0IDBwiyZPQMBmBg3qwJAhnahVy4X580fg5GTDkiW/aNV169Y9Ro36np9+moJarX2tGx+fxIoVvzF37jDatm1I/fpurFkzmTNnIggOfvbvuDjJOa/4FeWK1qXVgAEDWL16tSYgArCzs2Pfvn2aJQLy45UMilq2bJnncNnKlSsxMzNj7969L7dR/5GVmcU/ey6TnpKBc23b5xcAQneep2oTByzstIO99JQMvu2yjm/eWsuacbu5fSFGaztZmQp6+tpXimoDXa6fvqOVFhEWhX/71QS8s5FtX/1B0v2UAu5d8VLr6tG3yZusCNn13Lwnp6zm9te7CB7zPS1rNCj0ts0qGANwPzkhz7YNff1tHiQncvrmpUJvrzjI8cu/iIgo7ty5T7t2jTRpBgb6tGhRl5CQvIf5QkLO4evbSCutXbtGHDmSXSY9PYPQ0Ita9QL4+jbUqjcrK4t+/b7Gz+/dXIfrQkMvkZHxSKsee3trvLyqaLZV0uScVzxUKp0ieZVma9eu5Z133smRXrVqVX7//fd81/dKDp/lZe7cufj7+/P777/z2muvvfTt37l8nx8Gb+dReib6FdT0+aYdNlUtnlsuMSaZSyE36DmjtVZ6JRdzuk9tiW01S9IephOy8SzLh+xgxNoeWDubYVBRH6fathxYEUYlV3OMLSvwz54r3AyPxsrJTFNPDR8nvNpUxdzOmLjbiQQvPcGK4bsYvrp7jpNLSXu7bgvMKxizKiQozzxRCTF8+JM/oZHnMdBT80HTDuwbs5CWAcM5fPlUgbc9r8cYDl8+Rfjtq1rpnbyasWHwTIz0DYlKiMF3wWhiH8YXeDvFSY5f/t25EweAra3236qNjQWRkXefUe5+jjK2thaa+mJi4snMzMojz33N+zlzNqCnp8vo0d3z3I6+vhoLC+3g4el6SoKc80Rhvf3225w5c4Y5c+YQFhaGjo4ODRs2xM/Pjzp1cp979ywSFP1/kydP5scff+TgwYPUrl07z3xpaWmkpaVp3ick5H5VWxDWLmaM+OkdUhPTCT8QwZbpBxmytPNzTxJhuy5gaKxPrZZVtNKdatvi9J+rLue6lVn8wVaO/nyWt/yaAdBjeiu2zTzEN53WoqOrwq6mNXXaV9e6uqrtW03zs201SxxqVWJul3Vc+CsSz1bF/2yb/BjcrDO/hR8lKj4mzzwX70ZqTeY9GnEWJwtb/HzfL/CX+sLeftRxqM7rc4fm+OzAxVDqze6HtbEZHzbrys9DvqLpN4O5lxhXoG0VJzl+z7d2bTDDhgVo3u/aNRvIHrb5L0VRcqQ9LfcyT+fhqTxPyoWGXmTBgq2Ehi597rae9iLtK25yziteKnTQKeSAkKqUDyiFhobSokULvL29adeuHcuWLaN58+Y0a9aM3bt34+Pjk6/6JCgCvvvuOx4+fMiJEyee+1Rdf39/pk+fXizt0FPraq5WHDwqcfPcPY5sPMPbk9/Is4yiKIT9coF6HdzQUz/7CkZHR4WDRyVibzwJ5KwcTRmyrDPpKRmkPczAxNqIDVOCsbDPe86VibUR5nbGxEaWnqt1AGfLyrR1b0z3ZZ/mu+zRiLP0bfJmgba74N3xdKndnDfmDePWg3s5Pk9OT+XKvZtcuXeTYxHhXJy+icE+nfn699UF2l5xkeP3Yrp08dFMhAZIS8ueM3Xnzn3s7J5Mcr537wG2tuZ51lO5smWOnpro6AeaniFrazN0dXU0PUdP8sRp8hw+fIbo6Ae4uLyn+TwzMws/v6UEBm4hImIdlStbkp6eQVxcolZvUXT0A7y9PfO590VLznnFqyiGv0r78Nlnn33GgAEDWLhwIREREfzf//0fS5YswcPDg8mTJ3PoUM67EZ+ldO/tS9K8eXMyMzP5+eefn5t38uTJxMfHa143btwovoYpCpnpz16BMyIsitgbCTTs6v7MfNnVKdy5GIuJdc4H8+lXUGNibURKQhqXj96k1htV8qwn+UEq8Xcfak1gLA0Ger9FdGIcQWeP5LtsfacaRCXk3TuSl+97jad7/Ra0nj+Sa7FRL1RGBRjo6ed7W8VNjt+LMTExonp1B83Lw8OFypUt2bs3VJMnPT2DQ4dOPzPo8Pb2IDg4VCtt794T+Phkl9HXV9OwYQ2tegGCg0M19X7wQVtOn17OyZM/aF729lb4+b3L7t1zAGjY0A21Wk+rnqioWM6evabZVqkh57wilT1RWqeQr9I90TokJIQPP/wQ0H7MSKdOnfj777/zXZ/0FAFNmjRh1KhRtG/fHl1dXSZMmJBnXgMDAwwMDIq8DXsWH6eGtxNmtsakJWdwZs9lIsKi6B/YIfvzRcdJiH5Ij+mttMqF7jyPo5dNrrew7l8eipOXDVbOZprx9aiLMXSe2EyT51LIDRTA2tmM+zcT2L3gGNYuZpo7OtKSM9i/PBTPVq6YWBsRF5XI3sV/Y2RuiMdTXdclSaVSMdC7Ez8e/ZXMrEytz2Z3/RgH80r0/3EGAGNa9+JabBThtyPQ18ueWNyjQWutHhK1rh4edtnd5Pq6ejiYV6KuoxtJaSlcuXcTgEW9J9CncTu6Lp1IYtpDbE2zfwfxKQ9JzUjDSN+QzzoMYOc/h4mKj8WqohnDW7yDo4UNm8LyviupJMjxKziVSsWYMd3x91+Hm5sjbm4O+Puvw8jIkD592mjy9e//Nfb21vj7DwFg9OjutGgxljlz1tO1azN27PiL4OAwDh9+srbKuHE96Nfvaxo1qoG3twc//BBEZGQ0w4Z1BsDKygwrKzOt9qjVelSubEnNmk4AmJkZM2hQB/z8lmJlZYqlpQkTJiyjdm1X2rYt/AT5gpJznigKiqJQsWLFHOnR0dFUqpT/dbgkKPr/vL29+e2333jzzTfR09Nj3LhxL3X7SbEpbJ52gMSYZAyN9bGtbkX/wA5Ub+oIZE8sfHA3SatMalI65/ZH0HF87mOmqYlpbPc/TFJsdp12NawZsqwLjp42WnXsWZx98qlgaoBna1d8P26Crl52J6KOjoq7l+9z6teLpCamY2xtRNWG9vSa3QaDiqWnt6Ote2NcrOxYceSXHJ/ZmVnjbFlZ815fV83c7qNwMK9ESkYa4VERdFw4jt/CQzR57M0qceqzJyuiTvDtywTfvhy8GEargOEADG+RfcfDoU+0b/sc8ONMfjwaRGZWFu62Veg/tCPWFc2JfRjP39f/pfl3wzgXFVGk+19YcvwKZ+LE3qSkpDNiRKBm8cbff5+jtUZRZGQ0OjpPrrp9fDxZv/5zvvhiJVOnrqJaNXs2bPhCa2iuV69WxMYmMHPmGqKi7uPlVYWgIH9cXF7sDq3HAgKGo6enS69eMzSLN65cOavE1igCOee9DKr///SzwtZRmlWrVo1z585RvXr2Mh2KovDnn38yduxY3n777XzXp1LKw2Nt8+lZK1r/8ccfdOzYkdmzZzN69Ojn1pWQkICZmRmf7x+AoXHZ+oMpDT5fcbqkmyBeUVmLZ5d0E8qs2Sc2Pj+TyFVqUjqzWq8iPj4eU1PTYtnG4++l8FvzMDHNOXSYH4kJKXg6fFKs7S2Mr7/+mtu3b7NgwQKuXr1KjRo1AOjfvz/ff/89Rkb5G/J8JXuKDh48qPn52rVrWp+98cYbJCVpX50IIYQQovT59NMnw/bOzs6Eh4fj6uqKvn7BOileyaBICCGEKO9eheGz/9LT06NmzZrPz/isOoqoLUIIIYQoRV6FB8JWrVqVZ80CiojI3/xDCYqEEEIIUSY9/ciujIwMzpw5Q1BQEJ988km+65OgSAghhCiHXoXFG/O6IWrp0qUFWqeodO+tEEIIIQpEp4j+K4vatWvHpk2b8l2ubO6tEEIIIUQeNm3ahIXF8x8u/DQZPhNCCCHKoVdh+KxBgwZaE60VReHOnTvExMSwZMmSZ5TMnQRFQgghRDn0Ktx99vSq1To6OtjY2NCyZUvNQo75IUGREEIIUQ5lr1NUuEe5lPZ1iqZOnVqk9ZXuvRVCCCGEeEmkp0gIIYQoh1RFMHxW2ucUFTUJioQQQohy6FV7zEdReLX2VgghhBAiDxIUCSGEEOXQ47vPCvsqzbp06cL27dvJzMwskvpK994KIYQQokAer1NU2Fdp99577+Ho6MjEiRO5cOFCoeoq/XsrhBBCCJGLnTt3Eh0dzaeffsp3331H7dq1ef3111mxYgXJycn5rk+CIiGEEKIcelWefWZiYoKvry86OjrcunWL3r17s2zZMuzs7Pjwww8JCQl54bpK/94KIYQQIt9eleGz/6pUqRIjR47k2LFjnDhxAhMTE5o3b/7C5eWWfCGEEEKUG5mZmezevZu1a9eya9cu2rVr98Jly1YIKIQQQogX8ircffa0UaNGYW9vz6hRo/Dw8ODcuXP8+uuvL1xeeoqEEEKIcuhVWLzx5MmTbNmyhS1btqBWq4mLi2P9+vW0bt26QPVJUCSEEEKUQzoqVaF7enRUqiJqTfFo1KgRdevWZdSoUbz//vuYmZkVqr5yFxS1bNmSevXqMX/+/JJuSr4c23yO41vP8SAqEQAbVwtaDWlADR/nXPNvmX6Qk0EXc6TbuFowemNPAMJ2XWDrjEM58nx5eBBqg+xffdrDdIKXneDcwWs8jEvBroY1ncZ74+hh88xtOXrZMGzF2wXa16IWMWsbVazscqQvOrSZkRvm5khv4daAg58szpHuPq0XF+5eB8DDzpUZnYfS0NmdKlZ2jN0UQOD+jVr5P23fj+71WuJe2YWUjDSOXDnDpO2LuHg3UpPny05D6N2oLU4WtqRnZhAaeYHPdizl+LXwwu52kZHjV3iKojB9+mqWLw8iLi6Rpk1rsXDhaDw9qzyz3JYtfzB16kquXImiWjU7Zs0aTLdur2vlWbx4B3Pn/kxUVCyenlUICBhO8+Z1cq3vo4/msXx5EPPmDWfs2Hc06Wlp6fj5LWPDhv2kpKTTpk19Fi0ag6NjpULve0HJOU8UhdDQUOrVq5cjPTU1lY0bN9K/f/981VfugqKtW7eiVqtLuhn5ZmZbkXYjmmDlaArAyaCLrPXbw/A13bGtZpkjf6fxPrQb0UTzPiszi4Xvb8GzjatWPoOKasZu6qWV9vjkALDtqz+IvhJHj2mtMK1kxKnfLrFyRBBjNr6LqU1FTT43bye6f9FC815XXXq6VBt/PRBdnSft8bKvRvCY79kUuv+Z5Wp82ZOE1Iea9/cSH2h+NtI35GrMLTaF7SOgx9hcy7dwq8+iQ1v4+/o59HR0+arrMPaMCsRjxnskp6cCcDE6kpEbv+NqzC0qqA0Y1+Y99owOpPrUHsQkPci13pdNjl/hffPNBgICNrNy5URq1HDkq69+ol27iZw/vwoTE6Ncy4SEhNO790xmzBhIt26vs23bn/TqNYPDhwNp2rQWABs3HmDcuMUsWjSaZs28WLZsFx07TiY8fAXOzrZa9W3f/ifHj5/H3t4qx7bGjl3Mrl0hrF//OVZWpvj5LaVz5884cWIJurq6RX9AXoCc84pfSQ2fLV68mG+//ZaoqCg8PT2ZP39+vu4Ayw8PDw/Wr1/PtWvXSE9P16QnJSXx3Xffce3aNQC+/PLLF6qv3AVFlpY5/5jKAvfmLlrvfYc34fjWf7lxNjrXE4ShsT6Gxvqa9+cOXiM1MY0GnWtq5VOpVJhY535Szkh9xLkDEbz/bXtcG2T3FLQZ2oh/D13n2JZz+H7cWJNXT62TZz0l7ekvx0/b9+Ny9A0OXQp7ZrnoxDjiU5Jy/ezE9X85cf1fAL5+e0SueTosHKf1fuDqWdz7djcNnd05fPkUAOv/3qOV55PN8xnSrAt1HKqz/8KJZ7bvZZHjVziKohAYuJUpU/rQvXv2iX/VqklUrtyDdev28dFHnXMtFxi4FV/fhkye3AeAyZP78Mcf/xAYuIV16z4HICBgM4MGdWDIkE4AzJ8/gj17TrBkyS/4+w/R1HXr1j1Gjfqe3bvn8NZbU7S2Ex+fxIoVv7F69ae0bdsQgDVrJuPs/B7BwWG0b9+YkiDnvOJXFBOl81t+48aNjB07lsWLF9OsWTOWLVtGhw4dOHfuHM7OufcCFkbfvn3ZvXs3rq6uWgH+o0ePUKlU7NixA0VRXjgoKnuh73O0bNmSsWPHAlClShVmz57NoEGDMDExwdnZmR9++EEr/5EjR6hXrx6GhoY0atSI7du3o1KpOHXq1Mtv/P+XlZnFP3suk56SgXNt2+cXAEJ3nqdqEwcs7Ey00tNTMvi2yzq+eWsta8bt5vaFGK3tZGUq6OlrXymqDXS5fvqOVlpEWBT+7VcT8M5Gtn31B0n3Uwq4d8VLratH3yZvsiJk13Pznpyymttf7yJ4zPe0rNGg0Ns2q2AMwP3khDzbNvT1t3mQnMjpm5cKvb3iIMcv/yIiorhz5z7t2jXSpBkY6NOiRV1CQvIe5gsJOYevbyOttHbtGnHkSHaZ9PQMQkMvatUL4OvbUKverKws+vX7Gj+/d3MdrgsNvURGxiOteuztrfHyqqLZVkmTc175MW/ePAYPHsyQIUOoVasW8+fPx8nJiSVLlhTL9oKDgzl8+DCnT58mLCxM89q3bx+KohAWFsbJkydfuL5y11P0tO+++46ZM2cyZcoUNm/ezMcff8wbb7yBu7s7iYmJdO7cmY4dO7Ju3TquX7+uCajykpaWRlpamuZ9QkLuJ/CCuHP5Pj8M3s6j9Ez0K6jp8007bKpaPLdcYkwyl0Ju0HOG9mz7Si7mdJ/aEttqlqQ9TCdk41mWD9nBiLU9sHY2w6CiPk61bTmwIoxKruYYW1bgnz1XuBkejZXTk8lqNXyc8GpTFXM7Y+JuJxK89AQrhu9i+OruOU4uJe3tui0wr2DMqpCgPPNEJcTw4U/+hEaex0BPzQdNO7BvzEJaBgzX9FAUxLweYzh8+RTht69qpXfyasaGwTMx0jckKiEG3wWjiX0YX+DtFCc5fvl3504cALa22n+rNjYWREbefUa5+znK2NpaaOqLiYknMzMrjzz3Ne/nzNmAnp4uo0d3z3M7+vpqLCy0g4en6ykJcs4rXkWx+OLj8k9/1xkYGGBgYKCVlp6eTmhoKJ9++qlWert27Thy5Eih2pGX+Ph4HB0dc6QrioKqAJPEy31Q1LFjR4YPHw7ApEmTCAgI4ODBg7i7u7N27VpUKhXLly/H0NAQDw8Pbt26xYcffphnff7+/kyfPr1Y2mrtYsaIn94hNTGd8AMRbJl+kCFLOz/3JBG26wKGxvrUallFK92pti1O/7nqcq5bmcUfbOXoz2d5y68ZAD2mt2LbzEN802ktOroq7GpaU6d9da2rq9q+1TQ/21azxKFWJeZ2WceFvyLxbKU9nl/SBjfrzG/hR4mKj8kzz8W7kVqTeY9GnMXJwhY/3/cL/KW+sLcfdRyq8/rcoTk+O3AxlHqz+2FtbMaHzbry85CvaPrNYO4lxhVoW8VJjt/zrV0bzLBhAZr3u3bNBshxAn6Rk3LuZZ7Ow1N5npQLDb3IggVbCQ1dmu8vgIJ+aRQlOecVL5WS/SpsHQBOTk5a6V9++SXTpk3TSouJiSEzMxNbW+3ePltbW+7c0e6JKyorV67ExMQkR7qZmRkrV67Md33lPiiqU+fJXRoqlYrKlSsTHR0NwIULF6hTpw6GhoaaPE2aNMlRx39NnjyZTz75RPM+ISEhxz+WgtJT62quVhw8KnHz3D2ObDzD25PfyLOMoiiE/XKBeh3c0FM/+wpGR0eFg0clYm88ifitHE0Zsqwz6SkZpD3MwMTaiA1TgrGwz/mP7DETayPM7YyJjSw9V+sAzpaVaevemO7LPn1+5qccjThL3yZvFmi7C94dT5fazXlj3jBuPbiX4/Pk9FSu3LvJlXs3ORYRzsXpmxjs05mvf19doO0VFzl+L6ZLFx/NRGiAtLQMILtHxs7uySTne/ceYGtrnmc9lStb5uipiY5+oOkZsrY2Q1dXR9Nz9CRPnCbP4cNniI5+gIvLe5rPMzOz8PNbSmDgFiIi1lG5siXp6RnExSVq9RZFRz/A29szn3tftOScV3bcuHEDU1NTzfune4n+qyAXCAXVr1+/XNMTExP58ssv8/w8L+VuTtHTnr4TTaVSkZWVBeT+i1KUZ4fVBgYGmJqaar2KjaKQmZ71zCwRYVHE3kigYVf3F6hO4c7FWEysK+T4TL+CGhNrI1IS0rh89Ca13qiSZz3JD1KJv/uw1E1CHOj9FtGJcQSdzX83bX2nGkQl5N07kpfve42ne/0WtJ4/kmuxUS9URgUY6Ok/N9/LJsfvxZiYGFG9uoPm5eHhQuXKluzdG6rJk56ewaFDp58ZdHh7exAcHKqVtnfvCXx8ssvo66tp2LCGVr0AwcGhmno/+KAtp08v5+TJHzQve3sr/PzeZffuOQA0bOiGWq2nVU9UVCxnz17TbKvUkHNe0VKyiuYFOb73cguKrK2t0dXVzdErFB0dnaP3qKjs2rWLmjVrYmBggI6OjuZlY2PD9evXNe9fVLnvKXqWx0NoaWlpml/wiRMlc0fLnsXHqeHthJmtMWnJGZzZc5mIsCj6B3bI/nzRcRKiH9JjeiutcqE7z+PoZZPr3Rr7l4fi5GWDlbOZZnw96mIMnSc20+S5FHIDBbB2NuP+zQR2LziGtYuZ5o6OtOQM9i8PxbOVKybWRsRFJbJ38d8YmRvi8VTXdUlSqVQM9O7Ej0d/JTMrU+uz2V0/xsG8Ev1/nAHAmNa9uBYbRfjtCPT1sicW92jQWquHRK2rh4dddje5vq4eDuaVqOvoRlJaClfu3QRgUe8J9Gncjq5LJ5KY9hBb0+zfQXzKQ1Iz0jDSN+SzDgPY+c9houJjsapoxvAW7+BoYcOmsH0v47C8MDl+BadSqRgzpjv+/utwc3PEzc0Bf/91GBkZ0qdPG02+/v2/xt7eWnPX2OjR3WnRYixz5qyna9dm7NjxF8HBYRw+HKgpM25cD/r1+5pGjWrg7e3BDz8EERkZzbBh2Xe0WVmZYWWlvVidWq1H5cqW1KyZ3YNtZmbMoEEd8PNbipWVKZaWJkyYsIzatV1p27bwE+QLSs55L8F/gppC1fGC9PX1adiwIXv37qVbt26a9L1799K1a9fCtSMP48ePx9fXlzZt2mjdfRYfH0///v3Zvn17vup7pYOiPn368NlnnzF06FA+/fRTIiMjmTs3e7G6lz3WnhSbwuZpB0iMScbQWB/b6lb0D+xA9abZE8gSY5J5cFf79ufUpHTO7Y+g43ifXOtMTUxju/9hkmKz67SrYc2QZV1w9LTRqmPP4uyTTwVTAzxbu+L7cRN09bIjax0dFXcv3+fUrxdJTUzH2NqIqg3t6TW7DQYVS09vR1v3xrhY2bHiyC85PrMzs8bZsrLmvb6umrndR+FgXomUjDTCoyLouHAcv4WHaPLYm1Xi1GdrNO8n+PZlgm9fDl4Mo1VA9hy14S2yF8c79In2XRUDfpzJj0eDyMzKwt22Cv2HdsS6ojmxD+P5+/q/NP9uGOeiIop0/wtLjl/hTJzYm5SUdEaMCNQs3vj773O01iiKjIxGR+fJecXHx5P16z/niy9WMnXqKqpVs2fDhi+0huZ69WpFbGwCM2euISrqPl5eVQgK8sfFJX9X3QEBw9HT06VXrxmaxRtXrpxVYmsUgZzzyqtPPvmEDz74gEaNGuHt7c0PP/xAZGQkw4YNK5btRURE8MUXX+ToiXo8TaZLly75qk+lPG+8qIz574rWVapUYezYsVp3lNWrV4+3335bM0HsyJEjfPzxx5w/f57atWszfvx4+vTpw/nz56lZs2buG/mPhIQEzMzM+Hz/AK01NMSL+XzF6ZJugnhFZS2eXdJNKLNmn9j4/EwiV6lJ6cxqvYr4+Phim37x+HspPnYLpqYVn1/gmXU9xMzqnXy1d/HixXzzzTdERUXh5eVFQEAAb7yR9zyxwqhatSphYWGYm5trpcfGxtK4cWOuXr2ae8E8lLueooMHD2p+fryS5X89vf6Qj48Pp08/+WJeu3YtarW6WBaZEkIIIV4aRSmC4bP895sMHz5cc9d3ccsr6LGyssp3QATlMCjKr9WrV1O1alUcHBw4ffo0kyZN4t1336VChZwT84QQQogyIysr+1XYOkqxZy2RoyhKjmUDnueVD4ru3LnD1KlTuXPnDnZ2dvTs2ZOvvvqqpJslhBBCiOfYsWOH1vuHDx9y/fp11Go11atXl6AovyZOnMjEiRNLuhlCCCFE0XrJd5+VhLCwnM9ovH//Pn379qVnz575rq/cr1MkhBBCvJKKcJ2issTS0hJ/f39mzZqV77ISFAkhhBCiXNHV1eX69es8evQoX+Ve+eEzIYQQolx6BYbP8uLl5ZXvgAgkKBJCCCHKp1fg7rPWrVvn+XguRVE4ePAgDx48oFu3bhw4cOC59UlQJIQQQogyqV69es/No1arqV+//gvVJ0GREEIIUR69AsNn8+bNe26eihUrvlA+kKBICCGEKJ9egaCoqElQJIQQQogyqWrVqnnOKXpaRMTzHyQtQZEQQghRHr0CPUWDBg3iu+++o1mzZrz22msAhISE8Ndff+Hn55fvh+5KUCSEEEKUQ4qShaJkFrqO0iw8PJzPPvsMPz8/rfRvv/2WU6dOsXbt2nzVJ4s3CiGEEOXR41vyC/sqxX755Re6du2aI71bt27s3Lkz3/VJUCSEEEKIMsnU1JQ9e/bkSN+9e3e+h85Ahs+EEEKIcqoonl1WunuKpkyZwrhx4/jrr7+05hRt3ryZgICAfNcnQZEQQghRHr0CE61HjhyJu7s78+fPZ8GCBSiKQq1atdi9ezdt2rTJd30SFAkhhBCizGrbti1t27YtkrokKBJCCCHKo1egp+ix1NRU7t27R9ZTE8NdXFzyVY8ERUIIIUR59AoERefPn2fQoEEcPXpUK12lUqEoSo4g6XkkKBJCCCFEmTR48GD09fX59ddfsbOzQ6VSFao+CYpKiWObz3F86zkeRCUCYONqQashDajh45xr/i3TD3Iy6GKOdBtXC0Zv7AlA2K4LbJ1xKEeeLw8PQm2Q/atPe5hO8LITnDt4jYdxKdjVsKbTeG8cPWyeuS1HLxuGrXi7QPta1CJmbaOKlV2O9EWHNjNyw9wc6S3cGnDwk8U50t2n9eLC3esAeNi5MqPzUBo6u1PFyo6xmwII3L9RK/+n7fvRvV5L3Cu7kJKRxpErZ5i0fREX70Zq8nzZaQi9G7XFycKW9MwMQiMv8NmOpRy/Fl7Y3S4ycvwKT1EUpk9fzfLlQcTFJdK0aS0WLhyNp2eVZ5bbsuUPpk5dyZUrUVSrZsesWYPp1u11rTyLF+9g7tyfiYqKxdOzCgEBw2nevE6u9X300TyWLw9i3rzhjB37jiY9LS0dP79lbNiwn5SUdNq0qc+iRWNwdKxU6H0vKDnnvQRFsc5QKV+n6PTp0/z999/UqlWrSOqToKiUMLOtSLsRTbByzF5X4WTQRdb67WH4mu7YVrPMkb/TeB/ajWiieZ+VmcXC97fg2cZVK59BRTVjN/XSSnt8cgDY9tUfRF+Jo8e0VphWMuLUb5dYOSKIMRvfxdSmoiafm7cT3b9ooXmvqy49S1w1/noguv+vvTsPq6pqGz/+ZTiACByGI/PkgANiqTj8HAonNDWHyNSsNNNKsRwSLbPMGS0LMTXN93XMqRxLHp8Up8cnMRXSFFLUUByOIjMyyzm/P3g9dmRQJkG8P9e1r8u9z72Gs5HF2mutvbfhg/r4ODckfMK3/BR5sNR0jb94jfScTN3+nYxU3b/NTcz4O/EGP0UdIGTQxGLT+3m1YtmR7Zy8GoOxoRHzBoxh34eheM9+nay8HABiE+L5YOvX/J14gzoKUyZ1f51940NpNGMQiXdTi833SZPzV3FffrmFkJBtrFkzlcaNXZk37wd69pzK+fNrsbQ0LzZNREQ0Q4fOYfbskbzySmd27vwvQ4bM5ujRUNq3L2zgt249xKRJy1m2bDydOvmwcuUe+vSZRnT0atzdHfTy27Xrv5w4cR5nZ7siZU2cuJw9eyLYvPkz7OysCApaQb9+0zl16juMjIwq/4Q8BmnznoBnYPqsSZMm3Llzp9I6RU/hT7l2avqCB006uaPysEblYY1/YDtMzBVcO5dQbLyZhQmWKnPdduOvRHIycmndr4lenIGBgV6cpepBA52fc4+YQ3H0+rA99Vs7YeempPt7bbBxtuL37TF6+RgrDPXyMFeaVf5JKKfEu6ncTk/WbS+36MSlhGscuRhVarqEjBS9dJp//PKfuvoXU3csZeupcHLv5RebvvfSSaw7HkaMOo4/b1xi5Pq5eNg54eveVBez+eQ+Dpw/SVziTWLUcXy0bTHKOhY859Kocr58JZDzVzFarZbQ0B18+ukwAgJewMenPmvXfkxWVg6bNh0oMV1o6A78/X2ZNm0YTZu6M23aMLp3b01o6HZdTEjINt55pzejR/elWTMPFi8eh5ubPd9994teXjdu3OHDD7/lhx8+RaHQv9ZNS7vL6tV7WbRoDD16+NKqlRcbNkzj7Nk4wsNL/xlXJWnzRGX48ssvmTp1Kvv37ycxMZG0tDS9raxkpKgG0hRoOHfgb/Ky83Fv4fDoBEDkz+dp0M4FGydLveN52fl81X8TWo0WJy87uo9pg3MTla4cTYEWYxP9K0WFqRFXz9zSOxYXpSa413rMLEzxbO2E/9i2WNjWqcC3rBoKI2PebPcS3xzY/MjYPz5dj5nChBh1HHP3ruFwbMX+QCjrWACQnJVeYt3e6zyQ1KwMzly/WKGyqoqcv7KLi1Nz61YyPXu20R0zNTXBz+95IiKief/9fsWmi4iI0ZviAujZs42uU5SXl09kZCwff/y6Xoy/vy8REQ+mDzUaDcOHLyAoaHCx03WRkRfJz7+nVz9nZxU+Pp4cOxZNr15ty/ydK5u0eVXkGRgp6tmzJwAvvfQSWq22yOey0PopdutSMt+P2sW9vAJM6igY9mVP7BvYPDJdRmIWFyOu8drsbnrH63lYEzCjCw4NbcnNzCNi6zlWjd7NuI2DULkrMa1rglsLBw6tjqJefWssbOvw577LXI9OwM5NqcuncUc3fLo3wNrJgpSbGYSvOMXqwD0Erg8o0rhUt4HP+2Fdx4K1EWElxqjTE3n3h2Ai489jaqzgrfa9OTBhKV1CAjl66XS5y/5m0ASOXjpN9M2/9Y739enEllFzMDcxQ52eiP+S8SRllv0K5kmQ81d2t26lAODgoP+7am9vQ3z87VLSJRdJ4+Bgo8svMTGNggJNCTHJuv2FC7dgbGzE+PEBJZZjYqLAxka/8/BwPtVB2rwqptVWQqeoaEejJjl06FCl5iedojLKzc0lNzdXt5+eXvxVbXmoPJSM++FVcjLyiD4Ux/ZZhxm9ot8jG4moPRcwszChWRdPveNuLRxw+8dVl/vzjix/awfHfzzHy0GdABg0qys75xzhy74bMTQywKmJiud6NeLmhURduhb+DXX/dmhoi0uzeizqv4kLv8XTvKv+fH51G9WpH3ujj6NOSywxJvZ2vN5i3uNx53CzcSDI/41y/1FfOjSI51wa0XnRe0U+OxQbScv5w1FZKHm30wB+HD2P9l+O4k5GSrnKqkpy/h5t48Zwxox58PqAPXvmAxS560Wr1T7yTpji0zwcw0MxD9JFRsayZMkOIiNXlPmum8epX1WTNq+KPQMLrV988cVKzU86RWUUHBzMrFmzqiRvY4WR7mrFxbse12PucGzrWQZOK/mHrtVqifrlAi17e2GsKP0KxtDQABfveiRde9CRs3O1YvTKfuRl55ObmY+lypwtn4Zj42xZYj6WKnOsnSxIiq85V+sA7raO9GjaloCVn5Q57fG4c7zZ7qVylbtk8GT6t3iBF78Zw43UO0U+z8rL4fKd61y+c53f46KJnfUTozr2Y8Gv68tVXlWR8/d4+vfvqFsIDZCbW7hm6tatZJycHixyvnMnFQcH6xLzcXS0LTJSk5CQqhsZUqmUGBkZ6kaOHsSk6GKOHj1LQkIqHh4PptgKCjQEBa0gNHQ7cXGbcHS0JS8vn5SUDL3RooSEVDp0aF7Gb1+5pM0TFXXkSNG7Df/Jz8+Pe/fu8dtvv+Hn51dqLEinqMymTZvGRx99pNtPT0/Hzc2tagrTainIK72XHhelJulaOr4DmpYaV5idlluxSTg0KnoVZlJHgUkdBdnpuVw6fp1eH7YvMZ+s1BzSbmfqLWCsCUZ2eJmEjBTCzh0rc9pWbo1Rp5c8OlKSb4dM5pWWfnT5ZhxXktSPlcYAMDU2KXNZVU3O3+OxtDTXu6NMq9Xi6GjL/v2RtGrlBRSuBzpy5AwLFrxbYj4dOngTHh7JpEmDdMf27z9Fx46FHRUTEwW+vo3Zvz9S7zb98PBI+vcvHPV4660e9OjRWi/fl176mDff9GfkyMJOqq+vFwqFMfv3RzJ4cBcA1Ookzp27wsKFRUfmqpW0eZXrGVhT1K1btxJHPe8/vDE5OZlu3bpRUFDwyPykU1RGpqammJqaVnq++5afoHEHN5QOFuRm5XN23yXiotSMCO1d+PmyE6QnZDJoVle9dJE/n8fVx77YW1gProrEzcceO3elbn5dHZtIv6mddDEXI66hBVTuSpKvp/PvJb+j8lDq7ujIzcrn4KpImnetj6XKnBR1BvuXn8Tc2gzvh4auq5OBgQEjO/Rl3fF/UaDR/48/f8BYXKzrMWLdbAAmdBvClSQ10TfjMDEuXFg8qHU3vREShZEx3k6Fw+QmRsa4WNfjeVcv7uZmc/nOdQCWDZ3CsLY9GbBiKhm5mThYFf4M0rIzycnPxdzEjOm93+bnP4+iTkvCrq6SQL9XcbWx56eoku9Kqg5y/srPwMCACRMCCA7ehJeXK15eLgQHb8Lc3Ixhwx68kHLEiAU4O6sIDh4NwPjxAfj5TWThws0MGNCJ3bt/Izw8iqNHQ3VpJk0axPDhC2jTpjEdOnjz/fdhxMcnMGZM4eJtOzsldnZKvfooFMY4OtrSpEnhxZpSacE77/QmKGgFdnZW2NpaMmXKSlq0qF+kQ/UkSZv3BDwDnaKUlEdPo9vb2z9WHEinqMa4m5TNtpmHyEjMwszCBIdGdowI7U2j9q5A4cLC1Nt39dLk3M0j5mAcfSZ3LDbPnIxcdgUf5W5SYZ5OjVWMXtkf1+b2ennsW17Y+NSxMqV5t/r4j22HkXHh0xoMDQ24fSmZ0/+KJScjDwuVOQ18nRkyvzumdWvOaEePpm3xsHNi9bFfinzmpFThbuuo2zcxUrAo4ENcrOuRnZ9LtDqOPksnsTc6QhfjrKzH6ekbdPtT/N9kiv+bHI6NomtIIACBfoV3Dh356Du98t5eN4d1x8Mo0Gho6uDJiPf6oKprTVJmGiev/sULX48hRh1Xqd+/ouT8VczUqUPJzs5j3LhQ3cMbf/11od6IUnx8AoaGD65mO3ZszubNn/H552uYMWMtDRs6s2XL53pTc0OGdCUpKZ05czagVifj4+NJWFgwHh6Pd4fWfSEhgRgbGzFkyGzdwxvXrJlbbc8oAmnzROWwsrIq9nh+fj7Hjh3TTZmVFPcwA21x97CJx5aeno5SqeSzg29jZiG/MGX12eoz1V0F8YzSLJ9f3VV4as0/tfXRQaJYOXfzmNttLWlpaY/9h7qs7v9dSj0zCyvLij1fKT0jB+vnv6jS+lZUREQEV65cIS8vT3csLS2NiRMnsnr1agwMDBgxYsRj5SUjRQ9Zu3YtI0eOLPZ5B0IIIcRTQ6Mt3CqaRw02btw4VqxYgYWFhd7I5/11Rh999BFarVY6ReV15cqVx1qhLoQQQojq9eOPP7J//366ddN/ZtWdO3dwcHAgOblsz+KSTtFDfv31V0JDQx8dKIQQQtRk2kp4TlENX2idnJzM888/X+R4eZ/DJZ2ih0RERDw6SAghhKjpnoGHN37xxReYmxd9VIKFhQVffPFFmfOTTpEQQgghnkozZswA4NKlS8TExGBgYECzZs1o1KiR7rOykE6REEIIURs9AwutU1NTGTlyJD///DPGxoVdmvz8fPr168e6deuwtrYuU36GVVBHIYQQQlS3+9NnFd2qwJUrVxg1ahT169enTp06NGzYkC+++ELvtvrHMXHiRC5dusRvv/1GTk4OOTk5REREcPnyZcaPH1/meslIkRBCCFEbabSVsKaoakaKzp8/j0ajYeXKlTRq1Ihz587x7rvvkpmZyaJFix47n59//plffvmF//f//p/uWPv27fn+++95+eWXy1wv6RQJIYQQ4ol66aWXeOmlBy+RbtCgARcuXOC7774rU6coLy8PCwuLIsctLS3Jzc0tc71k+kwIIYSoje6vKaroRuFTsv+5lafD8ShpaWnY2hZ9p11p/Pz8+OSTT0hKStIdS05OZurUqeV65qB0ioQQQojaqBLXFLm5uaFUKnVbcHBwpVb18uXLfPvtt4wZM6ZM6ZYsWUJcXBzu7u60atWK1q1b4+bmxuXLl1myZEmZ6yHTZ0IIIYQo1bVr1/TefWZqalps3MyZM5k1a1apeZ08eZI2bdro9m/evMlLL73Ea6+9xujRo8tUr4YNGxIdHc3PP/9MTEwMWq2WZs2aMXDgwHK98Fg6RUIIIURtVIm35FtZWT3WC2E/+OADhg4dWmqMp6en7t83b96ka9eudOjQge+//75cVTQyMuKVV17hlVdeKVf6f5JOkRBCCFEbVcMTrVUqFSqV6rFib9y4QdeuXfH19WXNmjUYGpZ9Rc+6detK/fxxXwR7n3SKhBBCCPFE3bx5ky5duuDu7s6iRYu4c+eO7jNHR8fHzmfSpEl6+/n5+WRlZWFsbIy5ubl0ioQQQghBjX4h7L59+7h06RKXLl3C1dVVv0jt40/5JScnFzl25coV3n//fSZPnlzmesndZ0IIIUQtpNVqK2WrCm+//XaVlefp6cmCBQuYOHFimdNKp0gIIYQQtYqBgQHXrl0rczqZPhNCCCFqo2pYaP2k7d69W29fq9WiVqtZunQpnTt3LnN+0ikSQgghaqNnoFMUEBCgt29gYIC9vT3du3cv0+tC7pNOkRBCCFEbVeJzimqqgoKCSs1P1hQJIYQQQiAjRUIIIUTt9AxMn1U26RTVEL9vi+HEjhhS1RkA2Ne3oevo1jTu6F5s/PZZh/kjLLbIcfv6Nozf+hoAUXsusGP2kSIxXxx9B4Vp4Y8+NzOP8JWniDl8hcyUbJwaq+g7uQOu3valluXqY8+Y1QPL9V0rW9zcnXjaORU5vuzINj7YUnRO2c+rNYc/Wl7keNOZQ7hw+yoA3k71md3vPXzdm+Jp58TEn0IIPbhVL/6TXsMJaNmFpo4eZOfncuzyWT7etYzY2/G6mC/6jmZomx642TiQV5BPZPwFpu9ewYkr0RX92pVGzl/FabVaZs1az6pVYaSkZNC+fTOWLh1P8+aepabbvv0/zJixhsuX1TRs6MTcuaN45RX9xaHLl+9m0aIfUauTaN7ck5CQQF544bli83v//W9YtSqMb74JZOLEV3XHc3PzCApayZYtB8nOzqN791YsWzYBV9d6Ff7u5SVt3hOg0VZCp6hmT59VNukUFaNLly60bNmSxYsXP7EylQ516TmuHXauhe+W+SMslo1B+wjcEIBDQ9si8X0nd6TnuHa6fU2BhqVvbKd59/p6caZ1FUz8aYjesfuNA8DOef8h4XIKg2Z2xaqeOaf3XmTNuDAmbB2MlX1dXZxXBzcCPvfT7Rspas7Ma9sFIzH6x+PhfZwbEj7hW36KPFhqusZfvEZ6TqZu/05Gqu7f5iZm/J14g5+iDhAyaGKx6f28WrHsyHZOXo3B2NCIeQPGsO/DULxnv05WXg4AsQnxfLD1a/5OvEEdhSmTur/OvvGhNJoxiMS7qcXm+6TJ+au4L7/cQkjINtasmUrjxq7Mm/cDPXtO5fz5tVhamhebJiIimqFD5zB79kheeaUzO3f+lyFDZnP0aCjt2zcDYOvWQ0yatJxly8bTqZMPK1fuoU+faURHr8bd3UEvv127/suJE+dxdrYrUtbEicvZsyeCzZs/w87OiqCgFfTrN51Tp74r10szK4O0eaImkp9yDdH0BQ+adHJH5WGNysMa/8B2mJgruHYuodh4MwsTLFXmuu3GX4nkZOTSul8TvTgDAwO9OEvVgwY6P+ceMYfi6PVhe+q3dsLOTUn399pg42zF79tj9PIxVhjq5WGuNKv8k1BOiXdTuZ2erNtebtGJSwnXOHIxqtR0CRkpeuk0/3hy66mrfzF1x1K2ngon915+sel7L53EuuNhxKjj+PPGJUaun4uHnRO+7k11MZtP7uPA+ZPEJd4kRh3HR9sWo6xjwXMujSrny1cCOX8Vo9VqCQ3dwaefDiMg4AV8fOqzdu3HZGXlsGnTgRLThYbuwN/fl2nThtG0qTvTpg2je/fWhIZu18WEhGzjnXd6M3p0X5o182Dx4nG4udnz3Xe/6OV148YdPvzwW3744VMUCv1r3bS0u6xevZdFi8bQo4cvrVp5sWHDNM6ejSM8vPSfcVWSNu8JuL/QuqLbM0RGimogTYGGcwf+Ji87H/cWDo9OAET+fJ4G7VywcbLUO56Xnc9X/Teh1Whx8rKj+5g2ODdR6crRFGgxNtG/UlSYGnH1zC29Y3FRaoJ7rcfMwhTP1k74j22LhW2dCnzLqqEwMubNdi/xzYHNj4z949P1mClMiFHHMXfvGg7HVuwPhLKOBQDJWekl1u29zgNJzcrgzPWLFSqrqsj5K7u4ODW3biXTs2cb3TFTUxP8/J4nIiKa99/vV2y6iIgYvSkugJ492+g6RXl5+URGxvLxx6/rxfj7+xIR8WD6UKPRMHz4AoKCBhc7XRcZeZH8/Ht69XN2VuHj48mxY9H06tW2zN+5skmbV0VkTVGZPdWdoo8//pidO3dy/fp1HB0deeONN5gxYwYKhQKAmTNnsmvXLiZPnsznn39OSkoKvXv3ZtWqVVhaFv4iZWZmMnbsWHbs2IGlpSVBQUGllpmbm0tubq5uPz29+Aa8PG5dSub7Ubu4l1eASR0Fw77siX0Dm0emy0jM4mLENV6b3U3veD0PawJmdMGhoS25mXlEbD3HqtG7GbdxECp3JaZ1TXBr4cCh1VHUq2+NhW0d/tx3mevRCdi5KXX5NO7ohk/3Blg7WZByM4PwFadYHbiHwPUBRRqX6jbweT+s61iwNiKsxBh1eiLv/hBMZPx5TI0VvNW+NwcmLKVLSCBHL50ud9nfDJrA0Uunib75t97xvj6d2DJqDuYmZqjTE/FfMp6kzLRyl1OV5PyV3a1bKQA4OOj/rtrb2xAff7uUdMlF0jg42OjyS0xMo6BAU0LMg/c9LVy4BWNjI8aP139eyz/LMTFRYGOj33l4OJ/qIG2eqGme6k6RpaUla9euxdnZmbNnz/Luu+9iaWnJ1KlTdTGXL19m165d7Nmzh5SUFAYPHsyCBQuYN28eAFOmTOHQoUPs3LkTR0dHPv30UyIjI2nZsmWxZQYHBzNr1qwq+T4qDyXjfniVnIw8og/FsX3WYUav6PfIRiJqzwXMLExo1sVT77hbCwfc/nHV5f68I8vf2sHxH8/xclAnAAbN6srOOUf4su9GDI0McGqi4rlejbh5IVGXroV/Q92/HRra4tKsHov6b+LCb/E076o/n1/dRnXqx97o46jTEkuMib0dr7eY93jcOdxsHAjyf6Pcf9SXDg3iOZdGdF70XpHPDsVG0nL+cFQWSt7tNIAfR8+j/ZejuJORUq6yqpKcv0fbuDGcMWNCdPt79swHCqdt/kmr1RY59rDi0zwcw0MxD9JFRsayZMkOIiNXPLKshz1O/aqatHlVTEaKyuyp7hR99tlnun97enoyefJktm7dqtcp0mg0rF27Vjcy9NZbb3HgwAHmzZvH3bt3+d///V/Wr1+Pv78/AOvWrSvyxt5/mjZtGh999JFuPz09HTc3t0r5PsYKI93Viot3Pa7H3OHY1rMMnPZiiWm0Wi1Rv1ygZW8vjBWlX8EYGhrg4l2PpGsPRrfsXK0YvbIfedn55GbmY6kyZ8un4dg4W5aYj6XKHGsnC5Lia87VOoC7rSM9mrYlYOUnZU57PO4cb7Z7qVzlLhk8mf4tXuDFb8ZwI/VOkc+z8nK4fOc6l+9c5/e4aGJn/cSojv1Y8Ov6cpVXVeT8PZ7+/TvqFkID5OYWrpm6dSsZJ6cHi5zv3EnFwcG6xHwcHW2LjNQkJKTqRoZUKiVGRoa6kaMHMSm6mKNHz5KQkIqHx4MptoICDUFBKwgN3U5c3CYcHW3Jy8snJSVDb7QoISGVDh2al/HbVy5p86qYthLWBFXRC2Frqqd6ofW2bdvo3Lkzjo6OWFhY8PnnnxMfH68X4+npqesQATg5OZGQULiQ7/Lly+Tl5dGhQwfd57a2tjRpor9w759MTU2xsrLS26qMVktBXum99LgoNUnX0vEd0LTUuMLstNyKTcJSVXRe3KSOAkuVOdnpuVw6fp1mL3qWmE9Wag5ptzP1FjDWBCM7vExCRgph546VOW0rt8ao00seHSnJt0MmE9DKj26LP+BKkvqx0hgApsYmZS6rqsn5ezyWluY0auSi27y9PXB0tGX//khdTF5ePkeOnCm109Ghgzfh4ZF6x/bvP0XHjoVpTEwU+Po21ssXIDw8UpfvW2/14MyZVfzxx/e6zdnZjqCgwfz73wsB8PX1QqEw1stHrU7i3LkrurJqDGnzRDV7akeKjh8/ztChQ5k1axa9evVCqVSyZcsWvv76a724++uL7jMwMEDzf8OB2hrUA963/ASNO7ihdLAgNyufs/suERelZkRo78LPl50gPSGTQbO66qWL/Pk8rj72xd7CenBVJG4+9ti5K3Xz6+rYRPpN7aSLuRhxDS2gcleSfD2dfy/5HZWHUndHR25WPgdXRdK8a30sVeakqDPYv/wk5tZmeD80dF2dDAwMGNmhL+uO/4sCjf5j3+cPGIuLdT1GrJsNwIRuQ7iSpCb6ZhwmxoULiwe17qY3QqIwMsbbqXCY3MTIGBfrejzv6sXd3Gwu37kOwLKhUxjWticDVkwlIzcTB6vCn0FadiY5+bmYm5gxvffb/PznUdRpSdjVVRLo9yquNvb8FFXyXUnVQc5f+RkYGDBhQgDBwZvw8nLFy8uF4OBNmJubMWxYd13ciBELcHZWERw8GoDx4wPw85vIwoWbGTCgE7t3/0Z4eBRHj4bq0kyaNIjhwxfQpk1jOnTw5vvvw4iPT2DMmMLF23Z2SuzslHr1USiMcXS0pUmTwhFspdKCd97pTVDQCuzsrLC1tWTKlJW0aFGfHj1aV/XpKZG0eU+ATJ+V2VPbKfrtt9/w8PBg+vTpumNXr14tUx6NGjVCoVBw/Phx3N0LHxiWkpJCbGwsfn5+j0hdue4mZbNt5iEyErMwszDBoZEdI0J706h94VReRmIWqbfv6qXJuZtHzME4+kzuWGyeORm57Ao+yt2kwjydGqsYvbI/rs3t9fLYt7yw8aljZUrzbvXxH9sOI+PCQURDQwNuX0rm9L9iycnIw0JlTgNfZ4bM745p3Zoz2tGjaVs87JxYfeyXIp85KVW42zrq9k2MFCwK+BAX63pk5+cSrY6jz9JJ7I2O0MU4K+txevoG3f4U/zeZ4v8mh2Oj6BoSCECgX+GdQ0c++k6vvLfXzWHd8TAKNBqaOngy4r0+qOpak5SZxsmrf/HC12OIUcdV6vevKDl/FTN16lCys/MYNy5U9/DGX39dqPeMovj4BAwNH6zh6dixOZs3f8bnn69hxoy1NGzozJYtn+tNzQ0Z0pWkpHTmzNmAWp2Mj48nYWHBeHg83h1a94WEBGJsbMSQIbN1D29cs2ZutT2jCKTNeyKkU1RmBtqaNFxSBrt372bQoEFs2LCBtm3bEhYWxqxZsygoKCA1NRV4cPfZ6dOndekWL17M4sWLuXLlCgBjx47lX//6F6tXr8bBwYHp06dz8OBBRo0a9VgPb0xPT0epVPLZwbcxs3jKfmFqgM9Wn6nuKohnlGb5/OquwlNr/qmtjw4Sxcq5m8fcbmtJS0ursuUX9/8upWx8Eyvziv1dSs/Kw+aNH6q0vjXJU7umaMCAAUyaNIkPPviAli1bcuzYMT7//PMy5/PVV1/x4osv0r9/f3r06EHnzp3x9fWtghoLIYQQoiZ7akeKagoZKaoYGSkS1UVGispPRorK74mOFG0YVjkjRW9temZGip7aNUVCCCGEKJm2QIu2oGLjHhVN/7SpUdNnV65cwcDA4LE2Hx+f6q6uEEIIIWqRGjVSpFAoSn1G0D81aNCgimsjhBBCPMUq44Wu8kLY6uPi4sL58+eruxpCCCHE069AW7hVNI9nSI2aPhNCCCGEqC41aqRICCGEEJVDq9WireD017N2g7p0ioQQQojaqIBKmD6rlJo8NaRTJIQQQtRGBZrCraJ5PENkTZEQQgghBDJSJIQQQtRKWk0lrCmSW/KFEEII8dSTW/LLTKbPhBBCCCGQkSIhhBCidpInWpeZdIqEEEKIWkheCFt2Mn0mhBBCCIGMFAkhhBC1k1YDmgo+Z0j7bD2nSDpFQgghRG0kd5+VmUyfCSGEEEIgI0VCCCFErSQPbyw7GSkSQgghaqP702cV3apYbm4uLVu2xMDAgNOnT1d5eaWRkaIa4vdtMZzYEUOqOgMA+/o2dB3dmsYd3YuN3z7rMH+ExRY5bl/fhvFbXwMgas8Fdsw+UiTmi6PvoDAt/NHnZuYRvvIUMYevkJmSjVNjFX0nd8DV277Uslx97BmzemC5vmtli5u7E087pyLHlx3ZxgdbFhU57ufVmsMfLS9yvOnMIVy4fRUAb6f6zO73Hr7uTfG0c2LiTyGEHtyqF/9Jr+EEtOxCU0cPsvNzOXb5LB/vWkbs7XhdzBd9RzO0TQ/cbBzIK8gnMv4C03ev4MSV6Ip+7Uoj56/itFots2atZ9WqMFJSMmjfvhlLl46neXPPUtNt3/4fZsxYw+XLaho2dGLu3FG88kpnvZjly3ezaNGPqNVJNG/uSUhIIC+88Fyx+b3//jesWhXGN98EMnHiq7rjubl5BAWtZMuWg2Rn59G9eyuWLZuAq2u9Cn/38pI27wl4StYUTZ06FWdnZ86cOVPlZT2KdIpqCKVDXXqOa4edqxUAf4TFsjFoH4EbAnBoaFskvu/kjvQc1063rynQsPSN7TTvXl8vzrSugok/DdE7dr9xANg57z8kXE5h0MyuWNUz5/Tei6wZF8aErYOxsq+ri/Pq4EbA5366fSNFzRlkbLtgJEaGD+rj49yQ8Anf8lPkwVLTNf7iNdJzMnX7dzJSdf82NzHj78Qb/BR1gJBBE4tN7+fVimVHtnPyagzGhkbMGzCGfR+G4j37dbLycgCITYjng61f83fiDeooTJnU/XX2jQ+l0YxBJN5NLTbfJ03OX8V9+eUWQkK2sWbNVBo3dmXevB/o2XMq58+vxdLSvNg0ERHRDB06h9mzR/LKK53ZufO/DBkym6NHQ2nfvhkAW7ceYtKk5SxbNp5OnXxYuXIPffpMIzp6Ne7uDnr57dr1X06cOI+zs12RsiZOXM6ePRFs3vwZdnZWBAWtoF+/6Zw69R1GRkaVf0Ieg7R5AmDv3r3s27eP7du3s3fv3uqujkyfzZw5k5YtW1Z3NWj6ggdNOrmj8rBG5WGNf2A7TMwVXDuXUGy8mYUJlipz3Xbjr0RyMnJp3a+JXpyBgYFenKXqQQOdn3OPmENx9PqwPfVbO2HnpqT7e22wcbbi9+0xevkYKwz18jBXmlX+SSinxLup3E5P1m0vt+jEpYRrHLkYVWq6hIwUvXSaf9x6eurqX0zdsZStp8LJvZdfbPreSyex7ngYMeo4/rxxiZHr5+Jh54Sve1NdzOaT+zhw/iRxiTeJUcfx0bbFKOtY8JxLo8r58pVAzl/FaLVaQkN38OmnwwgIeAEfn/qsXfsxWVk5bNp0oMR0oaE78Pf3Zdq0YTRt6s60acPo3r01oaHbdTEhIdt4553ejB7dl2bNPFi8eBxubvZ8990vennduHGHDz/8lh9++BSFQv9aNy3tLqtX72XRojH06OFLq1ZebNgwjbNn4wgPL/1nXJWkzat699cUVXSrKrdv3+bdd99lw4YNmJsXf/HwpMlIUQ2kKdBw7sDf5GXn497C4dEJgMifz9OgnQs2TpZ6x/Oy8/mq/ya0Gi1OXnZ0H9MG5yYqXTmaAi3GJvpXigpTI66euaV3LC5KTXCv9ZhZmOLZ2gn/sW2xsK1TgW9ZNRRGxrzZ7iW+ObD5kbF/fLoeM4UJMeo45u5dw+HYiv2BUNaxACA5K73Eur3XeSCpWRmcuX6xQmVVFTl/ZRcXp+bWrWR69myjO2ZqaoKf3/NERETz/vv9ik0XERGjN8UF0LNnG12nKC8vn8jIWD7++HW9GH9/XyIiHkwfajQahg9fQFDQ4GKn6yIjL5Kff0+vfs7OKnx8PDl2LJpevdqW+TtXNmnzqkiBpnCraB5Aerr+76WpqSmmpqblzlar1fL2228zZswY2rRpw5UrVypSy0ojnaIa5NalZL4ftYt7eQWY1FEw7Mue2DeweWS6jMQsLkZc47XZ3fSO1/OwJmBGFxwa2pKbmUfE1nOsGr2bcRsHoXJXYlrXBLcWDhxaHUW9+tZY2Nbhz32XuR6dgJ2bUpdP445u+HRvgLWTBSk3MwhfcYrVgXsIXB9QpHGpbgOf98O6jgVrI8JKjFGnJ/LuD8FExp/H1FjBW+17c2DCUrqEBHL00ulyl/3NoAkcvXSa6Jt/6x3v69OJLaPmYG5ihjo9Ef8l40nKTCt3OVVJzl/Z3bqVAoCDg/7vqr29DfHxt0tJl1wkjYODjS6/xMQ0Cgo0JcQk6/YXLtyCsbER48cHlFiOiYkCGxv9zsPD+VQHafOeHm5ubnr7X3zxBTNnziwSN3PmTGbNmlVqXidPnuTYsWOkp6czbdq0yqxmhdX46bPr168zdOhQbG1tqVu3Lm3atOH333/Xff7dd9/RsGFDTExMaNKkCRs2bNBLHx8fz4ABA7CwsMDKyorBgwdz+3bJDVVcXByNGjVi7NixaIp5Emhubi7p6el6W2VReSgZ98OrvP+/A2n3qjfbZx0m4e+UR6aL2nMBMwsTmnXx1Dvu1sKBlr29cGpsh2crJ4bM74GduzXHfzynixk0qyto4cu+G5nZ+X+J2HqO53o1wsDIQBfTwr8hTTq749DQlqYveDAitDdJ8Wlc+C2emmZUp37sjT6OOi2xxJjY2/H8z2+7+ePaBY7HnWPclq8IO3eMIP83yl3u0qFBPOfSiNf/9/Minx2KjaTl/OF0XPQu/44+zo+j51HP8tENf3WQ8/doGzeGY2nZV7fl598DCqdt/kmr1RY59rDi0zwcw0MxD9JFRsayZMkO1qyZ+siyHvY49atq0uZVLa22EqbPtIXTZ9euXSMtLU23ldSZ+eCDD/jrr79K3Xx8fDh48CDHjx/H1NQUY2NjGjUqnBJv06YNI0aMeGLn6GE1eqTo7t27+Pn54eLiws8//4yjoyNRUVG6zsrOnTuZMGECixcvpkePHuzZs4eRI0fi6upK165d0Wq1DBw4kLp163LkyBHu3btHYGAgQ4YM4fDhw0XKO3fuHD179mTEiBEEBwcXW6fg4OBH9oLLy1hhpLtacfGux/WYOxzbepaB014sMY1WqyXqlwu07O2FsaL0KxhDQwNcvOuRdO1BR87O1YrRK/uRl51PbmY+lipztnwajo2zZYn5WKrMsXayICm+5lytA7jbOtKjaVsCVn5S5rTH487xZruXylXuksGT6d/iBV78Zgw3Uu8U+TwrL4fLd65z+c51fo+LJnbWT4zq2I8Fv64vV3lVRc7f4+nfv6NuITRAbm7hmqlbt5JxcnqwyPnOnVQcHKxLzMfR0bbISE1CQqpuZEilUmJkZKgbOXoQk6KLOXr0LAkJqXh4PJhiKyjQEBS0gtDQ7cTFbcLR0Za8vHxSUjL0RosSElLp0KF5Gb995ZI2r4pV4t1nVlZWWFlZPTJcpVKhUqkeGbdkyRLmzp2r27958ya9evVi69attG/fvvz1raAa3SnatGkTd+7c4eTJk9jaFt6NcL83CbBo0SLefvttAgMDAfjoo484fvw4ixYtomvXroSHh/Pnn38SFxenG/rbsGEDzZs35+TJk7Rt+2AuPSIigpdffplp06YRFBRUYp2mTZvGRx99pNtPT08vMqxYabRaCvJKnw+Oi1KTdC0d3wFNS40rzE7LrdgkHBoVvco2qaPApI6C7PRcLh2/Tq8PS/5PmZWaQ9rtTL0FjDXByA4vk5CRQti5Y2VO28qtMer0kkdHSvLtkMm80tKPLt+M40qS+rHSGACmxiZlLquqyfl7PJaW5np3lGm1Whwdbdm/P5JWrbyAwvVAR46cYcGCd0vMp0MHb8LDI5k0aZDu2P79p+jYsbCjYmKiwNe3Mfv3R+rdph8eHkn//p0AeOutHvTo0Vov35de+pg33/Rn5MjCTqqvrxcKhTH790cyeHAXANTqJM6du8LChe9V4ExUAWnznhnu7vqPXrCwKFxT2LBhQ1xdXaujSkAN7xSdPn2aVq1a6TpED/vrr7947z39X+pOnToRGhqq+9zNzU2v0+Lt7Y21tTV//fWXrlMUHx9Pjx49mDt3LpMmTSq1ThVdXFaSfctP0LiDG0oHC3Kz8jm77xJxUWpGhPYu/HzZCdITMguHfv8h8ufzuPrYF3sL68FVkbj52GPnrtTNr6tjE+k3tZMu5mLENbSAyl1J8vV0/r3kd1QeSt0dHblZ+RxcFUnzrvWxVJmTos5g//KTmFub4f3Q0HV1MjAwYGSHvqw7/i8KNAV6n80fMBYX63qMWDcbgAndhnAlSU30zThMjAsXFg9q3U1vhERhZIy3U+GtviZGxrhY1+N5Vy/u5mZz+c51AJYNncKwtj0ZsGIqGbmZOFgV/gzSsjPJyc/F3MSM6b3f5uc/j6JOS8KurpJAv1dxtbHnp6iS70qqDnL+ys/AwIAJEwIIDt6El5crXl4uBAdvwtzcjGHDuuviRoxYgLOziuDg0QCMHx+An99EFi7czIABndi9+zfCw6M4ejRUl2bSpEEMH76ANm0a06GDN99/H0Z8fAJjxhQu3razU2Jnp9Srj0JhjKOjLU2aFLZ7SqUF77zTm6CgFdjZWWFra8mUKStp0aJ+kQ7VkyRt3hOg0RZuFc3jGVKjO0V16jx6pX9p8/glzZk/fLxevXo4OzuzZcsWRo0a9VhDhJXtblI222YeIiMxCzMLExwa2TEitDeN2hf2mDMSs0i9fVcvTc7dPGIOxtFncsdi88zJyGVX8FHuJhXm6dRYxeiV/XFtbq+Xx77lhY1PHStTmnerj//YdhgZFy43MzQ04PalZE7/K5acjDwsVOY08HVmyPzumNatOaMdPZq2xcPOidXHfinymZNShbuto27fxEjBooAPcbGuR3Z+LtHqOPosncTe6AhdjLOyHqenP1ifNsX/Tab4v8nh2Ci6hhSOTAb6Fd45dOSj7/TKe3vdHNYdD6NAo6Gpgycj3uuDqq41SZlpnLz6Fy98PYYYdVylfv+KkvNXMVOnDiU7O49x40J1D2/89deFeiNK8fEJGBo+aHc6dmzO5s2f8fnna5gxYy0NGzqzZcvnelNzQ4Z0JSkpnTlzNqBWJ+Pj40lYWDAeHo93h9Z9ISGBGBsbMWTIbN3DG9esmVttzygCafOeBG0BaCs4faYteHRMZfD09NStX6pOBtqaUIsSrFu3jvHjxxMXF1fsaFGnTp1o3rw533//ve7Y4MGDycrKYs+ePezfv5/evXvrTZ/FxMTops/atGnDzJkz2bVrF7/99ht9+vQhLy+Pffv2YWlZ8vzyP6Wnp6NUKvns4NuYWTxdvzA1wWerq/8JpuLZpFk+v7qr8NSaf2rro4NEsXLu5jG321rS0tKq7AL8/t8l9cQeWJlWbOwjPfceTovDq7S+NUmNvvvs9ddfx9HRkYEDB/Lbb7/x999/s337diIiCq9Ip0yZwtq1a1mxYgUXL17km2++YceOHbo1QT169OC5557jjTfeICoqihMnTjB8+HD8/Pxo06aNXll169YlLCwMY2Njevfuzd27d4vURwghhHhq3J8+q+j2DKnRnSITExP27duHvb09ffr0oUWLFixYsEA35Dtw4EBCQ0P56quvaN68OStXrmTNmjV06dIFKJxa27VrFzY2Nrz44ov06NGDBg0asHVr8Vc5FhYW7N27F61WS58+fcjMzCw2TgghhKjx7j+8saLbM6RGT589DWT6rGJk+kxUF5k+Kz+ZPiu/Jzl9dnNsl0qZPnP+7rBMnwkhhBBCPEueeKfoypUrGBgYPNbm4+PzpKsnhBBC1A4a7YMHOJZ3e8bWFD3xW/IVCgVNmjR5dCDQoEGDKq6NEEIIUTtVxlvuK5r+afPEO0UuLi6cP3/+SRcrhBBCCFGqGv3wRiGEEEKUj7ZAWwkPb5SRIiGEEEI85WT6rOzk7jMhhBBCCGSkSAghhKiVNAVaNBWc/qpo+qeNdIqEEEKIWkimz8pOps+EEEIIIZCRIiGEEKJW0mo0aDUVe3dZRdM/baRTJIQQQtRGlXBLPrKmSAghhBBPO622EtYUPWPvjJc1RUIIIYQQyEiREEIIUStpC7RoDeWJ1mUhnSIhhBCiFpJb8stOps+EEEIIIZCRIiGEEKJW0mi0aCo40lPR9E8b6RQJIYQQtZC2gEpYU1RJlXlKyPSZEEIIIQS1cKSoS5cutGzZksWLF1d3Vcrk920xnNgRQ6o6AwD7+jZ0Hd2axh3di43fPuswf4TFFjluX9+G8VtfAyBqzwV2zD5SJOaLo++gMC380edm5hG+8hQxh6+QmZKNU2MVfSd3wNXbvtSyXH3sGbN6YLm+a2WLm7sTTzunIseXHdnGB1sWFTnu59Wawx8tL3K86cwhXLh9FQBvp/rM7vcevu5N8bRzYuJPIYQe3KoX/0mv4QS07EJTRw+y83M5dvksH+9aRuzteF3MF31HM7RND9xsHMgryCcy/gLTd6/gxJXoin7tSiPnr+K0Wi2zZq1n1aowUlIyaN++GUuXjqd5c89S023f/h9mzFjD5ctqGjZ0Yu7cUbzySme9mOXLd7No0Y+o1Uk0b+5JSEggL7zwXLH5vf/+N6xaFcY33wQyceKruuO5uXkEBa1ky5aDZGfn0b17K5Ytm4Cra70Kf/fykjav6slC67KrdZ2iHTt2oFAoqrsaZaZ0qEvPce2wc7UC4I+wWDYG7SNwQwAODW2LxPed3JGe49rp9jUFGpa+sZ3m3evrxZnWVTDxpyF6x+43DgA75/2HhMspDJrZFat65pzee5E148KYsHUwVvZ1dXFeHdwI+NxPt2+kqDmDjG0XjMTI8EF9fJwbEj7hW36KPFhqusZfvEZ6TqZu/05Gqu7f5iZm/J14g5+iDhAyaGKx6f28WrHsyHZOXo3B2NCIeQPGsO/DULxnv05WXg4AsQnxfLD1a/5OvEEdhSmTur/OvvGhNJoxiMS7qcXm+6TJ+au4L7/cQkjINtasmUrjxq7Mm/cDPXtO5fz5tVhamhebJiIimqFD5zB79kheeaUzO3f+lyFDZnP0aCjt2zcDYOvWQ0yatJxly8bTqZMPK1fuoU+faURHr8bd3UEvv127/suJE+dxdrYrUtbEicvZsyeCzZs/w87OiqCgFfTrN51Tp77DyMio8k/IY5A2r+pJp6jsnr6f8iPY2tpiaWlZ3dUos6YveNCkkzsqD2tUHtb4B7bDxFzBtXMJxcabWZhgqTLXbTf+SiQnI5fW/ZroxRkYGOjFWaoeNND5OfeIORRHrw/bU7+1E3ZuSrq/1wYbZyt+3x6jl4+xwlAvD3OlWeWfhHJKvJvK7fRk3fZyi05cSrjGkYtRpaZLyEjRS6fRPnjHz6mrfzF1x1K2ngon915+sel7L53EuuNhxKjj+PPGJUaun4uHnRO+7k11MZtP7uPA+ZPEJd4kRh3HR9sWo6xjwXMujSrny1cCOX8Vo9VqCQ3dwaefDiMg4AV8fOqzdu3HZGXlsGnTgRLThYbuwN/fl2nThtG0qTvTpg2je/fWhIZu18WEhGzjnXd6M3p0X5o182Dx4nG4udnz3Xe/6OV148YdPvzwW3744VMUCv1r3bS0u6xevZdFi8bQo4cvrVp5sWHDNM6ejSM8vPSfcVWSNk/URLWuU9SlSxcmTpwIgKenJ/Pnz+edd97B0tISd3d3vv/+e734Y8eO0bJlS8zMzGjTpg27du3CwMCA06dPP/nK/x9NgYY/910iLzsf9xYOj04ARP58ngbtXLBx0u8Q5mXn81X/TXz58kY2TPo3Ny8k6pWjKdBibKJ/pagwNeLqmVt6x+Ki1AT3Wk/Iq1vZOe8/3E3OLue3q1oKI2PebPcSqyP2PDL2j0/Xc3PBHsInfEuXxq0rXLayjgUAyVnpJdbtvc4DSc3K4Mz1ixUuryrI+Su7uDg1t24l07NnG90xU1MT/PyeJyKi5Gm+iIgY/P3b6B3r2bMNx44VpsnLyycyMlYvXwB/f1+9fDUaDcOHLyAoaHCx03WRkRfJz7+nl4+zswofH09dWdVN2ryqof2/d59VdHuW1Lrps4d9/fXXzJkzh08//ZRt27YxduxYXnzxRZo2bUpGRgb9+vWjT58+bNq0iatXr+o6VNXh1qVkvh+1i3t5BZjUUTDsy57YN7B5ZLqMxCwuRlzjtdnd9I7X87AmYEYXHBrakpuZR8TWc6wavZtxGwehcldiWtcEtxYOHFodRb361ljY1uHPfZe5Hp2AnZtSl0/jjm74dG+AtZMFKTczCF9xitWBewhcH1CkcaluA5/3w7qOBWsjwkqMUacn8u4PwUTGn8fUWMFb7XtzYMJSuoQEcvTS6XKX/c2gCRy9dJrom3/rHe/r04kto+ZgbmKGOj0R/yXjScpMK3c5VUnOX9ndupUCgIOD/u+qvb0N8fG3S0mXXCSNg4ONLr/ExDQKCjQlxCTr9hcu3IKxsRHjxweUWI6JiQIbG/3Ow8P5VAdp86qWVqtBqzGocB7PklrfKerTpw+BgYEAfPzxx4SEhHD48GGaNm3Kxo0bMTAwYNWqVZiZmeHt7c2NGzd49913S8wvNzeX3Nxc3X56evFXteWh8lAy7odXycnII/pQHNtnHWb0in6PbCSi9lzAzMKEZl089Y67tXDA7R9XXe7PO7L8rR0c//EcLwd1AmDQrK7snHOEL/tuxNDIAKcmKp7r1Ujv6qqFf0Pdvx0a2uLSrB6L+m/iwm/xNO+qP59f3UZ16sfe6OOo0xJLjIm9Ha+3mPd43DncbBwI8n+j3H/Ulw4N4jmXRnRe9F6Rzw7FRtJy/nBUFkre7TSAH0fPo/2Xo7iTkVKusqqSnL9H27gxnDFjQnT7e/bMBwqnbf5Jq9UWOfaw4tM8HMNDMQ/SRUbGsmTJDiIjVzyyrIc9Tv2qmrR5VUtboEVrIK/5KItaN332sOeee3CXhoGBAY6OjiQkFM5ZX7hwgeeeew4zswdzxe3atSuSxz8FBwejVCp1m5ubW6XV1VhhhJ2bEhfvevQc1w5HLzuObT1bahqtVkvULxdo2dsLY0XpVzCGhga4eNcj6dqDjpydqxWjV/ZjxpGRTPnlDcaufYWCexpsnEtel2WpMsfayYKk+JpztQ7gbutIj6Zt+Z/fdpc57fG4c3jVK9/PcsngyfRv8QJdQwK5kXqnyOdZeTlcvnOd3+OiGf3DfO5pChjVsV+5yqpKcv4eT//+Hfnjj+91m0pVOMLw8KjLnTupODhYl5iPo6NtkTQJCam6kSGVSomRkaFu5OhBTIou5ujRsyQkpOLh8ToKhT8KhT9Xr94mKGgF9esP05WTl5dPSkpGiWVVF2nzRE1T6ztFD9+JZmBggEZTOBxY3JWSVlt6r3jatGmkpaXptmvXrlVuhfUrQ0Fe6UOXcVFqkq6l4zugaalxhdlpuRWbhKWqTpHPTOoosFSZk52ey6Xj12n2omeJ+WSl5pB2O1NvAWNNMLLDyyRkpBB27liZ07Zya4w6veTRkZJ8O2QyAa386Lb4A64kqR8rjQFgamxS5rKqmpy/x2NpaU6jRi66zdvbA0dHW/bvj9TF5OXlc+TIGTp0aF5iPh06eBMeHql3bP/+U3TsWJjGxESBr29jvXwBwsMjdfm+9VYPzpxZpddJc3a2IyhoMP/+90IAfH29UCiM9fJRq5M4d+6KrqwaQ9q8SnX/7rOKbs+SWj99Vpr7U2i5ubmYmpoCcOrUqVLTmJqa6mIr077lJ2jcwQ2lgwW5Wfmc3XeJuCg1I0J7F36+7ATpCZkMmtVVL13kz+dx9bEv9hbWg6sicfOxx85dqZtfV8cm0m9qJ13MxYhraAGVu5Lk6+n8e8nvqDyUujs6crPyObgqkuZd62OpMidFncH+5ScxtzbD+6Gh6+pkYGDAyA59WXf8XxRo9B/BOn/AWFys6zFi3WwAJnQbwpUkNdE34zAxLlxYPKh1NwJWfqJLozAyxtupcJjcxMgYF+t6PO/qxd3cbC7fuQ7AsqFTGNa2JwNWTCUjNxMHq8KfQVp2Jjn5uZibmDG999v8/OdR1GlJ2NVVEuj3Kq429vwUVfJdSdVBzl/5GRgYMGFCAMHBm/DycsXLy4Xg4E2Ym5sxbFh3XdyIEQtwdlYRHDwagPHjA/Dzm8jChZsZMKATu3f/Rnh4FEePhurSTJo0iOHDF9CmTWM6dPDm++/DiI9PYMyYwpEyOzsldnZKvfooFMY4OtrSpEnhyJ1SacE77/QmKGgFdnZW2NpaMmXKSlq0qE+PHhVfIF9e0uZVPXnNR9k9052iYcOGMX36dN577z0++eQT4uPjWbSo8GF1T3qu/W5SNttmHiIjMQszCxMcGtkxIrQ3jdq7AoULC1Nv39VLk3M3j5iDcfSZ3LHYPHMyctkVfJS7SYV5OjVWMXplf1yb2+vlsW95YeNTx8qU5t3q4z+2HUbGhYOIhoYG3L6UzOl/xZKTkYeFypwGvs4Mmd8d07o1Z7SjR9O2eNg5sfrYL0U+c1KqcLd11O2bGClYFPAhLtb1yM7PJVodR5+lk9gbHaGLcVbW4/T0Dbr9Kf5vMsX/TQ7HRtE1pHCNWqBf4cPxjnz0nV55b6+bw7rjYRRoNDR18GTEe31Q1bUmKTONk1f/4oWvxxCjjqvU719Rcv4qZurUoWRn5zFuXKju4Y2//rpQ7xlF8fEJGBo+aFc6dmzO5s2f8fnna5gxYy0NGzqzZcvnumcUAQwZ0pWkpHTmzNmAWp2Mj48nYWHBeHg83h1a94WEBGJsbMSQIbN1D29cs2ZutT2jCKTNEzWTgfZR80VPmX8+0drT05OJEyfq3VHWsmVLBg4cyMyZM4HCW/LHjh3L+fPnadGiBZMnT2bYsGGcP3+eJk2aFF/IP6Snp6NUKvns4NuYWcgvTFl9tvpMdVdBPKM0y+dXdxWeWvNPbX10kChWzt085nZbS1paGlZWVlVSxv2/S6c7eGNpXLGOb8a9AlpGxFRpfWuSWjdSdPjwYd2/r1y5UuTzh58/1LFjR86cefCHeePGjSgUCtzdi3/UvBBCCPE0kCdal12t6xSV1fr162nQoAEuLi6cOXOGjz/+mMGDB1OnTtGFeUIIIYSovZ75TtGtW7eYMWMGt27dwsnJiddee4158+ZVd7WEEEKICpHnFJXdM98pmjp1KlOnTq3uagghhBCVS1sJt9TXrmXHj1Trn1MkhBBCiJopLCyM9u3bU6dOHVQqFQEBxb+u5kl55keKhBBCiNpIq6mE6bMqXGi9fft23n33XebPn0+3bt3QarWcPVv6E82rmnSKhBBCiFpIW6BFS81cU3Tv3j0mTJjAV199xahRo3THH+dROFVJps+EEEKIWuj+E60rukHhs4/+uf3zxejlERUVxY0bNzA0NKRVq1Y4OTnRu3dvoqOjK+Orl5t0ioQQQghRKjc3N72XoQcHB1cov7///huAmTNn8tlnn7Fnzx5sbGzw8/MjOTn5EamrjnSKhBBCiFpIo6mcDeDatWt6L0OfNm1asWXOnDkTAwODUrdTp07pXsw+ffp0Xn31VXx9fVmzZg0GBgb89NNPT+oUFSFrioQQQohaSKMBTQVf43m/U2RlZfVYr/n44IMPGDp0aKkxnp6eZGRkAODt7a07bmpqSoMGDYiPjy9/hStIOkVCCCGEqBQqlQqVSvXIOF9fX0xNTblw4QKdO3cGID8/nytXruDh4VHV1SyRdIqEEEKIWqgyR4oqm5WVFWPGjOGLL77Azc0NDw8PvvrqKwBee+21qin0MUinSAghhKiFNNrCraJ5VJWvvvoKY2Nj3nrrLbKzs2nfvj0HDx7Exsam6gp9BOkUCSGEEOKJUygULFq0iEWLFlV3VXSkUySEEELUQjV5+qymkk6REEIIUQtptBXv1FTl9FlNJM8pEkIIIYRARoqEEEKIWkmrgYrOfmll+kwIIYQQTztNJXSKZE2REEIIIZ560ikqO1lTJIQQQgiBjBQJIYQQtZKMFJWddIpqiN+3xXBiRwyp6sKX5NnXt6Hr6NY07uhebPz2WYf5Iyy2yHH7+jaM31r4iPSoPRfYMftIkZgvjr6DwrTwR5+bmUf4ylPEHL5CZko2To1V9J3cAVdv+1LLcvWxZ8zqgeX6rpUtbu5OPO2cihxfdmQbH2wp+lAwP6/WHP5oeZHjTWcO4cLtqwB4O9Vndr/38HVviqedExN/CiH04Fa9+E96DSegZReaOnqQnZ/Lsctn+XjXMmJvP3iZ4Rd9RzO0TQ/cbBzIK8gnMv4C03ev4MSV6Ip+7Uoj56/itFots2atZ9WqMFJSMmjfvhlLl46neXPPUtNt3/4fZsxYw+XLaho2dGLu3FG88kpnvZjly3ezaNGPqNVJNG/uSUhIIC+88Fyx+b3//jesWhXGN98EMnHiq7rjubl5BAWtZMuWg2Rn59G9eyuWLZuAq2u9Cn/38pI2r+pJp6jspFNUQygd6tJzXDvsXAvfQvxHWCwbg/YRuCEAh4a2ReL7Tu5Iz3HtdPuaAg1L39hO8+719eJM6yqY+NMQvWP3GweAnfP+Q8LlFAbN7IpVPXNO773ImnFhTNg6GCv7uro4rw5uBHzup9s3UtScmde2C0ZiZPigPj7ODQmf8C0/RR4sNV3jL14jPSdTt38nI1X3b3MTM/5OvMFPUQcIGTSx2PR+Xq1YdmQ7J6/GYGxoxLwBY9j3YSjes18nKy8HgNiEeD7Y+jV/J96gjsKUSd1fZ9/4UBrNGETi3dRi833S5PxV3JdfbiEkZBtr1kylcWNX5s37gZ49p3L+/FosLc2LTRMREc3QoXOYPXskr7zSmZ07/8uQIbM5ejSU9u2bAbB16yEmTVrOsmXj6dTJh5Ur99CnzzSio1fj7u6gl9+uXf/lxInzODvbFSlr4sTl7NkTwebNn2FnZ0VQ0Ar69ZvOqVPfYWRkVPkn5DFImydqIvkp1xBNX/CgSSd3VB7WqDys8Q9sh4m5gmvnEoqNN7MwwVJlrttu/JVITkYurfs10YszMDDQi7NUPWig83PuEXMojl4ftqd+ayfs3JR0f68NNs5W/L49Ri8fY4WhXh7mSrPKPwnllHg3ldvpybrt5RaduJRwjSMXo0pNl5CRopdO8497T09d/YupO5ay9VQ4uffyi03fe+kk1h0PI0Ydx583LjFy/Vw87JzwdW+qi9l8ch8Hzp8kLvEmMeo4Ptq2GGUdC55zaVQ5X74SyPmrGK1WS2joDj79dBgBAS/g41OftWs/Jisrh02bDpSYLjR0B/7+vkybNoymTd2ZNm0Y3bu3JjR0uy4mJGQb77zTm9Gj+9KsmQeLF4/Dzc2e7777RS+vGzfu8OGH3/LDD5+iUOhf66al3WX16r0sWjSGHj18adXKiw0bpnH2bBzh4aX/jKuStHlVT6OpnO1ZIiNFNZCmQMO5A3+Tl52PewuHRycAIn8+T4N2Ltg4Weodz8vO56v+m9BqtDh52dF9TBucm6h05WgKtBib6F8pKkyNuHrmlt6xuCg1wb3WY2ZhimdrJ/zHtsXCtk4FvmXVUBgZ82a7l/jmwOZHxv7x6XrMFCbEqOOYu3cNh2Mr9gdCWccCgOSs9BLr9l7ngaRmZXDm+sUKlVVV5PyVXVycmlu3kunZs43umKmpCX5+zxMREc377/crNl1ERIzeFBdAz55tdJ2ivLx8IiNj+fjj1/Vi/P19iYh4MH2o0WgYPnwBQUGDi52ui4y8SH7+Pb36OTur8PHx5NixaHr1alvm71zZpM2rGlqtFq22Yo+krmj6p410isooNzeX3Nxc3X56evENeHncupTM96N2cS+vAJM6CoZ92RP7Bo9+W3BGYhYXI67x2uxuesfreVgTMKMLDg1tyc3MI2LrOVaN3s24jYNQuSsxrWuCWwsHDq2Ool59ayxs6/Dnvstcj07Azk2py6dxRzd8ujfA2smClJsZhK84xerAPQSuDyjSuFS3gc/7YV3HgrURYSXGqNMTefeHYCLjz2NqrOCt9r05MGEpXUICOXrpdLnL/mbQBI5eOk30zb/1jvf16cSWUXMwNzFDnZ6I/5LxJGWmlbucqiTnr+xu3UoBwMFB/3fV3t6G+PjbpaRLLpLGwcFGl19iYhoFBZoSYpJ1+wsXbsHY2Ijx4wNKLMfERIGNjX7n4eF8qoO0eaKmkU5RGQUHBzNr1qwqyVvloWTcD6+Sk5FH9KE4ts86zOgV/R7ZSETtuYCZhQnNunjqHXdr4YDbP6663J93ZPlbOzj+4zleDuoEwKBZXdk55whf9t2IoZEBTk1UPNerETcvJOrStfBvqPu3Q0NbXJrVY1H/TVz4LZ7mXfXn86vbqE792Bt9HHVaYokxsbfj9RbzHo87h5uNA0H+b5T7j/rSoUE859KIzoveK/LZodhIWs4fjspCybudBvDj6Hm0/3IUdzJSylVWVZLz92gbN4YzZkyIbn/PnvlA4bTNP2m12iLHHlZ8modjeCjmQbrIyFiWLNlBZOSKR5b1sMepX1WTNq9qyULrspM1RWU0bdo00tLSdNu1a9cqLW9jhRF2bkpcvOvRc1w7HL3sOLb1bKlptFotUb9coGVvL4wVpV/BGBoa4OJdj6RrD0a37FytGL2yHzOOjGTKL28wdu0rFNzTYONsWWI+lipzrJ0sSIqvOVfrAO62jvRo2pb/+W13mdMejzuHVz23cpW7ZPBk+rd4ga4hgdxIvVPk86y8HC7fuc7vcdGM/mE+9zQFjOpY/JRKdZLz93j69+/IH398r9tUqsIRhodHXe7cScXBwbrEfBwdbYukSUhI1Y0MqVRKjIwMdSNHD2JSdDFHj54lISEVD4/XUSj8USj8uXr1NkFBK6hff5iunLy8fFJSMkosq7pIm1e1ZE1R2UmnqIxMTU2xsrLS26qMVktBXun/I+Oi1CRdS8d3QNNS4wqz03IrNglLVdF5cZM6CixV5mSn53Lp+HWavehZYj5ZqTmk3c7UW8BYE4zs8DIJGSmEnTtW5rSt3BqjTi95dKQk3w6ZTEArP7ot/oArSerHSmMAmBqblLmsqibn7/FYWprTqJGLbvP29sDR0Zb9+yN1MXl5+Rw5coYOHZqXmE+HDt6Eh0fqHdu//xQdOxamMTFR4OvbWC9fgPDwSF2+b73VgzNnVul10pyd7QgKGsy//70QAF9fLxQKY7181Ookzp27oiurxpA2T1QzmT6rIfYtP0HjDm4oHSzIzcrn7L5LxEWpGRHau/DzZSdIT8hk0Kyueukifz6Pq499sbewHlwViZuPPXbuSt38ujo2kX5TO+liLkZcQwuo3JUkX0/n30t+R+Wh1N3RkZuVz8FVkTTvWh9LlTkp6gz2Lz+JubUZ3g8NXVcnAwMDRnboy7rj/6JAU6D32fwBY3GxrseIdbMBmNBtCFeS1ETfjMPEuHBh8aDW3QhY+YkujcLIGG+nwmFyEyNjXKzr8byrF3dzs7l85zoAy4ZOYVjbngxYMZWM3EwcrAp/BmnZmeTk52JuYsb03m/z859HUaclYVdXSaDfq7ja2PNTVMl3JVUHOX/lZ2BgwIQJAQQHb8LLyxUvLxeCgzdhbm7GsGHddXEjRizA2VlFcPBoAMaPD8DPbyILF25mwIBO7N79G+HhURw9GqpLM2nSIIYPX0CbNo3p0MGb778PIz4+gTFjCkfK7OyU2Nkp9eqjUBjj6GhLkyaFI3dKpQXvvNOboKAV2NlZYWtryZQpK2nRoj49erSu6tNTImnzqp5GW/GRHs2ztc5aOkXFWbp0KTt37uTAgSfX8N5NymbbzENkJGZhZmGCQyM7RoT2plF7V6BwYWHq7bt6aXLu5hFzMI4+kzsWm2dORi67go9yN6kwT6fGKkav7I9rc3u9PPYtL2x86liZ0rxbffzHtsPIuHAQ0dDQgNuXkjn9r1hyMvKwUJnTwNeZIfO7Y1q35ox29GjaFg87J1Yf+6XIZ05KFe62jrp9EyMFiwI+xMW6Htn5uUSr4+izdBJ7oyN0Mc7KepyevkG3P8X/Tab4v8nh2Ci6hgQCEOhXeOfQkY++0yvv7XVzWHc8jAKNhqYOnox4rw+qutYkZaZx8upfvPD1GGLUcZX6/StKzl/FTJ06lOzsPMaNC9U9vPHXXxfqPaMoPj4BQ8MHa3g6dmzO5s2f8fnna5gxYy0NGzqzZcvnumcUAQwZ0pWkpHTmzNmAWp2Mj48nYWHBeHg83h1a94WEBGJsbMSQIbN1D29cs2ZutT2jCKTNexK0GtBUcNnYM3bzGQbaZ+1+u8cwc+ZM1q5dy5UrVx4Zm56ejlKp5LODb2Nm8XT9wtQEn60+U91VEM8ozfL51V2Fp9b8U1sfHSSKlXM3j7nd1pKWllZlyy/u/13aatEQc4OKdXyztAUMuXu5Sutbk8iaomLMnDnzsTpEQgghhKg9ZPpMCCGEqIU0lTB9JmuKhBBCCPHUk05R2cn0mRBCCCEEMlIkhBBC1EoabSU80foZGymSTpEQQghRC8n0WdnJ9JkQQgghBDJSJIQQQtRKMlJUdtIpEkIIIWoh6RSVnUyfCSGEEEIgI0UVdv8tKbmZedVck6dU3r3qroF4RqWnZ1Z3FZ5aOXelvSuv+38rnsQbtjK1mgqP9GRX+P61p4u8+6yCrl+/jpubW3VXQwghxFPk2rVruLq6VkneOTk51K9fn1u3blVKfo6OjsTFxWFmZlYp+dVk0imqII1Gw82bN7G0tMTAoIKTt0IIIWo1rVZLRkYGzs7OGBpW3QqWnJwc8vIqZ0TPxMTkmegQgXSKhBBCCCEAWWgthBBCCAFIp0gIIYQQApBOkRBCCCEEIJ0iIYQQQghAOkVCCCGEEIB0ioQQQgghAOkUCSGEEEIA8P8Bf9HOpEFwF/kAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1803,7 +1780,7 @@ { "cell_type": "code", "execution_count": 405, - "id": "5fe58d05", + "id": "0e505992", "metadata": {}, "outputs": [ { @@ -1867,7 +1844,7 @@ { "cell_type": "code", "execution_count": 406, - "id": "7aab7567", + "id": "69124c7c", "metadata": {}, "outputs": [ { @@ -1910,7 +1887,7 @@ { "cell_type": "code", "execution_count": 494, - "id": "250943a8", + "id": "e838a349", "metadata": {}, "outputs": [], "source": [ @@ -2048,7 +2025,7 @@ { "cell_type": "code", "execution_count": 497, - "id": "4ad72605", + "id": "ac42a4ac", "metadata": {}, "outputs": [ { @@ -2229,7 +2206,7 @@ { "cell_type": "code", "execution_count": 498, - "id": "e7699e5f", + "id": "5cbc2144", "metadata": {}, "outputs": [ { @@ -2251,7 +2228,7 @@ { "cell_type": "code", "execution_count": 503, - "id": "0050ebfc", + "id": "b2387886", "metadata": {}, "outputs": [ { @@ -2325,7 +2302,7 @@ { "cell_type": "code", "execution_count": 504, - "id": "8d730e3a", + "id": "9b200e90", "metadata": {}, "outputs": [ { @@ -2347,7 +2324,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fe09b4a3", + "id": "a2cc305d", "metadata": {}, "outputs": [], "source": [] From fcfdcce282df44b5fa394ccabaa843482f1921fa Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Fri, 11 Aug 2023 11:21:13 -0700 Subject: [PATCH 06/11] llm attr --- captum/attr/_core/shapley_value.py | 40 + tutorials/LLama2-Captum-Demo.ipynb | 4667 ++++++++++++++++++++++++++-- 2 files changed, 4451 insertions(+), 256 deletions(-) diff --git a/captum/attr/_core/shapley_value.py b/captum/attr/_core/shapley_value.py index 492ae20464..3ac5c3596d 100644 --- a/captum/attr/_core/shapley_value.py +++ b/captum/attr/_core/shapley_value.py @@ -341,6 +341,7 @@ def attribute( # Initialize attribution totals and counts output_shape = initial_eval.shape +<<<<<<< HEAD # attr shape (*output_shape, *input_feature_shape) total_attrib = [ torch.zeros( @@ -350,6 +351,24 @@ def attribute( ) for input in inputs ] +======= + if agg_output_mode: + total_attrib = [ + torch.zeros_like( + input[0:1], dtype=torch.float + ) + for input in inputs + ] + else: + total_attrib = [ + torch.zeros( + (*output_shape, *input.shape[1:]), dtype=torch.float, device=inputs[0].device + ) + for input in inputs + ] + + print("sv shape::",total_attrib[0].shape) +>>>>>>> 19803159 (llm attr) iter_count = 0 # Iterate for number of samples, generate a permutation of the features @@ -403,6 +422,7 @@ def attribute( prev_results = all_eval[-num_examples:] for j in range(len(total_attrib)): +<<<<<<< HEAD # format eval_diff to shape # (n_perturb, *output_shape, 1,.. 1) # where n_perturb may not be perturb_per_eval @@ -410,6 +430,26 @@ def attribute( # have the same dim as the mask tensor. formatted_eval_diff = eval_diff.reshape( (-1,) + output_shape + (len(inputs[j].shape) - 1) * (1,) +======= + current_eval_diff = eval_diff + if not agg_output_mode: + # current_eval_diff dimensions: + # (#features in batch, #num_examples, 1,.. 1) + # (contains 1 more dimension than inputs). This adds extra + # dimensions of 1 to make the tensor broadcastable with the + # inputs tensor. + # print("inputs[j]", inputs[j].shape) + # print("output_shape", output_shape) + # print("current_eval_diff]", current_eval_diff) + + current_eval_diff = current_eval_diff.reshape( + output_shape + (len(inputs[j].shape) - 1) * (1,) + ) + + # mask in shape (1, 1, 5), remove 1st + total_attrib[j] += ( + current_eval_diff * current_masks[j].squeeze(0).float() +>>>>>>> 19803159 (llm attr) ) # mask in shape (n_perturb, *mask_shape_broadcastable_to_input) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index a08c706048..1db693a0a5 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -273,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 315, + "execution_count": 654, "id": "bb032c18", "metadata": {}, "outputs": [ @@ -281,17 +281,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "[INST] Dave lives in Palm Coast, FL and is a lawyer. His personal interests include [/INST] Sure, here are some personal interests that Dave, a lawyer living in Palm Coast, Florida, might have:\n", + "[INST] Help me rewrite the following sentence.\n", "\n", - "1. Golfing: Palm Coast has several golf courses, and Dave might enjoy playing golf in his free time [INST] Anything else? [INST] Sure, here are a few more ideas for Dave's personal interests:\n", + "Table 1 presents the results, where the positive and negative value means the feature token increases and decreases respectively the LLM's probability of outputting the corresponding interest [/INST] Sure! Here's a possible rewrite of the sentence:\n", "\n", - "1. Fishing: With its proximity to the Atlantic Ocean and numerous waterways, Palm Coast offers ample opportunities for fishing. Dave might\n", - "['', '▁[', 'INST', ']', '▁Dave', '▁lives', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁F', 'L', '▁and', '▁is', '▁a', '▁lawyer', '.', '▁His', '▁personal', '▁interests', '▁include', '▁[', '/', 'INST', ']', '▁', '▁Sure', ',', '▁here', '▁are', '▁some', '▁personal', '▁interests', '▁that', '▁Dave', ',', '▁a', '▁lawyer', '▁living', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁Florida', ',', '▁might', '▁have', ':', '<0x0A>', '<0x0A>', '1', '.', '▁G', 'olf', 'ing', ':', '▁Pal', 'm', '▁Coast', '▁has', '▁several', '▁golf', '▁courses', ',', '▁and', '▁Dave', '▁might', '▁enjoy', '▁playing', '▁golf', '▁in', '▁his', '▁free', '▁time', '', '', '▁', '▁[', 'INST', ']', '▁An', 'yth', 'ing', '▁else', '?', '▁[', 'INST', ']', '▁', '▁Sure', ',', '▁here', '▁are', '▁a', '▁few', '▁more', '▁ideas', '▁for', '▁Dave', \"'\", 's', '▁personal', '▁interests', ':', '<0x0A>', '<0x0A>', '1', '.', '▁Fish', 'ing', ':', '▁With', '▁its', '▁proxim', 'ity', '▁to', '▁the', '▁Atlantic', '▁Ocean', '▁and', '▁numerous', '▁water', 'ways', ',', '▁Pal', 'm', '▁Coast', '▁offers', '▁am', 'ple', '▁opportun', 'ities', '▁for', '▁fish', 'ing', '.', '▁Dave', '▁might']\n" + "Table 1 displays the results, where positive and negative values indicate that the feature token increases and decreases, respectively, the language model's (LLM's) [INST] Try again. [INST] Sure! Here's another possible rewrite of the sentence:\n", + "\n", + "Table 1 shows the effects of each feature token on the LLM's probability of outputting the corresponding interest, with positive and negative values indicating increases and decreases,\n", + "['', '▁[', 'INST', ']', '▁Help', '▁me', '▁rewrite', '▁the', '▁following', '▁sentence', '.', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁presents', '▁the', '▁results', ',', '▁where', '▁the', '▁positive', '▁and', '▁negative', '▁value', '▁means', '▁the', '▁feature', '▁token', '▁increases', '▁and', '▁decre', 'ases', '▁respectively', '▁the', '▁L', 'LM', \"'\", 's', '▁probability', '▁of', '▁output', 'ting', '▁the', '▁corresponding', '▁interest', '▁[', '/', 'INST', ']', '▁', '▁Sure', '!', '▁Here', \"'\", 's', '▁a', '▁possible', '▁rewrite', '▁of', '▁the', '▁sentence', ':', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁displays', '▁the', '▁results', ',', '▁where', '▁positive', '▁and', '▁negative', '▁values', '▁indicate', '▁that', '▁the', '▁feature', '▁token', '▁increases', '▁and', '▁decre', 'ases', ',', '▁respectively', ',', '▁the', '▁language', '▁model', \"'\", 's', '▁(', 'LL', 'M', \"'\", 's', ')', '', '', '▁', '▁[', 'INST', ']', '▁Try', '▁again', '.', '▁[', 'INST', ']', '▁', '▁Sure', '!', '▁Here', \"'\", 's', '▁another', '▁possible', '▁rewrite', '▁of', '▁the', '▁sentence', ':', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁shows', '▁the', '▁effects', '▁of', '▁each', '▁feature', '▁token', '▁on', '▁the', '▁L', 'LM', \"'\", 's', '▁probability', '▁of', '▁output', 'ting', '▁the', '▁corresponding', '▁interest', ',', '▁with', '▁positive', '▁and', '▁negative', '▁values', '▁indicating', '▁increases', '▁and', '▁decre', 'ases', ',']\n" ] } ], "source": [ - "eval_prompt = \"[INST] Dave lives in Palm Coast, FL and is a lawyer. His personal interests include [/INST]\"\n", + "eval_prompt = \"[INST] Help me rewrite the following sentence.\\n\\nTable 1 presents the results, where the positive and negative value means the feature token increases and decreases respectively the LLM's probability of outputting the corresponding interest [/INST]\"\n", "\n", "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", "\n", @@ -300,7 +302,7 @@ " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=50)[0]\n", " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", " \n", - " eval_prompt = response + \" [INST] Anything else? [INST]\"\n", + " eval_prompt = response + \" [INST] Try again. [INST]\"\n", " \n", " model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", " \n", @@ -762,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 450, + "execution_count": 585, "id": "theoretical-cassette", "metadata": {}, "outputs": [], @@ -812,7 +814,10 @@ " \n", " log_prob_list = []\n", " for target_token in target_tokens:\n", - " output_logits = self.model.forward(model_inp)\n", + " output_logits = self.model.forward(\n", + " model_inp, \n", + " attention_mask=torch.tensor([[1] * model_inp.shape[1]])\n", + " )\n", " new_token_logits = output_logits.logits[:, -1]\n", " log_probs = torch.nn.functional.log_softmax(new_token_logits, dim=1)\n", " \n", @@ -821,7 +826,6 @@ " model_inp = torch.cat((model_inp, torch.tensor([[target_token]]).to(self.device)), dim=1)\n", " \n", " total_log_prob = sum(log_prob_list)\n", - " \n", " # 1st dim is the total prob, rest are the target tokens\n", " target_log_probs = torch.stack([total_log_prob, *log_prob_list], dim=0)\n", " target_probs = torch.exp(target_log_probs)\n", @@ -901,7 +905,7 @@ }, { "cell_type": "code", - "execution_count": 451, + "execution_count": 616, "id": "hairy-seeking", "metadata": {}, "outputs": [], @@ -1090,7 +1094,7 @@ }, { "cell_type": "code", - "execution_count": 442, + "execution_count": 617, "id": "57402c26", "metadata": {}, "outputs": [ @@ -1099,24 +1103,17 @@ "output_type": "stream", "text": [ " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [442], line 8\u001b[0m\n\u001b[1;32m 1\u001b[0m target \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mplaying golf, hiking, and cooking.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3\u001b[0m inp_feature \u001b[38;5;241m=\u001b[39m TextTemplateFeature(\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{name}\u001b[39;00m\u001b[38;5;124m lives in \u001b[39m\u001b[38;5;132;01m{city}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{state}\u001b[39;00m\u001b[38;5;124m and is a \u001b[39m\u001b[38;5;132;01m{occupation}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m{pronoun}\u001b[39;00m\u001b[38;5;124m personal interests include\u001b[39m\u001b[38;5;124m\"\u001b[39m, \n\u001b[1;32m 5\u001b[0m inputs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDave\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPalm Coast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFL\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlawyer\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHis\u001b[39m\u001b[38;5;124m\"\u001b[39m}, \n\u001b[1;32m 6\u001b[0m )\n\u001b[0;32m----> 8\u001b[0m attr_result_3 \u001b[38;5;241m=\u001b[39m \u001b[43mllm_attr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minp_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn [404], line 105\u001b[0m, in \u001b[0;36mLLMAttribution.attribute\u001b[0;34m(self, input_feature, target, num_trials, log_trials, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_trials): \n\u001b[1;32m 103\u001b[0m attr_input \u001b[38;5;241m=\u001b[39m input_feature\u001b[38;5;241m.\u001b[39minterpretable_tensor\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m--> 105\u001b[0m cur_attr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattr_method\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43mattr_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minput_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_tokens\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlog_trials\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m attr \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m cur_attr\n\u001b[1;32m 113\u001b[0m attr \u001b[38;5;241m=\u001b[39m (attr \u001b[38;5;241m/\u001b[39m num_trials) \n", - "File \u001b[0;32m~/local/captum/captum/log/__init__.py:42\u001b[0m, in \u001b[0;36mlog_usage.._log_usage..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:351\u001b[0m, in \u001b[0;36mFeatureAblation.attribute\u001b[0;34m(self, inputs, baselines, target, additional_forward_args, feature_mask, perturbations_per_eval, show_progress, **kwargs)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (\n\u001b[1;32m 332\u001b[0m current_inputs,\n\u001b[1;32m 333\u001b[0m current_add_args,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[38;5;66;03m# non-agg mode:\u001b[39;00m\n\u001b[1;32m 350\u001b[0m \u001b[38;5;66;03m# (feature_perturbed * batch_size, *initial_eval.shape[1:])\u001b[39;00m\n\u001b[0;32m--> 351\u001b[0m modified_eval \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strict_run_forward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward_func\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_target\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 355\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_add_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 356\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m show_progress:\n\u001b[1;32m 359\u001b[0m attr_progress\u001b[38;5;241m.\u001b[39mupdate()\n", - "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:599\u001b[0m, in \u001b[0;36mFeatureAblation._strict_run_forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 593\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_strict_run_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \u001b[38;5;124;03m A temp wrapper for global _run_forward util to force forward output\u001b[39;00m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m type assertion & conversion.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m Remove after the strict logic is supported by all attr classes\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 599\u001b[0m forward_output \u001b[38;5;241m=\u001b[39m \u001b[43m_run_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 600\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(forward_output, Tensor):\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_output\n", - "File \u001b[0;32m~/local/captum/captum/_utils/common.py:517\u001b[0m, in \u001b[0;36m_run_forward\u001b[0;34m(forward_func, inputs, target, additional_forward_args)\u001b[0m\n\u001b[1;32m 514\u001b[0m inputs \u001b[38;5;241m=\u001b[39m _format_inputs(inputs)\n\u001b[1;32m 515\u001b[0m additional_forward_args \u001b[38;5;241m=\u001b[39m _format_additional_forward_args(additional_forward_args)\n\u001b[0;32m--> 517\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mforward_func\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 519\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _select_targets(output, target)\n", - "Cell \u001b[0;32mIn [404], line 52\u001b[0m, in \u001b[0;36mLLMAttribution._forward_func\u001b[0;34m(self, perturbed_feature, input_feature, target_tokens, log_trials)\u001b[0m\n\u001b[1;32m 48\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mfunctional\u001b[38;5;241m.\u001b[39mlog_softmax(new_token_logits, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 50\u001b[0m log_prob_list\u001b[38;5;241m.\u001b[39mappend(log_probs[\u001b[38;5;241m0\u001b[39m][target_token]\u001b[38;5;241m.\u001b[39mdetach())\n\u001b[0;32m---> 52\u001b[0m model_inp \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat((model_inp, \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtarget_token\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 54\u001b[0m total_log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;28msum\u001b[39m(log_prob_list)\n\u001b[1;32m 56\u001b[0m \u001b[38;5;66;03m# 1st dim is the total prob, rest are the target tokens\u001b[39;00m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "open sourcing explainable techniques. [prob: 7.460598999674888e-23 ]\n", + " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "open sourcing explainable techniques. [prob: 7.016529001286807e-23 ]\n", + " Dave lives in , FL and is a lawyer. His personal interests include\n", + "open sourcing explainable techniques. [prob: 1.1619964047938748e-21 ]\n", + " Dave lives in Palm Coast, and is a lawyer. His personal interests include\n", + "open sourcing explainable techniques. [prob: 1.5589677720692103e-21 ]\n", + " Dave lives in Palm Coast, FL and is a . His personal interests include\n", + "open sourcing explainable techniques. [prob: 3.2460304118967485e-23 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", + "open sourcing explainable techniques. [prob: 6.223421373823065e-22 ]\n" ] } ], @@ -1128,12 +1125,12 @@ " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", ")\n", "\n", - "attr_result_3 = llm_attr.attribute(inp_feature, target=target)" + "attr_result_3 = llm_attr.attribute(inp_feature, target=\"open sourcing explainable techniques.\")" ] }, { "cell_type": "code", - "execution_count": 274, + "execution_count": 618, "id": "8af32cb0", "metadata": {}, "outputs": [ @@ -1146,9 +1143,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1543,7 +1540,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 537, "id": "iraqi-gibson", "metadata": {}, "outputs": [ @@ -1569,234 +1566,4104 @@ " Sarah lives in Boston, FL and is a doctor. His personal interests include\n", "playing golf, hiking, and cooking. [prob: 3.763693166547455e-05 ]\n", " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n" - ] - } - ], - "source": [ - "import importlib\n", - "import captum\n", - "\n", - "from captum.attr import ShapleyValueSampling\n", - "\n", - "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", - "\n", - "svs = m.ShapleyValueSampling(model) \n", - "baselines = ProductBaselines(\n", - " {\n", - " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", - " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", - " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", - " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", - " }\n", - ")\n", - "\n", - "sv_llm_attr = LLMAttribution(svs, tokenizer)\n", - "\n", - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", - " baselines=baselines,\n", - "# mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", - ")\n", - "\n", - "\n", - "attr_result_7 = sv_llm_attr.attribute(\n", - " inp_feature, \n", - " target=\"playing golf, hiking, and cooking.\",\n", - "# num_trials=2,\n", - " n_samples=200 # arg to ShapleyValueSampling.attribute\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 536, - "id": "c22f5569", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_7 = LLMAttrViz(**attr_result_7)\n", - "attr_viz_7.plot_seq_attr()\n", - "attr_viz_7.plot_token_attr()" - ] - }, - { - "cell_type": "markdown", - "id": "objective-america", - "metadata": {}, - "source": [ - "Let's now consider a more complex example, where we use the LLM as a few-shot learner to classify sample movie reviews as positive or negative. We apply FeatureAblation to measure the relative impact of the few shot examples. Since the prompt changes slightly in the case that no examples are needed, we define a prompt function rather than a format string in this case." - ] - }, - { - "cell_type": "code", - "execution_count": 333, - "id": "african-accessory", - "metadata": {}, - "outputs": [], - "source": [ - "def prompt_fn(*examples):\n", - " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", - " subset = [elem for elem in examples if elem is not None]\n", - " if len(subset) == 0:\n", - " return main_prompt\n", - " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative:\\n\"\n", - " return \"[INST] \" + prefix + \" \\n\".join(subset) + \"\\n \" + main_prompt + \"[/INST]\"" - ] - }, - { - "cell_type": "code", - "execution_count": 334, - "id": "powered-seating", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.48403507471084595 ]\n", - "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - "[INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n" + "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", + " John lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.899505489040166e-05 ]\n", + " Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0484606036698096e-06 ]\n", + " John lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.1097308490425348e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.106719148287084e-05 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8824379367288202e-05 ]\n", + " Rachel lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.271564310125541e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2926978342875373e-05 ]\n", + " Martin lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.373025538166985e-05 ]\n", + " Dave lives in Seattle, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.766460162703879e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.30380283028353e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.227898777273367e-07 ]\n", + " Dave lives in Boston, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.448989435943076e-06 ]\n", + " Dave lives in Palm Coast, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.861600973526947e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1721839427991654e-06 ]\n", + " Sarah lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.4719674810476135e-06 ]\n", + " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" ] - } - ], - "source": [ - "llm_attr = LLMAttribution(fa, tokenizer)\n", - "\n", - "input_examples = [\n", - " \"'The movie was ok, the actors weren't great' Negative\", \n", - " \"'I loved it, it was an amazing story!' Positive\",\n", - " \"'Total waste of time!!' Negative\", \n", - " \"'Won't recommend' Negative\",\n", - "]\n", - "inp_feature = TextTemplateFeature(\n", - " prompt_fn, \n", - " inputs=input_examples,\n", - ")\n", - "\n", - "attr_result_8 = llm_attr.attribute(\n", - " inp_feature, \n", - "# target=\"Positive\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 339, - "id": "bc40b7a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_8 = LLMAttrViz(**attr_result_8)\n", - "attr_viz_8.plot_seq_attr()\n", - "attr_viz_8.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 405, - "id": "0e505992", - "metadata": {}, - "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + " John lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.480950221681269e-06 ]\n", + " Rachel lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4692967599548865e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9094561139354482e-05 ]\n", - " Dave in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.641148168753716e-06 ]\n", - " Dave lives Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.978511813329533e-06 ]\n", - " Dave lives inm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6035468181362376e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", + " Dave lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.687276825483423e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.121143031923566e-05 ]\n", + " Sarah lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3429129467112944e-05 ]\n", + " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1338612239342183e-05 ]\n", + " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", + " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.3837108023581095e-06 ]\n", + " Rachel lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.194474513496971e-06 ]\n", + " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.21195658823126e-06 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.873038844583789e-06 ]\n", + " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", + " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.23475090530701e-06 ]\n", + " Rachel lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4643317172158277e-06 ]\n", + " Rachel lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.995898153647431e-07 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.685973403364187e-06 ]\n", + " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.1373730305640493e-06 ]\n", + " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", + " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", + " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Boston, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0030606063082814e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0534930652283947e-06 ]\n", + " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", + " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.603064088674728e-06 ]\n", + " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.508013939310331e-06 ]\n", + " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6120865211632918e-06 ]\n", + " Sarah lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.23475090530701e-06 ]\n", + " Rachel lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.807389920344576e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4758370525669307e-05 ]\n", + " Martin lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.761676842055749e-05 ]\n", + " Dave lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.491680323961191e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", + " Rachel lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6276373571599834e-05 ]\n", + " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n", + " Sarah lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7024378141504712e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.173955181206111e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.485392987087835e-06 ]\n", + " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.108045398723334e-05 ]\n", + " Martin lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.213460488244891e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.480950221681269e-06 ]\n", + " John lives in Palm Coast, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.958523277309723e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2626491045230068e-05 ]\n", + " Sarah lives in Seattle, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.385400850675069e-05 ]\n", + " Rachel lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2062064342899248e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.06315609527519e-06 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.193209396267775e-06 ]\n", + " Dave lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.7140732678817585e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.685696568340063e-05 ]\n", + " John lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.085239536128938e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2548389349831268e-05 ]\n", + " John lives in Palm Coast, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.14929467701586e-06 ]\n", + " Dave lives in Palm Coast, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.3295709727099165e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", + " Dave lives in Boston, FL and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1043377980968216e-06 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.889714935212396e-05 ]\n", + " Rachel lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.787422989873448e-06 ]\n", + " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4927624761185143e-05 ]\n", + " Martin lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0794499758048914e-05 ]\n", + " John lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.32769481651485e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2288547623029444e-05 ]\n", + " Dave lives in Boston, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0030606063082814e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.626012999622617e-05 ]\n", + " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.8221547078574076e-05 ]\n", + " Sarah lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7024378141504712e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.4307087086490355e-06 ]\n", + " John lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2543938282760791e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.537572633329546e-06 ]\n", + " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", + " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.448989435943076e-06 ]\n", + " Dave lives in Seattle, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4255711903388146e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.0007188140880316e-05 ]\n", + " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.009897444731905e-07 ]\n", + " Dave lives in Seattle, FL and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9428996438364265e-06 ]\n", + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0710449487305596e-06 ]\n", + " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", + " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4987554070321494e-07 ]\n", + " Dave lives in Palm Coast, WA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.3547094062669203e-06 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", + " Martin lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.692947292525787e-06 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.841361260332633e-06 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", + " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", + " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", + " Martin lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.692947292525787e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.240416430751793e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6553814930375665e-05 ]\n", + " Rachel lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4643317172158277e-06 ]\n", + " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.97077859210549e-06 ]\n", + " Sarah lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.1958392608212307e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.229522568901302e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.1782808491698233e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.1584108910465147e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.973982974363025e-06 ]\n", + " Martin lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6521782526979223e-05 ]\n", + " John lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.541747355484404e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", + " Dave lives in Seattle, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.761077202099841e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.175311450031586e-06 ]\n", + " Sarah lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.664822765538702e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7474596208776347e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.108045398723334e-05 ]\n", + " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.9818938855896704e-06 ]\n", + " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Boston, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", + " Dave lives in Seattle, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.227144801116083e-06 ]\n", + " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", + " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.185174008052854e-07 ]\n", + " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.4307087086490355e-06 ]\n", + " Rachel lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.2577593123714905e-06 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8029744751402177e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", + " John lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.2905325042520417e-06 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.389164653024636e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.071933119575988e-07 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.688950063311495e-06 ]\n", + " Dave lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", + " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0710449487305596e-06 ]\n", + " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.6533326642238535e-06 ]\n", + " Dave lives in Seattle, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6396523026051e-05 ]\n", + " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.942811862449162e-06 ]\n", + " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", + " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.878842550075206e-07 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Rachel lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.642711251610308e-06 ]\n", + " John lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.5235010475153103e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0534930652283947e-06 ]\n", + " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3604388186649885e-05 ]\n", + " John lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.11088529592962e-05 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.493829126455239e-06 ]\n", + " Dave lives in Boston, FL and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1043377980968216e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.000689841632266e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.543208782095462e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4346121133712586e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.8950561651727185e-05 ]\n", + " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", + " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", + " Martin lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.305322363507003e-06 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.78439948084997e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2185448667878518e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.87206743855495e-05 ]\n", + " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.508013939310331e-06 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9458868791843997e-06 ]\n", + " John lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.0111195883364417e-06 ]\n", + " Dave lives in Boston, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, WA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0618667147355154e-05 ]\n", + " John lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3888860848965123e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4346121133712586e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.839130502252374e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.685973403364187e-06 ]\n", + " John lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.169937791535631e-05 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.856503899944073e-06 ]\n", + " John lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.135143404302653e-05 ]\n", + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3854206599717145e-06 ]\n", + " Rachel lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.974666702153627e-06 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7345660126011353e-06 ]\n", + " Rachel lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6276373571599834e-05 ]\n", + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", + " John lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2912672900711186e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.584994869423099e-05 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.009874378927634e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6951678844634444e-05 ]\n", + " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", + " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.528855477772595e-06 ]\n", + " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.849522378615802e-06 ]\n", + " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", + " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3714279702981003e-05 ]\n", + " Martin lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.784412678622175e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.796097967599053e-05 ]\n", + " John lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.1097308490425348e-05 ]\n", + " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.1637800930184312e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1344003496560617e-06 ]\n", + " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.5707594179257285e-06 ]\n", + " Sarah lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.629943295090925e-06 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.796097967599053e-05 ]\n", + " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.175311450031586e-06 ]\n", + " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", + " Martin lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3855085853720084e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2665129361266736e-05 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.211084953771206e-06 ]\n", + " Sarah lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.2684488360246178e-06 ]\n", + " Rachel lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.995898153647431e-07 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.30380283028353e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n", + " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7119297101307893e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.060348591243383e-06 ]\n", + " Martin lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.761676842055749e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3579434582643444e-06 ]\n", + " Sarah lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.1958392608212307e-05 ]\n", + " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8824379367288202e-05 ]\n", + " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", + " Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.751972250640392e-06 ]\n", + " Rachel lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6416714743172633e-06 ]\n", + " Martin lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5096428796823602e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Palm Coast, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.279042958747596e-06 ]\n", + " Rachel lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.93247909314232e-06 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.685696568340063e-05 ]\n", + " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", + " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", + " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.102476668776944e-05 ]\n", + " Rachel lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.229522568901302e-06 ]\n", + " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", + " Rachel lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.787422989873448e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.688950063311495e-06 ]\n", + " Dave lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", + " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Boston, WA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.4543639887706377e-07 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.009874378927634e-06 ]\n", + " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7244088869338157e-06 ]\n", + " Dave lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.681404996314086e-05 ]\n", + " Dave lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.942811862449162e-06 ]\n", + " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", + " Dave lives in Seattle, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.766460162703879e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", + " Dave lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.463780972699169e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.1782808491698233e-06 ]\n", + " John lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.581859942234587e-05 ]\n", + " Dave lives in Seattle, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.216414360300405e-06 ]\n", + " Dave lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.491680323961191e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3575058801507112e-05 ]\n", + " Martin lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", + " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", + " Rachel lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.807389920344576e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.839130502252374e-06 ]\n", + " John lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n", + " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.62653189667617e-06 ]\n", + " Martin lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", + " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.284733586246148e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", + " Rachel lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2062064342899248e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.060348591243383e-06 ]\n", + " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", + " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7165631308889715e-06 ]\n", + " Dave lives in Palm Coast, WA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7510302541268175e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8445316527504474e-06 ]\n", + " Sarah lives in Palm Coast, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.567622843547724e-05 ]\n", + " Martin lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3855085853720084e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3579434582643444e-06 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", + " Martin lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.276793778350111e-06 ]\n", + " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", + " Sarah lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3714279702981003e-05 ]\n", + " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", + " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.271564310125541e-06 ]\n", + " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", + " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", + " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", + " Dave lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.687276825483423e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", + " Dave lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.3817009352787863e-06 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.78439948084997e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.4719674810476135e-06 ]\n", + " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " John lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", + " Dave lives in Palm Coast, MA and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.3817009352787863e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.4004607439565007e-06 ]\n", + " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2626491045230068e-05 ]\n", + " Dave lives in Seattle, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.227144801116083e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", + " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", + " John lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.899505489040166e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7474596208776347e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.297439085756196e-06 ]\n", + " Martin lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1502537745400332e-05 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.266794581373688e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4705698959005531e-05 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6120865211632918e-06 ]\n", + " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0484606036698096e-06 ]\n", + " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1344003496560617e-06 ]\n", + " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.94373500967049e-06 ]\n", + " Rachel lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.2577593123714905e-06 ]\n", + " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6842433271667687e-06 ]\n", + " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", + " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Boston, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.856503899944073e-06 ]\n", + " Dave lives in Boston, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.106719148287084e-05 ]\n", + " Dave lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.681404996314086e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.3837108023581095e-06 ]\n", + " John lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", + " John lives in Palm Coast, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1562068721104879e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Boston, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.187527792964829e-06 ]\n", + " Sarah lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.27215319784591e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.920510476338677e-05 ]\n", + " John lives in Palm Coast, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.541747355484404e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.213460488244891e-05 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Boston, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0794499758048914e-05 ]\n", + " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", + " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, WA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0618667147355154e-05 ]\n", + " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", + " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Seattle, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0753000424301717e-05 ]\n", + " Dave lives in Seattle, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4255711903388146e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.901234958902933e-05 ]\n", + " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Seattle, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.29604573987308e-06 ]\n", + " Dave lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", + " Dave lives in Palm Coast, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.749774689116748e-07 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", + " John lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.234447285649367e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", + " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.0485097163837054e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, FL and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7461550669395365e-05 ]\n", + " John lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.32769481651485e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7165631308889715e-06 ]\n", + " Rachel lives in Palm Coast, MA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.762457213771995e-05 ]\n", + " John lives in Palm Coast, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.085239536128938e-05 ]\n", + " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " John lives in Boston, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6938978660618886e-05 ]\n", + " Sarah lives in Boston, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.180361050501233e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.2610599848558195e-06 ]\n", + " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.514104537316598e-05 ]\n", + " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.266794581373688e-06 ]\n", + " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.614117288947455e-07 ]\n", + " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.3662584933626931e-05 ]\n", + " Dave lives in Palm Coast, WA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6444788343505934e-05 ]\n", + " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, MA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.169937791535631e-05 ]\n", + " Martin lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.272200830106158e-06 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Sarah lives in Seattle, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.506133341739769e-06 ]\n", + " Rachel lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.194474513496971e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.234447285649367e-05 ]\n", + " John lives in Palm Coast, FL and is a plumber. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.8762460715370253e-06 ]\n", + " Dave lives in Palm Coast, FL and is a technician. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.749774689116748e-07 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, WA and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.14929467701586e-06 ]\n", + " Martin lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9756529582082294e-05 ]\n", + " Dave lives in Palm Coast, MA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.861600973526947e-05 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", + " Martin lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9756529582082294e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", + " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, WA and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.087251444521826e-06 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Rachel lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.93247909314232e-06 ]\n", + " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Martin lives in Seattle, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.2570653022266924e-05 ]\n", + " Martin lives in Seattle, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.6521782526979223e-05 ]\n", + " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", + " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", + " Dave lives in Palm Coast, WA and is a teacher. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.173955181206111e-06 ]\n", + " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " Dave lives in Boston, WA and is a doctor. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", + " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", + " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", + "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " John lives in Boston, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.135143404302653e-05 ]\n", + " Martin lives in Boston, FL and is a technician. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.3771715405018767e-06 ]\n", + " Dave lives in Seattle, FL and is a teacher. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.463780972699169e-05 ]\n", + " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" + ] + } + ], + "source": [ + "import importlib\n", + "import captum\n", + "\n", + "from captum.attr import ShapleyValueSampling\n", + "\n", + "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", + "\n", + "svs = m.ShapleyValueSampling(model) \n", + "baselines = ProductBaselines(\n", + " {\n", + " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", + " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", + " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", + " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", + " }\n", + ")\n", + "\n", + "sv_llm_attr = LLMAttribution(svs, tokenizer)\n", + "\n", + "inp_feature = TextTemplateFeature(\n", + " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", + " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " baselines=baselines,\n", + "# mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", + ")\n", + "\n", + "\n", + "attr_result_7 = sv_llm_attr.attribute(\n", + " inp_feature, \n", + " target=\"playing golf, hiking, and cooking.\",\n", + "# num_trials=2,\n", + " n_samples=200 # arg to ShapleyValueSampling.attribute\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 538, + "id": "c22f5569", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_7 = LLMAttrViz(**attr_result_7)\n", + "attr_viz_7.plot_seq_attr()\n", + "attr_viz_7.plot_token_attr()" + ] + }, + { + "cell_type": "markdown", + "id": "objective-america", + "metadata": {}, + "source": [ + "Let's now consider a more complex example, where we use the LLM as a few-shot learner to classify sample movie reviews as positive or negative. We apply FeatureAblation to measure the relative impact of the few shot examples. Since the prompt changes slightly in the case that no examples are needed, we define a prompt function rather than a format string in this case." + ] + }, + { + "cell_type": "code", + "execution_count": 649, + "id": "african-accessory", + "metadata": {}, + "outputs": [], + "source": [ + "def prompt_fn(*examples):\n", + " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", + " subset = [elem for elem in examples if elem]\n", + " if not subset:\n", + " prompt = main_prompt\n", + " else:\n", + " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative:\\n\"\n", + " prompt = prefix + \" \\n\".join(subset) + \"\\n \" + main_prompt\n", + " return \"[INST] \" + prompt + \"[/INST]\"" + ] + }, + { + "cell_type": "code", + "execution_count": 650, + "id": "powered-seating", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9719566702842712 ]\n", + "sv shape:: torch.Size([6, 4])\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7624704241752625 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7624704241752625 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.75006502866745 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.75006502866745 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8428921103477478 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9038273692131042 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8428921103477478 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7624704241752625 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7624704241752625 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5533655285835266 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5533655285835266 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.708580493927002 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9063280820846558 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.708580493927002 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.75006502866745 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.75006502866745 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5533655285835266 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5533655285835266 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9048031568527222 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7999224066734314 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9048031568527222 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8428921103477478 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8428921103477478 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.708580493927002 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.708580493927002 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9048031568527222 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9443454146385193 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.9048031568527222 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n" + ] + } + ], + "source": [ + "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", + "\n", + "sv = m.ShapleyValues(model) \n", + "sv_llm_attr = LLMAttribution(sv, tokenizer)\n", + "\n", + "input_examples = [\n", + " \"'The movie was ok, the actors weren't great' Negative\", \n", + " \"'I loved it, it was an amazing story!' Positive\",\n", + " \"'Total waste of time!!' Negative\", \n", + " \"'Won't recommend' Negative\",\n", + "]\n", + "inp_feature = TextTemplateFeature(\n", + " prompt_fn, \n", + " inputs=input_examples,\n", + ")\n", + "\n", + "attr_result_8 = sv_llm_attr.attribute(\n", + " inp_feature, \n", + "# target=\"Positive\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 651, + "id": "bc40b7a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([-0.0413, -0.2751, -0.2085, -0.0399], device='cuda:0')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_8 = LLMAttrViz(**attr_result_8)\n", + "print(attr_viz_8.seq_attr)\n", + "attr_viz_8.plot_seq_attr()\n", + "attr_viz_8.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 652, + "id": "a35b2eb6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4795992076396942 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7636792659759521 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6186960935592651 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5283071994781494 ]\n", + "tensor([ 0.1416, -0.3236, -0.1131, 0.0449], device='cuda:0')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_result_88 = llm_attr.attribute(\n", + " inp_feature, \n", + "# target=\"Positive\"\n", + ")\n", + "attr_viz_88 = LLMAttrViz(**attr_result_88)\n", + "\n", + "print(attr_viz_88.seq_attr)\n", + "attr_viz_88.plot_seq_attr()\n", + "attr_viz_88.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 653, + "id": "abe20b53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 0.1416, -0.3236, -0.1131, 0.0449], device='cuda:0')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "print(attr_viz_88.seq_attr)\n", + "attr_viz_88.plot_seq_attr()\n", + "attr_viz_88.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 645, + "id": "a8d94d9b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8767213225364685 ]\n", + "sv shape:: torch.Size([6, 4])\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.48403507471084595 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7302335500717163 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7861713767051697 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7302335500717163 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6961074471473694 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.48403507471084595 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7302335500717163 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7861713767051697 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6478603482246399 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6075158715248108 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7861713767051697 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7861713767051697 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7302335500717163 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.3068313002586365 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6075158715248108 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6478603482246399 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7302335500717163 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7861713767051697 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.48403507471084595 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7924065589904785 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.48403507471084595 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6478603482246399 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6961074471473694 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8554695248603821 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6075158715248108 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4589369297027588 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6961074471473694 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.7078842520713806 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + " \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6478603482246399 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4492253363132477 ]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + " \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.8861209154129028 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + " \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.6961074471473694 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.4232654273509979 ]\n", + " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", + "'The movie was ok, the actors weren't great' Negative \n", + "'I loved it, it was an amazing story!' Positive \n", + "'Total waste of time!!' Negative \n", + "'Won't recommend' Negative\n", + " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", + "'I really liked the Avengers, it had a captivating plot!'\n", + "Reply only Positive or Negative.[/INST]\n", + " Positive. [prob: 0.5525419116020203 ]\n", + "tensor([-0.1081, -0.4112, -0.0173, 0.0749], device='cuda:0')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "svs = m.ShapleyValueSampling(model) \n", + "svs_llm_attr = LLMAttribution(svs, tokenizer)\n", + "\n", + "attr_result_888 = svs_llm_attr.attribute(\n", + " inp_feature, \n", + "# target=\"Positive\"\n", + ")\n", + "\n", + "attr_viz_888 = LLMAttrViz(**attr_result_888)\n", + "print(attr_viz_888.seq_attr)\n", + "attr_viz_888.plot_seq_attr()\n", + "attr_viz_888.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 405, + "id": "0e505992", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", + " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 1.9094561139354482e-05 ]\n", + " Dave in Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.641148168753716e-06 ]\n", + " Dave lives Palm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 3.978511813329533e-06 ]\n", + " Dave lives inm Coast, FL and is a lawyer. His personal interests include\n", + "playing golf, hiking, and cooking. [prob: 2.6035468181362376e-06 ]\n", " Dave lives in Pal Coast, FL and is a lawyer. His personal interests include\n", "playing golf, hiking, and cooking. [prob: 5.203700766287511e-06 ]\n", " Dave lives in Palm, FL and is a lawyer. His personal interests include\n", @@ -2323,9 +6190,297 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 539, "id": "a2cc305d", "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "530f82aac0db4cdb88697b058d8fd8db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading (…)lve/main/config.json: 0%| | 0.00/665 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "attr_viz_12 = LLMAttrViz(**attr_result_12)\n", + "attr_viz_12.plot_token_attr()" + ] + }, + { + "cell_type": "code", + "execution_count": 547, + "id": "cc32e100", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'input_ids': [44045, 3160, 287, 6182, 11, 8779, 290, 318, 257, 11949, 13, 2332, 2614, 5353, 2291], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}" + ] + }, + "execution_count": 547, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 596, + "id": "ffabc623", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", + "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'input_ids': tensor([[27984, 3160, 287, 18358, 8545, 11, 9977, 290, 318, 257,\n", + " 6853, 13, 2332, 2614, 5353, 2291]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n" + ] + }, + { + "data": { + "text/plain": [ + "'Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include the law, politics'" + ] + }, + "execution_count": 596, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gpt_inps = gpt_tokenizer(\"Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\", return_tensors='pt')\n", + "print(gpt_inps)\n", + "gpt_output = gpt_model.generate(gpt_inps[\"input_ids\"])\n", + "\n", + "gpt_tokenizer.decode(gpt_output[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 584, + "id": "7d457bd1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[ -44.9375, -43.5938, -47.0938, ..., -52.5000, -52.2500,\n", + " -45.3125],\n", + " [-113.3125, -112.9375, -121.3750, ..., -122.9375, -121.0000,\n", + " -115.6250],\n", + " [ -81.3750, -80.0000, -84.9375, ..., -87.1250, -87.3125,\n", + " -82.3750],\n", + " ...,\n", + " [-118.3750, -116.0625, -120.3125, ..., -119.7500, -123.8750,\n", + " -116.3750],\n", + " [ -98.8750, -98.5625, -102.5625, ..., -106.5625, -105.3125,\n", + " -96.6250],\n", + " [ -89.6250, -88.8125, -92.3125, ..., -95.5000, -94.9375,\n", + " -88.5625]]], dtype=torch.float16, grad_fn=)" + ] + }, + "execution_count": 584, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gpt_model(gpt_inps[\"input_ids\"]).logits" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db4abb82", + "metadata": {}, "outputs": [], "source": [] } From e27f934b80886870ac24d9ba00e6ed79e09d79cc Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Tue, 19 Dec 2023 00:08:33 -0800 Subject: [PATCH 07/11] llm attr --- captum/attr/_core/shapley_value.py | 40 ------------------------------ 1 file changed, 40 deletions(-) diff --git a/captum/attr/_core/shapley_value.py b/captum/attr/_core/shapley_value.py index 3ac5c3596d..492ae20464 100644 --- a/captum/attr/_core/shapley_value.py +++ b/captum/attr/_core/shapley_value.py @@ -341,7 +341,6 @@ def attribute( # Initialize attribution totals and counts output_shape = initial_eval.shape -<<<<<<< HEAD # attr shape (*output_shape, *input_feature_shape) total_attrib = [ torch.zeros( @@ -351,24 +350,6 @@ def attribute( ) for input in inputs ] -======= - if agg_output_mode: - total_attrib = [ - torch.zeros_like( - input[0:1], dtype=torch.float - ) - for input in inputs - ] - else: - total_attrib = [ - torch.zeros( - (*output_shape, *input.shape[1:]), dtype=torch.float, device=inputs[0].device - ) - for input in inputs - ] - - print("sv shape::",total_attrib[0].shape) ->>>>>>> 19803159 (llm attr) iter_count = 0 # Iterate for number of samples, generate a permutation of the features @@ -422,7 +403,6 @@ def attribute( prev_results = all_eval[-num_examples:] for j in range(len(total_attrib)): -<<<<<<< HEAD # format eval_diff to shape # (n_perturb, *output_shape, 1,.. 1) # where n_perturb may not be perturb_per_eval @@ -430,26 +410,6 @@ def attribute( # have the same dim as the mask tensor. formatted_eval_diff = eval_diff.reshape( (-1,) + output_shape + (len(inputs[j].shape) - 1) * (1,) -======= - current_eval_diff = eval_diff - if not agg_output_mode: - # current_eval_diff dimensions: - # (#features in batch, #num_examples, 1,.. 1) - # (contains 1 more dimension than inputs). This adds extra - # dimensions of 1 to make the tensor broadcastable with the - # inputs tensor. - # print("inputs[j]", inputs[j].shape) - # print("output_shape", output_shape) - # print("current_eval_diff]", current_eval_diff) - - current_eval_diff = current_eval_diff.reshape( - output_shape + (len(inputs[j].shape) - 1) * (1,) - ) - - # mask in shape (1, 1, 5), remove 1st - total_attrib[j] += ( - current_eval_diff * current_masks[j].squeeze(0).float() ->>>>>>> 19803159 (llm attr) ) # mask in shape (n_perturb, *mask_shape_broadcastable_to_input) From cf4d52056038f9a82e57303b6597f2716e74d130 Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Mon, 1 Jan 2024 02:27:04 -0800 Subject: [PATCH 08/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 6302 ++-------------------------- 1 file changed, 250 insertions(+), 6052 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index 1db693a0a5..a83a87861f 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -1,45 +1,65 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "9bdd6ea2", + "metadata": {}, + "source": [ + "# Use Captum LLM Attribution to understand Llama2\n", + "\n", + "In this tutorial, we will demonstrate the LLM attribution functionality introduced in Captum v0.7, which makes it a breeze to applying the attribution algorithms to interpret the large langague models (LLM) in text generation. The new functionalities include a series utilities that help you with many common tedious scaffolding required by LLMs like defining intepretable features in text input and handling the sequential predictions. You can also check our paper for more details https://arxiv.org/abs/2312.05491\n", + "\n", + "Next, we will use Llama2 (7b-chat) as an example and use both perturbation-based and grandient-based algrithms respectively to see how the input prompts lead to the generated content. First, let's import the needed dependencies. Specifically, from Captum, besides the algorithms `FeatureAblation` and `LayerIntegratedGradients` themselves, we will also import:\n", + "- perturbation-based and gradient-based wrappers for LLM, `LLMAttribution` and `LLMGradientAttribution`\n", + "- text-based interpretable input adapters, `TextTokenInput` and `TextTemplateInput`" + ] + }, { "cell_type": "code", - "execution_count": 408, + "execution_count": 81, "id": "inside-current", "metadata": {}, "outputs": [], "source": [ - "import argparse\n", "import bitsandbytes as bnb\n", - "from functools import partial\n", - "import os\n", - "#from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, AutoPeftModelForCausalLM\n", "import torch\n", - "from typing import Callable, List, Dict, Union, Iterable, Any, Optional\n", - "from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed, Trainer, TrainingArguments, BitsAndBytesConfig, \\\n", - " DataCollatorForLanguageModeling, Trainer, TrainingArguments\n", - "#from datasets import load_dataset\n", + "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n", "import random\n", - "import math\n", "import sys\n", - "from copy import copy\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", "\n", "sys.path.append(\"/home/aoboyang/local/captum\")\n", - "from captum.attr import FeatureAblation, Attribution, LayerIntegratedGradients\n", + "from captum.attr import (\n", + " FeatureAblation, \n", + " ShapleyValues,\n", + " LayerIntegratedGradients, \n", + " LLMAttribution, \n", + " LLMGradientAttribution, \n", + " TextTokenInput, \n", + " TextTemplateInput,\n", + " ProductBaselines,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "6f2695ee", + "metadata": {}, + "source": [ + "## Preparation\n", "\n", - "from captum.attr._core.dataloader_attr import _convert_output_shape" + "Let's make a helper function to load models through Huggingface. We will also add an extra step for 4-bits quantization which can effectively reduce the GPU memory consumption. Now, we can use them to load \"Llama-2-7b-chat\"." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "driven-privacy", "metadata": {}, "outputs": [], "source": [ "def load_model(model_name, bnb_config):\n", " n_gpus = torch.cuda.device_count()\n", - " max_memory = f'{10000}MB'\n", + " max_memory = \"10000MB\"\n", "\n", " model = AutoModelForCausalLM.from_pretrained(\n", " model_name,\n", @@ -52,16 +72,8 @@ " # Needed for LLaMA tokenizer\n", " tokenizer.pad_token = tokenizer.eos_token\n", "\n", - " return model, tokenizer\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "pleasant-tracy", - "metadata": {}, - "outputs": [], - "source": [ + " return model, tokenizer\n", + "\n", "def create_bnb_config():\n", " bnb_config = BitsAndBytesConfig(\n", " load_in_4bit=True,\n", @@ -70,33 +82,19 @@ " bnb_4bit_compute_dtype=torch.bfloat16,\n", " )\n", "\n", - " return bnb_config\n" + " return bnb_config" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 59, "id": "exclusive-ministry", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3dd4b2ff9fd54d57ba6aad6298ac0bdf", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading (…)fetensors.index.json: 0%| | 0.00/33.4k [00:00', '▁Dave', '▁lives', '▁in', '▁Pal', 'm', '▁Coast', ',', '▁F', 'L', '▁and', '▁is', '▁a', '▁lawyer', '.', '▁His', '▁personal', '▁interests', '▁include', '▁playing', '▁guitar', ',', '▁h', 'ik', 'ing', ',', '▁and', '▁sp', 'ending', '▁time', '▁with', '▁his', '▁family', '.']\n" + "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include playing guitar, hiking, and spending time with his family.\n" ] } ], @@ -260,724 +182,215 @@ "eval_prompt = \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\"\n", "\n", "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", - "print(model_input)\n", "model.eval()\n", "with torch.no_grad():\n", - " print(model_input[\"input_ids\"])\n", " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=15)[0]\n", - " print(output_ids)\n", " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", - " print(response)\n", - " print(tokenizer.convert_ids_to_tokens(output_ids))" + " print(response)" ] }, { - "cell_type": "code", - "execution_count": 654, - "id": "bb032c18", + "cell_type": "markdown", + "id": "urban-insight", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[INST] Help me rewrite the following sentence.\n", - "\n", - "Table 1 presents the results, where the positive and negative value means the feature token increases and decreases respectively the LLM's probability of outputting the corresponding interest [/INST] Sure! Here's a possible rewrite of the sentence:\n", - "\n", - "Table 1 displays the results, where positive and negative values indicate that the feature token increases and decreases, respectively, the language model's (LLM's) [INST] Try again. [INST] Sure! Here's another possible rewrite of the sentence:\n", - "\n", - "Table 1 shows the effects of each feature token on the LLM's probability of outputting the corresponding interest, with positive and negative values indicating increases and decreases,\n", - "['', '▁[', 'INST', ']', '▁Help', '▁me', '▁rewrite', '▁the', '▁following', '▁sentence', '.', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁presents', '▁the', '▁results', ',', '▁where', '▁the', '▁positive', '▁and', '▁negative', '▁value', '▁means', '▁the', '▁feature', '▁token', '▁increases', '▁and', '▁decre', 'ases', '▁respectively', '▁the', '▁L', 'LM', \"'\", 's', '▁probability', '▁of', '▁output', 'ting', '▁the', '▁corresponding', '▁interest', '▁[', '/', 'INST', ']', '▁', '▁Sure', '!', '▁Here', \"'\", 's', '▁a', '▁possible', '▁rewrite', '▁of', '▁the', '▁sentence', ':', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁displays', '▁the', '▁results', ',', '▁where', '▁positive', '▁and', '▁negative', '▁values', '▁indicate', '▁that', '▁the', '▁feature', '▁token', '▁increases', '▁and', '▁decre', 'ases', ',', '▁respectively', ',', '▁the', '▁language', '▁model', \"'\", 's', '▁(', 'LL', 'M', \"'\", 's', ')', '', '', '▁', '▁[', 'INST', ']', '▁Try', '▁again', '.', '▁[', 'INST', ']', '▁', '▁Sure', '!', '▁Here', \"'\", 's', '▁another', '▁possible', '▁rewrite', '▁of', '▁the', '▁sentence', ':', '<0x0A>', '<0x0A>', 'Table', '▁', '1', '▁shows', '▁the', '▁effects', '▁of', '▁each', '▁feature', '▁token', '▁on', '▁the', '▁L', 'LM', \"'\", 's', '▁probability', '▁of', '▁output', 'ting', '▁the', '▁corresponding', '▁interest', ',', '▁with', '▁positive', '▁and', '▁negative', '▁values', '▁indicating', '▁increases', '▁and', '▁decre', 'ases', ',']\n" - ] - } - ], "source": [ - "eval_prompt = \"[INST] Help me rewrite the following sentence.\\n\\nTable 1 presents the results, where the positive and negative value means the feature token increases and decreases respectively the LLM's probability of outputting the corresponding interest [/INST]\"\n", - "\n", - "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + "## Perturbation-based Attribution\n", "\n", - "model.eval()\n", - "with torch.no_grad():\n", - " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=50)[0]\n", - " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", - " \n", - " eval_prompt = response + \" [INST] Try again. [INST]\"\n", - " \n", - " model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", - " \n", - " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=50)[0]\n", - " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", - " \n", - " print(response)\n", - " print(tokenizer.convert_ids_to_tokens(output_ids))" + "OK now, the model is working and has completed the given prompt by producing several possible interests. To understand how the model prodcues them based on the prompt, we will first use the perturbation-based algrotihms from Captum to understand the generation. We can start with the simplest `FeatureAblation`, which ablates each of the features of this string to see how it affects the predicted probability of the target string. The way is the same as before: feed the model into the corresponding constrcutor to initiate the attribution method. But additionally, to help it work with text-based input and output, we need to wrap it with the new `LLMAttribution` class." ] }, { "cell_type": "code", - "execution_count": null, - "id": "30205531", + "execution_count": 63, + "id": "hairy-seeking", "metadata": {}, "outputs": [], "source": [ - "eval_prompt = \"spending\"\n", - "\n", - "model_input = tokenizer(eval_prompt, return_tensors=\"pt\").to(\"cuda\")\n", + "fa = FeatureAblation(model)\n", "\n", - "model.eval()\n", - "with torch.no_grad():\n", - " print(model_input[\"input_ids\"])\n", - " output_ids = model.generate(model_input[\"input_ids\"], max_new_tokens=15)[0]\n", - " print(output_ids)\n", - " response = tokenizer.decode(output_ids, skip_special_tokens=True)\n", - " print(response)\n", - " print(tokenizer.convert_ids_to_tokens(output_ids))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "68a7c1ea", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "device(type='cuda', index=0)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.device" + "llm_attr = LLMAttribution(fa, tokenizer)" ] }, { "cell_type": "markdown", - "id": "dd27aeb1", + "id": "494d2a02", "metadata": {}, "source": [ - "Vizualize" + "The newly created `llm_attr` is the same as the wrapped attribution method instance which provides an `.attribute()` function taking the model inputs and returns the attribution scores of cared features within the inputs. However, by default, Captum's attribution algorithms assume each input into the model must be PyTorch tensors and perturb them at tensor level. This is likely not what we want for LLM, where we are more interested in the interpretable text input and making text modifications like removing a text segment, than a less meaningful tensor of token indices. To solve this, we introduce a new adapter design called `InterpretableInput` which handles the conversion between more interpretable input type and tensor, and tells Captum how to work with them. `llm_attr` is made to accept certain text-based `InterpretableInput` as the arguements. The concept of \"Interpretable Input\" mainly comes from the following two papers:\n", + "- [“Why Should I Trust You?”: Explaining the Predictions of Any Classifier](https://arxiv.org/abs/1602.04938)\n", + "- [A Unified Approach to Interpreting Model Predictions](https://arxiv.org/abs/1705.07874)\n", + "\n", + "The question now is what are the intepretable features we want to understand in text. One most common and straightforward answer is \"tokens\". And we provide `TextTokenInput` specifically for such use cases. `TextTokenInput` is an `InterpretableInput` for text whose interpretable features are the tokens with respect to a given tokenizer. So let's create one and calculate its attribution w.r.t the previous generated output as the target:" ] }, { "cell_type": "code", - "execution_count": 338, - "id": "1e648344", + "execution_count": 68, + "id": "5be9d42e", "metadata": {}, "outputs": [], "source": [ - "class LLMAttrViz:\n", - " def __init__(self, seq_attr, token_attr, input_tokens, output_tokens):\n", - " self.seq_attr = seq_attr\n", - " self.token_attr = token_attr\n", - " self.input_tokens = input_tokens\n", - " self.output_tokens = output_tokens\n", - " \n", - " @property\n", - " def seq_attr_dict(self):\n", - " return {k: v for v, k in zip(self.seq_attr.cpu().tolist(), self.input_tokens)}\n", - " \n", - " def plot_token_attr(self):\n", - " token_attr = self.token_attr.cpu()\n", - " \n", - " # maximum absolute attribution value\n", - " # used as the boundary of normalization\n", - " # always keep 0 as the mid point to differentiate pos/neg attr\n", - " max_abs_attr_val = max([\n", - " token_attr.max().abs().item(), \n", - " token_attr.min().abs().item()\n", - " ])\n", - " \n", - " fig, ax = plt.subplots()\n", - " \n", - " # Plot the heatmap\n", - " data = token_attr.numpy()\n", - " \n", - " fig.set_size_inches(max(data.shape[1] * 1.3, 6.4), max(data.shape[0] / 2.5, 4.8))\n", - " im = ax.imshow(\n", - " data,\n", - " vmax=max_abs_attr_val,\n", - " vmin=-max_abs_attr_val,\n", - " cmap=\"RdYlGn\",\n", - " aspect=\"auto\"\n", - " )\n", - "\n", - " # Create colorbar\n", - " cbar = ax.figure.colorbar(im, ax=ax)\n", - " cbar.ax.set_ylabel(\"Token Attribuiton\", rotation=-90, va=\"bottom\")\n", - "\n", - " # Show all ticks and label them with the respective list entries.\n", - " ax.set_xticks(np.arange(data.shape[1]), labels=self.input_tokens)\n", - " ax.set_yticks(np.arange(data.shape[0]), labels=self.output_tokens)\n", - "\n", - " # Let the horizontal axes labeling appear on top.\n", - " ax.tick_params(top=True, bottom=False,\n", - " labeltop=True, labelbottom=False)\n", - "\n", - " # Rotate the tick labels and set their alignment.\n", - " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", - " rotation_mode=\"anchor\")\n", - " \n", - " # Loop over the data and create a `Text` for each \"pixel\".\n", - " # Change the text's color depending on the data.\n", - " for i in range(data.shape[0]):\n", - " for j in range(data.shape[1]):\n", - " val = data[i, j]\n", - " color = \"black\" if 0.2 < im.norm(val) < 0.8 else \"white\"\n", - " im.axes.text(\n", - " j, \n", - " i, \n", - " \"%.4f\" % val,\n", - " horizontalalignment=\"center\",\n", - " verticalalignment=\"center\",\n", - " color=color,\n", - " )\n", - " \n", - " plt.show()\n", - " \n", - " def plot_seq_attr(self): \n", - " fig, ax = plt.subplots()\n", - "\n", - " data = self.seq_attr.cpu().numpy()\n", - " \n", - " ax.set_xticks(range(data.shape[0]), labels=self.input_tokens)\n", - "\n", - " ax.tick_params(top=True, bottom=False,\n", - " labeltop=True, labelbottom=False)\n", - "\n", - " plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n", - " rotation_mode=\"anchor\")\n", - " # Example data\n", - " people = ('Tom', 'Dick', 'Harry', 'Slim', 'Jim')\n", - "\n", - " # pos bar\n", - " ax.bar(range(data.shape[0]), [max(v, 0) for v in data], align=\"center\", color=\"g\")\n", - " # neg bar\n", - " ax.bar(range(data.shape[0]), [min(v, 0) for v in data], align=\"center\", color=\"r\")\n", + "inp = TextTokenInput(\n", + " eval_prompt, \n", + " tokenizer,\n", + " skip_tokens=[1], # skip special token for the start of the text\n", + ")\n", "\n", - " ax.set_ylabel(\"Sequence Attribuiton\", rotation=90, va=\"bottom\")\n", + "target = \"playing guitar, hiking, and spending time with his family.\"\n", "\n", - " plt.show()" + "attr_res = llm_attr.attribute(inp, target=target)" ] }, { "cell_type": "markdown", - "id": "180bdf46", + "id": "53921fcb", "metadata": {}, "source": [ - "`SampleBaselines` class define the case that there are multiple possible baselines over certain data distribution" + "With just a few lines of codes, we now get the `FeatureAblation` attribution result of our LLM. The return contains the attribution tensors to both the entire generated target seqeuence and each generated token, which tell us how each input token impact the output and each token within it." ] }, { "cell_type": "code", - "execution_count": 286, - "id": "e6ef376e", + "execution_count": 69, + "id": "dc68909e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "attr to the output sequence: torch.Size([18])\n", + "attr to the output tokens: torch.Size([15, 18])\n" + ] + } + ], "source": [ - "class SampleBaselines:\n", - " \"\"\"\n", - " Abstract class for baselines from samples of training data\n", - " \"\"\"\n", - " def sample(self):\n", - " pass\n", - " \n", - "\n", - "class IterableBaselines(SampleBaselines):\n", - " \"\"\"\n", - " Baselines defined in an iterable\n", - " \"\"\"\n", - " \n", - " def __init__(\n", - " self, \n", - " iterable_baselines: Iterable[Any], \n", - " weights: Optional[Iterable[float]] = None,\n", - " ):\n", - " self.baseline_list = list(iter(iterable_baselines))\n", - " if weights is not None:\n", - " weights = list(iter(weights))\n", - " \n", - " self.weights = weights\n", - " \n", - " def sample(self):\n", - " return random.choices(self.baseline_list, weights=self.weights)[0]\n", - " \n", - " \n", - "\n", - "class ProductBaselines(SampleBaselines):\n", - " \"\"\"\n", - " Sample product of feature baselines\n", - " \"\"\"\n", - " \n", - " def __init__(\n", - " self, \n", - " feature_baselines: Union[List[List[str]], Dict[str, List[str]]], \n", - " feature_weights: Union[List[List[float]], Dict[str, List[float]]] = None, \n", - " ):\n", - " self.feature_baselines = feature_baselines\n", - " \n", - " self.feature_weights = feature_weights\n", - " \n", - " def sample(self):\n", - " feature_baselines = self.feature_baselines\n", - " feature_weights = self.feature_weights\n", - " \n", - " if type(feature_baselines) is list:\n", - " return [\n", - " random.choices(\n", - " l, \n", - " weights=(None if feature_weights is None else feature_weights[i])\n", - " )[0]\n", - " for i, l in enumerate(feature_baselines)\n", - " ]\n", - " else:\n", - " return {\n", - " k: random.choices(\n", - " l, \n", - " weights=(None if feature_weights is None else feature_weights[k])\n", - " )[0]\n", - " for k, l in feature_baselines.items()\n", - " }\n", - " " + "print(\"attr to the output sequence:\", attr_res.seq_attr.shape) # shape(n_input_token)\n", + "print(\"attr to the output tokens:\", attr_res.token_attr.shape) # shape(n_output_token, n_input_token)" ] }, { "cell_type": "markdown", - "id": "c95ac3e8", + "id": "eacfb8f1", "metadata": {}, "source": [ - "`InterpretableFeature` defines the feature type and tells Captum how to perturb the input data" + "It also provides the utilities to visualize the results. Next we will plot the token attribution to view the relations between input and output tokens. As we will see, the result is generally very positive. This is expected, since the target, \"playing guitar, hiking, and spending time with his family\", is what the model feel confident to generate by itself given the input tokens. So change in the input is more likely divert the model from this target." ] }, { "cell_type": "code", - "execution_count": 473, - "id": "d2798ec5", + "execution_count": 70, + "id": "0aebdd52", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "class InterpretableFeature:\n", - " \"\"\"\n", - " Interpretable feature adapter for different kinds of model inputs\n", - " to make Captum understand how to perturb the inputs\n", - " \"\"\"\n", - " def to_model_input(perturbed_tensor=None):\n", - " \"\"\"\n", - " Convert perturbed interpretable tensor into the perturbed input in the format required by the model\n", - " if perturbed tensor is not provided, return the orignal input\n", - " \"\"\"\n", - " pass\n", - " \n", - " def to_input_shape(interpretable_attr):\n", - " \"\"\"\n", - " Convert attribution of intepretable feature shape to raw input shape\n", - " \"\"\"\n", - " pass\n", - " \n", - "\n", - "class TextTemplateFeature(InterpretableFeature):\n", - " def __init__(\n", - " self,\n", - " template: Union[str, Callable],\n", - " inputs: Union[List[str], Dict[str, str]],\n", - " baselines: Union[List[str], Dict[str, str], \"SampleBaselines\", None] = None,\n", - " mask: Union[List[int], Dict[str, int], None] = None\n", - " ):\n", - " self.dict_keys = list(inputs.keys()) if type(inputs) is dict else None\n", - " \n", - " n_features = len(inputs)\n", - " \n", - " if baselines is None:\n", - " # default baseline is to remove the element\n", - " baselines = [\"\"] * len(inputs) \n", - " elif type(baselines) is dict:\n", - " # convert dict to list\n", - " baselines = [baselines[k] for k in self.dict_keys]\n", - " \n", - " if mask is None:\n", - " n_interpretable_features = n_features\n", - " else:\n", - " if self.dict_keys:\n", - " # convert dict to list\n", - " mask = [mask[k] for k in self.dict_keys]\n", - " \n", - " mask_ids = set(_ for _ in mask)\n", - " mask_id_to_idx = {mid: i for i, mid in enumerate(mask_ids)}\n", - " \n", - " # internal compressed mask of continuous interpretable feature indices from 0\n", - " # cannot replace original mask of ids for grouping across inputs externally\n", - " self.formatted_mask = [mask_id_to_idx[mid] for mid in mask]\n", - " \n", - " n_interpretable_features = len(mask_ids)\n", - " \n", - " # number of raw features and intepretable features\n", - " self.n_features = n_features\n", - " self.n_interpretable_features = n_interpretable_features\n", - " \n", - " # Init Interpretable representation in shape(1, n_interpretable_features)\n", - " self.interpretable_tensor = torch.tensor([[1.0] * n_interpretable_features])\n", - " \n", - " self.format_fn = template.format if isinstance(template, str) else template\n", - " \n", - " \n", - " if type(inputs) is dict:\n", - " # convert dict to list\n", - " inputs = [inputs[k] for k in self.dict_keys]\n", - " \n", - " # need better naming\n", - " self.inputs = inputs\n", - " \n", - " self.baselines = baselines\n", - " self.mask = mask\n", - " \n", - " \n", - " def to_model_input(self, perturbed_tensor=None):\n", - " inputs = [_ for _ in self.inputs] # clone\n", - " \n", - " if perturbed_tensor is not None:\n", - " baselines = self.baselines\n", - " if isinstance(baselines, SampleBaselines):\n", - " baselines = self.baselines.sample()\n", - " if self.dict_keys:\n", - " baselines = [baselines[k] for k in self.dict_keys]\n", - " \n", - " for i in range(len(inputs)):\n", - " interpretable_idx = i\n", - " if self.mask:\n", - " interpretable_idx = self.formatted_mask[i]\n", - " \n", - " interpretable_val = perturbed_tensor[0][interpretable_idx]\n", - " \n", - " if not interpretable_val:\n", - " inputs[i] = baselines[i]\n", - " \n", - " \n", - " if self.dict_keys:\n", - " inputs = {k: v for k, v in zip(self.dict_keys, inputs)}\n", - " input_str = self.format_fn(**inputs)\n", - " else:\n", - " input_str = self.format_fn(*inputs)\n", - " \n", - " return input_str\n", - "\n", - " def to_input_shape(self, interpretable_attr: torch.Tensor):\n", - " if self.mask is None:\n", - " return interpretable_attr\n", - " \n", - " device = interpretable_attr.device\n", - " \n", - " formatted_attr = _convert_output_shape(\n", - " interpretable_attr, # shape(*output_dims, n_interpretable_features)\n", - " (torch.zeros([1, self.n_features], device=device),), # fake input tensor\n", - " (torch.tensor([self.formatted_mask], device=device),)\n", - " )\n", - " return formatted_attr[0]\n", - " \n", - "class IdFeature(InterpretableFeature):\n", - " pass\n", - "\n", - "\n", - "class TextTokenFeature(IdFeature):\n", - " def __init__(\n", - " self, \n", - " text: str, \n", - " tokenizer, \n", - " baselines: Union[int, str] = 0, # usually UNK\n", - " skip_tokens: Union[List[int], List[str], None] = None,\n", - " ):\n", - " inp_tensor = tokenizer.encode(text, return_tensors=\"pt\")\n", - " \n", - " self.inp_tensor = inp_tensor\n", - " self.interpretable_tensor = inp_tensor\n", - " self.interpretable_mask = None\n", - " \n", - " if skip_tokens:\n", - " self.skip_tokens = set(skip_tokens)\n", - " interpretable_mask = torch.zeros_like(inp_tensor)\n", - " interpretable_mask.map_(inp_tensor, lambda _, v: v not in self.skip_tokens)\n", - " interpretable_mask = interpretable_mask.bool()\n", - " \n", - " interpretable_tensor = inp_tensor[interpretable_mask].unsqueeze(0)\n", - " \n", - " self.interpretable_tensor = interpretable_tensor\n", - " self.interpretable_mask = interpretable_mask\n", - " \n", - " self.inputs = tokenizer.convert_ids_to_tokens(self.interpretable_tensor[0])\n", - " \n", - " self.tokenizer = tokenizer\n", - " \n", - " # may diff in future if we allow filtering tokens\n", - " self.n_features = len(self.inputs)\n", - " self.n_interpretable_features = len(self.inputs)\n", - "\n", - " self.baselines = baselines if type(baselines) is int else tokenizer.convert_tokens_to_ids(baselines)\n", - " \n", - " def to_model_input(self, perturbed_tensor=None):\n", - " if perturbed_tensor is None:\n", - " return self.inp_tensor\n", - " \n", - " device = perturbed_tensor.device\n", - " \n", - " perturb_mask = (perturbed_tensor != self.interpretable_tensor.to(device))\n", - " \n", - " perturbed_tensor = perturbed_tensor * ~perturb_mask\n", - " perturbed_tensor[perturb_mask] = self.baselines\n", - " \n", - " perturbed_tensor = perturbed_tensor.detach()\n", - " \n", - " if self.interpretable_mask is not None:\n", - "# print(1, self.inp_tensor.shape)\n", - "# print(2, self.interpretable_mask.shape)\n", - " perturb_inp_shape = (perturbed_tensor.size(0), -1)\n", - " perturb_inp_tensor = self.inp_tensor.expand(*perturb_inp_shape).to(device)\n", - " interpretable_mask = self.interpretable_mask.expand(*perturb_inp_shape).to(device)\n", - "# print(3, perturb_inp_tensor.shape)\n", - "# print(4, interpretable_mask.shape)\n", - " \n", - "# print(5, perturbed_tensor.shape)\n", - " perturb_inp_tensor[interpretable_mask] = perturbed_tensor.view(-1)\n", - " \n", - " return perturb_inp_tensor\n", - " \n", - " return perturbed_tensor\n", - " \n", - " def to_input_shape(self, interpretable_attr: torch.Tensor):\n", - " return interpretable_attr\n", - " \n", - " \n", - " " + "attr_res.plot_token_attr()" ] }, { "cell_type": "markdown", - "id": "urban-insight", + "id": "4f039697", "metadata": {}, "source": [ - "We see that the first predicted interest is \"playing golf\". We would like to better understand the cause of this. For instance, is it related to the city, state, name or pronoun? \n", + "However, it may not always make sense to define individual token as intepretable features and perturb it. Tokenizers used in modern LLMs may break a single word making the tokens not intepretable by themselves. For example, in our case above, the tokenizer can break the word \"Palm\" into \"_Pal\" and \"m\". It doesn't make much sense to study the separate attribution of them. Moreover, even a whole word can be meaningless. For example, \"Palm Coast\" together result in a city name. Changing just partial of its tokens would likely not give anything belongs to the natural distribution of potential cities in Florida, which may lead to unexpected impacts on the perturbed model output.\n", + "\n", + "Therefore, Captum offers another more customizable interpretable input class, `TextTemplateInput`, whose interpretable features are certain segments (e.g., words, phrases) of the text defined by the users. For instance, our prompt above contains information about name, city, state, occupation, and pronoun. Let's define them as the interpretable features to get their attribution. \n", "\n", - "We will use Captum and the LLM Attribution wrapper defined below to better understand this question." + "The target to interpret can be any potential generations that we are interested in. Next, we will customize the target to something else." ] }, { "cell_type": "code", - "execution_count": 585, - "id": "theoretical-cassette", + "execution_count": 75, + "id": "0673a936", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "class LLMAttribution(Attribution):\n", - " def __init__(\n", - " self, \n", - " attr_method, \n", - " tokenizer, \n", - " init_kwargs=None, \n", - " attr_kwargs=None, \n", - " max_new_tokens=15,\n", - " attr_type: str = \"log_prob\", # or prob\n", - " ):\n", - " \"\"\"\n", - " attr_method: perturbation attribution instance crteated with a llm model huggingface style interface\n", - " tokenizer: required\n", - " \"\"\"\n", - "# assert (\n", - "# type(attr_method) in SUPPORTED_METHODS\n", - "# ), f\"LLMAttribution does not support {type(attr_method)}\"\n", - "\n", - " super().__init__(attr_method.forward_func)\n", + "inp = TextTemplateInput(\n", + " template=\"{} lives in {}, {} and is a {}. {} personal interests include\", \n", + " values=[\"Dave\", \"Palm Coast\", \"FL\", \"lawyer\", \"His\"],\n", + ")\n", "\n", - " # shallow copy is enough to avoid modifying original instance\n", - " self.attr_method = copy(attr_method)\n", + "target = \"playing golf, hiking, and cooking.\"\n", "\n", - " self.attr_method.forward_func = self._forward_func\n", - " \n", - " # alias\n", - " self.model = self.forward_func\n", - " \n", - " self.tokenizer = tokenizer\n", - " self.device = self.model.device\n", - " \n", - " # only when attr target is not given\n", - " self.max_new_tokens = max_new_tokens\n", - " \n", - " self.attr_type = attr_type\n", - " \n", - " \n", - " def _forward_func(self, perturbed_feature, input_feature, target_tokens, log_trials):\n", - " perturbed_input = self._format_model_input(input_feature.to_model_input(perturbed_feature))\n", - " init_model_inp = perturbed_input\n", - " \n", - " model_inp = init_model_inp\n", - " \n", - " log_prob_list = []\n", - " for target_token in target_tokens:\n", - " output_logits = self.model.forward(\n", - " model_inp, \n", - " attention_mask=torch.tensor([[1] * model_inp.shape[1]])\n", - " )\n", - " new_token_logits = output_logits.logits[:, -1]\n", - " log_probs = torch.nn.functional.log_softmax(new_token_logits, dim=1)\n", - " \n", - " log_prob_list.append(log_probs[0][target_token].detach())\n", - " \n", - " model_inp = torch.cat((model_inp, torch.tensor([[target_token]]).to(self.device)), dim=1)\n", - " \n", - " total_log_prob = sum(log_prob_list)\n", - " # 1st dim is the total prob, rest are the target tokens\n", - " target_log_probs = torch.stack([total_log_prob, *log_prob_list], dim=0)\n", - " target_probs = torch.exp(target_log_probs)\n", - " \n", - " if log_trials:\n", - " prompt = self.tokenizer.decode(init_model_inp[0])\n", - " response = self.tokenizer.decode(target_tokens)\n", - " print(prompt)\n", - " print(response, \"[prob:\", target_probs[0].item(), \"]\")\n", - " \n", - " return target_probs if self.attr_type != \"log_prob\" else target_log_probs\n", - " \n", - " def _format_model_input(self, model_input):\n", - " \"\"\"\n", - " Convert str to tokenized tensor\n", - " \"\"\"\n", - " # return tensor(1, n_tokens)\n", - " if type(model_input) is str:\n", - " return self.tokenizer.encode(model_input, return_tensors=\"pt\").to(self.device)\n", - " return model_input.to(self.device)\n", - " \n", - " def attribute(\n", - " self, \n", - " input_feature: Union[\"TextTemplateFeature\", \"TextFeature\", \"IdFeature\"], \n", - " target: Union[str, torch.Tensor, None] = None, \n", - " num_trials: int = 1, \n", - " log_trials=True,\n", - " **kwargs,\n", - " ):\n", - " if type(target) is str:\n", - " # exclude sos\n", - " target_tokens = self.tokenizer.encode(target)[1:]\n", - " elif type(target) is torch.Tensor:\n", - " target_tokens = target\n", - " else:\n", - " # generate when None\n", - " model_inp = self._format_model_input(input_feature.to_model_input())\n", - " output_tokens = self.model.generate(model_inp, max_new_tokens=self.max_new_tokens)\n", - " target_tokens = output_tokens[0][model_inp.size(1):]\n", - " \n", - " attr = torch.zeros(\n", - " [1 + len(target_tokens), input_feature.n_interpretable_features], \n", - " dtype=torch.float, \n", - " device=self.device\n", - " )\n", - " \n", - " for i in range(num_trials): \n", - " attr_input = input_feature.interpretable_tensor.to(self.device)\n", - " \n", - " cur_attr = self.attr_method.attribute(\n", - " attr_input, \n", - " additional_forward_args=(input_feature, target_tokens, log_trials),\n", - " **kwargs\n", - " )\n", + "attr_res = llm_attr.attribute(inp, target=target)\n", "\n", - " attr += cur_attr\n", - " \n", - " attr = (attr / num_trials) \n", - " \n", - " attr = input_feature.to_input_shape(attr)\n", - " \n", - " return {\n", - " \"seq_attr\": attr[0],\n", - " \"token_attr\": attr[1:], # shape(n_output_token, n_input_features)\n", - " \"input_tokens\": input_feature.inputs,\n", - " \"output_tokens\": self.tokenizer.convert_ids_to_tokens(target_tokens)\n", - " }" + "attr_res.plot_token_attr()" ] }, { "cell_type": "markdown", - "id": "adaptive-crazy", - "metadata": {}, - "source": [ - "We will first construct an LLMAttribution object using FeatureAblation, and ablate each of the aspects of this string to see how it affects the predicted probability of the target string. For ablation, we define a set of baseline tokens which we use to compare with the original." - ] - }, - { - "cell_type": "code", - "execution_count": 616, - "id": "hairy-seeking", + "id": "56535322", "metadata": {}, - "outputs": [], "source": [ - "fa = FeatureAblation(model)\n", + "We know that perturbation-based algrotihms calculate the attribution by switching the features between \"presence\" and \"absence\" states. So what should a text feature look like here when it is in \"absence\" in the above example? Captum allows users to set the baselines, i.e., the reference values, to use when a feature is absent. By default, `TextTemplateInput` uses empty string `''` as the baselines for all, which is equivalent to the removal of the segments. This may not be perfect for the same out-of-distribution reason. For example, when the feature \"name\" is absent, the prompt loses its subjective and no longer makes much sense. \n", "\n", - "llm_attr = LLMAttribution(fa, tokenizer)" + "To improve it, let's manually set the baselines to something that still fit the context of the original text and keep it within the natural data distribution." ] }, { "cell_type": "code", - "execution_count": 255, + "execution_count": 77, "id": "lined-eating", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - "Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - "Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n" - ] - } - ], - "source": [ - "inp_feature = TextTemplateFeature(\n", - " \"{} lives in {}, {} and is a {}. {} personal interests include\", \n", - " inputs=[\"Dave\", \"Palm Coast\", \"FL\", \"lawyer\", \"His\"],\n", - " baselines=[\"Sarah\", \"Seattle\", \"WA\", \"doctor\", \"Her\"],\n", - ")\n", - "\n", - "attr_result = llm_attr.attribute(inp_feature, target=\"playing golf, hiking, and cooking.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 256, - "id": "05965f80", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Dave': 0.09586238861083984, 'Palm Coast': -0.5810728073120117, 'FL': -0.17151927947998047, 'lawyer': -0.519902229309082, 'His': 1.2632627487182617}\n" - ] - }, { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "(
, )" ] }, + "execution_count": 77, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAHCCAYAAADcsdxaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVgU2xvA8e/SiHSDIKBImWBhd7fXa3deu1uv3YHd3Xrt7u7C7kQp6VJyfn/wY3UFLEBAzud59tGdOXP2zDC7++57zpyRSZIkIQiCIAiCIKQrpcxugCAIgiAIwp9IBFmCIAiCIAgZQARZgiAIgiAIGUAEWYIgCIIgCBlABFmCIAiCIAgZQARZgiAIgiAIGUAEWYIgCIIgCBlABFmCIAiCIAgZQARZgiAIgiAIGUAEWUKaiBsGCIIgCELKRJAlpIlMJgMgISEhk1siCIIgCFmLCLKEXzZu3Dg2bNgAgJKSEpIkicyWIAiCIPyfCLKEX3Lw4EF27dpF+/btsbOz4+TJk8hkMnlmSxAEQRByOhFkCT8tJCSE7du3Y2VlxcOHD/nnn39o1qwZo0ePJjY2VmSzBEEQBAERZAm/YPv27Tx58oRq1arh6OjIkCFDWLJkCVu3buXVq1cimyUIgiAIiCBL+EmvXr1i//792NnZMWDAAPlybW1tvL29uXr1qnyZyGgJgiAIOZlKZjdAyF42bdrEjRs3UFdX59mzZ9jb2xMREcGNGzdISEigYMGC8rIymYz4+HiUlJREdksQBEHIcUSQJfywS5cucfr0aWrUqIGxsTGurq64urqiqqrK5cuXadu2LcWKFWPBggX4+/szYMAADAwMgMSslgi0BEEQhJxEdBcKPyQuLo6tW7eSkJBA7969mTVrFnfv3qVQoUKYm5szb948Zs6cyfv371FWVubmzZvY2dkxb948AIUAKzo6mhMnTmTWrgiCIAjCbyGTxMAZ4QdcvHiRbt26Ua9ePaZPn66wLjo6GnV19WTb7Nq1i2HDhrF+/Xrc3d3ly0+dOkW1atU4duwY1apVy/C2C4IgCEJmEEGW8MNu3ryJhYUF5ubm8hnelZQSk6FhYWH07duXjx8/oq6uzvDhw3F2dqZy5cpUq1aNUaNGAYnTPzRr1gyZTMaxY8cybV8EQRAEIaOJMVnCD3Nzc5P/Pym4Shpr1b59e27evEnnzp15+/YtpUuXplWrVrx8+RIVlcTTLCEhgb1793Lq1Cnu3r0r3z4hIQFlZeXfv0OCIAiCkIFEJktIMz8/PywtLdm2bRtNmzYF4Pbt2zRs2BBJkrh37x56enq8efOGatWqUaVKFZYtW0ZMTAxqamryesTgeEEQBOFPIga+C2mmqqpK5cqVOX78OAChoaHExcURHh5Ojx490NPTIy4ujlWrVvHhwwdmzZoFJF6t2KhRI16+fAl8nvJBxP2CIAjCn0AEWUKaGRgYMGDAAHbv3k25cuXo27cvZcuWxcrKih49egDw4MEDPDw8GDduHNra2gQEBHDkyBH27dvH6dOnGTp0KC9evEBZWVlkswRBEIQ/ggiyhHRRp04d/Pz8GDx4MA0bNiQuLo6xY8diaGjIx48fmT59OpaWlvTv3x+A69evs3DhQipWrEhERAQfPnzAzc2NI0eOKNQbFxeXCXsjCCnz8PBg7969md0MQRCyCTHwXUhXjRo1IiwsjIkTJ1K/fn0Azp07x86dO9m3bx8Ab968YdmyZdjb23P69Gn5tp6enty4cYPKlSvz+PFjihQpIh80LwiZzcfHh2XLltGgQQMaNmyY2c0RBCEbEAPfhQwVFhaGm5sbefLk4fTp08TExLB582b69u3L4cOHKVu2LABeXl40aNCAuLg4HB0d8fHxITg4mB07duDs7JzJeyEI0KlTJ0JCQpg4cSIuLi7Ex8eLq2IFQfgm0V0oZCgdHR3GjRvHmjVrAHjy5AkrVqygXr168gAL4MiRI/j4+NCjRw/mz5/PqVOnsLW1ZebMmZnVdEGQu3HjBrdv36ZWrVq4uLgAoKysTHx8fCa3TBCErEz0xQgZrnXr1gDExMSwZ88eLl++zH///Sdff+fOHfbt24e7uzu9evWSL1dXV8fX15eEhARkMpkYEC9kivj4eEaMGEHhwoX5+++/efv2LW/evKF8+fIoKyvLr4YV56cgCF8TQVYWERgYiL6+vnySzz+RmpoaXbp0oUCBApibmwOJgdfhw4d59uwZq1evlpd9+vQpkZGRFC5cmISEhB8emyUCMiG97dixg8jISJo0aULu3LlZunQp+/btIyoqinnz5lGxYsXMbqIgCFnUn/uNno0kJCTQrVs3LCws8PDwyOzmZChzc3OaN28uf37q1Cm2b99OrVq1KFOmjHz55s2bCQ0NpWLFiqioqKQ6d9adO3c4cuQImzZt4tGjRygpKSGTyeS3/RGEtIiIiGDWrFmUKVOG6tWro6KiQs+ePdm5cycNGzakTZs2bNq0SWEbMcxVEIQkIsjKAk6dOoW/vz9VqlRh/vz5ODg4cOHChcxu1m+ho6ODpqYmAwcOlC87d+4cZ8+epVixYtStWxf43BWTNAbGy8uLfv364e7uTrNmzVi6dCnly5endevWhIWF/dEZQeH3mTFjBnp6enTu3Bk/Pz/27t3LoUOHMDc3Z/z48VSuXJnTp08rBFYiiyoIQhLxTZTJPn78yIIFCzAxMWHz5s28fPmSZs2a0aVLF1avXo0kSX/0L+MyZcpw7tw5rK2tgcTuw+3btyOTyejcuTOAQlYq6Wqunj17sn37dgYPHszbt2/ZsmULBw4cICoqisqVK3P79u3fvzPCH+Xly5ccPHiQ2rVr8+nTJ4oUKcLYsWOZOXMm+fLl47///sPd3Z0rV67Ig/9hw4Yl+4H0J79/BUH4NhFkZbINGzbg5+dHmzZtgMSAYty4cXTs2JHly5cTFBT0x/8y/vIy+CtXrnDq1ClKly4tvyF1UlYq6Ytsy5YtHDx4kG7dujF+/Hj09fXJkycPpUuXZtu2bRQtWpRdu3b9/h0R/igrVqxAW1ubFi1asGDBAhwdHTl79iyHDh2if//+DBw4kF69etGwYUNUVFR4+/Yt169f5+TJkwpXHYrua0HIuUSQlYl8fX3lQUHjxo2BxIBCRUWFFi1a8Pz5c1atWpXJrfy9KlSowLp16+Qzw6eUxZo9ezbu7u60bNlSfr/DJGpqarRp00aeGROEXzV16lRWrFiBpaUlcXFxWFtbo6enh6mpKX369KF58+bkyZOHbt26AcjvXODg4ICysjJPnjxh9uzZhIaGiu5rQcihxNWFmcjDw4PY2Fg6deoEKF4ZlzdvXpSVlYmMjFTYJj4+Xj64+09VokQJ+f+//nJ6+vQpwcHB1K9fH0dHR4BkE0JWrlwZd3f3ZPXGxcWJGeSFH5I00ai9vT2AfJB7z549qVy5MgcPHmTz5s1MmTJFHtBfunQJf39/WrRoASR2aZ8+fZrQ0FAmTJiQafsiCELmET+vMsndu3e5cOEClSpVomTJkoBiQHHgwAEAjIyMkCSJ8+fPEx4eLr+Bck6dBNHS0pKgoCBcXV0BUjwOCQkJaGhoEBUVxaNHjzhz5gzAN69SFIQvfR24N23alJs3b+Lr64uXlxfr16+nQoUKdOrUSf6DZ+PGjXTv3p3nz5/Tr18/bt++TZUqVahZs6a8nmvXrsn//6ePt8wMoltWyGpEkJUJ4uPjGT16NLly5WLQoEHyZUmZrIiICHbt2oWamhpVq1bl6tWrLFy4kEKFCjF+/Hgg+ZdAThAfH4+qqiqFCxdm69atREREKByHpA9YJSUlnj17RqNGjahevTqdO3cmf/78nDt37o/OAAoZQ5Ik4uPjcXZ2ZteuXXTt2hVHR0e6du2KgYEBADdv3sTU1BQlJSVmzpxJcHAwkyZNokCBAhgYGBAaGsrEiRMpXbo0r169Ijg4WMznlo4+fPhAQkKC6JYVshxxRmaC6OhodHV1OXHiBDt37iQuLg5lZWX5B8T8+fM5cuQITZs2xdnZGRcXF5YtW8a8efPYtWsXLVu2JDQ0VKHOnPALTllZGTU1NQYNGoSfn5/8htNJko5fUFAQjRs3Jj4+nnnz5nH16lUaN25Mnz598Pb2zoymC9mYTCZDWVlZ/h7T1tbm4cOH/P333/IyERERvHnzhrlz56KsrMy4cePQ1tbm5cuXODk5MX36dPbu3cuaNWuwtbWlZcuWrF+/PrN26Y+SkJBAjx49+Pvvv4mIiMjs5giCIknINNu3b5fMzc2lggULSh4eHtL48eOl7t27S8rKylKzZs0kPz8/6caNG9LWrVulZ8+eSZIkSdeuXZNsbW2lR48eZXLrM9fUqVMlTU1NqU2bNtKJEyekFStWSGFhYZIkSdL06dMlQ0NDydvbW17e19dXMjc3l9avX59ifXFxcb+l3UL2Fxsbm2zZmDFjJJlMJpUuXVoKDw+XJEmSChcuLK1fv16aO3euVKhQIWnRokXy8lpaWtLWrVslSZKk+Ph4hboSEhIysPV/nhMnTkhly5aVZs2aleL6r4+vIPxOIpOViZo1a4a3tzedOnXi5MmTnDlzhmvXrjF37lzGjBnD7NmzKVGiBIsXL6ZSpUr06NGDXLlyoa+vj6enJwD37t2jf//+OSKT9aXhw4fz7NkzZDIZ8+fP5/Dhw/j6+gKwcOFCevXqhbm5OTExMQDo6+sTGxtL7ty55XVcvnyZ48ePA8jvQSeJMTJpFhgY+EefjyldPNGiRQt69erFkiVLyJ07N5cvX0ZNTQ1PT08GDRrE+PHj5Re4nDp1ivz58+Pk5AR8zsC+fv0aEJOZ/oykeQYtLCzo2LEjoDhOMyoqSnQhCpkrs6M8IVF0dLQUFRUlf+7p6SnJZDJp3759UlBQkHTlyhWpSpUqkoqKiqSlpSUFBwdLkiRJkyZNkgoVKiQFBQUlqzOnZGcCAwOljx8/SpIkSW/fvpUcHR2llStXSpL0OSuwaNEiqXjx4tKBAwckSZKkiIgIqVu3blLBggWlokWLSpcvX86cxv9h4uPjpSZNmkimpqbS3LlzM7s5v0VKmaetW7dKKioqkrW1tfw4JGVULly4INnZ2Un379+XJCkxM7Zy5UrJ2NhY2rBhg0KdIgvzbStXrpTy588v7d69W5KkxM+8pM+9Bw8eSKamptLFixclX19f+bEVhN9JhPhZhJqaGhoaGvLnAQEBmJqa4uzsjL6+PqVKlWLu3LmoqakxfPhw9PT0SEhIQJIkTExMUFdXT1ZnThkcb2BgID92VlZW2NvbyzN9MpmMFy9esGPHDpydnSlbtiwAWlpazJw5k8uXL1O5cmXat2/PxYsXM2sX/hhf3iJq3rx55MuXjxMnTmR2szJUSpONamlpoaOjQ//+/ZPN+Xb27Fly586Ni4sL0dHRjB07lrFjxzJ48GBq1KghrxOST8QrfObr68uGDRsICgqid+/ebNy4EWVlZZSVlfn48SNLliwhISEBd3d3VFVVWbx4MYcPH87sZgs5TWZHeULKfH19pfLly0tOTk7Srl27pBkzZkjFixeXzMzM5FkbSZKksmXLSr169ZI///Tpk7Rp0yapefPmUmRkZGY0PdMk/frfuHGjpKOjI7Vs2VIaMmSIZGRkJFWtWlW6evWqJEmSdPz4cWnBggXSmjVr5NuWLl1aGj16dIr15pSMYFpFRUVJDRs2lP766y8pJiZGkiRJGj9+vCSTyaSxY8fmuKxMRESE/D2YtO+xsbFSnz59pH79+knPnz+X6tevLxUrVkw+XishIUE6fvy4NHjwYKldu3bSsmXLMq39Wd2wYcOkChUqSBcuXJA2bNggWVpaSiVKlJCuXr0qPX36VFJVVZV27dqV2c0UcjgxM2MWZWpqyrlz5xg1ahRbtmwBEi8T37p1qzxr8+rVK0JDQ6lQoYJ8u+HDh3Pp0iUsLS3JlStXsnqTJln8EyX9+m/dujUlSpRg5MiRvH//nvbt2zNp0iQ0NDSYNWsWs2fPpkCBAkRERDBlyhTGjBlDgQIFkCSJmJgY1NTU+PTpE0FBQVhYWChcWSbGd6Ru8+bNPHjwgJkzZ6KqqkpCQgJjx46la9euxMXFsXjxYnLlyiUfm/SnkiSJhIQEtLS05MuUlJRISEhARUWFhIQEDh06REBAAI8fP+bQoUPY2toC0LdvX27fvo2VlRWFCxdmwoQJbNu2jc2bN2NqappZu5TlJM0zWLVqVcqWLUvZsmWpWbMm06dPp3bt2kRFRVGuXDkaN27MzJkzefPmDfPnz5dPmyFJkhj7JvwemRzkCT8gJiZGWrFiheTg4KCw/PHjx5Kjo6N04cIFydvbWxo6dKikrq4ubd26VT6+69atW9LJkyel/fv3y7fLSVcvfXkl2Nu3b6UKFSpIXbp0kWJiYiR/f39p4cKFkp6enmRqairNmzdPkiRJevjwoVS+fHmpePHiUrly5aRbt25lVvOzDR8fH6lixYqSgYGBZGFhkWz8y927d6UqVapItWvXTvHqvD/Zl++3qKgoqWDBgpJMJpNGjhwpXbt2Tb7u3Llzkkwmk0qWLCm9f/9ekqTEbFjFihWldevWJas3p2UGk8TGxkr169eXatWqJb1580a+LMm0adMkmUwmPXr0SHry5Ilkb28vtWrVKsW6RJZayGjiZ3k2oKqqSpcuXbhx4wYAsbGxQGImy8fHB2dnZ/mYorVr19K8eXNCQ0OZPXs2NWvWZOLEifTt25fChQtz69atHPUL7ssrwfLkyUNcXBxGRkaoqqpibGxM8+bNqVSpEnZ2dvIMS9K96CZNmoSbmxtVqlRh0qRJ8nEx58+fZ86cOURHR//+HcqiPDw8kCSJffv2MX36dIYOHYq7uztv374FYNOmTcTExDBo0CB5NienkMlkREZGIkkSo0ePJiYmhj59+jB58mSFW0iNHDmS8uXLY2VlhaOjIyNHjkRLSwtbW1tu374tv/L16tWrQM4drxUTE4O9vT116tTB2tpaniEE8Pb2Zu3atXTv3h1HR0eWLl1KZGQkK1euBODixYusXr2ao0ePAihkqQUhQ2RykCekwfDhwyUDAwOpdOnSUtGiRRV+FU+YMEGysLCQFi5cKElS4q/ef/75R6pRo4b06dOnzGpypknKJsydO1fS0NCQevXqJc2cOVMqU6aMZGJiIs+8BAcHS1WqVJF69uwp33bt2rWSh4eH5O/vLx08eFAaNmyYZGFhIb18+TJT9iWruXPnjlS2bFlp7Nix8mX+/v7S1KlTpSdPnkgXLlyQypcvLw0YMCATW5l5Vq5cKclkMqlUqVKSjo6OtHfv3mRjtfz9/aUiRYrIxwkePXpUKlasmGRhYSE5OzvLz0dvb29JJpNJ8+fPl168eJEp+5NVJL2nk7JRcXFx0qRJkyRtbW0pMDBQOnPmjGRsbCx5eHhIkiRJO3bskHR0dKTKlStLJiYmUrly5aTHjx9nWvuFnEEEWdnY5s2bJWVlZal27dqSv7+/fPmNGzekChUqSHZ2dpKurq58QHd0dLSUN29e6ezZs5nV5Czh1q1bUr9+/aRevXpJWlpaUosWLRTWHz9+XHJ2dpYmTZokRUZGShEREZKfn58UEhIilS5dWpLJZFK7du0yqfVZS0pdN192Y0VFRUldunSRKlWqJD148CDZ+pzi6NGj0oYNG+TH4GuxsbFS+fLlpc6dO8uXxcTESEuXLpUPCZAkSerbt68kk8mkOnXqSO7u7lKRIkWk169f/5Z9yOpu374taWtrSwsWLJA+ffokNW3aVCpatKh8ffv27aWWLVtKUVFRUlRUlNS2bVupSpUq0rt37zKx1cKfTgRZ2dyHDx/kHxJJ4xLOnTsnGRkZSXfu3JEuXLggubq6Sra2ttKCBQuk3Llzp/pBn9O8efNGqlWrlnTy5ElJkhKPW2hoqCRJkrRq1SqpTJky0t69e+XlfX19pXbt2kl2dnaStra2VLRoUfnYmZwqMjJSGjhwoDR//nxJkj5nF5L+Xbt2rVS6dGlp5syZmdbG7GL16tWSu7t7sjnbku5kcPXqVUlZWVkaMmSIdPnyZendu3fSjBkz5FfN5nTr1q2TrKyspISEBGnz5s2Svr6+dOLECUmSErNcixYtkjQ0NOTjU729vaWDBw9KISEhmdls4Q8ngqw/0O7du6XcuXNLgYGBkiQlZrAWLFggmZqaSiVLlpTevn2byS3Met69eyfVr19f2rFjh3xZt27dJGdnZ/mUGUlZhT179kiSJEkjR46Ujh07lintzWq+DK6SMlVv3ryRmjRpIjVo0ED68OGDJEk5M4v1o2JiYqQePXpIGhoaUocOHaQ1a9ZIN27ckK+vVKmSVLVqVYWgIC4uLsddSPAtERERUlBQkGRvby9Vq1ZNkqTEz78k48aNkxo1aiTdvHkz2TpByAhi4PsfqHr16hQpUoTNmzcDiROd9u7dm/v377No0SIsLCwyuYVZj7GxMc7Ozvzzzz8MGTKEmzdv8uTJE2xtbZEkiTt37rBv3z4cHR1p2LAhAJMnT6Zq1aqZ3PKsIeliCplMJh+QvWXLFvz8/GjVqhVGRkYkJCSIKTBSIUkSqqqqLFmyhBs3biBJEg8ePODTp08AbN++nQsXLjB58mR0dXXl2ykrK6d4m5+cSktLC319febMmcPq1asBWLRoEQcPHgSgY8eOqKmp0atXL0JDQ1FTU8vM5go5QSYHeUI6S8ooeHh4SDo6OlKPHj2k27dvS1euXMnklmUPFy9elEqUKCGVKFFCql69uvx2HVOnTpWcnJzkXTkie/BtXl5eUvHixSVjY+McP0D7R8XHxytk+pK6rj9+/CiZmZlJvXv3zqymZVshISFS48aNpfr168vPwx07dkguLi7y2xoJQkaSSZK4I+6f6t69ewwcOJAPHz5QvXp1xo0bpzBBopC6V69ekTdvXpSUlPDz86Nu3boUL16cpUuXiokMf9D9+/dp06YNXl5eDB48mJ49eypkYYSUfZ3xu3LlCn/99Rfnzp3Dzs4uE1uWPQUGBtKjRw+OHDlC48aNuXr1Kubm5mzYsAErK6vMbp7whxNBVg5w7949DAwMsLS0zOymZEuBgYG4urqyaNEi6tWrJ7q9ftK6desYNGgQ2traLF++nOrVq2d2k7KdpDsRCL/uwoUL7N69GxcXF9zc3ChSpIj4wSRkOBFkCcJ3REdHM3ToUJYuXcqsWbPo06dPZjcpWxoxYgRRUVHMnTtXBKk/4U++FZYg/OlEkCUIP+jgwYNcu3aN3r17Y2xsnNnNyZZiY2NRVVUVGQRBEHIEEWQJgiAIgiBkAJGzFwRBEARByAAiyBIEQRAEQcgAIsgSBEEQBEHIACLIEgRBEARByAAiyBIEQRAEQcgAIsjKAaKjoxk3bhzR0dGZ3ZRsSRy/tBPHMO3EMUwbcfyEzCCmcMgBwsLC0NXVJTQ0FB0dncxuTrYjjl/aiWOYduIYpo04fkJmEJksQRAEQRCEDCCCLEEQBEEQhAygktkNyO4SEhLw9vZGW1s7y94mJCwsTOFf4eeI45d24himnTiGaZPVj58kSYSHh2NhYZHh9/b89OkTMTExaa5HTU0NDQ2NdGjRn0uMyUqjd+/eYWVlldnNEARBEP4AXl5e5MmTJ8Pq//TpE5qGOhAVm+a6zMzMePXqlQi0vkFkstJIW1sbgOXnO6KZWy2TW5N9lTIrktlNyNZUldQzuwnZnr66uOl3WhVZvzyzm5BtJXyMxWvYUfl3SkaJiYlJDLDaFAU15TRUFI/vRk9iYmJEkPUNIshKo6QuQs3cauTSFl90v0pbRzOzm5CtqSmJD7m00lHXyuwmZHtKmqqZ3YRs77cNO9FQQab26yGApJQ1h8dkNSLIEgRBEIQcRqYkQ5aWQElJhhhr9H3i6kJBEARBEIQMIDJZgiAIgpDDyGRpzGTJRCbrR4ggSxAEQRBymPToLhS+T3QXCoIgCIIgZACRyRIEQRCEHEYmk6XtSsYsOvl2ViMyWYIgCIKQwyR1F6bl8TPOnTtH/fr1sbCwQCaTsWfPnm+WP3PmjDwQ/PLx+PHjNOz17ycyWYIgCIIgZKjIyEiKFClCx44dadq06Q9v9+TJE3R0dOTPjY2z16TBIsgSBEEQhBzmdw98r127NrVr1/7plzExMUFPT++nt8sqRJCVxRzZeJe9K28R7B+Jlb0BHUdXwLmEZYpl7195x79tdiVbPu9oG/LkMwAgLjaeXUtvcGbXI4L8IrGw06ftkDIUq2jz+TU33eXo5nt8eJd441Qre0Oa9SmJ6xdlts27woWDzwj0CUdFVRm7gia0GuhOgaJm6bfz6WTt8lMs9jiMv28IBZwsmTCjFaXLFkixrJ9PCONHbOWu5xtePvej8z/VmDizlUKZ2Ng4Fsw6yPZNF/H1DiafvTmjJjajSo1C8jIlnAbz7m1gsvo7dKvC1Llt5c+fPvZm8pgdXL7whIQECQcnC5Zt6EkeK8N02vu0W7XsGAvnHsDPNwRH5zxMntEO93KOKZb19Qlm7PCNeN5+xcvnvnTrWZMps9qnWveu7Zfo2n4BtesVZ+OOQfLlly48YuHcA3jeeomfbwjrtw2kboMSCttGRHxiwugtHNp/g+CgcKzyGtOtZy06dauePjuejhYv3susWdvx8QnExcWGuXN7Ur584VTLnz17h0GDlvDgwWssLIwYMqQ5PXrUVyizc+c5xo5dw4sXPuTLZ86kSZ1p3LicfP25c3eZNWsbN28+w8cnkF27xtOoUTmFOiRJYvz49axYcZDg4HBKlXJi4cK+uLjYpOv+p0UJM2e6FW5IQcN8mGoZ0P34NI6/uZZq+Zo2pWjtVAsnAxvUlFV5FuzFvFvbOP/eU16mqX1lZlbsk2xbxzXNiYlPvIdfa6eatHaqiWVuEwCeBXux4PZ2zr67LS9vpKnL0BJtKW9ZFB11La75PGT85ZW8DvNJp73/fdIryPr6htvq6uqoq6ff3U+KFSvGp0+fcHZ2ZvTo0VSuXDnd6v4dMm1MVlJ/a0hISLrVOW7cOIoWLZpu9f1uFw8+Zc3kczT9pziz9rXEqYQlkzvv44N3+De3W3C8LSsvd5Y/zG305Ou2zL3C8a336fxvJTyOtKFGy4LM6HmQlw/85WUMzXLTZkhZZuxpwYw9LSjonofpPQ7w9unnoMHCVp8u/1ZkzsHWTNr6FyaW2kzssIfQwKh0Pw5psfe/q4wdupl+Q+tx7NJ4SpUpQOvGc3jnlTwAAoiJicPASJu+Q+rhUijlG31PH7+LDavOMHlWa87enEy7LpXo3HIB9zzfyMscPjeWOy885I9t+wcDUL/x50Dh9Ut/GlWfQv4C5uw8PIyTV8YzYHgDNNSzzq1Idu+4zKgh6xk4rBGnr0yldBkHmjeaxru3ASmWj4mJw9BIh4HDGlGwsPU36/Z684GxIzbhXjZ5wBYVGY1LIWumz+2Y6vajh67n1PE7LF3Ti8ues/mnTx2GD1zLof03fm4nM9i2bacZMGAxI0e24tatZZQrV4g6dUbw9q1fiuVfvfKhbt2RlCtXiFu3ljFiREv69VvIzp3n5GUuX35AixYTadOmOp6ey2nTpjrNm0/g6tVH8jKRkR8pXDgfCxYkDyaSzJixlblz/2PBgj5cu7YYMzN9atQYSnh41nkf51JR51Hga8ZdXvFD5UuauXDh/R06H51Mwz1DuOJznxU1RuBsaKtQLjwmkpKbOik8kgIsAJ/IQGZc20ijPUNotGcIl33usaz6cOz1Pn8uLK02HGttU7ofn0a93YN4H/GBDbXHoamS/W6pll5jsqysrNDV1ZU/pk6dmi7tMzc3Z/ny5ezcuZNdu3bh4OBA1apVOXfu3Pc3zkL+qEzW4MGD6dMn9Q+YrG7/6ttUaeZCteYFAeg0ugKe599wdNNd2gwpm+p2uoa50NJJ+U1+ds9jmv5THLdKNgDUal0Yz/Nv2b/qNv3m1ASgRFU7hW1aDyrDsc33eOrpi3WBxAxL+QYOCmU6jCzPyR0PefMkkMJlcv3S/maEZQuO0bJ9BVp3qAjAxJmtOHPyPutWnGLUhGbJylvlNWLSrNYAbN1wPsU6/9tymX5D61G1VuJNrNt3rcLpE/dZOv8Ii1Z3B8DIWEdhmwWzD2JjZ4J7+c/Hbdr4nVSpUZgxk/+WL8tra5KGvU1/i+cfpHWHyrTtWAWAKbPac+rEXVavOM7YiS2TlbfOa8zU2YmZq83rzqRab3x8At07LmL4mL+4fPExoSGKX+rVahalWs2i32zb9avPaNGmAuUqOAPQvnNV1q06ieetl9SpX/wn9jJjzZ37H5061aZLl7oAeHj04tixGyxZsp+pU7skK7906X6srU3w8OgFgJNTXm7ceMrs2dtp2rQCAPPm7aJ6dTdGjEjMso4Y0Ypz5+4yb95ONm8eDUDt2qWoXbtUqu2SJIl583YxcmQrmjQpD8DatcMwM/uLzZtP0r17/VS3/Z3OvrutkD36nolXVis8n3VjE9XylqCqdXEeBr6SL5ckCPgYkmo9p94qBuuzb2ymtWNNipkU4FmIF7Y65riaOlDzv348C/ECYOyl5VxvvYb6+cqz/cmJH27zn8TLy0thzFR6ZbEcHBxwcPj8+enu7o6XlxezZs2iQoUK6fIav8MfdXVh7ty5MTTMOt0uPyM2Jp4X9/0pWk4xG1CknDVPbn07FT24wRY6u69kXNtd3LvslaxeVXXFWFpNQ4VHN71TrCs+PoELB57yKSoWh2IpdwXGxsRzfNsDcmmrYeNo9L1d+21iYuK4e/s1Fau6KCyvWMWFG1dfpKHeWNQ1FLNNmhpqXLv8LNV27Nx2mRbtyssvkU5ISODEkbvY2ZvRosEsCubtS52KEzm8/9Yvtyu9xcTEcef2KypXVezWqly1MNevPE1T3TOn7MTQSJs2HX491V+6jAOHD9zE+30QkiRx/uwDnj/zoUq11LvhfreYmFhu3nxKjRqKQV/16m5cvvwgxW2uXHlI9epuCstq1izBjRtPiY2NA+Dy5YdUr65YZ40axbl0KeU6U/LqlQ++vkEKbVNXV6NixSKpti07kiEjt6omIdERCstzqWpwvvkyLrZcwcoaI5Nlur6kJFOinl1ZNFU1uOX/BAA15cTPgOj4GHm5BCmB2IQ4ipum3J2elaVXJktHR0fhkZ5dhV8rXbo0z56l/LmbVWVIkPX69WtkMhlbt26lTJkyaGho4OLiwpkzZ1LdJjAwkJYtW5InTx5y5cpFoUKF2LJli3z9+vXrMTQ0JDo6WmG7pk2b0q5dOyB5d2GHDh1o1KgRs2bNwtzcHENDQ3r16kVs7BcpYh8f6tati6amJra2tmzevBkbGxs8PDxSbGd0dDRhYWEKj/QQHvyRhHgJXSPFrJCeYS5CAlJO5eubaNFjUhWGLKzD0EV1sbDVZ3y73Ty49l5epmh5a/avvo336xASEiTuXHjL9RMvCfaPVKjrzZMAWhdeQgvnRSwbc4qhS+phZa8YsN449YrWhZfQ0mURB9bc5t91jdEx0EyX/U8PQYHhxMcnYGyimFUyNtXlg1/oL9dbqWpBli04ysvnviQkJHD25AOOHLyNv2/KdR7Zf4uwkCiat/mcfQzwDycy4hMLZx+kcvVCbN03mNr1XencciGXzmeNS5IDA8KIj0/AxERXYbmxqS5+aTh+Vy89YePaM3gs7pqm9k2d3QEHJ0sK5e+FmU5b/m4wjZnzOlE6he7HzBIQEEp8fAKmpvoKy01N9fH1DUpxG1/foBTLx8XFExAQ+s0yvr7BP9y2pLJf12Ni8nP1ZHVdCjVAU0WDQy8vyZe9CHnPkHML6Hp8Kv1PzSE6PpYd9adgo2OusK2DvjX32m/iccdtTCrbg3+OT+d5yDt5He/C/RlSog06alqoKqnQo3BjTHLpY5JL8ZhmB797Cof0cPv2bczNzb9fMAvJ0O7CIUOG4OHhgbOzM3PmzKFBgwa8evUqxWzTp0+fcHNzY9iwYejo6HDw4EHatm2LnZ0dpUqVolmzZvTt25d9+/bRrFlit09AQAAHDhzgyJEjqbbh9OnTmJubc/r0aZ4/f07z5s0pWrQoXbsmfuC3a9eOgIAAzpw5g6qqKgMHDsTf3z/V+qZOncr48ePTeGRS9/VpK0Gqk75Z2uljaff5ze3gak6ATzj7Vt7CpWTiYPlOoyuwZNQp+tXYADIws9alSlMnTu18pFCXha0+s/a1JDI8mitHnrNwyDEmbG6qEGgVLJ2HWftaEh78kePbHjC772Gm7fwbXcOs010IJJtgT5Kk5Af2J0yY2YrBvddSvthIZDIZNnYmtGhbjq0bLqRYfvO6c1SpUQgz889/mwQpAYBadYvRvU9iN23BItbcuPqcDSvPUKZ81gkUvj7dJEn65UkLw8M/0qPTIjwWd8XQSOf7G3zD8kVHuHHtOZv+G4yVtRGXLjxmSL/VmJrpUalKoe9X8BslP4bJz0vF8imcs18tT6nMr/xZUq7nz5hYsr5dOfq5Nqf78WkEfvr8w8Dzw1M8P3zOxt7we8z+xrNo51KHCZdXyZe/DPWm3u5B6KhpUcumNDMr9qHlwTE8D3lHnBRPzxMzmFahF57tNhCXEM/F93c543Xzt+5jdhUREcHz58/lz1+9eoWnpycGBgZYW1szYsQI3r9/z/r16wHw8PDAxsYGFxcXYmJi2LhxIzt37mTnzp2ZtQu/JEODrN69e8vnw1iyZAlHjhxh1apVDB06NFlZS0tLBg8eLH/ep08fjhw5wo4dOyhVqhSampq0atWKNWvWyIOsTZs2kSdPHipVqpRqG/T19Vm4cCHKyso4OjpSt25dTp48SdeuXXn8+DEnTpzg+vXrFC+emEJfuXIl9vb2qdY3YsQIBg4cKH8eFhaGlVXKA6Z/hra+JkrKsmRZq9DAKPQMfzxbVKCYOef2fs6M6BrmYvjSesRExxEe/AkDUy02zryESR7FLzxVNWX5gPn8hUx5fs+fg+vu0GNSFXkZjVyqmNvoYW6jR4Fi5vSquo6T2x/Q5B/Fq8Ayi4GhNsrKSvh/lXUJ8A/D+KvszM8wMtZh7ba+fPoUS3BQBGbmekweswNrm+RdpV5vAzh/+iGrtvRO1jYVFWXsnSwUlts7mKfa7fi7GRrpoKyslCxrFeAfhonJrwVIr1/68fbNB1o1nSlflpCQGECY5G7N1btzsLUz/W49Hz/GMOnfrazfNpAatV0BcCmUl/t337DI40CWCbKMjHRRVlZKlhny9w9OlkFKYmZmkCzL5e8fgoqKMoaGOt8sk1qdKb9OYllf3yDMzT//ePrwIQRTU70frierqmtXlmkVetH75Cwuet/9ZlkJibsfnifLZMUmxPEmzBeAewEvKGycnw4u9Rh9cSkA9wNfUm/3ILRVc6GqrELQpzB2NZjGvYBfH46QWX73FA43btxQuDIw6Xu0ffv2rF27Fh8fH96+fStfHxMTw+DBg3n//j2ampq4uLhw8OBB6tSp8+ttzgQZOibL3d1d/n8VFRWKFy/Oo0ePUiwbHx/P5MmTKVy4MIaGhuTOnZtjx44pHPSuXbty7Ngx3r9P7A5bs2YNHTp0+OavMBcXF5SVleXPzc3N5ZmqJ0+eoKKigqurq3x9/vz50ddP/YNLXV09WR90elBVUyZfQRPuXHirsPzuhbc4uP54evTVA3/0jbWSLVdTV8HQLDfxcQlcOfKcktXsUtj6C5JEbEz8d8rw/TK/kZqaCoWL2XDulOL4knOnH1K8VL4016+hoYq5RWI3zsG9N6lZt1iyMts2XMDIWIdq/x8k/2XbirrZ8OKpr8LyF8/9ssz0DWpqKhQpZsuZU4pfUGdO3aNE6ZSnwPgeewcLLtyYwdmr0+SPWnXdKFfRmbNXp2GZ58f2PTY2jtjYeJSUFD+ylJWV5EFbVqCmpoqbWwGOH1fMbpw4cRN3d5cUtyld2pkTJxTLHzt2g+LFC6Cqmvg72N09eZnjx29QpkzKdabE1tYcMzMDhbbFxMRy9uydVNuWXdS3K8fMCr3pf3oup38ws+RsaMuHqG93k8qQoaacPBcRHhtF0KcwbHTMKWSU75tTTGRVMpLPpv5Tj5/sHqhUqRKSJCV7rF27FoC1a9cqDCkaOnQoz58/5+PHjwQFBXH+/PlsF2BBJlxdmFpANHv2bObOnYuHhweFChVCS0uL/v37ExPzeZBhsWLFKFKkCOvXr6dmzZrcu3eP/fv3f/P1VFUVByzLZDISEhK7bpJS8l9LbXlGq9+pGPMHHyNfIRMciplzfOt9AnwiqNEq8Vf6xpkXCfKLpO+sGgAcWHMb4zw6WNkbEhcTz7m9j7ly9AVDFn0+EZ96+hLkF4GNkzFBfhFsn3+VBEmiUbfPA203zbpEsYp5MTLX5mNkDBcOPOXB1feMXt0QgE9RsexcfJ0SVW3RM9EiIvgTRzbdJdA3AvfaqWf9MkP3PjXo02UFRYrZ4FYqPxtXn+W9VyDtuiT+gpo8dge+3iEsWPl5fND9O4mBbWRENIEB4dy/8xZVNWUcnBK7XG9df4GPdzAFC1vj4x3C7Ml7SEiQ6DVA8Q2fkJDA1g0X+Lt1WVRUlPnaP/1r06PdEkqXc6BsBUdOH7/H8UOe7DwyLKMOx0/r2bcu/3ReRDFXO4qXKsD6VSd57xVAxy7VAJgwZgs+3sEsWdVTvs29O68BiIj8RGBAOPfuvEZVTQVHpzxoaKjh5KKY6dXVS+xe/nJ5RMQnXr34HIC+ff2Be3deo6+fmzzWRujo5KJseSf+HbkJDU01rKyNuHj+Eds2nWPi9LZkJQMG/EW7dtMoXrwA7u7OLF9+kLdv/eXzXo0YsRJv7wDWrRsOQI8e9Vm0aC8DBy6ma9e6XL78kNWrD7N58yh5nX37NqFixf5Mn76Fhg3LsnfvRU6cuMX58/PkZSIiPvL8+efxmK9e+eLp+RwDA22srU2RyWT069eEqVM3Y2+fB3t7S6ZO3UyuXBq0alX1Nx2d78ulokFenc8X3Vhpm+BkYENodATekQEMKd4aUy1DBp+dDyQGWLMq9WXi5dXc9n+KkaYeANFxMYTHJvYM9C32N7f9n/I6zIfcqpp0cKmLk6ENYy8tl7/O4OKtOet1C+/IAHKralIvXzlKmbvQ8egkeZnatu4EfQrDOyIAB31rxrp35viba1x4f+c3HBkhO8rQIOvKlSvySy3j4uK4efMmvXv3TrHs+fPnadiwIW3atAESv7CePXuGk5OTQrkuXbowd+5c3r9/T7Vq1dLUVefo6EhcXBy3b9/GzS0x6Hj+/Hm6zt31M8rWLUB48Cd2LLxGsH8k1gUMGbmyASaWidmy4A9RBHwxZ1ZcbALrp14gyC8CNQ0VrOwTyydN1wAQGx3HljmX8fMKQ0NLFdeKNvSdVUNhyoeQgCjmDz5GsH8kubTVyetoxOjVDSny/ysdlZRlvH8ZzJndjwgL+oi2vib5C5kwaetf8ikesoqGf5UiOCiSOdP24e8bioOzJRt3DcDKOrFrz983lPfvFOfMql7mX/n/795+ze7tV8hjbcj1R7MA+PQplukTdvP2lT+5cmtQtUZhFqzqKg8Wkpw79ZD3XoG0aFc+xbbVaeDG9HntWDD7IGMGbyKfvRkrN/eiVJlfyxJlhMbN3AkKCmfmlF34+Ybg5GLF1j3DsMqbeCsLP98Q3nspzplVqfQI+f/v3HrFf9suYmVthOeTBT/8up63XtKw5kT589HDNgDQok0FFq34B4AV6/sycexWundYSEhwBHmsjRk1rjkdu1b75f3NCM2bVyYwMIyJEzfg4xNEwYI2HDw4lbx5E7tFfX0Defv287hPW1tzDh6cwsCBi1m8eB8WFobMm9dbPn0DQJkyLmzZMpoxY9Ywduxa8uWzYOvWMZQq9fnz8caNJ1Sp8nmC10GDlgDQvn0N1qxJDOSHDm3Bx48x9Oo1Tz4Z6dGj09HWzjrjKgsZ52NL3S/OhdKdAPjv6SmGnluIcS59LHJ/7qpv6VQDVSUVJpTtxoSy3eTLk8oD6KhpMaXcPxjl0iM8JoqHgS9pcWA0dz98HiNkpKnL7Er9MM6lT3hMFE+CXtPx6CSFAMoklz6jSnXESFOXD1Eh7Hp+hoW3d2TYschIv7u7MKeSSRmQtnn9+jW2trZYW1vj4eGBk5MTc+fOZfPmzbx69QojIyPOnDlD5cqVCQ4ORk9PjwEDBrBz5062bt2Kvr4+c+bMYfv27VSuXFnhRpJhYWGYm5sTFxfH+vXrad68uXzduHHj2LNnD56enkDi1YUhISEK2/fv3x9PT095WrJ69eoEBQWxZMkSVFVVGTRoEFeuXGHq1Kn069fvu/saFhaGrq4uG253J5d29puQLqsoY5686034cWpKGpndhGxPXz1rzVmWHeVbtTCzm5BtJXyM5U3fA4SGhqbbMJSUJH1n6Yyugkzj1/Ms0qc4wiadyvD2ZncZOiZr2rRpTJ8+nSJFinD+/Hn27t2LkVHK8yqNGTMGV1dXatasSaVKlTAzM6NRo0bJyuno6NC0aVNy586d4vqftX79ekxNTalQoQKNGzema9euaGtro6EhvrQEQRAEQfh1Gdpd6OTkxJUrV1JclzQILomBgYFCxulbfHx8aN26dbJJz8aNG8e4cePkz5MG1H3p6/mvzM3NOXTokPz5u3fv8Pf3J3/+/D/UFkEQBEHIbkR34e+RrW6rExQUxLFjxzh16hQLF6ZPWvrUqVNERERQqFAhfHx8GDp0KDY2Ntlq2n5BEARB+BkiyPo9fjjIShpn9SO0tJJPIZAeXF1dCQ4OZvr06Qr3NEqL2NhYRo4cycuXL9HW1qZMmTJs2rQp2VWJgiAIgvCnkCmRxiAr/dryJ/vhIEtVVfWHA5sCBQqwb9++X25Ual6/fp3uddasWZOaNWume72CIAiCIORsPxxkWVpa8vhx1rjHmiAIgiAIaZDG7kJJdBf+kGw1JksQBEEQhLRL65iszLhBdHYkelUFQRAEQRAygMhkCYIgCEIOIzJZv4cIsgRBEAQhh0m60XNathe+T3QXCoIgCIIgZACRyUon7yNiEDfi+XU1Lh7M7CZka5dats7sJmR7sQkxmd2EbG9GpTyZ3YRsKyo8hva/8fVksjR2F4pM1g8RQZYgCIIg5DBiTNbvIYIsQRAEQchhRJD1e4gxWYIgCIIgCBlAZLIEQRAEIYdRUkp8/HoF6daUP5oIsgRBEAQhh1GWyVASUzhkOBGLCoIgCIIgZACRyRIEQRCEHEZZSYaSGPie4USQJQiCIAg5jOgu/D1Ed6EgCIIgCEIGEJksQRAEQchhlJRAWVxdmOFEkJXFXNj+gFPr7hAWEIVZPn0aDy5DPlfzFMtuGnua6/ufJltuZqfP8J1/A3B13xO2/HsmWZmZVzqjqp745z+89AZHl91UWK9tqMnEE+3kzyVJ4siym1ze+YiP4dFYFzThrxHlMM9n8Ku7miHcTJzo4NIAJ0M7THIZ0O/0DE57XU+1fFXrkvxdoCYOBjaoKanwIvQdS+5s55L3HYVy1axL0atoC6y0TfEK92PB7S2c8rqWYp2dCzain2trNj48yIwba1MsM6Z0N5oVqM6M62vY+OjQL+9vRlix9DDz5uzB1ycYJ2crps3uTNlyzqmWv3DuPiOGrOHRQy/MLQzoP6gRnbvVkq+PjY1j9vSdbN54Gu/3QdgXsGTClLZUr+kqLzNlwlamTtqmUK+JqR4vvNbIn/v7hTBm5HpOnfAkNCSSsuVdmDm3C/ntLdJx79PH0iUHmDP7P3x9gnB2ycus2d0pV75gquXPnb3L0CErePjgDeYWhgwa/BfdutdNsez2bWdo23o69Ru489+usQrr3r8PYNSI1Rw9coOPH2OwL2DJsuX9cXWzB0BdpXaKdU6Z1plBg//6xb3NGEc33WXvytuE+EeSx96AjqPK41TCMtXysdHx7Fh0jfN7nxDyIRJDs9w0+acEVZp9PnevHHnOVo8r+L0NxdRal5YD3SlVI59CPYG+EWyaeYnb594Q8ykOcxs9/plalXwFTZK95rLRpzix7QEdRpanbsei6bbvv4OyTIZyWrr8RHfhD8nxQValSpUoWrQoHh4eAERFRdG2bVuOHz9OeHg4wcHB6Onp/Za23Dr6nN0zL/HXiHLYFjXj0s6HLOt9iBE7/0bfXDtZ+SZDylC/byn584T4BGY0/48i1e0UymnkVmPk7uYKy5ICrCRm+fTpubSe/PnXAyJPrr3DmY13aTW+EiZ59Ti24hZLehxk5J7maGip/eoupztNFXWeBL9hz4vTzK005Lvl3UycueJzh/m3NxMeE0mj/JVZUHk4rQ+P4HHQawAKGxVgRoUBLPLcysm316hqXZKZFQfQ4cgY7gU8V6jPxTAff9lX58n/t01JZasSFDKyxy8qKC27miF2br/AsEGrmbOgG6XdHVmz8hhN60/k+p35WFkbJyv/+pUfTRtMokPn6qxY258rlx8zsM9yjIx0adjEHYAJYzezbctZFizpSQEHS04e96RVs+mcODuVIsU+n6tOzlbsPzJe/lzpi5/ZkiTR4q+pqKqqsHXnCLS1c7Fw3j4a1B7H9Tvz0dLKOncO3bH9LIMHLmP+wl64l3Fm5YpDNKg3Bs97y7C2Tv5F/eqVLw3rj6VTl1qsWTeEy5ce0rf3IoyNdWncpJxC2Tdv/Bg+dCXlyiUP2IKDw6lcYRAVKxVh34GJGJvo8fKFN7p6Wp+3f7dJYZujR27QvasHjZuUTae9Tx8XDz5lzeTzdB1XCQdXc45vvc/kLvuZe7g1xhbJPwsB5vQ7TGhAFP9MqYJZXj1CA6NIiJfk65/c9mFu/yO06F+aktXtuHb8JXP7HWHilqbYFzUDICL0E2Na/IdLqTyMXFkfXcNc+L0NRUtbPdnrXTv+gmd3/NA31Uq2ThCSiITfV9atW8f58+e5dOkSPj4+6Orq/rbXPrPxHqUaOeLexAkzO32aDCmLnlluLux4mGJ5TW11dIxyyR9vH37gY1g0pRo4JCv7ZTkdo1zJ1ispKymsz22gKV8nSRLnNt+jemdXilS1wzy/Aa0nVibmUxw3Dz9PVldmuuDtycL/B0M/YsaNtax5sI8HgS94G+7L/NtbeBPuQ8U8xeVl2jjX5YrPXVbd38PrMG9W3d/DNZ/7tHFSzDRoqmgwtXxfxl1ZSlhMZIqvZ6JpwMiSnRlxfh5xCXG/vqMZZOG8fbTrWJUOnarj6GTF9NmdscxjyMplR1Isv2r5UfJYGTF9dmccnazo0Kk6bTtUYd7cPfIyWzefYfCwptSs7YatnRlduteiavWiLPDYq1CXiooypmb68oex8ef33vNn3ly/+hSPBd1xK25PAQdL5i7oRkTER3ZsO58hx+JXzZu7mw6datCpcy2cnKyZPacHeayMWb405Zugr1h2ECtrE2bP6YGTkzWdOteifccazJ29U6FcfHw8HdrOYMy/bbG1M0tWz6wZO8iTx5gVqwZSoqQDNjamVKlajHz5Pmf6zMwMFB77912hYqXC2NmlnC3PLAdWe1LlL2eq/u1CnvwGdBxdASOz3BzbfC/F8rfPveHhtfeMWNmAwmWtMcmjg30RMxy+6AU4uNaTwmWtaNyjOJb5DGjcozgF3fNwcK2nvMye5TcxNM9Nr+nVsC9ihkkeHQqVscIsr+L3QKBvBKvGn6XfnBqoqGTPr9GkTFZaHsL3Zc+zIwO9ePECJycnChYsiJmZ2W+7giIuNp53jz7g6K54F3vH0nl4fcfvh+q4uucxBUrlweCrX3oxH2MZX3sT/9bcyPK+h3n3OCDZtgFvQxlbfQMT6m5m3bATBLwLk68LfB9OWECUQttU1JTJ72b+w23LLmTI0FLVJDQ6Qr6siHGBZN2HF709KWKsGMyOKtWZ8+9ucdUn5S8CGTKmlOvD2gf7eBH6Lv0bn0YxMbHcvvWCKtWKKiyvWr0oV688TnGba1efULX61+WLcfvmC2JjE4PI6OhY1DUUs52ammpcvvRIYdmL5z7Y5+1EwQLd6dB6Nq9e+n5uW3RiXeoaqvJlysrKqKmpcvmiYj2ZKSYmllu3nlG9uqvC8mrVXblyOeUfS1evPKbaV+Vr1HDl5s1n8mMIMHniZoyMdenYqWaK9Rw4cAVXN3taNp9MHvMWlCzei1UrD6faVj+/YA4fupZqfZklNiaelw/8KVLOWmF54XLWPLnlk+I2N06+Il8hE/auuEm3cqvpW30D66ddIPrT5+P39LZvsjqLlrfmyW1fxXoKmjK7z2E6l1rJkAZbOLHtvsI2CQkSC4Ycp0EXV6zsDdO6u5lGWUmW5ofwfdk6yLp06RJFixZFQ0OD4sWLs2fPHmQyGZ6envIyZ8+epWTJkqirq2Nubs7w4cOJi0s5g1CpUiVmz57NuXPnkMlkVKpU6ffsCBAZ/ImEeAntLzJIkDg2Kiww6rvbh36I5NFFL0o3dlRYbmqjR6vxlejiUYt2U6uiqqbMvI57+fAmVF4mb0ETWk+sTI/FdWg+pgJhgVHM67CHyJBPAIQHJL7+r7YtO2nvUh9NFXWOvbkkX2akoUfQp1CFckGfQjHS1JM/r2VTBicDO+bd2pxq3Z0KNiROimfT46w1BitJYEA48fEJmJjqKSw3NtHDzzckxW38fIMxNlEsb2KqR1xcPIEBiYF6terFWOixj+fPvElISODUCU8O7r+Gr0+wfJviJe1Zvrofew78y4IlPfHzC6ZaxREEBibWUcDREuu8xowbvZHg4AhiYmKZPWMnfr7B+PkGk1UEBIQlHkMTfYXlpiZ6+Pql3E5fv2BMvz6GJvrExcUT8P9jeOniA9auOcqSZf1Sfe1XL31Zvuwg+fNbcuDQJLp2q8vA/kvZuOFEiuU3rD+BtrYmjRpnra7C8OCPJMRL6H2Vcdcz0iQkIOXPGz+vUB7f8MHraRBDFtWhw6jyXDnynFXjzsjLhAREoWuoWKeuYS5CPnzOOvt7hXFs8z3MbXQZvbohNVoWYvXEc5zd/TmQ37v8JsrKMuq0L5IOe5t5lAFlWRoemb0D2US2HZMVHh5O/fr1qVOnDps3b+bNmzf0799focz79++pU6cOHTp0YP369Tx+/JiuXbuioaHBuHHjktW5a9cuhg8fzv3799m1axdqasnHGkVHRxMdHS1/HhYWlqxMmnz140CSfmw+kmv7nqKprU6hyjYKy20Km2JT2FT+3LaoGbNa7uTc1vs0HZb44er85a87e7ApYsqk+lu4tv8pldsW/k7bfmivsoXaNmX5p3Az+p6ZQdAnxb+rJEnJykskLjPNZciwEh3pfmISMQmxKdbtZGBHa6e6ND8wNP0bns6S/U0l6Zvn4Nfrko5V0vLpczrTp8di3Ar1QSYDWzsz2rSvwsZ1p+Tb1KjlJv+/C3kpWdqBwo7/sHnDafr0b4iqqgobtw2jV7eFWJu2RVlZicpVi1CjlmIGKKtI6Zj82jGE8PAoOrSfyeKl/TAySn34QkKChJubPRMndwCgaLH8PHz4huVLD9KmbbVk5detPUaLVpXR0Mg6YyoV/MTnjZQggQz6zqkhHz/VfkS5xIzUuEqoayR+1SX7G3z1+ZogSeQraEKrQWUAsHUxxutZIEc336diYyde3Pfn4Lo7zNjTXMwTJfyQbBtkbdq0CZlMxooVK9DQ0MDZ2Zn379/TtWtXeZnFixdjZWXFwoULkclkODo64u3tzbBhwxg7dixKX90d08DAgFy5cqGmpoaZWfIxDwBTp05l/PjxKa5LCy19DZSUZYQHflRYHhH0MVkG6WuSJHF172OK17VHRfXbvy+UlGRYuxjz4W1oqmXUNVUxz28gL6P9/1+U4YEf0TX+PMgzsW3Jx3dlRzVtyjCuzD8MPjsnWXdfwKcQDL/IWgEYaOgS+DHx+Dgb2mGoqcfWutPl61WUlHEzdaKFYy2Kb2qFm6kjBho6HG26RKHMILf2tHaqS+1dvTJu536QoZE2yspKybJWHz6EYmKa8pe7qZk+/l9laD74h6KiooyBYWK3tbGxLlt3juDTpxiCAsMxtzBg7MgN5LUxTalKALS0NHApmJcXzz93DxVzzcelG3MJDY0kJiYOY2NdKpcdSjG3fKnW87sZGekkHkM/xYsa/D+EJstWJTEz1U+W5frwIQQVFWUMDXV4+OANb1770aTROPn6hITEICyXel3uPVxBvnwWmJsb4OSs2B3m6GjFnl0Xk73mhfP3efrkHZs2j/iFvcxY2vqaKCnLCPmgmLUKDfyYLBOVRN9ECwPT3AoD1C3zGSBJEOQbgbmNHnpGuQgJUBwrGRoUhe4XGTN9Yy3y5Fe8YtoynwFXjr0A4PF1b8ICo/in4lr5+oR4iXXTLnBwnSeLz3T4lV3OFGnu8hPdhT8k2wZZT548oXDhwmhofL6qqGTJkgplHj16hLu7u8IvjrJlyxIREcG7d++wtlb8QPoRI0aMYODAgfLnYWFhWFlZ/cIeKFJRVSaPkzFPrryjcBVb+fInV95RsJLNN7d9ftOHAK8wSjdy/GY5SAzI3j8JxNw+9akX4mLi8XsVgl2xxEGjhpba6Bjl4smVd+RxNEosExvP85s+1O9XKtV6sovaNmUZX6Ynw857cP79rWTr73x4irt5YTY++jxwuYxFEe58eALAVZ97NNk3UGGbCWV68irUmzUP9pAgJbD/5TmufBW8Lak2mgMvz7H3+ekM2Kufp6amSjHXfJw+eYcGjUrLl586cYe69UumuE3JUg4cPqg4RcapE54Uc8uHqqrix4uGhhoWlobExsaxb89lGjdNvZsqOjqWJ4/fUaasU7J1urqJgf7zZ97cuvmC0eNa/fA+ZjQ1NVVcXe05ceI2DRt93r+TJ25Rv757ituUKu3IwYNXFZYdP34LNzd7VFVVcHC04pbnEoX1/45dT3h4FHPm9sDKKvGqT/cyzjx9ojjW79nT9yle0bh2zVFc3ewpXMQu2brMpqqmjJ2LCXcveilMr3D34ltKVEu5vQ6u5lw+/JyPkTFo/v9qZ5/XIciUZBiY5QagQDEz7l70ol7HYvLt7lx4i0MxM4V6vF8pBrw+r0PkVzRWaORAobKKn/eTOu2lQkMHKjdNfZqTrEgpjYPXJZHJ+yHZNshKKf3+dZfOt8r8aqpXXV0ddfXkl/Omh0ptCrFp9GmsnI2xKWzK5V2PCPaNoOxfiW/e/fOvEuofSZtJVRS2u7rnMXkLmWCeP3ngdGTZDfIWMsXYWpdPkTGc23Kf908D+WvE50vD9865jEuFvOib5yY86CPHV97iU2QMJesXABKPVYVWhTi+6jbG1roYW+tyfNVt1DRUcKudP0OOxa/SVNHAWvvzh6ZlbhMc9G0IjYnANzKAvsVaYZrLgFEXFwKJAdakcr2ZcX0Ndz88w1BDD4Do+BgiYhN/SW96dJA1NSfQ0aUhp72uU9mqBKXMC9HhyBgAouI+8TzES6EdH+OiCY0Oly8PjY5QGEwPEJcQR+DHYF6HeWfIsfgVvfs1oGvHeRRzy0fJUg6sXXWcd14BdO6WODj631Eb8PEOYvmaxLFBnbvVZPmSQwwfspoOnapz7eoT1q85yZoNn4PO69ee4v0+kMJFbPH2DmLqxK0kJEj0H9xYXmbksLXUqVucPFbGfPgQyowpOwgPi6JV28ryMrv/u4iRsS55rIx4cP8Nwwatol6DkskG3me2fgMa07H9LNzc7ClV2olVKw7j9fYDXbvXAWD0yDV4eweyeu1gALp2r8uSxfsZMmg5nbrU4uqVR6xdfYwNm4YBicGpS0EbhdfQ+/+0DF8u79uvERXLD2L61K00bVaBG9efsGrlYRYv7auwbVhYJDv/O8/0mV3Jqup1KsqCIcfJV9CEAsXMOLHtAQE+EdRomTh1xaZZlwjyi6DPzBoAlKtfgJ2LrrN4+En+7luK8OCPbJh+kSp/Ocm7Cuu2L8rYVjvZs+wmJarZcv3EK+5desfELU0/v27Hooxu/h+7llzHvY49z+/4cWLbfbpPTPzM1dbXRFtfsWdBRUUJfSMtLO0Ux+EJAmTjIMvR0ZFNmzYRHR0tD3pu3LihUMbZ2ZmdO3cqBFuXLl1CW1sbS8vUJ7XLLK418xMVGs3R5TcJC4jCPL8B3RfUll8tGBYQRbCv4hf1x/Bo7px8RZMhZVKs82N4DNsnniMsMArN3GpYOhrRZ2V98n4xsV6IXyTrR5wkMuQTufU1yFvIlAHrGitcpVi1QxFio+P4b+oFosKiyVvQhH+W1M1Sc2QBuBjasbrm5+7coSU6ALD3+RnGXFqEsaY+ZlpG8vV/FaiOqpIKo0p1ZVSpz186SeUhMZM17JwHvYu1oHfRFniF+zL03Nxkc2T9CZr+XY6goHCmT96Or08wzi7W/LdvNNZ5E88XX99gvLw+yMvb2Jqyc99ohg9ew4olhzG3MGDm3M7yObIAoj/FMPHfzbx+5YdWbg1q1nJjxZr+8kABwPtdIB3bziEwIBwjYx1KlCzAqfPT5a+b9Nojhq7B3y8UM3N9WrauxLBRzX7DUfk5zf6uSGBgOFMmbcbHJwiXgjbs3T+BvHkTu0d9fYPweusvL29ra8be/RMYMng5S5fsx9zCkDkePZLNkfU9xUs4sP2/MYwZvZbJkzZjY2vGrDndadlK8UfZ9m1nkSRo3qJSmvc1o5StW4CIkE/8t+gawf6RWBUwZOSK+hhb6gAQ7B9JgPfnz0JNLTXGrG3IqgnnGN5kG9p6GrjXyU+LAZ/PQwdXc/rPrcVWj8tsnXcFMytdBnjUlM+RBZC/sClDFtVh0+zL/LfwOiZ5dOgwqjzlGyafFie7S2t3oSS6C3+ITEppRG82EBYWhq2tLfXq1WP48OG8ffuW/v378/jxYzw9PSlSpAjv37+nQIECdOzYkd69e/PkyRO6dOlCr1695APfv56MtH///nh6enLmzJkfboeuri7TzndEI3fWCjiyk1V3AzO7CdnapZatM7sJ2Z6aUtaZ0DS72vcqa145mx1EhcfQ3nUZoaGh6OjoZNjrJH1nlV37Fyq5VL+/QSriomK52OG/DG9vdpdtp3DQ0dFh//79eHp6UrRoUUaNGsXYsYm3mEgap2VpacmhQ4e4du0aRYoUoUePHnTu3JnRo0dnZtMFQRAEQcgBsm13IUCZMmW4c+fzJJGbNm1CVVVVYUB7xYoVuXYt9dm/v85YJWW0BEEQBOFPJboLf49sHWStX78eOzs7LC0tuXPnDsOGDePvv/9GU/PbUx4IgiAIQk6W1lvjiKsLf0yW6i58/fo1Mpnshx4FCxbE19eXNm3a4OTkxIABA2jWrBnLly/P7N0QBEEQBEHIWpksVVVVHBx+7CoOOzs7hg4dytChWX8GbUEQBEHIShJvj5OWTFY6NuYPlqWCLEtLSx4/TvlGtIIgCIIgpA8lJVBOQ19WQpbqB8u6slSQJQiCIAhCxkvrmKwEMSbrh4hYVBAEQRAEIQOITJYgCIIg5DBpncIhQUzh8ENEkCUIgiAIOYzoLvw9RHehIAiCIAgZ6ty5c9SvXx8LCwtkMhl79uz57jZnz57Fzc0NDQ0N7OzsWLp0acY3NJ2JTFY6aZivGNo6YhLUX9WtoNn3Cwmpio6PyuwmZHvi3oVp1zhfg8xuQrYVFhYJLPttr6f8m68ujIyMpEiRInTs2JGmTZt+t/yrV6+oU6cOXbt2ZePGjVy8eJGePXtibGz8Q9tnFSLIEgRBEIQcRpk0dhfyc9vWrl2b2rVr/3D5pUuXYm1tLb/VnZOTEzdu3GDWrFnZKsgS3YWCIAiCIGQply9fpkaNGgrLatasyY0bN4iNjc2kVv08kckSBEEQhBxGKY1XF8b/f9uwsDCF5erq6qirq6epbQC+vr6YmpoqLDM1NSUuLo6AgADMzc3T/Bq/g8hkCYIgCEIOk3R1YVoeAFZWVujq6sofU6dOTbc2yr7qzpQkKcXlWZnIZAmCIAiC8Eu8vLzQ0dGRP0+PLBaAmZkZvr6+Csv8/f1RUVHB0NAwXV7jdxBBliAIgiDkMGm9ujBpWx0dHYUgK724u7uzf/9+hWXHjh2jePHiqKqqpvvrZRTRXSgIgiAIOUx6dRf+qIiICDw9PfH09AQSp2jw9PTk7du3AIwYMYJ27drJy/fo0YM3b94wcOBAHj16xOrVq1m1ahWDBw9Ot2PwO4hMliAIgiDkMMqyxEdatv8ZN27coHLlyvLnAwcOBKB9+/asXbsWHx8fecAFYGtry6FDhxgwYACLFi3CwsKC+fPnZ6vpG0AEWYIgCIIgZLBKlSrJB66nZO3atcmWVaxYkVu3bmVgqzKeCLIEQRAEIYdRkslQSsNVemnZNicRQZYgCIIg5DBKaewuTMMUWzmKGPiexaxbfhp3l+HkM/yH2uUmcvXi01TLHtp7i5b151A47wAczfvQoMpUzpy4r1Bm05pzNKk+HZc8/XDJ048W9eZw+8arVOtcOOsQeXJ35d+hW5Ote/bYh45/L8TJoi8OZr2pX3kK770Cf31nM8iyJQdxsu+Mfu4mlCnZn4sXHnyz/Plz9yhTsj/6uZvgXKALK5YdTlYmJCSC/n2WYGvVDv3cTShW6B+OHL6RYn0zp+8gl2p9hgxcobBckiQmTdiMnXV7DLSbUrPqCB4+ePPrO5pBVi47ShGH3pjptqGS+3AuXXiUallfn2C6tJtPiUL9MdBswYjBa5OV2b/nKpXLjCCvaUcsDdpRvuRQtm46l6yc9/sgunVYgJ1FZyz021K+5FA8b72Ur/f3C6Fnl8U42fbAQr8tf9WfwovnPumyz+lt6ZIDFMjfAR2tBpQu2YcL5+9/s/y5s3cpXbIPOloNcLDvyPJlB1Mtu33bGdRVavNXkwkKyyeO34i6Sm2Fh7VlK4UyX69Pesye9d+v72wGWbJ4H/nt2qKlWYeSxXty/vy9b5Y/e/YOJYv3REuzDvb52rJsqeKVaQ8evKbZX+PJZ9sGFaXqzPPYlayOuLh4xoxeQ367tuTOVRf7fG2ZOGEDCQkJ8jJ+fsF06jgDK8vmaGvVo07tETx79i59dlr444ggKwvZ9991xg3bRp8hdTlycSwly9jTtsn8VAOZqxefUr6KM+t39eXQ+dGUqeBAx2YLuX/n8+DBy+ef0LBZSbYfGsTek8OxtDKgdcO5+HgHJ6vP8+YrNq05h1PBPMnWvX7pT+Ma08lXwIwdhwdz7PK/9B9WD3X1rHUp7X/bzzN00EqGDv+by9fnUbacC43qjcPrrX+K5V+/8qVx/fGULefC5evzGDKsGYMHLGfProvyMjExsdSrNYY3b/zZvHU4dx4sZdGS3lhYJJ+r5cb1p6xeeYRChWySrZszaycLPPYwZ153zl+eg6mZPvVqjyU8POvc3HnXjkuMHLyOQcMac/bqNNzLOvJ3w6l4vQ1IsXxMdCxGxjoMGtaYgoXzplhGXz83g4Y15tjZiVy4PoPW7SrRu9sSTh73lJcJCY6gVuWxqKoqs2PvCK7cns2kaW3R1c0FJAaobf6exetXfmzaMZizV6eTx9qIRrUnERn5Kd2PQ1rs2H6WwQOXMXxEC67eWEjZci40qDeGt6mcg69e+dKw/ljKlnPh6o2FDBvenIH9l7J714VkZd+88WP40JWUK1cwxbqcXfLy5t0m+eOm52LF7b9Y9+bdJpavHIBMJqNxk7Jp3/F0tH3bGQYOWMKIkS25cWsJ5coVpF6dkd84hj7UrzuacuUKcuPWEoaPaEn/fovZtfO8vExUVDS2tuZMmdoZMzODFOuZMX0ry5cdYN6C3tx/uIpp07sye9YOFi7YAySeh00a/8vLl77s2jOBG7eWkNfalJrVhxEZ+THdj0NGUpKl/SF8n0z61kg04bvCwsLQ1dXlkfd8tHU001RXvUpTKFTEmqnz2siXVXIdQ836xRgxvskP1VGl+FjqNy3BgBH1U1wfH5+AS55+TJrdkr9alZEvj4z4RK1yE5kytzXzph/EpbAV42e0kK/v2X45KqrKzF/Z+Rf37tsM1M3SpZ4KZQZRtFg+5i/qKV9WrNA/1G9QmgmT2ycrP3rEWg4euMrte0vky/r0XMS9u684c2EWACuWHcZjzi487y9BVTX1HvaIiI+UKdkfjwX/MH3KNgoXsWPmnK5A4oeznXV7evdtwKAhfwEQHR2LjWVbJk5pT5duP37j1JREx6dPoFat/CgKF7VlzoIu8mWligygTv0S/Dup1Te2hHrVx1OoSF6mzurw3depWHoYNWq5MmpccwDGjd7M1UtPOHxqfIrlnz/zpkShAVy6NQsnZysg8Vy2t+rKuEmtaNep6g/uYepyqaTPXD/l3PtT1DUfCxf1kS8rXLAbDRq4M2lKx2TlRw5fxYEDV7l7f7l8Wa+eC7h35yXnLs6VL4uPj6da5aG061CDixfuExISyX+7xsrXTxy/kX37LnP95qIfbutfTSYQHh7F0ePTfnY3U6SslD4jUNxL98G1WH4WLeknX1bQuRMNGpZlytTkn0HDh63gwP7L3H+4Wr6sZw8P7tx9ycVL85OVz2fbhr79mtCvv+LnaoP6ozE10WfFqkHyZc3+Gk+uXOqsWz+cp0/f4ezYkTv3VuDiYgMk/l3MTZsxdVoXOnep88v7HBYWiYFeI0JDQzNk3qnPr5P4ndX7cDvUtdR+uZ7oyBgW1l6f4e3N7kQmK4uIiYnj3u03VKjqrLC8QlUXblx58UN1JCQkEBERjZ6+VqplPkbFEBsbn6zMqIGbqVqzMOUrOyfbJiEhgZNH72KX35TWDedSxGYg9SpN4cj+2z/Urt8lJiaW27eeU7V6MYXlVasV48rllLu8rl55TNVqiuWr1XDl1s3nxMbGAXDwwFVKlXKkf5+l2Fi2pXjRXsyYtp34+HiF7Qb0WUqt2sWpUrVostd5/coPP99ghddSV1elXIWCXL38+Fd2N93FxMTheeslVaoVVlheuVoRrl1Jvdv6Z0iSxNlT93j+1Icy5Zzky48cuEExNzs6tJqDvVVXKpQaxrpVJ+Xro6MT/xYaX2ROlZWVUFNT4cqlJ+nStvQQExPLrVvPqF7dVWF5tequXLn8MMVtrl55TLWvyteo4crNm8/k5yDA5ImbMTLWpWOnmqm+/vNn77Gxak2B/B1o02oqL1+m3p3q5xfM4UPXvllfZoiJieXWzadUr+GmsLx6dTcuX0656//KlUdUr65YvkbN4ty88VThGH5P2bIFOXXqNk+fJnb/3bnzgosX7lO7dkkg8YcRgIbG5+BEWVkZNTVVLl78dpewkDOJIOsnRUdHExYWpvBID0GBEcTHJ2BsoviLwNhEmw/+oT9Ux7L5x4mKiqZ+k+Kplpk6didmFnqU+yKY2rvjGvc83zI8lWxZwIdwIiOiWTTnMJWqF2Tzvv7Uql+Mrq2WcPl81vmCCwgIIz4+AVMTPYXlJqZ6+PmFpLiNn18wJqaK5U1N9IiLiycgIPFv+/qVL7t3XSQ+PoFd+/5l2IjmzJ+7h+lTt8u32bHtHJ63X6SYLQPw8w2Wt0WhbSZ6+Pkl77rNDIH/P37GJroKy41NdPFP5fj9qNDQKPIYtsNEuzXNG09n+pyOVP4imHv9yp/Vy49jl8+cnftH0rFLNYYPWsPWjWcBKOBggZW1MRPGbiEkOIKYmDjmztyDn2+I/NhmBUnnoImJvsJyUxM9fFP5O/v6BSc/Z030Fc7BSxcfsHbNUZYs65dCDYlKlHRg9drBHDg0iSVL++HnG0yl8oMIDEz5M2rD+hNoa2vSqHHW6ioMCAhNPIamisfQxFQ/1b+1n29QiuUTj+GPfX4CDB3WnOYtKuPi1AkNtVoUd/2Hvv2a0KJlFQAcHa3Im9eUUSNXERwcTkxMLNOnbcXXNwgfn6Cf3NPMpaQkS/ND+D5xdeFPmjp1KuPHp9ylkR6S3xATZHz/ZN6z/Spzpuxj9bZeGJmknLpdPPcIe/67xo7DQ9DQSMwIeL8L4t+hW9m8b4B82dcSEhJ7lGvULUrX3tUBcClszc2rL9i46izu5R1+eP9+h5RuKvqtq42/dxPShAQJYxNdFi3thbKyMq5u+fHxDmLunF2MHN2Sd14fGDJwBfsOTVD4hfvDr5XFLoVO+filrY3a2hqcuzaDyIhPnD19j1HD1mNja0K5ii5AYra0qFs+xk5sCUDhorY8fvSO1SuO06JNRVRVVVi/dSB9eizF1rwzyspKVKpSiGo1i6apXRnlZ49h6ucghIdH0aH9TBYv7YeRkW5KmwNQq3YJ+f8LFoLS7k44FejEhvUn6D8g+Q+odWuP0aJV5e+es5kl/Y7hj5+727edYfOmk2zcNAJnFxvueD5n4IAlWFgY0q59DVRVVdj+31i6dZmNsWETlJWVqFrNVeHYZxe/ezLSnEoEWT9pxIgR8plqIbF/28rKKs31GhjmRllZCX8/xV9dAR/CUw2akuz77zqDe61n2YbuKXb3ASydd5SFsw6xZf9AnL8Y2H739hsCPoRTu9wk+bL4+ASuXnzG2mWneRm0BAPD3KioKFPA0VyhzvwOZly//PxndzXDGBnpoKyslCxj8ME/FJOvMgVJTFP4dez/IRQVFWUMDbUBMDPTR1VVBWVlZXkZB6c8+PkG/7976Dn+/iGULdVfvj4+PoEL5x+wdPEBQiJ3YWqW+CvbzzcYc/PPg24/fAhNlsXILIb/P35fZ60CPoQly279LCUlJezyJY67K1TEhqeP3zN35h55kGVqpo+jo6XCNgUcLdm/56r8eVFXO85fm0FoaBSxMXEYGetQrfwoirrapalt6SnpHPTzU8xq+H/j72xmqp/8nP0Q8v9zUIeHD97w5rUfTRqNk69P+uGTS70u9x6uIF8+i2T1amlp4FLQhufP3ydbd+H8fZ4+ecemzSN+cg8znpGRbuIx9FU8hh/8Q5JlgpOYmhmkWD7pGP6oYUNXyLNZAIUK2fLmjT/Tp22lXfsaALi5FeDm7WWEhkYSExOLsbEe7qX7UNzN/if2UsgpRHfhT1JXV5ffEDM9b4yppqZCoWJ5OX9KcezQ+VMPKV46X6rb7dl+lQE91rBwdReq1iqcYpklHkeZN/0gG3b3o4irjcK6cpWcOHF1HEcvjZU/irjmpXHzUhy9NFY+7qWImw0vnvkpbPvymR+WVlnnbuhqaqoUc83PqROKY8VOnfSktLtTituUKu3IqZOeCstOHr+Nq1t++SD30mWcefHCR+Ey7udPvTEzN0BNTZXKVYpw/fZCrtyYL3+4uuWnRcuKXLkxH2VlZWxsTTE101d4rZiYWC6cu08pd8f0OQBppKamQlFXO06fvKuw/MzJu5QsXSBdX0uSPo+zAijl7sCzp4rjh1488yGPtXGybXV1c2FkrMOL5z7cvvmCOvVS7x7/3dTUVHF1tefEV+fgyRO3KO2e8g+gUqUdOXlCcVbr48dv4eZmj6qqCg6OVtzyXML1m4vkj3r1S1OxUmGu31yElVXyYwQQHR3Dk8dvMU/hSrq1a47i6mZP4SJZJ0BNoqamiqtbAU4cVzwmJ07cwt3dJcVtSpd24sTXx/DYTdyKF/jmxSpfi4r6hJKS4teisrKSwns/ia6uFsbGejx79o6bN55Sv2GZZGWyMnF14e8hMllZSLfe1enXdRWFXfPiVjIfm9ac4/27INp2rgjA1H934esdzLwViVfX7Nl+lf7d1jB+RnNcS9rJs2AaGqro/P/S98VzjzBr4l4WrO6CVV4jeRktLXW0cmuQW1sDRxfFDIJmLnX0DbQUlvfoV4Oe7ZdTqqw9ZSo4cub4fU4cvsuOw1nrZp19+zeic4c5uLrZU6q0I6tXHsHr7Qf51XtjR63D+30gK9cmZiO7dKvF0sUHGDZ4JR071+TqlcesW3OcdRs/71e37rVZuugAgwes4J9e9Xj+3JuZ03fwT+96AGhr58KloOL0BVpaGhgY6siXy2QyevdtwMxpO8iX34L8+S2YOX07mrnUad6y4u84ND+kZ9+69Oi0kGKu+ShR2p51q07yziuAjl0Tu4nHj96Mj3cQS1f3lm9z785rACIjPxHwIYx7d16jqqaCo1NixnTOjN0Uc82HrZ0pMbFxHD9ym62bzjF7fucvXrcONSuNZfb03TT+y52b15+zbtVJ5i7qKi+zZ+dljIx0yGNlxMMHbxk+aB11G5SgSvUiv+HI/Lh+AxrTsf0s3NzsKVXaiVUrDuP19gNduydeeTZ65Bq8vQNZvTbxHOvavS5LFu9nyKDldOpSi6tXHrF29TE2bBoGJA6ydiloo/AaenqJF658uXzYkBXUrVcKK2sTPviHMHXKFsLComjTrprCtmFhkez87zzTZ3YlqxowoCnt203HrXgBSrs7sWL5Id6+9ad7j8T33MgRq/D2DmDtusRj1L1HPRYv2seggUvp0rU2Vy4/YvXqI2zaPFJeZ0xMLA8fvpH///37ADw9n5M7tyb58yd+1tWrX5qpUzZjZW2Ci0tePG8/x2PuTjp0/HxxwH87zmJkrIe1tQn3771iQP/FNGxUhho1sk6w/yNEd+HvIYKsLKTBXyUIDorAY9oB/H1DcXC2YP3OvuSxTswW+fuG8N7rc0p84+pzxMXFM2rgZkYN3Cxf3qy1O3OXdQJg/YozxMTE0b3NUoXXGjCiPoNGNfjhttVu4MrUeW1YOPswY4dsJZ+9Kcs3/UPJMlkrRf7X3+UJDAxj6uSt+PoE4eySl937/8U6rwkAvj5BeHl9kJe3sTVj9/5/GTpoJcuWHMTcwoBZc7vR6It5g/JYGbP/0ASGDl5JSdc+WFga0rNPfQYN+bkblQ4c3JSPH2Po32cJIcERlChZgP2HJqCtnSt9dj4dNGlWhqCgcGZM2YmfbzBOLlZs2zMc67yJ2RI/3xDefTVvW4VSw+T/97z1kv+2XcTK2pi7TxcCEBUZzeB+q/B+H4iGphr2DpYsW9ObJs0+//J3LZ6fDdsHMWHMFmZO2UleG2OmzGzP3y3Ly8v4+YYwaugGPviHYGqmT4vWFRgyMuvdLLbZ3xUJDAxnyqTN+PgE4VLQhr37J5A3rykAvr5BCvO22dqasXf/BIYMXs7SJfsxtzBkjkcPGjcp91Ov+/59AO3aTCcgIAxjY11KlnLk/MW58tdNsn3bWSQJmreolOZ9zSh/N69EYGAYkyZuxMcniIIFbdh/cPIXxzBQYc4sW1tz9h+cxOCBS1myeB8WFoZ4zOtJk6afzx9v70CKu/4jfz5n9g7mzN5BhYqFOXV6NgDz5vfm3zFr6dNrPv7+IVhYGNK1W13GjP08rY6PTxCDBy3Dzy+x679N2+qMHtM6ow9JuhO31fk9xDxZX1m7di0dO3b85o0sv5Se82TlZOk1T1ZOlV7zZOVk6TVPVk6WXvNk5US/e56s4Sc7pHmerGlV14p5sr5DvCO+8vr1aypWzDrdN4IgCIKQ3pRI470L060lfzYRZH3l6NGjzJs3L7ObIQiCIAgZJq2D18XA9x8jgqyvXL58ObObIAiCIAjCH0AEWYIgCIKQwyjLZCinYfB6WrbNSUSQJQiCIAg5jOgu/D3E2DVBEARBEIQMIDJZgiAIgpDDiMlIfw8RZAmCIAhCDqOklPhIy/bC94nDJAiCIAiCkAFEJksQBEEQchhxdeHvIYIsQRAEQchhZGm8ulDEWD9GBFnpxOzmA3S01DO7GdnW1iozM7sJ2VqLc/UyuwnZn5lRZrcg25MZmGd2E7ItpfCPv/X1xMD330OMyRIEQRAEQcgAIpMlCIIgCDmMmIz09xBBliAIgiDkMGLg++8hugsFQRAEQRAygMhkCYIgCEIOI7oLfw8RZAmCIAhCDiOuLvw9RHehIAiCIAhCBhCZLEEQBEHIYZRkMpTSMHg9LdvmJCLIEgRBEIQcRimN3YViTNaPEd2FgiAIgiAIGUBksrIgSZKYsO4qKw4+IDj8E6WczFjQtxIutoapbrP2yEM6zziRbHnkkZ5oqCX+mZfsvcuy/fd47RsGgIuNIaPblqR2KRt5+Y7Tj7P+6COFOko5mXJpUXP58x5zTnHy5lu8AyPJramKu4s507qVxdHaIC27nW7yNK6Offfm6LsVRMNIn0NFGxJy5/F3t1PV1abI5AFYNamOmr4uEa/ecXvQNLwPnwPAuHxxnId0Rt+tILksTDjXqCfv9p78qddW09el0Pg+mNcoRy4rM6IDgnm35wR3x8wjNiwifQ9EGkiSxIQ1l1mx/17iOehszoIBVXCxTf3WM2sPP6Dz1KPJlkce74uG+uePmiW7PZm15QY+QZG42Bgyp08lyhfJI1/vFxTJ8KXnOX79DSER0ZQvYsn8flWwt9KXl4mOiWPI4nNsPfmYj9FxVHG1ZtHAquQx0U6nI5A2kiQxYcFJVmy/TnDoR0oVsWLBvw1wsTdNdZtdR+8zbdlZnr8JJDYuHvu8RgzoVI62jYrJy4yff4IJC08pbGdqlBvvSyPlz/0Cwhk+8yjHLz4jJOwT5UvYMH9Mfextkv/tJEmibpd1HD3/lJ2L2tCounM67H36kCSJ8TP2smL9WYJDIynlasfCGW1xcbRMdZsHj9/z77Td3LzzmjdegcyZ1JL+PWoolAkP/8iYabvZc/AW/gFhFCtkjcfkVpRwtVMo9+ipN8PH7+DspSckJEi4OFqwbVVPrPMYEhQcwb/T93D89AO8vIMwMshNwzquTBzRGF2dXBlyPNKb6C78PUSQlQXN3HqTuf/dZvXQ6hSw0mfyxmvUHLqHR+vaop1LLdXtdLTUeLSurcKypAALII9xbqZ0KUt+S10A1h97ROMxB7i5rKVCAFezZF5WD60mf66moqxQp2sBE1pVdcDaVJugsE+MX3eVWkP38GJTB5SVMz85qqKViw8Xb/N2xxFKrZz8Q9soqapS5fgaPvkHcv6vfkS980XLypzY8M+Bj4pWLoLvPOHFml1U2LXwl15b08IETQsTbg+eTujD52jltaTE0nFoWphwoVm/X9vhDDBz83Xmbr/F6hE1E8/B9VepOXAnjzZ1/P45uLGjwrIvA6xtJ58wYMEZFg6sStmCFizfd5e6Q3dzf317rE11kCSJJqP2oaqsxO4pDdHRUmPutpvUGPgf99d3QEtTFYABC85w4NJLNv9bF0MdTYYsOkuD4Xu4vqJ1ljgHZ644x9w1F1k9rSkFbI2YvPg0NTuu5tGRgWjnTvkepwZ6uRjRoxKOdsaoqSlz8PRjOo/YiYmhFjXLF5CXc7E34djazvLnyl/0+UiSRJOeG1FVUWb34rbo5FZn7poL1OiwmvuH+qP11d9u3tqLWfZGvzMWHGLukqOsWdiZAvnMmDx7PzWazuLxlSloa2umuE1UVDS2eY35q0EJBo7ekmKZrv3XcP/xe9Yv7oqFmR4bd1ymetNZPLg0GUvzxED+xSt/ytedQqfWFRg3rBG6Opo8euqDhnri+eftG4KPbwgzxzfH2cGCN14B/DN4PT6+IexY0ytjDkg6E0HW75Gjg6zXr19ja2vL7du3KVq0aGY3B0j8kJy305ORrUvQpEJ+ANYOq45505VsPvmE7vULpbqtDDAz0Ep1ff0yir/UJnUuw9J997jyyFchyFJXVf5mPd3qFZT/38ZMh4md3CnWdTOvfcPIZ6n3nT3MeK837gVAK2/qv3i/ZtepKWoGuhwr0wIpLg6AqLfeCmV8jpzD58i5NL126INnXPirr/x5xEsv7ozyoMzGmciUlZHi43+4zRlFkiTm7bjNyLYlaVLRHoC1I2ti3mgZm48/pnvDwqluK5PJMDNM/dzx2H6TTnUL0qVe4nk8t29ljl17w9I9d5jSvTzP3oVw5YEPd9e1k2fNFg2silnDpWw5+Zgu9QoRGhHN6oP3WTeqNtWK5wVg/Zja5P1rBSduvqVmSZt0OhK/RpIk5q27xMh/KtGkZuJ7Ze2MZpi7T2HzAU+6tyiV4naVSim+P/u2L8v63be5ePONQpCloqyMmXHKGbtnrwO54unF3YP95FmzReMaYuY+mS0H7tDl7xLysnce+TB3zUWu7uyJZdmpadrn9CZJEvOWHmfkwHo0qVccgLWLumDm1I/NO6/QvUPlFLcr4Wonz0iNmLgj2fqPH2PYeeAmezb0pUIZBwDGDWvE3sO3WLLmFJNGNgVg9OSd1KlWmBnj/pZva2djIv9/Qac8/Le2t/x5PlsTJo1qStt/lhMXF4/KVz9MsyIl0hhkIYKsH5H5P/kEBa98wvANiqJ6cWv5MnU1FSoUseTyA59vbhvxMRbbFmuw/nsV9Ufu4/Yz/1TLxscnsPXUUyI/xeLubKaw7qznO8yarMCx3Xq6zTqJf3BUqvVEfoxl7ZGH2JrrYJVFump+RZ4GVQi47EmJRWNp7HuROvf24zyiOzKljH+LqOnmJjYsIksEWACvfELxDYqkegkb+bLEczAPl+97p74hEPExBttmK7Buupz6w3Zz++nnczAmNp6bT/2oXiKvwjbVS+SV1xsdkxjgfpmBVVZWQk1FmYt33wNw84kfsXEJ1Cj5uR4Lo9wUtDX8bvt+h1dewfh+CKd6OXv5MnU1FSqUtOXyrbc/VIckSZy89Jwnrz5Q/ou/A8CzNwHkKTeVfFVm0rL/Fl6+DZKvkx8/9a+On6oKF2++kS+L+hhD64FbmT+2fqoBW2Z69eYDvv6h1Kj0+QeduroqFcs4cPn681+uNy4unvj4BDQ0VBWWa2qocfHKMwASEhI4ePwu9vnMqNVsFqaOfSldYyJ7Dt36Zt2hYVHoaGtkiwBL+H1EkJXF+AYlBjSm+or9+qb6ueTrUuJorc/qYdXZM7kem0bXQkNNmfJ9/+PZuxCFcvdeBqBTZwmaNRfRc+4pdo6vh7PN5yxWrZJ52TCqJidmN2Fmj3LceOJHtUG75B/eSZbsvYtOnSXo1F3C0etvODqjEWqq2ffDRcvOCuu/aiJTVuZMnW48mLQEp0EdcRn1T4a+rpqBHgXH9OT5sm0Z+jo/wzfw/+egwVfnoEEufIMiU93O0Vqf1SNqsmdqIzaNrYOGmgrle23lmVcwAAGhH4mPlzDVV8x0Jdab+JqOeQ3Ia6bDyOUXCA7/RExsPNM3XsM3KBKfwMTX9g2KRE1VGX1tDYV6TPS18A1MvX2/i29AOACmhrkVlpsa5sY34Nvj7kLDP6FTdBwaLmOo320988bUp3rZz8FaySJWrJ3RjMOrOrJsYmP8AiIo12Ipgf//IeRoZ0xeSz1Gzj5KcOhHYmLimL7sLL4fwvH5EC6vZ+CUg7gXy0vDallnDNaXfP1DATA11lFYbmKsK1/3K7S1NXEvkY9Js/bh7RNMfHwCG7df4urNl/j4Jdbr/yGciMhPTJ9/kJpVCnF0x2Aa1XWlafuFnL2Y8tjOwKAIJs3eT7f2lX65bb9bYnehUhoeIpP1I3J0d2GSly9fMmDAAK5evYq9vT1Lly7F3d09xbLR0dFER0fLn4eFhaXptTedeMw/c07Ln++fWh9I7Hb5kiTxzbETpZ3NKe1sLn9etqAFxbtvYeHuO8zrU1G+3MFKn1srWhISEc2uc8/pOP0Yp+c2lQdazSt/7pYoaGtIcQdTbFuu4eCV1/LuS4BWVR2o5maNT2Aks7ffosWEw5xf0EwhA/E72LSqT4ll4+XPz9TuyocLN3+6HpmSjE/+gVzrNgYpIYHgWw/QtDDBaUhn7k9clJ5NllPR1qLSwWWEPnzBvfEpj/H6HTYde8Q/sz9fNLF/eiOAZJ0BkiR9+xx0saC0i4X8edlClhTvspGFu24zr18V+fKv6/jy3FZVUWbHxPp0nX4Mo7qLUVaWUdXNmlpfXJyRGgkp2fvmd9i0z5N/xu6RP9+/vB2Q0n5++/gBaGupcWtvHyIiozl1+QWDpx7CzspA3pVYu6KDvGwhB3AvZo19tVms332LAZ3KoaqqzI4Frek6chdGJSairKxE1TL5qFXh8/t638lHnL7ykpt7eid7/cyyacdlegxeJ39+YHN/IKXPwbT/jdcv7kbnvqvJU2ggyspKuBbOS6umpbh1NzHLmJCQAEDDWsUY8E9NAIoWsubytecsW3uGimUdFeoLC/9IvZZzcXaw4N8hDdPUtt9JjMn6PUSQBYwaNYpZs2Zhb2/PqFGjaNmyJc+fP0dFJfnhmTp1KuPHj0+hll/ToIwdpZw+d9dFxyR2GfkGRWL+xdgW/5CoZNmtb1FSklHcwZRn70MUlqupKpP//+OmijuYcuOJP/N33WHpwCrJKwHMDbXIa6rN86/q0c2tjm5udezz6FHa2QzDhsvYff4FLas6pFhPRnm37xQBV+/In3987/dL9Xz0+YAUG4f0/w9YgNBHL9E0N0FJVZWE2Ng0t/VLKrm1qHxkJXERUZxr3Es+DiwzNCiXj1JfdBlHxyadg1GYG33OxvgHf0yWhfoWJSUZxR1N5dlUI11NlJVlybJh/sGK57abgym3VrclNCKamLh4jPVy4d59M24OiWOMzAy0iImNJzj8k0I260NwFGUKWvC7NajiRKkiVvLnSVlf34AIzE0+Z2L8gyKTZbe+pqSkRP68iT94ijpb8OjFB6YtO5tsvFYSrVxqFCxgxrM3AfJlbgUtubWvD6Hhn4iJjcPYIDfufy3GrWDiOMHTV17w4m0QBsUnKtTVrM8myhe34dTGrj+x9+mjQa2ilHL7vI/yY+gfirmZnnz5h4CwZNmtn5XP1oQz+4cTGRlNWPhHzM30aNF5MbbWiWMAjQy1UVFRxslB8VxyLGDOxavPFJaFh3+k9t+zya2lwa51fVBVFV+pgiLRXQgMHjyYunXrUqBAAcaPH8+bN294/jzlfv8RI0YQGhoqf3h5eaXptbVzqZHfUk/+cLYxwMwgFydufq43Jjaec3fe4+5i/o2aFEmSxJ0XHzD/xgD2pHJJX6opCQz9iJd/xDcHMyfWwzfryShxEZFEvHgrf8R/iv7+RikIuHiL3PmtFdIPOgVsiPL2T/8AS1uLKsdWkRATy9kG/5AQHZOu9f8s7Vxq5M+jL3842xhiZqDFiRufx/AknoPvcP+JIEaSJO48/yD/saCmqoxbAVNO3FAcl3TixpsU69XNrY6xXi6eeQVz44kfDcrlAxKDMFUVJY5f/9w+n4AI7r8K/Kn2pRft3Orkz2sofzjnN8HMWJsTFz9/hsTExHHu2ivcXa2/UVNyEhIxMakH4NExcTx+4Y95CuOqdLU1MDbIzbPXAdy4/54G/+8aHNatIp77+3Brb2/5A2DOyLqsmtr0p9qXXrS1NclvZyp/ODtYYGaiy/EzD+RlYmLiOHvpCe4l8n+jph+npaWOuZkewSGRHD19nwa1E6fKUFNToUQxG54+91Uo/+yFH3nzfB5aERb+kZrNZqOmqsLejX2TjfPK6pIyWWl5CN8nwm6gcOHPV0uZmycGMv7+/jg6OiYrq66ujrp6ypdgpweZTEa/pkWZuuk6+S31sM+jx9RN18mloUqrL7JE7acew9JIiyldywIwYd1VSjmbYW+pR1hUDAt23cHzeQAL+laSbzNq5SVqlcyLlYk24VExbDv9lDN33nNoWmKKO+JjDOPXXqVJhfyYG2rx2jeM0SsvYaSrQeP/f8G99A5l+5mnVC+eF2NdTd4HRDBj60001VWo8wNdOr+Dmr4uuazNyWWReDWQjoMtAJ98A/jkl/iL333ddKLe+3Fn5BwAni3ZQoE+bXGbN4qnCzaibZ8X55HdeTp/g7xeFa1ciYHY/2nZ5kGviCMxQaFEefn80Gur5NaiyrHVKOfS5FKbIajq5EZVJzG7Ef0hSCGTlllkMhn9mhVj6sZr5M+jh30efaZuvEoudRVaVf/8nmg/+TCWRrmZ0r08ABPWXKaUizn2efQIi4xhwc7beD77wIL+n7Ok/f92o/3kw7g5mOLuYs6K/fd46x9O94ZF5GV2nH6KsZ4m1qba3HsRwIAFZ2hYLh81/n/VoG5udTrVLciQRWcx1NXEQFuDoYvPUsjOiGpuPxfEZASZTEa/9mWYuvQM+fMaYm9jyNSlZ8ilqUqrekXl5doP2YGlqQ5TBid2SU1bega3QpbkszIkJjaOw2efsmHPbRaN+9wFNWTaIepVccTaXA//oEgmLz5NWEQ07Rq7ysvsOHwPYwMtrM31uPfUlwGTD9CwmjM1/j8Q38xYO8XB7lbmethaZY257mQyGf16VGeqxwHs85lib2fK1LkHyKWpTqumpeXl2vdcgYW5HlPHNAMSA7GHT7z///943vsE43nvLbm11Mlvl5gJPXrqHpIEDvnNeP7Kn6HjtuGQ35yOrcrJ6x3cuzYtuiyhvLsDlcs5cuTUPfYf9eT03mFAYgar5l+ziPoYw4Yl3QgL/0RY+CcAjI20s8Q0It8jugt/DxFkAaqqn3+BJPX3J2Til92QFm58jI6j97zTBIdHU8rJlCMzGinMT+TlH47SF/c1CImIpsfsU/gGR6KrpU7R/Mac8WhKyS+6Iv2Co2g/9Rg+QYllCtsZcWhaQ/mVjMpKStx7FciG448JiYjG3ECLSsXysGVsbflra6gpc/6uN/N2ehIcHo2pfi7KF7bkwvxmmPxEd2ZGsmxQBfe10+TPy23zAODeuAXysU+5rM0VApqod76crtEJ17kjqHN3H1Hv/Xgybz2Ppq+QlzEoXpBqZz4HXW5zEyeAfLl2F1c6jvih1zZwc8GodFEAGrxQnDx2r00VIt+8T+Pep48hrUoknoNzThEckTgh7pHZTRXPQb9whQ/akIhoesw8jm9QFLpaahS1N+HMgr8p+cVYweZVHQgK+8ikdVfwCYykoK0hB6Y3Jq/Z5y4g38AIBi88g19wFOaGWrSt6czo9p+/WAHm9K6EirISLf49kDgZqZs1e0fUyjJfbkO6VuDjp1h6j9/3/8lI83BkdUeFObK8fEIU3sORH2PoPW4f73xD0dRQxdHOmPUz/6Z53c8/At/5htJ64DYCgqMw1teiVFErLu3oQV7LzxO1+n4IZ/DUQ/gFRmBurE3bRsUY3TPlKQ+ysqF96vDxYyy9hmz4/2Sk+Tj63yCFObLevgtUOIbeviG4Vv5X/nz2oiPMXnSEimUcOL1vOAChYR8ZOek/3nkHY6CnRZP6bkwe1VShq69xXTeWzGrHNI+D9Bu5CYf8Zvy3phflSieObbt55w1Xb74EwL7EMIV2v7w1Exvr1CftFXIWmSRJUmY3IrOkNE9WSEgI+vr6nD59mkqVKn23jrCwMHR1dQne3x0drYzLcP3ptlY5ktlNyNZanKuX2U3I/szEF2NayQx+fEiDoCgs/CN6tj0JDQ1FRydt486++Tr//87acbcPubR//TsrKjyaZoUXZHh7szuRyRIEQRCEHEaWxu7CzLiSNzvKGrl1QRAEQRD+eIsXL8bW1hYNDQ3c3Nw4f/58qmXPnDmDTCZL9nj8+Pv3os0qcnQmy8bGhq97S/X09JItEwRBEIQ/SWYMfN+2bRv9+/dn8eLFlC1blmXLllG7dm0ePnyItXXqF608efJEoUvS2Nj4l9qcGUQmSxAEQRBymLTN9p74+Flz5syhc+fOdOnSBScnJzw8PLCysmLJkiXf3M7ExAQzMzP5Q1k5+9xd5I8Lsl6/fp1iejGlR8GCBb9foSAIgiD8YdJrnqywsDCFx5d3RPlSTEwMN2/epEaNGgrLa9SowaVLl77Z1mLFimFubk7VqlU5ffr0N8tmNH9/f5R+4p62f1x3oaqqKg4OPzbruJ1dyrMoC4IgCILwfVZWVgrP//33X8aNG5esXEBAAPHx8ZiamiosNzU1xdfXN1l5SJy3cvny5bi5uREdHc2GDRuoWrUqZ86coUKFCum2Dz/rZwb9/3FBlqWlZbYaFCcIgiAIv1t6jcny8vJSGC/1vcm6f+Z+lA4ODgpJE3d3d7y8vJg1a1amBlk/M277jwuyBEEQBEH4tvQKsnR0dH5oniwjIyOUlZWTZa38/f2TZbe+pXTp0mzcuPHnGvsT1q1b9831oaGhP1WfCLIEQRAEQchQampquLm5cfz4cRo3bixffvz4cRo2bPiNLRXdvn1bfvu7jDBgwIBvrv/Z2QdEkCUIgiAIOcyvXiH45fY/a+DAgbRt25bixYvj7u7O8uXLefv2LT169ABgxIgRvH//nvXr1wPg4eGBjY0NLi4uxMTEsHHjRnbu3MnOnTt/ud3fExQU9M31Hz58+KnMmwiyBEEQBCGHUUKGEmnoLvyFbZs3b05gYCATJkzAx8eHggULcujQIfLmzQuAj48Pb9++lZePiYlh8ODBvH//Hk1NTVxcXDh48CB16tT55Xan1c9msnL0vQvTQ9J9oEJC9qGjo5XZzcm+pMy7IfcfIQ2/SIX/E+dg2onz8JeFhUWip9fgt9278NiTYWil4d6FkeHR1HCY/kfeu3Dv3r3MnDmTR48eAeDk5MSgQYNo3Lgx/v7+mJubEx8f/0N1iXeEIAiCIOQw6TVP1p9m2bJlNG/enIIFCzJv3jw8PDwoVKgQLVq0YMmSJWhqatK+ffsfrk90FwqCIAhCDpN4g+hfz7P8qTeInjVrFvPmzaN79+7yZW3btqVo0aLMnDmTf/75h9WrV/9wfSKTJQiCIAiCQOK8X1WrVk22vGrVqnh5ef10fSLIEgRBEIQcRnQXpszW1pZ9+/YlW75///5fukuM6C4UBEEQhBwmvSYj/dOMGTOGDh06cPXqVcqUKYNMJuPixYvs2rWLNWvW/HR9IsgSBEEQhBwmM+bJyg5atWqFlZUVM2fOZOHChUiShJOTEydOnKBixYo/XZ8IsgRBEARBEP6vfPnylC9fPl3qEkGWIAiCIOQworvw9xBBliAIgiDkMJkx43t2oKys/MOzuickfH8CYxFkCYIgCIIgALt375b/f9++fRw7doy5c+eiqqr6S/WJIEsQBEEQchgl0thd+Idmsho0aAAk3lpny5YtWFpasmfPHjZs2PBL9f2Zlwd8R6VKlejfvz8ANjY2eHh4ZGp7viZJEuPGrcPS8m9y5apN5coDefDg9Xe327nzHC4uHdHQqIWLS0d2776QrMzixXuxs2uNpmYtihfvwfnzd1Otr3v3OSgpVcXDQ/GO59HRMfTpswBj48bkzl2Xhg1H8+7dh5/ez4wiSRLjxq/HMk9zcmnVpXKVQT94/M7jUrAzGpp1cCnYOdnxO3fuLg0ajMEyT3OUlKuzZ8/FZHUoKVdP8TFz1nYAgoLC6NN3IY5OHdHKXY+8Nq3o228RoaGR6bLv6eFnzhGAs2fvULx4DzQ1a5EvXxuWLt2frEx6nJu/+r7IDJl5Dn6pew8PlJSr4zFvl8Ly5csPUrnKIHT1GqKkXJ2QkIif3seMllnnYZKpUzejpFSV/v0XyZfFxsYxbNhyChfuQu7cdbG0/Jv27afh7R3w6zuaSZKuLkzL40+1c+dOWrZsyYoVK7hy5Qq3bt2iX79+v1TXn3uUvmHXrl1MnDgxs5uRqhkztjJ37n8sWNCHa9cWY2amT40aQwkPj0p1m8uXH9CixUTatKmOp+dy2rSpTvPmE7h69ZG8zLZtpxkwYDEjR7bi1q1llCtXiDp1RvD2rV+y+vbsucC1a4+xsDBMtq5//8Xs2XOBLVtGc/68BxERH6lff9QP3zAzo82YuY25c3eyYH5vrl1diJmpATVqDvvO8XtIi5aTaNOmGp63l9KmTTWat5ikcPwiIz9RuIgdC+b3TrUe7/fbFB6rVg5CJpPRtEnilSre3oH4eAcyc0Y37t5ZzprVQzh69DpdusxOvwOQBj9zjgC8euVD3bojKVeuELduLWPEiJb067eQnTvPycuk17n5K++LzJKZ52CSPXsucu3aoxTfw1Efo6lZswQjRrT8tR3MYJl1Hia5fv0xK1YcpHBhxckno6I+cfv2M0aPbsPNm0vZuXMcT5++o2HDMel7AIRMs2PHDtq1a8eaNWto1aoVBgYGnDhxgn379jFhwoSfrk8m/egIrz+UjY0N/fv3l2e2flbSHc1DQvaho6OV5vZIkoSl5d/069eEYcMSPwCjo2MwM/vrf+3ddVhUWR/A8S8gISkhqYIKBmCCAnaB3Wu3u8aaqBjYjbp2d671rt2Bq66BBaKuHbhYiCghBjnvHyOj49BDKefzPvd5lzPnnHvuzzsz55577hlmzepDv37Nky3XseM0oqI+cOTILFla48ZjMDTUZdu28QC4ug6kUiU7VqzwlOWxt+9Fy5bV8fH5TZb24sUbXF0HcezYbJo1G8vQoW3x9GwLQGRkNKambdm8eQwdOtQF4OXLMIoV68ThwzNp2LBKJg887QmE6apGIsGqSEeGDm3N6FEdgS/xs2jPLJ/f6NevWbLlOnacTlTUR44cmSlLa9zY+0v8xinkV1VzZ8/uybRqVT3V9rRuPYn30R/xPflHinn++uss3brPJvr9QQoUUEvPYSrKoqvK9J4jSUaPXs3Bg37cufN1kb7+/Rdw8+ZjLl5cCmTNuZnZ90WG/ETn4IsXYbi6DebYUR+aNR/P0KFt8BzaRiHfmTM3qFffi3dv91KokG5mD/mrH/w8BIiO/oSTUz+WLRvKjBlbqVChJAsXDkyxrVev3sPFZSBPn26jWDGzTB9zVNQHChVqQWRkJPr6+pmuJ+39SL+z/P+bhq6+VqbriY76jJP1hGxvb07T0dFh8+bNtG3bVi79yZMnVK9enVevXmWovnw5kvXt7cLvbdiwAQMDA06ePJmzjfoiKOgVISHv8PBwlqVpampQu3YF/Pxup1jOz+8O7u7OcmkeHs5cvCgtExsbh7//A7l6AdzdneTqTUxMpHv3WXh5tcfBwUZhP/7+D4mLi5erx9LSBEdHG9m+clNQUIg0fu7fxa9Wefz87qRYzu/SHdw9nOTSPBo6czGVMml5/Tqcw0cu07tX41TzRUZ+QF9fO/MdrCyS3nPkW5cu3cHdXT5uDRtW4dq1B8TFxQNZc25m9n2RG3L7HExMTKR7j9l4ebVL9j2c1+XWeZhk0KBFNGniSoMG8vWlJDLyAyoqKlnTSc1BKiqqSm8/o61btyp0sABKlCjB8ePHM1zfzxmlTJo7dy5eXl4cP34cd3f3XGlDSEg4AGZmhnLppqaGsteSL/dOoYyZ2dcyYWGRJCQkppDnnezv2bN3UKCAGkOGKF71Ju1HQ0MdQ0O9VOvJLUltMDMrJJdumkb7QkLCMTP9LjZpxDwtmzafQE9PmzZtaqSY5+3bKKbP2Erfvk0zvZ+skt5z5FspnXfx8QmEhUWmmicj52Zm3xe5IbfPwdlzdlJATZUhg1tnqFxekVvnIcCOHX8TEPAo2dGy5Hz+HIu391o6d66XJXcyhNzXqlUrbt26RdeuXbG3t8fR0ZEePXpw69Ytypcvn+H6RCfrC29vb+bPn8+ZM2dwdXVNMV9MTAxRUVFymzK2bvVFT6+pbEu66lL57qkPiUSikPa95Mt8n4fv8nwt5+//gMWL97Bhw6g09/W99LQvO2zdego9/eayTbn4yf+dXPwyYsOG43TuXA8tLY1kX4+K+kCz5uOwL2vNpIndMr+jLJbaOZJ8fsVYf5+u7LmZej25+5RTXjoHpe/hvWzYMDLX46KsnD4Pnz0LxdNzGVu2eKf4nv1WXFw8nTpNIzExkWXLMjcpOjepoKrU/1R+0u6Dv78/bm5uvH79Gg8PDx4/foy2tjbVq1fn4sWLGa5PLOEAzJs3jw8fPnDt2rU0f2Xbx8eHKVOmZNm+W7SohotLWdnfMTFxgPSqy8Li64TVN28iFK6Mv2VubqRwlRcaGiG7cjMxMUBNTVXhqjg0NFyW59y5W4SGRmBt/XUybEJCIl5eK1m0aDdBQdswNzciNjaO8PD3cqNZoaERuLk5ZPDoldeihRsuLmVkf3+NX7h8/L6JRXLMzQ0Jef1dbN6kXiY1587d4v79Z+zYrjiXBuD9+480bjIWXd2C7NkzGXX13H8rpucc+V5K512BAmoYG+unmicj56a5ufT/M/q+yAl56Rw8d/5f6XvYpossTfoeXsWiRXsIevJnuuvKLbl1Hvr7PyA0NAJn5/6y1xMSEvnnn5ssW7aPz5+PoaYmvaUfFxdPhw5TCQoK4dSpuT/kKJayt/x+1tuF48aNo2fPnixdupSgoCDWrVvHihUrsLe3x9vbm7Nnz2aovp8zShlUs2ZNEhIS+N///pdmXm9vbyIjI2Xbs2fPlNq3np42trZWss3e3hpzcyNOnvSX5YmNjePs2RupdmLc3Ozx9fWXSzt58hrVqknLaGio4+RUSq5eAF9ff1m93bo14MaNNVy/vlq2WVoa4+XVnmPHZgPg5GSHunoBuXpevXrLv/8+le0rJ6UYP9/v4vfPTdzc7FOsx83VHt/vYnPyhD/VUimTmvXrj+LkZEeFCiUVXouK+kDDRmPQ0CjA/n1T03XVnBPSc458z9VV8bw7ceIazs6lZB3HrDg3ixe3yNT7IifkpXOwW9cG3AhcxfWAlbJN+h5ux7GjPhk/uFyQW+dh/fqVuXlzrdznn7Nzabp0qc/166sVOlgPH77g5Mk/MDY2yJLjzmnSn9VRZgmHH3ukNCV+fn706dMHQG7l96ZNm3L16tUM15f7l895QNWqVRk8eDANGzZETU2NkSNHpphXU1MTTU3NbGuLiooKQ4e2wcdnG3Z2RbCzs8LHZxva2lp07lxflq9Hj1lYWprI5g4MGdKG2rU9mT17Oy1bVmf//gv4+gZw7twiWZlhw36he/dZODuXws3NntWrDxMcHEr//tIns4yNDRQ+MNTVC2BubkTp0kUBMDDQpXfvxnh5rcTYWB8jIz1GjlxFuXLFadCgcrbFJb2k8WuNj8927GytvsRvO9ramnTuXE+Wr0eP2VhameAz81cAhgxpTe06w5k9ZwctW1Rj/4GL+J4K4Nw/C2RloqM/8ejRC9nfQU9DCAx8hJGRPsWKmcrSo6I+8Neuc8z9o69C+96//0jDRmP4+DGGLZvHEBX1kago6WP9hQsbyD7Ic0ta54i391pevgxj06YxAPTv35xly/YzfPhy+vRpip/fHdavPyr3NFxWnJvpfV/kBbl5Dhob68tGbpJ8/x4G6YhgSMg7WV23bgWhp1eQYsVMMTLK/SfFcuM81NPTxtGxuFw7dHS0MDLSl6XHxyfQrt0UAgIecvDgDBISEmWjY0ZGemhoZG5VcCHvkEgk6OgojkyGhoZSuHDhDNcnOllfuLm5cfToURo1akSBAgUYNmxYrrVl1KiOfPoUy8CBiwgPf4+LS1mOH5+Nnp62LE9wcCiqql+vJKpVc2D79vFMmLCBiRM3UrKkJTt2TJC7FdmhQ13evo1i2rQtvHr1DkdHGw4f9sHaOmOPHS9YMIACBdTo0GEqnz7FUr9+JTZsmJ7rHYQko0Z2kMZv0JIv8SvD8WOz5OP3LJn4bRvHhIkbmThxEyVLWrBj+zi5+F279oB69b1kf48YsRKAHt3d2bBhlCx9x44zSCQSOnX6+oWaxN//IZcv3wPArlQPudeePN6CjY25kkevnLTOkZCQtwQHh8ryFy9uweHDMxk+fDnLlx/A0tKYRYsG0bZtLVmerDo30/O+yCty+xxMy8pVh5g69esK1rXrDAdg/TovevZsmPEDzmK5dR6m5fnzNxw4IJ2XU6mS/EXU33/Po06dikocdc5SUXJe1c86J6tkyZLcuXMHW1tbQNrpOn/+PJ6enrRq1SrD9eXLdbLq1KlDxYoVWbhwocI6Wf/88w9NmjRh5syZDBkyJM26snqdrHwri9Yoyrd+0vkROUqcg8oT52Gm5fQ6WbdfzEdPv2Cm63kf9QkHq+E/3TpZs2bN4uXLlyxevJgnT55QqlQpAHr06MGSJUvQ1s7YRV2+HMk6c+aM7L+fPn0q91qtWrWIjs57PzEhCIIgCEL2GjNmjOy/ixUrxu3btylevDgaGpmbO5svO1mCIAiCkJ+J24VpK1CgAKVLl1aujixqiyAIgiAIPwhlf+T5Z/2B6BIlSpDaLKqgoKAM1Sc6WYIgCIIgCKDwk3txcXHcunWLw4cPM3z48AzXJzpZgiAIgpDPiMVIk5fSA28rV67M1DpZP2eUBEEQBEFIkXI/qiP9X37i4eHBX3/9leFy+StKgiAIgiAIGfTXX39haJjxn1kTtwsFQRAEIZ8RtwuTV7lyZbmJ7xKJhJCQEMLCwlixYkWG6xOdLEEQBEHIZ8TThcn7flV3VVVVTE1NqVOnjmxh0owQnSxBEARByGek62Rl/qfQftZ1siZOnJil9f2cURIEQRAEQchlYiRLyBt+0qFn4QcizkEhH1FR8nbhzzonK6uJTpYgCIIg5DPiZ3VyhoiSIAiCIAhCNhCdLEEQBEHIZ5KeLlRm+xm1aNGCffv2kZCQkCX1/ZxREgRBEAQhRUnrZCmz/aw6depEkSJFGDVqFPfv31eqrp83SoIgCIIgCBlw4MABQkNDGTNmDPPmzaNcuXLUqFGD9evX8/HjxwzXJzpZgiAIgpDPiN8uTJmenh7u7u6oqqry4sULOnbsyKpVq7CwsKBPnz74+fmlu66fN0qCIAiCICRL3C5Mn8KFCzNo0CAuX77MtWvX0NPTo2bNmukuL5ZwEARBEARBSEFCQgLHjh1j69atHDp0CA8Pj3SXzR9dUUEQBEEQZMTThekzePBgLC0tGTx4MPb29ty5c4cjR46ku7wYyRIEQRCEfEYsRpq869evs3v3bnbv3o26ujrh4eFs376devXqZao+0ckSBEEQhHxGVUVFqdEoVRWVLGxN3uHs7EyFChUYPHgwXbp0wcDAQKn6frquaJ06dfD09MztZmTa8uX7KVGiCwULNsLZuT/nzt1MNf/Zszdwdu5PwYKNKFmyKytXHlTIs3v3Pzg49EJLqxEODr3Yu/d8hvcrkUiYPHkTVlbt0dZuTN26w7l9+6lSx5pdRAyVI+KnvMy2NafiFBMTy+DBSyhcuDW6uk1p2XI8z5+/UeaQs5w4D4Xc4O/vT0BAAAMGDJDrYH3+/JlNmzZluL6frpO1Z88epk2bltvNyJSdO08zbNhyxo7tTEDAKmrUKEeTJt4EB79ONn9Q0CuaNh1LjRrlCAhYhbd3J4YOXcru3f/I8vj53aZjx2l07epOYOBqunZ1p0OHqVy+fDdD+50zZwcLFuxiyZLBXLmyHHNzQzw8RvH+fcbXDclOIobKEfHLGplpa07GydNzOfv2nWf79vGcO7eQ6OhPNG8+LstWuVaWOA+zX9LtQmW2zFi+fDnFixdHS0sLJycnzp07l2r+s2fP4uTkhJaWFiVKlGDlypWZ2m962dvbs337dnx8fJgyZYpsmzBhAr169ZL9nV4qEolEko3t/elFRUVhYGBARMQB9PV1lKrL1XUglSrZsWKFpyzN3r4XLVtWx8fnN4X8o0ev5uBBP+7c2SBL699/ATdvPubixaUAdOw4jaioDxw5MkuWp3HjMRga6rJt2/h07VcikWBl1Z6hQ9swenQnQHolbG7+C7Nm9aFfv+ZKHXdWEjFUjoif8jLb1pyKU2RkNKambdm8eQwdOtQF4OXLMIoV68ThwzNp2LBKdoQlQ/LjeRgV9YFChVoQGRmJvr5+putJez/S76zwiP1KfWdFRX3AsFDLDLV3586ddOvWjeXLl1O9enVWrVrF2rVruXPnDsWKFVPIHxQUhKOjI3369KFfv35cuHCBAQMGsH37dtq2bZvptqemffv2HDt2jOLFi6OmpiZLj4+P5/bt21SoUAGJRML169fTVd9PN5L17e1CGxsbZs6cSe/evdHT06NYsWKsXr1aLv/FixepWLEiWlpaODs7s2/fPlRUVAgMDMzRdsfGxuHv/wAPD2e5dHd3J/z8bidb5tKlO7i7O8mlNWxYhWvXHhAXFw+An98d3N3l6/TwcObixdvp3m9Q0CtCQt7J5dHU1KB27Qopti03iBgqR8Qva2S2rTkVJ3//h8TFxcvlsbQ0wdHRRrav3CTOw5/X/Pnz+fXXX/ntt98oW7YsCxcupGjRoqxYsSLZ/CtXrqRYsWIsXLiQsmXL8ttvv9G7d2/mzp2bbW309fXl3Llz3Lhxg4CAANl26tQpJBIJAQEB6e5gwU/YyfrevHnzcHZ25vr16wwYMIDff/+de/fuAfD+/XuaN29OuXLlCAgIYNq0aYwePTrV+mJiYoiKipLbskJYWCQJCYmYmRnKpZuZGRIS8i7ZMiEh75LNHx+fQFhYZKp5QkLC073fpLzf5zE1/VpPXiBiqBwRv6yR2bbmVJxCQt6hoaGOoaFeivXkJnEe5oysWoz0++/DmJiYZPcXGxuLv7+/whpTHh4eXLx4Mdkyfn5+CvkbNmzItWvXiIuLy4IoKIqMjKRIkSIK6RKJBJVMTPb/6TtZTZo0YcCAAdja2jJ69GhMTEw4c+YMAFu3bkVFRYU1a9Zgb29P48aNGTlyZKr1+fj4YGBgINuKFi2ape39/t9QIiHVf9jvX0u6+/ttenJ5vq8yPftNvp6894SJiKFyRPwyZutWX/T0msq2pJGTzLQ1N+OUF2L5LXEeZi8VifIbQNGiReW+E318fJLdX1hYGAkJCZiZmcmlm5mZERISkmyZkJCQZPPHx8cTFhamfBCSsWHDBvT09BTSDQwM2LBhQzIlUvfTd7LKly8v+28VFRXMzc0JDQ0F4P79+5QvXx4tLS1ZnqpVq6Zan7e3N5GRkbLt2bNnWdJOExMD1NRUFa6GQkPDFa6akpibGylc2YWGRlCggBrGxvqp5kmqMz37NTeX/v/39bx5E4GZWaEMHGX2EjFUjohf5rRoUY3r11fLNhMT6RNJGW1rTsXJ3NyI2Ng4wsPfp7iv3CTOwx/Ls2fP5L4Tvb29U82f0Q5qejrPWal79+5oaGgopL9//55JkyZluL6fvpOlrq4u97eKigqJiYlA8v+4aT0HoKmpib6+vtyWFTQ01HFyKsXJk/5y6b6+/ri5OSRbxtXVHl9f+fwnTlzD2bkU6urSJdDc3BTznDx5jWrVHNK93+LFLTA3N5LLExsbx9mzN1JsW24QMVSOiF/m6OlpY2trJdvs7a0z1dacipOTkx3q6gXk8rx69ZZ//30q21duEudhDpEkKr+BwvehpqZmsrszMTFBTU1NYdQqNDRUYbQqibm5ebL5CxQogLGxcRYEQdGhQ4coXbo0mpqaqKqqyjZTU1P+++8/2d/pla8XIy1Tpgxbt24lJiZGdmJcu3Yt19ozbNgvdO8+C2fnUri52bN69WGCg0Pp31/6xIq391pevgxj06YxAPTv35xly/YzfPhy+vRpip/fHdavP8q2beNkdQ4Z0obatT2ZPXs7LVtWZ//+C/j6BnDu3KJ071dFRYWhQ9vg47MNO7si2NlZ4eOzDW1tLTp3rp+DEUqbiKFyRPyUl9629ugxC0tLE9nTcjkVJwMDXXr3boyX10qMjfUxMtJj5MhVlCtXnAYNKudgpFImzsMc8E1HKdPlM0BDQwMnJydOnjxJ69atZeknT56kZcuWyZZxc3Pj4EH59c5OnDiBs7OzwgBKVhkxYgTu7u7Ur19f7unCyMhIevTowb59+zJUX77uZHXu3Jlx48bRt29fxowZQ3BwsOyphdy4v96hQ13evo1i2rQtvHr1DkdHGw4f9sHaWtrLDwl5S3BwqCx/8eIWHD48k+HDl7N8+QEsLY1ZtGgQbdvWkuWpVs2B7dvHM2HCBiZO3EjJkpbs2DEBF5ey6d4vwKhRHfn0KZaBAxcRHv4eF5eyHD8+Gz097RyITPqJGCpHxC9rpKetwcGhqKp+/ZzJyTgtWDCAAgXU6NBhKp8+xVK/fiU2bJgu96WSm8R5+HMaPnw43bp1w9nZGTc3N1avXk1wcDD9+/cHpNNxXrx4webNmwHo378/S5cuZfjw4fTp0wc/Pz/WrVvH9u3bs62NQUFBTJgwQWF0LWmaUYsWLTJU30+3TladOnWoWLEiCxcuxMbGBk9PT7kV4CtWrEirVq2YPHkyIF3CIemJw3LlyjFixAg6d+7MvXv3KF26dJr7y8p1sgRBEIT8KafXyYp8u1vpdbIMjNtmuL3Lly9nzpw5vHr1CkdHRxYsWECtWtLOcM+ePXn69Kns4TSQLkY6bNgwbt++jaWlJaNHj5Z1yrJDiRIlCAgIoFChQnLpb9++pUqVKjx58iRD9f10nSxlbd26lV69ehEZGUnBggXTzC86WYIgCIKycryTFbYLff3Mj75FRX3EwOSXbG/vjy5f3y4E2Lx5MyVKlMDKyoobN24wevRo2rdvn64OliAIgiD8kBITpZsy5X9Cqf1kjvR3KydnqL5838kKCQlh4sSJhISEYGFhQbt27ZgxY0ZuN0sQBEEQhBy2f/9+ub8/fPjAf//9h7q6Ora2tqKTlVGjRo1i1KhRud0MQRAEQcg5Ofx04Y8iICBAIe3du3d07dqVdu3aZbi+n36dLEEQBEEQvpNF62TlB0ZGRvj4+DB9+vQMlxWdLEEQBEEQhFSoqanx33//ER8fn6Fy+f52oSAIgiDkO+J2YYY4OjpmuIMFopMlCIIgCPmPeLowWfXq1Uvx5/UkEglnzpwhIiKC1q1bc/r06TTrE50sQRAEQRAEpAuWp0VdXZ1KlSqlqz7RyRIEQRCE/EbcLkzW/Pnz08yjo6OTrnwgOlmCIAiCkP+ITlaOEJ2sLPIp/gPq8eIXijJLTVWcisp48+l5bjfhh2elWSy3m/DDS1ATD6xnVoIk45OqhaxXokSJFOdkfS8oKCjNPOKbTRAEQRDyGzGSlazevXszb948qlevjqurKwB+fn5cuHABLy+vDP9Oo+hkCYIgCEI+I5EkIpEkKFX+Z3T79m3GjRuHl5eXXPoff/xBYGAgW7duzVB9YmxXEARBEPKbpCUclNl+QgcPHqRly5YK6a1bt+bAgQMZrk90sgRBEARBEAB9fX1OnDihkH7s2LEM3yoEcbtQEARBEPIhZX9/8OccyRo7dizDhg3jwoULcnOydu3axYIFCzJcn+hkCYIgCEJ+Iya+J2vQoEGUKVOGhQsXsnjxYiQSCWXLluXYsWPUr18/w/WJTpYgCIIgCMIXDRo0oEGDBllSl+hkCYIgCEJ+I0ayUvX582fevHlD4ncT/K2trTNUj+hkCYIgCEJ+IzpZybp37x69e/fm0qVLcukqKipIJBKFTldaRCdLEARBEAQB+PXXX9HQ0ODIkSNYWFigoqKiVH1iCYc8ZvXKI9iX6oOR3i9UdxnOhfO3U81/7p9/qe4yHCO9X3Ao3Ze1q4/Kvd6owTh0NFoqbG1aTpXL9/LFW3r3mE9R866YGLTD1dmT6wGPAIiLi2e89yaqVBpC4ULtKWndk996LeDVy7dZe/BZZNWKQ5S27Y2BTivcqg7h/Ll/U83/z9lbuFUdgoFOK8rY9WbNqiNyr2/edBKtAk0Vts+fY2V5pk3ZqvC6tVUX2etxcfGMG7Mep4oDMNJvQ/Gi3ejdcx4v82AMN605QzXHsdiaDKRJzRlcvvAwxbxH9wfQucVCKtiMoKzlUFrWm8UZ39sKeZrUmoFDEU9KmQ2mYbVp7N5+KYUaYencoxTV68fk0TsV6unSahHlrYdTVK8ft28+U+5As5FEImHy1D+xsu6Ctn5L6jYYxe3b/6VZbvee8ziU74uWbnMcyvdl774LKeb1mb0TVY3GeI5YmWKefgMWo6rRmIWL98qlx8TEMthzOYUtOqBbqBUtW0/m+fM36T/AHLBixUHsSnZHV7sZVasM5Py5W6nm/+fsTapWGYiudjNK2fZg1cpDcq/v3XMel6qDMDFqg4FeC5wq/86fW3wV6nnxIozu3WZjVvgX9HWl+fz9v74Hpk7ZgqP9rxjotaCwcVsaeozm8uV7WXPQOUmsk5WsGzdusGLFCho1akSFChUoX7683JZRopOVh+z63zlGjVjHqDHtuHhlAdVq2NO6+VSeBSf/4fc06DVtWkylWg17Ll5ZwMjRv+A1bC379lyU5dn2vzE8Dt4o265eX4Kamiqt21aX5QkPj6Z+nTGoq6ux9+BE/G8sxWdOLwwMdAD4+DGGwMDHjBnbnguX57P9f948eviSdm1mZG9AMuGv//2D1/A1jPbuwOVri6lew5GWzSYRHByabP6goBBaNZ9E9RqOXL62mFFjOjDccxV798h/uenra/P0+Ra5TUtLQy6PvYO13OvXApfLXvv4MYbr1x/jPa4Tl64uZsdf43j04AW/tJbv7Oa2A7uvMmX0/xjs1YSj58dTtZot3dsu4cWzd8nmv3zxITXrlmXT7sEc+WcsbrVK07v9Mv69ESzLU8hIh8FeTdjnO5oTfhNp37UaI37fpNAZAwj0f8q2jeco61hE4bWPH2Op4loS7yltsu6As8mcuX+xYNEeliwcwJWLizA3M8SjyVjev/+YYhm/S3fp2MWHrl3qE3htOV271KdDZx8uX1H8Ar967T5r1h2lfLniKda3b/9Frly5j6WlscJrniNWsW//Rbb/OYZzp+cS/eEzzVtNJiEh8yuAZ6X/7TzDiGErGePdiav+y6lRw5FmTcen+j5u3mw8NWo4ctV/OaPHdGSY5wr27D4ny2NkpIe3dyfOXVhIQOBKevT04Ldf53Hi+DVZnvDw99SuORx1dTUOHp7OzX9X88cffSlUSEeWx87OikWLB3L9xirO/DMPa2tzmjTy5s2biGyLR7ZIul2ozPYTKl26NG/eZN0Fh4okvb+EKCQrKioKAwMDXoVtR19fW6m6alf3omKlkixa+rssrXK5gTRr4cLUGd0V8o/33sSRQ1cIuLVMljZk4HJu3XzK6XNzkt3H0sUHmD5lG4+DN6KjowXAhLGbuOR3j5OnfdLdVv9rD6lVzYt7j9ZStFjhdJdLSVb9QHRNt2FUrGzLkmUDZWkVHPvRvIUb02f2VMg/bsx6Dh26zI1/V8nSBg1Yyq0bQZy9MA+QjmSNHL6G12//l+J+p03ZysEDflzxX5rutl67+oAabsN48GQDxYqZprtccrLqB6Kb1/XBsUIxfBZ+HYWr6zSJhs0qMmZK63TVUb/KZJq3dcZzTLMU8zSuMZ16DcsxcsLXlZU/RH+mcY0ZzFjQmcVzjuBQvgiTZ3dQKPvsvzCqOY7j2IXxOJQvmoGjS11W/UC0RCLByroLQwe3YvTI9oB05Mi8SGdmzexNvz5Nki3XsbMPUe8/cuTgNFla42bjMSyky7Y/x8jSoqM/4VR1MMuWDGSGz3YqVCjBwnn95ep68SIM1xqeHDs0g2atJjJ0cCs8h0j//SIjP2Bq2ZHNG7zo0L42AC9fvqVYie4cPjCVhh5OmT72rPqB6GpuQ6hUyZZly4fI0so5/EaLltWYMbO3Qn7vMWs5dPASt26vlaUN+H0RN28Gcf7CwhT3U8V5IE2aVGXK1B4AjPVex8WLtzlzdn662xoV9QFjwzYcPzGLevUrpbtcSvVERkZmatHL9O9H+p0VcX8u+noFM1/P+08UKu2V7e3NaadOnWLcuHFMmzaNSpUqoa6uLve6gYFBhuoTI1l5RGxsHNcDHlO/QUW59HruFbl8Kfmh6CuX71HPXT5/A/dKBPg/Ii4u+V9037TBl1/a15R1sACOHLpCJaeSdO04G2ur7rhV8WTDOsUVb78VGfkBFRUVDL65wsttsbFxBAQ8ooG7/AddA/fKXPK7m2yZS5fu0cC9slyau0dl/P0fysUwOvoTdiV6UtK6O61bTCbw+mOFuh49fEnxot0obdubbp1n8+TJq1TbmxTDQoV003uI2So2Np5b14OpVc9eLr1WfXuuXVY83uQkJiYSHf2ZQobJnxcSiYTzZ+7y+OFrXKrbyb02fvh26jUqR826ZTN3AHlEUFAIISHheDT4el5pampQu2Y5/PzupFjO7/Jd3BvIn4se7k5cvCR/7g4asowmTarQIIUv9MTERLr3movX8F9wcFB8Eso/QHpue3xz3ltaGuPoYM3FVNqXU2Jj4wjwf4i7u3xnr4G7U4rxu3TpLg2+y+/h4Yz/tQfJfhZKJBL+PnWdB/efUbOmoyz90MFLODmVomP76Viat8fZaQBr1xxRKP9tW9euOYKBgQ7lK5TIyGHmPjGSlSwPDw+uXr1Ko0aNMDU1xdDQUG7LKDHxPY94GxZFQkIipmaF5NLNTAvhGxKebJnXIRGYmcrnNzUrRHx8AmFhUVhYGMm9du3qA+7c/o8VqwfJpQcFvWbtqmMMHtoSr9Ht8L/2AK9ha9DQKECXbvUU9vv5cywTx22mfcdaSo/eZaWwpBh+HxPTQrx+nUIMX4cnm//bGJYuXZQ164fh6GhDVNRHli05QN1aI7kasARbOysAqlYtzbqNI7Czs+L163BmzdxJ3ZpeBNxcgbGx4lXe58+xTBi3kQ6daueZGL57G01CQiKFTeXba1JYjzevo9JVx+rFJ/n4IZZmbeS/8KIiP1Gl9GhiY+JQU1Nl+vzOcp25/buucutGMIfOjlX+QHJZyJdzzcxM/gPZ1KxQire7AEJCwhXez2amhQgJ+XqrdsfOMwRcf8wVv0Up1jP7j78oUECVIYMUf38taT8aGgUwNNST35dZIVnbc1NYSp+FZoV4neJnYThm3+X/+lkYiYWF9JZpZOQHrIt2JubLebhk6WC5ztmTJ69YtfIQnsPaMNq7I1ev3GeY5wo0NdXp1t1dlu/woUt06ezDx48xWFgYcfS4DyYmGRvhyHUSiZJPF/6cN8FOnz6dpfWJTlYGxcTEEBMTI/s7Kip9Xz7p9f2TDBKJJPWnGxTyJ18PSEex7B2sca5SSi49MVFCZaeSTJneDYCKlUpw904wa1cfU+hkxcXF06PLXBITJSxcIn+LIq/IaAwV8yelS//fxbUMLq5lZK9Xq26Pa5UhLF92kPkLpTFo2NhZ9rpjORtc3cpiX+pX/tx8iqHD5G+zxcXF063zbBITJSxeOpC85vtQSZJJS86+v64w3+cQ63YMwKSwfEdNV0+TYxfG8/FDDOfP3GPa2L+wLm6CW83SvHz+jsmjdrJ1/1C0tNRTqD3v2rrtb/oPXCL7+9D+KUDy51VaTyqldu4+e/YGzxGrOH54hsJ8wCT+AQ9ZvHQ//peXZPipqPS0LyclH4uM5FdM19MryLWA5URHf+b039cZ6bWKEiXMqV2nAiD9LHRytmP6DOktyUqVbLlz5z9WrTos18mqU7ci1wKWExYWxbq1R+nccQYX/BYrXLDlacpOXv9JJ77XqlUrS+sTnawM8vHxYcqUKVler7GJPmpqqgpXaqFvIhWu6JKYmSuO0LwJjaBAATWMjeWvUj9+jGHX/84xflJnhXrMLQwpU1Z+bkvpMkXZt9dPLi0uLp5unebw9OlrjpyYlmdGYJKYJMXw+5i8iUzxw8/MzDCZ/EkxTH6egaqqKk7OpXj08GWKbdHR0cLB0YZHj+TzxMXF06XjLJ4+fc2xkzPzVAyNjHVRU1Ml9LtRq7dv3mNimvqciwO7rzJy4GZWbu6X7O0+VVVVipeUzjtzKF+UR/dfsXTeMdxqlubm9WDC3rynSc2ZsvwJCYlcvvCQjavO8PjtMtSyaK5PdmjR3BWXql874TExcQCEhLyTG01+E6o48vwtc3NDhZGk0DeRshEx/4CHhIZG4Ow6WPZ6QkIi/5z7l2XLD/I5+gDnzv9LaGgE1iW7y+XxGrWWRUv2EfRwE+bmhsTGxhMe/l5uNCs0NAI319y/VWuS0mdhaCSmZsnfrjEzNyQkJKXPwq/nrqqqKra20tHnihVLcvfuM2bP2inrZFlYGFG2rPwt1jJlirJ3z3m5NB0dLWxtrbC1tcLVtSxlS/diw/pjjB7TMXMHLeQZZ8+eTfX12rVrEx8fz4ULF6hdu3aa9YlOVgZ5e3szfPhw2d9RUVEULar85FsNDXUqVS7J36du0KKVmyz9tG8gTZu7JFumqksZjh6+Ipd2yjeQyk62qKvL/9Pu3nWemJg4OnZWPClc3cry8IF8Z+DhwxcU+2ZCe1IH69GjVxw9OT3FDkhu0tBQp3JlW075Xqdlq2qy9FO+12nW3DXZMq6uZTj8XQx9T17HyclOIYZJJBIJN288wcHRJsW2xMTEcf/eM6rXcJClJXWwHj16yXFfnzwXQw2NApSrVIxzp+/SuMXX+T7n/r6LR9MKKZbb99cVvAZsZun636jfqFy69iWRQGyMdK5MjTplOHl5otzrI37fhG0pc34f1jBPd7AA9PS00dP72lmWSCSYmxty8tR1KlWyBaRzd86eu8WsZCZtJ3FzKYvvqQCGDf068nnSN4BqXzo+9etV5GbACrkyvfvMp0zpoozyaoeamhrdutSnQT35uVqNmo2na+d69OrhAYBTZem5fdL3Ou3bSa/aX716x7+3/2O2z69KRCJraGioU9nJDl/fAFq1/voU9CnfAJq3cEu2jKtrWQ4fuiyXdvKkP07OpVJ8H4P03yomNk72d7Vq9jx4IL80yMOHLyhmnfqDKRKJRNa5/mGIxUiTVa9evRTvfiQtRvru3Tvq1auXrqdxRScrgzQ1NdHU1MyWugcPbclvvRZSyckWF5fSrF93nGfPwvitbyMAJo7bzMuXb1m7YRgAv/VtxKoVhxk9ch29entw+fJ9Nm3wZeOWEQp1b97gS/MWLsl+sQ8e2oJ6tUbzx6y/aPNLDa5dfcCGtSdYsnwAAPHxCXTpMJvAwMfs2juBhIRE2VWjkZEuGhp55xbPkGGt6d1jHpWd7HB1LcO6Ncd4FvyGPv2kT3SNH7uRly/fsn6jNEa/9WvCiuWHGDViDb1/a8ilS/fYuP4Em7eOktU5feo2XFxKU9LOkvdRH1m29CA3Ap+wcPHXp0DHjFxLk2YuFC1WmDehEcyauZOoqI907S79/av4+AQ6tZ/J9euP2bt/EgkJCbK5NkZGenkmhn0GNcCzzwbKV7LGqWoJtm48x4vn7+j6q/TLeNakvYS8imDh6l6AtIM1rO8GJs/pQOWqxQl9HQmAlpYG+gbSJ5eWzj1K+crWWBcvTFxsAn+fuMXu7X7MXCB9glFXT4sy9lZy7dDW1sTQSEcuPfzdB14+f8frVxEAPH4YAkBhM31MzfLOfBgVFRWGDm6Fz+yd2NlaYmdrhc/snWhra9K5Yx1Zvh695mJpaYzPDGkshwxuSe16I5n9x/9o2dyN/Qf98D11nXNn5gLSzpzjdx17HR0tjIz1ZOnGxvoK73F1dTXMzQ0pXVq6LIaBgQ69e3ngNXoNxsZ6GBnqMXLMWso52tCgfsVsiUlGeXq2oWePP3ByKoWrW1nWrjlCcHAoffs1BWDc2PW8eBHGxk3S92nffs1YvuwAXiNW8etvjbnkd5cN64/z59avT2XOnrUDJyc7SpS0JDY2jqNHr/LnFl+WLvs6MjjEsw21agxjls92fmlXi6tX7rN2zRFWrPQE4MOHz/jM3Eaz5m5YWBjx9m0UK1cc4vnzMNr+UjPnApQVRCcrWeHhac9LNDU1TVc+EJ2sPOWX9jV59+49s2bsJOTVO+wdrNlzYKLsKiokJJznz8Jk+W2Km7HnwERGe61j9YojWFgaMXfBb7RqU02u3ocPXnDxwh0OHEn+NqeTsx07/vJm4vgt+MzYiY2NGXPm/UbHznUAePE8jMOHpKM9blU85coePTmdWrXTN3qRE9q1r8W7t1HMnL6dkFfvcHC0Zt/BKVjLYvhObt2x4sXN2XdwCqO81rByxSEsLI2Zv7Afrdt8vYKOjIhmwO9LeB0SjoGBDhUqlsT39GyqVC0ty/PixVt6dJ1DWFgUhQsbUNWlNP9cmC/b7/PnYRw6KL3Srur09UMd4LivD7XrZHyRu+zQom0Vwt99YNHsw4SGRFLa3pJNuwZRpJh04vDrkEi5NbO2rj9HfHwi44dvZ/zw7bL0Xzq7sWBVT0B6q3rc8O28ehGOVkF1bO3MWbS2Ny3aVslQ204eucGI3zfJ/h7YU/q4/jDvZgwf2zyzh5wtRnm149OnWAYOWUZ4eDQuVUtz/PAMuRGv4GehqKp+vVqu5mbP9j/HMGHSZiZO3kLJEhbs2OotdysyqyyY248CBdTo0NmHT59iqV+3Ahv2jkBNTS3L95UZ7TvU4e2798yYvpVXX97HBw9Nx9raDJCOvD17Jv8+PnhoOiNGrGLF8oNYWhqxYOHvtGn7tePz4cNnBg9ayvPnYRQsqEHpMkXZtHkU7TvUkeWpUqU0u3ZPZNy4DUyftpXixc2ZN78/nbtI56aqqaly/95ztmyeRlhYFMbGejg7l+L02Xk4ONjkSGyE7JXSchRxcXFcvHhRdoswvctWiHWylJSV62TlZ1m1TlZ+lVXrZOVnWbVOVn6WVetk5Uc5vk7WjSno62mlXSClet5/plCFST/dOlkAfn5+PH36lNjYr7/qERkZiaenJ+vXr0dFRYUePXqkqy7xzfadjRs30qtXL0TfUxAEQfhpJUqkmzLlf0IDBw5k5cqV6Orqyo3sJs3TGj58OBKJRHSyMuvp06fpemJAEARBEISfy//+9z9OnjxJvXryyxe9efMGMzMz3r1L/ifGUiI6Wd85fvw4ixalvNCfIAiCIPzwJEquk/WTTnx/9+4dFSooPk2d5pqVKRCdrO/4+fmlnUkQBEEQfmRiMdJkTZo0CW1txfnVurq6TJo0KcP1iU6WIAiCIAgCMHGidM2+R48ecefOHVRUVChbtiy2tray1zJCdLIEQRAEIb8RE9+TFRERQa9evThw4AAFCki7SHFxcTRv3pxNmzZRqFChDNUnnrcVBEEQhPwm6XahMttPyNPTk0ePHnHhwgU+f/7M58+f8fPz4/HjxwwZMiTD9YmRLEEQBEHIbxIlSs7J+jlHsg4cOMDBgwdxdf36U2wuLi6sXr2aZs2aZbg+MZIlCIIgCIIAxMbGoqurq5Cup6dHTExMhusTnSxBEARByG+S5mQps/2EateuzZgxY3j79q0s7d27d4waNSpTa2iK24WCIAiCkN+IJRyStXjxYpo2bUqxYsUoVaoUKioq3L9/HysrK44cOZLh+kQnK4sUTJBuQib9nBdFOcZKyya3m/DjS4zP7Rb88OJEDDMtLjEut5sgACVLluT27dscOHCAO3fuIJFIKFu2LK1atcrUD6iLTpYgCIIg5DdiCYcUqamp0bp1a1q3bq10XaKTJQiCIAj5jbhdmKxNmzal+np6fxg6iehkCYIgCIKQZ4SHhzNkyBAOHDgAQIsWLViyZEmqC4H27NlToYPk4uLCpUuXMrTvYcOGyf0dFxfHx48fKVCgANra2qKTJQiCIAhCGvLwD0R37tyZ58+fc+zYMQD69u1Lt27dOHjwYKrlGjVqxIYNG2R/a2hoZHjf7969U0h7+vQp/fr1Y8SIERmuT3SyBEEQBCGfkUgkSCSZn1elTNnU3L17l2PHjnHp0iVcXFwAWLNmDW5ubty/f5/SpUunWFZTUxNzc/Msb5ONjQ2zZs2iS5cu3LlzJ0NlxTpZgiAIgiDkCX5+fhgYGMg6WACurq4YGBhw8eLFVMueOXMGU1NTSpUqRZ8+fQgNDc2ydqmoqPDs2bMMlxMjWYIgCIKQ32TRxPeoqCi5ZE1NTTQ1NTNdbUhICKampgrppqamhISEpFiucePGtGvXDmtra4KCgpgwYQL16tXD398/Q+3Zv3+/3N8SiYRXr16xdOlSatSokf4D+UJ0sgRBEAQhv8miTlbRokXlkidNmsTkyZMVsk+ePJkpU6akWuXVq1cB6ajR9yQSSbLpSTp06CD7b0dHR5ydnbG2tubw4cO0adMm1f1+6/u8KioqmJqaUr9+febOnZvuepKITpYgCIIg5DdZtE7Ws2fP0NfXlyWnNGo0aNAgOnbsmGqVNjY23Lx5k9evXyu89ubNG8zMzNLdPAsLC6ytrXn48GG6ywAkJGTtquKikyUIgiAIQqbo6+vLdbJSYmJigomJSZr53NzciIyM5MqVK1StWhWAy5cvExkZSbVq1dLdrrdv3/Ls2TMsLCzSXSY7iInvgiAIgpDfJN0uVGbLBmXLlqVRo0b06dOHS5cucenSJfr06UOzZs3kniwsU6YMe/fuBSA6OhovLy/8/Px4+vQpZ86coXnz5piYmGTJqu3KEJ2sPEgikTB5+nasivdE27AddT3GcftOcJrldu+9iEOlgWgZtMWh0kD27veTe7146T6oFmypsA30XCnLEx39iUGeqyhasjfahu2wrziQFauPytWzet1x6nqMw8C0I6oFWxIREZ01B55FJBIJk6dtxcqmG9oGranrPobbd/5Ls9zuvRdwqNAfLb2WOFToz979ik+yvHgRRreef2Bi0RGdQm2oVGUQ/gHS4ei4uHhGj11P+coD0DVsg5VNN3r0nsfLl2/l6li99ih13cdgYPILqppN81z84EsMp27BqlgntPWaU7f+SG7ffppmud17zuFQvg9aOs1wKN+HvfsuyL2+YuVBKlTqj4FRawyMWlOthidHj12VvR4XF89o77WUr9gPXYMWWBXrRI+ecxRiWLf+SFTVG8ptnbrMzJJjzwrZdQ5OnrYVVc2mcptFsS5yefbsu0CjphMobNkJVc2mBN54rLCfuu5jFOrp1HW2cgedxVatOExZu18x1G1DtaqeXDh/O9X85/65RbWqnhjqtsG+1G+sWSX/udWwvjfa6s0VttYtkp8n9Mfsv9BWb87I4WsUXrt39xm/tJ6GuXEHTA3bU7u6F8+Cs+5JthyRKFGyk5V9P6uzdetWypUrh4eHBx4eHpQvX54tW7bI5bl//z6RkZGA9Gdwbt26RcuWLSlVqhQ9evSgVKlS+Pn5oaenl23tTA/RyUpGnTp18PT0zLX9z5m3hwWL97NkQT+unJ+LuVkhPJpO5P37jymW8bt0j47d/qBr57oEXllE18516dD1Dy5fuS/Lc+X8XF4GbZRtJw5LP1zatakuyzNs1DqOnwxgy4Zh3AlciufgFgwZvpr9By/L8nz8GEND90p4j/wlG45eeXPm7WLBor0sWdifKxcXYG5miEeT8WnE7y4du8yia5d6BF5dStcu9ejQeRaXr9yT5QkPf0+NuiNRVy/AkQNTuB24grmzf6OQgS4gjcv1648ZP7YT/pcWs3vnOB48fEHLtlPl9vXxYwwNPSrjPbp99gQgC8yZ+z8WLNzDkkUDueK3BHNzQzwae6ceQ787dOw8k65d6hPov5yuXerTodMMLl/+GsMiRQrjM7M3Vy8t4eqlJdStW4FWbSbLOnDSGD5i/LjO+F9Zxu7/TZTGsPUkhf399mtjXj7bLttWLh+a1WHItOw6BwEc7K15+d8W2XbTf7nc6x8+xFCtWll8pvdMtY2/9W4oV8/KZYMyfbxZbdf/zjFqxFpGjWmP39VFVK/hQKtmk1PsyDwNCqF18ylUr+GA39VFjBzdDq9hq9m352snf/tfY3nybLNsuxa4FDU1Vdq0ra5Q37WrD1i/9hjlytkovPbk8Ssa1BlN6dJFOOY7k8v+ixkzrgOaWhlf+FJInpGREX/++SdRUVFERUXx559/Kqz2LpFI6NmzJwAFCxbk+PHjhIaGEhsby3///cfGjRsVJuXnBhVJdq0o9gOrU6cOFStWZOHChWnmjYqKwsDAgIjX29HX11Z63xKJBKsSvRg6sDmjvdoCEBMTh7l1D2ZN706/3xolW65j1zlEvf/Ekf1fv4wat5iMYSFdtm32SraMp9daDh+9yoN/V8qe2ijnNJj2v9RggvfXJzWcqw2ncUMnpk2Sv2I+888t6jUcz7tXWylUSFep40Y1a6YHSiQSrGy6MXRwS0Z7tQO+xK9oF2bN6EW/Po2TLdexyyyioj5y5ODXDlHjZhMwNNRl25bRAIwZt4GLfnf55+856W7P1WsPcKk+jKcPN1CsmPxjyWfO3qSehzfvXu/MM/GDLzEs1pmhQ1oxeqT0PIiJicXcqiOzZv5Kv75Nky3XsfMMaQwPzZClNW46FkNDPbb96Z3i/oxN2zJnVh9+7Z38uX316n1cqg3h6eMtshjWrT+SChVKsHD+75k9TEWJ8VlSTXaeg5OnbWX/AT+uX12aZjuePn1NidK9CbiymIoVSsq9Vtd9DBXKl2DhvL6ZPcxkfVbNmltItaqNoGKlkixeNkCWVqnc7zRv4crUGYo/azLeeyOHD13m+q0VsrTBA5Zx62YQZ84n/0TY0kX7mTZlK0+ebUZHR0uWHh39iWpVPVm45Hdmz9xJ+Qol+GN+H9nr3bvMQb2AGus2ZXz179RERX3E3LgDkZGR6ZrjlPn9SL+zwvf1RV8n8x3DqA+xGLZane3t/dGJkaw8Jujpa0JCwvFoUEmWpqmpTu2aDvhdupdiOb/L93GvX1EuzaNBJS6mUCY2No6tO87Qq0cDucdiq1cry8FDV3jx4i0SiYTTZ2/y4OELGn7TnrwsKCjkS/wqy9Kk8XPE79LdFMv5Xb6H+3fH6OFemYvflDl46DJOlW1p32kmZkU6U7nqYNasO5ZqeyIjP6CioqJ8JyoHSWP4Do8GTrI0TU0Natcqh59fyqsd+126i/s3ZQA83J25mEKZhIQEduw8w4cPMbi5lk2x3siopBjqyKVv236awubtcKzQB69Rq1MdJcpJ2XkOAjx89BIrm26UKNWbTl1n8+TJq0y1c9uO0xS27IRjxd/xGr02z8QvNjaO6wGPqO8uH4v6DSpxyS/5+F2+dI/638WugUdlAvwfEReXfOd504aT/NK+llwHC2DY4JU0auxMve8+TwESExM5duQatqWsaNFkItaWXalVbQQHvpua8UPIo3OyfjY/dCdr9OjRlCpVCm1tbUqUKMGECROIi4uTvT558mQqVqzIli1bsLGxwcDAgI4dO/L+/XtZng8fPtC9e3d0dXWxsLBg3rx5qe4zJiZGNoSZtGWlkJBwAMxMDeTSTU0LEfI6POVyryMwMy0kl2aWSpl9By4TEfGBnl3ryaUvntcH+7JFKWrbG039tjRuMYVli/pTo7p9Jo4m5yUd7/exMDUtJIttsuVCwjEzM5RLMzMzlCvzJCiElauPYGtrxbFD0+jXpwlDh69i85+nkq3z8+dYvMdvpHPH2lkyyplTQkKkv931fTxMTQ1TPwdDwjEzKySXZmamGPdbt4LQK9QSLZ1m/D5wMXt2TcTe3jrZOj9/jsV77Ho6d6yLvv7XTlbnTnXZ9ucYTvv+wfixXdiz9zxt201Nto6clp3noEuV0mxaP4Jjh6axesVgQl6HU72OF2/fZuxzqHPHOmzbPIrTJ30YP7Yje/ZepG37GWkXzAFhYVEkJCQqxs+sEK9fRyRb5vXrcEy/P/dMCxEfn0BYmGJsrl55wO3b/9Gzt4dc+l87/yHw+uNkR8sAQkMjiY7+xLw5u3D3qMyBI1Np0cqVTu18OPfPrXQfo5B//NBLOOjp6bFx40YsLS25desWffr0QU9Pj1GjRsnyPH78mH379nHo0CHCw8Np3749s2bNYsYM6QfKyJEjOX36NHv37sXc3JyxY8fi7+9PxYoVk92nj49PmguqZcTW7WfoP/jrEPehvRMAxcXY0lqILaNl1m86SeOGTlhaGsulL152iEtX7rN/1zisi5nyz/nbDBy6EgtzQxrUq5jew8oxW7efpv/Ar7dODu2bDCQTCyCN8Cm8/n38EhMlODvZMnOa9AO4UsWS3L7zHytXH6F71/pyZePi4unUdTaJiRKWLR6YsYPKYVu3/U3/AYtkfx86MA1IKR6p16V4DirWU7p0Ea5fW05ExAd27z1Pz95zOXPqD4WOVlxcPJ26zJTGcKn8fKE+vzWR/bejow12tlZUcR1EQMBDKle2S72RWSwnz8HGjZxl/13O0QY317LYlv2VTVtOMdwz/U9R9fn1661ZRwcb7GwtqeLmScD1R1SuZJvuerJT8p9nGcufXDrApg0ncHCwpkrVUrK058/eMHL4Gg4cmYpWCvOrEr+M3jRr4cJgz1YAVKhYgkt+91i7+hg1a5VL87jyjCxajFRI3Q/dyRo/frzsv21sbBgxYgQ7d+6U62QlJiayceNG2RMG3bp149SpU8yYMYPo6GjWrVvH5s2bcXd3B2DTpk0UKVIkxX16e3szfPhw2d9RUVFKTa5r0awqLlW/PpYaEyMdiQt5HYGFhZEs/c2bSIUru2+ZmymOWoWmUOa//0Lx/fsmu3eMkUv/9CmGcZP+ZM9Ob5o2ln6Yly9nQ+DNJ8xbuC9PdrJaNHPBpco38YtNil+4fPxCIxRGCb5lbm6oMMoQGhohNzJjYWFI2bLF5PKULVOUPfvknwCLi4unQ+dZBD19zanjM/P8KFaL5q7Jn4Mh4VhYfO2Ev3kTgZlpZmIoX0ZDQx1bWysAnJ1Lce3afRYt2ceqFV8nrsfFxdOh0wyCgkI4dXKO3ChWcipXtkVdvQAPH73I8U5WTp6D39PR0aKcgw0PH73MZOulKldKit/LXO9kmZjoo6amqvB59iY0EtMUPgPNzAx5/X3s3kRSoIAaxsbyT5d9/PiZXf87x4Tv5pgGBDwiNDSC6i6esrSEhETOn7vNyuWHiPiwBxMTfQoUUKPMd58DZcoU5eKFjP1wcK6TKLkYqZjOnS4/9O3CXbt2UaNGDczNzdHV1WXChAkEB8svdWBjYyP3CKeFhYXsRyMfP35MbGwsbm5usteNjIzS/JXvpMXX0rsIW2r09LSxLWkh2+zLFsXc3JCTpwJleWJj4zh77jZurmVSrMfNpTS+f9+QSzt5KpBqyZTZsOUUpqYGso5Ukri4BOLi4lFVlb/yU1NTIzEbH9dVhp6eNra2lrLNvmwxafx8r8vySOP3b6rzftxcyuD7TcwBTvpep9o3Zaq72fPgwQu5PA8evsC6WGHZ30kdrIePXnLy6AyMjfP+hFBpDK1km729NebmRpw8FSDLExsbx9l/buHmlvJtYzfXsvh+UwbgpK8/1VIpA9LP6tiYr7f5kzpYDx+94OTxWemK4e3b/xEXFy/XKcwpOXkOfi8mJo67959hYZFy5y09bt/5Ej9zo7QzZzMNDXUqVbbl72/iB/D3qUBc3ZKPhYtrGf7+LnanTl6nspO08/it3X+dJyYmjo5d6sil161XgavXl3Lp2mLZVtnJlo6danPp2mLU1NTQ0FDHydmOh/efy5V9+PAFxawLIwjf+2FHsi5dukTHjh2ZMmUKDRs2xMDAgB07dijMqVJXV5f7W0VFRTbkmxcfrFRRUWHowOb4/LELO1sL7Gwt8ZmzC+2CGnTuUEuWr8evC7C0NMZnWncAhgxsTm33scyeu5uWzV3Yf/Ayvn/f4NwpH7n6ExMT2bj5FN271KVAATW51/T1tald05FRYzdSsKAG1sVMOXvuX7ZsPc282b1l+UJCwgl5Hc6jx9IJt7f+/Q89vYIUK1oYI6PcXZNERUWFoYNb4jPnf9jZWUrjN/t/aGtr0rljbVm+Hr3nSeP35TH3IYNaULv+aGbP/YuWzVzZf+gSvn8Hcu701ycJPYe0onptL2bO3kn7tjW5cu0Ba9YdY9XywQDExyfQruNMAgIfc3DvJBISEmTzm4yM9NDQkJ6LISHvvovf0y/xM831+MGXGA5phc+sHdjZWmFna4XP7O3SGHaqK8vXo+ccLK1M8JkhPTeGDGpF7XpezP5jJy2bu7H/oB++p65z7sx8WZmx49fTuFEVihYpzPv3n9jxvzOcOXuTo4enA19i2GEaAdcfcXDfVBISEhVi+PjxS7Zu/5smjapiYqLPnbvBeI1aTaWKtlSvlvtzB7PzHPQavZbmTV0oVrQwoW8imOGzk6ioj/To2kCW59279wQ/C+XlS2nc7n+5MDA3M8Tc3IjHj1+xdcdpmjSqgonxl/iNXkuliiWpXi3lDl1OGuLZil97zqeykx0urmVYv/YYz4Lf8Ftf6ZOZE8dt4uWLt6zdKL2r8FvfRqxcfojRXmvp9WtDLl+6x6YNJ9n0p+KT1Zs2nKR5S1eFzruenjYOjvK3rHV0tDAy1pdL9xzRhu6d51C9piO165TjxPEAjhy6wnHfvLNOW7qI24U54oftZF24cAFra2vGjRsnS/vvv7QX+/uWra0t6urqXLp0iWLFpMO/4eHhPHjwgNq1a6dROvuMGtGGT59jGei5ivDwaFyqlOL4oSno6X297RT8LAxV1a8DkdXcyrJ9sxcTpmxl4tRtlCxhzo4tI+VuAwH4/n2D4Gdv6N2jAcnZvtmLsRM307XnfN6FR2NdrDDTJ3elf5+vczhWrj3G1Bk7ZH/Xdh8LwPrVQ+jZrb5CnTlt1Ihf+PQploFDlkvjV7U0xw9P+y5+b+RG7Kq52bP9z9FMmLSFiZP/lMZv62hcqn4dCaziXIo9/xvP2AkbmTZjO8VtzFgwty9dvnQ8nj8P48Ah6XpilaoMlmvT3yd8qFO7PAAr1xxl6vRtstdq15c+nr9+jSc9u7tncTQyZ5RXe2kMBy8lPPw9LlXLcPyITzIx/OYcrObA9q1jmTBpIxMnbaZkSQt2bBuLi8vXGL5+HUH3nn/w6tU7DAy0KV+uOEcPT5c9lfj8+RsOHLwEQCXnr4/vA/ztO4c6tSugoVGAv/8OZPGSfURHf6ZoUROaNHZh0oQuqKnJXzjkluw6B1+8eEvn7nMIC4uicGEDXKuWxu/cfKytvy4PcuDQJXr3WSj7O2mR0YnjOzN5Qhdp/E7fYPHSA0RHf6JokcI0aVyFSeM755n4/dK+Jm/fRuEzYwchr95h72DN3oOTKPblOENevePZszey/DbFzdl7cBKjRqxl1YrDWFgaMXdBX1q1kV8D6+GDF1y8cIeDRzP/kETLVm4sXjaAuXP+wmvYauxKWbHtf95Uq+GQ6Tpzhehk5Ygfdp2s/fv388svv7BlyxaqVKnC4cOHmTJlCgkJCURERADSpwv37dtHYGCgrNzChQtZuHAhT58+BeD333/nyJEjrF+/HjMzM8aNG8fff//Nr7/+mivrZOVbWbjOU74k4qe8LFonKz/LqnWy8qMcXydra1f0tZVYJ+tjLIZd/hTrZKXhh52T1bJlS4YNG8agQYOoWLEiFy9eZMKECRmu548//qBWrVq0aNGCBg0aUKNGDZycnNIuKAiCIAiCkIofdiQrrxAjWVlEjMQoR8RPeWIkS2liJCvzcnwka0tn5Ueyum0TI1lpEJ/MgiAIgpDPSBIkSBIyP8aiTNn8JE/dLnz69CkqKirp2hwdHXO7uYIgCIIgCCnKUyNZ6urqqa5R9a0SJUpkc2sEQRAE4SeVqORipHl07cS8Jk91sqysrLh3L+UfQRYEQRAEIQskSKSbMuWFNOWp24WCIAiCIAg/izw1kiUIgiAIQvaTSCRIlLjlJxYmSB/RyRIEQRCE/CYBJW8XZllLfmqikyUIgiAI+U1ConRTpryQJjEnSxAEQRAEIRuIkaws8nHqagpoinBmVsHurrndhB+aipllbjfhx6ddKLdb8MPTvHoxt5vww9L8EJuj+5MkKjknSyzhkC6iVyAIgiAI+Y1YwiFHiNuFgiAIgiAI2UCMZAmCIAhCfiNWfM8RopMlCIIgCPmM+IHonCFuFwqCIAiCIGQDMZIlCIIgCPmNJBESlVjrSiLWyUoP0ckSBEEQhPxGPF2YI8TtQkEQBEEQhGwgRrIEQRAEIZ8Ri5HmDNHJEgRBEIT8RtwuzBGik5UHSSQSZvo9YcOt50R8jsfZwoD59cpgb6KbYpm4hETmXgli251XvIyOwc5Qm2k17XAvbiLLs+bGM9beeE5w1CcAyhrrMsa1BB5f8sQlJDL1wmOOB4XxNPIj+poFqFvMmKk1bbHQ1ZLb3+WXEUy58IhrryJRV1OlXGE99rauREF1tWyISMZIJBKmrvyHNXsCCI/6jIujFUu8G+Fga5qu8juO/UuXMXtpUacUexd2kKXPWneevafuce/pWwpqFsCtQhFmedantM3XGKtVnJZsnbM96+PVs5pCO5sO2s7xC4/ZPb8dreqVycTRZg+JRMKUeYdZ8+d5wiM/4lLJhqU+HXEonfLP96z58zxb/rrEv/dfAuBUvhgzvFtRtZJNsvl9Fh9jnM9+hvxWl4XT2svSoz98ZsyMfew/doO34R+wKWLM4N/q8HuP2gC8C//ApLmHOHn2Ds9ehGNipEvLxhWYNqoFBvoFsy4ISpBIJEyZtZs1G08RHvEBF2dbls7thUPZoimWuX33GZNm7ML/xhP+Cw5jvk83PAc0kcuzYu1JVq4/ydPgMAAcyhRhwug2NHavKMvzOjSCMZO2c+Lvm0REfqRWtTIs/qMndiUtAHj63xtKlB+SbBt2bhxKu9Z54yeuJBIJUzdfYc2R24S//4xLGXOWDKmNg41ximU2Hr/Lr3/4KqR/OPI7WhqKX3eztl1j3Ho/hrSpwIIBtWTp0Z9i8V57kf0XnvA26jM25voMalWB31uUkyvvd+cVE9Zf4vK9ENTVVKlYsjCHfVpQ8Ef4iTXRycoRP8CZkP8suPqUpQH/sbKhA7aGOsy5/IQWu/253qs6esl8UABMvfCYHXdfsdS9LKWMdPD97y2dDtzgVKcqVDDVB8BKV4upNWwpYagNwNbbr+iwP5ALXV2xN9HlY3wCgaFRjHYtTrnCekR8jmP0mQe03x/IuS5fP3gvv4yg9Z7rjKhqw9y6ZdBQU+HWm2hUVVSyPzjp8MfGiyz48xLrp7aglLUxM9aco+HvW7m7bwB6Opqplv3vZQSj5vtSs3IxhdfO+gfze4cqVHGwID4hkfFLz9Do9238u6c/OgU1AHjhO0yuzNHzj+gz5SBtGpRVqG/Rn5dRIW/E7Htzlp1gwapTbFjYnVIlTZmx8CgeHRZz7/xk9L7rcCc5e/EBHVtXoZpzCbQ01Zmz/AQNOy7m3zMTsbIoJJf3auBT1vx5nvL2Vgr1DJu4izMXH7BlaS9sihpz4swdBnrvwNKsEC0bVeDl6whehUTwx8S22Jey4L/nb/l99HZehUTy19q+2RGODJuz8CALlh1hw/L+lLK1YMYfe/FoNZN71+ajp5d8R/Djx1iK25jySysXho/dkmyeIlZG+EzuhG0JcwA2bfuHVp3mEnDOB4eyRZFIJLTuPB91dTX2bfNCX78g85cewb3lTG5f/gMdHS2KFjHm5YMVcvWu3niKPxYdlOus5bY/dgawYPd11o9sQKkihszYepWGo/dzd0NX9LQ1Uiynr63B3Y1d5dKS62BdvfeaNUduU76EYqdt+PJznLnxgs1jPLAx1+fEtWAGLT6DpbEOLauXAKQdrCZjDjCmkxOLBtVCo4AaN56E5ZnPQSFvyPcT3ydPnkzFihVzuxkyEomEZdeDGVm1OC3tzHAw0WV1Q0c+xSfyv3shKZbbfvclXi7FaViiMMULadOnQlEa2Biz+Np/sjxNShamYYnC2BnqYGeow+Qatuiqq3H1VSQABprqHPzFibalzSllpENVy0LMrVea66/f8+zL6BfAmDMP6F+pKCOqFsfeRBdbQx1alzJDs0Dun04SiYRFW68w9rcatKlfFkdbUzZOa8nHT3FsO/pvqmUTEhLpNnYfk36vTXGrQgqvH13emZ4tK+Bga0qF0uasn9Kc4FeR+N95JctjbqIrtx04c5+6VWwoUcRQrq4b90NY8Odl1k1pniXHnZUkEgmL1vzN2KGNaNO0Eo5lrNi4qAcfP8Wybc/VFMv9ubw3A3rWpqJjUcrYmbNmblcSEyWcOndPLl/0h890HbiB1XO7YGigrVDPJf8ndG/nSp1qpbApakzfbjWpYG/FtRvSc9mxjBW71vWjuUd5StoUpl6NMkwf04KDJ28RH5+QtcHIBIlEwqIVRxk7ohVtWlTF0b4oG1f+Lo3fXxdSLFfFqSR/TO9Cx1+qoZnCSEjzxk408ahEKVsLaedtYgd0dbS4dPURAA8fh3Dp6kOWz+9NFaeSlLazZPn83kRHf2b7LumPN6upqWJuVkhu23fwKu1bu6GbQgc6p0kkEhbtCWRs5yq0qWmLY3FjNo5y5+PnOLb9/SDVsioqYG6kI7d9L/pTLN18TrBqWF0MkznmS3dD6O5RhjoVi2Bjrk/fZo5UKGmC/4NQWZ4Ry88xuHUFRndyxsHGGLsihfilli2aGrk/mp8eSXOylNmEtOX+t6Ig52nkJ15/iKX+N0PimgVUqVHEkMsvI1IsF5sgQUtN/p9Tq4AqfimUSUiU8Ne9ED7EJ1DV0iDFeqNi4lFB2gEDCP0Yy9WQSApra1B/+xWKrzxLw51XufgiPN3HmJ2CXkQQEhaNu1sJWZqmRgFqOVvjF/g81bLTVv2DiaE2v7aulK59RUbHAGBkkPzIxOu30Rw5/4herSrKpX/8FEcX770sHtMI81RuAeeWoOAwQkKj8KhtL0vT1FSntpsdftcep7uej59iiYtPwMhQ/ktukPcOmtR3pEEtxdE9gOpVbTl44iYvXkUgkUg4feE+D56E0rCOfbL5ASKjPqGvq0WBArn/BRf0NJSQ1xF41Pt6a0lTU53a1cvidyX1DkJGJCQksmPXRT58jMGtqh0AMTFxAGhpfh3pUVNTRUOjABcu3U+2Hv/rTwi89R+/dq+bZW1TVtCrKELefcTd6euIsqaGGrXKW+F3+1UqJSH6UxzFO2+kWMf1NB93kOsP3yjkGbT4LE1cbGjgpDhiDVDd0ZKDF4N4ERYtPQcDn/PgeQQeztL8oeEfuXzvNaaFClJjyF9Y/LKWusN3c/7WSyWOOoclJCq/CWkStwvzmNcfYwEw/W44vLC2Bs+iPqdYrr61MUsC/qN6kUKUKKTNmeB3HH78hgSJ/NXGv2/eU3/HVT7HJ6Krocb25hUoa5z8F/3n+AQmnn9I+zLm6H+5sn4a8REAH78nzKhlR3lTPbbdeUWzXf5c6e6GraHiVWNOCgmLBsDMSP6YzIx0+O/LiF1yLlx/xvp9gQTsTN/tJolEwoh5J6hRqSiOKcz12nzgJnraGrSpL9+ZGD73BG4VitCybul07SunhYRGAWBWWE8u3dREn+Dnb9Ndz5gZe7EyL0SDml/nmu3Yd5WAW8+4cnRMiuUWT29PX68/KVrZmwIFVFFVVWXN3K7UcLFNNv/bd9FMX3CUvt1qpLtt2SkkVHqemZnKX7yYFjYg+FmY0vXfuh1MNfeJfP4ch66uFnu2Dse+TBEAypSyxLqYCWOnbGflwt/Q0dFi/tLDhHy5xZqcdVtOU7a0FdVcSindtqwSEi79nDEzlL+AMTPU5r/X71MsV6aoIetHNaBccWOiPsayeM8Nanru4vqqTtgVKQTAjtMPuP7wDZeXt0+xnkUDa9F3/t8U67iBAmqqqKrC6uH1qVFOOifxySvpe2TK5ivM6VediiULs+XkPdxH7eXmmi6yfQlCnh/Jev78OR07dsTIyAgdHR2cnZ25fPmy7PUVK1ZQsmRJNDQ0KF26NFu2yM9lCA4OpmXLlujq6qKvr0/79u15/fp1ivsLCgrC1taW33//ncRkVsONiYkhKipKblPGzruvMFvyt2yL+3J1oDBXR0Kqs3fm1C2NbSFtKm+8iOHCU4z4+x5dHSxR+25+QCkjHS52deV0pyr8Vr4IfY/f5u7baIX64hIS6Xn4FokSWPBNJyEpIr3LW9HN0YoKpvrMrlMaO0Mdtvyb81dxWw/fQt9tlmyLi/8Sv+/DJwGVFOZKvP8QQ/dx+1g1sRkmhoq3r5Iz2OcYtx6EsnVWmxTzbNgfSOcm5dD65tbPgTP3OX3lKQtGNkzXfnLC1t1X0CvpKdvi4qS33L6Pl0QiSTGG35uz7AQ79l1j97q+aGlJR0GfvXiH54S/2LK0lywtOYvXneZSQBD7N/3OtePezJ3UloHe2/H9565C3qj3n2jWbRn2pcyZNKJZeg85S23933n0LHvKtri4eCCl+Cm/v9J2llw/Nws/36n0792Anv1XcOeedJRWXb0AuzYP48HjEIxt+qBj3oOz5+/Q2L0iamqKH/efPsWyfddFenero3zDlLD11H30m62UbV/fxxmLoau9OV0blKFCycLULGfFzgmNKVWkEEv33QDgWeh7hi37h83e7snO00qyZO8NLt8NYd+0Zlxd0YG5/WowaPEZfP2DAUj8cvHat5kDvRrZU8muMPMH1KR0EUM2HLujTChyjESi5O1CibhdmB55eiQrOjqa2rVrY2VlxYEDBzA3NycgIEDW+dm7dy9Dhw5l4cKFNGjQgEOHDtGrVy+KFClC3bp1kUgktGrVCh0dHc6ePUt8fDwDBgygQ4cOnDlzRmF///77Lx4eHvTo0QMfH59k2+Tj48OUKVOy7BiblCyMs/nXK96YL52s1x9jMNf9Okn7zadYTHVSnuxZWFuDHS0r8jk+gXef4rDQ1WTiuUdYf3crS0NNlZJfOhKVzQ3wfx3F8oBglrh/vRUTl5BIt0M3eRr5icPtnGSjWADmXyaOl/lupKi0kQ7P3qc80pZdWtQphUu5r5OnY2KlX3Ahb6Ox+GYkJjT8A2bJzM0AePwsnKcvI2g5dIcsLfHLfAMNp+nc3TeAkkWNZK8NmXWMg2cfcGZ9d4qY6Sdb57mAYO4/fcv22fKdsNNXnvL4+TuMas6RS2/ntYualYrx97ru6TnsLNWiYXlcKtvI/pbFMDQKC7Ov5+abt+8VRreSM3fFSXwWH+PkzqGUty8iS/e/GUxo2HucG359byUkJPLPpUcs23CWz/8tITY2nnE++9mzvh9NG0hvt5W3L0Lg7WfMW+Erd4vxffRnGndeiq6OJnvW90c9l55sbdHYCRenr6NsMbHSW3YhryOwMP86F+9NWJTC6FZmaGgUwLakdOK7c+WSXAt4wqIVx1i16DcAnCqV4Pr5WURGfiQ2Lp7CJvq41huPU6USCnXt2n+Zjx9j6N6plsJrOamFW3FcypjJ/o750tEPefcRC+Ov79vQiE+YpfNCCEBVVQXnUqY8fBEBgP/DUEIjPlHl952yPAmJEv659YJl+27y6egAYuMTGbfej92Tm9DUtTgA5UuYEPg4jHl/XaeBUzEsjKRtKGttJLe/MsUMCQ5NeaQtTxFPF+aIPN3J2rZtG2/evOHq1asYGUlPZlvbrx9mc+fOpWfPngwYMACA4cOHc+nSJebOnUvdunXx9fXl5s2bBAUFUbSo9NHpLVu24ODgwNWrV6lSpYqsLj8/P5o1a4a3tzdeXl4ptsnb25vhw4fL/o6KipLVnRl6GgXknhiUSCSY6Wjw93/vZE8FxiYkcv55OFNr2qVZn1YBNSz11IhLSGT/w9e0KW2Wan6JRFp/kqQO1uOIjxxp54xxQfmOnbW+FhY6mjwI/yCX/ij8Ix7FU360Orvo6WjKPTEokUgwN9HF1y+ISmWkj6zHxiXwz7X/8PGsn2wdZYqbcGNXP7m0CUtPE/0xlgWjGlL0SydYIpEwZNYx9v19n7/XdqO4lWFy1QGwfu91nOwtqFDaXC59dO/q/NpGfs5XhV9WMd/Lg2a10/73zQ56ulpyTwxKJBLMTfU5+c9dKpWTntuxsfGc9XvIrHGtU63rj+UnmLHwKMe2D8a5orXca/VrluHm6fFyab09t1DG1oxRgzxQU1MlLj6BuLgEhSe01FRVZR1fkI5gNeq0BE2NAuzfOCDVkbHspqdXUO6JQYlEgrlZIU6evkWlCtIv6djYeM5euMusyZ2yfP8SiYTYLx27bxl8eajg4eNXXLv+hKnjFG+Prd9ymhaNnShskvzFQk7R09aQe2JQIpFgbqSNb0AwlewKA1/exzdf4NOnerrrlUgk3HgchuOXz6b6lYpyY01nuTy//uFL6WKGjOrgJD0HP8cTF5+Iqur356CKbATLxlwfS2MdHjyLkMvz8HkEjarKn/dC/panO1mBgYFUqlRJ1sH63t27d+nbV34OTfXq1Vm0aJHs9aJFi8p1guzt7SlUqBB3796VdbKCg4Np0KAB06dPZ9gw+Ufwv6epqYmmZurLAChDRUWFgZWKMfdKECULaVPSUJu5l4MoWECV9mW+fmH3OfovlrqaTPnS8br6KpKX0Z8pX1iPl9ExzPR7QiLg6WwjKzP5/EPcbUwooqfF+9h4dt1/zbnn79jXpjIA8YmJdD10k8DXUexqXYlEiYTXH6STuw211NFQU0VFRQXPKtbMuPiEcoX1KF9Yj613XvLg3Qf+bF4+2+KSXioqKgztUhWfdeextTbCrpgRPmvPo11Qnc6NHWX5eozfh5WpHjOH1EdLs4DCvKpCetJOx7fpg2YeZfvRf9m7sAN6Opqy+V8GupoU/OZLPio6hl0n7/LHCHeF9iU9dfi9oub6qXbacpKKigpD+9TDZ/Ex7IqbYleiMD6Lj6FdUIPObb5emPQYvBFL80L4jGsFSG8RTpxzkK3LpEsvJM1N0tXRRFdH2pFzLCO/ZIOOtgZGhjqydH29gtR2s2PUtD0ULKiBdREjzvo9ZMuuy8yb3BaQjmA17LiYj5/i2LK0F1HRn4iKlj79WthYL9nbYjlJRUWFob83xmf+fuxKWmBX0hyfefuk8Wv3tYPQo99yLC0M8fnS8YqNjZfd9ouNjefFy3ACbz5FV0dLNnI1dsoOGrtXpKiVMe+jP7Fjtx9nzt/h6O6vc9z+2nuJwib6FCtizK07z/Acs4lWTavgUV/+/fnocQj/XLjH4V2jsjskGaaiosLQNhXx2XYNW6tC2FkVwmfbNbS11Olc7+vcsR6zTmBlosvM36Rr0E3dfBmXsubYWRUi6mMsS/beIPBxGEuGSNdY09PWkHW4kuhoqWOsryVL19fRoHZ5K0avvkBBjQJYm+lx9uZLtpy8x9z+NWXt82pfmcmbLlO+pAkVS5qw+cQ97j0L53+T5Nc2y7MSJdJNmfJCmvJ0J6tgwbQXFkxt3khKc0i+Ty9cuDCWlpbs2LGDX3/9FX393L2qG1bFhk/xiQz7+650MVJzffa3dZIb8Xr2/jPfXmh9jk9g6oXHPI38hI66Gg2Lm7C2sQOFvvnyD/0QS59j/xLyIQZ9jQI4FtZjX5vK1LOWfri8eB/D4cfSJ3HctlySa9ORdk7U+nLLbGBlaz7HJzLmzH3CP8dRrrAeB36pTIlC6R/Gz04je1bj0+d4Bs08SnjUJ1zKWXFsRRe5Ea9nr6IyvJ7Nyr/8Aaj322a59HVTWtCzZQXZ3zuO3UaChE6NHJQ4itw1aqAHnz7HMdB7+5fFSItzfMdguRGv4Bfv5K72V2w8S2xsPO36rJGra+KIpkz2Sv98qe0rf2XszP10HbiedxEfsbYyYvroFvTvLr2l5X8zmMsBTwGwc5soV/bJlenYFM35EdXvjfJszqfPsQwcsf7LYqQlOb53rNyIV/DzMLn4vXwVTuWa3rK/5y05xLwlh6hdoyynD0uP83VoJN37LeNVSAQG+tqUdyjG0d1jcK/3tQP16nUEI8Zt4XVoJBbmhnTrWJMJoxTnDq7/8wxWloZ41Mv9i6PkjOxQmU8x8QxafIbw9zG4lDXj2KyWciNez0Kj5WIYER1L/wWnCQn/gIGOJhVLFubMgjZULWOe3C5StG18Q8au86Obzwnevf+MtZke03u70b/51wu1oW0r8jk2nhErzvHu/WcqlDDh+OxWlEzlae28RJIAEiVu+Ulyf7WUH4KKJA/PXtu0aRNDhgwhKCgo2dGs6tWr4+DgwOrVq2Vp7du35+PHjxw6dIiTJ0/SuHFjuduFd+7ckd0udHZ2ZvLkyezbt48LFy7QpEkTYmNjOXHiBHp6ac89AentQgMDA14OrCs3d0nImILd88Yq0z8qFbOUV2IX0km7UG634IcnuXoxt5vww4r6EIthy1VERkZm64V+0nfWK88GSn1nRcXEY7HQN9vb+6PL008XdurUCXNzc1q1asWFCxd48uQJu3fvxs/PD4CRI0eyceNGVq5cycOHD5k/fz579uyRzalq0KAB5cuXp0uXLgQEBHDlyhW6d+9O7dq1cXZ2ltuXjo4Ohw8fpkCBAjRu3JjoaMUn7gRBEAThp5B0u1CZTUhTnu5kaWhocOLECUxNTWnSpAnlypVj1qxZqKlJnyJq1aoVixYt4o8//sDBwYFVq1axYcMG6tSpA0hvJe7btw9DQ0Nq1apFgwYNKFGiBDt37kx2f7q6uhw9ehSJREKTJk348OFDsvkEQRAE4YcmFiPNEXn6duGPQNwuzBridqFyxO3CLCBuFypN3C7MvJy+Xfjy9zpK3y60XHFG3C5MQ54eyRIEQRAEQfhR5Xgn6+nTp6ioqKRrc3R0TLtCQRAEQRAyJlHydUHSzGxiTla65Pj9LXV1dUqXTt9vtpUoobhCsSAIgiAIykn6eRxlymeXGTNmcPjwYQIDA9HQ0CAiIiLt9kgkTJkyhdWrVxMeHo6LiwvLli3DwSF3l9LJ8U6WlZUV9+7dy+ndCoIgCILwA4iNjaVdu3a4ubmxbt26dJWZM2cO8+fPZ+PGjZQqVYrp06fj7u7O/fv3070kU3YQM7UFQRAEIZ+RJEiUXIw0+0aykn4feOPGjelri0TCwoULGTduHG3aSBfe3bRpE2ZmZmzbto1+/fqlUUP2ERPfBUEQBCGfSbpdqMwG0qcVv91iYmJy/FiCgoIICQnBw8NDlqapqUnt2rW5eDF3n3gVnSxBEARBEDKlaNGiGBgYyDYfH58cb0NISAgAZmZmculmZmay13KLuF0oCIIgCPlMYoKERCVu+SWVffbsmdw6WZqamsnmnzx5suw2YEqSfu4us1L7LePcIjpZgiAIgpDPZNXThfr6+ulajHTQoEF07Ngx1Tw2NjaZaou5ufQHwENCQrCwsJClh4aGKoxu5TTRycoi2jOGoa2vk9vNEARByDUq9VrldhN+WCpRH4BVud2MbGNiYoKJiUm21F28eHHMzc05efIklSpVAqRPKJ49e5bZs2dnyz7TS8zJEgRBEIR8RpKYqPSWXYKDgwkMDCQ4OJiEhAQCAwMJDAwkOjpalqdMmTLs3bsXkN4m9PT0ZObMmezdu5d///2Xnj17oq2tTefOnbOtnekhRrIEQRAEIb9RcgkHsnEJh4kTJ7Jp0ybZ30mjU6dPn6ZOnToA3L9/n8jISFmeUaNG8enTJwYMGCBbjPTEiRO5ukYWiB+IVlrSj21GRBxAX9wuFARBEDIhKuoDhQq1yLEfiH7Srip66pkfZ3kfF0+Jv66IH4hOg7hdKAiCIAiCkA3E7UJBEARByGckCRIkqnlzxfefiehkCYIgCEI+k5d/IPpnIm4XCoIgCIIgZAMxkiUIgiAI+UxiooREJUajlCmbn4hOliAIgiDkM5IElJyTlYWN+YmJ24WCIAiCIAjZ4KfrZNWpUwdPT8/cbkamLV++nxIlulCwYCOcnftz7tzNVPOfPXsDZ+f+FCzYiJIlu7Jy5UGFPLt3/4ODQy+0tBrh4NCLvXvPZ3i/EomEyZM3YWXVHm3txtStO5zbt58qdazZRcRQOSJ+ystsW3MqTjExsQwevITChVujq9uUli3H8/z5G2UOOcuJ8zB7JU18V2YT0vbTdbL27NnDtGnTcrsZmbJz52mGDVvO2LGdCQhYRY0a5WjSxJvg4NfJ5g8KekXTpmOpUaMcAQGr8PbuxNChS9m9+x9ZHj+/23TsOI2uXd0JDFxN167udOgwlcuX72Zov3Pm7GDBgl0sWTKYK1eWY25uiIfHKN6//5h9AckEEUPliPhljcy0NSfj5Om5nH37zrN9+3jOnVtIdPQnmjcfR0JC3rgHJM7D7Cc6WTlDrPiupKxc8d3VdSCVKtmxYoWnLM3evhctW1bHx+c3hfyjR6/m4EE/7tzZIEvr338BN28+5uLFpQB07DiNqKgPHDkyS5anceMxGBrqsm3b+HTtVyKRYGXVnqFD2zB6dCdAeiVsbv4Ls2b1oV+/5kodd1YSMVSOiJ/yMtvWnIpTZGQ0pqZt2bx5DB061AXg5cswihXrxOHDM2nYsEp2hCVD8uN5mNMrvt9tWAk9dbVM1/M+LoGyx6+LFd/T8NONZH17u9DGxoaZM2fSu3dv9PT0KFasGKtXr5bLf/HiRSpWrIiWlhbOzs7s27cPFRUVAgMDc7TdsbFx+Ps/wMPDWS7d3d0JP7/byZa5dOkO7u5OcmkNG1bh2rUHxMXFA+Dndwd3d/k6PTycuXjxdrr3GxT0ipCQd3J5NDU1qF27Qoptyw0ihsoR8csamW1rTsXJ3/8hcXHxcnksLU1wdLSR7Ss3ifMwZ0i+/HahMpuQtp+uk/W9efPm4ezszPXr1xkwYAC///479+7dA+D9+/c0b96ccuXKERAQwLRp0xg9enSutDMsLJKEhETMzAzl0s3MDAkJeZdsmZCQd8nmj49PICwsMtU8ISHh6d5vUt7v85iafq0nLxAxVI6IX9bIbFtzKk4hIe/Q0FDH0FAvxXpykzgPc4ZEkogkUYlNkpjbh/BD+Ok7WU2aNGHAgAHY2toyevRoTExMOHPmDABbt25FRUWFNWvWYG9vT+PGjRk5cmSq9cXExBAVFSW3ZSUVFfm/JRJQ+T5RLr/8a0l3f79NTy7P91WmZ7/J15Ny23KLiKFyRPwyZutWX/T0msq2pJGTzLQ1N+OUF2L5LXEeZi8xkpUzfvpOVvny5WX/raKigrm5OaGhoQDcv3+f8uXLo6WlJctTtWrVVOvz8fHBwMBAthUtWjRL2mliYoCamqrC1VBoaLjCVVMSc3MjhSu70NAIChRQw9hYP9U8SXWmZ7/m5tL//76eN28iMDMrlIGjzF4ihsoR8cucFi2qcf36atlmYmIAZLytORUnc3MjYmPjCA9/n+K+cpM4D4WfyU/fyVJXV5f7W0VFhcRE6TBnclcfaT0H4O3tTWRkpGx79uxZlrRTQ0MdJ6dSnDzpL5fu6+uPm5tDsmVcXe3x9ZXPf+LENZydS6GuLl1n1s1NMc/Jk9eoVs0h3fstXtwCc3MjuTyxsXGcPXsjxbblBhFD5Yj4ZY6enja2tlayzd7eOlNtzak4OTnZoa5eQC7Pq1dv+fffp7J95SZxHuYM8XRhzsjXK76XKVOGrVu3EhMTg6amJgDXrl1LtYympqYsb1YbNuwXunefhbNzKdzc7Fm9+jDBwaH07y99YsXbey0vX4axadMYAPr3b86yZfsZPnw5ffo0xc/vDuvXH2XbtnGyOocMaUPt2p7Mnr2dli2rs3//BXx9Azh3blG696uiosLQoW3w8dmGnV0R7Oys8PHZhra2Fp0718+WWGSWiKFyRPyUl9629ugxC0tLE9nTcjkVJwMDXXr3boyX10qMjfUxMtJj5MhVlCtXnAYNKudgpFImzsPsJ35WJ2fk605W586dGTduHH379mXMmDEEBwczd+5cIPV7/9mlQ4e6vH0bxbRpW3j16h2OjjYcPuyDtbUZACEhbwkODpXlL17cgsOHZzJ8+HKWLz+ApaUxixYNom3bWrI81ao5sH37eCZM2MDEiRspWdKSHTsm4OJSNt37BRg1qiOfPsUycOAiwsPf4+JSluPHZ6Onp50DkUk/EUPliPhljfS0NTg4FFXVr58zORmnBQsGUKCAGh06TOXTp1jq16/Ehg3TUVPL/CP9WUmch8LP4qdbJ6tOnTpUrFiRhQsXYmNjg6enp9wK8BUrVqRVq1ZMnjwZkC7hkPTEYbly5RgxYgSdO3fm3r17lC5dOs39ZeU6WYIgCEL+lNPrZAW62aNXQIl1suITqOh3R6yTlYafbiQr6clBgKdPnyq8/v36V9WqVePGjRuyv7du3Yq6ujrFihXLphYKgiAIQu5Sdl6VmJOVPj9dJyujNm/eTIkSJbCysuLGjRuMHj2a9u3bU7BgwdxumiAIgiAIP7B838kKCQlh4sSJhISEYGFhQbt27ZgxY0ZuN0sQBEEQso0kQYJERYmRLLFOVrrk+07WqFGjGDVqVG43QxAEQRByjkTJZRh+runc2eanXydLEARBEAQhN+T7kSxBEARByG8kiUreLhQT39NFdLIEQRAEIZ+RJEiQIOZkZTfRyRIEQRCEfCYxUUKiEiNZYsX39BFzsgRBEARBELKBGMkSBEEQhHwmMRESlfj1uMTErGvLz0x0sgRBEAQhnxGdrJwhOllCnpCIeMcqQ1Xc+RfyAPE+zjwRu5+T6GQJgiAIQj4jRrJyhuhkCYIgCEI+kyiRbsqUF9Im7jEIgiAIgiBkAzGSJQiCIAj5jLhdmDNEJ0sQBEEQ8plEiXIdJXG7MH3E7UJBEARBEIRsIEayBEEQBCGfkSSi1KIREnG7MF1EJ0sQBEEQ8plEJTtZYk5W+ohOliAIgiDkM6KTlTPEnCxBEARBEIRsIEayBEEQBCGfESNZOUOMZOVBEomEyZM3YWXVHm3txtStO5zbt5+mWW737n9wcOiFllYjHBx6sXfveYU8y5fvp0SJLhQs2Ahn5/6cO3dT7vXJkzdRtmxPdHWbYmTUEnf3kVy+fFcuT79+87G17Yq2dmNMTdvQqtUE7t0LVuqYs9KK5QewLdENnYJNqOo8gHPnbqWa/+zZG1R1HoBOwSbYlezGqpUH5V6/ffsp7X6ZQsniXSmg6s6ihXsU6pgyeTMFVN3lNiuL9nJ5eveao5Cnmttg5Q84i6V1jnzv7NkbODv3p2DBRpQs2ZWV38UP0j4337//iKfnMmxsOqGt3Zjq1Qdz9eq9FPfZr998VFXrs3Dh7swdZDbLzffwt1KLk5/fberXH4GublMMDVtQt+5wPn2KydBxZqfceB+vXHGQShX6YmjQEkODllSvNoSjR6/I5YmO/sSQQUuwLtoJXe2mONr3ZuUKxXM+r0tMVH4T0iY6WXnQnDk7WLBgF0uWDObKleWYmxvi4TGK9+8/pljGz+82HTtOo2tXdwIDV9O1qzsdOkyV6yDt3HmaYcOWM3ZsZwICVlGjRjmaNPEmOPi1LE+pUkVYsmQwN2+u4dy5RVhbm9Gw4WjevImQ5XFyKsX69aO4c2cDx47NQiKR0LDhaBISErIlHhnxv51nGD5sBd5jO3EtYAU1ajjSrMlYgoNDk80fFPSK5k3HU6OGI9cCVjDGuxOeQ5ezZ/c5WZ6PH2MoXtyCmT6/Ym5ulOK+HRxseP5yp2wLvLlaIU/DRlXk8hw6PEP5g85C6TlHvhUU9IqmTcdSo0Y5AgJW4e3diaFDl7J79z+yPOk5N/v0mYevrz+bN3tz8+Za3N2dcXcfxYsXbxT2uW/fea5cuYelpXHWByCL5OZ7OElqcfLzu03jxt64uztz+fIyrlxZzsCBLVFVVWJ1yiyUW+9jqyImzPD5lctXl3H56jLq1q1Im1aT5DrII4at4Pjxa2zaMoZ/76xjqGdbhg5ZyoH9F7M0BsLPQUUikYglxZQQFRWFgYEBEREH0NfXUbo+iUSClVV7hg5tw+jRnQCIiYnF3PwXZs3qQ79+zZMt17HjNKKiPnDkyCxZWuPGYzA01GXbtvEAuLoOpFIlO1as8JTlsbfvRcuW1fHx+S2F4/tAoUItOHnyD+rXr5xsnps3H1OxYl8ePtxCyZKWmTnsLPsFejfXwVSuZMuyFUNlaY72vWnRsjozfX5VyD9m9BoOHfTj3zvrZWkD+i/kxs0nXLi4WCF/yeJdGTK0DUM928ilT5m8mQP7L+B/fVWKbevdaw4RER/Ys3dKZg4tVapZdL2U0XNk9OjVHDzox507G2Rp/fsv4ObNx1y8uBRI+9z89CkGff1m7Ns3jaZNXWV5KlXqS9Omrkyf3luW9uLFG1xdB3Hs2GyaNRvL0KFt8fRsmyXHnlXywns4rTi5uQ2iQQMnpk3rlZWH/sO/j5NT2LgNs+f0ofevjQGoUK4P7drXZvyErrI8VZ0H0KhxVaZO65mRw5QTFfUBo0KtiIyMRF9fP9P1pL0f6XfWQVNbdFTVMl3Ph8QEmoc+yvb2/ujESFYeExT0ipCQd3h4OMvSNDU1qF27An5+t1Ms5+d3B3d3Z7k0Dw9nLl6UlomNjcPf/4FcvQDu7k4p1hsbG8fq1YcxMNChQoWSyeb58OETGzYcp3hxC4oWLZyuY8wusbFxBPg/wN3DSS49tWO8dOku7u7y+T0aOuN/7QFxcfEZ2v/Dhy8patUB2xLd6NxpBk+evFLIc/bMDSzM2lG2dE/69ZlPaGh4hvaRnTJzjly6dEchfg0bVuHaN/FL69yMj08gISERLS0NuTwFC2pw4cK/sr8TExPp3n0WXl7tcXCwydQx5oTcfg+nFafQ0HAuX76LqWkhqlcfjLl5W+rUGcb586nfjsspuf0+TpKQkMDOHaf58OEzrm72svTq1R04dNCPFy/CkEgknD4dyIMHz/Fo6JxKbXmPRCJRehPSJjpZGRQTE0NUVJTclpVCQqRfumZmhnLppqaGsteSL/dOoYyZ2dcyYWGRJCQkppDnnVzaoUN+6Ok1pWDBxixcuIsTJ+ZgYmIgl2f58v3o6TVFT68Zx49f5cSJOWhoqGfsYLNY0jGafh87M0NepxC71yHvks0fH59AWFhkuvdd1aUMGzeN4sixWaxcPYyQkHfUrD6Ut2+/nh+NGlVl85/enDw1hzlz+3Ht2n3c648iJiY2A0eZfTJyjiRJ6bz7Nn5pnZt6etq4udkzffqfvHwZRkJCAn/+eZLLl+/x6tVbWZnZs3dQoIAaQ4akPfqQm3L7PZxWnJI6/1OmbOK335py9OgsKlWyo0GDkTx8+DydR5l9cvN9DHDrVhAGes3R1mrCgN8XsWvPJOztrWWvL1w8kLL21lgX7URBzcY0bTyWpcsGU6OGY4b2I+QPopOVQT4+PhgYGMi2okWLKlXf1q2+Xzor0i3pqktFRX5uhEQiUUj7XvJlvs/Dd3kUy9WtW5Hr11dz4cJiGjasQocO0xRGXLp0qU9AwCrOnFmAnZ0VHTpM5fPnvNFZyGjsksufXHpqGjeuSpu2NSlXrjgNGlTm4KHpAGzedEKWp32HOjRt6oKjY3GaN3fj0JGZPHjwnCOHL6d7PzkhPeeIfP6045fWubl5szcSiYQiRTqgpdWIJUv20rlzPdTUpB9R/v4PWLx4Dxs2jMrQv0tOyEvv4fTEKfHLj8717duMXr0aUamSHQsWDKB06SKsX38s1fblpNx4HwOULl0E/+srueC3mH79m9O75x/cufOf7PUli/dx+dJd9u6fypVry/ljbl8GDVyCr29AhvaT2/LyxPcZM2ZQrVo1tLW1KVSoULrK9OzZExUVFbnN1dU17YLZTCzhkEHe3t4MHz5c9ndUVJRSHa0WLarh4lJW9ndMTBwgvaq1sPg6YfXNmwjMzAqlWI+5uZHCaENoaITsqtfExAA1NVWFK+nQ0HCFK2MdnYLY2lpha2uFq6s9pUp1Z926o3h7d5blMTDQxcBAFzu7Iri6lsXIqBV7956nU6d6GQtAFko6xtffxeFNaASmKcTOzNwo2fwFCqhhbJz5eQY6OgVxLFecRw9fpJjHwsIYa2tTHqaSJydl5BxJktJ592380jo3AUqWtOTMmQV8+PCJqKiPWFgY07HjNIoXtwDg3LlbhIZGYG3dSVYmISERL6+VLFq0m6CgbZk/cCXlpfdweuJkYSGd9P3t6AxA2bLWPHuW/MTynJTb72MNDXVsba0AcHYuzbVr91myaC8rVnny6VMM48etZ9eeyTRt6gJA+fIluBH4mPnz/qJBg+TnreZFeXkJh9jYWNq1a4ebmxvr1q1Ld7lGjRqxYcPX+aEaGhqp5M4ZYiQrgzQ1NdHX15fblKGnpy3r0NjaWmFvb425uREnT/rL8sTGxnH27A3c3BxSrMfNzR5fX3+5tJMnr1GtmrSMhoY6Tk6l5OoF8PX1T7VekF4RJn1xpJ4nd0eyNDTUqexUCt+T8leUvr4BKR6jq2tZhSvQkyf8cXIuhbp65q9BYmJiuXc3GHOLlJ9GfPs2imfP2CHT6wAAB1hJREFU3sh9EeemzJwjrq6K592JE9dw/iZ+aZ2b39LRKYiFhTHh4e85fvwqLVpUA6BbtwbcuLGG69dXyzZLS2O8vNpz7NjsTB9zVshL7+H0xMnGxhxLS2Pu35e/NfjgwXOKFTPNfCCySF56H8OXz7ZY6WdbXFw8cXHxCk9hqqmpkSjWNMgyU6ZMYdiwYZQrVy5D5TQ1NTE3N5dtRkYpf/7mFDGSlceoqKgwdGgbfHy2YWdXBDs7K3x8tqGtrUXnzvVl+Xr0mIWlpYnsiaIhQ9pQu7Yns2dvp2XL6uzffwFf3wDOnVskKzNs2C907z4LZ+dSuLnZs3r1YYKDQ+nfX/q004cPn5gxYystWlTDwsKYt28jWb78AM+fv6Fdu9oAPHnykp07z+Dh4Uzhwga8eBHGnDk7KFhQgyZNXHIwUskbNqwtPbrPxsm5FK5uZVmz+gjBwaH0698MgLHe63j5MoyNm0YD0K9/M5YvO8CI4Sv5rU9jLvndZf36Y2zdNlZWZ2xsnOx2QWxsHC9ehBEY+Ahd3YKyK96RXqto1tyVYsVMCQ2NYOaMbURFfaR7Dw9AurbOlMmbadO2JhYWRjx9+prx49ZjYmJAq9bVczJEqUrrHPH2XsvLl2Fs2jQGgP79m7Ns2X6GD19Onz5N8fO7w/r1R9m2bZyszvScm8ePX0UikVC6dFEePXrBqFGrKV26KL16NQLA2NgAY2P5eYHq6gUwNzeidGnlbtlntdx8D6cnTioqKnh5dWDy5E1UqFCCihVt2bTpBPfuBfPXX5OyOzzpklvv43Fj19GocVWKFi3M+/ef2LnjNGfP3OTw0ZkA6OvrUKt2ecaMWkPBgppYW5vyz9mbbNlykrnz+udkiJSWKFFuNOrLXWeFecmamppoamoq0bLMO3PmDKamphQqVIjatWszY8YMTE1z98JBdLKSsXTpUvbu3cupU6dyZf+jRnXk06dYBg5cRHj4e1xcynL8+Gz09LRleYKDQ+WupqpVc2D79vFMmLCBiRM3UrKkJTt2TJC7jdGhQ13evo1i2rQtvHr1DkdHGw4f9sHa2gyQXo3dv/+MX36ZTFhYFMbG+lSpUpp//lkoe0pJS0uD8+dvsWjRbsLDozEzM6RWrfJcuLAEU9PkbynlpPYd6vD2bRTTp/0pO8aDh2fIjjEk5K3cWjvFi1tw8PB0vIavZMXyA1haGrNw0QDatK0py/Py5VucK/8u+3v+vL+YP+8vatUuz9+n5wHw4kUYXTvPJCwsisKFDXBxLcsFv8XfxFaVf/8N4s8tvkRERGNhYUSduhXYvmOc3L9rbkvrHEkufocPz2T48OUs/xK/RYsG0bZtLVme9JybkZEfGDt2Lc+fh2FkpEebNjWZMaO30qMQuSW33sPp5enZls+fYxk+fAXv3r2nQoUSnDgxJ9NLsGS13Hofh76OoGf32bx69Q4DAx3KlS/O4aMz5Z5c3LZ9HOPGrqN7Vx/evXuPtbUZ06b3knUAfxSSREhUYnpj0sOF30+XmTRpEpMnT858xZnUuHFj2rVrh7W1NUFBQUyYMIF69erh7++fa50+EOtkJWvy5Mls3LiRp0+fppk3q9fJyq+yan2d/Cqr1skSBGWI93Hm5fQ6WTt1S6Ktkvl1sj5KEugQ/Zhnz57JtTelkazJkyczZUrqawRevXoVZ+evS2Fs3LgRT09PIiIiMty+V69eYW1tzY4dO2jTJveeSP4xLxOz2eTJk3OlJy4IgiAIP5L0zk0eNGgQHTt2TDWPjY1NFrUKLCwssLa25uHDh1lWZ2aITpYgCIIg5DOJSt4uTMzgPTATExNMTEwyv8MMevv2Lc+ePcPCwiLH9pkccY9BEARBEPKZvLxOVnBwMIGBgQQHB5OQkEBgYCCBgYFER0fL8pQpU4a9e/cCEB0djZeXF35+fjx9+pQzZ87QvHlzTExMaN26dfY1NB3ESJYgCIIgCHnGxIkT2bRpk+zvSpUqAXD69Gnq1KkDwP3794mMlK7mr6amxq1bt9i8eTMRERFYWFhQt25ddu7ciZ6eXo63/1uikyUIgiAI+UyiRMnFSLPxkbmNGzeycePGVPN8+8xewYIFOX78ePY1SAmikyUIgiAI+UxOz8nKr8ScLEEQBEEQhGwgRrIEQRAEIZ8RI1k5Q3SyBEEQBCGfEZ2snCFuFwqCIAiCIGQDMZKlpKQnHKKiPuZyS35s4uc4lCN+VkfIC8T7OPOSvkNy6pfuPkgSlRqN+iT+rdNFdLKU9P79ewCKFUv95wIEQRAEIS3v37/HwMAg2+rX0NDA3NycISFBStdlbm6OhoZGFrTq5yV+IFpJiYmJvHz5Ej09PVRUlLjBLQiCIORbEomE9+/fY2lpiapq9o5Mf/78mdjYWKXr0dDQQEtLKwta9PMSnSxBEARBEIRsICZyCIIgCIIgZAPRyRIEQRAEQcgGopMlCIIgCIKQDUQnSxAEQRAEIRuITpYgCIIgCEI2EJ0sQRAEQRCEbCA6WYIgCIIgCNng/+Ew6qBwdH2hAAAAAElFTkSuQmCC\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -985,165 +398,48 @@ } ], "source": [ - "attr_viz = LLMAttrViz(**attr_result)\n", - "print(attr_viz.seq_attr_dict)\n", - "attr_viz.plot_seq_attr()\n", - "attr_viz.plot_token_attr()" + "inp = TextTemplateInput(\n", + " template=\"{} lives in {}, {} and is a {}. {} personal interests include\", \n", + " values=[\"Dave\", \"Palm Coast\", \"FL\", \"lawyer\", \"His\"],\n", + " baselines=[\"Sarah\", \"Seattle\", \"WA\", \"doctor\", \"Her\"],\n", + ")\n", + "\n", + "attr_res = llm_attr.attribute(inp, target=target)\n", + "\n", + "attr_res.plot_token_attr()" ] }, { "cell_type": "markdown", - "id": "collectible-thomas", + "id": "c34f5712", "metadata": {}, "source": [ - "We can also perform a similar attribution experiment with a dictionary of inputs / baselines. Additionally, we omit the attribution target, so we will attribute w.r.t what the model will generate in the default setting. As we can see, the result is generally more positive than above. This is expected, since the target, \"playing guitar, hiking, and spending time with his family.\", is what the model feel confident to generate given the input tokens." + "The result represents how the features impacts the output compared with the single baseline. It can be a useful setup to have some interesting findings. For example, the name \"Dave\" and the corresponding pronoun \"His\" are more positive to \"playing golf\" but negative to \"cooking\" compared with \"Sarah\".\n", + "\n", + "But more generally, we would prefer a distribution of baselines so the attribution method will sample from for generosity. Here, we can leverage the `ProductBaselines` to define a Cartesian product of different baselines values of various features. And we can specify `num_trials` in attribute to average over multiple trials\n", + "\n", + "Another issue we notice from the above results is that there are correlated aspects of the prompt which should be ablated together to ensure that the input remain in distribution, e.g. Palm Coast, FL should be ablated with Seattle, WA. We can accomplish this using a mask as defined below, which will group (city, state) and (name, pronoun). `TextTemplateFeature` accepts the argument `mask` allwoing us to set the group indices. To make it more explicit, we can also define the template and its values in dictionary format instead of list." ] }, { "cell_type": "code", - "execution_count": 452, - "id": "massive-french", + "execution_count": 80, + "id": "breathing-sound", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 0.0009605777449905872 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 2.644512824190315e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing guitar, hiking, and spending time with his family. [prob: 0.00028119259513914585 ]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [452], line 8\u001b[0m\n\u001b[1;32m 1\u001b[0m inp_feature \u001b[38;5;241m=\u001b[39m TextTemplateFeature(\n\u001b[1;32m 2\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{name}\u001b[39;00m\u001b[38;5;124m lives in \u001b[39m\u001b[38;5;132;01m{city}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;132;01m{state}\u001b[39;00m\u001b[38;5;124m and is a \u001b[39m\u001b[38;5;132;01m{occupation}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m{pronoun}\u001b[39;00m\u001b[38;5;124m personal interests include\u001b[39m\u001b[38;5;124m\"\u001b[39m, \n\u001b[1;32m 3\u001b[0m inputs\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDave\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPalm Coast\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFL\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlawyer\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHis\u001b[39m\u001b[38;5;124m\"\u001b[39m}, \n\u001b[1;32m 4\u001b[0m baselines\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSarah\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcity\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSeattle\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstate\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWA\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moccupation\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdoctor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpronoun\u001b[39m\u001b[38;5;124m\"\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHer\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[1;32m 5\u001b[0m )\n\u001b[0;32m----> 8\u001b[0m attr_result_2 \u001b[38;5;241m=\u001b[39m \u001b[43mllm_attr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minp_feature\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn [450], line 105\u001b[0m, in \u001b[0;36mLLMAttribution.attribute\u001b[0;34m(self, input_feature, target, num_trials, log_trials, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_trials): \n\u001b[1;32m 103\u001b[0m attr_input \u001b[38;5;241m=\u001b[39m input_feature\u001b[38;5;241m.\u001b[39minterpretable_tensor\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[0;32m--> 105\u001b[0m cur_attr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattr_method\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattribute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 106\u001b[0m \u001b[43m \u001b[49m\u001b[43mattr_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minput_feature\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_tokens\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlog_trials\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 108\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m attr \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m cur_attr\n\u001b[1;32m 113\u001b[0m attr \u001b[38;5;241m=\u001b[39m (attr \u001b[38;5;241m/\u001b[39m num_trials) \n", - "File \u001b[0;32m~/local/captum/captum/log/__init__.py:42\u001b[0m, in \u001b[0;36mlog_usage.._log_usage..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(func)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:351\u001b[0m, in \u001b[0;36mFeatureAblation.attribute\u001b[0;34m(self, inputs, baselines, target, additional_forward_args, feature_mask, perturbations_per_eval, show_progress, **kwargs)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m (\n\u001b[1;32m 332\u001b[0m current_inputs,\n\u001b[1;32m 333\u001b[0m current_add_args,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 349\u001b[0m \u001b[38;5;66;03m# non-agg mode:\u001b[39;00m\n\u001b[1;32m 350\u001b[0m \u001b[38;5;66;03m# (feature_perturbed * batch_size, *initial_eval.shape[1:])\u001b[39;00m\n\u001b[0;32m--> 351\u001b[0m modified_eval \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_strict_run_forward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward_func\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_target\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 355\u001b[0m \u001b[43m \u001b[49m\u001b[43mcurrent_add_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 356\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 358\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m show_progress:\n\u001b[1;32m 359\u001b[0m attr_progress\u001b[38;5;241m.\u001b[39mupdate()\n", - "File \u001b[0;32m~/local/captum/captum/attr/_core/feature_ablation.py:599\u001b[0m, in \u001b[0;36mFeatureAblation._strict_run_forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 593\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_strict_run_forward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \u001b[38;5;124;03m A temp wrapper for global _run_forward util to force forward output\u001b[39;00m\n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m type assertion & conversion.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m Remove after the strict logic is supported by all attr classes\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 599\u001b[0m forward_output \u001b[38;5;241m=\u001b[39m \u001b[43m_run_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 600\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(forward_output, Tensor):\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m forward_output\n", - "File \u001b[0;32m~/local/captum/captum/_utils/common.py:517\u001b[0m, in \u001b[0;36m_run_forward\u001b[0;34m(forward_func, inputs, target, additional_forward_args)\u001b[0m\n\u001b[1;32m 514\u001b[0m inputs \u001b[38;5;241m=\u001b[39m _format_inputs(inputs)\n\u001b[1;32m 515\u001b[0m additional_forward_args \u001b[38;5;241m=\u001b[39m _format_additional_forward_args(additional_forward_args)\n\u001b[0;32m--> 517\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mforward_func\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 518\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 519\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43madditional_forward_args\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\n\u001b[1;32m 520\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _select_targets(output, target)\n", - "Cell \u001b[0;32mIn [450], line 46\u001b[0m, in \u001b[0;36mLLMAttribution._forward_func\u001b[0;34m(self, perturbed_feature, input_feature, target_tokens, log_trials)\u001b[0m\n\u001b[1;32m 44\u001b[0m log_prob_list \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 45\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m target_token \u001b[38;5;129;01min\u001b[39;00m target_tokens:\n\u001b[0;32m---> 46\u001b[0m output_logits \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_inp\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m new_token_logits \u001b[38;5;241m=\u001b[39m output_logits\u001b[38;5;241m.\u001b[39mlogits[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 48\u001b[0m log_probs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mnn\u001b[38;5;241m.\u001b[39mfunctional\u001b[38;5;241m.\u001b[39mlog_softmax(new_token_logits, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:806\u001b[0m, in \u001b[0;36mLlamaForCausalLM.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 803\u001b[0m return_dict \u001b[38;5;241m=\u001b[39m return_dict \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39muse_return_dict\n\u001b[1;32m 805\u001b[0m \u001b[38;5;66;03m# decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\u001b[39;00m\n\u001b[0;32m--> 806\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 807\u001b[0m \u001b[43m \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 808\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 809\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 810\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 811\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 812\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 813\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 814\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_hidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_hidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 815\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_dict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 818\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 819\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpretraining_tp \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:693\u001b[0m, in \u001b[0;36mLlamaModel.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 685\u001b[0m layer_outputs \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mcheckpoint\u001b[38;5;241m.\u001b[39mcheckpoint(\n\u001b[1;32m 686\u001b[0m create_custom_forward(decoder_layer),\n\u001b[1;32m 687\u001b[0m hidden_states,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 690\u001b[0m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 691\u001b[0m )\n\u001b[1;32m 692\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 693\u001b[0m layer_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 694\u001b[0m \u001b[43m \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 695\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 696\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 697\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 698\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 699\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 700\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 702\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m layer_outputs[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 704\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_cache:\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:408\u001b[0m, in \u001b[0;36mLlamaDecoderLayer.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[1;32m 405\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[1;32m 407\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[0;32m--> 408\u001b[0m hidden_states, self_attn_weights, present_key_value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 409\u001b[0m \u001b[43m \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 410\u001b[0m \u001b[43m \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 411\u001b[0m \u001b[43m \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 412\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 413\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 414\u001b[0m \u001b[43m \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 415\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 416\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m residual \u001b[38;5;241m+\u001b[39m hidden_states\n\u001b[1;32m 418\u001b[0m \u001b[38;5;66;03m# Fully Connected\u001b[39;00m\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/transformers/models/llama/modeling_llama.py:307\u001b[0m, in \u001b[0;36mLlamaAttention.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)\u001b[0m\n\u001b[1;32m 305\u001b[0m query_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_proj(hidden_states)\n\u001b[1;32m 306\u001b[0m key_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(hidden_states)\n\u001b[0;32m--> 307\u001b[0m value_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_proj\u001b[49m\u001b[43m(\u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 309\u001b[0m query_states \u001b[38;5;241m=\u001b[39m query_states\u001b[38;5;241m.\u001b[39mview(bsz, q_len, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_heads, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 310\u001b[0m key_states \u001b[38;5;241m=\u001b[39m key_states\u001b[38;5;241m.\u001b[39mview(bsz, q_len, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_key_value_heads, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhead_dim)\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1190\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/accelerate/hooks.py:165\u001b[0m, in \u001b[0;36madd_hook_to_module..new_forward\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m output \u001b[38;5;241m=\u001b[39m old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 165\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mold_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 166\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/bitsandbytes/nn/modules.py:248\u001b[0m, in \u001b[0;36mLinear4bit.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 245\u001b[0m x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcompute_dtype)\n\u001b[1;32m 247\u001b[0m bias \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbias \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbias\u001b[38;5;241m.\u001b[39mto(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcompute_dtype)\n\u001b[0;32m--> 248\u001b[0m out \u001b[38;5;241m=\u001b[39m bnb\u001b[38;5;241m.\u001b[39mmatmul_4bit(x, \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[38;5;241m.\u001b[39mt(), bias\u001b[38;5;241m=\u001b[39mbias, quant_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mweight\u001b[38;5;241m.\u001b[39mquant_state)\n\u001b[1;32m 250\u001b[0m out \u001b[38;5;241m=\u001b[39m out\u001b[38;5;241m.\u001b[39mto(inp_dtype)\n\u001b[1;32m 252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\n", - "File \u001b[0;32m~/anaconda3/envs/captum/lib/python3.10/site-packages/torch/nn/modules/module.py:1252\u001b[0m, in \u001b[0;36mModule.__getattr__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_is_full_backward_hook\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m:\n\u001b[1;32m 1250\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_full_backward_hook \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1252\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getattr__\u001b[39m(\u001b[38;5;28mself\u001b[39m, name: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Union[Tensor, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mModule\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1253\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_parameters\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m:\n\u001b[1;32m 1254\u001b[0m _parameters \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_parameters\u001b[39m\u001b[38;5;124m'\u001b[39m]\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", - " baselines={\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"}\n", - ")\n", - "\n", - "\n", - "attr_result_2 = llm_attr.attribute(inp_feature)" - ] - }, - { - "cell_type": "code", - "execution_count": 222, - "id": "0c009685", - "metadata": { - "scrolled": true - }, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "(
, )" ] }, + "execution_count": 80, "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_2 = LLMAttrViz(**attr_result_2)\n", - "attr_viz_2.plot_token_attr()" - ] - }, - { - "cell_type": "markdown", - "id": "ea492d52", - "metadata": {}, - "source": [ - "Another way to ablate the input text is to directly remove the corresponding tokens, which can also be viewed as replacing them with emptry string. This is also the default baselines for `TextTemplateFeature`. Let's try this, but please note removing tokens is likely to create out-of-distribution text input and therefore may not give you meaningful results." - ] - }, - { - "cell_type": "code", - "execution_count": 617, - "id": "57402c26", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "open sourcing explainable techniques. [prob: 7.460598999674888e-23 ]\n", - " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "open sourcing explainable techniques. [prob: 7.016529001286807e-23 ]\n", - " Dave lives in , FL and is a lawyer. His personal interests include\n", - "open sourcing explainable techniques. [prob: 1.1619964047938748e-21 ]\n", - " Dave lives in Palm Coast, and is a lawyer. His personal interests include\n", - "open sourcing explainable techniques. [prob: 1.5589677720692103e-21 ]\n", - " Dave lives in Palm Coast, FL and is a . His personal interests include\n", - "open sourcing explainable techniques. [prob: 3.2460304118967485e-23 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", - "open sourcing explainable techniques. [prob: 6.223421373823065e-22 ]\n" - ] - } - ], - "source": [ - "target = \"playing golf, hiking, and cooking.\"\n", - "\n", - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", - ")\n", - "\n", - "attr_result_3 = llm_attr.attribute(inp_feature, target=\"open sourcing explainable techniques.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 618, - "id": "8af32cb0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Dave': 0.09586238861083984, 'Palm Coast': -0.5810728073120117, 'FL': -0.17151927947998047, 'lawyer': -0.519902229309082, 'His': 1.2632627487182617}\n" - ] + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHCCAYAAAD/6o2PAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFgElEQVR4nOzdd1gURx/A8e/RpQrSERUVRcResfdeY6yxl8TYe9dYgzX2bjRq7LGXaNTYxV5ji12jICoIAkrd9w9eT0+KwFHl98lzT7zZmdnZ0d2bnZmdVSmKoiCEEEIIIeKkk94FEEIIIYTIyKSxJIQQQgiRAGksCSGEEEIkQBpLQgghhBAJkMaSEEIIIUQCpLEkhBBCCJEAaSwJIYQQQiRAGktCCCGEEAmQxpIQQgghRAKksSS0IgvACyGE+NpJY0loRaVSARAdHZ3OJRFCCCFShzSWRLKNHz+etWvXAqCjo4OiKNLTJIQQ4qsjjSWRLHv37mXbtm106tSJvHnzcvjwYVQqlbqnSQghhPhaSGNJJNmbN2/YvHkzzs7O3Lx5kx9//JGWLVsyZswYIiIipHdJCCHEV0UaSyLJNm/ezJ07d6hVqxZubm4MHTqUxYsXs3HjRh4+fCi9S0IIIb4q0lgSSfLw4UN2795N3rx5GThwoDrczMyM58+fc/bsWXWY9DAJIYT4GuildwFE5rJu3TouXLiAoaEhd+/exdXVleDgYC5cuEB0dDQeHh7quCqViqioKHR0dKS3SQghRKYljSWRaKdPn+bIkSPUqVMHGxsbSpYsScmSJdHX18fb25sOHTpQokQJ5s+fj5+fHwMHDsTKygqI6WWSBpMQQojMSIbhRKJERkayceNGoqOj6dOnDzNnzuTatWsUKVIEBwcH5s6dy4wZM3j27Bm6urpcvHiRvHnzMnfuXACNhlJYWBiHDh1Kr0MRQgghkkSlyMQSkQinTp3i+++/p1GjRkybNk1jW1hYGIaGhrHSbNu2jeHDh7NmzRo8PT3V4X///Te1atXir7/+olatWqlediGEEEIb0lgSiXbx4kUcHR1xcHBQr9itoxPTORkUFES/fv149+4dhoaGjBgxAnd3d6pXr06tWrUYPXo0ELPsQMuWLVGpVPz111/pdixCCCFEYsmcJZFopUqVUv/5QyPpw1ykTp06cfHiRbp168aTJ08oX7487dq148GDB+jpxfwzi46OZufOnfz9999cu3ZNnT46OhpdXd20PyAhhBAiEaRnSWjtxYsXODk5sWnTJlq0aAHA5cuXadq0KYqicP36dbJnz87jx4+pVasWNWrUYOnSpYSHh2NgYKDORyaBCyGEyIhkgrfQmr6+PtWrV+fgwYMABAYGEhkZydu3b+nZsyfZs2cnMjKSX3/9lZcvXzJz5kwg5um6Zs2a8eDBA+DjUgPSfhdCCJGRSGNJaM3KyoqBAweyfft2KlWqRL9+/ahYsSLOzs707NkTgBs3bjBnzhzGjx+PmZkZr169Yv/+/ezatYsjR44wbNgw7t+/j66urvQuCSGEyFCksSRSRIMGDXjx4gVDhgyhadOmREZGMm7cOHLkyMG7d++YNm0aTk5ODBgwAIDz58+zYMECqlatSnBwMC9fvqRUqVLs379fI9/IyMh0OBoh4jZnzhx27tyZ3sUQQqQxmeAtUlSzZs0ICgpi0qRJNG7cGIDjx4+zdetWdu3aBcDjx49ZunQprq6uHDlyRJ32ypUrXLhwgerVq3P79m2KFSumnhwuRHrz8fFh6dKlNGnShKZNm6Z3cYQQaUgmeItUFRQURKlSpciZMydHjhwhPDyc9evX069fP/78808qVqwIwNOnT2nSpAmRkZG4ubnh4+NDQEAAW7Zswd3dPZ2PQgjo2rUrb968YdKkSRQuXJioqCh5ilOILEKG4USqMjc3Z/z48axatQqAO3fusHz5cho1aqRuKAHs378fHx8fevbsybx58/j7779xcXFhxowZ6VV0IdQuXLjA5cuXqVevHoULFwZAV1eXqKiodC6ZECItyBiHSHXfffcdAOHh4ezYsQNvb2/++OMP9farV6+ya9cuPD096d27tzrc0NAQX19foqOjUalUMvFbpIuoqChGjhxJ0aJFadWqFU+ePOHx48dUrlwZXV1d9dOb8u9TiK+XNJYyiNevX2Npaale7PFrZGBgQPfu3SlQoAAODg5ATAPqzz//5O7du6xcuVId999//yUkJISiRYsSHR2d6LlL0rASKW3Lli2EhITwzTffYGpqypIlS9i1axehoaHMnTuXqlWrpncRhRCp7Ov9Zc5EoqOj+f7773F0dGTOnDnpXZxU5eDgQOvWrdXf//77bzZv3ky9evWoUKGCOnz9+vUEBgZStWpV9PT04l176erVq+zfv59169Zx69YtdHR0UKlU6texCKGN4OBgZs6cSYUKFahduzZ6enr06tWLrVu30rRpU9q3b8+6des00sg0UCG+PtJYygD+/vtv/Pz8qFGjBvPmzaNgwYKcPHkyvYuVJszNzcmWLRuDBg1Shx0/fpxjx45RokQJGjZsCHwc4vgwR+Tp06f0798fT09PWrZsyZIlS6hcuTLfffcdQUFBX3UPnUg706dPJ3v27HTr1o0XL16wc+dO9u3bh4ODAxMmTKB69eocOXJEo4EkvZpCfH3kFyWdvXv3jvnz52Nra8v69et58OABLVu2pHv37qxcuRJFUb7qO9UKFSpw/PhxcuXKBcQMy23evBmVSkW3bt0ANHqJPjx91KtXLzZv3syQIUN48uQJGzZsYM+ePYSGhlK9enUuX76c9gcjvioPHjxg79691K9fn/fv31OsWDHGjRvHjBkzyJcvH3/88Qeenp6cOXNG3YgfPnx4rBudr/n8FSKrkMZSOlu7di0vXrygffv2QEzDYPz48XTp0oVly5bh7+//1d+pfvr49ZkzZ/j7778pX768+sW9H3qJPvwgbdiwgb179/L9998zYcIELC0tyZkzJ+XLl2fTpk0UL16cbdu2pf2BiK/K8uXLMTMzo02bNsyfPx83NzeOHTvGvn37GDBgAIMGDaJ37940bdoUPT09njx5wvnz5zl8+LDGU3IyLCxE5ieNpXTk6+ur/nFv3rw5ENMw0NPTo02bNty7d49ff/01nUuZtqpUqcLq1avVK33H1as0a9YsPD09adu2rfp9ch8YGBjQvn17dU+VEMnl5eXF8uXLcXJyIjIykly5cpE9e3bs7Ozo27cvrVu3JmfOnHz//fcA6pXoCxYsiK6uLnfu3GHWrFkEBgbKsLAQmZw8DZeO5syZQ0REBF27dgU0n+TKnTs3urq6hISEaKSJiopST2L+WpUpU0b9589/ZP79918CAgJo3Lgxbm5uALEWBqxevTqenp6x8o2MjJQVwUWifFhw0tXVFUA9mbtXr15Ur16dvXv3sn79en7++Wd1w/z06dP4+fnRpk0bIGao+MiRIwQGBjJx4sR0OxYhhPbkdiedXLt2jZMnT1KtWjXKli0LaDYM9uzZA4C1tTWKonDixAnevn2rftFsVl0Mz8nJCX9/f0qWLAkQZz1ER0djZGREaGgot27d4ujRowAJPlUnxKc+b4C3aNGCixcv4uvry9OnT1mzZg1VqlSha9eu6huX33//nR9++IF79+7Rv39/Ll++TI0aNahbt646n3Pnzqn//LXPR0wPMtwpUos0ltJBVFQUY8aMwdjYmMGDB6vDPvQsBQcHs23bNgwMDKhZsyZnz55lwYIFFClShAkTJgCxL+ZZQVRUFPr6+hQtWpSNGzcSHBysUQ8fLpQ6OjrcvXuXZs2aUbt2bbp160b+/Pk5fvz4V90jJ1KHoihERUXh7u7Otm3b6NGjB25ubvTo0QMrKysALl68iJ2dHTo6OsyYMYOAgAAmT55MgQIFsLKyIjAwkEmTJlG+fHkePnxIQECArAeWgl6+fEl0dLQMd4pUI/+y0kFYWBgWFhYcOnSIrVu3EhkZia6urvpEnzdvHvv376dFixa4u7tTuHBhli5dyty5c9m2bRtt27YlMDBQI8+scEelq6uLgYEBgwcP5sWLF+oX837wof78/f1p3rw5UVFRzJ07l7Nnz9K8eXP69u3L8+fP06PoIhNTqVTo6uqqzzEzMzNu3rxJq1at1HGCg4N5/Pgxs2fPRldXl/Hjx2NmZsaDBw8oVKgQ06ZNY+fOnaxatQoXFxfatm3LmjVr0uuQvirR0dH07NmTVq1aERwcnN7FEV8rRaSbzZs3Kw4ODoqHh4cyZ84cZcKECcoPP/yg6OrqKi1btlRevHihXLhwQdm4caNy9+5dRVEU5dy5c4qLi4ty69atdC59+vLy8lKyZcumtG/fXjl06JCyfPlyJSgoSFEURZk2bZqSI0cO5fnz5+r4vr6+ioODg7JmzZo484uMjEyTcovMLyIiIlbY2LFjFZVKpZQvX155+/atoiiKUrRoUWXNmjXK7NmzlSJFiigLFy5UxzcxMVE2btyoKIqiREVFaeQVHR2diqX/+hw6dEipWLGiMnPmzDi3f16/QiSH9Cylo5YtW/L8+XO6du3K4cOHOXr0KOfOnWP27NmMHTuWWbNmUaZMGRYtWkS1atXo2bMnxsbGWFpacuXKFQCuX7/OgAEDskTP0qdGjBjB3bt3UalUzJs3jz///BNfX18AFixYQO/evXFwcCA8PBwAS0tLIiIiMDU1Vefh7e3NwYMHAdTv+FJkDonWXr9+/VX/e4zrIYE2bdrQu3dvFi9ejKmpKd7e3hgYGHDlyhUGDx7MhAkT1A9y/P333+TPn59ChQoBH3tEHz16BMiilknxYZ06R0dHunTpAmjOYwwNDZWhOZEy0ru1JmKEhYUpoaGh6u9XrlxRVCqVsmvXLsXf3185c+aMUqNGDUVPT08xMTFRAgICFEVRlMmTJytFihRR/P39Y+WZVXpLXr9+rbx7905RFEV58uSJ4ubmpqxYsUJRlI936QsXLlRKly6t7NmzR1EURQkODla+//57xcPDQylevLji7e2dPoX/ykRFRSnffPONYmdnp8yePTu9i5Mm4uoJ2rhxo6Knp6fkypVLXQ8fejhOnjyp5M2bV/nnn38URYnpqVqxYoViY2OjrF27ViNP6RVJ2IoVK5T8+fMr27dvVxQl5pr34bp348YNxc7OTjl16pTi6+urrlshkkOa3BmEgYEBRkZG6u+vXr3Czs4Od3d3LC0tKVeuHLNnz8bAwIARI0aQPXt2oqOjURQFW1tbDA0NY+WZVSaBW1lZqevO2dkZV1dXdc+bSqXi/v37bNmyBXd3dypWrAiAiYkJM2bMwNvbm+rVq9OpUydOnTqVXofw1fj01T1z584lX758HDp0KL2LlariWnTSxMQEc3NzBgwYEGvNsGPHjmFqakrhwoUJCwtj3LhxjBs3jiFDhlCnTh11nhB7QVbxka+vL2vXrsXf358+ffrw+++/o6uri66uLu/evWPx4sVER0fj6emJvr4+ixYt4s8//0zvYovMKr1bayJuvr6+SuXKlZVChQop27ZtU6ZPn66ULl1asbe3V/eiKIqiVKxYUendu7f6+/v375V169YprVu3VkJCQtKj6Onmw93477//rpibmytt27ZVhg4dqlhbWys1a9ZUzp49qyiKohw8eFCZP3++smrVKnXa8uXLK2PGjIkz36zSQ6et0NBQpWnTpsq3336rhIeHK4qiKBMmTFBUKpUybty4LNdLEhwcrD4HPxx7RESE0rdvX6V///7KvXv3lMaNGyslSpRQz2eKjo5WDh48qAwZMkTp2LGjsnTp0nQrf0Y3fPhwpUqVKsrJkyeVtWvXKk5OTkqZMmWUs2fPKv/++6+ir6+vbNu2Lb2LKb4SskJfBmVnZ8fx48cZPXo0GzZsAGIeT964caO6F+Xhw4cEBgZSpUoVdboRI0Zw+vRpnJycMDY2jpXvh8X2vkYf7sa/++47ypQpw6hRo3j27BmdOnVi8uTJGBkZMXPmTGbNmkWBAgUIDg7m559/ZuzYsRQoUABFUQgPD8fAwID379/j7++Po6OjxpNQMv8hfuvXr+fGjRvMmDEDfX19oqOjGTduHD169CAyMpJFixZhbGysnrvztVIUhejoaExMTNRhOjo6REdHo6enR3R0NPv27ePVq1fcvn2bffv24eLiAkC/fv24fPkyzs7OFC1alIkTJ7Jp0ybWr1+PnZ1deh1ShvNhnbqaNWtSsWJFKlasSN26dZk2bRr169cnNDSUSpUq0bx5c2bMmMHjx4+ZN2+eerkGRVFkbphImnRurIlECA8PV5YvX64ULFhQI/z27duKm5ubcvLkSeX58+fKsGHDFENDQ2Xjxo3q+U+XLl1SDh8+rOzevVudLis9bfPpk0tPnjxRqlSponTv3l0JDw9X/Pz8lAULFijZs2dX7OzslLlz5yqKoig3b95UKleurJQuXVqpVKmScunSpfQqfqbh4+OjVK1aVbGyslIcHR1jzQ+5du2aUqNGDaV+/fpxPk32Nfv0fAsNDVU8PDwUlUqljBo1Sjl37px62/HjxxWVSqWULVtWefbsmaIoMb1TVatWVVavXh0r36zWU/dBRESE0rhxY6VevXrK48eP1WEfTJ06VVGpVMqtW7eUO3fuKK6urkq7du3izEt6jUViyW1yJqCvr0/37t25cOECABEREUBMz5KPjw/u7u7qOTe//fYbrVu3JjAwkFmzZlG3bl0mTZpEv379KFq0KJcuXcpSd1SfPrmUM2dOIiMjsba2Rl9fHxsbG1q3bk21atXImzevusfjw7u+Jk+eTKlSpahRowaTJ09Wzxs5ceIEv/zyC2FhYWl/QBnUnDlzUBSFXbt2MW3aNIYNG4anpydPnjwBYN26dYSHhzN48GB170pWoVKpCAkJQVEUxowZQ3h4OH379mXKlCkar/YZNWoUlStXxtnZGTc3N0aNGoWJiQkuLi5cvnxZ/aTm2bNngaw7nyk8PBxXV1caNGhArly51D12AM+fP+e3337jhx9+wM3NjSVLlhASEsKKFSsAOHXqFCtXruTAgQMAGr3GQiQonRtrQgsjRoxQrKyslPLlyyvFixfXuEudOHGi4ujoqCxYsEBRlJi70B9//FGpU6eO8v79+/Qqcrr5cHc/e/ZsxcjISOndu7cyY8YMpUKFCoqtra26JyQgIECpUaOG0qtXL3Xa3377TZkzZ47i5+en7N27Vxk+fLji6OioPHjwIF2OJaO5evWqUrFiRWXcuHHqMD8/P8XLy0u5c+eOcvLkSaVy5crKwIED07GU6WfFihWKSqVSypUrp5ibmys7d+6MNZfJz89PKVasmHoe3YEDB5QSJUoojo6Oiru7u/rf4/PnzxWVSqXMmzdPuX//frocT0bx4Zz+0DsUGRmpTJ48WTEzM1Nev36tHD16VLGxsVHmzJmjKIqibNmyRTE3N1eqV6+u2NraKpUqVVJu376dbuUXmYs0ljKx9evXK7q6ukr9+vUVPz8/dfiFCxeUKlWqKHnz5lUsLCzUE5fDwsKU3LlzK8eOHUuvImcIly5dUvr376/07t1bMTExUdq0aaOx/eDBg4q7u7syefJkJSQkRAkODlZevHihvHnzRilfvryiUqmUjh07plPpM5a4hkQ+HR4KDQ1VunfvrlSrVk25ceNGrO1ZxYEDB5S1a9eq6+BzERERSuXKlZVu3bqpw8LDw5UlS5aoh9oVRVH69eunqFQqpUGDBoqnp6dSrFgx5dGjR2lyDBnd5cuXFTMzM2X+/PnK+/fvlRYtWijFixdXb+/UqZPStm1bJTQ0VAkNDVU6dOig1KhRQ/nvv//SsdQis5DGUib38uVL9cn+Ydz++PHjirW1tXL16lXl5MmTSsmSJRUXFxdl/vz5iqmpabwX7Kzm8ePHSr169ZTDhw8rihJTb4GBgYqiKMqvv/6qVKhQQdm5c6c6vq+vr9KxY0clb968ipmZmVK8eHH13JKsKiQkRBk0aJAyb948RVE+3u1/+P9vv/2mlC9fXpkxY0a6lTGzWLlypeLp6Rlrza8PK9OfPXtW0dXVVYYOHap4e3sr//33nzJ9+nT1U55Z3erVqxVnZ2clOjpaWb9+vWJpaakcOnRIUZSYXqeFCxcqRkZG6vmbz58/V/bu3au8efMmPYstMglpLH2Ftm/frpiamiqvX79WFCWmR2n+/PmKnZ2dUrZsWeXJkyfpXMKM57///lMaN26sbNmyRR32/fffK+7u7uqlGj7c5e/YsUNRFEUZNWqU8tdff6VLeTOaTxtJH3qOHj9+rHzzzTdKkyZNlJcvXyqKkjV7lRIrPDxc6dmzp2JkZKR07txZWbVqlXLhwgX19mrVqik1a9bU+HGPjIzMchPmExIcHKz4+/srrq6uSq1atRRFibn+fTB+/HilWbNmysWLF2NtEyIhMsH7K1S7dm2KFSvG+vXrgZgFL/v06cM///zDwoULcXR0TOcSZjw2Nja4u7vz448/MnToUC5evMidO3dwcXFBURSuXr3Krl27cHNzo2nTpgBMmTKFmjVrpnPJM4YPDw2oVCr1xOMNGzbw4sUL2rVrh7W1tbwVPgGKoqCvr8/ixYu5cOECiqJw48YN3r9/D8DmzZs5efIkU6ZMwcLCQp1OV1c3ztevZFUmJiZYWlryyy+/sHLlSgAWLlzI3r17AejSpQsGBgb07t2bwMBADAwM0rO4IjNJ58aaSGEf7vDnzJmjmJubKz179lQuX76snDlzJp1LljmcOnVKKVOmjFKmTBmldu3a6tcoeHl5KYUKFVIPkcjdfMKePn2qlC5dWrGxscnyE5ETKyoqSqPn7cOQ8Lt37xR7e3ulT58+6VW0TOvNmzdK8+bNlcaNG6v/HW7ZskUpXLiw+nUzQiSGSlHkzaFfq+vXrzNo0CBevnxJ7dq1GT9+vMZCeSJ+Dx8+JHfu3Ojo6PDixQsaNmxI6dKlWbJkiSxol0j//PMP7du35+nTpwwZMoRevXpp9IqIuH3eA3fmzBm+/fZbjh8/Tt68edOxZJnT69ev6dmzJ/v376d58+acPXsWBwcH1q5di7Ozc3oXT2QS0ljKAq5fv46VlRVOTk7pXZRM6fXr15QsWZKFCxfSqFEjGU5KotWrVzN48GDMzMxYtmwZtWvXTu8iZTofVpYXyXfy5Em2b99O4cKFKVWqFMWKFZMbH5Fo0lgS4gvCwsIYNmwYS5YsYebMmfTt2ze9i5QpjRw5ktDQUGbPni2NzST4ml9RJERmIY0lIRJp7969nDt3jj59+mBjY5PexcmUIiIi0NfXlzt6IUSmIo0lIYQQQogESF+4EEIIIUQCpLEkhBBCCJEAaSwJIYQQQiRAGktCCCGEEAmQxpIQQgghRAKksZQFhIWFMX78eMLCwtK7KJmS1J/2pA61J3WoHak/oQ1ZOiALCAoKwsLCgsDAQMzNzdO7OJmO1J/2pA61J3WoHak/oQ3pWRJCCCGESIA0loQQQgghEqCX3gXI7KKjo3n+/DlmZmYZ9vUNQUFBGv8XSSP1pz2pQ+1JHWono9efoii8ffsWR0fHVH934vv37wkPD9c6HwMDA4yMjFKgRBmfzFnS0n///Yezs3N6F0MIIcRX4OnTp+TMmTPV8n///j3ZcphDaITWednb2/Pw4cMs0WCSniUtmZmZAXDq5kRMzb7+fzCpJfd7g/QugsjiInKk3g9UVvE85EF6FyHTCn77noru49S/KaklPDw8pqHUvjgY6GqRURS+v18hPDxcGkviyz4MvZmaGWFmni2dS5N5metLY0mkrwhzk/QuQqb3VleugdpKs+kcRnqoDJLfBFB0Mua0k9QijSUhhBAii1HpqFBp0+DRUZGV5vDI03BCCCGEEAmQniUhhBAii1GptOxZUmWtniVpLAkhhBBZTEoMw2UlMgwnhBBCCJEA6VkSQgghshiVSqXdk3cZdBHm1CKNJSGEECKLkWG4pJFhOCGEEEKIBEjPkhBCCJHFSM9S0kjPUgazdvlxqhT5CTfbgTSpMp1zp+8lKt2FMw9wtepPw0pTY237c+cV6pSdgpvNQOqUncKB3VfjzWfRrL/Ia9GXiSO2aoQP/XEteS36any+qTkraQeXRhRFYfyM3TgVG4Zxnj5Ubz6LG7efJ5hm295LlKkzBcsCAzB16UuJmpNYu+VMvPG95v2Jjv0PDBi7SSM8OOQ9fUZuwLnEcIzz9MG98k8s/u2YRpywsAj6jtqAjfsgTF360rTjQv57HpD8A04FUofaWbJ4DwXyd8bcpAnly/bl5Il/Eox//Ng1ypfti7lJEwq6dmHZ0r2x4rx5E0y/vgvJnbMd5iZNKOrxPX/uO6fePmnC7xjq1df45HJqp5FHcPA7+vdbRN7c7bEwbUpRj+9ZumRPyhx0CpNrYer60FjS5pOVpFvP0tGjR6levToBAQFkz549RfIcP348O3bs4MqVKymSX1rbs/Uik0duY+KsVpQqn5f1q07R9dvFHDg7Gidnq3jTBQW+Y8gPa6lQtQCvXr7V2Hbp3EP6dVnFwNENqdu4KAd2X6Nv55VsPjCQ4qXzaMS9evExG387hZuHY5z7qVqrENMXtVd/19fX4r1CqWj6ggPMXnqIVXM7USCvHVPm7KNO6zncPjURM9O432Fkld2EUQMa4JbfHgMDPfYcvEbXAauxtTajbvXCGnHPX37E8rUnKOoe+11iA8dt4eipO6xd0JU8zjn469hNeo/YgKO9BU3rFQdgwNjN7Dl4jQ1LepDD0oQh4/+gcYcFXPhrNLq6GeP+Reow+bZsPsaQQUuZt6A3nhXcWbF8H00ajeXK9aXkymUbK/7Dh740bTyOrt3rsWr1ULxP36Rfn4XY2FjQ/JtKAISHR9Cg3ihsbLKzYdNonHJa89/Tl5iZGWvk5V44N38e+Fn9/fO6GDp4GUePXmXV6mHkzmPHoYMX6ddnIQ6OOWjSxDMVaiN55FqY+qRnKWkyxpU5hQwZMoTDhw+ndzGS7deFR2jZwZPWnSqQv6A946a2wMHJknW/nkww3ZgBG2nSshQlyrrE2rZq0REqVS9Ir8F1yFfAnl6D61ChakFWLjqiES8kOIyBPVbz87y2WGQ3jpUPgIGhHjZ25upPdquM9y4tRVGYu/wwo/rX55uGJfEo5MRv8zoT+i6c9dvOxZuuWsWCNG9QgkIFHMiXx4b+PWpS1N2Jk+c072aDQ97TvvevLJvVAUuL2PV05sIDOrbypFrFguTJZc33HapQrHBOLlx9DEBg0DtWbjjFzJ++pVaVQpQokou1C7ty/dYzDh2/lbKVkUxSh9qZO3s7nbvWoWu3ehQqlItZv/Qkp7MNy5bE7i0CWL50L865bJn1S08KFcpF12716NSlDrNnfezR+G3VX/j7v+WPbeOoULEwuXPbUbGSB0WL5dXIS09PF3t7K/XHxia7xvYzZ27RoUMtqlYrSp48dnTv0YCixfJy6cLdFK8Hbci1UGQ0X1VjydTUlBw5cqR3MZIlPDySf648pXINN43wyjXcuHTuYbzptvx+hscPX9FvRP04t186/4hKn+dZM3aePw3ZTPW6halUXTPup86cvEeZfCOpUXIiI/uuj3XnlhE8fPIKX78g6lRzV4cZGupT1bMA3ufvJyoPRVE4fOIWd+69oEp5V41tfUZsoEGtItSqUijOtBXL5Wf3gas88wlAURSOnLzDv/dfULdaTM/KxWuPiYiI0iifo312PNycOJ3I8qU2qcPkCw+P4NKlu9SuXVIjvFbtkpzxvhlnmrNnblPrs/h16pTk4sW7REREArBn9xnKly9Ev74LcXZsS4liPZnmtZGoqCiNdPfuPiOP83cUyN+Z9u28ePDAR2N7hYqF2bPnDM+evUJRFI4eucrdf59Ru47m/tOTXAvThgzDJU2qNJYePXqESqVi48aNVKhQASMjIwoXLszRo0fjTfP69Wvatm1Lzpw5MTY2pkiRImzYsEG9fc2aNeTIkYOwsDCNdC1atKBjx45AzDBc8eLF1ds6d+5Ms2bNmDlzJg4ODuTIkYPevXsTERGhjuPj40PDhg3Jli0bLi4urF+/njx58jBnzpw4yxkWFkZQUJDGJyUEvA4hKioaa1szjfAcNma8fBH3Ph7e92P6+F3MXtEJPb24u4FfvQjC2tZcI8za1pxXLz6e3Lv/uMg/V58y7Kcm8Zavai13Zi/vyO+7+zJ6SnOuXX5C+8bzCQuLiDdNevD1i6krOxvNY7a1McP3ZcJ/V4FB7zDL2w9D5140ar+AeVPaULvqxx/kjTvOc+n6E7xGNY83j3mTW+NewAHnEiMwdO5F/XbzWDi1HZXK5VeXz8BAD8vsmneidokoX1qROky+V6+CiIqKxtbWUiPczjY7vi/inlPl+yIAO9vsGmG2tpZERkbx6lXM8Tx86Mu2rSeJjopm5+6JjBzVhjmztzH1543qNGXKFmTlb0PYs28yi5f054VvANUqD+b16491MntOTO9V3twdMM3WmMYNxzBvQW8qVvJIoRrQnlwL04Y0lpImVecsDR06lDlz5uDu7s4vv/xCkyZNePjwYZy9P+/fv6dUqVIMHz4cc3Nz9u7dS4cOHcibNy/lypWjZcuW9OvXj127dtGyZUsAXr16xZ49e9i/f3+8ZThy5AgODg4cOXKEe/fu0bp1a4oXL06PHj0A6NixI69eveLo0aPo6+szaNAg/Pz84s3Py8uLCRMmaFkz8Yu1SJgS99pfUVHRDOi2mgEjG5A3f+x5EJp5fpalosD/w57/F8DEEVtZs70Xhkb68ebRqEUp9Z8LujtSpEQuKnv8xJEDN6jXpHiC+09N67aepefQderve37vA8SuRyWeevyUmakhlw+PITgkjMMnbjN4/Bby5ramWsWCPH3mz4AxmziwqT9GCdTTvBV/c+bSQ3au6UXunDk47n2X3iPW42BnEW9Pysfypc/FR+ow5cWuOyXBssUVPyY85nt0tIKtbXYWLemHrq4uJUu58vy5P7Nn/cHosd8BUK9+GXV6jyJQ3rMQhQp0Ze2aQwwY+A0AC+bv5OzZ22zd/hO5c9tx4sR1+vVZiL29FTVrldD6uFOSXAtFRpKqjaU+ffrQokULABYvXsz+/fv59ddfGTZsWKy4Tk5ODBkyRP29b9++7N+/ny1btlCuXDmyZctGu3btWLVqlbqxtG7dOnLmzEm1atXiLYOlpSULFixAV1cXNzc3GjZsyOHDh+nRowe3b9/m0KFDnD9/ntKlSwOwYsUKXF1d481v5MiRDBo0SP09KCgIZ2fnJNVLnOXMYYKurk6sO6fXr97GuhsCCHn7nuuXn3Dz2n+MH7oFiLmgKoqCq1V/Vm/vRYWqBbG2M4+d58u36ru2f6484fXLtzSpOkO9PSoqmnOn7rN22XFuv5wd54RZW3sLHJ2teHT/pdbHro0mdYtRruTH+QlhYTHDFr5+gTjYWajDX756i5117Hr8lI6ODvldYi62xT2cuXXXh6nz91OtYkEuXnuC36u3lK7zcfJsVFQ0x8/cZeHKo7x/spDw8EhGe+1g28ofaVi7CABF3XNy5cZTZi3+i1pVCmFva054eCQBb0I0ekb8Xr3Fs7Tm/JO0InWYcqytzdHV1eHFC3+NcL+XgbF6jz6wt7OM1ev08uUb9PR0yZEjpr4d7C3R09dDV/djr4mbmzO+vgGEh0dgYBD7x93ExIjCHnm4d+8ZAO/ehTFuzGo2/zGWBg3LAlCkqAvXrj5g9i9bM0xjSa6FaUMmeCdNqjaWPD0/Pl2hp6dH6dKluXUr7gmYUVFRTJ06lU2bNvHs2TPCwsIICwvDxOTjxbBHjx6UKVOGZ8+e4eTkxKpVq+jcuXOCd2yFCxfWuMA4ODhw/fp1AO7cuYOenh4lS34cr8+fPz+Wlpax8vnA0NAQQ0PDLx98EhkY6OFR3JmTR25Tt3ExdfjJI3eo1aBIrPim5kb86T1SI+z3FSfwPv4vC9d0wzl3TO9dyTJ5OHnkDt161/iY59+3Kfn/CZAVqhaMlc+wXuvIV8COHwbUivfJogD/EHyeBWBrn/CPZ2ozMzXSeDpLURTsbc05eOwWJYrkAmLmQBzz/pepY75JUt6K8rHhULOyG9eOjNPY3nXAatxc7RnWuy66ujpEREYRERGFzmcXEV1dHaKjY3oKShXNjb6+LgeP3aJV05gGus+LQP65/YxpY5NWvpQidZhyDAz0KVnSlUOHLtO0WUV1+OFDl2jcOO6nzcqVd2Pv3rMaYQcPXqJUKVf09WMu0Z4VCrNp4xGio6PR0Yk5J+/efYaDg1WcDSWAsLBw7tx+QqVKMXO9IiIiiYiIjFW3Oro6REdHJ++AU4FcC9OGCi1fd4I0llJVfH85s2bNYvbs2cyZM4ciRYpgYmLCgAEDCA8PV8cpUaIExYoVY82aNdStW5fr16+ze/fuBPenr695IVGpVOoLw4eu7s/FF57auvWuzuAf1lKkRC5KlnVhw2+neP6fP991jXl8ePr4XbzwecOspR3R0dGhoLvmY605bMwwNNLXCO/8YzXa1J/LktkHqd2wCAf3XufU0TtsPjAQAFMzo1j5GJsYkN3KRB0eEhzGXK991GtaHFs7c/574s/MibuxymFKnUbFyEhUKhX9e9TEa96fuOa1xdXFFq95f2KczYB235RVx+vUZxWODtnxGh0zd8Zr3p+ULpabfHlsCA+PYt/h66zd4s2iaTFDHGamRngUctLYl4mxIVaWJupwc7NsVPUswLCJW8lmpE/unDk45v0va7ecYdb4mN5QC/NsdG1bkSET/iCHlQlW2U0YOuEPihRySnCIKS1JHWqn/8DmdOk0k1KlXClXvhC/Lv+Tp09e0uOHBgCMGbWK589fs/K3mJ70Hj80ZPGi3QwdvIyu3etx9swtflv5F2vXDVfn+X3PhixauItBA5fQq3cT7t19zvSpm+jd5+PcmuFDl9OwUTmcc9ny0u8NXj9vICgolPYdawFgbm5ClSpFGDniV7JlMyRXbltOHL/OurWHmT6zRxrW0JfJtVBkNKnaWDpz5gxVqlQBIDIykosXL9KnT5844544cYKmTZvSvn3M2hXR0dHcvXuXQoU0L37du3dn9uzZPHv2jFq1amk1BObm5kZkZCSXL1+mVKmYceh79+7x5s2bZOepjUYtShHgH8L86ft56RtEgUIOrNzyI065YtYVefkikOf/JW3hvVLl8jJ3ZWd+mbyH2VP2ksvFmnmrusRaVyQhuroq7tx8zvaN5wgKfIeNvTmelV2Zt6oLpmZxr7mTnob1qcu79xH0HrGegMBQypVw4cDG/hq9J0+e+WvcYYeEhtF7xAb+8wkgm5E+bvntWbugK62blYlrF/HasLQ7o6Zsp33vlfi/CSF3Tismj2hKz05V1HFmT2yFnp4Orb9fzrv34dSs5MaquZ3TfX2gT0kdJl/LVlV5/fotP09ej4+PP4U98rBz90Ry57YDwNfXn6dPPs6LdHGxZ+fuiQwdsowli3fj4JiDX+b0VK+xBODsbMPeP6cwdPBSSpfohaNTDvr0bcqQYS3VcZ49e0XH9tN49SoIGxsLypZz48Sp2er9AqxdP4Kxo3+jc8fp+Pu/JVduWyZM6sT3PzRMg5pJPLkWpj4ZhksalZIK3SiPHj3CxcWFXLlyMWfOHAoVKsTs2bNZv349Dx8+xNraOtailAMHDmTr1q1s3LgRS0tLfvnlFzZv3kz16tXZsWOHOu+goCAcHByIjIxkzZo1tG7dWr3t80UpO3fuzJs3bzTSDxgwgCtXrqifzKtduzb+/v4sXrwYfX19Bg8ezJkzZ/Dy8qJ///5fPNagoCAsLCy4+nQ6ZubZUqL6sqQ87wzSuwgii4uwzpXeRcj0noUkbpVtEdvboHcUcx5GYGAg5uapN6T34TfLfEwNVEbJ7y9R3kcSNPnvVC9vRpGqt2FTp05l2rRpFCtWjBMnTrBz506sra3jjDt27FhKlixJ3bp1qVatGvb29jRr1ixWPHNzc1q0aIGpqWmc25NqzZo12NnZUaVKFZo3b06PHj0wMzPDyChz3SUIIYQQInWk6jBcoUKFOHMm7ndDVatWTWNukJWVlUYPUEJ8fHz47rvvYk20Hj9+POPHj1d//+2332Kl/Xz9JAcHB/bt26f+/t9//+Hn50f+/PkTVRYhhBAis5FhuKRJt3fDJYe/vz9//fUXf//9NwsWLEiRPP/++2+Cg4MpUqQIPj4+DBs2jDx58qjnWgkhhBBfG2ksJU2iG0sf5iElxqeP+6ekkiVLEhAQwLRp0yhYsGCK5BkREcGoUaN48OABZmZmVKhQgXXr1sV6ik4IIYT4Wqh00LKxlHJlyQwS3VjS19dPdAOlQIEC7Nq1K9mFis+jR49SPM+6detSt27dFM9XCCGEEF+HRDeWnJycuH37dmqWRQghhBBpQcthOEWG4YQQQgjxNdN2zlJWe5FuFht1FEIIIURa8/LyokyZMpiZmWFra0uzZs24c+dOehcr0aSxJIQQQmQxH3qWtPkkxbFjx+jduzdnzpzh4MGDREZGUqdOHUJCQlLpCFOWDMMJIYQQWYxKpd2LdJOadv/+/RrfV61aha2tLRcvXswUS/VIY0kIIYQQyRIUFKTx3dDQMNaC0XEJDAwEYhakzgyksZRCfEJeEqTz5X8gIm55Jx1M7yKILG54+yLpXYRMr5GLfXoXIdMKCQlL0/2pVFpO8P5/z9LnL7P/6aefNN6kERdFURg0aBCVKlXCw8Mj2WVIS9JYEkIIIbKYlHoa7unTpxov0k1Mr1KfPn24du0aJ0+eTPb+05o0loQQQogsJqUaS+bm5hqNpS/p27cvu3bt4vjx4+TMmTPZ+09r0lgSQgghRKpSFIW+ffuyfft2jh49mujXp2UU0lgSQgghshgdnZhP8jNIWvTevXuzfv16du7ciZmZGb6+vgBYWFiQLVs2LQqSNqSxJIQQQmQxuioVOmm4dMDixYsBqFatmkb4qlWr6Ny5c7LLkVaksSSEEEKIVKUoSnoXQSvSWBJCCCGyGF0dFTrybrhEk8aSEEIIkcWk9TBcZifvhhNCCCGESID0LAkhhBBZjI4O6Kbh03CZnTSWMpjtv11gwxJvXvsFk6eADf0m1KFYuVzxxg8Pi+S32Sf4a9t1/F+GYONgRsd+lWjYpjgAkRFRrF1wiv1brvHK9y3OeXPw4+ialKue7+M+V19kx9qL+D59A4BLARs6D6xM+Rr51XH8XwazeMrfnD/+gODA9xQrn4sBk+rhnDfjvNdnRN2OfFO8Gm72uXkXEcbp+9cZvmMh/754kqj0FfIW5digRfzz/AElfu4YZ5zWpWuxsdtkdlw5RvOlw9XhPzXszvhG3TXi+ga+xmFEQ/V3E8NsTG3Wi2bFqpLDxJxHr32Zd3QzS45vS8bRpg6pQ+09veLD2fXXeHHnNcGvQ2n+cy0KVMkTb/z/rvpydMk5Xj8OJPJ9JOb2phRv6kaZ1h9fv3Jl121u7L/LywcBANgXtKbKD6VxdLdVxwkLDefE8ovcPf6Y0IB32BbIQa3+njgUslHH2TvlGP/8eVdj/w7uNnRc1jSFjj7lyLUwdemqVOhqM5SWxYbhsnxjqVq1ahQvXpw5c+YAEBoaSocOHTh48CBv374lICCA7Nmzp0lZDu+8wbzxfzHo5/oUKePMrrWXGNp+A2uP9sTOySLOND/13Ib/yxBGzGyEk4sVAa9CiIqMVm9fPv0of237h2HTG5I7fw7OHn3AqO5bWLyzMwU8Yt7jZOtgRs+RNXDKYwnA/i3XGNl1MysP9MCloA2KojCq6xb09HXwWtkKE1NDNi07w8A2v7P2aE+yGRukfuUkQlXXEiw8tpXzj2+ip6PLlKY9+avvXNwntiU0/H2Cac2NTFjTeRyH71zAzizui14uK3tmftOP43cvx7n9n+f3qTW3r/p7VHS0xvbZ3w6geoGStF81nkevfajjXpZFbYby/M1Ldl07kcSjTR1Sh9oLfxeJbf4cFGlYgB2jD38xvn42PUp+UxibfFYYZNPjv2u+HJhxCn0jfYo3dQPg6WUfCtXKR60idugZ6HJ23TU2D9pPt7UtMLMxAWD/1BO8fBBAo7FVMbU25saBe2wcsI/uv3+rjgPgUi4nDUZ9fMu7rn7G6yKQa6HIaDLeWZLOVq9ezYkTJzh9+jQ+Pj5YWMR9YqaGTcvP0rBNcRq3K0EeV2v6TayDraM529dcjDP+2SP3uXLmMTPWtqF0lbw4OGfHvYQTRcp8fLHhga3X6dC3Ip418+OY25LmnUpRtmpeNi49o45TsU4BPGvmJ1e+HOTKl4PvR1Qnm4kBNy79B8DTB/7cuPSMwV4NKFTckVz5czDIqz7vQiI4tONG6lZKEtRfMJDVZ/Zy0+ch157do8uayeTO4UCpXG5fTLv0uxGsP/8X3g/+iXO7jkqHdV0m8NOe5Tx49TzOOJFRUbwI8ld/XgW/0djumdeD1Wf2cezuJR77+7D85E6uPrtH6dyFknysqUXqUHv5PJ2p8n1pClZN3ArFdgWsca+dD5u8llg4mFG4risuZZ3475qvOk7jn6pT8ht37FxzkCN3duoNr4QSrfD4Qkw9RoRFcufYI6r3KotzcQcsc1pQqVspsjuYcXn7LY396RnoYprDWP3JZm6UcgefQuRamPo+9Cxp88lKpLH0mfv371OoUCE8PDywt7dPsxn/EeFR/HvNh7JV82qEl6mal38u/BdnmpN//UvBog6sX+xN81JzaVtpEQsnHiLsXcTHfMOiMDDU1UhnaKTH9XNP48wzKiqaQztv8D40gsKlcqrLBmjko6urg56BLtfiyScjsMhmCoB/aFCC8Tp7NiSftRMT9v4ab5xxDbvyMjiAlad3xxvH1daZZ167eTBpGxu6TcLF2lFj+8l7V2lStDKOFjHDItUKlKSArTMHbp5N7CGlOanDtPfi31c8+8cP5+L28caJCIskOjIaI/OYl5ZGR0WjRCnoGmie63qGehqNLoAnl32Y3+h3lrXZzJ/TThAS8C7lD0ILci1MG7o6Kq0/WUmmHoY7ffo0vXr14vbt23h4eDBmzBiaN2/O5cuXKV68OADHjh1j6NChXL16FSsrKzp16sTkyZPR04t96NWqVePYsWNAzGORVatW5ejRo2lyLIH+oURFKVham2iEW1qb4O8XHGea508CuH7+KQaGekxZ8S2B/u/4ZdSfBL15x8hfGgNQtlpeNi07S7FyuXHKY8nFkw85eeBfoqM1Fwi7f8uPH5usIjwskmwmBkxZ0RKXAjE/SLnz58A+pwVLvY4wdFoDjIwN2LTsDP5+wbyOp2wZwS/f9ufEvSvceP4g3jj5bZyZ2qw3lWf9QFR0VJxxKuQtSrcKTSg+pUO8+Zx9dIOOqyfy74sn2JlbMaZ+F04PWU7hSW3xD4lpaPTb/AvL24/k2dTdRERFEh0dTffff+bU/avaHWgqkjpMOwubr+fdm/dERylU7FqSYo3j7807tvg8pjYm5Ckd05g0NDbA0cOW079dJkee7JhYZuPWofs8v+mHVc6PveN5y+fErboL5vamBD5/y4kVF9nYbx+dfm2G3mcNrfQi18K0oQvoZq32jlYybWPp7du3NG7cmAYNGrB+/XoeP37MgAEDNOI8e/aMBg0a0LlzZ9asWcPt27fp0aMHRkZGjB8/Plae27ZtY8SIEfzzzz9s27YNA4PY489hYWGEhYWpvwcFJXzHnVSxerKU+NezUKIVUKkYt6AZpv/vSu/zU23Gfv8Hg6bUwzCbPv0m1mH60L20r7oYlQocc1vSoHUx9m3S/HHJlS8HK//qQXDQe47uu82UAbuYv7UDLgVs0NPXZfLyb5k6eA8NCs9CV1dFqcoulK+RL65iZQgL2gyhqFN+Ks38Pt44Oiod1neNGRa66xf3XaGpoTG/dxlPj3VevA4JjDev/Te81X/+5/l9vB9c5/7ErXQq35DZhzcA0K96K8q7eNB40RAe+/tSJX9xFrUdik/Qaw7fPp/MI009Uodp67uFjYl4F8GzG34cW3IeSydz3GvHPsfOrrvKrUMPaDu/AXqGHy/hjcZW40+v4yxqtgGVrgr7/w/vvfj3tTpOoZof87PJa4W9mw2Lv93Ife8niR42TCtyLRQZSaZtLK1btw6VSsXy5csxMjLC3d2dZ8+e0aNHD3WcRYsW4ezszIIFC1CpVLi5ufH8+XOGDx/OuHHj0PnsLYJWVlYYGxtjYGCAvX3cXeBeXl5MmDAhxY/HwsoYXV0V/i81704CXodgaWMSZ5octqbY2JupLw4AuV2tURTw83mLc14rLHOY4LWyFWHvIwkKCMXa3owlP/+NQ67sGnnpG+iS0yVmUq5bMUduX3nOHyvOMXR6zJNIBYs6sOpgzAUkIiIKyxwmfN9oJW5FHVKwFlLGvFaDaVKkMlV+6cmzNy/jjWdmZEyZPO6UcC7AgtaDgZgffx0dHSIWnKTO/P74hwThYu3I7h9nqNPpqGL+3UQsOEnB8a158OpZrLxDw99z/fl9XG1j5kwY6Rvyc9Mfab50OPv+OQ3A9Wf3KO5cgCG12mW4H3qpw7SX3dEMAJt8VoT6v+PUykuxGktn11/De+1VWs+pj23+HBrbLJ3MabegEeHvIggPicDU2pid4w5j4WAW7z5NrY2xsDcl4GnK3vRpQ66FaUProTQZhssc7ty5Q9GiRTEy+nhylC1bViPOrVu38PT01LgbqVixIsHBwfz333/kyhX/Y6jxGTlyJIMGDVJ/DwoKwtnZOYEUiaNvoEuBog6cP/6QKvU/dr+fP/6QSnULxJmmSBlnjuy5RWhIOMYmMb1gTx+8RkdHhe1nF0hDIz1sHMyJjIji2L7bVG+U8IRYRYHw8NhDKh8uRk8f+HPnqg/dh1ZN0nGmtvmtB9O8eFWq/dKbR699Eowb9D4Ej0ntNMJ6VWlBjYKl+Hb5KB6+ek5UdHSsOJMb/4CZkTH9t8zmacCLOPM20NOnkH0eTty7AoC+ri4GevpEf/Z+pKjoKHXDIaOQOkx/CjGPun/q7PprnF59mVaz6uPgZhN3QsAgmz4G2fR5HxTGw3PPqPZj2Xjjvgt8T5BfCKY5jFOq6FqTa2Ha0NFykraSxSZ4Z9rGkqIosbpkP39RX0Jxkjtx29DQEENDw2Sl/ZLWPcoxuf9O3Io5ULhUTnb9fgm/Z4E061ASgCVef/PK5y1j5sWsiVKruQer55zAa+Buug6pQqB/KIsmHaZBm2IYZtMH4MalZ7zyfYtrYTte+r5l5azjREcrtOtVQb3fpV5/U75GfmwdzQkNDufwzhtc8X7MzHVt1XGO7L5J9hzG2DlZcP+2H/PG/UXlegUpWzXjdD8vbDOUdmXq0HTJMN6GhWBnHnN3GPguhPcRMUOnPzf9EafsNnRaPRFFUWLNxfF7G8D7iHCN8M/jvHkXHCt8xjd92X39JE/8fbE1i5lvY25kwuoz+wB4+z6Uo/9eYsY3fXgXHsZjfx+qupakY7n6DNo6L+UrI5mkDrUXHhpBwLOPPTWBPm95cfc12cwMMbc35diS87x9GUKjsdUAuLT1JuZ2Jljlzg7Af9decG7DNUq1KKzO4+y6q5xYcZHGP1XHwsGU4NehwP8bRsYx5/qDs/+BomCVKzsBzwI5uvAcVs4WFGlYQF2ukysvUbBaHkxzGBPo85Zjyy6QzcIQ16q506BmEk+uhSKjybSNJTc3N9atW0dYWJi68XLhwgWNOO7u7mzdulWj0XT69GnMzMxwcnJK8zJ/Sc2mhQkKeMdvs0/w2i8Yl4I2TF/bBvuc2QF4/SKYF88/zvkwNjHgl43fMWfMAXrU/xULy2xUb+xOj2HV1HHCwyJZPv0oPk8CyGZsQPka+Rk7rylmFh975AJehTC5305e+wVjYmZIvkK2zFzXljJVPj6N8tovmAUTDuL/KoQctqbU+7YonQZUTvU6SYpeVVsAcGzQYo3wzqsnsfrMXgAcLKzJZRX/U0bJldPSlg1dJ2Jtmp2XwQGceXiD8tO78cT/45NIbX4dg1fTXqzrOh4rY3Me+/syetfSDLWgotSh9nxvv2RDv33q73/Pj3lSz6O+Kw1HVyX4dShBLz4OMSmKwrGlFwj0eYtKV4WlkznVepaheNOPPR6Xtt8iKiKaHWM0122q2KUElbqVAiAsOJzjS2MaYkbmhhSs6kKV70ujqxfT66bSVfHygT839t/lfXA4pjmMyVXSgaYTamCYwdYHkmth6tN2GE7JYsNwKuXz7phMIigoCBcXFxo1asSIESN48uQJAwYM4Pbt21y5coVixYrx7NkzChQoQJcuXejTpw937tyhe/fu9O7dWz3B+/NFKQcMGMCVK1cS/RRcUFAQFhYW7L89FBOz1OlxygoqTzqY3kUQWdzw9kW+HEkkqJFLyjeis4qQt2HUc5tBYGAg5ubmqbafD79ZFX/7Fr3/90omR2RoBKc6/5Hq5c0oMu1Av7m5Obt37+bKlSsUL16c0aNHM27cOAD1PCYnJyf27dvHuXPnKFasGD179qRbt26MGTMmPYsuhBBCiEwk0w7DAVSoUIGrVz8+9rlu3Tr09fU1Jm5XrVqVc+fOxZvH5z1IH3qYhBBCiK+VDMMlTaZuLK1Zs4a8efPi5OTE1atXGT58OK1atSJbtmzpXTQhhBAiw9L2lSVZ7Wm4DDUM9+jRI1QqVaI+Hh4e+Pr60r59ewoVKsTAgQNp2bIly5YtS+/DEEIIIcRXJEP1LOnr61OwYMFExc2bNy/Dhg1j2LBhqVwqIYQQ4uuiq0LLnqUULEwmkKEaS05OTty+fTu9iyGEEEJ81XR0QFeLsaXoDDUulfoyVGNJCCGEEKlP2zlL0TJnSQghhBBCfCA9S0IIIUQWo+3SAdGydIAQQgghvmYyDJc0MgwnhBBCCJEA6VlKIWXtK2JubpLexci0oud6pncRRBYXpSeXQ22pVHL/nVxBJiHAjDTbn648DZckcnUQQgghshhdtByGQ4bhhBBCCCHE/0nPkhBCCJHF6Gj5NFyUPA0nhBBCiK+Ztk/DaZM2M5JhOCGEEEKIBEjPkhBCCJHFaPs0nDZpMyNpLAkhhBBZjAzDJY00loQQQogsRlcV89EmfVaSxTrShBBCCCGSRnqWhBBCiCxGR6VCR4uhNG3SZkbSWBJCCCGyGB0th+Gy2DJLMgyX0SxetIv8eTtgkq0BZUv34sSJ6wnGP3bsKmVL98IkWwNc83Vg6ZLdGttXLN9H1SoDsbZqjrVVc+rUHsa5c7fjzW+q1wb0dGozaMCiWNtu3XpMs6ZjscrelOzmTajg2ZcnT/ySd6CpSFEUxk9ah1OeDhhbNKd67RHcuPn4i+m2bj9F4WI9MTJrSuFiPdm+87TG9sjIKMb8tIa8BbpibNGcfAW7MnHKeqKjo5O07+q1R6Bj2FDj07b9tJQ5+BQidaidxYt345qvI6bGjShbpjcnv3AeHz92jbJlemNq3IgC+TuxdMkeje2rf/sLfd26sT7v34er4yxZvJsSxXtilb05VtmbU6niAPb/eV4jn65dZsbKo2KF/il34ClIroUiI5HGUgayedNRBg1czMhRbblwaTGVKnnQqMGoeE/Chw99aNxwDJUqeXDh0mJGjGzLgP6L2Lb1hDrOsWNXadOmOof+nsHJ03PJ5WxL/bojePbsVaz8zp+/w4rl+yhaNG+sbffvP6dq5YEULJiLw0dmcenKUkaPaY+RkX7KVUAKmT7rD2bP3c78OT05d3o29naW1GkwhrdvQ+NN433mFm2+m0r772pw5fwC2n9Xg9btpnL2k4vptJlbWLr8T+bP6cnNq0uY5tWVmb9sY/7CjxflxO67e9e6PH+8Vv1ZsrBPyleEFqQOk2/zpqMMHriEESPbcv7iopjzuOGYBM5jXxo3ijmPz19cxPARbRg4YLHGeQxgbm7M02cbND5GRgbq7Tlz2vDzz105c24+Z87Np3r1YnzTfDw3bjzSyKdu3dIaeezeMynF60Bbci1MfToq7T9ZiUpRFCW9C5GZBQUFYWFhgf+bHZibm2iVl2f5vpQskZ+Fiz/e6Xm4d6VJ04r87NUtVvwRw5ezZ7c3/9xcqQ7r1XMOV6894NTpeXHuIyoqCmurb5g3vw8dOtZWhwcHv6NMqR+Zv7AfP09ZR/Fi+fhlTi/19nZtp6Cvr8vqNSO0Osb46ESEfzlSIiiKglOeDvTv25ThQ1oCEBYWgb3zd0yd0oUfetSPM12b76YSFBTKvt0T1WH1G43F0tKU9WuHA9C42Xhs7bLz69IB6jjftp6CsbEha1YNSfS+q9ceQbGieZkz6/sUOeaUllXrMEovZWYlVPDsR4kS+Vm4qJ86rEjh7jRpWoEpP3eNFX/kiBXs2X2G6zdWqMN6/TiXa9cecvLUHCCmZ2nwoCW88t+WpLLYWrdg6rQedO1WD4jpWQp8E8zW7eOTfmCJoFKlzP13VrwWBgWFYJW9GYGBgZibm6do3pr7ifnN6vNnRwxNDL6cIB5hIeEsqL8m1cubUUjPUgYRHh7BpYv/UrtOKY3w2rVL4e19I840Z87conZtzfh16pbm4oV/iYiIjDNNaGgYERGRWFqZaYT37TOf+g3KUatWyVhpoqOj2bf3LK6uOalfbwQOdi3xLN+XnTtOJeUQ08TDh774+gZQ55PjMDTUp2plD7zP3Io3nffZ29SuVUIjrE7tkpz+JE3Fiu78feQq//77DICr1x5w8vRN6tcrneR9r994BBvHtngU/5Ehw1ck2GOT1qQOky/mPL4b67ysVbsU3t4340xz5swtan1+HteJfR4HB78jn0sH8uT6jqaNx3L58r14yxEVFcWmjUcJCQmjvGchjW3Hjl3D0b4V7m5d+eH72fj5vUniUaYuuRaKjEgmeCdRWFgYYWFh6u9BQUEpku+rV4FERUVja2epEW5rZ8kL34A407zw9cfWrnSs+JGRUbx6FYiDQ45YaUaNWIGTk7XGhWDTxiNcvnSXM+cWxrkfP783BAe/Y/q0TUyc1Bmvqd05sP8C37aYwKG/Z1C1arGkHm6q8X0RU1d2ttk1wm1ts/Pkycv40/kGYPdZ3dvZWeL7Sd0PH9KSwMBQChX9AV1dHaKiopk8sSNtW1dL0r7btamGSx477O0t+efGY0aNWc21aw/5688pST3cVCF1mHyvXgX9/zzOrhFuZ5c9gfM4ALvP4tvaZdc4jwu6OfPryiF4FMnD26BQ5s/bQdXKg7h4eTGurk7qdNevP6RyxQG8fx+OqWk2/tg6Dnf33Ort9eqV5ttvK5Mrtx2PHvry00+rqVNrGGfPL8DQMPm9DClJroVpQ0dHhY4WY2napM2MpLGURF5eXkyYMCHV8ld99jimoiixwr4UP65wgBnTN7Fx41EOH5mpnuvw9KkfAwcs4s8DUzXmP3zqw+TbJk09GTCwBQDFi+fH2/sGy5buSdcLxLoNR+jZe4H6+54d44E46gX40pOun2//vO43bTnOug1HWLdmKIXdc3Pl6gMGDlmGo4MVnTrU+iSfhPfd4/9DIgAehfPgmt+RMp4DuHT5HiVL5E+4kKlA6jDlxX0eJyW+Znj58oUoX/5jD1GFioUpU7o3CxfsZM7cj0NEBQvm5MKlRbx5E8L2bSfp2mUmh4/MUDeYWv2/UQrg4ZGHUqVdyefSkX17z9H8m0rJOdRUI9fC1CWLUiaNNJaSaOTIkQwaNEj9PSgoCGdnZ63ztba2QFdXhxe+/hrhL/3exLpL/cDO3irO+Hp6uuTIoTmGPGvmFqZ6beDAwWkakxYvXbyLn98bypb+eMGNiormxPHrLFy4k9D3+7C2tkBPT5dChXJr5OnmlotTp/5JzuGmmCaNylGuTEH197DwCCCmh8LBwUod/tLvTaxej0/Z22v2gEDMXeSnd/zDRq5k+JCWtGlVFYAiHnl4/MSPqdO30KlDLez/n39S912yRH709fW4e+95uvzQSx2mHGtr8/+fx5/XQ2CsnpIP7OKot/jO4w90dHQoXboA9+4+0wg3MNAnf/6YnqbSpQtw4cId5s/bweIlcT/x5uCQg9y5bbl371mc29ODXAtFRiRzlpLI0NAQc3NzjU9KMDDQp2SpAhw6eEkj/NChS3h6Fo4zTfnyhTh0SDP+wb8uUqp0AfT1P7aDZ87YzJTJv7P3z58pXbqgRvwaNUtw5doyLl5eov6ULl2Adt/V4OLlJejq6mJgoE/pMgX599+nGmnv3n1G7tx22hy21szMjMmf31H9cS+UC3t7Sw4euqyOEx4ewbET/+BZvlC8+XiWc+PQ4SsaYQcPXabCJ2lCQ8NidT3r6uqo7zZdXOyTte8bNx8TERGJg71VvHFSk9Rhyok5j11jnZeHD13C09M9zjTlyxfi8Ofn8cHY5/GnFEXh6tUH2DskfLyKEjNBPj6vXwfx9OlL7NO53j4l18K0IU/DJY30LGUgAwe2oFPHaZQqXYDynoVYvmwfT5748UPPRgCMGvkrz5+/4rfVMU8W/dCzEYsW7mLwoCV071GfM963WLlyP+vWj1LnOWP6Jn4at5rf140kTx57fP9/92Vqmg1T02yYmRnj4eGiUQ5jEyNyWJlrhA8Z0pK2baZQuXJRqlUvxoH959mz25vDR2aldrUkiUqlon/fpnhN34yrqyOu+R3xmrYZY2ND2rWpqo7XqessHB1z4DW5MwD9+jShas3hTJu5haaNyrNzzxkO/X2FE0emq9M0bliWn6dtIpezDYXdc3P56n1mz91Ol061E73v+/d9WLfxCA3qlcE6hzk3bz1hyPAVlCiej4oV4m8MpCWpQ+0MGPANnTvNoFSpmPN4xfKY8/j7HxoCMHrUSp49e8Vvq4cB8P0PMefxkMFL6dY95jxetfIAv6/7+LTVpIm/U66cG/ldnQgKCmXB/B1cvXKfefN7q+OMGb2SevXKkNPZhrdv37F501GOHb3G3n2TgZgJ4hMnrKX5N5VwcLDi8aMXjBmzCmtrC5o1r5iGNfRlci1MfTIMlzTSWMpAWrWuxuvXQUye9Ds+Pv54eORh994p6jsWX9/XGuuMuLg4sHvvZIYMWsLiRbtwdMzBnLm9+KZFZXWcJYt3Ex4eQauWEzX2NXZcB34a3zHRZWvWvBKLFvdn2tQNDOi/kIIFc7Llj5+oVMlDy6NOecMGf8u7d+H07reIgIBgypUtyIG9kzAzM1bHefL0pUYPRwVPdzb8PpyxP61l3PjfyZfXno3rhlOurJs6zrzZPRk7/nd691+En18gjg5WfN+9PuNGt030vg0M9Pj7yFXmLdhFcPA7nHPa0KB+GX4a0w5dXd00qJ3EkTpMvlatq/Ha/y1TJq/Dx8efwh652b1nsvo89vHx5+nTj5PVXVzs2b1nMoMHL2Xxot04Oloxe86PGufxmzfB/NhzLr6+AVhYGFO8eH7+PjqTsp/U7YsXb+jcaQY+Pv5YWBhTpKgLe/dNVj9pp6urwz/XH/H72kO8eROCg4MVVasVY/2GURp/rxmBXAtTn7zuJGlknaXP/Pbbb3Tp0oXEVktKrrOUlaXUOktCJFdKrbOUlaXUOktZUVqvszTicGet11maWvO3LLPOklwdPvPo0SOqVq365YhCCCFEJqWDlu+GS7GSZA7SWPrMgQMHmDt3bnoXQwghhEg12k7SlgneWZy3t3d6F0EIIYQQGYg0loQQQogsRlelQleLSdrapM2MpLEkhBBCZDEyDJc0WW2OlhBCCCFEkkjPkhBCCJHFyKKUSSONJSGEECKL0dGJ+WiTPivJYocrhBBCCJE00rMkhBBCZDHyNFzSSGNJCCGEyGJUWj4Nl8XaStJYSik6Pv+iE5wtvYuRab3otza9iyCyONsBldK7CJmeKq9Lehch09J5+y5N9ycTvJNG5iwJIYQQQiRAepaEEEKILEYWpUwaaSwJIYQQWYxM8E4aGYYTQgghRKo6fvw4jRs3xtHREZVKxY4dO9K7SEkijSUhhBAii/kwDKfNJylCQkIoVqwYCxYsSJ0DSmUyDCeEEEJkMWn9NFz9+vWpX79+8neYzqRnSQghhBAiAdKzJIQQQmQxOioVOlpM0v6QNigoSCPc0NAQQ0NDrcqWEUnPkhBCCJHF6Kg+DsUl5/NhzpKzszMWFhbqj5eXV/oeWCqRniUhhBBCJMvTp08xNzdXf/8ae5VAGksZkqIoTPjlT5avP0XAm3eUK5GbBVNaUbigQ6LSb9x5kXa9f6Np3SJs//V7jW2LVh9n5pLD+PgFUbiAA7PHf0Plcvk14ty668uIn3dy7Mw9oqMVChdwYNOSLuRyssI/IISfZu3j4PHbPH0egLWVKU3rFmXS0IZYmGeM170YlquGcZ3m6Od1Q8c8O68Gtyfy0d0vplMZm2La7keMyldDx8SMKL/nBK2eR/il0wDYLN6Orq1jrHQhf/7B2xUzYvIwyoZp+94Yla2Kjqk5US99CNm3mXcHtsW5T8vRszEsWYGAaUMJO3dci6NOWVKH2lEUhYmrvFm++zoBb99Tzt2B+QNrUNjFOt40Nfpt5tiV/2KF1y/vwp7pzQHI22oFj32DYsX5sVkxFgyqSURkFGOXn+LPMw954BOIhYkhNUvnwuuHyjham8ZZzobDtnPg7CO2TmlCs8r5Y8VJL3IdTF0pNQxnbm6u0Vj6WkljKQOavugQs5cfYdUv31Egry1T5h2gTrsF3D42FjNTowTTPv7Pn6GTdlC5XL5Y2zbtusjA8dtYOKUVFcvkZenvp2jQYTE3jowml5MVAPcfvaRy89l0bePJ+MENsDDLxq17vhgZ6gPw/EUgPi8CmTG2Ge6u9jx+5s+PIzbh8yKQLcu6pXxlJIPKKBvht6/x/vRhLHqNTlwiPT2sfppPVGAAb2aMJMrfD90cdijvQtVRXg3vgkrn48i1Xq58WP20gDDvw+ows84DMPAoReDcn4jy88GgeDnMewwl2v8VYec1f8iNG7XR7kBTkdShdmasP8/szZdYObIuBZwtmbLmLHUHbeXWui6YGRvEmeaPyY0Jj4hWf38d9I4SXdfybfUC6rCzy9oRFaWov//z8BV1B21Vxwl9H8mlu36M7lSeYvltCHj7nkHzj9Js5E7OLf8u1j7nbrlERl1aUK6DqSulGkuJFRwczL1799TfHz58yJUrV7CysiJXrlzJLkdaydJzlh49eoRKpeLKlSvpXRQ1RVGY++tRRvWtwzcNiuPh5shvs9sT+i6C9TsuJJg2Kiqa9n1XM35wA/LmyhFr++xlR+jaxpPu7SpQyNWeORNa4OxoyeI1J9VxxkzfQ4MahZk+phklPJzJm9uahjU9sLU2A8DDzZE/lnence0i5MtjQ42KBZk8vDG7D/1DZGRUylZGMr0/9ichW34l/Nr5RKfJVqMxKlNz3kwbSsSda0S/9CXi9lUiH3/sTVGC3hD9xl/9MSxViUifp4TfuKSOo1+wCO+O7iP8xiWiXvrw7uAOIh/dQz9fIY396eV2xaRxOwIXTtL+gFOB1GHyKYrC3C2XGdWhLN9UdcUjrzW/japLaFgk6w/ejjedlXk27HOYqD+Hzj/B2FCfltU+NpZsshtrxNl7+gH5nCyoWjwnABamhvz1y7e0qlGQgrmsKF/Ykbn9a3DxzguevNDskbp67yWzN13k1xF1U6citCDXwdSng0rdYErWJ4nN7AsXLlCiRAlKlCgBwKBBgyhRogTjxo1LjcNLcVm6sZQRPXzyGl+/IOpUdVOHGRrqU7V8frwvPEww7cTZf2JjZUq3tp6xtoWHR3Lx+lPqVHHTCK9dxU2db3R0NHsP38A1ry31vluIXbGRlG80kx37rya438Cgd5ibGqGnp5vYw8xwjMpUIeLOdcx7DMPm1z/JMXs9Jt90Ap14ThE9PbJVqce7v3drBEfcuopRmcroWNkAYOBRCl1HZ8KunPkYycCQ7AMnEbRiJtFv/FPrkNKc1GGMhz6B+PqHULtMHnWYoYEeVYrlxPuf54nOZ+Xe67SuWRCTbPpxbg+PiGLdwVt0aeCBKoG7/MCQMFQqyG76cS5J6PsIvpuwl3kDamCfwyTRZUorch38+lSrVg1FUWJ9fvvtt/QuWqJIYymD8X0Zc/dnZ605BmxrbabeFpdT5x+wcuMZls1oG+f2V/4hREVFY2djphFuZ/MxX79XwQSHhDFt4UHqVivEgfW9aVavKC16/Mox77jnq7wOCGHy3P18375ioo8xI9K1c8TIswbo6BAwZSAhf6zCpMl3mLToEmd8o7JVUZmY8u7IXo3woJWziHz6ENvle7DbdArLMXMIWj6DiNsfL7TmXQYSfudarCGlzE7qMIbv65hhRzsrY41wOytjfP1DEpXHuZs+/PPwNd0aesQbZ8eJe7wJDqNT/cLxxnkfFsmopSdpW8sNc5OPjaVB84/i6eFI0ww0R+lTch1MfTE9RDpafDLqAG7qkDlLwIMHDxg4cCBnz57F1dWVJUuW4OkZ+64EICwsjLCwMPX3z9eYSKp1287Tc8RG9fc9q3sC8Pm/Q0VRUMXT7fk2+D0d+q1m2fQ2WFvFnsT5qc/vQBXl476io2PmQjStU4SBPWoAULxwTrwvPmTp7yep6umqkTbo7TsadVyCu6s9Pw1Mn5VZjSrXxfyHEervAVMGEnHrStIzUukQHRhA0BIviI4m8sFtdKysMWnanpAtv8aKnq1mE8IuexMd8Eoj3LhBa/QLeBDgNZiol74YuBePmW8T8Irwa+cxLF0ZgyKleT2kQ9LLmEqkDrWz7q9b/DjrkPr77mnNAGKdrYqixDqv47Ny7z94uOSgrHv8k5lX7v2HeuVc4py4DRARGUXbCXuJjlZYOKimOnzXyfscufSUi7+2T1xh0oBcB9NeWs9ZyuyksQSMHj2amTNn4urqyujRo2nbti337t1DTy929Xh5eTFhwoQU23eTOkUoVyKP+ntYeCQQc2flYGehDn/5OjjW3dAH9x+/4tFTf5p0WaYO+3DC6+fuz+1jY3B2tERXVwdfP83Gnd+rt+q7N2srE/T0dChUwF4jjlt+e06dv68R9jb4PfXbL8bUxIBtK3qgr58+Xc9h50/w+u4N9fco/5fJyic64BVKVCREf5xgG/nfI3QtrUFPDyIj1eE6NvYYFCnDmxkjNDMxMMSs3Y+8mT6csEunYvJ4fA+9PAUwafId4dfOY1CkNLp2TtiuOaSRNPuQqUTcuoL/T72SVX5tSB1qp0mlfJRz/3jOhEXEzFnx9Q/F4ZOGjF/AO+wsvzzkFfo+gk1/32FC1wrxxnnsG8Thi0/4Y1LjOLdHREbR+qc9PPIJ5NCclhq9SkcuPeH+8zdYNVyokabl2N1ULurE3/NafbGMKU2ugyKjk8YSMGTIEBo2bAjAhAkTKFy4MPfu3cPNzS1W3JEjRzJo0CD196CgIJydnZO9bzNTI40nOxRFwd7WnIPH71DCIybf8PBIjp25x9RRTeLMwy2fHdcOjdQIGztjD2+Dw9STFw0M9ChVxJmDJ27TvH4xdbxDJ+7QpE4RAAwM9ChTLDf/3vfTyOvuAz9y//8pEYi5k6r33SIMDfTYueoHjIzinlORFpT3oUT5hn454heE375Gtsp1Ym4vlZgLrJ5jrpiGwyc/8gDG1RsRHRRA2MVTGuEqXT1U+vooSrRGONHRoIoZ8Q7Zvpp3h3ZqbLaes4G3v80h7MIJrY8jOaQOtWNmbKDxhJuiKNhbmXDowmNKFLAFYuYXHb/6H14/VP5ifpuP/EtYRBTf1SkUb5zf9v2DbXZjGnrmjbXtQ0Pp3n9vODy3JTksNB9lH/5dWbo1KqIRVqzzGn7pU5VGFWI/PZYW5DqY9qRnKWmksQQULVpU/WcHh5hubz8/vzgbS6m9lLtKpaJ/t2p4LfgLVxcbXF1s8Jr/F8bZ9GnXrLQ6Xqf+a3C0z47XyCYYGenj4aa5dk32/6/18Wn4wO+r07H/WkoXzYVnKReWrTvFk2f+9OxQSR1nSM+atOm1isrl8lG9QgH2H73J7kP/cGRLPyDmTqpuu0WEvgtn7byOBL19T9Db9wDY5DBFVzf9p8GpTM3RtbZTTxDWc8wNQPSb1+rJwBZ9fyLK/yXB6xYBEHpgK8YNWmLWdRCh+zaj55ALk286E7pv02eZq8hWoxHvju6FaM2nXpR3IYT/cxGzjn15Gx5G1EsfDAqXJFvV+gStnvv/MvjHOSE56pUvUX4+KVoP2pA6TD6VSkX/liXw+v0c+XNmxzWnJV6/n8XYUI92tT9eUzpN+RMna1N+/qwBtWrvPzStlD9WI+eD6GiF3/68Qcd67ujpaZ5vkZHRtBy7h8v/vmDXtOZERSn4vo6ZJ2VlboSBvq76SbrPOduZ4+JoESs8Pch1MPVJYylppLEE6Ot/vCP4MJYdHR0dX/RUN6xXLd69j6D36M0EBIZSrngeDqzrrXHn9eRZADo6SfvH2rpJKV4HhDBpzn58/ILwKOjA3jU/kjvnx7ul5vWLsdirNVMXHKT/uK0UzGfLH8u6UalszB3nxWtPOXv5EQCulSZq5P/Aezx5nGM/qpvWjMpUxqLPx8dRsw+eAkDwpuUEb14BgK61HXzSexH92o+Aif0w6zIQ61/WEeX/ktC9GwnZsVYjb4OiZdG1ceDdYc0nuD54M3sMpt/1xqL/hJgFFV/58nbDkngXVMyopA61M7RdGd6FRdLnl78JCH5PuUL27J/VQqMH6umLt7F+cP59GsDJa8/YP6tFvHkfuvCYJy/e0iWOyd//vXzL7lMxQ0Ulu2rW++G5LalWIvm94GlNroMiI1EpiqJ8OdrX6dGjR7i4uHD58mWKFy8OwJs3b7C0tOTIkSNUq1bti3kEBQVhYWHBm1vTMTfLHCu3ZkQv+q39ciQhUpHtgEpfjiQSpMrrkt5FyLSC3r4je6FhBAYGpuqK2B9+s7Zc64uxWfJHSULfhtGy6PxUL29GIT1LQgghRBaj0nIYLqG1vb5GGX9gVQghhBAiHWXpnqU8efLw+Shk9uzZY4UJIYQQXxOZ4J00WbqxJIQQQmRFH1bi1iZ9VvLVHe2Hl+Mm5uPhEf+rBIQQQoivlVYv0dWyVyqj8PPzQye+d1d+5qvrWdLX16dgwYKJips3b+wF3YQQQgiRNSR2ovpX11hycnLi9u3b6V0MIYQQIsOSOUsxEjtH+atrLAkhhBAiYVmhsbR69eoEtwcGBiY6L2ksCSGEEOKrM3DgwAS3J+XJd2ksCSGEEFlMVngazt8/9jskP/Xy5Uvs7OwSlZc0loQQQogsRgcVOmgxDKdF2oxCepbSg4MbmMd+k7dIHLstU9K7CCKrywR3yuIrFhSS3iX4Ku3cuZMZM2Zw69YtAAoVKsTgwYNp3rw5kPin4eTqIIQQQmQxWWGdpaVLl9K6dWs8PDyYO3cuc+bMoUiRIrRp04bFixeTLVs2OnXqlKi8pGdJCCGEyGJiXqSb/P6SzPAi3ZkzZzJ37lx++OEHdViHDh0oXrw4M2bM4Mcff2TlypWJykt6loQQQgjx1Xn69Ck1a9aMFV6zZk2ePn2apLyksSSEEEJkMVlhGM7FxYVdu3bFCt+9e3eS3+Ahw3BCCCFEFpMVFqUcO3YsnTt35uzZs1SoUAGVSsWpU6fYtm0bq1atSlJe0lgSQgghspissM5Su3btcHZ2ZsaMGSxYsABFUShUqBCHDh2iatWqScpLGktCCCGE+CpVrlyZypUra52PNJaEEEKILCYrDMOlJGksCSGEEFlMVljBW1dXN9GrdEdHRye4XRpLQgghhPjqbN++Xf3nXbt28ddffzF79mz09fWTnJc0loQQQogsRgcth+EyQc9SkyZNgJhXnmzYsAEnJyd27NjB2rVrk5xXxp/OngqqVavGgAEDAMiTJw9z5sxJ1/J8TlEUxo9fjZNTK4yN61O9+iBu3Hj0xXRbtx6ncOEuGBnVo3DhLmzffjJWnEWLdpI373dky1aP0qV7cuLEtVhxbt16TNOmY8ievQnm5o3w9OzDkycvAPD3D6Jv3/m4uXXCxKQBuXO3pV+/BQQGBmt93ClFURTGT1iDU87WGJs0pHqNwYmsvxMU9uiGUbYGFPboFqv+vKZuoGy53phbNMHOviXNm//EnTuaC5t16TIdHd3aGh/PCn3jLWeDBqPQ0a3Njh2nkn28qUHqUDupdQ4fP36NJk1G4+TUCh2dmuzYEfsc/9QPP/yCjk5N5szZGis8f/72GBvXx9b2G5o1G8vt20+SfJypSa6DqevD03DafDKDrVu30rZtW5YvX86ZM2e4dOkS/fv3T3I+meNoU9i2bduYNGlSehcjXtOnb2T27D+YP78v584twt7ekjp1hvH2bWi8aby9b9CmzSTat6/NlSvLaN++Nq1bT+Ts2VvqOJs2HWHgwEWMGtWOS5eWUqlSERo0GKm+AADcv/+cypX7U7CgM0eOzOLKlWWMGdMeIyMDAJ4/f42Pz2tmzPiBa9dWsGrVMA4cOEf37jNTr0KSaPqMTcyevZX58/pw7uwC7O2sqFN3+Bfq7yZt2k6mfftaXLm8hPbta9G6zWSN+jt+7Bq9fmyC9+l5/HVgKpGRUdStN4KQkHcaedWrW4bnzzapP3v3xP2S4Dlzt5FR50hKHWontc7hkJB3FC2aj/nz4248fmrHjpOcO3cbR8ccsbaVKlWAlSuHcfPmKvbvn4qiKNStO5yoqKjkHXAqkOug0NaWLVvo2LEjq1atol27dlhZWXHo0CF27drFxIkTk5SXSkns7KevVJ48eRgwYIC6pympgoKCsLCw4M2bXZibm2hdHkVRcHJqRf/+3zB8eFsAwsLCsbf/lqlTe/DDD43jTNemzSSCgkLYt2+qOqx+/RFYWpqyfv0YAMqX702JEq4sXjxAHcfdvQtNm1bEy6s7AG3bTkJfX481a0YmusxbthyjQwcvgoP3oqenm9RDjqEkPLku0dkoCk4529C/f3OGD2sD/L/+HFox1as7P/zQKM50bdpMJigolH37flaH1a8/8v/1NzrONC9fvsHOviVHj8yiSpWiQEyvyJs3IWzfPiHBcl69ep/GTcZy7uwCHJ1as23reJo1q5icQ05xWbYOU+hOOTXP4U/p6NRk27YJNGtWKda2Z89eUr58H/bvn0ajRqPo378FAwa0iLfM167dp3jx77l7dy358jkm9ZBTXFa8DgYFhZA9exMCAwMxNzdPcvrE7yfmN+vi40mYmhslO5/goPeUyj021curDRMTE9asWUOLFpr/9h88eEDFihXx8fFJdF5Zsmfp02G4z61atQoLCwsOHjyYtoX6v4cPffD19adOndLqMENDA6pWLYa3941403l736R27dIaYXXqlOb06Zg04eERXLz4r0a+ALVrl1LnGx0dzd69Z3F1zUm9esOxs2tB+fK9v9jVHxgYjLm5cfIbSino4UPfmPqr/Vn9VSmKt/fNeNN5n7lJ7TqlNMLq1C3N6QTSBAaGAGBlZaYRfvTYVezsW1LQrTM9vv8FP78Aje2hoe9p993PzJ/XB3t7q0QfW1qROtROap3DiRUdHU3HjlMZMqQVhQvn+WL8kJB3rFp1ABcXB5ydbZK0r9Qi18HUp1LpaP3J6NatWxeroQSQN29eDhw4kKS8Mv7RpqGZM2cyZMgQDhw4QO3atdOlDL6+MT8KdnaWGuG2tpbqbXGn84+Vxs7uY5pXrwKJioqOJ44/AH5+bwgOfse0aRupW7cMBw5Mo1mzSrRoMZ5jx67Gud/XrwOZPPl3vv8+7t6GtPbhWOzssmuE235ynHGnC8DO9rO6SaDOFUVh8OAlVKrkgYeHizq8Xr2y/L52JIcPTWfmjB+4cOEONWsNIywsXB1n4KAleHq607RphaQeXpqQOtROap3DiTVt2kb09HTp1++bBOMtWrQTM7OGmJk14sCB8/z113QMDJL+lFBqkOugSAnNmjXj+vXrtG/fHnd3dzw8POjUqRPXr1+naNGiScpLGkv/N3LkSH755ReOHj1K+fLl440XFhZGUFCQxkcb69Yd+v8FK+YTEREJgOqziRiKosQK+1zcaT6Pw2dxPqb7sM5E06YVGDjwW4oXz8+IEW1p1Kg8S5fujrW/oKAQGjUajbt7bn76qeMXjzU1rFt3GDPzxuqPdvWn+T2u+vugT9/5XLv+kPXrRmmEt25djYYNy+Hh4ULjxp7s2/sz//77H3v3ngVg167THDlymTmzeyXhKFOX1KF20vocTsjFi/8yb942Vq0a9sV9ffddTS5dWsrRo7NxdXWideuJvH8fnmCa1CLXwbSnQker/1SZoPlw8eJFPD09efHiBXXq1OH+/fsYGxtTsWJFTp8+naS8ZOkAYNasWYSEhHDhwoUvvonYy8uLCRMSnkuRFE2aVKBcuULq72FhEUDMHZKDw8eJmS9fvol1p/8pe3urWHf9fn5v1HdQ1tYW6OrqxLor8/ML0Iijp6dLoUK5NeK4ueXi1Kl/NMLevg2lfv0RmJpmY9u2iejrp88/pSZNPClXzk39/WP9BWjW3yd1ERd7e0t8X3xWNy/jTtO33wJ27z7DsaOzyJkz4WELB4cc5M5ty917zwD4+8gV7t/3wdKqmUa8b1tOpHJlD478PSvB/FKD1KF20uocTowTJ67j5/eG3LnbqsOioqIZMmQJc+du5eHD9epwCwtTLCxMcXXNSfnyhbCyasb27Sdp27ZGoveXUuQ6mPa0HUrLDMNwo0ePpnPnzixYsICHDx/y66+/snjxYtzd3Rk5ciTHjh1LdF4Z/2jTQOXKlYmKimLz5s1fjDty5EgCAwPVn6dPn34xTULMzIzJn99J/XF3z429vRUHD15UxwkPj+DYsat4ehaONx9PT3cOHbqoEXbw4AUqVIhJY2CgT6lSBTTyBTh06KI6XwMDfcqUKci//2oe0927/5E7t536e1BQCHXrDsPAQJ+dOyepnxBJD/HW36HP6u/4NTw93ePNx7O8O4c+q5uDf12kwidpFEWhT9/5bN9+ksOHpuPi4vDF8r1+HcTTpy9xsI+54I8Y3oarV5Zy+dIS9Qfgl196svLXIUk69pQidaidtDqHE6NDh1pcvbqcy5eXqT+OjjkYMqQV+/dPSzCtoigaQ51pSa6DaS/mdSfaLB2QAR9D/Yy3tzc9evQA0FjJu2HDhpw/fz5JeWWeZnAqKlu2LH379qVu3bro6uoydOjQeOMaGhpiaGiYamVRqVT07/8NXl7rcXXNiaurE15e6zE2NqJdu5rqeJ06TcXR0Vr99Ea/ft9QteoApk3bQNOmFdm58xSHDl3ixIm56jQDB35Lx45TKV26AJ6e7ixbtpcnT/zo2fPjkyVDhrSmTZtJVK5clOrVi7N//3l27/bmyJFfgJg7qbp1hxMa+p61a0cRFBRKUFDMo7w2Nhbo6qbv5MaY+muOl9cGXPM7/b/+NmBsbEi7dh/vmDt1moajkzVeP3cDoF+/5lStNohp0zfStEkFdu46zaHDlzhxfLY6Te8+89mw4W92bJ+AmZmx+g7WwsKEbNkMCQ5+x/gJa2jxTWUcHKx49OgFo8esxNragubNY57Ssre3inNCci5n20Q1HNKC1KF2UvMcDg5+x73/97BBzGT8K1fuYWVlRq5cduTIYUGOHBYa5dHX18Pe3oqCBZ0BePDgOZs2HaVOndLY2Fjw7Nkrpk/fSLZsBjRoUC41qybR5DooUoKiKJiYxH5K3c/PDxubpD3MII2l//P09OTPP/+kXr166OnpMXDgwHQry7BhbXj3LpzevecSEPCWcuUKceDANMzMjNVxnjzxQ0fnY8u+QoXCbNgwhrFjVzFu3G/ky+fIxo1jNbq2W7euzuvXQUyatBYfH388PPKwd6+Xxt1S8+aVWLx4AFOnbqB//wUULOjMH3+Mp1KlIkDMnIgPa5a4unbQKPeDB+vIk8c+VeokKYYNbR1Tf33m/7/+3Diwf6pm/T2No/7Wj2bsuN8YN241+fI5sHHDaI36W7IkZr5C9RqavRcrfx1C58510dXV4Z/rD1m79hBv3gTj4GBF9WrF2LhhtMa+MwOpQ+2k1jl84cIdatQYrP4+ePBiADp1qsOqVcMTVTYjIwNOnrzO3LlbCQgIxs7OkipVinLq1HxsbRM/5Jfa5DqYulRazjvKDHOW8uXLx82bN8mfPz8Q03g6efIkAwYMoFmzZknKK0uus1StWjWKFy/OnDlzYq2zdPz4cRo0aMDPP/9Mv379vphXSq+zlGWl0DpLQiRbJpiDIb5eab3O0o1nv2Bmni3Z+bwNekdhp0EZep2lqVOn8vz5c+bNm8eDBw8oUKAAAJ06dWL+/PkYGyf+BixL9iwdPXpU/edHjx5pbKtSpQrBwZlnyXohhBBCxDZixAj1n3PlysWNGzdwcXHBwCDp88uyZGNJCCGEyMqywjDcp/T09ChYsGDy06dgWYQQQgiRCWj7MtzM8CLdvHnzktBMo4cPHyY6L2ksCSGEEOKr8/lrzSIiIrh+/Tp79+5l0KBBScpLGktCCCFEFpMVFqWM7yGtJUuWJHmdpYx/tEIIIYRIUdq97CTmv8yqTp06bNmyJUlpMu/RCiGEEEIk0ZYtW7C0TNqaYjIMJ4QQQmQxWWEYrmTJkhoTvBVFwdfXl1evXrF48eIk5SWNJSGEECKLyQpPw32+SreOjg62trZUq1ZNvUBlYkljSQghhMhiYtZZSv477DLDOkvjxo1Lsbwy/tEKIYQQQqQj6VkSGUMm6NIVQoivhUrLYbjMMGcpJUljSQghhMhistrrTrSVtY5WCCGEECKJpLEkhBBCZDEfnobT5pPRNWnShB07dhAVFaV1Xhn/aIUQQgiRoj6ss6TNJzNo27YtOXPmZNiwYdy5cyfZ+WSOoxVCCCGESIJdu3bh5+fHiBEjmDVrFkWKFKFSpUqsXLmS0NDQJOUljSUhhBAii8kq74YzMzOjdu3a6Ojo8OzZM9q0acPSpUtxcHCgR48eeHt7JyqfzHG0QgghhEgxWWUY7lM2Njb06dOHs2fPcuHCBczMzKhcuXKi0srSAUIIIYTIEqKioti/fz/r1q1jz5491KlTJ1HpMl/TUAghhBBayQpPw32ub9++ODo60rdvX9zd3bl58yb79u1LVFrpWRJCCCGymKywKOXly5fZunUrW7duRV9fn4CAADZs2ECNGjWSnJc0loQQQogsRkel0qp3SEelSsHSpI7SpUtTrFgx+vbty3fffYeFhUWy88r4TcMkqlatGgMGDEjvYiTbokU7yZv3O7Jlq0fp0j05ceJagvGPHbtK6dI9yZatHvnytWfJkt2x4mzdepzChbtgZFSPwoW7sH37ySTvV1EUxo9fjZNTK4yN61O9+iBu3Hik1bGmluSWNa3qKSwsnL5952Nj0xxT04Y0bTqG//57qc0hpzipQ+3Ieaw9qUOhrYsXL3Lp0iV69eql0VB6//49q1evTlJeX11jadu2bUyaNCm9i5EsmzYdYeDARYwa1Y5Ll5ZSqVIRGjQYyZMnL+KM//ChDw0bjqJSpSJcurSUkSPb0r//ArZuPa6O4+19gzZtJtG+fW2uXFlG+/a1ad16ImfP3krSfqdP38js2X8wf35fzp1bhL29JXXqDOPt26StVZEWklPWtKynAQMWsWPHSTZsGMOJE3MIDn5H48ajU2SV2ZQidZh8ch5rT+ow9X0YhtPmkxyLFi3CxcUFIyMjSpUqxYkTJ1L4yD5yd3dnw4YNeHl5MWHCBPVn7NixdOnSRf09MVSKoiipVtIsICgoCAsLC9682YW5uYlWeZUv35sSJVxZvHiAOszdvQtNm1bEy6t7rPjDhy9j925vbt5cpQ7r2XM2167d5/TpBQC0aTOJoKAQ9u2bqo5Tv/4ILC1NWb9+TKL2qygKTk6t6N//G4YPbwvE3Nnb23/L1Kk9+OGHxlodd0pKblnTqp4CA4OxtW3BmjUjaN26OgDPn78iV6627N37M3XrlkmNakkSqUPtyHmsvaxYh0FBIWTP3oTAwEDMzc2Tnc+X9xPzmxXwZqdWv1lBQSFYZm+apPJu2rSJDh06sGjRIipWrMjSpUtZsWIFN2/eJFeuXMkuS3xatWrF/v37cXFxQVdXVx0eGRnJjRs3KFasGIqicPny5S/m9dX1LH06DJcnTx5+/vlnunbtipmZGbly5WLZsmUa8U+fPk3x4sUxMjKidOnS7NixA5VKxZUrV9K03OHhEVy8+C916pTWCK9duxTe3jfiTHPmzE1q1y6lEVa3bhkuXPiXiIhIALy9b1K7tmaedeqU5vTpG4ne78OHPvj6+mvEMTQ0oGrVYvGWLb0kt6xpVU8XL94lIiJSI46jozUeHnnU+0pvUofJJ+ex9qQOv16//PIL3bp1o3v37hQqVIg5c+bg7OzM4sWLU2V/hw4d4sSJE1y9epVLly6pP4cPH0ZRFC5dupSohhJ8hY2lz82aNYvSpUtz+fJlevXqxY8//sjt27cBePv2LY0bN6ZIkSJcunSJSZMmMXz48ATzCwsLIygoSOOTEl69CiQqKho7O0uNcDs7S3x9/eNM4+vrH2f8yMgoXr0KTDCOr29Aovf7Ie7ncWxtP+aTUSS3rGlVT76+/hgY6GNpaRZvPulN6jD55DzWntRh2kipRSk//z0MCwuLc3/h4eFcvHgx1rpGderU4fTp06lyjIGBgeTMmTNWuKIoqJI4Qf2rbyw1aNCAXr16kT9/foYPH461tTVHjx4FYN26dahUKpYvX467uzv169dn6NChCebn5eWFhYWF+uPs7Jyi5f38709RSPAv9fNtH0ZVPw2PK87nWSZmv3Hnk75PRKxbdwgzs4bqz4e7yOSUNT3rKT3rUuow5cl5rD2pw9SlUrT/ADg7O2v8Jnp5ecW5v1evXhEVFYWdnZ1GuJ2dHb6+vqlyjKtWrcLMzCxWuIWFBatWrYojRfy++qUDihYtqv6zSqXC3t4ePz8/AO7cuUPRokUxMjJSxylbtmyC+Y0cOZJBgwapvwcFBaVIg8na2gJdXZ1Ydyd+fgGx7mI+sLe3inWn5ef3Bj09XXLkME8wzoc8E7Nfe/uY//v6+uPgkEMd5+XLN9jZZU/ikaasJk0qUK5cIfX3sLAIIOllTat6sre3Ijw8goCAtxo9I35+b/D0LJzYw05RUocpR85j7UkdZi5Pnz7VmLNkaGiYYPy0bGh27NgxzvC3b9/y008/xbs9Ll99z5K+vr7Gd5VKRXR0NBD3X9KX5rsbGhpibm6u8UkJBgb6lCpVgIMHL2qEHzp0Md4fgPLl3Tl0SDP+X39doHTpAujrx7SDPT1jxzl48AIVKhRO9H5dXBywt7fSiBMeHsGxY1fT/cfJzMyY/Pmd1B9399zJKmta1VOpUq7o6+tpxPHxec0//zxS7yutSR2mHDmPtSd1mEaUaO0/EOv3ML7GkrW1Nbq6urF6kfz8/GL1NqWUPXv2ULBgQQwNDdHR0VF/bG1tefz4sfp7Ynz1PUsJcXNzY926dYSFhan/gi9cuJBu5Rk48Fs6dpxK6dIF8PR0Z9myvTx54kfPnjFPWIwcuYLnz1+xevUIAHr2bMzChTsZNGgRPXo0xNv7JitX/sn69aPVefbr9w1Vqw5g2rQNNG1akZ07T3Ho0CVOnJib6P2qVCr69/8GL6/1uLrmxNXVCS+v9RgbG9GuXc00rKEvS2xZO3WaiqOjtfrJmrSqJwsLU7p2rc+QIUvIkcMcKyszhg5dSpEiLtSqVTINayp+UofakfNYe1KHaeCTBk+y0yeBgYEBpUqV4uDBgzRv3lwdfvDgQZo2bZr8ciRg8ODB1K5dm5o1a2o8DRcYGEinTp3YsWNHovPK0o2ldu3aMXr0aL7//ntGjBjBkydPmDlzJpDw2Hhqad26Oq9fBzFp0lp8fPzx8MjD3r1e5M4d0+r29X3Nkyd+6vguLg7s3fszgwYtYtGiXTg65mDu3D60aFFFHadChcJs2DCGsWNXMW7cb+TL58jGjWM1hl2+tF+AYcPa8O5dOL17zyUg4C3lyhXiwIFpmJkZp0HNJE1iyvrkiR86Oh//jtOynmbP7oWeni6tW0/k3btwatYswapVkzVO5vQmdZh8ch5rT+rw6zRo0CA6dOhA6dKl8fT0ZNmyZTx58oSePXumyv4ePnzI2LFjY/VcfZiK06RJk0Tn9dWts1StWjWKFy/OnDlzyJMnDwMGDNBY0bt48eI0a9aM8ePHAzFLB3x4Qq5IkSIMHjyYdu3acfv2bQoWLPjF/aXkOktCCCGyprReZynw9Vat11myyNEiyeVdtGgR06dPx8fHBw8PD2bPnk2VKlW+nDAZ8ubNy6VLl8iePbtG+OvXrylTpgwPHjxIdF5fXWNJW+vWraNLly4EBgaSLVu2L8aXxpIQQghtpXlj6dUfmJsnvzcsKCgUC+tvU728GUWWHoYDWLNmDXnz5sXJyYmrV68yfPhwWrVqlaiGkhBCCJEpRUfHfLRJn8El9CqTmHf8jU90Xlm+seTr68u4cePw9fXFwcGBli1bMmXKlPQulhBCCCG0sHPnTo3vISEhPH78GH19ffLnzy+NpaQYNmwYw4YNS+9iCCGEEGknjZ+GSw+XLl2KFebv70/79u1p2bJlkvL66tdZEkIIIcRnUmidpczGysoKLy8vJk+enKR00lgSQgghRJahq6vL48ePiYyMTHSaLD8MJ4QQQmQ5WWAYLj4eHh5JaiiBNJaEEEKIrCcLPA1Xo0aNeF9hpigKR48e5c2bNzRv3pwjR44kmJc0loQQQgjx1SlevPgX4+jr61OiRIkvxpPGkhBCCJHVZIFhuF9++eWLcUxMTBIVTxpLQgghRFaTBRpLKUkaSykkSokkSknahDHxka48mCnSm0r+DWpLroHJJ3WX8vLmzRvvnKXPPXz4MMHt0lgSQgghspos0LPUtWtXZs2aRcWKFSlfvjwA3t7enDp1iiFDhiTpnXbSWBJCCCGyGEWJRlGitEqf0d24cYPRo0czZMgQjfAZM2Zw5coV1q1bl+i8pN9ZCCGEyGo+LB2gzSeD2717N02bNo0V3rx5c3bt2pWkvKSxJIQQQoivjrm5OX/99Ves8P379ydpCA5kGE4IIYTIgrR9v1vG71kaNWoUAwcO5NSpUxpzlv744w9mz56dpLyksSSEEEJkNVlggnefPn1wc3Njzpw5zJs3D0VRKFSoEPv376dmzZpJyksaS0IIIYT4KtWqVYtatWppnY80loQQQoisJgv0LH3w/v17Xr58SfRnk9Jz586d6DyksSSEEEJkNVmgsXT79m26du3KmTNnNMJVKhWKosRqPCVEGktCCCGE+Op069YNAwMD9u3bh4ODAyqVKtl5ydIBGczixbtxzdcRU+NGlC3Tm5MnricY//ixa5Qt0xtT40YUyN+JpUv2xBt308aj6OvWpUXz8RrhSxbvpkTxnlhlb45V9uZUqjiA/X+e14gzccJaPNy7YWHWBJscLahbZzhnz95O9nGmJkVRGD9hDU45W2Ns0pDqNQZz48ajL6bbuvUEhT26YZStAYU9urF9+0mN7V5TN1C2XG/MLZpgZ9+S5s1/4s6dpxpxXrwIoEuX6TjlbI2JaSPq1x/J3bv/acQJCwunb78F2Ni2wNSsMU2bjuW//15qfdwpSepQO4qiMH78apycWmFsXJ/q1Qclsv6OU7hwF4yM6lG4cJdY9Xf8+DWaNBmNk1MrdHRqsmPHyVh56OjUjPMzY8YmdZxly/ZQvfogLCwao6NTkzdvgrU+5pQm18JUlgXWWbp69SqLFy+mXr16FCtWjKJFi2p8kkIaSxnI5k1HGTxwCSNGtuX8xUVUquRBo4ZjePLEL874Dx/60rjRGCpV8uD8xUUMH9GGgQMWs23riVhxHz9+wfBhy6lU2SPWtpw5bfj5566cOTefM+fmU716Mb5pPl7j4u7q6sTceb25fHUpR4/PInduexrUG8nLl29S6vBTzPQZm5g9eyvz5/Xh3NkF2NtZUafucN6+DY03jbf3Tdq0nUz79rW4cnkJ7dvXonWbyZw9e0sd5/ixa/T6sQnep+fx14GpREZGUbfeCEJC3gExP5DNv/mJBw992bF9IpcuLiZXbjtq1xmujgMwYOBiduw4xYb1ozlxfDbBIe9p3GQMUVHJX003pUkdamf69I3Mnv0H8+f35dy5RdjbW1KnzrAv1N8N2rSZRPv2tblyZRnt29emdeuJGvUXEvKOokXzMX9+33jzef58i8bn11+HolKpaNGisjpOaGgYdeuWYeTIdilzwClMroVp4MMwnDafDK5gwYK8fJkyN1EqJbFvmRNxCgoKwsLCgtcB2zA3N9Eqrwqe/ShRIj8LF/VThxUp3J0mTSsw5eeuseKPHLGCPbvPcP3GCnVYrx/ncu3aQ06emqMOi4qKokb1oXTqVIeTJ/8h8E0wW7ePT7AsttYtmDqtB1271Ytze1BQCDksv+HAX1OpUbNE0g40Din1Il1FUXDK2Yb+/ZszfFgbIKYXwt6hFVO9uvPDD43iTNemzWSCgkLZt+9ndVj9+iOxtDRl/frRcaZ5+fINdvYtOXpkFlWqFOXff//DrVAXrl9bTuHCeYCYurezb8lUr+50796AwMAQbO2+Zc3q4bRuXQ2A589fkSv3d+zdM5m6dcukSD1oI8vWYQq9SFdRFJycWtG//zcMH94W+H/92X/L1Kk9+OGHxnGma9NmEkFBIezbN1UdVr/+iP/X35hY8XV0arJt2wSaNauUYHmaNx/L27fvOHRoZqxtR49eoUaNwfj77yR7dtOkHGacUuplsFnxWvghn8DAwCQvmJi0/cT8Zr25MxNzs2zJz+ftO7IXHJLq5dXG4cOHGT16NJMmTaJEiRLo6+trbLewsEh0XtKzlEGEh0dw6eJdatcupRFeq3YpvL1vxpnmzJlb1Posfp06pbl44V8iIj5etCZPWoeNtUW8J/unoqKi2LTxKCEhYZT3LBRvWVcs34eFhQlFi+X9Yp5p6eFDX3x9/alTu7Q6zNDQgKpVisZbjwDeZ25Su85ndVm3NKcTSBMYGAKAlZUZAGFhEQAYGRmo4+jq6mJgoM+pU/8AcPFizN9NnU/25ehojYdHngT3lZakDrXz8KFPTP3V+az+qhbD2/tGvOm8vW9S+5M6h5jz+fTp+NN8yYsX/uzde5auXesnO4+0JtfCNJIFepbq1KnD+fPnqVevHra2tlhaWmp8kkImeGcQr14FERUVja1ddo1wO7vsvPANiDPNC98A7D6Lb2uXncjIKF69CsTBIQenTt1g1coDXLi0KMH9X7/+kMoVB/D+fTimptn4Y+s43N01H6vcu+cM37XzIjQ0DAcHK/484IW1deJb5mnB19cfII56seTJ4xcJpAvAzlbz5LGztcQ3nrpXFIXBg5dQqZIHHh4uALi5OZM7tx2jRv3KkiUDMDEx4pfZW/H19cfHx1+9HwMDfSwtzT7bV/Z495XWpA6186EMdnaadWFra8mTJwnVn3+sNHZ28ddfYqxe/RdmZsZ8803lL0fOIORamEYURcun4TL+oNSRI0dSLC9pLCVRWFgYYWFh6u9BQUEpmv/ns/UVRSGhCfyx438Mf/s2lM4dp7Fk6YAvnsgFC+bkwqVFvHkTwvZtJ+naZSaHj8zQuEhUq16cC5cW8epVEL+u+JN2baZwynsetrbZk3SMKWndusP0/HGO+vue3ZOB+Oox4SchPt+cUN336Tufa9cfcuL4xyXz9fX1+GPLOLr3mEUO62/Q1dWhVs2S1K/35WEhRYm9/7QidaiddesO0bPnx2PYsydmGDJ59Ze08/9LVq3aT7t2NTV66jILuRamMm0naWeCCd5VqlRJsbyksZREXl5eTJgwIcXztbY2R1dXJ9adk59fILZ2cXcX2tnHvut86fcGPT1dcuQw58aNxzx69IJmTcept0dHx1xBjAzqc+PWr+TL5wiAgYE++fM7AVC6dAEuXLjD/Hk7WLykvzqtiYkR+fM7kT+/E+XLF6JQwS6sWrmf4SPaaF8BydSkiSflyrmpv38YxvH1DcDBIYc6/KXfm1h37Z+yt7fE98Vndf8y7jR9+y1g9+4zHDs6i5w5bTS2lSpVgMuXlhIYGEJ4eAQ2Ntkp79mXUqVc1fsJD48gIOCtRs+I38s3eFZwT8KRpxypQ+00aVKBcuU+DtN8rD9/zfp7+SZW78en7O2t1L16H/h9oc4TcuLENe7cecrGjWOTlT69yLVQpJRjx44luL1q1apERkZy6tQpqlatmmBcmbOURCNHjiQwMFD9efr06ZcTJYKBgT4lS7ly6NAljfDDhy7h6Rn3D0D58oU4/Fn8gwcvUqp0AfT19XBzc+by1aVcuLRY/WncuDzVqhfjwqXFODvbxJkvxNyVfbjoxx9H+WKc1GZmZqy+aOXP74S7e27s7a04eOiiOk54eATHjl+Ltx4BPMu7c+jgRY2wg39dpMInaRRFoU/f+WzffpLDh6bj4uIQb34WFibY2GTn7t3/uHDhX5o2qQDENAT09fU4ePDj35uPz2v++eeRxr7SktShduKtv4Of1d+xq3h6Fo43H09Pdw4d+qz+Dl6gQoX40yRk5co/KVWqAMWK5UtW+vQi18I0kgXmLNWoUYPq1atTo0aNWJ/q1asD4O/vT40aNb6Yl/QsJZGhoSGGhoapkveAAd/QudMMSpUqQHnPQqxYvo8nT/z4/oeGAIwetZJnz17x2+phAHz/QyMWLdzFkMFL6da9Pme8b7Fq5QF+XzcCiJkk6+GRR2MfFv9/4uXT8DGjV1KvXhlyOtvw9u07Nm86yrGj19i7L2Y4JiTkPV4/r6dRY08cHKx4/TqIJYv38N9/r2jxbcaaC6FSqejfvzleXhtwze+E6//au++4KI7+geMfRDoHCkhVRAEb1keMosaONYqaKGiMNUWjscZCbBgLWBIlGlse+0/FJzF2jSWxRbHX2DUaNIqoICAiIOzvD+KZkyJwR9H7vl+vfSW3OzM7+8Xbm53ZnfV0ITh4LebmJnTv/vIL0avXdJxd7Aie1g+AwYM70bjJcKbPCMOvQ302bT7Mnl9PaQwRDRw0l7Vrf2PjhkmoVObqXgBrawvMzNL/Tfz4435KlSqBq6s958/fZOiw+XT0q6++2dfa2oK+fVvz5chF2NqqsLGxYuSoRVSr5kaLFv8pqDBlS2KonfT4dSY4eA2enqX/id8azM1N6d795cs7e/UKwdnZjuDgjwEYPLgzjRsPZfr0tfj5NWDTpkPs2XOKgwdD1XmePEnk+vW/1Z9v3ozkzJnr2NiocHV1UK+Pi0vgxx8PMGtW/0zrGBkZTWRktLqs8+f/RKUyx9XVHhubwn+ySc6FBUAPZvCOiXn9/X729vY5SieNpSKkq38THkXHM3XKau7di8aralm2bJ1C2bLpJ8F796K5ffvlnBHlyjmyZesURoxYxIL5W3B2tmH2nAF0fj93X9r79x/Tu9dM7t2LxtranGrVy7Ft+xT10yWGhsW4cvkOq1ZO5uHDOGxtVXh7V2Dv/m/Uj3cXJaNG+pOYmMzAQXOJiYmnbt1K7PwlBJXKXJ0m4nYUxYq9vMehfn0v1q4Zy/gJy5kwYQXu7k6ErR2rMbyycOEWAJo2+1Jjf0uXfEnv3q0AuBcZzYgvF3H/fgxOTjZ89JEv48d9qJF+9rcDKF7cEP+AKSQmJtO8WS2WbRqJoaGhzmORVxJD7YwaFZAev4Gh/8SvMjt3TteMX0Qm8Vs7jvHjlzFhwnLc3Z0JCxuvEb8TJ67QrNkI9ecRIxYA0KtXS5YtG61eHxa2F0VR6Nataab1W7hwC19/vVL9uXHjYQAsXTqS3r1f/6RYfpNzodCFrKY0SElJ4fDhw+qht5xMfSDzLGlJl/Ms6TNdzbMkRJ7paJ4lfaareZb0UYHPs3R2ElYq07yXE/+MEjUmFul5lgDCw8O5desWycnJ6nWxsbEMHTqUpUuXYmBgQK9evV5bjvQsvWL58uX06dMHaUMKIYR4a6Up6Ys2+Yu4gQMHsnDhQiwtLTV6nV88mTp8+HAURZHGUl7cunXrtXfFCyGEEKJo+9///sfu3bsz3MD94MEDHBwciI6OziJnRtJYesXOnTsJDQ19fUIhhBDiTaVoOc/SG3CDd3R0NDVq1MiwPidznr1KGkuvCA8PL+wqCCGEEPlLDyalnDhxIubm5hnWW1paMnHixFyVJY0lIYQQQrx1JkxIn4T0+vXrXLx4EQMDAypXroyHh4d6W05JY0kIIYTQN3pwg/fjx4/p06cPmzdvpnjx9OZOSkoK7du3Z8WKFZQoUSLHZcmzskIIIYS+eTEMp81SxA0dOpTr169z6NAhnj17xrNnzwgPD+fGjRsMHjw4V2VJz5IQQgihb9IULe9ZKvo9S5s3b2bLli3Uq1dPva5u3bosXryY9957L1dlSc+SEEIIId46ycnJWFpaZlivUqlISkrKVVnSWBJCCCH0zYt7lrRZirjGjRszZswYHj16pF4XHR3NqFGjcj2fogzDCSGEEPpGD6YO+O6772jXrh2urq5UqFABAwMDrly5gouLC9u3b89VWdJY0hFDisn7zbTx7Elh10DoO9OM3fUid+QcmHcSO91zd3fnwoULbN68mYsXL6IoCpUrV6Zjx465fum2NJaEEEIIfaMHUwcAGBoa0qlTJzp16qRVOdJYEkIIIfSNHgzDrVixItvtOXmB7gvSWBJCCCHEW2fYsGEan1NSUnj69CnFixfH3NxcGktCCCGEyIaevEj3Vbdu3eKzzz5jxIgRuSpL7igTQggh9IyiKFovbyI3NzdCQkIYOnRorvJJY0kIIYQQesPAwIDbt2/nKo8MwwkhhBD6Rg9u8N60aZPGZ0VRuHfvHvPmzaNhw4a5KksaS0IIIYS+0YPGUufOnTU+GxgYYG9vT/PmzZk1a1auypLGkhBCCKFv9GCepdTUVJ2VJfcsCSGEEEJkQ3qWhBBCCH2jB8NwuiQ9S0WQoigETVqJS2l/zC3a0bTZCC5cuPXafOvXH8Sraj9MzdriVbUfGzb8rrF9wYIt1Kj5KdYl/LAu4Uf9BoPZseNYhnIuXfoLP7/xlCjph5V1B3zqf0FERJR6e1JSMl8Mnkcp+/exVLXHz288d+480Pq4dUVRFIKmhuHi3hdzW3+ath7HhYsR2ea5cDGCD7pPp1zlTylm0Yk587Zkmz545nqKWXRi6MglGuuDpoZRudYgLEsFYOPSA992Ezl6/GqG/OFHL9O8zXgsSwVQ0vlDmrYeR2JiUu4PNp9IDLWTX9/h4JC1vFN3IFbWHXBw7EKnThO5ckXzqZ6gSSupXKUvlqr22Nh2wrflKI4evZRlPdu2/Ypihr5s3Hgoz8ebH+Q8mM/SlJcNpjwtRX8YTpeksZSJJk2a5HoOBl2aMXMds2evZ+53gzh2dB6ODja0bDWa+PinWeYJD79IQLcp9OjRgjOnF9KjRwv8A6ZonCRLl7YjeFo/jh/7nuPHvqdp05p07DRR4wR048Zd3m00jIqVXNn72zecOb2IcWN7YGpqpE4zdNgCNm48xNo1Yzl4YDZPEp7RvsM4nY4Pa2PGtxuYPXczc7/9hGMHZuDoUJKW7YOIj0/MMs/TxCTKuTkQ/PVHODqUzLb84yev8cOyXVSv6pZhWwUPZ+Z+8wnnjs3h4O5plC1rT6sOk3jwIFadJvzoZdp0nIxv85oc3T+DYwdmMvCzthQrVnS+jhJD7eTXd/jA/nN8PqAD4Ye/Y9fOEJ4/T6VV6zEkJLz8u1TwLM3c7wZx7uxiDh6YTdmyDrRqPYYHDx5n2Oec0J8xMNDpoeuMnAdFUWKgvKkzS+WjJk2aULNmTebMmfPatHFxcVhbW/M4ZiNWVhZa71tRFFxKBzBkSCdGjwoA0q9gHJ26EhL8MZ999l6m+QICphAX95Tt26ep17VpE0jJkpasWTM2y/3Z2nVmxvRP6NevDQDduk3FyMiQlSvHZJo+NjYBe4cPWLliNP7+TQC4e/chrmU/ZNvWKbRqVScvhw3PnuQt3ysURcHFvR9DBr7H6BHpT0IkJaXgWK43IZN78lm/Vq8to1zlTxkysD1DB7XPsO3Jk0RqNxjB97M/Y+qMH6lRrRxzZvbLsqy4uKeUcPqQ3Vsn0bxpdQB8moymRbMaTJ7QPY9Hmb/0NoamljoppiC/ww8ePMbBsQv79n5Do0bVM00TF5dAiZId2b1rOs2b/0e9/uzZG7TvMJ5jR+fh7OLPz+uD6NixQV4PW6f08Tz44u8UGxuLlZVVrvPnfD/pv1kxGz/FysI47+UkJFOy4+J8r29RUTQuw4TazZuRREZG09LXW73OxMSYxo2qEx5+Mct84Ucu4tuytsa6lq28OZxFntTUVMLC9pKQ8AwfnyoApKWlsW37UTwrlKZ16zE4OHahns8XGt3zJ09eJSXlOS3/tS9nZzuqVnXLcl8F6eat+0Tej6Fl85rqdSYmRjRu6EX4kctalz9o2GLatvKmRbMar02bnJzC4qW7sLY2p0Y1NwCioh5z9PhV7EtZ06DZGBzdetOk1Vh+P1z4sXtBYqidgvoOQ/qPNoCNjSrT7cnJKSz+YTvW1hbUqOGuXv/06TO6fziNud8NwtHRJkfHVZDkPFgAtBqC0/J+pzfQG91YGj16NBUqVMDc3Jzy5cszfvx4UlJS1NuDgoKoWbMmq1atws3NDWtrawICAoiPj1enSUhIoGfPnlhaWuLk5MQ333yT7T6TkpKIi4vTWHQpMjL9XTYODiU01ts7lFRvyzxfDA72mkMfDvYliYyM0Vh3/vxNVFbtMTVry4DPQ/l5/USqVCkLpP8IPXmSyPTp62jVug47fwmmY8cGvP/BJPbvP6vej7GxESVLql7ZV4kM+yoMkfcfA5nEz76Eeltehf14kFNn/iT46x7Zptu64zgq+26Y2fgzZ94Wdm0Jws4u/crrz1v3AZg0LYyPe/uyY+MEatVwp0W7iVy7fler+umKxFA7+f0dfkFRFEaMWEjDhlWpWrWcxratW4+gsmqPmXk75sxZz66d07Gzs1ZvHzZ8IT4+VfDzq5+bQyswch4URc0b3VhSqVQsX76cixcvEhoayg8//MDs2bM10ty4cYONGzeydetWtm7dyv79+wkJCVFvHzlyJHv37mXDhg3s2rWLffv2cfLkySz3GRwcjLW1tXopU6aMVsewevWvqKzaq5eUlOdA+uRZ/6YoSoZ1r3p1c3oezXUVK5bm9KmFhB/+jv7929O7z0wuXvwLSL+iAvDr4MOwoe9Ts6YHY0YH8F67uixatDXbfStKxv0XhNVh+1HZd1Mv6vhlqN/r45ed23ceMnTkElYtGYqpafZd100bVeN0+Lcc+i2YVr618P9oFlFRjwFI++emyE/7tqJPz+bUqlme2TP6UtHThaUrf81z/bQhMdROQX+HXxj0xVzOnb/JmtVfZdjWtGkNTp9ayKHf59CqVR38A6YQFZX+I75582H27j3NnNmf5/AI85+cBwuB9Czlyhs9dcC4cePU/+/m5saIESNYt24do0aNUq9PS0tj+fLlqFTpVwAfffQRv/76K1OnTuXJkycsWbKElStX4uvrC8CKFSsoXbp0lvsMDAxk+PDh6s9xcXFaNZg6dPChbt1K6s9JSek9Y5GRMTg52arXP4h6jEM2N806OpYk8r7mFU3Ug4x5jI2N8PBwAcDbuyInTlwh9LsNLFo4FDs7a4oXN6TyP1dYL1Sq7MqhQ3+o95OcnEJMTLzGVVXUg8f41K+Sm0PXiQ7t3qFunQrqz+r43X+Mk9PL4YUHD2JxsLfOkD+nTp6+QdSDWLwbfqlel5qaxoHfL/L9ou08i/kfhoaGAFhYmOLh7oSHuxP13qlIheqfs2TFrwSOfB8nx/S/R5VKmv/GKlcqze3bD/NcP21IDLVT0N9hgC8Gz2PLliPs3/cNpUuXyrDdwsIMDw8XPDxcqFevChUq9mLJ0l8IHNON3/ae4caNe5S06aiR54MuX/Puu1XZ+1v2vev5Qc6DhUDRclJKPbvd+Y1uLP3000/MmTOH69ev8+TJE54/f57hRjM3Nzd1QwnAycmJqKj0xz9v3LhBcnIyPj4+6u02NjZUrFgxy32amJhgYmKis2NQqcxRqczVnxVFwdHRht17TlKrlgeQft/B/gPnCAn+OMtyfOpVYc/ukwwb+r563e5dJ6nvk/0XV1EUkpOSgfQTSJ06Fbn6yqPI167+TVlXBwBq166AkVFxdu8+RdeujQG4d+8Rf/xxi+khWdcvv6hUZqhUZurPiqLg6FCS3b+dpVbN8sA/8fv9AiGTe+Z5P82bVOfcsTka6/r2n0elCi6MGt5J/SOfGUVRSEpOP/m7lbXH2cmGK9c0h4uuXrtL65b/ySx7vpMYaqcgv8OKovDF4Hls3HiIvb/Nolw5pxzVUVFeNkDGjA7g439uZH6heo1P+fbb/rR/r16OytM1OQ+Kou6NbSwdOXKEgIAAJk2aRKtWrbC2tiYsLCzDPUdGRkYanw0MDNTdrEXxQUADAwOGDOlEcPBaPD1c8PR0ITh4LebmJnTv3kydrlev6Ti7pD8CCzB4cCcaNxnO9Blh+HWoz6bNh9nz6ykOHng5LPnV2CW0af0OZcqUIj4+kbB1e9m37xw7/vXkyJcjuhDQbSrvvludpk1r8MvO42zZGq6+2rS2tqBv39Z8OXIRtrYqbGysGDlqEdWqudGiReH82P+bgYEBQwa+R/Csn/D0cMLT3YngmesxNzOhe9dG6nS9Pg7F2dmG4K8/AtJPxBcv3fnn/5/z991HnDl7E0vL9B4OlcqMql6aV5oWFibY2KjU6xMSnjF1xk90aFcHJ8eSPHoUz/wffuHO34/o0qm+un5fDu1I0NQwalRzo2b1cqxYvZfLV//mx9UjCyJEryUx1E5+focHDprL2rW/sXHDJFQqc/X9O9bWFpiZmZCQkMjUaWvo0N4HJydbHj2KY/6Czdy584AuH6T/7RwdbTK9qdu1jH2OG1/5Tc6DBUAmpcyVN7axdOjQIcqWLcvYsS8fB/3rr79yVYaHhwdGRkYcOXIEV1dXAGJiYrh69SqNGzfWaX1zY9RIfxITkxk4aC4xMfHUrVuJnb+EaFx5RdyOolixl4Pj9et7sXbNWMZPWM6ECStwd3cibO1Y6tatrE5z//5jevaazr170VhbW1C9ejl2bJ+Gr+/LJzo6dWrIgvlDCJm+liFDv6dixdL89ONEGjasqk4z+9sBFC9uiH/AFBITk2nerBbLNo3MtmegII0a3onEZ8kMHLqYmMdPqFvHk52bJ2r0nkTceaARv7v3YvhP/ZfDq9+EbuKb0E00fteLvb9MydF+DQ2LceXqHT5YvZeHj+KwtVFRp7YHB3ZPxauKqzrd0EHtefYsmeGjlxId84Qa1dzYtWUi7uWLxg8VSAy1lV/f4YUL0yf6bNrs5VAmwNIlX9K7dysMDQ25cvk2H6zczcOHcdjaqqjjXZED+2fj5eWWvwetY3IezGfSWMqVN3aepU2bNvHBBx+watUq6tSpw7Zt25g0aRKpqak8fvwYSH8abuPGjZw5c0adb86cOcyZM4dbt24BMGDAALZv387SpUtxcHBg7Nix/Pbbb/Tr169Q5lnSWzqaZ0mIPNPRPEtC5EWBz7O0ugdW5lrMs/Q0mZIf/l++1Hfq1Kls27aNM2fOYGxsrP5NL0xv7NNwfn5+DBs2jEGDBlGzZk0OHz7M+PHjc13OzJkzadSoER06dKBFixY0bNiQ2rVrvz6jEEIIIXQuOTmZLl26MGDAgMKuitob27NUVEjPko5Iz5IobNKzJApRgfcsrequfc/SR2vytb7Lly9n6NChRaJn6Y29Z0kIIYQQeaOkKiipee8reZH31YmZdf3EeFFRpIbhbt26hYGBQY6WqlWrvr5AIYQQQuSbMmXKaEzUHBwcXNhVyhdFqmfJyMgo2zmO/q18+fL5XBshhBDiLZWm5aSU/+S9ffu2xjBcVr1KQUFBTJo0Kdsijx8/jre3d7ZpCkuRaiy5uLhw+bL2L+oUQgghRDZSlfRFm/yAlZVVju5ZGjRoEAEBAdmmcXNzy3t98lmRaiwJIYQQ4u1jZ2eHnZ1dYVcjz6SxJIQQQugZRVFQtBiGy88H6SMiIoiOjiYiIoLU1FT1XIkeHh5YWhbOU6vSWBJCCCH0TSpaDsPprCYZTJgwgRUrVqg/16pVC4C9e/fSpEmT/NtxNorU03BCCCGEKACpadov+WT58uXpPV+vLIXVUAJpLAkhhBBCZEuG4XTlwZ/wzOz16USmlEdRhV0FoecMKtcv7Cq8+aKuF3YN3lzxiQW6OyVNy3uWtJl24A0kjSUhhBBC3+ho6gB9IcNwQgghhBDZkJ4lIYQQQt/oaAZvfSGNJSGEEELP6OpFuvpChuGEEEIIIbIhPUtCCCGEvlHSIE2LuZKU/JtnqSiSxpIQQgihb+RpuFyRYTghhBBCiGxIz5IQQgihZ2RSytyRxpIQQgihb2QYLldkGK4IUhSFoFlbcak5BvNyg2na+VsuXLmbbZ6ft52mTqtgSlYcjmX5IdRqMZVVPx7VSFOuzliKOQ3IsAwMXKtOk9n2Yk4DmDl/lzrNZyNX41FvPOblBmPvNZKOvRdw+VqkboOgBUVRmPT9Xko3nYVF7ck0672MC9ezf53K8o2nMaw6McPyLClFnSY+IYlhITso5/stFrUn0/DD/3L8/N9Zltl/0mYMq04kdFW4xvqk5OcMnrYN+4bTUdWZgt+gNdyJjNXuoHVMYqgdRVEImrQSl9L+mFu0o2mzEVy4cOu1+davP4hX1X6YmrXFq2o/Nmz4XWP7ggVbqFHzU6xL+GFdwo/6DQazY8cxjTR9+sygmKGvxuJT/wuNNJGR0fTsGYKTc1csVe2p7T2An346oPVx65KcB/PZi8aSNosekZ6lImjG97uYvehXls3pSQV3e6bO2UFL/++4/HsQKkvTTPPYlLTgqyFtqOThgLFxcbbuPk/fYSuxt1PRqmkVAI7tGEPqv55++OPyXVr6f0eX9rXV6+6eDdEod8dvF/h4+P/xfrta6nW1q7vyYed3cC1tQ3RMApO+2UqrgO/489gUDA0Lv/09c+nvzF4ZztIpHangZsvURQdo9clKLm39ApWFSZb5rCxNuLRV80fF1MRI/f+fTNjEhetRrAjujLO9itVbztHykxX8sWkQLg5WGvk2/nqJY+f+xtlelWE/w0J2sHX/VdbM/ADbEuaMnLmTDgPXcPx/nxWJ+IHEUFszZq5j9uz1LFv6JRUqlGbq1DW0bDWay5eWoVKZZ5onPPwiAd2m8PXXvenUsQEbNh7CP2AKBw/Mpm7dygCULm1H8LR+eHi4ALBi5S46dprIqZML8PJyU5fVulUdli79Uv3Z2FjzVN+z53Ri4xLYtPFr7OysWbP2NwK6TeW4uzO1annoOBp5I+dBUZTo/V80KCiImjVrFnY11BRFIfSH3/hqSGs6t6tF1UouLA/txdPEZNb8fDzLfE3qV6BT25pUruCEu1sphnzSjOqVXfj92MsXW5ayU+Fob61etu4+j7tbKRr7eKrT/Hu7o701m385R9MGFShftpQ6zacfvUsjH0/cytjyn+quTB7dgdt3Y7h1+1H+BCUXFEUhdNURvvr0XTr7VqGqpwPLp3Xi6bMU1mw7l21eAwMDHO1UGssLic9S+HnPJUKGt6SRtxserrZMHNiUci4lWbhO8+/y9/04Bk/bzqrp72NU3FBjW2z8M5b+fJqZX7aihY87tSo7sTKkM+ev3WfPkT91FwgtSAy1oygKoaEb+OqrbnTu/C5Vq5Zj+fKRPH2axJo1v2WZLzT0Z3xb1CZwTDcqVXIlcEw3mjerRWjoz+o07dv70LZtXSpUKJ3eCJvSF0tLM44cuaRRlomJEY6ONurFxkazIRp+5CKDBvrxzjuVKF/eiXFjP6RECQtOnbqm22DkkZwH89+Le5a0WfSJ3jeWipqbEQ+JjIqjZeMq6nUmJkY09vEk/MSNHJWhKAq/HrzMlRv3aVTPM9M0ycnPWb3+GH0CfDAwMMg0zf0HcWz79Tx9u2X9NvaEp0ksCwunnKstZZxL5qh++enmnRgiHz7Bt/7Lq2MT4+I08i5L+Jnb2eZ98jSZcr7f4tr8G9p/vprTl+6ptz1PTSM1NQ1TE80rdDPT4hw6FaH+nJaWRq/An/myd328POwz7OPkxbukPE+lZX139TpneyuqetgTfjoiQ/rCIDHUzs2bkURGRtPS11u9zsTEmMaNqhMefjHLfOFHLuLbsrbGupatvDmcRZ7U1FTCwvaSkPAMH58qGtv27T+Lg2MXKlbqzSeffktUVIzG9oYNqvK//+0nOjqOtLQ0wsL2kpSUQpMmNXJ7uPlCzoMFIDVN+0WPyDBcERMZFQeAQynNoQd7Oysi7mR/xRIbl0jpWoEkJadgaFiM74O74du4cqZpN/5ylsdxifT298myvBX/O4LK0pTObWtl2DZ/+X5GT95AwtMkKnk4smvdkAxd/YUh8uETABxsLTTWO9ha8tfdx1nmq1TOjqVTOlLN04G4hCS++78jvPvREk6vH4BnWVtUFib41CjD1IX7qVzeDgdbS9ZuP8/Rc3/jWdZGXc6MJb9jaFiML3rUy7J+xkaGlLQ201hvb2tJ5KMneTxq3ZIYaicyMhoAB4cSGuvtHUoS8df9bPLF4GCv+UPrYF+SyEjNhs758zep32Awz54lY2lpxs/rJ1KlSln19tat3+GDDxpTtqw9N29GMmHicpq3GMWJ499jYmIMQFjYOAICpmBX6n2KFzfE3NyEn9cH4e7urM2h64ycB0VRU+R7lu7cuUNAQAA2NjZYWFjg7e3N0aMvb9hbsGAB7u7uGBsbU7FiRVatWqWRPyIiAj8/PywtLbGysqJr167cv5/1CevmzZt4eHgwYMAA0jKZ3TQpKYm4uDiNRRur1x9D5T5UvaSkpAJkuMpRFCXLK58XVJYmnN7zFcd2jGHKGD9GBP3EvsNXM027dM0h2jTzwtmxRJblLVt7mO6d38HU1CjDtg87v8Op3V+x7+fheJYvhf+nP/DsWUompeSv1VvPYVVnqnpJeZ7+N8tt/OrVKEOP9jWoUcmRd2uXZd03XahQ1pZ5q1/+W1sR3BkFhTLNvsHsP5OZt/oo3dpWw7BY+tfo5IW7fPd/R1k2teNr/1avUhQFA3KXR1ckhtpZvfpXVFbt1UtKynMgb9/hVzen59FcV7FiaU6fWkj44e/o3789vfvM5OLFv9Tb/f2b0K5dXapWLUf79j5s3zaNq1fvsG3by7/DuPHLiHn8hN27pnP82PcMG/YBXf0nc/78zTxEQHtyHix4iqLlMJyiX8NwRboJ/OTJExo3boyLiwubN2/G0dGRU6dOqRsxGzZsYMiQIcyZM4cWLVqwdetW+vTpQ+nSpWnatCmKotCxY0csLCzYv38/z58/5/PPP8ff3599+/Zl2N8ff/xBy5Yt6dWrF8HBwZnWKTg4mEmTJunsGDu0qk7d/7ipPyclp59oI6PicHKwVq9/8Cg+w1XWq4oVK4ZHufRhi5pVy3Dp2j1CvvuFJvUraKT76/Yj9hy8zPoln2VZ1sEj17hy4z5hiz7OdLu1lRnWVmZ4lrenXu1y2FQawYYdZ+jWqU62ddS1Dk0rUre6i/pzUnL6STby4ROc/hWvqOiEDD0l2SlWrBjeVZ25FvHyKtbd1Ya9y/uS8DSZuIQknEqpCBjxP9xcSgDw+6m/iIpOwM13tjpPamoaX87cSeiqI/y5axiOdpYkp6QSE5uo0TPyIDqB+jXL5Pr4dUFiqJ0OHXyoW7eS+nPSP0//RUbG4ORk+7J+UY9xcMh6iMbRsSSR9zV7kaIeZMxjbGykvsHb27siJ05cIfS7DSxaODTTcp2cbClb1p5r19OfOrxx4y7ff7+J8+d+UN8UXqOGO7//fp7v529i4YLMy8lPch4sBDJ1QK4U6cbSmjVrePDgAcePH8fGJr2b3sPj5X0Us2bNonfv3nz++ecADB8+nCNHjjBr1iyaNm3Knj17OHfuHDdv3qRMmfST6KpVq/Dy8uL48ePUqfPyH3R4eDjvvfcegYGBfPnll2QlMDCQ4cOHqz/HxcWpy84LlaWpxpMdiqLgaG/F7gOXqFUtvdzk5OfsD79GyNhOuSpbUV6edP5t2bpw7O1UtGtRNcu8S9cepnZ1V2p4lc7hvpRM95XfVBYmGk9nKYqCo50le8JvUKuyEwDJKc85cOIvgoe1yHG5iqJw9nIkVT0dMmyzMDfGwtyYmNhEdh2+QchwXwB6tK9B83rlNdK2+WwVPdrXoHfH9C782lWcMSpuyO7wG3RtnR7/ew/i+eN6FCEjWubu4HVEYqgdlcpc4wk3RVFwdLRh956T6ifLkpNT2H/gHCHBmf/oAvjUq8Ke3ScZNvR99brdu05S/5X7kV6lKArJSclZbn/0KI7btx/g5JjecHv6NAmAYsU0e2gMixUjrZBu2pXzoCjqinRj6cyZM9SqVUvdUHrVpUuX+PTTTzXWNWjQgNDQUPX2MmXKaDRmqlSpQokSJbh06ZK6sRQREUGLFi2YMmUKw4YNy7ZOJiYmmJhk/ei0tgwMDBjySTOCv/sFz3L2eJYvRfB3v2BuZkz3zi8bd72+WI6zYwmCx3YEIPi7X/CuURZ3NzuSk1PZ/usfrPrxCPNDummUn5aWxvKwcHp2rUfxV54yeiEuPpEft5xi1sT3M2z7868HrNt0kpaNK1PKVsXfkY+ZMW8XZmbGtG3upbtA5JGBgQFDPqpH8A8H8XC1xbOsDcE/HMTc1Iju7aqr0/UK/BkXexXThqX/SH89fy91a5TB09WGuIQk5v7fUc5ciWTuuHbqPDsPXUdRFCq62XE9IprR3+yiopstff75EbctYY5tCc3Hwo2KG+JoZ0nFcnYAWKtM6du5FiNn7sS2hDk21maMmrWTap4OtHilkVBYJIbaMTAwYMiQTgQHr8XTwwVPTxeCg9dibm5C9+7N1Ol69ZqOs0v6VAAAgwd3onGT4UyfEYZfh/ps2nyYPb+e4uCBl71sX41dQpvW71CmTCni4xMJW7eXffvOsWP7NACePEkkaNJK3u/8Lk5ONty6dZ+x45ZiZ2dNp04NAKhUqQweHs70HxDKzBmfYmtrxcZNh9i95xRbNk8uwEhlTc6DBSBNSV+0ya9HinRjyczM7LVpshvTzmp8+9X1pUqVwtnZmbCwMPr164eVlVWGPAVp1MCWJD5LYWDgWmJin1K3Vjl2hn2hceUV8Xe0xpVhwtMkBgau5c69x5iZGlHJw5FV8/rg7+etUfaeA5eJ+DuavgFZP9kRtvEEiqJk2pVsamLE70evE/rDb8TEPsWhlBWN6npwaPOX2NsVbtxeGNm3IYnPnjNoylZi4p5Rt7oLvyz+SKP35Pa9WI34PY5/Rv+gzUQ+fIK1ypSalRzZt7wv71R7eUUZG/+MsXP2cOd+HDbWZnT2rcKUwc0xMsr8ZJuVb0e3pnjxYgSM+B+JSc9pVrccm+Z1KlJzs0gMtTNqpD+JickMHDSXmJh46tatxM5fQjR6oCJuR2nEr359L9auGcv4CcuZMGEF7u5OhK0dq55jCeD+/cf07DWde/eisba2oHr1cuzYPg1f3/Sn6AwNi/HH+ZusWrWHx4+f4ORkQ9MmNQhbO1a9byOj4mzbOpXAwCV08BvPkyfP8PBwZvmykbRtW7eAIvR6ch7MX0oqKFoMpSmpOqzMG8BAKcJ3aa1YsYLBgwdz8+bNTHuXGjRogJeXF4sXL1av69q1K0+fPmXr1q3s3r2bNm3aaAzDXbx4UT0M5+3tTVBQEBs3buTQoUO0bduW5ORkdu3ahUqV/bj4C3FxcVhbW/P46rdYqV7fuBOZUx5lPzu0EPnNoHLWP5wih6Kuvz6NyFRcfCIlKgwnNjY2Xy/YX/xm3RvaAiuTvPeXxCU9x2nOnnyvb1FRNC7DstCtWzccHR3p2LEjhw4d4s8//2T9+vWEh6e/+mDkyJEsX76chQsXcu3aNb799lt+/vln9T1HLVq0oHr16nz44YecOnWKY8eO0bNnTxo3boy3t+aVhoWFBdu2baN48eK0adOGJ08K/xFkIYQQIl+8GIbTZtEjRbqxZGxszK5du7C3t6dt27ZUq1aNkJAQDA3Tu+w7duxIaGgoM2fOxMvLi0WLFrFs2TKaNGkCpA/Rbdy4kZIlS9KoUSNatGhB+fLlWbduXab7s7S0ZMeOHSiKQtu2bUlISCioQxVCCCEKjkxKmStFehjuTSDDcLohw3CisMkwnA7IMFyeFfQw3N0BTbQehnNesE+G4YQQQgghRCE0lm7duoWBgUGOlqpVs57/QgghhBB5lKa8nJgyL4ue3bNU4FMHGBkZUbFixRylLV++8OdMEUIIId42L15bok1+fVLgjSUXFxcuX75c0LsVQgghhMiTIj0ppRBCCCF0T0lVtJyUUnqWhBBCCPEWk2G43JGn4YQQQgghsiE9S0IIIYSeSUtVSNNiKE2bvG8iaSwJIYQQekaG4XJHGku6Yu8BVhaFXYs3loFDhcKughBCW/I9zjszeb1WUSaNJSGEEELPKGlpKGl5f7+bNnnfRNJYEkIIIfSNllMHIPcsCSGEEOJtpiha3rOk6FdjSaYOEEIIIYTIhvQsCSGEEHpGSVVQiskM3jkljSUhhBBCz8jUAbkjw3BCCCGEENmQniUhhBBCz6SlKaRp0TukTd43kTSWhBBCCD2jpKLlPUs6rMwbQIbhhBBCCCGy8dY1lpo0acLQoUMLuxp5Nn/+JsqX/xAzs9Z4e/fn4MFz2abfv/8s3t79MTNrjbt7DxYu3JIhzfr1B/Dy6oOpaWu8vPqwYcPvud6voigEBa3AxaUr5uZtaNp0OBcu3NLqWPNLXutaUHFKSkrmiy/mUqpUJywt2+HnN447dx5oc8g6JzHUjnyPtScxzF8vbvDWZtEnb11j6eeff2by5MmFXY08WbduL8OGzeerr7pz6tQiGjasRtu2gURE3M80/c2b92jX7isaNqzGqVOLCAzsxpAh81i//oA6TXj4BQICJtOjhy9nziymRw9f/P2/5ujRS7na74wZYcye/RNz537BsWPzcXQsScuWo4iPf5p/AcmjvNS1IOM0dOh8Nm78nbVrx3Hw4ByePEmkffuxpKYWnX5tiWHeyfdYexLD/CeNpdwxUPRtGk4di4uLw9ramsePN2Ol5Yt069UbSK1anixYMFS9rkqVPvj5NSA4+OMM6UePXsyWLeFcvLhMva5//9mcO3eDw4fnARAQMJm4uAS2bw9Rp2nTZgwlS1qyZs24HO1XURRcXLoyZEhnRo/uBqRf2Ts6fkBIyCd89ll7rY5bl/Ja14KKU2zsE+zt32flyjH4+zcF4O7dh7i6dmPbtmm0alUnP8KSKxJD7cj3WHv6GMO4uARKlOhAbGwsVlZWeS7n9ftJ/8261KoWKiPDPJcTn5JK5Z2n872+RcVb17P072E4Nzc3pk2bRt++fVGpVLi6urJ48WKN9IcPH6ZmzZqYmpri7e3Nxo0bMTAw4MyZMwVa7+TkFE6evErLlt4a6319axMefiHTPEeOXMTXt7bGulat6nDixFVSUp4DEB5+EV9fzTJbtvTm8OELOd7vzZv3iIyM1khjYmJM48Y1sqxbYclrXQsqTidPXiMl5blGGmdnO6pWdVPvq7BJDPNOvsfakxgWDOWfd8Nps+iTt66x9KpvvvkGb29vTp8+zeeff86AAQO4fPkyAPHx8bRv355q1apx6tQpJk+ezOjRowulng8fxpKamoaDQ0mN9Q4OJYmMjM40T2RkdKbpnz9P5eHD2GzTREbG5Hi/L9K+msbe/mU5RUVe61pQcYqMjMbY2IiSJVVZllPYJIZ5J99j7UkMC4aipKGkabEoaYV9CAXqrW8stW3bls8//xwPDw9Gjx6NnZ0d+/btA2D16tUYGBjwww8/UKVKFdq0acPIkSOzLS8pKYm4uDiNRZcMDDQ/KwoYvLpSI73mthejqv9en1maV4vMyX4zLyfruhWE1av3oFK1Uy8vriLzUtfCjFNhxlJiqHvyPdaexDB/Sc9S7rz18yxVr15d/f8GBgY4OjoSFRUFwJUrV6hevTqmpqbqNO+880625QUHBzNp0iSd19POzhpDw2IZrk6iomIyXMW84Ohok+FKKyrqMcWLG2Jra5Vtmhdl5mS/jo7p/42MjMbJyVad5sGDxzg4lMjlkepWhw71qVu3svpzUlIKkPu6FlScHB1tSE5OISYmXqNnJCrqMT4+Xjk9bJ2SGOqOfI+1JzEURdFb37NkZGSk8dnAwIC0tPTuw8yuBl53v3tgYCCxsbHq5fbt2zqpp7GxEbVrV2D37pMa6/fsOZnlD0C9elXYs0cz/a5dJ/D2roCRUXo72McnY5rdu09Qv75XjvdbrpwTjo42GmmSk1PYv/9sof84qVTmeHi4qJcqVcrmqa4FFafatT0xMiqukebevUf88cct9b4KmsRQd+R7rD2JYcGQp+Fy563vWcpOpUqVWL16NUlJSZiYmABw4sSJbPOYmJio0+rasGEf0LNnCN7eFfDxqcLixduIiIiif//0JywCA//L3bsPWbFiDAD9+7fn++83MXz4fD75pB3h4RdZunQHa9aMVZc5eHBnGjceyvTpa/Hza8CmTYfYs+cUBw+G5ni/BgYGDBnSmeDgNXh6lsbT04Xg4DWYm5vSvXvzfIlFXuW0rr16heDsbKd+sqag4mRtbUnfvm348suF2NpaYWOjYuTIRVSrVo4WLf5TgJHKmsRQO/I91p7EMP/J605yR68bS927d2fs2LF8+umnjBkzhoiICGbNmgVkPzaeX/z9m/LoURyTJ6/i3r1oqlZ1Y9u2YMqWdQAgMvIRERFR6vTlyjmxbds0hg+fz/z5m3F2tiU0dBDvv99InaZ+fS/Wrh3H+PHLmDBhOe7uzoSFjdcYdnndfgFGjQogMTGZgQNDiYmJp27dyuzcOR2VyrwAIpM7OalrREQUxYq9/BsXZJxmz/6c4sUN8ff/msTEZJo3r8WyZVMwNMz7Y7y6JjHMO/kea09iKIqat26epSZNmlCzZk3mzJmDm5sbQ4cO1ZjRu2bNmnTs2JGgoCAgfeqAF0/IVatWjREjRtC9e3cuX75MxYoVX7s/Xc6zJIQQQj8V9DxLZ3yqoCquxTxLz1OpGX5Rb+ZZeut6ll486QZw69atDNtfnT+pfv36nD17Vv159erVGBkZ4erqmk81FEIIIQqXtvcdyT1LemblypWUL18eFxcXzp49y+jRo+natStmZmaFXTUhhBBCFAF631iKjIxkwoQJREZG4uTkRJcuXZg6dWphV0sIIYTIN0qqgmKgRc+SzLOkX0aNGsWoUaMKuxpCCCFEwVG0fPz/7brd+bXe+nmWhBBCCCG0ofc9S0IIIYS+UdK0HIaTG7yFEEII8TZTUhUU5J6lnJJhOCGEEELPvJjBW5slP9y6dYt+/fpRrlw5zMzMcHd3Z+LEiSQnJ+fL/nJKepaEEEIIUSRcvnyZtLQ0Fi1ahIeHB3/88QeffPIJCQkJ6jdsFAZpLAkhhBB6Ji0N0rR4q9c/76PXudatW9O6dWv15/Lly3PlyhUWLFggjSUhhBBCFBxdNZbi4uI01ufHy+ZjY2OxsbHRaZm5JfcsCSGEECJPypQpg7W1tXoJDg7Wafk3btxg7ty59O/fX6fl5pY0loQQQgg9k5am/QJw+/ZtYmNj1UtgYGCm+wsKCsLAwCDb5cSJExp57t69S+vWrenSpQsff/xxfockWzIMJ4QQQuiZNCV90SY/gJWVFVZWVq9NP2jQIAICArJN4+bmpv7/u3fv0rRpU3x8fFi8eHHeK6oj0lgSQgghRL6ys7PDzs4uR2n//vtvmjZtSu3atVm2bBnFihX+IJg0loQQQgg9U1Sfhrt79y5NmjTB1dWVWbNm8eDBA/U2R0fH/NlpDkhjSQghhNAzaYp2DZ78etvJrl27uH79OtevX6d06dIa25RCfHlv4fdtCSGEEEIAvXv3RlGUTJfCJD1LQgghhJ5R0kCbkTQln4bhiippLAkhhBB6Jk3LxlJ+3bNUVEljSQghhNAz0ljKHblnSQghhBAiG9KzJIQQQugZ6VnKHelZKmLmz99E+fIfYmbWGm/v/hw8eC7b9Pv3n8Xbuz9mZq1xd+/BwoVbMqRZv/4AXl59MDVtjZdXHzZs+D3X+71/P5o+fabj4tIVC4u2tGkzhmvX7mh3sPlEURSCglbg4tIVc/M2NG06nAsXbr02n7ZxSkl5zujRi6le/WMsLdvh4tKVXr1CuHv3oUYZn332LR4ePTA3b4O9fWc6dhzP5csRWh+3LkkMtVNY8QMIClpB5cq9sbRsh42NH76+Izl69JJ6+61bkRQr1jzT5ccf92t97Loi58L8pavXnegLaSwVIevW7WXYsPl89VV3Tp1aRMOG1WjbNpCIiPuZpr958x7t2n1Fw4bVOHVqEYGB3RgyZB7r1x9QpwkPv0BAwGR69PDlzJnF9Ojhi7//1xonz9ftV1EUOnWawJ9/3mPjxq85dWoRrq72+PqOJCEhMX+DkgczZoQxe/ZPzJ37BceOzcfRsSQtW44iPv5plnl0EaenT59x+vQ1xo3rwcmTC1m/PoirV+/g5zdeY1+1a1dg6dJRXLy4jF9+CUFRFFq1Gk1qamr+BCQPJIbaKaz4AVSoUJq5c7/g3LkfOHgwlLJlHWjVajQPHjwGoEyZUty9+6PGEhTUCwsLU9q0eSffYpIbci4URY2BUtiTF7zh4uLisLa25vHjzVhZWWhVVr16A6lVy5MFC4aq11Wp0gc/vwYEB2d8ieDo0YvZsiWcixeXqdf17z+bc+ducPjwPAACAiYTF5fA9u0h6jRt2oyhZElL1qwZl6P9Xr16m0qVenP+/BK8vNwASE1NxcHhfUJCPuHjj9tpddy6pCgKLi5dGTKkM6NHdwMgKSkZR8cPCAn5hM8+a59pPl3EKTPHj1+mbt2B3Lq1BldXh0zTnDt3g5o1P+XatVW4uzvn5bB1SmKonaIWv7i4BEqU6MDu3TNp3vw/mab5z38+o1YtD5YsGZmXQ9Y5fTwXvvg7xcbG5uhda3nfT/pv1hZ7DyyKGea5nIS0VNpHXc/3+hYV0rNURCQnp3Dy5FVatvTWWO/rW5vw8AuZ5jly5CK+vrU11rVqVYcTJ66SkvIcgPDwi/j6apbZsqU3hw9fyPF+k5JSADA1NVZvNzQ0xNjYiEOH/sjtoearmzfvERkZrXE8JibGNG5cI8s4gm7ilJnY2AQMDAwoUcIy0+0JCYksW7aTcuWcKFOm1GuPryBIDLVTlOKXnJzC4sXbsLa2oEYN90zTnDx5lTNnrtOvX9scHV9+k3Nhwchq4sfcLPpEGku5lJSURFxcnMaiCw8fxpKamoaDQ0mN9Q4OJYmMjM40T2RkdKbpnz9P5eHD2GzTREbG5Hi/lSq5UrasA1999V9iYuJJTk4hJGQtkZHR3LuXed0Ky4vjevV47O1fHnPm+bSP06uePUsmMPC/dO/eLEOv4/z5m1Cp2qFSvcfOncfZtWsGxsZGOTvIfCYx1E5RiN/WreGoVO0wM2vDnDk/sWvXDOzsrDPd75IlO6hc2ZX69b1ydoD5TM6FoiiSxlIuBQcHY21trV7KlCmj0/INXnmxoaKAwasrNdJrbnvR2v/3+szSvFpkdvs1MirOTz+l3ztia9sRC4u27N9/ljZt3sHQsHD/Ca1eveefH8z05cVVZObHnP1bI7WN07+lpDynW7fJpKWl8f33QzJs//DD5pw6tYh9+2bj6emCv//XPHuWnG398ovEUDtFMX5Nm9bk9OnFHDr0Ha1a1cHffzJRURkbaomJSaxd+yt9+7bJtl6FQc6F+Utu8M4dmToglwIDAxk+fLj6c1xcnE4aTHZ21hgaFstw5RkVFZPhSucFR0ebDFdaUVGPKV7cEFtbq2zTvCgzp/utXbsCp08vJjb2CcnJzylVqgT16g2kdu0KeTtgHenQoT5161ZWf37RTR4ZGY2Tk616/YMHj3FwKJFlObqKE6T/yPv7f83Nm5H8+uusTO9ls7a2xNraEk/P0tSrVxkbm45s2PA73bo1y9mB65DEUDtFMX4WFmZ4eLjg4eFCvXpVqFChJ0uW7CAwsLtGup9+OsDTp0n07Nky5wecz+RcWDBk6oDcebOawkWAiYkJVlZWGosuGBsbUbt2BXbvPqmxfs+ek/j4ZN49Xq9eFfbs0Uy/a9cJvL0rYGSU3g728cmYZvfuE+ou99zu19raklKlSnDt2h1OnLiKn1+D3B2ojqlU5uofBQ8PF6pUKYujo43G8SQnp7B//9ks4wi6i9OLH/lr1/5m9+6Z2NpmPvTxKkVRSEoqnJ4liaF2ilr8MpMem5QM65cu3UGHDj6UKlXidYdZYORcKIoi6VkqQoYN+4CePUPw9q6Aj08VFi/eRkREFP37pz89Exj4X+7efciKFWMA6N+/Pd9/v4nhw+fzySftCA+/yNKlO1izZqy6zMGDO9O48VCmT1+Ln18DNm06xJ49pzh4MDTH+wX48cf9lCpljaurPefP32To0O/p2LFBhpshC5uBgQFDhnQmOHgNnp6l8fR0ITh4DebmpnTv3lydrlevEJyd7dRP1ugiTs+fp9KlyyROnbrGli1TSU1NU1/J2tioMDY24s8/77Ju3T5atvSmVClr/v77ITNmhGFmZkzbtnULMFJZkxhqpzDjl5CQyNSpq+nQoT5OTrY8ehTL/PmbuXPnAV26NNao5/Xrf3PgwDm2bZtWAFHJHTkX5r80RbveoTT9ur9bGkuZmTdvHhs2bODXX38t0P36+zfl0aM4Jk9exb170VSt6sa2bcGULZv+uHRk5CMiIqLU6cuVc2LbtmkMHz6f+fM34+xsS2joIN5/v5E6Tf36XqxdO47x45cxYcJy3N2dCQsbrzFs8Lr9Aty794gRIxZw/34MTk42fPRRS8aP71EAUcm9UaMCSExMZuDAUGJi4qlbtzI7d05HpTJXp4mIiKJYsZc3J+giTnfuPGDz5sMA1Kr1qUadfvvtG5o0qYmpqTG//36e0ND1xMQ8wcGhJI0aVefQobnY22c+xFAYJIbaKaz4GRoacuXKbT74IIiHD+OwtbWiTp2KHDgwR/2o+wtLl+7AxcWuSP7Iy7kw/ylpkJb9LXTZ59ezxpLMs5SJoKAgli9fzq1bt16bVpfzLAkhhNBPBT3P0jpLd8wN8j7P0lMlFf8nN2SeJX0WFBSUo4aSEEIIId5+MgwnhBBC6Jk0LYfh5J4lIYQQQrzVpLGUOzIMJ4QQQgiRDelZEkIIIfRMmqLlpJR61rMkjSUhhBBCz8gwXO7IMJwQQgghRDakZ0kIIYTQM9KzlDvSWBJCCCH0jDSWckeG4YQQQgghsiE9S1p68baYuLinhVwTIYQQb6oXvyEF9QayBCVNq96hRK2epXvzSGNJS/Hx8QC4ugYUck2EEEK86eLj47G2ts638o2NjXF0dGRw5E2ty3J0dMTY2FgHtSr65EW6WkpLS+Pu3buoVCoMDLQYABZCCKG3FEUhPj4eZ2dnihXL3ztknj17RnJystblGBsbY2pqqoMaFX3SWBJCCCGEyIbc4C2EEEIIkQ1pLAkhhBBCZEMaS0IIIYQQ2ZDGkhBCCCFENqSxJIQQQgiRDWksCSGEEEJkQxpLQgghhBDZ+H9sH4C2yxrBegAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1153,369 +449,59 @@ } ], "source": [ - "attr_viz_3 = LLMAttrViz(**attr_result_3)\n", - "print(attr_viz.seq_attr_dict)\n", - "attr_viz_3.plot_token_attr()" - ] - }, - { - "cell_type": "markdown", - "id": "scheduled-disclaimer", - "metadata": {}, - "source": [ - "One issue we notice from the test results is that there are correlated aspects of the prompt which should be ablated together to ensure that the input remain in distribution, e.g. Palm Coast, FL should be ablated with Seattle, WA. We can accomplish this using a mask as defined below, which will group (city, state) and (name, pronoun)" - ] - }, - { - "cell_type": "code", - "execution_count": 278, - "id": "breathing-sound", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHCCAYAAADhI708AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC+IklEQVR4nOzdZ1gVxx6A8ffQBalKFxQrInYs2Bv2bqwxttgSG/YWjUYN9h5rYr2WaOwl1thFDdh7L1EQFQQBpe79QDzmCChV2v93n31uzuzM7OzI2TM7MzurUhRFQQghhBAih9PK6AIIIYQQQmQG0igSQgghhEAaRUIIIYQQgDSKhBBCCCEAaRQJIYQQQgDSKBJCCCGEAKRRJIQQQggBSKNICCGEEAKQRpEQQgghBCCNIpFCshC6EEKI7EYaRSJFVCoVALGxsRlcEiGEECJtSKNIJNuECRNYu3YtAFpaWiiKIj1HQgghsjxpFIlk2bNnD1u3bqVr164ULFiQw4cPo1Kp1D1HQgghRFYljSKRZK9fv2bTpk04ODhw/fp1vvvuO9q2bcsPP/xAVFSU9BYJIYTI0qRRJJJs06ZN3Lp1i3r16uHs7Mzw4cNZvHgxGzdu5MGDB9JbJIQQIkuTRpFIkgcPHrBr1y4KFizI4MGD1eHGxsY8e/aMs2fPqsOkx0gIIURWpJPRBRBZw7p16/Dx8UFfX587d+5QpEgRQkND8fHxITY2FldXV3VclUpFTEwMWlpa0nskhBAiy5BGkfis06dPc+TIEerXr4+lpSXlypWjXLly6Orq4u3tzTfffEPZsmVZsGABAQEBDB48GAsLCyCu10gaRkIIIbICGT4TnxQdHc3GjRuJjY2lf//+zJw5k8uXL1OyZElsbW2ZN28eM2bM4OnTp2hra+Pr60vBggWZN28egEaDKCIigkOHDmXUqQghhBCfpFJkAoj4hFOnTtG7d2+aNm3KtGnTNPZFRESgr68fL83WrVsZOXIka9aswd3dXR3+119/Ua9ePQ4cOEC9evXSvexCCCFEckijSHyWr68vdnZ22Nraqlew1tKK62QMCQlh4MCBvH37Fn19fUaNGoWLiwu1a9emXr16jB07Foh7nL9t27aoVCoOHDiQYecihBBCJEbmFInPKl++vPq/3zeG3s8V6tq1K76+vnz77bc8fvyYypUr06lTJ+7fv4+OTtyfV2xsLDt27OCvv/7i8uXL6vSxsbFoa2t/+RMSQgghEiA9RSLFnj9/jr29Pb///jtt2rQB4MKFC7Ro0QJFUbhy5QpmZmY8evSIevXqUadOHZYuXUpkZCR6enrqfGQythBCiMxAJlqLFNPV1aV27docPHgQgODgYKKjo3nz5g19+/bFzMyM6OhofvvtN168eMHMmTOBuKfZWrZsyf3794EPj/BL+1wIIURGkkaRSDELCwsGDx7Mtm3bqFatGgMHDqRq1ao4ODjQt29fAK5du8bcuXOZMGECxsbGvHz5kn379rFz506OHDnCiBEjuHfvHtra2tJbJIQQIkNJo0ikSuPGjXn+/DnDhg2jRYsWREdHM378ePLkycPbt2+ZNm0a9vb2eHp6AvD333+zcOFCatasSWhoKC9evKB8+fLs27dPI9/o6OgMOBshPpg7dy47duzI6GIIIb4gmWgt0kTLli0JCQlh0qRJNGvWDIDjx4+zZcsWdu7cCcCjR49YunQpRYoU4ciRI+q0Fy9exMfHh9q1a3Pz5k1Kly6tnqQtREbw8/Nj6dKlNG/enBYtWmR0cYQQX4hMtBbpIiQkhPLly5MvXz6OHDlCZGQk69evZ+DAgfz5559UrVoVgCdPntC8eXOio6NxdnbGz8+PoKAgNm/ejIuLSwafhcipevTowevXr5k0aRIlSpQgJiZGnpQUIgeQ4TORLkxMTJgwYQIrV64E4NatWyxfvpymTZuqG0QA+/btw8/Pj759+zJ//nz++usvnJycmDFjRkYVXeRwPj4+XLhwgYYNG1KiRAkAtLW1iYmJyeCSCSHSm4xRiHTz9ddfAxAZGcn27dvx9vbmjz/+UO+/dOkSO3fuxN3dnX79+qnD9fX18ff3JzY2FpVKJROwxRcTExPD6NGjKVWqFO3atePx48c8evSI6tWro62trX5CUv4mhciepFGUSbx69Qpzc3P14ojZiZ6eHj179qRo0aLY2toCcQ2lP//8kzt37rBixQp13Nu3bxMWFkapUqWIjY1N8twiaUCJtLB582bCwsJo3bo1uXPnZsmSJezcuZPw8HDmzZtHzZo1M7qIQoh0lP1+gbOg2NhYevfujZ2dHXPnzs3o4qQLW1tb2rdvr/78119/sWnTJho2bEiVKlXU4evXryc4OJiaNWuio6OT6NpFly5dYt++faxbt44bN26gpaWFSqVSv4ZEiOQKDQ1l5syZVKlSBQ8PD3R0dPj+++/ZsmULLVq0oHPnzqxbt04jjUzJFCJ7kUZRJvDXX38REBBAnTp1mD9/PsWKFePkyZMZXax0ZWJiQq5cuRgyZIg67Pjx4xw7doyyZcvSpEkT4MMwxfv5HE+ePGHQoEG4u7vTtm1blixZQvXq1fn6668JCQnJlj1t4suYPn06ZmZmfPvttzx//pwdO3awd+9ebG1tmThxIrVr1+bIkSMaDSHpmRQie5FfkAz29u1bFixYgJWVFevXr+f+/fu0bduWnj17smLFChRFyZZ3o1WqVOH48eM4OjoCccNpmzZtQqVS8e233wJo9Pq8f/Ln+++/Z9OmTQwbNozHjx+zYcMGdu/eTXh4OLVr1+bChQtf/mRElnf//n327NlDo0aNePfuHaVLl2b8+PHMmDGDQoUK8ccff+Du7s6ZM2fUDfSRI0fGu3nJjt9VIXISaRRlsLVr1/L8+XM6d+4MxDUEJkyYQPfu3Vm2bBmBgYHZ9m70v484nzlzhr/++ovKlSurX0D7vtfn/Y/Qhg0b2LNnD71792bixImYm5uTL18+KleuzO+//06ZMmXYunXrlz8RkeUtX74cY2NjOnTowIIFC3B2dubYsWPs3bsXT09PhgwZQr9+/WjRogU6Ojo8fvyYv//+m8OHD2s8lSZDuEJkbdIoykD+/v7qH/NWrVoBcQ0BHR0dOnTowN27d/ntt98yuJRfRo0aNVi9erV65euEeolmzZqFu7s7HTt2VL8v7T09PT06d+6s7nkSIjm8vLxYvnw59vb2REdH4+joiJmZGdbW1gwYMID27duTL18+evfuDaBejb1YsWJoa2tz69YtZs2aRXBwsAzhCpGFydNnGWju3LlERUXRo0cPQPMJqvz586OtrU1YWJhGmpiYGPWk4uymQoUK6v/++Ifl9u3bBAUF0axZM5ydnQHiLaZXu3Zt3N3d4+UbHR0tK2SLRL1fmLFIkSIA6knV33//PbVr12bPnj2sX7+en3/+Wd3oPn36NAEBAXTo0AGIG9Y9cuQIwcHB/PTTTxl2LkKI1JFbmgxy+fJlTp48Sa1atahYsSKg2RDYvXs3AHnz5kVRFE6cOMGbN2/UL07NaQvJ2dvbExgYSLly5QASPP/Y2FgMDAwIDw/nxo0bHD16FOCTT7EJ8XHjuk2bNvj6+uLv78+TJ09Ys2YNNWrUoEePHuqbkf/973/06dOHu3fvMmjQIC5cuECdOnVo0KCBOp9z586p/zu7zg3MKDJEKdKLNIoyQExMDD/88AOGhoYMHTpUHfa+pyg0NJStW7eip6dH3bp1OXv2LAsXLqRkyZJMnDgRiH8hz85iYmLQ1dWlVKlSbNy4kdDQUI3zf3+B1NLS4s6dO7Rs2RIPDw++/fZbChcuzPHjx7Nlz5pIe4qiEBMTg4uLC1u3bqVXr144OzvTq1cvLCwsAPD19cXa2hotLS1mzJhBUFAQkydPpmjRolhYWBAcHMykSZOoXLkyDx48ICgoSNbQSiMvXrwgNjZWhihFupG/rAwQERGBqakphw4dYsuWLURHR6Otra3+os+fP599+/bRpk0bXFxcKFGiBEuXLmXevHls3bqVjh07EhwcrJFndr5z0tbWRk9Pj6FDh/L8+XP1C2bfe19vgYGBtGrVipiYGObNm8fZs2dp1aoVAwYM4NmzZxlRdJHFqFQqtLW11d8nY2Njrl+/Trt27dRxQkNDefToEXPmzEFbW5sJEyZgbGzM/fv3KV68ONOmTWPHjh2sXLkSJycnOnbsyJo1azLqlLKN2NhY+vbtS7t27QgNDc3o4ojsShEZZtOmTYqtra3i6uqqzJ07V5k4caLSp08fRVtbW2nbtq3y/PlzxcfHR9m4caNy584dRVEU5dy5c4qTk5Ny48aNDC59xvDy8lJy5cqldO7cWTl06JCyfPlyJSQkRFEURZk2bZqSJ08e5dmzZ+r4/v7+iq2trbJmzZoE84uOjv4i5RZZU1RUVLywcePGKSqVSqlcubLy5s0bRVEUpVSpUsqaNWuUOXPmKCVLllR++eUXdXwjIyNl48aNiqIoSkxMjEZesbGx6Vj67OXQoUNK1apVlZkzZya4/+O6FSIlpKcoA7Vt25Znz57Ro0cPDh8+zNGjRzl37hxz5sxh3LhxzJo1iwoVKrBo0SJq1apF3759MTQ0xNzcnIsXLwJw5coVPD09s3VP0X+NGjWKO3fuoFKpmD9/Pn/++Sf+/v4ALFy4kH79+mFra0tkZCQA5ubmREVFkTt3bnUe3t7eHDx4EED9PitF5nukyqtXr7Ll32BCE/Q7dOhAv379WLx4Mblz58bb2xs9PT0uXrzI0KFDmThxovrhib/++ovChQtTvHhx4EOv5sOHDwFZ/DGp3q/nZmdnR/fu3QHNeYXh4eEypCbSRka3ykSciIgIJTw8XP354sWLikqlUnbu3KkEBgYqZ86cUerUqaPo6OgoRkZGSlBQkKIoijJ58mSlZMmSSmBgYLw8s3svyKtXr5S3b98qiqIojx8/VpydnZVff/1VUZQPd+C//PKL4ubmpuzevVtRFEUJDQ1Vevfurbi6uiplypRRvL29M6bw2UhMTIzSunVrxdraWpkzZ05GFyddJdSzs3HjRkVHR0dxdHRUn//7XouTJ08qBQsWVK5evaooSlzP06+//qpYWloqa9eu1chTejoS9+uvvyqFCxdWtm3bpihK3LXt/fXt2rVrirW1tXLq1CnF399fXa9CpIQ0rTMJPT09DAwM1J9fvnyJtbU1Li4umJubU6lSJebMmYOenh6jRo3CzMyM2NhYFEXBysoKfX39eHlm98nYFhYW6jpzcHCgSJEi6h40lUrFvXv32Lx5My4uLlStWhUAIyMjZsyYgbe3N7Vr16Zr166cOnUqo04hW/jva2rmzZtHoUKFOHToUEYXK10ktDijkZERJiYmeHp6xltn69ixY+TOnZsSJUoQERHB+PHjGT9+PMOGDaN+/frqPCH+YqUijr+/P2vXriUwMJD+/fvzv//9D21tbbS1tXn79i2LFy8mNjYWd3d3dHV1WbRoEX/++WdGF1tkVRndKhMJ8/f3V6pXr64UL15c2bp1qzJ9+nTFzc1NsbGxUfeOKIqiVK1aVenXr5/687t375R169Yp7du3V8LCwjKi6F/c+zvt//3vf4qJiYnSsWNHZfjw4UrevHmVunXrKmfPnlUURVEOHjyoLFiwQFm5cqU6beXKlZUffvghwXyze09bWggPD1datGihfPXVV0pkZKSiKIoyceJERaVSKePHj88xvR+hoaHq79v7c46KilIGDBigDBo0SLl7967SrFkzpWzZsur5RrGxscrBgweVYcOGKV26dFGWLl2aYeXPzEaOHKnUqFFDOXnypLJ27VrF3t5eqVChgnL27Fnl9u3biq6urrJ169aMLqbIJmRFu0zK2tqa48ePM3bsWDZs2ADEPQq8ceNGde/IgwcPCA4OpkaNGup0o0aN4vTp09jb22NoaBgv3/cL1WUn7++0v/76aypUqMCYMWN4+vQpXbt2ZfLkyRgYGDBz5kxmzZpF0aJFCQ0N5eeff2bcuHEULVoURVGIjIxET0+Pd+/eERgYiJ2dncZTSDJfIWHr16/n2rVrzJgxA11dXWJjYxk/fjy9evUiOjqaRYsWYWhoqJ5jk90oikJsbCxGRkbqMC0tLWJjY9HR0SE2Npa9e/fy8uVLbt68yd69e3FycgJg4MCBXLhwAQcHB0qVKsVPP/3E77//zvr167G2ts6oU8pU3q/nVrduXapWrUrVqlVp0KAB06ZNo1GjRoSHh1OtWjVatWrFjBkzePToEfPnz1cvgaAoiszbEsmTwY0ykQSRkZHK8uXLlWLFimmE37x5U3F2dlZOnjypPHv2TBkxYoSir6+vbNy4UT0/6fz588rhw4eVXbt2qdPlhCde/vvU0OPHj5UaNWooPXv2VCIjI5WAgABl4cKFipmZmWJtba3MmzdPURRFuX79ulK9enXFzc1NqVatmnL+/PmMKn6W4Ofnp9SsWVOxsLBQ7Ozs4s3luHz5slKnTh2lUaNGCT7FlR3997sVHh6uuLq6KiqVShkzZoxy7tw59b7jx48rKpVKqVixovL06VNFUeJ6m2rWrKmsXr06Xr45pcftv6KiopRmzZopDRs2VB49eqQOe2/q1KmKSqVSbty4ody6dUspUqSI0qlTpwTzkl5fkVRy+5sF6Orq0rNnT3x8fACIiooC4nqK/Pz8cHFxUc+NWbVqFe3btyc4OJhZs2bRoEEDJk2axMCBAylVqhTnz5/PEXdO/31qKF++fERHR5M3b150dXWxtLSkffv21KpVi4IFC6p7Md6/12ry5MmUL1+eOnXqMHnyZPUcjxMnTjB79mwiIiK+/AllQnPnzkVRFHbu3Mm0adMYMWIE7u7uPH78GIB169YRGRnJ0KFD1b0m2Z1KpSIsLAxFUfjhhx+IjIxkwIABTJkyReM1NmPGjKF69eo4ODjg7OzMmDFjMDIywsnJiQsXLqifhjx79iyQM+cbRUZGUqRIERo3boyjo6O69w3g2bNnrFq1ij59+uDs7MySJUsICwvj119/BeDUqVOsWLGC/fv3A2j0+grxSRncKBOpMGrUKMXCwkKpXLmyUqZMGY070Z9++kmxs7NTFi5cqChK3J3md999p9SvX1959+5dRhX5i3t/5z5nzhzFwMBA6devnzJjxgylSpUqipWVlbp3IygoSKlTp47y/fffq9OuWrVKmTt3rhIQEKDs2bNHGTlypGJnZ6fcv38/Q84lM7l06ZJStWpVZfz48eqwgIAAxcvLS7l165Zy8uRJpXr16srgwYMzsJRf3q+//qqoVCqlUqVKiomJibJjx454c40CAgKU0qVLq+e27d+/XylbtqxiZ2enuLi4qP8Gnz17pqhUKmX+/PnKvXv3MuR8MoP33+H3vT3R0dHK5MmTFWNjY+XVq1fK0aNHFUtLS2Xu3LmKoijK5s2bFRMTE6V27dqKlZWVUq1aNeXmzZsZVn6RtUijKAtbv369oq2trTRq1EgJCAhQh/v4+Cg1atRQChYsqJiamqonEkdERCj58+dXjh07llFFzlDnz59XBg0apPTr108xMjJSOnTooLH/4MGDiouLizJ58mQlLCxMCQ0NVZ4/f668fv1aqVy5sqJSqZQuXbpkUOkzj4SGNf47vBMeHq707NlTqVWrlnLt2rV4+7O7/fv3K2vXrlWf+8eioqKU6tWrK99++606LDIyUlmyZIl6OFxRFGXgwIGKSqVSGjdurLi7uyulS5dWHj58+EXOITO7cOGCYmxsrCxYsEB59+6d0qZNG6VMmTLq/V27dlU6duyohIeHK+Hh4co333yj1KlTR/nnn38ysNQiq5BGURb34sUL9Zf9/Xj78ePHlbx58yqXLl1STp48qZQrV05xcnJSFixYoOTOnTvRi3VO8ejRI6Vhw4bK4cOHFUWJq6/g4GBFURTlt99+U6pUqaLs2LFDHd/f31/p0qWLUrBgQcXY2FgpU6aMeh5IThQWFqYMGTJEmT9/vqIoH+7k3///qlWrlMqVKyszZszIsDJmditWrFDc3d3jrZP1fnX2s2fPKtra2srw4cMVb29v5Z9//lGmT5+ufpIyJ1u9erXi4OCgxMbGKuvXr1fMzc2VQ4cOKYoS14v0yy+/KAYGBup5lM+ePVP27NmjvH79OiOLLbIIaRRlQ9u2bVNy586tvHr1SlGUuB6iBQsWKNbW1krFihWVx48fZ3AJM49//vlHadasmbJ582Z1WO/evRUXFxf10gfv7+C3b9+uKIqijBkzRjlw4ECGlDcz+W9j6H1P0KNHj5TWrVsrzZs3V168eKEoSs7qJUqqyMhIpW/fvoqBgYHSrVs3ZeXKlYqPj496f61atZS6detq/JBHR0fnmAnrnxMaGqoEBgYqRYoUUerVq6coStx17r0JEyYoLVu2VHx9fePtE+JTZKJ1NuTh4UHp0qVZv349ELcwZP/+/bl69Sq//PILdnZ2GVzCzMPS0hIXFxe+++47hg8fjq+vL7du3cLJyQlFUbh06RI7d+7E2dmZFi1aADBlyhTq1q2bwSXPeO8n7KtUKvVE4A0bNvD8+XM6depE3rx55Y3mCVAUBV1dXRYvXoyPjw+KonDt2jXevXsHwKZNmzh58iRTpkzB1NRUnU5bWzvB147kREZGRpibmzN79mxWrFgBwC+//MKePXsA6N69O3p6evTr14/g4GD09PQysrgiK8ngRplIY+/v3ufOnauYmJgoffv2VS5cuKCcOXMmg0uWuZ06dUqpUKGCUqFCBcXDw0P9OgEvLy+lePHi6mEOuVNP3JMnTxQ3NzfF0tIyR08MToqYmBiNHrT3w7dv375VbGxslP79+2dU0bKk169fK61atVKaNWum/tvbvHmzUqJECfUrVoRICpWiyJsws6srV64wZMgQXrx4gYeHBxMmTNBYZE7E9+DBA/Lnz4+WlhbPnz+nSZMmuLm5sWTJElkILgmuXr1K586defLkCcOGDeP777/X6O0Qmj7uSTtz5gxfffUVx48fp2DBghlYsqzn1atX9O3bl3379tGqVSvOnj2Lra0ta9euxcHBIaOLJ7IIaRTlAFeuXMHCwgJ7e/uMLkqW8urVK8qVK8cvv/xC06ZNZSgoGVavXs3QoUMxNjZm2bJleHh4ZHSRsoz3q6uLlDl58iTbtm2jRIkSlC9fntKlS8sNjUgyaRQJkYiIiAhGjBjBkiVLmDlzJgMGDMjoImU5o0ePJjw8nDlz5kiDMgmy42t4hMhKpFEkxGfs2bOHc+fO0b9/fywtLTO6OFlOVFQUurq6crcuhMj0pFEkhBBCCAFIf7YQQgghBNIoEkIIIYQApFEkhBBCCAFIo0gIIYQQApBGkRBCCCEEII2ibC8iIoIJEyYQERGR0UXJkqT+Uk7qLuWk7lJH6k+klDySn82FhIRgampKcHAwJiYmGV2cLEfqL+Wk7lJO6i51pP5ESklPkRBCCCEE0igSQgghhABAJ6MLkNXFxsby7NkzjI2NM+UrDEJCQjT+XySP1F/KSd2lnNRd6mTm+lMUhTdv3mBnZ5eu7wN89+4dkZGRaZKXnp4eBgYGaZJXZidzilLpn3/+wcHBIaOLIYQQIgt58uQJ+fLlS5e83717R648JhAelSb52djY8ODBgxzRMJKeolQyNjYGwOtgZwyM9DK4NFlPd4eqGV0EkVMZy8t9U2rl9e0ZXYQs611YJKM9/qf+7UgPkZGRcQ2izmVATzuVmcXg/7+LREZGSqNIfN77ITMDIz1y5ZZGUXKZmBhmdBFETmVslNElyLLkWpd6X2S6hYEOKr3U/cwrWplvWkh6kkaREEIIkQ2ptFSoUtuo0VKRk+bYyNNnQgghhBBIT5EQQgiRLalUadBTpMpZPUXSKBJCCCGyobQaPstJZPhMCCGEEALpKRJCCCGyJZVKlfqn3DLhosTpSRpFQgghRDYkw2fJJ8NnQgghhBBIT5EQQgiRLUlPUfJJoyiTuOPzjAOrLvH4xguCX4TTd24DytRx+mSa2z7P+GPGaZ7dC8LM0pD63ctQo10J9f5ZPXZwx8cvXjrX6o70/6Vxko+76oe/OLPztkaYU0krRq5rndLTTReKojBx6haWrzpM0OswKrkVZuHM7pQonvi76ZavOszajSe4ev0fAMqXcWLKj+2pWL6wOs7xUzeYOX83vhfv4+f/mq3rhtCyaQWNfLp/t5jV649rhFVyK4z34UkaYd7nbvPDT79z1vceurralCmZn71/jCJXroxfIVjqL+UWLdrBzJmb8PN7RYkSBZgz53uqVy+VaPxjxy4xdOhirl17iJ1dXoYPb0/fvs004mzZcpzx41dy754fhQrZMnnyt7RqVU29//jxy8yc+Tu+vnfw83vF1q0TadmymkYeiqIwceIali/fQ1DQGypVKs7ChQMpUaJAmp5/Ssl1L31Joyj5MqxRdPToUWrXrk1QUBBmZmZpkueECRPYvn07Fy9eTJP8vqSIt9HkK5aHKi2LsXTIgc/Gf/lPCAu/30u1NsXp7lWXexf82TDlBLnNc1HOoyAAfec0IDoqVp0m7PU7JrfdTLn6BZN93BJVHegyqbb6s45u5ht5nT53F3N+2cvKRX0pWtiWKTO2Ub/lz9z0mY2xca4E0xw7eYMObapQZXpRDAx0mT5vFw1aeXH1zAzs7SwACAuPoJSrI92+rslX38xJ9PgN65VmxaK+6s96uppfL+9zt2nUZiqjBrdg/oxu6OnpcOnKY7QyyUVH6i9lfv/9CIMHL+KXXwZStaorS5fupnHj0Vy7tgJHR+t48R888KNJkzH07NmYtWtHc+rUVfr1m4+lpSlt2tQAwNv7Gh06TOKnn7rTqlU1tm07Sfv2P3HixDwqVSoOQFjYW0qVKkS3bg356qsJCZZt+vSNzJnzBytXjqBo0XxMmfI/6tcfwc2bqzA2zvhX7Mh1L31Joyj5slVP0bBhwxgwYEBGFyNFXKs74lrdMcnxj2++joVtbtqNjHuhqm1Bcx5df8HB1ZfUFwcjU82X9/n8eRc9Ax3KexRK9nF19LQxzZvxF9HEKIrCvMV/MmZoS1o3rwjAqiXfYVOkL+s3n6JPj3oJpvvfr/01Pi+f35stO85x+NhVunSM+4Fq5FGGRh5lPlsGfX1dbKzNEt0/ZPRaBvRpyKghLdRhRQrZfjbfL0HqL+XmzPmDHj0a0bNnEwDmzu3HgQM+LF68Cy+vnvHiL1myC0dHK+bO7QdA8eL58fG5zaxZm9SNonnztuLhUZ7RozsBMHp0J44fv8y8eVtYv/4HABo1qkSjRpUSLZeiKMybt5UxYzrRunV1AFatGomNzVesX3+YPn2aJZr2S5Hrnshsslaz9zNy585Nnjx5MroYX8T9S88p7p5PI8yligOPrr8gJiomwTSntt3ErWFh9A11k3282z7PGF5zFeObbWDthKOEvHqbonKnlwcPA/B//pr6dUqqw/T1dalZtTje525/IqWm8PAIoqKisTDPnewyHD15HetCfShWbjC9Biwj4EWwel/Ai2DO+tzFytKEqh7jsSnch1qNJ3LS+2ayj5MepP5SJjIyCl/f29Sv76YR7uFRHm/vawmmOXPmOh4e5TXCGjSogI/PbaKiogHw9r6Oh4dmnvXru3H6dMJ5JuTBAz/8/QM1yqavr0fNmqUTLVtmJ9e95HnfU5TaLSdJl0bRw4cPUalUbNy4kSpVqmBgYECJEiU4evRoomlevXpFx44dyZcvH4aGhpQsWZINGzao969Zs4Y8efIQERGhka5NmzZ06dIFiBs+K1OmjHpft27daNmyJTNnzsTW1pY8efLQr18/oqKi1HH8/Pxo0qQJuXLlwsnJifXr11OgQAHmzp2bYDkjIiIICQnR2DJCyKtwTPJo3sGY5MlFbHQsoa/fxYv/4Mpznt0NpGpr52Qfy7WaIz286uL5a3O+GurOo2svmNtzJ1GRCV+EMoJ/QNwPqLWVqUa4laUp/s+DE0qSoFETNmBva0G9Wq7JOn7DemX43/J+HN71AzOndMbnwn3qNptMRETc39r9hwEATPTaQs+udfhzyyjKlnaiXvMp3LkXf/7Dlyb1lzIvXwYTExOLtbW5Rri1tTn+/oEJpvH3D0wwfnR0DC9fBn8yjr9/UJLL9j7ux/lYWSUvn8xErnvJI42i5EvXnqLhw4czdOhQLly4QJUqVWjevDmvXr1KMO67d+8oX748u3fv5urVq/Tu3ZtvvvmGs2fPAtC2bVtiYmLYuXOnOs3Lly/ZvXs33bt3T7QMR44c4d69exw5coTVq1ezatUqVq1apd7fpUsXnj17xtGjR9myZQvLli0jICAg0fy8vLwwNTVVbw4OiU9CTW8fr6mlKErCO4DT225iV9gCp5Lx5zh8jlvDwpSskR/7IhaUqlWAAYsa8/xRMFePP0pJsdPEuk0nMbbrpt7e32F/vFCZoihJXnts+tydbPzjNFv+NxgDg+RN3G3fxp0mDcrh6uJAs0bl2fvHSG7f9WPP/gsAxMbG/dv07l6X7p1rUba0E3O8ulCsiC0r1h5N1rHSgtRf2or/XYxfl5rx49fzx+Gp+bf43LFSvaBfBsrJ1z2R/tJ1TlH//v1p06YNAIsXL2bfvn389ttvjBgxIl5ce3t7hg0bpv48YMAA9u3bx+bNm6lUqRK5cuWiU6dOrFy5krZt2wKwbt068uXLR61atRItg7m5OQsXLkRbWxtnZ2eaNGnC4cOH6dWrFzdv3uTQoUP8/fffuLnFdTH/+uuvFClSJNH8Ro8ezZAhQ9SfQ0JCMqRhZJLHkOCX4RphbwLfoaWjRW5TfY3wyLdR/L3vHs2+1+yOTylTSyMs7HIT8DjpPQhprXmj8lT6zxNOEZFxPQr+z19ja/PhzvjFy5B4vR8JmTl/N16zd3Bw+xhKueZPdflsbczJ72DJnXv+cZ//nSvj4myvEa94UXue/JPwjUJ6kvpLG3nzmqKtrRWv5yUgICheD817NjYW8XqRAgJeo6OjTZ48Jp+Mk1ieCR8nLq6/fyC2th+mFbx48RrrT8zdysxy+nUvuWSidfKla0+Ru7u7+r91dHRwc3Pjxo0bCcaNiYlhypQplCpVijx58pA7d24OHDjA48eP1XF69erFgQMHePr0KQArV66kW7dun7zrKVGiBNra2urPtra26p6gW7duoaOjQ7ly5dT7CxcujLl54hcefX19TExMNLaMULC0NTfOPNUIu3H6CfldLNHW1dYI9zlwj+jIGCo1LZomxw59/Y4g/7AMnYBobJyLwoVs1JuLcz5srM04eOSKOk5kZDTHTt3AveKnz3vGvF1MnrGVP7eMwq1coU/GTapXgW948vQVtjZmABTIb4mdrTm37mgO9dy+64ejQ940OWZySP2lDT09XcqXL8rBg74a4YcO+eLuXiLBNJUru3DokGb8Awd8cHMriu6/T9y5u8ePc/CgD1WqJJxnQpycbLGxsdAoW2RkFMeOXUq0bJldTr/uJZcKlfpVHyneyFmNoi/+9FliDZhZs2YxZ84c5s6dS8mSJTEyMsLT05PIyEh1nLJly1K6dGnWrFlDgwYNuHLlCrt27frk8XR1NSfXqVQqYmPjHtdUd7t+JLHw9PQuPIoX/7kDefk0hCc3X2Jkqo+FrTHb5p3l9fMwuv9cB4AabV04uuEqm2ecplqb4ty/9JxT227y7bT4Twmd3nqTMnUKkNvMIN6+zx33XXgUuxf5UM7DCZO8hrx69oYd88+R28yAMnU/vZ7Il6RSqRj0XSO8Zu+gSCFbihSywWvWdgxz6dGpbVV1vK59FmFna47XhI5A3JDP+CmbWfdrfwo4WuL//DUAuY0MyJ07rr5CQ99x976/Oo8Hj15w8fJDLMxz4+iQl9DQd0zw+oM2LSpia23Ow8cvGPvTRvLmMabVv+vxqFQqhg1sygSvPyjtmp8yJfOzesNxbt55xuY1g79QLSVO6i/lBg/+ii5dpuLmVhR3dxeWLdvD48cB6nWHRo/+lWfPXrJ69SgA+vZtxi+/7GDIkEX06tUEb+/rrFjxJ+vXj1XnOXBga2rW9GTatA20aFGVHTtOcejQeU6cmKeOExr6lrt3PzQQHjzw5+LFu1hYGOPoaB33bzqoNV5e6ylSJB9Fitjj5bUeQ0MDOnWq+4Vq59Pkuicym3RtFJ05c4YaNeIeMY2OjsbX15f+/fsnGPfEiRO0aNGCzp07AxAbG8udO3coXry4RryePXsyZ84cnj59Sr169VI1dOXs7Ex0dDQXLlygfPm4p0Hu3r3L69evU5xnSj26FsCcbz808P6Y4Q1A5eZF6Ta5DsEvwgj0f6PenzefCf0XNWbz9NMc23gVU0sj2o+qqn4s9b3nD19z94I/A5c2SdFxtbRUPLv7irO7bhH+JhJTS0OKVrCj5wwPDIwyfsHB/xrh2Yy37yLpN3TFv4sPFmL/tjEaa+w8/uelxro2i387SGRkNG27zNXIa/yoNkwY/RUAPhfuU6fph0UEh45ZC0DXTjVYufg7tLW1uHr9CWs3nuB1cBi2NubUru7CxpWDNI7t+X1j3r2LYsiYNQQGhVHa1ZED28dQqGDy5zukB6m/lGnfvjavXoUwadJa/PwCcXUtwJ49XuTPH1cuf/9XPH78YZ6ik5Mte/b8zJAhi1i0aCd2dnmYN6+/+nF8gCpVSrBhww+MG7eS8eNXUaiQHRs3jlOvUQTg43OLOnWGqj8PHboYgK5d67Ny5UgARozowNu3kfTrN0+9eOP+/dMyxRpFINe99CbDZ8mnUtKhW+Thw4c4OTnh6OjI3LlzKV68OHPmzGH9+vU8ePCAvHnzxlu8cfDgwWzZsoWNGzdibm7O7Nmz2bRpE7Vr12b79u3qvENCQrC1tSU6Opo1a9bQvn179b6PF2/s1q0br1+/1kjv6enJxYsX1U/CeXh4EBgYyOLFi9HV1WXo0KGcOXMGLy8vBg0a9NlzDQkJwdTUlDmne5Ard9b5smQWvfPXzOgiiJzK2CqjS5BlLbu6OaOLkGW9DY1kcJUVBAcHp9v0i/e/SyY/1EFlkLq+D+VdNCGT/0rX8mYm6TqnaOrUqUybNo3SpUtz4sQJduzYQd68CY//jxs3jnLlytGgQQNq1aqFjY0NLVu2jBfPxMSENm3akDt37gT3J9eaNWuwtramRo0atGrVil69emFsbIyBQfwuVyGEEEJkX+k6fFa8eHHOnDmT4L5atWppzN2xsLDQ6NH5FD8/P77++mv09TWfNpgwYQITJkxQf/7vo/fvfbz+kK2tLXv37lV//ueffwgICKBw4cIIIYQQWZUMnyVflnrNR2BgIAcOHOCvv/5i4cKFaZLnX3/9RWhoKCVLlsTPz48RI0ZQoEAB9VwoIYQQIiuSRlHyJblR9H6eUFIYGRmluECfUq5cOYKCgpg2bRrFihVLkzyjoqIYM2YM9+/fx9jYmCpVqrBu3bp4T60JIYQQWYlKizRoFKVNWbKKJDeKdHV1k9wQKVq0qMbK02nl4cOHaZ5ngwYNaNCgQZrnK4QQQoisJcmNInt7e27ezBwvrxRCCCHEZ6TB8JmSw4bPcljHmBBCCJEzfOkXwnp5eVGhQgWMjY2xsrKiZcuW3Lp1Kx3PMO1Jo0gIIYQQqXbs2DH69evHmTNnOHjwINHR0dSvX5+wsLCMLlqSZamnz4QQQgiRNGnx9Fly0u/bt0/j88qVK7GyssLX1zfLPNEtjSIhhBAiG3r/UtfU5gFxq2T/l76+fry1Aj8WHBz3fjkLC4tUleFLkuEzIYQQQnySg4MDpqam6s3Ly+uT8RVFYciQIVSrVg1XV9cvVMrUk56iNHIzKAq9yJw1Sz8taC2am9FFEDlU1C8/ZXQRsqxrgVEZXYQsKzLsy9WdSpUGw2f/9hQ9efJE491nn+sl6t+/P5cvX+bkyZOpOv6XJo0iIYQQIhtKyzlFJiYmSX4h7IABA9i5cyfHjx8nX758qTr+lyaNIiGEECIb+tITrRVFYcCAAWzbto2jR48m+S0YmYk0ioQQQgiRav369WP9+vXs2LEDY2Nj/P39ATA1NSVXrlwZXLqkkUaREEIIkQ1pacVtqcsk6VEXL14MQK1atTTCV65cSbdu3VJZkC9DGkVCCCFENqStUqGVRo/kJ4WiKKk6VmYgj+QLIYQQQiA9RUIIIUS2pK2lQusLTrTODqRRJIQQQmRDX3r4LDuQ4TMhhBBCCKSnSAghhMiWtLRA+ws+fZYdSKMok3h6yY/zG6/w4vYrwl6F03hSXQpVL5Bo/GeX/Tm97G+CHgcT9S4aY+vcuDZ3pmzbD++YiYmOxXfdJW7sv0PYi3DMHE2p2rsC+St9WGH0yo4bXNlxgxD/UADyFDCjQteyFKjkoI4THviWU0v/5onPUyJCI7ArZUPNQe6Y5TNN+4pIgVENutC6TC2cbfLzNiqC0/euMHL7L9x+/jhJ6asULMWxIYu4+uw+ZX/uog7vWbUFXSo3wtWuIAC+j28xZvti/n50XR0nt74hk5r3plXpmlgZm3PhyW0GbZ6Dz6Mb6jjK4jMJHnf41gXMPLguJaecZqTu0sbixbuYPXMzfn6BuJTIz+zZfalWvWSi8Y8fu8ywYUu5fu0RdnZ5GDqsLX36Nk0w7u8bj9L5ay+aN3dny7YJGvuePn3J6FG/sX/f37x9G0mRovYsWz6E8uWLAKCr3SDBPKdO68nQYW1TdrJpSK576UtbpUI7tcNfOWz4LMc3imrVqkWZMmWYO3cuAOHh4XzzzTccPHiQN2/eEBQUhJmZWbqXI+pdNHkLWVC8UVH+HH/4s/F1c+lQqpULeQpaoGugw7Mrzzky+xS6Bjq4NnMG4MxvPtw6eI86w6ph7mjK47+fsmfcIdr+0hTLInkByG1pRJXeFTC1j1u+/eb+O+wZe4gOy1uSx8kcRVHY88NBtHS0aDKlHnqGulzYfJXtQ//k61Vt0M2lm36VkkQ1i5Tll2Nb+PvRdXS0tJnSoi8HBszD5aeOhEe++2RaEwMj1nQbz+FbPlgba77JuVbRcmz4+yCn71/mXVQkI+p35sDAeZT4qRPPgl8A8GvnMbjaFeSbVRN5FvySzhUbcmjQAlwmdlTHsRnZWCPfRiXc+a3zWLZcOJKGtZAyUnept+n3owwdvIQFC/tTpWoJli/bQ9MmP3D56nIcHa3ixX/wwJ9mTX/g256NWL1mJKdPXWNA/4VYWprSuk11jbiPHj1n5IjlVKse/4WaQUFvqFl9CDVrlWLXnslYWZlx/54fZmZG6jhPnm7QSLPvz7/p3WsOrVpXS6OzTx257onMJod1jH3e6tWrOXHiBKdPn8bPzw9T0y9zV1CgkgPuPd0oXKNAkuJbFslL0bqFyONkjomtMc71C+NYwZ5nl/3VcW4duIfb16UpUNkBUzsTSrYojmMFey78flUdx6mKIwUqO2DuYIq5gynuPd3QzaWD//UAAF7/E4L/9RfUGlwVa2dLzB3NqOVZhai30dw+fD9N6yClGi0czOoze7ju94DLT+/Sfc1k8uexpbyj82fTLv16FOv/PoD3/avx9nVe+SOLj2/h0j93uPX8Eb3+54WWSou6zm4AGOjq06ZsLUZsW8iJuxe59+IfJu75lQcvn/FdzdbqfJ6HBGpsLUrV4MhtXx68fJZmdZBSUnepN3fuVrr3aMC3PRtRvLgjs+d8h4ODJUuX7E4w/rKlu3F0tGL2nO8oXtyRb3s2olv3+syevUUjXkxMDF2+mcb4H7/Byck2Xj4zpm8in0NeflsxjIoVnSlQwIY6dctSqJCdOo6NjYXGtmunN7Vql6Zgwfj5ZQS57qWv9z1Fqd1yEmkUfeTevXsUL14cV1dXbGxssszM+xd3XuJ/NQD70h8udjFRMWjraWvE09GPu7tKSGxMLLcP3yPqXTS2JazUeQDo/CcfLW0ttHS0Es0no5nmyg1AYHjIJ+N1c29Cobz2TNzzW5LyNdQzQFdbm8CwuHx1tLTR0dbhXVSkRry3URFUK1Q6wTysjC1oUrIqv53elaRjfmlSd8kTGRnFed87eHiU1wiv51Eeb+/rCaY5c+YG9T6KX7++G74+t4mKilaHTZ60Dsu8pvT4tmGC+ezedYby5YvSod1k7Gza4Vb+e35dvjfRsj5/HsTevefo3j3hIbWsSK57n6atpUqTLSfJ0o2i06dPU6ZMGQwMDHBzc2P79u2oVCouXryojnPs2DEqVqyIvr4+tra2jBo1iujo6ATzq1WrFrNmzeL48eOoVKp4S5VnRiu+2sAvHiv5vc9OSrYqTommxdT7HCvYc3HzVV7/E4wSq/DY5ykPTj0iLDBcI4+X9wNZ0nA1izxWcWT2aZpMqodFAXMAzB3NMLbOzenlPrx7E0FMVAw+6y4RHviW8I/yySxmfzWIE3cvcu1Z4nd0hS0dmNqyH1+v/JGY2Jgk5Tu11fc8ff2CQzf/BiA0IpzT9y4zrnEPbE3zoqXS4uuKDalUoAS2pnkSzKNr5ca8eRfG1gtHk31eX4LUXfK8fBlCTEwsVtZmGuHW1mY89w9KMM1z/yCsP4pvZW1GdHQML18GA3Dq1DVWrtjPkmWeiR77/n0/li7ZTeEiduz582d6927CYM/FrF1zMMH4a9ccxNg4V6YZOksNue4ljTagrUrlltEn8YVl2TlFb968oVmzZjRu3Jj169fz6NEjPD09NeI8ffqUxo0b061bN9asWcPNmzfp1asXBgYGTJgwIV6eW7duZdSoUVy9epWtW7eip6cXL05ERAQRERHqzyEhn76jTm9tFjQl6m0U/tcD8F7mg5m9CUXrFgKgxoDKHJ5xkv91ieuWN7U3oXijotz487ZGHuYOpnT4tRURoRHcO/6Qg17HaTOvMRYFzNHW0aLxT3U5PP0Ey5v9D5WWCofydhqTFjOThR2GUcq+MNVm9k40jpZKi/U9JvLj7uXcCXiSpHyHe3Smo5sHteb0IyL6Q+/GN6smsuKbsTybupvomGjOP7nF+r8PUM6xWIL59KjSlHXnDmjkkVlI3aXcxz3KiqJ8cn5q/Pgfwt+8Cadbl2ksWepJ3ryJD9/HxiqUdyvC5Ck9AChbtjDXrz9i6dI9fNPFI178VSv307FTHQwM4l/Xshq57on0kmUbRevWrUOlUrF8+XIMDAxwcXHh6dOn9OrVSx1n0aJFODg4sHDhQlQqFc7Ozjx79oyRI0cyfvx4tD56U56FhQWGhobo6elhY2OT4HG9vLyYOHFiup5bcpjaGgOQt6AFbwPfcnbVBfXFIZdZLppO8SA6Ipp3IREY5TXk9LK/Mfk3zXvautqY5YubcGjtbMnzmy+5uOUadYbG3VFaFctLx99aEREaSWx0DLnMcrHpu51YFcv7Bc/08+a3G0rzktWpMbsvT1+/SDSesYEhFQq4UNahKAvbDwXifuy1tLSIWniS+gsGceSWrzr+0HqdGNOwK/XmDeDK07saed1/+ZRac77HUM8AEwMj/ENesfHbyQnOealWuDTONgVo/+sPaXTGaUfqLmXy5jVBW1srXq9QQEAwVtbmCaaxtjHH/6P4LwJeo6OjTZ48Jly79oiHD5/TssV49f7Y2LhWk4FeI67d+I1CheywtbWgePH8Gvk4OzuwbevJeMc8eeIKt279w7oNY1J0npmNXPeSJk2Gv3LY8FmWbRTdunWLUqVKYWBgoA6rWLGiRpwbN27g7u6ucVdWtWpVQkND+eeff3B0dEz2cUePHs2QIUPUn0NCQnBwcPhEii9HAWIi4w9n6OjrkNtSh5joWO4de0jh2gU/m1NMZGy8UP3ccXeYr/8JJuDWSyr3KJcGpU4bC9oPpVWZmtSa3Y+Hr/w+GTfkXRiukzpphH1fow11ipXnq+VjNH6Uh3l8zQ+NutNgwSB8H99MNM/wyHeER77DzNCYBi6VGLFtYbw431Zpjs+jG1z+qHGQ0aTuUk5PT5dy5Ytw6NB5Wraqqg4/fOg8zZq7J5imcuXi7Nl9ViPs4EFfyrsVRVdXB2dnBy5cWqqx/8dxq3gT+lY9iRugShUXbt/W7K27c+cpjvnjP/G2YsV+ypUvQunShVJ0nplZTr7ufY5WGkyUVrLIvNq0kmUbRXHd0/G7rJMaJ6UTqPX19dHX109R2k+JDI8i+OmHobgQ/1Be3HmFgYl+3Nj2sr8JfRlO/TE1Abi87TrG1rkxd4zrXn925TkXfr9CqVYu6jz8rwcQ+jIcy8IWhL4M59yq8ygKlO/wYf2U08t9yF8pH8aWRkS+jeLOX/d5etGf5tM/TMa8c/QBuUwNMLY24tX9II4vOEPBavlxrJA5upJ/6TCcThXq02LJCN5EhGFtEvd4ePDbMN5FxQ11/tziO+zNLOm6+icURYk3ZybgTRDvoiI1wod7dGZSs950WvkjD1/5qfMNjXhLWMRbAOoXr4RKpeLW80cUtnRgRuv+3Hr+mJWnNZ88MjYwpG25OgzdMj/d6iElpO5Sz9OzNd26zqB8+aJUdi/Or8v38vhxAL37NAFg7JgVPH36klWrRwDQu09TFv2yk2FDl/Jtz0ac8b7ByhX7+d+6UQAYGOjh6lpA4ximZnET4P8bPtCzNTWqDWaq1wa+aluDv8/d4tfle1m8xFMjbUhIGFv+OM70GYkPi2YUue6JzCbLNoqcnZ1Zt24dERER6kaKj4+PRhwXFxe2bNmi0Tg6ffo0xsbG2Nvbf/Eyf0rArZdsG/zhyZGTv8TdSTo3KILH6BqEvXpL6PNQ9X5FUTi97G9C/EPR0lZhamdCld4V1Gt1QNzd05nffAl59gbdXDrkr+yAx5ia6Bt/aNS9DXrLwSnHCAsMR99IjzwFLWg+vQGObh/qJ/xVOCd/OUt40FuM8uTCuX4RKnQpk461kTzf12wDwLEhizXCu62exOozewCwNc2Lo0XCQ6KfyldfV48tvb00wifs/pWJe34F4p7W8mr5HfnMrAgMD2HLhSOM3bGE6I8mIHdw80ClUrHh7wPJKkN6k7pLvXbta/Eq8A1TJq/Dzy+QEq752bV7MvnzWwPg5xfIkycfhiSdnGzYtXsyQ4cuZfGiXdjZWTBn7nfx1ij6nAoVivHHlvGMHbuSyZPW4eRkw6zZfen0dR2NeL9vPIaiQIeOtVN/smlMrnvpKy2Gz5QcNnymUj7uXskiQkJCcHJyomnTpowaNYrHjx/j6enJzZs3uXjxIqVLl+bp06cULVqU7t27079/f27dukXPnj3p16+feqL1x4s3enp6cvHiRY4ePZrkcpiamtJnzzfoGWX9CYxf2oKN8de4EeJLiPrlp4wuQpY15MSmjC5ClhUZFsnSJmsJDg7GxMQkXY7x/nep6qqv0DFM3UKT0eFRnOr2R7qWNzPJso/km5iYsGvXLi5evEiZMmUYO3Ys48fHTUx8P8/I3t6evXv3cu7cOUqXLk3fvn359ttv+eGHzDVZUwghhBAZL8sOnwFUqVKFS5cuqT+vW7cOXV1djQnUNWvW5Ny5c4nm8XGP0PseIyGEECIrk+Gz5MvSjaI1a9ZQsGBB7O3tuXTpEiNHjqRdu3bkypUro4smhBBCZKi0eE1HTnv6LFMNnz18+BCVSpWkzdXVFX9/fzp37kzx4sUZPHgwbdu2ZdmyZRl9GkIIIYTIgjJVT5Guri7FiiW8mu3HChYsyIgRIxgxYkQ6l0oIIYTIeuJe1ZHanqI0KkwWkakaRfb29ty8mfgib0IIIYRIGi0t0E7leFBsphpPSn+ZqlEkhBBCiLSRFnOKYmVOkRBCCCFEziM9RUIIIUQ2lBaP5MfKI/lCCCGEyOpk+Cz5ZPhMCCGEEALpKUoz06q2xcTEKKOLkeXMqxye0UUQOVTM56OIRMyr0Smji5BlhYSEsZS1X+RY2vL0WbJJo0gIIYTIhrRJg+EzZPhMCCGEECLHkZ4iIYQQIhvSSoOnz2Lk6TMhhBBCZHVp8fRZatNnNTJ8JoQQQgiB9BQJIYQQ2VJaPH2W2vRZjTSKhBBCiGxIhs+STxpFQgghRDakrYrbUptHTpLDOsaEEEIIIRImPUVCCCFENqSlUqGVyuGv1KbPaqRRJIQQQmRDWmkwfJbDlimS4bPMZtGiHRQs+DW5cjXEza0vJ05c/mT8Y8cu4ebWl1y5GlKoUGeWLNkVL86WLccpUaI7BgYNKVGiO9u2ndTY7+W1nooVv8fEpCnW1m1o1Woct249iZfPjRuPaNHiB8zMmmNi0hR39/48fvw8dSechhRFYcKk9dg7dcXQrA21PUZz7fqjT6a5dv0RX3X4Gaei36Jl0Iy5C3YkGG/R0j0ULPYtuUxb4+buyYmT1zT2P38eRPeec7B36oqReRsaNfuRO3efacS5d8+P1u2mYJXva0wt29H+66k8fx6UupNOQ1J/Kbd48S6KFOpCbsOmVKzQj5Mnrnwy/vFjl6lYoR+5DZtStHBXli7ZnWjc3zceRVe7AW1aTdAI/2niWnS1G2hs+ew6aMT5eP/7bdbMzSk+17Qm1zyRmUijKBP5/fcjDB68iDFjOnH+/FKqVStJ48ajE/0SPnjgR5MmY6hWrSTnzy9l9OiODBq0kC1bjqvjeHtfo0OHSXTu7MHFi8vo3NmD9u1/4uzZG+o4x49f5vvvm+PtvZADB6YTHR1DgwYjCAt7q45z794zqlcfRLFiDhw5MouLF5fxww+dMTDQS78KSabps7YwZ/52Fszpw7lTs7GxMad+k/G8eZP4S2fDwyNwcrLBa3JXbGzME4zz++YTDB72K2NGtuP82XlUq1qCxi0m8PhxABDXmGjVbgr3Hzxn++axnD87D0dHSzwa/UBY2DsAwsLe0aDpeFQqFYf3TeHkkelERkbTvM0kYmNj074yUkDqL2U2/X6UoYOXMGp0R/72XUS1aq40bfKD+vw+9uCBP82a/kC1aq787buIkaM6MNhzMVu3nIgX99Gj54wcsZxq1V0TzKtEifw8ebpBvV24tERj/3/3PXm6geW/DkGlUtGqdbXUn3gakGte+tJSpc2Wk6gURVEyuhBZWUhICKamprx+vRMTE6NU5VW5cj/Kli3C4sWe6jAXl+60aFEVL6+e8eKPHLmMXbu8uX59pTqsb985XL58j9OnFwLQocMkQkLC2Lt3qjpOo0ajMDfPzfr1PyRYjhcvXmNt3YajR+dQo0YpADp2nISurg5r1oxO1TnGE5n4D25yKIqCvVNXBvVvzshhXwEQERGFjeM3TJ3clT69Gn02D6ei3zJoQHM8B7TQCK9cfShlyxRi8YLv1WEupb+jRbPKeE3uyu07T3Eu2Zcr5xdSwiU/ADExMVg7xB27Z48GHDh4nsYtJhLovwETE0MAgoJCyWPbkQN7JlGvbpk0qYeUyon1F6ObNj9uVdwHUrZsYX5ZNFAdVrJET5q3qMKUn3vEiz961K/s3nWGK9d+VYd9/908Ll9+wMlTcz+ULyaGOrWH07VrfU6evErw61C2bJug3v/TxLXs2HEa3/OLk1zWNq0m8Cb0LQcOTkveSX5EW5U2My9y4jUvJCQMM7PmBAcHY2JikqZ5fzhG3O9S/z+7oG+Uur/ziLBIFjZak67lzUykpyiTiIyMwtf3NvXru2mEe3iUx9v7WoJpzpy5jodHeY2wBg0q4ONzm6ioaAC8va/j4aGZZ/36bpw+nXCeAMHBYQBYWBgDEBsby549ZylSJB8NG47E2roNlSv3Y/v2k4nm8aU9ePAcf/8g6tcrqw7T19elZnVXvM/cTHG+kZFR+J6/q5EvgEe9snifibvzjIiIAsBA/8PFR1tbGz09HU6dvh4XJzIalSquTO8ZGOiipaXFyX/jZCSpv5SJjIzivO+deN/Deh7l8fZOuFxnztyg3kfx69d3w/c/31uAyZPWYZnXlB7fNkz0+HfvPMUxX0eKFOrC1x1/5v59v0TjPn8exN695+jevUFSTi3dyTVPZEbSKEqmiIgIQkJCNLa08PJlMDExsVhbaw5BWFub4+8fmGAaf//ABONHR8fw8mXwJ+P4+yc8F0NRFIYOXUy1aq64ujoBEBDwmtDQt0ybtpEGDSqwf/80WrasRps2Ezh27FKKzjet+f87t8Taykwj3MrKTL0vJV6+DIn7d/koX2srM/yfvwbAuVg+8jtaMWb8aoKCQomMjGLqjM34+wfh9289V65YDCMjA0aOXUV4+DvCwt4xfPRKYmNj8Uvk3/dLkvpLmffnZ2VtphFubW3G80S+Y8/9g7D+KL6VtZnG9/bUqWusXLGfJcs8Ez12xYrOrFw1nD1//sySpZ74Pw+iRrXBvHqV8DVp7ZqDGBvnyjRDZ3LNS39aWqo02XISaRQlk5eXF6ampurNwcEhTfP/+OlHRQHVJx6J/Hjf+9HQ/4YnFCexLPv3n8/ly/c1upnfz9lo0aIKgwd/RZkyhRk1qiNNm1Zm6dL4kxy/hHUbjmKcp616e3+XmPC5pv5L/ak61NXV4Y+No7l95xl5bDtiZP4Vx45fpVGD8mj/u0a+paUpm9aNZPeecxjnaYeZVXtCgsMoV7aQOs6XJPWXtpLzHUs4/ofwN2/C6dZlGkuWepI3r2mieTRsVIHWbapTsqQTdeuVY+euSQCsWXMwwfirVu6nY6c6mW5OjFzz0s/7xRtTu+Uk8kh+Mo0ePZohQ4aoP4eEhKRJwyhvXlO0tbXi3c0EBATFu+t5z8bGIt4dVUDAa3R0tMmTx+STcRLKc8CABeza5c2xY3PIl89So2w6OtoUL55fI76zsyOnTl1N+kmmoeZNK1KpYlH15/dDMP7Pg7C1tVCHv3gRHK+XIjny5jWJ+3f5qLck4KN8y5crzIVz8wkODiMyMhpLS1MqVx9K+XKF1XHqe5Tj7o3lvHwZjI6ONmZmubHN/w1OBWxSXL6UkvpLG+/P7+NeoYCAYKwS+d5a28TvtXjxn+/ttWuPePjwOS1bjFfvj42N++E30GvEtRu/UaiQXbx8jYwMcHUtwN07T+PtO3niCrdu/cO6DWOSfY7pRa55IjPK+FusLEZfXx8TExONLS3o6elSvnxRDh701Qg/dMgXd/cSCaapXNmFQ4c04x844IObW1F0dePau+7u8eMcPOhDlSof8lQUhf7957Nt2wkOH56Jk5NtvLJVqFCM27c1H1m9c+cf8ue3Tt6JphFjY0MKF7JTby7FHbGxMefg4YvqOJGRURw7cRX3ys4pPo6eni7lyxXm4OELGuGHDl/EvXLxePFNTY2wtDTlzt1n+PjepUXTSvHi5M1riplZbv46comAgGCaN62Y4vKllNRf2tDT06Vc+SIcOnReI/zwofO4u7skmKZy5eIc/ij+wYO+lP/3e+vs7MCFS0vxOb9YvTVrVplatUvjc34xDg6WCeYbERHJzZtPNBq1761YsZ9y5YtQunShFJ5p2pNrXvqTp8+ST3qKMpHBg7+iS5epuLkVxd3dhWXL9vD4cQB9+zYDYPToX3n27CWrV48CoG/fZvzyyw6GDFlEr15N8Pa+zooVf7J+/Vh1ngMHtqZmTU+mTdtAixZV2bHjFIcOnefEiXnqOP36zWfDhsNs3z4JY2ND9V2WqakRuXLpAzBsWHs6dJhE9eqlqF27DPv2/c2uXd4cOTL7S1XPJ6lUKgb1b47X9M0UKWxHkcJ2eE3bhKGhPp061FTH69pjNnZ2efCa3BWI++G/fiPuwhcZFc3TZ6+4eOk+uXMbUPjfu/HBA1vSpcds3MoVwb2yM8t+28fjJy/o+58nsjZvOYllXlMcHSy5cu0hnkOX07J5Jep7lFPHWbn6EMWd82GZ1xTvszfxHLYcz4EtKFY035eook+S+ks5T8/WdOs6g/Lli1LZvTi/Lt/L48cB9O7TBICxY1bw9OlLVq0eAUDvPk1Z9MtOhg1dyrc9G3HG+wYrV+znf+vivtcGBnq4uhbQOIapWW4AjfARw5fRtGllHBytCAh4jdeU9YSEhPNNFw+NtCEhYWz54zjTZ/ROpxpIObnmpS9591nySaMoE2nfvjavXoUwadJa/PwCcXUtwJ49Xuo7E3//Vxprnzg52bJnz88MGbKIRYt2YmeXh3nz+tOmTQ11nCpVSrBhww+MG7eS8eNXUaiQHRs3jqNSpQ936UuW7ASgdu0Pw4IAK1YMp1u3uCdfWrWqxuLFnkyduoFBgxZSrJgDf/wxgWrVSqZbfSTXiKFtePs2kn6DFhMUFEqlCkXZv/snjI0N1XEeP3mhMXHw2bNAylUapP48a842Zs3ZRs3qrhw56AVA+7bVeRUYwqSfN+LnH4hrifzs2f4j+fNbqdP5+QcydMRvPA94ja2NOd98XYdxY9prlO/WnX8YM341gYGhFMhvxZiR7Rg8UPPx9Ywk9Zcy7drX4lXgG6ZMXoefXyAlXPOza/dk9ffWzy+QJ09eqOM7Odmwa/dkhg5dyuJFu7Czs2DO3O9o3aZ6so779J+XdP7ai5cvQ7C0NKVSJWdOnp4bryfj943HUBTo0LF26k82jck1L33Jaz6ST9Yp+siqVavo3r07Sa2WtFynKEdKo3WKhEiutFqnKCdKq3WKcqIvuU7RqMPd0mSdoql1V+WYdYrkL/sjDx8+pGbNmp+PKIQQQmRiWqTBu8/SpCRZhzSKPrJ//37mzZv3+YhCCCFEJpYWE6VlonUO5+3tndFFEEIIIUQGkEaREEIIkQ1pq1Rop3KidGrTZzXSKBJCCCGyIRk+S76cNodKCCGEECJB0lMkhBBCZEOyeGPySaNICCGEyIa0tOK21OaRk+Sw0xVCCCGESJj0FAkhhBDZkDx9lnzSKBJCCCGyIVUaPH2Ww9pE0ihKK8qBrSiG8i6l5DrW82hGF0HkULUuDs3oImRZio9vRhchy1LCI7/YsWSidfLJnCIhhBBCCKSnSAghhMiWZPHG5JNGkRBCCJENyUTr5JPhMyGEEEKkiePHj9OsWTPs7OxQqVRs3749o4uULNIoEkIIIbKh98Nnqd2SIywsjNKlS7Nw4cL0Oal0JsNnQgghRDaUEU+fNWrUiEaNGqXuoBlIGkVCCCGE+KSQkBCNz/r6+ujr62dQadKPDJ8JIYQQ2ZCWSpUmG4CDgwOmpqbqzcvLK4PPLn1IT5EQQgiRDWmlwfDZ+zlFT548wcTERB2eHXuJQBpFQgghhPgMExMTjUZRdiWNokxGURR+Wu/L8v03CQqNoFJRKxZ8V5US+S0STRMVHcvUzRdYc/g2T1+FU8zeFK/ulWhY3kEj3uI915i59TJ+geGUcDRndi93qrvaqvd3n3OUNYdva6SpVMyK07Naqj/XGbWLY1f9NOK0q16QDSPrpeKsU0+lo4PTSE/y1K1BrvwORIeEEnTiNPemzCLyeUCi6QyLFsZpxECMS5Ugl0M+7oz/mX+Wr9aIU/ncYXI55IuX9p+V67gz5icAdPPmodAPw7CoWQ0dU2Nen/HhzthJvH3w6EMZ9XQpPH4kVq2aom2gT9CJM9wePYEIv+dpVAspJ/WXOoqiMHHmbpb/7wRBweFUKuvEQq+OlHC2SzTN1j3n8Zr3J3cfviAqKoYiBa0Y0teDb9pWVseZMGMXP83arZHO2tIEvysz1J+fvwhh1KStHDh2ndch4dSoXIT5UzpQpKB1guVs0mkB+45cY+vK72jZqEzqTz6V5JqXfv47/JWaPHISaRRlMjO2XGLO9iusGFyLonamTPn9PA3G7eXGknYYJ/JutXFr/2bdkTssHVADZwcz9p//hzZTDnByRgvKFsoLwO/H7zF4uTcLv6tGVRdrlv15gyYT/uTqonY4WuVW59WgvAMrPGuqP+vpxJ921rOBMxM7u6k/59LL+D8jrVwGGJd04eGcxYRev4muqQmFfxpDydWL8W3YJtF02rly8e7RP7zYtY/CE0cnGMe30VeotLTVn42ci1Bm0ype7NqnDiu58heU6GiudPue6NBQHPp0o8ymlZyt0YTYt28BKPLTWPJ41OZ638FEBb2m8I+jKLlmKT4NWkNsbBrVRMpI/aXO9IX7mbP0ECvndaVoQWumzN1L/fZzuXnqJ4xzGySYxsLMiDGejXEubIOeng67D16mh+dqrPIa06B2CXW8EsXsOLjZU/1ZW+vDd1JRFFp1W4SurjbbV32PibEBs5cewqPtXK4dn4CRkeYQx9xlh1Flsh85uealn4xoFIWGhnL37l315wcPHnDx4kUsLCxwdHRMVVm+hBw90frhw4eoVCouXryY0UUB4i5w83ZcYUz7srSu4oRrAQtWDalNeEQ064/dTTTd/47cYXS7sjSu4EhBGxO+a+xC/XL5mL3tsjrO3O2X6eFRjJ4NnCnuYM6c3lVwyJubJXuva+Slr6uFjbmherMwjn9BN9TX0YhjapTxL8KNeRPKpQ49eLHrT97ee0DI+UvcGTsZk9Ku6NvbJpruzaUr3Js0nYAde4mNTPhFjVGvgoh88VK95fGoTfiDR7z2PgdAroIFMHUry62RE3hz6Qpv7z3g9qiJaBsaYt2qCQDaxrmx7diGexOnEnTCm9CrN7jefzi5ixfFokaVtK+QZJL6SzlFUZi3/DBjBjWidZNyuBa3Z9X8boS/jWT91nOJpqtVtRitGpeleFFbChWwZFCvupRysefkOc3vuo6OFjZWpurNMq+xet+d+wGc8X3AoqlfU6FsAYoVtmHR1E6EhkewYfvfGvlcuvaEOUsP8dvcLmlbAakg17z0pUUaTLQmeY0iHx8fypYtS9myZQEYMmQIZcuWZfz48elximkuRzeKMpsHz9/gH/QWj7Ifhhr0dbWp4WqL943EhwgiomLQ19PWCMulp8Op6/4AREbF4Hv3pUa+AB5l8+F9UzPfY1f8sPl6Dc69f6f3/OMEvH4b73jrj97FqtNqSn6/meG/neHNF3zrc3LomORGiY0lOjjk85GTSKWri3Wb5vhv3KIO09KLu0DGRkR8iBgbS2xUFKYVywNgXMoVLT09Ao+dUkeJfB5A2M07mLiVTbPypSWpv6R58Pgl/gEh1K/log7T19elpntRvP++l6Q8FEXh8Ikb3Lr7nBqVi2jsu3M/APvSIyhYYQwd+yzn/qMX6n0RkdEAGBjoqsO0tbXQ09Xm1NkPjYrw8Eg69f2NBT93wMbKNEXnmR7kmpf91KpVC0VR4m2rVq3K6KIlSdboA8wh/IPCAbA2y6URbm2Wi0cBoYmmq18uH3O3X6FGCVsK2Zpw+NJTdp59SEyMAsDLkHfExCpYm3+Ur3ku/M+Hqz83LO/AV9UKkt8yNw+ev+HH//lQb8xu/p7XGn3duAtQx1qFcbIxxsbMkKuPAhm75m8uPXjFgclN0qQO0oqWvh4Fxw7j+bbdxISGpVm+eRvWQ8fEGL/ft6nDwu/e5+2Tfyg0Zii3RownJvwtDn26oW9thb61JQB6VnmJjYiM18CIfPkSPau8aVa+tCL1l3T+AXFlsrbUnIRqZWnM438CP5k2OOQt+cqMJCIyCm1tLX7x6oRHzQ+Nq0rlnFi9oDtFC1nz/EUIU+bspWrT6Vw99iN5LHLjXNiG/PnyMGbKNpbM+BojQ31mLz2Ef0AIfgHB6nwG/7gJ9woFadGwTNqdeBqQa176iuvtSV3fh8wpyoHu37/P4MGDOXv2LEWKFGHJkiW4u7snGDciIoKI/9zRfrygVXKsO3KH7345of6868eGAPHG/BUFPvV3Obd3FXovOI7Ld5tQAYVsTehWrxirDt3SiKfi43wVjXzb1yik/m/XAha4FbHEqcd69vz9mNZVnADo1bC4Rpwi9qZU9NzG+bsvKVf4y/04WbduRtHpE9WfL3/di+CzvkDcpGGXJXNQaam4PWpCmh7XrlMbAv86rjH5WImO5mrPgTjPmkL1m38TGx1N0AlvXh0+loQcVaCkaRGTROov5dZtOUvf4evUn3f/r39cSZL5vQUwzq3PhcM/EBoWweETNxk6YTMF8+elVtViADSq66qOW7K4Pe7lC1K48g+s3uTNkL4e6Opq88dvfeg5ZA15nIegra1FvRrONKrzId3O/Zc4cvIW5w+NTe2pp5pc874smWidfNIoAsaOHcvMmTMpUqQIY8eOpWPHjty9excdnfjV4+XlxcSJExPIJfmaV8pPpWJW6s8RUTFA3N2TrYWhOjwg+G28O6n/sjTNxbYfGvAuMppXIRHY5TFk9KpzOFnH3bnmNTFAW0ulvitT5/v6HdZmhgllCYCthSH5LXNz91lwonHKFcqLro4Wd54Ff9ELxMv9fxFy/pL6c4R/XJe4SkeHEsvmksshHxfadk3TXg79fHaYV6/C1W8HxNsXevkaPh4t0TbOjZaeLlGvgii/ZxMhl64CEBnwEi19PXRMTTR6O/Ty5iHY50KalTGppP5SrnmD0lQq56T+HBERN4TlHxCMrfWHoakXL99gnffTjzBraWlR2CnuGlDG1YEbd/yYumCfulH0MSMjfUoWt+fO/Q+NyvKl83Ph8DiCQ94SGRmNZV5jKjfyonzp/AD8dfIm9x6+wLzoYI28vvp2CdUrFeHItqHJOPvUkWueyOxkThEwbNgwmjRpQtGiRZk4cSKPHj3SmD3/X6NHjyY4OFi9PXnyJMXHNTbUo7CdqXpzcTTHxjwXhy78o44TGRXD8at+uBeP/3jtxwz0dLDPa0R0jMLW0w9oXinuoqinq035wnk5dPGpRvxDF//B3TnxfF+FvOPJyzBszBO/iFx7FERUdKzGBe1LiAkL4+3Dx+ot9l3Ehx90p/xcbN+N6KDXaXpM2/atiXz5ileHjiZerjehRL0KIpdTfoxLu/Jy/2EA3ly+SmxkJOY1qqrj6llZYuRchJAMaBRJ/aWccW4DCjtZqTeXYrbYWJlw8NgNdZzIyGiOed/GvUKhT+QUn6J8aGQlJCIiiht3/DQaX++ZmuTCMq8xd+4/x+fSI/VQ2agBDbn01zguHPpBvQHM/qkdK+Z2TVb5UkuueV9WWq5onVNITxFQqlQp9X/b2sY9aRMQEICzs3O8uOn5vheVSsWgFiXx2nyRwnamFLEzxWvzBQz1dehUs7A6XtdZR7DPY8TP3SoCcPZWAE9fhVGmYB6evgzjp/W+xMYqDG9TWp3Gs2Upus4+QvnCeXEvbs3yfTd4/CKUPo3juoZD30Yxcb0vras4YWthyMPnb/hhzd/kNTGglXsBAO75hbD+6B0auTmS18SA64+DGP7bGcoWykPVJFzA0pNKW5sSy+djXNKFy136oNLSRs8y7i4u6nUwSlQUAMXnTyPC/zn3f54dl05XF6OicT9cWrp66NtYk7uEMzFh4bx9+Pg/B1Bh26E1/pu2o8TExDu+ZdOGRL0K5N3TZ+QuXozCk8bwYt8hgv6dGBzzJhS/DVso/ONIooOCiHodTOHxIwm9cZvA46fTs2qSROov5VQqFYN61cVr/p8UKWhFEScrvOb/iWEuPTq1rqiO17X/SuxszfAa2woAr/l/4lY6P4UKWBIZGcPew1dYu9mbRdO+VqcZNuEPmtUvhaO9BQGv3jBlzh5C3ryja7sPw/ubd/pimSc3jvksuHLjKZ4/bKJlozLqid/vn1r7mKO9BU75M7anQ6556UuGz5JPGkWAru6HJzfej23HZtC6J8PblOZtRDT9F58kKDSSSsWs2PdTY431Op68CEVL68Mf6rvIaMav/Zv7/m/InUuHRuUdWT20Nma5PzTe2tcoROCbd0zeeB6/wHBc81uwe0Ij8lvFPd6rraXiysNA1v51m9dhkdiaG1KrlB0bRtZVH1tPR4u/Lj1j/s6rhL6NwsEyN43dHBnfqRza2hnb6ahva4Nlw7oAVDy8U2PfhdbfqB//1re3RfnPv62+tRUVDu1Qf3b8/lscv/+WoNNnudjmw6PL5jWqYJDPHr//PDX1X3rWlhSeMAo9yzxEBrzAf/MOHs5ZpBHn7o8/o0RHU2LpXLRyGRB0wpsbnqMyfI0dkPpLrRH9G/D2XRT9Rq1XL964f+MgjTWKHj8N1PjehoVH0G/UBv7xCyKXgS7OhW1Yu7AH7VtWUMd56hdEp+9+5WVgKJZ5jKlc3gnvPSPJ75BHHccvIJihEzbz/EUItlamfNOuMuMGZ/5JwO/JNU9kJipFUTJgmmfm8PDhQ5ycnLhw4QJlypQB4PXr15ibm3PkyBFq1ar12TxCQkIwNTUlaFM3TBJZaEwk7ljPoxldBJFD1br45ebSZDeKj29GFyHLCgmPxLzdKoKDg9PttRnvf5c2Xx6AoXHqRjbC30TQttSCdC1vZiI9RUIIIUQ2pEqD4bPMtgJ6epP+PyGEEEIIcnhPUYECBfh49NDMzCxemBBCCJHVyETr5MvRjSIhhBAiu9JSaaXBitY5a0Ap253t+5e8JmVzdXX9fIZCCCFEFiTrFMUtr6OllfSmTrbrKdLV1aVYsYRXg/1YwYIF07k0QgghhMhIyZksnu0aRfb29ty8eTOjiyGEEEJkKJlTFCc584SzXaNICCGEEDmjUbR69epP7g8OTvw9dgmRRpEQQgghsqTBgwd/cn9ynyaXRpEQQgiRDeWEp88CAwM/uf/FixdYWyf9PXXSKBJCCCGyIS1UaJHK4bNUps9o0lOUQVT1W6MyMcroYmQ5tZ62zegiiJwqk98BZ2aqxoU/H0kkSBUSBqzK6GJkKzt27GDGjBncuHEDgOLFizN06FBatWoFJO/pM7kqCCGEENlQTlinaOnSpbRv3x5XV1fmzZvH3LlzKVmyJB06dGDx4sXkypWLrl27Jjk/6SkSQgghsqG4F8Kmru8js78QdubMmcybN48+ffqow7755hvKlCnDjBkz+O6771ixYkWS85OeIiGEEEJkSU+ePKFu3brxwuvWrcuTJ0+SnZ80ioQQQohsKCcMnzk5ObFz58544bt27UrRWytk+EwIIYTIhnLC4o3jxo2jW7dunD17lipVqqBSqTh16hRbt25l5cqVyc5PGkVCCCFENpQT1inq1KkTDg4OzJgxg4ULF6IoCsWLF+fQoUPUrFkz2flJo0gIIYQQWVb16tWpXr16muQljSIhhBAiG8oJw2dpTRpFQgghRDaUE1a01tbWTvKq1bGxsZ+NI40iIYQQQmRJ27ZtU//3zp07OXDgAHPmzEFXVzdF+UmjSAghhMiGtEiD4bNM3lPUvHlzIO5VHxs2bMDe3p7t27ezdu3aFOWXuaeVp5NatWrh6ekJQIECBZg7d26Glue/FEVhwoTV2Nu3w9CwEbVrD+HatYefTbdly3FKlOiOgUFDSpTozrZtJzX2Hz9+mebNx2Jv3w4trbps334yXh5bt56gYcORWFq2QkurLhcv3o0Xp0+f2RQu3BlDw0ZYWbWmZctx3Lz5OMXnm5YURWHCxDXY52uPoVETatcZmsS6O0EJ128xyNWYEq7fxqs7r6kbqFipHyamzbG2aUurVj9y65bmomDdu09HS9tDY3OvMkAjzr17z2jdegJW1l9hataC9u0n8fx5UGpPO81I/aVcRn5v/6tPn9loadVl7twtGuHLlu2mdu0hmJo2Q0urLq9fhyb7HNOLXPPSz/unz1K7ZXZbtmyhY8eOLF++nDNnznD+/HkGDRqUorwy/9mmg61btzJp0qSMLkaCpk/fyJw5f7BgwQDOnVuEjY059euP4M2b8ETTeHtfo0OHSXTu7MHFi8vo3NmD9u1/4uzZG+o4YWFvKVWqEAsWDEg0n7Cwd1SpUgIvr56JxilfvigrVozg+vWV7Ns3FUVRaNBgJDExMSk74TQ0fcbvzJmzhQXz+3Pu7EJsrC2o32DkZ+ruOh06TqZz53pcvLCEzp3r0b7DZI26O37sMt9/1xzv0/M5sH8q0dExNGg4irCwtxp5NWxQgWdPf1dve3ZPUe8LC3tLg4ajUKng8KEZnDwxl8jIaJq3GJekce4vQeov5TLye/ve9u0nOXfuJnZ2eeLtCw+PoEGDCowe3SllJ5iO5JonUmPz5s106dKFlStX0qlTJywsLDh06BA7d+7kp59+SnZ+KiWpM5SyqQIFCuDp6anuOUqukJAQTE1Nef16JyYmRqkqi6Io2Nu3Y9Cg1owc2RGAiIhIbGy+YurUXvTp0yzBdB06TCIkJIy9e6eqwxo1GoW5eW7Wr/8hXnwtrbps3TqRli2rJZjfw4f+FCz4NefPL6VMmU+/Dfvy5XuUKdObO3fWUqiQXVJP9QMlbX7QFEXBPl8HBg1qxcgRHYB/6862HVO9etKnT9ME03XoMJmQkHD27v1ZHdao0eh/625sgmlevHiNtU1bjh6ZRY0apYC4no7Xr8PYtm1igmkOHPChcZOxBL7aqv47CQp6Q568rTmwfxr16pVL8bmnhRxZf2l0B5wZvrdPn76gcuX+7Ns3jaZNxzBoUBs8PdvEi3f06EXq1BlKYOAOzMxyp/SU00xmqDv4ste8kJAwzMyaExwcjImJSbLTJ+0Ycb9Lvo8mkdvEIFV5hYa8o3z+cela3tQwMjJizZo1tGmj+fd+//59qlatip+fX7Lyy5E9Rf8dPvvYypUrMTU15eDBg1+2UMCDB374+wdSv76bOkxfX4+aNUvj7X0t0XTe3tfx8HDTCKtf343TpxNPkxbCwt6ycuV+nJxscXCwTNdjfc6DB/5xdefxUd3VKIW39/VE03mfuY5H/fIaYfUbuHH6E2mCg8MAsLAw1gg/euwS1jZtKebcjV69ZxMQ8GFoJyIiCpUK9PU/TP4zMNBDS0uLk6euJu0k05HUX8pl9Pc2NjaWLl2mMmxYO0qUKJCstBkto+suuTLTNS8pVCqtNNkys3Xr1sVrEAEULFiQ/fv3Jzu/zH22X9jMmTMZNmwY+/fvx8PD44sf398/7kfA2tpcI9zKyly9L+F0gfHSWFt/Ok1qLFq0A2PjJhgbN2X//r85cGA6enopm+mfVvz9AwGwtjbTCLeyNlfvSzhdENZWH9XdJ+pbURSGDl1CtWquuLo6qcMbNqzI/9aO5vCh6cyc0Qcfn1vUrTeCiIhIACpXLo6RkQEjR/1KePg7wsLeMnzEMmJjY/HzS7x8X4rUX8pl9Pd22rSN6OhoM3Bg62Slywwyuu6SKjNe80Scli1bcuXKFTp37oyLiwuurq507dqVK1euUKpUqWTnJ42if40ePZrZs2dz9OhRKleunGi8iIgIQkJCNLaUWrfu0L9ftLgtKioaANVHTwsoihIv7GMJp0lx0T7p66/rcv78Uo4enUORIva0b/8T795Fps/BErFu3WGMTZqpt9TVnebnT9Vd/wELuHzlAevXjdEIb9++Fk2aVMLV1YlmzdzZu+dnbt/+hz17zgJgaWnGpt/HsXv3GYxNmmNm3pKQ4DDKlSuCtvaX/xpK/aVcZvre+vreZv78raxcOeKzx8oMMlPdJUdmuOalhAqtVP9PlcmbCb6+vri7u/P8+XPq16/PvXv3MDQ0pGrVqpw+fTrZ+ckj+cCsWbMICwvDx8fns2/V9fLyYuLEhOc9JFfz5lWoVKm4+nNERBQQdxdka/thsuSLF6/j3cH/l42NRby7+YCA1/HupNKKqWluTE1zU6RIPipXLo6FRUu2bTtJx4510uV4CWne3J1KlZzVnz/UXZBm3X2mHmxszPH/6AmmgBcJpxkwcCG7dp3h2NFZ5Mv36a5zW9s85M9vxZ27T9Vh9eu7cffOGl6+DEZHRxszs9zY2rXDycnm0yebDqT+Ui4zfW9PnLhCQMBr8ufvqA6LiYll2LAlzJu3hQcP1ic5ry8hM9VdcmSGa15KpMXwV2YfPhs7dizdunVj4cKFPHjwgN9++43Fixfj4uLC6NGjOXbsWLLyy9xn+4VUr16dmJgYNm3a9Nm4o0ePJjg4WL09efLks2kSY2xsSOHC9urNxSU/NjYWHDzoq44TGRnFsWOXcHcvkWg+7u4uHDrkqxF28KAPVaokniYtKYqiHub4UhKtu0Mf1d3xy7i7uySaj3tlFw4d/KjuDvhS5T9pFEWh/4AFbNt2ksOHpuPkZPvZ8r16FcKTJy+wtYn/JFDevKaYmeXmr78uEBDwmubN3JNyymlK6i/lMtP39ptv6nHp0nIuXFim3uzs8jBsWDv27ZuW/JNLZ5mp7lIjI655KRH3mo/UPpKfuXsgvb296dWrF4DGytZNmjTh77//TnZ+0lMEVKxYkQEDBtCgQQO0tbUZPnx4onH19fXR19dPl3KoVCoGDWqNl9d6ihTJR5Ei9nh5rcfQ0IBOneqq43XtOhU7u7zqx0gHDmxNzZqeTJu2gRYtqrJjxykOHTrPiRPz1GlCQ99y9z933Q8e+HPx4l0sLIxxdLQGIDAwhMePA3j27BWAei0ZGxsLbGwsuH//Gb//fpT69d2wtDTl6dOXTJ++kVy59GjcuFK61ElSxdVdK7y8NlCksP2/dbcBQ0N9OnX6cDfXtes07Ozz4vXztwAMHNiKmrWGMG36Rlo0r8KOnac5dPg8J47PUafp138BGzb8xfZtEzE2NlTfoZqaGpErlz6hoW+ZMHENbVpXx9bWgocPnzP2hxXkzWtKq1ZV1fmsXLmP4sUdsbQ0w9v7Op6DF+Hp2ZpixRy+UC0lTuov5TLye5snjyl58phqlEdXVwcbGwuNevH3D8TfP1Cd15Ur9zE2NsTR0QoLi4x7okiueSK1FEXByCj+k98BAQFYWiZ/Mrw0iv7l7u7On3/+ScOGDdHR0WHw4MEZUo4RIzrw9m0k/frNIyjoDZUqFWf//mkYGxuq4zx+HICW1ofWe5UqJdiw4QfGjVvJ+PGrKFTIjo0bx2l0U/v43KJOnaHqz0OHLgaga9f6rFw5EoCdO0/To8cMdZyOHScDMH58FyZM6IqBgR4nT15h3rwtBAWFYm1tTo0apTh1agFWVunTbZ0cI4a3j6u7/gv+rTtn9u+bqll3TxKou/VjGTd+FePHr6ZQIVs2bhirUXdLluwCoHadYRrHW/HbMLp1a4C2thZXrzxg7dpDvH4diq2tBbVrlWbjhrEax751+x/GjF1BYOAbChSwZsyYTgxO4LHpjCL1l3IZ+b1NiiVLdvHTT2vUn2vWjLu+rVgxnG7dGib/hNOQXPPSjyoN5gRl9jlFhQoV4vr16xQuHLeUgqIonDx5Ek9PT1q2bJns/HLkOkW1atWiTJkyzJ07N946RcePH6dx48b8/PPPDBw48LN5peU6RTlSGq1TJESyZfK5EiJ7+pLrFF17Ohtjk1ypyutNyFtK2A/JtOsUTZ06lWfPnjF//nzu379P0aJFAejatSsLFizA0NDwMzloypE9RUePHlX/98OHDzX21ahRg9DQzLMEvhBCCCESNmrUKPV/Ozo6cu3aNZycnNDT00tRfjmyUSSEEEJkdzlh+Oy/dHR0KFasWOrySKOyCCGEECITSYsXumb2F8IWLFiQT80CevDgQbLyk0aREEIIIbKkj1/ZFRUVxZUrV9izZw9DhgxJdn7SKBJCCCGyoZyweGNiD0QtWbIkResUZe6zFUIIIUSKpP4lH3H/y4rq16/P5s2bk50ua56tEEIIIUQiNm/ejLl58teSkuEzIYQQIhvKCcNn5cqV05horSgK/v7+vHz5ksWLFyc7P2kUCSGEENlQTnj67ONVq7W0tLCysqJWrVrqhRyTQxpFQgghRDYUt06RdqrzyMzGjx+fpvll7rMVQgghhPhCpKdIZKxM3jUrhBBZlSoNhs8y+5yitCaNIiGEECIbymmv+UgLOetshRBCCCESIY0iIYQQIht6//RZarfMrHnz5mzfvp2YmJg0yS9zn60QQgghUuT9OkWp3TK7jh07ki9fPkaMGMGtW7dSlVfmP1shhBBCiATs3LmTgIAARo0axaxZsyhZsiTVqlVjxYoVhIeHJzs/aRQJIYQQ2VBOefeZsbExHh4eaGlp8fTpUzp06MDSpUuxtbWlV69eeHt7JzmvzH+2QgghhEi2nDJ89l+Wlpb079+fs2fP4uPjg7GxMdWrV09yenkkXwghhBDZRkxMDPv27WPdunXs3r2b+vXrJzlt1moCCiGEECJJcsLTZx8bMGAAdnZ2DBgwABcXF65fv87evXuTnF56ioQQQohsKCcs3njhwgW2bNnCli1b0NXVJSgoiA0bNlCnTp0U5SeNIiGEECIb0lKpUt3To6VSpVFp0oebmxulS5dmwIABfP3115iamqYqv8zdBEyBWrVq4enpmdHFSDFFUZgwYTX29u0wNGxE7dpDuHbt4WfTbdlynBIlumNg0JASJbqzbdvJeHEWLdpBwYJfkytXQ9zc+nLixOVkHzsiIpIBAxZgadmK3Lmb0KLFD/zzz4vUnHKakbpLHam/lJO6SzmpO5Eavr6+nD9/nu+//16jQfTu3TtWr16d7PyyXaNo69atTJo0KaOLkWLTp29kzpw/WLBgAOfOLcLGxpz69Ufw5k3i6y14e1+jQ4dJdO7swcWLy+jc2YP27X/i7Nkb6ji//36EwYMXMWZMJ86fX0q1aiVp3Hg0jx8/T9axPT0XsX37STZs+IETJ+YSGvqWZs3GptlqoqkhdZc6Un8pJ3WXclJ36ef98Flqt+RatGgRTk5OGBgYUL58eU6cOJEOZxfHxcWFDRs24OXlxcSJE9XbuHHj6N69u/pzUqkURVHSrbQ5QEhICKamprx+vRMTE6NU5aUoCvb27Rg0qDUjR3YE4u5SbGy+YurUXvTp0yzBdB06TCIkJIy9e6eqwxo1GoW5eW7Wr/8BgMqV+1G2bBEWL/ZUx3Fx6U6LFlXx8uqZpGMHB4diZdWGNWtG0b59bQCePXuJo2NH9uz5mQYNKqTq/FND6i51pP5STuou5XJi3YWEhGFm1pzg4GBMTEySnT5px4j7XQp6vSPVv0shIWGYm7VIcnl///13vvnmGxYtWkTVqlVZunQpv/76K9evX8fR0TFVZUlIu3bt2LdvH05OTmhra6vDo6OjuXbtGqVLl0ZRFC5cuJCk/LJdT9F/h88KFCjAzz//TI8ePTA2NsbR0ZFly5ZpxD99+jRlypTBwMAANzc3tm/fjkql4uLFi1+87A8e+OHvH0j9+m7qMH19PWrWLI2397VE03l7X8fDw00jrH59N06fjksTGRmFr+9tjXwBPDzKq/NNyrF9fe8QFRWtEcfOLi+urgXUx8ooUnepI/WXclJ3KSd1l/3Mnj2bb7/9lp49e1K8eHHmzp2Lg4MDixcvTpfjHTp0iBMnTnDp0iXOnz+v3g4fPoyiKJw/fz7JDSLIho2ij82aNQs3NzcuXLjA999/z3fffcfNmzcBePPmDc2aNaNkyZKcP3+eSZMmMXLkyE/mFxERQUhIiMaWVvz9gwCwtjbXCLeyMlfvSzhdYLw01tYf0rx8GUxMTGwicQKTfGx//0D09HQxNzdONJ+MInWXOlJ/KSd1l3JSd+krLRdv/Ph3LyIiIt7xIiMj8fX1jbcuUP369Tl9+nS6nGNwcDD58uWLF64oCqoUTBLP9o2ixo0b8/3331O4cGFGjhxJ3rx5OXr0KADr1q1DpVKxfPlyXFxcaNSoEcOHD/9kfl5eXpiamqo3BweHFJdt3bpDGBs3UW9RUdEA8f4hk/KPm3Caj+PwUZz46VJy7JT+8aWG1F3qSP2lnNRdykndfVkqJW02AAcHB43fPi8vr3jHe/nyJTExMVhbW2uEW1tb4+/vny7nuHLlSoyNjeOFm5qasnLlymTnl+0fyS9VqpT6v1UqFTY2NgQEBABw69YtSpUqhYGBgTpOxYoVP5nf6NGjGTJkiPpzSEhIihtGzZtXoVKl4urPERFRQNzdia1tHnX4ixevsbY2SzQfGxuLeHctAQGv1XdAefOaoq2tFe/OKyAgSB3Hxsb8s8e2sbEgMjKKoKA3GndOAQGvcXcvkdTTThNSd6kj9ZdyUncpJ3WXdT158kRjTpG+vn6icVPS0EypLl26JBj+5s0bfvzxx0T3Jybb9xTp6upqfFapVMTGxgIJ/0N9bt65vr4+JiYmGltKGRsbUriwvXpzccmPjY0FBw/6quNERkZx7NilT34B3d1dOHTIVyPs4EEfqlSJS6Onp0v58kU18gU4dMhXna+Tk+1nj12+fBF0dXU04vj5veLq1YfqY30pUnepI/WXclJ3KSd194UpsWmzQbzfvYQaRXnz5kVbWzter1BAQEC83qO0snv3booVK4a+vj5aWlrqzcrKikePHqk/J1W27yn6FGdnZ9atW0dERIT6H9jHxyfDyqNSqRg0qDVeXuspUiQfRYrY4+W1HkNDAzp1qquO17XrVOzs8uLl1ROAgQNbU7OmJ9OmbaBFi6rs2HGKQ4fOc+LEPHWawYO/okuXqbi5FcXd3YVly/bw+HEAffs2S/KxTU1z06NHI4YNW0KePCZYWBgzfPhSSpZ0ol69cl+wpuKTuksdqb+Uk7pLOam7dPafRk2q8kgiPT09ypcvz8GDB2nVqpU6/ODBg7Ro0SJ15UjE0KFD8fDwoG7duhpPnwUHB9O1a1e2b9+erPxydKOoU6dOjB07lt69ezNq1CgeP37MzJkzgfjdf1/KiBEdePs2kn795hEU9IZKlYqzf/80jI0N1XEePw5AS+tD+apUKcGGDT8wbtxKxo9fRaFCdmzcOE6jm7p9+9q8ehXCpElr8fMLxNW1AHv2eJE/v3Wyjj1nzvfo6GjTvv1PvH0bSd26ZVm5crLGH2NGkbpLHam/lJO6Szmpu+xlyJAhfPPNN7i5ueHu7s6yZct4/Pgxffv2TZfjPXjwgHHjxsXriXo/TaZ58+bJyi/brVNUq1YtypQpw9y5cylQoACenp4aK1yXKVOGli1bMmHCBCDukfz3T6SVLFmSoUOH0qlTJ27evEmxYsU+e7y0XKdICCFE9vYl1ykKfrUlTdYpMs3TJlnlXbRoEdOnT8fPzw9XV1fmzJlDjRo1UlWOxBQsWJDz589jZmamEf7q1SsqVKjA/fv3k5VftmsUpda6devo3r07wcHB5MqV67PxpVEkhBAiqb5oo+jlH5iYGH4+wSfzCsc071fpWt7MJEcPnwGsWbOGggULYm9vz6VLlxg5ciTt2rVLUoNICCGEyLRiY+O21OaRiX3qFR5x77abkKz8cnyjyN/fn/Hjx+Pv74+trS1t27ZlypQpGV0sIYQQQnzGjh07ND6HhYXx6NEjdHV1KVy4sDSKkmvEiBGMGDEio4shhBBCpK0v/PRZRjh//ny8sMDAQDp37kzbtm2TnV+2X6dICCGEyJHScJ2irMTCwgIvLy8mT56c7LTSKBJCCCFEtqKtrc2jR4+Ijo5OVrocP3wmhBBCZEs5YPgsMa6ursluEIE0ioQQQojsKQc8fVanTp1EX8+lKApHjx7l9evXtGrViiNHjnw2P2kUCSGEECJLKlOmzGfj6OrqUrZs2STlJ40iIYQQIjvKAcNns2fP/mwcIyOjJMUDaRQJIYQQ2VMOaBSlNWkUiYyVw75wIhPJ5HMlMjVt+ekQmUPBggUTnVP0sQcPHnw2jvxlCyGEENlRDugp6tGjB7NmzaJq1apUrlwZAG9vb06dOsWwYcOS/b42aRQJIYQQ2ZCixKIoManOIzO7du0aY8eOZdiwYRrhM2bM4OLFi6xbty5Z+cnijUIIIUR29P6R/NRumdiuXbto0aJFvPBWrVqxc+fOZOcnjSIhhBBCZEkmJiYcOHAgXvi+ffuSPXQGMnwmhBBCZFNp8e6yzN1TNGbMGAYPHsypU6c05hT98ccfzJkzJ9n5SaNICCGEyI5ywETr/v374+zszNy5c5k/fz6KolC8eHH27dtH3bp1k52fNIqEEEIIkWXVq1ePevXqpUle0igSQgghsqMc0FP03rt373jx4gWxH00Mz58/f7LykUaREEIIkR3lgEbRzZs36dGjB2fOnNEIV6lUKIoSr5H0OdIoEkIIIUSW9O2336Knp8fevXuxtbVFpVKlKj95JD+TWbRoBwULfk2uXA1xc+vLiROXPxn/2LFLuLn1JVeuhhQq1JklS3Zp7L927SFffTUBJ6dOaGnVZe7cLfHyeL/v461fv3nqOM+fB9K9+zTs7dthZNSYRo1GcefOP2lz0mlEURQmTFyDfb72GBo1oXadoVy79vCz6bZsOUEJ128xyNWYEq7fsm3bSY39XlM3ULFSP0xMm2Nt05ZWrX7k1q0nGnFCQ9/Sf8ACHBw7YmjUBJcSPVi8WPPfok/fuRQu0gVDoyZYWX9Fy5bjuXnzcarPO61I/aWcoihM+Gkt9o4dMTRuRu26w5NWd1tPUKJULwyMmlKiVC+2bT+VaFyvaRvR0m2A55DFicbp8908tHQbMHfeVo3wiIhIBgz6BUubtuQ2bU6LVj/yzz8vknx+6UmueekoB6xTdOnSJRYvXkzDhg0pXbo0pUqV0tiSSxpFmcjvvx9h8OBFjBnTifPnl1KtWkkaNx7N48fPE4z/4IEfTZqMoVq1kpw/v5TRozsyaNBCtmw5ro4THv4OJydbvLx6YmNjkWA+584t4tmzzertwIHpALRtWxOIu+C3ajWe+/f92L79J86fX4qjoxUeHsMJC3ubxrWQctNn/M6cOVtYML8/584uxMbagvoNRvLmTXiiaby9r9Oh42Q6d67HxQtL6Ny5Hu07TObs2RvqOMePXeb775rjfXo+B/ZPJTo6hgYNR2mc++Ahi9m/34e1a0Zx/dpveA5qw8BBC9mx47Q6TvlyRVjx2zCuX/uNfX96oSgKDRqOIiYmdSvOphWpv5SbPnMTc+ZuZcG8fpzzXoCNjTn1G43+fN11+pnOX9flou8iOn9dl/Ydp3D27M14cf/++xbLf91LqZJOiea3fcdpzp27iZ1dnnj7PIcsYfuO02xYN5oTR2cTGvqWZi3GZ3jdyTUvnb0fPkvtlokVK1aMFy/SroGvUpL6JjWRoJCQEExNTXn9eicmJkapyqty5X6ULVuExYs91WEuLt1p0aIqXl4948UfOXIZu3Z5c/36SnVY375zuHz5HqdPL4wX38mpE4MGtcHTs80ny+Hp+Qt79pzh9u01qFQqbt9+grNzN65c+Y0SJQoAEBMTg7V1G6ZO7UXPnk1SdsKQZl84RVGwz9eBQYNaMXJEByDu7tjGth1TvXrSp0/TBNN16DCZkJBw9u79WR3WqNFozM1zs3792ATTvHjxGmubthw9MosaNeLuREqW6kW7djUZ90NndTy3Ct/TqFFFJv3ULcF8Ll++T5myfbhzezWFCtml5LTTTI6svzS6A1YUBXvHTgwa2JKRw9sD/9adfQem/vwtfXon/P3o0GlKXN3tnqIOa9RkDObmxqz/32h1WGjoW8pX7McvC/oz5ecNlC5dkLmzv9PI6+nTl1SuOoh9e6bQtMV4Bg1oieeg1gAEB4dhZduONauG075dLQCePXuFo1Nn9uyaRIP6bsk/6TR6IWxOvOaFhIRhZtac4ODgFC0umLRj/Pu7dGsmJsa5UpfXm7eYFRuWruVNjcOHDzN27FgmTZpE2bJl0dXV1dhvamqarPykpyiTiIyMwtf3NvU/ukB5eJTH2/tagmnOnLmOh0d5jbAGDSrg43ObqKjoFJdj3bpDdO/eUD02GxERBYCBgZ46nra2Nnp6upw6dTVFx0lrDx744+8fSH2PD/Wnr69HzRql8Pa+nmg67zPX8aivWYf1G7hx+hNpgoPDALCwMFaHVa1agl27vHn69CWKonDkyEVu3/4n0R+csLC3rFy1HycnGxwcLJN0julJ6i/l1HVX70M9xNVdyc/U3Q086n1Udx7x667/gIU0blSRenXLJZhPbGwsXbpNZ9iQr9Q/4P/le/4OUVHR1P/PtcLOLg+uJfJ/8t8pvck17wvIAT1F9evX5++//6Zhw4ZYWVlhbm6usSWXTLTOJF6+DCYmJhZra81/RGtrc/z9AxNM4+8fmGD86OgYXr4MxtY2fjf652zfforXr0Pp1q2BOszZ2ZH8+a0ZM+ZXliwZjJGRAbNn/4G/fyB+fgmX7Ut7X0fW1mYa4VbW5jx+lHBXfFy6IKytPqpDK3P8/YMSjK8oCkOHLqFaNVdcXT8MZcyf14/evefg4NgRHR1ttLS0WL5sMNWquWqkX7R4JyNHLics7B3Ozg4c2D8NPT3djw/zxUn9pdyHutOsBysrcx4/DvhEuqB49W1tbaZRdxt/P8r5C3c5d2ZBovlMm7EJHR1tBg5omWj59PR0MTc31giPu7Yk/O/0Jcg17wtQlDR4+ixzDyYdOXIkTfOTRlEyRUREEBERof4cEhKSpvl/PHFeUfjkbPqP970fDU3pDPwVK/6kUaOK2NnlVYfp6urwxx8T6NlzJnnytERbW4t69crTqFHFFB0jLaxbd5i+381Vf969azKQcH18ri7i17kSL+y9/gMWcPnKA04c11w+fv6C7Zw5e4Md238if35rjp+4TL/+C7C1zUO9eh/u8L/uVBePeuXw8wtk1qzNtO8wmZMn5mrckX4JUn8pt279X/T9/sOE3N07JwHJq4f34tf3h3yePAnAc8hi9u/9OdHz8/W9w/wF2/E990uyv/NJKd+XINe8dJQWE6Uz+UTrGjVqpGl+0ihKJi8vLyZOnJjm+ebNa4q2tla8O7eAgKB4d0bv2dhYxLujCgh4jY6ONnnyJH/s99Gj5xw6dJ4tWybE21e+fFEuXFhGcHAokZHRWFqaUblyP8qXL5rs46SF5s3dqVTJWf35fXe3v3+Qxt3ii4DXidYfgI2NOf7PP6rzFwmnGTBwIbt2neHY0Vnky/dhyObt2wjGjl3B1i0TaNKkEgClShXk4sV7zJq1WeNH3dTUCFNTI4oUyUflysWxyNOabdtO0rFjnWTWQOpI/aVc82aVqVSxmPpzonX34nW8XrT/srGJ31MT8J/69j1/l4CA17hV6q/eHxMTy/ETV/hl0U7ehe3mxMkrBAS8Jn/Bzhpxho1YzrwF23lwdw02NhZERkYRFPRGo7coIOA17u4uKayF1JNrnkgLx44d++T+mjVrEh0dzalTp6hZs+Zn85NGUTKNHj2aIUOGqD+HhITg4OCQ6nz19HQpX74oBw/60qpVNXX4oUO+NG9eNcE0lSu7sHu3t0bYgQM+uLkVRVc3+f+0K1fuw8rKjCZNKicax9Q0NwB37vyDj89tfvqpe7KPkxaMjQ0xNjZUf1YUBRsbCw4e8qVs2cJA3FyBY8cvMzWBCZvvuVd24dBBXwb/ZyLmwQO+VPnPj4WiKAwYuJDt209x5K+ZODnZauQRFRVNVFQ0Wlqad6ra2tqfXThMURT1j+qXJPWXconW3eHzH9XdFab+/G2i+bhXLs6hw+cZ7NlaHXbw0Ie6q1unDJcvLNVI06PnLJyLOTBieDu0tbX5pnO9eHONGjYZQ+ev69K9a30g7qk9XV0dDh46T7t/n67y83vF1WuPmDY18X/b9CbXvC8gByzeWKdOnUR7tN8v3hgYGEidOnWS9LSlNIqSSV9fH319/XTJe/Dgr+jSZSpubkVxd3dh2bI9PH4cQN++zQAYPfpXnj17yerVowDo27cZv/yygyFDFtGrVxO8va+zYsWfGk/9REZGcf36o3//O5qnT19y8eJdcufOReHC9up4sbGxrFq1jy5d6qOjox2vbJs3H8PS0hRHRyuuXHmAp+cvtGxZNd4kyYyiUqkYNKgVXl4bKFLYniJF7PHy2oChoT6dOn3oRejadRp29nnx+vfHauDAVtSsNYRp0zfSonkVduw8zaHD5zWGd/r1X8CGDX+xfdtEjI0N1XeqpqZG5Mqlj4mJETVrlmLEyOXkyqVP/vxWHDt2mbVrDzJrZl8A7t/34/dNR6nvUR5LSzOePn3J9Om/kyuXHo0bZ3yXvNRfyqlUKgYNbInX1I1xdVfYHq9p/9Zdx9rqeF27TY+ruyk9ABjYvyU16wxj2ozfadHMnR27vDl0+AInjs4G4hpfrq4FNI5lZGSARR5jdXiePCbxekh0dXWwsTanWLG4mzVTUyN6dG/AsBHLyJPHBAtzY4aPXE5J1wLUq1s2nWolaeSal85yQKMoKOjz8+KsrKySFA+kUZSptG9fm1evQpg0aS1+foG4uhZgzx4v8ue3BsDf/5XGxE0nJ1v27PmZIUMWsWjRTuzs8jBvXn/atPkwxvrs2SvKleuj/jxr1iZmzdpEzZqlOXJktjr80KHzPH4cQI8eDRMsm5/fK4YOXczz50HY2lrwzTf1GTeuc4JxM8qI4e15+zaSfv0XEBT0hkqVnNm/b6rGXf3jJwEaPRJVqpRgw/qxjBu/ivHjV1OokC0bN4ylUqXi6jjvF4erXWeYxvFW/DZMPTlzw/qxjBnzG52/8SIw8A3581szeXJ3+vaNe5TdwECXkyeuMG/eVoKCQrG2NqdG9ZKcOjkPq08MsXxJUn8pN2JYu7i6G7Awru4qOrN/r9dHdfcCLa0PD/xWqVKCDevGMO7HVYz/cU1c3a0fozGsmVbmzOqLjo427TtO4e3bSOrWKcPK3yairR2/MfAlyTVPpFZiywRERUVx+vRp9ZBZUpcTkHWKUikt1ynKkTL5XYjIxjL5BNJMLY3WKcqJvug6RZcmYmJskLq83rzDrPSPmXadIgBvb28ePnxIZGSkOiw4OBhPT09WrFiBSqWia9euScpL/rI/smrVKrp37460FYUQQmRpsUrclto8MrF+/fqxZMkScufOrdHz+X6e0ZAhQ1AURRpFKfXw4cMkzVAXQgghRMbatGkTBw8epE4dzSdQX7x4gbW1NYGByVtXShpFH9m/fz/z5s37fEQhhBAiM1PSYJ2iTD7FITAwkNKlS8cLT8oaawmRRtFHvL29Px9JCCGEyOxywOKNP/74I4aGhvHCc+fOzY//b+/Ow6qo/geOvy8IKKsgwgVcUMANLU3c/YYkorhbLoh7arnvYpgLaoZbKVpa9MutXCoXNG1RS9MUl1yy3ArTcENc2EQFhPn9gV67Agr3XvbP63nmebxzzzlz5oMz98w5Z2ZmzsxzedIoEkIIIUSxNGPGDACioqI4e/YsKpWK2rVr4+7urvkuL6RRJIQQQpREpWCidXx8PIMGDWL79u2UKZPZpElLS6NTp06sWbOG8uXL56k8oxcnEUIIIUSx82T4TN+lCBs3bhxRUVEcPHiQhw8f8vDhQyIjI7l48SJjxozJc3nSUySEEEKURBmKAeYUFe2eou3bt/Ptt9/StOnTV7U0adKE8PBwOnbsmOfypKdICCGEEMVSamoqlpaWWdZbWVmRkpKS5/KkUSSEEEKURE/mFOm7FGHe3t6888473LlzR7Pu7t27BAUF6fTMQRk+E0IIIUqiUnBL/tKlS+nQoQNVqlShRo0aqFQqLly4gIuLC999912ey5NGkaE8SoVHJoVdi+In7WFh10CUVqZZn20iculR6ovTiOxJ7AzKzc2NM2fOsH37ds6ePYuiKNSuXZuuXbvq9MJjaRQJIYQQJVEpuCUfwNjYmG7dutGtWze9y5JGkRBCCFESlYLhszVr1jz3+9y+CPYJaRQJIYQQolgaP3681ue0tDTu379PmTJlMDc3l0aREEIIISg1L4R91uXLl3n77beZOHFinsuTW/KFEEKIEkhRFIMsxY2rqyvz5s1j3Lhxec4rjSIhhBBClCgqlYorV67kOZ8MnwkhhBAlUSmYaL1t2zatz4qicOPGDT766CNatmyZ5/KkUSSEEEKURKWgUfT6669rfVapVDg4ONC6dWsWLVqU5/KkUSSEEEKURKXgOUXp6ekGLU/mFAkhhBBCID1FQgghRMlUCobPDE16iooYRVEImf0lLlX7YG7dBR/fIM6c+feF+TZv+RXPl96irGUnPF96i60RB7W+r+YxACNT/yzLyDEfZ1ve2yOWYmTqz5KlW7XW+/gGZSmjd59Q3XfYgBRFIWTuRlzc3sS8Qi982k3jzNno5+Y5czaa7oHzqVb7LYwsurHko2+zpFnx2Q+83HgcNupAbNSBNPeZwvc/Hs+xzLdHr8hS1uV/YzGy6Jbt8s2WgzmWVZAkfrrLPG6/wKVKb8ytOuHTejJnzlx+Yb7NWw7g+dJQylp0xPOloVmO25DZX2Bk0lZrcaoUoJVmy9Zfadd+KhXVPTAyacupUxezbMen9eQs5fTu875e+2wocs7LRxnK04aRzkvRHj4zNGkUZaNVq1Y6Pd/AEBYs+obFYVtYtmQERw+FoXa0xa/9VJKS7ueYJ/LwOQL6hNK3T2tO/bacvn1a0yswlCNHz2vSHD0UxvXodZpl1/eZJ8Qeb/wvS3kR2w5x9OgFnJ0rZLu9IYPbaZX1yfIxeu61YSz4cCuLl21n2YdDObp/QWbsOoWQlPQgxzz3H6RQzdWR0Nn9UDvaZpumkksFQmf349iBhRw7sBAf73p07TUv2wZDxLdHOHrsL5yd7LTWV65UgesXV2otIdMCsLAoi7/fK/rtuIFI/HS3YNHXLF6yhWVhIzkauQy12hY//+DnH7eRZwkIfD/zuD3++LjtPZcjR85rpfP0rMr1Kxs0y+mTn2h9n5z8kObN6xA6983n1nHIYH+tcj5ZPlb3HTYgOeeJokQaRUWIoiiELYtg6jsBvN6tBXXrurJ65UTu309h/cZ9OeYLWxpBG99XCJ7Si1q1KhM8pRetX6tP2NIITZqKFcujVttplh3fHcHNzQnvV+tplXXt2m1Gj1vOl2uCMDHJ/g3D5uZmWmXZ2FgYYvf1oigKYR/vYOrk7rzepRl1PauyOnwM9x+ksP7r/Tnma9TQg4XvDySgx/8wM8t+NLlT+0a0b9eQGh4u1PBwYW5IXywty3L42F9a6a5dv8PoCZ/x5crxWWJnbGyMWm2rtURsP0LPN1pgaVlO/wDoSeKnO0VRCFsawdTgAF7v1vLxcTsp87jdsDfHfGHLtj4+bgOoVasKwVMCMo/bZdo9FWWMjbWOt4oVy2t936+vLzOm9cW3dYPn1rPIHrdyzss/TyZa67uUItIoKkIuXYohJiYOP9+nV75mZqZ4/68ekZFnc8wXeeQcbXy1r5b92jTk0OFz2aZPTU1j3fq9DBrgh0ql0qzPyMig/6BFTJrQHU/Pqjlub/2GvVR06kXdl99m0pTPnntFV1AuXb5JzM04/FrX16wzMzPBu6UnkYfP55wxj9LT09n4zQGSkx/SrHFNzfqMjAz6D17CpHFd8KxT5YXlHD95kVOnLzF4gK/B6qYPiZ/uMo/bu/j5NtSsMzMzxfvVFxy3h8/R5j95APzaeHHomTx/R13DpUpvqnv0p3ef9/nnnxs61XP9hr1UVPeg7stDmRQUXjSOWznn5S+9h84MMCepmCnWE62nTJnC1q1buXr1Kmq1mj59+jBjxgxMTEwACAkJISIigokTJzJ9+nTi4uLw9/fns88+w8rKCoDk5GSGDx/Oli1bsLKyYtKkSc/dZkpKCikpKZrPiYmJBtufmJtxADg+Mwzh4Fie6OjYnPPFxOHoUF5rnaNDeWJisr4TBiBiWyTx8fcY2L+N1vr5C7+hTBkjxozqkuO2Anv7UM1VjdrRlj/PXGbq9NWcPn1J0zVdWGJuxgPg6Fhea72DQ3mio2/pXf4ff/5L89fe4eHDVCwty7JlwzvUqV1Z8/38D7ZSpowxY0Z0zFV5n6/ZQ+1alWjetJbedTMEiZ/unhxnWY5bB9sXH7fPxNvRsTwxMXGaz00a12LNqsnU8KjEzdg45r6/gRavjufP38OpUME613UM7O1DtWpq1I52mcfttJWcPv0Pu36Yl+sy8oOc80RRU6wbRVZWVqxevRpnZ2f++OMPhg4dipWVFUFBQZo0Fy9eJCIigh07dhAXF0fPnj2ZN28ec+fOBWDy5Mns3buXrVu3olarmTp1KsePH6d+/frZbjM0NJRZs2YZpP7r1v/MsJHLNJ93bMss979XMgCKknXds7LmUXLMs3L1j/i39dIaPz9+4m+WfrSN40eWPXdbQwf7a/5dt64rHh4uNGo6hhMno3ilgftz62hI6zb+wrAxT+dW7Nj8LgDP1vx5cciLmjWcORn5IfEJyWyOiGTg20vZ98N71KldmeMnL7J0+Q6OH/ogV9t68CCFDV/vZ9qUnnrXS1cSP92tW/8zw0aEaT7v2D4HgGernhm755eV/bH+9LN/u0aaf9ejGs2a1sG95kDWrN3NhPFv5LrOQ4e01/y7bl1XPNxdaNR0FCdO/M0rr3jkuhx9yTmvgMndZ3lWrBtF06ZN0/zb1dWViRMn8tVXX2k1ijIyMli9erWmZ6hfv3789NNPzJ07l3v37vH555+zdu1a2rTJvIJYs2YNlSpVynGbwcHBTJgwQfM5MTGRypUr55j+eTp3akqTxk+vdFNS0oDMK0+n/0w0vRUbn+Wq6L/UalvNFdcTsbcSslx9Afz77032/HSKzV9P01p/4Nc/iY2Np6pbf8269PQMJgX9H2HLIrj095pst/1KA3dMTMrw99/XCvQE0blDY5o0qqH5rIndzXjt2N1KwNHBRu/tmZqa4O7mBIDXK+78djyKsOU7+HTZcA4cPEvsrQSq1hyqSZ+ensGk4NWEffwtl86Fa5W1aWsk9++n0j+wld710pXET3eZx+3Tob+nx20cTk5Pf3Rv3YrH0SH7yefw+LiNeea4jY3P9rh9wsKiLPXquvJ31DVdqw/AK688Pm6jrhVoo0jOeQVMMcCcoGL4Qlh9FOtG0aZNm1iyZAlRUVHcu3ePR48eYW2t3aXs6uqqaRABODk5ERub2S178eJFUlNTadasmeZ7Ozs7atasSU7MzMwwMzMzSP2trMyxsjLXfFYUBbXalt0/naTB44MtNTWNXw78wbz3c76zpFmT2uz56QTjx3bTrNu95wTNm9bOknbVmt04ONjQoX1jrfX9+rTG9zXtiZrtOk6jb+BrDBrgl+O2z5z5l7S0R1ontIJgZVUOK6unE2wVRUHtaMvun3+nQf3qwOPY/XqGeXP651SMzhRFIfXxCb1fb298fV7S+r5dl9n07e3NoH6ts+RduXYPnTs0omJF/RsbupL46S7749aO3T+d0D5u9//BvPcH51hOs6aPj9txT19TsHvPcZo3q5NjnpSUVM6dv0LLlnX12oenx232d1vlFznniaKu2DaKDh8+TEBAALNmzaJt27bY2NiwceNGPvjgA610T+YXPaFSqch43B2oFLEWsEqlYuzoroTO/woPd2c83F0Inf8V5uZmBAa00qQbMGgRzs4VCJ07CIAxo7vg/dpk5i/8mi6dmrHt20j2/HSSA/u03/uSkZHB6rW76d/XlzJltO+yqFDBOsscBROTzDt+atbM7Dm7ePE66zbspb1/I+wr2HD23L9MCvo/GtR3o0XznE/kBUGlUjF2ZEdCF23Cw90JDzcnQhduxrycGYE9X9WkGzAkDGdnO0Jn9wMyT8Bnz119/O9HXLt+h1O/X8LSsqymZ2PqzC/x93uFypXsSUp6wMZNB9h34AzfR0wHnhM7R1tq1nDRWh918Qb7fz3Lzi3aV62FTeKnO5VKxdgxXQmdtxEPd5fHx+2GzOO2t48m3YCBC3B2sdfcOj9mVFe8X5vE/IVfPXPcfqjJMykonE4dm1KlsgOxsfHMDV1PYuJ9BvR7Ojfm7t1EoqNvcf3GHQAu/JX5ZvDMu/TsHh+3P9O+XWPs7a05ey6aSUHhNKjvXjSOWznn5R8ZPsuzYtsoOnjwIFWrVuXdd9/VrPv33xc/8Ou/3N3dMTEx4fDhw1SpknnHS1xcHH/99Rfe3t4GrW9uBU3qwYMHqYwc8zFxcfdo0rgmP+6cq3V1FX0lFiOjp2PgzZvVYcOX7zB95lpmhHyBW3UnNq4L1uqmBtjz00mio2N5c2DOV0HPY2pqws97T7H0o23cu/eAypUr0t6/MTOn9cHYOPtbWQtS0IRuPHiYyshx4cTF36NJIw9+3D5Tq0ck+uotrdhdvxHHK82fDod+ELaND8K24f0/T/b+8B4AN2Pj6T9kCTdi4rCxNueluq58HzGdNv+5Uyu3Vq79CRdnO/x88543v0n8dBc0qWfmcTv6I+LikmjSuBY/fhf6zHF7CyOjpzf8Nm/uyYZ1U5k+czUzZq7Fzc2Jjeun0qTJ0+P22rXbBPYN5fbtRCpWtKFpk1pE/rqEqlUdNWm2f3uYN4c8vRh88mDBGdP7EjKjH6amZfj551MsXRbBvXsPqVzZnvb+TZg5vYgct3LOyz/SKMozlVLUuktyadu2bXTv3p0vvviCRo0asXPnTmbNmkV6ejrx8fHA07vPTp06pcm3ZMkSlixZwuXLlwEYPnw43333HStXrsTR0ZF3332Xn3/+mcGDB7NkyZIX1iMxMREbGxvib2/C2rqYPLuiKEl7WNg1EKWVqfmL04jsKaXrh9KQEhOTKW/fnYSEhCzTPQy3jczfpbh1fbE2N9WvrPup2Pb5Ml/qO3fuXHbu3MmpU6cwNTXV/HYXpmL7nKIuXbowfvx4Ro0aRf369Tl06BDTp0/PczkLFy7k1VdfpXPnzvj6+tKyZUsaNmz44oxCCCGE0Flqaio9evRg+PDhhV0VjWLbU1RUSE+RnqSnSBQW6SnSnfQU6axAe4q+CDRMT1G/9fla39WrVzNu3Lgi0VNUbOcUCSGEECJnSrqCkq5fv8eT/M8+qNiQd2IXJUVq+Ozy5cuoVKpcLXXr6ndLqhBCCCFyp3LlytjY2GiW0NDQwq5SvihSPUUmJibPfUbQf1WvXj2fayOEEEIUY4Z4oevj/FeuXNEaPsuplygkJOSFb304duwYXl5e+tUrnxSpRpGLiwvnzxvu5ZNCCCFEqZWuZC76lgFYW1vnak7RqFGjCAgIeG4aV1dX/eqUj4pUo0gIIYQQxZe9vT329vaFXQ2dSaNICCGEKIEURUHRc/gsP29Qj46O5u7du0RHR5Oenq55pqC7uzuWlpb5tt3nkUaREEIIURKlY4DhM4PUJFszZsxgzZqnL95t0CDzXXR79+6lVatW+bfh5yhSd58JIYQQwkDSMwyz5JPVq1dn9mY9sxRWgwikUSSEEEIIAcjwmcEokbtRLEreg6zym6qGR2FXQZRWtpUKuwbFlnJkb2FXodhSklMKblsZBphTpO8t/cWMNIqEEEKIksiAt+SXFjJ8JoQQQgiB9BQJIYQQJZMBn2hdWkijSAghhCiBDPlC2NJChs+EEEIIIZCeIiGEEKJkUjIgQ8/nDCn595yiokgaRUIIIURJJHef5ZkMnwkhhBBCID1FQgghRIkkD2/MO2kUCSGEECWRDJ/lmQyfFTGKojBr9WEq9fgci3Yf89r4zZy5dOeF+cI2naR2/7VYtPuYqr1WMuHj/TxMfaT5fv/v1+g8dTuVenyO8WtLifj1YpYytuyPol1QBA5dwzF+bSmnom5lSRO+409eG7+Z8h1XYPzaUuLvFdwj619EURRCPvgOl4bvYu42AZ/uYZy5cCPX+TduO45RpdF0Gxye5bvla/ZTvdlMyrmNx8t/AQeORGl9H/LBd9T2noOlx0TsPINoE7CMIycua6UJ//IgPt3DsKk1GaNKo4lPuK/TfuYXiZ/uFEUhZO5GXNzexLxCL3zaTePM2ejn5jlzNprugfOpVvstjCy6seSjb7OkWfHZD7zceBw26kBs1IE095nC9z8e10pz82Y8g95aiovbm1jY98K/y2z+jrqu+f7yv7EYWXTLdvlmy0HDBEAPcs7LR08aRfoupYg0ioqYhRuPs3jTSZaO9ubIigAc7cxpGxRB0v3UHPOs23Oe4M8OMX1AE86s7sdnk1rz9b6/mfrZIU2a5IdpvOxWkaWjvXMsJ/lhGi3qOvH+0OY5pnnwMI22jaoSHNhItx3MRwuW72HxZ3tZNqcHR3dOQu1gjV/gRyTde/jCvP9evcvkORH8r4lblu++2n6c8SFbmDq6LSd+mELLxm6077eC6Gt3NWlqVHdg2Xs9OL0nmANbxlO1UgXa9vmYW3eSNGnuP0ylbavaBI9qY5gdNjCJn+4WfLiVxcu2s+zDoRzdvwC1oy1+nUJISnqQY577D1Ko5upI6Ox+qB1ts01TyaUCobP7cezAQo4dWIiPdz269pqnaXApikK3gFD+uXyTiK+DOXHoQ6pUqUibjiEkJ2f+3SpXqsD1iyu1lpBpAVhYlMXf7xXDByOP5JwnipJSP3wWEhJCREQEp06dKuyqoCgKYZtPMbVPI15/1R2A1VPa4PTG/7H+pwu83aletvkOn4mhRV0nAlvXBMBVbU3AazU4dv6mJo1/E1f8m7g+d/v9/GoDcDkmMcc0Y7s3AGDfqau53q+CoCgKYZ/vY+poP15vXx+A1Yv7om7wLusjfuPtvi1zzJuenkHf0WsImdieX49GEZ+o/UO2OHwvbwY0Y0hg5olzyaw32PXLOVas/ZXQ4M4ABHbz0srz4cxurNwYyelz12ndMvPvMm6IDwD7Dv1tkH02JImf7hRFIezjHUyd3J3XuzQDYHX4GNTVBrL+6/28PbhttvkaNfSgUcPMFyIHz/gi2zSd2mv/EM8N6csn//cjh4/9hWedKvwddZ3DR//ij2NheNapAsDyJW/h6DqQDd8cYMjANhgbG6NWaze6IrYfoecbLbC0LKfXvutLznn5S+YU5Z30FBUhl24kEnP3Pm28qmjWmZmW4dWXXYg8k/MwRot6zhz/K5aj52IA+Od6At8fuUz7F5wQSpJL0XeIiU3Ez7uWZp2ZmQneTd2J/O3Sc/POXvw9Fe0sGdy7WZbvUlMfcfyPK/i9WktrfZtXa+VYbmrqI8LXHcLGuhwv13HRYW8KnsRPd5cu3yTmZhx+retr1pmZmeDd0pPIw+cNtp309HQ2fnOA5OSHNGuc2RhISckcLipb1kSTztjYGFMTEw4eOpdtOcdPXuTU6UsMHuBrsLrpSs55+Sw9wzBLKVLqe4qKkpi7mXMkHG3NtdY72prz782k7LIAEPBaDW7HP+DVsZtQFHiUnsGwzvWYEuiVY56SJuZW5pWeo7211noHeyutYZpnHTz2Dys3HubkrinZfn/7bjLp6Rk4VrTSWu9Y0UqzzSd27PmT3iNWcf9BGk4O1uxaPxJ7O0tddqfASfx0F3MzHgBHx/Ja6x0cyhMdnXWOSl798ee/NH/tHR4+TMXSsixbNrxDndqVAahV04WqVSoydeaXfLJ0OBYWZny4dDsxN+O4EROXbXmfr9lD7VqVaN60VrbfFyQ554mipsj3FF29epWAgADs7OywsLDAy8uLI0eOaL5fsWIFbm5umJqaUrNmTb74QrsbOjo6mi5dumBpaYm1tTU9e/bk5s2bz25G49KlS7i7uzN8+HAysnkSaEpKComJiVqLrtbtOY91+xWaJS09HQCVSqWVTlHgmVVa9p26yvvrjvHR2Fb89mkAm2Z1YOfhS7z3xVGd61bUrdtyDKsaEzVLWtqT2GmnUxQFFdkHL+neQ/qNWUP4goAX/vjm5m/i09yDkz++w8GI8bRtVZtew1cSezvnE3thkvjpbt3GX7By6K1Z0tIye2uejZKiKFn2Wxc1azhzMvJDIvfNZ9iQdgx8eylnz10BwMSkDJvWT+Gvv69ToVI/LOwD+OXAGfz9XsHYOOvp/cGDFDZ8vZ83+xdOL5Gc8wqWoiiaITSdF6V0DZ8V6Z6ie/fu4e3tjYuLC9u3b0etVnPixAlNY2Xr1q2MHTuWJUuW4Ovry44dOxg0aBCVKlXCx8cHRVHo2rUrFhYW/PLLLzx69IgRI0bQq1cv9u3bl2V7f/75J35+fgwYMIDQ0NBs6xQaGsqsWbMMsn+dm1enSW215nNKauYJIuZuMk4VLDTrY+PvZ7mS+q+Zqw7Tt00thnSoC0C96vYkP0xj2Ic/M7VPI4yM9D8xFzWd/erRpIGr5nPK47tOYm4l4uRoo1l/6869LL0UT1z89zaXr9yl86Cnd0tlPB4/N6k6lvO/TKOysy3GxkbExGo3fmNvJ2XpVbEwN8O9WkXcq1WkacNq1Gg5m883RhI8yk+vfc0PEj/dde7QmCaNamg+p6SkAZk9Rk5Odpr1t24l4OhgkyV/XpmamuDu5gSA1yvu/HY8irDlO/h02XAAGjZw4+ThxSQkJJOa+oiKFW1o6h1Ew1eyTnrftDWS+/dT6R/YSu966ULOeQVMbsnPsyLdKFq/fj23bt3i2LFj2Nllnmzc3d013y9atIiBAwcyYsQIACZMmMDhw4dZtGgRPj4+7Nmzh9OnT3Pp0iUqV87sbv7iiy/w9PTk2LFjNGr0dBJjZGQkHTt2JDg4mEmTJuVYp+DgYCZMmKD5nJiYqCk7r6zMTbEyN9V8VhQFtZ05e45foYGHAwCpaens//0aoW+1yLGc+w/TspwEjI1UmVcJikLWa9jiz8qyLFaWZTWfFUVB7WDN7v0XaFA38++RmvqIXw5HMW9q52zLqOXmyOk9wVrrpi/cQdK9FJbMeoPKzraYmpahYb3K7D5wnm7+L2vS7Tlwgc5+2U8C/W+dnsz5KGokfrqzsiqHldXTCcqKoqB2tGX3z7/ToH51AFJT0/jl1zPMm9Pf4NtXFIXUxw2x/7KxyWxU/B11nd9OXGT29MAsaVau3UPnDo2oWFH/xpou5Jwniroi3Sg6deoUDRo00DSInnXu3DneeustrXUtWrQgLCxM833lypW1Gi116tShfPnynDt3TtMoio6OxtfXl/fee4/x48c/t05mZmaYmZnps1s5UqlUjH2jPqHrjuHuUh6PSuUJXXcM87ImmrssAAaE7sLF3oL3h2aeNDo2q8biTSep716RJrUdibqWwMxVh+nUvLqmC/3eg1SiriVoyrh8I5FTUbewsypLFcfMnoC7iQ+Jjk3i+u1kAC5cyZyToLYzR22XecKNuZtMzN37RF2LB+CPf25jZW5KFQcr7Kyf/sgWNJVKxdjBrQj9aBce1SriUa0ioct2YV7OhMCuT+cZDBi7Fmd1eUKDO1O2rAl1azlrlVPeOvPH7r/rx7/lQ/+xX+D1UhWaNaxG+LqDRF+7y7B+mXdkJd9PYe7SH+ncph5OjjbciUtm+ZoDXI2Jp0fHBppyYmITibmVSNTlzHkmf5y/jpVlWao422Jna0FhkvjpTqVSMXZkR0IXbcLD3QkPNydCF27GvJwZgT1f1aQbMCQMZ2c7Qmf3AzIbTmfPXX3870dcu36HU79fwtKyrKZnaOrML/H3e4XKlexJSnrAxk0H2HfgDN9HTNeU+82Wg1S0t6FKZXv+OPMv4yZ/TtdOjfHzra9Vz6iLN9j/61l2bpmWzxHJPTnn5bMMJXPRt4xSpEg3isqVe/HtolnHop+O4+c0pv/s+ooVK+Ls7MzGjRsZPHgw1tbWWfIUlMkBDXmQ8ohRYXuJS0qhSW1HfljQVevq6kpsktZV0rv9GqNSqZixMpJrt+9RsXw5OjarxnuDnz5747cLsbSesEXzeeKKAwD0b1ubVVMyn/uy/dA/DF6wR5MmcM4PAMzo35iZA5sC8On2P5i99um4fatxmwH4PMiXge3qGCwOugga4cuDh2mMfPdr4hLu06S+Kz+uG6nVIxJ9LS7PXeu9OjfkTlwyc5b8wI3YROrWdGLn2uFUrZTZWDc2MuJC1E26f3OU23HJVLA1p9HLVdm/eRyeNZ005Xzyxa/MXvy95rP3G5mN95Uf9mFgz6b67LpBSPx0FzShGw8epjJyXDhx8fdo0siDH7fP1OpRir56Syt212/E8Urzp73OH4Rt44OwbXj/z5O9P7wHwM3YePoPWcKNmDhsrM15qa4r30dMp81/7nS7ERPHxHdWcTM2ASe1Lf0CWzH9nR5Z6rhy7U+4ONtlaSwVNjnn5R8lHRQ9h7+UdANVpphQKUV4FtWaNWsYM2YMly5dyra3qEWLFnh6ehIe/nROQ8+ePbl//z47duxg9+7d+Pv7aw2fnT17VjN85uXlpXlO0cGDB2nfvj2pqans2rULK6vs51E8KzExERsbG+K+fRtri/zpQSrJVDU8CrsKorSyrVTYNSi2lCN7C7sKxVZicgq2nT4lISEh3y7An/wu3Rjni7WZfn0fiSmPcFqyJ1/rW5QU6bvPevfujVqtpmvXrhw8eJB//vmHzZs3ExkZCcDkyZNZvXo1n3zyCX///TcffvghW7Zs0cwJ8vX15aWXXqJPnz6cOHGCo0eP0r9/f7y9vfHy0r5108LCgp07d1KmTBn8/f25d+9ege+vEEIIYTBPhs/0XUqRIt0oMjU1ZdeuXTg4ONC+fXvq1avHvHnzMDY2BqBr166EhYWxcOFCPD09+fTTT1m1ahWtWrUCMofWIiIisLW15dVXX8XX15fq1avz1VdfZbs9S0tLvv/+exRFoX379iQnJxfUrgohhBCGJQ9vzLMiPXxWHMjwmX5k+EwUGhk+05kMn+muIIfPrg9vZZDhM+cV+2T4TAghhBCiNCnwRtHly5dRqVS5WurWrVvQ1RNCCCFKhgzl6QMcdV1K2ZyiAr8l38TEhJo1a744IVC9evV8ro0QQghRMj15VYe+ZZQmBd4ocnFx4fx5w705WgghhBDCEIr0wxuFEEIIoRslXTHAwxulp0gIIYQQxZwMn+Wd3H0mhBBCCIH0FAkhhBAlUka6Qoaew1/65i9upFEkhBBClEAyfJZ30igyENX/OqCytijsagghRL5TtepS2FUotlSJycCnhV0NkQNpFAkhhBAlkJKRgZKh37vL9M1f3EijSAghhCiJDHBLPjKnSAghhBDFnaIYYE5RKXtnvNySL4QQQgiB9BQJIYQQJZKSrqAYyROt80IaRUIIIUQJJLfk550MnwkhhBBCID1FQgghRImUkaGQoWdPj775ixtpFAkhhBAlkJKOAeYUGagyxYQMnwkhhBBCUAIbRa1atWLcuHGFXQ2dKYpCSMgaXFx6Ym7uj4/PBM6cufzCfJs378fTcxBly7bD03MQW7f+miXN8uXbqF69D+XKtcPLaxgHDpzO87ZTUlIZPXoZFSt2w9KyA126TOPq1Vv67LLBSOz0I/HTncROdxK7/PNkorW+S2lS4hpFW7ZsYc6cOYVdDZ0tWLCRxYs3sWzZaI4eXY5abYufXxBJSfdzzBMZeYaAgDn07duGU6fC6du3Db16zebIkXOaNF99tZfx45czdWogJ058SsuW9WjfPpjo6Jt52va4ccuJiPiVDRumceDAEu7de0CnTu+Snl74fawSO/1I/HQnsdOdxC7/SKMo71RKaXtcpYElJiZiY2NDfPx2rPV8IayiKLi49GTs2NeZMqU3kHmVolZ3Z968obz9dqds8wUEzCExMZnvvpunWefv/w62tpasXz8NgKZNR9KggQcrVozTpKlTZxBdurQgNHRIrradkHAPB4c3WLv2HXr18gHg+vXbVKnSm50736dt20Z67b8+JHb6kfjpTmKnu9IYu8TEZMqX70xCQgLW1tZ5zp+7bWT+Lp1r2wArE2O9ykpKS6f2jyfztb5FSYnrKfrv8Jmrqyvvv/8+b775JlZWVlSpUoXw8HCt9IcOHaJ+/fqULVsWLy8vIiIiUKlUnDp1qsDrfunSDWJi7uLn56VZZ2Zmirf3y0RGnskxX2TkWdq08dJa5+fnxaFDmXlSU9M4fvwvrXIB2rRpqCk3N9s+fvxv0tIeaaVxdranbl1XzbYKi8ROPxI/3UnsdCexy1/K43ef6buUJiWuUfSsDz74AC8vL06ePMmIESMYPnw458+fByApKYlOnTpRr149Tpw4wZw5c5gyZUqh1TUmJg4AR0dbrfUODraa77LPdzdLHkfHp3lu304gPT0jhzR3c73tmJi7mJqaYGtrlWM5hUVipx+Jn+4kdrqT2OUvRclAydBzUTIKezcKVIlvFLVv354RI0bg7u7OlClTsLe3Z9++fQCsW7cOlUrFZ599Rp06dfD392fy5MnPLS8lJYXExEStRVfr1u3ByqqDZklLewSASqXSSqcoSpZ1z8o+z7NpeCZN1ny6bDs3aQxNYqcfiZ/uJHa6k9gVLOkpyrsS/5yil156SfNvlUqFWq0mNjYWgAsXLvDSSy9RtmxZTZrGjRs/t7zQ0FBmzZplkLp17tycJk1qaz6npKQBmVcnTk4VNOtv3YrH0bF8juWo1XZZrlpiY+M1V0D29jYYGxtlufKKjY3TpFGrbV+4bbXajtTUNOLikrSunGJj42nWzDO3u20QEjv9SPx0J7HTncROFHUlvqfIxMRE67NKpSIjI7M7MLvW/ovmnQcHB5OQkKBZrly5onPdrKzMcXd30Sx16lRFrbZj9+7jmjSpqWn88svvzz0AmzWrw549x7XW7d79G82bZ+YxNTWhYcMaWuUC7NlzXFNutWpOL9x2w4YemJiU0Upz48Yd/vzzsmZbBUVipx+Jn+4kdrqT2BUsufss70p8T9Hz1KpVi3Xr1pGSkoKZmRkAv/3223PzmJmZadIamkqlYuzY1wkNXY+HRyU8PFwIDV2PuXlZAgNba9INGDAPZ2d7QkOHADBmzOt4e49j/vwNdOnSgm3bDrJnzwkOHAjT5Bk/vjv9+8/Dy6sGzZrVITx8J9HRsQwb1inX27axseTNN/2ZNOkTKlSwxs7OismTP6VevWr4+r6SLzHJLYmdfiR+upPY6U5il7/kNR95V6obRYGBgbz77ru89dZbvPPOO0RHR7No0SIg6zhzQQkKCuDBg1RGjgwjLi6JJk1q8+OP87GyMtekiY6Oxcjoaf2aN/dkw4ZpTJ++ihkzVuPm5szGjdO1uql79fLhzp1E5sz5ghs37lK3ris7d4ZStapjnra9ePEIypQxplev2Tx4kErr1g1Yteo9jI31u+3TECR2+pH46U5ipzuJnShKStxzilq1akX9+vVZsmQJrq6ujBs3TusJ1/Xr16dr166EhIQAmbfkP7kjrV69ekycOJHAwEDOnz9PzZo1X7g9Qz6nSAghRMlWkM8pOtWsDlZl9HxO0aN06keeLTXPKSpxPUVP7iwDuHz5cpbvn33+UPPmzfn99981n9etW4eJiQlVqlTJpxoKIYQQ+c8Qc4JkTlEps3btWqpXr46Liwu///47U6ZMoWfPnpQrV66wqyaEEEKIAlTqG0UxMTHMmDGDmJgYnJyc6NGjB3Pnzi3sagkhhBB6UdIVFJWePUXynKLSJSgoiKCgoMKuhhBCCGFYigFuqS9Z045fqMQ/p0gIIYQQIjdKfU+REEIIURIpGQYYPpOJ1kIIIYQo7pR0BQWZU5QX0igSQgghSqCMDIUMPXuKStsTrWVOkRBCCCEK1OXLlxk8eDDVqlWjXLlyuLm5MXPmTFJTUwu1XtJTJIQQQpRAGRmQoecbqx6/P93gzp8/T0ZGBp9++inu7u78+eefDB06lOTkZM3rtgqDNIqEEEKIEqgoN4ratWtHu3btNJ+rV6/OhQsXWLFihTSKhBBCCFF0JSYman02MzPDzMzMoNtISEjAzs7OoGXmlcwpEkIIIUqgjAzDLACVK1fGxsZGs4SGhhq0rhcvXmTZsmUMGzbMoOXmlTSKhBBCiBIoQzHMAnDlyhUSEhI0S3BwcLbbDAkJQaVSPXf57bfftPJcv36ddu3a0aNHD4YMGZLfYXkuGT4TQgghxHNZW1tjbW39wnSjRo0iICDguWlcXV01/75+/To+Pj40a9aM8PBwfaupN2kUCSGEECVQYUy0tre3x97ePldpr127ho+PDw0bNmTVqlUYGRX+4JU0ioQQQogSKEPR/+6x/Hp24/Xr12nVqhVVqlRh0aJF3Lp1S/OdWq3On43mgjSKhBBCCFGgdu3aRVRUFFFRUVSqVEnrO0UpvKdoF35flRBCCCEMTjHAnWdKPj2naODAgSiKku1SmKSnSAghhCiBMjJA3zZNfj28saiSRpEQQghRAkmjKO9k+EwIIYQQAukpEkIIIUok6SnKO+kpKmKWL99G9ep9KFeuHV5ewzhw4PRz0//yy+94eQ2jXLl2uLn15ZNPvs2SZvPm/Xh6DqJs2XZ4eg5i69Zftb4PDV1P48YjsLbuiKPjG3TrNp0LF65opVEUhZCQNbi49MTc3B8fnwmcOXNZ7/01JF3r+KL4wIv/LiEha6hdeyCWlh2ws+tCmzaTOXLknFaa8PAd+PhMwMamE0ZGrYmPv6fX/hqaxE93hRm7/3r77Q8xMmrNkiWbs3wXGXmG1q0nYmnZAVvbzvj4TODBg5Q87Wd+kHNe/jHkaz5KC2kUFSFffbWX8eOXM3VqICdOfErLlvVo3z6Y6Oib2aa/dOkGHTpMpWXLepw48SnBwb0ZO/YjNm/er0kTGXmGgIA59O3bhlOnwunbtw29es3W+sHZv/80I0Z0JjLyI3btWsCjR+m0bRtEcvIDTZoFCzayePEmli0bzdGjy1GrbfHzCyIp6X7+BSSPdKljbuKTm79LjRqVWLZsNKdPf8aBA2FUrepI27ZTuHUrXpPm/v0U2rZtRHBwYL7sv74kfrorzNg9ERHxK0ePnsfZuUK22/L3D6ZNGy+OHPmYo0eXM3JkF4yM9Hyyn57knCeKGpVS2Pe/FXOJiYnY2NgQH78da2sLvcpq2nQkDRp4sGLFOM26OnUG0aVLC0JDs74PZsqUcL79NpKzZ1dp1g0btpjTpy9y6NBHAAQEzCExMZnvvpunSePv/w62tpasXz8t23rcuhWPo+Mb7Nu3mFdffQlFUXBx6cnYsa8zZUpvAFJSUlGruzNv3lDefruTXvttCLrWMTfxyevfBSAxMZny5Tuze/dCWrd+Reu7fftO8dprE7l7dxvly1vqs9sGI/HTXVGI3bVrt2jadBQ//DCfjh2nMnbsG4wb94bm+2bNRuHr25A5cwYZctf1VhrPeU/+byckJOTqtRm6bSPzd+lbB3csjIz1Kis5I51OsVH5Wt+iRHqKiojU1DSOH/8LPz8vrfVt2jQkMvJMtnkOHz5LmzYNtda1bduI3377i7S0RwBERp6lTRvtMv38vDh0KPsyARISkgGws7MCMq/OYmLuatXNzMwUb++Xc6xbQdO1ji+Kjy5/l9TUNMLDd2JjY8HLL7vpuksFSuKnu8KOXUZGBv37z2PSpJ54erpm2U5sbBxHjpzDwaE8LVqMRq1+g1atxvPrr3/osrsGI+e8/JfTc4DyupQm0ijKo5SUFBITE7UWQ7h9O4H09AwcHW211js62hITczfbPDExd7NN/+hROrdvJzw3TUxMXLZlKorCxIkraNmyLnXrVntcRpwm3385OORcTkHTtY4vik9e/i47dkRiZdWBcuX8WbJkE7t2LcDe3kbnfSpIEj/dFXbs5s/fSJkyxowZ83q22/nnnxsAzJq1hiFDOvD99/No0MADX9/J/P331VzupeHJOU8URdIoyqPQ0FBsbGw0S+XKlQ1avuqZIX5FAdWzK7XSa3/3pFX/3/XZpcmpyFGjlnL69D/ZdjNnX07hzElYt24PVlYdNMuTq0Rd6pib+OTm7+LjU5+TJ8M5eHApbds2olevOcTGFs0TqMRPd0UpdseP/8XSpVtYtSoox21lPH551VtvdWTQoHY0aODB4sUjqFmzEitX/vDc+hUEOeflH5lonXdyS34eBQcHM2HCBM3nxMREgzSM7O1tMDY2ynIVEhsbl+Vq5Qm12i7LFVVsbDxlyhhToYL1c9NkV+bo0cv49ttIfvllMZUqVfzPdjLTxsTcxcnp6STOzHH48rnfSQPq3Lk5TZrU1nxOSUkD8l7HF8UnL38XC4tyuLu74O7uQtOmdahRoz+ff/59kZwYLPHTXVGK3YEDfxAbG0/Vqr0136enZzBp0ieEhW3m0qX1ODnZAVCnTlWtcmrXrsqVK7G53W2Dk3Ne/pNb8vNOeoryyMzMDGtra63FEExNTWjYsAa7dx/XWr9nz3GaNfPMNk/TpnXYs0c7/a5dv+HlVQMTk8z2brNmWdPs3v0bzZs/LVNRFEaNWsrWrQf46adFVKvmpJW+WjUn1Go7rbqlpqbxyy+/51i3/GZlZa75AXV3d6FOnao61fFF8dHl7/KEoiiaH8yiRuKnu6IUu379fPn99884eTJcszg7V2DSpJ788MN8AFxd1Tg7V+DCBe2hsr/+ukqVKg66B0JPcs4TRZH0FBUh48d3p3//eXh51aBZszqEh+8kOjqWYcMy73QIDv4/rl+/zZo17wAwbFgnPv54GxMmLGfo0A5ERp5l5crvWb/+XU2ZY8a8jrf3OObP30CXLi3Ytu0ge/ac4MCBME2akSOXsmHDT0REzMHKylxzlWVjY0G5cmaoVCrGjn2d0ND1eHhUwsPDhdDQ9ZiblyUwsHUBRihnua3jgAHzcHa219zZkpv4vOjvkpz8gLlz19G5c3OcnCpw504Cy5dv5+rVW/To4a0pJybmLjExd4mKugbAH3/8g5WVOVWqOGBnV7h3dUj8dFeYsatQwYYKFbTnXZmYlEGttqNmzcqa+k2a1IuQkDW8/HJ16td3Z82aXZw/H80338zM7/A8l5zz8leGon9PT0bpmmctjaLsfPTRR2zdupWffvqpQLfbq5cPd+4kMmfOF9y4cZe6dV3ZuTOUqlUdAYiJuUN09NPu7mrVnNi5830mTFjO8uXbcXauQFjYKN5441VNmubNPdmwYRrTp69ixozVuLk5s3HjdK3u/08+2Q6Aj8/TYUGAlSsnM3BgOwCCggJ48CCVkSPDiItLokmT2vz443ysrMzzLR55lZs6RkfHaj2bJTfxedHfxdjYmAsXrtC9ewi3bydSoYI1jRrVZP/+JVp3A33yybfMnr1W89nbezygHefCJPHTXWHFLrfGjXuDhw9TmTBhBXfvJvHyy9XZtWsBbm7O+u+8HuScl7+UDMjQcwpUKbv5TJ5TlJ2QkBBWr17N5cuXX5jWkM8pEkIIUbIV5HOKvrJ0w1yl33OK7ivp9Lp3UZ5TVJqFhITkqkEkhBBCiJJDhs+EEEKIEijDAMNnMqdICCGEEMWeNIryTobPhBBCCCGQniIhhBCiRMpQDPDwxlLWUySNIiGEEKIEkuGzvJPhMyGEEEIIpKdICCGEKJGkpyjvpFEkhBBClEDSKMo7GT4TQgghhEB6ivT25C0piYn3C7kmQgghironvxUF8YatZCVD756eB3rfv1a8SKNIT0lJSQBUqRJQyDURQghRXCQlJWFjY5MvZZuamqJWqxkTc8kg5anVakxNTQ1SVlEnL4TVU0ZGBtevX8fKygqVSs/BWyGEECWaoigkJSXh7OyMkVH+zWB5+PAhqampBinL1NSUsmXLGqSsok4aRUIIIYQQyERrIYQQQghAGkVCCCGEEIA0ioQQQgghAGkUCSGEEEIA0igSQgghhACkUSSEEEIIAUijSAghhBACgP8HvM+0aAbM6usAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", - " baselines={\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"},\n", - " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", - ")\n", - "\n", - "attr_result_4 = llm_attr.attribute(\n", - " inp_feature, \n", - " target=target,\n", + "baselines = ProductBaselines(\n", + " {\n", + " (\"name\", \"pronoun\"):[(\"Sarah\", \"her\"), (\"John\", \"His\"), (\"Martin\", \"His\"), (\"Rachel\", \"Her\")],\n", + " (\"city\", \"state\"): [(\"Seattle\", \"WA\"), (\"Boston\", \"MA\")],\n", + " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", + " }\n", ")\n", "\n", - "attr_viz_4 = LLMAttrViz(**attr_result_4)\n", - "attr_viz_4.plot_token_attr()" - ] - }, - { - "cell_type": "markdown", - "id": "french-armstrong", - "metadata": {}, - "source": [ - "We have only chosen one baseline, but ideally, we could define a distribution of baselines so the attribution method will sample from it for perturbations. Here, we define a list of baselines with `IterableBaselines` and specify `num_trials` in `attribute` to average over multiple trials " - ] - }, - { - "cell_type": "code", - "execution_count": 281, - "id": "2ac65d49", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in New York, NY and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2415995115588885e-05 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Menlo Park, CA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 0.0001207862442242913 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n" - ] - } - ], - "source": [ - "baselines = IterableBaselines([\n", - " {\"name\":\"Sarah\", \"city\": \"Seattle\", \"state\": \"WA\", \"occupation\":\"doctor\", \"pronoun\":\"Her\"},\n", - " {\"name\":\"John\", \"city\": \"Boston\", \"state\": \"MA\", \"occupation\":\"engineer\", \"pronoun\":\"His\"},\n", - " {\"name\":\"Martin\", \"city\": \"Menlo Park\", \"state\": \"CA\", \"occupation\":\"teacher\", \"pronoun\":\"His\"},\n", - " {\"name\":\"Rachel\", \"city\": \"New York\", \"state\": \"NY\", \"occupation\":\"plumber\", \"pronoun\":\"Her\"},\n", - "])\n", - "\n", - "inp_feature = TextTemplateFeature(\n", + "inp = TextTemplateInput(\n", " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", + " values={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"}, \n", " baselines=baselines,\n", " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", ")\n", "\n", - "attr_result_5 = llm_attr.attribute(\n", - " inp_feature, \n", - " target=target,\n", - " num_trials=10,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 282, - "id": "63668488", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_5 = LLMAttrViz(**attr_result_5)\n", - "attr_viz_5.plot_seq_attr()\n", - "attr_viz_5.plot_token_attr()" + "attr_res = llm_attr.attribute(inp, target=target, num_trials=3)\n", + "\n", + "attr_res.plot_token_attr()" ] }, { "cell_type": "markdown", - "id": "0a29a08b", - "metadata": {}, - "source": [ - "We can also independently define the baseline distribution of each attribute with `ProductBaselines`." - ] - }, - { - "cell_type": "code", - "execution_count": 287, - "id": "dominant-leave", + "id": "documented-harvard", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", - "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - "Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", - "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.841361260332633e-06 ]\n", - "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - "Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - "Dave lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", - "Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - "Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - "Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - "Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - "Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - "Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - "Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n" - ] - } - ], "source": [ - "baselines = ProductBaselines(\n", - " {\n", - " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", - " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", - " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", - " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", - " }\n", - ")\n", + "One potential issue with the current approach is using Feature Ablation. If the model learns complex interations between the prompt features, the true importance may not be reflected in the attributio scores. Consider a case where the model predicts a high probability of playing golf if a person is either a lawyer or lives in Palm Coast. By ablating a feature one at a time, the probability may appear to be unchanged when ablating each feature independently, but may drop substantially when perturbing both together.\n", "\n", - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", - " baselines=baselines,\n", - " mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", - ")\n", + "To address this, we can apply alternate perturbation-based attribution methods available in Captum such as ShapleyValue(Sampling), KernelShap and Lime, which ablate different subgroups of features and may result in more accurate scores.\n", "\n", - "attr_result_6 = llm_attr.attribute(\n", - " inp_feature, \n", - " target=target,\n", - " num_trials=10,\n", - ")" + "We will use `ShapleyValue` below because we essentially only have three features now after grouping. The computation is tracable." ] }, { "cell_type": "code", - "execution_count": 292, - "id": "0c9cec9c", + "execution_count": 83, + "id": "iraqi-gibson", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "(
, )" ] }, + "execution_count": 83, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHCCAYAAAAkUSetAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADD2ElEQVR4nOzdd1wURxvA8d/RLYAiHcGugFixYe+9xlhj77H3rq9GEzRqxN57bDEae8VesPfeUCwgIgICSt33D+KZE1A6iM83n/vEm5udnX309mZnZmdViqIoCCGEEEKIRNNK7woIIYQQQnyrpCElhBBCCJFE0pASQgghhEgiaUgJIYQQQiSRNKSEEEIIIZJIGlJCCCGEEEkkDSkhhBBCiCSShpQQQgghRBJJQ0oIIYQQIomkISWSRBbEF0IIIaQhJZJIpVIBEB0dnc41EUIIIdKPNKREok2aNIl169YBoKWlhaIo0kMlhBDiuyQNKZEoe/bsYdu2bXTu3Jn8+fNz+PBhVCqVuodKCCGE+J5IQ0okWEBAAH/99Re2trbcvn2bn3/+mVatWjF+/HgiIiKkV0oIIcR3RxpSIsH++usv7t27R+3atbG3t2fEiBEsWrSITZs24enpKb1SQgghvjvSkBIJ4unpya5du8ifPz9DhgxRpxsaGvLy5UvOnTunTpOeKSGEEN8LnfSugPg2rF+/nosXL6Kvr8+DBw8oVKgQwcHBXLx4kejoaJycnNR5VSoVUVFRaGlpSS+VEEKITE0aUuKrzpw5w9GjR6lbty5mZmaULl2a0qVLo6uri4eHBx07dqRUqVLMmzcPX19fhgwZgomJCRDTOyWNKSGEEJmVDO2JL4qMjGTTpk1ER0fTv39/Zs6cyfXr1ylWrBhWVlbMmTOHGTNm8OLFC7S1tbl06RL58+dnzpw5ABqNqLCwMNzd3dPrUIQQQogUp1JkQov4gtOnT9OrVy8aN27M9OnTNT4LCwtDX18/1jbbtm1j1KhRrF27FhcXF3X6kSNHqF27NgcPHqR27dqpXnchhBAitUlDSnzVpUuXsLa2xsrKSr2SuZZWTGdmUFAQAwcO5P379+jr6zN69GgcHR2pUaMGtWvXZty4cUDM0gmtWrVCpVJx8ODBdDsWIYQQIiXJHCnxVc7Ozuo/f2xAfZz71LlzZy5dukT37t3x8vKiQoUKtG/fnsePH6OjE/PPKzo6mh07dnDkyBGuX7+u3j46Ohptbe20PyAhhBAihUiPlEiyV69eYWNjw+bNm2nZsiUAV65coVmzZiiKwo0bN8iRIwdPnz6ldu3a1KxZkyVLlhAeHo6enp66HJmQLoQQ4lslk81Fkunq6lKjRg0OHToEQGBgIJGRkbx7944+ffqQI0cOIiMjWbFiBa9fv2bmzJlAzF2AzZs35/Hjx8Cn5RKkTS+EEOJbIw0pkWQmJiYMGTKEf/75h8qVKzNw4EAqVaqEra0tffr0AeDWrVu4ubkxadIkDA0N8fPzY//+/ezcuZOjR48ycuRIHj16hLa2tvRKCSGE+OZIQ0okS8OGDXn16hXDhw+nWbNmREZGMnHiRHLlysX79++ZPn06NjY2DB48GIALFy4wf/58qlWrRnBwMK9fv8bZ2Zn9+/drlBsZGZkORyPEJ25ubuzYsSO9qyGEyOBksrlIEc2bNycoKIgpU6bQpEkTAE6cOMHWrVvZuXMnAE+fPmXJkiUUKlSIo0ePqre9evUqFy9epEaNGty9e5cSJUqoJ6oLkR68vb1ZsmQJTZs2pVmzZuldHSFEBiaTzUWqCAoKwtnZmdy5c3P06FHCw8PZsGEDAwcOZN++fVSqVAmAZ8+e0bRpUyIjI7G3t8fb25u3b9+yZcsWHB0d0/koxPeqW7duBAQEMGXKFIoWLUpUVJTcYSqEiJMM7YlUYWRkxKRJk1i1ahUA9+7dY9myZTRu3FjdiALYv38/3t7e9OnTh7lz53LkyBHy5cvHjBkz0qvq4jt38eJFrly5Qv369SlatCgA2traREVFpXPNhBAZkYyfiFTz008/ARAeHs727dvx8PDg77//Vn9+7do1du7ciYuLC/369VOn6+vr4+PjQ3R0NCqVSiahizQTFRXFmDFjKF68OK1bt8bLy4unT59SpUoVtLW11XeWyr9JIcRH0pDKIN68eUPOnDnVC15mJnp6evTo0YPChQtjZWUFxDSu9u3bx4MHD1i5cqU67/379wkJCaF48eJER0cneK6UNLpEStiyZQshISH88MMPZM+encWLF7Nz505CQ0OZM2cO1apVS+8qCiEymMz3q/0Nio6OplevXlhbW+Pm5pbe1UkVVlZWtGnTRv3+yJEj/PXXX9SvX5+KFSuq0zds2EBgYCDVqlVDR0cn3rWlrl27xv79+1m/fj137txBS0sLlUqlfoSNEIkVHBzMzJkzqVixInXq1EFHR4e+ffuydetWmjVrRocOHVi/fr3GNjLFVAghDakM4MiRI/j6+lKzZk3mzp1LkSJFOHXqVHpXK1UZGRmRJUsWhg4dqk47ceIEx48fp1SpUjRq1Aj4NITycX7Ks2fPGDRoEC4uLrRq1YrFixdTpUoVfvrpJ4KCgjJlj55IG7///js5cuSge/fuvHr1ih07drB3716srKyYPHkyNWrU4OjRoxqNJ+kBFULIr046e//+PfPmzcPc3JwNGzbw+PFjWrVqRY8ePVi5ciWKomTKq96KFSty4sQJ7OzsgJihvr/++guVSkX37t0BNHqXPt4x1bdvX/766y+GDx+Ol5cXGzduZPfu3YSGhlKjRg2uXLmS9gcjvnmPHz9mz549NGjQgA8fPlCiRAkmTpzIjBkzKFCgAH///TcuLi6cPXtW3agfNWpUrAuezPhdFUJ8mTSk0tm6det49eoVHTp0AGIaD5MmTaJr164sXboUf3//THvV+9/byc+ePcuRI0eoUKGC+iHJH3uXPv5wbdy4kT179tCrVy8mT55Mzpw5yZ07NxUqVGDz5s2ULFmSbdu2pf2BiG/esmXLMDQ0pG3btsybNw97e3uOHz/O3r17GTx4MEOHDqVfv340a9YMHR0dvLy8uHDhAocPH9a4m0+Gl4X4/khDKh35+PioGwAtWrQAYhoPOjo6tG3blocPH7JixYp0rmXaqFq1KmvWrFGvgB5Xb9SsWbNwcXGhXbt26ufzfaSnp0eHDh3UPVxCJIarqyvLli3DxsaGyMhI7OzsyJEjBxYWFgwYMIA2bdqQO3duevXqBaBelb9IkSJoa2tz7949Zs2aRWBgoAwvC/Gdkbv20pGbmxsRERF069YN0LzzLE+ePGhraxMSEqKxTVRUlHpidWZTtmxZ9Z8//zG6f/8+b9++pUmTJtjb2wPEWiCxRo0auLi4xCo3MjJSVkoX8fq42GahQoUA1BPL+/btS40aNdizZw8bNmzgt99+UzfUz5w5g6+vL23btgVihpyPHj1KYGAgv/zyS7odixAi7cmlUzq5fv06p06donr16pQrVw7QbDzs3r0bAFNTUxRF4eTJk7x79079cN/vbXFAGxsb/P39KV26NECcxx8dHY2BgQGhoaHcuXOHY8eOAXzx7j8hPm+Qt2zZkkuXLuHj48OzZ89Yu3YtVatWpVu3buoLmD///JPevXvz8OFDBg0axJUrV6hZsyb16tVTl3P+/Hn1nzPrXMf0IsOnIiORhlQ6iIqKYvz48WTNmpVhw4ap0z72SAUHB7Nt2zb09PSoVasW586dY/78+RQrVozJkycDsU/+mVlUVBS6uroUL16cTZs2ERwcrHH8H0+qWlpaPHjwgObNm1OnTh26d+9OwYIFOXHiRKbswRMpT1EUoqKicHR0ZNu2bfTs2RN7e3t69uyJiYkJAJcuXcLCwgItLS1mzJjB27dvmTp1KoULF8bExITAwECmTJlChQoV8PT05O3bt7LGWQp5/fo10dHRMnwqMhT515gOwsLCMDY2xt3dna1btxIZGYm2trb65DB37lz2799Py5YtcXR0pGjRoixZsoQ5c+awbds22rVrR2BgoEaZmfkKTVtbGz09PYYNG8arV6/UD0H+6GPc/P39adGiBVFRUcyZM4dz587RokULBgwYwMuXL9Oj6uIbo1Kp0NbWVn+fDA0NuX37Nq1bt1bnCQ4O5unTp8yePRttbW0mTZqEoaEhjx8/xsHBgenTp7Njxw5WrVpFvnz5aNeuHWvXrk2vQ8o0oqOj6dOnD61btyY4ODi9qyPEJ4pIN3/99ZdiZWWlODk5KW5ubsrkyZOV3r17K9ra2kqrVq2UV69eKRcvXlQ2bdqkPHjwQFEURTl//rySL18+5c6dO+lc+/Th6uqqZMmSRenQoYPi7u6uLFu2TAkKClIURVGmT5+u5MqVS3n58qU6v4+Pj2JlZaWsXbs2zvIiIyPTpN7i2xQRERErbcKECYpKpVIqVKigvHv3TlEURSlevLiydu1aZfbs2UqxYsWUBQsWqPNny5ZN2bRpk6IoihIVFaVRVnR0dCrWPnNxd3dXKlWqpMycOTPOzz+PrRBpRXqk0lGrVq14+fIl3bp14/Dhwxw7dozz588ze/ZsJkyYwKxZsyhbtiwLFy6kevXq9OnTh6xZs5IzZ06uXr0KwI0bNxg8eHCm7pH6r9GjR/PgwQNUKhVz585l3759+Pj4ADB//nz69euHlZUV4eHhAOTMmZOIiAiyZ8+uLsPDw4NDhw4BqJ+fpsj8lWR58+ZNpvw3GNdNCm3btqVfv34sWrSI7Nmz4+HhgZ6eHlevXmXYsGFMnjxZfQPJkSNHKFiwIA4ODsCn3tMnT54AsqBnQn1cb8/a2pquXbsCmvMkQ0NDZbhPpJ/0bsmJGGFhYUpoaKj6/dWrVxWVSqXs3LlT8ff3V86ePavUrFlT0dHRUbJly6a8fftWURRFmTp1qlKsWDHF398/VpmZvbflzZs3yvv37xVFURQvLy/F3t5eWb58uaIon670FyxYoJQpU0bZvXu3oiiKEhwcrPTq1UtxcnJSSpYsqXh4eKRP5TORqKgo5YcfflAsLCyU2bNnp3d1UlVcPUibNm1SdHR0FDs7O/Xxf+wdOXXqlJI/f37l5s2biqLE9HAtX75cMTMzU9atW6dRpvSoxG/58uVKwYIFlX/++UdRlJhz28fz261btxQLCwvl9OnTio+PjzquQqQVacJnEHp6ehgYGKjf+/n5YWFhgaOjIzlz5qR8+fLMnj0bPT09Ro8eTY4cOYiOjkZRFMzNzdHX149VZmafkG5iYqKOma2tLYUKFVL31KlUKh49esSWLVtwdHSkUqVKAGTLlo0ZM2bg4eFBjRo16Ny5M6dPn06vQ8gU/vuIozlz5lCgQAHc3d3Tu1qpIq4FN7Nly4aRkRGDBw+OtQ7a8ePHyZ49O0WLFiUsLIyJEycyceJEhg8fTt26ddVlQuwFaEUMHx8f1q1bh7+/P/379+fPP/9EW1sbbW1t3r9/z6JFi4iOjsbFxQVdXV0WLlzIvn370rva4nuS3i05ETcfHx+lSpUqioODg7Jt2zbl999/V8qUKaNYWlqqe2EURVEqVaqk9OvXT/3+w4cPyvr165U2bdooISEh6VH1NPfxiv7PP/9UjIyMlHbt2ikjRoxQTE1NlVq1ainnzp1TFEVRDh06pMybN09ZtWqVetsKFSoo48ePj7PczN6jlxJCQ0OVZs2aKT/++KMSHh6uKIqiTJ48WVGpVMrEiRO/m16W4OBg9fft4zFHREQoAwYMUAYNGqQ8fPhQadKkiVKqVCn1/Kno6Gjl0KFDyvDhw5VOnTopS5YsSbf6Z2SjRo1Sqlatqpw6dUpZt26dYmNjo5QtW1Y5d+6ccv/+fUVXV1fZtm1beldTfMdklcIMysLCghMnTjBu3Dg2btwIxNx2vWnTJnUvjKenJ4GBgVStWlW93ejRozlz5gw2NjZkzZo1VrkfFx/MTD5e0f/000+ULVuWsWPH8uLFCzp37szUqVMxMDBg5syZzJo1i8KFCxMcHMxvv/3GhAkTKFy4MIqiEB4ejp6eHh8+fMDf3x9ra2uNu7dk/kXcNmzYwK1bt5gxYwa6urpER0czceJEevbsSWRkJAsXLiRr1qzqOUOZjaIoREdHky1bNnWalpYW0dHR6OjoEB0dzd69e/Hz8+Pu3bvs3buXfPnyATBw4ECuXLmCra0txYsX55dffmHz5s1s2LABCwuL9DqkDOXjenu1atWiUqVKVKpUiXr16jF9+nQaNGhAaGgolStXpkWLFsyYMYOnT58yd+5c9XITiqLIPDSR+tK5IScSIDw8XFm2bJlSpEgRjfS7d+8q9vb2yqlTp5SXL18qI0eOVPT19ZVNmzap51tdvnxZOXz4sLJr1y71dt/DnUL/vdvKy8tLqVq1qtKjRw8lPDxc8fX1VebPn6/kyJFDsbCwUObMmaMoiqLcvn1bqVKlilKmTBmlcuXKyuXLl9Or+t8Eb29vpVq1aoqJiYlibW0da27K9evXlZo1ayoNGjSI8+63zOi/363Q0FDFyclJUalUytixY5Xz58+rPztx4oSiUqmUcuXKKS9evFAUJaZXq1q1asqaNWtilfu99Oz9V0REhNKkSROlfv36ytOnT9VpH02bNk1RqVTKnTt3lHv37imFChVS2rdvH2dZ0rssUpNcZn8DdHV16dGjBxcvXgQgIiICiOmR8vb2xtHRUT3XZ/Xq1bRp04bAwEBmzZpFvXr1mDJlCgMHDqR48eJcvnz5u7hC++/dVrlz5yYyMhJTU1N0dXUxMzOjTZs2VK9enfz586t7Sz4+R23q1Kk4OztTs2ZNpk6dqp6zcvLkSf744w/CwsLS/oAyIDc3NxRFYefOnUyfPp2RI0fi4uKCl5cXAOvXryc8PJxhw4ape2cyO5VKRUhICIqiMH78eMLDwxkwYAC//vqrxiOQxo4dS5UqVbC1tcXe3p6xY8eSLVs28uXLx5UrV9R3kZ47dw74PudPhYeHU6hQIRo2bIidnZ26lw/g5cuXrF69mt69e2Nvb8/ixYsJCQlh+fLlAJw+fZqVK1dy4MABAI3eZSFSXDo35EQyjB49WjExMVEqVKiglCxZUuOK95dfflGsra2V+fPnK4oSc0X7888/K3Xr1lU+fPiQXlVOcx97CGbPnq0YGBgo/fr1U2bMmKFUrFhRMTc3V/eivH37VqlZs6bSt29f9barV69W3NzcFF9fX2XPnj3KqFGjFGtra+Xx48fpciwZybVr15RKlSopEydOVKf5+voqrq6uyr1795RTp04pVapUUYYMGZKOtUx7y5cvV1QqlVK+fHnFyMhI2bFjR6y5U76+vkqJEiXUc/UOHDiglCpVSrG2tlYcHR3V/wZfvnypqFQqZe7cucqjR4/S5Xgygo/f4Y+9SpGRkcrUqVMVQ0ND5c2bN8qxY8cUMzMzxc3NTVEURdmyZYtiZGSk1KhRQzE3N1cqV66s3L17N93qLzI/aUh9wzZs2KBoa2srDRo0UHx9fdXpFy9eVKpWrarkz59fMTY2Vk+mDgsLU/LkyaMcP348vaqcri5fvqwMGjRI6devn5ItWzalbdu2Gp8fOnRIcXR0VKZOnaqEhIQowcHByqtXr5SAgAClQoUKikqlUjp16pROtc844hpy+e/QU2hoqNKjRw+levXqyq1bt2J9ntkdOHBAWbdunfrYPxcREaFUqVJF6d69uzotPDxcWbx4sXqoXlEUZeDAgYpKpVIaNmyouLi4KCVKlFCePHmSJseQkV25ckUxNDRU5s2bp3z48EFp2bKlUrJkSfXnnTt3Vtq1a6eEhoYqoaGhSseOHZWaNWsqz58/T8dai8xMGlLfuNevX6tPEB/nD5w4cUIxNTVVrl27ppw6dUopXbq0ki9fPmXevHlK9uzZ4z3Bfy+ePn2q1K9fXzl8+LCiKDHxCgwMVBRFUVasWKFUrFhR2bFjhzq/j4+P0qlTJyV//vyKoaGhUrJkSfW8lu9RSEiIMnToUGXu3LmKonzqMfj4/9WrVysVKlRQZsyYkW51zOhWrlypuLi4xFrH7OMq/efOnVO0tbWVESNGKB4eHsrz58+V33//XX0H6vdszZo1iq2trRIdHa1s2LBByZkzp+Lu7q4oSkxv1YIFCxQDAwP1vNCXL18qe/bsUQICAtKz2iITk4ZUJvTPP/8o2bNnV968eaMoSkxP1Lx58xQLCwulXLlyipeXVzrXMON4/vy50qRJE2XLli3qtF69eimOjo7qZSY+9hRs375dURRFGTt2rHLw4MF0qW9G8t8G1Mcep6dPnyo//PCD0rRpU+X169eKonxfvVEJFR4ervTp00cxMDBQunTpoqxatUq5ePGi+vPq1asrtWrV0vjxj4yM/G4m7X9NcHCw4u/vrxQqVEipXbu2oigx57mPJk2apDRv3ly5dOlSrM+ESGky2TwTqlOnDiVKlGDDhg1AzGKf/fv35+bNmyxYsABra+t0rmHGYWZmhqOjIz///DMjRozg0qVL3Lt3j3z58qEoCteuXWPnzp3Y29vTrFkzAH799Vdq1aqVzjVPfx9vWlCpVOrJ0Bs3buTVq1e0b98eU1NToqOjZemIzyiKgq6uLosWLeLixYsoisKtW7f48OEDAH/99RenTp3i119/xdjYWL2dtrZ2nI+s+R5ly5aNnDlz8scff7By5UoAFixYwJ49ewDo2rUrenp69OvXj8DAQPT09NKzuiKzS+eGnEhhH3sJ3NzcFCMjI6VPnz7KlStXlLNnz6ZzzTK206dPK2XLllXKli2r1KlTR/0oCldXV8XBwUE9BCM9AvF79uyZUqZMGcXMzOy7nhydEFFRURo9dR+Hlt+/f69YWloq/fv3T6+qfZMCAgKUFi1aKE2aNFH/29uyZYtStGhR9eN5hEgtKkWRp7VmVjdu3GDo0KG8fv2aOnXqMGnSJI2FA0Vsnp6e5MmTBy0tLV69ekWjRo0oU6YMixcvlsX9EuDmzZt06NCBZ8+eMXz4cPr27avRqyI0fd5jd/bsWX788UdOnDhB/vz507Fm3543b97Qp08f9u/fT4sWLTh37hxWVlasW7cOW1vb9K6eyMSkIfUduHHjBiYmJtjY2KR3Vb4pb968oXTp0ixYsIDGjRvLMFUirFmzhmHDhmFoaMjSpUupU6dOelfpm/FxlX2RNKdOneKff/6haNGiODs7U6JECbkIEqlKGlJCxCMsLIyRI0eyePFiZs6cyYABA9K7St+cMWPGEBoayuzZs6URmgCZ8RFOQmR20pAS4iv27NnD+fPn6d+/P2ZmZuldnW9OREQEurq60isghMiUpCElhBBCCJFE0tcuhBBCCJFE0pASQgghhEgiaUgJIYQQQiSRNKSEEEIIIZJIGlJCCCGEEEkkDalMLiwsjEmTJhEWFpbeVfkmSfySTmKXdBK75JH4ibQkyx9kckFBQRgbGxMYGIiRkVF6V+ebI/FLOold0knskkfiJ9KS9EgJIYQQQiSRNKSEEEIIIZJIJ70r8K2Ljo7m5cuXGBoaZsjHXwQFBWn8XySOxC/pJHZJJ7FLnowcP0VRePfuHdbW1qn6/MkPHz4QHh6eImXp6elhYGCQImVlRjJHKpmeP3+Ora1teldDCCHEN+TZs2fkzp07Vcr+8OEDWXIZQWhEipRnaWmJp6enNKbiIT1SyWRoaAjA4hNdyZJdL51r8+1pkr9BeldBfKcCw16ndxW+WSdeXEzvKnyz3geH06fqKvVvR2oIDw+PaUR1KAl62sksLAqfP68SHh4uDal4SEMqmT4O52XJrkdWQ2lIJZaRUbb0roL4TkWHhaR3Fb5ZWYPkXJdcaTIVxEAHlV7yfuYVrYw3ZSWjkYaUEEIIkQmptFSoktsQ0lIh83++TO7aE0IIIYRIIumREkIIITIhlSoFeqRU0iP1NdKQEkIIITKhlBraE18mQ3tCCCGEEEkkPVJCCCFEJqRSqZJ/d2AGXGg6o5GGlBBCCJEJydBe2pChPSGEEEKIJJIeKSGEECITkh6ptCENqQzmwPrr7Fh+hQDfEHIXMqHruCo4lLWJM+/8kYc4/s/dWOm5C5owe99PsdJP776P25ADlK2dj5GLGmt89sYnmPUzznDlxFPCP0RilTcHP7vWooCTOQDvQ8JZP/MMFw495l3AB8xtjGjQqQT1fiqWAkedMhYt3MmsmVvw9n5D0aJ5mTX7Z6pUib9+x49fY8SwJdy69QRr61wMH9Ga3n2aqD9fvmwv69Yd4tbNJwCUdi7E1F+7Ua6cvTpPgXwdePr0Vayyf/65CfMWDARAR6tOnPufNr0nw0e0TsqhpjiJXfKsXHKI+bP38MongCKONvz6e0dcKtvHmdfH+y0TR6/n2pUnPH7oQ6++9fh1ZsdY+RbP28eqZYd58cwPk1yGNGlRjglT2mBgELOqeKkig3jm5Rdru269a/O7W9dY6UP7r2DtiiNM/b0DfQZknEczyTkv9UhDKm2kW0Pq2LFj1KhRg7dv35IjR44UKXPSpEls376dq1evpkh5ae30nvus+vUkPSdVp0hpKw5tusmvPXYxe99PmFnHfi5T1wlV+WlERfX76EiF4U034tKgYKy8r18EsXbaKRzKWMf6LDjwAxPa/k3R8rkZu7wJxrmy8sorkGyG+uo8a347yc2zLxg4qy5mNkZcO+XF8knHMLHIRtna+VMoAkn31+ZjDB2yiPkLBlCxUlGWLdlD44ZjuXFrBXZ25rHye3p606TReHr0aMCadaM4c/oW/fvNw8wsBz+0rALENBbatq2BS0VHDAz0mPn7XzSoN5rrN5djY2MKwNnz84mKilaXe/PmE+rXHUXLVtXUac9fbtbY9/595+nZ4w/1ftKbxC55/tniwbgR6/h9TlfKuxRmzfIjtG3+O6cv/05uO9NY+cPDIzE1NWLoqGYsnrcvzjK3bDzNlAmbmbO4J+VcCvPogTf9ey4B4NcZMY2uQ6emaMTv7u3ntGzkStMfyscqb+/Oi1y+8BBLq5wpccgpRs55qUsaUmkjU82RGj58OIcPH07vaiTZ7pVXqfmjI7VaFyV3QRO6jq+KqWV2Dm64EWf+bIb65DTLpn49uvmKkMAP1GjpoJEvKiqaOcMO0npQecxtjWKVs33pJXJZZaff9NoUKmGJeW4jilW0xTKPsTrP/Ss+VG9hT9HyuTHPbUSdtk7ksTfl0Q3flA1CEs2evZVu3erTvUdDHBzy8IdbX2xtzVi8aFec+Zcs3o2dnRl/uPXFwSEP3Xs0pGvXesyatUWdZ92fY/i5b1NKliyIvb0dS5YNITpa4cjhK+o8ZmY5sLQ0Ub/27j5LgQLWVKtWXJ3nv59bWpqwc6cH1WuUIH9+q9QLSCJI7JJn0dx9/NSlOh271qCwvQ2/zuyIde5crFrmHmd+uzxm/DarE21+qoKhUdY481w894ByLoX5sW0l7PKYUaN2cX5o7cK1y57qPKZmRlhY5lC/Du69Qr78FlSqovn9937hz6ghq1m8qh+6usl8gG0Kk3OeyAwyVUMqe/bs5MqVK72rkSQR4VE8vuVLicp2GunFK9tx77J3gso4suU2xSraYmajeeL4e/55jEyyUKtV0Ti3u3jYkwJOFswasI/u5ZczoulG3Dff1Mhj72zNxSOevPEJRlEUbp59jveTAEpUsYuzzLQUHh7B5Uv3qVPXWSO9Th1nPDxuxbnN2bN3qFNHM3/demW4dPE+ERGRcW4TGhpGREQkOU3ifmp7eHgE69cfpkvXevHecvzq1Vv27jlHt24ZY2hFYpc84eGRXLviSY1amsM9NWoV4/zZB0kut3zFIly74snlC48AeOLpi/uBa9SpXzLeemzZdIr2natpxC86Opqfuy+i/5DG2DvmTnJ9UoOc81Lfxx6p5L7El6VKQ+rJkyeoVCo2bdpExYoVMTAwoGjRohw7dizebd68eUO7du3InTs3WbNmpVixYmzcuFH9+dq1a8mVKxdhYWEa27Vs2ZJOnToBMUN7JUuWVH/WpUsXmjdvzsyZM7GysiJXrlz069ePiIgIdR5vb28aNWpElixZyJcvHxs2bCBv3ry4ubnFWc+wsDCCgoI0Xinh3dv3REcp5DDVvELNYZqFAL/Qr27/1jeEKyeeUqu15onj7qWXHNlymz5Ta8a7re+zIA5uuIFVXmPGr2xG3XbFWDnlBMf/uaPO03VCVXIXNKFPlVW0c1zIr9120GNS9Ti7zdOan18gUVHRmFtoDluYW+Tklc/bOLd55eMfZ/7IyCj8/ALj3Gbs6Jhhqdq1S8f5+Y7tZwgICKZzl7rx1nXtmoMYGmalxQ+Vv3RIaUZilzxv/N4RFRWNmbmxRrqZhTG+r+KORUL80NqFMRN/pFGtyVgadqKM4xAqV3Nk0Iimcebfu/MigQGhtO1QVSN97qxd6Oho0atfvSTXJbXIOS/1SUMqbaTqHKkRI0bg5uaGo6Mjf/zxB02bNsXT0zPOXqMPHz7g7OzMqFGjMDIyYs+ePXTs2JH8+fNTvnx5WrVqxcCBA9m5cyetWrUCwM/Pj927d7N///5463D06FGsrKw4evQoDx8+pE2bNpQsWZKePXsC0KlTJ/z8/Dh27Bi6uroMHToUX9/4u25dXV2ZPHlyMiPzBZ/9m1WUhK2HdmzbHbIZ6WuM3b8PDmfu8EP0+bUmRiZZ4t02WlEo4GRO+2Excw/yFTXj2YM3HNhwk2otYrrM9629xv2rPoxa3BgzG0NuX3jB8knHyGmWleKVMsYV2uc9GYqifHExurjyx5UOMOP3zWzadIzDR2eqJ/t+buXKfdRvUA5r69jzYj5aveoA7dvXjLeM9CKxS56445f08k6duM3s33fw+5yuOJctgOejV4wdvg4LyxwMH9MiVv71a45Rq14JrKw/NXCvXvZk6YIDHD7za/IXZUxNcs4T37hUbUj179+fli1bArBo0SL279/PihUrGDlyZKy8NjY2DB8+XP1+wIAB7N+/ny1btlC+fHmyZMlC+/btWbVqlbohtX79enLnzk316tXjrUPOnDmZP38+2tra2Nvb06hRIw4fPkzPnj25e/cu7u7uXLhwgTJlygCwfPlyChUqFG95Y8aMYejQoer3QUFB2NraJioucTHMmQUtbRUBrzWvxALfvMc4V9zzKD5SFIUjf9+majN7dPU+zYHw8Qrk9fMgpvXe/SlvdMwPXhv7+cw50BHLPMbkNMtG7oImGmXaFDDh7MGYYYWwD5Fs+MODEQsa4lwjHwB57E15csePnSuupPtJxdTUGG1tLV75+Gukv/YNwNwiR5zbWFiaxJlfR0ebXLk0hwlmzdzCNNeNHDg0neLF455k+vTpKw67X+Hvrf+Lt54nT97g3r1nbNg0LgFHlTYkdsmTy9QQbW0tfF8FaKT7+QbF6qVKjGmT/6ZVu8p07FoDAEcnO0JCwxjWbwVDRzVDS+vTYMKzp685fuQmqzcN1ijj7Om7vPYNomThgeq0qKhoJo5ez5L5+7lyb06S65cS5JyX+mSyedpI1YaUi4vLpx3p6FCmTBnu3LkTZ96oqCimTZvG5s2befHiBWFhYYSFhZEtWzZ1np49e1K2bFlevHiBjY0Nq1atokuXLl+82ipatCja2p++aFZWVty4ETOR8d69e+jo6FC69KfhhoIFC5IzZ/x3tujr66Ovrx/v50mlq6dN/qLmXD/9jPJ1C6jTr5/2+uodIrfPv8DnaSA1WzlqpNsUyMmsPe010jbN9uB9SARdx1cll1V2AIqUtuKlp+YwjveTAPVdM1ER0URFRKP12RdKS0ulPkmlJz09XUo7F8b90GWat/g07OPufpkmTSvGuU2FCg7s2X1WI+3QwUs4lymMru6nr8XMGX/x26/r2bvflTJlisRbh9WrDmBunoOGjWLfMfXRqpX7cHYuRIkSBeLNk9Ykdsmjp6dDiVL5OHbkJo2alVWnHztygwaNnb+w5ZeFvg+L9X3T1tJCURSUz75yG9adwNTcmLoNSmmkt25fmWo1nTTSWjWZTuv2lWnXSXMIMD3IOS/1qUiBR8R83mUoYknz5Q/i+0udNWsWs2fPxs3NjWLFipEtWzYGDx5MeHi4Ok+pUqUoUaIEa9eupV69ety4cYNdu+K+s+gjXV3dWPuPjo65ZVj5/Iz0r/jSU1vjbiWZN+IQBZzMKVzKEvfNt/DzDqZuu5iT4fqZZ/B/FcyAGZrzSA5vuU2hEhbYFdYcMtXT14mVlvXf23v/m964a0nGt/mbbYsu4NKwEA+vvcJ98016T6n57zZ6OJazYd300+gZ6GBqbcjt8y85vv0uncdkjNvQhwxpSedO03EuU5gKLg4sW7oXLy9feveJWTtm7JgVvHzpx+o1owDo3acxCxfsZNjQxfTo2YCzHndYuXI/6zeMVZc54/fN/G/iGv5cP4a8eS3x+bcXJnv2LGTP/mnYIDo6mjWrD9CxUx10dOK+KyooKIS/t5xkxsxeqRWCJJPYJc/PAxvQt/siSpbOR9nyhViz4ggvnr2hS49aAEyZsAnvl29ZuOJn9TY3rj0BICTkA35+Qdy49gQ9PR2KOMRMCK/XsDSL5u6lWIm8OJeLGdqb9svf1GtUGm3tT71R0dHRbFx7nLY/VYkVP5Nchpjk0pzcr6urjbmFMYUKZ4x5PnLOE5lBqjakzp49S9WqMVc+kZGRXLp0if79+8eZ9+TJkzRr1owOHToAMSeIBw8e4OCgeVtrjx49mD17Ni9evKB27drJGlazt7cnMjKSK1eu4Owcc/X48OFDAgICklxmclRqVJjggA/8veA8b31DsC2ci7HLmqjvSHnrG4Lfy2CNbULehXHuwCO6jk/6l7tgcQtGLGjI+lke/D3/Aua5jegyrgpVmn3qRRjsVo8NMz2YM+wgwQEfMLMxpN1QF+q2d/pCyWmndZvqvHkTxNQpf+Lt7Y+TU1527fmVPHksAPDxeYOX16e5b/nyWbFrz1SGD13MooU7sbbOhducvhrrEy1etIvw8Ahat/pFY18TJnbkf5M6qd+7u1/Gy8uXrt3qx1u/zZuOoSgKbdvFPwE2vUjskqdFKxfe+gcz87d/eOUTgH3R3GzcPgLbPGYAvPIJ4PmzNxrb1KjwaYjy2mVPtm4+g62dqXq4bdjo5qhU4Dp5C94v/cllakS9RqUYN0lzEdLjR27y/Nkb2neuxrdIznmpS4b20oZKSYXulydPnpAvXz7s7Oxwc3PDwcGB2bNns2HDBjw9PTE1NY21IOeQIUPYunUrmzZtImfOnPzxxx/89ddf1KhRg+3bt6vLDgoKwsrKisjISNauXUubNm3Un32+IGeXLl0ICAjQ2H7w4MFcvXpVfQdhnTp18Pf3Z9GiRejq6jJs2DDOnj2Lq6srgwYN+uqxBgUFYWxszJrLvclqmPEmwWZ0LQrEfReSEKktIEzWA0qqo8/Pfj2TiFPou3A6l15CYGAgRkax17hKCR9/l4zG10RlkLz+EuVDJEFTj6Rqfb91qbqO1LRp05g+fTolSpTg5MmT7NixA1PTuO/KmTBhAqVLl6ZevXpUr14dS0tLmjdvHiufkZERLVu2JHv27HF+nlhr167FwsKCqlWr0qJFC3r27ImhoSEGBgbJLlsIIYQQmVuqDu05ODhw9mzcVy7Vq1fXmItkYmKi0XP0Jd7e3vz000+xJn1PmjSJSZMmqd+vXr061rafrw9lZWXF3r171e+fP3+Or68vBQvGfuSAEEII8a2Qob208U09tNjf35+DBw9y5MgR5s+fnyJlHjlyhODgYIoVK4a3tzcjR44kb9686rldQgghxLdIGlJpI8ENqY/znhLiv0sWpKTSpUvz9u1bpk+fTpEi8d9OnRgRERGMHTuWx48fY2hoSMWKFVm/fn2su/2EEEKIb4lKixRoSKVMXTKzBDekdHV1E9x4KVy4MDt37kxypeLz5MmTFC+zXr161KuX8R6fIIQQQoiML8ENKRsbG+7evZuadRFCCCFESkmBoT1Fhva+6puaIyWEEEKIhEmJOVLy0OKvk9FPIYQQQogkkh4pIYQQIhOSHqm0IQ0pIYQQIhNSqZL/0OLkP/Q485OhPSGEEEKIJJIeqRTy+n0EWbSl5Z5YOn3Hp3cVxHeqV6tv5+GzGU0JU1lnL6nev49Is32pVCkwtCc9Ul8lDSkhhBAiE5I5UmlDGlJCCCFEJiQNqbQhc6SEEEIIIZJIeqSEEEKITEhLK+aVvEJSpCqZmjSkhBBCiExIW6VCS5Y/SHXS1hRCCCGESCLpkRJCCCEyIW0tFVoy2TzVSY+UEEIIkQlpq1Qp8kqMEydO0KRJE6ytrVGpVGzfvv2L+Y8dO6Zegf2/r7t37ybjyNOW9EgJIYQQIkWEhIRQokQJunbtSsuWLRO83b179zAyMlK/NzMzS43qpQppSAkhhBCZkJYWaKfxXXsNGjSgQYMGid6Nubk5OXLkSPR2GYE0pDKYE5tv4r76GoF+oVgVyMmPIytRsLRVvPnP77mP++pr+HoFkiW7Ho4VbWkxzIXsOQwAiIqI4sCKK5zbdZ8A3xAs8uag2eDyFK1kp1FOwKtgtrud4/ZpL8LDojDPY0yHSdWxc4y5KvgQGsEOt7NcP/qEkMAPmFgbUr19Maq2Lpp6wUiEKgVLMqJOB5ztimCdw4zmi0ey49qJL27Tt1pL+ldrRd5clni9fcWv+1az7tw+jTyDarbh56o/YJfTAr/gQP6+coQx2xcRFhkOQHb9rExp2osWJaphbpiTK8/uM2jLbC4+vaMuw9zQhOkt+lHXoRw5shpy4sEVBmz+g4evn6V8IJJAYpd03te9ubb5Bn4P3hD6JpS6k2uRt3LeePOHvgnFY/E5/O6/IfBFIE4tilKxXwWNPNGR0VzZcI37Bx8Q6heKsa0x5XuWxbZcbnWeKxuu8eTUEwK8AtHW18bC0ZzyvcqSwzaHOs/FNZd5dPQxIa9D0NLRwqywKWW7OWPuYJ7SYUgWOeelnqQMzcXy7/ZBQUEayfr6+ujr6yev7P8oVaoUHz58wNHRkfHjx1OjRo0UKzu1ffdzpKpXr87gwYPV70NDQ2nZsiVGRkaoVCoCAgLSrC6X9j/k79/PUK9nacZs/pGCpa1Y0HcP/t7v4sz/8LI3a8cfxaW5PeO3tqb7jDo8veXLhknH1Hl2zb/Aqb9v02p0JSb804bKrRxZNuQAz+74qfOEBoUxq8t2tHW06LugIRO2teaHYS5kMdRT59k64zS3zzyj8281mfBPG2p2KM6Waae4dtQz1eKRGNn0s3DtxQP6b56VoPx9qv6Aa7O+TNqznKJT2vO/3ctY0HY4jYtVVudpX7Ye05r3ZfKeFThMbkf3P3+ljXNtXJv/rM6zvMNY6tiXo+PqyRSb2oGDd87jPmge1safuqW395lOflNrmi0eSanfOvHU3wf3QXPJqmeQcgFIBold0kW8jyRXARMqDXBJUP6oiCiyGBtQ6qcS5CpgEmeeCysvcmf3XSoNcKHVyh9wbGLPwf+54/fg03fW+7o3jk0daDa/CY1+r48SpbB35H4i/vMctxy5jak0wIUfl7Wg6ZzGZLfIzp5R+3kf8D55B52C5Jz37bC1tcXY2Fj9cnV1TZFyraysWLp0KVu3bmXbtm0UKVKEWrVqceLEly/mMhLpkfrMmjVrOHnyJGfOnMHU1BRjY+M02/fhdddxaWFPpR8cAPhxZCVun3nGyb9u02xQ+Vj5n9x4RS5rQ2r8VAwA09xGVP7RkUOrr6rznN9zn3o9SuNUJQ8AVVsX5c6ZZxxee40urrUAOLjyCjktstNxyqcrgFw2n8aqATyvvaJCkyIULmsDQOUfHTn19228br2mRI18KReEJNp/y4P9tzwSnL9jufosOfUPf11yB8DT7yUV8jkxqm5Hdt84BYBLfidOP7rOxgsHAXjq783Gi4col9cRAANdfVqWqk6zxSM5+fAqAJP3LKd5iar8XO0HJuxcQiFzW1zyF6PoL+247R1zAu67cQa+v++jXdm6rDi9M4UikHQSu6SzK2+LXXnbBOc3tDSkYv+YRte9/ffjzPPA/RGl2pdQl+vY1IhnF55zfctNao6tDkDDafU1tqk2sgrrWm7A74EfVsVjenMK1iqgkcfl5/Lc23cf/8dvsSmdJcF1Tk1yzktdKdkj9ezZM405TCnVG1WkSBGKFCmifu/i4sKzZ8+YOXMmVatWTZF9pLbvvkfqc48ePcLBwQEnJycsLS3TbDGyyIgont15jYOL5knZwSU3j6/5xLlN/hKWBLwK5ubJpyiKQtCbUK64P1afQAAiw6PQ1dPW2E5XX4dHV73V728cf4pdUTOWDz/IqOqrcW29hdNbb2tsU6CUFdePPyHgVTCKonD//At8nwbiUDHhPyIZib6uHh8iwjXS3oeHUS6vIzpaMfE69egaznb2lM0T8+Ofz9SahkUrsufGaQB0tLTR0daJXU5EGJULlIjZj07MFe5/80Qr0YRHRajzfGskdqkrKjwK7c++szr6OvjcfBXvNuEhMT1R+oZx/7hFRURxZ8899LLpxdsTltbknJf6tLVUKfICMDIy0nil5LDe5ypUqMCDBw9SrfyU9k33SJ05c4a+ffty9+5dnJycGD9+PC1atODKlSuULFkSgOPHjzNixAiuXbuGiYkJnTt3ZurUqejoxD706tWrc/z4cSBmNddq1apx7NixNDmW4LcfiI5SMMqleaVomCsrQX5xzwfJX9KSzq61WDnSnYjwKKIjoylWPS+tR1dS53GoaMvhddcp6GyFqa0x98495/qxJyhR0eo8fs+DOPnXbWp2LE697qV5ctOXLdNPo6OnTfkmMVcKrUZXYsPk44yr+ydaOlpoqaD9/6p/cS5DRnbg9ll6VGrK9mvHuex1D2c7e7pVbIKeji6m2XPgE/SGzRfdMcuek1PDl6BSqdDV1mHh8a1MP7gOgOCwUM48us6Eht244/OEV0H+tCtbl/J5i/Lg3zk8d32e8OSNN67Nf6b3humEhL1naK12WBmbYmWcKz1DkGQSu9SVu6wNN/6+iVVxS4ysjXhx+SVPzjxFiVbizK8oCh6LzmHpZIFJPs1G0lMPLw5PPUpkWCRZTbLS8Pf6GBhnjGFROeelPm1A+xtcBurKlStYWX07cf5mG1Lv3r2jSZMmNGzYkA0bNvD06VONuU4AL168oGHDhnTp0oW1a9dy9+5devbsiYGBAZMmTYpV5rZt2xg9ejQ3b95k27Zt6OnpxcoTFhZGWFiY+v3nE/CS7fN/9IoSb6+Y9yN//p5+mga9nXGsaEvg61D+me3Bxqkn6TC5OhDTVb7hl+P80nwzKlVMV7hLsyJ47Lj3aRfRCnZFzWg2MKYr3dbBFO9H/pz867b6pHJsww08r7+iz5z6mFgb8uCSN5t/O4mxWVbsK+T+vGoZ3pS9q7A0ysXZkStQAa/e+bPaYw+j6nUkSok54VYrVJpx9bvQd9MMznneoqBZbua0HoJ3oB9T960CoOPqyazsOI6X03YTGRXJ5Wf32HDhIKXtYuIWGR1Fy6WjWdFhHG9nHSIyKhL3uxfYe/NMeh16sknsUlfFfhU4MesUf3XdCoCRtRFF6hXm3oG4hwJPz/XA/7E/Tec0jvWZdUkrWi5twYfAD9zdc4/DU47QfH5TsuTMGEN7gJzzMpng4GAePnyofu/p6cnVq1cxMTHBzs6OMWPG8OLFC9auXQuAm5sbefPmpWjRooSHh/Pnn3+ydetWtm7dml6HkGjfbENq/fr1qFQqli1bhoGBAY6Ojrx48YKePXuq8yxcuBBbW1vmz5+PSqXC3t6ely9fMmrUKCZOnIjWZ09zNDExIWvWrOjp6WFpaRnnfl1dXZk8eXKKH0/2nAZoaasI8tOcCPrO/z2GueI+6R1YcYX8JS2p06UkADaFc6GXRYfZXXfQpH9ZjM2yYWiShd5u9YkIiyQk4APG5tnY4XaOXNaG6nKMzLJilT+nRtmW+XNy1f0xAOEfItk59zy9ZtfDqWoe9b5e3PPDfc21b/Kk8iEijO7rfqX3+mlYGJngHfiGXlWaE/Q+BL/gAACmNO3FuvP71HNxbr58RDb9LCz9aTS/7l+Noig89ntB9dl9yapngJFBNnyC3rCp+1Q8/V6q93XZ6x6lfuuEkUE29HR08QsO4OzIFVz0uhNX1TI8iV3qypIjC/Wm1CEyPJKwwDCymmbl/LILGFkaxsp7ep4HTz28aDK7EdnNssX6XDeLLsY2uhjbGGHhaM6mTlu4u+8+pdqn/9ConPNS33+H5pIskdtfvHhR4467oUOHAtC5c2dWr16Nt7c3Xl5e6s/Dw8MZPnw4L168IEuWLBQtWpQ9e/bQsGHD5NU7DX2zc6Tu3btH8eLFMTD41E1drlw5jTx37tzBxcVF4+qmUqVKBAcH8/z58yTtd8yYMQQGBqpfz56lzG3YOrra2DqYcfesZnl3z74gf4m4G3URHyJjXblp/duPq3w2CqCrr0MOi+wxt1YffkzxGnnVnxUoacmrJwEa+X2fBmDy74knKjKaqMjoWI8KUGmp4h1u+FZERkfxIuA10Uo0bZ1rs/vmKZR/g5dVz4Doz44vKjoKFaD67DI6NPwDPkFvyJHVkHqO5dlxPfYdJ0EfYhoaBc1sKZPH/qtLDGR0ErvUpaOnQzazbChRCp4nn5Cn4qd5QIqicGruGTxPPqHxzAYYWcVuZMVJUYiKiEqlGieOnPNSn1YKrGqe2IceV69eHUVRYr1Wr14NwOrVqzWmzIwcOZKHDx/y/v17/P39OXny5DfViIJvuEdKiaP7V/nsm/SlPEmdRJ7Sa2f8V62OxVkz7gh2jubkL2HBqa238fd+R+VWMRN2d8w5R4BvCJ1/rQmAU7U8bPjlBCf+uvVvN3cIf884Qx4nc3KYx1ydel5/RaBvCLntTQnwDWHPooso0Yr6ig6gZofizOy8nf3LL1O6bgGe3vTl9N93aDcx5o6JLNn1KFTGin/+8EBXXxsTK0MeXHrJ+d33+WF4xVSJRWJl089CQbNPV4n5cllTInch/EOCePb2Fb81+xmbHGZ0XvMLAIXMbSmXtyjnPG+RM6shQ2u3w8m6AJ3XTFGXsev6KYbWaseV5/f+HZ6yZUqTXuy8forof4ew6jqUR6VSce/VUwqa2TLjh/7ce+XFqjO71eX8WLomr98F4PXWh2LWBZjTeijbr53g0J3zaRSdL5PYJV3E+wgCX3wa3g/yCcbv4RsMDPXJbpGd88svEOIXSo3R1dR5/B6++XfbSD4EfsDv4Ru0dbTImTemh8T3ji8hfqHkKmBCiF8ol9ZeRlGgRNti6jJOzz3Dw8OPqTulNrpZdQn1DwVAL5seOvo6RLyP4Mr6a+SpaEfWXFkICwzj1s47hLwOJX+1jHPHmZzzRGbwzTak7O3tWb9+PWFhYeqGzcWLFzXyODo6snXrVo0G1ZkzZzA0NMTGxibN6/w1zvULEhL4gX1LLxL0OhSrgib0XdBQ3SUd6BfCW59P66u4NLMnLCSC4xtvsm2WB1kN9Shc1obmgz/dNhwZHsWuBRfwex6EflZdila2o/OvNclq9KkxmMfJnF5/1GPn3HPsW3KJXDaG/DiyIuUaFVbn6Tq9DjvnnGP1mMOEBoVhYmVIk/7lqPLvCS+9lbFz4NjQher3s1sNBmC1xx66rp2ClbEpdiafrnK1tbQZVrsdRSzyEBEVydF7l6g4sydP/T/d2TN13yoUFKY26Y1NDjNeBwew68Ypxu1YrM5jnCU7rs1/JncOc/xDg9h65SjjdiwmMvrTVb+VsSl/tBz07zCYH2vP7WPK3pWpGI3Ekdgl3et7fuwetlf9/uyicwAUrluI6qOqEvrmPcG+wRrbbOu9Xf1nv/t+PDz8iOwW2Wm/oQ0Q8529sPIS77zfoZNFB7vyttQYXQ397J++s7d3xjyHbPfQvRplVxtRhSL1C6PSVhHwLID7kx7wIegDBkYGmBUxpYlbI0zyag5ppSc556WulBjaU+ShxV+lUj7vxvlGBAUFkS9fPho3bszo0aPx8vJi8ODB3L17l6tXr1KiRAlevHhB4cKF6dq1K/379+fevXv06NGDfv36qSebV69enZIlS+Lm5gbA4MGDuXr1aoLv1gsKCsLY2JiZp7uRJXvsyeniy/otupLeVRDfqV6tnNK7Ct+sEqa66V2Fb9b74HCGV1pJYGCgxrpMKenj71Kl1T+ikzV5f1eRoRGc7vJ3qtb3W/fNzpEyMjJi165dXL16lZIlSzJu3DgmTpwIoJ43ZWNjw969ezl//jwlSpSgT58+dO/enfHjx6dn1YUQQgiRSXyzQ3sAFStW5Nq1a+r369evR1dXFzu7T89UqlatGufPxz+f4vOep489U0IIIcS3TIb20sY33ZBau3Yt+fPnx8bGhmvXrjFq1Chat25NliwZaI0UIYQQIh2kxCNilDR6use3LEMN7T158gSVSpWgl5OTEz4+PnTo0AEHBweGDBlCq1atWLp0aXofhhBCCCG+ExmqR0pXV1fj4YVfkj9/fkaOHMnIkSNTuVZCCCHEt0dbRQr0SKVQZTKxDNWQsrGx4e7du+ldDSGEEOKbp6UF2skcd4rOUONWGVOGakgJIYQQImWkxBypaJkj9VXS1hRCCCGESCLpkRJCCCEyoZRY/iBalj/4KmlICSGEEJmQDO2lDRnaE0IIIYRIIumRSiGdHRpiZJQtvavxzem1oEV6V0F8p8KjPqR3Fb5ZOlryXNGkCgoKYThp8+BtbblrL01IQ0oIIYTIhLRJgaE9ZGjva6StKYQQQgiRRNIjJYQQQmRCWilw116U3LX3VdKQEkIIITKhlLhrL7nbfw9kaE8IIYQQIomkR0oIIYTIhFLirr3kbv89kIaUEEIIkQnJ0F7akIaUEEIIkQlpq2JeyS1DfJl02gkhhBBCJJH0SAkhhBCZkJZKhVYyh+aSu/33QBpSQgghRCaklQJDe7KM1NfJ0F4Gs3jRbgoX7IJRtqZUKDeAUydvfjH/iePXqVBuAEbZmlKkUFeWLtmj8fnaNYfQ12kQ6/XhQ7g6z5TJf8b63M6mvUY52/85TaMG47C2aIO+TgOuXX2UcgedQhYt2kWhAp3InrUx5cr249TJG1/Mf+L4dcqV7Uf2rI0pXLAzSxbv1vj8n22nKF+uP6YmP2Bs2BTn0j/z5zr3WOW8eOFHp47TsTD7EaPsMfkuXXqg/lxRFH6ZvA673O0wzNaEWjVHcOvWkxQ55pQisUuepYv34li4JyaGP1Kp/FBOn7oVb15vb3+6dJxFyaI/k12/OSOGLY8z3/ZtZ3Au3o+c2VviXLwfO7d7aHzuUKgn2fSaxXoNGbhYI9/dO89o1WIqVqbtsDBpQ/XKI3jm9Tr5B51C5JwnvnXSI5WBbPnrOMOHLmHu/H64VHRk+bK9NG08gas3lmBnZx4rv6enD82aTKRbj/qsWjMCjzO3Gdh/AWZmxrT4obI6n5FRVm7cXqaxrYGB5kNHHYvmYd+B39TvtT+75zUk5AMVKzrS8scq/Nx7Tkocbor6a/Mxhg1ZzLz5/alYqSjLlu6hcaPxXL+5LN7YNWk8nu49GrBm7SjOnL7FgP7zMTMz5oeWVQAwMTFkzJh2FLG3RU9Phz17ztGj+yzMzXNQt14ZAN6+fUe1KkOpVr04u/ZMxdw8B48feZMjx6cHWM+c8Rdus7exYuUwChXOjeuvG2hQbwy37qzA0DBr2gToCyR2yfP3XycZOWwFbvN6U8HFgRXLD9CiyS9cujYfWzuzWPnDwyIwNTNixOhWzJ+7M84yz529S6efZjBh0k80bVaBnTvO0rH9DNyPuVK2XBEATpyZSVRUtHqb27ee0qTB/2jRspI67fEjb+rUGEOnLrUZN7E9xsZZuXf3OfoGuikchaSRc17q0lIlv0dJeqS+TqUoipLelfiWBQUFYWxszGv/vzEyyvb1Db6gsstgSpYuwPwFA9RpxZ160bSpC1N/6xor/9jRK9i9+xzXby5Vp/XrO48b1x5z4vRsIObqbPjQJfi++Tve/U6Z/Cc7d3pw4dKCr9bxyZNXFCnYhfMX51OiZIHEHF6ctFQp0yla0WUgpUoVZMHCgeq0YkV70LRZRX79rVus/GNGL2f3rrPcuPWpN6Dvz3O4ft2TU6fd4t1P2TL9aNiwHJN/6QzA2DErOHPmFseO/xFnfkVRsMvdnoGDmjNiZBsAwsLCsbFqy2+u3enVu1FSDjdFfa+xC4/6kKztP6pWaTglSxVgzvyf1Wmli/WjcdPy/PJrpy9uW7/2OIqVyMeMWT000ju1/52gd+/Zvut/6rRmjSeRI0d21vw5PM6yRgxbzv69F7h+ezGqf+e1dP5pBjq6OqxYPSSphxcnHS29r2dKgO/xnBcUFIKZyY8EBgZiZGSU7PLi3kfM71L/fZ3Qz5a8v6uwkHDmN1ibqvX91snQXgYRHh7B5csPqFOntEZ67TqlOetxO85tzp29S+3P8tetW5pLlx4QERGpTgsOfk+h/J3Jn6cDzZv+j6tXHsYq6+GDF+S1/YnCBbvQob0rjx97p8BRpY3w8AguX3pAnTrOGum16zjjEU/szp69Q+3P8tetW4ZLF+9rxO4jRVE4cvgK9+89o0oVJ3X67l1ncXYuTNvWU7G2bE0Z574sX7ZX/bmnpw8+Pv4a+9LX16Nq1WLx1i0tSeySJzw8giuXH1GrdkmN9Jp1SnLu7N0kl3vu3L1YZdauUyreMsPDI9i84RidOtdWN6Kio6PZv+8ihQpZ07TR/8hj04lqlYaza8fZJNcrJck5T2QW0pBKpLCwMIKCgjReKcHPL4ioqGjMzXNqpFuY58Dn1ds4t/F59RYL8xwaaebmOYmMjMLPL6ZeRYrkZvnKYWz953+s/XM0Bga6VK86nAcPXqi3KVuuCCtXD2f33qksWjyIVz5vqV5lGG/epMyxpTZ17CxyaKRbWOTglU/csXvl8xaLz/KbW+T4N3aB6rTAwBByGDUjq0EjmjaZgNucfho/7I8fe7Nk8W4KFrJmz77f6NWrEUMGL2Ld2kMA+Pj4/1uXnJ/tK2e8dUtLErvkeRNf/Mzjj19CvPIJwDzWdzv+MnftOEdAQAgdOtVUp/n6BhIc/IFZM7ZSp25pdu6ZRJNmFWjXehonT3x5HlJakHNe6tPSUqXIS3yZzJFKJFdXVyZPnpxq5as+u9VUUZRYaV/LH5Me8758BQfKV3BQf16xkiPlyw5g4YKdzHaLGYqo36Cs+nOnYlDBxQGHwt1Yt9adwUN+SNbxpKW4Y5eY/LHTDQ2zcPHyQoKDP3D0yBVGDF9C/vyWVKteAoDoaAXnMoWY+mvMEFipUgW5ffspS5bsoWOnOv/Zl+a+v1a3tCaxS57Efm9Tusw1qw9Rt54zVta5PuWPjpk/1ahJeQYMagZAiZL5Oedxl+VL91OlqlOcZaU1OeelHlmQM21Ij1QijRkzhsDAQPXr2bNnKVKuqakR2tpavHrlr5Hu+zow1hXYR5YWOWNdub1+HYCOjja5csU9lq2lpUWZMoV5+OBlvHXJls2Aok55efjwRbx5MhJ17D67Wvf1DcT8s96Mjywsc+LzWf7XvrFjp6WlRcGCNpQsWYAhQ3/kh5ZVmD5ts/pzKysTHBzyaJRjb2/LMy9fACwtTQDi3Fd8dUtLErvkyRVf/F4HxuqlSgwLyxy8ivXdjrtMr6e+HD18nS7d6mik5zI1QkdHGwcHW430Iva2PH+W/nftyTlPZBbSkEokfX19jIyMNF4pQU9Pl9KlC+HufkUj/bD7ZSq4OMa5TfkK9hx2v6yRdujQZZydC6GrG3dno6IoXLv2CCur+H+IwsLCuXfXC6t/f8gyOj09XUo7F8L9s1gcdr+MSzyxq1DBIY7YXcK5TOF4Ywcx8QsLj1C/r1jRkfv3NRvTDx68wC5PzB1H+fJZYmlporGv8PAITpy4EW/d0pLELnn09HQpVboARw5f00g/6n6V8hXsk1xu+fJFYpV5OJ4y1605jJm5MfUblolVN+cyBbl/X7Nx8PDBC2zjuCMurck5L/V9vGsvuS/xZTK0l4EMGtKCrp1n4uxciPIVHFixbB/PvF7Ts3dDAMaPXcXLl29YuTrmrp2evRuxaOEuRgxbSrce9Tl39g6rVx5k3fpR6jKn/rKecuXtKVjImndBoSyYv4NrVx8zZ24/dZ5RI5bRqHF5bO3Mee0bgOtvGwkKCqVDp9rqPP7+73jm5cvLl28AuH//ORDTO2GZAU4+gwf/QJfOM3B2LkwFFweWL9uLl5ev+s6ucWNX8uKFH6vXjASgV+/GLFywk+HDltC9RwPOetxh1coD/Ll+tLrM6dM24exciPwFrAkPj2Dfvgv8uc5d4w6jgYN/oGrlIUxz3ciPrapy4fw9li/by6LFg4GYYYiBg5ozzXUTBQvaULCQDdNdN5I1qz7t2tdIuwB9gcQueQYMakaPrm6Uci5I+fJFWLniAM+e+dGjV30AJo5by8uXb1i+6tOdc9euPgZiJkX7vQ7k2tXH6Onp4OBoB0DfAU2oW3Mss2ZspXGT8uzedY6jh6/hfsxVY9/R0dGsW3uYnzrUQEdHO1bdBg9tQaefZlK5SlGqVivGoYOX2bvnAvvdf02tcCSKnPNSlwztpQ1pSGUgrVpX482bd/w2dQPe3v4UdcrLjl2/kCePBRAz+fbjsAfEXLHv2PULI4YvZfGiXVhZ5+IPtz4a66kEBATT7+e5+Pj4Y2ycjRIlC3D46Az1WjTw76KIHabj5xeEmZkx5crbc/L0bPV+IeYOq57dP92m3qH9NADGT/iJCf/rkGoxSajWbarzxv8dv05d/2/s8rBr91T1MXh7+/PsP8MZ+fJZsmv3VIYNW8KihbuwtjZhttvP6nWQIGYdmQH95/P8uR9ZsuhRxN6WNWtH0rpNdXWesmWL8PfWiYwbt4qpU9aTL58ls/7oQ/ufPk36HT6iNe/fhzOg/3zevn1HufL27N3vmmHWQZLYJc+Pravg7/+Oab9uxsfbH8eiedi2c6K6Z83H5y3Pn/lpbFOx3KdG1ZXLj/hr0wns8phz50HM2kcVXBxY8+dwfvnfeqZM2kD+/JasXT9C43sLcOTwNZ55vaZTl9rEpWlzF+Ys+JlZv//N8CHLKFTYhg2bR1OxUsbo0ZNzXupKj0fEnDhxghkzZnDp0iW8vb35559/aN68+Re3OX78OEOHDuXWrVtYW1szcuRI+vTpk4xapy1ZR+ozq1evpmvXriQ0LCm5jtT3KKXWkRIisVJqHanvUUqtI/U9Sst1pEYf7pIi60hNq7U6wfXdt28fp0+fpnTp0rRs2fKrDSlPT0+cnJzo2bMnvXv35vTp0/Tt25eNGzfSsmXLZNU9rUiP1GeePHlCtWrV0rsaQgghRLJokQLP2ktk/gYNGtCgQYME51+8eDF2dna4ubkB4ODgwMWLF5k5c6Y0pL5VBw4cYM6cb/NxAEIIIcRHKfmImM/XTNTX10dfXz95hQMeHh7UrVtXI61evXqsWLGCiIgIdHUzxuOMvkTGVT7j4eFBuXLl0rsaQgghRIZha2uLsbGx+uXq6vr1jRLAx8cHCwsLjTQLCwsiIyPx8/OLZ6uMRXqkhBBCiExIW6VCO5mTzT9u/+zZM405UinRG/VR/Iusfhu3DEpDSgghhMiEUnJoLyXXTfwvS0tLfHx8NNJ8fX3R0dEhV65c8WyVscjQnhBCCCHShYuLC4cOHdJIO3jwIGXKlPkm5keBNKSEEEKITOnjgpzJfSVGcHAwV69e5erVq0DM8gZXr17Fy8sLiHnMWqdOndT5+/Tpw9OnTxk6dCh37txh5cqVrFixguHDh6dUGFKdDO0JIYQQmZCWVswruWUkxsWLF6lR49OTB4YOHQpA586dWb16Nd7e3upGFUC+fPnYu3cvQ4YMYcGCBVhbWzN37txvZukDkIaUEEIIIVJI9erVv7ig9erVq2OlVatWjcuXL8fO/I2QhpQQQgiRCaXkXXsiftKQEkIIITIhVQrctSftqK+ThlQK0Xl2Cx1Dg/SuxjfHq/uG9K6C+E7ZzW6a3lX4dhllT+8afLN03qXdMx6TMlk8rjLEl8lde0IIIYQQSSQ9UkIIIUQmlJILcor4SUNKCCGEyIRksnnakKE9IYQQQogkkh4pIYQQIhOSob20IQ0pIYQQIhOSu/bShgztCSGEEEIkkfRICSGEEJmQlkqFVjIniyd3+++BNKSEEEKITEgrBYb2ZI7U18nQnhBCCCFEEkmPVAajKAq/zHFn2aZzvA18T/mSdsyb3IyihS0TtP2mXVf5adBGmtZx5J8lnTU+W7TOg5nLjuPt+46ihS34Y3wTqpTLp/5cO/+oOMucProhw3tVAyAsLJIRrnvYtOsq7z9EULNiQRb80pzcVjmSdsApKGuVmhg2/hG9wg5oG+fkZc82hD+6l+Dts9Woh9mE6YSeOorvxCEan2mbmpOz5yCylKuESl+fyOde+M2YRPiDOwnat46FNbk37o1zv76TRxB6/FASjjhlSfySTlEUfll8gmXbLvM26APlnWyYN6Y+RQuax7vN6h3X6P6/nbHSQ86NwUA/5tR84tJTZq7x4PIdb7xfB7P1j1Y0r2mvkV+75JQ4y58+uBbDu1QEoM+UPRw+58nL1+/InlUPlxK5mTaoFvb5TJN6yClGznmpR4b20oY0pDKYGUuOM3vlSVb+3prC+Uz5dcFh6nVazh33ERhm1//itk9fvGWk6x6qlM0X67PNu68xZOou5v/SnErOeVi64RyNuq3k5oGh2NnkBODFufEa2+w7dpeeo7fyQ30nddqQKbvYfeQ2G+a0J1fOrIz4bQ9Ne6zmws6BaGunbwenyiALH25eJeT4IUyH/y9R22pbWJGzz1A+XL8U6zOt7IZYzV3N+6sXeDWmP9Fv/dGxzk10yLsE7zvytQ/PWtbSSMveuCXGbbvw/typRNU1tUj8km7G6jPM/vMsK39pSuE8ufh12Unq/byeO9v7Ypgt/u+tUXZ97mzvq5H2sREFEPI+ghKFLejSrASthv0dZxkv3DUbrftOPaTn5F38UNtBnVbawYr2DZ2wszTGP+g9kxcfp/7P63m0Z0C6f2/lnJd6pCGVNr7rhtSTJ0/Ily8fV65coWTJkuldHRRFYc6qU4ztW1P9RV49ow1W5aawYecVerevEO+2UVHRdBy8if8NqsOpi08ICHqv8bnbipN0a1WWHm3KATB7YlMOnrzP4vVn+W1kAwAszQw1ttnpfpsaFfKT3y4XAIFB71m55QJrZrWhduVCAKz9oy15Kv2G++kH1KtaJGUCkUQhh/YAMb0XiaKlhdnY3whYvQiDYqXRyq4ZB+N2XYn09eHN759+4CNfvUzcvqOjiXr7RiMpa+WahBw9gPLhfdzbpDGJX9IoisKc9ecZ26MyP9SKabysntIMq5p/sGHfTXr/6BzvtirA0jT+BwA3qFyQBpULfnH/n2+/89g9apTNS/7cOdVpvX4srf5zXpscTOlXg1Ktl/LkZQAFbE2+WH5qknNe6tIiBRpSSEPqazJ2c/o74/nMH5/X76hTpZA6TV9fh6rl8+Nx+ekXt50y1x3TXNno/u9J47/CwyO5dPOFRrkAdaoUjrfcV6/fsffoXbq2LqtOu3TzBRERUdT9TznWFkY4FbbE49KX65eR5ejYm6jAtwTv2x7n51lcqhF2/zZm/5uB7dYjWC3ZRPZGPyRrn3qFHNAvZB/vPr8l33v8PF8E4OMXTB2X/Oo0fT0dqpbJg8fV51/cNvh9OPkazMWurhtNBmziyl3vZNXl1Ztg9p56SNfmJePNE/I+nNU7rpHPJge2lsbJ2l9yyTlPZAbfdY9URuPzOmaow8JU8yrJwjQ7T1+8jXe70xefsHLLBS7vHhzn535vQ4mKisbisytXi1zZ1fv83NptlzDMpq/Rxe3z+h16etrkNM6qkdfcNDs+fnGXk9HpFy1J9obNedmzTbx5dK1zo9u0FYFb/iRw/XL07J0w6T8SJTyckEO7k7Tf7A1bEP7kEWG3riW16hmCxA98/IIBsDD57Ptlko2n3oHxbmefLxcrf2lKsYLmBIWEM3fDOap0Wc2Vzb0olCdXkuqydud1DLPqqXvG/mvR5ouMcnMn5H0E9vlycWDxT+jpaidpPylFznmpK2ZoL3n9JTK093XSIwU8fvyYGjVqkDVrVkqUKIGHh0e8ecPCwggKCtJ4JdX67VcwcpqgfkVERgPw+b9bRVFQxfOP+V1wGJ2GbmLJby0xNcn2xf19XoYSR9pHq7ZcpH2zUhjo6371OBRFQZXG3b/ZajXEbs8Z9Uu/WKlEl6HKkhXTsb/yZtYvRAcFfCGjFmEP7hKwYh7hD+8RvHsrwXu2Ydi0VZLqrtLTJ3utBunamyLxS7r1e25g5DJN/Yr/exv/9wugQvHcdGhUnBJFLKlS2o7Nv/9IYbtczN90Icl1W7XjKu0bFtOYZ/VR+4ZOXNrUk6MrOlHQzoS2I7fyISwyyftKCjnnpa2Pc6SS+xJfJj1SwLhx45g5cyaFChVi3LhxtGvXjocPH6KjEzs8rq6uTJ48OUX227S2I+VL2qrfh4XHnNR8Xr/DytxIne77JiTWldVHj7ze8OT5W5r1XKNOi45WANArNIY77sOxtTJGW1sr1pWY75vgOMs9ed6Te49fs3Fee410SzNDwsOjeBsYqnGF9vpNCBVL50noYaeI0DPHCLtzQ/0+ys830WXoWtuia2WD+a9zPiX+e/WW59BFXnRuTuTL50T5vybiySONbSO8PMlatXaS6p61Wm1U+gYEH0xab0xKkPglXdPqhSlfzEb9Xv29fROM1X/m3Pi+DcHiKz/0/6WlpaJMUWseePknqV4nL3tx78kbNk6Pe9jU2NAAY0MDCuXJRYXiuclVZQb/HLlLuwZOceZPDXLOE5mRNKSA4cOH06hRIwAmT55M0aJFefjwIfb29rHyjhkzhqFDh6rfBwUFYWtrGytfQhhm19e4K0VRFCzNDHE/9YBSRWNO1OHhkZw49xjXUQ3iLMO+gBnX9mnetTPhjwMEB4cxe2JTbK2M0dPTwdnJBvdTD2hR79NJ0/3UA5rWdoxV5sotF3B2sqGEg+bEX2cnG3R1tTl06gGtG5UAwNs3iJv3fZg2Ou76pRblfSiR70OTVUaElycvurXUSMvZrT+qrFnxn/87kb4+AHy4eQ1d27wa+XRy5yHyVdLmsxg2aEHomWNEB8Y/dJHaJH5JZ5hNX+NOPEVRsDTNjruHJ6XsrQAIj4jixMWnuA6uFV8xsSiKwrV7PjgVin/JhC9Z+c8VnB2tKFEkYcsGKCiEhUclaV9JJee8tCV37aUNaUgBxYsXV//ZyirmROjr6xtnQ0pfXx99/S/fkptUKpWKQV0r47rwKAXzmlIorymuC4+SNYsu7Zt+GnrpPGwzNhZG/DayAQb6ujh9duLMYZQFQCN9cPcqdB62GediuXEpbceyjefxehlA758074oJeveBv/deZ8bYxrHqZ2yUhW6tyjLitz3kypENkxxZGPnbHooVsaR2pUKx8qc1LUMjdMyt0DY1A0DHNuaKMcrfT33Hl+noKUT6+RKwfB5KRHisnpLo4HdogUZ60N9/YjVvNcbtuxNy7CD69k4YNmrJmz8+rd+TkH0D6Fjbol+8NL5j+qd8AJJJ4pc0KpWKQT+Vw3XFKQrmMaGQnQmuy0/FfG//09vTefx2bMwN+W1gTOPql8XHKV88N4XsTAgKDmPexvNcvf+KeWM+/UAHh4bz8D89VE9eBHD1rg8mxlmws/o0UTwoOIy/D91hxrA6ser3+Plb/jpwizouBTDLmZUXvu/4fdVpsujr0rDKl+8ITG1yzktd0pBKG9KQAnR1P42Jfxw/j46OTpe6jOhdjfcfIug/cfu/i9PZsn9ND42ruGcvA9BK5Lr9bRqXwP9tKFPnHcb7dRBOhS3ZvbIreWxyauTbtPsaigLtmpSIs5w/JjRGR0eLtgPWqxen2zGjdYZYTyVrxeqYjvpF/d584u8ABKxZTMCaxQDomFvBv8MACRV+7xa+E4eSs8dAcnTqRYT3C/wXziDk8KcFIhOyb4DsDZoT5efL+4vxz8NLLxK/pBvRpSLvP0TS/7d9vA16T/liNuxf9JNGz9Uz7yCNH6WAd2H0mbIHH79gjLPrU9LekmMrOlPuP8OGF2+9pFbPder3w2bFLDzaqUlxVk1ppk7ftP8WCgrt6heNVTcDPR1OXn7GnPXneRv0Hotc2alS2o5Ta7pgnoihx9Qi5zzxrVMpipK4s2ImEtc6UgEBAeTMmZOjR49SvXr1r5YRFBSEsbExb69NxsjQIHUrnAl5dd+Q3lUQ3ym72U3TuwrfLqP4174SXxb07gM5S/yPwMBAjIyMvr5BUvbx7+/SlusDyGqYvBGU0HdhtCo+L1Xr+62THikhhBAiE1KlwNDel+48FTGkb1IIIYQQIom+6x6pvHnz8vnIZo4cOWKlCSGEEN8amWyeNr7rhpQQQgiRWWmptFJgZXMZuPqaTBehJ0+eoFKpEvRyckq7heiEEEKItCQrmyedr68vWloJayJluh4pXV1dihRJ2BO58+fP//VMQgghhPjuJHSifaZrSNnY2HD37t30roYQQgiRrmSOVPIkdL50pmtICSGEEEIaUl+yZs2aL34eGBiY4LKkISWEEEKI78qQIUO++Hli7t6XhpQQQgiRCclde/Hz9/f/4uevX7/GwsIiQWVJQ0oIIYTIhLRQoUUyh/aSuf23Snqk0oEqTylURun/ANBvTR730uldBfG9yqRX2iJjUwWFpHcVxL927NjBjBkzuHPnDgAODg4MGzaMFi1aAAm/a0/OJEIIIUQmlF7rSC1cuJB8+fJhYGCAs7MzJ0+ejDfvsWPH4lznMbXvvl+yZAlt2rTBycmJOXPm4ObmRrFixWjbti2LFi0iS5YsdO7cOUFlSY+UEEIIkQnFPLQ4ef0liX1o8ebNmxk8eDALFy6kUqVKLFmyhAYNGnD79m3s7Ozi3e7evXsYGRmp35uZmSW5zgkxc+ZM5syZQ+/evdVpHTt2pGTJksyYMYOff/6ZlStXJqgs6ZESQgghRIr4448/6N69Oz169MDBwQE3NzdsbW1ZtGjRF7czNzfH0tJS/dLW1k7Vej579oxatWrFSq9VqxbPnj1LVFnSkBJCCCEyoZQc2gsKCtJ4hYWFxdpfeHg4ly5dom7duhrpdevW5cyZM1+sa6lSpbCysqJWrVocPXo05YIQj3z58rFz585Y6bt27Ur0U09kaE8IIYTIhFJyQU5bW1uN9P/9739MmjRJI83Pz4+oqKhYywZYWFjg4+MTZ/lWVlYsXboUZ2dnwsLCWLduHbVq1eLYsWNUrVo1WXX/kgkTJtClSxfOnTtHxYoVUalUnD59mm3btrFq1apElSUNKSGEECITSsl1pJ49e6Yxh0lfXz/ebT6fV6UoSrxzrYoUKaLxfFwXFxeePXvGzJkzU7Uh1b59e2xtbZkxYwbz589HURQcHBxwd3enWrVqiSpLGlJCCCGE+CIjIyONhlRcTE1N0dbWjtX75Ovrm+DFLQEqVKjAn3/+maR6JkaVKlWoUqVKssuROVJCCCFEJpTWyx/o6enh7OzMoUOHNNIPHTpExYoVE1zOlStXsLKySnD+9CY9UkIIIUQmlB4rmw8dOpSOHTtSpkwZXFxcWLp0KV5eXvTp0weAMWPG8OLFC9auXQuAm5sbefPmpWjRooSHh/Pnn3+ydetWtm7dmqx6f422tnaCVy+Pjo7+4ufSkBJCCCFEimjTpg1v3rzhl19+wdvbGycnJ/bu3UuePHkA8Pb2xsvLS50/PDyc4cOH8+LFC7JkyULRokXZs2cPDRs2TNV6/vPPP+o/79y5k4MHDzJ79mx0dXUTXZZKScwDZUQsQUFBGBsbExCwEyN5REziKV9u6QuRauQRMSIdBAWFkCNHUwIDA7865yjp+4j5XTrnOYnsRgbJKis46APl801K1fqmpx07dtC+fXtsbGwoX74869atS3QZ3+WZpHr16gwePBiAvHnz4ubmlq71+S9FUZg0aQ02Nq3JmrUBNWoM5datJ1/dbuvWExQt2hUDg/oULdqVf/45FSvPwoU7yJ//J7JkqU+ZMn04efK6xuddu05HS6uWxsvFpb9GnqVLd1OjxlCMjZugpVWLgIDgZB1vSlIUhUmT12KTuw1ZszWiRs1hCYzdSYo6dccgS0OKOnWPFbsTJ67TtOkEbHK3QUu7Dtu3n45VxqtXb+na9XdscrchW/bGNGgwhgcPnqs/f/LEBy3tOnG+tmw5nuxjTwkSv6RLz+/tq1f+dO06HRub1mTL1pAGDUZrxA7Ax8efTp1csbL6kezZG+Hs3Ju//07/uIGc81LTx7v2kvvKrLZu3Uq7du1YtmwZZ8+e5fLlywwaNCjR5WTeCH3Btm3bmDJlSnpXI06//76J2bP/Zt68AZw/vxBLy5zUrTuSd+9C493Gw+MWbdtOoUOHOly9upQOHerQps0vnDt3R51n8+ajDBmykLFj23P58hIqVy5Gw4Zj8PJ6pVFW/fpleflyi/q1Z89vGp+HhoZRr15Zxoxpn7IHngJ+n7GZ2bO3Mm9uf86fm4+lhQl16436Suxu07bdVDp0qM3VK4vp0KE2bdpO1YhdSMgHipfIz7y5/eMsQ1EUWvzwPx57+rD9n1+4fGkRdnksqFN3FCEh7wGwtTXj5YvNGq9JkzqRLZsBDRqUS9lAJJHEL+nS63urKAotWkzk8WNvtm//hcuXl2BnZ06dOiPUsQPo1MmVe/eesWPHVK5fX0aLFlVo23YqV648SL2gJJCc80R62LJlC506dWLVqlW0b98eExMT3N3d2blzJ7/88kuiyvruh/by5s3L4MGD1T1UiZWSQ3uKomBj05pBg35g1Kh2AISFhWNp+SPTpvWkd+8mcW7Xtu0UgoJC2Lt3mjqtQYPR5MyZnQ0bxgNQoUI/SpUqxKJFg9V5HB270qxZJVxdewAxV2cBAcH888/XG5nHjl2lZs1h+PvvIEeO7Ek95BQb2lMUBZvcbRk0qAWjRrYF/o2dVWumufagd+/GcW7Xtu1UgoJC2bv308mzQYMx/8ZuXKz8Wtp12LZ1Es2bV1Kn3b//HHuHrty4voyiRfMCxCxKZ9mKaa496NEj7rH+0s59KFWqECuWD0vqYaeY7zJ+KXSlnZ7f2/v3n2Fv34UbN1Zoxs6iJdOm9aRHj0YAGBo2YuHCwXTsWEddjqlpc6ZP70X37qk7F+VLvsdzXloO7V16OiVFhvac80zIdEN72bJlY+3atbRs2VIj/fHjx1SqVAlvb+8El/Vd9kj9d2jvc6tWrcLY2DjW7ZtpwdPTGx8ff+rWLaNO09fXo1q1Enh43Ip3Ow+P29SpU0YjrW7dMpw5E7NNeHgEly7d1ygXoE4d51jlHjt2DQuLlhQp0omePWfh6/s2uYeVJjw9fWJiV+ez2FUtjofH7Xi38zh7mzp1nTXS6tYrw5kvbPO5sLAIAAwM9NRp2tra6Onpcvr0zTi3uXTpPlevPqJ7t/oJ3k9qkvglXXp+bxMau8qVi/HXX0fx9w8iOjqaTZuOEBYWQfXqJZN20ClEznmpS6XSSpFXZrR+/fpYjSiA/Pnzc+DAgUSVlTkjlEQzZ85k+PDhHDhwgDp16nx9gxTm4xPzBbawyKmRbm6eU/1Z3Nv5x9rGwuLTNn5+gURFRceTx1/9vn79cvz551gOH57JzJl9uHjxHrVqDScsLDxZx5UWPh6HhUUOjXTzz44x9nZvsTD/LC5fiffn7O1tyZPHgrFjV/D27TvCwyOYNn0TPj7+eHvHve8VK/fj4GBHxYpFE7yf1CTxS7r0/N7a29v9G7vln2I3bWOs2G3aNJ7IyGhMTVtgYFCfPn3c2LZtMgUKWCf9wFOAnPNEemnevDk3btygQ4cOODo64uTkROfOnblx4wbFixdPVFnSkPrXmDFj+OOPPzh27BgVKlSIN19YWFishzcm1fr17hgaNlK/IiIigcQtr/9R3Nt8nofP8mhu16ZNDRo1qoCTUz6aNKnI3r2u3L//nD17ziXyyFLf+vWHMTRqon4lL3aa7+OK3Zfo6urw95aJ3H/wnFymP5Ate2OOH7tGg/pl0daO/RV7/z6MjRuP0C0de1MkfkmXkb63uro6/P33JO7ff06uXM3Jlq0hx49fo0GDchqxGz9+FW/fvuPQoRlcuLCIIUN+pHXrX7hx43FiDj3ZMlLs4Ns65yWFCq1k/6fKpM2ES5cu4eLiwqtXr6hbty6PHj0ia9asVKpU6asPWP6crCMFzJo1i5CQEC5evPjVpz67uroyefLkFNlv06YVKV/eQf3+Yze9j48/Vla51OmvXwfE6in4L0tLk1i9Br6+AeqrMVNTY7S1tWJd4fn6vo11xfZfVla5yJPHItYdQBlB06YulC9vr37/KXZvNWP3nzjExdIyJz6vPovL6y9vExdn58JcubyEwMAQwsMjMDPLQQWXATg7F4qV9++/TxAaGkanjmnf6/mRxC/pMtr31tm5MFeuLCUwMJjw8MiY2FXoh7NzYQAePXrJggXbNeZRlShRgFOnbrBgwQ4WLx6S+CAkUUaL3ecy8jkvKVJiaC6zDu2NGzeOLl26MH/+fDw9PVmxYgWLFi3C0dGRMWPGcPx4wu9qzZwRSqQqVaoQFRXFX3/99dW8Y8aMITAwUP169uxZkvdraJiVggVt1C9HxzxYWppw6NAldZ7w8AiOH7+Gi0v8QxguLo64u1/SSDt06KJ62ENPTxdn58Ia5QK4u1/6Yrlv3gTy7Jmvxgkuo4g3du6fxe7EdVxcHOMtx6WCI+6fxeXQwUtU/MI2X2JsnA0zsxw8ePCcixfv06xp7McirFy1n6ZNXDAzy5GkfaQEiV/SZdTvrbFxds3YNYuZ0B8a+gEALS3N7hltbS2io9P2XqOMGruPMvI5LyliHvGS3OUPkrcyekbl4eFBz549ATRWOG/UqBEXLlxIVFnSIwWUK1eOAQMGUK9ePbS1tRkxYkS8efX19b/41OvkUKlUDBr0A66uGyhUKDeFCtng6rqBrFkNaN++ljpf587TsLY2Vd95MnDgD1SrNpjp0zfSrFklduw4jbv7ZU6enKPeZsiQH+nUaRplyhTGxcWRpUv34OXlS58+MXfFBAe/Z9KkNbRsWQUrq1w8eeLDuHErMDU1pkWLyupyfHz88fHx5+HDFwDcuPEYQ8Os2NmZY2KSfnd0xMSuBa6uGylU0Obf2G0ka1Z92revqc7XufN0rG1Mcf2tOwADB7agWvWhTP99E82aVmTHzjO4H77MyROz1dsEB79XHy+A5xMfrl59iImJEXZ25gBs2XIcM7Mc2NmZc+OGJ4OHLKR5s4qxJrs+fPiCEydusGf3r6kZjkST+CVden5v4WPsjD/FbvACmjevpI6dvb0dBQva0KfPbGbM6EOuXEZs336KQ4cusWtX+sZRznkivSiKQrZsse+09/X1xczMLFFlSUPqXy4uLuzbt4/69eujo6PDkCFp1939XyNHtuX9+3D69ZvD27fvKF/egQMHpmNomFWdx8vLV+PqsmLFomzcOJ4JE1YxceJqChSwZtOmCRpd6G3a1ODNmyCmTFmHt7c/Tk552bPHlTx5Yp7Ira2txc2bnqxbd4iAgGCsrEyoUaMkmzZN0Nj34sW7+OWXter31arFxGnlyhF06ZK+d1CNHNEmJnb95/0bO3sO7J+mGbtnccRuwzgmTFzNxIlrKFDAik0bx2nE7uLF+9SsNVz9ftiwxQB07lSHVatGAuDt48+w4Ut49eotVlYmdOxYhwnjf4pVx5Wr9mNjY0rdz+50ywgkfkmXXt9bAG/vNwwbtug/savLhAkd1J/r6uqwZ89vjBmznKZNxxEc/IGCBa1ZvXoUDRuWT+XIfJ2c81KPKgXmOGXWOVIFChTg9u3bFCxYEIhpWJ06dYrBgwfTvHnzRJX1Xa4jVb16dUqWLKl+WOJ/15E6ceIEDRs25LfffmPgwIFfLUseEZNM8ogYkV4y6dwPkbGl5TpSt178gaFRlmSV9S7oPUVthma6daSmTZvGy5cvmTt3Lo8fP6Zw4Zg5hZ07d2bevHlkzZr1KyV88l32SB07dkz95ydPnmh8VrVqVYKDv51HAAghhBAicUaPHq3+s52dHbdu3SJfvnzo6el9Yau4fZcNKSGEECKzk6G9hNHR0aFIkSJJ3z4F6yKEEEKIDCIlHjqcWR9anD9/fr40s8nT0zPBZUlDSgghhBDflc8fExcREcGNGzfYs2cPQ4cOTVRZ0pASQgghMiFZkDN+8d1Mtnjx4kSvI5U5IySEEEJ855L/gJiY/74ndevWZcuWLYna5vuKkBBCCCFEPLZs2ULOnIl7xJUM7QkhhBCZkAztxa906dIak80VRcHHxwc/Pz8WLVqUqLKkISWEEEJkQnLXXvw+X71cS0sLc3Nzqlevrl6cM6GkISWEEEJkQjHrSGknu4zMaOLEiSlWVuaMkBBCCCFEGpAeKZG+Mmm3sRBCpDdVCgztZdY5UilJGlJCCCFEJiSPiEkbEiEhhBBCiCSShpQQQgiRCX28ay+5r8yoadOmbN++naioqGSXlTkjJIQQQnznPq4jldxXZtWuXTty587NyJEjuXfvXpLLybwREkIIIYSIw86dO/H19WX06NHMmjWLYsWKUblyZVauXEloaGiiypKGlBBCCJEJybP2vszQ0JA6deqgpaXFixcvaNu2LUuWLMHKyoqePXvi4eGRoHIyb4SEEEKI75gM7SWcmZkZ/fv359y5c1y8eBFDQ0OqVKmSoG1l+QMhhBBCfPeioqLYv38/69evZ/fu3dStWzdB230fTU0hhBDiOyN37SXcgAEDsLa2ZsCAATg6OnL79m327t2boG2lR0oIIYTIhGRBzvhduXKFrVu3snXrVnR1dXn79i0bN26kZs2aiS5LGlJCCCFEJqSlUiW7R0lLpUqh2mQsZcqUoUSJEgwYMICffvoJY2PjJJeV6Zqa1atXZ/DgweldjSRbuHAH+fP/RJYs9SlTpg8nT17/Yv7jx69RpkwfsmSpT4ECHVi8eFesPFu3nqBo0a4YGNSnaNGu/PPPqUTvV1EUJk1ag41Na7JmbUCNGkO5detJso41pUnskk5ilzwSv6ST2In0cOnSJS5fvkzfvn01GlEfPnxgzZo1iSor0zWktm3bxpQpU9K7GkmyefNRhgxZyNix7bl8eQmVKxejYcMxeHm9ijO/p6c3jRqNpXLlYly+vIQxY9oxaNB8tm49oc7j4XGLtm2n0KFDHa5eXUqHDnVo0+YXzp27k6j9/v77JmbP/pt58wZw/vxCLC1zUrfuSN69S9x6G6lFYpd0ErvkkfglncQudX0c2kvuK7EWLlxIvnz5MDAwwNnZmZMnT34x//Hjx3F2dsbAwID8+fOzePHipB5ygjk6OrJx40ZcXV2ZPHmy+jVhwgS6du2qfp8QKkVRlFSub6YWFBSEsbExAQE7MTLKlqyyKlToR6lShVi0aLA6zdGxK82aVcLVtUes/KNGLWXXLg9u316lTuvTZzbXrz/izJn5ALRtO4WgoBD27p2mztOgwWhy5szOhg3jE7RfRVGwsWnNoEE/MGpUOwDCwsKxtPyRadN60rt3k2Qdd0qQ2CWdxC55JH5J9z3GLigohBw5mhIYGIiRkVGSy/nyPmJ+l94G7Ej271JQUAg5czRLcH03b95Mx44dWbhwIZUqVWLJkiUsX76c27dvY2dnFyu/p6cnTk5O9OzZk969e3P69Gn69u3Lxo0badmyZbLq/iWtW7dm//795MuXD21tbXV6ZGQkt27dokSJEiiKwpUrV75aVqbrkfrv0F7evHn57bff6NatG4aGhtjZ2bF06VKN/GfOnKFkyZIYGBhQpkwZtm/fjkql4urVq2la7/DwCC5duk/dumU00uvUccbD41ac25w9e5s6dZw10urVK8vFi/eJiIgEwMPjNnXqaJZZt24Zzpy5leD9enp64+Pjr5FHX1+PatVKxFu3tCSxSzqJXfJI/JJOYpc5/fHHH3Tv3p0ePXrg4OCAm5sbtra2LFq0KM78ixcvxs7ODjc3NxwcHOjRowfdunVj5syZqVpPd3d3Tp48ybVr17h8+bL6dfjwYRRF4fLlywlqREEmbEh9btasWZQpU4YrV67Qt29ffv75Z+7evQvAu3fvaNKkCcWKFePy5ctMmTKFUaNGfbG8sLAwgoKCNF4pwc8vkKioaCwscmqkW1jkxMfHP85tfHz848wfGRmFn1/gF/P4+LxN8H4/5v08j7n5p3LSk8Qu6SR2ySPxSzqJXepLyQU5P//dCwsLi7W/8PBwLl26FGv9pbp163LmzJk46+jh4RErf7169bh48SIREREpFInYAgMDyZ07d6x0RVFQJXKCfaZvSDVs2JC+fftSsGBBRo0ahampKceOHQNg/fr1qFQqli1bhqOjIw0aNGDEiBFfLM/V1RVjY2P1y9bWNkXr+/nfn6Lwxb/Uzz/7OFL73/S48nxeZEL2G3c5GeeODold0knskkfil3QSu9SjUlLmBWBra6vx2+fq6hprf35+fkRFRWFhYaGRbmFhgY+PT5x19PHxiTN/ZGQkfn5+KROIOKxatQpDQ8NY6cbGxqxatSqOLeKX6RtSxYsXV/9ZpVJhaWmJr68vAPfu3aN48eIYGBio85QrV+6L5Y0ZM4bAwED169mzZylST1NTY7S1tWJd7fj6vo11VfSRpaVJrCs3X98AdHS0yZXL6It5PpaZkP1aWsb8//NyXr8OwMIiRyKOMnVI7JJOYpc8Er+kk9h9W549e6bx2zdmzJh48ya2AZqQxnFK69SpE3p6erHS3717x//+979ElZXpG1K6uroa71UqFdHR0UDcf7lfm3uvr6+PkZGRxisl6Onp4uxcmEOHLmmku7tfwsWlaJzbVKjgiLu7Zv6DBy9SpkxhdHVjlghzcYmd59Chi1SsWDTB+82XzwpLSxONPOHhERw/fi3euqUliV3SSeySR+KXdBK7NKBEp8wLYv3u6evrx9qdqakp2trasXqffH19Y/U6fWRpaRlnfh0dHXLlypVCgYht9+7dFClSBH19fbS0tNQvc3Nznj59qn6fEN/1gpz29vasX7+esLAw9T+Kixcvplt9hgz5kU6dplGmTGFcXBxZunQPXl6+9OkTc4fImDHLefnSjzVrRgPQp08TFizYwdChC+nZsxEeHrdZuXIfGzaMU5c5cOAPVKs2mOnTN9KsWSV27DiNu/tlTp6ck+D9qlQqBg36AVfXDRQqlJtChWxwdd1A1qwGtG9fKw0jFD+JXdJJ7JJH4pd0ErtU9p+GULLKSCA9PT2cnZ05dOgQLVq0UKcfOnSIZs2axbmNi4sLu3ZprgV28OBBypQpE6sjJCUNGzaMOnXqUKtWLY279gIDA+ncuTPbt29PcFnfdUOqffv2jBs3jl69ejF69Gi8vLzUdwqkxzh4mzY1ePMmiClT1uHt7Y+TU1727HElT56YlryPzxu8vHzV+fPls2LPnt8YOnQhCxfuxNo6F3Pm9Kdly6rqPBUrFmXjxvFMmLCKiRNXU6CANZs2TaB8eYcE7xdg5Mi2vH8fTr9+c3j79h3lyztw4MB0DA2zpkFkvk5il3QSu+SR+CWdxC7zGTp0KB07dqRMmTK4uLiwdOlSvLy86NOnDxAzPebFixesXbsWgD59+jB//nyGDh1Kz5498fDwYMWKFWzcuDFV6+np6cmECRNi9ZR9nPrTtGnTBJeV6daRql69OiVLlsTNzY28efMyePBgjZXOS5YsSfPmzZk0aRIQs/zBxzv5ihUrxrBhw2jfvj13796lSJEiX91fSq4jJYQQInNLy3WkAt9sTZF1pIxztUxUfRcuXMjvv/+Ot7c3Tk5OzJ49m6pVYxq7Xbp04cmTJ+qbviBmQc4hQ4Zw69YtrK2tGTVqlLrhlVry58/P5cuXyZEjh0b6mzdvKFu2LI8fP05wWZmuIZVc69evp2vXrgQGBpIlS5av5peGlBBCiIRK04aU398YGSWvBy0oKBRj0x9Ttb7fuu96aA9g7dq15M+fHxsbG65du8aoUaNo3bp1ghpRQgghRIYVHR3zSm4ZmdCXHv8S85zFSQku67tvSPn4+DBx4kR8fHywsrKiVatW/Prrr+ldLSGEEEKkkh07dmi8DwkJ4enTp+jq6lKwYEFpSCXGyJEjGTlyZHpXQwghhEhZaXzX3rfk8uXLsdL8/f3p0KEDrVq1SlRZmX4dKSGEEOK7lILrSH0PTExMcHV1ZerUqYnaThpSQgghhBCAtrY2T58+JTIyMsHbfPdDe0IIIUSmJEN7iebk5JSoRhRIQ0oIIYTInOSuvXjVrFkz3kfCKYrCsWPHCAgIoEWLFhw9evSLZUlDSgghhBDflZIlS341j66uLqVKlfpqPmlICSGEEJmRDO3F648//vhqnmzZsiUonzSkhBBCiMxIGlJpQhpSKSRKiSRKSdwENQGB4X7pXQXxnTLRt0zvKnyz5FyXdBK7jCF//vzxzpH6nKen5xc/l4aUEEIIkRlJj1S8unXrxqxZs6hUqRIVKlQAwMPDg9OnTzN8+PBEPVdQGlJCCCFEJqQo0ShKVLLLyIxu3brFuHHjGD58uEb6jBkzuHr1KuvXr09wWbIgpxBCCJEZfVz+ILmvTGjXrl00a9YsVnqLFi3YuXNnosqShpQQQgghvitGRkYcPHgwVvr+/fsTNawHMrQnhBBCZFIp8ay8zNkjNXbsWIYMGcLp06c15kj9/fffzJ49O1FlSUNKCCGEyIxksnm8+vfvj729PW5ubsydOxdFUXBwcGD//v3UqlUrUWVJQ0oIIYQQ353atWtTu3btZJcjDSkhhBAiM5Ieqa/68OEDr1+/JvqzSfV58uRJcBnSkBJCCCEyI2lIxevu3bt069aNs2fPaqSrVCoURYnVsPoSaUgJIYQQ4rvSvXt39PT02Lt3L1ZWVqhUqiSXJcsfZDCLFu2iUIFOZM/amHJl+3Hq5I0v5j9x/DrlyvYje9bGFC7YmSWLd8ebd/OmY+hq16Nli0ka6SdP3KB504nY5W6HrnY9dmw/E+f2d+540aLZ/8iVswU5jZtTqeIgvLx8E32MqWXlkkOUth+MTY4u1Kw4Do9Td+PNu3v7BVo2cqWIbR/ymnenfrX/ceTQ9Vj5dv1znoqlRmBt3JmKpUawZ8cFjc/PnLpD+5YzKZqvH6ZZfmLvzotx7qtVk2kUzt0b0yw/cePak2Qfa0qT2CXPwoU7yJ//J7JkqU+ZMn04eTJ2PP7r+PFrlCnThyxZ6lOgQAcWL96l8fmtW0/48cdJ5MvXHi2tWri5bY1VxokT12nadBw2Nq3R0qrF9u2nYuUJDn5P//5zsbVtQ9asDXB07MqiRYlbIye1yTkvFck6UvG6du0aixYton79+pQoUYLixYtrvBJDGlIZyF+bjzFsyGJGj2nHhUsLqVzZicaNxsf7xfX09KFJ4/FUruzEhUsLGTW6LUMGL2Lb1pOx8j59+opRI5dRuYpTrM9CQj5QvER+5sztF2/dHj16SfWqQylib4v7kRlcurKIcePaY2Cgl/QDTkH/bPFg3Ih1DBnVjKNnf8Wloj1tm//Oc6+4n+Xnceou1Wo6sfGfERw+8yuVqznyU8uZXL/6RJ3nwtkH9Og4j9btK3P8vCut21eme4d5XDr/UJ0nNCQMp2J2TJ/dJd66hYZ+oJxLYSZMaZtSh5uiJHbJs3nzUYYMWcjYse25fHkJlSsXo2HDMXh5vYozv6enN40ajaVy5WJcvryEMWPaMWjQfLZuPaHOExr6gXz5rHB17YGlpUmc5YSEvKd48QLMmzcg3roNGbKQAwcusG7dGG7fXsXgwS0ZOHAeO3acTt5BpxA556Wyj0N7yX1lQkWKFOH169cpUpZKSehT+0ScgoKCMDY25s3bbRgZZUtWWRVdBlKqVEEWLByoTitWtAdNm1Xk19+6xco/ZvRydu86y41by9VpfX+ew/Xrnpw67aZOi4qKomaNEXTuXJdTp24SGBDM1n8mxVkHXe16/L31fzRrXlEj/ad2v6Gjq8OatSOTdYyfS6mHFtetMpHipfIyc+6nOLmUHEHDJs4J/hGuVHokzX+swIixPwDQvcNcgt+9Z/OOUeo8rZtOxzhHNpat7R9re9MsP7F28xAaNi0TZ/leT19T2n4wR8/+SrESeRNxdKnre41dSj20uEKFfpQqVYhFiwar0xwdu9KsWSVcXXvEyj9q1FJ27fLg9u1V6rQ+fWZz/fojzpyZHyt/vnztGTSoJYMHt4y3Dlpatdi2bTLNm1fWSC9WrDutW1dnwoSO6rQyZfrQoEF5pkzpmpjD1JBSD979Hs95QUEh5Mr5A4GBgYle+DHh+4j5XQq4NxMjwyzJK+vde3IUGZ6q9U0Phw8fZty4cUyZMoVSpUqhq6ur8bmxsXGCy5IeqQwiPDyCy5ceUKeOs0Z67TrOeHjcjnObs2fvUPuz/HXrluHSxftERHw60U2dsh4zU2O6da+fpLpFR0ezd+95Che2oWH9sVhbtqaiy8B4u8PTWnh4JNeueFKjVjGN9Bq1inH+7IMElREdHU3wuw/kzJldnXbx3EOq19Ls4q1RuzgXzt5PfqUzCIld8oSHR3Dp0n3q1tVsANap44yHx604tzl79nas73m9emW5+Nn3NiVUquTErl0evHjxGkVROHr0CvfvP6devbgbrGlJznlpQHqk4lW3bl0uXLhA/fr1MTc3J2fOnBqvxJDJ5hmEn18QUVHRmFvk0Ei3sMjBK5+3cW7zyuctFp/lN7fIQWRkFH5+gVhZ5eL06VusWnmAi5cXJrluvr4BBAe/5/fpm5k8pQu/TevOwQMXafXjL7gf/p2q1RI3npzS3vi9IyoqGjNzzSsIMwtjfF8FJqiMBW57CQ0No1nL8uo031cBmJlrXoGZmRsluMxvgcQuefz8AomKisbCQvPEa2GREx8f/zi38fHxjzP/f7+3KWXu3P706jULW9u26Ohoo6WlxbJlw6hcudjXN05lcs5LA4qSAnftZc5Bq6NHj6ZYWdKQSqSwsDDCwsLU74OCglK0/M/vHFAUhS/dTBA7/6f0d+9C6dJpOouXDMbUNOHdlJ+Ljo4ptGlTFwYPjhm6KVmyAB5nbrN0yZ4Mc1JJbOw+2rr5DDN+3ca6LUNjNSjiim9y7u7IqCR2yfP5YX3tWOOKd1zpyTV37j+cPXuHHTumkCePBSdO3KBfvzlYWZlQu7bz1wtIA3LOS0UpMVk8k042r1q1aoqVJQ2pRHJ1dWXy5MkpXq6pqRHa2lqxrsR8fQMxt4i7m9HCMic+n+V/7RuAjo42uXIZcevWU548eUXzZhPVn388QRjoNeDWnRUUKGCdoLrp6Gjj4Ki5QJm9gy2nT8c9fJGWcpkaoq2the+rAI10P9+gWD/un/tniweDf17GivUDqVZTc1KquUWOWD0ofq+DYvW0fMskdsljamqMtrZWrO+hr+/bWL1OH1lamsTqrfL9z/c2pbx/H8a4cSvYtm0yjRrFPEusePECXL36kFmztqR7Q0rOeSI9HT9+/IufV6tWjcjISE6fPk21atW+mFcaUok0ZswYhg4dqn4fFBSEra1tssvV09OltHMh3N0v07xFJXX6YffLNGnqEuc2FSo4sGf3OY20Q4cu4VymMLq6Otjb23Ll2hKNz/83YTXvgt/zx+yfsbU1S3DdypQtzL17zzXSH9x/QR478wSVkZr09HQoUSofx47cpFGzsur0Y0du0KBx/D8WWzefYVCfpSxd05+6DUrF+rxM+YIcP3KDnwc2+FTm4euUrVA4ZQ8gHUnskkdPTxdn58IcOnSJFi0+TfR2d79E06aV4tymQgVHdu/20Eg7ePAiZf793qaUiIhIIiIi0dLS7MHR1tZK1GKDqUXOeWlAFuSMV82aNf/t/Yzd/flxQU5/f39q1qxJVFTUF8uShlQi6evro6+vnyplDx78A106z8DZuTAVXBxYvmwvXl6+9OrdCIBxY1fy4oUfq9fE3EXSq3djFi7YyfBhS+jeowFnPe6wauUB/lw/GgADAz2cnPJq7MM4R8yE4P+mBwe/5+HDl+r3nk98uHr1ESYmhtj9e9IYNqwV7dv9RpUqTlSvUYIDBy6ye/dZ3I/MSJVYJNbPAxvQt/siSpbOR9nyhViz4ggvnr2hS4+Yh09OmbAJ75dvWbjiZyCmIdCvx2J+m9kR53IFeeUTAECWLHoYGWcFoHe/+jSpM4W5M3fRoIkz+3Zd4viRW+w5/OlqNzj4A56PfNTvnz55zY1rT8iZMzu57UwBeOsfzPNnfvh4x+zj4X1vIKbXxsIyR2qGJUEkdskzZMiPdOo0jTJlCuPi4sjSpXvw8vKlT58mAIwZs5yXL/1Ysybme9mnTxMWLNjB0KEL6dmzER4et1m5ch8bNoxTlxkeHsHt20///XMkL174cfXqQ7Jnz0LBgjbAx+/tC/U2np4+XL368N/vrQVGRtmoVq0EI0cuJUsWffLkseD48WusW3eIWbN+TqvwfJGc81KZNKTi9fZt3PPw/svc3DxB+WT5g2RKyeUPIGZxulkztuDt7U9RpzzMmtWHKlVjJoZ26zqTp09fcfg/X+QTx68zbNgSbt96irW1CcNHtKZ3n8bxlt+t68xYtwIfP3aN2rVi3+LbsVMdVq4arn6/auUBfp++iefP/ShcJDf/+19HmjarGGu7xEip5Q8gZlHJeX/s5pVPAPZFczP19w5UrOwAQP+ei/F66sfOg+MBaFp3KmdO3olVRtsOVZi/rI/6/c5t5/ht8haeevqSN78F4ya1pnHzTz03p07cpnm9X79YzsZ1xxnQa2msPCPG/cCo8fHf0p6WvsfYpdTyBxCzIOeMGZvx9vbHySkvf/zRl6pVY+bRdO06nSdPXnH06B//b+/O46Kq+geOf0YEZEdEGEQEF9zAciG3TLQE912TXFIrc01xT03FzDDTXHN9Uszc+lW4Vm6luaC5oeVeSZiKuLCrgHB/f5BjI/ssgOP3/Xrd1+PcOdv9Ps3lzDnnntGkP3DgDGPGLOXcub+pUKEcEyYEaTpeAFFRMVSp0idbPf7+L2rK2b8/kldfHZstTf/+gaxZk7XtREzMPSZP/h+7d5/g3r0kPD1dGTSoPaNH99BrPZahtj+A5++eV6TbH/w2E3u7MvqVlfQQxzpTTW77g9ykp6dz5MiRfKfz/ks6UnoydEfqeWPIjpQQhWHIjtTzxpAdqedNkXakzswwTEfqxekm2ZGKiIggKiqKtLQ0zbmEhASCg4NZvXo1KpWK/v3751uOTO09JSwsjIEDByL9SyGEEM+0TCXr0LcMEzR8+HCWL1+Ora0tZmZmmvOP102NGTMGRVGkI6WLqKioQg3pCSGEEOLZ8vXXX7Nnzx5effVVrfO3b9/G1dWVe/dy3gcuJ9KResquXbtYuHBhcTdDCCGE0I9igH2kTHSx+b1793jxxReznc/tSb68yE/EPCUiIoKGDRsWdzOEEEII/TzekFPfw0ji4uLo168fDg4OODg40K9fP+Lj4/PMM2DAAFQqldbRuHHjQtc9ffp0rK2ts523tbVl+vTphSpLRqSEEEIIUeR69+7NP//8w48//gjAu+++S79+/di+fXue+dq0acOaNU9+9NvCwqLQdU+blrUVyx9//MH58+dRqVTUqlWLatWqad4rKOlICSGEEKaoBC82v3DhAj/++CNHjx6lUaOs3+lctWoVTZo04dKlS9SoUSPXvJaWlqjV+j11Gx8fz8CBA9m2bRulS2d1hdLT0+nYsSNr167F0dGxwGXJ1J4QQghhikrw1F5ERAQODg6aThRA48aNcXBw4MiRI3nm3b9/Py4uLlSvXp1BgwYRGxtb6PqDg4P5448/OHz4MA8fPuThw4dERETw559/MnLkyEKVJSNSQgghhCnKVAzwo8VZI1KJiYlap/X9lY+YmBhcXLL/3I6LiwsxMTE55MjStm1bevbsiaenJ1evXmXq1Km8+uqrnDx5slDt2bZtG9u3b9daX9WoUSNWrlxJhw65b/CaExmREkIIIUSePDw8NIvCHRwcCA0NzTFdSEhItsXgTx8nTpwAyPV37vJ6aq5Xr160b98eX19fOnbsyA8//MDly5fZuXNnoa4nLS0NW1vbbOft7OxITU0tVFkyIiWEEEKYIgOukbp27ZrWzua5jf6MGDGCoKCgPIv08vLi7Nmz3Lp1K9t7j/dxKig3Nzc8PT25cuVKgfMA+Pv78/777/PVV19Rrlw5IGtLhAkTJhR6L0npSAkhhBCmyBBrnP7Nb29vX6CfiHF2dsbZ2TnfdE2aNCEhIYFff/1Vs+XQsWPHSEhIoGnTgv+e4d27d7l27Rpubm4FzgOwaNEi2rdvT6VKlahevToqlYpLly7h7u7O999/X6iypCNlIGaUwkxmSgvNqZRjcTdBPK9MdKPBoiD3Ot1J7LLUqlWLNm3aMGjQIFasWAFkbX/QoUMHrSf2atasSWhoKF27diU5OZmQkBC6d++Om5sbUVFRTJ48GWdnZ7p27Vqo+qtWrcq5c+fYtm0b58+fR1EUatWqRZcuXbR+MqYgpCMlhBBCmKISvP0BwPr16xk5ciSBgYEAdOrUiSVLlmiluXTpEgkJCQCYmZnx22+/8eWXXxIfH4+bmxstW7Zk8+bN2NnZFbp+MzMzunbtWuhO2NOkIyWEEEKYIgNO7RmDk5MTX331VZ5pFOVJR87Kyopdu3YZpO61a9fm+X5Bfqz4MelICSGEEOK5Mnr0aK3X6enp3L9/n9KlS2NtbS0dKSGEEOK5Jz9anKt79+5lOxcVFcXgwYMZO3ZsocqSVW9CCCGECVIUxSDH88LLy4vZs2cTHBxcqHzSkRJCCCGEIGuT0GvXrhUqj0ztCSGEEKaohC82L05bt27Veq0oCjdv3mTJkiU0a9asUGVJR0oIIYQwRdKRylW3bt20XqtUKlxcXHjttdeYO3duocqSjpQQQghhikr4PlLFKSMjw2BlyRopIYQQQggdyYiUEEIIYYpkaq9IyIhUCaMoCiEzvsS9Yi+sbdrT8tWxnDsXlW++b789iI/v25SxaoeP79uEhx/Sej909kYaNhqOvUMnXNU96dp1OpcuaT+Z8N13B2nT5n3Ku3SnlFkAkZF/ZKtn8JAFVPN+E2ub9ri49qBLl2lcvBit1zUbiqIohMxcj7tXP6wdutIy4H3Onf8733zfhh/G58UhlLHrjM+LQwjfekTr/crVB1LKsn22Y/jIpYWqe/CwxVSr+TbWDl1xcX+DLt0/5OLFwj0dYkwSP90V5+f2vwYPWUApswAWLPxO63zLV8dSyixA63jjjVk6XauhyT3PiDKVJ50pnQ/TnNozJOlI5aBFixaF3kfCUOZ8upn5879l8aIR/HpsCWpXJwJbTyQp6X6ueSIizhP0xkf07duKyNPL6du3Fb2CPuLYsQuaNL8cOMuwoZ2IOLKI3btm8+hRBq3bvE9KygNNmpSUhzR92YfQj9/Ota4G9b1Z/cU4zp/7gh9/CEVRFFq3ed+g8826mjPvG+YvDGfxgiH8emQ+ateyBLb7IO/YHb1AUJ/Z9O3zKpHHl9C3z6v06j2bY79e1KT59fACbvy9TnPs/v4jAHp2f/JkR0HqblC/GqtXjeb8meX8uGNmVuw6TC0RsQOJnz6K83P72JYth/n11wtUqFAux/reeacdN65v1hzLlwfrfd2GIPc88axTKc/TblsF1KJFC+rWrcuCBQvyTZuYmIiDgwPxcVuwt7fRq15FUXCvGMSoUV2ZOCEIgNTUNNRurzM79B0GD+6QY76goI9ITLzP999/rDnXtu0kypa1ZcOGKTnmuX07Hld1T/b/PI/mzV/Qei8qKoYqVftx6uQy6tatlmebz579i7r1BnPl8lqqVq1QmMvN8iit8HlyoCgK7l79GPVeZyaO6wlAamo6ao8+zJ41kMGD2uaYL6jP7KzYbf9Qc65th6lZsVs3Mcc8wWNXsvP7X7l8fhUqlUrnus/+dpW6fiO4cv5/VK3qps/l6+25jF9pi8LnyUFJ+Nxev36Hxk3e48cfQunQ8QNGjepG8KgnTyW1fHUsL75YlQXzhxnikg2mJMQOivael5iYgmPZLiQkJGBvb1/o/AWrI+vvUtyWd7G30e+/88SUNMp2WWnU9j7rZESqBLl6NYaYmHsEBvhpzllaWuDf/AUiIs7nmi/i6HkCAhtonQts7ceRPPIkJKQA4ORU+F/Mfiwl5QFrwnZRubIaD4/yOpdjCFmxiyOwVX3NOUtLc/xf8SXi6IVc80Ucu0hAq3pa5wID6nMklzxpaems3/gzAwcEoFKpdK47JeUha9buobKXKx4ezgW+TmOR+OmuuD+3mZmZvNn/E8aN64mPj1eueTds+InyLt3xrfMO48avyHPEp6gUd+wKqyTd8wpE72k9A6yxeg480x2piRMnUr16daytralSpQpTp04lPT1d835ISAh169Zl3bp1eHl54eDgQFBQEElJSZo0KSkpvPnmm9ja2uLm5sa8efPyrDM1NZXExEStw1BiYrJ++8fV1VHrvItrWc17OeeLw9WlrNY5V5eyxMTE5ZheURTGjl1Os2a++PpWLnQ7ly7bhp19R+zsO7Fr13F27/oECwvzQpdjSDG3sq7V1cVR67yLi2OucYB/Y+f6VOxcc4/dlm1HiY9PZkC/VjrVvXT5DuycumPn1J1du0+y+/tZxR47kPjpo7g/t5/M2Uxps1KMfK9rrnX1fuM1NqyfzM8/zeWDKX347rtDdO8+I79LM7rijl1BlcR7nig5numOlJ2dHWFhYZw/f56FCxeyatUq5s+fr5Xmzz//ZMuWLezYsYMdO3Zw4MABZs+erXl//Pjx/Pzzz4SHh7N7927279/PyZMnc60zNDQUBwcHzeHh4aFz+9ev3/fvhzPrSE9/BKD5pv6YoijZzj3t6bez8uScdsR7izn721U2rJ+sU7v79H6NUyeXsf/neXhXc6dX0Ec8fGiYKbqCWr/xZ80fVDun7qSnZ61XyBY7ssfmaTnHLudMq9fspm1rvxzXoRSk7j5vtOTUsUXs3/sJ3tUq0KtPaJHHDiR++ihJn9uTJy+zaFE4a9aMz7OuQYPa0apVfXx9KxMU1JL/+3oqe/ed4tSpK3m2z9BKUuwKoyTc83QiI1JF4pne/uCDDz7Q/NvLy4uxY8eyefNmJkyYoDmfmZlJWFgYdnZZw7n9+vVj3759zJo1i+TkZL744gu+/PJLAgICAFi7di0VK1bMtc5JkyYxZswYzevExESdO1OdOjWhUaOamtepqVmjaTExcbi5PflDczs2Ptu3/v9Sq8tqvtU/Fns75zzvjVzC9u1HObB/HhUr6jY07eBgg4ODDd7eFWncuBZO5boRHn6IN954VafydNGpQyMavVRD8zo17d/Y3YrDzc1Jc75AsXvqW2xsbHy2b8gAf/8dy96fIvl2s/bNWP1v+QWp+0ns3GncqAZOrr0I33qEN3q1yPuCDUzip7uS9Lk9eOh3YmPj8fTqozmXkZHJuHErWLjwO67+9VWOddev7425eWmuXLlO/fre+Vyx4ZSk2BVGSbjn6UQxwIacsow6X8/0iNQ333xDs2bNUKvV2NraMnXqVKKjtR9L9fLy0nSiANzc3IiNjQWyRqvS0tJo0qSJ5n0nJydq1KhBbiwtLbG3t9c6dGVnZ021au6ao3ZtT9RqJ/bsfTIilpaWzoFfztKkSe1cy2nSuDZ792iPou3ZfZKm/8mjKAoj3ltMePgh9u2dQ+XKhlvcrCiK5oZYVLJiV0Fz1K5VCbW6LHv2ntakSUtL58DB32nSuFau5TRpVJO9+yK1zu3Ze5qmOeRZ8+UeXFwcaN+uodb5ypXVOtUNWfeooo4dSPz0UZI+t/36tuJM5ApOn1quOSpUKMe4cT358YfQXOs+dy6K9PRHWh3XolCSYqeP4rjniZLrmR2ROnr0KEFBQcyYMYPWrVvj4ODApk2bsq1xMjfXnsdWqVRk/jtUWdIeWFSpVIwa1ZXQ0I14V3PH29ud0NCNWFtb0rv3k28+/ft/QgV3Z80juyNHdsW/xRg+mbOJzp2asnXbEfbuO8XBX55Mcw4fsZiNG39iS/gM7OysNesPHBxssLKyBODevUSio2O5ceMuAJcu/QOAWu2EWu3EX3/dZPPX+wkMaED58o5cv36HOXM2Y2VlQbun/jgWNZVKxaj3OhM652u8vSvgXa0CoZ98nRW7IH9Nuv5vzaNChXKEfjQAgJEjOuH/2kQ+mft/dO7QmK07jrL3p0gO/jxHq/zMzEzCvtzDm31fo3Rps0LX/ddfN9n8zUECW9WjvLMD12/cZc7cb7Ji1+Yl4wanACR+uivOz225cvaUK6f9Zc7cvDRqtRM1amSNlP/55w3Wb9hHu7YNcXZ24Pz5vxk3fgX16lXj5Zd9jB2ePMk9z8hkQ84i8cx2pA4fPoynpydTpjx51PXvv/PfPPC/qlWrhrm5OUePHqVSpUoAxMXFcfnyZfz9/fPJbRwTxvfiwYM0ho9YTFxcEo0a1WTXj7Oxs7PWpIm+FkupUk8WAzRt6sPGDVOYOi2MadPWUrWqG5s2TqFRoyff5pcv3w5Ay1fHadW3+otxDBjQGoBt2yJ46+0nP9b4Ru+sDfumTetHyPQ3KVPGnEMHf2Phwu+Ii0vG1bUszV+pw+FDC3FxyX0YvqhMGNsjK3YjlxIXl0yjhjXYtXPmU7G7rR27JrXZ+NVEpk5fx7SQr6haRc2m9RNp1LCmVtl790USHX2bt/oH6lR3mTIWHDp0joWLt/4bO0eaN/Pl8P65uDy1yLq4SPx0V5yf2/xYWJTmp59Os2hROMnJD/HwKE+7dg2ZPq0fZmZm+RdgZHLPMyLpSBWJZ3Yfqa1bt9KjRw/WrVvHSy+9xM6dO5kxYwYZGRnEx8cDWU/tbdmyhcjISE2+BQsWsGDBAqKiogAYOnQo33//PatXr8bV1ZUpU6bw008/8fbbbxf5PlLPJQPtIyVEoRloHykhCqNI95Fa3xd7az33kbqfRtk+X8k+Unl4ZtdIde7cmdGjRzNixAjq1q3LkSNHmDp1aqHL+fTTT2nevDmdOnWiVatWNGvWjAYNGuSfUQghhBDPvWd2RKqkkBEpPcmIlCguMiIlikGRjkit622YEal+G2REKg/P7BopIYQQQuROyVBQMvQbK9E3//OgRE3tRUVFoVKpCnT4+voWd3OFEEII8ZwrUSNS5ubmee7h9F9VqlQxcmuEEEKIZ1imATbk1Df/c6BEdaTc3d25ePFicTdDCCGEePZlKFmHvmWIPJWoqT0hhBBCiGdJiRqREkIIIYRhKIqCoufUnDzYnz/pSAkhhBCmKAMDTO0ZpCUmTTpSQgghhCnKyMw69C1D5EnWSAkhhBBC6EhGpAxEOX0AxdayuJvxzFG5lCvuJojnVHpF2YtOV6VPHSjuJjyzlOTUoqsr0wBrpGT7g3xJR0oIIYQwRbL9QZGQqT0hhBBCCB3JiJQQQghhimRn8yIhHSkhhBDCBMmPFhcNmdoTQgghRJGbNWsWTZs2xdraGkdHxwLlURSFkJAQKlSogJWVFS1atODcuXPGbWg+pCMlhBBCmCIlEzL1PBTj7SOVlpZGz549GTp0aIHzzJkzh88++4wlS5Zw/Phx1Go1AQEBJCUlGa2d+ZGpPSGEEMIUlfCn9mbMmAFAWFhYgdIrisKCBQuYMmUK3bp1A2Dt2rW4urqyYcMGBg8ebKym5klGpIQQQgiRp8TERK0jNbXo9sN67OrVq8TExBAYGKg5Z2lpib+/P0eOHCny9jwmHSkhhBDCBD3ekFPfA8DDwwMHBwfNERoaWuTXExMTA4Crq6vWeVdXV817xUE6UkIIIYQpejy1p+8BXLt2jYSEBM0xadKkHKsMCQlBpVLleZw4cUKvy1KpVFqvFUXJdq4oyRqpEkZRFD5cdYhVW84Ql/SQRj5uLB4fiE/V8rnmCdtxlrc//D7b+ZSD4yhjmfV/cZXOS/n7ZmK2NEN71GfJhKxh0hkrD7J5zwWu3UrCwrwUDWqqmTnUn0a+FTTpV4ZHsmnXOU5dukVSShp39wXjaFdG38s2CEVRmLFgD6s2HiMu4T6N6lZiycyu+FRXFyj/pm2R9B65ns4BPoSvGqD13tJ1R5i7Yj83Y5Pwqe7K/GmdeKVhFc373/34GyvXH+Xk7/9wN+4+p3YGU9fHXauMwZO+Yd/hK9y4lYitjSVN63sy+/321Kzmove1G4LET3fLl+3gs3nfEHPzHrV9PJk7bzDNXsn9J2h+OXCWCeNXcf7c37hVKMfYcT14d3B7zftfrt3DoLc/y5YvIXkrZcpYALBi+Q5WrtjJ31G3AKhd25PJH/SmTduXNOlv3YpjyqTV7N1zivj4FJq94sv8hUPx9nbPVnZxkXueERlwjZS9vT329vb5Jh8xYgRBQUF5pvHy8tKpKWp11r0oJiYGNzc3zfnY2Nhso1RFSTpSJcynXx5j/sbjrJ7WnuqVnJi1+git39vMhf8bhJ1N7r/lZ29jyYX/G6R17vENBeBY2AAy/vMr3r//dYfWIzbR47UamnPelZxYND6QKu6OPHiYzoKNx2nz3mYufzeY8mWtAXjwMJ3WTarQukkVJn9esn5va87y/cz/4hfWzO1F9crlmbV4L4F9V3Hxp/HY2eZ94/v7nzjGf7yDVxpWzvbe5u2RjP5wG5/P7MrLfl6sWH+UdgO+4NyecVRyLwtAyv00mvp50aP9C7z7/jc51tGgTkX6dKlPpQqO3Eu4z4wFe2j95ir+OjgJM7PiHxyW+Onm/74+wLgxK1i0ZDhNmtbmf6u+p1OHqUT+toJKlbJ38q5ejaFzx2m89U4b1qwdT8SR84wc8TnlyzvQtVszTTp7e2t+O79KK+/jThSAu7szH80aSNVqWX/0v/pyLz26fcivJ5ZQ28cTRVHo2e1DzM1L881307Czt2Hhgu9o13oykb+twMamZHQG5J5nWpydnXF2djZK2ZUrV0atVrNnzx7q1asHZD35d+DAAT755BOj1FkQxX/3LmYhISHUrVu3uJsBZH0zW7jpOJMHNKVbyxr4Vi1P2PT23H+YzoZd5/PMq1KB2tlW6/iv8mWttd7beegPqlZ0xL9+JU2a3m18aNXQiyrujvhULc+84NdITEnl7JVYTZpRb7zExP5NtL6xlQSKorBw9UEmD3+Nbm3q4FtDTdi8IO4/SGPD1tN55s3IyKRv8AZCRgdSxcMp2/vz//cLb73+Eu8ENaJWNVcWTO+Mh5sjy76K0KTp160B00YF0Opl71zrebd3Y5o3qoKXhxP1fSsyc2xrrt2IJ+qfe7pfuIFI/HS3cH44A94K5K2321CrViXmfTaEih7lWbl8Z47pV63YiUclF+Z9NoRatSrx1ttt6D8wkPnzvtVKp1KpUKudtI7/6tCxMW3bNaR69YpUr16RDz8agK1tGY4duwjAlSvXOXbsIos/H4HfSzWoUaMii5cMJzn5AZs37TdKLApL7nnGZcg1UsYQHR1NZGQk0dHRZGRkEBkZSWRkJMnJyZo0NWvWJDw8HMj6TAQHB/Pxxx8THh7O77//zoABA7C2tqZ3795Ga2d+nvuOVEly9UYCMXdTCGjspTlnaVGa5vU9iDh7Pc+8yQ/SqNxpKZU6fE7H0f/H6Uu5L7xLS89g/Q/nGNjxhVznldPSM1i1JRIHW0terF78Uyf5uXrtHjG3kwh8pbrmnKVlafwbVSHi5N955v1w4R7KO9nwdq+G2d5LS3vEyd+va5ULEPBK9XzLzUvK/TTW/N8JKns44eHmqHM5hiLx001aWjqnTl0hIKC+1vlWAfU5GpFzR+DY0Yu0eip9YGB9Tp68Qnr6I8255OQHeFfpTxXPvnTpNJ3I03/k2o6MjAy+3ryflJSHNG5cM6ttqekAWJYx16QzMzPDwqI0Rw4X7waGj8k9z8gyMg1zGMm0adOoV68e06dPJzk5mXr16lGvXj2tNVSXLl0iISFB83rChAkEBwczbNgw/Pz8uH79Ort378bOzs5o7cyPTO2VIDF3s3rhrk42WuddnWxynOt/rKZnOVZPa0+dquVJTElj0eYTvPLOV5xe/xbelbKPEGzZf5n45If071An23s7Dv5B7w+2cv9hOm7OtuxaEoSzo7WeV2Z8MbezNmNzLa/9rdSlvB3R/8Tlmu/wiaus/vo4p78fneP7d+JSyMjIxLW89ofUtbwtMXcKvwHc0nVHmBi6k5T7adSs6sLurwZhYVH8H0OJn27u3EkkIyMTF5eyWuddXRyJuZVz3GJuxRHo4qh1zsWlLI8eZXDnTiJubk7UqFGR/60ei6+vF4mJ91myeAstmo/j+KnPtdY3/f7bVZo3G8PDh2nY2lrx9TdTqVXbE4AaNT3w9HRh6pQwPl/2HjY2ZVg4P5yYmDhu3iz+UVCQe97zLiwsLN89pBRFe0RMpVIREhJCSEiI8RpWSCV+ROqff/4hKCgIJycnbGxs8PPz49ixY5r3ly1bRtWqVbGwsKBGjRqsW7dOK390dDSdO3fG1tYWe3t7Xn/9dW7dupVrfVevXqVatWoMHTqUzMzsPfHU1NRs+2noav2P57D3n6c50h9l1Zf9iYSsYezcNK7jTt+2vrxY3ZVX6nmw+eMuVK/kxJKvT+aYfvW2s7RpUoUK5bP34Fv6VeLUV29x6H/9aN24CkGTthB7L0XnazSW9VtOYVd7iuZIT88AcnuaI+cykpIf0i94IytDe+D81I38aU8XoSjZzxVEn871OLUzmP2bh+Jd2Zlew7/i4cN0HUrSj8TPsAr7FFFO6bPOZ71u1LgWvfu8ygsvVqHZK75s2DQZ7+ruLP18m1a+6jUq8uvJzzl4eD7vDm7PO2/N48L5rJE+c/PSbPr6A65cuY66/Os42nXhwIGztG7jV2xryuSeV7QUxQBTe4rxpvZMRfF/Fc5DcnIy/v7+uLu7s23bNtRqNadOndJ0cMLDwxk1ahQLFiygVatW7Nixg4EDB1KxYkVatmyJoih06dIFGxsbDhw4wKNHjxg2bBi9evVi//792er7/fffCQwMpH///rnukREaGqrZjVVfnV6pRiOftzSvU9OyhvVj7ibj9p/5/ti4lGzf2PJSqpQKv9puXLmW/Rvx3zcT2Hc8im8+6ZpjXhsrC6p5WFDNoyyN67hTo/sKVm87y/sDmhS4/qLQqVVtGtV9stZBE7vYJNxcnjxZcvtOMq7OOQ/5/vn3XaL+iaPTO2s05zL/XQ9gXnUiF38aj4ebI2ZmpTQjNo/F5lFuXhzsrXCwt8K7cnka16uE04vTCN/1O290rlfosvQh8TMMZ2d7zMxKceuW9ghP7O0EXJ8adXpM7Vo222jV7dvxlC5tRrlyOT8VVapUKfz8qvPHlRta5y0szKn272LzBn7VOXHiMosXb2XpspEA1G/gzfGTn5OQkEJaWjrlyzvSrEkw9f1yX4tmTHLPK2IlfGdzU1GiO1IbNmzg9u3bHD9+HCenrOHaatWqad6fO3cuAwYMYNiwYQCMGTOGo0ePMnfuXFq2bMnevXs5e/YsV69excPDA4B169bh4+PD8ePHeemlJ48JR0RE0KFDByZNmsS4ceNybdOkSZMYM2aM5nViYqKm7MKys7HUeipFURTU5WzYeyyKejWyHvNMS8/gl1PXCB3RosDlKorCmcu38K2W/fHhsO1ncSlrTfuXq+WQM+eyHt/sShI72zJaT5IpioK6vB17Dl2mnm/W1Eda2iMOHPuL2e+3y7GMmlVdOLtrrNa5qXN/JCklVbMg2sKiNA183dlz6Apd2zyZFth76DKdAnz0vg5FoVjiK/EzDAsLc+rX92bv3tN07vKy5vy+vafo2DHnP8SNGtdk585jWuf27DlFgwbemJvnfEtWFIUzZ/7E19crz/YoiqJZG/VfDg5ZnZIrV65z8uQVps/ol2c5xiL3PGGKSnRHKjIyknr16mk6UU+7cOEC7777rta5l19+mYULF2re9/Dw0Oro1K5dG0dHRy5cuKDpSEVHR9OqVSs++ugjRo/Oea3HY5aWllha5v5Irj5UKhWjgl4iNCyCah5l8a7kROiaCKzLmNO7dW1Nuv7Tt+PuYsfHw1sA8OGqQzTyrYB3JScSU1JZvPkEkZdjWTwhUKv8zEyFsB2/8Wb7OpQurT20n/IgjY/XRNDxlWq4OdtyN+EBy745xT+xSfR4raYmXcydZGLupfDHtXgAfvvjNnY2FlRytcfJwcoocSkIlUrFqLdeIfTzn/D2csa7cnlCP9+HtZUFvf8zWtF/zEYquDoQOrEdZcqY41tDe48kR/uszsV/z49+pzlvjtmE3wsVaVLfk5UbjhF9I54hfZ78obwXf5/o63HciM2a6r30120A1OXtULvY81f0XTZvP0Ng8+qUd7LhekwCc5bvx6qMOe1a1jJaXApK4qe7UaO7MrD/XBo08KZR41p8seoHrkXfZtDgrA7oB5PXcOPGXVaHZX1BGzS4PcuWbmf82JW89U4bjh29QNjq3axbP1FT5kcfrqdho5pU865AUuJ9Pl+ylTORf7Fw0XBNmqlTwmjdxo+KHuVJTrrP15sP8MuB39i+c6YmzbffHMTZ2QGPSuX5/fcoxo1eTqfOTQgIbFBE0cmb3POMLFPJOvQtQ+SpRHekrKzy/480r7UJua1TePp8+fLlqVChAps2beLtt98u0KZjxjL+zUY8SE1nxJzd/25OV4EfF/fS+hZ37VYipUo9aX980kOGhP5IzN0UHGwtqVvdlf0r+tDQR/tx3b2/RhEdk8jAji9kq9esVCkuRt3ly52/cSf+AeUcrPCrrebAyr5aG+Ot+O40H/7vsOZ1i8HrAfhiWjsGdMheblGaMKQFDx6mM3xqOHEJD2hUtxK71g3SGnmJvh5PqULugNurY13uxt9n5sK93LydiG91NTvXvI1nxScLjLftOcdb47/WvH7jvay4TBsVQMjoQMpYlubQ8assXHOQuIQHuDrb0rxhFQ5/OxyXpx7bLi4SP930fN2fu3eT+PijDdy8eQ8fXy+2bv8QT8+sDQJjYu5xLfrJ4/SVK6vZuv1Dxo9byfJl23GrUI7PFgzR2kMqPj6Z4UMXERNzDwcHG16sW5V9P3/KSw2f7IEUGxvHWwM+5ebNrDS+dSqzfedMrScCb968x4RxK7l1Kx43Nyf69H2NyR+8UQRRKTi55xmPkgGKnlNzSoaBGmPCVEoJXkm2du1aRo4cydWrV3MclXr55Zfx8fFh5cqVmnOvv/469+/fZ8eOHezZs4e2bdtqTe2dP39eM7Xn5+dHSEgIW7Zs4fDhw7Rr1460tLRCPUqZmJiIg4MDcT+Nxt7WOCNVpkzlUq64myCeU+kVc995XOSt9CnZmFJXicmplH11PgkJCUb70v7479LN4FbYW+o3XpKY+gi3BXuN2t5nXYl+au+NN95ArVbTpUsXDh8+zF9//cW3335LRETWRn7jx48nLCyM5cuXc+XKFT777DO+++47zRqnVq1a8cILL9CnTx9OnTrFr7/+yptvvom/vz9+fn5addnY2LBz505Kly5N27ZttTYEE0IIIZ45j6f29D1Enkp0R8rCwoLdu3fj4uJCu3btqFOnDrNnz8bMzAyALl26sHDhQj799FN8fHxYsWIFa9asoUWLFkDWtN+WLVsoW7YszZs3p1WrVlSpUoXNmzfnWJ+trS0//PADiqLQrl07UlJM4xFYIYQQz6ESviGnqSjRU3vPApna049M7YniIlN7upOpPd0V5dTejaEtDDK1V2HZfpnay0OJHpESQgghhCjJirwjFRUVhUqlKtDh6yvfGIUQQgidZCpPNuXU9ZA1Uvkq8u0PzM3NqVGjRv4JgSpVqhi5NUIIIYRpevwzL/qWIfJW5B0pd3d3Ll68WNTVCiGEEEIYXInekFMIIYQQulEyFANsyCkjUvmRjpQQQghhgmRqr2jIU3tCCCGEEDqSESkhhBDCBGVmKGTqOTWnb/7ngXSkhBBCCBMkU3tFQzpSBqKq3xKVvU1xN0MIUUDmxd2AZ5lfQHG34JmlSkwB5hd3M4QBSUdKCCGEMEFKZiZKpn6/ladv/ueBdKSEEEIIU2SA7Q+QNVL5ko6UEEIIYYIUxQBrpBTpSOVHtj8QQgghhNCRjEgJIYQQJkjJUFBKyc7mxiYdKSGEEMIEyfYHRUOm9oQQQgghdCQjUkIIIYQJysxUyNRzREnf/M8D6UgJIYQQJkjJwABrpAzUGBMmU3tCCCGEEDoyuY5UixYtCA4OLu5m6Gzp0q1UqdIHK6s2+PkN4eDBs3mmP3DgDH5+Q7CyakPVqn1Zvnx7tjTffvsLPj4DKVOmDT4+AwkPP1ToehVFISRkLe7ur2Nt3ZaWLcdw7lyUXtdqaBI73Uns9CPx053EzngeLzbX9xB5M7mO1HfffcfMmTOLuxk62bz5Z0aPXsrkyb05dWoFzZrVoV27SURH38ox/dWrN2nffjLNmtXh1KkVTJr0BqNGLeHbb3/RpImIOEdQ0Ez69g0gMnIlffsG0KvXhxw7dqFQ9c6Zs4n5879h8eL3+PXXpajVZQkMnEBS0n3jBaQQJHa6k9jpR+KnO4mdcUlHqmioFNm2VC+JiYk4ODgQH78Nez1/tLhx4+HUq+fNsmXBmnO1aw+kc+eXCQ19J1v6iRNXsn17BOfPr9GcGzJkPmfP/smRI0sACAqaSWJiCt9/P1uTpm3b9ylb1pYNGz4oUL2KouDu/jqjRnVj4sQ3AEhNTUOt7sHs2YMYPLijXtdtCBI73Uns9CPx093zGLvExBQcHTuRkJCAvb29zuXkXUfW36ULrethZ26mV1lJ6RnU2nXaqO191pnciNR/p/a8vLz4+OOPeeutt7Czs6NSpUqsXLlSK/2RI0eoW7cuZcqUwc/Pjy1btqBSqYiMjCzSdqelpXPy5GUCA/20zgcENCAi4lyOeY4ePU9AQAOtc61bv8SJE5dJT38EQETEeQICtMsMDPTjyJFzBa736tWbxMTc00pjaWmBv/+LubatKEnsdCex04/ET3cSO+NT/v2tPX0PkTeT60g9bd68efj5+XH69GmGDRvG0KFDuXjxIgBJSUl07NiROnXqcOrUKWbOnMnEiROLpZ137iSQkZGJq2tZrfOurmWJibmXY56YmHs5pn/0KIM7dxLyTBMTE1fgeh+nfTqNi8uTcoqTxE53Ejv9SPx0J7EzPkXJRMnU81Ayi/sySjyT3/6gXbt2DBs2DICJEycyf/589u/fT82aNVm/fj0qlYpVq1ZRpkwZateuzfXr1xk0aFCu5aWmppKamqp5nZiYaND2qlTarxUFVE+f1Eqv/d7jmdr/ns8pzdNFFqTenMvJvW1FTWKnO4mdfiR+upPYGY+SoaCo5CdijM3kR6ReeOEFzb9VKhVqtZrY2FgALl26xAsvvECZMmU0aRo2bJhneaGhoTg4OGgODw8Pg7TT2dkBM7NS2b7txMbGZftW9Jha7ZTtm1tsbDylS5tRrpx9nmkel1mQetXqrP99upzbt+NxdXUsxFUah8ROdxI7/Uj8dCexE7NmzaJp06ZYW1vj6OhYoDwDBgxApVJpHY0bNzZuQ/Nh8h0pc3NzrdcqlYrMzKyhypy+XeS39n7SpEkkJCRojmvXrhmknRYW5jRoUJ09e05qnd+79yRNmvjkmKdx49rs3audfvfuE/j5VcfcPGuwsUmT7Gn27DlB06Y+Ba63cmU31GonrTRpaekcOHAm17YVJYmd7iR2+pH46U5iZ3wl/am9tLQ0evbsydChQwuVr02bNty8eVNzfP/990ZqYcGY/NReXh5P76WmpmJpaQnAiRMn8sxjaWmpSWtoo0f34M03Z+PnV50mTWqzcuVOoqNjGTIk6wmRSZP+x40bd1i79n0AhgzpyOefb2XMmKUMGtSeiIjzrF79Axs2TNGUOXJkN/z9g/nkk4107vwyW7ceZu/eUxw8uLDA9apUKkaN6kZo6Aa8vSvi7e1OaOgGrK3L0Lv3a0aJRWFJ7HQnsdOPxE93EjvjKuk/ETNjxgwAwsLCCpXP0tIStVpthBbp5rnuSPXu3ZspU6bw7rvv8v777xMdHc3cuXOBvOfojaVXr5bcvZvIzJnruHnzHr6+XuzcGYqnpysAMTF3iY6O1aSvXNmNnTs/ZsyYpSxduo0KFcqxcOEIundvrknTtKkPGzd+wNSpa5g2LYyqVSuwadNUGjWqVeB6ASZMCOLBgzSGD19IXFwSjRrVYteuT7Czsy6CyORPYqc7iZ1+JH66k9gJXezfvx8XFxccHR3x9/dn1qxZuLi4FFt7TG4fqRYtWlC3bl0WLFiAl5cXwcHBWjud161bly5duhASEgJkbX/w+Em+OnXqMHbsWHr37s3FixepUaNGvvUZch8pIYQQpq0o95GKbFIbu9J67iP1KIO6Eee5du2aVnsNOTsTFhZGcHAw8fHx+abdvHkztra2eHp6cvXqVaZOncqjR484efKk0WaL8mNyI1L79+/X/DsqKirb+0/vD9W0aVPOnDmjeb1+/XrMzc2pVKmSkVoohBBCGJ8h1jg9zv/0g1XTp0/XDEj8V0hIiGbKLjfHjx/Hz88vzzS56dWrl+bfvr6++Pn54enpyc6dO+nWrZtOZerL5DpShfXll19SpUoV3N3dOXPmDBMnTuT111/HysqquJsmhBBClAg5jUjlZMSIEQQFBeVZlpeXl8Ha5ebmhqenJ1euXDFYmYX13HekYmJimDZtGjExMbi5udGzZ09mzZpV3M0SQggh9GLIfaTs7e0LNBXp7OyMs7OzXnUWxt27d7l27Rpubm5FVufTTH77g/xMmDCBqKgoHj58yNWrV5k/fz7W1rKYUAghxDNOMcDWB0ZcRh0dHU1kZCTR0dFkZGQQGRlJZGQkycnJmjQ1a9YkPDwcgOTkZMaNG0dERARRUVHs37+fjh074uzsTNeuXY3Wzvw89yNSQgghhCh606ZNY+3atZrX9erVA+Dnn3+mRYsWQNbG2QkJWT//Y2Zmxm+//caXX35JfHw8bm5utGzZks2bN2NnZ1fk7X9MOlJCCCGECVIyDTC1Z8R9pMLCwvLdQ+q/GwtYWVmxa9cuo7VHV9KREkIIIUyQkqGgIL+1Z2zSkRJCCCFMUGamQqaeI1LG3NncVDz3i82FEEIIIXQlI1JCCCGECcrMhEw9f+0sM9MwbTFl0pESQgghTJB0pIqGTO0JIYQQQuhIRqSEEEIIEyQjUkVDOlJCCCGECcpUsg59yxB5k6k9IYQQQggdyYiUEEIIYYJkaq9oSEdKCCGEMEGZiv4dIZnay59M7QkhhBBC6EhGpIQQQggTpGSCvjNzikzt5Us6UkIIIYQJyjRAR0rWSOVPOlJCCCGECZKOVNGQNVJCCCGEEDqSESkhhBDCBMmIVNGQEakSZunSrVSp0gcrqzb4+Q3h4MGzeaY/cOAMfn5DsLJqQ9WqfVm+fHu2NN9++ws+PgMpU6YNPj4DCQ8/pPV+aOgGGjYchr19B1xdu9O161QuXbqmlSY5+QEjRizCw6MX1tZtqV17IMuWbdP/gg3I0LE7dy6KHj1CqFy5N6VKvcaCBd/qVG9IyFpq1RqArW17nJw6ExAwnmPHLuh3sQYmsdOPoiiEhKzF3f11rK3b0rLlGM6di8o3X36fTcg/RgWp+88/b9Ct2zRcXLrh4NCRXr0+5Nate/pcssHIPc94MjMNc4i8SUeqBNm8+WdGj17K5Mm9OXVqBc2a1aFdu0lER9/KMf3Vqzdp334yzZrV4dSpFUya9AajRi3h229/0aSJiDhHUNBM+vYNIDJyJX37BtCr14daf4x++eUsw4Z1IiJiCbt3z+HRowxat55ASsoDTZrRo5eya9dx1q2bxPnzawgO7s7IkYvZuvWw8QJSCMaI3f37D6lc2Y3Q0HdQq510rrd69YosXvweZ8+u4uDBhXh6utK69URu3443aAx0JbHT35w5m5g//xsWL36PX39dilpdlsDACSQl3c81T0E+mwWJUX51p6Q8oHXrCahUKvbtm8uhQwtJS0unU6cPyCzmv5JyzxOmQKUoimy3pYfExEQcHByIj9+Gvb2NXmU1bjycevW8WbYsWHOudu2BdO78MqGh72RLP3HiSrZvj+D8+TWac0OGzOfs2T85cmQJAEFBM0lMTOH772dr0rRt+z5ly9qyYcMHObbj9u14XF27s3//fJo3fwGAOnXe5vXXWzB1aj9NOj+/IbRt24iZMwfqdd2GYIzY/Vflyr0ZNao7wcHd9aoXIDExBUfHTuzZ8ymvvVa/kFdqeBI7/SiKgrv764wa1Y2JE98AIDU1DbW6B7NnD2Lw4I455ivIZzO/GBWk7t27T9Cu3STu3duiuUfFxSVRrlwXdu+eQ6tWDYwRlgJ5Hu95j/8bTkhIwN7eXudy8q4j6+/Sdpdq2JQy06uslMwMOsb+YdT2PutkRKqESEtL5+TJywQG+mmdDwhoQETEuRzzHD16noAA7Ztg69YvceLEZdLTHwEQEXGegADtMgMD/ThyJOcyARISUgBwcrLTnHv5ZV+2b4/g+vXbKIrCzz+f5vLlf2jd2i+3YoqMsWJnjHrT0tJZuXInDg42vPhi1QLVY0wSO/1dvXqTmJh7WtdiaWmBv/+LuV4L5P/ZLEiMClJ3amoaKhVYWppr0pQpY0GpUqU4dOh3Ha9af3LPMz5FUQxyiLxJR6qQUlNTSUxM1DoM4c6dBDIyMnF1Lat13tW1LDExOa9liIm5l2P6R48yuHMnIc80MTFxOZapKApjxy6jWTNffH0ra84vWjSC2rUr4eERhKVla9q2ncTnn4+iWbM6hb5WQzNW7AxZ744dEdjZtcfKqi0LFnzD7t1zcHZ2KFA9xiSx09/jz9LT1+LikvvnLCtf3p/NgsSoIHU3blwbGxsrJk5cxf37D0lJecD48SvIzMzk5s27hb1cg5F7njAV0pEqpNDQUBwcHDSHh4eHQctXPfUDk4oCqqdPaqXXfu/xt4f/ns8pTW5FjhixiLNn/8o2BL5oUThHj15g69aZnDixjLlzhzB8+EL27j2Z3yUVGWPEzlD1tmxZl9OnV3L48CJat36JXr1mEhub+x/ZoiaxK7j16/diZ9deczweCcn5c5Z3PAry2SxIjPKqu3x5R77+etq/HdIOODp2IjExhfr1vTEz02/axxDknmc8sti8aMj2B4U0adIkxowZo3mdmJhokM6Us7MDZmalsn1rio2Ny/bt6jG12inbN7fY2HhKlzajXDn7PNPkVOZ77y1m+/YIDhyYT8WK5TXnHzxIZcqUL/juuxm0b98YgBdeqEpk5B/Mm/d/xbrGAowXO0PWa2NjRbVq7lSr5k7jxrWpXv1NvvjiByZN6l2guoxFYld4nTo1pVGjWprXqanpQNZIiJtbOc35rHU3jrmWk99nsyAxUqvLFqjuwEA//vjjK+7cSaB0aTMcHW1xc+tB5crqQly5Yck9z/hk+4OiISNShWRpaYm9vb3WYQgWFuY0aFCdPXu0v+3s3XuSJk18cszTuHHtbN+Odu8+gZ9fdczNs/rITZpkT7NnzwmaNn1SpqIojBixiPDwg+zbN5fKld200qenPyI9/RGlSml/pTMzK1XsT/2A8WJnjHofUxRF8we4OEnsCs/OzlrTsatWzZ3atT1Rq520riUtLZ0DB87keS35fTYLEqPKld0KVbezswOOjrb89NNpYmPj6dSpaeEDYCByzxOmQkakSpDRo3vw5puz8fOrTpMmtVm5cifR0bEMGZL11M+kSf/jxo07rF37PgBDhnTk88+3MmbMUgYNak9ExHlWr/6BDRumaMocObIb/v7BfPLJRjp3fpmtWw+zd+8pDh5cqEkzfPgiNm7cx5YtM7Gzs9Z8m3NwsMHKyhJ7exv8/V9kwoSVWFlZ4unpyoEDZ1i3bg/z5g0twgjlzhixS0tL5/z5v//99yOuX79DZOQf2NpmjZAUpN6UlAfMmrWeTp2a4uZWjrt3E1i6dBv//HObnj39izJEuZLY6UelUjFqVDdCQzfg7V0Rb293QkM3YG1dht69X9Ok699/NhUqOGueRivIZzO/GBW07jVrfqRWrUqUL+9IRMQ5goM/Jzi4OzVqGHZpQmHJPc+4MhX9R5QyZa15vmT7gxwsWbKE8PBw9u3bl29aQ25/AFmb03366WZu3ryHr68Xn302TPM47sCBnxAVdYuff/5Mk/7AgTOMGbOUc+f+pkKFckyYEKS5CT32zTcHmDp1DX/9dZOqVSvw0Udv0a3bK5r3S5V6jZysXj2eAQPaAFlTB5Mn/4/du09w714Snp6uDBrUntGjexR6XYyxGDp2UVExVKnSJ1s9/v4vapWTV70PH6bRp88sjh27wJ07iZQrZ89LL9VgypQ+vPRSTWOFotAkdvpRFIUZM75k5codxMUl0ahRLZYsGam1eLllyzF4ebmyZs1Ezbn8PpuQd4wKWvf7769i7dpd3LuXhJeXK4MHdywxn93n7Z5XlNsf/J99VaxV+q2Du69k0DPxT9n+IA/SkcpBSEgIYWFhREVF5ZvW0B0pIYQQpqsoO1KbbQ3TkeqVLB2pvMgaqRyEhIQUqBMlhBBCiOebrJESQgghTFBmJmTqOXsra6TyJx0pIYQQwgRJR6poyNSeEEIIIYSOZERKCCGEMEGZigE25JQRqXxJR0oIIYQwQTK1VzRkak8IIYQQQkcyIiWEEEKYIBmRKhrSkRJCCCFMkHSkioZM7QkhhBBC6EhGpPT0+Bd2EhPvF3NLhBBClHSP/1YUxa+zpSiZeo8oPdD7uT/TJx0pPSUlJQFQqVJQMbdECCHEsyIpKQkHBwejlG1hYYFarWZkzFWDlKdWq7GwsDBIWaZIfrRYT5mZmdy4cQM7O7sS8UvqQgghSi5FUUhKSqJChQqUKmW81TUPHz4kLS3NIGVZWFhQpkwZg5RliqQjJYQQQgihI1lsLoQQQgihI+lICSGEEELoSDpSQgghhBA6ko6UEEIIIYSOpCMlhBBCCKEj6UgJIYQQQuhIOlJCCCGEEDr6fz2lWqsR1oVoAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1523,4573 +509,77 @@ } ], "source": [ - "attr_viz_6 = LLMAttrViz(**attr_result_6)\n", - "attr_viz_6.plot_seq_attr()\n", - "attr_viz_6.plot_token_attr()" - ] - }, - { - "cell_type": "markdown", - "id": "documented-harvard", - "metadata": {}, - "source": [ - "One potential issue with the current approach is using Feature Ablation. If the model learns complex interations between the prompt features, the true importance may not be reflected in the attributio scores. Consider a case where the model predicts a high probability of playing golf if a person is either a lawyer or lives in Palm Coast. By ablating a feature one at a time, the probability may appear to be unchanged when ablating each feature independently, but may drop substantially when perturbing both together.\n", + "sv = ShapleyValues(model) \n", + "\n", + "sv_llm_attr = LLMAttribution(sv, tokenizer)\n", "\n", - "To address this, we can apply alternate perturbation-based attribution methods available in Captum such as ShapleyValueSampling, KernelShap and Lime, which ablate different subgroups of features and may result in more accurate scores." - ] - }, - { - "cell_type": "code", - "execution_count": 537, - "id": "iraqi-gibson", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Sarah lives in Boston, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5114422240003478e-05 ]\n", - "sv shape torch.Size([12, 5])\n", - " Dave lives in Boston, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4987554070321494e-07 ]\n", - " Dave lives in Seattle, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.2764603424293455e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.193209396267775e-06 ]\n", - " Sarah lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.763693166547455e-05 ]\n", - " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", - " John lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.899505489040166e-05 ]\n", - " Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0484606036698096e-06 ]\n", - " John lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.1097308490425348e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.106719148287084e-05 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8824379367288202e-05 ]\n", - " Rachel lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.271564310125541e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2926978342875373e-05 ]\n", - " Martin lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.373025538166985e-05 ]\n", - " Dave lives in Seattle, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.766460162703879e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.30380283028353e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.227898777273367e-07 ]\n", - " Dave lives in Boston, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.448989435943076e-06 ]\n", - " Dave lives in Palm Coast, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.861600973526947e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1721839427991654e-06 ]\n", - " Sarah lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.4719674810476135e-06 ]\n", - " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " John lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.480950221681269e-06 ]\n", - " Rachel lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4692967599548865e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", - " Dave lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.687276825483423e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.121143031923566e-05 ]\n", - " Sarah lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3429129467112944e-05 ]\n", - " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1338612239342183e-05 ]\n", - " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", - " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.3837108023581095e-06 ]\n", - " Rachel lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.194474513496971e-06 ]\n", - " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.21195658823126e-06 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.873038844583789e-06 ]\n", - " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", - " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.23475090530701e-06 ]\n", - " Rachel lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4643317172158277e-06 ]\n", - " Rachel lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.995898153647431e-07 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.685973403364187e-06 ]\n", - " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.1373730305640493e-06 ]\n", - " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", - " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", - " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Boston, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0030606063082814e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0534930652283947e-06 ]\n", - " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", - " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.603064088674728e-06 ]\n", - " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.508013939310331e-06 ]\n", - " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6120865211632918e-06 ]\n", - " Sarah lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.23475090530701e-06 ]\n", - " Rachel lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.807389920344576e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4758370525669307e-05 ]\n", - " Martin lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.761676842055749e-05 ]\n", - " Dave lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.491680323961191e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", - " Rachel lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6276373571599834e-05 ]\n", - " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n", - " Sarah lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7024378141504712e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.746541763888672e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.173955181206111e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.485392987087835e-06 ]\n", - " Martin lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.8024847779306583e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.108045398723334e-05 ]\n", - " Martin lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.213460488244891e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.480950221681269e-06 ]\n", - " John lives in Palm Coast, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.958523277309723e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2626491045230068e-05 ]\n", - " Sarah lives in Seattle, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.385400850675069e-05 ]\n", - " Rachel lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2062064342899248e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.06315609527519e-06 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.193209396267775e-06 ]\n", - " Dave lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.7140732678817585e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.685696568340063e-05 ]\n", - " John lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.085239536128938e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2548389349831268e-05 ]\n", - " John lives in Palm Coast, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.14929467701586e-06 ]\n", - " Dave lives in Palm Coast, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.3295709727099165e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", - " Dave lives in Boston, FL and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1043377980968216e-06 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.889714935212396e-05 ]\n", - " Rachel lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.787422989873448e-06 ]\n", - " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4927624761185143e-05 ]\n", - " Martin lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0794499758048914e-05 ]\n", - " John lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.32769481651485e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2288547623029444e-05 ]\n", - " Dave lives in Boston, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0030606063082814e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.626012999622617e-05 ]\n", - " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.8221547078574076e-05 ]\n", - " Sarah lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7024378141504712e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.4307087086490355e-06 ]\n", - " John lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2543938282760791e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.537572633329546e-06 ]\n", - " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", - " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.448989435943076e-06 ]\n", - " Dave lives in Seattle, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4255711903388146e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.0007188140880316e-05 ]\n", - " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.009897444731905e-07 ]\n", - " Dave lives in Seattle, FL and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9428996438364265e-06 ]\n", - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0710449487305596e-06 ]\n", - " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", - " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4987554070321494e-07 ]\n", - " Dave lives in Palm Coast, WA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.3547094062669203e-06 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", - " Martin lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.692947292525787e-06 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.841361260332633e-06 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", - " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", - " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", - " Martin lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.692947292525787e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.240416430751793e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6553814930375665e-05 ]\n", - " Rachel lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4643317172158277e-06 ]\n", - " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.97077859210549e-06 ]\n", - " Sarah lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.1958392608212307e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.229522568901302e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.1782808491698233e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.1584108910465147e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.973982974363025e-06 ]\n", - " Martin lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6521782526979223e-05 ]\n", - " John lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.541747355484404e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", - " Dave lives in Seattle, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.761077202099841e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.175311450031586e-06 ]\n", - " Sarah lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.664822765538702e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7474596208776347e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.108045398723334e-05 ]\n", - " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.9818938855896704e-06 ]\n", - " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Boston, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", - " Dave lives in Seattle, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.227144801116083e-06 ]\n", - " Dave lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4610484615550376e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", - " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.185174008052854e-07 ]\n", - " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.4307087086490355e-06 ]\n", - " Rachel lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.2577593123714905e-06 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8029744751402177e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", - " John lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.2905325042520417e-06 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.389164653024636e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.071933119575988e-07 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.688950063311495e-06 ]\n", - " Dave lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", - " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0710449487305596e-06 ]\n", - " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.6533326642238535e-06 ]\n", - " Dave lives in Seattle, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6396523026051e-05 ]\n", - " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.942811862449162e-06 ]\n", - " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", - " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.878842550075206e-07 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Rachel lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.642711251610308e-06 ]\n", - " John lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.5235010475153103e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0534930652283947e-06 ]\n", - " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3604388186649885e-05 ]\n", - " John lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.11088529592962e-05 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.493829126455239e-06 ]\n", - " Dave lives in Boston, FL and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1043377980968216e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.000689841632266e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.543208782095462e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4346121133712586e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.8950561651727185e-05 ]\n", - " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", - " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", - " Martin lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.305322363507003e-06 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.78439948084997e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2185448667878518e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.87206743855495e-05 ]\n", - " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.508013939310331e-06 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9458868791843997e-06 ]\n", - " John lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.0111195883364417e-06 ]\n", - " Dave lives in Boston, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4384635821661504e-07 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, WA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0618667147355154e-05 ]\n", - " John lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3888860848965123e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4346121133712586e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.839130502252374e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.685973403364187e-06 ]\n", - " John lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.169937791535631e-05 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.856503899944073e-06 ]\n", - " John lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.135143404302653e-05 ]\n", - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3854206599717145e-06 ]\n", - " Rachel lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.974666702153627e-06 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7345660126011353e-06 ]\n", - " Rachel lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6276373571599834e-05 ]\n", - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.951152499823365e-06 ]\n", - " John lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2912672900711186e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.584994869423099e-05 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.009874378927634e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6951678844634444e-05 ]\n", - " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", - " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.528855477772595e-06 ]\n", - " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.849522378615802e-06 ]\n", - " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", - " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3714279702981003e-05 ]\n", - " Martin lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.784412678622175e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.796097967599053e-05 ]\n", - " John lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.1097308490425348e-05 ]\n", - " Martin lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.632036143448204e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.1637800930184312e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1344003496560617e-06 ]\n", - " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.5707594179257285e-06 ]\n", - " Sarah lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.629943295090925e-06 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.796097967599053e-05 ]\n", - " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.175311450031586e-06 ]\n", - " Martin lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.375547359813936e-05 ]\n", - " Martin lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3855085853720084e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2665129361266736e-05 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.211084953771206e-06 ]\n", - " Sarah lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.2684488360246178e-06 ]\n", - " Rachel lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.995898153647431e-07 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.30380283028353e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.0083914478163933e-06 ]\n", - " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7119297101307893e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.060348591243383e-06 ]\n", - " Martin lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.761676842055749e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.384238516446203e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3579434582643444e-06 ]\n", - " Sarah lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.1958392608212307e-05 ]\n", - " Martin lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.688873039209284e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8824379367288202e-05 ]\n", - " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", - " Martin lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.18204968405189e-06 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.751972250640392e-06 ]\n", - " Rachel lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6416714743172633e-06 ]\n", - " Martin lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5096428796823602e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Palm Coast, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.279042958747596e-06 ]\n", - " Rachel lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.93247909314232e-06 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.685696568340063e-05 ]\n", - " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", - " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", - " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.102476668776944e-05 ]\n", - " Rachel lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.229522568901302e-06 ]\n", - " Dave lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5982268450898118e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", - " Rachel lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.787422989873448e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.688950063311495e-06 ]\n", - " Dave lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6599138689343818e-05 ]\n", - " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Boston, WA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.4543639887706377e-07 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.009874378927634e-06 ]\n", - " Dave lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.6476822060649283e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7244088869338157e-06 ]\n", - " Dave lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.681404996314086e-05 ]\n", - " Dave lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.030421228482737e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.942811862449162e-06 ]\n", - " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", - " Dave lives in Seattle, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.766460162703879e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3950356990098953e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", - " Dave lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.463780972699169e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.1782808491698233e-06 ]\n", - " John lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.581859942234587e-05 ]\n", - " Dave lives in Seattle, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.216414360300405e-06 ]\n", - " Dave lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.491680323961191e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3575058801507112e-05 ]\n", - " Martin lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", - " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", - " Rachel lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.807389920344576e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.839130502252374e-06 ]\n", - " John lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n", - " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.62653189667617e-06 ]\n", - " Martin lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.414568815671373e-06 ]\n", - " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.284733586246148e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Martin lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.5857316106557846e-05 ]\n", - " Rachel lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2062064342899248e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.060348591243383e-06 ]\n", - " Rachel lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.581846951623447e-06 ]\n", - " Dave lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5351371985161677e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7165631308889715e-06 ]\n", - " Dave lives in Palm Coast, WA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7510302541268175e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8445316527504474e-06 ]\n", - " Sarah lives in Palm Coast, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.567622843547724e-05 ]\n", - " Martin lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3855085853720084e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3579434582643444e-06 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", - " Martin lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.276793778350111e-06 ]\n", - " Martin lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.690660741995089e-05 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", - " Sarah lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3714279702981003e-05 ]\n", - " Sarah lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2073238142183982e-05 ]\n", - " Martin lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.407893043709919e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.271564310125541e-06 ]\n", - " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", - " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", - " John lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.345301956869662e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.28432179230731e-06 ]\n", - " Dave lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.687276825483423e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.160925866221078e-06 ]\n", - " Dave lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.3817009352787863e-06 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.78439948084997e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.4719674810476135e-06 ]\n", - " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " John lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.200912998290733e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", - " Dave lives in Palm Coast, MA and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.3817009352787863e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.4004607439565007e-06 ]\n", - " Dave lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5334953786805272e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.407068889937364e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2626491045230068e-05 ]\n", - " Dave lives in Seattle, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.227144801116083e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1322349564579781e-05 ]\n", - " Martin lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.016311711689923e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.2265660340490285e-06 ]\n", - " John lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.899505489040166e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7474596208776347e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.297439085756196e-06 ]\n", - " Martin lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1502537745400332e-05 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.266794581373688e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4705698959005531e-05 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.738218270475045e-05 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6120865211632918e-06 ]\n", - " Sarah lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.070447514299303e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0484606036698096e-06 ]\n", - " Dave lives in Boston, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5768946468597278e-06 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1344003496560617e-06 ]\n", - " Dave lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.330101324332645e-06 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.94373500967049e-06 ]\n", - " Rachel lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.2577593123714905e-06 ]\n", - " Dave lives in Seattle, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.047844282060396e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6842433271667687e-06 ]\n", - " Dave lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9219525711378083e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.998934052011464e-06 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", - " Dave lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.111387392593315e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Boston, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.856503899944073e-06 ]\n", - " Dave lives in Boston, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.106719148287084e-05 ]\n", - " Dave lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.681404996314086e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.3837108023581095e-06 ]\n", - " John lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0155678864975926e-05 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6720156054361723e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.5921538079055608e-06 ]\n", - " John lives in Palm Coast, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1562068721104879e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Boston, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.187527792964829e-06 ]\n", - " Sarah lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.27215319784591e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.920510476338677e-05 ]\n", - " John lives in Palm Coast, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.541747355484404e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.213460488244891e-05 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Boston, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7155207337491447e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0794499758048914e-05 ]\n", - " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", - " Rachel lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.125030939874705e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.252255272760522e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, WA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0618667147355154e-05 ]\n", - " Martin lives in Palm Coast, MA and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.1934822547773365e-06 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", - " Dave lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7769470761995763e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Seattle, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0753000424301717e-05 ]\n", - " Dave lives in Seattle, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4255711903388146e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.901234958902933e-05 ]\n", - " Dave lives in Palm Coast, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.8385987863875926e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Seattle, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.29604573987308e-06 ]\n", - " Dave lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0107300113304518e-05 ]\n", - " Dave lives in Palm Coast, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.749774689116748e-07 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", - " John lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.234447285649367e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0762079909909517e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.524438579916023e-05 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Seattle, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1804342648247257e-05 ]\n", - " Dave lives in Palm Coast, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.2960887943336274e-05 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.0485097163837054e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, FL and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7461550669395365e-05 ]\n", - " John lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.32769481651485e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.987407581007574e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7165631308889715e-06 ]\n", - " Rachel lives in Palm Coast, MA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.762457213771995e-05 ]\n", - " John lives in Palm Coast, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.085239536128938e-05 ]\n", - " John lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.367542376508936e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.43818544226815e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Palm Coast, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2959869966143742e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " John lives in Boston, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.7432888600742444e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.7795736716361716e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6938978660618886e-05 ]\n", - " Sarah lives in Boston, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.180361050501233e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.2610599848558195e-06 ]\n", - " John lives in Palm Coast, MA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.121639747405425e-05 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1650074156932533e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.514104537316598e-05 ]\n", - " Dave lives in Seattle, FL and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6962918380158953e-05 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Boston, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.28680237341905e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.266794581373688e-06 ]\n", - " Dave lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1433635336288717e-05 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.614117288947455e-07 ]\n", - " Dave lives in Palm Coast, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4292467312770896e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.3662584933626931e-05 ]\n", - " Dave lives in Palm Coast, WA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6444788343505934e-05 ]\n", - " Dave lives in Palm Coast, FL and is a engineer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.604279512132052e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, MA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.169937791535631e-05 ]\n", - " Martin lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.272200830106158e-06 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Sarah lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.7573045624885708e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Sarah lives in Seattle, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.506133341739769e-06 ]\n", - " Rachel lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.194474513496971e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.234447285649367e-05 ]\n", - " John lives in Palm Coast, FL and is a plumber. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.8762460715370253e-06 ]\n", - " Dave lives in Palm Coast, FL and is a technician. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.749774689116748e-07 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, WA and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.14929467701586e-06 ]\n", - " Martin lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9756529582082294e-05 ]\n", - " Dave lives in Palm Coast, MA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.861600973526947e-05 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Palm Coast, MA and is a doctor. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.864318437583279e-05 ]\n", - " Martin lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9756529582082294e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", - " Dave lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.8493276456865715e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, WA and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.087251444521826e-06 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Rachel lives in Palm Coast, MA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.93247909314232e-06 ]\n", - " John lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.725796422164422e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Martin lives in Seattle, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.2570653022266924e-05 ]\n", - " Martin lives in Seattle, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.6521782526979223e-05 ]\n", - " Rachel lives in Palm Coast, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.862979719495343e-07 ]\n", - " Dave lives in Palm Coast, FL and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.25289620377589e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Rachel lives in Palm Coast, WA and is a engineer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.4904565432516392e-05 ]\n", - " Dave lives in Palm Coast, WA and is a teacher. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.173955181206111e-06 ]\n", - " Dave lives in Palm Coast, FL and is a plumber. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6620389235176845e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " Dave lives in Boston, WA and is a doctor. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 4.439010808710009e-06 ]\n", - " Dave lives in Seattle, WA and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.780196144973161e-06 ]\n", - " Dave lives in Seattle, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.725744010007475e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.468289600685239e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " John lives in Boston, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.135143404302653e-05 ]\n", - " Martin lives in Boston, FL and is a technician. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.3771715405018767e-06 ]\n", - " Dave lives in Seattle, FL and is a teacher. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.463780972699169e-05 ]\n", - " Dave lives in Seattle, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.458089486230165e-05 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n" - ] - } - ], - "source": [ - "import importlib\n", - "import captum\n", - "\n", - "from captum.attr import ShapleyValueSampling\n", - "\n", - "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", - "\n", - "svs = m.ShapleyValueSampling(model) \n", - "baselines = ProductBaselines(\n", - " {\n", - " \"name\":[\"Sarah\", \"John\", \"Martin\", \"Rachel\"],\n", - " \"city\": [\"Seattle\", \"Boston\"], \"state\": [\"WA\", \"MA\"], \n", - " \"occupation\": [\"doctor\", \"engineer\", \"teacher\", \"technician\", \"plumber\"], \n", - " \"pronoun\":[\"Her\", \"His\", \"His\", \"Her\"]\n", - " }\n", - ")\n", - "\n", - "sv_llm_attr = LLMAttribution(svs, tokenizer)\n", - "\n", - "inp_feature = TextTemplateFeature(\n", - " \"{name} lives in {city}, {state} and is a {occupation}. {pronoun} personal interests include\", \n", - " inputs={\"name\":\"Dave\", \"city\": \"Palm Coast\", \"state\": \"FL\", \"occupation\":\"lawyer\", \"pronoun\":\"His\"},\n", - " baselines=baselines,\n", - "# mask={\"name\":0, \"city\": 1, \"state\": 1, \"occupation\": 2, \"pronoun\": 0},\n", - ")\n", - "\n", - "\n", - "attr_result_7 = sv_llm_attr.attribute(\n", - " inp_feature, \n", - " target=\"playing golf, hiking, and cooking.\",\n", - "# num_trials=2,\n", - " n_samples=200 # arg to ShapleyValueSampling.attribute\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 538, - "id": "c22f5569", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_7 = LLMAttrViz(**attr_result_7)\n", - "attr_viz_7.plot_seq_attr()\n", - "attr_viz_7.plot_token_attr()" + "attr_res = sv_llm_attr.attribute(inp, target=target, num_trials=3)\n", + "\n", + "attr_res.plot_token_attr()" ] }, { "cell_type": "markdown", - "id": "objective-america", - "metadata": {}, - "source": [ - "Let's now consider a more complex example, where we use the LLM as a few-shot learner to classify sample movie reviews as positive or negative. We apply FeatureAblation to measure the relative impact of the few shot examples. Since the prompt changes slightly in the case that no examples are needed, we define a prompt function rather than a format string in this case." - ] - }, - { - "cell_type": "code", - "execution_count": 649, - "id": "african-accessory", - "metadata": {}, - "outputs": [], - "source": [ - "def prompt_fn(*examples):\n", - " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", - " subset = [elem for elem in examples if elem]\n", - " if not subset:\n", - " prompt = main_prompt\n", - " else:\n", - " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative:\\n\"\n", - " prompt = prefix + \" \\n\".join(subset) + \"\\n \" + main_prompt\n", - " return \"[INST] \" + prompt + \"[/INST]\"" - ] - }, - { - "cell_type": "code", - "execution_count": 650, - "id": "powered-seating", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9719566702842712 ]\n", - "sv shape:: torch.Size([6, 4])\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7624704241752625 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7624704241752625 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.75006502866745 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.75006502866745 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8428921103477478 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9038273692131042 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8428921103477478 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7624704241752625 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7624704241752625 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5533655285835266 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5533655285835266 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.708580493927002 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9063280820846558 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.708580493927002 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.75006502866745 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.75006502866745 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5533655285835266 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5533655285835266 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9048031568527222 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7999224066734314 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9048031568527222 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8428921103477478 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8428921103477478 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.708580493927002 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.708580493927002 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9048031568527222 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9443454146385193 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.9048031568527222 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n" - ] - } - ], - "source": [ - "m = importlib.reload(sys.modules['captum.attr._core.shapley_value'])\n", - "\n", - "sv = m.ShapleyValues(model) \n", - "sv_llm_attr = LLMAttribution(sv, tokenizer)\n", - "\n", - "input_examples = [\n", - " \"'The movie was ok, the actors weren't great' Negative\", \n", - " \"'I loved it, it was an amazing story!' Positive\",\n", - " \"'Total waste of time!!' Negative\", \n", - " \"'Won't recommend' Negative\",\n", - "]\n", - "inp_feature = TextTemplateFeature(\n", - " prompt_fn, \n", - " inputs=input_examples,\n", - ")\n", - "\n", - "attr_result_8 = sv_llm_attr.attribute(\n", - " inp_feature, \n", - "# target=\"Positive\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 651, - "id": "bc40b7a2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([-0.0413, -0.2751, -0.2085, -0.0399], device='cuda:0')\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_8 = LLMAttrViz(**attr_result_8)\n", - "print(attr_viz_8.seq_attr)\n", - "attr_viz_8.plot_seq_attr()\n", - "attr_viz_8.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 652, - "id": "a35b2eb6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4795992076396942 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7636792659759521 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6186960935592651 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5283071994781494 ]\n", - "tensor([ 0.1416, -0.3236, -0.1131, 0.0449], device='cuda:0')\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_result_88 = llm_attr.attribute(\n", - " inp_feature, \n", - "# target=\"Positive\"\n", - ")\n", - "attr_viz_88 = LLMAttrViz(**attr_result_88)\n", - "\n", - "print(attr_viz_88.seq_attr)\n", - "attr_viz_88.plot_seq_attr()\n", - "attr_viz_88.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 653, - "id": "abe20b53", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([ 0.1416, -0.3236, -0.1131, 0.0449], device='cuda:0')\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx8AAAJYCAYAAAADjlvFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADu4ElEQVR4nOzddUBW1//A8fdDKKCCYmBgYIFid4LY2LO7dc6YNXX2zDljNrO/dndhd3ejIiGCGAiISvOc3x/8njsRdLpNmfh5/bNxn3uvN564n3PO53N0SimFEEIIIYQQQnxmRsl9AEIIIYQQQohvgwQfQgghhBBCiC9Cgg8hhBBCCCHEFyHBhxBCCCGEEOKLkOBDCCGEEEII8UVI8CGEEEIIIYT4IiT4EEIIIYQQQnwREnwIIYQQQgghvggJPoQQQgghhBBfhAQfQgghhBBCiC/iXwk+/P39uX37tva3Xq9HKfVv7FoIIYQQQgiRQvwrwYebmxvDhw/Hy8uLsLAwjIyM0Ol0xMXF/Ru7F0IIIYQQQqQA/zj4OHv2LD4+PtSoUYMMGTJQrFgx2rZtS2xsLMbGxkB8T4gQQgghhBDi2/aPg4/ly5cDULduXaytrVm/fj2BgYFYWlqyYMGC+H/EyAillAzFEkIIIYQQ4humU/8wIvDy8sLT05O6desmWD5mzBgmTpxI0aJFmT59OrVq1QLie0GMjCTPXQghhBBCiG/NP4oClFLky5dPCzxiY2MBCAkJQSlF0aJFcXZ25rvvvqNKlSo8f/4cIyMjIiMj//mRCyGEEEIIIb4q/yj40Ol0Cf42MTEB4OjRo+zatYs2bdowZ84c7t69S65cufjtt9+4c+cORYsWxd3d/Z/800IIIYQQQoivzD8edmWglEKn0/Hw4UNGjx6Nl5cXhw8fxszMTFsnODiYJUuWMHr0aJ49e4aVldW/8U8LIYQQQgghvgL/WvKFoRdk3759XLx4kX79+mFmZqYNxQJ49OgREydOZNq0aVhZWREVFSVJ6EIIIYQQQnwj/pXgwxBAXLt2jZ07d1KoUCFat24NoJXbffXqFX/88QeZMmWiTZs2hIWFkTp1anQ6nQQgQgghhBBCfAP+cfBhGG4VFRWFu7s7Xl5e/Pzzz0B8ArqhR+TMmTOsWrWK6OhoJkyYQM6cOfntt9+AxLkjQgghhBBCiJTH5J/uwBA4HDlyhDVr1uDq6kq5cuVQSmkJ6C9evGDcuHGUL1+eqVOnUqRIEZydnenbty81a9akdOnS//QwhBBCCCGEEP9x/zj4MLCzsyN//vwMHjwYiJ/Pw9jYGKUUmzdv5uLFi3h4eJA/f34ASpUqhbm5OWfOnEky+IiLi9OGbAkhhBBCCCG+fv9a8OHg4MD27duBhIHDw4cPmTRpEv379yd//vzaJIOhoaE8fPiQYsWKaft48eIFz58/J0+ePFqVLJmUUAghhBBCiJThXyu1m1RPRUxMDD/++CPbtm3j4cOHpE6dGojPBWnWrBlPnjzh/PnzhIaGsmjRIubPn0/u3Lm5d+8eQ4YM4aeffvo3Dk0IIYQQQgjxH/Cv9XwkNUQqLi4OX19fRo8eTerUqbXk9N27d7N7926OHj0KwIgRIzhx4gSzZs2iTp067Ny5k4kTJ6LT6bRhXEIIIYQQQoiv27/W8/GxXr58iYuLC4UKFWLNmjWcO3eOSpUqkTZtWpycnHBzcyNXrlxMnz6dvXv3cvDgQcn9EEIIIYQQIgX4rMkUcXFxiZYtXbqUa9euMWXKFABWrFhB9erV2bdvH+nTp8fR0ZHBgweTL18+IiIiePz48Xv3L/ODCCGEEEII8fX4rMFHUj0WHTt2ZPv27eTMmRMAa2tr3rx5Q6VKlVi9ejV79uzh0qVLNGvWjJiYGG09A71er/2/TFAohBBCCCHE1+OLlpFSSpEpUyYaNWqkLStWrBiRkZH4+PgA4OTkxPHjx1m1ahWrVq0CEvagGCpfzZkzB09PT22ekbi4OAlEhBBCCCGE+A/74jkf73r27BktW7YkMjKS6dOnU7BgQdKlS4e5uXmidQ0J60eOHKFPnz4UKlSI7t27U6ZMGbJkyZIMRy+EEEIIIYT4WMk+gUaWLFk4cuQIpUuXpnnz5vTt25cZM2YkGF4FfwYer169YvXq1Tx69Ig3b96wY8cOsmbNyh9//KGtB0nnmwghhBBCCCGST7L3fLw9P0hAQACnTp2iePHiODg4aAHH25YtW8a8efOoX78+EyZMAGDSpEns2rWLs2fPEh4eTpo0aQCZoFAIIYQQQoj/kn9tno+/y9jYGKUUer2eHDly0KpVK+01Q+BhCCJ8fHzYtWsXdnZ2DBw4UFvPzMyMCxcuMHbsWPz8/PDx8WH27NmUKFHiS5+OEEIIIYQQ4j3+E90COp1OC0KSYui92LhxI0+ePKFVq1ZYW1sD8OrVK/bs2YO9vT329vb0798fOzs7unfvjr+//xc7ByGEEEIIIcSHJXvPx9veHWL1trNnz7Jx40ZKlSpFy5YtteVubm6Eh4fz888/065dOwCGDRtGyZIl8ff3x9bWNtHwrbeHegkhhBBCCCG+jP9Ez8fHyJ8/Py4uLrRv315b9uDBA7Zt20bp0qVp3Lixtvz06dNYWlqSN29eID6oiYmJ4dGjR0D8UK93E9qFEEIIIYQQn1eyJ5z/E7169eLBgwcMHz6cGjVqAPDmzRvKli1L9erVmTlzJjExMSxcuJC1a9cSFhZGtmzZWLhwIfb29sl89EIIIYQQQnxbvpqej3d7Kh49esS1a9coXrw4Li4u2vIJEyZgZGREu3bt0Ov1TJw4kfHjx1OnTh1mzpyJg4MD9evX59KlSwn2J6V5hRBCCCGE+Lz+UzkfH/JuydycOXNy5MgRgoODtdfu37/Phg0b6Nq1KxUqVGDr1q0cO3aMIUOGMGLECACqVKlChQoVuHDhAmXKlCEyMhIzMzPJARFCCCGEEOIz+2p6Pt4VFxeHhYUFtra22rK+ffuSOXNmGjRogE6n49ixY+h0Onr37g1AbGyslgty8eJFAG7fvk3lypUJDg5+b7UtIYQQQgghxD/31fR8vCupnooff/yRsLAwihYtCsD58+epWLEi6dOnJzY2FhMTEyIiIjhy5Ahz5szR1vHy8tJK977NsE10dDSRkZFYWlp+3pMSQgghhBAiBftqez6S0qBBA9q2bYuJiQmxsbE4Ojry9OlTAExM4uOswYMHkz17dlxdXdHr9fj5+eHs7MzLly+1vI/Xr18n2MbPz4/SpUuzdevWZDgrIYQQQgghUoavtufjr5iYmNCkSRO6d+/O+PHjKVSoEAcOHGDp0qVs2bIFGxsbjIyMuH//PqlTp8bKykrbdujQoXh4eLB06VLy5s1L/vz52bhxo8yYLoQQQgghxD+QYoMPgMaNG5MuXToGDx7M5s2byZUrF0uXLuW7774DICIignPnzjFr1iwAfHx8mDJlCnv27GHw4MHkzZuXCxcuYGpqSsmSJSUnRAghhBBCiH8gxQYfhkChevXqXL16lYcPH5I7d+4E61y7do1cuXKRI0cO/Pz8GDhwIPfu3WPt2rU4OTnx9OlTBg8eTGhoKDdv3kwwS7per09UgUskj4CAAEJDQ3F0dEzuQxFCCCGEEB+QYp+edTodOp1Oy+MwBB5KKW3OEBMTE7y9vQkMDKR58+ZERkYyf/58nJyciIqKYu/evdy5c4c//vgj0f4NgYfMD5L85s+fz4gRI7h9+3aC5dJTJYQQQgjx35Jiez4M3q2KZQhKANzd3QkKCmLp0qWYm5uzc+dOUqVKBcTPGeLm5katWrWoUqUKkZGReHh4sHv3bp4+fUrVqlVp1aqVzA+SzM6ePYuPjw8uLi4ULlwYgF27dlG/fn3pmRJCCCGE+I/5pp/OXF1dKViwIFWqVGHFihVa4PH69Wu2b9+Ot7c3M2fOBGDEiBEMHz6cEydOkC5dOvr27UvDhg0JCgpKzlP45i1fvhyAWrVqodPpOHLkCL1792bq1KnJe2BCCCGEECIRnZKxKcTFxSXowThz5gzt2rWjffv2TJgwgdOnT1O1alUqV67Mtm3byJQpEyEhITRo0IBevXrRoUOHZDz6b5uXlxf37t2jXr16ALRu3Zrw8HDGjBlDmTJlUEolyNURQgghhBDJ55vu+YiNjQUSDs16/vw5s2fPxtTUlAkTJgAwfPhwKlasiJmZGQULFuTXX38lQ4YMlCxZknPnzhEXFyf5BclAKUW+fPlwdXUFYOXKldy/f5+aNWtSpkwZAC3wMNyfsLAwXr16lTwHLIQQQgjxjfumgw/DJIJvMzc3JzY2llGjRgHw9OlTdDodLVq04ODBgyxZsoSVK1fi4ODAkSNHePPmDcbGxu9tXTckt4t/n6GggE6nIzQ0lBUrVlC4cGGaNGkCJEw4N9yfDRs2UKlSJS5fvpwchyyEEEII8U37poOPpKRNm5YtW7bQsWNHAKytrQkPD+fOnTsANG3alMuXL9O1a1devHhBv379gMRBhpeXF76+vpL0/JkZru/8+fN5/fo1DRs2JFeuXEDiXo/79+9z5MgRrK2tKV26dPIcsBBCCCHEN0yejN/xbulcU1NT+vXrh4eHB1euXAHAwsKCoUOHcu/ePUqXLo1SKlHp3aFDh9K2bdu/3L/4+/R6PTqdDg8PD3bu3EmFChW03I93ez2UUuzdu5erV68yfPhwQO6FEEIIIcSXJsHHO5IqndusWTPs7OxwcnKif//+rFu3jqtXr5I+fXqABEOujI2NCQkJwcvLi06dOmnLr1+//t79i7/n7V6PNGnS0KRJE9KlS5cgydwQhJw/f55du3ZRvnx56tatC/x53yQIEUIIIYT4MiT4+AtKKdKkScPKlSs5dOgQAQEBHDt2jIiIiPduc+nSJaysrChYsCDR0dFs376dkiVL0qNHD6KiorT1JB/kn9u3bx+7du2ievXquLi4AAmHW+l0Ol69esXOnTt58uQJw4YN07Y1BCaGgFCCECGEEEKIzyvFTzL4T+l0Oi1IqFChAps3byYoKIhMmTIlWtfwsPvo0SNtIsL58+dz9+5dANKkSUPq1KnR6/VER0djZmb2Rc8lJSpRogTdu3enYcOGAAl6PQz/PXbsGAcOHKBx48YULlyYly9f4u7uzt69e3nx4gWdO3emRYsW0islhBBCCPGZSc/HRzAyMsLIyEhrGU8q8HjbihUraNKkCfv372fz5s04OjqSMWNGLYl948aNNG3alB07diTYTlreP13WrFkZPXo0xYsXBxInmQcEBLBz506MjIy0Xo/OnTszduxYnj9/TqlSpejVqxc9evQgOjo6eU5CCCGEEOIbIcHHJ/hQy7ihxd3T0xNfX19iY2Pp0qULQ4cOxcrKCldXV+zt7blx4waTJk3CxsaGIkWKAPD48WNt/3q9XoZjfYL3za9iCEIOHTrEmTNn6NGjB1ZWVqxZs4Y9e/Ywc+ZMdu3axYQJE1i3bh1nz57l/v37X/LQhRBCCCG+ORJ8/EsMD7tXrlzh0aNHHDp0iAEDBtCwYUNCQ0NJmzYt169fp3nz5hQrVozx48eTL18+/P396d27Nw0aNODs2bNaL4v4OB+avfzmzZv873//I0+ePPTo0QOAMWPG0LNnT2rXrq3N81KiRAnu3bvHixcvAJgxYwZbt279/AcvhBBCCPGNkafcf1nOnDmxtbWlb9++9O/fH4CTJ09y+/Ztli9fTsaMGVmzZg05c+YEICYmhvbt2+Po6Ejt2rUZMWKENvO6+GeyZctG7ty5GTBgAADXrl0DoH79+piYmGi9JqdOnaJw4cJaEYEHDx6wfPlyXr9+nWif0islhBBCCPH3ScL5v6xSpUrasKtUqVJx7949tmzZQr58+ShUqBBubm5AfH5HWFgYxsbGNG/enObNm1OzZk0GDx5Mx44dcXBwSLBfvV4vPSKfKFOmTKxYsUL729bWlri4OHx9fYH4XpNnz55x+PBh0qdPr+WN3L17l8KFC5M2bdpE113ugRBCCCHE3ydPUv+yuLg4jIyMSJUqFQAeHh4opXB0dKRfv36ULFmSmJgYli5dSrly5WjRogUlS5Zk7969FC9enFevXhEQEJBov0ZGRpIP8oneTeC3tLSkevXq7NixAw8PD+7fv8+wYcM4e/Ys7dq1I1u2bPj4+ODl5UX9+vWB+OseExPDuHHjmDx5cnKchhBCCCFEiiE9H/+yd5PSmzRpwtGjRylTpgxp0qQB4PTp0/zvf/+jatWq9OrVi6NHj9K1a1fSp09P5syZiYmJAcDT05MDBw5w7949evToQdGiRYGE5WTF+717L1KlSsW0adPo1KkTFSpUwNbWllevXjFt2jRatmwJQGBgIJkzZ9Z6OJ48ecLEiRNZuXIlkyZNIioqitSpU2v7VEolmOFeCCGEEEK8n069r1yQ+MfeDRIMQ3jOnj2Lq6srx48f14b6nDhxgm7dulGoUCF27twJQI4cObCxsSFXrlwcOnSI9u3bM3v27AQPv+LjvT2E6ubNm0RHR5MzZ06yZMmirbNnzx7at2/P06dPiYqKok6dOqRKlYru3bvTvn17IiMjCQgI4MaNG+TJk4eSJUsm2rcQQgghhEia9Hx8Ru/2ThgeTjNnzkz27NmZP38+w4cPJygoiCVLlhAXF8cPP/wAwPnz54mNjWX9+vUULFiQ69ev06tXL9atW0fnzp2/9KmkCIa5WoyMjLRepHft2rWL5s2bc/z4cWbOnElQUBAHDx4kd+7c6PV6WrZsia+vLxYWFjx48AAnJyeWLFmCtbX1Fz4bIYQQQoivj/R8JJObN2/StWtXMmXKxOvXrzl9+jQ9e/ZkwYIFAAQHB+Pq6oqlpSULFy4kb968nD9/nhw5cmBra5vMR58yRUZG0r9/f86dO8fDhw9p1aoVP/zwAyVKlODp06fMnTuXyZMn8/jxY7JmzcrDhw/p1q0bZcqUYcqUKcl9+EIIIYQQ/3kyTiQZ6PV6ihYtysWLF5k1axbNmzcnffr0DBw4EICXL19ibW3NypUryZgxoxaQlC9fnhw5cnxw3xJL/n2pUqXCwsKCmzdv0rFjR+bNm0eJEiUA8PX1xc3NjaxZs1KlShX+97//kTt3bkaNGsWyZcsICgpKtL+4uDitQEBISMiXPBUhhBBCiP8k6flIJnFxcQkSoo8ePYqLiwuXLl1i06ZNjBgxAktLS06cOEGTJk2YOHEiffr0SbSf9+UavLt/8fHu3r1LgQIFMDY2JjY2FhMTEyZNmsSSJUvw8fFh3rx5/Prrr9jb21O6dGkuX77M7t27sbCwICIiggcPHmBubk7+/PkBePbsGT/99BOxsbGsXbs2mc9OCCGEECL5SM9HMjEEBoaWcRcXFwCeP3/O1q1b+fXXX4mJiaFq1aoUKlSI58+fJ7kfQ+Cxfft2pk2bxqpVqxLsH6Q35GPFxcWhlMLBwUG7foZZ0MPDw7GxsSEyMpK+ffty9epVHB0dWbJkCalTp8bMzIzDhw/j6upK48aNKVq0KJ07dyYiIoJLly6xb98+nJ2dAbkfQgghhPh2Sc/Hf9CFCxfo1q0bb968IVOmTISFhTFy5Eg6dOigrWOopHXz5k2mTJnCpk2bqFq1Kp6enlhbW7Nhwwbs7e21HpCnT58yb9482rVrl2gCQ/HXLl26ROfOnVmyZAkVKlTQlt++fZs0adIQGhpKx44dyZ07N4MGDcLS0pKJEydSrVo1zp07x6NHjzh16lQynoEQQgghRPKTalf/IYY4sFy5cty8eZPt27cTGhpKpUqVsLOzS7COTqcjLCyMxYsXc/XqVU6fPk2pUqWIi4ujQYMGLFmyhGnTpmkt+Fu3bmXTpk1kyZJFgo9PpJSiUKFCVKpUiYYNGzJy5EiqVKlC5syZcXR0BMDV1RUHBwd++eUXChcuDECzZs0YMWIEL1684PDhw0DSw+Fk3hYhhBBCfCtk2NV/iE6nQ6fTaTNzN2nShM6dO1OwYEFt+I9hHYBTp05x8eJFunXrRtmyZdHpdKRKlYrSpUtz+vRpXrx4AcTPsr5nzx7KlClD9+7dARn68yl0Oh1p0qRh0aJFzJs3j2XLlvHTTz+xb98+wsPDOXv2LIGBgdStW1cLPCA+gd3f359u3bpRoUIFlFJJ5uHMnz+fatWqaZNLCiGEEEKkVNLz8R9keEB9u0U8qckKAwMD8ff3p3fv3gBER0djZmaGqakpL168IGPGjACsXbuWFy9e0KtXL8zNzbUkapkY7+MZeixatWpFq1atOH/+PHny5MHCwgJLS0sePnyoTRgJ8dWtLly4gLW1NWPHjgXe38PRuXNncuXKhampqbZM7o0QQgghUiJ5uvkPe99QHMND6cOHDzE3N8fc3By9Xo+ZmRnR0dG4ubnRvn17AA4ePMjJkycpXbo0DRo0AP5MopaH249nCAgNvVLly5fHxsYGiL9PVlZWCcrtHjhwgLVr1zJw4EAyZsyoTW74rlOnTpE2bVoaNWoEoBUWkHsjhBBCiJRInnC+Yk2aNMHIyIgDBw5gZGSEj48PnTt3xtLSkm7duhEdHc3WrVvR6XR0796diIgINm3axK+//kr37t2JjIxM7lP46iQ1bCpv3rw4OzvTtm1bZsyYQb9+/ejduzcZMmRg5MiRQNLBxKVLl3BycsLd3V1b1qNHD5o3b/75TkAIIYQQIhnJsKuvWIkSJWjYsCENGzbEycmJ+/fvA/HDrLJnz866deu4ceMGV65cYerUqezevZv8+fNTtmxZbGxsePDgAUWKFEnms/j6mZmZsWLFClatWsWpU6d49eoVISEh2pwehmFu7xo5ciQ1atSgdu3aHDt2jN69e+Pp6cmFCxcAiImJSTAUSwghhBDiayeldlMADw8PNm/eTOHChbG3t6dIkSL4+/szaNAgQkNDuXz5Mm3atKFfv37kz59fJh/8l71bwWrHjh3MmTNHq3CVlM2bN9O6dWtOnjxJxYoV8fb2pnDhwlov1ezZs2XolRBCCCFSHAk+vmJ6vf69FZR+++03duzYwbBhw/Dx8eHIkSPs3LlTe/1jyru+u46UhP2wt5PEDQFJUqV1IyIiKFq0KNWrV2fRokUopVi4cCE//vgjmzdvZsKECZiamrJp0yZy5MiRHKcihBBCCPFZSNPqV8zIyAhjY2NtlnSDoKAgzpw5Q4YMGXB1daVgwYLcvn2b0NBQbZ1PCSJ27dpFdHS0BB5/wcjICKVUgoAwqcBw1qxZhISEMGLECAB8fHyYOHEi/fv3p1GjRly8eBE3NzcJPIQQQgiR4kjPRwoVHh6On58fDg4O+Pn5UbZsWXbs2JFgdu73MfRwBAcH4+/vT9OmTWnbti2jRo0iVapUX+DoUy5fX18cHByYPHkygwYNIjY2lqFDh7JmzRoePXpEqlSpPrqH6UO9K0IIIYQQ/0XS85EC6fV6LCwstJnMc+XKhb29PXv27AH+nGDw3R4TA8OD76xZs6hRowbp06enffv2pEqVSis1e/nyZU6ePPm5TyXFuXjxInZ2dnTu3BmIL5e8YMECpk+frl3fj+1hMgQcLi4uLFiw4HMdshBCCCHEv0aCjxTo7URlQ6AxePBgnj17RlRUlPZw+76EZkNQUqxYMYyNjblz5w7dunXDy8sLY2NjXr58Sa9evRg4cOBnPpOUp0WLFly5cgVra2sgPjk9Xbp0dOjQ4b35O+9juLe//PILRYsWTbRcCCGEEOK/RoKPFM4QaDRu3JiFCxeSOnVqFixYwC+//JLk+kopjIyMCA8PZ+nSpdSsWZPjx49jY2PDqFGj0Ov17Ny5k5s3b7J8+XJtG/HXlFLo9XrMzc21Zba2tlhaWrJt27aP7vEwXG+dTse9e/eoXr06lStXBiA4OFhyc4QQQgjxnyXBxzckLi6OtWvXMmLECAIDAz84yeDChQsJCgqiZs2alC1bls2bN/O///2PwMBAxo8fT7du3bQ5QgwP1eLDdDpdot6mli1b0r17dzp16sS8efMSvPa+oM4w9G348OEUK1aMp0+faq/ly5ePrVu3/stHLoQQQgjx75Dg4xvy8uVL/P39GTt2LAsXLsTMzCzB63q9Hp1Oh6+vL5s3b6Z06dI0atRIe93Y2Jh169bh5eVFkSJF6NevH8eOHcPIyEjmpPgbDMHFsGHDePz4MQ0bNiQuLo6DBw8CSVck0+v1mJiY8PLlS+bOncuoUaOwsbFh5MiRlChRAnNzc5o0aaKtK4QQQgjxXyJPjN8Qa2trhg4dSt++fYHED6eGAGLVqlXodDqaNWuGtbW19pDs4eHBr7/+SoUKFXjz5g0ZM2akQYMGzJkz58ueSAqh0+lQShETE0PatGnJkSMHy5Yto06dOgnmZElK7969yZMnD+3atQPiiwrcuHGD6OhoduzYAbw/p0cIIYQQIrmYJPcBiC/HUMLVkNT8vofT6OhoTE1NqVWrFhD/kBwREcHUqVPJnDkzR48eJXXq1AD4+/tz8uRJ+vTpg5GRUYLW+rcn3RNJ0+l0mJqaAjB//nzc3d2ZOHFigh4nA0NJ3StXrrBu3TpWr15N7ty5AThw4ADly5encePGdO7cmUOHDjF37ly5/kIIIYT4T5Hg4xvysYnIefPm5Y8//mDGjBkMHjwYgBMnTrBu3Tr27t2rBR4AVlZWnD59Gp1Ol2j/RkZGWu+KPAT/tf79+9O+fXsyZswIJA7eDEFjz549cXV1pVatWhgbG+Pu7s727ds5ePAg1atXp3fv3ty7d0+b9FACQiGEEEL8V8gkgyJJu3fvpnPnzuzatQsHBweaNGmCpaUlu3bt0tYJCAigdOnS9O7dmzFjxvD8+XMuXLjAlStX8Pf3p2fPnpQuXToZz+Lr8VcTCxqChiVLlvDjjz+yd+9eqlWrhlKKYsWKUaxYMVatWpVkYCGTEAohhBDiv0J6PkQChqTzBg0aEBQUBMD//vc/Tp48iaenZ4J1f//9d3Q6HUOHDgWga9euREVFkTlzZszNzXFycqJ///6MHz8eExN5q33IX/VKGYKKHTt20KJFC4oXLw7A4sWL8fPzY+vWre/t0TAEHr1792bw4MHky5dPe+1jZ1MXn4+/vz8vX77E0dER+PMzKPdFCCFESiTjL0QChryN2NhYbVmbNm3YunUr+fLl04ZR3bhxg/nz5zN+/HjMzMyYMmUKe/bsIW/evKxZs4YlS5Zw4MAB3N3duXv3bnKdToqza9cu5syZQ4YMGQBYsmQJjRs3pkCBAh+cb+Xq1aucO3eOU6dOJVhuSHoXycfNzY3hw4fj5eVFWFiY9hk0lFQWQgghUhIJPkSSDD0VSinMzMy08q1GRkbExsYyaNAgSpUqRY8ePQgNDWXGjBm0bNmSkydPUqBAAXbu3EmlSpVImzYtV65cScYzSTkMAaGVlRUAkZGRVKlSBW9vb168ePHBlvLnz58TERGhta4fO3aM+fPnAx+fCyT+fWfPnsXHx4caNWqQIUMGihUrRtu2bYmNjdV6rKRkshBCiJREgg/xQUk9mAYHB/Po0SMmTpwIwIMHD7CxsaFPnz7cvn2bHj160K1bN6pUqcK9e/f+8uFJWt4/zrtD18zMzBg+fDhmZmYULVqUS5cuJdrG0Hq+ZcsWMmXKRJkyZQgMDKRbt27069cvUUlfedD9spYvXw5A3bp1sba2Zv369QQGBmJpacmCBQsAtMIB8jkRQgiREkjCufjHfH19cXR0ZOnSpbRu3RqIT0YfM2YMJ0+e5P79+x+1H0mM/jRv52tcunQJR0dHzM3NE60XFhZGmTJlGDNmDMWKFWPcuHGcOXOGsmXLMm/ePHLlygXA7du3tZ4R8WV4eXnh6elJ3bp1EywfM2YMEydOpGjRokyfPl0rey3VyoQQQnzt5FdMfLK380EAcufOTffu3dm2bRsvXrwAIEeOHCxdupTz588DJDl+3cPDg4kTJ2qtvxJ4fBpDXoBSijJlyiQZeED8EKvSpUtz//595syZQ/r06Rk/fjy2trakTZuWgIAA2rZtS9WqVXn16lWCbSXv4PNRSpEvXz4t8DB8rkJCQlBKUbRoUZydnfnuu+9wcnLiyZMnEngIIYT46skvmfhk7w7/0el09O3bF19fX4oXL85vv/3GmjVrCAwM1BKj3w0sYmNjefnyJTExMUyZMgVHR0fOnTv3xc4hpTA2Nn5vzoahUzM0NJQ7d+5ovRy//fYbDx48wMzMDHNzc8aNG8e9e/fYu3cv6dKlw8fHhxMnTmj7BxmO9Tm8e98Mn6ujR4+ya9cu2rRpw5w5c7h37x7Zs2dn2rRpiYJDIYQQ4msjw67EP/b28J/Vq1ezYcMGHBwc+Omnn7CxsUlyPUg4hKRHjx74+fmxffv297bgi7/H1dWV/fv307ZtW1avXk14eDi2trYcO3aMWbNm4e3tTb9+/WjWrBkREREsW7aMnTt34u3tzaRJk2jZsmVyn0KKZ/hsPHz4kNGjR/PgwQOOHDmCmZlZonViY2MxMjKSXhAhhBBfJQk+xL/i3XyN4OBgrK2tEwQchnU2b97M8ePHCQgIoGTJkowePZrXr1+TM2dO3N3dqVChQqJARfJB/r6DBw/i7u7O8OHDyZw5M+vXr+f333+nVKlSrF69mqNHj1KqVCnt+r5584aoqCjWrFnD9OnT6du3L0OGDEnms/g2LFy4kFmzZjFixAg6dOiAl5cXBw4c4NixY0RFRTF8+HDKly+f5LaSD5J8AgICCA0NlZwpIYT4CPJLJf4V7w7Psba2Bv4cWqKUwtjYmMDAQHr06IGvry/FihXD3d2dPHnyMHbsWADy5MmTYLuwsDBt/3q9PtHwH4md/1qtWrX4/fffyZw5M9HR0Xh5eXHp0iWOHDnCxo0bKVu2LMbGxnh5eeHu7s7WrVsxMzOjX79+dOrUiaNHjxITE5PoWks+yL/DcF2vXbvGzp07cXBwoEOHDgA0a9aMefPmYWZmhq2tLdWrV2fGjBmJ9hERESGBRzKaP38+w4YN4+HDhzJEUQgh/oJMOy3+Ve97ADIEEzt27MDCwoJp06bh4ODA6NGjWblyJd26daNTp06kSZMGiG+tX7BgAaGhoRgZGTF27FiqVKmi7c/QMyJzVPy1t1vEU6VKhbm5OdmzZ2fcuHHUq1cPAB8fH6pVq4a5uTnW1taMGDGCoUOHUrlyZZYsWUJISAhZsmQB4hOiM2TIoAWc0iv19xnex1FRUbi7u+Pl5cXSpUsBGDhwIEFBQezcuZNSpUoBUKBAATZv3kyHDh20++Hp6UmJEiW4cuUK9vb2yXYu3yrDXC21a9cmd+7czJ8/n/DwcIYMGZKoB1cIIYT0fIgvzNDK7unpqS0LCQkhW7ZsNG3alHTp0rFu3TqaNm1KVFQUNWvWpESJEtStW5eRI0dqFYGuXr3KyJEjCQ8Pl96Pv/BuQDho0CBu3rxJ8+bNtWXLli0jLi6O06dPs2PHDqZOncqCBQtwdXWlSpUqZMmShYCAAMaOHUvLli2pWLEiu3btAqRK2T9heDA9cuQIa9asoU6dOlSuXJng4GD++OMPfvnlF0qWLKmtX6hQIS5duqRtV69ePerXr0/VqlWxt7dHr9fL5+ELM1Trq1GjBgBnzpxh2bJlQOKiAnJvhBBCej7EF1aqVClatWpFs2bN6NKlC1euXOHGjRt0794dFxcXHjx4wIIFC6hZsybbtm3TtqtVqxZnzpzB19eXu3fvcuLECWbOnMnIkSOlZfET6PV6dDqdVoXMQCmFnZ0d1tbWGBsb06ZNG8LCwhg0aBA///wzAGvWrGHnzp00adKEVKlS0bFjRxo1asS8efNIly5dcpxOimFnZ0f+/Pm13JqjR4+SM2dOKleunOD9fePGDYoUKcLz58/JnDkzadOmxdfXFxMTE27evEnRokWT6xS+WUOHDuXevXtavoe7uzvjx48H/ux1fPXqFenSpZPvKiGEQIIP8YXpdDqmTZtGr169ePbsGffv38fBwYGWLVuSNm1arl27xo0bNzhz5gzw55CeatWqkTNnTrJkyULr1q25cuUKXbp0wcLCIpnP6OvyvmFx9erVw83NjVatWtG+fXv27dvH+vXr6dy5szbkx8rKijdv3jB06FDMzc2pW7cuK1aswMvLixIlSnzBs0h5HBwc2L59u/a3nZ0dz58/Jzg4WFt27do1zp8/j52dHYULFyYyMpKLFy/SpUsXjI2NtUkju3fvrm0jQ+I+L8NcLfny5QPiA/T06dNTrFgxIP7zduXKFTp27IiTkxOzZ8/G1NQ0OQ9ZCCGSnQy7El+UXq8nLi6OfPnyUbFiRSZOnEj//v0pXbo0AOfPnyd//vwUKlRIS1KH+FyFQoUKERsbS/78+cmVKxdbt26lWLFi+Pr6JuMZpQyVKlXCw8MDc3NzPDw82Lp1K9myZWPYsGHaOg0bNsTa2prvv/8eb29vSpQoQbdu3aTCz7/g3eR9W1tbSpUqxYoVK/Dz8+PSpUuMHDkSPz8/fvjhBwAmTJjAmzdvGDNmDG5ubty+fZs6deoA8T0kED8kTiklSdCfiU6n04ZSxcXFcf/+fTJnzky2bNkA2LZtG4sXL8bPz49r164leR9kKJYQ4lsjwYf4ooyMjBK0xFauXJmuXbuSNm1aAIoVK0ZwcDBeXl6JhijExcWxZ88e9u7dy/r16wkJCaFly5bcvHkz0b/z7izs4sPi4uKwsbFh1apVDB48mOLFi9O+fXty5crFtWvX8Pf3J3v27EydOpWwsDBWrFiBTqejaNGif9mSa5iFXbzfu70TWbJkYc6cOVy8eJHy5cvTvHlzQkJCGDt2LC4uLvj6+jJz5kxGjRpFjhw5AMiXLx9ZsmRh165d/Pzzz5QpUwZ3d3d0Op1UwvqMdDoder0eY2NjTpw4gZ2dHQUKFCAgIICffvqJsmXLYmlpSbNmzUidOjUQ3wjz+PFjbXshhPiWyDwfIlm9Ww3G29ubpk2bUr58ecaNG4eFhQWWlpYA3Lt3j65du5I1a1a2bNmSYD/e3t5cu3aNmJgYWrVq9UXPIaV4d54IQ9AwZMgQcubMyaBBgwBYtWoVAwYMYOfOnVSuXDnJfUVGRuLh4UHu3Lm1sssyBOjjvf25OHPmDJaWltjZ2WnV4Nq1a8e9e/c4duyYFrgbtgkNDcXf359du3bx+++/069fP8aMGQPEB+UmJia4ublx8uRJVqxYQapUqZLnJFMIw3V//Pgxtra2HDlyBFtbW7p164a9vT29evWiT58+LFu2jEKFCgGwc+dOfvzxR5o1a5Zk6WQhhEjJpDlMJKt3W/3y5s3L2rVruXbtGmXLlmXhwoV4e3sTGxvLrl278PDw4Pfff0+wzaJFi6hatSpDhgxh1KhR5M6dm5MnT37J00gRDIGHodfI2NgYExMTypQpw4wZM+jQoQM3b94kIiKC2NjYD/YuXbp0iWXLllGqVClt6JYEHh9Pp9NpQ7EqVapEkSJFtMAjODiYHTt20LNnT9KmTUt0dDQAz58/59atW1y8eBFHR0eGDx/OhAkTOHjwICEhIej1ekxM4tP8Ro8eTZo0aaSH8F9g+A5bvnw5tWrV4t69e0yaNAlbW1vc3NwICAjAzs5O+3ydOnWKMWPGULBgQQYMGADInDlCiG+L9HyI/5S3W9+PHDmCqakpFSpUICYmhqJFi9KoUSNmzpypVW06cOAAjRs3Zty4cTRt2pR8+fLRu3dvfH192bVrV4IhQdLy/vf5+vrSq1cvHjx4QLZs2cidOzerV69OsM7brfXR0dGEhYVx6dIlxowZg6WlJevXrydTpkzJcfgpSlBQEO3btydr1qxamVcAZ2dnAgMDSZcuHaGhoUyePJnSpUvj6OiIn58fNjY2APz0009s3LiR/fv3ay3x4p8JDw/n559/5tatW1oPbYsWLShWrBijRo3C09OTDRs24OnpSfXq1SlZsiSjR4+mbNmyCb7z5DtKCPFNUEL8x8TGxiZaFhAQoPLkyaP27NmjlFJKr9eriIgIVadOHeXi4pJg3TNnzihLS0t1/vx5pZRSMTExSq/Xa6/HxcV9xqNPWfR6fYL7cffuXfXixQsVFRWllEr6Xl28eFFt3bpV3b17VymllLe3t3JwcFAnTpxItG5S24u/dvHiRZU/f35Vrlw5FR0drWbOnKlsbGzU7t27lbe3t1qwYIHKmzevSpUqlapdu7YKDQ1VSinl5+enjIyM1Ny5c1V0dHQyn0XKERoaqhwdHZVOp1OtWrVS4eHh2ms2NjbqwIED6vr166pixYqqWLFiKiQkRCml1IkTJ9Ts2bOVu7u7tv7b31VCCJESybAr8Z+TVMtf5syZad26NQ0aNGDGjBnodDqePHnCgQMH+PXXXwGIiIgA4odBxMTEaBVnTp06ReXKlbl06RIQP7xISYffR9HpdBgbG2vDQuzt7bG2ttbyBAz3ylDFZ/DgwdSqVYspU6ZQu3Zt2rdvT44cOYiOjubOnTvafu/fv09YWJi2vQz/+XhKKcqUKYOnpydTp07F1NQUCwsLMmbMSJkyZbCzs+P7779n+vTppE+fnubNm2slqXv27EnZsmX57rvvpOTrv8jKyorp06fTs2dP5s2bh7m5OQA7duygRIkSmJub07FjR1KnTs22bdtIlSoVzZs3p379+qxevZoOHTrg4uLC48ePJQFdCJHiSfAhvgqmpqb8+uuvHDt2jJcvXxIcHKwNJTE8wBp+8OfMmUO1atUwNTUlLCyMffv2ce7cOQ4fPkzPnj3ZvXu39gOvlJJA5CP81VAQIyMjAgMDmTlzJrNnz2b9+vVs2rSJyMhIzMzMCA4O1srARkdH07hxY77//nsePnwIoOUiiL+m0+m0YM3Z2RmAkiVLEhQUxLBhwzhz5gzz5s3jxx9/pGzZslStWhVTU1MOHjzI/v37GTFiBNmzZ0/OU0iR6taty4IFC8iUKZP2vWJ4fzdr1oxMmTIxffp0cuXKxdixYzl+/DgnTpzg8OHDPHjwgMjISJYuXZpov5IPIoRIaST4EF8FvV6PXq/HycmJ8ePHY21tTcmSJbG1teX06dPaesuXL+fSpUs0atSIrFmzcu7cOebOnUutWrUwMzMjTZo0jBw5kpcvXwLxD3JvP8yJv+/Zs2fkzp2bjBkzYmdnR7ly5di0aRPp0qWje/fuZMyYEYC1a9dy7949PD09GTJkCPny5WPPnj3JfPRfl3eDtbJly3L27FkCAwPZu3cvv/32G2ZmZnTt2hUHBwcA+vTpQ6tWrXByckqydd3X15ejR48CMvfE3/H2HB6G8ruXL1/mwIEDZM6cmRUrVlC6dGnOnz/Prl27GDlyJCVKlMDCwgIrKyucnJzYs2cPr169AiAkJARI3LsohBBfO2luFF8FQ0Km+v+kZr1eT7p06ejcuTM//fQT+/fvJzo6mqNHj/Lzzz/TunVrgoODmTt3Lvnz52f//v0J9rdt2zZu3bqFsbExI0aMkJb3f0G+fPkoXLgwAwYMICYmBj8/P/bu3YuZmRlt27bVEqGHDx9Ohw4d6Nq1K2XKlGHChAkMHTqUUqVKaUPlxKeJi4sjb9687N+/n9evX3Pr1i2sra0pW7YsALNnz+bJkyf079+f9OnTJ9rW2NiYixcv0qpVKyIiIrT5KN5+XXzYu3OpGBsbM3ToUIyNjfnhhx+0+VguXrxIWFiYVukqJiYGY2NjoqOjiY6OJl26dMTExDBr1izu3LmDm5sbmTNnxsjISO6FECJlSL50EyH+HT4+Pqpv375q0qRJauPGjUqp+ETmZcuWqXTp0qlTp04ppZSWJH3gwAGl0+lUmzZtVPHixVW2bNnU+vXrk+34U5qxY8eqDh06qO+//17pdDo1c+ZMFRERoZRSauDAgSpnzpzK399fW//y5csqffr0av/+/cl1yCnCu8n7hmscGRmpzMzM1KhRo7T7kJQmTZqoVq1aKaXiizLcuXNHhYWFfb4DTuHelzg+aNAgVbp0aaWU0pL+g4ODlY2NjZoyZYpSKr5ohpOTk8qYMaOaNm2aatasmfL29v7kf0sIIf6LZNiV+GoppYiLiyNPnjzMnTuXESNG0KJFCwBu3brF4sWLadiwIZUrV0YppSVJ79u3j1q1amnziQwaNIj58+fj6+ubjGfz9TOMTf/ll19YsWIF5cqVw97eHldXV8zMzLh79y7z589n7Nix5MiRQxtG8ujRIyIiIihVqlRyHv5Xz9AibrgPhpb27du3kylTJtq2bYuZmVmS23p6ehISEkLt2rUBcHd3p2bNmpQtW5aAgIAE68rwn49j6KF9V5MmTQgLC+Py5cuYmpoSERFB165dyZEjB40bNyYiIoItW7Zw/vx5evXqRaFChUibNi3VqlXTimYYnDhxQvu3hBDiq5Hc0Y8Q/9S7pXNjY2PVtGnTlE6nU48fP060zu7du1WaNGnUtGnTVHR0tAoJCVGnTp1SkZGRSe5fWhU/nl6vT3C9QkNDtWvv4uKiqlatqt68eZNgm/z586tu3bp91P5jY2PlfvwNL1++/GCJ6ePHj6tixYqpO3fuqB07dqi2bdsqR0dHVaNGDfX69WullFJPnz79UoebooWHh6suXbooCwsL1aBBA1WwYEGVMWNGdezYMaWUUrt27VLFixdXv/zyi7bNixcvlK2trVq7dq227Ny5c6patWrKzc0twf7l8yGE+K+Tng/x1UtqrPWAAQPYv38/2bJlIy4uDiMjIy2Rs379+ri5uXHkyBH2799P+vTpqVy5coJx7u8mj4qPY0jg1+v1KKWwsrLCyMiIJ0+e4O3tzYgRI7CwsNASmqdPn05QUJA2/j0pr169YteuXTx+/BhjY+MEs3+LD1NKodfrsbS0TPQ5gT97Sa5evcqrV69Ily4d3bp1o2nTpsTGxuLs7EyaNGm4evUq7du3Z/LkyQk+G3IfPp25uTnLli1j//792NvbM2rUKA4fPoyzszN+fn5s2rQJCwsLhg4dqm3j6+uLjY0NT58+1ZZt2bIFe3t7La/n5MmTXLt2Tb6vhBD/eRJ8iBRHr9djYmJCrVq1gD+Dk1WrVrFixQoAmjZtSvHixenRo0eSw60M20yfPp2LFy8meE1JJaC/ZGRklOAhKGvWrPj6+lK3bl0gPkgJCQlh8uTJ/PTTTx+cafvw4cNs2LCB0qVL069fP5RSknT7kXQ6XZJBh4HhOm7YsAEbGxuGDRtGmzZtKFu2LOnTp6d169bExcXRqVMn0qdPT9myZbVgMjY2NtFQL/HXDIF5lSpVmD59Oh06dKB48eIA7N27l6tXr9K3b1+tdHhERASHDx9OUK567969nD17FmdnZ8qUKcPr16/p27cv48aNIzAwMNnOTQghPoYEHyLFefdhS6fTERUVxf3795kxYwa7du0ibdq0VKxYEUtLS62k5btCQkI4deoUS5cuTRBwvG8st3i/pEoZ9+nTh1SpUtGlS5dEwcTb17t+/fqsXLmSDRs2cPnyZVq3bk1YWNhnP+ZvxeXLl7l27Rr+/v7kypWL6dOnc/nyZcqWLcvNmzfp0qULERERWsnqV69eMW3aNCpWrMjs2bOBv54HRvzJEJi/+x3y5MkTdu7cSYYMGWjbtq22/PLly6xfv5769etrQbqrqyvDhw/HycmJCxcukCNHDgICAujatatUjBNC/OdJfVHxTUidOjWzZs3it99+o02bNpQpU4a7d+9SuXJl0qZNm+Q2er2eq1evMnHiRHQ6HZ6enpw6dYrWrVtrrZLi4yRVyrh///507tw5yQnvdDod4eHh7N69m6CgIMqVK4eTkxMzZsygffv2PHv2DEtLywTb6PX6D7byi6TlypWLMmXKUL16dX744QdSpUpFYGAgN27c4OnTpwQFBbF582ZsbGyA+ECjQYMGFC1alPHjx7N9+3bWr1+vvS4+zrvv1axZs7J06VJteChAcHAw27dvJywsjPHjxwPxgbyJiQn16tUDIFOmTFhaWhIVFUW3bt2YMGEC33//vVaWXAgh/nOSLdtEiC/o7WTb0NBQtWDBArV792715MmT9667fPlylTlzZm15ixYtlE6nU8OHD0+wviR4frq/umaPHz9WjRo1UhYWFqpu3boqR44cqkWLFurEiRPK0dFR7d69Wyml1Js3b5S7u7sKCgrSto2Jifmsx55SvX1PSpQooXQ6nWrXrp12rWNiYtSrV6/UjRs31IsXL5RS8SViy5YtmyAR2uBDCe4isaSu17p161S2bNnUvHnzlFIJyykb1u/Xr58qW7asOnv2rFq6dKnKlSuXCg8P/zIHLYQQf4M0E4pvgpGRkVaa18rKiu+//5769esn2VpraJHcs2cP7dq14/Hjx/Tr148jR47g4uKiJXhCfElfaV38dH91zTw9Pdm1axdnz55l69atHDp0iLi4OJydnQkODqZ+/foAXLt2jR49evDTTz9x//59IOleFvF+hiFxhnvi5eXF3bt3yZQpE2PHjtXydFatWkWtWrVo27Yt5cuXZ9iwYWTIkAFjY2M8PT0T7dfwOZJ8kI+TVK9d5syZKVy4MH369EmwjqGIxvXr19m6dSvNmjWjePHidO3alQcPHmBubp7kUEcZLiqE+C+Q4EN8M3Q6HcbGxh+VMP7gwQNSp05NZGQkS5cu5caNGyxbtoxMmTJp8ydMnz6dYsWKceXKFeDPH3b5gf/nwsPDyZkzJxYWFpibm+Pg4MCgQYMwMjJi3LhxAAQFBbFp0yaePXuGn58fI0aMIFOmTOzbty/BvuR+fNi7wVq+fPl4+PAhR48epUCBAhgbG/Po0SOWL19OgQIFmD9/PjNmzOD06dOkT5+eN2/ekDVrVgCioqKYOnUqvXr14n//+x9Akp+5j/kMCqhRowYHDx4E4gMOQ4BoyLEZM2YMjo6O1KtXD3Nzc/R6PaampsCf9/Xt4M8QvMj1F0IkJwk+xDfnQ63uhh/l6OhoLly4wL59+wgKCmLOnDlERkby4MEDypUrx7x585gzZw4LFy7UJscz/LBLi+8/V6pUKfLmzUutWrVYsmQJgwcPpl27djg4ONCjRw8ALly4wLJly5g4cSKrVq1i8+bNNG3alKlTpwJ/tugbGRnJvfgEcXFxZMmShcKFCwPxnwlzc3NCQkIoWrQoTk5ONGrUiCNHjlC8eHGsrKyoVKkSAN26dWP8+PGYmZkxevRoypUrx/Xr17XP3P379/H09JTewo+k1+sTBRwGhw8f5vr167Rv354iRYoASfeeGLarW7cud+/eBaRohhAieUnwIcRbDD/0W7duxdPTExsbGwYOHEjx4sWZN28eI0aM4I8//mDNmjV06dKFHj16EBcXx7Jly+jVqxffffcdCxYsAKQC0D+RJUsWjh49Sv/+/bly5QqPHj3Cz8+PefPmAfDw4UOWLFlCwYIFGTJkiJa0njlzZjw9PZk6dSqDBw+mS5cuhIWFyb34BIZrZfgs6HQ60qVLR4ECBdiwYQMXL17kzJkzDB8+nEePHlG/fn2KFClCTEwM58+fx83NjVmzZuHj40PBggVZunQpcXFxREREsHz5clq2bMmNGzeS8xS/Gh8qoPDmzRvSp09PyZIl3zv3jSEAX7NmDQcOHGDLli388ssv3L17V4ozCCGSjXz7CJGEhg0b0qJFC9zc3MiTJw/Xrl3D2tqaw4cPM2DAALp06cKQIUMAaN++PYsWLSJdunRUrVqVSZMmUbduXYKDg5P5LL5ehgepAQMGMH/+fGrWrEn16tWpVq0aMTExHD9+nEOHDjFjxgxtm0ePHvHgwQMiIiIwMjLC1dWVgIAAGjZsyLNnz5LrVFKE1KlTs3HjRkqWLMmgQYOYNGkSixcvxtHRkW7dugFgampKw4YNGT16NHv37sXU1JThw4fTt29f/P39cXZ2ZsWKFVSvXp1ixYoBMvznn7C3t+f169eMHj0af3//RAG2Yb6juLg4+vXrR8aMGQkKCsLX15d69epx5syZBOsnlSMihBCfRfLlugvx9Th69KiysLBQqVOnVr/99pu2fMWKFUqn0ylnZ2f1/PlzpZRSISEhqnLlymrnzp2J9iMVgD7N2xWYoqOjlVJKXb16VRUuXFi1adMmwbqLFy9WhQsXVsuXL9eWHTlyRFlaWqoHDx4k2ndcXJzcj4/0dpWlkJAQtX79elWkSBG1YsUKpZRSgYGBSimlwsPD1bBhw1Tz5s2Vv7+/tk1MTIyqX7++srCwUJkyZVKrV6/+sieQQgUHB6vKlSurYcOGJXrNcM969+6tcuTIoY4ePaq9dufOHRUUFKTCwsLU9evXteV6vV6q9wkhPjvp+RAiCe8OYXj9+jXR0dEMGDCAoUOHast/++03vvvuO2xtbcmbNy8jRowgffr0mJmZcevWLQAiIyM5dOgQ8OcwCmll/DiGselKKS2RNl26dJibm2u5HQA3btxgx44d5M+fn06dOmnLL1++jL29PREREUB8Ls+pU6d49OgRRkZGkg/ykYyNjdHr9ej1etKnT0+rVq1Yv3497dq1IzAwkDlz5nD16lXMzc358ccfefz4MX369CE6OhqIH/YTGhrKhAkTmDZtGkOHDuX06dPAn70fcXFx0hPyCeLi4siQIQOnTp1iypQpwJ/FFeLi4jA2NubBgwf88ccfjB49mooVK2rbvnz5kl9//RUHBwe6du2Kg4MDhw8fRqfTST6OEOKzk+BDiCS8O4ShQYMGPHv2jJ9//llb5uPjQ2hoKH379mX16tVs3ryZ/fv3kylTJvz8/LSH5atXr1K7dm2WL1+Ot7c3IOVgP4VhRmiDfPnycenSJWxtbYH4gGL37t34+PgwbNgwbb179+5x/Phx7O3tyZcvHwBnzpxh3bp1VKpUie+//57o6GjJB/lIhmDNECA4OjpibGxMZGQkZ86cYdiwYdy6dYvs2bOTP39+wsPDSZUqFb6+vuzcuRNra2s6duxI586duX//PpUrVwbi719UVBTGxsbvzV0QiRkbG2vXynBP3i160adPH6pWrUqjRo1InTq1tm2vXr3w9/dny5YtHDx4kNatW9OvXz+OHj36hc9CCPEtkuBDiL+g/n9+kAwZMpA+fXptuY2NDdmzZ+fAgQMA1K5dm/PnzzNlyhRy5sxJ7dq1AZg7dy4A7u7uNG/eHEdHRx4/fpygNK+0+H68dx9OfXx82Lx5M6VKldKqLgGsW7eO58+f891332kz0lepUoVp06axYcMGPD09qVOnDoGBgQn2J/fiw95tGbezs2Pv3r1ky5aNSpUq4eLiwubNm2nSpAkAW7Zswd/fn9atW5MpUyYALCws8Pb2pmHDhnz33XeULl2aSZMmAVKo4VO8WxzAQKfTsWfPHg4ePMiwYcPIli2b9trYsWO5ceMG7u7u7NixgwwZMvDLL7+QI0cOjh07BiQuTy0BoRDi36RT8ksrxN82Y8YMtm7dyqxZsyhbtixKKXQ6HZGRkZiZmbF582ZatmzJ3LlzcXFxIX369OzYsYOmTZtiY2NDbGxsgnr88uD199y7dw9ra2syZ84MwKlTpxg7diz29va4ubkBcODAAZ4/f06BAgUoV64c/v7+uLi4sHTpUpycnBLszzCJmwxB+Wtvv289PDy4ceMGDg4OFC9enIcPH9KzZ09sbW1ZsmSJdj3379/PlClTyJgxI/369SMgIIDJkyfj6OjI//73PywsLJLzlFKEoKAgtmzZQqtWrbRGk/DwcKpUqULdunVxdnbml19+wdfXl4kTJ+Ln54e3tzfLli3Tem3DwsKwtLQE/gxIpEqWEOIfS6ZcEyFShOjoaNWzZ09lbm6uOnTooP744w9169YtpVR8Em6xYsVUy5YtE223YsUK9eOPP6qmTZuqSZMmfenDTlHeTZCNjo5Wbdu2VRUqVFAXL15USin1448/KhMTE+Xk5KTy5MmjGjRooLy8vFSRIkXUnDlzlFJKPX/+XI0bN075+Pho+4qJifli5/E1e1/yvqenp7Kzs1NbtmzRlj1//ly1adNGpU2bVlWrVk0r1HDr1i1VvHhxdefOnS923ClVUknjer1eRUZGqkqVKqkRI0YopeLf34sWLVL58uVTOp1OTZ06VSml1L59+1TTpk1V9erVVc2aNdXJkye/6PELIVI2acIQ4m8yzCa8cOFCLl++jLm5OcHBwVrL4Nq1a7l//z6zZ8/WtomLi2P06NFMnDgRExMTXFxcWLVqFWXKlMHPzy+5TuWr9m7vhKmpKTVr1qRu3bqUKVOGwMBA5s6dy5o1a9iyZQvu7u5YWVmRP39+PD09adu2LRA/FOj58+fkzZuXPn36AH/m5hgKBBw+fPgLntnX4918EIO0adNibW3N6tWrefz4MQC+vr5cvXqVIUOGULBgQezs7OjTpw+Ojo4EBwdrE+GJv0+n0yW6FzqdjtSpU1OsWDF8fX2JiYnBxMSEHj16cO7cORYsWMDAgQPZuHEjzZo1Iyoqipo1a1KyZElcXV0ZMWKEFMoQQvw7kjv6EeJr9m6Lb3h4uFJKqdu3b6s0adKoiRMnKqX+LHu5f/9+lS5dOlWwYEHl5eWlbefq6qoWLFiQ5P7F32No/b1y5YrKkyePcnd3114LCgpSmTJl0kqUvt1SfO7cOVW5cmWVMWNGtWzZMm15bGysatCggRo5cqSKior6Qmfx9QsKClJOTk6qdevWSqn465sqVSr15s0bpZRSp06dUlWqVFE6nU6Zm5uru3fv/uU+5XPx9506dUrlypVLdezYUd2/f189efJEe+3OnTvK2dlZNW7cOME2Bw4cUKNHj1YBAQGJ9vd2GWYhhPgYkvMhxL9Ar9cnGAt95MgRevXqxf3794E/x8W7urry6tUrSpQowYoVK2jdujWLFy+mc+fOpE6dmoULFxIbG8uZM2eoUKECqVKlAkiQGyI+TP1/3o3Bmzdv6Ny5M6dOneLXX3/l6dOn7Nq1iwcPHnDu3Dny5MmDUgq9Xq/lLnh5edG1a1dOnjzJgQMHqFmzpra/58+fa7kl4sPezgd5+fIladOm5dGjR9SuXZtx48bRpk0bbd0NGzbw6NEjOnbsSJYsWT5q35KX8/c8ePCAnj178vDhQ5ycnKhbty6tWrVi69atdO/endOnT1OoUCHt/kVFReHl5UXhwoUB8PPzIywsjCJFigCJv/+EEOJD5NtCiH/Buz+81atX586dOwDaQ21oaCg+Pj50796defPmcejQIR48eICVlRVnzpzREjsNVZgmTpyIj48PIKV5P8W7D6Np0qRh06ZNjBgxggMHDhAQEMCZM2cYN24cefLk0bZ5+fIle/fupXbt2pQpUwYrKysmTJhAzZo1uXTpEgMHDiQyMlILPKQC0F97uxyslZUVxsbG5MmTh1q1ajFjxgxOnjyJXq8nIiKCVq1aMXDgwASBx9ttYydPnmTWrFn89NNPPHr0SCvNKz6NXq8nf/78HDlyhLVr19KwYUPq1KkDwLlz58ibNy+FChUC/qymlTp1agoXLsy1a9fo3bs3FStWpEGDBpQrV45bt25J4CGE+DTJ2u8iRAr17rAQw8zBDRs2VO3atUvw2saNG1WNGjXUvn37lFJKDRw4UOl0OtWgQQNVq1YtlS9fPnXq1CltP+LTvDssZNu2bcre3l5FRESoyMhIdeLECdWmTRtla2urHBwcVJcuXdTp06cTbFO7dm1Vrlw5dePGjUT7l3vy9wwYMEBZWlqqJk2aqIEDB6qgoKAErxuu65s3b9S4ceNUmjRpVIUKFVT16tVV6tSptUIBhvUM/3327NkXPIuv0/uGSq1atUrlzZtXeXp6assM1zU4OFg5OTmpKlWqqMWLF6vbt2+r77//XpUpUybBEFKlZFicEOLDJPgQ4gtatWqVKlWqlBZoGB4CoqOjlVJKnT59WpmamqqpU6eqW7duqdjYWNWxY0fl4uKSIM/g0qVLasaMGerly5eJHr5E0pLKzRkyZIgW6G3btk29fv060fpr165VuXPnVqtXr9Zeq1evnrp+/XqCdeWB6+O8fZ38/f3VhAkT1LZt2xKtZ3g/z549W5UvX16NHz9ee23p0qWqRIkSyt/fP8E2a9euVWXKlFGOjo5q9uzZn+cEUjAvLy9VokQJ1aNHD/X48WP18uVL7bVhw4apypUrq71792rLHj16pDJmzKi2b9+e5P7kO0kIkRTpKxXiC2rfvj2urq40adKEpk2b8scff3DhwgVMTU15+fIlEyZMoFy5cgwZMkSbQdrFxQVPT08ePHgAwKtXrzhy5AgrVqwgMjJSG3oiQ1A+zFCNSa/Xa5MO1qtXDwcHBzw8PMiQIQNp0qQBICYmBiMjI/R6PVOmTKFGjRrajNzbtm3TJmgbN24cN27c0Ko9ib9muA9xcXHkyJGDUaNGaRMSvk2n0xEYGMi+ffsoXrw4P/zwg/Za4cKFefbsGd7e3iilmDJlCjNnzmT8+PGUL1+ePn36sHbtWvz9/b/gmX398ubNy5o1a7h+/TrlypVjwYIFeHt7ExwczLlz56hYsSJVq1bV1jc2NiZfvnwEBARoy7p06cK9e/cAtBnrlaSWCiHeIr+WQnwhhh/giRMn4u3tTa5cuXjy5In20Lpv3z7279/PnDlzgD8n9TI8YBmSPc+cOcOhQ4cYPHgwWbJk4cmTJ3Tr1k2bnVi8n06nSxAkVKtWjTt37tCuXTvq1KlD7dq1uX//vjbJ2qRJk4iJiaFZs2ZafsgPP/yAjY0NL1++5NWrV5QqVYqZM2cmx+l8tXQ6HcbGxn/5UBoXF8eDBw9wcnIiU6ZMWv5ImjRpCAkJIS4uTpvUc/DgwQQFBTF27Fh++OEHzp49i62t7Zc4nRRDr9dTuHBhzp8/z8qVK6lYsSI5c+YkQ4YMPHnyBBsbG9KmTQvE35t79+5x584dcuXKBcTPZr9ixQoWL17MjBkz8PT0lNwcIUQiEnwI8YUYau/HxcWRLVs2Zs2axciRI7W5KIYMGULXrl0pVaoUSimMjIzw9PRkzpw5DBs2DICIiAju379PdHQ0HTt2ZNOmTUyePJnr169r8yhIK+PHM8xbMG7cOJ4/f46JiQk//vgjAP7+/qxYsYJmzZpRvnx5AIYMGQLApk2bmD59OtOnT2f06NHs3LmT0NDQRPs3BJAiaX/1UBoVFYW3tzc5cuQA/kyAnj9/Prly5aJatWoAODo6kjVrVuzs7LCxsWHbtm0f3Ld8RpJmZGSkBXguLi5UrVoVU1NTIiMjyZ07NyEhIdq6Dx8+ZMqUKRQqVIgGDRoQFRXFuHHjyJgxI2/evMHPzw97e3sWLFiQ4N+QQg1CCCmhI8QXZGjxNZSmNAz/CQoKwsjIiClTpmjrKaWYMGECOXLk4PvvvwfA3Nycfv36acNUPDw8mDdvHrlz58bZ2VnbVnwcExMTLSBMly4de/fuJSwsDID+/ftjYWFB/fr1yZgxIwEBAcycOZPp06dTtmxZbR8ZMmTg6tWrpEuXLtH+DQ9zUhL277G1taVJkyasWbOGqlWrEhAQwMGDB1m0aBFbt24F4ObNmyxZsoSyZcuyY8cOzp49i729vbYP9f+ll6OjowkICMDOzk7uxQcYAry3mZub06ZNG3788UciIyOxsbFhy5YtPHv2jO3btwPwyy+/EBMTw/z582nZsiUQH9zv37+fnj178uzZM7Jmzar1eMk9EOLbJcGHEMng3fyAokWL4uvrC/z5sHTixAk2btzIli1btPk+DEFLzpw5AYiMjKRUqVJYWVmRM2dOfv/9dwYMGPAlT+Wrp9PpMDExQa/Xo9PptJLH33//PU+fPqVEiRIA9OnTh9KlS9OsWTNSp06tbf/HH3/QvHlz7aHt9OnTHD58GD8/P4YOHUrBggUBmQvh70idOjUDBgygffv2ODo6ajk7gwcPpkmTJoSHh7N//35u377Nzp07AahYsWKCfeh0OvR6PY8fP6ZatWoMGDCAgQMHJsfpfNU6d+5MwYIFGT58OKlSpaJChQq0bNmS4sWL4+npydq1a+natSt169bVtrG2tuaPP/6gX79+PHnyBE9PT/744w8tf0oI8Y364inuQohE3i19GRUVpYoWLaqcnJwSrWuoFrR7925VuXJlNXz4cKWUUidOnFC7d++WGYc/g2PHjimdTqe2bNmilU1WSqlp06apbNmyqTNnzqi4uDg1ceJElSFDBlWhQgVVu3ZtlTFjRrV58+ZkPvqUYdWqVWr58uXq3r172nv82LFjqnTp0qpv375KqaRLvMbFxalx48apvHnzKhsbG215ZGSkUiq+wpxhtnWRNL1en+DahoSEJHi9Xbt2ytnZWV26dCnBNhkzZlTfffedOnz4sHr+/Lnq2rWrqlSpUoKqckrJLOlCfGsk+BDiP+ro0aOJ6ucbHnpfvnypOnXqpGrUqKHu3r2bHIf3TQkNDVVubm7qxYsX2rKXL1+qzJkzq2HDhiml4h+Oy5Urp0aMGKGts2bNGtWnTx/l7Oysjh8//sWPOyWIiYlJcvnTp0/V4MGDlb29vQoODlZKvX9+iVWrVimdTqcsLCzUjBkzErzWtWtX1aNHD/Xq1at/98BToKSChEOHDikTExP1xx9/JHh9wIABKleuXAlKUm/btk1lyZJFXbt2TSmlEpQPV0rmBxHiWyFjAIT4j6pWrRp58+ZNsMwwTnr79u08ePCARo0aYW9v/0kJtIYka/FxlFJYWVnxww8/YG1trS3v06cPtra2dOrUidevX7N582YcHBwSlITNnz8/Cxcu5Ny5c9qs0eLTmJgkPTr4wYMHLF26lK5du5IhQwYtt+ZdgYGBHDx4kKJFi7J9+3bmzp1L3759tc/M0qVLmTRpklbFSbxfUvkgJUqUYNq0adSoUUN73c/Pj9mzZzNkyJAE7/s7d+5gbGxM8eLFAThy5AgVK1bEw8MDQCtv/SnfZ0KIr48EH0J8ZSIjIzl//jxKKTp16gR8uHrPo0eP2LlzJ2vXrgX+fJiTSkwfx5D8/7bQ0FDOnz9P27ZtsbOzIzIyEi8vLypVqoStra22fnh4OHq9nhkzZpA5c2a55v+iSpUqsX37doYOHQokzqOC+Pf48ePH2b59O5MnT6ZWrVp4eHjwyy+/8PTpU3r27EloaCiZM2cGpBLT35ExY0YGDBhAgQIFtGUdO3akSpUqfPfdd1rZ6sDAQKZOnarlpAUGBrJnzx7Onz/P4cOHad++PWfOnJHiDEJ8AyT4EOIrY2Zmhl6vx8rKCisrKyDpBy+AXbt2UbduXXr16sXPP/9M7ty58fT0/OA2IrF3H4bSp0/P/fv36d69O2ZmZrx58wYPDw9tvgOdTkdISAj/+9//sLOzo0+fPkDCa55UwCgPv5/GUOFNvad6kre3NwsWLKBKlSrUr1+fuLg4UqdOTaZMmfj55585fvw4d+7c0dY3tNxLy/vHe/daPX78mFu3btGvXz+yZ8+uLR89ejQ2NjZa5b4zZ86wcOFCWrZsiaWlJTlz5qRu3brs2LEjwf6kp1aIlEeePoT4CnXo0IE7d+5QoECBBLMLv+3+/ft06NCBmjVrsmvXLnx8fOjSpQtLlizR5rUwkIetT2N4IEqfPj0A2bNnx9XVlTVr1vDmzRt8fHxYvHgxq1atYsaMGUDiniZD+ddTp05x/PhxAK0M87v3Q+7Ph72vpfzo0aNcuXKFuXPnAvEz1xsqyR06dIiBAwdSqlQpAFq3bs2RI0e0/an/r6wlPuzda589e3aePn1Kw4YNtdcuXrzI6tWrmTBhAlZWVvj4+ODm5kblypVZv349HTt25Ndff8XOzo6rV68SFBTE0aNHgfcPuxNCfL10Sn7VhPhqLVq0iDp16pA7d25tmaGka5cuXbh8+TJXrlzRfsDPnTtHw4YNsba2ZvTo0bRv3z7B/t7XgiwSM1znp0+fYmVlxfXr12nXrh3W1tbY2tqyfft2GjZsmKgl1+DBgwdMmDCBEydOoNPpSJcunTZfheE+REREaHPBiE/XuHFjAHbs2EFUVJRWIrlatWpYW1szceJEChcuzLlz56hUqRJ9+/YlQ4YM1KhRAycnp+Q89K9WbGxsooChZMmSmJmZcfbsWaKjo1m0aBEjRozg7NmzODo6AvGfh++++464uDgKFSpEaGgo9+7dY/PmzVSoUCE5TkUI8ZlIz4cQXyFDy3vPnj0TBB4QP7Tn5cuXrFu3jtGjR2NiYkJUVBQQP2QrJCSERo0a0ahRIwB++uknDhw4APzZ4ittEn/NMIRq4cKFrF+/nvLly/PgwQN+//13qlSpgk6nY/r06UDSPRcvXrzg1KlTLFmyBA8PD2rWrEnbtm3Zu3evFgA2btyYmTNnSgv836CUIn/+/Pj7+3Pt2jUt8Fi2bBkPHz6kVatWFC5cGIAePXpgZWVFbGwsOp2OWrVqMWbMmAT3TYb/fJykeiqmTZvG4sWLgT8nhezQoYMWeCil2LNnD0FBQfzyyy+sXLmSw4cPU6FCBebPn/9Fj18I8flJf6YQX6G/Gorg7e1N1qxZSZMmDYD24PX7779TtmxZGjZsiKWlJR4eHri5ufHo0SM8PDwoVaoUVatW/ezHn5LY2NgwePBgjh49Stu2bdm+fTvu7u4MHjyYAgUKfHBywUePHvHo0SNSp07NjBkzyJs3L/b29uzZs4f169fj4eFB9+7dtYnyJE/n4+l0OmbMmEGPHj1o0KABO3fupHDhwsyaNQtXV1dtorv58+fj7e3N5s2bcXV1BSAqKorLly/z8uVL3rx5Q44cOWT4zz9Qs2ZNIH7Y27Zt27hx4wanT5/WXr9w4QK7du2iVq1a2uzoEH8fYmJiiImJwdjYONH7P6leFiHEf5/8kgmRAjk6OmJtbc21a9e0ZZs2beLkyZM0aNBAG1IycuRI4uLieP36NX5+fjRt2pRZs2Yl2JckQX/Y999/z6lTp3jy5AmjRo3iypUrdO7cmalTpwJ/jok3tKIbrmf58uVxc3NjxYoVrFu3DojP5cmXLx/Zs2dny5YtBAUFERQUhE6nk8DjExl6ixYvXsy1a9coUaIEv/zyCyEhITRt2hRbW1vi4uIYMWIE/fr1SzDMKkuWLBw4cID27dszfPhwbG1t2bx5c3KdSophamrK8OHDOXz4sNYw8ubNG/bu3cvjx4+1ymUAV69eJSIigiJFimBiYoKRkREPHz7k5MmT7N69G5B8ECG+Wl9oPhEhxBdimHBtwYIFysjISHXo0EE1btxYWVhYqJo1a6pbt24ppZTauHGjyp49u5o0aZI2uZe3t7d68OCB9v9vkwnA/tqjR4+0mbOVSvqaubu7qz179qiYmBgVHBysRowYoRwcHJSHh4e2zowZM5S9vb3q06ePSpMmjSpatKiKiorS9meYbFJ8WFxcXIJ7cPbsWbVw4UJtssg+ffqovHnzJrj2b968UQUKFFDfffedOnr0qIqIiFC//PKLcnBwUEFBQV/8HFKSpD4PW7duVQ4ODmrUqFEJlg8ZMkRVrFhRnTp1Siml1Jw5c1ShQoVU8eLFVeHChVXevHnVoUOHvshxCyH+XRJ8CJGCxMTEqG3btmmzafv4+KgDBw6odu3aqZIlS6olS5Zo65YsWVJ17NhR+fj4aMuePXumli9frnLnzq2cnZ1Vrly5Emwj/pmYmBi1ZMkSVaNGDXX69GltuYODgxozZoxSSqnHjx+rPHnyqJ9//lnFxcWpiIgItWXLlvfuT/w9Xl5eSqfTKTc3twTXcdKkSSpjxozK09NTW7Zr1y6VM2dO7UH4XXIf/r6rV6+qhg0bao0mSsUH6FWqVFFDhw5VSsUHKJaWlmrKlCnaOj///LOqUqWKev78eYL9JTULuxDiv0X6LIVIQZRSXLhwQSvxWrVqVfR6PSdOnOC7776jbt26APz2229ERETQqlUr8uTJo20/adIkzp07x6hRo7Rx8r/99hsvX75k0KBByXRWKYeJiQlt27bl0qVL1KlTh5YtW5IqVSru3bun5SCMGjUKGxsbGjdujJGREWZmZjRt2pSQkBAWLlxIQEAABQoU4Mcff5RhJ59I/X8VMb1eT86cOZk7dy6NGzfWrmNAQABTpkxhzJgx5M+fH4gfvvXw4UPCwsIoVqyYtq/nz5/z5MkTihYtqm2vpFrcJytRogQ7d+7U/g4LC2PDhg1YWFjQuXNnAGbNmoWpqSlTpkwhICCAGTNm8Ouvv5ItWzYOHz5Mq1atiImJwdTUVJurRXKkhPgPS+bgRwjxGcyZM0dlz55d5cuXT6VNm1a1a9dOeXl5KaWUCgwMVObm5mrIkCEqJCRE2+bw4cMqc+bMysLCQrVt21aFhoYqpZSaMmWKcnV1TbJFUVoZP83bw6UuXbqkWrVqpQYMGKAWLlyolFLqwoULKleuXGru3LkJhm9t2bJFubi4qHTp0qnvv/9e5c2bV5UsWVK7p+Lf0bx5c1WsWLEEnwsvLy9la2urBg0apJSKb6kfMWKEypYtm6pQoYLKkyeP2rp163v3KcMVP+zd63PixAlVpEgRNWHCBKWUUp6enkqn06mrV6+qGzduqEqVKqls2bKpcePGqfLly6vDhw8rpZQ6cuSIqlChgrpy5Yq2L71eL9dfiP8gCT6ESKGio6PVoUOHEgyrUip+iMjcuXPVmTNnEiz/6aefVPXq1dWOHTtU48aNlaWlpZo4caI6fvy4KlCggPLz81NKxQ/lMgzrMpAf+I/3bh7C2wHJyJEjVdmyZbW8HKWUCg0NVWXKlFHt2rXThgK9fPlSOTs7q99++y3RfiQg/Djv5s2EhoYqBwcHtXbtWm1ZVFSUGjx4sMqUKZOKjo5WSilVpUoV5erqqo4eParCwsLUtGnTlL29vdq+fXuif8MQwItP8+DBA/Xq1SulVHwwki1bNm2YYlxcnPrf//6nChQooHLlyqVOnTqlIiIi1ODBg5VOp1OzZs1SnTp10oISIcR/j/RJCpFCmZqaUqNGjQTDqiB+6E/fvn2pWLEi8GdVIFNTU8LCwmjUqBHbt29n7dq1bN26lWrVqpE5c2Zy5sxJZGQke/fuZfLkyeTPn58NGzYAJDm8QeamSJqRkRFGRkba9Xl7mI5hcrV06dJpy/744w90Oh2dO3fWhgJZWlpiZWXFjRs3iI6OBsDf3x+9Xq8NO5EqZR/27vAoKysrPDw8aN26tbbs2rVrLF68mMmTJ2NqasqcOXM4ffo0p06dYtOmTZiamvLTTz9RokQJba4c9f9VzZ4+fUrOnDnZv3//lzupFEApRb58+UibNi0AVatWpVixYhw8eBCI//x07tyZixcvsnz5cipXrszx48eZP38+jRs3xtzcnLx589K0aVMWLVqUnKcihHgPCT6E+Maodya8MwQOjo6OxMbG4uPjA0D9+vU5d+4cS5YsYebMmUD8JIWdOnVi7dq1DBgwgKFDh2olZQ37jYmJ4fnz5zLe+i8kdX0aNWpEmTJlyJMnDxs3bgQgODgYGxubBKVgX79+jZWVFS9fviRVqlQANG/enB9++AEvLy+ABGPfxV8zTCJoCEqioqIYO3Ys1tbW9OjRg7i4OLZu3UqvXr3YuXMnd+/eJUeOHMyePZvy5cvj7+9PRESEtv3kyZPJkCEDJUuWTLZz+hq9HRQavlM6duzI7Nmzad++PRcuXODGjRtYWVnh4uKCv78/c+fOpWjRomzbto2ePXsyZswYqlWrxoULF4DEn4G4uDj5XAiRjOTpQIhvzPsSYmvWrImFhQU9evTg+vXrhIWFoZSia9eulCtXDh8fH9zd3dm6dSupU6emb9++dOnShSNHjhAdHa3Njv7kyROyZ8/OsWPHvuyJfeWUUqRLl461a9dy5MgRqlWrBsTPhP706VMtyID4ORC2bNmiTci2adMmrly5wvHjxxk+fDilS5fm8uXLQNJBjkjs3eT91KlTM3XqVG1Oibi4ONKkSUNsbCzVqlXj8OHDzJs3j0WLFjF48GBy5syJubk5ADdu3MDNzY3JkyeTJUsW7SE6ICCA27dvf9kT+4oZvqvatm2rTfrYtWtX1qxZw927d9Hr9ezfv58TJ04wZ84cbbs3b96QIUMG/Pz8iIuL0z4Db968AdAmLNTr9UyYMEG+q4T4wnTq3WZQIcQ36/Xr13z//fccOnQIJycnihYtypgxY3j48CFOTk6kSpWKjBkzEhAQwJAhQyhUqBAdO3bk2rVr2NjY0L17d06ePImxsTF37txBKZVgKJD4MENrrJGRkVY5ac+ePQwbNoxZs2bh5OTE3r17mTt3Lq9fv+b8+fPExsZSpkwZTE1N6d27N2XKlOHAgQN4eHiQI0cOhg0bhoWFRTKf2ddHJVG5atSoUVy7do3169drw4Jev37N6tWrad++vbasTp06REdHs2/fPlKnTp1g+61bt7Js2TIqVKigLZfKTO/37nfInTt3MDY2xt7eHg8PDzp37oy9vT0rV67Utrlw4QKurq6MHTuWH3/8EU9PT9zd3XF3dyc2NpYJEyZQoUIF3N3dGTFiBJUrV2bevHnavycVy4T4zL58mokQ4r/o7URlDw8PtXDhQnXnzh2llFKjRo1SWbNmVc+ePVNPnjxR69atU46Ojkqn06nmzZtr240ZM0bpdDplY2Oj9u7dqy339/dXN2/e/HInk8IMHjxYpU6dWlWoUEGlSZNGNW/eXJsYb9SoUapQoUKJEp5PnTql7O3t1Z49exLtT5LS/57r16+rggULqu+++07dunVLPXnyRHvNkMB+4MABZWZmphV0MCw/c+aMqlOnjurevfuXP/AU4N33bGxsrJoyZYrS6XTq6dOn2vLQ0FDVvn17ZWdnpy0rVqyYKlKkiOrWrZv64YcfVLFixdTOnTtV586dVe3atbXP0tsV5oQQn48EH0IIzbuVmAxGjx6tKlSokGAytcWLFytzc3N18eJFpZRST548UZUrV1YNGzZUc+fOVRkyZFCTJk1SSik1fPhw1ahRIy2YER/n7YpMDx8+VCtXrlRnzpzRqij5+PioXLlyqVGjRqmXL18qpZRWlenYsWMqbdq0Kjw8XCn11wGHzJr+cR4/fqwaNGigcuXKpTp06KCWLl2a4PWcOXOqLl26JFgWFxen+vfvr6pUqZKgytzZs2dVmTJlVGBg4Bc59pQmKipKHTx4UCn15/t3z549ysjISO3evVsppVS/fv2Ura2tunr1qrbd6NGjVc2aNVWNGjXUjBkzlFJKhYSEqF69eqmjR49+0XMQ4lskwYcQIpF3H0TPnj2rrK2tVdOmTdW2bdtUr169VPr06VXPnj21debPn69MTU210r5BQUHq6dOn6vbt26pVq1Zq1qxZX/IUUgy9Xv/ewKFFixbK2dlZXbp0KdFro0ePVq6ururNmzdKqfjg4+bNm6pevXrqyZMn2j537NghvVIf6e37cPXqVbVx48YEvR/h4eHKx8dHC9INgfyOHTtU5cqV1ahRoxLsr0GDBqpr164qLCzsCxx9ypJUI8mjR49UsWLFVK1atZRSSj1//lylSpVKLVmyJMF6W7ZsUUZGRqpp06banC5LlixRDRs2VOvXr//sxy7Et04GmQohEnl3zHOFChXw8PDAwsKCO3fusG3bNmxsbBg+fDgAPj4+TJ48mf79+5MnTx5iY2PJmDEjWbJkYe7cuSilqFOnDpC42paBim8M+bwn9hXS6XQYGxsnujZPnjzh5s2b1K9fn+LFi2vL384bMTY2xszMDICZM2fSqVMnwsPDiYuLw9jYGL1eT5MmTVi8eLFWsvfd/Yg/Ga6ZUooSJUrQokULbGxsAPDz86NgwYIEBwdryetGRkYEBwfj7u6u5UQZLFu2jLt37zJgwIAEpZXfJZ+JpCWVI6OUIioqivnz5wNw8OBB8uTJQ9WqVROsd/jwYXLlykXXrl1Jnz49d+/eZc+ePZQtW5b69etr+xJCfB4mf72KEOJbFxcXR5YsWVi1ahXR0dEcP34cZ2dncufODcCSJUvQ6/X8+uuvQMLKQUOGDOH+/fs4ODgAfwY26v8TO9+8eUNISAi2trZf+Ky+Lu8GhFmzZuXGjRuEhYVhYmKiXU/DQ9mOHTto06YNRkZGjBs3jnnz5jFw4EB+/vlnbZ0ff/yRfPny0atXL62aVkhICBkyZJAE6Pd433W5dOkSFhYW2NnZJVgeEhLCixcvqF27Nrlz507wvu/WrRv29vYf/Pck+fnj5cyZk7t372p/29nZ8fz5c169eqUtO3r0KLdu3aJOnTpaoBEaGoqVlRWVK1cmbdq0f5l0/levCyE+TKpdCSE+yrsVeWJiYjA1NUUpRYECBWjTpg0TJkzQlkPiH+mkfrT3799Pt27dqFevHvPmzcPU1FR+2D+CofciKY8ePaJXr17Ur1+fI0eO4OHhwahRo2jTpo22jo+PD/ny5cPNzY1u3bphamrKmzdvGDx4MC9fvmTdunVf6lRSjIiICMzNzbXPSkBAAACZM2dGp9NpnxfD+zupKleGZZ6enowfP57mzZvTuHHjL34uX6PY2NgEDR9+fn40atSIsmXLMmTIEHx9fRk2bBgmJibMnz+fcuXKaffj7e+td0VFRbF+/XpiY2Pp1q3blzodIVIsadoSQnwUw0OSYTI2ww/169evKV++PJcuXSIkJCTBD/i7QcS7fwcGBrJv3z4eP37Mjh07iIuLS7SOtI8k7UPlizNkyICPjw99+/YlIiKC33//XQs8DNezV69eVKlShUaNGmn37MaNGxw7doyuXbsCMvTqY6n/LwdrmOfD8FmZOnUqzZo1w9vbW7vGhvlw3l7vbYZlGzduZN26dfTq1Uub+FN82LtzteTKlYvly5dz8eJFhg0bxqBBg/Dx8aF58+aUK1dOW0+v17838ID48r5LliyhR48e/O9///tsxy/Et0KGXQkhPsm7P/Dp0qVjxowZtGzZkmrVqrFx48a/HEoC8Q9sp06dYt26dVSuXJksWbIkaIE0tGJKL8jHebvVd9u2bdy/f58GDRqwdu1abf4JQ2/Jnj17OH/+PFu2bCF79uxA/Ezq48aNo2TJktSqVQtI/HBsaCWWeSkS0ul0Sb5Pa9asiampqTbk8O31k2K4rseOHePixYs4ODgQGBhIlixZPstxp3SG3Jxr167h6enJ4sWLOXr0KG3btgX+vN5J3Q/Dez0sLIxdu3Zx8+ZNAO3z8qGeRyHEh0nwIYT4R/R6PVmzZuXEiRPcvn070Zj39/H29mb+/PlUqVKF77//nh9++AETExPtAbpt27akSpWK5cuXJwp4REKxsbG4ublx7do1UqdOzZo1axg3bhzdunUjbdq02oOS4WEpICCAHj16UKVKFW0flpaWlCpViu+//x5IOCTI8CBmeEgzTIIIkpPwIQ0bNqRBgwbAX08kqJTCyMiImJgYNm3axOvXr6lSpQpeXl7ExMRo67i7u+Pl5UW/fv0k9+Av6HQ67b1foEABpk6dyuXLl8mZM6d2vT+0LcCVK1dYuHAh3bp1w9vbm2fPngF/9jzOnj2b/v37f/6TESIFkaYrIcQ/YmRkRFxcHACOjo5a4vKHREVFsWfPHq5cucK0adO4ceMGWbNm1YKMmzdvsm3bNlxcXCTw+AgmJiY4OTlx5coVoqOjmTdvHiNHjiRr1qxA/IOSYbjc/v37adSoEdOmTUsw+7aJiQmTJ0/WkqLffjAz3N9Zs2aRPXt29u3bpwUjMjTr/d4ODj62p2j79u1cunSJevXq0apVK27cuKFtGxgYyOjRo1mxYgUggd/HMAQJhvdp6dKlgY+7ds+ePWP58uVkzJiR3377jRMnTiTohZoxYwYDBw7Ew8PjMxy5ECmXBB9CiH/sU4cf3L59m4ULF9K2bVvs7OwwMTEhPDxce0Du06cPLi4utGjRIsF2kv/xfobhJYsWLaJjx45AwpwNExMTIiMjcXV1ZenSpVpAYfD2um8/mOn1ekxMTIiKimLs2LFky5aNFi1aUL16dR49eiTDrz7gY4MDvV6PTqfj6dOnbN26lYwZM9KlSxc8PT3JkycPlpaWREZGsm3bNm7evMnWrVsBEt1D8X6f+j5VSnHixAm2b9/O+PHjiYmJIXPmzNo1f/nyJRMnTmT8+PEULFjwcxyyECmW/GoIIb4IQ+Dw8uVLNmzYQEhICL///jsQn9BpY2ODiYkJ69ev59y5c4waNQpLS8sE+zC0tEtr+/u9HQi+/cCl1+sxMzPDzc2N1q1bJwoY3/dwZrhvffv2xcbGhr179+Ln50e2bNmoU6cOt2/f/gxn8W0xXPsNGzbg4+ND48aNyZAhA6lTpyYoKIjIyEj8/PyYOnUqvXv3JleuXIlyDiQQ+Xd5e3uzYMECypUrR5MmTYiOjsbPz4/06dMDMHjwYLJkyULnzp21+2D4rMi9EOLDZDyDEOKLMLQCnzx5koULFzJ58mQsLCwAsLW15cGDB8TGxjJ8+HA6depE5cqVgfhymffu3ePmzZvUq1dPS96V8e6fxvCA26tXr4/exvCAe+fOHZYuXcqiRYuwtLTE3NycKVOm4OzsjLu7O46Ojp/rsFM8w/v42rVrHDhwgAIFCtCpUycgPijPnz+/Vho2LCyMWbNmAfFB5ps3b3jy5An58uVLMBGlfC7+mcjISPbu3cvVq1c5deoUAPfv3ydHjhxYWVlx/fp1li1bxsqVK8mWLZu23atXr7C0tEww1Et6BoVITD4VQogvysTEhEKFCtG7d29t2Z07d7C3t2fhwoWEhIQwbNgwjI2N2b59Ow0bNmT48OEcOHCAsmXL8uOPPxITEyMPWH/Dpw5bMzxEDRkyhCJFitC9e3etnGzOnDkJCgoiODg4wb5laNynMbyPL168iKenJ61atdJmpbezs+PZs2ecOHGCZcuWMWnSJCA+J2ratGk4OjrSvn17HB0dOXTo0HurbolP8/jxY3777TcaNWpEoUKFgPj3u7+/P2nSpGHkyJE4OzvTokULlFJcuHCB6tWr07JlS0qUKMHq1auBTx/qJcQ3QwkhxBcWFxenlFIqMjJSKaXUiBEjlJOTkzIxMVG//fabUkqpQ4cOqfLly6uiRYtq2127dk0VLVpU7dixI9E+9Xr9Fzjyb0dMTIxSSqmtW7cqnU6n0qVLp5o2baqCgoJUeHi4Gjp0qLKwsFArVqx477bi01y7di3B3/369VPlypVTbdu2Vfb29tryBg0aqDp16qidO3cqPz8/NW7cOJU/f361bdu2L3zEKdfp06dVRESE9vfRo0dV+fLl1fjx45WRkZE6fvy4UkqplStXqmLFiqlBgwapY8eOqXnz5qmcOXOqn3/+Wb6ThHgPCcuFEF/U20MRDNWWfHx8OHnyJLVr16Zjx47ExMSwZ88eXr16RXBwMMWLF2fr1q0UL16cmjVrsmrVKm1fBoaymkpa3v8xpZRWZaxfv3706NGDI0eOYGRkRObMmSlatCjTpk2jT58+tGrVipMnTzJ37lzmzJkDJJ4LRnyY4X1cvHjxBH/nzJmT69evs27dOhYvXgzA77//zqlTpzhx4gQXL14kZ86cjBkzhrJly3Ls2LEE2xtIDsKnq1SpEmZmZtq1tLW15f79+4wdO5a+ffvi5OSEh4cHK1eu5Pbt27x+/ZoKFSrQp08fZsyYwcmTJwkNDU3UIyj3QggZdiWE+MKSGorQoUMH8uXLR8eOHcmYMSOmpqZcvHiROnXq4O/vT7NmzejRowdt2rTh6NGjWtJnREQEPj4+rFu3Dj8/P4yNjRPMIC3+HsP1GzlyJLGxsfTq1YsyZcqwadMm7t69y6BBg7h8+TLdunVj/PjxODs7s2nTJhYuXEj27Nk5fvx4Mp/B1+Xdz4ThbwsLC6Kjo2nVqhVVq1YlPDycU6dO0bBhQ1avXs2BAwfImjUra9euxcnJiUuXLhEdHa1t//TpU4AE+SDi0xiuZUhICKGhoWTPnp2ePXsC4OHhgZeXF7NmzeLx48fY2Ngwa9YsateuzY0bN3j27Jk2DC4qKgogUXK6EN+k5Ot0EUKIhAzDsKKiolShQoXUyJEjtdd8fX1Vu3btVNasWdX69euVUkr16NFD5cqVSxUoUEAZGRmpiRMnJstxp0SxsbGqZMmSavjw4drwk9jY2ATrTJw4UTk4OKi1a9dqQ0x69uypmjRpkmh/MgTl7zl79qx6+fKl9ne9evVUly5dlFJKRUdHq8WLFys7Ozul0+nUwIEDlVJKHTt2TLVu3VoVKVJElSlTRp06dUrb/t17KD6eh4eH2rVrl/Y9tWDBApUtWzbt9a1bt6pChQopnU6n7OzslFJKBQcHqyVLlqiGDRuqypUrq02bNmnr6/V6+VyIb5JOKQm/hRDJ692yoQDz589n/fr1bNq0SZssD8DT05O8efMyZcoUZs2axaRJk2jUqBHe3t7MnTuXYsWKUaFCBVxcXL70aaRIr169Il26dNrfhmFzly9fZtiwYRQpUkSrwASwfPlyJk6cyN69e5Oc/yA2NlaGZX0Ew3Cfd3tFRowYwfXr11m/fr12X4KCgti0aROurq6EhITg4uJCxYoVqVu3LoGBgVy7do0ZM2Zga2uLlZXVFz+XlCCp76ijR4/SrVs31q1bR/ny5YH4SlkrVqxAKUWvXr1o0qQJd+/epVixYtjb27NhwwbGjh1LvXr1yJAhQ3KcihDJL5mDHyGESNLDhw+Vs7Ozypkzp1q6dKnauXOnevTokVJKqcDAQJUqVSq1YMGCBNt07txZZc6cWTk7OydoLVYqvsVXWhk/3vuSxg3X8PTp0ypDhgzqzp07Siml9Y5s2bJFpUmTRoWEhCillFq1apUaPXq0mj17dpL78fHx+QxHn3JdvXpVFShQQHXq1En5+Pio4OBg7bVnz56pevXqqTJlyiTYplu3bipr1qzK2dlZ+wwZGIo/iE/36tUrVb9+feXq6qru3r2rYmJiElzPtWvXKlNTU3Xw4EGtx2nlypWqcuXKqkaNGokKZ8i9EN8KyfkQQvwn5cqVi2PHjjFixAjc3NxYsGABz549A2DOnDnY29vTrFmzBGOnw8LCSJ06NQMHDsTS0pLXr19z9epVgoODtXwQSfj8OO/rnTCMYQ8ICCAmJgYbGxsArTzs5MmTqVevHunTp2fJkiV07NgRX19f5s+fT/78+Tl48KC2n9jYWFavXk21atWIiIj4Amf19StRogTu7u48fPgQFxcXfvjhB5YtWwbE9wq6u7uzaNEi4M88g0KFChEREUH9+vWxtrYG4if7hPieFZm48+9JmzYtq1evxsLCgsqVK9OuXTt+/fVXoqOjAfj555/p168fLi4uWq9J5cqVuXHjBuHh4eTJkwdAW9/IyAillHxHiRRPgg8hxH+S4Qe4V69eXLx4kZkzZ1KqVCmUUiilyJgxIxYWFgkmLwwICKBevXo0btwYgMuXL7N06VJKlSrFzz//DJBo6ISBkhGon6Rq1aoUKFCADRs2APDo0SPGjRvH3bt3GTJkCACHDx+mU6dOrFy5knv37tG8eXN+//13goKCgPgAZ9SoUUyZMkWbPwTkXnyIXq8nX758HD16lFWrVlGjRg0aNWoEwJ49eyhatCglS5YkLi5Oqya3efNmSpQoQaNGjbCwsCAwMJDJkyfToUMHrl+/jpGRkcxJ8Tfo9XrSp0/P5s2bOXToEA4ODjg7O5MqVSouXbqETqejUaNGCRL+d+3aRZo0aejYsSPFihUjOjqaPXv20LdvX44ePYpOp5MCASLFk28bIcR/kiFIiIuLQ6fTafkDOp2OfPny8fjxYyIjI7X158yZg5GRER06dNCWVahQgbFjx+Lm5sahQ4eoXbs2L168AP58wH316pW2X/HxsmbNSteuXRk0aBDOzs64uLiwaNEi/vjjD8qWLQtArVq12LRpE8uWLUMpxYABAxg9ejSZMmXC29ubNWvWEBMTQ4UKFQA4fvw4sbGxci8+wMjISAvMq1SpQo8ePciUKRMA+fLlIzIyksDAQO3zs2LFCjw9PenRowf29vYAvHnzhtKlS5MmTRqqVKnCzz//TGxsbPKc0Ffs7V6jEiVKMG7cOKpUqQLEfz5iYmIIDAwE4r9fvLy8OHjwIBUqVKB169ZAfA+UsbExxsbGtGjRgmbNmvHixQv5DIiULbnGewkhxKeKjY1VUVFRKjAwUJUqVUrlzZtXjRw5UlWqVEmZmZmpsWPHauueP39ebdmyRd27d08ppdSDBw+Ug4NDgso/SsVXD+rZs6dUAfqbnj9/rn799Ve1YsUKbZI8Q76HUkrNmjVL1a9fX505cybBdvPmzVOWlpbq0KFDKjY2Vj148EA5OTmpbt26qaioqC95Cl+td3OY7ty5o7Jly6Z++OEHdf78eTV9+nRlaWmp2rVrp/z9/ZVSSoWHh6vXr19r25w4cULZ29sn+lysXLlSLVq06POfRArxbr5GVFSUqlu3rqpTp47y8PBQZ86cUQ0aNFAFChRQa9euVUolrjzm7++vSpcuraZOnZpg+atXr9SMGTM+7wkI8QVJ8CGE+Gq8ePFCLV68WPt7+/btasqUKapq1aqqRo0aytvbWymlVJ8+fVSGDBlUuXLlVK5cuVT79u1VVFSUypMnj7b9kSNHVIkSJZSJiYk6f/68Uiq+dKlS8UnQr169+sJn93XR6/VJBmyxsbFq8uTJ2mzbISEhqkuXLsrBwUE9ffpUKaXU5cuXlaurq2rRooVSSik3NzeVI0cO5ejoqE6fPq2U+vNe+Pr6qv3793+BM/p6vXjxQgvurl27pipWrKhGjBihsmfPrhwdHdXhw4eVUkrduHFDVahQQbm4uCgnJyfl7u6ulFLK2dlZzZw5UykVf71Xr16typQpoxo1aqSUkvK8n8rX11e9evVKPXnyRFWrVk3VqVNHOTs7KzMzM/X9999r6/Xr10+1aNFC1a1bV/3vf/9TSik1d+5cVaFCBe3758qVK2rChAlKp9Mpf39/FRcXJ4UzxFdPhl0JIb4aAQEBTJkyhZ49exIQEECNGjXw9fUFoEWLFtjZ2fHo0SPc3NyYM2cO69atY8OGDbx58wYzMzNevnxJ7dq1AciTJw83btzA1NSUHTt2AGBqagrAoUOHqFu3Lt7e3slynl+D941NDw8P5/bt20yZMoUTJ06QPn16ypcvj7GxMTExMURERLB79258fHz46aefALCzs9OGpYwcORI/Pz/tXpw7d46xY8dKQvoHPH36lJkzZ7J69WqKFy/OmTNnaNWqFTExMbRs2ZLSpUsTERFBz549iYmJoXfv3ri4uNChQwdcXFzw9PTUCgY8evSIDh06cOvWLS13xzCEy93dnUaNGmnJ6iIxpRRLly5l8uTJ2NjYcPToUdauXUvevHmpVKmSNix0+vTpLFu2jNy5c1O5cmV++eUXnJyc2Lp1K2nTpiVt2rSEh4dTs2ZNxowZw8CBA8mRIwdGRkbodDqePn1K//79uXXrVjKfsRB/Q3JHP0II8Snu3LmjKleurLJkyaLs7e1VmjRp1NKlS7VSr5cuXVK5c+dWe/fu1baJi4tT6dKlU0OHDlVhYWFKKaWWLFmiLCws1KJFi1TBggVViRIlEgwX8vDw+KLnldIMGTJEmZubq5o1a6qMGTOqTp06qbCwMHXs2DFVrlw51b9/f6VU/JCSHj16qJo1a6qjR4+qZs2aqXr16iUYGmToBRHvN3XqVJU2bVpVr1491aJFC5U2bVrl6uqqHjx4oJRSytvbW5mammq9IEopdffuXZU3b16VL18+bdmlS5dUzpw5Vbly5ZROp1O9e/fWWtpfvXql3NzclK+v75c9ua/M5s2bVdasWVXVqlXVuHHjVIUKFVT+/PkTlJsuX768at26tfZ3dHS0ateunTIzM1Pbt2/Xljdt2lTZ2toqExMTVb9+/QTfUbNnz1YrVqz4IuckxL9Jgg8hxFfp5MmT6tSpU9rDlVLxQ4HCwsJU3bp1VYECBdS2bdvUrFmzVK1atVTWrFnV1atXlVLxw1QyZ86shg8frm174cIFFRsbq2bNmpVgLoT3zXchkvb2EB1/f3/l5uam9u/fr968eaNevXql+vTpo0qWLKkCAwOVUkotX75cVahQQU2ePFnbLiQkREVHR6s6deqoEydOaMtlHoQPe/bsmRowYID64Ycf1KRJkxIEbU+ePFEuLi6qTZs2Kjg4WHl7e6vFixerVKlSqWXLliml4ufP6d69uxaM3L59Ww0fPly9efNGy50SHyc6OloNHDhQubq6qjZt2qjjx49ruUyxsbFq/PjxqmjRourJkycqIiJCPXr0SJUtW1a5urqqgIAApZRSBw8eVDqdTp08eVL5+/urtm3bql27diUIzA1kKJb4mkjwIYRIkUaPHq06duyoevTooXQ6nZo9e7YKDw9XSinVv39/lStXLvXkyROl1+u1H+4VK1YoOzs79fvvvyulZKz73/W+fJAlS5YoOzs7NWfOHKVU/ESSLVq0UPXr11dPnjxRSv0Z7C1atEjpdDp148YNpZT0RH2Ktx9E3w7YLl++rBwdHVWZMmVUs2bNlE6nU87Ozto227ZtUxkyZFDr1q1LsL8XL16odOnSqenTp7/33xFJi4yMTHJ5YGCgql69usqUKZMaOHCgypgxo8qYMaM6cOCAtk7JkiVV8+bNE/X89e3bVzVu3DjBBJMSmIuviQQfQogU5e2HXr1erxYtWqQKFy6sPbw+evRIpUqVSq1cuVIp9eePtq+vr2ratKlq2rSpev78/9q777io6z8O4K9jyjwVZAriluEEU1BzgntmggNXrspJpaJmpBVaudLQ9JczNTM1NCeYuQAHiBpuE0HlBEQ5RJn3/f1BnJ5s7jiQez17fB/G9z7fz/fz/XwY977PShIePXoktGvXToiKilL/Q1QT+W9O8//9+++/hUGDBslf37Bhg9C2bVvhl19+EQThVdvl90wtWLBAEARBOHjwoGBmZibExMSos/jVyuuBwvnz54W9e/cKIpFIiIiIEARBEOLi4oQ+ffoIXbp0kafLb4+pU6cKbdu2FcLDw4WUlBThm2++EVJTU9X7ANXI620RFhYm3L59WxCJRMK0adOEpKQkQRAEYd26dYKhoaFw9epVQRBe/Z46evSo0LVrV+HDDz8UBEEQ/vzzT+H27dtqfgIi5RS+hS0R0Vvq9UnQIpEIEydOxLBhw2BiYgIA2LRpEywtLTFgwAAIgiDfXG3nzp14+PAhpk2bBnNzc1y8eBHnz5+HjY1NgXvIZDJuylYK+XsV5P/buXNndO7cWf56Wloa0tPTMXLkSIXrFi9eDENDQ0ydOhVA3maEdnZ2aip19SQSiZCbmwttbW20bdsWbdu2xa+//op27doBeLU7+sWLFwEAGRkZqFGjBqKiorBv3z7MmjULLVu2xJMnT/Djjz/C3t6+QLvx56J0Xm8Ld3d3AMD//vc/uLq6yvdsWbhwIT766CO4uLjIf0+lp6fjt99+A5C3+SoArF69GiKRCIcPH1a4hyAI3CuEqiz+liCiakckEkEkEkEmk0EQBIjFYvmbombNmkFfX1++AzEAXLhwAcePH4eTk5P8DdXx48fRo0cPeT5A3pur1NRUvsEqp/x6zGdlZYUnT57ghx9+AJAXOMbExODHH39EQEAALC0tAQDh4eF4+fIlnJyc5Nfm5OTg7Nmz6it8NZC/alV+cD5s2DD5a48ePULDhg3h7OwMAPLVrz7//HO0aNECXl5eMDAwQHx8PJKTk9GnTx8AQHZ2tjwP/lyUXn5b5Bs/fjxatmwJALh79y7Mzc3h5uamkOb3339HTEwMevfujRYtWuDFixe4d+8eBg0aBADIysqSp2XgQVUZf1MQUbWVvyzl695//30MHjwYvXv3xoYNGwAAv/32G16+fIlx48bJ06WnpyMjIwO1a9eWv6maP38+evTogb/++kshzzffVFPh3nxzOnz4cPz0009YvHgx9u3bBwCYN28e3N3d4e3tLU937tw59OvXT/71lStXMHXqVHTq1Em+HHJ+G+Tm5hZY/pcUFfbG9N1334WFhQUcHBxw5swZAHlvdq9evYrhw4ejefPmAICjR4+iY8eO8jx0dXWRlJSEESNGID4+Xn0PUY3VrVsX7777LiZOnIht27ZBJBLh/v37CA4OhqWlJcaPHw8AuHPnDszNzSEWiwEAenp6AICVK1fi/PnzlVZ+opIw+CAijZH/pvTbb7/F/fv30atXL5w4cQKHDh1C586d0alTJ3naP//8E23btoWOjg7+/fdfLFq0CMuXL8eECRPg4uKikK+WlhZkMhmDkDLIb4uBAwciKSkJffr0wdGjR3HgwAEsWrQIBgYGAPKGZslkMvkbrIcPH2L48OGIi4vDvn370KBBAwB5bZCdnQ1tbW35sBYqPXt7e5w9exbz58+XB3SLFi1Cz5490a1bN3m6rKws6OnpwcjICABw4MABDBgwAJcuXYJEIimQb05OjnoeoBrR19fH2rVr8eOPP2Lv3r0QBAE7duxAYmIifHx8YGZmBiDvez4qKgqurq4AgGfPnmH+/Pn48ssvsXv37gL58meCqgrO+SAijSESiSAIAmQyGaytrQHkvZnq2rUrxowZI0938+ZNGBgYoG3btsjKysKkSZPw8uVLrF69GpMmTYJUKkVISAjCw8Px6NEjjBo1Ch07dqysx3or5X9ynpOTAx0dHejr6+Pdd9/F5s2bFeaFyGQyHD9+HMuWLUNoaCi++OIL1KxZExs2bICtrS2kUin8/Pzw9OlTPHz4EIMGDcLcuXMLDGuh4uXPQcifZ3PmzBmkpaWhX79+sLW1lacLDg6Gj48PdHV18dtvv+Hzzz9HmzZtsG7dOojFYkilUty/fx8SiQSenp7Q0eHbjLLKbwtfX1/4+voiLS0NJ06cgIWFBXx8fOTp9u7dCxcXFzRu3Bj379/HokWLcPDgQWzduhX9+/cHkLcBZUpKCho3bixvC87NocrG7z4i0ij5O3Pna9iwIdasWYMmTZrIP43P/xQ9Ojoa48ePx/3797Fs2TJMmjQJAPDBBx/g+++/x5UrVyASidCrVy/MnDlTYcw1lU7+GyJBEGBgYIDRo0crvH7ixAk4Ojri8OHD8PX1RfPmzbFnzx7Y2toiKioK3t7euHPnDoYPH44PP/wQW7ZsQd++fSGVSivjcd5abwZrHTt2RGRkJDw9PeXnrl27BhMTEzg6OmLNmjWYNGkShg0bhhUrVkAsFuPIkSMYMGAAhgwZgjlz5sDOzg5//PGHmp/k7ZffFvk9qSYmJvj999+xdOlSAHnBSXZ2NrKystC4cWNcv34dw4YNw/3797Fy5Ur0798fjx8/RmBgIFxdXTF58mTUrVsXq1evBsC5OVQFVMoaW0REVURh6+MfOnRIEIlEQps2bYT+/fsrLGUZFBQkiEQiYdSoUfJzly5dElq2bClftpRUZ+fOnYJIJBJEIpGwZMkS+Q7Pz549Ez777DPByMhIePfdd+V7HsTHxwtubm5CWFhYJZb67VfYz8W1a9cENzc3wcHBQejataswf/58+WsxMTGCg4ODfCd7QRCEJUuWCK1atZIvF0vl82Zb5H89cOBAwdbWVhg1apTg4uIiSCQS+Wu+vr5C69atheDgYOH58+fCli1bBEdHR2HNmjVqLz/Rmxj+EpFGK+xTQFdXV3To0AE9evTADz/8gEaNGgHIG6L1zTffYNCgQfjnn39Qr1497Ny5E61atYKFhYV8mVJSHR8fHyxbtgyrVq3CnDlzULNmTQDA8+fPERwcjDFjxsDR0RH29vaYNm0a6tati+fPn+P69euVW/C3XGE/FzKZDJGRkUhISMDChQsxf/58+Ws//PADJBIJgoOD4efnh+fPn2POnDkQiUQ4cOCAOote7bzZFlpaWnj58iWuX7+OR48ewc7ODr/++issLS2hpaWFv/76C7/88gvu3r2LLVu2IC0tDaNHj8awYcNw8ODBSnoKolcYfBARvcHCwgKnT5/G0qVL4eDgID9/9+5d1KpVC5MmTcKlS5fw6aefws/PD+3atcM///yjsOwoKU/4bxjcrFmzMG3aNACvJs2mpqYiNjYWCxYswLp163D48GFcunQJenp6ePz4Mezt7Sut3NWVs7MzUlNTceHCBXTp0kW+HG9mZiZ27NiBtWvX4syZM/j3339Rv359fPPNN2jatCkMDQ0rueTVj4GBAW7evIng4GB888038iWSAWDr1q3o06cPDh8+DB0dHTRp0gT+/v5wcnKCVCotdGEAInVi8EFE9IaiVoWpXbs24uPjERsbCwCYNm0aLl++jLZt20JXV1c+J4RUI3+BgNdpa2tDJpPB3NwcjRs3xp49ewDkzVE4c+YMtm7dig8++EAhaCTVyMnJgYmJiXzZ3fxFAx4/fgxbW1tkZ2fD2dkZx48fx5o1a7Bjxw7s2bMH+vr6lVnsail/FbH8ieXAq2C9Zs2aePHiBTw8PLBr1y7s3bsXJ0+ehI+PD3R0dGBlZVUpZSbKJxLe/M1ORERFmj9/Pv755x+sXbtWYffzlJQU1K5dmyvJqJG/vz9CQ0OxcuVKdOjQQb4MbHZ2NnR1dSu7eBpl3Lhx0NXVxfr16+XnXrx4gWPHjmHAgAH8mVCjzZs348cff8S+fftQt25dAHlD5rZt24aOHTuiYcOG3AGdKhWDDyKiMoiPj4evry+uX7+OqVOnokGDBujUqROH+VSSWbNmYf369ejZsyeaN2+ODz74gG2hRvlvYo8fPw5fX1+0a9cO8+fPh4mJCZo2bVrZxdNIjx49wtChQ6GtrY1vv/0WDRs2hFgsZg8UVRn8KIKIqJQEQYCdnR3+/vtv/Pjjjzh//jwuXrzIHbUrQf4ypCtWrMCNGzfg5OSEBg0awMTEpJJLplnyPz3v3r07oqKiIBKJMHz4cPzwww8IDQ2t5NJpJhsbG/z9999o1qwZhgwZgunTp2PlypWVXSwiOfZ8EBGVQf4GYPmePHki33GY1Ev4b8PI/PZ4s21IfV6v+xs3bkAqlcLZ2Vm+Ezqpz+ttERsbi3PnzsHV1RWNGjXicCuqEhh8EBGVA9/oVh2cZ1M1yGQyiEQivrmtAvJ7BvlzQVURgw8iIiKiaog9HVQVMSQmIiIiqoYYeFBVxOCDiIiIiIjUgsEHERERERGpBYMPIiIiIiJSCwYfRERERESkFgw+iIjKITMzEwEBAcjMzKzsomg8tkXVwvaoOtgWVBVxqV0ionKQSqUQi8VITU2FqalpZRdHo7Etqha2R9XBtqCqiD0fRERERESkFgw+iIiIiIhILXQquwBEpHlkMhkePXoEExOTt3YTLKlUqvAvVR62RdXC9qg6qkNbCIKAtLQ02NjYQEur4j4zz8jIQFZWlkry0tPTQ40aNVSSV3XEOR9EpHYPHjyAnZ1dZReDiIjeEvHx8ahbt26F5J2RkQEDM1PgRbZK8rOyssK9e/cYgBSBPR9EpHYmJiYAgLi4X2FqaljJpSEioqpKKn0Be3sf+d+NipCVlZUXeIxuDehpK5lZLiRbLyErK4vBRxEYfBCR2uUPtTI1NYSpqVEll4aIiKo6tQzR1dOGSE+5t8YcTlQyTjgnIiIiIo0n0hKp5CiroKAg1K9fHzVq1ICrqytOnz5dZNozZ86gQ4cOMDMzg4GBAZo1a4YVK1Yo89hqx54PIiIiItJ4IlH5goc3MilT78euXbswc+ZMBAUFoUOHDvjpp5/Qu3dvXLt2Dfb29gXSGxkZYerUqWjRogWMjIxw5swZTJ48GUZGRpg0aZJyZVcTTjgnIrXL3/jq2bP9HHZFRERFkkrTUbPmgArdKDH/b5L2h+0g0ldy2FVmDnLXnit1edu1a4c2bdpg7dq18nOOjo4YNGgQAgMDS3XPIUOGwMjICNu2bSt3udWJw66IiIiIiFRIKpUqHJmZmQXSZGVlITIyEl5eXgrnvby8EBYWVqr7XLp0CWFhYejcubNKyq0ODD6IiIiISOOJRCKVHABgZ2cHsVgsPwrrxUhOTkZubi4sLS0VzltaWkIikRRb1rp160JfXx9ubm74+OOPMWHCBNVVRAXjnA8iIiIi0njlnTCu4L/r4+PjFYZd6evrF33fN1byEgShxNW9Tp8+jefPnyMiIgJz585Fo0aNMHz4cCUKrj4MPoiIiIiIVMjU1LTEOR/m5ubQ1tYu0MuRmJhYoDfkTfXr1wcANG/eHI8fP0ZAQMBbE3xw2BURERERaTx1L7Wrp6cHV1dXhISEKJwPCQmBh4dHqfMRBKHQOSVVFXs+iIiIiEjjqXLYVWn5+fnB19cXbm5ucHd3x/r16xEXF4cpU6YAAPz9/fHw4UNs3boVAPDjjz/C3t4ezZo1A5C378f333+PadOmKVduNWLwQURERERUCby9vfHkyRMsWrQICQkJcHFxwaFDh1CvXj0AQEJCAuLi4uTpZTIZ/P39ce/ePejo6KBhw4ZYsmQJJk+eXFmPUGbc54OI1I77fBARUWmoc5+PGn4dVbLPR8byMxVa3rcdez6IiIiISONVxrArTcQJ50REREREpBbs+SAiIiIijceeD/Vg8EFEREREGo/Bh3ow+CAiIiIijSeCqMSdxUuTCxWPcz6IiIiIiEgt2PNBRERERBqPw67Ug8EHEREREWk8Bh/qwWFXRERERESkFuz5ICIiIiKNx54P9WDwQUREREQaj8GHenDYFRERERERqQV7PoiIiIhI44m0oIKeD9WUpTpj8EFEREREpIJhVwKHXZWI8RkREREREakFez6IiIiISOOpYsK50sO2NACDDyIiIiLSeAw+1IPDrohIIwQFBaNBg5EwMOgFN7cpOH36SrHpT568DDe3KTAw6IWGDUdh3boDBdLs2XMKzs7jUKNGLzg7j8O+fWfKfF9BEBAQsAW2tsNgaNgbXbv6ISYmVqlnrerYFlUH26JqKe9zq6vOMzOzMG3aatSpMxjGxn0xcOACPHiQpMwjVykikUglBxWPwQcRVXu7dp3ArFlBmDdvBKKifkLHjs3Rp48/4uIeF5r+3r0E9O07Dx07NkdU1E/w9x+OGTPWYM+eU/I04eEx8PFZjFGjPBEdvR6jRnnC23sRzp27Xqb7fvvtr1ix4nesXj0N588HwcqqFry8ZiMt7UXFVUglYltUHWyLqqc8z63OOp85Mwh//HEGO3cuwOnTK/H8+Uv07z8fubm5FVMhVC2JBEEQKrsQRKRZpFIpxGIxnj3bD1NTowq/X/v2H6N168ZYu3am/JyT0zgMHNgBgYETCqSfM2c9DhwIx7Vrm+TnpkxZgStX7iIsbA0AwMdnMaTSdBw6tESepnfvuahVyxg7diwo1X0FQYCt7TDMmDEEc+YMB5D3yaKV1VAsWTIRkyf3V2U1VAlsi6qDbVG1lPe51VXnqanPYWHxHrZunQtv764AgEePkmFvPxwHD36Dnj3bVkS1QCpNR82aA5CamgpTU9MKukfe36Q63/aGloGuUnnJXmYjafbhCi3v2449H0RUrWVlZSMy8ha8vNwUznt6uiI8PKbQayIirsHT01XhXM+ebXHx4i1kZ+cAAMLDr8HTUzFPLy83hIXFlPq+9+4lQCJJUUijr6+Hzp1bFlm2txnboupgW1Q95X1uddV5ZORtZGfnKKSxsTGHi4uD/F5vu/w5H8oeVDwGH0RUrSUnpyI3VwZLy1oK5y0ta0EiSSn0GokkpdD0OTm5SE5OLTaNRPK01PfNT/tmGguLV/lUJ2yLqoNtUfWU97nVVecSSQr09HRRq5ZJkfkQlQaDDyKqcJmZmZBKpQqHur05B1AQUOzEwDdfyx+h+vr5wtK8mWVp7lt4PtX30zO2RdXBtqg827eHwsSkr/zI7z0qz3NXZp1Xp3Zhz4d6MPggogoXGBgIsVgsP+zs7NR2b3NzMbS1tQp8cpiY+LTAp3z5rKxqF/gkLzHxGXR0tGFmZlpsmvw8S3NfK6u8f9/MJynpGSwta5bhKd8ObIuqg21R+QYM8MClS+vlh7m5GEDZn1tddW5lVRtZWdl4+jStyHu97bS0VHNQ8VhFRFTh/P39kZqaKj/i4+PVdm89PV24ujZBSEikwvnQ0Ei4uzsXek379k4IDVVMf+zYRbi5NYGubt72SO7uBdOEhFyEh4dzqe9bv741rKxqK6TJysrGyZOXiyzb24xtUXWwLSqfiYkhGjWylR9OTvXK9dzqqnNX18bQ1dVRSJOQ8AT//BMrvxdRaXCTQSKqcPr6+tDX16+0+8+aNRSjRy+Bm1sTuLs7Yf36g4iLS8SUKXmrx/j7/w+PHiVjy5a5AIApU/rjxx+D4ecXhIkT+yI8/Bo2bjyMHTvmy/OcPn0IOneeiaVLd2LgwA4IDj6L0NAonD69qtT3FYlEmDFjCAIDd6Bx47po3NgWgYE7YGhYAyNGdFdjDakP26LqYFtULaV97jFjlsDGxly+Ipm66lwsNsb48b3x6afrYGZmitq1TfDZZz+hefP66NGjjRprquJoi0TQUnIIWXUZglaRGHwQUbXn7d0VT55IsXjxNiQkpMDFxQEHDwaiXj1LAIBE8gRxcYny9PXrW+PgwW/g5xeEoKD9sLExw6pVU/Hee+/K03h4OGPnzgX4/PNNWLhwMxo2tMGvv36Odu0cS31fAJg92wcvX2bh449X4enTNLRr54ijR5fCxMRQDTWjfmyLqoNtUfWU5rnj4hKh9dq8AnXW+YoVH0FHRxve3ovw8mUWundvjU2bvoK2tnYF14x6aGuJFOq2PDjno2Tc54OI1E7d+3wQEdHbSZ37fNRb3V8l+3zcn3aA+3wUgz0fRERERKTxOOxKPRh8EBEREZHG09ICtJVdiolLOZWIwQcRERERaTxtkQjayvZcsOejRIzPiKhEsbGxEIlEpTpcXFwqu7hERERURbHng4hKpKuri6ZNm5YqbYMGDSq4NERERKrHng/1YPBBRCWytbXFjRs3KrsYREREFUZbSwRtZZfK5VK7JeKwKyIiIiIiUgv2fBARERGRxtMGoM2OiwrH4IOIiIiINB6HXakHh10REREREZFasOeDiIiIiDSelgpWuxK42lWJGHwQERERkcZTxbArgcOuSsRhV0REREREpBbs+SAiIiIijactUn61K4EdHyVi8EFEREREGo/DrtSDwQcRERERaTxtTjhXC875ICIiIiIitWDPBxERERFpvLw5H8r2fKioMNUYgw8iIiIi0nhaWoC2kmOCZBxTVCJWERERERERqQV7PoiIiIhI46liwrmME85LxJ4PIiIiItJ4+UvtKnuUVVBQEOrXr48aNWrA1dUVp0+fLjLt3r174enpiTp16sDU1BTu7u44evSoMo+tdgw+iIiIiIgqwa5duzBz5kzMnz8fly5dQqdOndC7d2/ExcUVmv7UqVPw9PTEoUOHEBkZia5du6J///64dOmSmktefiJBEITKLgQRaRapVAqxWIxnz/bD1NSosotDRERVlFSajpo1ByA1NRWmpqYVdI+8v0kDfxsOXUM9pfLKfpGF4GE7ER8fr1BefX196OvrF0jfrl07tGnTBmvXrpWfc3R0xKBBgxAYGFiqezo7O8Pb2xsLFy5Uquzqwp4PIiIiItJ42lqqOQDAzs4OYrFYfhQWSGRlZSEyMhJeXl4K5728vBAWFlaqMstkMqSlpaF27dpKP7+6cMI5EREREZEKFdbz8abk5GTk5ubC0tJS4bylpSUkEkmp7rNs2TKkp6dj2LBhyhVYjRh8EBEREZHG04YKVrtC3vWmpqalHiYmeuOegiAUOFeYnTt3IiAgAMHBwbCwsCh7YSsJgw8iIiIi0nha5Vyt6nW5Zbje3Nwc2traBXo5EhMTC/SGvGnXrl344IMPsHv3bvTo0aNcZa0snPNBRERERBovf58PZY/S0tPTg6urK0JCQhTOh4SEwMPDo8jrdu7cibFjx2LHjh3o27dvuZ+3srDng4iIiIioEvj5+cHX1xdubm5wd3fH+vXrERcXhylTpgAA/P398fDhQ2zduhVAXuAxevRorFq1Cu3bt5f3mhgYGEAsFlfac5QFgw8iIiIi0nivr1alTB5l4e3tjSdPnmDRokVISEiAi4sLDh06hHr16gEAEhISFPb8+Omnn5CTk4OPP/4YH3/8sfz8mDFjsHnzZuUKryYMPoio0qy+vA81jJVbU52UZ+N6orKLQP/xOdStsotAr3nQsWVlF0HjpT1/qbZ7lXXYVFF5lNVHH32Ejz76qNDX3gwo/v7773KUqmrhnA8iIiIiIlIL9nwQERERkcbTFuUdyuZBxWPwQUREREQaT0skgpaSw66UvV4TcNgVERERERGpBXs+iIiIiEjjaalg2JWSexRqBAYfRERERKTxtETKBw8MPkrGYVdERERERKQW7PkgIiIiIo3H1a7Ug8EHEREREWk8LS0RtJQcN6Xs9ZqAwQcRERERaTz2fKgH53wQEREREZFasOeDiIiIiDQeV7tSDwYfRERERKTxOOxKPTjsioiIiIiI1II9H0RERESk8bREImiJlFztSsnrNQGDDyIiIiLSeFpQftgUhxSVjHVERERERERqwZ4PIiIiItJ4XO1KPRh8EBEREZHG0xaJoK3knA1lr9cEHHZFRERERERqwZ4PIiIiItJ4HHalHgw+iIiIiEjjcZNB9WDwQUREREQaT0sr71A2Dyoeq4iIiIiIiNSCPR9EREREpPG42pV6MPggIiIiIo0nUsGEc8YeJeOwKyIiIiIiUgv2fBARERGRxuNqV+rB4IOIiIiINB73+VAPDrsiIiIiIiK1YM8HEREREWk8rnalHgw+iEgjhP0Wg7+3XUZa8gtYNqiFAZ96oEFr60LTSpPScWBFBB7eSEJyXCo6+Lhg4KcdFNJc2H8Tv335d4Frvwn7ALr6eb9a/416hL+3XsbD68mQJr/AmO+94NK1vkL6q3/9i4g91/HgejJepGZg5o73YNvUXDUPXYU1/2IqGk7yhl4tUzw5dxkXP16E1Gt3ikxfd7AnnOdNgUkje2jp6iDt9n1cX7YJsb8Ey9PU6eQGp88+QC1XFxjaWODUoI/wIPh4gfva+/SFkZ0VZFnZSImMweX5K/Dk/BUAgF4tMZp/OQ3WXh1haGeFzOSnePBHKK58vgrZ0ucVUxmVSBAELNp+ERuOXMfT55lo19QCqz/qBOd6tYu8JuZ+Cr7YdgFRd5JwP/E5lk/ywIxBLRTSnLr6CN/vuYyoO0lISHmBPQt6YpCH4vf+l79cwK5TdxGf9Bx6ulpwbVQHi0e/g3bNLOVppqw+ieOXHuJRSjqMa+jC3ckKS8a1QzO7WqqtiCpg64aT+OmHECRJUtHY0RpfLHkf73g0LjJ9xJlbWDzvd9y+ngALazGmzPDCqA/eLTTt/t8vYNr4jfDq2xIbdk5ReE3y6BkCF+7D3yExyMjIQoNGlvh2zSg0b10PAFDP9MNC8/RfPBhTZniV82mrJg67Ug8OuyKiai/62B3sXxaG7uNbY+aO91C/tRV+nnYITxPSCk2fky2Dca0a6Da+DaybmBWZbw0jPXx+1FfhyA88ACDrZQ5smphh0JwOReaR9TIHDi2t0GfaO+V/wLeM4+yJaOY3DhenLsLRtkORIUlG15BN0DE2KvKarJRUxHy9FsfcvXGoxQD8u2kv2m/6BtZeHeVpdIwM8fTyTVycuqjIfKS3YnFx6iIcbN4fIR1H4HnsQ3Q9thH65nlvZg1sLGBgY4FLny7Foeb9ETHWH9a9OqHdz1+rrgKqkO9+j8aKfVfww4cdcW7le7CsZYie8/9E2ousIq95kZmDBtam+GZce1jVMiw0TXpGDlrWN8MPH3Ys9HUAaGxbEz982BGXg4bh1HeDUM/CBL0WHERS6kt5mjaN6uDnWV0Q85M3Dn/VF4IgoNeCg8jNlZX7mauiA3suYtHc3Zj6aS8cPDMP77g3wpj3fsTD+JRC08fFJmPs0B/xjnsjHDwzDx9/0gsBs3/DoeCoAmkfxD3B1wv24h2PRgVeS32ajve8voOurja27JmK0PNfYP7X78FU/KpdL9xeonB8F+QLkUiEPgNaq64CSKOw54NIQ4le6xo2NjZG06ZNMW/ePAwZMqQSS1UxTv1yFW0HNkO7wY4AgIGfdsCt8AcI//0a+kxrVyB9bRsTDPwsL2C4sP9G0RmLAFPzwt98AUCzDvZo1sG+2LK59m0CAEh5VHggVB01mzka/3y9Dg/2hQAAwsfMwZDHYXAY0Q931u8q9JrEk+cVvr75w1bUHzMIdTq6IuHYGQBAwpFTSDhyqth739/5p8LXUX6BaDThfdRs0RSP/4pAasxtnBk6Xf7683/jcXn+Snj88h1E2toQcnPL/LxVlSAIWPXHVczzaYMhHRoAADZ/0g3WI7Zgx993MLmPU6HXtW1igbZNLAAA8zZFFJqmd1t79G5b/Pf+iK6Kn+ovm+SBjcdu4Mq9J+jeqi4AYFLvV2VwsAQWj34HrT/ejdjENDS0FpfuQd8C/1tzHN6jPTB8TF6w9sXSYTh5/Dp++fkU5gQMKpB++8bTsKlbG18sHQYAaNzUGlcvxWH9D6HoM7CNPF1urgwzJmzCrHn9cCHsDqSvBXYAsHblMVjb1sL3a0fLz9nVU/zAxcJSsZ5DDl6B+7tNYF+/jlLPXBVxtSv1YM8HkQbbtGkTEhIScOHCBbRs2RLvv/8+wsPDK7tYKpWTnYuHN5LQpH1dhfNN2tfF/SuPlco762U2vu67HV/1/gUbZxzGwxvJSuWnCYzq14WBtQUk/wUMACDLykbiyQsw9yj9J6mW3drDtGl9JJ66UO6yaOnqotEkb2Q9k+LZ5ZtFptMTGyNb+rxaBR4AcE+SBsnTF/BsYyc/p6+rjXeb2yD8ukStZcnKzsWGw9cgNtJDy/qF9zamZ2Rjc8gN1LcygZ25sVrLV5GysnJwNToOnbopBnvvdnNE5Ll/C70m6vy/eLebo2L67k64euk+srNffZ+uWnIQZubG8BldeO9ryKEraNG6Hj4cvQFtGnyG3h2/xs7NZwpNCwBJiVL8dfQqvH09Svt4bxUtkUglBxWPwQeRBqtZsyasrKzQrFkzrFu3DjVq1MD+/fsBAFevXkW3bt1gYGAAMzMzTJo0Cc+fvxrz/vfff+Odd96BkZERatasiQ4dOuD+/fuV9ShFSn+WAVmuABMzA4XzxmYGSHvyotz5WtSviWEBXTBuRS+M+KY7dPS18eP4YCTFpSpb5GrNwCrv09KMx08Uzmc8ToaBVfFzXXRNjfF+WhR8sv5Bl4PrcXHaV5CEhpW5DDZ9u+D9tCh4Z1xBs1lj8ZfneGQ+eVpoWr3aNeHy+Ue481PhPTJvM8nTvO9/y5qKPxuWNQ3kr1W0P8/dh+mQ/8Fw0Aas/OMKjn7dD+ZixfKs/fMfmA75H0yH/IyjkfE4+nU/6Olqq6V86vD0yXPk5spgbmGicN7cwgRJjwv/fZL0WFpo+pwcGVKe5P2evhBxF7u2hWHJ6lFF3js+Nhm//HwK9RvWwdZ90zFq/Lv4YvZv2LOj8B6tPTsiYGRcA72q6ZArLdGr3o/yHpzzUTIGH0QEANDV1YWOjg6ys7Px4sUL9OrVC7Vq1cKFCxewe/duhIaGYurUqQCAnJwcDBo0CJ07d8aVK1cQHh6OSZMmKQzlel1mZiakUqnCoXZvFk0o7GTp1WtuCdc+TWDTxAwNWltj1BJPmNcT4+yv/yhTymrHYUR/vJ8WJT+0dPNG+wqCoJhQJMKbp96UnZaOw60G4Ujbobg8fwXaLJ8Li85lnyvz+MQ5HG41CMc8fJBw5DQ6/rYS+nUKTrDWMTFCl4M/IfXaXVz9ck2Z71PVbD9x67838XlH9n/zJt78sRUEocifZVXr2tIGUWvex5llg9HT1R4+gSFIfKY4NGhE18aIXD0UJ5YOQCMbMXwCQ5CRlaOW8qmT6I3fR4KAYtvhzdfyf35EIuB5WgZmTtyEJT+MRG2zonuJZDIBzi3tMfuLQXBpaYeR4zth+JgO2PZz4cMXf9sWhkHD3kGNGrqlfCqigjjng4iQmZmJ7777DlKpFN27d8f27dvx8uVLbN26FUZGeZOA16xZg/79+2Pp0qXQ1dVFamoq+vXrh4YNGwIAHB0di8w/MDAQX375pVqe5U1GNWtAS1uEtGTFNzTPU14W6A1RhpaWCHZOdZAcz56P1z3Y/xeSz12Wf62trwcAMLAyR4YkSX6+hoUZMh6XMGxNEPD8bhwA4NnlGzB1bAhn/0kF5oOUJPfFSzy/G4fnd+Pw5Nxl9L91FA0/GIprS9bL0+gYG6Hrkf8h5/kLnBr8MYSct//N7oB2DmjX9NVKUpn/Dc+RPH0J69qvJvsnpmYU6A2pKEY1dNHIRoxGNmK0b2aJphN2YOPR65jr/WregthIH2IjfTS2rYn2zSxhNmwT9oXdw/AuRa8E9TapZWYMbW0tJCUqfijzJCkN5hamhV5Tx9IUSY8LptfR0UKt2sa4df0RHtx/gg+818pfl8nyopMGtT7GicgA1GtQBxZWYjRuZqWQT6OmVji8/1KBe54Pu427tx9jzeYJ5XrOt4Eqhk1x2FXJ2PNBpMGGDx8OY2NjGBoaYvny5fj+++/Ru3dvXL9+HS1btpQHHgDQoUMHyGQy3Lx5E7Vr18bYsWPRs2dP9O/fH6tWrUJCQkKR9/H390dqaqr8iI+PV8fjAQB0dLVh26wObp97oHD+1rkHqNfCsoiryk4QBDy69aTYCeiaKOd5uvyN/vO7cUi9dgcvExJh5flqDLqWri4sOrdFcljBNzzFEYlE0PovmFGKSCQPioC8Ho9ux36GLCsbJwd8CFlm0Ss/vU1MDPXkb/Qb2YjhZF8LVrUMERr16ucxKzsXp64+grujVTE5VRxBeBUUFZkGJad5m+jp6aB5K3uc/uu6wvnTJ67DtV2DQq9p804DnD7xRvq/rqF563rQ1dVGwyZWOBaxAIfPzpMfnn1awP3dJjh8dh6s6+at7ubargH+va049+3enUTY2hWcd7Nraxiat7aHU/O6BV6rLjjnQz3Y80GkwVasWIEePXrA1NQUFhYW8vPFDbvIP79p0yZMnz4dR44cwa5du7BgwQKEhISgffv2Ba7R19eHvr5+xTxEKbw7qjl+/fwE6jrVQb0Wlji39zqeSZ7DfWjeBM9Dq88hNSkdwxd1k1/z8Gbep/BZL7KR/jQDD28mQ0dXG5YN8v5oH1t/EfVcLGFuL0ZGehbO/voPHt18gsFzXi0tmvkiW6EnJOVRGh7eTIahqT5qWeeN136RmoGnkueQJuWNsU+6/wwAYGJmWG0DmRsrt8J53mSk3Y5F2u37cJ43GTkvMhC749VKVO5bluLFw8e4PG85AMBp7iSkXPwHaXfjoK2nB5s+76L+6IG48GGA/BodI0MYN3q1wpJR/bqo2bIZslJS8SI+AdqGBnCZPwUP9v+FlwlJ0DericYfjYBhXSvE7T6Sl4exEbod2whtQwOEjfoMuqbG0DXNG7aSmZQCQVZ9lngViUSYMag5An+7hEa2NdHYRozAXVEw1NfBiC6vlmUd8/1fsDUzwjfj8laGy8rOxbW4vDkyWTkyPHySjui7yTA2yOvFAIDnL7Nx59Gr7/3Yx1JE301GbRN92FuYID0jG9/8GoX+7R1gXcsQT9IysPbPGDxITsfQTnm9qf8mSPHbqTvwbGOHOuIaePgkHd/ujoaBnjb6tK2nrmpSiwlTu2PWpM1o0aYe2rxTHzs3ncGjB08xcnwnAMDSgD8gefQMK9aPBQCMHN8JW9b/jUX+v2P42A6IOn8Pu7aG4YeN4wEANWrooqmTrcI9TP+bS/P6+Qkfd8cQz++w5vvD6DfYFdGRsdix+QwCV41UuDZN+hIH/4jCgq/fq6gqIA3C4INIg1lZWaFRo4Jrvzs5OWHLli1IT0+X936cPXsWWlpaaNKkiTxd69at0bp1a/j7+8Pd3R07duwoNPiobK28GuHFs0yEboiENPkFrBrWxgc/9JYHANLkF3gmUdxAbuWIPfL/f3A9GZeO3EEta2PM+zPvj3JGWhZ+//oU0p68QA1jPdg2NceH/+sPe5dXQdyDa0lYN/mA/OsDy/NWEnPt1wQ+X3YFAMScvK+wWeF2/7xN8TwnucJrspsKa6HquP7tBugY6KNt0BfQqyVG8rnLOOE1HjnP0+VpDO2tFd7o6xgZom3QFzCoa4XclxmQ3vgXYaM+Q9xvh+Vparu5oMff2+Rfu66YBwD4d/NeRIzzh5CbC9NmDdBpzGDom9dC5pNnSLlwFSGdRso3OKzt6gzz9q0AAAPuhiqUO9ihG9LvP1R5fVSmz4a2wsvMHEz98bR8k8EjX/WDieGrnqD4pDRovTZO4lFKOlyn/S7/etmey1i25zI6N7fGX0sHAgAu3k5E97mvvvc/2ZD3vT+6RxNs8usGbS0Rbjx4hq1fH0VyagbMTGvArYkFTn43UL7BYQ09bZyOScCq4Kt4+jwTljUN0MnFGmeWDYaFmoaFqUv/99zwNCUdPyw9iESJFE2crLH5949R1z6vByJRkopHD17t+WHvYI7Nv3+MRf6/Y9uGk7CwFiPg22EKy+yWRktXB6zfPgVLv/wDPyw9hLr1zPHFkvcx2FtxLtWBPRchCAIGDG2r/MNWYVpQwbArJeYSagqRUGDWHxFpApFIhH379mHQoEEFXnvx4gUaNWoEDw8PBAQEICkpCRMmTECnTp2wefNm3Lt3D+vXr8eAAQNgY2ODmzdvYvjw4fjqq6/w4YeF74b7OqlUCrFYjMUnx6GGsQqGzZBSbFxPVHYR6D8+h7qVnIjU5kHHlpVdBI2XJn0Jl7p+SE1Nhalp4XNglJX/N2nbpSkwNFGul/5FWiZ8W6+r0PK+7djzQUQFGBoa4ujRo5gxYwbatm0LQ0NDvPfee1i+fLn89Rs3bmDLli148uQJrK2tMXXqVEyePLmSS05ERERVGYMPIg1VUqdn8+bN8ddffxX6mqWlJfbt21cRxSIiIqoUXO1KPRh8EBEREZHGY/ChHlxql6iaiI2NhUgkKtXh4uJS2cUlIiIiDcSeD6JqQldXF02bNi1V2gYNCl87noiISFOx50M9GHwQVRO2tra4ceNGZReDiIjoraT133/K5kHFYw0RERERkcYTqWB386I26C1OUFAQ6tevjxo1asDV1RWnT58uMm1CQgJGjBiBpk2bQktLCzNnzlTiiSsHgw8iIiIiokqwa9cuzJw5E/Pnz8elS5fQqVMn9O7dG3FxcYWmz8zMRJ06dTB//ny0bPl27kPD4IOIiIiINJ6yvR6vzxmRSqUKR2ZmZqH3XL58OT744ANMmDABjo6OWLlyJezs7LB27dpC0zs4OGDVqlUYPXo0xGJxhdVFRWLwQUREREQaT0ukpZIDAOzs7CAWi+VHYGBggftlZWUhMjISXl5eCue9vLwQFhamlmeuDJxwTkRERESkQvHx8TA1NZV/ra+vXyBNcnIycnNzYWlpqXDe0tISEomkwstYWRh8EBEREZHGU+VSu6ampgrBR3HenKQuCEK5Jq5XpsTERFhZWUEmk5WYlsEHEREREWk8de/zYW5uDm1t7QK9HImJiQV6Q94GpQ2YOOeDiIiIiEjN9PT04OrqipCQEIXzISEh8PDwqKRSlZ8gCKVKx54PIiIiItJ4lbHDuZ+fH3x9feHm5gZ3d3esX78ecXFxmDJlCgDA398fDx8+xNatW+XXREdHAwCeP3+OpKQkREdHQ09PD05OTkqVvThbtmwp9vXU1NRS58Xgg4iIiIg03uurVSmTR1l4e3vjyZMnWLRoERISEuDi4oJDhw6hXr16API2FXxzz4/WrVvL/z8yMhI7duxAvXr1EBsbq1TZizNr1qxiXy9trwfA4IOIiIiIqNJ89NFH+Oijjwp9bfPmzQXOleWNvqqkpKQU+3pSUlKp56kw+CAiIiIijacFEbSg5LArJa9/W5UlIOKEcyIiIiLSeKrc4bw6Cg4ORseOHWFmZgYzMzN07NgR+/btk7/O1a6IiIiIiEpJJBIpvbv527Y/R2n99NNP8Pb2houLC1atWoWVK1eiefPm8PHxwdq1a2FgYIAxY8aUKi8OuyIiIiIioiJ9//33WLVqFSZPniw/5+vri1atWuG7777Dhx9+iI0bN5YqL/Z8EBEREZHG47CrosXHx6N79+4Fznfv3h3x8fFlyovBBxERERFpPAYfRatfvz72799f4PyBAwfQoEGDMuXFYVdERERERFSkzz//HGPHjsW5c+fg4eEBkUiEs2fPYu/evdi0aVOZ8mLwQUREREQarzI2GXxbjBgxAnZ2dvjuu++wZs0aCIIAR0dHhIaGonPnzmXKi8EHEREREWk8VQybqq7DrgCgU6dO6NSpk9L5VM/wjIiIiIiIqhz2fBARERGRxuMO50XT1tYu9S7mMpms2NcZfBARERGRxtOCCoZdVdPg4/WdzPfv349jx45hxYoV0NXVLXNeDD6IiIiISONxwnnRBgwYAAAIDg7Gzp07YWtriz/++APbtm0rc17Vs4aIiIiIiEhl9uzZg+HDh2PDhg2IiIhAVFQUZsyYUeZ82PNBRJVmWsvBMDU1quxikGxYZZeAqEqyq+wCEKSydLXdi6tdFW337t0YO3YsNm3aBG9vbwBAaGgoPDw8YGZmhoULF5Y6L/Z8EBEREZHGE4m0VHJUR2PHjsXWrVvlgQcAWFtb4/jx41i7dm2Z8mLPBxERERERFWn79u0YNGhQgfMNGjTA0aNHy5RX9QzPiIiIiIjKQAQtpf8TVdO31oMGDcLVq1cxatQoODk5wcXFBWPGjMHVq1fRokWLMuVVPWuIiIiIiKgMOOyqaJGRkXB3d8fjx4/h5eWFu3fvwtDQEB06dEBYWFiZ8qqeNURERERERCoxf/58jB07FiEhIZgxYwZ0dHSwdu1afP311/D39y9TXgw+iIiIiEjj5a12paXkUT1XuwoPD8fEiRMBQGGn8759++LChQtlyosTzomIiIhI44lUMGejus75EAQBRkYFl8ZPTExEnTp1ypRX9awhIiIiIiJSiYYNG+LatWvyrwVBwJkzZzB16tRCV8EqDoMPIiIiItJ4yg+5yjuqI29vb4SGhsq/zsjIQJcuXdCyZUsEBgaWKS8OuyIiIiIijcdhV0WbO3eu/P/t7e0RExOD+vXrQ09Pr8x5MfggIiIiIo2nip6L6trz8TodHR00bdq0/NersCxERERERFTNNGjQQGGVqzfdu3ev1Hkx+CAiIiIijaeKTQKr6yaDM2fOVPg6OzsbV69excGDB+Hn51emvBh8EBEREZHG0/rvP2XzqI6mT59e6Pl169aVeZ+P6llDRERERERUoby8vLB79+4yXcOeDyIiIiLSeBx2VXa7d+9GrVq1ynQNgw8iIiIi0nhc7apobdq0UZhwLggCJBIJkpOTsXbt2jLlxeCDiIiIiIiK9OYu5lpaWrCwsECXLl3QpEmTMuXF4IOIiIiINF7eJoPaSudRHS1cuFBleTH4ICIiIiKNJ1LBsCtNm/NRHqwhIiIiIiJSC/Z8EBEREZHGyxt2pWTPBz/XLxGDDyIiIiLSeFztSj1YQ0RERESk8fL3+VD2qI4GDBiAP/74A7m5uUrnVT1riIiIiIiIVGb48OGoW7cuZs+ejZs3b5Y7HwYfRERERKTxtFT0X3W0f/9+JCYmYu7cuVi2bBmaN2+Ojh07YuPGjXjx4kWZ8qqeNUREREREVAYcdlU8ExMTeHp6QktLCw8fPoSPjw9++uknWFtbY+LEiQgPDy9VPtW3hoiIiIiISOXq1KmDqVOn4ty5c7h48SJMTEzQqVOnUl3L1a6IiIiISONxtauyyc3NxZEjR7B9+3b8+eef8PLyKtV1mlNDRERERERFyN/nQ9lDE0ybNg02NjaYNm0anJyccO3aNRw6dKhU17Lng4iIiIiIinTp0iXs2bMHe/bsga6uLp4+fYqdO3eiW7duZc5LM8IzItJ4QUHBaNBgJAwMesHNbQpOn75SbPqTJy/DzW0KDAx6oWHDUVi37kCBNHv2nIKz8zjUqNELzs7jsG/fmTLfVxAEBARsga3tMBga9kbXrn6IiYlV6lmrOrZF1VHeZ1ZXfWdmZmHatNWoU2cwjI37YuDABXjwIEmZR67S2B6VS0skkg+9Kv8hquzHqBBubm44dOgQpk2bhoSEBPzyyy/lCjwABh9E1VqXLl0wc+bMIl/fvHkzatasqbbyVJZdu05g1qwgzJs3AlFRP6Fjx+bo08cfcXGPC01/714C+vadh44dmyMq6if4+w/HjBlrsGfPKXma8PAY+PgsxqhRnoiOXo9Rozzh7b0I585dL9N9v/32V6xY8TtWr56G8+eDYGVVC15es5GWVralC98WbIuqpTzPrM76njkzCH/8cQY7dy7A6dMr8fz5S/TvP18lG51VRWyPysVhV0WLjIxEVFQUPvroI4jFYvn5jIwMbNmypUx5iQRBEFRdQCKqGlJSUqCrqwsTExM4ODhg5syZCsHIy5cvkZaWBgsLC7WWSyqVQiwW49mz/TA1Narw+7Vv/zFat26MtWtnys85OY3DwIEdEBg4oUD6OXPW48CBcFy7tkl+bsqUFbhy5S7CwtYAAHx8FkMqTcehQ0vkaXr3notatYyxY8eCUt1XEATY2g7DjBlDMGfOcAB5nyxaWQ3FkiUTMXlyf1VWQ5XAtqg6yvvM6qrv1NTnsLB4D1u3zoW3d1cAwKNHybC3H46DB79Bz55tK6JaKg3bo3BSaTpq1hyA1NRUmJqaVtA98v4mPXm6T+m/SVJpOsxqDS5TeYOCgvDdd98hISEBzs7OWLlyZbErR508eRJ+fn6IiYmBjY0NZs+ejSlTpihV7pJkZWVhz549iI2NRVZWlvz88+fPsWzZMnzxxRcAIP+3ONUzPCMiAEDt2rVhYmJS5OsGBgZqDzzULSsrG5GRt+Dl5aZw3tPTFeHhMYVeExFxDZ6ergrnevZsi4sXbyE7OwcAEB5+DZ6einl6ebkhLCym1Pe9dy8BEkmKQhp9fT107tyyyLK9zdgWVUt5n1ld9R0ZeRvZ2TkKaWxszOHi4iC/V3XC9qh8yg+5KvtqWbt27cLMmTMxf/58XLp0CZ06dULv3r0RFxdXaPp79+6hT58+6NSpEy5duoR58+Zh+vTp2LNnjyqqoEijRo3C5MmT8euvvyI4OFh+HD16FCKRCMHBwfjjjz9KlReDD6JqLH/YVZcuXXD//n3MmjULIpEIov/GpL4+7OrmzZsQiUS4ceOGQh7Lly+Hg4MD8jtJr127hj59+sDY2BiWlpbw9fVFcnJyseXIzMyEVCpVONQlOTkVubkyWFrWUjhvaVkLEklKoddIJCmFps/JyUVycmqxaSSSp6W+b37aN9NYWLzKpzphW1Qt5X1mddW3RJICPT1d1KplUmQ+1Qnbo/KpcpPBN//mZWZmFnrP5cuX44MPPsCECRPg6OiIlStXws7ODmvXri00/bp162Bvb4+VK1fC0dEREyZMwPjx4/H9999XWL0AQGhoKE6fPo3Lly8jKipKfhw/fhyCICAqKgqXLl0qVV4MPog0wN69e1G3bl0sWrQICQkJSEhIKJCmadOmcHV1xfbt2xXO79ixAyNGjIBIJEJCQgI6d+6MVq1a4eLFizhy5AgeP36MYcOGFXv/wMBAiMVi+WFnZ6fS5yuNN+cACgLkQVjh6RVfyw++Xj9fWJo3syzNfQvPp3pOWgTYFpVl+/ZQmJj0lR/5PUfleebKrO/q0iZsj6pHJKjmAAA7OzuFv3uBgYEF7peVlYXIyMgC+2N4eXkhLCys0DKGh4cXSN+zZ09cvHgR2dnZqqmIQqSmpqJu3boFzpen/bnULpEGqF27NrS1tWFiYgIrK6si040cORJr1qzB4sWLAQC3bt1CZGQktm7dCgBYu3Yt2rRpg2+++UZ+zcaNG2FnZ4dbt26hSZMmhebr7+8PPz8/+ddSqVRtAYi5uRja2loFPjlMTHxa4FO+fFZWtQt8kpeY+Aw6OtowMzMtNk1+nqW5r5VV3r8SSQqsrc3kaZKSnsHSsmYZn7TqY1tUrgEDPNCunaP868zMvDcqZX1mddW3lVVtZGVl4+nTNIVP2xMTn8Hd3bm0j11lsT2qt/j4eIU5H/r6+gXSJCcnIzc3F5aWlgrnLS0tIZFICs1XIpEUmj4nJwfJycmwtrZWQekL2rRpU6HDuMViMTZt2lTIFUVjzwcRyfn4+OD+/fuIiIgAAGzfvh2tWrWCk5MTgLzVLk6cOAFjY2P50axZMwDA3bt3i8xXX18fpqamCoe66OnpwtW1CUJCIhXOh4ZGFvkHs317J4SGKqY/duwi3NyaQFc37zMbd/eCaUJCLsLDw7nU961f3xpWVrUV0mRlZePkycvV8o8526JymZgYolEjW/nh5FSvXM+srvp2dW0MXV0dhTQJCU/wzz+x8nu9zdgeVZAgU80BFPibV1jwka+sPU6l6Q1WtdGjR0NPT6/A+bS0tFJNMn8dez6ISM7a2hpdu3bFjh070L59e+zcuROTJ0+Wvy6TydC/f38sXbq00GurqlmzhmL06CVwc2sCd3cnrF9/EHFxiZgyJW/1GH///+HRo2Rs2TIXADBlSn/8+GMw/PyCMHFiX4SHX8PGjYexY8d8eZ7Tpw9B584zsXTpTgwc2AHBwWcRGhqF06dXlfq+IpEIM2YMQWDgDjRuXBeNG9siMHAHDA1rYMSI7mqsIfVhW1QdpX3mMWOWwMbGXL4ambrqWyw2xvjxvfHpp+tgZmaK2rVN8NlnP6F58/ro0aONGmtKPdgeVcBrwYNSeZSSubk5tLW1C/RyJCYmFujdyGdlZVVoeh0dHZiZmRV6jSr8+eef+OSTTxAbG1vo8C4trbz+DJms5Odn8EGkIfT09Eq1FvvIkSMxZ84cDB8+HHfv3oWPj4/8tTZt2mDPnj1wcHCAjs7b8+vD27srnjyRYvHibUhISIGLiwMOHgxEvXp5v9wlkieIi0uUp69f3xoHD34DP78gBAXth42NGVatmor33ntXnsbDwxk7dy7A559vwsKFm9GwoQ1+/fVzhWEUJd0XAGbP9sHLl1n4+ONVePo0De3aOeLo0aUwMTFUQ82oH9uiainNM8fFJUJL69Unquqs7xUrPoKOjja8vRfh5cssdO/eGps2fQVtbe0KrpnKwfbQLHp6enB1dUVISAgGDx4sPx8SEoKBAwcWeo27uzsOHFDcaPXYsWNwc3ODrq5uhZX1k08+gaenJ7p3767Q3qmpqRgzZkypV7oCuM8HUbXWpUsXtGrVCitXroSXlxcMDAwQFBQEfX19mJubY/PmzZg5cyaePXsmv0YqlcLS0hJNmzaFubk5QkND5a89evQIrVq1QufOnfHZZ5/B3Nwcd+7cwa+//ooNGzaU+g+Quvf5ICKit5M69/lIfbJHJft8iM3eK3V5d+3aBV9fX6xbtw7u7u5Yv349NmzYgJiYGNSrVw/+/v54+PChfO7lvXv34OLigsmTJ2PixIkIDw/HlClTsHPnTrz33ntKlb04enp6iI+PL9Ajk5iYCCsrq1L1eOTjnA8iDbFo0SLExsaiYcOGqFOnTpHpTE1N0b9/f1y+fBkjR45UeM3GxgZnz55Fbm4uevbsCRcXF8yYMQNisVje5UpERPRWEgQVzPko22f63t7eWLlyJRYtWoRWrVrh1KlTOHToEOrVqwcASEhIUNjzo379+jh06BD+/vtvtGrVCosXL8YPP/xQoYEHANStW7fQeSva2tpwcHAoU17s+SAitWPPBxERlYZaez6Sf4epqXLDLKXSFxCbD63Q8r7t3p5B20REREREFUUmyzuUzaMa+vLLL4t8TRAEBAQElDovBh9ERERERGpe7eptEhwcrPB1eno67t+/D11dXTRq1IjBBxERERERqUZUVFSBcykpKRg1ahTef//9MuXFGaJERERERCrcZFAT1K5dG4GBgfjqq6/KdB17PoiIiIiIOOyqzLS1tXH//n3k5OSUev8vBh9ERERERJxwXmYuLi7Iyckp0zUMPoiIiIiIqEjdunVDUbtzCIKAv//+G8+ePcPgwYNx4sSJYvNi8EFERERExGFXRWrVqlWJaXR1ddG6desS0zH4ICIiIiJi8FGk5cuXl5jGyMioVOm42hUREREREakFez6IiIiIiNjzUaQGDRoUOefjTffu3Sv2dQYfRERERKTxBEEGQchVOo/qaPz48Vi2bBk6dOiA9u3bAwDCw8Nx9uxZfPrppzA1NS11Xgw+iIiIiIioSDExMZg/fz4+/fRThfPfffcdoqOjsX379lLnxTkfRERERET5+3woe1RDBw4cwMCBAwucHzx4MPbv31+mvBh8EBERERFB9mreR3kPVM/gw9TUFMeOHStw/siRI2UacgVw2BURERERERVj3rx5mDVrFs6ePasw5+P333/HihUrypQXgw8iIiIiIq52VaSpU6eiWbNmWLlyJX744QcIggBHR0ccOXIE3bt3L1NeDD6IiIiIiBh8FKtHjx7o0aOH0vkw+CAiIiIiYvBRooyMDCQlJUH2xsT6evXqlToPBh9ERERERFSkGzduYPz48YiIiFA4LxKJIAhCgWCkOAw+iIiIiIhUsVRuNV1q94MPPoCenh4OHToEa2triESicufF4IOIiIiIiMOuinT58mVcuHABjo6OSufFfT6IiIiIiKhITZs2RVJSkkryYvBBRERERKTsBoOq6Dmpor799lvMnj0bISEhSE5ORmpqqsJRFhx2RUREREQkCCoYdiWopixVjJeXFwCgV69eEAp5Rk44JyIiIiIilThx4oTK8mLwQURERETE1a6K9O6776osLwYfRERERERc7apIJ0+eLPb1zp07IycnB2fPnkXnzp2LTcvgg4iIiIiIitStWzcIglDo/h75mwympKSgW7duyM3NLTYvBh9EVHlysoAc3couBVXTT+reSro1KrsERJqLPR9Fevr0aYlpLCwsSpWOwQcREREREed8FMnU1LTQ89nZ2QgLC5MPtSoq3esYfBARERERyYS8Q9k8qqnw8HDExsYiKytLfi41NRUzZ87Exo0bIRKJMGbMmBLzYfBBRERERERF+vjjj7Fu3ToYGxtDW1tbfj5/Hoifnx8EQWDwQURERERUKoIKhl1V0zkfv/32G0JCQtCtWzeF80lJSbC0tERKSkqp82LwQURERETEOR9FSklJQcuWLQucL2oFrOJoqapQRERERERU/XzxxRcwNDQscN7Y2BhffPFFmfJizwcRERERESecF2nhwoUAgDt37uDatWsQiURwdHREo0aN5K+VFoMPIiIiIiIOuyrSs2fPMG7cOOzfvx86OnnhQ3Z2Nvr3748tW7agZs2apc6Lw66IiIiIiKhIM2fOxJ07d3D27FlkZGQgIyMD4eHhuHv3LqZPn16mvNjzQUREREQkE1TQ81E9h13t378fBw4cQPv27eXn2rVrh/Xr16Nfv35lyovBBxERERER53wUKSsrC8bGxgXOm5iYIDMzs0x5cdgVEREREREVqXPnzpg7dy6ePHkiP5eSkoLZs2ejc+fOZcqLPR9ERERERJxwXqQffvgBffv2hb29PZo0aQKRSISbN2/C1tYWhw4dKlNeDD6IiIiIiDjsqkgNGzZETEwM9u/fj2vXrkEQBDg6OmLQoEHQ1tYuU14MPoiIiIiI2PNRLG1tbQwePBiDBw9WKh8GH0REREREVKQtW7YU+/qYMWNKnReDDyIiIiIiQQU9H0L17PmYNWuWwtfZ2dl48eIFdHR0YGhoyOCDiIiIiKgsBEGAICg3Z0PZ66uqlJSUAudiY2MxefJkfPLJJ2XKi0vtEhERERFVcU+fPoWvry/EYjHEYjF8fX3x7NmzYq/Zu3cvevbsCXNzc4hEIkRHR6usPA4ODliyZAlmzpxZpusYfBARERER5U84V/aoICNGjEB0dDSOHDmCI0eOIDo6Gr6+vsVek56ejg4dOmDJkiUVUiaRSIT4+PgyXcNhV0REREREKlztSiqVKpzW19eHvr5+ubO9fv06jhw5goiICLRr1w4AsGHDBri7u+PmzZto2rRpodflByexsbHlvjcABAcHK3wtCAISEhKwZs0adOzYsUx5MfggIiIiIlIhOzs7ha+/+OILBAQElDu/8PBwiMVieeABAO3bt4dYLEZYWFiRwYeqDBkyROFrkUgECwsLdO/eHd9//32Z8mLwQURERESkwk0G4+PjYWpqKj+tTK8HAEgkElhYWBQ4b2FhAYlEolTepZGbm6uyvDjng4iIiIhIhXM+TE1NFY6igo+AgACIRKJij4sXLwLI6214kyAIhZ6vytjzQURERERUCaZOnQofH59i0zg4OODKlSt4/PhxgdeSkpJgaWlZUcWrEAw+iIiIiIhkggomnJdt2Ja5uTnMzc1LTOfu7o7U1FScP38e77zzDgDg3LlzSE1NhYeHR7mKWlk47IqIiIiIKH/Oh7JHBXB0dESvXr0wceJEREREICIiAhMnTkS/fv0UJps3a9YM+/btk3+dkpKC6OhoXLt2DQBw8+ZNREdHq2WeSFEYfBARERERVfF9PrZv347mzZvDy8sLXl5eaNGiBbZt26aQ5ubNm0hNTZV/vX//frRu3Rp9+/YFAPj4+KB169ZYt25dhZWzJBx2RURERERUxdWuXRu//PJLsWkEQbHnZezYsRg7dmwFlqrsGHwQEREREalwk0EqGoMPIiIiIiJBBXM2hIqZ81GdcM4HEWkEQRAQsOgX2NYbCUPTgejaYzZiYu6XeN2evWfg3GISahj3h3OLSdj3x9kCaYLW/YkGTcbCwGQA3NpNw+kz/yi8/vjxU4z7YBls642EkXgQevdbgNu3HxbIJzziOrp7zYVxzUGoVWcouvaYjZcvM8v/0FWUIAgIWLwdtg6+MBQPRlfPuYi5Voq22HcWzi2noIbJQDi3nIJ9wWEKr586/Q8GDP4Stg6+0NLviz+Cw5W6tyAI6NN/YZF5VQdBQcFo0GAkDAx6wc1tCk6fvlJs+pMnL8PNbQoMDHqhYcNRWLfuQIE0e/acgrPzONSo0QvOzuOwb9+ZMt03OzsHc+asR4sWE2Bs3Be2tsMwZswSPHqUrPwDV3GCICAgYAtsbYfB0LA3unb1Q0xMbInXKVvnALB372n06jUHdeoMhpZWd0RH31F4PTZWAi2t7oUeu3efVOq5SbMw+CAijfDt97uxYtVerF75Ec6HrYKVZS149ZmHtLQXRV4THnEdPiMDMWpkd0RfDMKokd3hPSIQ587fkKfZ9dtJzPrkJ8yb64Oo82vQsaMz+vT/HHFxiQDy3kwMHroI/96T4I89CxF1fg3s7S3g2Xse0tMzFO7Vu98CePZog3NnV+F82Cp8/GF/aGm9XZtHlca3y37HilX7sHrlFJwPW/FfWywoRVsswaiR3RB9YQ1GjewG7xFLFNoiPT0DLVrUx+qVU1Ry75U//PHWbd5VFrt2ncCsWUGYN28EoqJ+QseOzdGnjz/i4gruJQAA9+4loG/feejYsTmion6Cv/9wzJixBnv2nJKnCQ+PgY/PYowa5Yno6PUYNcoT3t6LcO7c9VLf98WLDFy6dBsLFoxCZOQ67NkTgFu3HmDgwM8rtkKqgG+//RUrVvyO1aun4fz5IFhZ1YKX1+zifzZUUOdA3s+Ph4czAgMnFHofO7s6ePRot8IREDAGRkY10Lv3O6qrhMpUxSecVxci4c2ZKUREFUwqlUIsFuNZ8u8wNTWq8PsJggDbeiMxY9ogzPlsGAAgMzMLVnVHYMk34zF5Yp9Cr/MZEQhp2gscOrBYfq53vwWoVdMYO36ZCwBo32EmWrduiLVrpsnTODWfhIED3BH49TjcuvUAzVwm4uqldXB2rgcAyM3NhaXtcCz5ZjwmjO8FAHDvOBM9urfB4i9HV0gdFEtQ3x9LQRBg6+CLGdMGYs6n7wMAMjOzYWU3Eku+HofJE3sXep3PyCWQSl/g0IFF8nO9+32OWrWMsWPbnALptfT7Yu9vCzBooHu57n35yr/oP/hLnD+7Ajb1fAvkVWF0a1T8Pf7Tvv3HaN26MdaunSk/5+Q0DgMHdij0DeicOetx4EA4rl3bJD83ZcoKXLlyF2FhawAAPj6LIZWm49ChJfI0vXvPzWunHQvKdV8AuHDhBtq1+xixsTtgb/92bahWWoIgwNZ2GGbMGII5c4YD+O/3lNVQLFkyEZMn9y/0OlXXeWysBA0ajERU1E9o1apRsWVu02YyWrduhJ9//qw8j1wqUmk6atYcgNTUVJiamlbQPfL+Jj3d6QtTQz3l8nqRhVrDt1Voed927Pkgomrv3j0JJJKn8OrRRn5OX18PnTs1R3j4tSKvCz93HZ6vXQMAXp6uCIvI+0QxKysbkVG3FfIFAE/PNgiPyMs3MzMbAFCjhq78dW1tbejp6eDs2RgAQGLiM5w7fxMWFmJ0eNcPVnWHo0v3z3DmrOLwreqg8LbQRedOLgiPuF7kdeHnbsCzR2uFc16ebeRtocp7v3iRgRG+32L1iimwsqpd6vzfJllZ2YiMvAUvLzeF856erggPjyn0moiIa/D0dFU417NnW1y8eAvZ2TkAgPDwa/D0VMzTy8sNYWEx5b4vAKSmpkMkEqFmTePSPeBb6N69BEgkKQp1o6+vh86dWxZbNxVV5yWJjLyF6Og7+OCDwj+8ISoKgw8iqnCZmZmQSqUKhzpJHj8FAFha1lI4b2FZU/5aoddJnsLSoqbCOUuLmpBIUgAAyclS5ObKCuSblyYv32bN7FCvngXmLdiMp0/TkJWVjSXf/gaJ5CkS/svn33sJAIAvF2/HhA964fCBxWjduhF69PQvdG7I20zeFm/Uq8VrdVbodZKnBevZslax15T33rM+3QB3d0cMHKCGno5KkpycWvj3rmUt+ff3mySSlELT5+TkIjk5tdg0+fVbnvtmZGTB3/9/GDGim1p6SitLfh0V+D1lUfz3eUXUeWn8/PNhODraw8PDudx5VDlVeJPB6oTBBxFVuMDAQIjFYvlhZ2dXoffbvuMvmNQaLD/yP5V9c/y+IBQ896aC1wgFzhWXRldXB7/vWoBbtx/CzHIYjMSDcPLUFfTu5QZt7bxfwbL//lhNmtAH48Z4oXXrRljx/WQ0bVIXGzcfK+PTVy3bd56ASe335Ed2di6AQuoMQEnTK958vbC2KI3i7r3/QARO/H0FK7+fVOZ830YF67T4n4nCvtffPF/4z0P57pudnYPhwxdDJpPhxx9nFFmut9H27aEwMekrP4r+PVXy97kq67w0Xr7MxM6dxzF+fOHDJN9anPOhFlxql4gqnL+/P/z8/ORfS6XSCg1ABvRvj3bvNJN/nT/0SSJJgbX1q2E0SYnPCnwK/jorq1oFekYSk1LlnyCam5tCW1urwKeHeWle5evapjEuXfwRqanpyMrKRp06NdG+w0y4ujYGAFj/N7THydFeIR/HZvaIj08s5VNXTQP6tUO7tk3lX2dm/dcWj58WbIs3Ppl9nZVVwU9/ExOfKdRzSaz+y7+4e//19xXc/TcBtSyGKVw71OcbdOrojBMhS1AdmJuL//vefbNOC/Yw5bOyql3wez3xGXR0tGFmZlpsmlc/M6W/b3Z2Dry9F+HePQmOH/++2vV6DBjggXbtHOVfK/6eMpOfT0oq/vtclXVeWr//fgovXmRi9Givcl1Pmo09H0RU4fT19WFqaqpwVCQTE0M0amQjP5yc7GFlVQshxy/J02RlZePk6atwd3cqMh/3do4IPR6lcC4kNAoe7fPeMOjp6cK1TWOFfAEgNDQK7u0L5isWG6FOnZq4ffshLkbexsD+7QEADg6WsLExw81bDxTS37r94K2fXFugLRz/a4vQN9viH7i3dywyH/d2zRB6PFrhXEjoJXlblEb9+lYl3nvuZ0NxOXINLl1YLT8AYPl3E7Fx/cxS36uq09PThatrE4SERCqcDw2NhLt74cNo2rd3QmioYvpjxy7Cza0JdHXzPst0dy+YJiTkonxoTmnvmx943L79ECEh38HMTFy+B63C8n42bOWHk1M9WFnVVqibrKxsnDx5ucg2AVRX52WxceNhDBjgjjp1apbr+qpKyBVUclDx2PNBRNWeSCTCjGmDELh0Fxo3skHjRrYIXLoLhob6GOHTRZ5uzLjvYWNjhsCvxwEApk8biM7dPsPS737DwP7uCD4QjtDjl3D67+/l18yaMRijx30PN9fGcG/niPU/H0ZcfBKmTHo1CXP376dRp44Y9nZ1cPWfWMz8ZB0GDXCH13+Td0UiET71ew8Bi35Byxb10aplQ2zZFoobNx9g96/z1VNJapLXFgMR+O1vaNzYBo0b2SBw6W//tUVnebox45fltcVXYwEA06cOQOfuc7D0+90Y2K89gv+MQOhf0Th94lv5Nc+fv8Sdu4/kX9+LlSD68l3UrmUCe3uLUt3byqp2oZPM7e3qoH59qwqqlcoxa9ZQjB69BG5uTeDu7oT16w8iLi4RU6bkrark7/8/PHqUjC1b8lZ2mzKlP378MRh+fkGYOLEvwsOvYePGw9ix49X36PTpQ9C580wsXboTAwd2QHDwWYSGRuH06VWlvm9OTi7ef/9LREXdxoEDXyM3Vyb/ZL92bRPo6b1avKE6EYlEmDFjCAIDd6Bx47po3NgWgYE7YGhYAyNGdJenGzNmCWxszOWrVKmizgEgJUWKuLhEPHr0BABw82Y8gII/E3fuPMSpU1dw8OA3FVoflUIVczY456NEDD6ISGlr1qzBvn37cPz48couSpFmf/o+Xr7MwsfTf8TTp8/R7p2mOHrwa5iYGMrTxMUnKuyr4eHuhJ2/zMXnX2zFwoBtaNjAGr9u91cY0uU9rDOepKRh8dc7kJCQAhdnBxzcvwj16r3qsUiQpOCT2evx+PEzWFvXhu/I7vh8/nCF8s2cPhgZGdnw+2w9UlLS0LJFAxw7/DUaNrSpwFqpHLM/GfpfWwS91haL32iLpELaYg4+/2IbFgb8goYNrPDr9jkKbXEx8ja6efnLv/5k9v8AAGN8u2PT//xKfW9N4e3dFU+eSLF48ba8710XBxw8GCj/3pVInsj3qwGA+vWtcfDgN/DzC0JQ0H7Y2Jhh1aqpeO+9d+VpPDycsXPnAnz++SYsXLgZDRva4NdfP1cYXlTSfR88SML+/XkbSLZurTj35q+/lqFLl1YVVSWVbvZsn7zvz49X4enTNLRr54ijR5cq/mzEvfF7SgV1DgD794dh/Pjv5F8PH/4VAGDhwtEICBgjP79x42HY2poXWD2rWsgV8g5l86BicZ8PIlJaQEAANm/ejNjY2FKlV/c+H1QCNe7zQSVQ4z4fRG8Dde7zkbLBWyX7fNSeuIv7fBSDcz6ISGkBAQGlDjyIiIiqIkEQIMiUPPiZfok47IqIiIiIKBcqGHalkpJUa+z5ICIiIiIitWDPBxERERFRrizvUDYPKhaDDyIiIiLSePnzNpTNg4rHYVdERERERKQW7PkgIiIiIuI+H2rB4IOIiIiIiDucqwWHXRERERERkVqw54OIiIiINJ6QK0BQctiUstdrAgYfRERERESCDJApuVSuwKV2S8Lgg4iIiIiIE87VgnM+iIiIiIhILdjzQUREREQaj5sMqgeDDyIiIiIiDrtSCw67IiIiIiIitWDPBxERERERez7UgsEHEREREWk8zvlQDw67IiIiIiIitWDPBxERERFRrizvUDYPKhaDDyIiIiLSeIKggmFXAoddlYTDroiIiIiISC3Y80FERERExNWu1ILBBxERERGRTMg7lM2DisXgg4iIiIg0npALCEr2XAi5KipMNcY5H0REREREpBbs+SAiIiIi4rArtWDwQURERETEfT7UgsOuiIiIiIhILdjzQUREREQaT5CpYJNBDrsqEYMPIiIiIiKZCvb5YPBRIgYfRFR5dPTyDiIiItIIDD6IiIiISONx2JV6MPggIiIiIo0n5Aoq2GSQwUdJuNoVERERERGpBYMPIiIiItJ4+cOulD0qytOnT+Hr6wuxWAyxWAxfX188e/asyPTZ2dmYM2cOmjdvDiMjI9jY2GD06NF49OhRhZWxNBh8EBEREZHGk+UKKjkqyogRIxAdHY0jR47gyJEjiI6Ohq+vb5HpX7x4gaioKHz++eeIiorC3r17cevWLQwYMKDCylganPNBRERERBpPlRPOpVKpwnl9fX3o6+uXO9/r16/jyJEjiIiIQLt27QAAGzZsgLu7O27evImmTZsWuEYsFiMkJETh3OrVq/HOO+8gLi4O9vb25S6PMtjzQURERESkQnZ2dvLhUWKxGIGBgUrlFx4eDrFYLA88AKB9+/YQi8UICwsrdT6pqakQiUSoWbOmUuVRBns+iIiIiEjjCTIZBJlM6TwAID4+HqampvLzyvR6AIBEIoGFhUWB8xYWFpBIJKXKIyMjA3PnzsWIESMUyqZu7PkgIiIiIvpvqV1ljvwd0k1NTRWOooKPgIAAiESiYo+LFy8CAEQiUYHrBUEo9PybsrOz4ePjA5lMhqCgICUqSXns+SAiIiIiqgRTp06Fj49PsWkcHBxw5coVPH78uMBrSUlJsLS0LPb67OxsDBs2DPfu3cNff/1Vqb0eAIMPIiIiIiIIggomnAtlu97c3Bzm5uYlpnN3d0dqairOnz+Pd955BwBw7tw5pKamwsPDo8jr8gOP27dv48SJEzAzMytT+SoCh10RERERkcZTdsiVKnZIL4qjoyN69eqFiRMnIiIiAhEREZg4cSL69eunsNJVs2bNsG/fPgBATk4Ohg4diosXL2L79u3Izc2FRCKBRCJBVlZWhZSzNBh8EBERERFVcdu3b0fz5s3h5eUFLy8vtGjRAtu2bVNIc/PmTaSmpgIAHjx4gP379+PBgwdo1aoVrK2t5UdZVshSNQ67IiIiIiKNp8p9PipC7dq18csvvxR//9eGfTk4OJR5GJg6MPggIiIiIo0nkwmQKRk8KHu9JuCwKyIiIiIiUgv2fBARERGRxhNyAUFLyWFXuSoqTDXG4IOIiIiINF5Vn/NRXTD4ICIiIiKNx+BDPTjng4iIiIiI1II9H0RERESk8YRcQQVzPtjzURIGH0RERESk8QRBBkEmUjoPKh6HXRERERERkVqw54OIiIiINJ6QK0AQcdhVRWPwQUREREQaj6tdqQeHXRERERERkVqw54OIiIiINJ5MJkCmZM+FstdrAgYfRERERKTxOOdDPTjsioiIiIiI1II9H0RERESk8TjhXD0YfBARERGRxuOwK/XgsCsi0ghBQcFo0GAkDAx6wc1tCk6fvlJs+pMnL8PNbQoMDHqhYcNRWLfuQIE0e/acgrPzONSo0QvOzuOwb9+ZMt93797T6NVrDurUGQwtre6Ijr6j3IO+BapqWwiCgICALbC1HQZDw97o2tUPMTGxSj1rVce2qFrK+9zqqvP16/9E165+EIv7Q0urO549e67M41Y9giDv/SjvAYHBR0kYfBBRtbdr1wnMmhWEefNGICrqJ3Ts2Bx9+vgjLu5xoenv3UtA377z0LFjc0RF/QR//+GYMWMN9uw5JU8THh4DH5/FGDXKE9HR6zFqlCe8vRfh3LnrZbpvenoGPDycERg4oeIqoAqpym3x7be/YsWK37F69TScPx8EK6ta8PKajbS0FxVXIZWIbVH1lOe51VnnL15komfPtvD3H1ExFUAaQSQIDNGINNHLly9hZmaGqKgoNGvWTK33lkqlEIvFePZsP0xNjSr8fu3bf4zWrRtj7dqZ8nNOTuMwcGCHQt/0z5mzHgcOhOPatU3yc1OmrMCVK3cRFrYGAODjsxhSaToOHVoiT9O791zUqmWMHTsWlPm+sbESNGgwElFRP6FVq0aqeOwqqaq2hSAIsLUdhhkzhmDOnOEAgMzMLFhZDcWSJRMxeXJ/VVZDlcC2qFrK+9yVUed//x2Nbt0+QUpKMGrWNFZlNRQglaajZs0BSE1NhampaQXdI+9vUmTrJjDW1lYqr+e5uXC9dKtCy/u2Y88HkYZ4+vQpnj9/1UUeEhICOzu7EgOPjIwMJCUlVXTxKkxWVjYiI2/By8tN4bynpyvCw2MKvSYi4ho8PV0VzvXs2RYXL95CdnYOACA8/Bo8PRXz9PJyQ1hYTLnvW91V5ba4dy8BEkmKQhp9fT107tyyWrYX26LqKe9zs85VR8gVVHJQ8Rh8EFVjOTk5OHjwIIYNGwZra2vcvXtX/lpwcDAGDBgAALh8+TK6du0KExMTmJqawtXVFRcvXgQAPH78GLa2thg0aBD27duHrKysMpcjMzMTUqlU4VCX5ORU5ObKYGlZS+G8pWUtSCQphV4jkaQUmj4nJxfJyanFppFInpb7vtVdVW6L/LRvprGweJVPdcK2qHrK+9ysc3rbMPggqoauXr2KTz/9FHXr1sXo0aNhZmaGEydOoGXLlgAAmUyGP//8EwMHDgQAjBw5EnXr1sWFCxcQGRmJuXPnQldXFwBQr149hIeHo169epg8eTJsbGwwffp0REZGlro8gYGBEIvF8sPOzk71D10CkUjxa0EARG+eVEiv+Fr+CNXXzxeW5s0sy3pfTVCV26LwfKpve7EtKs/27aEwMekrP/J7j8rz3Kxz1cjf4VzZg4rHpXaJqoknT55g+/bt2Lx5M2JiYtC7d28EBQWhX79+0NPTU0gbEREBmUwGDw8PAEBcXBw+++wz+RCsxo0bK6R3dXWFq6srli1bhsOHD2Pr1q3o0KEDGjdujDFjxsDX1xeWlpZFls3f3x9+fn7yr6VSqdoCEHNzMbS1tQp8epeY+LTAp3z5rKxqF/j0NzHxGXR0tGFmZlpsmvw8y3Pf6q4qt4WVVd6/EkkKrK3N5GmSkp7B0rJmGZ+06mNbVL4BAzzQrp2j/OvMzGwAZX9u1rnqyGSATMlYSyZTTVmqM/Z8EFUTq1evxowZM2BsbIw7d+7gjz/+wJAhQwoEHkDekKt+/fpBSyvvV4Cfnx8mTJiAHj16YMmSJQrDs16no6OD/v37Y/fu3YiNjYW1tTU+++wzBAYGFls2fX19mJqaKhzqoqenC1fXJggJUeypCQ2NhLu7c6HXtG/vhNBQxfTHjl2Em1sT6OrmfWbj7l4wTUjIRXh4OJf7vtVdVW6L+vWtYWVVWyFNVlY2Tp68XC3bi21R+UxMDNGoka38cHKqV67nZp3T24bBB1E1MWnSJHz11VeQSCRwcnLC2LFjcfz4ccgK+Rhm//798iFXABAQEICYmBj07dsXf/31F5ycnLBv374C1wmCgFOnTmHixIlo1qwZbt++jYULFyr0alRFs2YNxc8/H8LGjYdx/fp9zJoVhLi4REyZkreCi7///zBmzKuVYqZM6Y/79xPh5xeE69fvY+PGw9i48TA++WSYPM306UNw7NhFLF26EzduxGHp0p0IDY3CjBnvlfq+AJCSIkV09B1cu3YfAHDzZjyio+9U23khVbUtRCIRZswYgsDAHdi37wz++ecexo37FoaGNTBiRHc11Y56sS2qltI+95gxS+Dv/z/51+qsc4kkBdHRd3DnzkMAwNWr/yI6+g5SUtQ3j68iyWSqOah4XGqXqBoKCwvDli1bsGvXLpiYmGDkyJHw9fWFs7Mzbt++jRYtWuDJkycwNDQs9Prhw4cjPT0d+/fvBwDcunUL27Ztwy+//ILk5GQMHToUY8aMQefOncs1HljdS+0CeRtsfffdLiQkpMDFxQHLl3+Ed99tAQAYN24pYmMf48SJ5fL0J09ehp9fEGJi7sPGxgyzZ/soBA0A8PvvJ/H555vw778JaNjQBl99NR5DhnQq9X0BYPPmIxg//rsC5V24cDQCAsaosgqqjKraFoIg4Msvt2L9+j/x9Gka2rVzxJo10+HiUr8Ca6NysS2qltI8d9eufnBwsMSmTXPk59RV5wEBW7Bo0dYC5d648TOMHdtLlVUhp86lds80aaSSpXY73rrDpXaLweCDqBrLyMjAH3/8gS1btiAkJASXLl3C0aNHcfLkSRw4kLcz8cuXL/HZZ59h6NChqF+/Ph48eIAxY8bgvffew9KlSxEXF4f69eujS5cu8vNGRsoFDJURfBAR0duHwUf1wwnnRNVYjRo14OPjAx8fHzx69AjGxsYIDg7GmDGvPlHX1tbGkydPMHr0aDx+/Bjm5uYYMmQIvvzySwCAubk57t27B3t7+8p6DCIiogonE/IOZfOg4jH4INIQNjY2SE5ORkREBHbv3i0/r6enh507dxZ5naGhIQMPIiKq9rjalXow+CDSICkpKVi+fDmsrKwquyhERERVikxQPnhgz0fJGHwQaZAmTZqgSZMmlV0MIiIi0lAMPoiIiIhI4wkyQNlRUwKHXZWIwQcRERERaTyZCoIPzvkoGTcZJCIiIiIitWDPBxERERFpPPZ8qAeDDyIiIiLSeAw+1IPDroiIiIiISC3Y80FEREREGo89H+rB4IOIiIiINB6DD/XgsCsiIiIiIlIL9nwQERERkcYTBAGCICidBxWPwQcRERERaTwOu1IPBh9EREREpPEYfKgH53wQEREREZFasOeDiIiIiDSeTFC+50LGKR8lYvBBRERERBpPkAEykZJ5MPgoEYddERERERGRWjD4ICIiIiKNJ5Op5qgoT58+ha+vL8RiMcRiMXx9ffHs2bNirwkICECzZs1gZGSEWrVqoUePHjh37lzFFbIUGHwQERERkcar6sHHiBEjEB0djSNHjuDIkSOIjo6Gr69vsdc0adIEa9aswdWrV3HmzBk4ODjAy8sLSUlJFVfQEogE7oZCRGomlUohFovx7Nl+mJoaVXZxiIioipJK01Gz5gCkpqbC1NS0gu6R9zdpp2FDGIq0lcrrhZCL4S/uqry8169fh5OTEyIiItCuXTsAQEREBNzd3XHjxg00bdq0VPnkP2toaCi6d++usvKVBSecExEREZHGk6lgwnn+aldSqVThvL6+PvT19cudb3h4OMRisTzwAID27dtDLBYjLCysVMFHVlYW1q9fD7FYjJYtW5a7LMrisCsiIiIi0ngyQTUHANjZ2cnnZojFYgQGBipVNolEAgsLiwLnLSwsIJFIir32zz//hLGxMWrUqIEVK1YgJCQE5ubmSpVHGQw+iIiIiIhUKD4+HqmpqfLD39+/0HQBAQEQiUTFHhcvXgQAiEQFu2UEQSj0/Ou6du2K6OhohIWFoVevXhg2bBgSExOVf8hy4rArIiIiItJ4qhx2ZWpqWqo5H1OnToWPj0+xaRwcHHDlyhU8fvy4wGtJSUmwtLQs9nojIyM0atQIjRo1Qvv27dG4cWP8/PPPRQZEFY3BBxERERFpPFUGH6Vlbm5eqiFQ7u7uSE1Nxfnz5/HOO+8AAM6dO4fU1FR4eHiU6Z6CICAzM7NsBVUhDrsiIiIiIo1XlZfadXR0RK9evTBx4kREREQgIiICEydORL9+/RQmmzdr1gz79u0DAKSnp2PevHmIiIjA/fv3ERUVhQkTJuDBgwd4//33K6agpcDgg4iIiIioitu+fTuaN28OLy8veHl5oUWLFti2bZtCmps3byI1NRUAoK2tjRs3buC9995DkyZN0K9fPyQlJeH06dNwdnaujEcAwGFXRFQJ8rcXkkpfVHJJiIioKsv/O6GObenSBVmZh0296SUqbpfB2rVr45dffik2zev1VKNGDezdu7fCylNeDD6ISO3S0tIAAPb2xU+yIyIiAvL+bojF4grJW09PD1ZWVpguuaeS/KysrKCnp6eSvKoj7nBORGonk8nw6NEjmJiYlLhEIBERaS5BEJCWlgYbGxtoaVXcbIGMjAxkZWWpJC89PT3UqFFDJXlVRww+iIiIiIhILTjhnIiIiIiI1ILBBxERERERqQWDDyIiIiIiUgsGH0REREREpBYMPoiIiIiISC0YfBARERERkVow+CAiIiIiIrVg8EFERERERGrxf/600iAWmYusAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "print(attr_viz_88.seq_attr)\n", - "attr_viz_88.plot_seq_attr()\n", - "attr_viz_88.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 645, - "id": "a8d94d9b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8767213225364685 ]\n", - "sv shape:: torch.Size([6, 4])\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.48403507471084595 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7302335500717163 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7861713767051697 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7302335500717163 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6961074471473694 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.48403507471084595 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7302335500717163 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7861713767051697 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6478603482246399 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6075158715248108 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7861713767051697 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7861713767051697 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7302335500717163 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.3068313002586365 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6075158715248108 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6478603482246399 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7302335500717163 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7861713767051697 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.48403507471084595 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7924065589904785 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.48403507471084595 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6478603482246399 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6961074471473694 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8554695248603821 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6075158715248108 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4589369297027588 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6961074471473694 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.7078842520713806 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - " \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6478603482246399 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4492253363132477 ]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - " \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.8861209154129028 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - " \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.6961074471473694 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.4232654273509979 ]\n", - " [INST] Here are some examples of movie reviews and classification of whether they were Positive or Negative:\n", - "'The movie was ok, the actors weren't great' Negative \n", - "'I loved it, it was an amazing story!' Positive \n", - "'Total waste of time!!' Negative \n", - "'Won't recommend' Negative\n", - " Decide if the following movie review enclosed in quotes is Positive or Negative:\n", - "'I really liked the Avengers, it had a captivating plot!'\n", - "Reply only Positive or Negative.[/INST]\n", - " Positive. [prob: 0.5525419116020203 ]\n", - "tensor([-0.1081, -0.4112, -0.0173, 0.0749], device='cuda:0')\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "svs = m.ShapleyValueSampling(model) \n", - "svs_llm_attr = LLMAttribution(svs, tokenizer)\n", - "\n", - "attr_result_888 = svs_llm_attr.attribute(\n", - " inp_feature, \n", - "# target=\"Positive\"\n", - ")\n", - "\n", - "attr_viz_888 = LLMAttrViz(**attr_result_888)\n", - "print(attr_viz_888.seq_attr)\n", - "attr_viz_888.plot_seq_attr()\n", - "attr_viz_888.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 405, - "id": "0e505992", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.934102692757733e-05 ]\n", - " lives in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.9094561139354482e-05 ]\n", - " Dave in Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.641148168753716e-06 ]\n", - " Dave lives Palm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.978511813329533e-06 ]\n", - " Dave lives inm Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.6035468181362376e-06 ]\n", - " Dave lives in Pal Coast, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 5.203700766287511e-06 ]\n", - " Dave lives in Palm, FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.904232926288387e-06 ]\n", - " Dave lives in Palm Coast FL and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 3.864713107759599e-06 ]\n", - " Dave lives in Palm Coast,L and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.113435913197463e-06 ]\n", - " Dave lives in Palm Coast, F and is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.2460433683590963e-05 ]\n", - " Dave lives in Palm Coast, FL is a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 9.888166459859349e-06 ]\n", - " Dave lives in Palm Coast, FL and a lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 8.247206096712034e-06 ]\n", - " Dave lives in Palm Coast, FL and is lawyer. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 1.1111003914265893e-05 ]\n", - " Dave lives in Palm Coast, FL and is a. His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 7.453636953869136e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer His personal interests include\n", - "playing golf, hiking, and cooking. [prob: 6.971460152271902e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. personal interests include\n", - "playing golf, hiking, and cooking. [prob: 2.472557980581769e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His interests include\n", - "playing golf, hiking, and cooking. [prob: 6.2888325373933185e-06 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal include\n", - "playing golf, hiking, and cooking. [prob: 5.19798902587354e-07 ]\n", - " Dave lives in Palm Coast, FL and is a lawyer. His personal interests\n", - "playing golf, hiking, and cooking. [prob: 3.9929703987695575e-10 ]\n" - ] - } - ], - "source": [ - "llm_attr = LLMAttribution(fa, tokenizer)\n", - "\n", - "inp_feature = TextTokenFeature(\n", - " \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\", \n", - " tokenizer,\n", - " baselines=0, # UNK\n", - " skip_tokens=[1], # \n", - ")\n", - "\n", - "attr_result_9 = llm_attr.attribute(inp_feature, target=\"playing golf, hiking, and cooking.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 406, - "id": "69124c7c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_9 = LLMAttrViz(**attr_result_9)\n", - "attr_viz_9.plot_seq_attr()\n", - "attr_viz_9.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 409, - "id": "fc8152a6", - "metadata": {}, - "outputs": [], - "source": [ - "emb_layer = model.get_submodule(\"model.embed_tokens\")" - ] - }, - { - "cell_type": "code", - "execution_count": 494, - "id": "e838a349", + "id": "objective-america", "metadata": {}, - "outputs": [], "source": [ - "class LLMGradientAttribution(Attribution):\n", - " def __init__(\n", - " self, \n", - " attr_method, \n", - " tokenizer,\n", - " max_new_tokens=15,\n", - " attr_type: str = \"log_prob\", # or prob\n", - " ):\n", - " \"\"\"\n", - " attr_method: gradients attribution instance crteated with a llm model huggingface style interface\n", - " tokenizer: required\n", - " \"\"\"\n", - "# assert (\n", - "# type(attr_method) in SUPPORTED_METHODS\n", - "# ), f\"LLMAttribution does not support {type(attr_method)}\"\n", - "\n", - " super().__init__(attr_method.forward_func)\n", - "\n", - " # shallow copy is enough to avoid modifying original instance\n", - " self.attr_method = copy(attr_method)\n", - "\n", - " self.attr_method.forward_func = self._forward_func\n", - " \n", - " # alias\n", - " self.model = self.forward_func\n", - " \n", - " self.tokenizer = tokenizer\n", - " self.device = self.model.device\n", - " \n", - " # only when attr target is not given\n", - " self.max_new_tokens = max_new_tokens\n", - " \n", - " self.attr_type = attr_type\n", - " \n", - " \n", - " def _forward_func(self, perturbed_feature, input_feature, output_tokens, target_token):\n", - " perturbed_input = self._format_model_input(input_feature.to_model_input(perturbed_feature))\n", - "# print(\"perturbed_feature\", perturbed_feature)\n", - "# print(\"perturbed_input\", perturbed_input.shape)\n", - "# print(\"output_token_tensor\", output_token_tensor.shape)\n", - " \n", - " if output_tokens:\n", - " output_token_tensor = torch.tensor([output_tokens] * perturbed_input.size(0), device=self.device) \n", - " new_input_tensor = torch.cat([perturbed_input, output_token_tensor], dim=1)\n", - " else:\n", - " new_input_tensor = perturbed_input\n", - " \n", - " output_logits = self.model(new_input_tensor)\n", - " \n", - " new_token_logits = output_logits.logits[:, -1]\n", - " log_probs = torch.nn.functional.log_softmax(new_token_logits, dim=1)\n", - " \n", - " token_log_probs = log_probs[..., target_token]\n", - " print(\"log_probs\", token_log_probs)\n", - " return token_log_probs\n", - " \n", - " \n", - " def _format_model_input(self, model_input):\n", - " \"\"\"\n", - " Convert str to tokenized tensor\n", - " \"\"\"\n", - " return model_input.to(self.device)\n", - " \n", - " def attribute(\n", - " self, \n", - " input_feature: Union[\"TextFeature\", \"IdFeature\"], \n", - " target: Union[str, torch.Tensor, None] = None, \n", - "# num_trials: int = 1, \n", - "# log_trials=True,\n", - " **kwargs,\n", - " ):\n", - " if type(target) is str:\n", - " # exclude sos\n", - " target_tokens = self.tokenizer.encode(target)[1:]\n", - " elif type(target) is torch.Tensor:\n", - " target_tokens = target\n", - " else:\n", - " # generate when None\n", - " model_inp = self._format_model_input(input_feature.to_model_input())\n", - " output_tokens = self.model.generate(model_inp, max_new_tokens=self.max_new_tokens)\n", - " target_tokens = output_tokens[0][model_inp.size(1):]\n", - " \n", - " init_model_inp = input_feature.interpretable_tensor.to(self.device)\n", - " \n", - " model_inp = init_model_inp\n", - " \n", - " log_prob_list = []\n", - " \n", - " attr_list = []\n", - " output_tokens = []\n", - " for target_token in target_tokens: \n", - " # attr in shape(batch_size, input+output_len, emb_dim)\n", - " attr = self.attr_method.attribute(\n", - " model_inp,\n", - "# target=target_token,\n", - " additional_forward_args=(input_feature, output_tokens, target_token),\n", - " **kwargs,\n", - " )\n", - " \n", - "# print(attr.shape)\n", - " \n", - " # the author uses sum \n", - " # https://github.com/ankurtaly/Integrated-Gradients/blob/master/BertModel/bert_model_utils.py#L350\n", - " attr = attr.sum(-1)\n", - " \n", - " # we may have the attr for previous output tokens, how to use them?\n", - " if output_tokens:\n", - " attr = attr[..., :-len(output_tokens)]\n", - "\n", - " attr_list.append(attr)\n", - " \n", - " output_tokens.append(target_token)\n", - " \n", - " \n", - " \n", - " # assume inp batch only has one instance\n", - " attr = torch.cat(attr_list, dim=0)\n", - " \n", - " if isinstance(input_feature, TextTokenFeature) and input_feature.interpretable_mask is not None:\n", - " interpretable_mask = input_feature.interpretable_mask.to(self.device)\n", - " interpretable_mask = interpretable_mask.expand_as(attr)\n", - " attr = attr[interpretable_mask].view(attr.size(0), -1)\n", - " \n", - " return {\n", - " \"seq_attr\": None, # TODO\n", - " \"token_attr\": attr, # shape(n_output_token, n_input_features)\n", - " \"input_tokens\": input_feature.inputs,\n", - " \"output_tokens\": self.tokenizer.convert_ids_to_tokens(target_tokens)\n", - " }\n" + "Let's now consider a more complex example, where we use the LLM as a few-shot learner to classify sample movie reviews as positive or negative. We want to measure the relative impact of the few shot examples. Since the prompt changes slightly in the case that no examples are needed, we define a prompt function rather than a format string in this case." ] }, { "cell_type": "code", - "execution_count": 497, - "id": "ac42a4ac", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "log_probs tensor([-2.0709], device='cuda:0')\n", - "log_probs tensor([-9.4683], device='cuda:0')\n", - "log_probs tensor([ -9.5406, -9.6553, -9.9278, -10.4854, -10.8005, -10.2532, -10.1805,\n", - " -14.0455, -12.1830, -11.2045, -9.9975, -11.8878, -12.6220, -11.6448,\n", - " -11.8720, -10.7416, -10.0644, -9.1234, -3.4986, -3.2085, -3.0359,\n", - " -3.0088, -2.6658, -2.2921, -2.1588, -2.1595, -2.2699, -2.2817,\n", - " -2.3294, -2.3406, -2.3513, -2.3412, -2.3305, -2.2634, -2.2051,\n", - " -2.1849, -2.1575, -2.1481, -2.1430, -2.1222, -2.1132, -2.1002,\n", - " -2.0928, -2.0770, -2.0843, -2.0725, -2.0786, -2.0701, -2.0715,\n", - " -2.0661], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.9615], device='cuda:0')\n", - "log_probs tensor([-5.6482], device='cuda:0')\n", - "log_probs tensor([-5.6477, -5.6869, -5.7107, -5.8108, -5.9896, -6.2228, -6.4274, -8.7211,\n", - " -4.8410, -4.5691, -5.5906, -5.6740, -7.5825, -7.0264, -8.0953, -8.7098,\n", - " -7.6135, -4.3560, -2.2461, -1.8300, -1.3981, -1.0928, -0.9956, -1.0341,\n", - " -1.0432, -1.0768, -1.4605, -1.8595, -1.8596, -1.8224, -1.6506, -1.4515,\n", - " -1.2607, -1.0950, -1.0314, -0.9947, -0.9811, -0.9794, -0.9668, -0.9546,\n", - " -0.9581, -0.9534, -0.9532, -0.9591, -0.9613, -0.9576, -0.9515, -0.9558,\n", - " -0.9591, -0.9535], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.4636], device='cuda:0')\n", - "log_probs tensor([-1.6449], device='cuda:0')\n", - "log_probs tensor([-1.6434, -1.6663, -1.7097, -1.7761, -1.8556, -1.9532, -2.0148, -6.3389,\n", - " -2.6998, -3.2949, -2.9760, -2.4610, -2.3910, -2.7350, -3.4769, -3.5385,\n", - " -3.5503, -1.6001, -0.2519, -0.3083, -0.4258, -0.4132, -0.4364, -0.4366,\n", - " -0.5266, -0.5890, -0.6069, -0.6105, -0.6382, -0.6220, -0.5920, -0.5321,\n", - " -0.5061, -0.4850, -0.4715, -0.4709, -0.4702, -0.4702, -0.4699, -0.4639,\n", - " -0.4638, -0.4695, -0.4634, -0.4635, -0.4632, -0.4632, -0.4636, -0.4691,\n", - " -0.4633, -0.4635], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-1.2316], device='cuda:0')\n", - "log_probs tensor([-7.7042], device='cuda:0')\n", - "log_probs tensor([-7.6972, -7.6542, -7.6036, -7.5507, -7.4936, -7.4577, -7.4766, -7.1102,\n", - " -7.4851, -6.5747, -5.7761, -6.2487, -5.8500, -6.2982, -6.4095, -6.3358,\n", - " -4.7494, -2.1934, -1.7727, -1.2845, -0.9165, -0.8639, -1.2729, -1.2650,\n", - " -1.2322, -1.2437, -1.4309, -1.4960, -1.4593, -1.3912, -1.3109, -1.3155,\n", - " -1.3039, -1.2470, -1.2205, -1.2294, -1.2508, -1.2543, -1.2551, -1.2584,\n", - " -1.2572, -1.2643, -1.2552, -1.2555, -1.2508, -1.2508, -1.2495, -1.2374,\n", - " -1.2409, -1.2387], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0061], device='cuda:0')\n", - "log_probs tensor([-3.4981], device='cuda:0')\n", - "log_probs tensor([-3.5210e+00, -3.5241e+00, -3.5458e+00, -3.5580e+00, -3.5840e+00,\n", - " -3.5486e+00, -3.6213e+00, -4.2026e-01, -1.4344e+00, -2.2248e+00,\n", - " -4.4411e+00, -3.5577e+00, -4.7194e+00, -4.5466e+00, -2.6148e+00,\n", - " -2.0950e+00, -6.8024e-01, -1.6951e-02, -9.5959e-03, -4.0313e-03,\n", - " -2.2748e-03, -3.2298e-03, -7.2201e-03, -9.8084e-03, -1.4193e-02,\n", - " -1.8943e-02, -2.6169e-02, -2.7008e-02, -2.3326e-02, -1.6971e-02,\n", - " -1.2437e-02, -1.2625e-02, -1.1336e-02, -8.4125e-03, -7.5415e-03,\n", - " -6.9929e-03, -6.9987e-03, -6.7954e-03, -6.6970e-03, -6.6936e-03,\n", - " -6.4946e-03, -6.4995e-03, -6.3989e-03, -6.2040e-03, -6.1161e-03,\n", - " -6.2124e-03, -6.0197e-03, -6.1128e-03, -6.1110e-03, -6.1146e-03],\n", - " device='cuda:0', grad_fn=)\n", - "log_probs tensor([-2.4676e-05], device='cuda:0')\n", - "log_probs tensor([-0.0080], device='cuda:0')\n", - "log_probs tensor([-7.8454e-03, -8.2549e-03, -7.9442e-03, -7.9829e-03, -8.3349e-03,\n", - " -8.0030e-03, -7.0472e-03, -6.7268e-03, -4.9508e-03, -5.0620e-03,\n", - " -6.4590e-03, -4.1252e-03, -4.7543e-03, -2.8470e-03, -4.9937e-03,\n", - " -2.6211e-03, -2.3967e-03, -2.5129e-03, -2.1773e-03, -1.0865e-03,\n", - " -8.3555e-04, -7.5812e-04, -5.7609e-04, -3.8164e-04, -3.8283e-04,\n", - " -4.4276e-04, -4.1178e-04, -3.4398e-04, -2.7986e-04, -2.1479e-04,\n", - " -1.4614e-04, -1.2540e-04, -9.8581e-05, -4.8517e-05, -3.8265e-05,\n", - " -3.4451e-05, -3.2424e-05, -3.1709e-05, -2.9802e-05, -2.7895e-05,\n", - " -2.8014e-05, -2.7299e-05, -2.6226e-05, -2.5868e-05, -2.5868e-05,\n", - " -2.4795e-05, -2.4914e-05, -2.4914e-05, -2.4795e-05, -2.4795e-05],\n", - " device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.2264], device='cuda:0')\n", - "log_probs tensor([-0.2352], device='cuda:0')\n", - "log_probs tensor([-0.2340, -0.2447, -0.2482, -0.2528, -0.2599, -0.2616, -0.2416, -0.1688,\n", - " -0.1987, -0.0651, -0.1450, -0.1208, -0.1878, -0.1472, -0.1953, -0.2304,\n", - " -0.2069, -0.1964, -0.2021, -0.7574, -1.0162, -0.7839, -0.4694, -0.2876,\n", - " -0.2679, -0.3055, -0.3308, -0.3179, -0.3181, -0.3062, -0.2871, -0.2760,\n", - " -0.2660, -0.2357, -0.2295, -0.2237, -0.2235, -0.2266, -0.2266, -0.2268,\n", - " -0.2297, -0.2296, -0.2296, -0.2265, -0.2232, -0.2295, -0.2294, -0.2263,\n", - " -0.2264, -0.2262], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.1152], device='cuda:0')\n", - "log_probs tensor([-1.6059], device='cuda:0')\n", - "log_probs tensor([-1.6050, -1.6326, -1.6575, -1.6559, -1.6843, -1.6950, -1.6140, -0.9357,\n", - " -1.4674, -1.7290, -1.7059, -1.0814, -1.3955, -1.1739, -1.0795, -1.1383,\n", - " -0.8868, -0.4796, -0.0696, -0.0616, -0.0702, -0.0802, -0.0811, -0.0601,\n", - " -0.0592, -0.0669, -0.1023, -0.1135, -0.1152, -0.1142, -0.1185, -0.1409,\n", - " -0.1582, -0.1455, -0.1355, -0.1335, -0.1297, -0.1316, -0.1267, -0.1248,\n", - " -0.1227, -0.1211, -0.1206, -0.1188, -0.1194, -0.1171, -0.1162, -0.1164,\n", - " -0.1153, -0.1146], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-1.5733], device='cuda:0')\n", - "log_probs tensor([-3.8375], device='cuda:0')\n", - "log_probs tensor([-3.8212, -3.6290, -3.4646, -3.2761, -3.1055, -2.9610, -2.9705, -2.8450,\n", - " -1.4860, -1.6356, -1.2170, -0.9426, -1.4574, -1.5975, -1.6965, -1.7592,\n", - " -1.7783, -1.3063, -1.2455, -1.4052, -1.4927, -1.2665, -1.4001, -1.3986,\n", - " -1.5204, -1.7205, -2.0572, -2.2677, -2.3425, -2.3839, -2.2673, -2.1256,\n", - " -1.9484, -1.7658, -1.7014, -1.6566, -1.6371, -1.5936, -1.6087, -1.5914,\n", - " -1.5949, -1.5832, -1.5908, -1.5817, -1.5770, -1.5811, -1.5802, -1.5716,\n", - " -1.5852, -1.5717], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-6.8185e-05], device='cuda:0')\n", - "log_probs tensor([-0.0003], device='cuda:0')\n", - "log_probs tensor([-3.1204e-04, -2.8964e-04, -2.7200e-04, -2.5841e-04, -2.4292e-04,\n", - " -2.2445e-04, -2.0550e-04, -5.8276e-04, -3.3731e-04, -1.7811e-03,\n", - " -2.8796e-03, -4.4035e-03, -3.7628e-03, -1.9863e-03, -2.3408e-03,\n", - " -2.1783e-03, -2.5642e-03, -2.4138e-03, -2.4013e-03, -1.2952e-03,\n", - " -9.3452e-04, -8.1161e-04, -8.1387e-04, -5.7502e-04, -4.6004e-04,\n", - " -4.2441e-04, -4.7565e-04, -4.7267e-04, -4.5575e-04, -3.5959e-04,\n", - " -2.2492e-04, -1.9405e-04, -1.4900e-04, -8.5469e-05, -7.5337e-05,\n", - " -7.7721e-05, -7.4622e-05, -7.4503e-05, -7.7364e-05, -7.3907e-05,\n", - " -7.2477e-05, -7.1285e-05, -7.3549e-05, -6.9497e-05, -6.9735e-05,\n", - " -7.0212e-05, -6.8781e-05, -6.9854e-05, -6.7828e-05, -6.9735e-05],\n", - " device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0004], device='cuda:0')\n", - "log_probs tensor([-0.0035], device='cuda:0')\n", - "log_probs tensor([-0.0035, -0.0034, -0.0036, -0.0036, -0.0036, -0.0036, -0.0035, -0.0013,\n", - " -0.0024, -0.0248, -0.0315, -0.0234, -0.0290, -0.0212, -0.0330, -0.0466,\n", - " -0.0565, -0.0553, -0.0352, -0.0147, -0.0093, -0.0095, -0.0079, -0.0044,\n", - " -0.0032, -0.0033, -0.0035, -0.0036, -0.0040, -0.0031, -0.0020, -0.0017,\n", - " -0.0014, -0.0008, -0.0007, -0.0006, -0.0006, -0.0006, -0.0006, -0.0005,\n", - " -0.0005, -0.0005, -0.0005, -0.0005, -0.0005, -0.0005, -0.0004, -0.0004,\n", - " -0.0004, -0.0004], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0107], device='cuda:0')\n", - "log_probs tensor([-0.2793], device='cuda:0')\n", - "log_probs tensor([-0.2726, -0.2580, -0.2491, -0.2366, -0.2276, -0.2251, -0.2300, -0.1019,\n", - " -0.0061, -0.0191, -0.0318, -0.0206, -0.0374, -0.0263, -0.0236, -0.0286,\n", - " -0.0279, -0.0316, -0.0175, -0.0109, -0.0117, -0.0149, -0.0223, -0.0177,\n", - " -0.0179, -0.0195, -0.0201, -0.0189, -0.0194, -0.0183, -0.0158, -0.0164,\n", - " -0.0163, -0.0134, -0.0123, -0.0121, -0.0120, -0.0117, -0.0121, -0.0112,\n", - " -0.0113, -0.0112, -0.0110, -0.0110, -0.0111, -0.0108, -0.0109, -0.0107,\n", - " -0.0107, -0.0106], device='cuda:0', grad_fn=)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "log_probs tensor([-0.0596], device='cuda:0')\n", - "log_probs tensor([-1.3381], device='cuda:0')\n", - "log_probs tensor([-1.3258, -1.3262, -1.3034, -1.2795, -1.2711, -1.2623, -1.2526, -0.6327,\n", - " -1.2945, -1.1639, -1.4952, -1.4264, -1.2434, -1.5907, -1.3319, -1.5639,\n", - " -1.7715, -0.5916, -0.1001, -0.0836, -0.0882, -0.1100, -0.1221, -0.1155,\n", - " -0.1154, -0.1160, -0.1157, -0.0908, -0.0812, -0.0789, -0.0798, -0.0801,\n", - " -0.0825, -0.0757, -0.0720, -0.0719, -0.0677, -0.0686, -0.0676, -0.0655,\n", - " -0.0635, -0.0625, -0.0615, -0.0606, -0.0605, -0.0587, -0.0596, -0.0596,\n", - " -0.0587, -0.0587], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.2075], device='cuda:0')\n", - "log_probs tensor([-0.0851], device='cuda:0')\n", - "log_probs tensor([-0.0853, -0.0894, -0.0916, -0.0980, -0.0998, -0.0969, -0.0868, -0.1488,\n", - " -0.0432, -0.1149, -0.0989, -0.1055, -0.1507, -0.1588, -0.1008, -0.1406,\n", - " -0.0902, -0.1292, -0.1662, -0.1209, -0.1293, -0.1515, -0.1912, -0.1328,\n", - " -0.1340, -0.1825, -0.2248, -0.2551, -0.2556, -0.2477, -0.2363, -0.2483,\n", - " -0.2509, -0.2336, -0.2281, -0.2272, -0.2256, -0.2248, -0.2217, -0.2208,\n", - " -0.2165, -0.2171, -0.2134, -0.2111, -0.2112, -0.2080, -0.2091, -0.2084,\n", - " -0.2077, -0.2073], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0209], device='cuda:0')\n", - "log_probs tensor([-0.1763], device='cuda:0')\n", - "log_probs tensor([-0.1742, -0.1795, -0.1808, -0.1794, -0.1866, -0.1806, -0.1750, -0.0858,\n", - " -0.0326, -0.1616, -0.1693, -0.1404, -0.1806, -0.1811, -0.2330, -0.1810,\n", - " -0.1193, -0.0624, -0.0140, -0.0115, -0.0191, -0.0322, -0.0416, -0.0316,\n", - " -0.0285, -0.0323, -0.0317, -0.0315, -0.0269, -0.0249, -0.0239, -0.0259,\n", - " -0.0276, -0.0265, -0.0256, -0.0257, -0.0249, -0.0246, -0.0237, -0.0236,\n", - " -0.0224, -0.0224, -0.0212, -0.0212, -0.0215, -0.0210, -0.0207, -0.0206,\n", - " -0.0203, -0.0206], device='cuda:0', grad_fn=)\n" - ] - } - ], + "execution_count": null, + "id": "powered-seating", + "metadata": { + "scrolled": true + }, + "outputs": [], "source": [ - "lig = LayerIntegratedGradients(model, emb_layer)\n", - "llm_grad_attr = LLMGradientAttribution(lig, tokenizer)\n", + "def prompt_fn(*examples):\n", + " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", + " subset = [elem for elem in examples if elem]\n", + " if not subset:\n", + " prompt = main_prompt\n", + " else:\n", + " prefix = \"Here are some examples of movie reviews and classification of whether they were Positive or Negative:\\n\"\n", + " prompt = prefix + \" \\n\".join(subset) + \"\\n \" + main_prompt\n", + " return \"[INST] \" + prompt + \"[/INST]\"\n", "\n", - "inp_feature = TextTokenFeature(\n", - " \"Dave lives in Palm Coast, FL and is a lawyer. His personal interests include\", \n", - " tokenizer,\n", - " baselines=0, # UNK\n", - " skip_tokens=[1],\n", + "input_examples = [\n", + " \"'The movie was ok, the actors weren't great' Negative\", \n", + " \"'I loved it, it was an amazing story!' Positive\",\n", + " \"'Total waste of time!!' Negative\", \n", + " \"'Won't recommend' Negative\",\n", + "]\n", + "inp = TextTemplateInput(\n", + " prompt_fn, \n", + " values=input_examples,\n", ")\n", "\n", - "attr_result_10 = llm_grad_attr.attribute(inp_feature)" + "attr_res = sv_llm_attr.attribute(inp)\n", + "\n", + "attr_res.plot_token_attr()" ] }, { "cell_type": "code", - "execution_count": 498, - "id": "5cbc2144", + "execution_count": 85, + "id": "b93835f3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "['▁Pos', 'itive']" ] }, + "execution_count": 85, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "attr_viz_10 = LLMAttrViz(**attr_result_10)\n", - "attr_viz_10.plot_token_attr()" + "attr_res.output_tokens" ] }, { @@ -6156,6 +646,10 @@ } ], "source": [ + "emb_layer = model.get_submodule(\"model.embed_tokens\")\n", + "\n", + "LLMGradientAttribution()\n", + "\n", "inp_feature = TextTokenFeature(\n", " \"Both Canada and France are beautiful countries. Their capitals are\", \n", " tokenizer,\n", @@ -6187,302 +681,6 @@ "attr_viz_11 = LLMAttrViz(**attr_result_11)\n", "attr_viz_11.plot_token_attr()" ] - }, - { - "cell_type": "code", - "execution_count": 539, - "id": "a2cc305d", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "530f82aac0db4cdb88697b058d8fd8db", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading (…)lve/main/config.json: 0%| | 0.00/665 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "attr_viz_12 = LLMAttrViz(**attr_result_12)\n", - "attr_viz_12.plot_token_attr()" - ] - }, - { - "cell_type": "code", - "execution_count": 547, - "id": "cc32e100", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'input_ids': [44045, 3160, 287, 6182, 11, 8779, 290, 318, 257, 11949, 13, 2332, 2614, 5353, 2291], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}" - ] - }, - "execution_count": 547, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 596, - "id": "ffabc623", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", - "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'input_ids': tensor([[27984, 3160, 287, 18358, 8545, 11, 9977, 290, 318, 257,\n", - " 6853, 13, 2332, 2614, 5353, 2291]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n" - ] - }, - { - "data": { - "text/plain": [ - "'Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include the law, politics'" - ] - }, - "execution_count": 596, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gpt_inps = gpt_tokenizer(\"Dave lives in Palm Coast, FL and is a lawyer. Her personal interests include\", return_tensors='pt')\n", - "print(gpt_inps)\n", - "gpt_output = gpt_model.generate(gpt_inps[\"input_ids\"])\n", - "\n", - "gpt_tokenizer.decode(gpt_output[0])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 584, - "id": "7d457bd1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[[ -44.9375, -43.5938, -47.0938, ..., -52.5000, -52.2500,\n", - " -45.3125],\n", - " [-113.3125, -112.9375, -121.3750, ..., -122.9375, -121.0000,\n", - " -115.6250],\n", - " [ -81.3750, -80.0000, -84.9375, ..., -87.1250, -87.3125,\n", - " -82.3750],\n", - " ...,\n", - " [-118.3750, -116.0625, -120.3125, ..., -119.7500, -123.8750,\n", - " -116.3750],\n", - " [ -98.8750, -98.5625, -102.5625, ..., -106.5625, -105.3125,\n", - " -96.6250],\n", - " [ -89.6250, -88.8125, -92.3125, ..., -95.5000, -94.9375,\n", - " -88.5625]]], dtype=torch.float16, grad_fn=)" - ] - }, - "execution_count": 584, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gpt_model(gpt_inps[\"input_ids\"]).logits" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "db4abb82", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From fc98c3bdabf1e21bf2f6d9fc9a17ca1b96de98f2 Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Mon, 1 Jan 2024 17:58:52 -0800 Subject: [PATCH 09/11] llm attr --- tutorials/LLama2-Captum-Demo.ipynb | 276 +++++------------------------ 1 file changed, 45 insertions(+), 231 deletions(-) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/LLama2-Captum-Demo.ipynb index a83a87861f..e3a187bcb6 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/LLama2-Captum-Demo.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 1, "id": "inside-current", "metadata": {}, "outputs": [], @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "driven-privacy", "metadata": {}, "outputs": [], @@ -87,28 +87,14 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 3, "id": "exclusive-ministry", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2e5220b4f9c34f30a9a709bbc04cd206", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Downloading shards: 0%| | 0/3 [00:00\n", ")\n", "\n", "target = \"playing guitar, hiking, and spending time with his family.\"\n", @@ -251,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 7, "id": "dc68909e", "metadata": {}, "outputs": [ @@ -279,20 +245,10 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "id": "0aebdd52", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -305,7 +261,7 @@ } ], "source": [ - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { @@ -322,20 +278,10 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 9, "id": "0673a936", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -357,7 +303,7 @@ "\n", "attr_res = llm_attr.attribute(inp, target=target)\n", "\n", - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { @@ -372,20 +318,10 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 10, "id": "lined-eating", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -406,7 +342,7 @@ "\n", "attr_res = llm_attr.attribute(inp, target=target)\n", "\n", - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { @@ -423,23 +359,13 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 11, "id": "breathing-sound", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -466,7 +392,7 @@ "\n", "attr_res = llm_attr.attribute(inp, target=target, num_trials=3)\n", "\n", - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { @@ -478,28 +404,18 @@ "\n", "To address this, we can apply alternate perturbation-based attribution methods available in Captum such as ShapleyValue(Sampling), KernelShap and Lime, which ablate different subgroups of features and may result in more accurate scores.\n", "\n", - "We will use `ShapleyValue` below because we essentially only have three features now after grouping. The computation is tracable." + "We will use `ShapleyValue` below because we essentially only have three features now after grouping. The computation is tractable." ] }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 12, "id": "iraqi-gibson", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -515,7 +431,7 @@ "\n", "attr_res = sv_llm_attr.attribute(inp, target=target, num_trials=3)\n", "\n", - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { @@ -528,12 +444,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "powered-seating", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def prompt_fn(*examples):\n", " main_prompt = \"Decide if the following movie review enclosed in quotes is Positive or Negative:\\n'I really liked the Avengers, it had a captivating plot!'\\nReply only Positive or Negative.\"\n", @@ -558,128 +485,15 @@ "\n", "attr_res = sv_llm_attr.attribute(inp)\n", "\n", - "attr_res.plot_token_attr()" + "attr_res.plot_token_attr(show=True)" ] }, { - "cell_type": "code", - "execution_count": 85, - "id": "b93835f3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['▁Pos', 'itive']" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "attr_res.output_tokens" - ] - }, - { - "cell_type": "code", - "execution_count": 503, - "id": "b2387886", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "log_probs tensor([-1.6702], device='cuda:0')\n", - "log_probs tensor([-11.6209], device='cuda:0')\n", - "log_probs tensor([-11.6196, -13.1850, -13.6289, -11.8115, -10.9584, -10.8725, -10.8887,\n", - " -11.0517, -12.4454, -12.3448, -11.4665, -13.3972, -12.4931, -10.5451,\n", - " -11.7205, -11.8162, -11.2747, -10.8822, -11.5802, -10.8118, -7.8154,\n", - " -7.5461, -8.7099, -8.8438, -6.2957, -0.9970, -0.4526, -0.4897,\n", - " -0.5069, -0.5451, -0.6533, -0.7891, -0.9134, -0.9663, -1.0652,\n", - " -1.1914, -1.2986, -1.4371, -1.5030, -1.5316, -1.5561, -1.5857,\n", - " -1.5955, -1.5967, -1.6409, -1.6452, -1.6422, -1.6383, -1.6367,\n", - " -1.6722], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0028], device='cuda:0')\n", - "log_probs tensor([-9.7633], device='cuda:0')\n", - "log_probs tensor([-9.6995e+00, -9.7178e+00, -9.6750e+00, -9.6096e+00, -9.5780e+00,\n", - " -9.5400e+00, -9.4322e+00, -8.9115e+00, -3.4575e+00, -2.8064e+00,\n", - " -2.8352e+00, -2.1759e+00, -1.5783e+00, -2.2325e+00, -1.1509e+00,\n", - " -1.6164e+00, -1.9960e+00, -2.7684e+00, -3.9720e+00, -1.8793e+00,\n", - " -1.0121e-02, -2.1858e-02, -3.9189e-02, -3.6149e-02, -2.8183e-02,\n", - " -2.2928e-02, -1.6638e-02, -1.0761e-02, -1.0007e-02, -1.0310e-02,\n", - " -1.0101e-02, -9.6416e-03, -8.9785e-03, -8.4362e-03, -7.3081e-03,\n", - " -6.0661e-03, -5.0096e-03, -4.3436e-03, -4.0257e-03, -3.6811e-03,\n", - " -3.3913e-03, -3.2756e-03, -3.1172e-03, -3.0715e-03, -2.9740e-03,\n", - " -2.9545e-03, -2.9082e-03, -2.7982e-03, -2.7951e-03, -2.8760e-03],\n", - " device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.1655], device='cuda:0')\n", - "log_probs tensor([-3.5733], device='cuda:0')\n", - "log_probs tensor([-3.5995, -3.5994, -3.6710, -3.7234, -3.7342, -3.7042, -3.6184, -3.6426,\n", - " -5.6745, -5.9610, -6.4531, -5.6245, -5.3044, -5.6563, -4.9139, -5.1317,\n", - " -5.0820, -5.3189, -3.0807, -0.5243, -0.0929, -0.0425, -0.0482, -0.0539,\n", - " -0.0427, -0.0270, -0.0288, -0.0390, -0.0500, -0.0693, -0.0964, -0.1072,\n", - " -0.1075, -0.1110, -0.1176, -0.1261, -0.1277, -0.1330, -0.1435, -0.1514,\n", - " -0.1525, -0.1577, -0.1594, -0.1598, -0.1588, -0.1610, -0.1600, -0.1599,\n", - " -0.1590, -0.1637], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-0.0236], device='cuda:0')\n", - "log_probs tensor([-6.9556], device='cuda:0')\n", - "log_probs tensor([-6.9536, -6.9546, -7.0525, -7.1391, -7.1825, -7.1824, -7.2133, -7.3497,\n", - " -6.2502, -6.4195, -7.1589, -7.0065, -7.2657, -7.5917, -6.6775, -7.0575,\n", - " -6.5688, -4.7888, -2.8797, -1.7950, -0.0873, -0.0646, -0.1366, -0.1431,\n", - " -0.1098, -0.0613, -0.0464, -0.0488, -0.0493, -0.0431, -0.0349, -0.0301,\n", - " -0.0267, -0.0263, -0.0250, -0.0229, -0.0210, -0.0203, -0.0208, -0.0218,\n", - " -0.0207, -0.0213, -0.0223, -0.0229, -0.0223, -0.0234, -0.0253, -0.0243,\n", - " -0.0239, -0.0244], device='cuda:0', grad_fn=)\n", - "log_probs tensor([-1.5348], device='cuda:0')\n", - "log_probs tensor([-2.1932], device='cuda:0')\n", - "log_probs tensor([-2.2013, -2.2331, -2.2460, -2.2333, -2.2063, -2.1883, -2.0798, -1.4750,\n", - " -1.6519, -2.0948, -1.9041, -1.5726, -1.5102, -1.6404, -1.7114, -1.8618,\n", - " -1.7982, -1.7944, -0.9950, -0.1761, -0.2472, -0.3988, -0.7632, -0.8285,\n", - " -0.6289, -0.4188, -0.3990, -0.4565, -0.4825, -0.5437, -0.6645, -0.8324,\n", - " -0.9454, -0.9994, -1.0593, -1.1560, -1.2525, -1.3226, -1.3594, -1.4042,\n", - " -1.4330, -1.4632, -1.5011, -1.5119, -1.5220, -1.5228, -1.5382, -1.5396,\n", - " -1.5343, -1.5558], device='cuda:0', grad_fn=)\n" - ] - } - ], - "source": [ - "emb_layer = model.get_submodule(\"model.embed_tokens\")\n", - "\n", - "LLMGradientAttribution()\n", - "\n", - "inp_feature = TextTokenFeature(\n", - " \"Both Canada and France are beautiful countries. Their capitals are\", \n", - " tokenizer,\n", - " baselines=0, # UNK\n", - " skip_tokens=[1],\n", - ")\n", - "\n", - "attr_result_11 = llm_grad_attr.attribute(inp_feature, target=\"Ottawa and Paris.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 504, - "id": "9b200e90", + "cell_type": "markdown", + "id": "faaebc70", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "attr_viz_11 = LLMAttrViz(**attr_result_11)\n", - "attr_viz_11.plot_token_attr()" + "Interestingly, we can see all these few-shot examples we choose actually make the model less likely to correctly label the given review as \"Positive\"." ] } ], From ba9ce1540ca79652f8a2be1795955491a606b95a Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Mon, 1 Jan 2024 18:18:34 -0800 Subject: [PATCH 10/11] llm attr --- ...LLama2-Captum-Demo.ipynb => Llama2_LLM_Attribution.ipynb} | 4 ++-- website/pages/tutorials/index.js | 5 +++++ website/tutorials.json | 4 ++++ 3 files changed, 11 insertions(+), 2 deletions(-) rename tutorials/{LLama2-Captum-Demo.ipynb => Llama2_LLM_Attribution.ipynb} (99%) diff --git a/tutorials/LLama2-Captum-Demo.ipynb b/tutorials/Llama2_LLM_Attribution.ipynb similarity index 99% rename from tutorials/LLama2-Captum-Demo.ipynb rename to tutorials/Llama2_LLM_Attribution.ipynb index e3a187bcb6..1558176c68 100644 --- a/tutorials/LLama2-Captum-Demo.ipynb +++ b/tutorials/Llama2_LLM_Attribution.ipynb @@ -5,7 +5,7 @@ "id": "9bdd6ea2", "metadata": {}, "source": [ - "# Use Captum LLM Attribution to understand Llama2\n", + "# Understanding Llama2 with Captum LLM Attribution\n", "\n", "In this tutorial, we will demonstrate the LLM attribution functionality introduced in Captum v0.7, which makes it a breeze to applying the attribution algorithms to interpret the large langague models (LLM) in text generation. The new functionalities include a series utilities that help you with many common tedious scaffolding required by LLMs like defining intepretable features in text input and handling the sequential predictions. You can also check our paper for more details https://arxiv.org/abs/2312.05491\n", "\n", @@ -490,7 +490,7 @@ }, { "cell_type": "markdown", - "id": "faaebc70", + "id": "aa2739bf", "metadata": {}, "source": [ "Interestingly, we can see all these few-shot examples we choose actually make the model less likely to correctly label the given review as \"Positive\"." diff --git a/website/pages/tutorials/index.js b/website/pages/tutorials/index.js index 6e776c6516..b46ff267d8 100644 --- a/website/pages/tutorials/index.js +++ b/website/pages/tutorials/index.js @@ -85,6 +85,11 @@ class TutorialHome extends React.Component { Using Captum and Integrated Gradients we interpret the output of several test questions and analyze the attribution scores of the text and visual parts of the model. Find the tutorial here. +

Understanding Llama2 with Captum LLM Attribution:

+ This tutorial demonstrates how to easily use the LLM attribution functionality to interpret the large langague models (LLM) in text generation. + It takes Llama2 as the example and shows the step-by-step improvements from the basic attribution setting to more advanced techniques. + Find the tutorial here. +

Interpreting question answering with BERT Part 1:

This tutorial demonstrates how to use Captum to interpret a BERT model for question answering. We use a pre-trained model from Hugging Face fine-tuned on the SQUAD dataset and show how to use hooks to diff --git a/website/tutorials.json b/website/tutorials.json index 80de2d75b1..8486942fb5 100644 --- a/website/tutorials.json +++ b/website/tutorials.json @@ -46,6 +46,10 @@ "id": "Image_and_Text_Classification_LIME", "title": "Interpreting vision and text models with LIME" }, + { + "id": "Llama2_LLM_Attribution", + "title": "Understanding Llama2 with Captum LLM Attribution" + }, { "title": "Interpreting BERT", "children": [ From d0d0632581b07406c92aa588b1b0a9f7929414bb Mon Sep 17 00:00:00 2001 From: Aobo Yang Date: Sun, 7 Jan 2024 22:00:26 -0800 Subject: [PATCH 11/11] llm attr --- tutorials/Llama2_LLM_Attribution.ipynb | 35 +++++--------------------- 1 file changed, 6 insertions(+), 29 deletions(-) diff --git a/tutorials/Llama2_LLM_Attribution.ipynb b/tutorials/Llama2_LLM_Attribution.ipynb index 1558176c68..983abffe08 100644 --- a/tutorials/Llama2_LLM_Attribution.ipynb +++ b/tutorials/Llama2_LLM_Attribution.ipynb @@ -87,33 +87,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "exclusive-ministry", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "98d7482c11974f5fbdef8fdf7714f747", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Loading checkpoint shards: 0%| | 0/3 [00:00