diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml index 68077759..68577f72 100644 --- a/.github/workflows/checks.yml +++ b/.github/workflows/checks.yml @@ -36,15 +36,31 @@ jobs: env: WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }} runs-on: ubuntu-latest + strategy: + matrix: + versions: + - python: "3.10" + torch: "1.13.1" + - python: "3.10" + torch: "2.0.1" + - python: "3.11" + torch: "2.0.1" steps: - name: Checkout code uses: actions/checkout@v3 + - name: Set up python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.versions.python }} + - name: Install dependencies run: | curl -sSL https://install.python-poetry.org | python3 - poetry lock --check - poetry install + export CUDA_VISIBLE_DEVICES=0 + poetry add torch@${{ matrix.versions.torch }}+cpu --source torch_cpu + poetry install --all-extras - name: Unit tests run: make unit diff --git a/.gitignore b/.gitignore index 31f650c1..0bfc5dcc 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ models/ wandb tests/_temp/** tests/**/_temp/** +notebooks/data/** .coverage htmlcov/ diff --git a/examples/datasets/custom-hallway-g8-n100-a_dfs-h20593.zanj b/examples/datasets/custom-hallway-g8-n100-a_dfs-h20593.zanj new file mode 100644 index 00000000..70848975 Binary files /dev/null and b/examples/datasets/custom-hallway-g8-n100-a_dfs-h20593.zanj differ diff --git a/examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj b/examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj new file mode 100644 index 00000000..4c88d9d4 Binary files /dev/null and b/examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj differ diff --git a/maze_transformer/mechinterp/direct_logit_attribution.py b/maze_transformer/mechinterp/direct_logit_attribution.py new file mode 100644 index 00000000..756eab91 --- /dev/null +++ b/maze_transformer/mechinterp/direct_logit_attribution.py @@ -0,0 +1,469 @@ +import datetime +import json +from pathlib import Path +from typing import Literal + +import einops +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import torch +from jaxtyping import Float, Int + +# maze-datset stuff +from maze_dataset import MazeDataset, MazeDatasetConfig +from maze_dataset.tokenization import MazeTokenizer + +# TransformerLens imports +from transformer_lens import ActivationCache + +# mechinterp stuff +from maze_transformer.mechinterp.logit_attrib_task import ( + LOGIT_ATTRIB_TASKS, + DLAProtocolFixed, +) +from maze_transformer.mechinterp.logit_diff import ( + logit_diff_residual_stream, + logits_diff_multi, + residual_stack_to_logit_diff, +) +from maze_transformer.mechinterp.logit_lens import plot_logit_lens +from maze_transformer.mechinterp.plot_attention import plot_attention_final_token +from maze_transformer.mechinterp.plot_logits import plot_logits + +# model stuff +from maze_transformer.training.config import ZanjHookedTransformer + + +def compute_direct_logit_attribution( + model: ZanjHookedTransformer, + cache: ActivationCache, + answer_tokens: Int[torch.Tensor, "n_mazes"], +) -> dict[Literal["heads", "neurons"], Float[np.ndarray, "layer index"]]: + n_layers: int = model.zanj_model_config.model_cfg.n_layers + n_heads: int = model.zanj_model_config.model_cfg.n_heads + d_model: int = model.zanj_model_config.model_cfg.d_model + mlp_dim: int = 4 * d_model + + print(f"{answer_tokens.shape = }") + print(f"{n_layers = }, {n_heads = }, {d_model = }") + print(f"{n_layers * n_heads = }") + print(f"{n_layers * mlp_dim = }") + + # logit diff + avg_diff, diff_direction = logit_diff_residual_stream( + model=model, + cache=cache, + tokens_correct=answer_tokens, + tokens_compare_to=None, + directions=True, + ) + + # per head + per_head_residual, head_labels = cache.stack_head_results( + layer=-1, pos_slice=-1, return_labels=True + ) + + per_head_logit_diffs = residual_stack_to_logit_diff( + residual_stack=per_head_residual, + cache=cache, + logit_diff_directions=diff_direction, + ) + + print(f"{per_head_residual.shape = }") + print(f"{per_head_logit_diffs.shape = }") + + per_head_logit_diffs = einops.rearrange( + per_head_logit_diffs, + "(layer head_index) -> layer head_index", + layer=n_layers, + head_index=n_heads, + ) + + print(f"{per_head_logit_diffs.shape = }") + + # per neuron + per_neuron_residual, neuron_labels = cache.stack_neuron_results( + layer=-1, + pos_slice=-1, + return_labels=True, + ) + + per_neuron_logit_diffs = residual_stack_to_logit_diff( + residual_stack=per_neuron_residual, + cache=cache, + logit_diff_directions=diff_direction, + ) + + print(f"{per_neuron_residual.shape = }") + print(f"{per_neuron_logit_diffs.shape = }") + + per_neuron_logit_diffs = einops.rearrange( + per_neuron_logit_diffs, + "(layer neuron_index) -> layer neuron_index", + layer=n_layers, + neuron_index=mlp_dim, + ) + + print(f"{per_neuron_logit_diffs.shape = }") + + # return + return dict( + heads=per_head_logit_diffs.to("cpu").numpy(), + neurons=per_neuron_logit_diffs.to("cpu").numpy(), + ) + + +def plot_direct_logit_attribution( + model: ZanjHookedTransformer, + cache: ActivationCache, + answer_tokens: Int[torch.Tensor, "n_mazes"], + show: bool = True, +) -> tuple[plt.Figure, plt.Axes, dict[str, Float[np.ndarray, "layer head"]],]: + dla_data: dict[str, torch.Tensor] = compute_direct_logit_attribution( + model=model, + cache=cache, + answer_tokens=answer_tokens, + ) + dla_heads: Float[np.ndarray, "layer head"] = dla_data["heads"] + dla_neurons: Float[np.ndarray, "layer neuron"] = dla_data["neurons"] + + extval_heads: float = np.max(np.abs(dla_heads)) + extval_neurons: float = np.max(np.abs(dla_neurons)) + fig_heads, ax_heads = plt.subplots(figsize=(5, 5)) + fig_neurons, ax_neurons = plt.subplots(figsize=(20, 5)) + + # heads + ax_heads.imshow(dla_heads, cmap="RdBu", vmin=-extval_heads, vmax=extval_heads) + ax_heads.set_xlabel("Head") + ax_heads.set_ylabel("Layer") + plt.colorbar(ax_heads.get_images()[0], ax=ax_heads) + ax_heads.set_title( + f"Logit Difference from each head\n{model.zanj_model_config.name}" + ) + + # neurons + # don't enforce aspect ratio, no blending + ax_neurons.imshow( + dla_neurons, + cmap="RdBu", + vmin=-extval_neurons, + vmax=extval_neurons, + aspect="auto", + interpolation="none", + ) + ax_neurons.set_xlabel("Neuron") + ax_neurons.set_ylabel("Layer") + plt.colorbar(ax_neurons.get_images()[0], ax=ax_neurons) + ax_neurons.set_title( + f"Logit Difference from each neuron\n{model.zanj_model_config.name}" + ) + + if show: + plt.show() + + return (fig_heads, fig_neurons), (ax_heads, ax_neurons), dla_data + + +def _output_codeblock( + data: str | dict, + lang: str = "", +) -> str: + newdata: str = data + + if isinstance(data, dict): + newdata = json.dumps(data, indent=2) + + return f"```{lang}\n{newdata}\n```" + + +def create_report( + model: ZanjHookedTransformer | str | Path, + dataset_cfg_source: MazeDatasetConfig | None, + logit_attribution_task_name: str, + n_examples: int = 100, + out_path: str | Path | None = None, + device: torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu"), +) -> Path: + # setup + # ====================================================================== + torch.set_grad_enabled(False) + + # model and tokenizer + if not isinstance(model, ZanjHookedTransformer): + model = ZanjHookedTransformer.read(model) + tokenizer: MazeTokenizer = model.zanj_model_config.maze_tokenizer + + # dataset cfg + if dataset_cfg_source is None: + dataset_cfg_source = model.zanj_model_config.dataset_cfg + + # output + if out_path is None: + out_path = Path( + f"data/dla_reports/{model.zanj_model_config.name}-{dataset_cfg_source.name}-{logit_attribution_task_name}-n{n_examples}/" + ) + + out_path.mkdir(parents=True, exist_ok=True) + + fig_path: Path = out_path / "figures" + fig_path.mkdir(parents=True, exist_ok=True) + fig_path_md: Path = Path(f"figures") + + output_md_path: Path = out_path / "report.md" + output_md = output_md_path.open("w") + + # write header + output_md.write( + f"""--- +title: Direct Logit Attribution Report +model_name: {model.zanj_model_config.name} +dataset_cfg_name: {dataset_cfg_source.name} +logit_attribution_task_name: {logit_attribution_task_name} +n_examples: {n_examples} +time: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} +--- + +# Direct Logit Attribution Report + +## Model +`{model.zanj_model_config.name}` +{_output_codeblock(model.zanj_model_config.summary(), 'json')} + +## Dataset +`{dataset_cfg_source.name}` +{_output_codeblock(dataset_cfg_source.summary(), 'json')} + +""" + ) + + # task + logit_attribution_task: DLAProtocolFixed = LOGIT_ATTRIB_TASKS[ + logit_attribution_task_name + ] + + # dataset + dataset: MazeDataset = MazeDataset.from_config(dataset_cfg_source) + dataset_tokens: list[list[str]] = dataset.as_tokens( + tokenizer, join_tokens_individual_maze=False + ) + + dataset_prompts: list[list[str]] + dataset_targets: list[str] + dataset_prompts, dataset_targets = logit_attribution_task(dataset_tokens) + dataset_prompts_joined: list[str] = [" ".join(prompt) for prompt in dataset_prompts] + dataset_target_ids: Float[torch.Tensor, "n_mazes"] = torch.tensor( + tokenizer.encode(dataset_targets), dtype=torch.long + ) + + # print some info about dataset + + n_mazes: int = len(dataset) + d_vocab: int = tokenizer.vocab_size + + output_md.write( + f""" + +number of mazes: {n_mazes} +vocabulary size: {d_vocab} + +### First Maze + +full: {_output_codeblock(' '.join(dataset_prompts[0]))} +prompt: {_output_codeblock('[...] ' + dataset_prompts_joined[0][-150:])} +target: {_output_codeblock(dataset_targets[0])} +target id: {_output_codeblock(str(dataset_target_ids[0]))} + +![First maze as raster image]({fig_path_md / 'first_maze.png'}) + +""" + ) + + plt.imsave(fig_path / "first_maze.png", dataset[0].as_pixels()) + + # run model + # ====================================================================== + + logits: Float[torch.Tensor, "n_mazes seq_len d_vocab"] + cache: ActivationCache + logits, cache = model.run_with_cache(dataset_prompts_joined, device=device) + + last_tok_logits: Float[torch.Tensor, "n_mazes d_vocab"] = logits[:, -1, :] + + output_md.write( + f"""# Model Output + +``` +logits.shape: {logits.shape} +cache_shapes: TODO +last_tok_logits.shape: {last_tok_logits.shape} +``` +""" + ) + + plot_logits( + last_tok_logits=last_tok_logits, + target_idxs=dataset_target_ids, + tokenizer=tokenizer, + n_bins=50, + show=False, + ) + plt.savefig(fig_path / "last_tok_logits.png") + output_md.write(f"![last token logits]({fig_path_md / 'last_tok_logits.png'})\n") + + predicted_tokens: list[str] = tokenizer.decode( + last_tok_logits.argmax(dim=-1).tolist() + ) + prediction_correct: Float[torch.Tensor, "n_mazes"] = torch.tensor( + [pred == target for pred, target in zip(predicted_tokens, dataset_targets)] + ) + + output_md.write( + f""" +``` +predicted_tokens.shape: {len(predicted_tokens)} +prediction_correct.shape: {prediction_correct.shape} +prediction_correct.mean(): {prediction_correct.float().mean().item()} +``` +""" + ) + + # logit diff + logit_diff_df: pd.DataFrame = logits_diff_multi( + model=model, + cache=cache, + dataset_target_ids=dataset_target_ids, + last_tok_logits=last_tok_logits, + noise_sigmas=np.logspace(0, 3, 100), + ) + + output_md.write( + f""" +# Logit Difference +``` +logit_diff_df.shape: {logit_diff_df.shape} +``` + +``` +{logit_diff_df} +``` +""" + ) + + # scatter separately for "all" vs "random" + fig, ax = plt.subplots() + for compare_to in ["all", "random"]: + df = logit_diff_df[logit_diff_df["compare_to"] == compare_to] + ax.scatter( + df["result_orig"], + df["result_res"], + label=f"comparing to {compare_to}", + marker="o", + ) + ax.legend() + plt.xlabel("result_orig") + plt.ylabel("result_res") + plt.title("Scatter Plot between result_orig and result_res") + plt.savefig(fig_path / "logit_diff_scatter.png") + output_md.write( + f"![logit difference scatterplot comparison]({fig_path_md / 'logit_diff_scatter.png'})\n" + ) + + # logit lens + logitlens_figax, logitlens_results = plot_logit_lens( + model=model, + cache=cache, + answer_tokens=dataset_target_ids, + show=False, + ) + logitlens_figax[0].savefig(fig_path / "logitlens.png") + output_md.write(f"![logit lens results]({fig_path_md / 'logitlens.png'})\n") + + # direct logit attribution + output_md.write(f"# Direct Logit Attribution") + dla_fig, dla_ax, dla_data = plot_direct_logit_attribution( + model=model, + cache=cache, + answer_tokens=dataset_target_ids, + show=False, + ) + dla_ax.set_title( + f"Logit difference from each head\n{model.zanj_model_config.name}\n'{logit_attribution_task_name}' task" + ) + + dla_fig.savefig(fig_path / "logit_attribution.png") + output_md.write(f"![logit attribution]({fig_path_md / 'logit_attribution.png'})\n") + + # head analysis + # let's try to plot the values of the attention heads for the top and bottom n contributing heads + # (layer, head, value) + top_heads: int = 5 + important_heads: list[tuple[int, int, float]] = sorted( + [ + (i, j, dla_data[i, j]) + for i in range(dla_data.shape[0]) + for j in range(dla_data.shape[1]) + ], + key=lambda x: abs(x[2]), + reverse=True, + )[:top_heads] + # print(f"{important_heads = }") + output_md.write( + f""" +# Head Analysis +top {top_heads} heads: `{important_heads}` +""" + ) + + # plot the attention heads + important_heads_scores = { + f"layer_{i}.head_{j}": ( + c, + cache[f"blocks.{i}.attn.hook_attn_scores"][:, j, :, :].numpy(), + ) + for i, j, c in important_heads + } + + attn_final_tok_output: list[dict] = plot_attention_final_token( + important_heads_scores=important_heads_scores, + prompts=dataset_prompts, + targets=dataset_targets, + mazes=dataset, + tokenizer=tokenizer, + n_mazes=3, + last_n_tokens=20, + exponentiate_scores=False, + maze_colormap_center=0.0, + # important + show_all=False, + print_fmt="latex", + ) + + head_fig_path: Path = fig_path / "head_analysis" + head_fig_path.mkdir(parents=True, exist_ok=True) + head_fig_path_md: Path = fig_path_md / "head_analysis" + + for i, attn_final_tok in enumerate(attn_final_tok_output): + head_info: dict = attn_final_tok["head_info"] + head_lbl: str = head_info["head"] + + attn_final_tok["scores"][0].savefig(head_fig_path / f"scores-{head_lbl}.png") + attn_final_tok["attn_maze"][0].savefig( + head_fig_path / f"attn_maze-{head_lbl}.png" + ) + + output_md.write( + f""" +## Head {head_lbl} +head info: `{head_info}` + +{attn_final_tok['colored_tokens']} + +![scores of attention head over tokens]({head_fig_path_md / f'scores-{head_lbl}.png'}) +![scores of attention head over maze]({head_fig_path_md / f'attn_maze-{head_lbl}.png'}) +""" + ) + + # cleaning up + output_md.flush() + output_md.close() diff --git a/maze_transformer/mechinterp/logit_attrib_task.py b/maze_transformer/mechinterp/logit_attrib_task.py new file mode 100644 index 00000000..6ef67363 --- /dev/null +++ b/maze_transformer/mechinterp/logit_attrib_task.py @@ -0,0 +1,137 @@ +import functools +import typing + +import numpy as np +from jaxtyping import Float +from maze_dataset import SPECIAL_TOKENS + + +def get_token_first_index(search_token: str, token_list: list[str]) -> int: + return token_list.index(search_token) + + +TaskSetup = typing.NamedTuple( + "TaskSetup", + [ + ("prompts", list[list[str]]), + ("targets", str), + ], +) + + +class DLAProtocol(typing.Protocol): + """should take a dataset's tokens, and return a tuple of (prompts, targets)""" + + def __call__(self, dataset_tokens: list[list[str]], **kwargs) -> TaskSetup: + ... + + +class DLAProtocolFixed(typing.Protocol): + """should take a dataset's tokens, and return a tuple of (prompts, targets) + + this variant signifies it's ready to be used -- no keyword arguments are needed + """ + + def __call__(self, dataset_tokens: list[list[str]]) -> TaskSetup: + ... + + +def token_after_fixed_start_token( + dataset_tokens: list[list[str]], + start_token: str = SPECIAL_TOKENS.PATH_START, + offset: int = 1, +) -> TaskSetup: + """in this task, we simply predict the token after `start_token` + + # Parameters: + - `dataset_tokens : list[list[str]]` + list of string-lists + - `start_token : str` + token to look for + (defaults to `SPECIAL_TOKENS.PATH_START`) + - `offset : int` + which token to predict: + 1: the token after `start_token`, given everything up to and including `start_token` + 0: the token at `start_token`, given everything up to and **not** including `start_token` + (defaults to `1`) + + # Returns: + - `TaskSetup` + tuple of (prompts, targets) + """ + + prompts: list[list[str]] = list() + targets: list[str] = list() + + for maze_tokens in dataset_tokens: + path_start_idx: int = get_token_first_index(start_token, maze_tokens) + prompt_tokens: list[str] = maze_tokens[: path_start_idx + offset] + prompts.append(prompt_tokens) + targets.append(maze_tokens[path_start_idx + offset]) + + return TaskSetup(prompts=prompts, targets=targets) + + +def rand_token_in_range( + dataset_tokens: list[list[str]], + start_token: str = SPECIAL_TOKENS.PATH_START, + end_token: str = SPECIAL_TOKENS.PATH_END, + start_offset: int = 1, + end_offset: int = -1, +) -> TaskSetup: + """predict some random token between (non-inclusive) `start_token` and `end_token`""" + n_samples: int = len(dataset_tokens) + + prompts: list[list[str]] = list() + targets: list[str] = list() + positions_p: Float[np.ndarray, "n_samples"] = np.random.uniform(size=(n_samples,)) + + for i, sample_tokens in enumerate(dataset_tokens): + start_idx: int = ( + get_token_first_index(start_token, sample_tokens) + start_offset + ) + end_idx: int = get_token_first_index(end_token, sample_tokens) + end_offset + + selected_token_idx: int + if start_idx < end_idx: + selected_token_idx = int(positions_p[i] * (end_idx - start_idx) + start_idx) + else: + selected_token_idx = start_idx + + prompts.append(sample_tokens[:selected_token_idx]) + targets.append(sample_tokens[selected_token_idx]) + + return TaskSetup(prompts=prompts, targets=targets) + + +LOGIT_ATTRIB_TASKS: dict[str, DLAProtocolFixed] = { + "path_start": functools.partial( + token_after_fixed_start_token, start_token=SPECIAL_TOKENS.PATH_START, offset=0 + ), + "origin_after_path_start": functools.partial( + token_after_fixed_start_token, start_token=SPECIAL_TOKENS.PATH_START, offset=1 + ), + "first_path_choice": functools.partial( + token_after_fixed_start_token, start_token=SPECIAL_TOKENS.PATH_START, offset=2 + ), + "path_end": functools.partial( + token_after_fixed_start_token, start_token=SPECIAL_TOKENS.PATH_END, offset=0 + ), + "final_before_path_end": functools.partial( + token_after_fixed_start_token, start_token=SPECIAL_TOKENS.PATH_END, offset=-1 + ), + "rand_path_token": functools.partial( + rand_token_in_range, + start_token=SPECIAL_TOKENS.PATH_START, + end_token=SPECIAL_TOKENS.PATH_END, + start_offset=1, + end_offset=-1, + ), + "rand_path_token_non_endpoint": functools.partial( + rand_token_in_range, + start_token=SPECIAL_TOKENS.PATH_START, + end_token=SPECIAL_TOKENS.PATH_END, + start_offset=3, + end_offset=-2, + ), +} diff --git a/maze_transformer/mechinterp/logit_diff.py b/maze_transformer/mechinterp/logit_diff.py new file mode 100644 index 00000000..87976659 --- /dev/null +++ b/maze_transformer/mechinterp/logit_diff.py @@ -0,0 +1,198 @@ +# Numerical Computing +import pandas as pd +import torch +from fancy_einsum import einsum +from jaxtyping import Float, Int + +# TransformerLens imports +from transformer_lens import ActivationCache, HookedTransformer + +# model stuff +from maze_transformer.training.config import ZanjHookedTransformer + +LArr = Float[torch.Tensor, "samples"] + + +def residual_stack_to_logit_diff( + residual_stack: Float[torch.Tensor, "components batch d_model"], + cache: ActivationCache, + logit_diff_directions: Float[torch.Tensor, "samples d_model"], +) -> float: + scaled_residual_stack = cache.apply_ln_to_stack( + residual_stack, layer=-1, pos_slice=-1 + ) + + return ( + einsum( + "... batch d_model, batch d_model -> ...", + scaled_residual_stack, + logit_diff_directions, + ) + / logit_diff_directions.shape[0] + ) + + +def logit_diff_direct( + model_logits: Float[torch.Tensor, "samples d_vocab"], + tokens_correct: Int[torch.Tensor, "samples"], + tokens_compare_to: Int[torch.Tensor, "samples"] | None = None, + diff_per_prompt: bool = True, +) -> Float[torch.Tensor, "samples"] | float: + """based on Neel's explanatory notebook + + https://colab.research.google.com/github/neelnanda-io/Easy-Transformer/blob/main/Exploratory_Analysis_Demo.ipynb + + if `tokens_compare_to` is None, then compare to sum of logits on all other tokens + """ + + # logit on the correct answer token for each sample + model_logits_on_correct: LArr = torch.gather( + model_logits, 1, tokens_correct.unsqueeze(1) + ).squeeze(1) + + output_diff: LArr + if tokens_compare_to is None: + # subtract total logits across all other tokens + all_logits: LArr = torch.sum(model_logits, dim=1) + output_diff = model_logits_on_correct - (all_logits - model_logits_on_correct) + else: + # subtract just the logit on the compare_to token + logits_compare_to: LArr = torch.gather( + model_logits, 1, tokens_compare_to.unsqueeze(1) + ).squeeze(1) + output_diff = model_logits_on_correct - logits_compare_to + + assert output_diff.shape == tokens_correct.shape + + if diff_per_prompt: + return output_diff + else: + return output_diff.mean().item() + + # return answer_logits / (all_logits - answer_logits) + + +def logit_diff_residual_stream( + model: ZanjHookedTransformer, + cache: ActivationCache, + tokens_correct: Int[torch.Tensor, "samples"], + tokens_compare_to: Int[torch.Tensor, "samples"] | None = None, + directions: bool = False, +) -> float | tuple[float, torch.Tensor]: + d_vocab: int = model.config.maze_tokenizer.vocab_size + d_model: int = model.config.model_cfg.d_model + + # embed the whole vocab first + vocab_tensor: Float[torch.Tensor, "d_vocab"] = torch.arange( + d_vocab, dtype=torch.long + ) + vocab_residual_directions: Float[ + torch.Tensor, "d_vocab d_model" + ] = model.tokens_to_residual_directions(vocab_tensor) + # get embedding of answer tokens + answer_residual_directions = vocab_residual_directions[tokens_correct] + # get the directional difference between logits and corrent and logits on {all other tokens, comparison tokens} + logit_diff_directions: Float[torch.Tensor, "samples d_model"] + if tokens_compare_to is None: + logit_diff_directions = ( + answer_residual_directions - vocab_residual_directions[~tokens_correct] + ) + else: + logit_diff_directions = ( + answer_residual_directions - vocab_residual_directions[tokens_compare_to] + ) + + # get the values from the cache at the last layer and last token + final_token_residual_stream: Float[torch.Tensor, "samples d_model"] = cache[ + "resid_post", -1 + ][:, -1, :] + + # scaling the values in residual stream with layer norm + scaled_final_token_residual_stream: Float[ + torch.Tensor, "samples d_model" + ] = cache.apply_ln_to_stack( + final_token_residual_stream, + layer=-1, + pos_slice=-1, + ) + + # measure similarity between the logit diff directions and the residual stream at final layer directions + average_logit_diff: float = ( + torch.dot( + scaled_final_token_residual_stream.flatten(), + logit_diff_directions.flatten(), + ) + / logit_diff_directions.shape[0] + ).item() + + if directions: + return average_logit_diff, logit_diff_directions + else: + return average_logit_diff + + +def logits_diff_multi( + model: HookedTransformer, + cache: ActivationCache, + dataset_target_ids: Int[torch.Tensor, "samples"], + last_tok_logits: Float[torch.Tensor, "samples d_vocab"], + noise_sigmas: list[float] = [1, 2, 3, 5, 10], + n_randoms: int = 1, +) -> pd.DataFrame: + d_vocab: int = last_tok_logits.shape[1] + + test_logits: dict[str, Float[torch.Tensor, "samples"]] = { + "target": dataset_target_ids, + "predicted": last_tok_logits.argmax(dim=-1), + "sampled": torch.multinomial( + torch.softmax(last_tok_logits, dim=-1), num_samples=1 + ).squeeze(-1), + **{ + f"noise={s:.2f}": ( + last_tok_logits + s * torch.randn_like(last_tok_logits) + ).argmax(dim=-1) + for s in noise_sigmas + }, + # "random": torch.randint_like(dataset_target_ids, low=0, high=d_vocab), + **{ + f"random_r{i}": torch.randint_like(dataset_target_ids, low=0, high=d_vocab) + for i in range(n_randoms) + }, + } + compare_dict: dict[str, None | Float[torch.Tensor, "samples"]] = { + "all": None, + "random": torch.randint_like(dataset_target_ids, low=0, high=d_vocab), + "target": dataset_target_ids, + } + + outputs: list[dict] = list() + + for k_comp, compare_to in compare_dict.items(): + for k, d in test_logits.items(): + result_orig: float = logit_diff_direct( + model_logits=last_tok_logits, + tokens_correct=d, + diff_per_prompt=False, + tokens_compare_to=compare_to, + ) + result_res: float = logit_diff_residual_stream( + model=model, + cache=cache, + tokens_correct=d, + tokens_compare_to=compare_to, + ) + # print(f"logit diff of {k}\tcompare:\t{'all' if compare_to is None else 'random'}\t{result = }\t{result_res = }") + outputs.append( + dict( + test=k, + compare_to=k_comp, + result_orig=result_orig, + result_res=result_res, + ) + ) + + df_out: pd.DataFrame = pd.DataFrame(outputs) + df_out["diff"] = df_out["result_orig"] - df_out["result_res"] + df_out["ratio"] = df_out["result_orig"] / df_out["result_res"] + + return df_out diff --git a/maze_transformer/mechinterp/logit_lens.py b/maze_transformer/mechinterp/logit_lens.py new file mode 100644 index 00000000..e418502c --- /dev/null +++ b/maze_transformer/mechinterp/logit_lens.py @@ -0,0 +1,109 @@ +import matplotlib.pyplot as plt +import numpy as np +import torch +from jaxtyping import Int + +# TransformerLens imports +from transformer_lens import ActivationCache + +# mechinterp stuff +from maze_transformer.mechinterp.logit_diff import ( + logit_diff_residual_stream, + residual_stack_to_logit_diff, +) + +# model stuff +from maze_transformer.training.config import ZanjHookedTransformer + + +def compute_logit_lens( + model: ZanjHookedTransformer, + cache: ActivationCache, + answer_tokens: Int[torch.Tensor, "n_mazes"], +) -> tuple[ + torch.Tensor, + torch.Tensor, # x/y for diff + torch.Tensor, + torch.Tensor, # x/y for attr +]: + # logit diff + avg_diff, diff_direction = logit_diff_residual_stream( + model=model, + cache=cache, + tokens_correct=answer_tokens, + tokens_compare_to=None, + directions=True, + ) + + accumulated_residual, labels = cache.accumulated_resid( + layer=-1, + incl_mid=True, + pos_slice=-1, + return_labels=True, + ) + + logit_lens_logit_diffs = residual_stack_to_logit_diff( + residual_stack=accumulated_residual, + cache=cache, + logit_diff_directions=diff_direction, + ) + + # logit attribution + per_layer_residual, labels = cache.decompose_resid( + layer=-1, pos_slice=-1, return_labels=True + ) + per_layer_logit_diffs = residual_stack_to_logit_diff( + residual_stack=per_layer_residual, + cache=cache, + logit_diff_directions=diff_direction, + ) + + return ( + # np.arange(model.zanj_model_config.model_cfg.n_layers*2+1)/2, + np.arange(logit_lens_logit_diffs.shape[0]), + logit_lens_logit_diffs.to("cpu").numpy(), + np.arange(per_layer_logit_diffs.shape[0]), + per_layer_logit_diffs.to("cpu").numpy(), + ) + + +def plot_logit_lens( + model: ZanjHookedTransformer, + cache: ActivationCache, + answer_tokens: Int[torch.Tensor, "n_mazes"], + show: bool = True, +) -> tuple[ + tuple[plt.Figure, plt.Axes, plt.Axes], # figure and axes + tuple[ + torch.Tensor, + torch.Tensor, # x/y for diff + torch.Tensor, + torch.Tensor, # x/y for attr + ], +]: + diff_x, diff_y, attr_x, attr_y = compute_logit_lens( + model=model, + cache=cache, + answer_tokens=answer_tokens, + ) + + fig, ax1 = plt.subplots(figsize=(10, 5)) + + ax1.set_xlabel("Layer") + ax1.set_ylabel("Logit Difference", color="tab:blue") + ax1.set_title("Logit Lens") + ax1.plot(diff_x, diff_y, label="Logit Difference", color="tab:blue") + ax1.tick_params(axis="y", labelcolor="tab:blue") + ax1.legend(loc="upper left") + + # create a second y-axis sharing the same x-axis + ax2 = ax1.twinx() + + ax2.set_ylabel("Logit Attribution", color="tab:red") + ax2.plot(attr_x, attr_y, label="Logit Attribution", color="tab:red") + ax2.tick_params(axis="y", labelcolor="tab:red") + ax2.legend(loc="lower right") + + plt.show() + + return (fig, ax1, ax2), (diff_x, diff_y, attr_x, attr_y) diff --git a/maze_transformer/evaluation/plot_attention.py b/maze_transformer/mechinterp/plot_attention.py similarity index 55% rename from maze_transformer/evaluation/plot_attention.py rename to maze_transformer/mechinterp/plot_attention.py index 1910643d..d5a28aa6 100644 --- a/maze_transformer/evaluation/plot_attention.py +++ b/maze_transformer/mechinterp/plot_attention.py @@ -1,9 +1,8 @@ # Generic import typing +from collections import defaultdict # plotting -import IPython -import matplotlib import matplotlib.pyplot as plt # Numerical Computing @@ -16,6 +15,9 @@ from jaxtyping import Float from maze_dataset import CoordTup, MazeDataset, MazeDatasetConfig, SolvedMaze from maze_dataset.plotting import MazePlot +from maze_dataset.plotting.plot_tokens import plot_colored_text +from maze_dataset.plotting.print_tokens import color_tokens_cmap +from maze_dataset.tokenization import MazeTokenizer from maze_dataset.tokenization.token_utils import coord_str_to_tuple_noneable # Utilities @@ -197,6 +199,7 @@ def plot_attentions_on_maze( for idx_attn, (name, attn) in enumerate( zip(self.attention_names, self.attention_tensored) ): + # -------------------------- # empty node values node_values: Float[np.ndarray, "grid_n grid_n"] = np.zeros( self.input_maze.grid_shape @@ -216,6 +219,7 @@ def plot_attentions_on_maze( node_values=node_values, color_map=color_map, ) + # -------------------------- # create a shared figure fig, axs = plt.subplots( @@ -232,32 +236,202 @@ def plot_attentions_on_maze( return fig, axs -def colorize( - tokens: list[str], - weights: list[float], - cmap: matplotlib.colors.Colormap | str = "Blues", - template: str = ' {tok} ', -) -> str: - """given a sequence of tokens and their weights, colorize the tokens according to the weights (output is html) +def mazeplot_attention( + maze: SolvedMaze, + tokens_context: str, + target: str, + attention: Float[np.ndarray, "n_tokens"], + mazeplot: MazePlot | None = None, + cmap: str = "RdBu", + min_for_positive: float = 0.0, + show_other_tokens: bool = True, + fig_ax: tuple[plt.Figure, plt.Axes] | None = None, + colormap_center: None | float | typing.Literal["median", "mean"] = None, +) -> tuple[MazePlot, plt.Figure, plt.Axes]: + # storing attention + node_values: Float[np.ndarray, "grid_n grid_n"] = np.zeros(maze.grid_shape) + total_logits_nonpos = defaultdict(float) + + # get node values for each token + for idx_token, token in enumerate(tokens_context): + coord: CoordTup | None = coord_str_to_tuple_noneable(token) + # TODO: mean/median instead of just sum? + if coord is not None: + node_values[coord[0], coord[1]] += np.sum(attention[idx_token]) + else: + total_logits_nonpos[token] += attention[idx_token] + + # MazePlot attentions + if mazeplot is None: + mazeplot = MazePlot(maze) + + final_prompt_coord: CoordTup | None = coord_str_to_tuple_noneable( + tokens_context[-1] + ) + target_coord: CoordTup | None = coord_str_to_tuple_noneable(target) + + colormap_center_val: float | None + if colormap_center is None: + colormap_center_val = None + elif colormap_center == "median": + colormap_center_val = np.median(attention) + elif colormap_center == "mean": + colormap_center_val = np.mean(attention) + else: + colormap_center_val = colormap_center + + mazeplot.add_node_values( + node_values=node_values, + color_map=cmap, + target_token_coord=target_coord, + preceeding_tokens_coords=[final_prompt_coord] + if final_prompt_coord is not None + else None, + colormap_center=colormap_center_val, + ) + + # set up combined figure + if fig_ax is None: + fig, (ax_maze, ax_other) = plt.subplots( + 2, + 1, + figsize=(7, 7), + height_ratios=[7, 1], + ) + else: + fig, (ax_maze, ax_other) = fig_ax + # set height ratio + mazeplot.plot( + title=f"{attention.min() = }\n{attention.max() = }", + fig_ax=(fig, ax_maze), + ) + + # non-pos tokens attention + total_logits_nonpos_processed: tuple[list[str], list[float]] = tuple( + zip(*sorted(total_logits_nonpos.items(), key=lambda x: x[0])) + ) + + if len(total_logits_nonpos_processed) == 2: + plot_colored_text( + total_logits_nonpos_processed[0], + total_logits_nonpos_processed[1], + cmap=cmap, + ax=ax_other, + fontsize=5, + width_scale=0.01, + char_min=5, + ) + else: + print(f"No non-pos tokens found!\n{total_logits_nonpos_processed = }") + + ax_other.set_title("Non-Positional Tokens Attention") + + return mazeplot, fig, (ax_maze, ax_other) + + +def plot_attention_final_token( + important_heads_scores: dict[ + str, + tuple[float, Float[np.ndarray, "n_mazes n_tokens n_tokens"]], + ], + prompts: list[list[str]], + targets: list[str], + mazes: list[SolvedMaze], + tokenizer: MazeTokenizer, + n_mazes: int = 5, + last_n_tokens: int = 20, + exponentiate_scores: bool = False, + plot_colored_tokens: bool = True, + plot_scores: bool = True, + plot_attn_maze: bool = True, + maze_colormap_center: None | float | typing.Literal["median", "mean"] = None, + show_all: bool = True, + print_fmt: str = "terminal", +) -> list[dict]: + # str, # head info + # str|None, # colored tokens text + # tuple[plt.Figure, plt.Axes]|None, # scores plot + # tuple[plt.Figure, plt.Axes]|None, # attn maze plot + output: list[dict[str, str | None | tuple[plt.Figure, plt.Axes]]] = list() + + for k, (c, v) in important_heads_scores.items(): + head_info: str = f"head: {k}, score: {c = }, {v.shape = }" + if show_all: + print("-" * 80) + print(head_info) + + head_output: dict[str, str | None | tuple[plt.Figure, plt.Axes]] = dict( + head_info_str=head_info, + head_info=dict( + head=k, + score=c, + shape=v.shape, + ), + ) - originally from https://stackoverflow.com/questions/59220488/to-visualize-attention-color-tokens-using-attention-weights - """ + # set up scores across tokens figure + if plot_scores: + scores_fig, scores_ax = plt.subplots(n_mazes, 1) + scores_fig.set_size_inches(30, 4 * n_mazes) + + # set up attention across maze figure + if plot_attn_maze: + mazes_fig, mazes_ax = plt.subplots( + 2, + n_mazes, + figsize=(7 * n_mazes, 7), + height_ratios=[7, 1], + ) - if isinstance(cmap, str): - cmap = matplotlib.cm.get_cmap(cmap) + # for each maze + for i in range(n_mazes): + # process tokens and attention scores + n_tokens_prompt = len(prompts[i]) + n_tokens_view = min(n_tokens_prompt, last_n_tokens) + v_final = v[i][-1] # -1 for last token + if exponentiate_scores: + v_final = np.exp(v_final) + + # print token scores + if plot_colored_tokens: + color_tokens_text: str = color_tokens_cmap( + prompts[i][-n_tokens_view:], + v_final[-n_tokens_view:], + fmt=print_fmt, + labels=(print_fmt == "terminal"), + ) + if show_all: + print(color_tokens_text) - colored_string: str = "" + head_output["colored_tokens"] = color_tokens_text - for word, color in zip(tokens, weights): - color_hex: str = matplotlib.colors.rgb2hex(cmap(color)[:3]) - colored_string += template.format(clr=color_hex, tok=word) + # plot across tokens + if plot_scores: + scores_ax[i].plot( + v_final[-n_tokens_prompt:], + "o", + ) + scores_ax[i].grid(axis="x", which="major", color="black", alpha=0.1) + scores_ax[i].set_xticks(range(n_tokens_prompt), prompts[i], rotation=90) + + head_output["scores"] = (scores_fig, scores_ax) + + # plot attention across maze + if plot_attn_maze: + mazeplot, fig, ax = mazeplot_attention( + maze=mazes[i], + tokens_context=prompts[i][-n_tokens_prompt:], + target=targets[i], + attention=v_final[-n_tokens_prompt:], + fig_ax=(mazes_fig, mazes_ax[:, i]), + colormap_center=maze_colormap_center, + ) - return colored_string + head_output["attn_maze"] = (mazes_fig, mazes_ax) + if show_all: + plt.show() + else: + output.append(head_output) -def _test(): - mystr: str = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est laborum" - tokens: list[str] = mystr.split() - weights: list[float] = np.random.rand(len(tokens)).tolist() - colored: str = colorize(tokens, weights) - IPython.display.display(IPython.display.HTML(colored)) + return output diff --git a/maze_transformer/mechinterp/plot_logits.py b/maze_transformer/mechinterp/plot_logits.py new file mode 100644 index 00000000..3ce7c717 --- /dev/null +++ b/maze_transformer/mechinterp/plot_logits.py @@ -0,0 +1,119 @@ +# Numerical Computing +import matplotlib.pyplot as plt +import numpy as np +import torch +from jaxtyping import Float, Int + +# Our Code +from maze_dataset.tokenization import MazeTokenizer + +_DEFAULT_SUBPLOTS_KWARGS: dict = dict( + figsize=(20, 20), + height_ratios=[3, 1], +) + + +def plot_logits( + last_tok_logits: Float[torch.Tensor, "n_mazes d_vocab"], + target_idxs: Int[torch.Tensor, "n_mazes"], + tokenizer: MazeTokenizer, + n_bins: int = 50, + mark_incorrect: bool = True, + mark_correct: bool = False, + subplots_kwargs: dict | None = None, + show: bool = True, + density: bool = True, + logy: bool = False, +) -> None: + # set up figure + # -------------------------------------------------- + n_mazes: int + d_vocab: int + n_mazes, d_vocab = last_tok_logits.shape + if subplots_kwargs is None: + subplots_kwargs = _DEFAULT_SUBPLOTS_KWARGS + + fig, (ax_all, ax_sum) = plt.subplots( + 2, 1, **{**_DEFAULT_SUBPLOTS_KWARGS, **subplots_kwargs} + ) + + # fig.subplots_adjust(hspace=0.5, bottom=0.1, top=0.9, left=0.1, right=0.9) + + # plot heatmap of logits + # -------------------------------------------------- + # all vocab elements + ax_all.set_xlabel("vocab element logit") + ax_all.set_ylabel("maze index") + # add vocab as xticks + ax_all.set_xticks(ticks=np.arange(d_vocab), labels=tokenizer.token_arr, rotation=90) + ax_all.imshow(last_tok_logits.numpy(), aspect="auto") + # set colorbar + plt.colorbar(ax_all.imshow(last_tok_logits.numpy(), aspect="auto"), ax=ax_all) + + if mark_correct: + # place yellow x at max logit token + ax_all.scatter( + last_tok_logits.argmax(dim=1), + np.arange(n_mazes), + marker="x", + color="yellow", + ) + # place red dot at correct token + ax_all.scatter(target_idxs, np.arange(n_mazes), marker=".", color="red") + if mark_incorrect: + raise ValueError("mark_correct and mark_incorrect cannot both be True") + + if mark_incorrect: + # place a red dot wherever the max logit token is not the correct token + ax_all.scatter( + last_tok_logits.argmax(dim=1)[last_tok_logits.argmax(dim=1) != target_idxs], + np.arange(n_mazes)[last_tok_logits.argmax(dim=1) != target_idxs], + marker=".", + color="red", + ) + + # histogram of logits for correct and incorrect tokens + # -------------------------------------------------- + ax_sum.set_ylabel("probability density" if density else "frequency") + ax_sum.set_xlabel("logit value") + + # get correct token logits + correct_token_logits: Float[torch.Tensor, "n_mazes"] = torch.gather( + last_tok_logits, 1, target_idxs.unsqueeze(1) + ).squeeze(1) + mask = torch.ones(n_mazes, d_vocab, dtype=torch.bool) + mask.scatter_(1, target_idxs.unsqueeze(1), False) + other_token_logits: Float[torch.Tensor, "n_mazes d_vocab-1"] = last_tok_logits[ + mask + ].reshape(n_mazes, d_vocab - 1) + + # plot histogram + bins: Float[np.ndarray, "n_bins"] = np.linspace( + last_tok_logits.min(), last_tok_logits.max(), n_bins + ) + ax_sum.hist( + correct_token_logits.numpy(), + density=density, + bins=bins, + label="correct token", + alpha=0.5, + ) + ax_sum.hist( + other_token_logits.numpy().flatten(), + density=density, + bins=bins, + label="other token", + alpha=0.5, + ) + ax_sum.legend() + if logy: + ax_sum.set_yscale("log") + + if show: + plt.show() + + return fig, (ax_all, ax_sum) + + +def plot_logits_maze(*args, **kwargs): + raise NotImplementedError() diff --git a/maze_transformer/mechinterp/plot_weights.py b/maze_transformer/mechinterp/plot_weights.py new file mode 100644 index 00000000..2deffb7a --- /dev/null +++ b/maze_transformer/mechinterp/plot_weights.py @@ -0,0 +1,196 @@ +import matplotlib.pyplot as plt +import numpy as np +import torch +from jaxtyping import Float, Int +from transformer_lens import HookedTransformer + + +def _weights_plot_helper( + fig: plt.Figure, + ax: plt.Axes, + data: Float[np.ndarray, "inputs_outputs_or_1 n_interesting_neurons"], + title: str, + ylabel: str = None, + cmap: str = "RdBu", +): + # plot heatmap + n_rows: int = data.shape[0] + singlerow: bool = n_rows == 1 + vbound: float = np.max(np.abs(data)) + im: plt.AxesImage = ax.imshow( + data, + aspect="auto" if not singlerow else "equal", + interpolation="none", + cmap=cmap, + vmin=-vbound, + vmax=vbound, + ) + # colorbar + fig.colorbar(im, ax=ax) + # other figure adjustments + ax.set_title(title) + if ylabel: + ax.set_ylabel(ylabel) + + if singlerow: + ax.set_yticks([]) + + +def plot_important_neurons( + model: HookedTransformer, + layer: int, + neuron_idxs: Int[np.ndarray, "neuron_idxs"] | None = None, + neuron_dla_data: Float[np.ndarray, "n_layers n_neurons"] | None = None, + n_important_neurons: int = 10, + show: bool = True, +) -> tuple[plt.Figure, plt.Axes]: + """Plot the weights and biases for the selected or most important neurons in a given layer + + - if both of `neuron_idxs` and `neuron_dla_data` are `None`, then all neurons will be plotted + - if a value is provided for `neuron_idxs`, then only those neurons will be plotted + - if a value is provided for `neuron_dla_data`, then the most important neurons will be selected based on the DLA data + """ + + # get dimension info from model state dict (expecting TransformerLens style) + + # state dict + state_dict: dict[str, torch.Tensor] = model.state_dict() + state_dict_keys: list[str] = list(state_dict.keys()) + + # layers + layer_ids: list[int] = sorted( + list( + set( + [ + int(key.split(".")[1]) + for key in state_dict_keys + if key.startswith("blocks.") + ] + ) + ) + ) + n_layers: int = len(layer_ids) + assert n_layers == max(layer_ids) + 1, f"Layers are not contiguous? {layer_ids}" + assert layer_ids == list(range(n_layers)), f"Layers are not contiguous? {layer_ids}" + # handle layer negative indexing + if layer < 0: + layer = layer_ids[layer] + assert layer in layer_ids, f"Layer {layer} not found in {layer_ids}" + + # model dim and hidden dim + d_model: int + n_neurons: int + d_model, n_neurons = state_dict[f"blocks.{layer}.mlp.W_in"].shape + + # dim checks for sanity + assert state_dict[f"blocks.{layer}.mlp.b_in"].shape[0] == n_neurons + assert state_dict[f"blocks.{layer}.mlp.W_out"].shape[0] == n_neurons + assert state_dict[f"blocks.{layer}.mlp.W_out"].shape[1] == d_model + assert state_dict[f"blocks.{layer}.mlp.b_out"].shape[0] == d_model + + # get the neuron indices to plot + + # all neurons if nothing specified + if neuron_idxs is None and neuron_dla_data is None: + neuron_idxs = np.arange(n_neurons) + + # from dla data + if neuron_dla_data is not None: + assert ( + neuron_idxs is None + ), "Cannot provide both neuron_idxs and neuron_dla_data" + + neuron_idxs: np.ndarray = np.argsort(np.abs(neuron_dla_data[layer]))[ + -n_important_neurons: + ][::-1] + + mlp_key_base: str = f"blocks.{layer}.mlp" + + # Cache model state for easier access + model_state = model.state_dict() + + # Create named subplots, tight layout + fig, axes = plt.subplots( + 3 + int(neuron_dla_data is not None), # w_in, b_in, w_out, dla (if applicable) + 1, + figsize=(10, 10), + sharex=True, + gridspec_kw=dict(hspace=0.1, wspace=0.1), + ) + + if neuron_dla_data is not None: + ax_w_in, ax_b_in, ax_w_out, ax_dla = axes + else: + ax_w_in, ax_b_in, ax_w_out = axes + + # Plot in weight + w_in_data = model_state[mlp_key_base + ".W_in"].cpu().numpy()[:, neuron_idxs] + _weights_plot_helper(fig, ax_w_in, w_in_data, "W_in", "input neuron") + + # Plot in bias + b_in_data = model_state[mlp_key_base + ".b_in"].cpu().numpy()[neuron_idxs][None, :] + _weights_plot_helper(fig, ax_b_in, b_in_data, "b_in") + + # Plot out weight + w_out_data = model_state[mlp_key_base + ".W_out"].cpu().numpy()[neuron_idxs, :].T + _weights_plot_helper(fig, ax_w_out, w_out_data, "W_out", "output neuron") + + # Plot DLA + neuron_dla_data = neuron_dla_data[layer][neuron_idxs][None, :] + _weights_plot_helper(fig, ax_dla, neuron_dla_data, "DLA") + + # Show the plot + if show: + plt.show() + + return fig, axes + + +def plot_embeddings( + model: HookedTransformer, token_arr: list[str], show: bool = True +) -> tuple[plt.Figure, plt.Axes]: + # Get the weight matrices for vocab and positional embeddings + W_E: Float[torch.Tensor, "vocab_size d_model"] = model.W_E + W_pos: Float[torch.Tensor, "max_seq_len d_model"] = model.W_pos + + # Make sure they have the same dimension + d_model: int = W_E.shape[1] + assert W_pos.shape[1] == d_model + + # Create the figure and axes + fig, (ax_e, ax_pos) = plt.subplots(2, 1, figsize=(16, 16), sharex=True) + + # Visualize vocab embeddings + vbound_e: float = W_E.abs().max().item() + ax_e.imshow( + W_E.cpu().detach().numpy(), + cmap="RdBu", + aspect="auto", + vmin=-vbound_e, + vmax=vbound_e, + ) + ax_e.set_title("Vocab Embeddings") + ax_e.set_ylabel("vocab item") + ax_e.set_yticks(np.arange(len(token_arr))) + ax_e.set_yticklabels(token_arr, fontsize=5) + fig.colorbar(ax_e.get_images()[0], ax=ax_e) + + # Visualize positional embeddings + vbound_pos: float = W_pos.abs().max().item() + ax_pos.imshow( + W_pos.cpu().detach().numpy(), + cmap="RdBu", + aspect="auto", + vmin=-vbound_pos, + vmax=vbound_pos, + ) + ax_pos.set_title("Positional Embeddings") + ax_pos.set_ylabel("pos vs token embed") + ax_pos.set_xlabel("d_model") + fig.colorbar(ax_pos.get_images()[0], ax=ax_pos) + + # Show the plot + if show: + plt.show() + + return fig, (ax_e, ax_pos) diff --git a/maze_transformer/mechinterp/residual_stream_structure.py b/maze_transformer/mechinterp/residual_stream_structure.py new file mode 100644 index 00000000..86fa7e77 --- /dev/null +++ b/maze_transformer/mechinterp/residual_stream_structure.py @@ -0,0 +1,404 @@ +import itertools +from typing import NamedTuple + +import matplotlib.pyplot as plt + +# numerical +import numpy as np +import seaborn as sns +from jaxtyping import Float + +# maze_dataset +from maze_dataset.constants import _SPECIAL_TOKENS_ABBREVIATIONS +from maze_dataset.tokenization import MazeTokenizer +from maze_dataset.tokenization.token_utils import strings_to_coords + +# scipy +from scipy.spatial.distance import pdist, squareform +from scipy.stats import pearsonr +from sklearn.decomposition import PCA + +# transformerlens +from transformer_lens import HookedTransformer + +# from scipy.spatial.distance import cosine + + +def coordinate_to_color( + coord: tuple[float, float], max_val: float = 1.0 +) -> tuple[float, float, float]: + """Maps a coordinate (i, j) to a unique RGB color""" + coord = np.array(coord) + if max_val < coord.max(): + raise ValueError( + f"max_val ({max_val}) must be at least as large as the largest coordinate ({coord.max()})" + ) + + coord = coord / max_val + + return ( + coord[0] * 0.6 + 0.3, # r + 0.5, # g + coord[1] * 0.6 + 0.3, # b + ) + + +TokenPlottingInfo = NamedTuple( + "TokenPlottingInfo", + token=str, + coord=tuple[float, float] | str, + color=tuple[float, float, float], +) + + +def process_tokens_for_pca(tokenizer: MazeTokenizer) -> list[TokenPlottingInfo]: + tokens_coords: list[str | tuple[int, int]] = strings_to_coords( + tokenizer.token_arr, when_noncoord="include" + ) + tokens_coords_only: list[tuple[int, int]] = strings_to_coords( + tokenizer.token_arr, when_noncoord="skip" + ) + max_coord: int = np.array(tokens_coords_only).max() + # token_idxs_coords: list[int] = tokenizer.encode(tokenizer.coords_to_strings(tokens_coords_only)) + + vocab_coordinates_colored: list[TokenPlottingInfo] = [ + TokenPlottingInfo(*x) + for x in zip( + tokenizer.token_arr, + tokens_coords, + [ + coordinate_to_color(coord, max_val=max_coord) + if isinstance(coord, tuple) + else (0.0, 1.0, 0.0) + for coord in tokens_coords + ], + ) + ] + + return vocab_coordinates_colored + + +EmbeddingsPCAResult = NamedTuple( + "EmbeddingsPCAResult", + result=np.ndarray, + index_map=list[int] | None, + pca_obj=PCA, +) + + +def compute_pca( + model: HookedTransformer, + token_plotting_info: list[TokenPlottingInfo], +) -> dict[str, EmbeddingsPCAResult]: + pca_all: PCA = PCA(svd_solver="full") + pca_coords: PCA = PCA(svd_solver="full") + pca_special: PCA = PCA(svd_solver="full") + + # PCA_RESULTS = pca_all.fit_transform(MODEL.W_E.cpu().numpy().T) + # PCA_RESULTS_COORDS_ONLY = pca_coords.fit_transform(MODEL.W_E[token_idxs_coords].cpu().numpy().T) + + idxs_coords: list[int] = list() + idxs_special: list[int] = list() + + i: int + tokinfo: TokenPlottingInfo + for i, tokinfo in enumerate(token_plotting_info): + if isinstance(tokinfo.coord, tuple): + idxs_coords.append(i) + elif isinstance(tokinfo.coord, str): + idxs_special.append(i) + else: + raise ValueError( + f"unexpected coord type: {type(tokinfo.coord)}\n{tokinfo = }" + ) + + return dict( + all=EmbeddingsPCAResult( + result=pca_all.fit_transform(model.W_E.cpu().numpy().T), + index_map=None, + pca_obj=pca_all, + ), + coords_only=EmbeddingsPCAResult( + result=pca_coords.fit_transform(model.W_E[idxs_coords].cpu().numpy().T), + index_map=idxs_coords, + pca_obj=pca_coords, + ), + special_only=EmbeddingsPCAResult( + result=pca_special.fit_transform(model.W_E[idxs_special].cpu().numpy().T), + index_map=idxs_special, + pca_obj=pca_special, + ), + ) + + +def plot_pca_colored( + pca_results_options: dict[str, EmbeddingsPCAResult], + pca_results_key: str, + vocab_colors: list[tuple], + dim1: int, + dim2: int, + lattice_connections: bool = True, + symlog_scale: float | None = None, + axes_and_centered: bool = True, +) -> tuple[plt.Figure, plt.Axes]: + # set up figure, get PCA results + fig, ax = plt.subplots(figsize=(5, 5)) + pca_result: EmbeddingsPCAResult = pca_results_options[pca_results_key] + + # Store lattice points for drawing connections + lattice_points: tuple[tuple[int, int], tuple[float, float]] = list() + + for i in range(pca_result.result.shape[1]): + # map index if necessary + if pca_result.index_map is not None: + i_map: int = pca_result.index_map[i] + else: + i_map = i + token, coord, color = vocab_colors[i_map] + # plot the point + ax.scatter( + pca_result.result[dim1 - 1, i], + pca_result.result[dim2 - 1, i], + alpha=0.5, + color=color, + ) + if isinstance(coord, str): + # label with the abbreviated token name + ax.text( + pca_result.result[dim1 - 1, i], + pca_result.result[dim2 - 1, i], + _SPECIAL_TOKENS_ABBREVIATIONS[coord], + fontsize=8, + ) + else: + # add to the lattice points list for later + lattice_points.append( + ( + coord, + (pca_result.result[dim1 - 1, i], pca_result.result[dim2 - 1, i]), + ) + ) + + if axes_and_centered: + # find x and y limits + xbound: float = np.max(np.abs(pca_result.result[dim1 - 1])) * 1.1 + ybound: float = np.max(np.abs(pca_result.result[dim2 - 1])) * 1.1 + # set axes limits + ax.set_xlim(-xbound, xbound) + ax.set_ylim(-ybound, ybound) + # plot axes + ax.plot([-xbound, xbound], [0, 0], color="black", alpha=0.5, linewidth=0.5) + ax.plot([0, 0], [-ybound, ybound], color="black", alpha=0.5, linewidth=0.5) + + # add lattice connections + if lattice_connections: + for (i, j), (x, y) in lattice_points: + for (i2, j2), (x2, y2) in lattice_points: + # manhattan distance of 1 + if np.linalg.norm(np.array([i, j]) - np.array([i2, j2]), ord=1) == 1: + # plot a line between the two points + ax.plot( + [x, x2], + [y, y2], + color="red", + alpha=0.2, + linewidth=0.5, + ) + + ax.set_xlabel(f"PC{dim1}") + ax.set_ylabel(f"PC{dim2}") + ax.set_title(f"PCA of Survey Responses:\nPC{dim1} vs PC{dim2}") + + # semi-log scale + if isinstance(symlog_scale, (float, int)): + if symlog_scale > 0: + ax.set_xscale("symlog", linthresh=symlog_scale) + ax.set_yscale("symlog", linthresh=symlog_scale) + + return fig, ax + + +def compute_distances_and_correlation( + embedding_matrix: Float[np.ndarray, "d_vocab d_model"], + tokenizer: MazeTokenizer, + embedding_metric: str = "cosine", + coordinate_metric: str = "euclidean", + show: bool = True, +) -> dict: + """embedding distances passed to pdist from scipy""" + + coord_tokens_ids: dict[str, int] = tokenizer.coordinate_tokens_ids + coord_embeddings: Float[np.ndarray, "n_coord_tokens d_model"] = np.array( + [embedding_matrix[v] for v in coord_tokens_ids.values()] + ) + + # Calculate the pairwise distances in embedding space + embedding_distances: Float[np.ndarray, "n_coord_tokens d_model"] = pdist( + coord_embeddings, + metric=embedding_metric, + ) + # normalize the distance by the maximum distance + embedding_distances /= embedding_distances.max() + + # Convert the distances to a square matrix + embedding_distances_matrix: Float[ + np.ndarray, "n_coord_tokens n_coord_tokens" + ] = squareform(embedding_distances) + + # Calculate the correlation between the embedding and coordinate distances + coordinate_coordinates: Float[np.ndarray, "n_coord_tokens 2"] = np.array( + list(tokenizer.coordinate_tokens_coords.keys()) + ) + coordinate_distances = pdist( + coordinate_coordinates, + metric=coordinate_metric, + ) + correlation, corr_pval = pearsonr(embedding_distances, coordinate_distances) + + return dict( + embedding_distances_matrix=embedding_distances_matrix, + correlation=correlation, + corr_pval=corr_pval, + tokenizer=tokenizer, + embedding_metric=embedding_metric, + coordinate_metric=coordinate_metric, + ) + + +def plot_distances_matrix( + embedding_distances_matrix: Float[np.ndarray, "n_coord_tokens n_coord_tokens"], + tokenizer: MazeTokenizer, + embedding_metric: str, + show: bool = True, + **kwargs, +) -> tuple[plt.Figure, plt.Axes]: + coord_tokens_ids: dict[str, int] = tokenizer.coordinate_tokens_ids + + # Plot the embedding distances + fig, ax = plt.subplots(figsize=(15, 15)) + cax = ax.matshow( + embedding_distances_matrix, + cmap="viridis", + interpolation="none", + ) + ax.grid(which="major", color="white", linestyle="-", linewidth=0.5) + ax.grid(which="minor", color="white", linestyle="-", linewidth=0.0) + fig.colorbar(cax) + + ax.set_xticks(np.arange(len(coord_tokens_ids))) + ax.set_yticks(np.arange(len(coord_tokens_ids))) + ax.set_xticklabels(coord_tokens_ids.keys()) + ax.set_yticklabels(coord_tokens_ids.keys()) + + plt.setp(ax.get_xticklabels(), rotation=90, ha="left", rotation_mode="anchor") + + ax.set_title(f"{embedding_metric} Distances Between Coordinate Embeddings") + ax.grid(False) + + if show: + plt.show() + + return fig, ax + + +def compute_grid_distances( + embedding_distances_matrix: Float[np.ndarray, "n_coord_tokens n_coord_tokens"], + tokenizer: MazeTokenizer, +) -> Float[np.ndarray, "n n n n"]: + n: int = tokenizer.max_grid_size + grid_distances: Float[np.ndarray, "n n n n"] = np.full((n, n, n, n), np.nan) + + for idx, ((x, y), token_id) in enumerate( + tokenizer.coordinate_tokens_coords.items() + ): + # Extract distances for this particular token from the distance matrix + distances: Float[np.ndarray, "n_coord_tokens"] = embedding_distances_matrix[ + idx, : + ] + + # get distances + for (x2, y2), distance in zip( + tokenizer.coordinate_tokens_coords.keys(), distances + ): + grid_distances[x, y, x2, y2] = distance + # coords = np.array(list(tokenizer.coordinate_tokens_coords.keys())) + # grid_distances[x, y, coords[:, 0], coords[:, 1]] = distances + + return grid_distances + + +def plot_distance_grid( + grid_distances: Float[np.ndarray, "n n n n"], + embedding_metric: str, + show: bool = True, +) -> tuple[plt.Figure, plt.Axes]: + n: int = grid_distances.shape[0] + # print(n) + # print(tokenizer.coordinate_tokens_coords) + fig, axs = plt.subplots(n, n, figsize=(20, 20)) + + for i in range(n): + for j in range(n): + ax = axs[i, j] + cax = ax.matshow(grid_distances[i, j], cmap="viridis", interpolation="none") + ax.plot(j, i, "rx") + ax.set_title(f"from ({i},{j})") + # fully remove both major and minor gridlines + ax.grid(False) + + fig.suptitle(f"{embedding_metric} distances grid") + plt.colorbar(cax, ax=axs.ravel().tolist()) + + if show: + plt.show() + + return fig, axs + + +def plot_distance_correlation( + distance_grid: Float[np.ndarray, "n n n n"], + embedding_metric: str, + coordinate_metric: str, + show: bool = False, + **kwargs, +) -> plt.Axes: + n: int = distance_grid.shape[0] + n_coord_tokens: int = n**2 + n_dists: int = ((n_coord_tokens) ** 2 - n_coord_tokens) / 2 + + # Initialize lists to store distances + embedding_distances: list[float] = [] + + # Create an array of points to be used with pdist + points: Float[np.ndarray, "n_coord_tokens 2"] = np.array( + list(itertools.product(range(n), range(n))) + ) + assert points.shape == (n_coord_tokens, 2) + pdist_distances: Float[np.ndarray, "n_dists"] = pdist( + points, metric=coordinate_metric + ) + assert pdist_distances.shape == (n_dists,) + + # Calculate distances in the embedding space using itertools for unique pairs + for idx1, idx2 in zip(*np.triu_indices(len(points), k=1)): + x1, y1 = points[idx1] + x2, y2 = points[idx2] + embedding_distances.append(distance_grid[x1, y1, x2, y2]) + + embedding_distances_np: Float[np.ndarray, "n_dists"] = np.array(embedding_distances) + assert embedding_distances_np.shape == (n_dists,) + + ax = sns.boxplot( + x=pdist_distances, + y=embedding_distances, + color=sns.color_palette()[0], + showfliers=False, + width=0.5, + ) + ax.set_xlabel(f"{coordinate_metric} distance between coordinates") + ax.set_ylabel(f"{embedding_metric} embedding distance") + + if show: + plt.show() + + return ax diff --git a/maze_transformer/training/config.py b/maze_transformer/training/config.py index 97e9d891..16af592a 100644 --- a/maze_transformer/training/config.py +++ b/maze_transformer/training/config.py @@ -408,6 +408,23 @@ class ConfigHolder(SerializableDataclass): loading_fn=_load_maze_tokenizer, ) + # shortcut properties + @property + def d_model(self) -> int: + return self.model_cfg.d_model + + @property + def d_head(self) -> int: + return self.model_cfg.d_head + + @property + def n_layers(self) -> int: + return self.model_cfg.n_layers + + @property + def n_heads(self) -> int: + return self.model_cfg.n_heads + def _set_tok_gridsize_from_dataset(self): self.maze_tokenizer.max_grid_size = self.dataset_cfg.max_grid_n self.maze_tokenizer.clear_cache() @@ -552,7 +569,7 @@ def get_config_multisource( @set_config_class(ConfigHolder) -class ZanjHookedTransformer(ConfiguredModel, HookedTransformer): +class ZanjHookedTransformer(ConfiguredModel[ConfigHolder], HookedTransformer): """A hooked transformer that is configured by a ConfigHolder the inheritance order is critical here -- super() does not call parent, but calls the next class in the MRO diff --git a/maze_transformer/training/training.py b/maze_transformer/training/training.py index 63570b3f..15af763d 100644 --- a/maze_transformer/training/training.py +++ b/maze_transformer/training/training.py @@ -123,6 +123,8 @@ def train( f"will train for {n_batches} batches, {evals_enabled=}, with intervals: {intervals}" ) + # TODO: add model output dir / run name to model.training_records + # start up training # ============================== model.train() diff --git a/maze_transformer/utils/dict_shapes.py b/maze_transformer/utils/dict_shapes.py new file mode 100644 index 00000000..d00b4fbf --- /dev/null +++ b/maze_transformer/utils/dict_shapes.py @@ -0,0 +1,23 @@ +import json + +from muutils.dictmagic import dotlist_to_nested_dict + + +def get_dict_shapes(d: dict[str, "torch.Tensor"]) -> dict[str, tuple[int, ...]]: + """given a state dict or cache dict, compute the shapes and put them in a nested dict""" + return dotlist_to_nested_dict({k: tuple(v.shape) for k, v in d.items()}) + + +def string_dict_shapes(d: dict[str, "torch.Tensor"]) -> str: + """printable version of get_dict_shapes""" + return json.dumps( + dotlist_to_nested_dict( + { + k: str( + tuple(v.shape) + ) # to string, since indent wont play nice with tuples + for k, v in d.items() + } + ), + indent=2, + ) diff --git a/notebooks/demo_dataset.ipynb b/notebooks/demo_dataset.ipynb index aa612675..2b81acb9 100644 --- a/notebooks/demo_dataset.ipynb +++ b/notebooks/demo_dataset.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basics\n", + "\n", + "to start, let's import a few things we'll need:" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -9,25 +19,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "dict_keys(['test-g3-n5-a_dfs-h81250', 'demo_small-g3-n100-a_dfs-h12257', 'demo-g6-n10K-a_dfs-h76502'])\n" + "dict_keys(['test-g3-n5-a_dfs-h75556', 'demo_small-g3-n100-a_dfs-h88371', 'demo-g6-n10K-a_dfs-h30615'])\n" ] } ], "source": [ - "import json\n", - "\n", + "# other package imports\n", "import matplotlib.pyplot as plt # keep this import for CI to work\n", - "from zanj import ZANJ\n", + "from zanj import ZANJ # saving/loading data\n", + "from muutils.mlutils import pprint_summary # pretty printing as json\n", "\n", - "from maze_dataset.generation import LatticeMazeGenerators\n", - "from maze_dataset import SolvedMaze, MazeDataset, MazeDatasetConfig\n", + "# maze_dataset imports\n", + "from maze_dataset import LatticeMaze, SolvedMaze, MazeDataset, MazeDatasetConfig\n", + "from maze_dataset.generation import LatticeMazeGenerators, GENERATORS_MAP\n", + "from maze_dataset.generation.default_generators import DEFAULT_GENERATORS\n", "from maze_dataset.dataset.configs import MAZE_DATASET_CONFIGS\n", "from maze_dataset.plotting import plot_dataset_mazes, print_dataset_mazes\n", - "from muutils.mlutils import pprint_summary\n", "\n", + "# check the configs\n", "print(MAZE_DATASET_CONFIGS.keys())\n", - "\n", - "LOCAL_DATA_PATH: str = \"../data/maze_dataset/\"" + "# for saving/loading things\n", + "LOCAL_DATA_PATH: str = \"../data/maze_dataset/\"\n", + "zanj: ZANJ = ZANJ(external_list_threshold=256)" ] }, { @@ -35,7 +48,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "you should always see `test-g3-n5-a_dfs-h81250` in the list of available dataset configs" + "You should always see `test-g3-n5-a_dfs-h9136` in the list of available dataset configs above.\n", + "\n", + "Now, let's set up our initial config and dataset:" ] }, { @@ -47,19 +62,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "test-g3-n32-a_dfs-h36643\n" + "test-g5-n4-a_dfs-h84708\n" ] } ], "source": [ - "zanj: ZANJ = ZANJ(external_list_threshold=256)\n", "cfg: MazeDatasetConfig = MazeDatasetConfig(\n", - "\tname=\"test\",\n", - "\tgrid_n=3,\n", - "\tn_mazes=32,\n", - "\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", + "\tname=\"test\", # name is only for you to keep track of things\n", + "\tgrid_n=5, # number of rows/columns in the lattice\n", + "\tn_mazes=4, # number of mazes to generate\n", + "\tmaze_ctor=LatticeMazeGenerators.gen_dfs, # algorithm to generate the maze\n", + " # there are a few more arguments here, to be discussed later\n", ")\n", "\n", + "# each config will use this function to get the name of the dataset\n", + "# it contains some basic info about the algorithm, size, and number of mazes\n", + "# at the end after \"h\" is a stable hash of the config to avoid collisions\n", "print(cfg.to_fname())" ] }, @@ -72,6 +90,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "trying to get the dataset 'test-g5-n4-a_dfs-h84708'\n", "generating dataset...\n" ] }, @@ -79,14 +98,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "generating & solving mazes: 100%|██████████| 32/32 [00:00<00:00, 695.67maze/s]" + "generating & solving mazes: 100%|██████████| 4/4 [00:00<00:00, 181.81maze/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "saving dataset to ..\\data\\maze_dataset\\test-g3-n32-a_dfs-h36643.zanj\n" + "saving dataset to ..\\data\\maze_dataset\\test-g5-n4-a_dfs-h84708.zanj\n" ] }, { @@ -100,13 +119,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Got dataset test with 32 items. output.cfg.to_fname() = 'test-g3-n32-a_dfs-h36643'\n" + "Got dataset test with 4 items. output.cfg.to_fname() = 'test-g5-n4-a_dfs-h84708'\n" ] } ], "source": [ + "# to create a dataset, just call MazeDataset.from_config\n", "dataset: MazeDataset = MazeDataset.from_config(\n", + " # your config\n", "\tcfg,\n", + " # and all this below is completely optional\n", "\tdo_download=False,\n", "\tload_local=False,\n", "\tdo_generate=True,\n", @@ -118,75 +140,66 @@ ")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "now that we have our dataset, let's take a look at it!" + ] + }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "loading dataset from ../data/maze_dataset/test-g3-n32-a_dfs-h36643.zanj\n", - "Got dataset test with 32 items. output.cfg.to_fname() = 'test-g3-n32-a_dfs-h36643'\n" - ] + "data": { + "text/plain": [ + "(
,\n", + " array([, , , ], dtype=object))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "dataset_cpy: MazeDataset = MazeDataset.from_config(\n", - "\tcfg,\n", - "\tdo_download=False,\n", - "\tload_local=True,\n", - "\tdo_generate=False,\n", - "\tlocal_base_path=LOCAL_DATA_PATH,\n", - "\tverbose=True,\n", - "\tzanj=zanj,\n", - ")\n" + "plot_dataset_mazes(dataset, count=None) # for large datasets, set the count to some int to just plot the first few" ] }, { - "cell_type": "code", - "execution_count": 5, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "32 32\n", - "SolvedMaze(connection_list=array([[[ True, True, True],\n", - " [ True, False, True],\n", - " [False, False, False]],\n", - "\n", - " [[False, False, False],\n", - " [False, True, False],\n", - " [ True, True, False]]]), generation_meta={'func_name': 'gen_dfs', 'grid_shape': array([3, 3]), 'start_coord': array([0, 1]), 'n_accessible_cells': 9, 'max_tree_depth': 18, 'fully_connected': True, 'visited_cells': [[0, 1], [1, 2], [2, 1], [0, 0], [1, 1], [2, 0], [0, 2], [2, 2], [1, 0]]}, start_pos=array([1, 2]), end_pos=array([0, 0]), solution=array([[1, 2],\n", - " [2, 2],\n", - " [2, 1],\n", - " [2, 0],\n", - " [1, 0],\n", - " [0, 0]]))\n" - ] - } - ], "source": [ - "assert dataset.cfg == dataset_cpy.cfg\n", - "print(len(dataset), len(dataset_cpy))\n", - "print(dataset_cpy[0])\n", - "assert all(x == y for x,y in zip(dataset, dataset_cpy))" + "# Filtering\n", + "\n", + "you can also filter datasets by a variety of parameters:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "len(dataset) = 32\n", - "len(dataset_filtered) = 27\n" + "len(dataset) = 4\n", + "len(dataset_filtered) = 4\n" ] } ], @@ -199,39 +212,25 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(
,\n", - " array([, , , , , ,\n", - " , , , , , ,\n", - " , , , , , ,\n", - " , , , , , ,\n", - " , , ], dtype=object))" + "(
,\n", + " array([, , , ], dtype=object))" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -239,13 +238,12 @@ } ], "source": [ - "plot_dataset_mazes(dataset)\n", - "plot_dataset_mazes(dataset_filtered)\n" + "plot_dataset_mazes(dataset_filtered)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -266,19 +264,20 @@ } ], "source": [ - "print(json.dumps(dataset_filtered.cfg.serialize()[\"applied_filters\"], indent=2))\n", + "pprint_summary(dataset_filtered.cfg.serialize()[\"applied_filters\"])\n", "print(f\"{MazeDataset._FILTER_NAMESPACE = }\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "trying to get the dataset 'test-g5-n4-a_dfs-h59697'\n", "generating dataset...\n" ] }, @@ -286,14 +285,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "generating & solving mazes: 100%|██████████| 27/27 [00:00<00:00, 587.07maze/s]" + "generating & solving mazes: 100%|██████████| 4/4 [00:00<00:00, 233.23maze/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Got dataset test with 24 items. output.cfg.to_fname() = 'test-g3-n24-a_dfs-h71523'\n" + "Got dataset test with 4 items. output.cfg.to_fname() = 'test-g5-n4-a_dfs-h59697'\n" ] }, { @@ -305,6 +304,8 @@ } ], "source": [ + "# filters can also be specified at generation time -- but it will still generate the whole dataset and then filter it\n", + "\n", "dataset_filtered_from_scratch: MazeDataset = MazeDataset.from_config(\n", "\tdataset_filtered.cfg,\n", "\tdo_download=False,\n", @@ -320,28 +321,25 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(
,\n", - " array([, , , , , ,\n", - " , , , , , ,\n", - " , , , , , ,\n", - " , ], dtype=object))" + "(
,\n", + " array([, , , ], dtype=object))" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -349,9 +347,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -366,36 +364,21 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(
,\n", - " array([, , , , , ,\n", - " ], dtype=object))" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "No mazes to plot for dataset\n" + ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -411,9 +394,19 @@ "plot_dataset_mazes(dataset_filtered_custom)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## metadata\n", + "\n", + "by default, each maze stores some metadata about generation in a dictionary. if you don't care about this, you can filter it out (but keep some statistics) to save on storage space:" + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -422,125 +415,113 @@ "text": [ "{\n", " \"func_name\": {\n", - " \"gen_dfs\": 32\n", + " \"gen_dfs\": 4\n", " },\n", " \"grid_shape\": {\n", - " \"(3, 3)\": 32\n", + " \"(5, 5)\": 4\n", " },\n", " \"start_coord\": {\n", - " \"(0, 1)\": 9,\n", - " \"(1, 0)\": 7,\n", - " \"(1, 1)\": 6,\n", - " \"(0, 0)\": 10\n", + " \"(2, 3)\": 1,\n", + " \"(0, 3)\": 1,\n", + " \"(0, 1)\": 1,\n", + " \"(1, 3)\": 1\n", " },\n", " \"n_accessible_cells\": {\n", - " \"9\": 32\n", + " \"25\": 4\n", " },\n", " \"max_tree_depth\": {\n", - " \"18\": 32\n", + " \"50\": 4\n", " },\n", " \"fully_connected\": {\n", - " \"True\": 32\n", + " \"True\": 4\n", " },\n", - " \"visited_cells\": {\n", - " \"(0, 1)\": 32,\n", - " \"(1, 2)\": 32,\n", - " \"(2, 1)\": 32,\n", - " \"(0, 0)\": 32,\n", - " \"(1, 1)\": 32,\n", - " \"(2, 0)\": 32,\n", - " \"(0, 2)\": 32,\n", - " \"(2, 2)\": 32,\n", - " \"(1, 0)\": 32\n", - " }\n", + " \"visited_cells\": \"...\"\n", "}\n" ] } ], "source": [ "dataset_with_meta = dataset.filter_by.collect_generation_meta()\n", - "\n", - "pprint_summary(dataset_with_meta.serialize()['generation_metadata_collected'])" + "metadata = dataset_with_meta.serialize()['generation_metadata_collected']\n", + "metadata[\"visited_cells\"] = \"...\" # this is a huge list and unweildy to print\n", + "pprint_summary(metadata)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# output formats" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "generating dataset...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 32/32 [00:00<00:00, 344.07maze/s]" + "ASCII:\n", + "\n", + "###########\n", + "# XXX# #\n", + "# ###X#X# #\n", + "# #X#S #\n", + "#####X#####\n", + "#XXXXX#EXX#\n", + "#X### ###X#\n", + "#X# #X#\n", + "#X#######X#\n", + "#XXXXXXXXX#\n", + "###########\n", + "\n", + "Raw tokens:\n", + "\n", + " (0,0) <--> (1,0) ; (2,0) <--> (3,0) ; (4,1) <--> (4,0) ; (2,0) <--> (2,1) ; (1,0) <--> (1,1) ; (3,4) <--> (2,4) ; (4,2) <--> (4,3) ; (0,0) <--> (0,1) ; (0,3) <--> (0,2) ; (4,4) <--> (3,4) ; (4,3) <--> (4,4) ; (4,1) <--> (4,2) ; (2,1) <--> (2,2) ; (1,4) <--> (0,4) ; (1,2) <--> (0,2) ; (2,4) <--> (2,3) ; (4,0) <--> (3,0) ; (2,2) <--> (3,2) ; (1,2) <--> (2,2) ; (1,3) <--> (0,3) ; (3,2) <--> (3,3) ; (0,2) <--> (0,1) ; (3,1) <--> (3,2) ; (1,3) <--> (1,4) ; (1,3) (2,3) (1,3) (0,3) (0,2) (1,2) (2,2) (2,1) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) (3,4) (2,4) (2,3) \n", + "\n", + "Colored tokens, raw html:\n", + "\n", + " <ADJLIST_START> (0,0) <--> (1,0) ; (2,0) <--> (3,0) ; (4,1) <--> (4,0) ; (2,0) <--> (2,1) ; (1,0) <--> (1,1) ; (3,4) <--> (2,4) ; (4,2) <--> (4,3) ; (0,0) <--> (0,1) ; (0,3) <--> (0,2) ; (4,4) <--> (3,4) ; (4,3) <--> (4,4) ; (4,1) <--> (4,2) ; (2,1) <--> (2,2) ; (1,4) <--> (0,4) ; (1,2) <--> (0,2) ; (2,4) <--> (2,3) ; (4,0) <--> (3,0) ; (2,2) <--> (3,2) ; (1,2) <--> (2,2) ; (1,3) <--> (0,3) ; (3,2) <--> (3,3) ; (0,2) <--> (0,1) ; (3,1) <--> (3,2) ; (1,3) <--> (1,4) ; <ADJLIST_END>   <ORIGIN_START> (1,3) <ORIGIN_END>   <TARGET_START> (2,3) <TARGET_END>   <PATH_START> (1,3) (0,3) (0,2) (1,2) (2,2) (2,1) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) (3,4) (2,4) (2,3) <PATH_END> \n", + "\n", + "Colored tokens, raw latex:\n", + "\n", + "\\colorbox[RGB]{ 234,209,220 }{ \\texttt{ (0,0) <--> (1,0) ; (2,0) <--> (3,0) ; (4,1) <--> (4,0) ; (2,0) <--> (2,1) ; (1,0) <--> (1,1) ; (3,4) <--> (2,4) ; (4,2) <--> (4,3) ; (0,0) <--> (0,1) ; (0,3) <--> (0,2) ; (4,4) <--> (3,4) ; (4,3) <--> (4,4) ; (4,1) <--> (4,2) ; (2,1) <--> (2,2) ; (1,4) <--> (0,4) ; (1,2) <--> (0,2) ; (2,4) <--> (2,3) ; (4,0) <--> (3,0) ; (2,2) <--> (3,2) ; (1,2) <--> (2,2) ; (1,3) <--> (0,3) ; (3,2) <--> (3,3) ; (0,2) <--> (0,1) ; (3,1) <--> (3,2) ; (1,3) <--> (1,4) ; } } \\colorbox[RGB]{ 217,210,233 }{ \\texttt{ (1,3) } } \\colorbox[RGB]{ 207,226,243 }{ \\texttt{ (2,3) } } \\colorbox[RGB]{ 217,234,211 }{ \\texttt{ (1,3) (0,3) (0,2) (1,2) (2,2) (2,1) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) (3,4) (2,4) (2,3) } }\n", + "\n", + "Colored tokens, terminal:\n", + "\n", + "\u001b[30m\u001b[48;2;234;209;220m (0,0) <--> (1,0) ; (2,0) <--> (3,0) ; (4,1) <--> (4,0) ; (2,0) <--> (2,1) ; (1,0) <--> (1,1) ; (3,4) <--> (2,4) ; (4,2) <--> (4,3) ; (0,0) <--> (0,1) ; (0,3) <--> (0,2) ; (4,4) <--> (3,4) ; (4,3) <--> (4,4) ; (4,1) <--> (4,2) ; (2,1) <--> (2,2) ; (1,4) <--> (0,4) ; (1,2) <--> (0,2) ; (2,4) <--> (2,3) ; (4,0) <--> (3,0) ; (2,2) <--> (3,2) ; (1,2) <--> (2,2) ; (1,3) <--> (0,3) ; (3,2) <--> (3,3) ; (0,2) <--> (0,1) ; (3,1) <--> (3,2) ; (1,3) <--> (1,4) ; \u001b[0m \u001b[30m\u001b[48;2;217;210;233m (1,3) \u001b[0m \u001b[30m\u001b[48;2;207;226;243m (2,3) \u001b[0m \u001b[30m\u001b[48;2;217;234;211m (1,3) (0,3) (0,2) (1,2) (2,2) (2,1) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) (3,4) (2,4) (2,3) \u001b[0m\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\maze_dataset\\test_disconnected-g10-n32-a_dfs-h88647.zanj\n", - "Got dataset test_disconnected with 32 items. output.cfg.to_fname() = 'test_disconnected-g10-n32-a_dfs-h88647'\n" - ] + "data": { + "text/html": [ + " <ADJLIST_START> (0,0) <--> (1,0) ; (2,0) <--> (3,0) ; (4,1) <--> (4,0) ; (2,0) <--> (2,1) ; (1,0) <--> (1,1) ; (3,4) <--> (2,4) ; (4,2) <--> (4,3) ; (0,0) <--> (0,1) ; (0,3) <--> (0,2) ; (4,4) <--> (3,4) ; (4,3) <--> (4,4) ; (4,1) <--> (4,2) ; (2,1) <--> (2,2) ; (1,4) <--> (0,4) ; (1,2) <--> (0,2) ; (2,4) <--> (2,3) ; (4,0) <--> (3,0) ; (2,2) <--> (3,2) ; (1,2) <--> (2,2) ; (1,3) <--> (0,3) ; (3,2) <--> (3,3) ; (0,2) <--> (0,1) ; (3,1) <--> (3,2) ; (1,3) <--> (1,4) ; <ADJLIST_END>   <ORIGIN_START> (1,3) <ORIGIN_END>   <TARGET_START> (2,3) <TARGET_END>   <PATH_START> (1,3) (0,3) (0,2) (1,2) (2,2) (2,1) (2,0) (3,0) (4,0) (4,1) (4,2) (4,3) (4,4) (3,4) (2,4) (2,3) <PATH_END> " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "dataset_not_fully_connected = MazeDataset.from_config(\n", - "\tMazeDatasetConfig(\n", - "\t\tname=\"test_disconnected\",\n", - "\t\tgrid_n=10,\n", - "\t\tn_mazes=32,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", - " maze_ctor_kwargs=dict(\n", - "\t\t\tn_accessible_cells = 70,\n", - " \tmax_tree_depth = 15,\n", - "\t\t),\n", - "\t),\n", - "\tdo_download=False,\n", - "\tload_local=False,\n", - "\tdo_generate=True,\n", - "\tsave_local=True,\n", - "\tlocal_base_path=LOCAL_DATA_PATH,\n", - "\tverbose=True,\n", - "\tzanj=zanj,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAW3UlEQVR4nO3dXYxU9fnA8WeAMlADo2hZ2AK6NaaoKLUiRGna/MNGYojRNjFtgw3ViyZmLSBJq7YB0lhd0dQ0KsGXC7Wpor0oviW2IVQxRN4U8CW2gJHUjXZBE51BrKvZPf8L28UVEC2zPLPL55P8LvbM7J4nh9nzzZkdZkpFURQBAEfZkOwBADg2CRAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkGJY9wGf19PTEW2+9FaNGjYpSqZQ9DgBfUlEUsXfv3mhubo4hQw59ndNwAXrrrbdi4sSJ2WMAcIQ6OjpiwoQJh7y94Z6CGzVqVPYIANTB4c7nDRcgT7sBDA6HO583XIAAODYIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABS9FuAli9fHqecckqMGDEiZsyYEZs2beqvXQEwAPVLgB555JFYtGhRLF26NLZs2RJTp06N2bNnx549e/pjdwAMREU/mD59etHW1tb7dXd3d9Hc3Fy0t7cf9nur1WoREZZlWdYAX9Vq9XPP93W/Avroo4/ihRdeiNbW1t5tQ4YMidbW1li/fv0B9+/q6opardZnATD41T1A77zzTnR3d0dTU1Of7U1NTdHZ2XnA/dvb26NSqfQunwUEcGxIfxXc9ddfH9VqtXd1dHRkjwTAUVD3T0Q96aSTYujQobF79+4+23fv3h3jxo074P7lcjnK5XK9xwCgwdX9Cmj48OFx7rnnxpo1a3q39fT0xJo1a+L888+v9+4AGKDqfgUUEbFo0aKYN29eTJs2LaZPnx6///3vY9++fXHFFVf0x+4AGID6JUA//OEP4+23344lS5ZEZ2dnfOtb34q//OUvB7wwAYBjV6koiiJ7iE+r1WpRqVSyxwDgCFWr1Rg9evQhb09/FRwAxyYBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIgRb+8F9xg0WDvUkSDKJWyJ+BAjfGP0gjnjNIAeoC6AgIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRAimHZA/D5SqVS9ggcoMge4D8a4bHRKMeCgcgVEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkKLuAWpvb4/zzjsvRo0aFWPHjo1LL700tm/fXu/dADDA1T1Aa9eujba2ttiwYUOsXr06Pv7447jwwgtj37599d4VAANYqSiKfv1Aj7fffjvGjh0ba9euje9+97uHvX+tVotKpdKfI31h/XxovhCfB9SI8h8Xn2iEx4Zj8WnOGX1Vq9UYPXr0IW/v9w+kq1arERExZsyYg97e1dUVXV1dvV/XarX+HgmABtCvL0Lo6emJhQsXxsyZM2PKlCkHvU97e3tUKpXeNXHixP4cCYAG0a9PwV111VXx1FNPxbp162LChAkHvc/BroAaJUIupzm4/MfFJxrhseFYfJpzRl9pT8FdffXV8eSTT8azzz57yPhERJTL5SiXy/01BgANqu4BKooifv7zn8eqVavimWeeiZaWlnrvAoBBoO4Bamtri4ceeigee+yxGDVqVHR2dkZERKVSiZEjR9Z7dwAMUHX/G9Chnn+877774qc//elhv9/LsPtqpOdz+a/8x8UnGuGx4Vh8mnNGX0f9b0CN8A8AQOPzXnAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKTo9w+k48h4Z4n9GuktRviPojH+TYqGeUsgvgxXQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIMSx7gEZWKpWyR4DG1iC/IqVGGYQvxRUQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQot8DdPPNN0epVIqFCxf2964AGED6NUCbN2+Ou+++O84+++z+3A0AA1C/Bej999+PuXPnxr333hsnnHBCf+0GgAGq3wLU1tYWc+bMidbW1s+9X1dXV9RqtT4LgMGvXz4R9eGHH44tW7bE5s2bD3vf9vb2+M1vftMfYwDQwOp+BdTR0RELFiyIBx98MEaMGHHY+19//fVRrVZ7V0dHR71HAqABlYqiKOr5Ax999NH4/ve/H0OHDu3d1t3dHaVSKYYMGRJdXV19bvusWq0WlUqlniNBndX1V+YIlLIHgM9VrVZj9OjRh7y97k/BzZo1K15++eU+26644oqYPHlyXHvttZ8bHwCOHXUP0KhRo2LKlCl9th133HFx4oknHrAdgGOXd0IAIEXd/wZ0pPwNiMbXKL8y/gZEYzvc34BcAQGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkKJfPg9o8GiU//EOjalRfkNKDTNJIxg475DhCgiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBTDsgfgcErZA/AZRVFkjxAREaUGeGg0wAj/0SiTNMZjY6BwBQRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASNEvAXrzzTfj8ssvjxNPPDFGjhwZZ511Vjz//PP9sSsABqi6vxv2u+++GzNnzoz/+7//i6eeeiq+9rWvxc6dO+OEE06o964AGMDqHqBly5bFxIkT47777uvd1tLSUu/dADDA1f0puMcffzymTZsWl112WYwdOzbOOeecuPfeew95/66urqjVan0WAINf3QP0+uuvx4oVK+K0006Lv/71r3HVVVfF/Pnz44EHHjjo/dvb26NSqfSuiRMn1nskABpQqajzxzsOHz48pk2bFs8991zvtvnz58fmzZtj/fr1B9y/q6srurq6er+u1WoNFKFG+HTDRvmkR/6rcT4R1WOj8TTCY6NxHhfVajVGjx59yNvrfgU0fvz4OOOMM/psO/300+ONN9446P3L5XKMHj26zwJg8Kt7gGbOnBnbt2/vs23Hjh1x8skn13tXAAxgdQ/QNddcExs2bIibbropXnvttXjooYfinnvuiba2tnrvCoCBrOgHTzzxRDFlypSiXC4XkydPLu65554v/L3VarWIT55IbYBVNMDKPgbWZ1ejyD4O1sFW9vmisR4X1Wr1cx/DdX8RwpGq1WpRqVSyx/iPRjg0jfMHRT7RKL8yXoTQiBrhsdE4j4uj/iIEAPgiBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKer+iagMTo3yv//Zz7/Jft4VYmByBQRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQIph2QMwMJRKpewRgEHGFRAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIEXdA9Td3R2LFy+OlpaWGDlyZJx66qlxww03RFEU9d4VAANY3d8Ne9myZbFixYp44IEH4swzz4znn38+rrjiiqhUKjF//vx67w6AAaruAXruuefikksuiTlz5kRExCmnnBIrV66MTZs21XtXAAxgdX8K7oILLog1a9bEjh07IiLixRdfjHXr1sVFF1100Pt3dXVFrVbrswA4BhR11t3dXVx77bVFqVQqhg0bVpRKpeKmm2465P2XLl1aRESDrqIBVvYxsCzri6/s80VjnTOq1ern9qLuAVq5cmUxYcKEYuXKlcVLL71U/OEPfyjGjBlT3H///Qe9/4cfflhUq9Xe1dHRkX7QPJgsy/rfVvb5orHOGUc9QBMmTCjuvPPOPttuuOGG4pvf/OYX+v5qtZp+0DyYLMv631b2+aKxzhmHC1Dd/wb0wQcfxJAhfX/s0KFDo6enp967AmAAq/ur4C6++OK48cYbY9KkSXHmmWfG1q1b47bbbosrr7yy3rsCYAArFUVR1PMH7t27NxYvXhyrVq2KPXv2RHNzc/z4xz+OJUuWxPDhww/7/bVaLSqVSj1HOgJ1PTT/o1L2AMAX5pzxadVqNUaPHn3I2+seoCMlQJ/VOA8m4HCcMz7tcAHyXnAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABS1P3NSKm3RnhrD4D6cwUEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUAgRACgECIIUAAZBCgABIIUAApBAgAFIIEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSCBAAKQQIgBTDsgdobKXsAQAGLVdAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACkECIAUXzpAzz77bFx88cXR3NwcpVIpHn300T63F0URS5YsifHjx8fIkSOjtbU1du7cWa95ARgkvnSA9u3bF1OnTo3ly5cf9PZbbrklbr/99rjrrrti48aNcdxxx8Xs2bPjww8/POJhARhEiiMQEcWqVat6v+7p6SnGjRtX3Hrrrb3b3nvvvaJcLhcrV678Qj+zWq0WEWFZlmUN8FWtVj/3fF/XvwHt2rUrOjs7o7W1tXdbpVKJGTNmxPr16w/6PV1dXVGr1fosAAa/ugaos7MzIiKampr6bG9qauq97bPa29ujUqn0rokTJ9ZzJAAaVPqr4K6//vqoVqu9q6OjI3skAI6CugZo3LhxERGxe/fuPtt3797de9tnlcvlGD16dJ8FwOBX1wC1tLTEuHHjYs2aNb3barVabNy4Mc4///x67gqAAW7Yl/2G999/P1577bXer3ft2hXbtm2LMWPGxKRJk2LhwoXx29/+Nk477bRoaWmJxYsXR3Nzc1x66aX1nBuAge7LvvT66aefPujL7ebNm9f7UuzFixcXTU1NRblcLmbNmlVs3779C/98L8O2LMsaHOtwL8MuFUVRRAOp1WpRqVSyxwDgCFWr1c/9u376q+AAODYJEAApBAiAFAIEQAoBAiCFAAGQQoAASCFAAKQQIABSNFyAGuyNGQD4Hx3ufN5wAdq7d2/2CADUweHO5w33XnA9PT3x1ltvxahRo6JUKv1PP6NWq8XEiROjo6PjmP98IceiL8djP8diP8div3oci6IoYu/evdHc3BxDhhz6OudLfxxDfxsyZEhMmDChLj/LB9zt51j05Xjs51js51jsd6TH4ou8qXTDPQUHwLFBgABIMSgDVC6XY+nSpVEul7NHSedY9OV47OdY7OdY7Hc0j0XDvQgBgGPDoLwCAqDxCRAAKQQIgBQCBECKQRmg5cuXxymnnBIjRoyIGTNmxKZNm7JHOura29vjvPPOi1GjRsXYsWPj0ksvje3bt2eP1RBuvvnmKJVKsXDhwuxRUrz55ptx+eWXx4knnhgjR46Ms846K55//vnssVJ0d3fH4sWLo6WlJUaOHBmnnnpq3HDDDcfEe1I+++yzcfHFF0dzc3OUSqV49NFH+9xeFEUsWbIkxo8fHyNHjozW1tbYuXNnXWcYdAF65JFHYtGiRbF06dLYsmVLTJ06NWbPnh179uzJHu2oWrt2bbS1tcWGDRti9erV8fHHH8eFF14Y+/btyx4t1ebNm+Puu++Os88+O3uUFO+++27MnDkzvvKVr8RTTz0Vr776avzud7+LE044IXu0FMuWLYsVK1bEnXfeGX//+99j2bJlccstt8Qdd9yRPVq/27dvX0ydOjWWL19+0NtvueWWuP322+Ouu+6KjRs3xnHHHRezZ8+ODz/8sH5DFIPM9OnTi7a2tt6vu7u7i+bm5qK9vT1xqnx79uwpIqJYu3Zt9ihp9u7dW5x22mnF6tWri+9973vFggULskc66q699triO9/5TvYYDWPOnDnFlVde2WfbD37wg2Lu3LlJE+WIiGLVqlW9X/f09BTjxo0rbr311t5t7733XlEul4uVK1fWbb+D6groo48+ihdeeCFaW1t7tw0ZMiRaW1tj/fr1iZPlq1arERExZsyY5EnytLW1xZw5c/o8Po41jz/+eEybNi0uu+yyGDt2bJxzzjlx7733Zo+V5oILLog1a9bEjh07IiLixRdfjHXr1sVFF12UPFmuXbt2RWdnZ5/flUqlEjNmzKjrubTh3oz0SLzzzjvR3d0dTU1NfbY3NTXFP/7xj6Sp8vX09MTChQtj5syZMWXKlOxxUjz88MOxZcuW2Lx5c/YoqV5//fVYsWJFLFq0KH71q1/F5s2bY/78+TF8+PCYN29e9nhH3XXXXRe1Wi0mT54cQ4cOje7u7rjxxhtj7ty52aOl6uzsjIg46Ln0v7fVw6AKEAfX1tYWr7zySqxbty57lBQdHR2xYMGCWL16dYwYMSJ7nFQ9PT0xbdq0uOmmmyIi4pxzzolXXnkl7rrrrmMyQH/605/iwQcfjIceeijOPPPM2LZtWyxcuDCam5uPyeNxtA2qp+BOOumkGDp0aOzevbvP9t27d8e4ceOSpsp19dVXx5NPPhlPP/103T7mYqB54YUXYs+ePfHtb387hg0bFsOGDYu1a9fG7bffHsOGDYvu7u7sEY+a8ePHxxlnnNFn2+mnnx5vvPFG0kS5fvGLX8R1110XP/rRj+Kss86Kn/zkJ3HNNddEe3t79mip/nu+7O9z6aAK0PDhw+Pcc8+NNWvW9G7r6emJNWvWxPnnn5842dFXFEVcffXVsWrVqvjb3/4WLS0t2SOlmTVrVrz88suxbdu23jVt2rSYO3dubNu2LYYOHZo94lEzc+bMA16Ov2PHjjj55JOTJsr1wQcfHPCBaUOHDo2enp6kiRpDS0tLjBs3rs+5tFarxcaNG+t7Lq3byxkaxMMPP1yUy+Xi/vvvL1599dXiZz/7WXH88ccXnZ2d2aMdVVdddVVRqVSKZ555pvjXv/7Vuz744IPs0RrCsfoquE2bNhXDhg0rbrzxxmLnzp3Fgw8+WHz1q18t/vjHP2aPlmLevHnF17/+9eLJJ58sdu3aVfz5z38uTjrppOKXv/xl9mj9bu/evcXWrVuLrVu3FhFR3HbbbcXWrVuLf/7zn0VRFMXNN99cHH/88cVjjz1WvPTSS8Ull1xStLS0FP/+97/rNsOgC1BRFMUdd9xRTJo0qRg+fHgxffr0YsOGDdkjHXURcdB13333ZY/WEI7VABVFUTzxxBPFlClTinK5XEyePLm45557skdKU6vVigULFhSTJk0qRowYUXzjG98ofv3rXxddXV3Zo/W7p59++qDniHnz5hVF8clLsRcvXlw0NTUV5XK5mDVrVrF9+/a6zuDjGABIMaj+BgTAwCFAAKQQIABSCBAAKQQIgBQCBEAKAQIghQABkEKAAEghQACkECAAUggQACn+HyFDT7ODig3KAAAAAElFTkSuQmCC", "text/plain": [ - "(
,\n", - " array([, , , , ], dtype=object))" + "
" ] }, - "execution_count": 14, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -548,257 +529,175 @@ } ], "source": [ - "plot_dataset_mazes(dataset_not_fully_connected, 5)" + "\n", + "from maze_dataset.plotting import MazePlot\n", + "from maze_dataset.tokenization import MazeTokenizer, TokenizationMode\n", + "from maze_dataset.plotting.print_tokens import display_color_maze_tokens_AOTP, color_maze_tokens_AOTP\n", + "\n", + "maze: SolvedMaze = dataset[0]\n", + "\n", + "# as pixels (what you've already seen)\n", + "plt.imshow(maze.as_pixels())\n", + "\n", + "# as ascii (useful for debugging)\n", + "print(\"ASCII:\\n\")\n", + "print(maze.as_ascii())\n", + "\n", + "# as a MazePlot\n", + "MazePlot(maze).plot()\n", + "\n", + "# as tokens\n", + "\n", + "# first, initialize a tokenizer -- more about this in the `notebooks/demo_tokenization.ipynb` notebook\n", + "tokenizer: MazeTokenizer = MazeTokenizer(tokenization_mode=TokenizationMode.AOTP_UT_rasterized, max_grid_size=100)\n", + "maze_tok = maze.as_tokens(maze_tokenizer=tokenizer)\n", + "\n", + "# you can view the tokens directly\n", + "print(\"\\nRaw tokens:\\n\")\n", + "print(\" \".join(maze_tok))\n", + "\n", + "# or color and print them in various formats\n", + "print(\"\\nColored tokens, raw html:\\n\")\n", + "print(color_maze_tokens_AOTP(maze_tok, fmt=\"html\"))\n", + "print(\"\\nColored tokens, raw latex:\\n\")\n", + "print(color_maze_tokens_AOTP(maze_tok, fmt=\"latex\"))\n", + "print(\"\\nColored tokens, terminal:\\n\")\n", + "print(color_maze_tokens_AOTP(maze_tok, fmt=\"terminal\"))\n", + "\n", + "display_color_maze_tokens_AOTP(maze_tok)" ] }, { - "cell_type": "code", - "execution_count": 15, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "STANDARD_KWARGS_FROM_CONFIG: dict = dict(\n", - " do_download=False,\n", - "\tload_local=False,\n", - "\tdo_generate=True,\n", - "\tsave_local=True,\n", - "\tlocal_base_path=LOCAL_DATA_PATH,\n", - "\tverbose=True,\n", - "\tzanj=zanj,\n", - ")" + "# more algorithms\n", + "\n", + "there are a bunch of algorithms included, some with various parameters. Here's a few:" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "generating dataset...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 5/5 [00:00<00:00, 713.54maze/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\maze_dataset\\test_hallway-g5-n5-a_dfs-h99081.zanj\n", - "Got dataset test_hallway with 5 items. output.cfg.to_fname() = 'test_hallway-g5-n5-a_dfs-h99081'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" + "Generating gen_dfs for grid_n=4\n", + "Generating gen_dfs for grid_n=4\n", + "Generating gen_dfs for grid_n=4\n", + "Generating gen_dfs for grid_n=4\n", + "Generating gen_wilson for grid_n=4\n", + "Generating gen_percolation for grid_n=4\n", + "Generating gen_dfs_percolation for grid_n=4\n", + "Generating gen_dfs_percolation for grid_n=4\n" ] } ], "source": [ - "dataset_hallway: MazeDataset = MazeDataset.from_config(\n", - "\tMazeDatasetConfig(\n", - "\t\tname=\"test_hallway\",\n", - "\t\tgrid_n=5,\n", - "\t\tn_mazes=5,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", - " maze_ctor_kwargs=dict(\n", - "\t\t\tn_accessible_cells = 70,\n", - " \tmax_tree_depth = 15,\n", - " do_forks = False,\n", - "\t\t),\n", - "\t),\n", - "\t**STANDARD_KWARGS_FROM_CONFIG,\n", - ")" + "DATASETS: dict[int, list[MazeDataset]] = dict()\n", + "for grid_n in [4]:\n", + "\tDATASETS[grid_n] = list()\n", + "\tfor gen_name, gen_kwargs in DEFAULT_GENERATORS:\n", + "\t\tprint(f\"Generating {gen_name} for grid_n={grid_n}\")\n", + "\t\tDATASETS[grid_n].append(MazeDataset.from_config(\n", + "\t\t\tMazeDatasetConfig(\n", + "\t\t\t\tname=\"demo\",\n", + "\t\t\t\tmaze_ctor=GENERATORS_MAP[gen_name],\n", + "\t\t\t\tgrid_n=grid_n,\n", + "\t\t\t\tn_mazes=4,\n", + "\t\t\t\tmaze_ctor_kwargs=gen_kwargs,\n", + "\t\t\t),\n", + "\t\t\tlocal_base_path=LOCAL_DATA_PATH,\n", + "\t\t\tload_local=False,\n", + "\t\t\tverbose=False,\n", + "\t\t\tzanj=zanj,\n", + "\t\t))\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(
,\n", - " array([, , , , ], dtype=object))" + "
" ] }, - "execution_count": 17, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAADcCAYAAAAxzGueAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAKJklEQVR4nO3bQW4bSxIE0CyDW11AsO9/MAO6gPaqWQz+bmxSfyqoEPne2qgOJjtJOtBae+89AAAAAHDYj68OAAAAAMBjUjwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAERcbvlHHx8f8/b2Ni8vL7PWSmeCb2XvPe/v7/P6+jo/fnR2uXYY/qx9h+0v/Fn7/s7YYfib9h22v/B3t+7wTcXT29vb/Pr161g4eES/f/+enz9/fnWM/8kOw3WtO2x/4brW/Z2xw3CL1h22v3Cbazt8U6388vJyLBA8quY9ac4GLVr3pDUXNGnek+Zs0KJ1T1pzQZtru3JT8eSxQriueU+as0GL1j1pzQVNmvekORu0aN2T1lzQ5tqu9P0hLQAAAAAPQfEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEXO59wb33sbPWWkfOOZWpLc9MX6a2PDPnMj2Lxtm7P68zI2Y6534y08M6NOs1jbO2v5/xyDvclmemL1NbnhnfwZ/ROHf35nVmdIYnngAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEHG59wXXWve+5FVtmdryzPRlasvzTBpn35apLc9MX6a2PM+ice6NmR7XqVnvQ+fwWY370papLc9MX6a2PM+ice5tmdryzPRlastzK088AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABBxufcF997HzlprHTnnVKa2PDN9mdryzJzL9DzOzf5h7XP31C6btx3+3hrn7vvlFl2fA3ydxvvTDl9nRvyXz/KrDv6GnkNH2d8zPPEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQMTl3hdca937kle1ZWrLM9OXqS0P/9aDvo8HX9Y6dNje+8g5p9jhr9E497ZMbXnOeuTX9hwa78+2TG15ZvoyteXh33jM93DPud+rp35Dt+1LW55beeIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgIjLvS+49z521lrryDmnMrXlmenMdMSh1zUzc+4kPu/MfbUPvYun7oW6fSnU+Dn3DBrn7jv4BvvQOafiNM7oSTTO/pF3uE3jjOzwV3nM39AntX0WPPv+euIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARl3tfcK1170te1ZapLc9MY6Z98Ky219aub15tifr2pY8ZfY3GubdlasszM7MPfeetQ5+WjTN6Fo2zb8x0yqO+tkd9Xf365t6WqPHe3Pvk/zv/f40zuoUnngAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIuNz7gnvvY2ettY6ccypTW56Zvkyn8sw+dM7MzMGjnoH78zozuq5xRs+gce7uze/HjL5O5exPRSq8FU7O+wSfc99b49x9B38/33VGnngCAAAAIELxBAAAAECE4gkAAACACMUTAAAAABGKJwAAAAAiFE8AAAAARCieAAAAAIhQPAEAAAAQoXgCAAAAIELxBAAAAECE4gkAAACACMUTAAAAABGKJwAAAAAiFE8AAAAARCieAAAAAIhQPAEAAAAQoXgCAAAAIOJy7wuute59yavaMrXlmenLtGcfO2tN12tr13YvzPRlassz05epLc+zaJx7W6a2PDN9mdryPJPK2a9Tv8nOvLbGGe197nfrCY0zegaNc2/L1JZnpi9TW55beeIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgAjFEwAAAAARiicAAAAAIhRPAAAAAEQongAAAACIUDwBAAAAEKF4AgAAACBC8QQAAABAhOIJAAAAgIjLvS+49773JYGDTu7wWuvIOacyteWZ6cvUlmfmXKZn0Dh39+Z1ZsQ/Gme/59B76P8Id9N4Hz2Dxrn7frnOjM7wxBMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABCheAIAAAAgQvEEAAAAQITiCQAAAIAIxRMAAAAAEYonAAAAACIu977gWuvelwQOatzhtkxteWb6MrXleRaNc2/L1JZnpi9TW55n0jj7Y4kKX9ujaryPnkHj3NsyteWZ6cvUludWnngCAAAAIELxBAAAAECE4gkAAACACMUTAAAAABGKJwAAAAAiFE8AAAAARCieAAAAAIhQPAEAAAAQoXgCAAAAIELxBAAAAECE4gkAAACACMUTAAAAABGKJwAAAAAiFE8AAAAARCieAAAAAIhQPAEAAAAQcVPxtPdO54Bvr3lPmrNBi9Y9ac0FTZr3pDkbtGjdk9Zc0ObartxUPL2/vx8JA4+seU+as0GL1j1pzQVNmvekORu0aN2T1lzQ5tqurH1Djfvx8TFvb2/z8vIya61j4eAR7L3n/f19Xl9f58ePzr9etcPwZ+07bH/hz9r3d8YOw9+077D9hb+7dYdvKp4AAAAA4LP6amUAAAAAHoLiCQAAAIAIxRMAAAAAEYonAAAAACIUTwAAAABEKJ4AAAAAiFA8AQAAABDxH5ZxGRa0wJp5AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "plot_dataset_mazes(dataset_hallway)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating dataset...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 5/5 [00:00<00:00, 262.71maze/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\maze_dataset\\test_perc-g8-n5-a_percolation-h47645.zanj\n", - "Got dataset test_perc with 5 items. output.cfg.to_fname() = 'test_perc-g8-n5-a_percolation-h47645'\n" - ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "dataset_perc: MazeDataset = MazeDataset.from_config(\n", - "\tMazeDatasetConfig(\n", - "\t\tname=\"test_perc\",\n", - "\t\tgrid_n=8,\n", - "\t\tn_mazes=5,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_percolation,\n", - " maze_ctor_kwargs=dict(p=0.5),\n", - "\t),\n", - "\t**STANDARD_KWARGS_FROM_CONFIG,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(
,\n", - " array([, , , , ], dtype=object))" + "
" ] }, - "execution_count": 19, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAADcCAYAAAAxzGueAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAL+UlEQVR4nO3bQW4buxIFUNLQ1Bswkv0vLIA34Ln5R/8BD4jsLj1dq6g+Z6wUSiSLLV905lprDQAAAAC4s5dHNwAAAADAcxI8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABEXI586PPzc7y/v4/X19cx50z3BFtZa42Pj4/x9vY2Xl56ZrlmGK7rPsPmF67rPr9jmGH4SvcZNr/wtaMzfCh4en9/H79//75bc/CM/vz5M379+vXoNv7KDMP3us6w+YXvdZ3fMcwwHNF1hs0vHPPdDB+KlV9fX+/WEDyrznPSuTfoouucdO0LOuk8J517gy66zknXvqCb72blUPDktUL4Xuc56dwbdNF1Trr2BZ10npPOvUEXXeeka1/QzXez0u8/0gIAAADwFARPAAAAAEQIngAAAACIEDwBAAAAECF4AgAAACBC8AQAAABAhOAJAAAAgAjBEwAAAAARl1ThtVbp83POWO20Su9j9Oo/3fuZ1ubZdJrh3c9prX6fGbjFGoXvGp73M89wp7s0befnTNrOa3Pm+R3jXM/gNH9j/HztW+o/E/O7h24z8Ozz640nAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiLikCs85U6WjtTuqfN+1VrCTvLPtbWc770W6915r06mXMUbhDuq1jufWaS+6PceSz+DquqfXptM5OLsz7UW3OajYuXf21O1uSM/Amf4OfnbeeAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQMQlVXitVfr8nLNF7Z+o30n1u3arn7Tzvt5DpzlIn6Mz3RF65292vqu5n8o5ONO9+QidZnL334qd1hL+ZuczunPvadbm37zxBAAAAECE4AkAAACACMETAAAAABGCJwAAAAAiBE8AAAAARAieAAAAAIgQPAEAAAAQIXgCAAAAIELwBAAAAECE4AkAAACACMETAAAAABGXVOE5Z6p0XLr3TmtT7WWt1aZ+uvezS57T9Ayk97rTDJ+JdT8uuVadngNns/PvE/NbY70eY/f7x7np4UzP4DOdud3/fnk0bzwBAAAAECF4AgAAACBC8AQAAABAhOAJAAAAgAjBEwAAAAARgicAAAAAIgRPAAAAAEQIngAAAACIEDwBAAAAECF4AgAAACBC8AQAAABAxCVVeK1V+vycs/DZcjfVf7Ct9NrU67Or6gwnVe6HW9Tvq1AjDXU6B8nnyrPptG9ct/M+VefL/NYk16t66qo7kd7rTmcpPcM73xFn1mnfnNHr9P6zvPEEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEZdU4TlnqvQNar2stWrVG33XfO+1+uwrea6r57QqP5PV/vvcEVWd7jdyOu1zupdk/XTv6Wd8+m7muOg5DT/DOt0nVTv3nuZ+yKmcu27PgU71d+69Wn/H57s3ngAAAACIEDwBAAAAECF4AgAAACBC8AQAAABAhOAJAAAAgAjBEwAAAAARgicAAAAAIgRPAAAAAEQIngAAAACIEDwBAAAAECF4AgAAACDikiq8ip+f5X9x3Fq52reo9jPnDHVyg1XsJdh6t319Np3Oabe9To5kt+9aVem/1d3GYem7odsMVPrvdG+O0W8tOS56loq/5VbwN/oYvZ4FZ5qZTutOzu5neuf+k73vuC7eeAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAICIS6rwDP6LtVat8qx3k9Stn5JGrVfXsXpuzq7TOU3vdf275s5Sp3Xvxtocd6a1OtOz4Ez7enbRvS6Wnp1+/I3s2qRnbOe/YTr1cmZn24dO37fT/dBpXY7yxhMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIuqcJrrVTpsk697M5ankenve7Uyy127n/O+egW/lFdx069/7ROa7Xz+R8j2396bar7uvtePZPkDKfvh53rd7o7b9FphrutzbOo7nB1FzqdoTGy/XS6e9I69O6NJwAAAAAiBE8AAAAARAieAAAAAIgQPAEAAAAQIXgCAAAAIELwBAAAAECE4AkAAACACMETAAAAABGCJwAAAAAiBE8AAAAARAieAAAAAIi4pArPOVOlt7fWKn2+spbV2lXpfU33z3Fm+H6SM9xtn5L9dPuuHFPdt27PgU7zu/sznuPsxXWeM9cl++92N3cWPaOjug/ZM737zPBzvPEEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEZdU4bVWqnQ7c85o/eRa7rxPO/e+g+r6Vuag296VZ3gVPx+8ItJrWV2bSj/J2rfUh5+Wnt/6zIQauUmrZn5ct+dkJ2f6fdKtHw6qbtvcd5+d0cfYcd298QQAAABAhOAJAAAAgAjBEwAAAAARgicAAAAAIgRPAAAAAEQIngAAAACIEDwBAAAAECF4AgAAACBC8AQAAABAhOAJAAAAgAjBEwAAAAARl0c38H9zzsOfXWvFanfUqf+zrT09tDtHwXbafdei3fvn8dJnKFl///NfecZXv2vt9wM1yd/R3XSas0690Mcq3ncz+cMyrDoDO/8t2enu7LQuR3njCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIuj26go7VW6fNzzlAnddXeu6n0X133nfeVmt3noKLbHCRnmHPodEbLir3McZ67in2ln6np+slnTbfe/Y5+fmf6jTvG+b7vUd3uniO88QQAAABAhOAJAAAAgAjBEwAAAAARgicAAAAAIgRPAAAAAEQIngAAAACIEDwBAAAAECF4AgAAACBC8AQAAABAhOAJAAAAgAjBEwAAAAARl0c3cIs5p/oPqP0Tdu+fY3aesTHGWGuVPl/pp1q7yoydw877vPv9UFPrJXn30EunvevUSzfd1sbfGD3Yh/tJ/obeeS2rvaf/vjjCG08AAAAARAieAAAAAIgQPAEAAAAQIXgCAAAAIELwBAAAAECE4AkAAACACMETAAAAABGCJwAAAAAiBE8AAAAARAieAAAAAIi4PLqBW6y1Ht0CB805S5+v7G21Nn1UZzh5jm6pvzNrcw6d9tkz+7p281XZqmlfkzrNcFW3Z3wnO/de1elM/jT7fD+d1rJTLzvyxhMAAAAAEYInAAAAACIETwAAAABECJ4AAAAAiBA8AQAAABAheAIAAAAgQvAEAAAAQITgCQAAAIAIwRMAAAAAEYInAAAAACIETwAAAABEXFKF55yp0tHaPJZz08fOe7Fz/Z17T9c3w8fZh+cUX/tSeecgaecZ3r1+0s69c5x9vm7ntdH7f+ONJwAAAAAiBE8AAAAARAieAAAAAIgQPAEAAAAQIXgCAAAAIELwBAAAAECE4AkAAACACMETAAAAABGCJwAAAAAiBE8AAAAARBwKntZa6T5ge53npHNv0EXXOenaF3TSeU469wZddJ2Trn1BN9/NyqHg6ePj4y7NwDPrPCede4Muus5J176gk85z0rk36KLrnHTtC7r5blbmOhDjfn5+jvf39/H6+jrmnHdrDp7BWmt8fHyMt7e38fLS83+vmmG4rvsMm1+4rvv8jmGG4SvdZ9j8wteOzvCh4AkAAAAAqvrFygAAAAA8BcETAAAAABGCJwAAAAAiBE8AAAAARAieAAAAAIgQPAEAAAAQIXgCAAAAIOJ/qgNjyE0biE8AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "plot_dataset_mazes(dataset_perc)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating dataset...\n" - ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 5/5 [00:00<00:00, 66.67maze/s]" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\maze_dataset\\test_dfs_perc-g8-n5-a_dfs_percolation-h13073.zanj\n", - "Got dataset test_dfs_perc with 5 items. output.cfg.to_fname() = 'test_dfs_perc-g8-n5-a_dfs_percolation-h13073'\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "dataset_dfs_perc: MazeDataset = MazeDataset.from_config(\n", - "\tMazeDatasetConfig(\n", - "\t\tname=\"test_dfs_perc\",\n", - "\t\tgrid_n=8,\n", - "\t\tn_mazes=5,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs_percolation,\n", - " maze_ctor_kwargs=dict(p=0.2),\n", - "\t),\n", - "\t**STANDARD_KWARGS_FROM_CONFIG,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(
,\n", - " array([, , , , ], dtype=object))" + "
" ] }, - "execution_count": 21, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAEnCAYAAAA0B9WGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1MElEQVR4nO3deVyVZf7/8fcBZMcFxcQlVDLXRovMwr1M3HLIBdEssMzKLQ2baRkTzCWXyklH0xbN1O+3RkWnr6lpYeVkZWaNk+mQAppWkmGhggLn+v3h75zheECWG0Ts9Xw8fDw817nPfX/u+1w357zPfd/XbTPGGAEAAACABR5VXQAAAACA6o9gAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAFcBRITE2Wz2aq6DFxGNptNiYmJLm27d+9WZGSkAgICZLPZ9NVXX1VJbVeSpk2bKj4+vkLnGR8fr6ZNm1boPMuy7MDAwCpZNgCUhGABoFq68847ZbPZNH78+EpdTl5entq0aSObzab58+dX6rKsyMvL09ChQ/XLL7/oxRdf1JtvvqmwsLCqLqvaOn78uBITE6t1OHvrrbc0cuRItWjRQjabTT169Chyuvj4eNlstmL/HTt2zDltXl6ekpKS1Lx5c/n4+Kh58+aaMWOG8vPzXea5Y8eOYuf36aefukw7a9Ys3XrrrQoJCZGvr69atGihSZMmKTMzs8K3CYDK5VXVBQBAWa1fv167du26LMtauHChjhw5clmWZcWhQ4eUkZGhV155RaNHj67qcqq948ePKykpSU2bNlWHDh1cnnvllVdkt9urprAyWLJkifbs2aOOHTvq5MmTxU730EMPqVevXi5txhg9/PDDatq0qRo1auRsHzlypP7+97/r/vvv180336xPP/1UU6dO1ZEjR7Rs2TK3eU+cOFEdO3Z0abvuuutcHu/Zs0cdOnRQbGysgoKC9O233+qVV17Rpk2b9NVXXykgIKA8qw+gChAsAFQrubm5SkhI0J///Gc988wzlbqsEydOaPr06ZdlWVadOHFCklS7du2qLcSCs2fPyt/fv6rLKFGNGjWquoRSefPNN9WoUSN5eHioXbt2xU5322236bbbbnNp27lzp86ePat77rnH2bZ79269/fbbmjp1qqZPny5Jevjhh1WvXj298MILGj9+vP7whz+4zKdr164aMmTIJetct25dkTUNGTJE77zzjmJjY0tcVwBXBk6FAqqZnTt3qmPHjvL19VV4eLiWLl1a5HSrVq1SRESE/Pz8FBwcrNjYWB09etRlmh49eqhdu3b617/+pe7du8vf31/XXXed1q5dK0n68MMP1alTJ/n5+ally5bavn2723L27t2rvn37qmbNmgoMDNQdd9zhdqrDpWRkZGjgwIEKCAhQ/fr1NXnyZG3dulU2m007duxwm37u3Lmy2+2aMmVKqZchSStWrJDNZtM///lPPfbYYwoJCVFAQIDuvvvuYk+5eOKJJ9SyZUuNHDmyTMvKyMjQ2LFj1bJlS/n5+alu3boaOnSo0tPTyzQfSTp37pwmT56skJAQBQUFaeDAgfr+++9dpomPj1f37t0lSUOHDnU57eXHH3/UqFGj1LhxY/n4+Cg0NFR//OMfy1SL4xqeAwcOKCYmRjVr1lTdunX16KOPKjc31236svS9PXv2qFu3bvL399dTTz0l6UJ4TExM1PXXXy9fX1+FhoZq0KBBOnTokPP1Z86cUUJCgpo0aSIfHx+1bNlS8+fPlzHmkuvyyy+/aMqUKbrhhhsUGBiomjVrqm/fvvr666+d0+zYscP5K/uoUaOcp/CsWLHCub0vvsaitPU4Tt/bsGGD2rVrJx8fH7Vt21Zbtmy59JtwkWPHjik6OlqBgYEKCQnRlClTVFBQ4DJNkyZN5OFRvo/5NWvWyGazacSIEc62jz/+WJLcvujHxsbKGKO33nqryHllZ2e7nSpVEsf2PXXqVJleB6BqccQCqEb27dun3r17KyQkRImJicrPz9e0adN0zTXXuEw3c+ZMTZ06VTExMRo9erQyMzO1cOFCdevWTXv37nX5VTsrK0sDBgxQbGyshg4dqiVLlig2NlarV6/WpEmT9PDDD2vEiBGaN2+ehgwZoqNHjyooKEiS9M0336hr166qWbOm/vSnP6lGjRpaunSpevTo4Qwll3LmzBndfvvt+uGHH/Too4+qQYMGWrNmjVJSUoqc/siRI3ruuef0+uuvy8/Pr1zbcMKECapTp46mTZum9PR0LViwQOPHj3f7UvT555/rjTfe0M6dO8t8Yfzu3bv1ySefKDY2Vo0bN1Z6erqWLFmiHj16aP/+/WX6VX706NFatWqVRowYocjISH3wwQfq37+/yzQPPfSQGjVqpFmzZjlPPXH0icGDB+ubb77RhAkT1LRpU504cULbtm3TkSNHynwBckxMjJo2barZs2fr008/1UsvvaSsrCytXLnSOU1Z+t7JkyfVt29fxcbGauTIkbrmmmtUUFCgAQMG6P3331dsbKweffRRZWdna9u2bfr3v/+t8PBwGWM0cOBApaSk6IEHHlCHDh20detWPf744zp27JhefPHFYtfh8OHD2rBhg4YOHapmzZrpp59+0tKlS9W9e3ft379fDRs2VOvWrTV9+nQ988wzGjNmjLp27SpJioyMLHKeZa1n586dWr9+vcaOHaugoCC99NJLGjx4sI4cOaK6deuW+D4UFBQoKipKnTp10vz587V9+3Y9//zzCg8P1yOPPFLi60uSl5ent99+W5GRkS595Ny5c5Lktu85+vOePXvc5jVq1CidPn1anp6e6tq1q+bNm6ebb77ZbTpjjE6ePKn8/HylpqbqiSeekKenZ7HXhQC4QhkA1UZ0dLTx9fU1GRkZzrb9+/cbT09P49id09PTjaenp5k5c6bLa/ft22e8vLxc2rt3724kmTVr1jjbDhw4YCQZDw8P8+mnnzrbt27daiSZ5cuXu9Tj7e1tDh065Gw7fvy4CQoKMt26dStxfZ5//nkjyWzYsMHZlpOTY1q1amUkmZSUFJfphwwZYiIjI52PJZlx48aVuBxjjFm+fLmRZHr16mXsdruzffLkycbT09OcOnXK2Wa3280tt9xihg8fbowxJi0tzUgy8+bNK9Wyzp4969a2a9cuI8msXLmyVPMwxpivvvrKSDJjx451aR8xYoSRZKZNm+ZsS0lJMZLM3//+d2dbVlZWmeouzrRp04wkM3DgQJf2sWPHGknm66+/NsaUr++9/PLLLtO+/vrrRpJ54YUX3OpwvG8bNmwwksyMGTNcnh8yZIix2Wzmu+++c7aFhYWZuLg45+Pc3FxTUFDg8rq0tDTj4+Njpk+f7mzbvXu3W393iIuLM2FhYc7HZalHkvH29nZp+/rrr40ks3DhQrdlFbVsSS61GmPMjTfeaCIiIop9Xdu2bU337t1LnL8xxrzzzjtGklm8eLFL+7p164wk8+abb7q0v/zyy0aSadeunbPtn//8pxk8eLB57bXXzMaNG83s2bNN3bp1ja+vr/nyyy/dlvnDDz8YSc5/jRs3Nm+99Vap6gVw5eBUKKCaKCgo0NatWxUdHa1rr73W2d66dWtFRUU5H69fv152u10xMTH6+eefnf8aNGigFi1auB0NCAwMdDm1oWXLlqpdu7Zat27tcsTB8f/Dhw8763nvvfcUHR2t5s2bO6cLDQ3ViBEjtHPnTv3222+XXKctW7aoUaNGGjhwoLPN19dXDz74oNu0KSkpWrdunRYsWHDJeZZkzJgxLkcgunbtqoKCAmVkZDjbVqxYoX379mnOnDnlWkbhX3Tz8vJ08uRJXXfddapdu7a+/PLLUs/n3XfflXThAtjCJk2aVOo6vL29tWPHDmVlZZV6ucUZN26cy+MJEya41FnWvufj46NRo0a5tK1bt0716tVzzrswx/v27rvvytPT0227JCQkyBijzZs3F7sOPj4+ztODCgoKdPLkSQUGBqply5Zlem8KK2s9vXr1Unh4uPPxH/7wB9WsWdO5b5XGww8/7PK4a9euZXr9paxZs0Y1atRQTEyMS3u/fv0UFhamKVOmaP369crIyNDbb7+tp59+Wl5eXsrJyXFOGxkZqbVr1+r+++/XwIED9cQTT+jTTz+VzWbTk08+6bbM4OBgbdu2Te+8846mT5+uevXq6fTp0xWyPgAuH06FAqqJzMxM5eTkqEWLFm7PtWzZ0vnlLjU1VcaYIqeT3C88bdy4sdupPrVq1VKTJk3c2iQ5v6BmZmbq7NmzatmypdsyWrduLbvdrqNHj6pt27bKzMx0Of87MDBQgYGBysjIUHh4uNvyLx41Jj8/XxMnTtS9997rNsLMxX788Ue3ugt/0S8cyiSpTp06Luv122+/6cknn9Tjjz/utg0KKygocLs2Izg4WN7e3srJydHs2bO1fPlyHTt2zOU8+19//fWS9ReWkZEhDw8Ply+hkorc5kXx8fHRnDlzlJCQoGuuuUa33nqrBgwYoPvuu08NGjQodR0OF/ep8PBweXh4OK/XKGvfa9Sokby9vV3aDh06pJYtW8rLq/iPp4yMDDVs2NB5Sp5D69atnc8Xx263669//asWL16stLQ0l35ZmtOQKqKei/ugdKEfOvrg+fPn9csvv7g8HxISIk9PT0kXwndISEixr7fi9OnT2rhxo6Kioty2h6+vrzZt2qSYmBgNHjxY0oU+NnfuXM2cObPE+2tcd911+uMf/6j169eroKDAuT6S5O3t7RyZasCAAbrjjjvUuXNn1a9fXwMGDLC8XgAuD4IFcJWx2+2y2WzavHmzywe3w8Uf/kVNc6l2U8LFsUXp2LGjy5eradOmud3c7VJWrlypgwcPaunSpW4XHWdnZys9PV3169eXv7+/QkNDXZ5fvny5yw3SSlqv+fPn6/z58xo2bJhzWY6LpbOyspSenq6GDRvq+PHjatasmcs8UlJS1KNHD02YMEHLly/XpEmTdNttt6lWrVqy2WyKjY297MOUTpo0SXfddZc2bNigrVu3aurUqZo9e7Y++OAD3XjjjZbmfXEgLGvfK+91MlbMmjVLU6dO1f33369nn31WwcHB8vDw0KRJky7be1NSH/zkk0/Us2dPl+fS0tKc1zsU9/qKsGHDBrfRoApr27at/v3vf2v//v3KyspSmzZt5Ofnp8mTJzsHELiUJk2a6Pz58zpz5oxq1qxZ7HSRkZEKDQ3V6tWrCRZANUKwAKqJkJAQ+fn5KTU11e25gwcPOv/vuLi1WbNmuv766yu1Hn9/f5dlOxw4cEAeHh7OX/xXr17tcpqE49SpsLAw7d+/X8YYly+p3333ncv8jhw5ory8PHXu3NltWStXrtTKlSuVnJys6Ohobdu2zeX5tm3blmm9jhw5oqysrCJfN2vWLM2aNUt79+5Vq1at3JbVvn17SdLatWsVFxen559/3vlcbm5umUe4CQsLk91ud/6K71DUNr+U8PBwJSQkKCEhQampqerQoYOef/55rVq1qkzzSU1NdQlT3333nex2u/MLb0X0vfDwcH322WfKy8srdljXsLAwbd++XdnZ2S5HCQ4cOOB8vjhr165Vz5499dprr7m0nzp1SvXq1XM+LssF+1bqKUr79u3d+lZ5jjCVx+rVqxUYGOhyeuLFbDaby/7x7rvvym63u90LoyiHDx+Wr69vqe4enpubW6YjfACqHtdYANWEp6enoqKitGHDBpcbtn377bfaunWr8/GgQYPk6emppKQkt6ML5v+PvFJR9fTu3VsbN250OYrw008/ac2aNerSpYvzF8nOnTurV69ezn+OYBEVFaVjx47pH//4h/P1ubm5euWVV1yWFRsbq+TkZLd/0oXzvpOTk53XgBReTq9evdyOYJRk4sSJbstxDOkbHx+v5ORkNWvWTL6+vm7LcpxW5enp6bbtFy5c6DYcaEn69u0rSXrppZdc2kt7ncnZs2fdhoMNDw9XUFCQc4Sfsvjb3/7m8njhwoUudVZE3xs8eLB+/vlnLVq0yO05xzz79eungoICt2lefPFF2Ww2Zz1FKeq9+fvf/+5yd2lJzpuylSYMWqmnKHXq1HHrW76+vmWaR3lkZmZq+/btuvvuu0s9cllOTo6mTp2q0NBQDR8+3GVeF/v666/1j3/8Q71793Ze53LmzBmdPXvWbdp169YpKyuryBGkAFy5OGIBVCNJSUnasmWLunbtqrFjxyo/P18LFy5U27Zt9a9//UvShS+OM2bM0JNPPqn09HRFR0crKChIaWlpSk5O1pgxY8p8D4jizJgxQ9u2bVOXLl00duxYeXl5aenSpTp37pzmzp1b4usfeughLVq0SMOHD9ejjz7qPPXB8SXK8atxq1at1KpVqyLn0axZM0VHR1fI+kjSTTfdpJtuusmlzRGc2rZtW6plDRgwQG+++aZq1aqlNm3aaNeuXdq+fXuZz+Hv0KGDhg8frsWLF+vXX39VZGSk3n//fbcjOsX5z3/+ozvuuEMxMTFq06aNvLy8lJycrJ9++qlcNx1LS0vTwIED1adPH+3atcs5DK7jSE1F9L377rtPK1eu1GOPPabPP/9cXbt21ZkzZ7R9+3aNHTtWf/zjH3XXXXepZ8+eevrpp5Wenq727dvrvffe08aNGzVp0iS3a1IKGzBggKZPn65Ro0YpMjJS+/bt0+rVq10GIHCsS+3atfXyyy8rKChIAQEB6tSpk9vpb5Is1VOZPvroI3300UeSLnzRP3PmjGbMmCFJ6tatm7p16+Yy/VtvvaX8/PxiT4OSLgw53LBhQ7Vp00a//fabXn/9dR0+fFibNm1yOVozbNgw+fn5KTIyUvXr19f+/fu1bNky+fv767nnnnNOl5qaql69emnYsGFq1aqVPDw89MUXX2jVqlVq2rSpHn300YrcJAAq2+UehgqANR9++KGJiIgw3t7epnnz5ubll192Dgda2Lp160yXLl1MQECACQgIMK1atTLjxo0zBw8edE7TvXt307ZtW7dlhIWFmf79+7u1q4jhXb/88ksTFRVlAgMDjb+/v+nZs6f55JNPSr0+hw8fNv379zd+fn4mJCTEJCQkOIe1LDzcbVGKqqc4juFmd+/e7dLuGKb14qFtCyvrcLNZWVlm1KhRpl69eiYwMNBERUWZAwcOuA19Who5OTlm4sSJpm7duiYgIMDcdddd5ujRo6Uabvbnn38248aNM61atTIBAQGmVq1aplOnTubtt98uUw2O/rV//34zZMgQExQUZOrUqWPGjx9vcnJy3Ka30veMuTBc79NPP22aNWtmatSoYRo0aGCGDBniMqxxdna2mTx5smnYsKGpUaOGadGihZk3b57LUMLGFD3cbEJCggkNDTV+fn6mc+fOZteuXaZ79+5uw7Fu3LjRtGnTxnh5ebkMPXvxcLNlqae4PlvavhEXF2cCAgLc2ov6G+BoK+pf4b7jcOutt5r69eub/Pz8Ypc/Z84c06pVK+Pr62vq1KljBg4caPbu3es23V//+ldzyy23mODgYOPl5WVCQ0PNyJEjTWpqqst0mZmZZsyYMc4+6u3tbVq0aGEmTZpkMjMzS9weAK4sNmPKcSUmAFSiBQsWaPLkyfr+++/VqFGjqi7ndy8xMVFJSUnKzMx0uQ4BAIDCuMYCQJUqfFG3dOEai6VLl6pFixaECgAAqhGusQBQpQYNGqRrr71WHTp00K+//qpVq1bpwIEDWr16dVWXVqkuvt/Gxfz8/Jz3Dqksp0+fLvEmZBffLwEAgOIQLABUqaioKL366qtavXq1CgoK1KZNG/3v//6vhg0bVtWlVaqSRquKi4vTihUrKrWG+fPnKykp6ZLTpKWlVWoNAICrB9dYAEAV2L59+yWfd4y8U5kOHz6sw4cPX3KaLl26XJahTgEA1R/BAgAAAIBlXLwNAAAAwDKCBYDLpmnTpoqPj3dpS01NVe/evVWrVi3ZbDZt2LChSmq7kvTo0UM9evSo0HkmJiY6bzhY2d5++20FBweXeGF4WZVlHWw2mxITEyt0+ag8eXl5atKkiRYvXlzVpQCwgGABoErFxcVp3759mjlzpt58803dfPPNVV1StXX27FklJiZqx44dVVZDQUGBpk2bpgkTJigwMLDK6qgO7rzzTtlsNo0fP76qSynRa6+9ptatW8vX11ctWrTQwoULyzWfmTNnymazqV27di7tNWrU0GOPPaaZM2cqNze3IkoGUAUIFgCqTE5Ojnbt2qUHHnhA48eP18iRI9W4ceOqLqvaOnv2rJKSkooMFn/5y1/c7hlSGd555x0dPHhQY8aMqfB5X651uBzWr1+vXbt2VXUZpbJ06VKNHj1abdu21cKFC3Xbbbdp4sSJmjNnTpnm8/3332vWrFkKCAgo8vlRo0bp559/1po1ayqibABVgGABoMpkZmZKkmrXrl21hVhw5syZqi6hVLy8vC7L6E7Lly9X586dK/Tmho5tfLnWobLl5uYqISFBf/7zn6u6lBLl5OTo6aefVv/+/bV27Vo9+OCDWrlype655x49++yzysrKKvW8pkyZoltvvbXYo5K1a9dW7969K32YZQCVh2ABVFM7duzQzTffLF9fX4WHh2vp0qXFnoO+atUqRUREyM/PT8HBwYqNjdXRo0ddpunRo4fatWun/fv3q2fPnvL391ejRo00d+7cMtdmjNGMGTPUuHFj+fv7q2fPnvrmm29cpklMTFRYWJgk6fHHH5fNZlPTpk0lSdnZ2Zo0aZKaNm0qHx8f1a9fX3feeae+/PLLUtewYsUK2Ww2ffTRR3rooYdUt25d1axZU/fdd1+RX4Y2b96srl27KiAgQEFBQerfv79bzfHx8QoMDNShQ4fUr18/BQUF6Z577pEk2e12/fWvf9UNN9wgX19fhYSEqE+fPvriiy+cr8/Pz9ezzz6r8PBw+fj4qGnTpnrqqad07ty5S67L+fPn9cwzzygiIkK1atVSQECAunbtqpSUFOc06enpzpvZJSUlyWazuVxnUFTfKG09TZs21YABA7Rz507dcsst8vX1VfPmzbVy5UqX6XJzc7Vlyxb16tXLbR1ycnI0ceJE1atXT0FBQRo4cKCOHTvmdi2Eo879+/drxIgRqlOnjrp06VLsOpw7d06TJ09WSEiIc77ff//9JbdnUdLT02Wz2TR//nwtW7bMuU06duyo3bt3l3l+lzJ37lzZ7XZNmTLF8rwcffLw4cOKiopSQECAGjZsqOnTp6siBn1MSUnRyZMnNXbsWJf2cePG6cyZM9q0aVOp5vPRRx9p7dq1WrBgwSWnu/POO7Vz50798ssv5S0ZQBXiBnlANbR371716dNHoaGhSkpKUkFBgaZPn17kXZJnzpypqVOnKiYmRqNHj1ZmZqYWLlyobt26ae/evS5HC7KystSnTx8NGjRIMTExWrt2rf785z/rhhtuUN++fUtd3zPPPKMZM2aoX79+6tevn7788kv17t1b58+fd04zaNAg1a5dW5MnT9bw4cPVr18/5zn5Dz/8sNauXavx48erTZs2OnnypHbu3Klvv/1WN910U5m21fjx41W7dm0lJibq4MGDWrJkiTIyMrRjxw7nl9Q333xTcXFxioqK0pw5c3T27FktWbJEXbp00d69e52BR7rwZTwqKkpdunTR/Pnz5e/vL0l64IEHtGLFCvXt21ejR49Wfn6+Pv74Y3366afOX2hHjx6tN954Q0OGDFFCQoI+++wzzZ49W99++62Sk5OLXYfffvtNr776qoYPH64HH3xQ2dnZeu211xQVFaXPP/9cHTp0UEhIiJYsWaJHHnlEd999twYNGiRJ+sMf/lDsfMtSz3fffachQ4bogQceUFxcnF5//XXFx8crIiJCbdu2lSTt2bNH58+fL/I9io+P19tvv617771Xt956qz788EP179+/2NqGDh2qFi1aaNasWZf8gjx69GitWrVKI0aMUGRkpD744INLzrcka9asUXZ2th566CHZbDbNnTtXgwYN0uHDh1WjRg1JF8JMdnZ2qeZXr149l8dHjhzRc889p9dff11+fn7lrrOwgoIC9enTR7feeqvmzp2rLVu2aNq0acrPz9f06dOd02VlZamgoKDE+fn7+zv79d69eyXJ7ShDRESEPDw8tHfvXo0cObLE+iZMmKDRo0frhhtuuOS0ERERMsbok08+0YABA0qsFcAVxgCodu666y7j7+9vjh075mxLTU01Xl5epvBunZ6ebjw9Pc3MmTNdXr9v3z7j5eXl0t69e3cjyaxcudLZdu7cOdOgQQMzePDgUtd24sQJ4+3tbfr372/sdruz/amnnjKSTFxcnLMtLS3NSDLz5s1zmUetWrXMuHHjSr3MoixfvtxIMhEREeb8+fPO9rlz5xpJZuPGjcYYY7Kzs03t2rXNgw8+6PL6H3/80dSqVculPS4uzkgyTzzxhMu0H3zwgZFkJk6c6FaHYxt89dVXRpIZPXq0y/NTpkwxkswHH3zgbOvevbvp3r2783F+fr45d+6cy+uysrLMNddcY+6//35nW2ZmppFkpk2b5lbHtGnTXPpGWeoJCwszksxHH33kbDtx4oTx8fExCQkJzrZXX33VSDL79u1zmeeePXuMJDNp0iSX9vj4eLd6HXUOHz681OswduxYl+lGjBhR7HYojqMv1q1b1/zyyy/O9o0bNxpJ5p133nG2OfpWaf5dbMiQISYyMtL5WJKlvu7okxMmTHC22e12079/f+Pt7W0yMzOd7Y73saR/hbfbuHHjjKenZ5HLDgkJMbGxsSXWuGjRIlOrVi1z4sQJY8yF/t22bdsipz1+/LiRZObMmVOa1QdwheGIBVDNFBQUaPv27br77rvVsGFDZ/t1112nvn376p133nG2rV+/Xna7XTExMfr555+d7Q0aNFCLFi2UkpKip556ytkeGBjo8uujt7e3brnllhLvzlzY9u3bdf78eU2YMMHltJVJkyZp1qxZpZpH7dq19dlnn+n48eMu61geY8aMcf7SLEmPPPKInnrqKb377rsaOHCgtm3bplOnTmn48OEu28jT01OdOnVyOd2o8DwKW7dunWw2m6ZNm+Y2rWMbvPvuu5Kkxx57zOX5hIQEzZ8/X5s2bVLPnj2LXAdPT095enpKunDK1alTp2S323XzzTeX6fSwwspaT5s2bdS1a1fn45CQELVs2dKlb5w8eVKSVKdOHZd5btmyRZLcTqeZMGFCsefTP/zww6Veh4kTJ7q0T5o0qdwXAA8bNsylfsc6F17PqKgobdu2rczzTklJ0bp16/TZZ5+Vq7ZLKTyylGOkqU2bNmn79u2KjY2VJK1evbpUF783b97c+f+cnBx5e3sXOZ2vr2+J8zt58qSeeeYZTZ06tcgjqhdzbPvC+yKA6oNgAVQzJ06cUE5Ojq677jq35y5uS01NlTFGLVq0KHJehb9wS1Ljxo3dzmGvU6eO/vWvf5W6voyMDElyW2ZISIjbF87izJ07V3FxcWrSpIkiIiLUr18/3XfffS5feErr4joCAwMVGhqq9PR0SRe2kSTdfvvtRb6+Zs2aLo+9vLzcRq46dOiQGjZsqODg4GLryMjIkIeHh9t71KBBA9WuXdu53Yrzxhtv6Pnnn9eBAweUl5fnbG/WrNklX1dR9Vx77bVu86hTp06R16uYi05dcizr4lqL6sMOpVkvx3zDw8Nd2lu2bFnia4tz8Xo6+mzh9QwNDVVoaGiZ5pufn6+JEyfq3nvvVceOHctdX1E8PDzc9o3rr79ekpz9XJI6d+5c5nn7+fm5nMJYWG5ubomnc/3lL39RcHCwJkyYUKrlOfrO5brnCoCKRbAArmJ2u102m02bN292/uJd2MX3GShqGsn9i2Jli4mJUdeuXZWcnKz33ntP8+bN05w5c7R+/foyXetRGna7XdKF6ywaNGjg9ryXl+ufSR8fH3l4lH/ci/J8YVq1apXi4+MVHR2txx9/XPXr15enp6dmz56tQ4cOlbuWstRTmr5Rt25dSRe+hFsdNriirj8oq9KsZ05Ojn799ddSzc/Rp1auXKmDBw9q6dKlLl/2pQuDFaSnp6t+/frOaxsqQ2ZmZqmusQgMDHT+bQgNDVVBQYFOnDih+vXrO6c5f/68Tp48eckjiqmpqVq2bJkWLFig48ePO9tzc3OVl5en9PR01axZ0yWQOwLcxdemAKgeCBZANVO/fn35+vrqu+++c3vu4rbw8HAZY9SsWTPnL5iVzTHSU2pqqsuvqJmZmWUamjI0NFRjx47V2LFjdeLECd10002aOXNmmYNFamqqyyk9p0+f1g8//KB+/fpJkvPX7vr16xc5mlFphIeHa+vWrfrll1+KPWoRFhYmu92u1NRUtW7d2tn+008/6dSpU87tVpS1a9eqefPmWr9+vUsQuPjUq7KEFiv1FKdVq1aSpLS0NJeLdB3LSktLczmCVFQfLgvHfA8dOuRylOLgwYOW5luSt956S6NGjSrVtI5AcuTIEeXl5RV51GDlypVauXKlkpOTFR0dXeZ67Ha7Dh8+7LKP/+c//5Ekl4EHOnbsWOKRMelCv3KM1NWhQwdJ0hdffOHcZxyP7Xa78/miHDt2THa7XRMnTnQ7XU26cFTq0UcfdRkpKi0tTZJc+iSA6oPhZoFqxtPTU7169dKGDRtcfgX87rvvtHnzZpdpBw0aJE9PTyUlJbkddTDGOM+Jr0i9evVSjRo1tHDhQpdlljTMpENBQYHbr8H169dXw4YNSxyWtSjLli1zOXVoyZIlys/PdwaUqKgo1axZU7NmzXKZzsFxr41LGTx4sIwxSkpKcnvOsQ0cX8ou3g4vvPCCJF1yJCPHr+iFt+dnn33mdoM1x6/dp06dKrFmK/UUJyIiQt7e3i5D7EoXtrEkLV682KW9vHdvdnC8hy+99JJLe2n7Wnk5rrEozT+H2NhYJScnu/2TLrwXycnJ6tSpU7lrWrRokfP/xhgtWrRINWrU0B133OFsX716dalqvu+++5yvuf322xUcHKwlS5a4LG/JkiXy9/d36Sc///yzDhw4oLNnz0qS2rVrV+Q6t23bVtdee62Sk5P1wAMPuMx3z549stlsuu2228q9LQBUHY5YANVQYmKi3nvvPXXu3FmPPPKICgoKtGjRIrVr105fffWVc7rw8HDNmDFDTz75pNLT0xUdHa2goCClpaUpOTlZY8aMqZCx9AsLCQnRlClTNHv2bA0YMED9+vXT3r17tXnz5lKd3pCdna3GjRtryJAhat++vQIDA7V9+3bt3r1bzz//fJnrOX/+vO644w7FxMTo4MGDWrx4sbp06aKBAwdKunANxZIlS3TvvffqpptuUmxsrEJCQnTkyBFt2rRJnTt3dvnSVpSePXvq3nvv1UsvvaTU1FT16dNHdrtdH3/8sXr27Knx48erffv2iouL07Jly3Tq1Cl1795dn3/+ud544w1FR0cXe+G2JA0YMEDr16/X3Xffrf79+ystLU0vv/yy2rRpo9OnTzun8/PzU5s2bfTWW2/p+uuvV3BwsNq1a6d27dq5zdNKPcXx9fVV7969tX37dpdhTiMiIjR48GAtWLBAJ0+edA436/hVvbzn03fo0EHDhw/X4sWL9euvvyoyMlLvv/++5SMhJSnPNRatWrVyHtG5WLNmzdyOVPTo0UMffvhhqU5D9PX11ZYtWxQXF6dOnTpp8+bN2rRpk5566imXC6bLe43Fs88+q3Hjxmno0KGKiorSxx9/rFWrVmnmzJkuR+gWLVqkpKQkpaSkqEePHqpXr16RR2Acwa+o57Zt26bOnTs7T6sDUM1c/oGoAFSE999/39x4443G29vbhIeHm1dffdUkJCQYX19ft2nXrVtnunTpYgICAkxAQIBp1aqVGTdunDl48KBzmuKGgIyLizNhYWFlqq2goMAkJSWZ0NBQ4+fnZ3r06GH+/e9/m7CwsBKHmz137px5/PHHTfv27U1QUJAJCAgw7du3N4sXLy5TDY4hQT/88EMzZswYU6dOHRMYGGjuuecec/LkSbfpU1JSTFRUlKlVq5bx9fU14eHhJj4+3nzxxRcu2yIgIKDI5eXn55t58+aZVq1aGW9vbxMSEmL69u1r9uzZ45wmLy/PJCUlmWbNmpkaNWqYJk2amCeffNLk5ua6zOvi4WbtdruZNWuWCQsLMz4+PubGG280//d//1fke/PJJ5+YiIgI4+3t7TJ06MVDtZalnrCwMNO/f3+3db64TmOMWb9+vbHZbObIkSMu7WfOnDHjxo0zwcHBJjAw0ERHR5uDBw8aSea5555zTueos/AwqRc/V1hOTo6ZOHGiqVu3rgkICDB33XWXOXr0aLmHm7146GNjTJnnVRYqZrjZiIgI06BBgxJf7+iThw4dMr179zb+/v7mmmuuMdOmTTMFBQUVVueyZctMy5YtnX9vXnzxRZfhpI357/uTkpJyyXkV97fm1KlTxtvb27z66qsVVjeAy8tmzGW+KhNApYmOjtY333zjHOno92zFihUaNWqUdu/e7XZzL1SegoICtWnTRjExMXr22WcvOe1XX32lG2+8UatWrXLewRwXjtoFBwdrwYIFGjdu3CWnjY+P19q1a12OXFVXCxYs0Ny5c3Xo0KEqu3gfgDVcYwFUUxePH5+amqp3331XPXr0qJqCAF24HmT69On629/+5vJlt6j7HSxYsEAeHh7q1q3b5SzxivfRRx+pUaNGevDBB6u6lMsmLy9PL7zwgv7yl78QKoBqjGssgGqqefPmio+PV/PmzZWRkaElS5bI29tbf/rTnyptmSUNV+nt7X3JezlUhNIM9VnZNeDShg0bpmHDhrm0zZ07V3v27FHPnj3l5eWlzZs3a/PmzRozZoyaNGlSabUUFBSUeAF+4eFVrwT9+/cv18Xz1VmNGjV05MiRqi4DgEUEC6Ca6tOnj/7nf/5HP/74o3x8fHTbbbdp1qxZxd4MryKUNFxl9+7dtWPHjkpbvlS6oT6Luls2qlZkZKS2bdumZ599VqdPn9a1116rxMREPf3005W63KNHj5Z4s73Cw6sCAMqPaywAlNo///nPIk9pcahTp44iIiIqtYYffvhB33zzzSWniYiIKPVdvnF1y83N1c6dOy85TfPmzct1V3cAgCuCBQAAAADLuHgbAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGCZV2kmstvtOn78uIKCgmSz2Sq7JqDSGWOUnZ2thg0bysOjbPma/QFXGyv7g8Q+gasPnxHAf5VlfyhVsDh+/LiaNGlSIcUBV5KjR4+qcePGZXoN+wOuVuXZHyT2CVy9+IwA/qs0+0OpYnhQUFCFFARcacrTt9kfcLUqb99mn8DVis8I4L9K07dLFSw4lIerVXn6NvsDrlbl7dvsE7ha8RkB/Fdp+jYXbwMAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALPOqqgUbY6pq0ajGbDZbVZdQKdgfUB5X6/4g/T73iYp+P9mGV4/f43sJ66pif+CIBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsMyrqguoKDabrapLuOyMMRU6v8rYhhVdI0qnOryX7LO4nKrDPnGlYxteParDe8lnRPXEEQsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZV5VXUBFMcZUdQmXnc1W0XOshG1Y8UWiFKrD/lAdakQVqvC/HRXf3yq6RPYJXC7Voa9VhxrhjiMWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMq+qLqCi2Gy2qi6hCpgKnl8lbENTwTX+Lt/nsquM/cFU8HtZ0TVe6fVJFV/jVa1a/O248vscrg7VoW9c6X+Dr/T6pKvjM4IjFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKvqi7gSmaMqeoSLskmW4XOz+jKXl9cXa70/atS2Cp2n8XV5UrfJ2z03ypzpfeNynClr3Ol1HcV7GMcsQAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJZ5VdWCbTZbVS26ylT0OhtjKnR+v8f3BKVH/7DOpordZyXek6vJlf4ZgasHf8+vVNX/M4IjFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLvKpqwcaYqlp0lbnS1/lKr0+SbDZbVZdQLVSH97Ki2VTBfcP2+9uGKCNTsX3O6Mruc7/HvytXq9/je8lnxOXBEQsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGAZwQIAAACAZQQLAAAAAJYRLAAAAABYRrAAAAAAYBnBAgAAAIBlBAsAAAAAlhEsAAAAAFhGsAAAAABgGcECAAAAgGUECwAAAACWESwAAAAAWEawAAAAAGCZV1Ut2GazVdWigSsO+8OViPekKlWLfaKCS7TR51CMarE//O7wnhSFIxYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAywgWAAAAACwjWAAAAACwjGABAAAAwDKCBQAAAADLCBYAAAAALCNYAAAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsKxUwcIYU9l1AFWiPH2b/QFXq/L2bfYJXK34jAD+qzR9u1TBIjs723IxwJWoPH2b/QFXq/L2bfYJXK34jAD+qzR922ZKET/sdruOHz+uoKAg2Wy2CikOqErGGGVnZ6thw4by8CjbGYHsD7jaWNkfJPYJXH34jAD+qyz7Q6mCBQAAAABcChdvAwAAALCMYAEAAADAMoIFAAAAAMsIFgAAAAAsI1gAAAAAsIxgAQAAAMAyggUAAAAAy/4fbGp8qpgY/tAAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -806,398 +705,9 @@ } ], "source": [ - "plot_dataset_mazes(dataset_dfs_perc)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ds.cfg.name = 'test_disconnected'\n", - "{\n", - " \"func_name\": {\n", - " \"gen_dfs\": 32\n", - " },\n", - " \"grid_shape\": {\n", - " \"(10, 10)\": 32\n", - " },\n", - " \"start_coord\": {\n", - " \"(6, 3)\": 1,\n", - " \"(4, 1)\": 1,\n", - " \"(2, 0)\": 1,\n", - " \"(7, 4)\": 1,\n", - " \"(5, 3)\": 1,\n", - " \"(5, 6)\": 1,\n", - " \"(8, 3)\": 1,\n", - " \"(8, 2)\": 1,\n", - " \"(2, 5)\": 2,\n", - " \"(2, 7)\": 1,\n", - " \"(5, 5)\": 1,\n", - " \"(2, 4)\": 2,\n", - " \"(7, 3)\": 1,\n", - " \"(8, 6)\": 1,\n", - " \"(8, 1)\": 1,\n", - " \"(3, 5)\": 2,\n", - " \"(0, 4)\": 2,\n", - " \"(2, 1)\": 1,\n", - " \"(8, 5)\": 1,\n", - " \"(1, 2)\": 1,\n", - " \"(7, 1)\": 1,\n", - " \"(1, 3)\": 1,\n", - " \"(1, 7)\": 1,\n", - " \"(2, 3)\": 1,\n", - " \"(3, 0)\": 1,\n", - " \"(2, 2)\": 1,\n", - " \"(5, 1)\": 1,\n", - " \"(1, 0)\": 1\n", - " },\n", - " \"n_accessible_cells\": {\n", - " \"70\": 32\n", - " },\n", - " \"max_tree_depth\": {\n", - " \"15\": 32\n", - " },\n", - " \"fully_connected\": {\n", - " \"False\": 32\n", - " },\n", - " \"visited_cells\": {\n", - " \"(3, 4)\": 22,\n", - " \"(4, 3)\": 23,\n", - " \"(3, 7)\": 10,\n", - " \"(5, 4)\": 24,\n", - " \"(4, 6)\": 18,\n", - " \"(5, 1)\": 15,\n", - " \"(5, 7)\": 11,\n", - " \"(9, 5)\": 9,\n", - " \"(8, 3)\": 13,\n", - " \"(8, 6)\": 9,\n", - " \"(2, 5)\": 17,\n", - " \"(7, 4)\": 14,\n", - " \"(6, 2)\": 17,\n", - " \"(7, 1)\": 12,\n", - " \"(7, 7)\": 8,\n", - " \"(6, 5)\": 17,\n", - " \"(6, 8)\": 5,\n", - " \"(4, 2)\": 21,\n", - " \"(4, 5)\": 22,\n", - " \"(3, 3)\": 22,\n", - " \"(5, 6)\": 15,\n", - " \"(4, 8)\": 7,\n", - " \"(3, 6)\": 16,\n", - " \"(5, 3)\": 23,\n", - " \"(5, 9)\": 4,\n", - " \"(8, 2)\": 11,\n", - " \"(9, 7)\": 6,\n", - " \"(8, 5)\": 13,\n", - " \"(8, 8)\": 6,\n", - " \"(2, 4)\": 24,\n", - " \"(1, 5)\": 17,\n", - " \"(6, 4)\": 16,\n", - " \"(7, 3)\": 14,\n", - " \"(6, 7)\": 8,\n", - " \"(7, 6)\": 11,\n", - " \"(4, 7)\": 14,\n", - " \"(3, 5)\": 22,\n", - " \"(5, 2)\": 18,\n", - " \"(4, 4)\": 23,\n", - " \"(5, 5)\": 19,\n", - " \"(8, 4)\": 12,\n", - " \"(9, 3)\": 10,\n", - " \"(5, 8)\": 7,\n", - " \"(8, 7)\": 8,\n", - " \"(9, 6)\": 7,\n", - " \"(2, 6)\": 11,\n", - " \"(7, 2)\": 14,\n", - " \"(6, 6)\": 12,\n", - " \"(7, 5)\": 13,\n", - " \"(6, 3)\": 18,\n", - " \"(4, 0)\": 11,\n", - " \"(3, 1)\": 15,\n", - " \"(8, 0)\": 8,\n", - " \"(0, 2)\": 15,\n", - " \"(2, 2)\": 17,\n", - " \"(1, 0)\": 13,\n", - " \"(1, 3)\": 20,\n", - " \"(3, 0)\": 13,\n", - " \"(5, 0)\": 12,\n", - " \"(9, 1)\": 7,\n", - " \"(0, 1)\": 14,\n", - " \"(2, 1)\": 16,\n", - " \"(6, 1)\": 12,\n", - " \"(7, 0)\": 6,\n", - " \"(3, 2)\": 18,\n", - " \"(4, 1)\": 16,\n", - " \"(8, 1)\": 8,\n", - " \"(0, 0)\": 10,\n", - " \"(1, 1)\": 12,\n", - " \"(2, 0)\": 11,\n", - " \"(2, 3)\": 23,\n", - " \"(6, 0)\": 9,\n", - " \"(0, 5)\": 12,\n", - " \"(1, 2)\": 18,\n", - " \"(0, 4)\": 18,\n", - " \"(0, 3)\": 18,\n", - " \"(1, 4)\": 21,\n", - " \"(9, 2)\": 8,\n", - " \"(9, 4)\": 11,\n", - " \"(7, 9)\": 2,\n", - " \"(9, 0)\": 7,\n", - " \"(7, 8)\": 5,\n", - " \"(4, 9)\": 5,\n", - " \"(2, 7)\": 10,\n", - " \"(3, 8)\": 9,\n", - " \"(1, 6)\": 13,\n", - " \"(0, 8)\": 7,\n", - " \"(1, 9)\": 4,\n", - " \"(2, 8)\": 6,\n", - " \"(3, 9)\": 4,\n", - " \"(0, 7)\": 10,\n", - " \"(1, 8)\": 8,\n", - " \"(0, 6)\": 11,\n", - " \"(1, 7)\": 9,\n", - " \"(0, 9)\": 5,\n", - " \"(2, 9)\": 5,\n", - " \"(8, 9)\": 1,\n", - " \"(9, 8)\": 2,\n", - " \"(6, 9)\": 2,\n", - " \"(9, 9)\": 1\n", - " }\n", - "}\n", - "ds.cfg.name = 'test_hallway'\n", - "{\n", - " \"func_name\": {\n", - " \"gen_dfs\": 5\n", - " },\n", - " \"grid_shape\": {\n", - " \"(5, 5)\": 5\n", - " },\n", - " \"start_coord\": {\n", - " \"(2, 3)\": 1,\n", - " \"(2, 2)\": 1,\n", - " \"(0, 1)\": 1,\n", - " \"(3, 1)\": 1,\n", - " \"(2, 1)\": 1\n", - " },\n", - " \"n_accessible_cells\": {\n", - " \"70\": 5\n", - " },\n", - " \"max_tree_depth\": {\n", - " \"15\": 5\n", - " },\n", - " \"fully_connected\": {\n", - " \"False\": 5\n", - " },\n", - " \"visited_cells\": {\n", - " \"(4, 4)\": 1,\n", - " \"(2, 4)\": 1,\n", - " \"(4, 0)\": 1,\n", - " \"(3, 4)\": 1,\n", - " \"(4, 3)\": 2,\n", - " \"(4, 2)\": 2,\n", - " \"(2, 3)\": 5,\n", - " \"(4, 1)\": 2,\n", - " \"(1, 2)\": 2,\n", - " \"(2, 1)\": 2,\n", - " \"(1, 1)\": 2,\n", - " \"(2, 0)\": 2,\n", - " \"(2, 2)\": 3,\n", - " \"(1, 0)\": 2,\n", - " \"(1, 3)\": 2,\n", - " \"(0, 1)\": 1,\n", - " \"(0, 4)\": 1,\n", - " \"(0, 3)\": 1,\n", - " \"(1, 4)\": 1,\n", - " \"(0, 2)\": 1,\n", - " \"(3, 3)\": 3,\n", - " \"(3, 1)\": 1,\n", - " \"(3, 2)\": 1\n", - " }\n", - "}\n", - "ds.cfg.name = 'test_perc'\n", - "{\n", - " \"func_name\": {\n", - " \"gen_percolation\": 5\n", - " },\n", - " \"grid_shape\": {\n", - " \"(8, 8)\": 5\n", - " },\n", - " \"percolation_p\": {\n", - " \"0.5\": 5\n", - " },\n", - " \"start_coord\": {\n", - " \"(6, 3)\": 1,\n", - " \"(3, 1)\": 2,\n", - " \"(2, 1)\": 1,\n", - " \"(4, 1)\": 1\n", - " },\n", - " \"visited_cells\": {\n", - " \"(4, 0)\": 2,\n", - " \"(3, 4)\": 3,\n", - " \"(4, 3)\": 3,\n", - " \"(3, 1)\": 4,\n", - " \"(3, 7)\": 1,\n", - " \"(5, 4)\": 3,\n", - " \"(4, 6)\": 1,\n", - " \"(5, 7)\": 2,\n", - " \"(0, 5)\": 2,\n", - " \"(2, 2)\": 2,\n", - " \"(1, 6)\": 2,\n", - " \"(2, 5)\": 2,\n", - " \"(1, 3)\": 1,\n", - " \"(6, 5)\": 2,\n", - " \"(4, 2)\": 3,\n", - " \"(3, 0)\": 1,\n", - " \"(4, 5)\": 3,\n", - " \"(5, 6)\": 2,\n", - " \"(3, 6)\": 1,\n", - " \"(5, 3)\": 3,\n", - " \"(2, 4)\": 2,\n", - " \"(0, 4)\": 2,\n", - " \"(2, 1)\": 3,\n", - " \"(2, 7)\": 1,\n", - " \"(1, 5)\": 2,\n", - " \"(6, 4)\": 2,\n", - " \"(3, 2)\": 4,\n", - " \"(4, 1)\": 4,\n", - " \"(4, 7)\": 1,\n", - " \"(3, 5)\": 2,\n", - " \"(4, 4)\": 3,\n", - " \"(5, 5)\": 3,\n", - " \"(1, 1)\": 2,\n", - " \"(0, 3)\": 1,\n", - " \"(1, 4)\": 2,\n", - " \"(2, 3)\": 2,\n", - " \"(1, 7)\": 1,\n", - " \"(2, 6)\": 2,\n", - " \"(6, 3)\": 2,\n", - " \"(3, 3)\": 2,\n", - " \"(0, 1)\": 1,\n", - " \"(0, 7)\": 1,\n", - " \"(1, 2)\": 1,\n", - " \"(2, 0)\": 1,\n", - " \"(0, 6)\": 1,\n", - " \"(5, 1)\": 2,\n", - " \"(7, 4)\": 1,\n", - " \"(7, 1)\": 1,\n", - " \"(7, 7)\": 1,\n", - " \"(6, 1)\": 1,\n", - " \"(7, 3)\": 1,\n", - " \"(6, 7)\": 1,\n", - " \"(7, 6)\": 1,\n", - " \"(5, 2)\": 1,\n", - " \"(7, 2)\": 1,\n", - " \"(6, 6)\": 1,\n", - " \"(7, 5)\": 1,\n", - " \"(5, 0)\": 1,\n", - " \"(6, 0)\": 1\n", - " }\n", - "}\n", - "ds.cfg.name = 'test_dfs_perc'\n", - "{\n", - " \"func_name\": {\n", - " \"gen_dfs_percolation\": 5\n", - " },\n", - " \"grid_shape\": {\n", - " \"(8, 8)\": 5\n", - " },\n", - " \"start_coord\": {\n", - " \"(6, 3)\": 1,\n", - " \"(2, 3)\": 1,\n", - " \"(2, 1)\": 1,\n", - " \"(2, 4)\": 1,\n", - " \"(1, 5)\": 1\n", - " },\n", - " \"n_accessible_cells\": {\n", - " \"64\": 5\n", - " },\n", - " \"max_tree_depth\": {\n", - " \"128\": 5\n", - " },\n", - " \"fully_connected\": {\n", - " \"True\": 5\n", - " },\n", - " \"visited_cells\": {\n", - " \"(4, 0)\": 5,\n", - " \"(3, 4)\": 5,\n", - " \"(4, 3)\": 5,\n", - " \"(3, 1)\": 5,\n", - " \"(3, 7)\": 5,\n", - " \"(5, 4)\": 5,\n", - " \"(4, 6)\": 5,\n", - " \"(5, 1)\": 5,\n", - " \"(5, 7)\": 5,\n", - " \"(0, 2)\": 5,\n", - " \"(0, 5)\": 5,\n", - " \"(2, 2)\": 5,\n", - " \"(1, 0)\": 5,\n", - " \"(1, 6)\": 5,\n", - " \"(2, 5)\": 5,\n", - " \"(1, 3)\": 5,\n", - " \"(7, 4)\": 5,\n", - " \"(6, 2)\": 5,\n", - " \"(7, 1)\": 5,\n", - " \"(7, 7)\": 5,\n", - " \"(6, 5)\": 5,\n", - " \"(4, 2)\": 5,\n", - " \"(3, 0)\": 5,\n", - " \"(4, 5)\": 5,\n", - " \"(3, 3)\": 5,\n", - " \"(5, 0)\": 5,\n", - " \"(5, 6)\": 5,\n", - " \"(3, 6)\": 5,\n", - " \"(5, 3)\": 5,\n", - " \"(0, 1)\": 5,\n", - " \"(0, 7)\": 5,\n", - " \"(2, 4)\": 5,\n", - " \"(1, 2)\": 5,\n", - " \"(0, 4)\": 5,\n", - " \"(2, 1)\": 5,\n", - " \"(2, 7)\": 5,\n", - " \"(1, 5)\": 5,\n", - " \"(6, 1)\": 5,\n", - " \"(7, 0)\": 5,\n", - " \"(6, 4)\": 5,\n", - " \"(7, 3)\": 5,\n", - " \"(6, 7)\": 5,\n", - " \"(7, 6)\": 5,\n", - " \"(3, 2)\": 5,\n", - " \"(4, 1)\": 5,\n", - " \"(4, 7)\": 5,\n", - " \"(3, 5)\": 5,\n", - " \"(5, 2)\": 5,\n", - " \"(4, 4)\": 5,\n", - " \"(5, 5)\": 5,\n", - " \"(0, 0)\": 5,\n", - " \"(1, 1)\": 5,\n", - " \"(0, 3)\": 5,\n", - " \"(2, 0)\": 5,\n", - " \"(1, 4)\": 5,\n", - " \"(0, 6)\": 5,\n", - " \"(2, 3)\": 5,\n", - " \"(1, 7)\": 5,\n", - " \"(2, 6)\": 5,\n", - " \"(7, 2)\": 5,\n", - " \"(6, 0)\": 5,\n", - " \"(6, 6)\": 5,\n", - " \"(7, 5)\": 5,\n", - " \"(6, 3)\": 5\n", - " },\n", - " \"percolation_p\": {\n", - " \"0.2\": 5\n", - " }\n", - "}\n" - ] - } - ], - "source": [ - "for ds in [dataset_not_fully_connected, dataset_hallway, dataset_perc, dataset_dfs_perc]:\n", - "\tprint(f\"{ds.cfg.name = }\")\n", - "\tpprint_summary(ds.filter_by.collect_generation_meta().serialize()['generation_metadata_collected'])" + "for g, ds_list in DATASETS.items():\n", + " for ds in ds_list:\n", + " plot_dataset_mazes(ds, figsize_mult=(2, 4))\n" ] } ], diff --git a/notebooks/demo_generator.ipynb b/notebooks/demo_generator.ipynb index ee52861a..f6095c22 100644 --- a/notebooks/demo_generator.ipynb +++ b/notebooks/demo_generator.ipynb @@ -51,7 +51,7 @@ "sample_lattice_maze = LatticeMazeGenerators.gen_dfs(\n", " grid_shape=(6,6), \n", " lattice_dim=2,\n", - " n_accessible_cells = 20,\n", + " accessible_cells = 20,\n", " max_tree_depth = None,\n", " start_coord = None,\n", ")\n", @@ -88,7 +88,7 @@ "sample_lattice_maze = LatticeMazeGenerators.gen_dfs(\n", " grid_shape=(6,6), \n", " lattice_dim=2,\n", - " n_accessible_cells = None,\n", + " accessible_cells = None,\n", " max_tree_depth = 5,\n", " start_coord = (0,0),\n", ")\n", @@ -125,7 +125,7 @@ "sample_lattice_maze = LatticeMazeGenerators.gen_dfs(\n", " grid_shape=(6,6), \n", " lattice_dim=2,\n", - " n_accessible_cells = None,\n", + " accessible_cells = None,\n", " max_tree_depth = None,\n", " start_coord = None,\n", ")\n", @@ -162,7 +162,7 @@ "sample_lattice_maze = LatticeMazeGenerators.gen_dfs(\n", " grid_shape=(10,10), \n", " lattice_dim=2,\n", - " n_accessible_cells = 20,\n", + " accessible_cells = 20,\n", " max_tree_depth = 5,\n", " start_coord = (5,5),\n", ")\n", diff --git a/notebooks/direct_logit_attribution.ipynb b/notebooks/direct_logit_attribution.ipynb new file mode 100644 index 00000000..e09bcb0d --- /dev/null +++ b/notebooks/direct_logit_attribution.ipynb @@ -0,0 +1,967 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Logit Lens and Direct Logit Attribution" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "In this notebook we explore how the model is doing prediction of the first path token in the maze (ie. the token that immediately comes after the `PATH_START` token), to this end we use:\n", + "\n", + "* Logit Lens\n", + "* Direct Logit Attribution\n", + "* Activation Patching\n", + "\n", + "In summary, we find that the majority of computation associated with this task is in the form of MLP computation (in particular in MLP10 and MLP11) but that there does appear to be a few heads within early layers (Layer 0, 1 and 2) that are also playing some role. Further evals outside of this notebook however are suggestive of this instance of maze-transformer doing some form of memorization (atleast overfitting to its training data and not generalising OOD), for this reason, this study has not yet been taken further.\n", + "\n", + "This notebook takes significant inspiration from two great resources:\n", + "\n", + "* Nanda's [Exploratory Analysis Demo](https://github.com/neelnanda-io/TransformerLens/blob/main/demos/Exploratory_Analysis_Demo.ipynb) Notebook\n", + "* Janiak & Heimersheim's [Python docstrings](https://colab.research.google.com/drive/17CoA1yARaWHvV14zQGcI3ISz1bIRZKS5) Notebook" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\mivan\\AppData\\Local\\pypoetry\\Cache\\virtualenvs\\maze-transformer-2cGx2R0F-py3.10\\lib\\site-packages\\_distutils_hack\\__init__.py:33: UserWarning: Setuptools is replacing distutils.\n", + " warnings.warn(\"Setuptools is replacing distutils.\")\n" + ] + } + ], + "source": [ + "# Generic\n", + "import os\n", + "from pathlib import Path\n", + "from copy import deepcopy\n", + "import typing\n", + "\n", + "# Numerical Computing\n", + "import numpy as np\n", + "import torch\n", + "import pandas as pd\n", + "# import torch.nn.functional as F\n", + "from fancy_einsum import einsum\n", + "import einops\n", + "from jaxtyping import Float, Int, Bool\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from muutils.misc import shorten_numerical_to_str\n", + "from muutils.nbutils.configure_notebook import configure_notebook\n", + "# TransformerLens imports\n", + "from transformer_lens import ActivationCache\n", + "\n", + "# Our Code\n", + "# dataset stuff\n", + "from maze_dataset import MazeDataset, MazeDatasetConfig, SolvedMaze, LatticeMaze, SPECIAL_TOKENS\n", + "from maze_dataset.tokenization import MazeTokenizer, TokenizationMode\n", + "from maze_dataset.plotting.print_tokens import color_maze_tokens_AOTP\n", + "\n", + "# model stuff\n", + "from maze_transformer.training.config import ConfigHolder, ZanjHookedTransformer, BaseGPTConfig\n", + "\n", + "# mechinterp stuff\n", + "from maze_transformer.mechinterp.plot_logits import plot_logits\n", + "from maze_transformer.mechinterp.logit_attrib_task import DLAProtocol, DLAProtocolFixed, token_after_fixed_start_token, LOGIT_ATTRIB_TASKS\n", + "from maze_transformer.mechinterp.logit_diff import logits_diff_multi\n", + "from maze_transformer.mechinterp.logit_lens import plot_logit_lens\n", + "from maze_transformer.mechinterp.direct_logit_attribution import plot_direct_logit_attribution\n", + "from maze_transformer.mechinterp.plot_attention import plot_attention_final_token\n", + "from maze_transformer.mechinterp.plot_weights import plot_important_neurons\n", + "from maze_transformer.utils.dict_shapes import string_dict_shapes\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEVICE = device(type='cuda')\n", + "list(LOGIT_ATTRIB_TASKS.keys()) = ['path_start', 'origin_after_path_start', 'first_path_choice', 'path_end', 'final_before_path_end', 'rand_path_token', 'rand_path_token_non_endpoint']\n" + ] + } + ], + "source": [ + "# Setup (we won't be training any models)\n", + "DEVICE: torch.device = configure_notebook(seed=42, dark_mode=False)\n", + "print(f\"{DEVICE = }\")\n", + "torch.set_grad_enabled(False)\n", + "\n", + "# print the available logit attribution tasks\n", + "print(f\"{list(LOGIT_ATTRIB_TASKS.keys()) = }\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## primary configuration\n", + "\n", + "this is where we pick the model to load, task to perform, dataset to use, etc" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# path to load the model from\n", + "MODEL_PATH: str = \"../examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\"\n", + "# source for dataset config. Either add your own here, or it will copy the one from the model if set to None\n", + "DATASET_CFG_SOURCE: MazeDatasetConfig|None = None\n", + "# number of examples to run experiments on\n", + "N_EXAMPLES: int = 10\n", + "# task to perform\n", + "LOGIT_ATTRIBUTION_TASK_NAME: str = \"path_end\"\n", + "# if you have a custom task, set it here -- otherwise we will attempt to load one of the known tasks\n", + "LOGIT_ATTRIBUTION_TASK: DLAProtocolFixed|None = None\n", + "if LOGIT_ATTRIBUTION_TASK is None:\n", + " LOGIT_ATTRIBUTION_TASK = LOGIT_ATTRIB_TASKS[LOGIT_ATTRIBUTION_TASK_NAME]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Loading the model in\n", + "\n", + "By default, we load the small \"hallway\" model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded model with 1.3M params (num_params = 1274699) from\n", + "../examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\n" + ] + } + ], + "source": [ + "MODEL: ZanjHookedTransformer = ZanjHookedTransformer.read(MODEL_PATH)\n", + "num_params: int = MODEL.num_params()\n", + "print(f\"loaded model with {shorten_numerical_to_str(num_params)} params ({num_params = }) from\\n{MODEL_PATH}\")\n", + "TOKENIZER: MazeTokenizer = MODEL.zanj_model_config.maze_tokenizer" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Dataset Creation\n", + "\n", + "Creating a collection of mazes to have the model predict on" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded 10 mazes\n", + "first maze:\n", + " (6,4) <--> (6,3) ; (4,7) <--> (3,7) ; (3,4) <--> (3,5) ; (3,3) <--> (4,3) ; (4,4) <--> (4,5) ; (3,7) <--> (3,6) ; (3,3) <--> (3,4) ; (4,7) <--> (4,6) ; (4,2) <--> (4,1) ; (6,5) <--> (5,5) ; (3,5) <--> (3,6) ; (4,6) <--> (4,5) ; (5,1) <--> (4,1) ; (6,4) <--> (6,5) ; (5,1) <--> (5,2) ; (5,2) <--> (5,3) ; (5,3) <--> (5,4) ; (4,3) <--> (4,2) ; (5,4) <--> (5,5) ; (3,4) (4,1) (3,4) (3,3) (4,3) (4,2) (4,1) \n", + "first maze, colored:\n", + "\u001b[30m\u001b[48;2;217;210;233m (6,4) <--> (6,3) ; (4,7) <--> (3,7) ; (3,4) <--> (3,5) ; (3,3) <--> (4,3) ; (4,4) <--> (4,5) ; (3,7) <--> (3,6) ; (3,3) <--> (3,4) ; (4,7) <--> (4,6) ; (4,2) <--> (4,1) ; (6,5) <--> (5,5) ; (3,5) <--> (3,6) ; (4,6) <--> (4,5) ; (5,1) <--> (4,1) ; (6,4) <--> (6,5) ; (5,1) <--> (5,2) ; (5,2) <--> (5,3) ; (5,3) <--> (5,4) ; (4,3) <--> (4,2) ; (5,4) <--> (5,5) ; \u001b[0m \u001b[30m\u001b[48;2;217;234;211m (3,4) \u001b[0m \u001b[30m\u001b[48;2;234;209;220m (4,1) \u001b[0m \u001b[30m\u001b[48;2;207;226;243m (3,4) (3,3) (4,3) (4,2) (4,1) \u001b[0m\n" + ] + } + ], + "source": [ + "# copy config if needed, adjust number of mazes\n", + "if DATASET_CFG_SOURCE is None:\n", + "\tDATASET_CFG_SOURCE = deepcopy(MODEL.zanj_model_config.dataset_cfg)\n", + "DATASET_CFG_SOURCE.n_mazes = N_EXAMPLES\n", + "\n", + "# get the dataset and tokens\n", + "DATASET: MazeDataset = MazeDataset.from_config(DATASET_CFG_SOURCE)\n", + "DATASET_TOKENS: list[list[str]] = DATASET.as_tokens(TOKENIZER, join_tokens_individual_maze=False)\n", + "\n", + "# print some info\n", + "print(f\"loaded {len(DATASET_TOKENS)} mazes\")\n", + "print(f\"first maze:\\n{' '.join(DATASET_TOKENS[0])}\")\n", + "print(f\"first maze, colored:\\n{color_maze_tokens_AOTP(DATASET_TOKENS[0], fmt='terminal')}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "process the data into prompts and targets" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "for first maze:\n", + "full:\n", + " (6,4) <--> (6,3) ; (4,7) <--> (3,7) ; (3,4) <--> (3,5) ; (3,3) <--> (4,3) ; (4,4) <--> (4,5) ; (3,7) <--> (3,6) ; (3,3) <--> (3,4) ; (4,7) <--> (4,6) ; (4,2) <--> (4,1) ; (6,5) <--> (5,5) ; (3,5) <--> (3,6) ; (4,6) <--> (4,5) ; (5,1) <--> (4,1) ; (6,4) <--> (6,5) ; (5,1) <--> (5,2) ; (5,2) <--> (5,3) ; (5,3) <--> (5,4) ; (4,3) <--> (4,2) ; (5,4) <--> (5,5) ; (3,4) (4,1) (3,4) (3,3) (4,3) (4,2) (4,1)\n", + "prompt:\n", + "[...] 4,2) ; (5,4) <--> (5,5) ; (3,4) (4,1) (3,4) (3,3) (4,3) (4,2) (4,1)\n", + "target:\n", + "\n", + "target id:\n", + "7\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# process with the task\n", + "DATASET_PROMPTS: list[list[str]]; DATASET_TARGETS: list[str]\n", + "DATASET_PROMPTS, DATASET_TARGETS = LOGIT_ATTRIBUTION_TASK(DATASET_TOKENS)\n", + "\n", + "DATASET_PROMPTS_JOINED: list[str] = [\" \".join(prompt) for prompt in DATASET_PROMPTS]\n", + "DATASET_TARGET_IDS: Float[torch.Tensor, \"n_mazes\"] = torch.tensor(TOKENIZER.encode(DATASET_TARGETS), dtype=torch.long).cpu()\n", + "\n", + "print(\"for first maze:\")\n", + "print(f\"full:\\n{' '.join(DATASET_PROMPTS[0])}\")\n", + "print(f\"prompt:\\n{'[...] ' + DATASET_PROMPTS_JOINED[0][-150:]}\")\n", + "print(f\"target:\\n{DATASET_TARGETS[0]}\")\n", + "print(f\"target id:\\n{DATASET_TARGET_IDS[0]}\")\n", + "plt.imshow(DATASET[0].as_pixels())\n", + "\n", + "n_mazes: int = len(DATASET_TOKENS)\n", + "d_vocab: int = TOKENIZER.vocab_size" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# run model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "LOGITS: Float[torch.Tensor, \"n_mazes seq_len d_vocab\"]\n", + "CACHE: ActivationCache\n", + "\n", + "LOGITS, CACHE = MODEL.run_with_cache(DATASET_PROMPTS_JOINED)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n_mazes = 10, d_vocab = 75\n", + "LOGITS.shape = torch.Size([10, 233, 75])\n", + "cache_shapes = {'hook_embed': torch.Size([10, 233, 128]), 'hook_pos_embed': torch.Size([10, 233, 128]), 'blocks.0.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.0.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.0.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.0.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.0.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.0.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.0.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.0.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.0.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.0.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.0.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.0.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.0.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.0.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.0.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.0.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.0.hook_resid_post': torch.Size([10, 233, 128]), 'blocks.1.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.1.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.1.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.1.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.1.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.1.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.1.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.1.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.1.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.1.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.1.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.1.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.1.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.1.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.1.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.1.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.1.hook_resid_post': torch.Size([10, 233, 128]), 'blocks.2.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.2.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.2.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.2.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.2.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.2.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.2.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.2.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.2.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.2.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.2.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.2.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.2.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.2.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.2.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.2.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.2.hook_resid_post': torch.Size([10, 233, 128]), 'blocks.3.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.3.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.3.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.3.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.3.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.3.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.3.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.3.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.3.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.3.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.3.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.3.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.3.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.3.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.3.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.3.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.3.hook_resid_post': torch.Size([10, 233, 128]), 'blocks.4.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.4.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.4.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.4.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.4.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.4.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.4.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.4.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.4.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.4.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.4.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.4.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.4.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.4.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.4.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.4.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.4.hook_resid_post': torch.Size([10, 233, 128]), 'blocks.5.hook_resid_pre': torch.Size([10, 233, 128]), 'blocks.5.ln1.hook_scale': torch.Size([10, 233, 1]), 'blocks.5.ln1.hook_normalized': torch.Size([10, 233, 128]), 'blocks.5.attn.hook_q': torch.Size([10, 233, 4, 32]), 'blocks.5.attn.hook_k': torch.Size([10, 233, 4, 32]), 'blocks.5.attn.hook_v': torch.Size([10, 233, 4, 32]), 'blocks.5.attn.hook_attn_scores': torch.Size([10, 4, 233, 233]), 'blocks.5.attn.hook_pattern': torch.Size([10, 4, 233, 233]), 'blocks.5.attn.hook_z': torch.Size([10, 233, 4, 32]), 'blocks.5.hook_attn_out': torch.Size([10, 233, 128]), 'blocks.5.hook_resid_mid': torch.Size([10, 233, 128]), 'blocks.5.ln2.hook_scale': torch.Size([10, 233, 1]), 'blocks.5.ln2.hook_normalized': torch.Size([10, 233, 128]), 'blocks.5.mlp.hook_pre': torch.Size([10, 233, 512]), 'blocks.5.mlp.hook_post': torch.Size([10, 233, 512]), 'blocks.5.hook_mlp_out': torch.Size([10, 233, 128]), 'blocks.5.hook_resid_post': torch.Size([10, 233, 128]), 'ln_final.hook_scale': torch.Size([10, 233, 1]), 'ln_final.hook_normalized': torch.Size([10, 233, 128])}\n" + ] + } + ], + "source": [ + "print(f\"{n_mazes = }, {d_vocab = }\")\n", + "print(f\"{LOGITS.shape = }\")\n", + "cache_shapes: dict[str, tuple[int, ...]] = {k: v.shape for k, v in CACHE.items()}\n", + "print(f\"{cache_shapes = }\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we expect the logits to have shape `(n_mazes, n_tokens, n_vocab)`\n", + "\n", + "\n", + "## get and evaluate predictions\n", + "\n", + "these should have shape `(n_mazes, n_vocab)`" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LAST_TOK_LOGITS.shape = torch.Size([10, 75])\n" + ] + } + ], + "source": [ + "LAST_TOK_LOGITS: Float[torch.Tensor, \"n_mazes d_vocab\"] = LOGITS[:, -1, :].cpu()\n", + "print(f\"{LAST_TOK_LOGITS.shape = }\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_logits(\n", + " last_tok_logits=LAST_TOK_LOGITS,\n", + " target_idxs=DATASET_TARGET_IDS,\n", + " tokenizer=TOKENIZER,\n", + " n_bins=50,\n", + " density=False,\n", + " logy=True,\n", + " show=False,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(PREDICTED_TOKENS) = 10\n", + "DATASET_TARGETS[0] = ''\n", + "PREDICTED_TOKENS[0] = ''\n" + ] + } + ], + "source": [ + "PREDICTED_TOKENS: list[str] = TOKENIZER.decode(LAST_TOK_LOGITS.argmax(dim=-1).tolist())\n", + "print(f\"{len(PREDICTED_TOKENS) = }\")\n", + "print(f\"{DATASET_TARGETS[0] = }\")\n", + "print(f\"{PREDICTED_TOKENS[0] = }\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## overall accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "prediction_correct.float().mean().item() = 1.0\n" + ] + } + ], + "source": [ + "prediction_correct: Bool[torch.Tensor, \"n_mazes\"] = torch.tensor([\n", + "\tpred == target \n", + "\tfor pred, target in zip(PREDICTED_TOKENS, DATASET_TARGETS)\n", + "])\n", + "\n", + "# print(f\"{prediction_correct.shape = }\")\n", + "print(f\"{prediction_correct.float().mean().item() = }\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Results" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## logit diff\n", + "\n", + "A logit difference $d$ can be interpreted as the model being $e^{d}$ times more likely to choose the correct response. Here, the `test` column tells us what token we are comparing: `taget` (correct) token, `predicted` (argmax sample) token, and `sampled` (sampled from logits) token. Also included are `noise={p}` (predicted with gaussian noise added to logits) and `random_r{i}` (a fully random one-hot vector). We compare these to either `all` other logits, or a `random` other vector." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " test compare_to result_orig result_res diff ratio\n", + "0 target all 55.075279 30.117826 24.957453 1.828660\n", + "1 predicted all 55.075279 30.117826 24.957453 1.828660\n", + "2 sampled all 55.075279 30.117826 24.957453 1.828660\n", + "3 noise=1.00 all 55.075279 30.117826 24.957453 1.828660\n", + "4 noise=2.00 all 55.075279 30.117826 24.957453 1.828660\n", + "5 noise=3.00 all 55.075279 30.117826 24.957453 1.828660\n", + "6 noise=5.00 all 55.075279 30.117826 24.957453 1.828660\n", + "7 noise=10.00 all 37.254379 20.538260 16.716120 1.813901\n", + "8 random_r0 all -0.611049 0.647107 -1.258156 -0.944278\n", + "9 target random 27.497416 26.158972 1.338444 1.051166\n", + "10 predicted random 27.497416 26.158972 1.338444 1.051166\n", + "11 sampled random 27.497416 26.158972 1.338444 1.051166\n", + "12 noise=1.00 random 27.497416 26.158972 1.338444 1.051166\n", + "13 noise=2.00 random 27.497416 26.158972 1.338444 1.051166\n", + "14 noise=3.00 random 27.497416 26.158972 1.338444 1.051166\n", + "15 noise=5.00 random 27.497416 26.158972 1.338444 1.051166\n", + "16 noise=10.00 random 18.586960 17.870415 0.716545 1.040097\n", + "17 random_r0 random -0.345753 -0.534039 0.188286 0.647431\n", + "18 target target 0.000000 0.000000 0.000000 NaN\n", + "19 predicted target 0.000000 0.000000 0.000000 NaN\n", + "20 sampled target 0.000000 0.000000 0.000000 NaN\n", + "21 noise=1.00 target 0.000000 0.000000 0.000000 NaN\n", + "22 noise=2.00 target 0.000000 0.000000 0.000000 NaN\n", + "23 noise=3.00 target 0.000000 0.000000 0.000000 NaN\n", + "24 noise=5.00 target 0.000000 0.000000 0.000000 NaN\n", + "25 noise=10.00 target -8.910452 -8.288555 -0.621897 1.075031\n", + "26 random_r0 target -27.843166 -26.693012 -1.150154 1.043088\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "LOGIT_DIFF_DF: pd.DataFrame = logits_diff_multi(\n", + "\tmodel=MODEL,\n", + "\tcache=CACHE,\n", + "\tdataset_target_ids=DATASET_TARGET_IDS,\n", + "\tlast_tok_logits=LAST_TOK_LOGITS,\n", + "\t# noise_sigmas=np.logspace(0, 3, 100),\n", + ")\n", + "\n", + "print(LOGIT_DIFF_DF)\n", + "\n", + "# scatter separately for \"all\" vs \"random\"\n", + "fig, ax = plt.subplots()\n", + "for compare_to in [\"all\", \"random\"]:\n", + "\tdf = LOGIT_DIFF_DF[LOGIT_DIFF_DF[\"compare_to\"] == compare_to]\n", + "\tax.scatter(\n", + "\t\tdf['result_orig'], df['result_res'], \n", + "\t\tlabel=f\"comparing to {compare_to}\",\n", + "\t\tmarker='o',\n", + "\t)\n", + "ax.legend()\n", + "plt.xlabel('result_orig')\n", + "plt.ylabel('result_res')\n", + "plt.title('Scatter Plot between result_orig and result_res')\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## logit lens\n", + "\n", + "Here, we test the logit difference of the correct token at various layers" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figax, results = plot_logit_lens(\n", + " model=MODEL,\n", + " cache=CACHE,\n", + " answer_tokens=DATASET_TARGET_IDS,\n", + " show=False,\n", + ")\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## direct logit attribution" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "answer_tokens.shape = torch.Size([10])\n", + "n_layers = 6, n_heads = 4, d_model = 128\n", + "n_layers * n_heads = 24\n", + "n_layers * mlp_dim = 3072\n", + "Tried to stack head results when they weren't cached. Computing head results now\n", + "per_head_residual.shape = torch.Size([24, 10, 128])\n", + "per_head_logit_diffs.shape = torch.Size([24])\n", + "per_head_logit_diffs.shape = torch.Size([6, 4])\n", + "per_neuron_residual.shape = torch.Size([3072, 10, 128])\n", + "per_neuron_logit_diffs.shape = torch.Size([3072])\n", + "per_neuron_logit_diffs.shape = torch.Size([6, 512])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZEAAAHrCAYAAAC+QdNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABqpElEQVR4nO3deXxU1f3/8fedSTKBkIQtbBJWFQVFKyiNiKAgiKhFa7V+URatYgUFcYO2grgF3AouX9C2ggv+VFq32rqgbKJiFcWtwBcUBWVTkWyQbeb+/piZm5nkzmS2ZCbm9Xw87sPMveee+7nLuffOh+MZwzRNUwAAAAAAAAAA2HAkOwAAAAAAAAAAQOoiiQwAAAAAAAAACIkkMgAAAAAAAAAgJJLIAAAAAAAAAICQSCIDAAAAAAAAAEIiiQwAAAAAAAAACIkkMgAAAAAAAAAgJJLIAAAAAAAAAICQSCIDAAAAAAAAAEIiiQwAAJqEYcOGadiwYY26zVtvvVWGYQTNq66u1k033aT8/Hw5HA6NHTtWklRaWqrf/e536tSpkwzD0PTp0xs11lTD8ajfxIkT1apVq2SHAQAAANSLJDIAAIjK0qVLZRiGPvzww6TGsWvXLt16663auHFjROX9cfunzMxMdenSRaNGjdIDDzygkpKSiOp57LHHdM899+iCCy7Q448/ruuuu06SdNddd2np0qX6/e9/ryeffFKXXnpprLv2s8DxAAAAAH4+0pIdAAAAQCTeeOONoM+7du3S3Llz1aNHDx1//PER13PbbbepZ8+eqqqq0p49e7R69WpNnz5d999/v15++WX179/fKvunP/1JM2fODFp/5cqVOuyww/TnP/+5zvxf/vKXmjNnTvQ79zPE8QAAAAB+PkgiAwCAJiEjIyMh9YwePVoDBw60Ps+aNUsrV67U2WefrXPPPVebNm1SixYtJElpaWlKSwt+Xdq3b59at25dp959+/apb9++CYlRkjwejyorK5WZmZmwOhtTpMejvLxcGRkZcjj4H+SaurKyMmVlZSU7DAAAADQA3tYBAECD+PjjjzV69Gjl5OSoVatWGj58uNavX1+n3KeffqqhQ4eqRYsW6tq1q+644w4tWbJEhmHo66+/tsoFjom8evVqnXjiiZKkSZMmWUNULF26NKZYTz/9dN1yyy365ptv9NRTT1nzA8dE/vrrr2UYhlatWqUvvvjC2ubq1atlGIa2b9+uf/3rX9Z8f+wVFRWaM2eODj/8cLlcLuXn5+umm25SRUVFUAyGYWjq1KlatmyZ+vXrJ5fLpddee02S9N133+myyy5Tx44d5XK51K9fPz322GNB6/vjeO6553TnnXeqa9euyszM1PDhw7Vt27Y6+/z+++/rrLPOUps2bZSVlaX+/ftr4cKFQWU2b96sCy64QG3btlVmZqYGDhyol19+OeyxDHc8/MueeeYZ/elPf9Jhhx2mli1bqri4WJK0fPlyDRgwQC1atFD79u11ySWX6Lvvvguq3z+O8I4dO3T22WerVatWOuyww/Twww9Lkj777DOdfvrpysrKUvfu3fX000+HjdfP4/FowYIF6tevnzIzM9WxY0dNnjxZP/30U1C5l156SWPGjFGXLl3kcrnUu3dv3X777XK73TEdY8l7fseOHatWrVopLy9PN9xwg219tfXo0UNnn3221q1bp5NOOkmZmZnq1auXnnjiiTplDxw4oOnTpys/P18ul0uHH3645s+fL4/HY5Xxn5/Vq1cHreu/9gPbl/88fPnllzrrrLOUnZ2tcePGSfImk6+//nprW3369NG9994r0zSD6vVf8y+++KKOOeYY69r2X/cAAABIHfREBgAACffFF19oyJAhysnJ0U033aT09HQ98sgjGjZsmNasWaNBgwZJ8ibPTjvtNBmGoVmzZikrK0t//etf5XK5wtZ/9NFH67bbbtPs2bN15ZVXasiQIZKkk08+OeaYL730Uv3hD3/QG2+8oSuuuKLO8ry8PD355JO68847VVpaqsLCQiuWJ598Utddd526du2q66+/3irv8Xh07rnnat26dbryyit19NFH67PPPtOf//xn/d///Z9efPHFoG2sXLlSzz33nKZOnar27durR48e2rt3r375y19aCbe8vDy9+uqruvzyy1VcXFznB+vmzZsnh8OhG264QUVFRbr77rs1btw4vf/++1aZFStW6Oyzz1bnzp01bdo0derUSZs2bdIrr7yiadOmSfKew8GDB+uwww7TzJkzlZWVpeeee05jx47VP/7xD5133nm2xzHc8fAn1m+//XZlZGTohhtuUEVFhTIyMrR06VJNmjRJJ554ogoLC7V3714tXLhQ77zzjj7++OOg3t9ut1ujR4/WqaeeqrvvvlvLli3T1KlTlZWVpT/+8Y8aN26czj//fC1evFjjx49XQUGBevbsGfb8T5482Yrh2muv1fbt2/XQQw/p448/1jvvvKP09HRJ3rG1W7VqpRkzZqhVq1ZauXKlZs+ereLiYt1zzz1RHWP/vowaNUqDBg3SvffeqzfffFP33Xefevfurd///vdhY5akbdu26YILLtDll1+uCRMm6LHHHtPEiRM1YMAA9evXT5J08OBBDR06VN99950mT56sbt266d1339WsWbO0e/duLViwoN7t2KmurtaoUaN0yimn6N5771XLli1lmqbOPfdcrVq1SpdffrmOP/54vf7667rxxhv13Xff1RkGZt26dXr++ed19dVXKzs7Ww888IB+/etfa8eOHWrXrl1McQEAAKABmAAAAFFYsmSJKcn84IMPQpYZO3asmZGRYX755ZfWvF27dpnZ2dnmqaeeas275pprTMMwzI8//tia9+OPP5pt27Y1JZnbt2+35g8dOtQcOnSo9fmDDz4wJZlLlixJWNy5ubnmL37xC+vznDlzzNqvS0OHDjX79etXZ93u3bubY8aMCZr35JNPmg6Hw3z77beD5i9evNiUZL7zzjvWPEmmw+Ewv/jii6Cyl19+udm5c2fzhx9+CJr/29/+1szNzTUPHjxomqZprlq1ypRkHn300WZFRYVVbuHChaYk87PPPjNN0zSrq6vNnj17mt27dzd/+umnoDo9Ho/19/Dhw81jjz3WLC8vD1p+8sknm0cccUSd/Y/kePhj7NWrlxW3aZpmZWWl2aFDB/OYY44xDx06ZM1/5ZVXTEnm7NmzrXkTJkwwJZl33XWXNe+nn34yW7RoYRqGYT7zzDPW/M2bN5uSzDlz5oSN9e233zYlmcuWLQua/9prr9WZHxi33+TJk82WLVtaxyrSY+zfl9tuuy2ozC9+8QtzwIABYWM2Te8xlmSuXbvWmrdv3z7T5XKZ119/vTXv9ttvN7Oyssz/+7//C1p/5syZptPpNHfs2GGaZs35WbVqVVC57du312lr/thnzpwZVPbFF180JZl33HFH0PwLLrjANAzD3LZtmzVPkpmRkRE075NPPjElmQ8++GC9+w8AAIDGw3AWAAAgodxut9544w2NHTtWvXr1suZ37txZ//M//6N169ZZwxe89tprKigoCPphvLZt21r/W3xja9WqlUpKShJW3/Lly3X00UfrqKOO0g8//GBNp59+uiRp1apVQeWHDh0aNI6waZr6xz/+oXPOOUemaQbVMWrUKBUVFemjjz4KqmPSpElB40f7e2l/9dVXkrzDjGzfvl3Tp0+vM7azf+iO/fv3a+XKlbrwwgtVUlJibfPHH3/UqFGjtHXr1jrDTERjwoQJ1rjTkvThhx9q3759uvrqq4PGgB4zZoyOOuoo/etf/6pTx+9+9zvr79atW6tPnz7KysrShRdeaM3v06ePWrdube17KMuXL1dubq7OOOOMoGM8YMAAtWrVKug8BcbtPzZDhgzRwYMHtXnzZkmRHeNAV111VdDnIUOG1BuzX9++fa1zLHl7fPfp0ydo/eXLl2vIkCFq06ZN0P6NGDFCbrdba9eujWhbdmr3lv73v/8tp9Opa6+9Nmj+9ddfL9M09eqrrwbNHzFihHr37m197t+/v3JyciLefwAAADQOhrMAAAAJ9f333+vgwYPq06dPnWVHH320PB6Pdu7cqX79+umbb75RQUFBnXKHH354Y4RaR2lpqTp06JCw+rZu3apNmzYpLy/Pdvm+ffuCPtcecuH777/XgQMH9Oijj+rRRx+NqI5u3boFfW7Tpo0kWWP7fvnll5KkY445JmTc27Ztk2mauuWWW3TLLbeE3O5hhx0Wso5wau/nN998I0m218xRRx2ldevWBc3LzMysc0xzc3PVtWvXOkna3NzcOuMa17Z161YVFRWFPPeBx/iLL77Qn/70J61cudL6xxC/oqIiSZEd43D70qZNm3pj9qt9vu3W37p1qz799NOIr8NIpaWlqWvXrkHzvvnmG3Xp0kXZ2dlB848++mhrebTxAwAAIPlIIgMAAEj69ttvVVRUlNAEtsfj0bHHHqv777/fdnl+fn7Q58Berv71JemSSy7RhAkTbOvo379/0Gen02lbzqz1o2bh+Ld7ww03aNSoUbZl4jlOtfczWqH2MdZ993g86tChg5YtW2a73J98PXDggIYOHaqcnBzddttt6t27tzIzM/XRRx/p5ptvDvqRukiFijne9QP32ePx6IwzztBNN91kW/bII4+UZN9LWlLIH/lzuVxyOOL7HxsTcb0CAACg4ZFEBgAACZWXl6eWLVtqy5YtdZZt3rxZDofDSp52795d27Ztq1PObl5toRJesXryySclKWTSNBa9e/fWJ598ouHDh8cUb15enrKzs+V2uzVixIiExSRJn3/+ecg6/cOQpKenJ2y74XTv3l2StGXLFmuoD78tW7ZYyxtK79699eabb2rw4MFhE9yrV6/Wjz/+qOeff16nnnqqNX/79u116pPCH+PG1Lt3b5WWltYbi7/X+oEDB4Lm1+49HE737t315ptvqqSkJKg3sn+oj4Y+lwAAAGgYjIkMAAASyul0auTIkXrppZf09ddfW/P37t2rp59+WqeccopycnIkeRO27733njZu3GiV279/f8geoYGysrIk1U14xWLlypW6/fbb1bNnz4SOx3zhhRfqu+++01/+8pc6yw4dOqSysrKw6zudTv3617/WP/7xD33++ed1ln///fdRx3TCCSeoZ8+eWrBgQZ1j5+/92aFDBw0bNkyPPPKIdu/enZDthjNw4EB16NBBixcvVkVFhTX/1Vdf1aZNmzRmzJiEbq+2Cy+8UG63W7fffnudZdXV1dZx8veaDewlW1lZqf/93/8NWieSY9yYLrzwQr333nt6/fXX6yw7cOCAqqurJXkTvE6ns84YybX3L5yzzjpLbrdbDz30UND8P//5zzIMQ6NHj45hDwAAAJBs9EQGAAAxeeyxx/Taa6/VmT9t2jTdcccdWrFihU455RRdffXVSktL0yOPPKKKigrdfffdVtmbbrpJTz31lM444wxdc801ysrK0l//+ld169ZN+/fvD9t7t3fv3mrdurUWL16s7OxsZWVladCgQXXG263t1Vdf1ebNm1VdXa29e/dq5cqVWrFihbp3766XX3456Ifd4nXppZfqueee01VXXaVVq1Zp8ODBcrvd2rx5s5577jm9/vrrGjhwYNg65s2bp1WrVmnQoEG64oor1LdvX+3fv18fffSR3nzzTe3fvz+qmBwOhxYtWqRzzjlHxx9/vCZNmqTOnTtr8+bN+uKLL6xE48MPP6xTTjlFxx57rK644gr16tVLe/fu1Xvvvadvv/1Wn3zySczHpbb09HTNnz9fkyZN0tChQ3XxxRdr7969WrhwoXr06KHrrrsuYduyM3ToUE2ePFmFhYXauHGjRo4cqfT0dG3dulXLly/XwoULdcEFF+jkk09WmzZtNGHCBF177bUyDENPPvlkncRwpMe4sdx44416+eWXdfbZZ2vixIkaMGCAysrK9Nlnn+nvf/+7vv76a7Vv3165ubn6zW9+owcffFCGYah379565ZVXohoz+ZxzztFpp52mP/7xj/r666913HHH6Y033tBLL72k6dOnB/2IHgAAAJoOksgAACAmixYtsp0/ceJE9evXT2+//bZmzZqlwsJCeTweDRo0SE899ZQGDRpklc3Pz9eqVat07bXX6q677lJeXp6mTJmirKwsXXvttWETuunp6Xr88cc1a9YsXXXVVaqurtaSJUvqTSLPnj1bkpSRkaG2bdvq2GOP1YIFCzRp0qQ6PwYWL4fDoRdffFF//vOf9cQTT+iFF15Qy5Yt1atXL02bNs0aizacjh076j//+Y9uu+02Pf/88/rf//1ftWvXTv369dP8+fNjimvUqFFatWqV5s6dq/vuu08ej0e9e/fWFVdcYZXp27evPvzwQ82dO1dLly7Vjz/+qA4dOugXv/iFdQwTaeLEiWrZsqXmzZunm2++WVlZWTrvvPM0f/58tW7dOuHbq23x4sUaMGCAHnnkEf3hD39QWlqaevTooUsuuUSDBw+WJLVr106vvPKKrr/+ev3pT39SmzZtdMkll2j48OF1hkGJ5Bg3lpYtW2rNmjW66667tHz5cj3xxBPKycnRkUceqblz5yo3N9cq++CDD6qqqkqLFy+Wy+XShRdeqHvuuSeiHwmUvNf8yy+/rNmzZ+vZZ5/VkiVL1KNHD91zzz26/vrrG2oXAQAA0MAMk1+tAAAAKWb69Ol65JFHVFpaGvcPjwEAAAAA4sOYyAAAIKkOHToU9PnHH3/Uk08+qVNOOYUEMgAAAACkAIazAAAASVVQUKBhw4bp6KOP1t69e/W3v/1NxcXFuuWWW5IdGgAAAABAJJEBAECSnXXWWfr73/+uRx99VIZh6IQTTtDf/vY3nXrqqckODQAAAAAgxkQGAAAAAAAAAITBmMgAAAAAAAAAgJBIIgMAAAAAAAAAQiKJDAAA0ABuvfVWGYahH374ISH1DRs2TMOGDbM+f/311zIMQ0uXLk1I/c1Bjx49NHHiROvz6tWrZRiGVq9enbSYAAAAgKaAJDIAAAAAAAAAIKS0ZAcAAAAAJMOpp56qQ4cOKSMjI9mhAAAAACmNJDIAAACaJYfDoczMzGSHAQAAAKQ8hrMAAABoQAcOHNDEiRPVunVr5ebmatKkSTp48KC1fMmSJTr99NPVoUMHuVwu9e3bV4sWLYp6Oy+//LIMw9Cnn35qzfvHP/4hwzB0/vnnB5U9+uijddFFF0UVw4QJE9S+fXtVVVXV2fbIkSPVp0+fsPEtXbpUhmFo3bp1uvbaa5WXl6fWrVtr8uTJqqys1IEDBzR+/Hi1adNGbdq00U033STTNIPq8Hg8WrBggfr166fMzEx17NhRkydP1k8//RRUzjRN3XHHHeratatatmyp0047TV988UWdmOzGRK49brJf7TGp/es+99xzmjt3rg477DBlZ2frggsuUFFRkSoqKjR9+nR16NBBrVq10qRJk1RRURH2GAEAAACpip7IAAAADejCCy9Uz549VVhYqI8++kh//etf1aFDB82fP1+StGjRIvXr10/nnnuu0tLS9M9//lNXX321PB6PpkyZEvF2TjnlFBmGobVr16p///6SpLffflsOh0Pr1q2zyn3//ffavHmzpk6das2LJIZLL71UTzzxhF5//XWdffbZ1rp79uzRypUrNWfOnIjivOaaa9SpUyfNnTtX69ev16OPPqrWrVvr3XffVbdu3XTXXXfp3//+t+655x4dc8wxGj9+vLXu5MmTtXTpUk2aNEnXXnuttm/froceekgff/yx3nnnHaWnp0uSZs+erTvuuENnnXWWzjrrLH300UcaOXKkKisrIz6ekSosLFSLFi00c+ZMbdu2TQ8++KDS09PlcDj0008/6dZbb9X69eu1dOlS9ezZU7Nnz054DAAAAECDMwEAAJBwc+bMMSWZl112WdD88847z2zXrp31+eDBg3XWHTVqlNmrV6+geUOHDjWHDh1qfd6+fbspyVyyZIk1r1+/fuaFF15ofT7hhBPM3/zmN6Ykc9OmTaZpmubzzz9vSjI/+eSTqGJwu91m165dzYsuuiio3P33328ahmF+9dVXdofBsmTJElOSOWrUKNPj8VjzCwoKTMMwzKuuusqaV11dbXbt2jVof99++21Tkrls2bKgel977bWg+fv27TMzMjLMMWPGBG3nD3/4gynJnDBhgjVv1apVpiRz1apV1rzu3bsHlfGrffz96x5zzDFmZWWlNf/iiy82DcMwR48eHbR+QUGB2b1793CHCAAAAEhZDGcBAADQgK666qqgz0OGDNGPP/6o4uJiSVKLFi2sZUVFRfrhhx80dOhQffXVVyoqKopqW0OGDNHbb78tSSopKdEnn3yiK6+8Uu3bt7fmv/3222rdurWOOeYYa71IYnA4HBo3bpxefvlllZSUWOWXLVumk08+WT179owoxssvv1yGYVifBw0aJNM0dfnll1vznE6nBg4cqK+++sqat3z5cuXm5uqMM87QDz/8YE0DBgxQq1attGrVKknSm2++qcrKSl1zzTVB25k+fXpE8UVr/PjxVg/owP257LLLgsoNGjRIO3fuVHV1dYPEAQAAADQkksgAAAANqFu3bkGf27RpI0nWOL7vvPOORowYoaysLLVu3Vp5eXn6wx/+IEkxJZF3796tbdu26d1335VhGCooKAhKLr/99tsaPHiwHI6a18BIYxg/frwOHTqkF154QZK0ZcsWbdiwQZdeeqlVZs+ePUHToUOHwh6P3NxcSVJ+fn6d+YFjHW/dulVFRUXq0KGD8vLygqbS0lLt27dPkvTNN99Iko444oig+vLy8qxjn0jR7I/H44n6nAIAAACpgDGRAQAAGpDT6bSdb5qmvvzySw0fPlxHHXWU7r//fuXn5ysjI0P//ve/9ec//1kejyeqbZ1yyimSpLVr1+qrr77SCSecoKysLA0ZMkQPPPCASktL9fHHH+vOO++01okmhr59+2rAgAF66qmnNH78eD311FPKyMjQhRdeaJXp3LlzUExLliwJ+qG6UMfDbr4Z8MN6Ho9HHTp00LJly2zXz8vLC3NkIhfYezmQ2+22jTGa/ZFU58cCAQAAgKaAJDIAAECS/POf/1RFRYVefvnloB6t/qEZotWtWzd169ZNb7/9tr766isNGTJEknTqqadqxowZWr58udxut0499dSYYxg/frxmzJih3bt36+mnn9aYMWOCeviuWLEiqHy/fv1i2pfaevfurTfffFODBw8OGn6jtu7du0vy9lzu1auXNf/7778P6tkcSps2bXTgwIE687/55pug+gAAAIDmhOEsAAAAksTfWzWwd2pRUZGWLFkSc51DhgzRypUr9Z///MdKIh9//PHKzs7WvHnz1KJFCw0YMCDmGC6++GIZhqFp06bpq6++0iWXXBK0fMSIEUFT7Z7Jsbrwwgvldrt1++2311lWXV1tJX5HjBih9PR0Pfjgg0H7tGDBgoi207t3b61fv16VlZXWvFdeeUU7d+6MK34AAACgKaMnMgAAQJKMHDlSGRkZOuecczR58mSVlpbqL3/5izp06KDdu3fHVOeQIUO0bNkyGYZhDW/hdDp18skn6/XXX9ewYcOUkZERcwx5eXk688wztXz5crVu3VpjxoyJbeejNHToUE2ePFmFhYXauHGjRo4cqfT0dG3dulXLly/XwoULdcEFFygvL0833HCDCgsLdfbZZ+uss87Sxx9/rFdffVXt27evdzu/+93v9Pe//11nnnmmLrzwQn355Zd66qmn1Lt370bYSwAAACA10RMZAAAgSfr06aO///3vMgxDN9xwgxYvXqwrr7xS06ZNi7lOf+/jo446Su3atasz3//feGIYP368JG/vYJfLFXOs0Vq8eLEeffRR7du3T3/4wx80a9YsrVy5UpdccokGDx5slbvjjjs0d+5cffzxx7rxxhv15Zdf6o033lBWVla92xg1apTuu+8+/d///Z+mT5+u9957T6+88oq6du3akLsGAAAApDTD5Nc9AAAAEIWXXnpJY8eO1dq1a+skpQEAAAD8/JBEBgAAQFTOPvtsbdq0Sdu2bZNhGMkOBwAAAEADY0xkAAAAROSZZ57Rp59+qn/9619auHAhCWQAAACgmaAnMgAAACJiGIZatWqliy66SIsXL1ZaGv0RAAAAgOaAN38AAABEhL4HAAAAQPPkSHYAAAAAAAAAAIDURRIZAAAAAAAAABBSkx7OwuPxaNeuXcrOzuaHXQAAAAAAAIAomaapkpISdenSRQ4H/U2jUV5ersrKyoTUlZGRoczMzITU1RCadBJ5165dys/PT3YYAAAAAAAAQJO2c+dOde3aNdlhNBnl5eVqkd1Wqj6UkPo6deqk7du3p2wiuUknkbOzsyVJ27ZuVSvf35IUrk+y3c/BxNOH2V9ftNu023YkdUVar902TJt5Mj2+GTX/0hRrHIk4joHCxR1um/WeY5t9DldHuG1EEmN988JJxPVaXxy1l7kDFjqN2OqINKZIj1Uk9Uf7U0+Rtr1oY4u0vF0cdttMZLlK38l1OeuWiuccRHo8wi2LtI3E1fajqCPa6yNwmb8N2RzmOusFrtsYP1dWO6T6jlntfYn2uWO3rUjbWTixxBHuvhOufDiegEIOo24dobYdap6d2nHYlbe7b9e3/fq2E0qk12skz+tEiPY+Uu+15ntHMAPeEaJ994jkeRrttRYo2mss3HrR1hFUn6faW8YR2deJaN+FEn1N1i7vrqf9RvLsjueZH+nxjui+7X+3VfC1G+827Zb573uOgEoieSbH894Vbll98/zxhnuORdtuGuoZbtsefO1MAe0sEe870Yr0OdYQ3wvj+W4c6zPLbl5jXK+RLIu2XDzPG7v2Xt82QknEe1c85yDSeqN9Z4qkXKJzPg3VpktKSnT4EUdYeTZEprKyUqo+pPRjLpac6fFV5q7Sns//nyorK0kiNwT/EBbZ2dnKzsmpmR9mnUQ3wni/mCX6hhJuG7Y3O5LI9cYTyUtZLC8JiXjYRiLalxWSyKHrTURiNFwcdttMZDmSyJHXEe31EbiMJHJ85y7We2N9cYS774QrHw5J5MjLJeILj51o7yP1XmskkUkiR1BfIp75kR7viO7bJJFDziOJ3HAJp0QkyMJtyy8RybZYkrGx3vvDLYvne4WdWO87kSKJbC/a51iicz4N1aat+hkqNjbOdBnOjLiqaIzvg/Fq0klkAAAAAAAAAEgWw+GU4XDGV4kZ5/qNgCQyAAAAAAAAAMSguSSR+clFAAAAAAAAAEBI9EQGAAAAAAAAgBgYRgJ6IntSvycySWQAAAAAAAAAiIHhdMhwxjucReoPFpH6EQIAAAAAAAAAkoaeyAAAAAAAAAAQA0cCfljPjHc4jEZAEhkAAAAAAAAAYmAkIImsJpBEZjgLAAAAAAAAAEBI9EQGAAAAAAAAgBg0l57IJJEBAAAAAAAAIAaGwyHDEedgD/Gu3whSP0IAAAAAAAAAQNLQExkAAAAAAAAAYsBwFgAAAAAAAACAkLzDWcSbRE79wSJSP0IAAAAAAAAAQNLQExkAAAAAAAAAYmAYCRjOwmA4CwAAAAAAAAD4eXI6ZTjjSwKbntRPIjOcBQAAAAAAAAAgJHoiAwAAAAAAAEAMDEf8w1nEPRxGIyCJDAAAAAAAAAAxaC5JZIazAAAAAAAAAACERE9kAAAAAAAAAIiBw+GUI96exE2gJzJJZAAAAAAAAACIgeFwJGA4i9QfLCL1IwQAAAAAAAAAJA09kQEAAAAAAAAgBvywXiN6+OGH1aNHD2VmZmrQoEH6z3/+k+yQAAAAAAAAACAsfxI53inVJT2J/Oyzz2rGjBmaM2eOPvroIx133HEaNWqU9u3bl+zQAAAAAAAAAKDZS3oS+f7779cVV1yhSZMmqW/fvlq8eLFatmypxx57LNmhAQAAAAAAAEBIzaUnclLHRK6srNSGDRs0a9Ysa57D4dCIESP03nvv1SlfUVGhiooK63NxcXGjxAkAAAAAAAAAtRlGAsZENlI/iZzUnsg//PCD3G63OnbsGDS/Y8eO2rNnT53yhYWFys3Ntab8/PzGChUAAAAAAAAAmqWkD2cRjVmzZqmoqMiadu7cmeyQAAAAAAAAADRThtOZkCnVJXU4i/bt28vpdGrv3r1B8/fu3atOnTrVKe9yueRyuRorPAAAAAAAAAAIyXA44h/OwpH6/XyTGmFGRoYGDBigt956y5rn8Xj01ltvqaCgIImRAQAAAAAAAACkJPdElqQZM2ZowoQJGjhwoE466SQtWLBAZWVlmjRpUrJDAwAAAAAAAICQDEcCflgvzvUbQ9L7Sl900UW69957NXv2bB1//PHauHGjXnvttTo/tgcAAAAAAAAAqcSfRI53isaiRYvUv39/5eTkKCcnRwUFBXr11VcbaA+9kt4TWZKmTp2qqVOnJjsMAAAAAAAAAEhpXbt21bx583TEEUfINE09/vjj+tWvfqWPP/5Y/fr1a5BtpkQSGQAAAAAAAACaGofDkMNhxFlJdOufc845QZ/vvPNOLVq0SOvXryeJDAAAAAAAAACpxHAYMuJMIsezvtvt1vLly1VWVqaCgoK44giHJDIAAAAAAAAAJFlxcXHQZ5fLJZfLZVv2s88+U0FBgcrLy9WqVSu98MIL6tu3b4PFlvQf1gMAAAAAAACApsgwjIRMkpSfn6/c3FxrKiwsDLndPn36aOPGjXr//ff1+9//XhMmTNB///vfBttPeiIDAAAAAAAAQAyMBIyJbPrW37lzp3Jycqz5oXohS1JGRoYOP/xwSdKAAQP0wQcfaOHChXrkkUfiiiUUksgAAAAAAAAAkGQ5OTlBSeRoeDweVVRUJDiiGiSRAQAAAAAAACAGhpGAH9Yzolt/1qxZGj16tLp166aSkhI9/fTTWr16tV5//fW44giHJDIAAAAAAAAAxMBwJCCJHOX6+/bt0/jx47V7927l5uaqf//+ev3113XGGWfEFUc4JJEBAAAAAAAAoIn429/+1ujbJIkMAAAAAAAAADFwGIYcUQ5HUZsZ5/qNgSQyAAAAAAAAAMQgGcNZJIMj2QEAAAAAAAAAAFIXPZEBAAAAAAAAIAbNpScySWQAAAAAAAAAiIHDYcgRZxLYbAJJZIazAAAAAAAAAACERE9kAAAAAAAAAIiB4fBO8daR6kgiAwAAAAAAAEAMDMOQYcQ5JnKc6zeGJpDnBgAAAAAAAAAkCz2RAQAAAAAAACAGDocS8MN6CQqmAZFEBgAAAAAAAIAYGA5DRpxJ5HjXbwxNIM8NAAAAAAAAAEgWeiIDAAAAAAAAQAwMIwE9kZvAD+uRRAYAAAAAAACAGDgMQ444k8BmE0giM5wFAAAAAAAAACAkeiIDAAAAAAAAQCwS8MN6agI/rPezSCKbkuwOtRnwt93ySE5PPHWYEZSJR7T1Bpa3YjNCd0avb9/DLbPbd7NWGSPE35HUH+02g7Zda59juTaiPe+xXgvhjl995yfcNsPF4YwwSH+x2nGFiiPcuvUdq3DbiPbYRhJPpOtGGmMk10s89QaWCVefy+bkRnr8wh2jWO8BduUjXRZpHHblIz3fsdZl9+yP5DjXdw7C1RHt9Rfp+Ql3P4g2DrsyRq3/RhNb7TrqOy+RHPv64q9dR6TvefE8x2qXj/Q8hdv3SN9tEn38olX7eCT6vaT2Mm8BR731RxpH4PUR7bMqkmMa7TtqtNd3fXGYjrpfI8KWDzMv1vNZXx3htlnf+060z+5oRXpdR3R/t3mfj+daC/e+E+17YrQifX+O9B3SH28ini2RxpiId1OrDpt2Fm1d0ZaL9l4Qrlx9xzuSbUX7zme3PJZ3rEieQQ31faX2duzqirRcLNewn/85lohrPtJrIZ4cSiTXf6K/58ezrXjriPZ7rRHibySGkYAkctxJ6EbAcBYAAAAAAAAAgJB+Fj2RAQAAAAAAAKCxORyGHHH2JI53/cZAEhkAAAAAAAAAYmAYhgwjzuEs4ly/MTCcBQAAAAAAAAAgJHoiAwAAAAAAAEAMDIft79xGXUeqI4kMAAAAAAAAADFoLmMiN4E8NwAAAAAAAAAgWeiJDAAAAAAAAAAxMByGjDh7Ese7fmMgiQwAAAAAAAAAMTAMQ4YRZxI5zvUbA8NZAAAAAAAAAABCoicyAAAAAAAAAMSgufywHklkAAAAAAAAAIiBYSRgTGSGswAAAAAAAAAANGX0RAYAAAAAAACAGDgdhpxx9kQ2Gc4CAAAAAAAAAH6eHAlIInuaQBKZ4SwAAAAAAAAAACHRExkAAAAAAAAAYpCI4SyaQk9kksgAAAAAAAAAEIPmkkRmOAsAAAAAAAAAQEj0RAYAAAAAAACAGDSXnsgkkQEAAAAAAAAgBmkOKS3OJLDZBMaKaAIhAgAAAAAAAACShZ7IAAAAAAAAABCD5jKcBT2RAQAAAAAAACAGDl8SOZ7JEWUSubCwUCeeeKKys7PVoUMHjR07Vlu2bGmgPfQiiQwAAAAAAAAATcSaNWs0ZcoUrV+/XitWrFBVVZVGjhypsrKyBtsmw1kAAAAAAAAAQAychkNOR3z9dJ1GdOu/9tprQZ+XLl2qDh06aMOGDTr11FPjiiUUksgAAAAAAAAAEINEjInsX7+4uDhovsvlksvlqnf9oqIiSVLbtm3jiiOcpA5nsXbtWp1zzjnq0qWLDMPQiy++mMxwAAAAAAAAACAp8vPzlZuba02FhYX1ruPxeDR9+nQNHjxYxxxzTIPFltSeyGVlZTruuON02WWX6fzzz09mKAAAAAAAAAAQlUT2RN65c6dycnKs+ZH0Qp4yZYo+//xzrVu3Lq4Y6pPUJPLo0aM1evToZIYAAAAAAAAAADFJZBI5JycnKIlcn6lTp+qVV17R2rVr1bVr17hiqE+TGhO5oqJCFRUV1ufa44QAAAAAAAAAwM+ZaZq65ppr9MILL2j16tXq2bNng28zqWMiR6uwsDBoXJD8/PxkhwQAAAAAAACgmXIaRkKmaEyZMkVPPfWUnn76aWVnZ2vPnj3as2ePDh061EB72cSSyLNmzVJRUZE17dy5M9khAQAAAAAAAGimHL7hLOKZHFEOh7Fo0SIVFRVp2LBh6ty5szU9++yzDbSXTWw4C5fLFdGA0gAAAAAAAADwc2SaZqNvs0klkQEAAAAAAAAgVSTyh/VSWVKTyKWlpdq2bZv1efv27dq4caPatm2rbt26JTEyAAAAAAAAAAgvzWEoLc4ksJskcngffvihTjvtNOvzjBkzJEkTJkzQ0qVLkxQVAAAAAAAAAMAvqUnkYcOGJWUMDwAAAAAAAACIF8NZAAAAAAAAAABCai5JZEeyAwAAAAAAAAAApC56IgMAAAAAAABADJxGAnoiG6nfE5kkMgAAAAAAAADEwJGA4SwcDGcBAAAAAAAAAGjK6IkMAAAAAAAAADHgh/UAAAAAAAAAAM0ePZEBAAAAAAAAIAbNpScySWQAAAAAAAAAiIHTEX8S2NkExopoAiECAAAAAAAAAJKFnsgAAAAAAAAAEAOGswAAAAAAAAAAhNRcksgMZwEAAAAAAAAACImeyAAAAAAAAAAQA0cCeiI7mkBPZJLIAAAAAAAAABADp2HIacQ5nEWc6zcGhrMAAAAAAAAAAIRET2QAAAAAAAAAiIHDMOSIsydxvOs3BpLIAAAAAAAAABADpyRnnDlgZ0IiaVgMZwEAAAAAAAAACImeyAAAAAAAAAAQA4fDkMMR53AWca7fGEgiAwAAAAAAAEAMnIYhZ5xjGse7fmNgOAsAAAAAAAAAQEj0RAYAAAAAAACAGDgMQ444exLHu35jIIkMAAAAAAAAADFwGJIzzhxwExgSmeEsAAAAAAAAAACh/Wx6IpsBf9sl7/3LDdMTUDB0Dt0MuSSx7OKOdl4s/1hRe51I9zfaOMKdl/rOWazbtBNYLtpzG668Ueu/9ZULt8/VAQvTjPq3bSeW8xiO3f754/T/K5vdsbU7HpGe43Bx2JW3O7aR1FFfmXiusTo81TX1OtLqLR9t26iv7fm5fTMD/4XT9tr03Sc9Af/OWPt829Ufz30z0n2IViRxRnvvSsT9JNL9jbbd2MVmty+Rtptwxyrc9iPdl2jvRZHcj6Opt3b5+uqoXS7Saydc/YHzor1P2YlkW/Hct2N9zkR7rkNtP9r6wq0Xa2cPu3fJaI9ffeWjvVeEWxbuvCdCtO9A9R533zPT8D0vE/1OHun9LxyPzfM0EeWjvS9Eci3UV1ck9+tY3rFqbz8R3zXqKx9OpO8v4Z750W4z0mdWJN8T7N7T7L7LNlQntkTck6J994j2nTPW75ORrhvpO5Ad//entChPULTHqj7RfkezltWTQ4nk/S8R59Fu3Xi+v9nFEcn9L9p3iWjvGbFca7Geg4Z6N2iOHA5Djji7Ese7fmP42SSRAQAAAAAAAKAxNZcxkRnOAgAAAAAAAAAQEj2RAQAAAAAAACAGzgT8sF686zcGksgAAAAAAAAAEAOGswAAAAAAAAAANHv0RAYAAAAAAACAGDgdhpyO+HoSx7t+YyCJDAAAAAAAAAAxYDgLAAAAAAAAAECzR09kAAAAAAAAAIiB0/BO8daR6uiJDAAAAAAAAAAxMHzDWcQzGVEOZ7F27Vqdc8456tKliwzD0IsvvtgwOxeAJDIAAAAAAAAANBFlZWU67rjj9PDDDzfaNhnOAgAAAAAAAABi4HQYcjriG48i2vVHjx6t0aNHx7XNaJFEBgAAAAAAAIAYOCTFmUO2hoooLi4Omu9yueRyueKrPEEYzgIAAAAAAAAAkiw/P1+5ubnWVFhYmOyQLPREBgAAAAAAAIAYOA1Dzih/GM+uDknauXOncnJyrPmp0gtZIokMAAAAAAAAADFxGIYccSaR/evn5OQEJZFTCcNZAAAAAAAAAABCoicyAAAAAAAAAMTA6fBO8dYRjdLSUm3bts36vH37dm3cuFFt27ZVt27d4gsmBJLIAAAAAAAAABADh6EEDGcRXfkPP/xQp512mvV5xowZkqQJEyZo6dKlccUSCklkAAAAAAAAAGgihg0bJtM0G3WbJJEBAAAAAAAAIAYOw5AzQT+sl8pIIgMAAAAAAABADByGkYDhLFI/iRznsM8AAAAAAAAAgJ8zeiIDAAAAAAAAQAycDu8Ubx2pjiQyAAAAAAAAAMSA4SwAAAAAAAAAAM0ePZEBAAAAAAAAIAaG4Z3irSPVJbUncmFhoU488URlZ2erQ4cOGjt2rLZs2ZLMkAAAAAAAAAAgIg4ZCZlSXVKTyGvWrNGUKVO0fv16rVixQlVVVRo5cqTKysqSGRYAAAAAAAAAwCepw1m89tprQZ+XLl2qDh06aMOGDTr11FOTFBUAAAAAAAAA1K+5DGeRUmMiFxUVSZLatm1ru7yiokIVFRXW5+Li4kaJCwAAAAAAAABqcxjeKd46Ul1Sh7MI5PF4NH36dA0ePFjHHHOMbZnCwkLl5uZaU35+fiNHCQAAAAAAAADNS8okkadMmaLPP/9czzzzTMgys2bNUlFRkTXt3LmzESMEAAAAAAAAgBr+4SzinVJdSgxnMXXqVL3yyitau3atunbtGrKcy+WSy+VqxMgAAAAAAAAAwJ5DhhyKLwsc7/qNIalJZNM0dc011+iFF17Q6tWr1bNnz2SGAwAAAAAAAACoJalJ5ClTpujpp5/WSy+9pOzsbO3Zs0eSlJubqxYtWiQzNAAAAAAAAAAILxHDUaR+R+Tkjom8aNEiFRUVadiwYercubM1Pfvss8kMCwAAAAAAAADq5TASM6W6pA9nAQAAAAAAAABIXSnxw3oAAAAAAAAA0NQYin80iibQEZkkMgAAAAAAAADEwmEYcsQ5KHK86zeGpI6JDAAAAAAAAABIbfREBgAAAAAAAIAYGJLi7Uic+v2QSSIDAAAAAAAAQEwcin+oh6YwVERTiBEAAAAAAAAAkCT0RAYAAAAAAACAGBiGISPO8SziXb8xkEQGAAAAAAAAgBg4DO8Ubx2pjuEsAAAAAAAAAAAhRZ1ErqqqUu/evbVp06aGiAcAAAAAAAAAmgTDSMyU6qIeziI9PV3l5eUNEQsAAAAAAAAANBkOxT/UQ1MYKiKmGKdMmaL58+eruro60fEAAAAAAAAAAFJITD+s98EHH+itt97SG2+8oWOPPVZZWVlBy59//vmEBAcAAAAAAAAAqcowDBlxjkcR7/qNIaYkcuvWrfXrX/860bEAAAAAAAAAQJPhMLxTvHWkupiSyEuWLEl0HAAAAAAAAACAFBTzuM3V1dV688039cgjj6ikpESStGvXLpWWliYsOAAAAAAAAABIZUacU1MQU0/kb775RmeeeaZ27NihiooKnXHGGcrOztb8+fNVUVGhxYsXJzpOAAAAAAAAAEgpzWU4i5h6Ik+bNk0DBw7UTz/9pBYtWljzzzvvPL311lsJCw4AAAAAAAAAkFwx9UR+++239e677yojIyNofo8ePfTdd98lJDAAAAAAAAAASGWGYcgw4utKHO/6jSGmJLLH45Hb7a4z/9tvv1V2dnbcQQEAAAAAAABAqmM4izBGjhypBQsWWJ8Nw1BpaanmzJmjs846K1GxAQAAAAAAAACSLKYk8n333ad33nlHffv2VXl5uf7nf/7HGspi/vz5iY4RAAAAAAAAAFKOkaApFg8//LB69OihzMxMDRo0SP/5z3/i2ZWwYhrOomvXrvrkk0/0zDPP6NNPP1Vpaakuv/xyjRs3LuiH9gAAAAAAAADg58phGHLEOaZxLOs/++yzmjFjhhYvXqxBgwZpwYIFGjVqlLZs2aIOHTrEFY+dmJLIZWVlysrK0iWXXJLoeAAAAAAAAAAAYdx///264oorNGnSJEnS4sWL9a9//UuPPfaYZs6cmfDtxTScRceOHXXZZZdp3bp1iY4HAAAAAAAAAJoEw0jMJEnFxcVBU0VFhe02KysrtWHDBo0YMcKa53A4NGLECL333nsNsp8xJZGfeuop7d+/X6effrqOPPJIzZs3T7t27Up0bFGxG0PEbnwR03DUTJLMCOqz1rWZ/PyfKz01Uzj+8nb125ULNy9cXKHqqK2+cVns4nWb3ilSteOo99iaHu9kU4fdeuHmhdvXcDEqRLlIhDofobaVZtRMdsc7kuukvuu2tvrajd16TsM7Rbqf4Y6fYXpk1DrHHtM71Vdv7e1HOp6Q7XHxXWuRnrNI7gVBdTjSrCmS+1S07LZpV5//3NV33t1yyC2HVd5pE1R994dwbc/u3mF3TMPVF+35DhV7qDYS7v4Uaf3WPcz0hI0xkuvcbluBMTqqy+WoLq/3/hfJMY607UVy3Ou7niM5LtGen1D7HolIr7/6nru1y0X6zIrk3mJXf6Cw12SY/QwXv135Kk/NZHfMam870msi3L7Hc58Mt62o78OGw5oibb+hth3q+RHuOWwXr/++Gm4fIm1L4dTXHsKVs4vL9nngSPNOiu66iue9wY5/mfNQkZyHioLvuYZ3stu+Xb2R/mJ7JPtid5343508MVyM0bapWNt0LOcs5jZqU0c44dpBfe8nduXs6o01ftsYfd9lq01ZU6z3omjVd84i2c/A5Xbfm2uva3d913c9RXtdRbIv9b0jhLt2/N/x6ttOOIan2jvZbDtcvXbsjpFdHsMqF5BDifZ4RxtbOPW9R0XzPAusL1ybToSIz7FC71M89Ua6LcTHMM2ETJKUn5+v3NxcayosLLTd5g8//CC3262OHTsGze/YsaP27NnTIPsZUxJ57NixevHFF/Xdd9/pqquu0tNPP63u3bvr7LPP1vPPP6/q6upExwkAAAAAAAAAP1s7d+5UUVGRNc2aNSvZIVliSiL75eXlacaMGfr00091//33680339QFF1ygLl26aPbs2Tp48GCi4gQAAAAAAACA1BLwf6HGNUnKyckJmlwul+0m27dvL6fTqb179wbN37t3rzp16tQguxlXEnnv3r26++671bdvX82cOVMXXHCB3nrrLd133316/vnnNXbs2ASFCQAAAAAAAACpxT9UZ7xTNDIyMjRgwAC99dZb1jyPx6O33npLBQUFid5FSVJaLCs9//zzWrJkiV5//XX17dtXV199tS655BK1bt3aKnPyySfr6KOPTlScAAAAAAAAAABJM2bM0IQJEzRw4ECddNJJWrBggcrKyjRp0qQG2V5MSeRJkybpt7/9rd555x2deOKJtmW6dOmiP/7xj3EFBwAAAAAAAAApK2A4irjqiNJFF12k77//XrNnz9aePXt0/PHH67XXXqvzY3uJElMSeffu3WrZsmXYMi1atNCcOXNiCgoAAAAAAAAAUp5peqd464jB1KlTNXXq1Pi2HaGYksiBCeTy8nJVVlYGLc/JyYkvKgAAAAAAAABASojph/XKyso0depUdejQQVlZWWrTpk3QBAAAAAAAAAA/e/7hLOKdUlxMSeSbbrpJK1eu1KJFi+RyufTXv/5Vc+fOVZcuXfTEE08kOkYAAAAAAAAASDmGacowPXFOcQ6H0QhiGs7in//8p5544gkNGzZMkyZN0pAhQ3T44Yere/fuWrZsmcaNG5foOAEAAAAAAAAASRBTT+T9+/erV69ekrzjH+/fv1+SdMopp2jt2rWJiw4AAAAAAAAAUhXDWYTWq1cvbd++XZJ01FFH6bnnnpPk7aGcm5ubuOgAAAAAAAAAIFWRRA5t0qRJ+uSTTyRJM2fO1MMPP6zMzExdd911uummmxIaIAAAAAAAAAAgeWIaE/m6666z/h4xYoQ2b96sDRs2qH379nrqqacSFhwAAAAAAAAApKxE9CT+ufZErq179+46//zzlZubq7/97W+JqBIAAAAAAAAAUpvpkTxxTs0liQwAAAAAAAAA+HmKaTgLAAAAAAAAAGjuDNMjI86exPGu3xhIIgMAAAAAAABALJrJmMhRJZHPP//8sMsPHDgQTywAAAAAAAAAgBQTVRI5Nze33uXjx4+PKyAAAAAAAAAAaBJM0zvFW0eKiyqJvGTJkoaKAwAAAAAAAACalmYynIUj2QEAAAAAAAAAAFIXP6wHAAAAAAAAADEwTFNGnD2JjZ/bcBYAAAAAAAAAAB+GswAAAAAAAAAANHf0RAYAAAAAAACAWDSTnsgkkQEAAAAAAAAgFs0kiZzU4SwWLVqk/v37KycnRzk5OSooKNCrr76azJAAAAAAAAAAAAGS2hO5a9eumjdvno444giZpqnHH39cv/rVr/Txxx+rX79+yQwNAAAAAAAAAMIyTI+MOHsSx7t+Y0hqEvmcc84J+nznnXdq0aJFWr9+PUlkAAAAAAAAAKnN4/FO8daR4lJmTGS3263ly5errKxMBQUFtmUqKipUUVFhfS4uLm6s8AAAAAAAAACgWUp6Evmzzz5TQUGBysvL1apVK73wwgvq27evbdnCwkLNnTu3kSMEAAAAAAAAABum6Z3irSPFJfWH9SSpT58+2rhxo95//339/ve/14QJE/Tf//7XtuysWbNUVFRkTTt37mzkaAEAAAAAAADAx/QkZkpxSe+JnJGRocMPP1ySNGDAAH3wwQdauHChHnnkkTplXS6XXC5XY4cIAAAAAAAAAM1W0pPItXk8nqBxjwEAAAAAAAAgFRmmR0acPYnjXb8xJDWJPGvWLI0ePVrdunVTSUmJnn76aa1evVqvv/56MsMCAAAAAAAAgPolYjgKksjh7du3T+PHj9fu3buVm5ur/v376/XXX9cZZ5yRzLAAAAAAAAAAAD5JTSL/7W9/S+bmAQAAAAAAACB2ppmAnshmYmJpQCk3JjIAAAAAAAAANAmmW/K4468jxTmSHQAAAAAAAAAAIHXRExkAAAAAAAAAYmB6PDI98Q1nEe/6jYEkMgAAAAAAAADEwpOA4SziXb8RMJwFAAAAAAAAACAkeiIDAAAAAAAAQCyaSU9kksgAAAAAAAAAEAPT7Zbpji8JHO/6jYHhLAAAAAAAAADgZ+jOO+/UySefrJYtW6p169Yx10MSGQAAAAAAAABi4fEkZmoglZWV+s1vfqPf//73cdXDcBYAAAAAAAAAEAuPJwFjIjdcEnnu3LmSpKVLl8ZVD0lkAAAAAAAAAEiy4uLioM8ul0sulytJ0QRjOAsAAAAAAAAAiIHpcSdkkqT8/Hzl5uZaU2FhYZL3rgY9kQEAAAAAAAAgFmYCxjQ2vevv3LlTOTk51uxQvZBnzpyp+fPnh61y06ZNOuqoo+KLKwBJZAAAAAAAAABIspycnKAkcijXX3+9Jk6cGLZMr169EhSVF0lkAAAAAAAAAIhB4HAU8dQRjby8POXl5cW1zWiRRAYAAAAAAACAWHjc3ineOhrIjh07tH//fu3YsUNut1sbN26UJB1++OFq1apVxPWQRAYAAAAAAACAn6HZs2fr8ccftz7/4he/kCStWrVKw4YNi7geR6IDAwAAAAAAAIBmweNJzNRAli5dKtM060zRJJAleiIDAAAAAAAAQExMt1umO84xkeNcvzHQExkAAAAAAAAAEBI9kQEAAAAAAAAgFh5PAn5Yr+GGs0gUksgAAAAAAAAAEAuPOwFJZIazAAAAAAAAAAA0YfREBgAAAAAAAIAYmB6PzDiHo4h3/cZAEhkAAAAAAAAAYsFwFgAAAAAAAACA5u5n0RPZkGTW+qwQ82qvF8i0KeMJmOkw6q5XVOntbp6T4c3HZwSk5c1a/7Vjt8wdMDPNJnD/crt47Oqz2/dwMUXK2r7pPQamUbPz4bZZO35JqvTNzHDWzPTXF66uwGXVNjvltFu5FiPE37W3VRlwYvxx2sVht3+22/UdN/n2s7Sq5n9dyEqv++877lr7F7hvdufTLrZIRHpt7CiukiR1z0kPWDl4nwIFxm/FblPO7rj5V/UfosDDE66927UN22U211okbckM8XckdRiVB71lMlrWu53addVebhe3x2bj4e4ZgfOcnkrvMmdGRLHZnYNwsfnPv//+KUm5/punafO/8NjdWzzV3uKOuo8xI7AOm2usdpyR3iPtyvnvO7btMTBuX7wewxtv4HXuj9cd8O+64dqB3fE20zJDxmgnXLnAZYd8DTfTv4MBxzbidhPuXPn/a1evzTy77dS+l4aKI9rnnv/cBu5fuPt6uHuuf9nXRVXWvB656XXKhbuffVXkbZc9czMiKh/ooG9nWvheKjx292ObeIMW1XrW2zymbLlt2ohtrL76qwPaQe116nvXq72fdtsKLH/IV76lTflw94B6ryXfNV9t1Fzz/k3Y1eGxOUZ295Zwwl2bL27ZL0n6VZ+21rxIr53a+2oXt+22w7Rfu/eBSO+5sdpfXtOzp12mM+Q27bhb5EqSygMCz7Q5MZE+C/2ivSfZlfc/Ru2+f9QuE1gunu8BkdzrQi2vKegNyrB5RofbZiIcCvjCEO5eUeE7367A7yY28fiXBl7XtdvEQZttRnp91/7+JNW0m8DLMFybDndNBl4f6WGuj+Ja33kDy5UFfIdp5avEuk5s3skC68+wuQQqan0vtLsP2n6vCJCI9li7jqDvjNXl3mW+968gvmeAbN576s1Z1Fo36B0rzHtUIP+xqf3eHTjP7t0twwh8Bw8+MXbvDXbzwrXV+r5/1FnXfyykmuNhN8+uXpv8hF9VhNd8pO8v4fISkT7Dw9VvG0eE+ZfaMQbmM/z3tsDzmMjnbrNkJqAnspn6PZF/FklkAAAAAAAAAGhszWVMZIazAAAAAAAAAACERE9kAAAAAAAAAIiFx5OAH9ZL/Z7IJJEBAAAAAAAAIBaeBIyJHO/6jYDhLAAAAAAAAAAAIdETGQAAAAAAAABiYLrdMt3x9SSOd/3GQBIZAAAAAAAAAGLh8cQ/pnETGBOZ4SwAAAAAAAAAACHRExkAAAAAAAAAYtFMfliPJDIAAAAAAAAAxMD0uGXGmQSOd/3GwHAWAAAAAAAAAICQ6IkMAAAAAAAAADEwPR6Zcf4wXrzrNwaSyAAAAAAAAAAQA9NjynTHm0Q2ExRNw2E4CwAAAAAAAABASPREBgAAAAAAAIAYmG5P/D2R41y/MZBEBgAAAAAAAIAYNJcxkRnOAgAAAAAAAAAQEj2RAQAAAAAAACAGDGcBAAAAAAAAAAipuSSRGc4CAAAAAAAAABASPZEBAAAAAAAAIAam2y2P2x13HamOJDIAAAAAAAAAxMA0PTI9cQ5nYTKcBQAAAAAAAACgCaMnMgAAAAAAAADEoLn8sB5JZAAAAAAAAACIQXNJIjOcBQAAAAAAAAAgpJRJIs+bN0+GYWj69OnJDgUAAAAAAAAA6mV6TJkeT5yTmezdqFdKDGfxwQcf6JFHHlH//v2THQoAAAAAAAAARMTj9sgT53AU8a7fGJLeE7m0tFTjxo3TX/7yF7Vp0ybZ4QAAAAAAAAAAAiQ9iTxlyhSNGTNGI0aMqLdsRUWFiouLgyYAAAAAAAAASAb/D+vFO6W6pA5n8cwzz+ijjz7SBx98EFH5wsJCzZ07t4GjAgAAAAAAAID6JSIJ3BSSyEnribxz505NmzZNy5YtU2ZmZkTrzJo1S0VFRda0c+fOBo4SAAAAAAAAAJqer7/+Wpdffrl69uypFi1aqHfv3pozZ44qKyujritpPZE3bNigffv26YQTTrDmud1urV27Vg899JAqKirkdDqD1nG5XHK5XI0dKgAAAAAAAADUYZoemZ44eyKbDdMTefPmzfJ4PHrkkUd0+OGH6/PPP9cVV1yhsrIy3XvvvVHVlbQk8vDhw/XZZ58FzZs0aZKOOuoo3XzzzXUSyAAAAAAAAACQSlJ5OIszzzxTZ555pvW5V69e2rJlixYtWtR0ksjZ2dk65phjguZlZWWpXbt2deYDAAAAAAAAwM9ZcXFx0OeGGJWhqKhIbdu2jXq9pI2JDAAAAAAAAABNmb8ncryTJOXn5ys3N9eaCgsLExrrtm3b9OCDD2ry5MlRr5u0nsh2Vq9enewQAAAAAAAAACAiHo9HnjjHRPavv3PnTuXk5FjzQ/VCnjlzpubPnx+2zk2bNumoo46yPn/33Xc688wz9Zvf/EZXXHFF1DGmVBIZAAAAAAAAAJqjnJycoCRyKNdff70mTpwYtkyvXr2sv3ft2qXTTjtNJ598sh599NGYYiOJDAAAAAAAAAAxSMYP6+Xl5SkvLy+ist99951OO+00DRgwQEuWLJHDEdvoxiSRAQAAAAAAACAG3iSyO+46GsJ3332nYcOGqXv37rr33nv1/fffW8s6deoUVV0kkQEAAAAAAADgZ2bFihXatm2btm3bpq5duwYtM00zqrpi678MAAAAAAAAAM2c6fEkZGoIEydOlGmatlO0SCIDAAAAAAAAAEJiOAsAAAAAAAAAiIHpScAP6zVQT+REIokMAAAAAAAAALFwx59EVgP9sF4iMZwFAAAAAAAAACAkeiIDAAAAAAAAQAw8bo88cfYkjnf9xkASGQAAAAAAAABiYHo8cY9p3BTGRGY4CwAAAAAAAABASPREBgAAAAAAAIAYmAn4Yb24f5ivEZBEBgAAAAAAAIAYmG5TptuMu45Ux3AWAAAAAAAAAICQ6IkMAAAAAAAAADHweDzyxDkchacJ/LAeSWQAAAAAAAAAiIHpMWV64hzOIs71GwPDWQAAAAAAAAAAQqInMgAAAAAAAADEwOOWPI74ehJ73AkKpgGRRAYAAAAAAACAGJhuj0xHfGMam3GOqdwYGM4CAAAAAAAAABASPZEBAAAAAAAAIAam25QZ53AWpjv1f1iPJDIAAAAAAAAAxMDjNhMwJnLqJ5EZzgIAAAAAAAAAEBI9kQEAAAAAAAAgBs3lh/VIIgMAAAAAAABADDymKY8nzuEszNQfzuLnkUT2VNvONgLnO7y7+lO525rVKsMpScrwDephmAFZf9/fTofNIQqoNyfDu9xwVwZtxzuz/tFCjIC/7S4Xo6LUu8zVqk65ogpvjLtLq6xlR7VzBcUfKg7noSJJkqdFbp1l/voDj4ejvMRbPjPbmrejxHssu7fy7kVZwOGu9I3l0jbTWVOHb18M374E7q9hBB4JX/3F3v3q6ThgzStytZMktUqvu09pdauQfOfFdGbUWeTfP/++SQHHI2Df/dXuPVhz7eRnpwfV4Q4YGcZhE4d/aJvSqpp621T+KEk61KK9JCnLZp+MyoPW32kO73JPWqY3xMBydTep9O+3SZKq8g4PWS6w/gpnC0lShrOmlL8NmQHXtX+fu+ek14nDUVXunZfR0prnXx44vI/TLmB/HdW+OgLOmem7hv3HNnB1f71OT2VNed+6zoM/WfM8Ldv4Vqh7TVjXekBbuf/dnZKkGwa0qak33Xfsbe4LxZXeOnIzaurY57tmOrSsaQf+w+A/3q6AOr7xX/PpNeelKjM3aD1Jyij3tt/S9BxJUgubiz/wGDt8x8HtOwY5J0+xlpWsLPTWn5lTE6Pv2ASes/Jq7/7llH8vSfJkd7SW+e9Tlek196kK37+iZgdc19Y92Xf8WjsCzpnp3eaPFTUbbZHmXbelzW3YX1eFWXNsXb4xqEyj7jaDjpBv+9a1Y9bcvKoN77LvD9bMS/NdeHktvNsKPBf+Q18dMLPK9/LQwqi5Z/jrtbtPlfo21cpZs0237/EceB79t48Mw/tHlVmzn/7Lrqiy5h6T7os78PqoPcxWYP12zTLTV+CQbwf950SS/O9Igfc8u7ZU+xnkf3ZJNfebwHqt6oy680p8ByHwGeA/34H7ttf3QOrSKuDe5fuvo8x77/VktatZwSZu//4FNGnr3H/va9vtWtRcf/5jWRJwn3c5vSv7w80LuBf4n5POgAOYZnOP89+zeuV49yXgFFvb/PFQzbXW1hdT4Ln1XwP+WXb3S/+91xuI914X9H7lO0aV8t77iwMCycv01hzY9vznI83Xvkyj5lz4n4WB94dq33M06Jr0bf+gx7tPLQOuZbvz6N9P23u/v86A53uWx7vP1WbNM8spT9C2Jclwe//+weO9Y2dn1JxH//Xh8L1XSZLb9y4RdOvybfeUeeskSetmnVqzL77dOhDQNlq7gttN4D3GOo9h7g+S5PA943/Vp60kqTygkfjbtu3jOGDfS93eOLKd3nrTfvy6Jqa23XwbqtlT6xoIuBb8223h22aaamI0fef9+4B3LH878V8nge9H/n0q9z1DJSnTrKizTbfD9x7g28F2mXWfw4HXgt315+e//wV+sfP4TprdO1/QrFrviXbXt907RSDrWWUExy9JGfLW4ThY8y5rZniPjf990e4eFnCbsuqQXRy++I3A+7jN/TLtq/Xeenv9ss62jFqfa69bW+B58b9feHzvKJUB17D/usrJsHl+2PHV2zLgebPpR++10ze75vrzv8O6/M/woK9UaXX2xTo/gQVrjRiZ5TlU86Hce7z3erKsWf5r/pO9NeWO6+g9j1bbDqjyze3e+83wnjXf4w76rtOqgASGv+3421zge7//u6U74LrO8P/tvzYD3pX977d231c/3VtT78mHeY+f/5oJfC5Y3z9dNfvuv/4Dz53/fa7a9N0zAhb6tx/Y9vz3xzSbZ5uf3bUR9F3Kt8/VAc8qf327Dnn3ISfgvtzK953ACPOdO3CbDpt931fuLdE28F2iVju0y2cEPZ/85yqwPVZ7467wvZcHxmGseNT7x8grrXk1z4+acv5j47+cAt8b/L4qrvn7iNa+91bfs/mHtLbWsnYObzsL/H64q7Tue5q/fbt8N7vA56r1rLe5T9m1x0q3t46g7xC+9ymno+ba2Oy7B1g5FNWc0zTr3NaT0/Ed+60/1RyjI3J9310Pee/NPzhqvmfluLznO02hr52g7xpV3vYVePz85a0clCT5rvkyu3dl339bHPrBmud/Pwq85lI/fYlU8PNIIgMAAAAAAABAY3ObMo04U/FN4If1SCIDAAAAAAAAQAw8bo88hqf+gvXUkerqH28BAAAAAAAAANBs0RMZAAAAAAAAAGJgJmA4C5PhLAAAAAAAAADg56m5JJEZzgIAAAAAAAAAEBI9kQEAAAAAAAAgBs3lh/VIIgMAAAAAAABADEzTlOmJczgLk+EsAAAAAAAAAABNGD2RAQAAAAAAACAGHrcpj+LrSexpAj+sRxIZAAAAAAAAAGJguk2Zim9MY7MJJJEZzgIAAAAAAAAAEBI9kQEAAAAAAAAgBt6eyHH+sF4T6IlMEhkAAAAAAAAAYtBcxkRmOAsAAAAAAAAAQEj0RAYAAAAAAACAGJgej0zDiLuOVEcSGQAAAAAAAABiwHAWAAAAAAAAAIAm69xzz1W3bt2UmZmpzp0769JLL9WuXbuirockMgAAAAAAAADEwPSYMt1xTp6G64l82mmn6bnnntOWLVv0j3/8Q19++aUuuOCCqOthOAsAAAAAAAAAiIXbI9OMb0xkNeCYyNddd531d/fu3TVz5kyNHTtWVVVVSk9Pj7geksgAAAAAAAAAkGTFxcVBn10ul1wuV8Lq379/v5YtW6aTTz45qgSyxHAWAAAAAAAAABATj9tMyCRJ+fn5ys3NtabCwsKExHjzzTcrKytL7dq1044dO/TSSy9FXQdJZAAAAAAAAACIQdzjIfsmSdq5c6eKioqsadasWbbbnDlzpgzDCDtt3rzZKn/jjTfq448/1htvvCGn06nx48fLNKMbh5nhLAAAAAAAAAAgyXJycpSTk1Nvueuvv14TJ04MW6ZXr17W3+3bt1f79u115JFH6uijj1Z+fr7Wr1+vgoKCiGMjiQwAAAAAAAAAMfCYpjxR9uq1qyMaeXl5ysvLi21bvh/xq6ioiGo9ksgAAAAAAAAAEAO3acodZxI53vVDef/99/XBBx/olFNOUZs2bfTll1/qlltuUe/evaPqhSwxJjIAAAAAAAAA/Oy0bNlSzz//vIYPH64+ffro8ssvV//+/bVmzRq5XK6o6kpqT+Rbb71Vc+fODZrXp0+foIGfAQAAAAAAACAVuU3vFG8dDeHYY4/VypUrE1JX0oez6Nevn958803rc1pa0kMCAAAAAAAAgHql8nAWiZT0jG1aWpo6deqU7DAAAAAAAAAAADaSPiby1q1b1aVLF/Xq1Uvjxo3Tjh07QpatqKhQcXFx0AQAAAAAAAAAyeAfziLeKdUlNYk8aNAgLV26VK+99poWLVqk7du3a8iQISopKbEtX1hYqNzcXGvKz89v5IgBAAAAAAAAwMvjG84insnTBIazSGoSefTo0frNb36j/v37a9SoUfr3v/+tAwcO6LnnnrMtP2vWLBUVFVnTzp07GzliAAAAAAAAAGhekj4mcqDWrVvryCOP1LZt22yXu1wuuVyuRo4KAAAAAAAAAOpyK/7hKNwJiaRhJX1M5EClpaX68ssv1blz52SHAgAAAAAAAABhxTuUhX9KdUlNIt9www1as2aNvv76a7377rs677zz5HQ6dfHFFyczLAAAAAAAAACAT1KHs/j222918cUX68cff1ReXp5OOeUUrV+/Xnl5eckMCwAAAAAAAADq5TbjH44i3uEwGkNSk8jPPPNMMjcPAAAAAAAAADFrLknklBoTGQAAAAAAAACQWpLaExkAAAAAAAAAmiq3acqt+LoSN4Uf1iOJDAAAAAAAAAAx8CRgOAtP6ueQGc4CAAAAAAAAABAaPZEBAAAAAAAAIAYMZwEAAAAAAAAACMmdgOEs3KmfQ2Y4CwAAAAAAAABAaPREBgAAAAAAAIAYeHsixzucRYKCaUAkkQEAAAAAAAAgBgxnAQAAAAAAAABo9uiJDAAAAAAAAAAxcJtmAoazSP2uyCSRAQAAAAAAACAGpiRPAupIdQxnAQAAAAAAAAAIiZ7IAAAAAAAAABADhrMAAAAAAAAAAITkNiV3AupIdQxnAQAAAAAAAAAIiZ7IAAAAAAAAABADhrMAAAAAAAAAAITEcBYAAAAAAAAAgGaPnsgAAAAAAAAAEAOGswAAAAAAAAAAhORJwHAWntTPITOcBQAAAAAAAAAgNHoiAwAAAAAAAEAMGM4CAAAAAAAAABCSW5I7zhxwvMNhNIYmnUQ2fVn6kpISmY6aXTH8f3iqawr7lpeU15wWT4ZTkpThH9TD9ARU7glaL0hAvf7tGu7KOuVNo/7RQoyAv/3XW+CFl15Z5l3mqomt2re8rNI7r7SsylpWnO7y1hu4LzZxOA6VeHelyqizzL/5wDoc5aXe8pU1wZWWeo9lscdbR5m7ZjuVvp1Iq3TWhFERvC+B7avKt6n0gFBLS7z7VewoseaVVKR74/AVrBt9Lb7zYjoz6izy759/36SA4xF4/PzxlNVcO8VmelAd7oCRYRw2QfnHtimrqqnXWeXdr0NV3tgynHVXdFQeCvjgXe5Jq6y7L3U3qbQS735VuYrrlPMf+8D6y51VdeIwfNd6UPvyHxvfdRV4Hv31mRkBbcT334Bdr2lztcpIkqO63Dsv4Jz525K/baQF7LB/ntNTc1z86zoP1Vw7nmrftWhzTdTeJ0kqL/Mev+LigDad7lvX5r5Q4muPRsDOlRzyXjOZ1TXtwL+v/jbiCjje1jWfVnNeqiqNoPUkKaPcu1+l6b4yaXWvgMA5/vbu9sVhumuOVXGxd5kZcFnZ3Ysqqn3HqMJ37zBb1GzL17Yr0mtOcqXb184DG7X/3um/b/rOtVRzPkoqajZaleZdt9pu/3zrlhsua57L4V038N5rBD4H/Hzbt64ds6ZMteF7VhyqmZdmeLfvqvIdv8A4/OsFzKzyNfgqo+ae4a/XZles+4LHWXP83L7ygbcF3yWmDMP7R6VZs5/+y85/HUpSmu+eEXh91H6xCazf7j7iL37It4OBdfnva4H3PLu25L+f+s9LSUVNjOnOujGGu6+X+o9Vet3nWuC+lRz0nr9iT913A8dB3zXsTq8TY2Dc1vEO3BV//b62nV5V07b9x7I04GZX4fSu7A/3YFXd8+MMOIB214dqvV8Ennf/NgPfbdJ8Mdk8UmqOrbvu/dIR2B79z5nA9uM7RhXyHrfAa83lv08FHD/rfm3WfY74r/nA+4O/DQVdk77tH/R49ynwXmB3Hv3nx/beX2s/JMmoqvDWm16zn055/CvWlHN7j2+Jx1vezKip0399OAK26fa9SwSdAv/7gu9+WVxc82y2rquAtuFwBV/jgfcYf73h7g+SZPieyR7fe1d5QCOpdNrE6Bew76W+dzvTd3/yv1tIUnWabx/qeff1b7fKH3DAObDuC4dqrmGX75z524s74Drxv2f431kkqdKsqLNtt8P3HmCzg3bvudW+9zi7e+JB38E3zbrPJ7t3PtvzblO/7N6xasUo1dxrrcMXuC1fHY6KmvNipnuPjf990e67RtA7mYKfzUHC3NMD56WVeq/rqoDr2oqx1rbrE3he/O8X/le8yoBruML/d8BNOtxzzO75VFrivXaKA69J/ztsmPcH2/OjgINaqx0Yge/zvnpLzLrXfFlJTbniFt7zWGXzLDpY6r3fFBfX7LH/OV0dMKCmv+2k+WILjMP/fexQwDGt8r1HWddm4Luyfz3VVeY7/96YfMfN5nuC/97scdXsu/VdOrBC3/nwt8vAZ6Pd9q3njc13gdrxB20mcLlvn/3va4H1lZT7vndW1JwE67uozf3M8NRtUw6bfS+p8EaVZvMuUTsuKeBYBT6f/Ocq8N232nvt+N/Lg+5rB73PeiOgrVbZPD/89VnXt6fu98/Smseein2x+Z/NJc6afU93+L4/BXw/LCmr+55W+7uRvy6p1jtbLYHn0X8t+OsK+g7he/fxPx+8++C7B6TXfJ+wzqnd/c9u+77lpSUB36988/z35pLA8+rynu+0MPeM+r5fWwLe5+S75sts3pWt96Mym/ejgOu0pMT3vbAJ9IZNRZWB5zSJdTQ0w2zCV8i3336r/Pz8ZIcBAAAAAAAANGk7d+5U165dkx1Gk1FeXq6ePXtqz549CamvU6dO2r59uzIzMxNSX6I16SSyx+PRli1b1LdvX+3cuVM5OTnJDglAjIqLi5Wfn09bBpow2jHQ9NGOgaaPdgw0fY3djk3TVElJibp06SKHo/7/qx41ysvLVVlZt8d+LDIyMlI2gSw18eEsHA6HDjvsMElSTk4OD0jgZ4C2DDR9tGOg6aMdA00f7Rho+hqzHefm5jbKdn5uMjMzUzrxm0j88wIAAAAAAAAAICSSyAAAAAAAAACAkJp8EtnlcmnOnDlyuVz1FwaQsmjLQNNHOwaaPtox0PTRjoGmj3aMVNSkf1gPAAAAAAAAANCwmnxPZAAAAAAAAABAwyGJDAAAAAAAAAAIiSQyAAAAAAAAACAkksgAAAAAAAAAgJCafBL54YcfVo8ePZSZmalBgwbpP//5T7JDAuCzdu1anXPOOerSpYsMw9CLL74YtNw0Tc2ePVudO3dWixYtNGLECG3dujWozP79+zVu3Djl5OSodevWuvzyy1VaWtqIewE0b4WFhTrxxBOVnZ2tDh06aOzYsdqyZUtQmfLyck2ZMkXt2rVTq1at9Otf/1p79+4NKrNjxw6NGTNGLVu2VIcOHXTjjTequrq6MXcFaLYWLVqk/v37KycnRzk5OSooKNCrr75qLacNA03PvHnzZBiGpk+fbs2jLQOp7dZbb5VhGEHTUUcdZS2nDSPVNekk8rPPPqsZM2Zozpw5+uijj3Tcccdp1KhR2rdvX7JDAyCprKxMxx13nB5++GHb5XfffbceeOABLV68WO+//76ysrI0atQolZeXW2XGjRunL774QitWrNArr7yitWvX6sorr2ysXQCavTVr1mjKlClav369VqxYoaqqKo0cOVJlZWVWmeuuu07//Oc/tXz5cq1Zs0a7du3S+eefby13u90aM2aMKisr9e677+rxxx/X0qVLNXv27GTsEtDsdO3aVfPmzdOGDRv04Ycf6vTTT9evfvUrffHFF5Jow0BT88EHH+iRRx5R//79g+bTloHU169fP+3evdua1q1bZy2jDSPlmU3YSSedZE6ZMsX67Ha7zS5dupiFhYVJjAqAHUnmCy+8YH32eDxmp06dzHvuucead+DAAdPlcpn/7//9P9M0TfO///2vKcn84IMPrDKvvvqqaRiG+d133zVa7ABq7Nu3z5RkrlmzxjRNb7tNT083ly9fbpXZtGmTKcl87733TNM0zX//+9+mw+Ew9+zZY5VZtGiRmZOTY1ZUVDTuDgAwTdM027RpY/71r3+lDQNNTElJiXnEEUeYK1asMIcOHWpOmzbNNE2ex0BTMGfOHPO4446zXUYbRlPQZHsiV1ZWasOGDRoxYoQ1z+FwaMSIEXrvvfeSGBmASGzfvl179uwJasO5ubkaNGiQ1Ybfe+89tW7dWgMHDrTKjBgxQg6HQ++//36jxwxAKioqkiS1bdtWkrRhwwZVVVUFteWjjjpK3bp1C2rLxx57rDp27GiVGTVqlIqLi62ekAAah9vt1jPPPKOysjIVFBTQhoEmZsqUKRozZkxQm5V4HgNNxdatW9WlSxf16tVL48aN044dOyTRhtE0pCU7gFj98MMPcrvdQY1Hkjp27KjNmzcnKSoAkdqzZ48k2bZh/7I9e/aoQ4cOQcvT0tLUtm1bqwyAxuPxeDR9+nQNHjxYxxxzjCRvO83IyFDr1q2DytZuy3Zt3b8MQMP77LPPVFBQoPLycrVq1UovvPCC+vbtq40bN9KGgSbimWee0UcffaQPPvigzjKex0DqGzRokJYuXao+ffpo9+7dmjt3roYMGaLPP/+cNowmockmkQEAQOOaMmWKPv/886Cx2wA0DX369NHGjRtVVFSkv//975owYYLWrFmT7LAARGjnzp2aNm2aVqxYoczMzGSHAyAGo0ePtv7u37+/Bg0apO7du+u5555TixYtkhgZEJkmO5xF+/bt5XQ66/xS5d69e9WpU6ckRQUgUv52Gq4Nd+rUqc4PZVZXV2v//v20c6CRTZ06Va+88opWrVqlrl27WvM7deqkyspKHThwIKh87bZs19b9ywA0vIyMDB1++OEaMGCACgsLddxxx2nhwoW0YaCJ2LBhg/bt26cTTjhBaWlpSktL05o1a/TAAw8oLS1NHTt2pC0DTUzr1q115JFHatu2bTyP0SQ02SRyRkaGBgwYoLfeesua5/F49NZbb6mgoCCJkQGIRM+ePdWpU6egNlxcXKz333/fasMFBQU6cOCANmzYYJVZuXKlPB6PBg0a1OgxA82RaZqaOnWqXnjhBa1cuVI9e/YMWj5gwAClp6cHteUtW7Zox44dQW35s88+C/pHoRUrVignJ0d9+/ZtnB0BEMTj8aiiooI2DDQRw4cP12effaaNGzda08CBAzVu3Djrb9oy0LSUlpbqyy+/VOfOnXkeo0lo0sNZzJgxQxMmTNDAgQN10kknacGCBSorK9OkSZOSHRoAeR+K27Ztsz5v375dGzduVNu2bdWtWzdNnz5dd9xxh4444gj17NlTt9xyi7p06aKxY8dKko4++mideeaZuuKKK7R48WJVVVVp6tSp+u1vf6suXbokaa+A5mXKlCl6+umn9dJLLyk7O9saby03N1ctWrRQbm6uLr/8cs2YMUNt27ZVTk6OrrnmGhUUFOiXv/ylJGnkyJHq27evLr30Ut19993as2eP/vSnP2nKlClyuVzJ3D2gWZg1a5ZGjx6tbt26qaSkRE8//bRWr16t119/nTYMNBHZ2dnW7xH4ZWVlqV27dtZ82jKQ2m644Qadc8456t69u3bt2qU5c+bI6XTq4osv5nmMpsFs4h588EGzW7duZkZGhnnSSSeZ69evT3ZIAHxWrVplSqozTZgwwTRN0/R4POYtt9xiduzY0XS5XObw4cPNLVu2BNXx448/mhdffLHZqlUrMycnx5w0aZJZUlKShL0Bmie7NizJXLJkiVXm0KFD5tVXX222adPGbNmypXneeeeZu3fvDqrn66+/NkePHm22aNHCbN++vXn99debVVVVjbw3QPN02WWXmd27dzczMjLMvLw8c/jw4eYbb7xhLacNA03T0KFDzWnTplmfactAarvooovMzp07mxkZGeZhhx1mXnTRRea2bdus5bRhpDrDNE0zSflrAAAAAAAAAECKa7JjIgMAAAAAAAAAGh5JZAAAAAAAAABASCSRAQAAAAAAAAAhkUQGAAAAAAAAAIREEhkAAAAAAAAAEBJJZAAAAAAAAABASCSRAQAAAAAAAAAhkUQGAAAAAAAAAIREEhkAAKCZmzhxogzD0Lx584Lmv/jiizIMI0lRAQAAAEgVJJEBAACgzMxMzZ8/Xz/99FOjbreqqqpRtwcAAAAgeiSRAQAAoBEjRqhTp04qLCwMWWbdunUaMmSIWrRoofz8fF177bUqKyuzlhuGoRdffDFondatW2vp0qWSpK+//lqGYejZZ5/V0KFDlZmZqWXLlsnj8ei2225T165d5XK5dPzxx+u1116z6vCv9/zzz+u0005Ty5Ytddxxx+m9995L6DEAAAAAYI8kMgAAAOR0OnXXXXfpwQcf1Lfffltn+ZdffqkzzzxTv/71r/Xpp5/q2Wef1bp16zR16tSotzVz5kxNmzZNmzZt0qhRo7Rw4ULdd999uvfee/Xpp59q1KhROvfcc7V169ag9f74xz/qhhtu0MaNG3XkkUfq4osvVnV1dcz7DAAAACAyJJEBAAAgSTrvvPN0/PHHa86cOXWWFRYWaty4cZo+fbqOOOIInXzyyXrggQf0xBNPqLy8PKrtTJ8+Xeeff7569uypzp07695779XNN9+s3/72t+rTp4/mz5+v448/XgsWLAha74YbbtCYMWN05JFHau7cufrmm2+0bdu2eHYZAAAAQARIIgMAAMAyf/58Pf7449q0aVPQ/E8++URLly5Vq1atrGnUqFHyeDzavn17VNsYOHCg9XdxcbF27dqlwYMHB5UZPHhwnRj69+9v/d25c2dJ0r59+6LaNgAAAIDopSU7AAAAAKSOU089VaNGjdKsWbM0ceJEa35paakmT56sa6+9ts463bp1k+QdE9k0zaBldj+cl5WVFVNs6enp1t+GYUiSPB5PTHUBAAAAiBxJZAAAAASZN2+ejj/+ePXp08ead8IJJ+i///2vDj/88JDr5eXlaffu3dbnrVu36uDBg2G3lZOToy5duuidd97R0KFDrfnvvPOOTjrppDj2AgAAAECikEQGAABAkGOPPVbjxo3TAw88YM27+eab9ctf/lJTp07V7373O2VlZem///2vVqxYoYceekiSdPrpp+uhhx5SQUGB3G63br755qDew6HceOONmjNnjnr37q3jjz9eS5Ys0caNG7Vs2bIG20cAAAAAkSOJDAAAgDpuu+02Pfvss9bn/v37a82aNfrjH/+oIUOGyDRN9e7dWxdddJFV5r777tOkSZM0ZMgQdenSRQsXLtSGDRvq3da1116roqIiXX/99dq3b5/69u2rl19+WUcccUSD7BsAAACA6Bhm7YHrAAAAAAAAAADwcSQ7AAAAAAAAAABA6iKJDAAAAAAAAAAIiSQyAAAAAAAAACAkksgAAAAAAAAAgJBIIgMAAAAAAAAAQiKJDAAAAAAAAAAIiSQyAAAAAAAAACAkksgAAAAAAAAAgJBIIgMAAAAAAAAAQiKJDAAAAAAAAAAIiSQyAAAAAAAAACAkksgAAAAAAAAAgJD+PwcruRIWWix1AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax, DLA_DATA = plot_direct_logit_attribution(\n", + "\tmodel=MODEL,\n", + "\tcache=CACHE,\n", + " answer_tokens=DATASET_TARGET_IDS,\n", + " show=False,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ,\n", + " ], dtype=object))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_important_neurons(\n", + " MODEL,\n", + " layer=-1,\n", + " neuron_dla_data=DLA_DATA[\"neurons\"],\n", + " n_important_neurons=50,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "important_heads = [(4, 1, 4.4497685), (3, 1, 0.6722618), (5, 3, -0.50733894), (1, 0, -0.47259304), (2, 1, 0.39200124)]\n", + "CACHE.keys() = dict_keys(['hook_embed', 'hook_pos_embed', 'blocks.0.hook_resid_pre', 'blocks.0.ln1.hook_scale', 'blocks.0.ln1.hook_normalized', 'blocks.0.attn.hook_q', 'blocks.0.attn.hook_k', 'blocks.0.attn.hook_v', 'blocks.0.attn.hook_attn_scores', 'blocks.0.attn.hook_pattern', 'blocks.0.attn.hook_z', 'blocks.0.hook_attn_out', 'blocks.0.hook_resid_mid', 'blocks.0.ln2.hook_scale', 'blocks.0.ln2.hook_normalized', 'blocks.0.mlp.hook_pre', 'blocks.0.mlp.hook_post', 'blocks.0.hook_mlp_out', 'blocks.0.hook_resid_post', 'blocks.1.hook_resid_pre', 'blocks.1.ln1.hook_scale', 'blocks.1.ln1.hook_normalized', 'blocks.1.attn.hook_q', 'blocks.1.attn.hook_k', 'blocks.1.attn.hook_v', 'blocks.1.attn.hook_attn_scores', 'blocks.1.attn.hook_pattern', 'blocks.1.attn.hook_z', 'blocks.1.hook_attn_out', 'blocks.1.hook_resid_mid', 'blocks.1.ln2.hook_scale', 'blocks.1.ln2.hook_normalized', 'blocks.1.mlp.hook_pre', 'blocks.1.mlp.hook_post', 'blocks.1.hook_mlp_out', 'blocks.1.hook_resid_post', 'blocks.2.hook_resid_pre', 'blocks.2.ln1.hook_scale', 'blocks.2.ln1.hook_normalized', 'blocks.2.attn.hook_q', 'blocks.2.attn.hook_k', 'blocks.2.attn.hook_v', 'blocks.2.attn.hook_attn_scores', 'blocks.2.attn.hook_pattern', 'blocks.2.attn.hook_z', 'blocks.2.hook_attn_out', 'blocks.2.hook_resid_mid', 'blocks.2.ln2.hook_scale', 'blocks.2.ln2.hook_normalized', 'blocks.2.mlp.hook_pre', 'blocks.2.mlp.hook_post', 'blocks.2.hook_mlp_out', 'blocks.2.hook_resid_post', 'blocks.3.hook_resid_pre', 'blocks.3.ln1.hook_scale', 'blocks.3.ln1.hook_normalized', 'blocks.3.attn.hook_q', 'blocks.3.attn.hook_k', 'blocks.3.attn.hook_v', 'blocks.3.attn.hook_attn_scores', 'blocks.3.attn.hook_pattern', 'blocks.3.attn.hook_z', 'blocks.3.hook_attn_out', 'blocks.3.hook_resid_mid', 'blocks.3.ln2.hook_scale', 'blocks.3.ln2.hook_normalized', 'blocks.3.mlp.hook_pre', 'blocks.3.mlp.hook_post', 'blocks.3.hook_mlp_out', 'blocks.3.hook_resid_post', 'blocks.4.hook_resid_pre', 'blocks.4.ln1.hook_scale', 'blocks.4.ln1.hook_normalized', 'blocks.4.attn.hook_q', 'blocks.4.attn.hook_k', 'blocks.4.attn.hook_v', 'blocks.4.attn.hook_attn_scores', 'blocks.4.attn.hook_pattern', 'blocks.4.attn.hook_z', 'blocks.4.hook_attn_out', 'blocks.4.hook_resid_mid', 'blocks.4.ln2.hook_scale', 'blocks.4.ln2.hook_normalized', 'blocks.4.mlp.hook_pre', 'blocks.4.mlp.hook_post', 'blocks.4.hook_mlp_out', 'blocks.4.hook_resid_post', 'blocks.5.hook_resid_pre', 'blocks.5.ln1.hook_scale', 'blocks.5.ln1.hook_normalized', 'blocks.5.attn.hook_q', 'blocks.5.attn.hook_k', 'blocks.5.attn.hook_v', 'blocks.5.attn.hook_attn_scores', 'blocks.5.attn.hook_pattern', 'blocks.5.attn.hook_z', 'blocks.5.hook_attn_out', 'blocks.5.hook_resid_mid', 'blocks.5.ln2.hook_scale', 'blocks.5.ln2.hook_normalized', 'blocks.5.mlp.hook_pre', 'blocks.5.mlp.hook_post', 'blocks.5.hook_mlp_out', 'blocks.5.hook_resid_post', 'ln_final.hook_scale', 'ln_final.hook_normalized', 'blocks.0.attn.hook_result', 'blocks.1.attn.hook_result', 'blocks.2.attn.hook_result', 'blocks.3.attn.hook_result', 'blocks.4.attn.hook_result', 'blocks.5.attn.hook_result'])\n", + "================================================================================\n", + "--------------------------------------------------------------------------------\n", + "head: layer_4.head_1, score: c = 4.4497685, v.shape = (10, 233, 233)\n", + "\u001b[30m\u001b[48;2;141;192;221m<-->\u001b[0m \u001b[30m\u001b[48;2;154;199;224m(4,2)\u001b[0m \u001b[30m\u001b[48;2;195;217;238m;\u001b[0m \u001b[30m\u001b[48;2;217;231;245m(5,4)\u001b[0m \u001b[30m\u001b[48;2;199;219;239m<-->\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(5,5)\u001b[0m \u001b[30m\u001b[48;2;193;217;237m;\u001b[0m \u001b[30m\u001b[48;2;98;168;210m\u001b[0m \u001b[30m\u001b[48;2;188;215;235m\u001b[0m \u001b[30m\u001b[48;2;112;177;215m(3,4)\u001b[0m \u001b[30m\u001b[48;2;88;161;206m\u001b[0m \u001b[30m\u001b[48;2;187;214;235m\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(4,1)\u001b[0m \u001b[30m\u001b[48;2;102;170;212m\u001b[0m \u001b[30m\u001b[48;2;215;230;244m\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(3,4)\u001b[0m \u001b[30m\u001b[48;2;222;235;247m(3,3)\u001b[0m \u001b[30m\u001b[48;2;97;167;210m(4,3)\u001b[0m \u001b[30m\u001b[48;2;115;178;215m(4,2)\u001b[0m \u001b[30m\u001b[48;2;8;80;154m(4,1)\u001b[0m\n", + "2.2 1.9 -0.6 0.4 -2.1 3.4 0.8 2.9 3.7 0.8 8.3 3.2 -0.4 -0.7 -0.9 3.4 2.9 7.0 \n", + "\u001b[30m\u001b[48;2;231;240;249m(5,5)\u001b[0m \u001b[30m\u001b[48;2;90;163;207m(4,5)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(4,4)\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(4,3)\u001b[0m \u001b[30m\u001b[48;2;227;238;248m(3,3)\u001b[0m \u001b[30m\u001b[48;2;187;214;235m(2,3)\u001b[0m \u001b[30m\u001b[48;2;234;242;250m(2,4)\u001b[0m \u001b[30m\u001b[48;2;114;177;215m(3,4)\u001b[0m \u001b[30m\u001b[48;2;127;184;218m(3,5)\u001b[0m \u001b[30m\u001b[48;2;123;183;217m(2,5)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(1,5)\u001b[0m \u001b[30m\u001b[48;2;205;223;241m(0,5)\u001b[0m \u001b[30m\u001b[48;2;208;225;242m(0,6)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(0,7)\u001b[0m \u001b[30m\u001b[48;2;246;250;254m(1,7)\u001b[0m \u001b[30m\u001b[48;2;135;189;220m(1,6)\u001b[0m \u001b[30m\u001b[48;2;122;182;217m(2,6)\u001b[0m \u001b[30m\u001b[48;2;90;163;207m(2,7)\u001b[0m \u001b[30m\u001b[48;2;96;166;209m(3,7)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,6)\u001b[0m\n", + "-0.2 3.8 -0.9 2.1 -0.1 1.5 -0.4 3.2 3.0 3.0 -0.9 0.9 0.8 0.3 -0.9 2.8 3.0 3.8 3.7 7.6 \n", + "\u001b[30m\u001b[48;2;241;247;253m(2,0)\u001b[0m \u001b[30m\u001b[48;2;203;222;240m;\u001b[0m \u001b[30m\u001b[48;2;239;245;252m(1,6)\u001b[0m \u001b[30m\u001b[48;2;243;248;253m<-->\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(1,7)\u001b[0m \u001b[30m\u001b[48;2;203;222;240m;\u001b[0m \u001b[30m\u001b[48;2;123;183;217m\u001b[0m \u001b[30m\u001b[48;2;212;228;243m\u001b[0m \u001b[30m\u001b[48;2;190;215;236m(0,7)\u001b[0m \u001b[30m\u001b[48;2;120;181;216m\u001b[0m \u001b[30m\u001b[48;2;211;227;243m\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(4,6)\u001b[0m \u001b[30m\u001b[48;2;130;186;219m\u001b[0m \u001b[30m\u001b[48;2;214;229;244m\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(0,7)\u001b[0m \u001b[30m\u001b[48;2;227;238;248m(1,7)\u001b[0m \u001b[30m\u001b[48;2;202;221;240m(1,6)\u001b[0m \u001b[30m\u001b[48;2;117;179;216m(2,6)\u001b[0m \u001b[30m\u001b[48;2;98;168;210m(3,6)\u001b[0m \u001b[30m\u001b[48;2;8;73;145m(4,6)\u001b[0m\n", + "-2.1 -2.0 -2.2 -2.4 2.6 -0.5 0.6 2.6 -0.5 8.4 2.4 -0.6 -1.0 -1.3 0.1 2.7 3.2 7.3 \n", + "\u001b[30m\u001b[48;2;210;227;243m(2,7)\u001b[0m \u001b[30m\u001b[48;2;117;179;216m(2,6)\u001b[0m \u001b[30m\u001b[48;2;168;206;228m(2,5)\u001b[0m \u001b[30m\u001b[48;2;170;207;229m(3,5)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(4,5)\u001b[0m \u001b[30m\u001b[48;2;192;216;237m(4,6)\u001b[0m \u001b[30m\u001b[48;2;235;243;251m(5,6)\u001b[0m \u001b[30m\u001b[48;2;191;216;236m(5,5)\u001b[0m \u001b[30m\u001b[48;2;203;222;240m(6,5)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(7,5)\u001b[0m \u001b[30m\u001b[48;2;235;243;251m(7,4)\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(7,3)\u001b[0m \u001b[30m\u001b[48;2;180;211;232m(7,2)\u001b[0m \u001b[30m\u001b[48;2;57;137;193m(6,2)\u001b[0m \u001b[30m\u001b[48;2;206;224;241m(5,2)\u001b[0m \u001b[30m\u001b[48;2;88;161;206m(5,1)\u001b[0m \u001b[30m\u001b[48;2;185;213;234m(5,0)\u001b[0m \u001b[30m\u001b[48;2;38;118;183m(4,0)\u001b[0m \u001b[30m\u001b[48;2;71;149;200m(3,0)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,1)\u001b[0m\n", + "-1.3 1.8 0.4 0.3 -3.3 -0.4 -2.6 -0.4 -0.9 -1.7 -2.6 -0.7 -0.0 3.7 -1.1 2.6 -0.2 4.5 3.2 7.4 \n", + "\u001b[30m\u001b[48;2;175;209;230m;\u001b[0m \u001b[30m\u001b[48;2;155;200;224m\u001b[0m \u001b[30m\u001b[48;2;163;204;227m\u001b[0m \u001b[30m\u001b[48;2;177;210;231m(2,3)\u001b[0m \u001b[30m\u001b[48;2;115;178;215m\u001b[0m \u001b[30m\u001b[48;2;163;204;227m\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(6,1)\u001b[0m \u001b[30m\u001b[48;2;147;196;222m\u001b[0m \u001b[30m\u001b[48;2;211;227;243m\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(2,3)\u001b[0m \u001b[30m\u001b[48;2;175;209;230m(2,4)\u001b[0m \u001b[30m\u001b[48;2;133;188;219m(2,5)\u001b[0m \u001b[30m\u001b[48;2;219;233;246m(3,5)\u001b[0m \u001b[30m\u001b[48;2;226;237;248m(3,4)\u001b[0m \u001b[30m\u001b[48;2;239;246;252m(3,3)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(4,3)\u001b[0m \u001b[30m\u001b[48;2;178;210;232m(4,2)\u001b[0m \u001b[30m\u001b[48;2;114;177;215m(5,2)\u001b[0m \u001b[30m\u001b[48;2;83;157;204m(5,1)\u001b[0m \u001b[30m\u001b[48;2;20;97;168m(6,1)\u001b[0m\n", + " 1.4 1.1 0.7 2.4 1.2 7.9 1.6 -0.7 -1.1 0.8 2.0 -1.1 -1.5 -2.2 -2.6 0.7 2.5 3.4 5.9 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "head: layer_3.head_1, score: c = 0.6722618, v.shape = (10, 233, 233)\n", + "\u001b[30m\u001b[48;2;200;220;239m<-->\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(4,2)\u001b[0m \u001b[30m\u001b[48;2;182;212;233m;\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(5,4)\u001b[0m \u001b[30m\u001b[48;2;192;216;237m<-->\u001b[0m \u001b[30m\u001b[48;2;209;226;242m(5,5)\u001b[0m \u001b[30m\u001b[48;2;182;212;233m;\u001b[0m \u001b[30m\u001b[48;2;56;136;192m\u001b[0m \u001b[30m\u001b[48;2;130;186;219m\u001b[0m \u001b[30m\u001b[48;2;161;203;226m(3,4)\u001b[0m \u001b[30m\u001b[48;2;83;157;204m\u001b[0m \u001b[30m\u001b[48;2;131;187;219m\u001b[0m \u001b[30m\u001b[48;2;120;181;216m(4,1)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;62;142;196m\u001b[0m \u001b[30m\u001b[48;2;171;207;229m(3,4)\u001b[0m \u001b[30m\u001b[48;2;85;159;205m(3,3)\u001b[0m \u001b[30m\u001b[48;2;105;172;213m(4,3)\u001b[0m \u001b[30m\u001b[48;2;38;118;183m(4,2)\u001b[0m \u001b[30m\u001b[48;2;87;160;206m(4,1)\u001b[0m\n", + "0.3 1.8 -2.8 0.7 -0.3 5.8 3.0 2.0 4.6 2.9 3.3 10.2 5.5 1.6 4.5 3.8 6.7 4.5 \n", + "\u001b[30m\u001b[48;2;90;163;207m(5,5)\u001b[0m \u001b[30m\u001b[48;2;133;188;219m(4,5)\u001b[0m \u001b[30m\u001b[48;2;133;188;219m(4,4)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(4,3)\u001b[0m \u001b[30m\u001b[48;2;187;214;235m(3,3)\u001b[0m \u001b[30m\u001b[48;2;246;250;254m(2,3)\u001b[0m \u001b[30m\u001b[48;2;217;231;245m(2,4)\u001b[0m \u001b[30m\u001b[48;2;206;224;241m(3,4)\u001b[0m \u001b[30m\u001b[48;2;59;139;194m(3,5)\u001b[0m \u001b[30m\u001b[48;2;177;210;231m(2,5)\u001b[0m \u001b[30m\u001b[48;2;96;166;209m(1,5)\u001b[0m \u001b[30m\u001b[48;2;165;205;227m(0,5)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(0,6)\u001b[0m \u001b[30m\u001b[48;2;170;207;229m(0,7)\u001b[0m \u001b[30m\u001b[48;2;103;171;212m(1,7)\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(1,6)\u001b[0m \u001b[30m\u001b[48;2;40;120;184m(2,6)\u001b[0m \u001b[30m\u001b[48;2;139;192;221m(2,7)\u001b[0m \u001b[30m\u001b[48;2;23;101;171m(3,7)\u001b[0m \u001b[30m\u001b[48;2;43;123;186m(3,6)\u001b[0m\n", + "4.8 4.3 4.3 2.3 3.6 2.3 3.0 3.2 5.3 3.7 4.7 3.9 6.9 3.8 4.6 3.4 5.6 4.2 6.0 5.6 \n", + "\u001b[30m\u001b[48;2;226;237;248m(2,0)\u001b[0m \u001b[30m\u001b[48;2;195;217;238m;\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(1,6)\u001b[0m \u001b[30m\u001b[48;2;213;229;244m<-->\u001b[0m \u001b[30m\u001b[48;2;195;217;238m(1,7)\u001b[0m \u001b[30m\u001b[48;2;195;217;238m;\u001b[0m \u001b[30m\u001b[48;2;53;133;191m\u001b[0m \u001b[30m\u001b[48;2;146;195;222m\u001b[0m \u001b[30m\u001b[48;2;117;179;216m(0,7)\u001b[0m \u001b[30m\u001b[48;2;83;157;204m\u001b[0m \u001b[30m\u001b[48;2;144;194;222m\u001b[0m \u001b[30m\u001b[48;2;103;171;212m(4,6)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;44;124;187m\u001b[0m \u001b[30m\u001b[48;2;74;151;201m(0,7)\u001b[0m \u001b[30m\u001b[48;2;85;159;205m(1,7)\u001b[0m \u001b[30m\u001b[48;2;97;167;210m(1,6)\u001b[0m \u001b[30m\u001b[48;2;85;159;205m(2,6)\u001b[0m \u001b[30m\u001b[48;2;107;174;214m(3,6)\u001b[0m \u001b[30m\u001b[48;2;74;151;201m(4,6)\u001b[0m\n", + "-1.8 -3.4 -0.7 0.6 7.1 2.9 4.0 5.6 3.0 4.6 12.2 7.6 6.0 5.4 4.9 5.4 4.4 6.0 \n", + "\u001b[30m\u001b[48;2;27;106;175m(2,7)\u001b[0m \u001b[30m\u001b[48;2;88;161;206m(2,6)\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(2,5)\u001b[0m \u001b[30m\u001b[48;2;62;142;196m(3,5)\u001b[0m \u001b[30m\u001b[48;2;207;225;242m(4,5)\u001b[0m \u001b[30m\u001b[48;2;151;198;223m(4,6)\u001b[0m \u001b[30m\u001b[48;2;178;210;232m(5,6)\u001b[0m \u001b[30m\u001b[48;2;122;182;217m(5,5)\u001b[0m \u001b[30m\u001b[48;2;176;209;231m(6,5)\u001b[0m \u001b[30m\u001b[48;2;127;184;218m(7,5)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(7,4)\u001b[0m \u001b[30m\u001b[48;2;136;190;220m(7,3)\u001b[0m \u001b[30m\u001b[48;2;196;218;238m(7,2)\u001b[0m \u001b[30m\u001b[48;2;34;114;181m(6,2)\u001b[0m \u001b[30m\u001b[48;2;119;180;216m(5,2)\u001b[0m \u001b[30m\u001b[48;2;60;140;195m(5,1)\u001b[0m \u001b[30m\u001b[48;2;50;130;190m(5,0)\u001b[0m \u001b[30m\u001b[48;2;16;92;164m(4,0)\u001b[0m \u001b[30m\u001b[48;2;19;95;167m(3,0)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,1)\u001b[0m\n", + "5.4 4.1 2.8 4.6 1.9 3.1 2.6 3.5 2.6 3.5 0.7 3.3 2.3 5.3 3.6 4.7 4.9 5.8 5.7 6.8 \n", + "\u001b[30m\u001b[48;2;247;251;255m;\u001b[0m \u001b[30m\u001b[48;2;64;144;197m\u001b[0m \u001b[30m\u001b[48;2;201;221;240m\u001b[0m \u001b[30m\u001b[48;2;154;199;224m(2,3)\u001b[0m \u001b[30m\u001b[48;2;94;165;209m\u001b[0m \u001b[30m\u001b[48;2;204;223;241m\u001b[0m \u001b[30m\u001b[48;2;204;223;241m(6,1)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;122;182;217m\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(2,3)\u001b[0m \u001b[30m\u001b[48;2;197;218;238m(2,4)\u001b[0m \u001b[30m\u001b[48;2;157;201;224m(2,5)\u001b[0m \u001b[30m\u001b[48;2;128;185;218m(3,5)\u001b[0m \u001b[30m\u001b[48;2;203;222;240m(3,4)\u001b[0m \u001b[30m\u001b[48;2;135;189;220m(3,3)\u001b[0m \u001b[30m\u001b[48;2;206;224;241m(4,3)\u001b[0m \u001b[30m\u001b[48;2;106;173;213m(4,2)\u001b[0m \u001b[30m\u001b[48;2;178;210;232m(5,2)\u001b[0m \u001b[30m\u001b[48;2;177;210;231m(5,1)\u001b[0m \u001b[30m\u001b[48;2;191;216;236m(6,1)\u001b[0m\n", + " 7.1 3.1 4.6 6.2 2.9 2.9 10.9 5.4 3.1 3.3 4.6 5.3 3.0 5.1 2.8 5.8 3.9 3.9 3.5 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "head: layer_5.head_3, score: c = -0.50733894, v.shape = (10, 233, 233)\n", + "\u001b[30m\u001b[48;2;49;129;189m<-->\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(4,2)\u001b[0m \u001b[30m\u001b[48;2;88;161;206m;\u001b[0m \u001b[30m\u001b[48;2;48;128;189m(5,4)\u001b[0m \u001b[30m\u001b[48;2;59;139;194m<-->\u001b[0m \u001b[30m\u001b[48;2;13;88;161m(5,5)\u001b[0m \u001b[30m\u001b[48;2;92;163;208m;\u001b[0m \u001b[30m\u001b[48;2;117;179;216m\u001b[0m \u001b[30m\u001b[48;2;84;158;205m\u001b[0m \u001b[30m\u001b[48;2;192;216;237m(3,4)\u001b[0m \u001b[30m\u001b[48;2;115;178;215m\u001b[0m \u001b[30m\u001b[48;2;83;157;204m\u001b[0m \u001b[30m\u001b[48;2;8;67;136m(4,1)\u001b[0m \u001b[30m\u001b[48;2;154;199;224m\u001b[0m \u001b[30m\u001b[48;2;99;169;211m\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(3,4)\u001b[0m \u001b[30m\u001b[48;2;87;160;206m(3,3)\u001b[0m \u001b[30m\u001b[48;2;81;156;204m(4,3)\u001b[0m \u001b[30m\u001b[48;2;8;80;154m(4,2)\u001b[0m \u001b[30m\u001b[48;2;16;92;164m(4,1)\u001b[0m\n", + "0.2 2.4 0.2 -0.1 1.3 -1.3 -0.7 -2.8 -1.3 -0.6 1.9 -2.0 -1.0 -4.7 -0.7 -0.6 1.6 1.2 \n", + "\u001b[30m\u001b[48;2;8;48;107m(5,5)\u001b[0m \u001b[30m\u001b[48;2;84;158;205m(4,5)\u001b[0m \u001b[30m\u001b[48;2;19;96;167m(4,4)\u001b[0m \u001b[30m\u001b[48;2;127;184;218m(4,3)\u001b[0m \u001b[30m\u001b[48;2;157;201;224m(3,3)\u001b[0m \u001b[30m\u001b[48;2;235;243;251m(2,3)\u001b[0m \u001b[30m\u001b[48;2;160;202;225m(2,4)\u001b[0m \u001b[30m\u001b[48;2;183;212;234m(3,4)\u001b[0m \u001b[30m\u001b[48;2;80;155;203m(3,5)\u001b[0m \u001b[30m\u001b[48;2;234;242;250m(2,5)\u001b[0m \u001b[30m\u001b[48;2;157;201;224m(1,5)\u001b[0m \u001b[30m\u001b[48;2;196;218;238m(0,5)\u001b[0m \u001b[30m\u001b[48;2;112;177;215m(0,6)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(0,7)\u001b[0m \u001b[30m\u001b[48;2;188;215;235m(1,7)\u001b[0m \u001b[30m\u001b[48;2;239;246;252m(1,6)\u001b[0m \u001b[30m\u001b[48;2;90;163;207m(2,6)\u001b[0m \u001b[30m\u001b[48;2;212;228;243m(2,7)\u001b[0m \u001b[30m\u001b[48;2;8;60;125m(3,7)\u001b[0m \u001b[30m\u001b[48;2;46;126;188m(3,6)\u001b[0m\n", + "2.9 0.4 1.8 -0.2 -0.7 -2.4 -0.7 -1.1 0.5 -2.4 -0.7 -1.3 -0.0 -2.8 -1.2 -2.6 0.3 -1.8 2.6 1.2 \n", + "\u001b[30m\u001b[48;2;244;249;254m(2,0)\u001b[0m \u001b[30m\u001b[48;2;186;214;234m;\u001b[0m \u001b[30m\u001b[48;2;99;169;211m(1,6)\u001b[0m \u001b[30m\u001b[48;2;76;153;202m<-->\u001b[0m \u001b[30m\u001b[48;2;222;235;247m(1,7)\u001b[0m \u001b[30m\u001b[48;2;190;215;236m;\u001b[0m \u001b[30m\u001b[48;2;216;231;245m\u001b[0m \u001b[30m\u001b[48;2;200;220;239m\u001b[0m \u001b[30m\u001b[48;2;183;212;234m(0,7)\u001b[0m \u001b[30m\u001b[48;2;238;245;252m\u001b[0m \u001b[30m\u001b[48;2;198;219;239m\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(4,6)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m\u001b[0m \u001b[30m\u001b[48;2;151;198;223m\u001b[0m \u001b[30m\u001b[48;2;165;205;227m(0,7)\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(1,7)\u001b[0m \u001b[30m\u001b[48;2;202;221;240m(1,6)\u001b[0m \u001b[30m\u001b[48;2;188;215;235m(2,6)\u001b[0m \u001b[30m\u001b[48;2;18;94;166m(3,6)\u001b[0m \u001b[30m\u001b[48;2;8;68;137m(4,6)\u001b[0m\n", + "-1.5 0.7 1.0 -1.0 -0.9 -0.5 -0.3 -1.4 -0.5 2.8 -1.6 0.1 -0.0 -1.0 -0.6 -0.4 2.0 2.5 \n", + "\u001b[30m\u001b[48;2;228;239;249m(2,7)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(2,6)\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(2,5)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(3,5)\u001b[0m \u001b[30m\u001b[48;2;128;185;218m(4,5)\u001b[0m \u001b[30m\u001b[48;2;163;204;227m(4,6)\u001b[0m \u001b[30m\u001b[48;2;106;173;213m(5,6)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(5,5)\u001b[0m \u001b[30m\u001b[48;2;207;225;242m(6,5)\u001b[0m \u001b[30m\u001b[48;2;225;237;248m(7,5)\u001b[0m \u001b[30m\u001b[48;2;199;219;239m(7,4)\u001b[0m \u001b[30m\u001b[48;2;167;206;228m(7,3)\u001b[0m \u001b[30m\u001b[48;2;96;166;209m(7,2)\u001b[0m \u001b[30m\u001b[48;2;34;114;181m(6,2)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(5,2)\u001b[0m \u001b[30m\u001b[48;2;37;117;183m(5,1)\u001b[0m \u001b[30m\u001b[48;2;49;129;189m(5,0)\u001b[0m \u001b[30m\u001b[48;2;115;178;215m(4,0)\u001b[0m \u001b[30m\u001b[48;2;8;69;139m(3,0)\u001b[0m \u001b[30m\u001b[48;2;59;139;194m(3,1)\u001b[0m\n", + "-2.7 -3.2 -2.1 -2.5 -1.2 -1.6 -1.0 -2.5 -2.3 -2.7 -2.1 -1.6 -0.8 0.1 1.2 0.1 -0.1 -1.1 0.9 -0.3 \n", + "\u001b[30m\u001b[48;2;144;194;222m;\u001b[0m \u001b[30m\u001b[48;2;202;221;240m\u001b[0m \u001b[30m\u001b[48;2;101;170;211m\u001b[0m \u001b[30m\u001b[48;2;223;235;247m(2,3)\u001b[0m \u001b[30m\u001b[48;2;225;237;248m\u001b[0m \u001b[30m\u001b[48;2;109;175;214m\u001b[0m \u001b[30m\u001b[48;2;46;126;188m(6,1)\u001b[0m \u001b[30m\u001b[48;2;236;243;251m\u001b[0m \u001b[30m\u001b[48;2;149;197;223m\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(2,3)\u001b[0m \u001b[30m\u001b[48;2;161;203;226m(2,4)\u001b[0m \u001b[30m\u001b[48;2;182;212;233m(2,5)\u001b[0m \u001b[30m\u001b[48;2;181;211;233m(3,5)\u001b[0m \u001b[30m\u001b[48;2;226;237;248m(3,4)\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(3,3)\u001b[0m \u001b[30m\u001b[48;2;193;217;237m(4,3)\u001b[0m \u001b[30m\u001b[48;2;103;171;212m(4,2)\u001b[0m \u001b[30m\u001b[48;2;209;226;242m(5,2)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(5,1)\u001b[0m \u001b[30m\u001b[48;2;63;143;196m(6,1)\u001b[0m\n", + " -0.8 0.3 -1.2 -1.3 0.2 1.0 -1.4 -0.2 -1.7 -0.3 -0.5 -0.5 -1.3 -1.2 -0.7 0.3 -0.9 2.1 0.7 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "head: layer_1.head_0, score: c = -0.47259304, v.shape = (10, 233, 233)\n", + "\u001b[30m\u001b[48;2;200;220;239m<-->\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(4,2)\u001b[0m \u001b[30m\u001b[48;2;217;231;245m;\u001b[0m \u001b[30m\u001b[48;2;228;238;248m(5,4)\u001b[0m \u001b[30m\u001b[48;2;205;223;241m<-->\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(5,5)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m;\u001b[0m \u001b[30m\u001b[48;2;46;126;188m\u001b[0m \u001b[30m\u001b[48;2;211;227;243m\u001b[0m \u001b[30m\u001b[48;2;203;222;240m(3,4)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;213;229;244m\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(4,1)\u001b[0m \u001b[30m\u001b[48;2;80;155;203m\u001b[0m \u001b[30m\u001b[48;2;180;211;232m\u001b[0m \u001b[30m\u001b[48;2;188;215;235m(3,4)\u001b[0m \u001b[30m\u001b[48;2;217;231;245m(3,3)\u001b[0m \u001b[30m\u001b[48;2;196;218;238m(4,3)\u001b[0m \u001b[30m\u001b[48;2;212;228;243m(4,2)\u001b[0m \u001b[30m\u001b[48;2;192;216;237m(4,1)\u001b[0m\n", + "2.5 0.4 -0.5 1.9 -2.4 11.7 1.3 2.0 17.9 1.0 0.2 9.3 3.8 3.3 0.7 2.8 1.2 3.0 \n", + "\u001b[30m\u001b[48;2;218;232;245m(5,5)\u001b[0m \u001b[30m\u001b[48;2;21;98;169m(4,5)\u001b[0m \u001b[30m\u001b[48;2;160;202;225m(4,4)\u001b[0m \u001b[30m\u001b[48;2;8;50;110m(4,3)\u001b[0m \u001b[30m\u001b[48;2;84;158;205m(3,3)\u001b[0m \u001b[30m\u001b[48;2;17;93;165m(2,3)\u001b[0m \u001b[30m\u001b[48;2;172;208;230m(2,4)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,4)\u001b[0m \u001b[30m\u001b[48;2;186;214;234m(3,5)\u001b[0m \u001b[30m\u001b[48;2;71;149;200m(2,5)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(1,5)\u001b[0m \u001b[30m\u001b[48;2;79;155;203m(0,5)\u001b[0m \u001b[30m\u001b[48;2;239;246;252m(0,6)\u001b[0m \u001b[30m\u001b[48;2;198;219;239m(0,7)\u001b[0m \u001b[30m\u001b[48;2;236;243;251m(1,7)\u001b[0m \u001b[30m\u001b[48;2;125;184;217m(1,6)\u001b[0m \u001b[30m\u001b[48;2;219;233;246m(2,6)\u001b[0m \u001b[30m\u001b[48;2;133;188;219m(2,7)\u001b[0m \u001b[30m\u001b[48;2;188;215;235m(3,7)\u001b[0m \u001b[30m\u001b[48;2;23;101;171m(3,6)\u001b[0m\n", + "-2.5 1.7 -1.1 2.9 0.2 1.9 -1.4 3.0 -1.6 0.4 -3.5 0.3 -3.2 -1.9 -3.1 -0.5 -2.6 -0.7 -1.7 1.7 \n", + "\u001b[30m\u001b[48;2;228;239;249m(2,0)\u001b[0m \u001b[30m\u001b[48;2;232;241;250m;\u001b[0m \u001b[30m\u001b[48;2;232;241;250m(1,6)\u001b[0m \u001b[30m\u001b[48;2;218;232;245m<-->\u001b[0m \u001b[30m\u001b[48;2;229;239;249m(1,7)\u001b[0m \u001b[30m\u001b[48;2;232;241;250m;\u001b[0m \u001b[30m\u001b[48;2;53;133;191m\u001b[0m \u001b[30m\u001b[48;2;224;236;247m\u001b[0m \u001b[30m\u001b[48;2;218;232;245m(0,7)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;222;235;247m\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(4,6)\u001b[0m \u001b[30m\u001b[48;2;89;162;207m\u001b[0m \u001b[30m\u001b[48;2;165;205;227m\u001b[0m \u001b[30m\u001b[48;2;208;225;242m(0,7)\u001b[0m \u001b[30m\u001b[48;2;225;236;247m(1,7)\u001b[0m \u001b[30m\u001b[48;2;206;224;241m(1,6)\u001b[0m \u001b[30m\u001b[48;2;225;237;248m(2,6)\u001b[0m \u001b[30m\u001b[48;2;191;216;236m(3,6)\u001b[0m \u001b[30m\u001b[48;2;238;245;252m(4,6)\u001b[0m\n", + "-0.7 -1.0 0.4 -0.8 10.8 -0.2 0.4 17.4 -0.1 -2.5 8.5 4.5 1.4 -0.3 1.5 -0.4 2.9 -1.6 \n", + "\u001b[30m\u001b[48;2;232;241;250m(2,7)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(2,6)\u001b[0m \u001b[30m\u001b[48;2;115;178;215m(2,5)\u001b[0m \u001b[30m\u001b[48;2;192;216;237m(3,5)\u001b[0m \u001b[30m\u001b[48;2;79;155;203m(4,5)\u001b[0m \u001b[30m\u001b[48;2;206;224;241m(4,6)\u001b[0m \u001b[30m\u001b[48;2;35;115;182m(5,6)\u001b[0m \u001b[30m\u001b[48;2;193;217;237m(5,5)\u001b[0m \u001b[30m\u001b[48;2;46;126;188m(6,5)\u001b[0m \u001b[30m\u001b[48;2;123;183;217m(7,5)\u001b[0m \u001b[30m\u001b[48;2;97;167;210m(7,4)\u001b[0m \u001b[30m\u001b[48;2;175;209;230m(7,3)\u001b[0m \u001b[30m\u001b[48;2;43;123;186m(7,2)\u001b[0m \u001b[30m\u001b[48;2;26;104;174m(6,2)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(5,2)\u001b[0m \u001b[30m\u001b[48;2;94;165;209m(5,1)\u001b[0m \u001b[30m\u001b[48;2;8;72;143m(5,0)\u001b[0m \u001b[30m\u001b[48;2;119;180;216m(4,0)\u001b[0m \u001b[30m\u001b[48;2;17;93;165m(3,0)\u001b[0m \u001b[30m\u001b[48;2;40;120;184m(3,1)\u001b[0m\n", + "-3.1 -3.7 0.3 -1.5 1.2 -2.0 2.5 -1.5 2.1 0.1 0.7 -1.0 2.2 2.8 4.6 0.8 3.9 0.2 3.2 2.3 \n", + "\u001b[30m\u001b[48;2;204;223;241m;\u001b[0m \u001b[30m\u001b[48;2;43;123;186m\u001b[0m \u001b[30m\u001b[48;2;188;215;235m\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(2,3)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m\u001b[0m \u001b[30m\u001b[48;2;193;217;237m\u001b[0m \u001b[30m\u001b[48;2;217;231;245m(6,1)\u001b[0m \u001b[30m\u001b[48;2;62;142;196m\u001b[0m \u001b[30m\u001b[48;2;177;210;231m\u001b[0m \u001b[30m\u001b[48;2;214;229;244m(2,3)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(2,4)\u001b[0m \u001b[30m\u001b[48;2;232;241;250m(2,5)\u001b[0m \u001b[30m\u001b[48;2;239;245;252m(3,5)\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(3,4)\u001b[0m \u001b[30m\u001b[48;2;215;230;244m(3,3)\u001b[0m \u001b[30m\u001b[48;2;187;214;235m(4,3)\u001b[0m \u001b[30m\u001b[48;2;199;219;239m(4,2)\u001b[0m \u001b[30m\u001b[48;2;152;199;223m(5,2)\u001b[0m \u001b[30m\u001b[48;2;214;229;244m(5,1)\u001b[0m \u001b[30m\u001b[48;2;176;209;231m(6,1)\u001b[0m\n", + " 11.1 3.1 0.2 16.5 2.7 0.6 9.8 3.6 0.9 -2.2 -0.8 -1.4 2.2 0.8 3.1 2.4 5.1 0.9 3.7 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACwIAAAI+CAYAAAC1sFyfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT1f8H8HeS7r1oS4GWUSh7ryJ7ikyhlKFsBGQVUNlYREBFlKpMUYpgK0uGg68sZQkoW4YoqxTKHt27Ob8/+uu1l6Rt0qZN07xfz9Pn6T05OfeTtJB37zn3XoUQQoCIiIiIiIiIiIiIiIiIiIiIiIiIiIhMitLYBRAREREREREREREREREREREREREREZH+uBCYiIiIiIiIiIiIiIiIiIiIiIiIiIjIBHEhMBERERERERERERERERERERERERERkQniQmAiIiIiIiIiIiIiIiIiIiIiIiIiIiITxIXAREREREREREREREREREREREREREREJogLgYmIiIiIiIiIiIiIiIiIiIiIiIiIiEwQFwITERERERERERERERERERERERERERGZIC4EJiIiIiIiIiIiIiIiIiIiIiIiIiIiMkFcCExERERERERERERERERERERERERERGSCuBCYSh2FQoEFCxYYuwy9HTp0CAqFAocOHSr0GH/++SesrKxw+/Ztqa1ly5aYMWOGASokIiKi4sQMwwxDRERkiphhmGGIiIhMETMMMwwREZGpYo5hjiEiKg5cCGxmrly5ggULFiAqKkrjsVWrVmHDhg0lUseePXtMMtgUt7lz52Lw4MHw8/OT2mbOnImVK1fiwYMHRqxMbtq0aWjcuDHc3NxgZ2eHWrVqYcGCBUhMTNR7rGPHjkGhUEChUODJkycajx84cAAdOnSAh4cHXFxc0Lx5c2zatEmjX84YL359+OGHsn6VK1fOs2/16tVlfR8+fIiRI0fC09MTtra2aNy4MbZt26ax7wULFmgdz8bGRtZvw4YNee5boVAgIiJC7/ePiMhcMMOUbqaSYXK7ceMGbGxsoFAocPr06QL7X716FTNmzEDDhg3h6OiI8uXLo0ePHlqfu3PnTnTr1g0+Pj6wtrZGxYoVERQUhEuXLmn03bJlC15//XVUr14dCoUC7du3z7OGtLQ0zJw5Ez4+PrC1tUWLFi2wf/9+jX4ZGRl47733ULVqVVhbW6Nq1apYtGgRMjMzZf1yDtpp+zp58qSs75IlS9CyZUuUK1cONjY2qF69OqZOnYrHjx8X+N4REZkzZpjSjRlGk67HYeLi4jBjxgxUr14dtra28PPzw+jRoxEdHa3RNyYmBsHBwXBxcYGTkxP69OmDmzdvavRbvXo1BgwYAF9fXygUCowYMaLgNwTAG2+8AYVCgZ49e+bbT9/3jojInDHDlG6mlGESEhIwY8YMVKlSBdbW1qhQoQKCgoKQnJxc4HMXL16M3r17w8vLK98FU/rM++iaN/Kbz8nvPS4ob8TGxmLs2LEoV64c7O3t0aFDB5w9e1bWJ7/jNQqFAosXL87/jSMiMnPMMaWbKeWYHIU5nnD9+nUEBQXB1dUVdnZ2aN26NX777TetfVesWIFatWpJWWn69OlISkoqkTFzXt+QIUOkdTHVq1fH3LlzZX3WrVuHdu3awcvLC9bW1qhSpQpGjhyp8e8sJSUFo0ePRt26deHs7AwHBwc0aNAAn332GTIyMnR454ioKCyMXQCVrCtXruC9995D+/btUblyZdljq1atgoeHh84H2Ytiz549WLlypdbgk5KSAgsL0/vVbNu2LVJSUmBlZVWo558/fx4HDhzA8ePHZe19+vSBk5MTVq1ahYULFxqi1CI7deoU2rRpg5EjR8LGxgbnzp3Dhx9+iAMHDuDIkSNQKnU7x0CtVmPy5Mmwt7fXGjp++OEH9O3bF4GBgdJi261bt2LYsGF48uQJpk2bJuvfpUsXDBs2TNbWqFEj2XZYWJjGguXbt29j3rx56Nq1q9QWHx+P1q1b4+HDhwgJCYG3tze2bt2K4OBgREREYMiQIRr1rl69Gg4ODtK2SqWSPd62bVutk2fLly/HhQsX0KlTJ43HiIgoGzNM8TGnDJPbtGnTYGFhgbS0NJ36f/XVV/j666/Rv39/TJgwAXFxcVi7di1atmyJX375BZ07d5b6Xrx4Ea6urggJCYGHhwcePHiA9evXo3nz5jhx4gQaNGgg9V29ejXOnDmDZs2a4enTp/nWMGLECGzfvh1Tp05F9erVsWHDBrzyyiv47bff0Lp1a6nf66+/jm3btmHUqFFo2rQpTp48ifnz5yM6OhpffvmlxrhTpkxBs2bNZG3+/v6y7TNnzqBhw4YYNGgQHB0d8ffff2PdunX4+eefcf78edjb2+v0PhIRmRtmmOLDDGP4DKPrcRi1Wo0uXbrgypUrmDBhAmrUqIHr169j1apV2Lt3L/7++284OjoCABITE9GhQwfExcVhzpw5sLS0xPLly9GuXTucP38e7u7u0v4/+ugjJCQkoHnz5rh//75Or+/06dPYsGGDxsnYhnjviIjMGTNM8TGnDBMXF4d27drh7t27GDt2LPz9/fH48WMcPXoUaWlpsLOzy/f58+bNg7e3Nxo1aoS9e/fm2U/XeR9A/7yxcOFCVKlSRdbm4uKSZ//88oZarUaPHj1w4cIFvPPOO/Dw8MCqVavQvn17nDlzRlq0XKtWLa1zSZs2bcK+ffs0XhMREckxxxQfc8oxuel7POHOnTsIDAyESqXCO++8A3t7e4SHh6Nr1644ePAg2rZtK/WdOXMmli5diqCgIISEhODKlSv44osvcPnyZVn+KY4xgeyfSfv27VGhQgW89dZbcHd3R3R0NO7cuSPrd+7cOVSpUgW9e/eGq6srbt26hXXr1uGnn37ChQsX4OPjAyD7d/vy5ct45ZVXULlyZSiVShw/fhzTpk3DH3/8gcjISL3ffyLSgyCzsm3bNgFA/PbbbxqP1alTR7Rr165E6pg4caLgr5/clClThK+vr1Cr1RqPTZo0Sfj5+Wl9rLRYtmyZACBOnDih83NWr14t3N3dRUhIiAAgHj9+LHu8S5cuwsfHR6SmpkptGRkZolq1aqJ+/fqyvgDExIkTC1X7+++/LwCI33//XWpbunSpACAOHjwotWVlZYlmzZoJb29vkZaWJrWHhoZqrV8XycnJwtHRUXTp0qVQtRMRmQtmmNLLFDPML7/8IqysrMS8efMEAHHq1KkCn3P69GmRkJAga3vy5IkoV66ceOmllwp8/oMHD4SFhYUYN26crD06OlpkZWUJIfL/Xf7jjz8EAPHxxx9LbSkpKaJatWoiMDBQavvzzz8FADF//nzZ89966y2hUCjEhQsXpLbffvtNABDbtm0rsH5ttm/fLgCI7777rlDPJyIyB8wwpRczjGaG0fU4zO+//y4AiBUrVsiev379egFA7NixQ2r76KOPBADx559/Sm1///23UKlUYvbs2bLnR0VFSe+5vb29GD58eL6vTa1Wi8DAQDFq1Cjh5+cnevTokWffwrx3RETmjBmm9DKlDPPmm28KFxcXcfPmzUI9/9atW0IIIR4/fiwAiNDQUJ2fq23eRwjd80Z4eLjemaGgvLFlyxaN4zCPHj0SLi4uYvDgwQWO7+/vL6pXr65zPURE5oo5pvQypRyTozDHEyZMmCAsLCzE1atXpbakpCRRqVIl0bhxY6nt3r17wsLCQgwdOlT2/C+++EIAED/88EOxjpmVlSXq1q0rWrRoIZKTk3V4N+ROnz4tAIgPPvigwL6TJk0SAMT9+/f13g8R6U63y3ZSqXf79m1MmDABAQEBsLW1hbu7OwYMGCC7DPuGDRswYMAAAECHDh2kW8gcOnQIlStXxuXLl3H48GGpPfdtiWNjYzF16lRUqlQJ1tbW8Pf3x0cffQS1Wi31iYqKgkKhwLJly/Dll1+iWrVqsLa2RrNmzXDq1Cmp34gRI7By5UoAkN3KJoe22/ucO3cO3bt3h5OTExwcHNCpUyeN2xXn3Kbn999/x/Tp06Xb6rz66qs63bJ4xIgRcHBwQHR0NHr27AkHBwdUqFBBqvXixYvo2LEj7O3t4efnp3GmSs6teg4dOiS1tW/fHnXr1sWVK1fQoUMH2NnZoUKFCli6dKnG/nft2oWOHTvK3oscXbp0we3bt3H+/PkCX4ex5JxNFxsbq1P/Z8+eYd68eVi4cGGeZ0/Hx8fD1dUV1tbWUpuFhQU8PDxga2ur9TkpKSlITU3Vp3RERkaiSpUqaNWqldR29OhRlCtXDh07dpTalEolgoOD8eDBAxw+fFhjHCEE4uPjIYTQed8//vgjEhIS8Nprr+lVMxFRWcEMwwxT0jIyMhASEoKQkBBUq1ZN5+c1adJEduV/AHB3d0ebNm3w999/F/h8T09P2NnZaWSlSpUq6XQ3he3bt0OlUmHs2LFSm42NDUaPHo0TJ05IZ2cfPXoUADBo0CDZ8wcNGgQhBLZs2aJ1/ISEBGRmZhZYR2765j8iorKEGYYZpqSVRIbR9ThMfHw8AMDLy0v2/PLlywOArO/27dvRrFkz2d0HatasiU6dOmHr1q2y5/v5+Wn9eeRl06ZNuHTpUoG3xy7se0dEVBYxwzDDlJTY2FiEh4dj7NixqFKlCtLT0/W+Kv+LV3HUh7Z5H0D/vAFkHzPJysrKt48ueWP79u3w8vJCv379pLZy5cohODgYu3fvzvf9+fPPP3H9+nXOJRGRWWOOYY4paYU9nnD06FE0atQIAQEBUpudnR169+6Ns2fP4tq1awCAEydOIDMzU+t8DgBs3ry5WMfct28fLl26hNDQUNja2iI5ObnAzJObPnNEnE8iKhmmd6150urUqVM4fvw4Bg0ahIoVKyIqKgqrV69G+/btceXKFdjZ2aFt27aYMmUKPv/8c8yZMwe1atUCkH2LmbCwMEyePBkODg6YO3cugP8O5icnJ6Ndu3aIiYnBuHHj4Ovri+PHj2P27Nm4f/8+wsLCZLVERkYiISEB48aNg0KhwNKlS9GvXz/cvHkTlpaWGDduHO7du4f9+/drvbXNiy5fvow2bdrAyckJM2bMgKWlJdauXYv27dvj8OHDaNGihaz/5MmT4erqitDQUERFRSEsLAyTJk3Kc9FDbllZWejevTvatm2LpUuXIiIiApMmTYK9vT3mzp2L1157Df369cOaNWswbNgwBAYGatwS6EXPnz/Hyy+/jH79+iE4OBjbt2/HzJkzUa9ePXTv3h0AEBMTg+joaDRu3FjrGE2aNAEA/P7772jUqFGB+9Plw9nOzq7A2y7lJzMzE7GxsUhPT8elS5cwb948ODo6onnz5jo9f/78+fD29sa4cePw/vvva+3Tvn17fPTRR5g/fz6GDx8OhUKByMhInD59WmOyCMgOvqtWrYIQArVq1cK8efMwZMiQfOs4d+4c/v77b+n3PkdaWprWxcY579mZM2fQpUsX2WNVq1ZFYmIi7O3t0bdvX3zyyScak2IvioiIgK2trezADxGROWGG+Q8zTMlkmLCwMDx//hzz5s3Djh07Cj1OjgcPHsDDw0PrY7GxscjIyMCDBw8QFhaG+Ph4dOrUqVD7OXfuHGrUqAEnJydZe072On/+PCpVqiRNGr2YY3JnmBeNHDkSiYmJUKlUaNOmDT7++GM0bdpUo58QAk+fPkVmZiauXbuGWbNmQaVSyQ6WEhGZC2aY/zDDlJ0Mo+txmKZNm8Le3h7z58+Hm5sbAgICcP36dcyYMQPNmjVD586dAWTf/vqvv/7CqFGjNPbfvHlz7Nu3DwkJCXB0dNS7/oSEBMycORNz5syBt7d3vn0N/d4REZkyZpj/MMMUb4Y5duwYUlNT4e/vj6CgIOzatQtqtRqBgYFYuXIlGjZsqPeYuspr3qcwOnTogMTERFhZWaFbt2745JNPUL16dY1+uuSNc+fOoXHjxhonhDdv3hxffvkl/v33X9SrV0/rcyMiIgCAC4GJyKwxx/yHOaZ0H4tJS0uDq6ur1nqA7Hma6tWr6zWfUxxjHjhwAABgbW2Npk2b4syZM7CyssKrr76KVatWwc3NTWN/T58+RVZWFqKjo7Fw4UIA0DrvlZ6ejvj4eKSkpOD06dNYtmwZ/Pz84O/vr9GXiAzIqNcjJoPRdpn2EydOCABi48aNUlthboPw/vvvC3t7e/Hvv//K2mfNmiVUKpWIjo4WQmTfogeAcHd3F8+ePZP67d69WwAQP/74o9SW320Q8MLtffr27SusrKzEjRs3pLZ79+4JR0dH0bZtW6kt5zY9nTt3lt0uYNq0aUKlUonY2Fit+8sxfPhwAUAsWbJEanv+/LmwtbUVCoVCbN68WWq/evWqRp05t1bO/d62a9dO42eQlpYmvL29Rf/+/aW2AwcOaLxHL7KyshJvvvlmvq9BCCH8/PwEgAK/9LmFkjY5v185XwEBAVp/r7S5cOGCUKlUYu/evUIIIUJDQwUA8fjxY1m/xMREERwcLBQKhbQfOzs7sWvXLo0xW7VqJcLCwsTu3bvF6tWrRd26dQUAsWrVqnxreeuttwQAceXKFVn75MmThVKpFFFRUbL2QYMGCQBi0qRJUltYWJiYNGmSiIiIENu3bxchISHCwsJCVK9eXcTFxeW576dPnworKysRHBycb41ERGUZMwwzTI6SyDD3798Xjo6OYu3atUKIwt3mMbcjR44IhUIh5s+fr/XxgIAAqW4HBwcxb948kZWVled4+d2WrE6dOqJjx44a7ZcvXxYAxJo1a4QQQnz//fcCgNi0aZOs35o1awQAUbduXant999/F/379xdff/212L17t/jggw+Eu7u7sLGxEWfPntXY1/3792U/i4oVK4otW7bk+XqIiMoyZhhmmBxlKcPocxzmp59+EuXLl5e9xm7duomEhASpT85tvBcuXKjx/JUrVwoAslta5pbfrbqFEOLtt98WVapUEampqUKI7J9Djx49NPoZ+r0jIjJ1zDDMMDmKO8N8+umn0s+5efPmIiIiQqxatUp4eXkJV1dXce/ePZ3HyskUutaS17zPi/LLG1u2bBEjRowQ33zzjdi5c6eYN2+esLOzEx4eHtLvcg5d84a9vb0YNWqUxr5+/vlnAUD88ssvWmvJzMwUXl5eonnz5vm+HiKiso45hjkmR2k/FtOrVy/h4uIi4uPjZe2BgYECgFi2bJkQQogzZ84IAOL999+X9fvll1+keaXiHLN3797S7/Nrr70mtm/fLubPny8sLCxEq1atZL9jOaytraX3193dXXz++eda34PvvvtO9rNo2rSp+Ouvvwp664ioiHhF4DIi99kcGRkZiI+Ph7+/P1xcXHD27FkMHTq00GNv27YNbdq0gaurK548eSK1d+7cGR9++CGOHDkiOwN14MCBsjNR2rRpAwC4efOm3vvOysrCvn370LdvX1StWlVqL1++PIYMGYJ169YhPj5edmW0sWPHym4l0KZNGyxfvhy3b99G/fr1C9znmDFjpO9dXFykq5oEBwdL7QEBAXBxcdHpNTk4OOD111+Xtq2srNC8eXPZc58+fQoAWs/gyfHi+5+XiIgIpKSkFNgv9/tZGLVr18b+/fuRlJSE48eP48CBA0hMTNTpuVOmTEH37t3RtWvXfPtZW1ujRo0aCAoKQr9+/ZCVlYUvv/wSr7/+Ovbv34+WLVtKfX///XfZc0eNGoUmTZpgzpw5GDFihNar+6rVamzevBmNGjWSzgbMMWbMGKxZswbBwcFYvnw5vLy8sHXrVuzcuRMAZO9xSEiI7Ln9+/dH8+bN8dprr2HVqlWYNWuW1te3fft2pKen8wxuIjJrzDDMMDlKIsPMnDkTVatWlb1XhfXo0SMMGTIEVapUwYwZM7T2CQ8PR3x8PG7evInw8HCkpKQgKytL48ovukhJSZHdpjuHjY2N9DgAvPLKK/Dz88Pbb78NOzs7NGnSBH/88Qfmzp0LCwsL2XvcqlUr2S0ye/fujaCgINSvXx+zZ8/GL7/8ItuXm5sb9u/fj9TUVJw7dw47duzQOf8REZU1zDDMMDnKUobR5zhMuXLl0KhRI0yaNAl16tTB+fPnsXTpUowcORLbtm0D8F8+0SXD6OPff//FZ599hu+++07r2LkZ8r0jIioLmGGYYXIUd4bJOV6gUChw8OBBODg4AAAaNWokXRV40aJFhRo7P/nN++gjODhY9rPs27cvunXrhrZt22Lx4sVYs2aN9JiueUPXYzsvOnjwIB4+fIg5c+YU5qUQEZUZzDHMMTlK+7GYN998Ez/++CMGDhyIxYsXw97eHqtWrcLp06cB/PeZ37hxY7Ro0QIfffQRKlSogA4dOuDvv//Gm2++CUtLS9lrLI4xc/Jas2bN8O233wLIXutiZ2eH2bNn4+DBg9Jdn3L873//Q2pqKv7++298++23SEpK0voedOjQAfv370dsbCwOHjyICxcu5NmXiAyHC4HLiJSUFHzwwQcIDw9HTEwMhBDSY3FxcUUa+9q1a/jrr79Qrlw5rY8/evRItu3r6yvbzvkgf/78ud77fvz4MZKTkxEQEKDxWK1ataBWq3Hnzh3UqVPHIPu3sbHReJ3Ozs6oWLGiLEjltOsyprbnurq64q+//tLom/vnpu2xF8fR5qWXXiqwjy6ePXuG9PR0advW1hbOzs7StpOTk/Sh36dPH0RGRqJPnz44e/YsGjRokOe4W7ZswfHjx3Hp0qUCa5g0aRJOnjyJs2fPSgtmgoODUadOHYSEhOCPP/7I87lWVlaYNGkSxo8fjzNnzqB169YafQ4fPoyYmBhMmzZN47H69esjMjIS48ePl95Tb29vhIWF4c0335QOWuVlyJAheOutt3DgwIE8FwJHRETAzc1Nuh0GEZE5YoZhhslR3Bnm5MmT2LRpEw4ePFiohbi5JSUloWfPnkhISMCxY8fyzAWBgYHS94MGDZImoJYtW6b3Pm1tbaVbOuWWmpoqPQ5k/y78/PPPCA4ORv/+/QFkL75ZunQpFi9eXGCG8ff3R58+fbBjxw5kZWVBpVJJj1lZWUn5r2fPnujUqRNeeukleHp6omfPnnq/JiIiU8YMwwyToyxlGF2Pw9y8eRMdOnTAxo0bpbzRp08fVK5cGSNGjMD//vc/dO/eXconumQYfYSEhKBVq1bSvvNiyPeOiKisYIZhhslR3Bkm5zO+V69esszRsmVLVKlSBcePHzfI/l+U37xPUbVu3RotWrSQbqMN6Jc3dD2286KIiAioVCoMHDiwCNUTEZk+5hjmmByl/VhM9+7d8cUXX2DWrFlo3LgxgOy5l8WLF2PGjBmybPT9999j4MCBGDVqFABApVJh+vTpOHz4MP75559iHTMnewwePFhW/5AhQzB79mwcP35cYyFwhw4dpHr69OmDunXrwsHBAZMmTZL18/LygpeXFwAgKCgIS5YsQZcuXXDt2jV4e3vr+5YSkY64ELiMmDx5MsLDwzF16lQEBgbC2dkZCoUCgwYNglqtLtLYarUaXbp0yfNKZzVq1JBt514skFt+H+iGVJT95/Xc4hgz93Pd3d0B5B/MYmNj4eHhUeD+Hj9+jKysrAL7OTg45LsQpF+/fjh8+LC0PXz4cGzYsCHf/kOHDsXmzZvzXQj8zjvvYMCAAbCyskJUVBSA7NcGAHfu3EF6ejp8fHyQnp6Or7/+GjNmzJCFK0tLS3Tv3h0rVqxAeno6rKys8txXpUqVAGQHOG0iIiKgVCo1gk2OoKAg9O7dGxcuXEBWVhYaN26MQ4cOAdD8vc9r/3ntOzo6GkePHsXYsWNhaWlZ4FhERGUVM4xh9s8M85+8MsyMGTPQpk0bVKlSRcogOWeW379/H9HR0RoHz7RJT09Hv3798Ndff2Hv3r2oW7dugc8Bsg96dezYEREREYVaCFy+fHnExMRotN+/fx8A4OPjI7XVqVMHly5dwpUrV/D8+XPUrl0btra2mDZtGtq1a1fgvipVqoT09HQkJSXJrjLwolatWqF8+fKIiIjgQmAiMjvMMIbZPzPMf4ydYfQ5DrNhwwakpqZqfP737t0bQPZdm7p37w43NzdYW1tLeSU3bRlGF7/++it++eUX7NixQ3o/ACAzMxMpKSmIioqCm5sbnJycDPbeERGVJcwwhtk/M8x/8sowOZ/xOQtAcvP09CzUQildFDTvU1SVKlWSLaDRJ2+UL19e71yUkpKCnTt3onPnzlrfSyIic8IcY5j9M8f8pziPxUyaNAkjR47EX3/9BSsrKzRs2BBff/01APnvU4UKFXDs2DFcu3YNDx48QPXq1eHt7Q0fHx+N3ztDj5lXXvP09ARQ8MLyatWqoVGjRoiIiNBYCPyioKAgzJ07F7t378a4cePy7UtEhceFwGXE9u3bMXz4cHzyySdSW2pqqrTAMkd+Z8/k9Vi1atWQmJiocaZHUehyFg+QfZtBOzs72R/VOa5evQqlUikt9jRlNWvWBADcunVL6+MxMTFIT0/X6TZGzZo1w+3btwvsFxoaigULFuT5+CeffCL7YC9oYiYtLQ1qtbrAs+3u3LmDyMhIREZGajzWuHFjNGjQAOfPn8fTp0+RmZmpNcBlZGRArVYXGO5ybjWh7cy9tLQ0fP/992jfvn2+r83KygrNmjWTtnPO9C7o34MQAlFRUWjUqJHWx7/77jsIIWS3ECEiMkfMMKbNlDJMdHQ0bt++jSpVqmg8p3fv3nB2dtb4vXuRWq3GsGHDcPDgQWzdulWnRbW5paSkFPrKBA0bNsRvv/2mcQuwnCvzNWzYUNZfoVDIrhCwZ88eqNVqnf493Lx5EzY2NgVePRjI/vda1KstEBGZImYY08YMo5lh9DkO8/DhQwghNPpmZGQAyF6UCwBKpRL16tWTblOZ2x9//IGqVavC0dEx39pfFB0dDSB7su5FMTExqFKlCpYvX46pU6ca5L0jIiprmGFMmyllmCZNmkg1vejevXvSazEkXed9iuLmzZuyOSd98kbDhg1x9OhRqNVq2YlXf/zxB+zs7LRegOaHH35AQkIC55KIiMAcY+pMKccY6niCvb297M6RBw4cgK2trdYrGlevXh3Vq1cHAFy5cgX379/HiBEjinXMJk2aYN26dRp57d69ewC0r7N5UUpKitY7HmjrBxT96t1ElD8uBC4jVCqVxpk4X3zxhcYBeXt7ewDQ+qFkb2+vtT04OBgLFizA3r170a1bN9ljsbGxcHBwgIWFfr9KuetwcXHJs59KpULXrl2xe/duREVFoXLlygCyJxwiIyPRunXrfK9Slpf79+8jLi4O1apVKxVXY61QoQIqVaqkdWIEAM6cOQMg+6prBYmIiJA+RPNTtWrVfB/POUjzotjYWNjb22u8b1999RUAoGnTplJbcnIyoqOj4eHhIZ25tXPnTo0xN2/ejC1btmDjxo2oWLEigOyzjFxcXLBz504sXLhQuvJvYmIifvzxR9SsWVO6VcHjx481QkhCQgLCwsLg4eGh9bXs2bMHsbGxeh08uXbtGtasWYOePXvKDsho2//q1avx+PFjvPzyy1rHioyMhK+vL1q3bq3z/qlsqFy5stY/TCZMmICVK1dqtF++fBnvvvsuzpw5g9u3b0sTmrklJCRg/vz52LlzJx49eoRGjRrhs88+ky1iJyqtmGH0wwxT+Azz5ZdfIjk5Wdb266+/4osvvsCyZctkE1BxcXG4f/8+ypcvD2dnZ6l98uTJ2LJlC9auXat18UmOR48eSWdM54iKisLBgwdlWUkfQUFBWLZsGb788ku8/fbbALInuMLDw9GiRYt8DwSmpKRg/vz5KF++vOyKONoyzIULF/DDDz+ge/fu0qRUUlISFAoF7OzsZH2///57PH/+vNCviUzbhx9+iNmzZyMkJARhYWF59gsLC8Pq1aulvwuCgoLwwQcfwMbGRuqzcuVKfPzxx3jw4AEaNGiAL774As2bNy+BV0FUeMww+mGGKf0ZRp/jMDVq1IAQAlu3bpVNIH333XcAIDspOigoCLNmzcLp06elzPDPP//g119/lTKNPjp27Kj12NLYsWPh5+eHuXPnol69egD0e+/IfOiSYTZs2ICRI0fK2qytraVbt79o/PjxWLt2rdZjNkSlDTOMfphhCp9hAgIC0KBBA+zevRtPnjyR5oj27duHO3fuYPLkyVLfvDKMvgoz75MXbcdM9uzZgzNnzmDKlClSmz55IygoCNu3b8eOHTsQFBQEIPvqgtu2bUOvXr1gbW2tUUdkZCTs7Ozw6quvFvk1kekpzNzPoUOHMH36dFy+fBmVKlXCvHnztC4kA3Q/tkNUWjDH6Ic5xrjHYl50/Phx7NixA2+++Wa+/dRqNWbMmAE7OzuMHz8+3/qLOmafPn0QEhKC8PBwjBgxQpoTyln706VLFwDZJ3wnJCTA1dVVNu6ff/6JixcvYsiQIVLbkydP4O7urrEQXtt6Iiq7jhw5go8//hhnzpzB/fv3sXPnTvTt21d6XAiB0NBQrFu3DrGxsXjppZewevVqaeG6NgsWLMB7770nawsICMDVq1el7QcPHuCdd97B/v37kZCQgICAAMydOxf9+/c3+GssrbgQuIzo2bMnNm3aBGdnZ9SuXRsnTpzAgQMHpMvr52jYsCFUKhU++ugjxMXFwdraGh07doSnpyeaNGmC1atXY9GiRfD394enpyc6duyId955Bz/88AN69uyJESNGoEmTJkhKSsLFixexfft2REVF6XR5/txyPlCnTJmCbt26QaVSYdCgQVr7Llq0CPv370fr1q0xYcIEWFhYYO3atUhLS8PSpUsL9X7Nnj0b33zzDW7duiUFKWPr06cPdu7cCSGExofi/v374evrm+fVZXPTdqaPIR06dAhTpkxBUFAQqlevjvT0dBw9ehQ7duxA06ZN8frrr0t9//zzT3To0EF2plXu/9xznD9/HgDQvXt36XdJpVLh7bffxrx589CyZUsMGzYMWVlZ+Prrr3H37l18++230vNXrlyJXbt2oVevXvD19cX9+/exfv16REdHY9OmTdLkVW4RERGwtrbO9z/82rVrY8CAAfD19cWtW7ewevVquLm5Yc2aNbJ+fn5+GDhwIOrVqwcbGxscO3YMmzdvRsOGDbXe1uDSpUv466+/MGvWLJ3PBKSy49SpU7I/SC9duoQuXbpgwIABWvsnJyejatWqGDBgAKZNm6a1z5gxY3Dp0iVs2rQJPj4++Pbbb9G5c2dcuXIFFSpUKJbXQWQozDD6YYYpvK5du2q05Rzwa9eunezgw86dOzFy5Ejp4AeQvZhx1apVCAwMhJ2dnSyLAMCrr74qHdirV68eOnXqhIYNG8LV1RXXrl3D119/jYyMDHz44Yey5x05cgRHjhwBkD3JlJSUhEWLFgEA2rZti7Zt2wIAWrRogQEDBmD27Nl49OgR/P398c033yAqKkq69VOO4OBg+Pj4oHbt2oiPj8f69etx8+ZN/Pzzz7Kr7g0cOBC2trZo1aoVPD09ceXKFXz55Zews7OT1Xnt2jV07twZAwcORM2aNaFUKnH69Gl8++23qFy5MkJCQnT+OVDZcOrUKaxduxb169fPt19kZCRmzZqF9evXo1WrVvj3338xYsQIKBQKfPrppwCALVu2YPr06VizZg1atGiBsLAwdOvWDf/884/Ggnqi0oQZRj/MMIVXUhlGn+MwI0aMwLJlyzBu3DicO3cOderUwdmzZ/HVV1+hTp06soUqEyZMwLp169CjRw+8/fbbsLS0xKeffgovLy+89dZbslp+/PFHXLhwAUD21YX/+usvKRf17t0b9evXh6+vr9bbb06dOhVeXl6y4076vHdkHnTNMADg5OQkuyJXXsfwdu7ciZMnTxbblSeJDI0ZRj/MMEWzfPlydOnSBa1bt8a4ceMQFxeHTz/9FDVq1MCbb74p9dOWYQBg06ZNuH37trQQ58iRI1I2GDp0KPz8/GT702XeR5e8AWQvQmrUqBGaNm0KZ2dnnD17FuvXr0elSpUwZ84caTx98kZQUBBatmyJkSNH4sqVK/Dw8MCqVauQlZWlsagBAJ49e4b//e9/6N+/v053baKyR9+5n1u3bqFHjx4YP348IiIicPDgQYwZMwbly5fXWNioTy4iKi2YY/TDHFN4RT0Wc/v2bQQHB6N3797w9vbG5cuXsWbNGtSvXx9LliyRjRsSEoLU1FQ0bNgQGRkZiIyMxJ9//olvvvlGdvyjOMb09vbG3Llz8e677+Lll19G3759ceHCBaxbtw6DBw+WTjxJTExEpUqVMHDgQNSpUwf29va4ePEiwsPD4ezsjPnz50tjfvvtt1izZg369u2LqlWrIiEhAXv37sX+/fvRq1cvdOzYsXA/FDIpSUlJaNCgAUaNGqX1ogRLly7F559/jm+++QZVqlTB/Pnz0a1bN1y5ckV2EZkX1alTR7qLOwCNEzSGDRuG2NhY/PDDD/Dw8EBkZCSCg4Nx+vRpnf5vKRMElQnPnz8XI0eOFB4eHsLBwUF069ZNXL16Vfj5+Ynhw4fL+q5bt05UrVpVqFQqAUD89ttvQgghHjx4IHr06CEcHR0FANGuXTvpOQkJCWL27NnC399fWFlZCQ8PD9GqVSuxbNkykZ6eLoQQ4tatWwKA+PjjjzXqAyBCQ0Ol7czMTDF58mRRrlw5oVAoRO5fxRf7CiHE2bNnRbdu3YSDg4Ows7MTHTp0EMePH5f1CQ8PFwDEqVOnZO2//fab7HUKIcTw4cMFAHHr1i1Zm729vUbt7dq1E3Xq1NFo9/PzEz169Mh3P3k9d/jw4cLPz0/jNQIQR48elbVnZWWJ8uXLi3nz5mmMYwzXr18Xw4YNE1WrVhW2trbCxsZG1KlTR4SGhorExERZ35z35MWf54tCQ0MFAPH48WONxyIiIkTz5s2Fi4uLsLW1FS1atBDbt2+X9dm3b5/o0qWL8Pb2FpaWlsLFxUV07dpVHDx4UOv+4uLihI2NjejXr1++dQ0aNEhUqlRJWFlZCR8fHzF+/Hjx8OFDjX5jxowRtWvXFo6OjsLS0lL4+/uLmTNnivj4eK3jzpo1SwAQf/31V777J/MQEhIiqlWrJtRqdYF9/fz8xPLly2VtycnJQqVSiZ9++knW3rhxYzF37lxDlkpULJhhmGGMKa/3Pqc9PDxcast57/P6yv0zCQ0NFU2bNhWurq7CwsJC+Pj4iEGDBmn97M/JQdq+Xvx9SklJEW+//bbw9vYW1tbWolmzZuKXX37RGPOjjz4SNWvWFDY2NsLV1VX07t1bnDt3TqPfZ599Jpo3by7c3NyEhYWFKF++vHj99dfFtWvXZP0eP34sxo4dK2rWrCns7e2FlZWVqF69upg6darW/EZlW0JCgqhevbrYv3+/aNeunQgJCcmz78SJE0XHjh1lbdOnTxcvvfSStN28eXMxceJEaTsrK0v4+PiIDz74wOC1ExkSMwwzjDEVV4YRQrfjMEIIcffuXTFq1ChRpUoVYWVlJcqXLy/eeOMNrdngzp07IigoSDg5OQkHBwfRs2dPjbxRUK25X5M2L/5+5CWv947KPn0yTHh4uHB2di5wzLt374oKFSqIS5cuaT1mQ1QaMcMww5S0/fv3i5YtWwobGxvh5uYmhg4dKu7fvy/roy3DCJH9vuSVDXK/f0LoPu+ja96YO3euaNiwoXB2dhaWlpbC19dXvPnmm+LBgwcFvub88sazZ8/E6NGjhbu7u7CzsxPt2rXLM5esWbNGABA//PBDgfuksqcwcz8zZszQ+L9k4MCBolu3brI2fXIRUWnCHMMcY0z6HIt59uyZ6NOnj/D29hZWVlaiSpUqea4fCQ8PFw0aNBD29vbC0dFRdOrUSfz6668a/YpjTCGEUKvV4osvvhA1atQQlpaWolKlSmLevHnS77wQQqSlpYmQkBBRv3594eTkJCwtLYWfn58YPXq0xnGlU6dOiQEDBghfX19hbW0t7O3tRePGjcWnn34qMjIy8nuLqYwCIHbu3Cltq9Vq4e3tLft/NDY2VlhbW4vvvvsuz3FCQ0NFgwYN8t2Xvb292Lhxo6zNzc1NrFu3rlC1myKFEC9cO5+IjKZTp07w8fHBpk2bpLZdu3ZhyJAhuHHjBsqXL2/E6ojKhtTUVKSnpxt0TKHlrEVra2utt/LKLT09HT4+Ppg+fbrsKgJ5qVy5MqZOnSq7zWRCQgKcnJxw4MABdOrUSWpv3bo1LCwscOjQIb1eCxFRYTDDEBW/0pJhhg8fDjc3Nyxfvhzt27dHw4YN87x9ZGRkJCZMmIB9+/ahefPmuHnzJnr06IGhQ4dizpw5SE9Ph52dHbZv3y67guPw4cMRGxuL3bt3G+JlEhHliRmGqPgVR4YB9M8x+mSYDRs2YMyYMahQoQLUajUaN26MJUuWoE6dOlIftVqNzp07S7dS1XbMhoiouDDDEBU/Y2eYwsz9tG3bFo0bN5ZlnPDwcEydOhVxcXFSmz65iIjI0JhjiIpfaZlPArLvsLRz505pDujmzZuoVq0azp07h4YNG0r92rVrh4YNG+Kzzz7TOs6CBQvw8ccfw9nZGTY2NggMDMQHH3wgu8p1165dYWVlhY0bN8LFxQVbt27F6NGjceHCBfj7+xfuhZsYi4K7EFFJWbJkCdq0aYNFixZJtzT66KOPMGnSJAYeIgNITU2FraMbkJli0HEdHByQmJgoawsNDcWCBQvyfd6uXbsQGxsru92ZvhwdHREYGIj3338ftWrVgpeXF7777jucOHHCbMIMERkfMwxR8SotGWbz5s04e/YsTp06pdP4Q4YMwZMnT9C6dWsIIZCZmYnx48dLJ0A9efIEWVlZ8PLykj3Py8sLV69e1f8FERHpiRmGqHgVV4YB9Msx+maYgIAArF+/HvXr10dcXByWLVuGVq1a4fLly6hYsSKA7P8rLCwsMGXKlCK/FiIifTHDEBWv0pBhCjP38+DBA63HWOLj45GSkgJbW1u9cxERkaExxxAVr9Iyn5SXBw8eAIDWzJLzmDYtWrTAhg0bEBAQgPv37+O9995DmzZtcOnSJTg6OgIAtm7dioEDB8Ld3R0WFhaws7PDzp07zWrdDBcCE5UiLVq00Dgr48SJE0aqhqjsSU9PBzJTYFE7GFBZGmbQrAwkXtmKO3fuwMnJSWou6MwnAPj666/RvXt3+Pj4FKmETZs2YdSoUahQoQJUKhUaN26MwYMH48yZM0Ual4hIV8wwRMWrNGSYO3fuICQkBPv374eNjY1Ouzh06BCWLFmCVatWoUWLFrh+/TpCQkLw/vvvY/78+QZ5GURERcEMQ1S8iiXDAHrlmMJkmMDAQAQGBkrbrVq1Qq1atbB27Vq8//77OHPmDD777DOcPXtW42o4REQlgRmGqHiVhgwDGH7upzC5iIjI0JhjiIpXaZhPKg7du3eXvq9fvz5atGgBPz8/6aq/ADB//nzExsbiwIED8PDwwK5duxAcHIyjR4+iXr16JVarMXEhMBERmR2FpQ0UKiuDjCWUKgCAk5OTLPQU5Pbt2zhw4AB27NhR5BqqVauGw4cPIykpCfHx8ShfvjwGDhyIqlWrFnlsIiIiKj2MmWHOnDmDR48eoXHjxlJbVlYWjhw5ghUrViAtLQ0qlUr2nPnz52Po0KEYM2YMAKBevXpISkrC2LFjMXfuXHh4eEClUuHhw4ey5z18+BDe3t5FfYlERERUShgywwD65ZjCZJgXWVpaolGjRrh+/ToA4OjRo3j06JHs9pNZWVl46623EBYWhqioqEK+MiIiIipNjJlhAP3nfry9vbUeY3FycoKtra1BchERERGZhtKwJkabnLmfhw8fyq4C/vDhQzRs2FDncVxcXFCjRg3pWM2NGzewYsUKXLp0CXXq1AEANGjQAEePHsXKlSuxZs2aItVtKrgQmIiIzI5CqYJCaaCDGaJw44SHh8PT0xM9evQwTB0A7O3tYW9vj+fPn2Pv3r1YunSpwcYmIiIi4zNmhunUqRMuXrwoaxs5ciRq1qyJmTNnap0oSk5OhlKplLXl9BNCwMrKCk2aNMHBgwfRt29fAIBarcbBgwcxadIkveojIiKi0sugGQbQK8cUJsO8KCsrCxcvXsQrr7wCABg6dCg6d+4s69OtWzcMHToUI0eO1Lk2IiIiKt2MmWFy03XuJzAwEHv27JG17d+/X7rTgSFyEREREZmG0rAmRpsqVarA29sbBw8elBb+xsfH448//sCbb76p8ziJiYm4ceMGhg4dCiB7PgqA1jkptVptmOJNABcCExERlTC1Wo3w8HAMHz4cFhbyj+Jhw4ahQoUK+OCDDwBk37rhypUr0vcxMTE4f/48HBwc4O/vDwDYu3cvhBAICAjA9evX8c4776BmzZqcfCIiIiKDcXR0RN26dWVt9vb2cHd3l9pfzDG9evXCp59+ikaNGqFFixa4fv065s+fj169ekmTS9OnT8fw4cPRtGlTNG/eHGFhYUhKSmKOISIiIoMoTIZZuHAhWrZsCX9/f8TGxuLjjz/G7du3pbscuLu7w93dXTampaUlvL29ERAQUAKvioiIiMxBQXM/s2fPRkxMDDZu3AgAGD9+PFasWIEZM2Zg1KhR+PXXX7F161b8/PPPAHTLRURERERFlZiYKF2pFwBu3bqF8+fPw83NDb6+vpg6dSoWLVqE6tWro0qVKpg/fz58fHykC8YA2Scwvfrqq9JFY95++2306tULfn5+uHfvHkJDQ6FSqTB48GAAQM2aNeHv749x48Zh2bJlcHd3x65du7B//3789NNPJfr6jYkLgYmIyOwY++ynAwcOIDo6GqNGjdJ4LDo6WnaW0r1799CoUSNpe9myZVi2bBnatWuHQ4cOAQDi4uIwe/Zs3L17F25ubujfvz8WL14MS0tL/V8PERERlVrGzjAFeTHHzJs3DwqFAvPmzUNMTAzKlSuHXr16YfHixVKfgQMH4vHjx3j33Xfx4MEDNGzYEL/88gu8vLwMXh8REREZR2m5ml5eXswwz58/xxtvvIEHDx7A1dUVTZo0wfHjx1G7dm2D7peIiIhKN2NnmILmfu7fv4/o6Gipf5UqVfDzzz9j2rRp+Oyzz1CxYkV89dVX6Natm+FeAxEREZkEY84nnT59Gh06dJC2p0+fDgAYPnw4NmzYgBkzZiApKQljx45FbGwsWrdujV9++QU2NjbSc27cuIEnT55I23fv3sXgwYPx9OlTlCtXDq1bt8bJkydRrlw5ANknaO/ZswezZs1Cr169kJiYCH9/f3zzzTfSHZ7MgUIIIYxdBFFuCoUCoaGhWLBggbFLKRW2bt2K8ePHIzo6Gg4ODsjIyEDVqlUxe/ZsTJgwwdjlEZmU+Ph4ODs7w7rJGChUVgYZU2SlI+3MV4iLi4OTk5NBxiSisoXZRo7Zhkh/zDBEVNyYV+SYV4gMozgyDMAcQ0T/YYaRY4YhMgxmGCIq7ZiB5JiBiP7D+STzpiy4C5UlV65cwYIFCxAVFaXx2KpVq7Bhw4YSqWPPnj0MJTrIyspCaGgoJk+eDAcHBwDZZzFMnz4dixcvRmpqaonXtGXLFrz++uuoXr06FAoF2rdvr7XfiBEjoFAo8vyKiYkpcF8HDhxAhw4d4OHhARcXFzRv3hybNm3S6BcXF4cZM2agevXqsLW1hZ+fH0aPHi07CxYAduzYgYEDB6Jq1aqws7NDQEAA3nrrLcTGxmqMmZiYiKlTp6JixYqwtrZGrVq1sHr1ao1+GzZsyPM1PnjwQKN/QkICZsyYgSpVqsDa2hoVKlRAUFAQkpOTC3w/yHAUCpV0BlSRvxSGv5oeEemO2ca0mHK2AYBr165h0KBBqFixIuzs7FCzZk0sXLhQp8/xBQsWaM0Luc9uze3hw4cYN24cKlSoABsbG1SuXBmjR4/W6BcTE4Pg4GC4uLjAyckJffr0wc2bNzX65ZVXPvzwQ1m/ypUr59m3evXqBb5OKl7MMESmiXnFtJhyXjHEsZjcunTpAoVCId2CL7fVq1djwIAB8PX1hUKhwIgRI7SOceTIEfTu3RuVKlWCjY0NvL298fLLL+P333/Pd9+xsbHw9PSEQqHA9u3btfY5e/YsevfuDTc3N9jZ2aFu3br4/PPPizQmFQ+DZhjmGKISwwxjWsw5w+hzLOPhw4cYOXIkPD09YWtri8aNG2Pbtm1ax9V1jiq3Y8eOSfvOfQWzF9+XwMBA2Nvbw8XFBa1atcKvv/4q66PrvBcVL2YYIvPEDGRaTDkD5dD3+EYOXeedUlJSMHr0aNStWxfOzs5wcHBAgwYN8NlnnyEjI0Pr2AcOHEDHjh3h7OwMR0dHNGnSBFu2bNH5PSDj43ySebIwdgFUsq5cuYL33nsP7du3R+XKlWWPrVq1Ch4eHnkeuDekPXv2YOXKlVqDS0pKCiws+KsJAD/++CP++ecfjB07VtY+cuRIzJo1C5GRkRg1alSJ1rR69WqcOXMGzZo1w9OnT/PsN27cOHTu3FnWJoTA+PHjUblyZVSoUCHf/fzwww/o27cvAgMDpQCzdetWDBs2DE+ePMG0adMAAGq1Gl26dMGVK1cwYcIE1KhRA9evX8eqVauwd+9e/P3333B0dAQAjB07Fj4+Pnj99dfh6+uLixcvYsWKFdizZw/Onj0LW1tbANlhsVu3bjh9+jQmTpyI6tWrY+/evZgwYQKeP3+OOXPmaNS7cOFCVKlSRdbm4uIi246Li0O7du1w9+5djB07Fv7+/nj8+DGOHj2KtLQ02NnZ5fuekOEoVEooVIa6DQLPqSEyJmYb02LK2ebOnTto3rw5nJ2dMWnSJLi5ueHEiRMIDQ3FmTNnsHv3bp33l3MwCgBUWj6P7ty5g5deegkAMH78eFSoUAH37t3Dn3/+KeuXmJiIDh06IC4uDnPmzIGlpSWWL1+Odu3a4fz583B3d5f179KlC4YNGyZra9SokWw7LCwMiYmJsrbbt29j3rx56Nq1q06vkYoPMwyRaWJeMS2mnFeKeiwmtx07duDEiRN5Pv7RRx8hISEBzZs3x/379/Ps9++//0KpVGL8+PHw9vbG8+fP8e2336Jt27b4+eef8fLLL2t93rvvvpvvyVb79u1Dr1690KhRI8yfPx8ODg64ceMG7t69m+dzChqTio9BMwzAHENUQphhTIs5Zxhdj2XEx8ejdevWePjwIUJCQuDt7Y2tW7ciODgYERERGDJkiNRX1zmq3NRqNSZPngx7e3skJSVprXXBggVYuHAhgoKCMGLECGRkZODSpUuyxc76zHtR8WKGITJPzECmxZQzEFC44xva9pffvFNKSgouX76MV155BZUrV4ZSqcTx48cxbdo0/PHHH4iMjJT1Dw8Px+jRo9GlSxcsWbIEKpUK//zzD+7cuaNzTWR8nE8yT/xkoFInr6uimaPw8HC89NJLGgc5XFxc0LVrV2zYsKHEQ8umTZtQoUIFKJVK1K1bN89+gYGBCAwMlLUdO3YMycnJeO211wrcz4oVK1C+fHn8+uuvsLa2BpB9MKhmzZrYsGGDdJDl5MmTOHXqFFasWIGJEydKzw8ICMCoUaNw4MABvPrqqwCA7du3a5xt1aRJEwwfPhwREREYM2YMgOzJruPHj+Prr7+W3t8333wTQUFBeP/99zFmzBh4enrKxunevTuaNm2a72uaPXs2bt++jbNnz8oWDc+cObPA94OIiEwXs81/TDnbbNq0CbGxsTh27Bjq1KkDIPskI7VajY0bN+L58+dwdXUtcH9BQUHw8PDIt8+4ceNgYWGBU6dOaSzmzW3VqlW4du0a/vzzTzRr1gxAdiapW7cuPvnkEyxZskTWv0aNGnj99dfz3Xffvn012hYtWgQAOmU4IiIyTcwr/zHlvFLUYzE5UlNT8dZbb2HmzJl49913tfY5fPiwdDXg3JNNLxozZox0vCXHhAkTULVqVYSFhWldCHzp0iWsXr0a7777rtb9x8fHY9iwYejRowe2b98OpbLgyYiCxiQiItPEDPMfc84wuh7LWLt2La5fv46DBw+iY8eOALLnflq2bIm33noLQUFBsLLKvn2yrnNUuX355Ze4c+cOxowZg88++0zj8ZMnT2LhwoX45JNPtD4/dz9d572IiMg8MQP9x5QzUGGOb2hT0LyTm5sbTp48KWsbP348nJ2dsWLFCnz66afw9vYGAERFRWHixImYPHmy1jxDRKUbl2yXEbdv38aECRMQEBAAW1tbuLu7Y8CAAbLbFWzYsAEDBgwAAHTo0EG6LPyhQ4dQuXJlXL58GYcPH5bacy+YjI2NxdSpU1GpUiVYW1vD398fH330EdRqtdQnKioKCoUCy5Ytw5dffolq1arB2toazZo1w6lTp6R+I0aMwMqVKwHIb1GcQ6FQaJzVdO7cOXTv3h1OTk5wcHBAp06dND6oNmzYAIVCgd9//x3Tp09HuXLlYG9vj1dffRWPHz8u8D0cMWIEHBwcEB0djZ49e8LBwQEVKlSQar148SI6duwIe3t7+Pn5aZwV8+zZM7z99tuoV68eHBwc4OTkhO7du+PChQuyfsOHD4eNjQ3+/vtvWXu3bt3g6uqKe/fuAciedPnll180zoLO0aVLFxw7dgzPnj0r8LUZUqVKlQodQCIjI6FQKGRnVeclPj4erq6u0gEWALCwsICHh4d05d6cfgDg5eUle3758uUBQNZX2y0Xcg6W5P55HD16FAAwaNAgWd9BgwYhNTU1zyv+JSQkICsrS+tjsbGxCA8Px9ixY1GlShWkp6cjLS1Na18qfkqlyqBfRGR4zDbMNiVF12yTX+ZQKpXSRFFBhBCIj4+HEELr41evXsX//vc/vPPOO3B3d0dqamqet2bavn07mjVrJi0CBoCaNWuiU6dO2Lp1q9bnpKSk6H0rrMjISFSpUgWtWrXS63lkeMwwRKUL8wrzSkkpqWMxOZYuXQq1Wo233347zz5+fn6y3yF92NnZoVy5coiNjdX6eEhICF599VW0adNG6+ORkZF4+PAhFi9eDKVSiaSkJNm/i8KMScXL0BmGOYaoaJhhmGFKSklnmBef/+KxjKNHj6JcuXLSImAAUCqVCA4OxoMHD3D48GGpXdc5qhzPnj3DvHnzsHDhQo27ReYICwuDt7c3QkJCIITQuIpx7n0Dus17UfFihiEqW5iBmIFKiq4ZqDDHN7QpaN4pLzlXvM59fGbNmjXIysrCwoULAWTfmVLfcal0YIYxT7wicBlx6tQpHD9+HIMGDULFihURFRWF1atXo3379rhy5Qrs7OzQtm1bTJkyBZ9//jnmzJmDWrVqAQBq1aqFsLAwTJ48GQ4ODpg7dy6A//7ATE5ORrt27RATE4Nx48bB19cXx48fx+zZs3H//n2EhYXJaomMjERCQgLGjRsHhUKBpUuXol+/frh58yYsLS0xbtw43Lt3D/v378emTZsKfG2XL19GmzZt4OTkhBkzZsDS0hJr165F+/btcfjwYbRo0ULWf/LkyXB1dUVoaCiioqIQFhaGSZMmYcuWLQXuKysrC927d0fbtm2xdOlSREREYNKkSbC3t8fcuXPx2muvoV+/flizZg2GDRuGwMBA6cquN2/exK5duzBgwABUqVIFDx8+xNq1a9GuXTtcuXIFPj4+AIDPPvsMv/76K4YPH44TJ05ApVJh7dq12LdvHzZt2iT1O3PmDNLT09G4cWOttTZp0gRCCBw/fhw9e/bM93U9efKkwNcOAI6OjrKDGoaUkZGBrVu3olWrVhq30NCmffv2+OijjzB//nwMHz4cCoUCkZGROH36tGxhS9OmTWFvb4/58+fDzc0NAQEBuH79OmbMmIFmzZrlGfpyPHjwAABkZ0ilpaVBpVJpLOixs7MDkP2zeeONN2SPdejQAYmJibCyskK3bt3wySefoHr16tLjx44dQ2pqKvz9/REUFIRdu3ZBrVYjMDAQK1euRMOGDQt8T4iIzAmzzX+YbTQZI9vkZJPRo0fjvffeg7u7O44fP47Vq1djypQpsLe312mcqlWrIjExEfb29ujbty8++eQT2cTOgQMHAGT/vnbq1Am//vorVCoVunTpgtWrV0s5Sq1W46+//tJ6Jnvz5s2xb98+JCQkyG4VuWHDBqxatQpCCNSqVQvz5s0rcELt3Llz+Pvvv6V/R0RE9B/mlf8wr2gyxWMxABAdHY0PP/wQ69evN+gik/j4eKSnp+PJkyfYuHEjLl26hDlz5mj027ZtG44fP46///5bNhmb24EDB+Dk5ISYmBj07dsX//77L+zt7TF06FAsX75c48pIuoxJRGROmGH+wwyjyVQzTG55HctIS0vTmm9yz/106dIFgO5zVDnmz58Pb29vjBs3Du+//77Wug4ePIhWrVrh888/x6JFi/D06VN4e3tj7ty5mDRpktSvqPNeRESkHTPQf5iBNBkjA+l7fCMvBc075UhPT0d8fDxSUlJw+vRpLFu2DH5+fvD395fVVLNmTezZswfvvPMOYmJi4OrqiokTJ+K9994r9EleRFRCBJUJycnJGm0nTpwQAMTGjRultm3btgkA4rffftPoX6dOHdGuXTuN9vfff1/Y29uLf//9V9Y+a9YsoVKpRHR0tBBCiFu3bgkAwt3dXTx79kzqt3v3bgFA/Pjjj1LbxIkTRV6/fgBEaGiotN23b19hZWUlbty4IbXdu3dPODo6irZt20pt4eHhAoDo3LmzUKvVUvu0adOESqUSsbGxWveXY/jw4QKAWLJkidT2/PlzYWtrKxQKhdi8ebPUfvXqVY06U1NTRVZWlmzMW7duCWtra7Fw4UJZ+969ewUAsWjRInHz5k3h4OAg+vbtK+vz1VdfCQDi4sWLWuu9d++eACA++uijfF+XENnvqS5f4eHhBY6VW16/M9r8+OOPAoBYtWqVTv0TExNFcHCwUCgUUn12dnZi165dGn1/+uknUb58edlr6datm0hISChwP6NHjxYqlUr2+/3JJ58IAOLo0aOyvrNmzRIARM+ePaW2LVu2iBEjRohvvvlG7Ny5U8ybN0/Y2dkJDw8P6d+GEEJ8+umn0r+P5s2bi4iICLFq1Srh5eUlXF1dxb1793R6X6ho4uLiBADh8FKIcGw3wyBfDi+FCAAiLi7O2C+PqExhtmG2yY+xss37778vbG1tZfuYO3euTmOHhYWJSZMmiYiICLF9+3YREhIiLCwsRPXq1WWfIVOmTJF+715++WWxZcsW8fHHHwsHBwdRrVo1kZSUJIQQ4vHjxwKAxs9CCCFWrlwpAIirV69Kba1atRJhYWFi9+7dYvXq1aJu3bo6ZbO33npLABBXrlzR6XVS8WCGISqdmFeYV/JjisdihBAiKChItGrVSvY6Jk6cmO9z7O3txfDhw/Pt061bN+k1W1lZiXHjxomUlBRZn+TkZOHr6ytmz54thBDit99+EwDEtm3bZP3q168v7OzshJ2dnZg8ebL4/vvvxeTJkwUAMWjQoEKNScWjODIMcwxR0THDMMPkx1QzTG55HcuYPHmyUCqVIioqStY+aNAgAUBMmjRJatNnjurChQtCpVKJvXv3CiGECA0NFQDE48ePpT7Pnj2TfucdHBzExx9/LLZs2SJefvllAUCsWbNGNmZR5r2o6JhhiMomZiBmoPwYIwPpc3xDG13nnXJ89913stfStGlT8ddff8n6ODk5CVdXV2FtbS3mz58vtm/fLoYMGSIAiFmzZun12sk4OJ9k3nhF4DIi9xmsGRkZiI+Ph7+/P1xcXHD27FkMHTq00GNv27YNbdq0gaurq+wsmM6dO+PDDz/EkSNH8Nprr0ntAwcOhKurq7Sdc8u9mzdv6r3vrKws7Nu3D3379kXVqlWl9vLly2PIkCFYt24d4uPj4eTkJD02duxY2W0R2rRpg+XLl+P27duoX79+gfscM2aM9L2Li4t0pm1wcLDUHhAQABcXF9lryn3WT1ZWFmJjY+Hg4ICAgACcPXtWto+uXbti3LhxWLhwIbZv3w4bGxusXbtW1ufp06cAIHsvc8tp1+XMpP379xfYBwDq1KmjU7/CiIyMhKWlpex9zI+1tTVq1KiBoKAg9OvXD1lZWfjyyy/x+uuvY//+/WjZsqXUt1y5cmjUqBEmTZqEOnXq4Pz581i6dClGjhyJbdu25VvT119/jRkzZsiu3jtkyBAsXLgQo0aNwsqVK1G9enXs27cPq1atApB9S+0cwcHBstfUt29fdOvWDW3btsXixYuxZs0aAJBu8aRQKHDw4EE4ODgAABo1aiRdFXjRokU6vTdUdAqlCgpD3b6At0EgKhbMNsw2+TFWtqlcuTLatm2L/v37w93dHT///DOWLFkCb29v2ZVbtAkJCZFt9+/fH82bN8drr72GVatWYdasWQD+ywze3t74+eefpbOrK1asiMGDByMyMhJjxoyR8oi2M89zzhLPnVl+//13WZ9Ro0ahSZMmmDNnDkaMGKH1ijhqtRqbN29Go0aNpCsfkHExwxCVLswrzCv5McVjMb/99hu+//57/PHHHwav5cMPP8Rbb72FO3fu4JtvvkF6ejoyMzM1+mRkZGi9UnBuiYmJSE5Oxvjx4/H5558DAPr164f09HSsXbsWCxculI7z6DomFS+DZhiAOYaoiJhhmGHyY4oZJrf8jmWMGTMGa9asQXBwMJYvXw4vLy9s3boVO3fuBCA/jqLPHNWUKVPQvXt3dO3aNc+6co73PH36FJs3b8bAgQMBAEFBQahXrx4WLVqEcePGSf0LO+9FhsUMQ1S2MAMxA+XHGBlIn+Mb2ug675SjQ4cO2L9/P2JjY3Hw4EFcuHABSUlJGjWp1Wp8+OGHmDlzpjTus2fP8Nlnn2HOnDmyO1FS6cX5JPPEhcBlREpKCj744AOEh4cjJiYGQgjpsbi4uCKNfe3aNfz1118oV66c1scfPXok2/b19ZVt53y4Pn/+XO99P378GMnJyQgICNB4rFatWlCr1bhz547sw7Yo+7exsdF4nc7OzqhYsaIsCOW05x5TrVbjs88+w6pVq3Dr1i1kZWVJj7m7u2vsa9myZdi9ezfOnz+PyMhIeHp6aq0p989SW/uLdWlj7NsEJSYmYvfu3ejWrZvW90KbSZMm4eTJkzh79qy0ACY4OBh16tRBSEiINCl18+ZNdOjQARs3bkT//v0BAH369EHlypUxYsQI/O9//0P37t01xj969ChGjx6Nbt26YfHixbLHvL298cMPP2Do0KHSgRsnJyd88cUXGD58uLSINy+tW7dGixYtpFt7A//9YdGrVy/Z81u2bIkqVarg+PHjOr0vRETmgtmG2SY/xsg2mzdvxtixY/Hvv/+iYsWKALIPyKjVasycORODBw/WOefkGDJkCN566y0cOHBAOiCTkxmCg4Nlt1gaMGAAhg4diuPHj2PMmDFSv7S0NI1xU1NTZWNpY2VlhUmTJmH8+PE4c+YMWrdurdHn8OHDiImJwbRp0/R6XURE5oJ5hXklP6Z2LCYzMxNTpkzB0KFD0axZM4PX07BhQ+n7119/HY0bN8aIESOwfft2AEBUVBQ+/vhjrFy5ssDjLjkZZ/DgwbL2IUOGYO3atThx4gSqV6+u15hEROaEGYYZJj+mlmFelN+xjPr16yMyMhLjx4/HSy+9BCB7PigsLAxvvvmmLC/oOke1ZcsWHD9+HJcuXcq3rpz8YmlpiaCgIKldqVRi4MCBCA0NRXR0NHx9fQs970VERPljBmIGyo8xMpCuxzf0oW3eKYeXlxe8vLwAZJ+MtGTJEnTp0gXXrl2Dt7e3VFNSUpJGTYMHD8Yvv/yCc+fOoW3btnrVREQlhwuBy4jJkycjPDwcU6dORWBgIJydnaFQKDBo0CCo1eoija1Wq9GlSxfMmDFD6+M1atSQbatU2s8EyOvD19CKsv+8nqvLmEuWLMH8+fMxatQovP/++3Bzc4NSqcTUqVO1/gzOnTsnBb6LFy9qfJDmBJ3nz59Li01yywlMHh4eBb6uBw8eFNgHyA5i+S0YKaxdu3YhOTlZdpZbftLT06Ur9eZeAGNpaYnu3btjxYoVSE9Ph5WVFTZs2IDU1FT07NlTNkbv3r0BZF/97sUDIhcuXEDv3r1Rt25dbN++HRYWmv8Vtm3bFjdv3sTFixeRlJSEBg0a4N69ewA0f+e1qVSpEv755x9p28fHBwCkYJWbp6dnoUI9FZ5CqYQi1+9WkRhqHCKSYbYxzP6ZbQyXbVatWoVGjRpp1N67d29s2LAB586dK9SBokqVKuHZs2fSdl6ZQaVSwd3dXXqf3NzcYG1tjfv372uMmdOWM1Z++wYg239uERERUCqVGj9LMh5mGKLShXnFMPtnXikdx2I2btyIf/75B2vXrkVUVJTssYSEBERFRcHT0xN2dnZFrs3Kygq9e/fGhx9+iJSUFNja2uLdd99FhQoV0L59e2n/Oe/h48ePERUVBV9fXyiVSvj4+ODy5csaeSlnQjDn56TPmFS8DJphAOYYoiJihjHM/plhSkeGeVFBxzKCgoLQu3dvXLhwAVlZWWjcuDEOHToE4L/fT33mqN555x0MGDAAVlZWUt6IjY0FANy5cwfp6enw8fGBm5sbbGxs4OLiovE7kjvD+Pr6Fmrei4oHMwxR2cIMZJj9MwMZLgPpenxDXy/OO+UlKCgIc+fOxe7du6U7E/j4+ODatWsGr4lKHueTzBMXApcR27dvx/Dhw/HJJ59IbampqdIfmznyO9Mlr8eqVauGxMREg54Bo8sZN0D2rW/s7OxkCypzXL16FUqlUlrAYGzbt29Hhw4d8PXXX8vaY2NjNYJFUlISRo4cidq1a6NVq1ZYunQpXn31VdkVV2rWrAkAuHXrFurVq6exv1u3bgGATrdpLl++vE6vITw8HCNGjNCprz4iIiLg4OAgHaQoyNOnT5GZmSk7AyxHRkYG1Gq19NjDhw8hhNDom5GRAQAat5m8ceMGXn75ZXh6emLPnj35XhFGpVLJrliTc4VfXf4t3Lx5U3YmXJMmTQAAMTExGn3v3bsn/byJiCgbs43xMdvIPXz4UOvtpfLKHLoQQiAqKgqNGjWS2vLKDOnp6Xjy5ImUL5RKJerVq4fTp09rjPvHH3+gatWqBd6eKeeWXNquUpCWlobvv/8e7du3L3BBMRGRuWJeMT7mlbzpeywmOjoaGRkZ0tXxctu4cSM2btyInTt3om/fvgapLyUlBUIIJCQkwNbWFtHR0bh+/brsNqY5JkyYACB7ssnFxQVNmjTB/v37ERMTI7viUc4J3DnZRp8xiYjMCTOM8THD5E3fDJObrscyrKysZO/fi3M/+sxR3blzB5GRkYiMjNTo27hxYzRo0ADnz5+HUqlEw4YNcerUKWkRcY4XM4y+815ERKQbZiDjYwaS0/X4hj60zTvlJSUlBYD8ithNmjTBtWvXEBMTIzueUpSaiKjkcCFwGaFSqTTOzvniiy80/ki0t7cHAI0wk/OYtvbg4GAsWLAAe/fuRbdu3WSPxcbGwsHBQesVVfOTu478DrarVCp07doVu3fvRlRUFCpXrgwg+4/gyMhItG7dGk5OTnrtG8i+SlpcXByqVasGS0tLvZ+fV60v/gy2bduGmJgY+Pv7y9pnzpyJ6OhonDx5EgEBATh48CCGDx+Oc+fOwdraGkD2B6yVlRVOnz6t9YDHmTNnoFAoEBgYWGBt+/fv1+k15L4dhKE8fvwYBw4cwODBg/O8akx0dDSSk5OloObp6QkXFxfs3LkTCxculA6IJCYm4scff0TNmjWls6xq1KgBIQS2bt0qC1zfffcdAMgCzoMHD9C1a1colUrs3btXr5Dy+PFjfPTRR6hfv74swD9+/FhjnD179uDMmTOYMmWK1BYQEIAGDRpg9+7dePLkiRRk9+3bhzt37mDy5Mk610JFp1CqoFBqPytRb4Yah4hkmG30w2yjnSGzTY0aNbBv3z78+++/srP3v/vuOyiVStSvX19qezHbANozw+rVq/H48WO8/PLLUlv79u3h6emJiIgIzJkzBzY2NgCADRs2ICsrC126dJH6BgUFYdasWTh9+jSaNm0KAPjnn3/w66+/4u2338533wkJCQgLC4OHh4e0+Di3PXv2IDY2ttBX4KHiwQxDVLowr+iHeUW70nIsZtCgQbKToXO8+uqreOWVV/DGG2+gRYsWetfy6NEjjVt3xsbG4vvvv0elSpWkxxYtWoQnT57I+l26dAnz58/HjBkzEBgYKP0OBwcH48MPP8TXX3+Njh07Sv2/+uorWFhYoH379nqPScXLoBkGYI4hKiJmGP0ww2hXWjJMboU5lnHt2jWsWbMGPXv2lI736DNHtXPnTo0xN2/ejC1btmDjxo2yqxMOHDgQJ0+exDfffIM33ngDQPYCtIiICNSuXVtavKzPvBcVL2YYorKFGUg/zEDaGTID6Xp8AyjavNOTJ0/g7u6usbj8q6++AgBpfgnIziubN2/G119/jcWLFwPIvuJ1eHg43NzctM4nUenE+STzxIXAZUTPnj2xadMmODs7o3bt2jhx4gQOHDggXQo/R8OGDaFSqfDRRx8hLi4O1tbW6NixIzw9PdGkSROsXr0aixYtgr+/Pzw9PdGxY0e88847+OGHH9CzZ0+MGDECTZo0QVJSEi5evIjt27cjKipKp0vp55bz4TBlyhR069YNKpUKgwYN0tp30aJF2L9/P1q3bo0JEybAwsICa9euRVpaGpYuXVqo92v27Nn45ptvcOvWLSkIFVXPnj2xcOFCjBw5Eq1atcLFixcRERGhcdWRX3/9FatWrUJoaCgaN24MIPusofbt22P+/PnSa7KxsUHXrl1x4MABLFy4UGN/+/fvx0svvaTxM9bGkGeeHTlyBEeOHAGQHSySkpKwaNEiAEDbtm3Rtm1bWf8tW7YgMzMz3wMvw4YNw+HDh6XQp1Kp8Pbbb2PevHlo2bIlhg0bhqysLHz99de4e/cuvv32W+m5I0aMwLJlyzBu3DicO3cOderUwdmzZ/HVV1+hTp06ePXVV6W+L7/8Mm7evIkZM2bg2LFjOHbsmPSYl5eXbGFNu3btEBgYCH9/fzx48ABffvklEhMT8dNPP8luBdWqVSs0atQITZs2hbOzM86ePYv169ejUqVKmDNnjux1Ll++HF26dEHr1q0xbtw4xMXF4dNPP0WNGjXw5ptv6vwzoKLLvg2CoUIPb4NAVByYbfTDbFN4umabd955B//73//Qpk0bTJo0Ce7u7vjpp5/wv//9D2PGjJFdaebFbAMAfn5+GDhwIOrVqwcbGxscO3YMmzdvRsOGDaVbLgGAtbU1Pv74YwwfPhxt27bF0KFDER0djc8++wxt2rRBv379pL4TJkzAunXr0KNHD7z99tuwtLTEp59+Ci8vL7z11ltSv5UrV2LXrl3o1asXfH19cf/+faxfvx7R0dHYtGmT7Co0OSIiImBtbY3+/fsb6J0mQ2CGISpdmFf0w7xSeCVxLKZmzZp53q2oSpUqGlcC/vHHH3HhwgUA2Ven++uvv6SaevfuLZ0k1b17d1SsWBEtWrSAp6cnoqOjER4ejnv37mHLli3SeK1bt9bYb85EZ7NmzWT7b9SoEUaNGoX169cjMzMT7dq1w6FDh7Bt2zbMnj1bymX6jEnFy6AZBmCOISoiZhj9MMMUXklkmNx0OZZRu3ZtDBgwAL6+vrh16xZWr14NNzc3rFmzRuqjzxyVtjxx/vx5ANk5KPfv+7hx4/DVV19h4sSJ+Pfff+Hr64tNmzbh9u3b+PHHH6V++sx7UfFihiEqW5iB9MMMVHi6ZiBdj28ARZt3+vbbb7FmzRr07dsXVatWRUJCAvbu3Yv9+/ejV69eskXIffr0QadOnfDBBx/gyZMnaNCgAXbt2oVjx45h7dq10iJsKv04n2SmBJUJz58/FyNHjhQeHh7CwcFBdOvWTVy9elX4+fmJ4cOHy/quW7dOVK1aVahUKgFA/Pbbb0IIIR48eCB69OghHB0dBQDRrl076TkJCQli9uzZwt/fX1hZWQkPDw/RqlUrsWzZMpGeni6EEOLWrVsCgPj444816gMgQkNDpe3MzEwxefJkUa5cOaFQKETuX8UX+wohxNmzZ0W3bt2Eg4ODsLOzEx06dBDHjx+X9QkPDxcAxKlTp2Ttv/32m+x1CiHE8OHDBQBx69YtWZu9vb1G7e3atRN16tTRaPfz8xM9evSQtlNTU8Vbb70lypcvL2xtbcVLL70kTpw4Idq1aye9l/Hx8cLPz080btxYZGRkyMabNm2aUCqV4sSJE1Lbjh07hEKhENHR0bK+sbGxwsrKSnz11VcadRW30NBQAUDr14s/NyGEaNmypfD09BSZmZl5jtmuXTuh7b+jiIgI0bx5c+Hi4iJsbW1FixYtxPbt2zX63b17V4waNUpUqVJFWFlZifLly4s33nhDPH78WNYvr7pf/H0XIvvnUbVqVWFtbS3KlSsnhgwZIm7cuKGx77lz54qGDRsKZ2dnYWlpKXx9fcWbb74pHjx4oPW17t+/X7Rs2VLY2NgINzc3MXToUHH//v083xsyrLi4OAFAuHSaLVy7vWeQL5dOswUAERcXZ+yXR1SmMNsw25QUfbLNH3/8Ibp37y68vb2FpaWlqFGjhli8eLHGa9eWbcaMGSNq164tHB0dhaWlpfD39xczZ84U8fHxWuv67rvvRIMGDYS1tbXw8vISkyZN0tr3zp07IigoSDg5OQkHBwfRs2dPce3aNVmfffv2iS5dukh1u7i4iK5du4qDBw9q3XdcXJywsbER/fr1K+jtoxLCDENUOjGvMK+UlJI8FvMiAGLixIka7Tk/T21f4eHhUr8VK1aI1q1bCw8PD2FhYSHKlSsnevXqJY4cOVLgvnN+j7Zt26bxWHp6uliwYIHw8/OTstXy5cuLNCYZXnFkGOYYoqJjhmGGKSklmWF0PZYxaNAgUalSJWFlZSV8fHzE+PHjxcOHD7X21XWO6kU5r/vFOSohhHj48KEYPny4cHNzE9bW1qJFixbil19+0ein67wXFQ9mGKKyiRmIGaik6JOBdD2+UZR5p1OnTokBAwYIX19fYW1tLezt7UXjxo3Fp59+qvEeC5H9uxwSEiK8vb2FlZWVqFevnvj222+L/L5QyeB8knlTCKHllEkiKhWysrJQu3ZtBAcH4/3335faw8LCsHTpUty4cUO6/RARFSw+Ph7Ozs5w7TwPCksbg4wpMlLx/MAixMXFFeq2KkRE5oTZhqhwmGGIiEoO8wqR4RRHhgGYY4iItGGGITIcZhgiItPBDEQkx/kk88ZrNxOVYiqVCgsXLsTKlSuRmJgIIPt2i59++inmzZvHwEJEREQmhdmGiIiISjvmFSIiIjJFzDBERERkjpiBiIj+wysCExGR2ZDOfuoWCqWBzn5SZ6Ti+d73ePYTERERFRtmGCIiIjJFxZFhAOYYIiIiKl7MMERERGSqOJ9k3iyMXQAREVFJUyhVUChVBhuLiIiIqCQwwxAREZEpMmSGyRmPiIiIqLgxwxAREZGp4nySeVIauwAiIiIiIiIiIiIiIiIiIiIiIiIiIiLSH68ITEREZodnPxEREZEpYoYhIiIiU8Sr6REREZEpYoYhIiIiU8X5JPNk0guB7e3tkZqaCpVKBU9PT2OXQ0RERfTo0SNkZWXBxsYGSUlJxi6HqNgwwxARlS3MMGROmGOIiMoW5hgyF8wwRERlCzMMmQtmGCKisoUZhoqTSS8ETk1NhVqthlqtRkxMjLHLISIiA0lNTS3W8ZVKFZSGOmuJZz9RITDDEBGVTcwwZA6YY4iIyqbizDEGzTAAcwwVCjMMEVHZxAxDZR0zDBFR2cT5JCoOJr0QWKVSQa1WQ6lUonw5d2OXQ0RERXT/8VOo1WqoVMUbJBRKpQFvg6A0yDhkXmQZxotncBMRmbr7Dx8xw5DZkOUYz3LGLoeIiIro/qPHxZ5jDJlhcsYj0pf8WIyXscshIqIiuv/wITMMmQXOJxERlS2cT6LiZNILgT09PRETE4Py5dwRfewHpFVoYOySdGZnZyfbTk5ONlIl+stdu6nWDZhu7aZaN2C6tZtq3YDp1s5b21BZJ2UYL0/cvPAHshxMZxFNWfl/xlTrBky3dlOtGwAeh003UiVF88XMXcYuodBa+jgauwSdvXLrgvQ9MwyZAynHeJbDrTNHoEw33duXqZ/eM3YJhXJj1Tpjl1BoYevPG7uEQmnjbmvsEgqt+/u9jV1CoTg0amnsEgrts7R6xi5BZzPaV5e+Z46hsu6/YzFeuHH5HJ7C3tglFZqlSmHsEgrFSW06xwVsXOX/J2b8dcBIlRRN8ulDxi6h0J5eumXsEnRW9dMI6XtTPv5lqrUzw1BZl3s+6da535HmWN7YJRXak5RMY5dQKI7fLTR2CYW2ftYuY5egsxlJ16XvTfUzCTDd2k21bsB0a2eGoeJg0guBiYiICkOhVBnw7CfeBoGIiIhKBjMMERERmSJDZpic8YiIiIiKGzMMERERmSrOJ5knXruZiIiIiIiIiIiIiIiIiIiIiIiIiIjIBPGKwEREZHZ49hMRERGZImYYIiIiMkW8mh4RERGZImYYIiIiMlWcTzJPXAhMRERmh6GHiIiITBEzDBEREZkiLqIhIiIiU8QMQ0RERKaK80nmSWnsAoiIiIiIiIiIiIiIiIiIiIiIiIiIiEh/vCIwERGZHYXCgGc/KXj2ExEREZUMZhgiIiIyRYbMMDnjERERERU3ZhgiIiIyVZxPMk+8IjAREREREREREREREREREREREREREZEJ4hWBiYjI7ChUKihUBjr7yUDjEBERERWEGYaIiIhMkSEzTM54RERERMWNGYaIiIhMFeeTzBOvCExERERERERERERERERERERERERERGSCeEVgIiIyOwqlEgqlgc5+UvKcGiIiIioZzDBERERkigyZYXLGIyIiIipuzDBERERkqjifZJ64EJiIiMyOQqkyYOjhbRCIiIioZDDDEBERkSkyZIbJGY+IiIiouDHDEBERkanifJJ54pJtIiIiIiIiIiIiIiIiIiIiIiIiIiIiE8QrAhMRkdnh2U9ERERkiphhiIiIyBTxanpERERkiphhiIiIyFRxPsk88YrAREREREREREREREREREREREREREREJohXBCYiIrOjVCqgVCoMNJiBxiEiIiIqADMMERGRGRECtnHPYZmSjAxbO6Q4uwIK0/z8NmiGAZhjiIhId0JAmZoGZXom1FYWUNtYm+znKZU8ZhgiIiIyVZxPMk9cCExERGZHoVRAYaCwYqhxiIiIiArCDENERFT2WSfEo87eHWi8YxNc70VL7c99fHG231Bc7tYPaY5ORqxQf4bMMDnjERER5UeZmg6HKzfhdO4fWMYlSu0Zzg6IbxSAxNpVobaxMmKFZAqYYYiIiMhUcT7JPHEhMBERERERERERERGRkVX+8yj6vDsJlmkpEC885nz/DjquXII2Xy3H7oUrENW8jVFqJCIiKu1so+7B88ejUGRkajxmEZcIt0Nn4Pr7BTzq1QYplX2MUCEREREREZHhKY1dABERUUlTKBQG/SIiIiIqCcwwREREZVflP4+i/6wxsEhLgUIIKIV8KbBSCCiEgEVaCvrPGoPKfx41UqX6M3SGYY4hIqK82Ebdg9fOQ1BkZEIB4MVPjJw2RUYmvHYegm3UvZIvkkwGMwwRERGZKmYY81QqFgKvXLkSlStXho2NDVq0aIE///zT2CURERERFYgZhoiIiEwRMwwRUelinRCPPu9OArQsAH6RUghACPR5dxKsE+JLqEKi0oEZhojyo0xNh+ePRwEhNBYAv0gBAELA88ejUKaml0B1RGTOmGGIiIioJBh9IfCWLVswffp0hIaG4uzZs2jQoAG6deuGR48eGbs0IiIqoxRKBZQG+lIoefaTuWKGISKiksYMQ4bADENEVPrU2bsDlmkpBS4CzqEUApZpKaizb2cxV2YYhswwzDHmixmGiAricOWmdCVgXeRcGdjhys3iLItMGDMMGQIzDBERGQPnk8yThbEL+PTTT/HGG29g5MiRAIA1a9bg559/xvr16zFr1iwjV0dERGWRQmG4sMLbIJgvZhgiMpi0dFjEPNbrKcLeFllebhrtqruPoEjPAAD4qlN1GuuuwhrqFz7PHEQm3ESmXjXFKiwQr9D8E1PXOnJkT9k5arTbZaTBOitDr7ESLG2RqVLp9ZzSjBmGDIEZhoiolBECjXdsAnRbA/zf0wA0/n4jzvYbBpTyz3VDZpic8cj8MMMQUb6EgNO5fwr1VKdz/yC+UUCp/zylkscMQ4bADENERMbA+STzZNSFwOnp6Thz5gxmz54ttSmVSnTu3BknTpzQ6J+Wloa0tDRpW+h4hQQiIiIiQ2KGISJDUj16DpfPt+j1nLRGAUgY3kOj3WHLfljeeQgAGK3jWEusKiPthevl1FAno0/mE71q2qdyw+8WLhrtIzLuQZ+luE9hgT/hodFeOe4x/BKe6lXTn95V8dRWc1ExkbnSN8MAzDFERMXNNu45XO9F6/08pRBwvRcNm/hYpDq7FkNlRKUHMwwRFUSZmgbLuES9n6cAYBmXCGVqOtS21oYvjIjMGjMMERERlSSlMXf+5MkTZGVlwcvLS9bu5eWFBw8eaPT/4IMP4OzsLH3du3evpEolIqIyRPH/ty8w1BeZH2YYIiIyBmYYKip9MwzAHENEVNwsU5KL9Hyr5CQDVVJ8DJ1hmGPMDzMMERVEma7fXY00n6/fHYjIPDDDUFExwxARkbEww5gnoy4E1tfs2bMRFxcnffn4+Bi7JCIiIqICMcMQERGRqWKOISIqXhm2dkV6frqdvYEqISpbmGGIzIvaqmg3wVVbWRqoEiKiomGGISIiosIq2l9FReTh4QGVSoWHDx/K2h8+fAhvb2+N/tbW1rC2/u+2LAoFV5wTEZH+lAoFlAb6DBH8LDJLzDBEVFiKlDRY3H0kbWdW9ESWpytipwzUaxxhb6u1PXFgFyj+/yo2368+qtNYGdD8P+lfpR2+ttTvIHOsQvuflxv0HCcTCvhqaY9yLof7Di56jZVgaQuVOgt2melSW7KFFbKUKr3GKS2YYaio9M0wAHMMEVFxS3F2xXMfXzjfvwOlHrf9VSsUiCtfCalOLsVXnIEYMsMAzDHmiBmGiAqitrFGhrMDLOIStRzlyJsAkOnsALWNVXGVRiaMGYaKihmGiIiMhfNJ5smoC4GtrKzQpEkTHDx4EH379gUAqNVqHDx4EJMmTTJmaUREVIYZ8vYFvA2CeWKGIaLCUt1/AueV26Tt2CkDkVm1AjKrVjDI+FkVPaXvo5U2hR4nUWGBxDwW9uqrMHVoWwicbGmNZEtrLY/kzzU1ES3v35C2T5avhuc2DnqPUxoww1BRMcMQEZVCCgXO9huKjiuX6Pc0AGf7DwNMYDLG0LeRZI4xP8wwRFQghQLxjQLgduiM3k+NbxRgEp+nVPKYYaiomGGIiMhYOJ9knoy6EBgApk+fjuHDh6Np06Zo3rw5wsLCkJSUhJEjRxq7NCIiIqI8McMQERGRKWKGISIqfS5364c2Xy2HRVqKTlcFViuUyLS2weWur5ZAdUSlAzMMERUksXZVuP5+AcjI1OmqwAKAsLRAYu2qxV0aEZkxZhgiIiIqKUZfCDxw4EA8fvwY7777Lh48eICGDRvil19+gZeXl7FLIyKiMopnP5EhMMMQEVFJY4YhQ2CGISIqfdIcnbB74Qr0nzUGaiDfxcBqhQJQALvfX4E0R6eSK7IIeDU9MgRmGCIqiNrGCo96tYHXzkMQQuS7GFgAgEKBR73aQm1jVUIVkqlhhiFDYIYhIiJj4HySeTL6QmAAmDRpEm99QERERCaHGYaIiIhMETMMEVHpE9W8Db7/8Cv0eXcSLNNSAAEo8N+CYIHsBcCZ1rbY/f4KRDVrY8RqiYyDGYaICpJS2QcPX20Pzx+PAhmZACBbEJzzySosLfCoV1ukVC5f0iUSkRlihiEiIqKSUCoWAhMREZUkpVIBpYHOWhI8+4mIiIhKCDMMERFR2RbVvA3WbDuKOvt2ovl36+D45KH0WKKHJ/4c/AYudeuHdAdHI1apP0NmGIA5hoiI8pdS2Qd33ngVDlduwvnUFVgkpUiPZdnbIq5ZbSTUqQphzSsBU/6YYYiIiMhUcT7JPHEhMBERmR2FMvvLUGMRERERlQRmGCIiorIvzdEJZ/sPx0P/2hgSMkRq/3H+csQ0aGbEygrPkBkmZzwiIqL8qG2sEN+4JtI8XeGz9YDU/qjHS0ir6GXEysiUMMMQERGRqeJ8knnij4qIiIiIiIiIiIiIqDRRKPLfJiIiooLx85SIiIiIiMwErwhMRERmR6FQQGGgA36GGoeIiIioIMwwREREZIoMmWFyxiMiIiIqbswwREREZKo4n2SeeEVgIiIiIiIiIiIiIiIiIiIiIiIiIiIiE8QrAhMRkdlRKgGl0jBnLQmeUkNEREQlhBmGiIiITJEhMwzAHENEREQlgxmGiIiITBXnk8wTFwITEZHZUSgVUBgo9BhqHCIiIqKCMMMQERGZj2e+VfDj/E9l26bKkBkmZzwiIiJdZLg64dErL8m2iXTFDENERESmivNJ5okLgYmIiIiIiIiIiIiISpEUF3dc7dTL2GUQERGZNLWdDZJqVjZ2GURERERERMWOC4GJiMjsKBQGPPtJwbOfiIhId2pHO6QE1pNtU/FKV1rgvp2zbNtUMcMQERGRKTJkhskZj4iIiKi4McMQERGRqeJ8knky3RlQIiIiIiIiE6Mu54qkgV2MXYZZSbKywXmvysYug4iIiIiIiIiIiIiIiIioWHAhMBERmR2lQgGlgc5aEjz7iYiIiEoIMwwRERGZIkNmGIA5hoiIiEoGMwwRERGZKs4nmScuBCYiIvOjNODtnAx4WygiIiKifDHDEBERmQ1lRjps42Ol7RQnF6gtrYxXUFEYMsP8/3hEREQ6ycqCKiX9v01bK0ClMmJBZFKYYYiIiMhUcT7JLHEhMBERERERERERERFRKVL+778wZMpgaTvy8+8QU7+pESsiIiIyPdYPnsJny35p+97ALkir4GnEioiIiIiIiIpHmVoIbGdnZ+wSdJacnCzbNtXaTbVuwHRrN9W6AdOt3VTrBkyvdn9/f9y7d6/Y96Uw4NlPBj0bnMyWqf1bzc1UazfVugHTrd1U6waApC/nGamSolmYdtPYJejsXeuqxi6h0PZUaYCh0VfwNCuj2PfFDENkWFZNexq7BJ2ln/5J+r7W+t1GrEQ/f4/qI9tei9tGqkR/4+Anff/606tGrEQ/37rXlG27T1hqpEr093TVDOl768B+RqxEP2kndhi7hEJbeugaFge1RtyTh8W6H0NmmJzxiMyZp7ODsUvQ2aO4ROl7G1fTWXyZ+vyRbNvShGrP+OuA9L3zqEVGrEQ/cetN89gLANyc/pr0vSkf/zK12ktiPokZhsiwqng4GbsEnd16Ei997zF5mREr0c+TL942dgmFttTeX/re1D6TcjPV2k21bsD0aueaGCpOZWohMBERERERUWmmuvMQjhv3SNsJw15BViUvI1ZU9jmmpaDO07vS9mX3ikiwtjViRUREREREREREREREREREhsOFwEREZHaUSgWUBjpryVDjEBGReVBkZMLi8XPZNhUvC5EF17Rk2bapYoYhIiIiU2TIDJMzHhEREVFxY4YhIiIiU8X5JPPEhcBERGR2FAoFFAoD3QbBQOMQERERFYQZhoiIiEyRITNMznhERERExY0ZhoiIiEwV55PMU5laCJycnFxwp1LCzs5Otm2qtZtq3YDp1m6qdQOmW7up1g2Ydu1E5sSU/62aau2ZN08bsRI9Pbgi20w7scNIhejPuox8no6Dn8HGroZUvJNre93nh3ADNgYbfy1uS99ffeNVg41b0h5dfGiwsWzjs4D7ubZdbZHhZG+w8duePG6wsYhM0WWrqsYuQWcNKrjItm8/STBOIYWQ678xxG9412h1FNX+k3eNXUKhzOjaytglFNrp6xWMXYLO3Ccslb5PexJjxEqKZnrsHcMM9CBOtjnQMw6o+NQwY/8/C/+WBh2PyJS42aiMXYLObMvIsZiM6EtGrERPCY9km/cWTzBSIfp7/ON/x41S9qwxYiX6sX1lvGz74pBXDDKueCrP/KlPE5CssjTI2NqY0rGY6JDXZNuGPP5V3DifROYsQy2MXYLO3Bzlx2BNNcOYat2Aaf3fnntuw5Tfc1Ot3VTrBky7diJDK1MLgYmIiHShUGZ/GWosIiIiopLADENERESmyJAZJmc8IiIiouLGDENERESmivNJ5ok/KiIiIiIiIiIiIiIiIiIiIiIiIiIiIhPEKwITEZHZUSoVUCoVBhuLiIiIqCQwwxAREZEpMmSGyRmPiIiIqLgxwxAREZGp4nySeeJCYCIiMjsKpQIKA4UVQ41DREREVBBmGCIiIjJFhswwOeMRERERFTdmGCIiIjJVnE8yT0pjF0BERERERERERERERERERERERERERET64xWBiYjI7CgUCigUBjr7yUDjEBERERWEGYaIiIhMkSEzTM54RERERMWNGYaIiIhMFeeTzBMXAhMRERERERERERERlSaODhDNG8m2iYiISD9ZVhZI8nSTbRMREREREZVF/GuHiIjMjlKpgFJpmLOWDDUOERERUUGYYYiIiMxIgD/UkauNXYVBGDLD5IxHRESkizQXJ9zq3NLYZZCJYoYhIiIiU8X5JPPEhcBERGR2FAoFFAYKK7wNAhEREZUUZhgiIiIyRYbMMDnjERERERU3ZhgiIiIyVZxPMk9cCExERERERFRCbsAG4+Fn7DLMSoKDA040bSZtZylVRqyGiIiIiIiIiIiIiIiIiMiwlMYugIiIqKSplAqDfhXFhx9+CIVCgalTp+bZ5/Lly+jfvz8qV64MhUKBsLAwjT4LFizIPqsr11fNmjWLVBsREVFZIJRKZFpYSl9Cabp/BpemDENERESkK0NnGOYYIiIiKgnMMERERGSqmGHME68ITEREZCSnTp3C2rVrUb9+/Xz7JScno2rVqhgwYACmTZuWZ786dergwIED0raFBT/miYiIiIiIiIiIiIiIiIiIiIjKMq4QIiIis6M04FlL6kKOk5iYiNdeew3r1q3DokWL8u3brFkzNGuWfUvzWbNm5dnPwsIC3t7ehaqHiIiISr/SkGGIiIiohFy7BeXHK6VN9TsTgepVjFhQ4RkywwDMMUREpDvruAR4nf9H2n7YMABpzo5GrIhMCTMMERERmSrOJ5knLgQmIiKzY8jbF+SEnvj4eFm7tbU1rK2t83zexIkT0aNHD3Tu3LnAhcC6unbtGnx8fGBjY4PAwEB88MEH8PX1NcjYREREZHzFkWGIiIiolIqLg+LXY/9tj33deLUUkaFvI8kcQ0REulKlZcAp5pG0/aRWVSNWQ6aGGYaIiIhMFeeTzBMXAhMRERlApUqVZNuhoaFYsGCB1r6bN2/G2bNncerUKYPtv0WLFtiwYQMCAgJw//59vPfee2jTpg0uXboER0de4YCIqLRwQSaaIFnaPgM7xPLPsmJlmZ4O19hYafu5iwsyrKyMVxARERERERERERERERERkQFxxpmIiMxOcZz9dOfOHTg5OUnteV0N+M6dOwgJCcH+/fthY2NjkBoAoHv37tL39evXR4sWLeDn54etW7di9OjRBtsPEREVjTsyMQDPpe0oWHEhcDGzTU1FwM3r0vaF2nVNdiEwz+AmIiIiU8Sr6REREZEpYoYhIiIiU8X5JPPEGWciIiIDcHJyki0EzsuZM2fw6NEjNG7cWGrLysrCkSNHsGLFCqSlpUGlUhW5HhcXF9SoUQPXr18vuDMREREREREREREREREREREREZkkLgQmIiKzY8yznzp16oSLFy/K2kaOHImaNWti5syZBlkEDACJiYm4ceMGhg4dapDxiIiIyPh4BjcRERGZIl5Nj4iIiEwRMwwRERGZKs4nmSelMXd+5MgR9OrVCz4+PlAoFNi1a5cxyyEiIjNhoQQslAoDfem3b0dHR9StW1f2ZW9vD3d3d9StWxcAMGzYMMyePVt6Tnp6Os6fP4/z588jPT0dMTExOH/+vOxqv2+//TYOHz6MqKgoHD9+HK+++ipUKhUGDx5skPeM5JhhiIjIGIyZYajsYI4hIqKSZtgMwxxjrphhiIiopDHDkCEwwxARkTFwPsk8GfWKwElJSWjQoAFGjRqFfv36GbMUIiKiUiM6OhpK5X9p6t69e2jUqJG0vWzZMixbtgzt2rXDoUOHAAB3797F4MGD8fTpU5QrVw6tW7fGyZMnUa5cuZIu3ywwwxARZVOmpcP6ebxez8m0s0GGk4NGu83j51BkZQEAnOJ1GFMBxDs6aTRbpaXBJi1N2rZPTtKrPqKyjjmGiEhO8ecpQC10f4KVJUTjRprtUbehePAQSHyo+1j+VQAXZ3lbSipw+SoUV69rfw6RmWKGISJDsIlNAACkuDlDWMjvzqdKS4d1XKJe42XY2SDDwU5zP4+eQaFW6zyOUCiQ6uWu0W6RmAzLxGS9akp3dkSWrbW8Ua2G7aNn+T6vGlJl26lQIgZWGv28kQF7ZBVYRwYUuAsrqMEryJF5Y4YhIiJzs2DBArz33nuytoCAAFy9ejXP58TGxmLu3LnYsWMHnj17Bj8/P4SFheGVV14p9JjmyKgLgbt3747u3bvr3D8tLQ1puSZ0hdDjAC0REdH/K223QchZzJvXduXKlQv8zNu8eXOR6yDdMcMQEWWzefQclX45rtdzntepiketGmi0+xz4U5rc8tVhHLVCgd9bBGq0ez55jCp3ovWqyVSUtgxDpok5hohIziJoMBTJKTr3F+W9kXHxjEa76qtwqNas02vfWes+ATq8JG+8/xCqQeP1Gqe04221yRCYYYjIEHxOXwYA/NuzLdJfOEnZ9kksKh8+rdd4TwIq40GT2pr7OfAHLJNStTxDO7WFCtdG9tZod/o3GuXO/K1XTffbN0F8dfmRFVVaBnx/PJrv8955Yfs6rLEM3hr9+uA5GkG37BQNK3wIb5NdDMwMQ4bADENERMZg7PmkOnXq4MCBA9K2hUXeS1TT09PRpUsXeHp6Yvv27ahQoQJu374NFxeXQo9prkzqHfnggw80VncTERERlXbMMEREpYdayXsYEemDOYaITN7dGCi3bJM21QMHABUrGLGgQrK2LrgPEUmYYYgIANQqHgMwJl+koyLSEQ3mGCJdMcMQEVFZYGFhAW9vzZPKtFm/fj2ePXuG48ePw9LSEkD2xfKKMqa5Mqm/fmbPno24uDjpy8fHx9glERGRCVL+/9lPhvhS8gxu0gEzDBGZOkVGJqyexUtfioxMY5dUKIl29kiy07xlp6lghiFjYI4hIlOnuBsDiw8+lr4Ud2OMXZLeRO0aQM3qxi6j0AyZYZhjSFfMMEQEAKmuTkhxdTJ2GWbNEqZ7NVNmGDIGZhgiIjKE4phPio+Pl33lvoL9i65duwYfHx9UrVoVr732GqKj876T5w8//IDAwEBMnDgRXl5eqFu3LpYsWYKsrKxCj2muTOqKwNbW1rDOdeUDhYJhmYiI9KdSKKEy0NUAVQqTOqeGjIQZhohMnc3TWNktJKN7tUGKtwdSPV0R3auNXmNl2tlobb/XuTkU//9H/fMbzwseKI//Sh95lEO8o+Ykn1qpRJKdHYQJXxGYGYaMgTmGiMq6zO3fAWo9FqhYWWptzhozEuqer0CZ+FD3sfyraLaV90LW5jX/bVtbZy8CtjSpQ/kyhswwOeMRFYQZhogAAEolbnRrBZvn8VBmqaXmDDtbja4pHi642bmlXsNn5HmMowUUarXWx7QRefwfFV/DFyk+HnrVlO7sqNGWZW1Z4PGbLT/+K9tOzeN6YrvhigPIe3F1RWRgMJ7pUGnpxwxDxsAMQ0REhlAc80mVKlWStYeGhmLBggUa/Vu0aIENGzYgICAA9+/fx3vvvYc2bdrg0qVLcHTUzKo3b97Er7/+itdeew179uzB9evXMWHCBGRkZCA0NLRQY5or0z16SEREREREREaltrZCird+E1J5SS3nKn0f/zgrn575S7e2RjpvnU1EREQ6Es2bGWagyn4Qlf2A2DtFG8fWBmja0CAlEREREQClEqnuLgV2y7K2QrKnm0F2mWqgcTId7JDpYIA7GymVBR6/uQHdrqj2AJYAtJ8YBQB3YIV/8d9xmadcjkBERERUJty5cwdOTv+dEGadx1xc9+7dpe/r16+PFi1awM/PD1u3bsXo0aM1+qvVanh6euLLL7+ESqVCkyZNEBMTg48//lhaCKzvmOaKyZuIiMxOzi0MDDUWERERUUlghiEiIiJTZMgMkzMeERERlU7pUOI+rIxdhkEwwxAREZGpKo75JCcnJ9lCYF25uLigRo0auH79utbHy5cvD0tLS6hUKqmtVq1aePDgAdLT02FlpZktCxrTXBl1IXBiYqLsB3Lr1i2cP38ebm5u8PX1NWJlRERERHljhiEiIiJTxRxDREREpogZhoiIiEwRMwwREZm7xMRE3LhxA0OHDtX6+EsvvYTIyEio1WoolUoAwL///ovy5ctrXQSsy5jmyqgLgU+fPo0OHTpI29OnTwcADB8+HBs2bDBSVUREVNbxanpUVMwwRFRYj2GBCLjJtol0xQxDhsAcQ0REJY1X0yNDYIYhIqKSxgxDhsAMQ0RExmDM+aS3334bvXr1gp+fH+7du4fQ0FCoVCoMHjwYADBs2DBUqFABH3zwAQDgzTffxIoVKxASEoLJkyfj2rVrWLJkCaZMmaLzmJTNqLPO7du3hxDCmCUQERER6Y0ZhogKKx4WOApHY5dBRGaMOYaIiIhMETMMERERmSJmGCIiMjd3797F4MGD8fTpU5QrVw6tW7fGyZMnUa5cOQBAdHS0dOVfAKhUqRL27t2LadOmoX79+qhQoQJCQkIwc+ZMncekbLz8FBERmR1eTY+IiIhMETMMERERmSJeTY+IiMh82CELlZEubUfBCslQGbGiwmOGISIiIlNlzPmkzZs35/v4oUOHNNoCAwNx8uTJQo9J2bgQmIiIzI5KoYBKYaDQY6BxiIiIiArCDENERESmyJAZJmc8IiIiKp3KIwNT8Eja/hheuGGqC4GZYYiIiMhEcT7JPCkL7kJERERERERERERERERERERERERERESlDa8ITEREZkdpwNsgKHkrJyIi0oMCApYQ0nYGFBDgZwnphhmGiIiITJEhM0zOeERERETFjRmGiIiITBXnk8wTFwITERERERGVkKpIwzt4KG1n3x7RxogVERERERERERERERERERGRKeNCYCIiMjsqA579ZMizwYmIiIjywwxDRESkP1GtKjJXfS7bppJlyAyTMx4RERFRcWOGISIiIlPF+STzxIXARERkdiyUClgYKKxkMfQQEZEZyLK2QkLl8rJtKnnMMERERIVQzgPq4P7GrsKsGTLDAMwxREREVDKYYYiIiMhUcT7JPHEhMBEREREREeUr3dUJ97q0NHYZRERERERERERERERERET0Ai4EJiIis8PbIBAREZEpYoYhIiIiU8TbahMREZEpYoYhIiIiU8X5JPOkNHYBREREREREREREREREREREREREREREpD9eEZiIiMwOz34iIiIiU8QMQ0REVAgZGUBc/H/bzk6ApaXx6jFDvJoeERERmSJmGCIiIjJVnE8yT1wITEREZkelMGDoUTD0EBERUclghiEiItKf4sw5WPZ8VdrO+GknRMvmRqzI/Bgyw+SMR0RERFTcmGGIiIjIVHE+yTxxITARERERERHly/ppHDx/Py9tP3qpIdLcnY1XEBERERERERERERERERERAShjC4Ht7OyMXYLOkpOTZdumWrup1g2Ybu2mWjdgurWbat2A6dXu7++Pe/fuFfu+lAa8DYKSt0EgAzC1f6u5mWztD64Yr5Aisg7sZ+wSdJZ2Yof0vbWp/q4AmGZXy0iV6G8c/IplXGVGBuwePpNtF6e2J48X6/iGdKRlK/Q/exqP09OLfV/MMERFcyEm1tglGITTiIXGLkFn8RvelW13uXLGSJXob3/tJtL31cK+M2Il+rkxdbCxSyi00z07GbsEg7Dwb2nsEnSWef0k/F7qhZiHj4t1P4bMMDnjEZmTlBf+RrU11b+vn9w0XiFF5DN3lbFL0Nm9xROMXUKhpOxZI9u2fWW8kSrR38Uhr0jf11y304iV6OfqG68W3KkQ4qDCr3CUbRvaOPjhW9xFErIMPnZuzDBERfMsIUm2barzSaZaN2C6cxum/J6bau2mWjdgerVzTQwVpzK1EJiIiIiIiIiIiIiIiIiIiIhK3hNYYivcjF0GEREREZHZ4UJgIiIyOyoDnv1kyLPBiYiIiPLDDENERESmyJAZJmc8IiIiouLGDENERESmivNJ5qlMLQR+8fLfpdmLlyY31dpNtW7AdGs31boB063dVOsGTLv24sTQQ6WNKf9bNdXav/jddG5HOfmlqrLtqw/ijFSJ/m7l+j5px6dGq0NfL/6ep53YYbCxFf/chHrJSml76pyJEAFV83mGfqwD+0nfD7/ml09P/TjGxsu24+/EIyGh+D4D/x7Vp9jGNrRa63eX2L6YYag0qqV6auwSCm3ML8+NXYLONr7eVPreVPMXYLq1Z1z61YiVFI2frYOxS9CZRbXm0vcZiY8NN3BKrGxTkRILhQHHt6zcULZtSr/nFiV0LIaLaIgM68s/ooxdgs6+vfhI+r5XjcrGK0RP5V3ln59Z104YqZKiybh3q+BOpYRNuyGybUMeiylJv101nb+P7p+R35K6q6e9kSrRX/9HV0pkP8wwVBo9S8kydgk68/d0km2b0t9KZWWtQObVY0aqpGi8Ggwzdgk6+9C1rmx7qb2/kSrRX1n5PTfl2osT55PMU5laCExERERERFSaiYCqyPzmE2OXQUREREREREREREREREREZQQXAhMRkdlRKQ131pJKaZBhiIiIiArEDENERESmyJAZJmc8IiIiouLGDENERESmivNJ5okLgYmIiIiIiIiIiIiIiIiIiKhIXDNS0DzurrT9f+zdeXwU9f3H8fdujs1BDgKBcN+nIKAIglWxooCI0lr1pyKKqFVBVKwVWhUUEa1K1WKxKopHFeuJUgRRRGtFEBUVwQgqZwhXICEJuXbn9wfdlWWTsJvMZjKZ1/PxmIf7nf3Odz/BkLzZ+ezM6rTW2h+XaGFFAAAAgDPQCAwAcJwYt8vETz+Z92lwAACA6pBhAACAHZmZYfzrAQCA+sltGEr2lQeN7YoMAwAA7IrzSc5EIzAAwHEIPQAAwI7IMAAAwI5oogEAAHZEhgEAAHbF+SRnohEYAAAAAOrKlh2KefbVwNA77kKpXSsLCwIAAAAAAAAAAAAA2BmNwAAAx3Gb+OknN59+AgBEwHWgQDFLPw6Mfb8ZJoNGYISJDAMAQA00SpbRv2/QGHXLzAzjXw8AACDayDAAAMCuOJ/kTDQCAwAAAAAAAAAaph5d5X1tvtVVAAAAAAAAAEDU0AgMAHCcGJdLMS5zPrVk1joAANRnhakp+nzwyYGxN5Z/SlqBDAMAAOzIzAzjXw8AACDayDAAAMCuOJ/kTJy9BQA4jtvlktuksGLWOgAA1GeG262K+Hiry3A8MgwAALAjMzOMfz0AAIBoI8MAAAC74nySM7mtLgAAAAAAAAAAAAAAAAAAAABA5LgiMADAcWIkxZj0oaUYc5YBAAA4JjIMAACwIzMzjH89AACAaCPDAAAAu+J8kjPRCAwAAAAAAAAAaJg2/ST3g3MCQ99tE6XOHS0sCAAAAAAAAADMRSMwAMBx3G6X3G5zPv5k1joAANRnsWVlSs/bHxgfyGisivh4CytyJjIMAAA1sD9f7qXLA0Pf1ZdbWIwzmZlh/OsBAABEGxkGAADYFeeTnIlGYACA48S4XIpxmRNWzFoHAID6LLH4kLp8nx0Yr+vbRwdpBK5zZBgAAGBHZmYY/3oAAKB+MiR55Qoa2xUZBgCOYBjSgXyp6JCUnCilp0n8XAPqLc4nORONwAAAAAAAAAAAAAAAoFby4pO0sFkPq8sAAJil4KBcb70r14uvy7V1R2C30baVjDEXyBg9QkpNsbBAAIAfjcAAAMdxu1xym/SpJbPWAQAAOBYyDAAAsCMzM4x/PQAAgGgjwwBwvP+sknvSHVJJSehz23LkmvU3uf76lHyP3SudOrDu6wNQJc4nOZPb6gIAAAAAAAAAAAAAAAAAAPXAf1bJ/fvbpJISuQxDLsMIejqwr6Tk8Lz/rLKoUACAn6WNwLNmzdJJJ52klJQUNWvWTKNHj1Z2draVJQEAHMDtkmJM2tx8+MmRyDAAasro3F7l8x4IbEbn9laXBBshw6C2yDAAACuYmWHIMc5EhgEAWIEMAzOQY2BLBQcPXwm4kgbgo7kMQzKMw/MLDtZRgQCOhfNJzmRpI/BHH32kCRMm6LPPPtOyZctUXl6us88+W0VFRVaWBQBo4Nxul6kbnIcMA6DGkhNl9OwS2JScaHVFsBEyDGqLDAMAsILZGYYc4zxkGACAFcgwMAM5BnbkeuvdwJWAw5r/vysDu95aEuXKAISLDONMsVa++JIlwb8E5s+fr2bNmumLL77QaaedZlFVAAAA1SPDwAncBfnybFgf0TEVmc1U3rFTyH7PN2vl3vBTRGv5uneQXMH/sHTl5cu1a1/wxLg4+dq3lGJjIloftZP0vzeqSxM8KktICHm+UX6+XOG9RyhJMtwuFaamhuyPKyhSbHFJRLWVNk6RzxMftM9VUSHPgYMqyUiT3JZ+HhawFBkGAADYERkGQK1UVMi1cbNUVi5JMlpkSs2ahkxzfb0hsnXj42T06ByyO6G0RJ7y8oiWKkpIVEVs8Gl7t9erlEPFEa1THhOr4sTQD50nFxcp1uer9lhXWfBr5cUlyjjqvTmPr0KNKsqqXSfRV662JfkqjIlXiTtW2xLSdCgmLsyvAGh4yDGwHcOQ68XXa3KgXE//8/AFUI76/aEObaWMxsH7ysqlbys/B9XWV/k5gRK5tdsdH7I/01emRFX/e+5oO13xKncFnytINLzKNCL7HX7QFaP9rtDfc1neEsUo/JMkhqScmNDf4Sm+ciUZXu1xe+Q7+s8VAI5iaSPw0fLz8yVJGRkZlT5fWlqq0tLSwNgI89MnAAAcye1yyW1SUDZrHdgbGQYNkWfDerU9f3hExxy49HLtmj0nZH+Lib+X54fvI1qr+NUHpZjg5t6YlV8rft5bIXN9HVqp5IGbaQauQx03bpIkbW3fTjvatwt5vufX3yrmGCeYjlQaH68vB58csr/xhp+V8d2PEdW27ayBKmqTFbQvruiQ2r/9sUqapGnzqNNs2wxMhoHZjpVhJHIMAKD2zMww/vXgbGQYAGGrqFDs+Nvl/uHnX3ZNGCvfmNEhU2Mn3CmXN/z3MoxWWSp/7e8h+9vs2qlWe3dHVObXnbtrf2pa0L7E0lL1+yGyD+nvTs/Q+o5dQvZ33bZZaUWFEa31TtNuKncFv9fWvLRQ/Q/mRLTOvrgk2zYCk2EQDZxPQr13IF+urTsiPsxlSNq9VzFjJoY853tomoxzzwp5nZjLJlS61vgqXuNnV4Lmx7cM2T/Um6fuvsg+PPNYXGvtcwU3Fbf2lWpMRW5E63wak6alsU1C9o8u3akUwxv2OmVy6dHk0AvtHFdxUKeW52mX26MXE1rTDIywcT7JmerN2U+fz6ebb75Zp5xyinr16lXpnFmzZiktLS2w5eRE9g8NAAAAs5FhYGeuwoNK+OqLwOYqPGh1STXi/nmH3Jv5exVNPps2zkpSzKESuSoOv+GWsC9fCXn5FlcE1A/hZBiJHAMAAOoXMgyASLg2bg5qAkbd89I4AgRwPgm2UHTI6grwP0lGheL+d1Xh5r5SZfpKj3EEAKerN2dzJ0yYoHXr1mnBggVVzpk6dary8/MDW8uWoZ/0AADgWGJc5m5wNjIM7Czhu3VqN+LXgS3hu3VWl1RzEd5y0TKFRXJ9vSGwqbDI6orCUtwoWYWNGlldRo3E5xep9furA2NXRWS3CKtPyDAwUzgZRiLHAABqz+wMQ45xNjIMgIiU2eT9ogbqQGyC8mMTrC6jxsgwMBvnk2ALyYlWV4D/aewr18nl+wPjWHGFcISPDONMsVYXIEkTJ07UokWL9PHHH6t169ZVzvN4PPJ4PIGxi08QAgBqgNsgwCxkGDRkpT16auvCJREdU5HZrNL9O+f8Q1mfvxpZAZVcgdY7qI9KOh7+u+bevFPxT70e2Zr1gOvHrYq77s+BcfkTM2X06WFhReEx3G6tO6GvkgqL5Pb90khbmuCpdP76Pr0P3wos7PUr/7m4v0cHHWzXIqJaSxunhOyLayBXMSDDwCzhZhiJHAMAqD1uqw2zkGEA1FbFH66R79STKn/u8RmRLRYfV+nubc1baHdG04iWKkoIbbo65PHoq649I1qnPKbyU/8/tGmvWF/1H4wu2B18S/UKV+h7c7s8jfRRTPuwavG6XMqPTZBh45+/ZBiYifNJsI30NBltW0nbcuQywn+T33BJymwq3+zp0tHftx3aVvo63n8+Xula86+cWen+kiqudfl+TIb+G5Medq2SVOAK/Z253e3RvLjImu8PumIq3f+Wp4ViImjcpcUXZuN8kjNZ2ghsGIZuvPFGvfnmm1qxYoU6dOhgZTkAAABhIcPACXypaTo0cJApa5Ue31e+wi9qvY6RkSYjI82EilAThtutotTQJtvKFKaZ8/+pPDVZ5anJpqwFgAwDwKGO666K9177Zdy6lXW1AKgRMgwAsxid20vNKm/SNeuD2iWeBJV4an8VXF9MjPIbhfc+zLEUJR37vZW8A8dep9Qdq9L4enGdMcA2yDGwHZdLxpgL5Jr1t0gPlHH1ZVL/vuFNj4+TTuxT6VNb3ZH9Ht3jjo9oflUOuWK0tYrG3kjlxtj3ivgA7MvSpD5hwgS99NJLWrhwoVJSUpSbmytJSktLU2Iil5sHAERHjNulmCquPFiTteA8ZBgAgBXIMKgtMgwAR0pKlLp2troKRzMzw/jXg7OQYQAAViDDwAzkGNiRMXqEXH99SkZJSVhXBTbcLsmTIGP08DqoDkA4OJ/kTJVfN72OzJ07V/n5+RoyZIhatGgR2F555RUrywIAAKgWGQYAANgRGQYA4EQff/yxRo0apZYtW8rlcumtt96qdv4bb7yhs846S5mZmUpNTdWgQYO0dOnSoDkHDx7UzTffrHbt2ikxMVGDBw/W559/HsWvwtnIMAAAwK7IMbCl1BT5Hrv38NWBXdU3AB5+3iXf32ZKYd5REAAQHZZeEdgI45MjAACYze1yyX2Mf7REshachwwDALACGQa1RYYBAFjBzAzjXy8SRUVF6tOnj6666ir99re/Peb8jz/+WGeddZbuu+8+paen69lnn9WoUaO0atUq9evXT5J09dVXa926dXrhhRfUsmVLvfjiixo6dKjWr1+vVq1a1ejrQtXIMAAAK1idYdAwkGNgW6cOlO8fD8o96Q4ZJSWSFHR14ECDcELC4SbgXw2wokoAVeB8kjNZ2ggMAIAVYlyHN7PWAgAAqAtkGAAAYEdmZhj/epJUUFAQtN/j8cjj8YTMHzFihEaMGBH2+o888kjQ+L777tPChQv1zjvvqF+/fjp06JBef/11LVy4UKeddpokafr06XrnnXc0d+5c3XvvvZF9QQAAoF6KVoYBANs4daB8H70h11tL5HrxNWnrjl+ea9NSxpjfyfjNCCmlkXU1AqgU55OciUZgAAAAALZjNG+ismt+GzQGAAAAQuQXyLV2XWBo9O0lpaVaWBDM0qZNm6DxtGnTNH36dNNfx+fz6eDBg8rIyJAkVVRUyOv1KiEhIWheYmKiPvnkE9NfHwAAAAAsk5oiY+yFMi7/nXSgQCoqlpKTpPRUiauEAkC9QiMwAMBxXCbeBsHFP3AAwBJGRpoqRvzK6jKAOkWGAQCgBn74UTFX3BAYVrz6rHRSPwsLch4zM4x/PUnatm2bUlN/aequ7GrAZnjooYdUWFioiy66SJKUkpKiQYMGacaMGerRo4eaN2+ul19+WStXrlTnzp2jUgMAAKh70cowAGBLLpfUOO3wBqDe43ySM9EIDAAAAAAAAAAAbCU1NTWoETgaXnrpJd19991auHChmjVrFtj/wgsv6KqrrlKrVq0UExOjE044QZdccom++OKLqNYDAIiM0TpLFVOvDxoDAAAAQEPktroAAADqWozbZeoGAABQF8gwAADAjszOMHWVYxYsWKCrr75a//rXvzR06NCg5zp16qSPPvpIhYWF2rZtm1avXq3y8nJ17NixTmoDAISpSWP5zjsrsKlJY6srgo1YmWFmzZqlk046SSkpKWrWrJlGjx6t7Ozsao9544031L9/f6Wnpys5OVl9+/bVCy+8EHi+vLxct99+u3r37q3k5GS1bNlSY8eOVU5OTo3/jAAAQP1kx/dhUHtcERgA4DhuSWZlFT5RAwBA/eb1xOlgm6ygsV2RYQAAgB2ZmWH860Xbyy+/rKuuukoLFizQyJEjq5yXnJys5ORk7d+/X0uXLtVf/vKXOqgOAADUBSszzEcffaQJEybopJNOUkVFhf70pz/p7LPP1vr165WcnFzpMRkZGfrzn/+s7t27Kz4+XosWLdK4cePUrFkzDRs2TMXFxfryyy915513qk+fPtq/f79uuukmnXfeeVqzZo05XyQAwDT73XH6t6d50BgIF+eTnIlGYAAAAMChKpo0VcEFFwWNbcPnk7y+X8YxbsnNP0URqqxxqnacNdDqMgAAAGCRwsJCbdq0KTD++eeftXbtWmVkZKht27aaOnWqduzYoeeff16S9NJLL+mKK67Qo48+qoEDByo3N1eSlJiYqLS0NEnS0qVLZRiGunXrpk2bNum2225T9+7dNW7cuLr/AgEAgK0UFBQEjT0ejzweT9C+JUuWBI3nz5+vZs2a6YsvvtBpp51W6bpDhgwJGt9000167rnn9Mknn2jYsGFKS0vTsmXLgubMmTNHAwYM0NatW9W2bdsafkUAgGgodsVqfWyK1WUAsBEagQEAjhPjcinGZc7Hn8xaBwCsUN65i3Y+/pTVZdSIO3uzEv48JzAumTlRvh71/za8RkaavKPODBoD4SLDAAAAOzIzw/jXi8SaNWt0xhlnBMaTJ0+WJF1xxRWaP3++du7cqa1btwaef/LJJ1VRUaEJEyZowoQJgf3++ZKUn5+vqVOnavv27crIyNAFF1ygmTNnKi6OKzQBANBQRCvDtGnTJmj/tGnTNH369GqPzc/Pl3T4qr/hMAxDy5cvV3Z2th544IFq13W5XEpPTw9rXQAAYA+cT3ImGoEBAAAAoK60aSnvnyYcex4AAAAAUwwZMkSGYVT5vL+512/FihXHXPOiiy7SRRdddMx5AACLVXil0tJfxh6PFBtjXT2ApG3btik1NTUwPvpqwEfz+Xy6+eabdcopp6hXr17Vzs3Pz1erVq1UWlqqmJgY/f3vf9dZZ51V6dySkhLdfvvtuuSSS4LqAQAAgD3RCAwAcBy3yyW3SZ9aMmsdAACAYyHDAAAAOzIzw/jXAwAgHK7vflDcdX8OjMufmCmjTw8LK4KdRCvDpKamRtR4O2HCBK1bt06ffPLJMeempKRo7dq1Kiws1AcffKDJkyerY8eOGjJkSNC88vJyXXTRRTIMQ3Pnzo3o6wAAAPUf55OciUZgAIDjxLgPb2atBQAAUBfIMAAAwI7MzDD+9QAAAKKtPmSYiRMnatGiRfr444/VunXrY853u93q3LmzJKlv377asGGDZs2aFdQI7G8C3rJli5YvX87VgAGgnnIbhjzyBcalcstHQybCxPkkZ6IRGAAAAADQYHnyCtT8s28C410nH6/SDE5wAAAAAAAAoH4yDEM33nij3nzzTa1YsUIdOnSo0To+n0+lpaWBsb8JeOPGjfrwww/VpEkTs0oGAJisha9El5bsCIxfSmilHTGJFlYEoL6jERgA4Dhul3m3L3DzoTsANub59mtlTZ4YGOfOnqPS3n0srAgwn7usXEm5+4LGdkWGAQAAdmRmhvGvBwAAEG1WZpgJEybopZde0sKFC5WSkqLc3FxJUlpamhITDzeBjR07Vq1atdKsWbMkSbNmzVL//v3VqVMnlZaWavHixXrhhRc0d+5cSYebgH/3u9/pyy+/1KJFi+T1egPrZmRkKD4+3rSvFQAAWIvzSc7UoBqBk5KSrC4hbMXFxUFju9Zu17ol+9Zu17ol+9Zu17ol+9XeuXNn5eTkWF0KUOfs9nf1SHatfd5XuRZWEpm//fenqK3tLi5WwrffBI0hFb0xO2pru7J/VMzdjwXG3mmTZHTrZNr6pSvfCDz2DPqtaetG26dDTrO6hBrbcNX5GrJgqXYVl1hdCmCJ+CzzfoZFW1nuj0Hj58f0t6iSyI19cU3gsV3zl2Tj2n/6zLpCaim20wCrSwhbxY+rA48NC+uIVPnmtUHjOJt9n/NeDJwq0UZ/Vw8d9fv02oHtrSmkBp5ctTnwuEXjRtYVEqGd+wuDd+z91ppCainh9EutLiFsJR+9ZHUJpjjjy1VWlxC2D08YGDS+YPd6iyqJ3OvNeuqavT8oz1dhdSlR42/eHTJkSND+Z599VldeeaUkaevWrXK7f7lXd1FRkW644QZt375diYmJ6t69u1588UVdfPHFkqQdO3bo7bffliT17ds3aN0PP/ww5LWA2tq0uyBobNf3BOxatyTF2qj2iu8/CTy+pzR658XMdpeno9Ul1NhfkjsHHtv5+9xutfM+DKKpQTUCAwAQDrfLpRjTPv3Ex58AABEoKZP7522BobekzMJiYDdkGAAAaqBZU/muvCRojLplZobxrwcAABBtVmYYwzj2R+NWrFgRNL733nt17733Vjm/ffv2Ya0LAADsj/NJzkQjMADAcdwul4m3QSD0AACAukGGAQCgBtq1kW/67VZX4WhmZhj/egAAANFGhgEAAHbF+SRnch97CgAAAAAAAAAAAAAAAAAAAID6pkFdEbi4uNjqEsKWlJQUNLZr7XatW5K27D1oUSWR21PsDTyO6zvOwkoikzZ4QtD44AvTrSmkBryv/yXw+FBRoYWVRMjwBQ1/r3YWFRK5o/+ORlOM+/Bm1lpAbd37frbVJYRt9qfbgsadb3jDokoid/wflgQe5/283sJKIpP37h1B45/3Fpi2dlyMK2TsizXvU50dmqYGHicNvsm0dSVpUEGu3j9ifO7LuVqZGmPqa/jtnRJn2lruA3uCxr4De+Tbk1rF7MglnXdj4PGOPPvk3aPFzPuzaWvFJQT//0tpn6WEDi1NWz/rtsdMW+tYyDCoj+z0vkD8Uf/m+OCH3RZVErkzuzYLPLbTn3lDef/rt09/ZmElkXnj6pODxmU77PNvjdhW3QKP7fT+V/naZ4PGdv0+jyYzM4x/PaC2Tr53mdUlhO2M2f8NGne78S1rCqmBawe2Dzye9MbX1hUSoVkf/hg0/ssZnSyqJHIJje2ZGxOO+p1UtnqhKeu63O7QcYy57x/FDzg/8NhOf+YNJatHExkG9dGGPUVWlxC2Uce1CBrb9eeMXeuWpJ/2mHc+Kdq2HvHYTr08R4uZM9m0teK35ErP7giMz7rkBJW1yzJt/dbTnwo8tvP3uZ1rjybOJzkT/6sAAAAAAAAAAAAAAAAAAAAAG2pQVwQGACAcbpdLbpc5V7w0ax0AQGQOueO0LqlJ0Bho6MgwAADAjszMMP71AAAAoo0MAwAA7IrzSc5EIzAAAAAA21nbqJkG9h1jdRkAAACo504s3qOXf14RGF/SYYi+SMq0rB4AAAAAAAAAMBuNwAAAx3G5Dm9mrQUAAFAXyDAAAETO4/OpfXlh0Bh1y8wM418PAIBwGEkJ8vXoHDQGwkWGAQAAdsX5JGeiERgA4DhuueSWSbdBMGkdAACAYyHDAAAAOzIzw/jXAwAgLF07yvvcw1ZXAZsiwwAAALvifJIz0QgMAAAAAAAAAAAAAAAAAEA94PPEqbRN86AxAFTHbXUBAADUNf9tEMzaAABA/VXeprn23Dk+sJUf8caZ3dSHDPP444+rffv2SkhI0MCBA7V69eoq5w4ZMkQulytkGzly5BFfU+jzLpdLDz74YM0KBAAA9Y7ZGYb3YgAAQF0gwwAArFSR1UR7x58X2CqymlhdEmyEDONMXBEYAAAAcKjSkwZoy5adgbGRkGBhNZHpfGi/btv+eWD8YOuTtCmxsYUVod6KjZEvNdnqKhqEV155RZMnT9YTTzyhgQMH6pFHHtGwYcOUnZ2tZs2ahcx/4403VFZWFhjv27dPffr00YUXXhjYt3PnzqBj3n33XY0fP14XXHBB9L4QAAAAAAAAAAAAoAHhisAAAMdxu8zdIvHxxx9r1KhRatmypVwul956661q5+/cuVOXXnqpunbtKrfbrZtvvrnSea+++qq6d++uhIQE9e7dW4sXL46sMADOFBMjIzk5sCkmxuqKwpZZXqwxezYEtszyYqtLCouvR0cdevORwObr0dHqkmAjVmYYSZo9e7auueYajRs3Tj179tQTTzyhpKQkPfPMM5XOz8jIUFZWVmBbtmyZkpKSghqBj3w+KytLCxcu1BlnnKGOHfm7AQBAQ2F2hqlJjgEAAIgUGQYAANgVGcaZaAQGADiOlbdBKCoqUp8+ffT444+HNb+0tFSZmZm644471KdPn0rnfPrpp7rkkks0fvx4ffXVVxo9erRGjx6tdevWRVYcACD6XK7DDdf+jfvpIALRyDAFBQVBW2lpaaWvXVZWpi+++EJDhw4N7HO73Ro6dKhWrlwZVv3z5s3T//3f/yk5ufIrNO/atUv//ve/NX78+Mj+YAAAQL3GbbUBAJbZvF0xdzwU2LR5u9UVwUbIMAAAwK7IMM4Ua3UBAAA0BAUFBUFjj8cjj8cTMm/EiBEaMWJE2Ou2b99ejz76qCRVebW9Rx99VMOHD9dtt90mSZoxY4aWLVumOXPm6Iknngj7tQAAgPO0adMmaDxt2jRNnz49ZN7evXvl9XrVvHnzoP3NmzfX999/f8zXWb16tdatW6d58+ZVOee5555TSkqKfvvb34ZXPAAAAAAA1XAdKJD7vf8Exr7fnSPDwnoAAAAAIFpoBAYAOI5bLrllzseW/OuE20QTDStXrtTkyZOD9g0bNkxvvfVWnbw+AAD1mauwWJ6N2wLj0i5tZDRKsrCimotGhtm2bZtSU1MD+yv7IJMZ5s2bp969e2vAgAFVznnmmWd02WWXKSEhISo1AAAAa5iZYfzrAQAARBsZBgBgpdg9+5X6wZrAuODM/qrIbGxhRbCTaJxPQv1HIzAAACaoqyaayuTm5lZ6db7c3Nw6qwGAPcXk5ipxyeLA+NDwc+TNyrKwIsB8sXsOKO2lpYFx3g2/U7lNG4GjITU1NSjDVKVp06aKiYnRrl27gvbv2rVLWcf4uVFUVKQFCxbonnvuqXLOf/7zH2VnZ+uVV14Jr3AAAAAAAAAAABood3GpEr/fHBgXDuptXTEAbIFGYMDJDENNvKVq5C1XYUyc9sV4JBef5IADuEz8Vv/fOuE20QBAfRK7+Wc1/cPNgfHO7j1oBI62ffmK+fSrwNA7uJ/UJM3CgsK3KzdXL85/RmOuvErN+T6xRhQyTLji4+N14okn6oMPPtDo0aMlST6fTx988IEmTpxY7bGvvvqqSktLNWbMmCrnzJs3TyeeeKL69OkTWWEAAKD+MzPD/G89AOapKMrTgXVLld5rmGKTM6wuBwDqDzIMAACwKwvPJ8E6NAIDDpRWUarL92/ShD0b1KnsYGD/j/Epejyzh15o3Fn5sXV3NVOgrrldhzez1rJaVlZWja7OBwCoe+5dexX/1OuBcWmnNvLVs0bglPvvkxETo8Lbbg/av3tXrmb/ZZbOHnFOSCNwowcfkMvr1cEpf6rLUh3H6gwzefJkXXHFFerfv78GDBigRx55REVFRRo3bpwkaezYsWrVqpVmzZoVdNy8efM0evRoNWnSpNJ1CwoK9Oqrr+rhhx+OvCgAAI7BkFTqcgeNUbfMzDD+9QBEbuKql+V1uTV3wMVB+yuK9mvf6lfUqMOAkEbg61e/ohjDpzkDL6nLUgGgXiDDAAAAu7L6fBKsQSMw4DBnFezQK5uXK8lXEfJch7KDemjHat2z80td3P7XWpbayoIKAURq0KBB+uCDD3TzzTcH9i1btkyDBg2yrigAgG0ZMTFKnXWvJIU0A1em0YMPKHXWvSqYeke0S4PFLr74Yu3Zs0d33XWXcnNz1bdvXy1ZskTNmzeXJG3dulVutzvomOzsbH3yySd67733qlx3wYIFMgxDl1xCcwEAwHwrGzVXSp8rrC4DACzndbl106qXJSmkGbgy169+RTetelmP0gQMAAAAAEC9RyMw4CBnFezQwp+WySVD7kqe9+9L9FVo4U/LdH7Hs2gGRoPkknl3L4h0ncLCQm3atCkw/vnnn7V27VplZGSobdu2mjp1qnbs2KHnn38+MGft2rWBY/fs2aO1a9cqPj5ePXv2lCTddNNNOv300/Xwww9r5MiRWrBggdasWaMnn3yytl8eAMCB/M2/4TQDH9kEHE7TMGrHygzjN3HiRE2cOLHS51asWBGyr1u3bjKM6q+9eO211+raa6+tYUUAAKC+MzPD+NcDEDl/8284zcBHNgGH0zQMAA0RGQYAANhVfTifhLpHIzDgEGkVpXpl83K5ZCjmGHNjJHll6JXNy9Wh50XKj/XURYmAI6xZs0ZnnHFGYDx58mRJ0hVXXKH58+dr586d2rp1a9Ax/fr1Czz+4osv9NJLL6ldu3bavHmzJGnw4MF66aWXdMcdd+hPf/qTunTporfeeku9evWK/hcEAGiQwmkGpgkYAAAAAOwlnGZgmoABAAAAALCfyi4KWmfmzp2r448/XqmpqUpNTdWgQYP07rvvWlkS0GBdvn+TknwVx2wC9ouRlOSr0Jj9P0azLMASbpfL1C0SQ4YMkWEYIdv8+fMlSfPnzw+5ml5l8/1NwH4XXnihsrOzVVpaqnXr1umcc86pxZ8QjoUMA8AJCm+7XQVT71DqrHvV6MEHgp6jCdgaVmYYNAxkGACAFczOMOQY5yHDmGvugIv16MBLdNOql3X96leCnqMJGAB+QYaBGcgxAAArkGGcydIrArdu3Vr333+/unTpIsMw9Nxzz+n888/XV199peOOO87K0oDIlZcrft23cpWWVDvN2zhDFd26h+yPW/+d3AX5x3yZwYW7Ao8/T2qqcndwa2/TihJ1LTlqHcPQrbvWHXPtykzcs16PN+0h8YMdDYhL5n1L8zfDmcgwQP2VUlGqXsV7IzpmT1ySNiU2Dtnft3C3En3lcq8P/6e9r3sHyX3U5y335cu963BNrs07IqrNakdeGbhj7k61kdTzwQeUunhRSBOwK2+f4n7Ijmh9b4uW8rZrH7I/dmuuXF5f+Au5XCpv3yJkt3v/QcXujOz7oT4jw6C2yDAAACuYmWH868FZ7JJhYrwV6pL7o+LLyyVJu9KbaVd6s5B5vbaul9sX/r93KmJitL5Nj5D9rfJ3qXnRvohq/Klxax1ITA2+MvDBvXpY0o3fLdNN65bQBAwA/0OGgRnskmOAsJSXK/67b+UqKQ1rui8jQ+Vdu4Xsj1/3rVyFhVUeF1PJD8zSE0+S4uKC9rl371bcT5vCqsWvok1beVu1Dq1p1Uq5DCPsdYx4j8pOODFkf0xegWIOFkdUU3mzxjISg+/S7SorV9yuvIjWAY7E+SRnsrQReNSoUUHjmTNnau7cufrss88qDT2lpaUqLf3lF4oRwQ9hIKrKy5V19hmK//brY04tHjZCe//5r5D9jaf8QQmffnLM41cc8bjtcRcr150U9PyZB3P0wpaPjrlOONySOpUdVIa3VHmxCaasCQANARkGsN66pKY6o/dFgfGGxAxJUo9DeXp/3WsRrfViZg/9vsvZIfv/sek99SreJ00Jf61Dr88OaQSO+exrxf/j1Yhqssqu3Fzt3pUbvPPsYeqYu1Ndnp2nnyTFLl6kzRdcqOyzh0lfrw1My/zvJzrhjqkRvV7hxEkquGdmyP70+YsierPM54nTnnuvD9mf+Pl3arRsdUQ1AQ1ZpBlGIscAsL/WZYW6dP9PgfFLjTtqe3wjCysCECk7ZJgYb4XmPXGjuu38pRHh6TMu17wzx4bMfeS5qUouDf/fO3sbZWjUlFdC9l/67bsa/9VbEdV59a/G6f1WvSRJf23fXxVF+3XruiWaICl23RI93Gu4/ta+v7Q7+E6BscmNFZucEdFrAQAAziehASkvV8thv5YnjJ4Yv6JRo7X7medD9je57WYlrPk8opffvnGLfI2D82jiB++pyY2h5wWqc+COaSq4+Q8h+5v/5ly5ysrCXqeiTVvlfPVdyP5Gn61To9Wh+6uzd8xwlXZuE7Qv5sBBpS/+b0TrAICljcBH8nq9evXVV1VUVKRBgwZVOmfWrFm6++6767gy4Nji130bVhOwXaV4y2kERoPi/t9m1lpwNjIMYI2DsR6tTgm9AqzdGEd9gt1qL85/RrP/MqvS50ok+T+TPvT1V/Xj68HNzaMkvR3V6sxhxMYce1I9RYaBmcLJMBI5BoD9tS0r0r07vwiMP0luTiNwHTMzw/jXg3PV1wzTJffHoCbg+mr3J89qyxHjP0i6UVK8pFJJf1i3RFq3JOS4JgMuVtOBl9RNkQBQT5BhYDbOJ8HO4r/7NqImYJjPzuc2UPc4n+RMljcCf/vttxo0aJBKSkrUqFEjvfnmm+rZs2elc6dOnarJkycHxj169FBOTk5dlQpUyVVaYnUJUXUwpn41qABAfUCGAVBbvo6tZXRoZXUZQcZceZXOHnFOyP6Oz8+X59l5qtDhf0S+f8GFyp44KWhO5n8/kSK8InBdK2+VqYqWTa0uA7BUJBlGIscAAID6ob5nmPjy8qitbaZmvxqndv+7IrAk3fjdMsWvW6IKHf7g50O9hutvx50VclxscuO6KxIwkdG1g8qfn/3LjrYtrSsGgGNxPgkNgauk9NiTEDVlWU1UntXE6jIA1HOWNwJ369ZNa9euVX5+vl577TVdccUV+uijjyoNPh6PRx6PJzB2uVx1WSoQtry/zFZ5z8pvSeZtXPnts/bf/5DcBfnHXPvimx8NPN4X4wl5/oOUlhrS+ajmDcPQP7d8pBYVxRF9UsMn6ef4FOVV8jqAnblcLtN+h/C7yLnIMED9tCExQ0N7/S6iY/bEJVW6//edz1air1z/HtM6/MViQj+R7T25j0qPavg14uIONwHXs09wN8/KUvOsrKB9jR58QKnPztPGceN15rPz9N9zzlX7119VRtduKrzt9sA8V5s22nvCCRG9nrdF5SfgDlx5rlxeX/gLVfFz9dBJx6msS1tJhz8tX9GyaaX/j+yCDAMzRJJhJHIMAKD2zMww/vXgPHbLMA+OulH/7XZypc/dfMUsuX3h/3unoop/w7zUe4Q+6Dggorp+atxaCYmpkqTrV7+im9Yt0aM9z9LD65fppl7Ddeu6JYpNbqy5Ay6OaF2g3kpKlLp3sroK2BQZBmbhfBIagrLex2v7ik8Vs2e34n76URXtO8iXlFztMb6Myntj9j34iFyFhVUeF1PJt72vUUrIvkNnnq1di5ZWX/hRKtq0rXT/rjcXyWUYYa9jxFfeQ1N4ci8dOq5jRDWVNwv90J03PUV7xo06/FqxMYebgGO4LivCx/kkZ7K8ETg+Pl6dO3eWJJ144on6/PPP9eijj+of//iHxZUBNVfe8ziVnjw44mPC8WmjBdU+vzc2QXsbJYTsf7h5Lz20Y3VENUnSnMyeVTZWAHbldh3ezFoLzkSGAeqng7EerUw15yq7axs1kyT5etbyhFGTNPmapJlQUd1r9OADSp11rwqm3qGfzh6mbc/O0/rbbldan75KnXWvJAWagY2MJiqLMANXpaJt1rEnhcHXOEW+xqFvENoVGQZmIMMAAOqamRnGvx6cx24ZZlPzjtqV3qzS59a1rfpKxpHYkdZcO9Ka1+jY61e/optWvaxHB16iv7bvr23rl+lvx52l2OTGumnVy5JEMzAAxyPDwCx2yzFAZYzkZJUf10vlkkqG/LpWa5X16l3t8zFh9qf4mjVTabPKM3ekygYOMmUdb0aqvBmptV7HiI9TWTtzzpPAmTif5EyWNwIfzefzqbSUS8rDXsqO76uclV8Ext5WEVw1ro680Liz7tn5pRJ9FQrnGmheSYfcsXqxMZ+UBoBwkGFgRxXt2invnvuCxoDfkU3AhbfdLn29NvCcv/n36GZgAPZDhgEAAHZEhqm5I5uA5w64WNr9Y+A5f/MvzcAAAEQPOQYAAESDpY3AU6dO1YgRI9S2bVsdPHhQL730klasWKGlSyO7dDtgNSMpSRVdulpdRrXyYz26uP2vtfCnZfLKqLYZ2CvJkEsXtf+18mMrv6UBYGcul3kXuuaC2c5EhkFD4W3RUgU3TLS6DNRDIU3AlaAZuO6RYVBbZBgAgBXMzDD+9eAsZBjzhDQBV4JmYAA4jAwDM5BjAABWqA/nkx5//HE9+OCDys3NVZ8+ffS3v/1NAwYMqHTukCFD9NFHH4XsP+ecc/Tvf/9b5eXluuOOO7R48WL99NNPSktL09ChQ3X//ferZcuWNSuwAbK0EXj37t0aO3asdu7cqbS0NB1//PFaunSpzjrrLCvLAhqsZamtdH7Hs/TK5uVK8lVIktxHPO/7338PuWN1Uftf632TbqsNAA0NGQZAQxZOE7AfzcCAvZBhAACAHZFhzBFOE7AfzcBoMAqL5Mr+KTA0unWUGiVbWBAApyHHAACc6JVXXtHkyZP1xBNPaODAgXrkkUc0bNgwZWdnq1mzZiHz33jjDZWVlQXG+/btU58+fXThhRdKkoqLi/Xll1/qzjvvVJ8+fbR//37ddNNNOu+887RmzZo6+7rqO0sbgefNm2flywOOtCy1lTr0vEhj9v+oiXvWq1PZwcBzP8enaE5mT72Q0VkFMfEWVglEl1vBTfC1XQvOQ4YB0JC5vN6wmoD9/PNcXm80y4LIMKg9MgwAwApmZhj/enAWMow5YgxfWE3Afv55MYbvGDOB+su1aYtir78jMK54cpaMvj0trAh2QoaBGcgxaCjc+QcUv/arwLisbz/50tKtKwhAtaw+nzR79mxdc801GjdunCTpiSee0L///W8988wzmjJlSsj8jIyMoPGCBQuUlJQUaAROS0vTsmXLgubMmTNHAwYM0NatW9W2bdsaVNnwWNoIDMAa+bEePZ7ZU4837aEMb6lSvOU6GBOnvBgP96WBI7hcLrlM+l43ax0AAOqLg1P+VOn+Zs2zNPmPU9WseVbIc1wJuG6QYQAAgB2ZmWH86wGI3JyBl1S6Pza5sZoMuFixyY1DnuNKwACcjAwDAL+I27BBLX53fmCc885SlZ48yMKKAFQnGueTCgoKgvZ7PB55PJ6Q+WVlZfriiy80derUwD63262hQ4dq5cqVYb3mvHnz9H//939KTq76bh75+flyuVxKT08Pa00noBEYMIF7f57iP18dGJedNEC+xhnVHFFPuFzKi01QXmyC1ZUAAACgnmuelaVbq2gSBgAAAADYU2xyhppW0SQMAAAAAIAktWnTJmg8bdo0TZ8+PWTe3r175fV61bx586D9zZs31/fff3/M11m9erXWrVtX7VX1S0pKdPvtt+uSSy5RampqeF+AA9AIDJggLvt7Nbv0wsB416KlKj15sIUVAaiO23V4M2stALArz2cr1eLcYYHxzkV8ghuoz8gwAADAjszMMP71gPpma2Zr3XXh1KAxAMDeyDAAAMCuonE+adu2bUFNt5VdDdgM8+bNU+/evTVgwIBKny8vL9dFF10kwzA0d+7cqNRgVzQCAwAAAAAAAAAAADV0IDldy/r82uoyAAAAAACIitTU1LCuvtu0aVPFxMRo165dQft37dqlrKysao8tKirSggULdM8991T6vL8JeMuWLVq+fDlXAz4KjcAAAEfig9cAAMCOyDAAAERmkydV49v8KmiMukeGAQAAdkSGAQAAdmVVjomPj9eJJ56oDz74QKNHj5Yk+Xw+ffDBB5o4cWK1x7766qsqLS3VmDFjQp7zNwFv3LhRH374oZo0aRKN8m2NRmAAgONwW20AAGBHZBgAACK3Oy5RLzTpYnUZjsZttQEAgB2RYQAAgF1ZfT5p8uTJuuKKK9S/f38NGDBAjzzyiIqKijRu3DhJ0tixY9WqVSvNmjUr6Lh58+Zp9OjRIU2+5eXl+t3vfqcvv/xSixYtktfrVW5uriQpIyND8fHxNfviGhgagQEAAAAAAAAAAAAAAAAAAFArF198sfbs2aO77rpLubm56tu3r5YsWaLmzZtLkrZu3Sq32x10THZ2tj755BO99957Ievt2LFDb7/9tiSpb9++Qc99+OGHGjJkSFS+DrupUSPw2LFjdcYZZ+i0005Tp06dzK4JAICocrlccrnM+fiTWeugbpBhAAB2RoZxNnIMAMCuzMww/vVgH07JMLEV5Uo7VBAY5yemqiI2zsKKAAC1RYZxNqdkGABAw1QfzidNnDhREydOrPS5FStWhOzr1q2bDMOodH779u2rfA6/cB97Sqj4+HjNmjVLXbp0UZs2bTRmzBg9/fTT2rhxo9n1AQAAmIYMAwAA7IocAwAA7MgpGabn9mwteuD/AlvP7dlWlwQAAGrBKRkGAAA0HDVqBH766af1ww8/aNu2bfrLX/6iRo0a6eGHH1b37t3VunVrs2sEAMBUbpe5G+yDDAMAsDMyjLORYwCgZmINnxpXlAa2WMNndUmOY3aGIcfYCxkGAGBXZBhnI8MAAOyMDONMsbU5uHHjxmrSpIkaN26s9PR0xcbGKjMz06zaAACICtf/NrPWgv2QYQAAdkSGgUSOAYBIDSjaoxWbFgfGQzqfo08bNbewIucxM8P414P9kGEAAHZDhoFEhgEA2BPnk5ypRo3Af/rTn7RixQp99dVX6tGjh04//XRNmTJFp512mho3bmx2jQAAAKYgwwAAALsixwAAADsiwwCwktGksby/GRY0BoBwkGEAAIDduGty0P33368ff/xR06ZN04IFC/TXv/5V559/PoEHAGALbpfL1K0mHn/8cbVv314JCQkaOHCgVq9eXe38V199Vd27d1dCQoJ69+6txYsXBz1vGIbuuusutWjRQomJiRo6dKg2btxYo9oaMjIMAMDOyDDORo4BANiV2RmmJjmGDGMdMgwAS7VpId/UGwKb2rSwuiLYCBnG2cgwQDBv8+YqGHd1YPM25047QH1mdYaRyDFWqNEVgb/66it99NFHWrFihR5++GHFx8fr9NNP15AhQzRkyBB17drV7DrDkpSUZMnr1kRxcXHQ2K6127VuSdpT7LWoktopX/us1SWELa7vuKBxyuXTrSmkBg6+MD3wODG5kXWFROhQUaHVJdTY79VOL2q7imTPv5uReOWVVzR58mQ98cQTGjhwoB555BENGzZM2dnZatasWcj8Tz/9VJdccolmzZqlc889Vy+99JJGjx6tL7/8Ur169ZIk/eUvf9Fjjz2m5557Th06dNCdd96pYcOGaf369UpISKjrL7Heqq8Zxs42/f23VpcQts43vBF4nPfuHRZWEpmMEfdaXUKN/by3IPC4Q9NUCyuJTNLgm4LH591oUSWRK377b4HH+y2so7aybnvM6hLClvvgJPW7d5525hdZXUrUkWGsVV9zjJ3fF1i53T7/fvrgh92Bx3b+M7dr7WNe+sbCSiLz26c/s7qEGivbkR14nDzyfgsriczR73/Z7fu8c+fOysnJsbqUqCLDWKu+ZhjUjW43vmV1CaZIaBz6s6K+Ktn/S25MsNnvpCDrlllTSA2UrV4YeBxv4z9zMkz9Q4axFhmm9t75bmfQ2G4/Z/zsWrck5RZVmLZ2RYeO2veX2aatV512TVPq5HXMsGXvwaBx6+lPWVRJ5LZPvybw2M7f53ar3QkZRiLHWKVGVwTu06ePJk2apDfeeEN79uzR4sWLFR8frwkTJqhHjx5m1wjUexVZLVRw3YTAVpHFJ4qB+szlMneTpIKCgqCttLS0ytefPXu2rrnmGo0bN049e/bUE088oaSkJD3zzDOVzn/00Uc1fPhw3XbbberRo4dmzJihE044QXPmzJF0+JNPjzzyiO644w6df/75Ov744/X8888rJydHb731ltl/fLZGhgGCGQkJKu/UObAZ/CMJqNfIMM5GjgEA2JXZGSbSHEOGsRYZBgBgV2QYZyPDAADsjPNJzlSjRmDDMPTll19q9uzZOu+883TGGWfoxRdfVO/evTVp0iSzawTqPW/7Djpw7/2Bzdu+g9UlAaiGyzBM3SSpTZs2SktLC2yzZs2q9LXLysr0xRdfaOjQoYF9brdbQ4cO1cqVKys9ZuXKlUHzJWnYsGGB+T///LNyc3OD5qSlpWngwIFVrulUZBggWFnfftqx6svAVta3n9UlAagGGcbZyDEAALsyO8NEkmPIMNYjwwAA7IoM42xkGACAnXE+yZlia3JQRkaGCgsL1adPH51++um65pprdOqppyo9Pd3k8iITctuYeuzoS5P3n7bUokoid9oD/wk8fmXtdgsricw7P+QFjed9stmaQmrgvYm/Cjw+tPgJCyupnfgu11pdQo18fPJ7VpcQts/PPDto/PvfdLOoksid8KZ9/pwrs23bNqWm/nLbe4/HU+m8vXv3yuv1qnnz5kH7mzdvru+//77SY3Jzcyudn5ubG3jev6+qOTisvmaYP3b3Wfr6kYhvHfxJd7vmL7vWLUldh/5oUSW1c+RtEu3msyZ3WF1C2JI6ZQYeV3xvn8bu2O6/ChofeSvT+s5Ot4itDBnGPuprjrHz79TCIvvU3ii5YeQYu9ZevnmtdYVEKK5936Cx+6c11hRSA7Ed+wceP5LSxbR1W1YcChpP2PGNfhObaNr6Nx/cGDS26/e5HYWTY8gw1quvGWbZLaeYup77U5f09C/jv17cW77Bg01ZOyU5+O/qNzsOmLJuXft8R77VJYRt/IB2QWM7/WxPaCDvf5Xu3WFRJbVT9NqDVpcQtoaS1e2IDGMP9TXDnNCikaWvH4lWGSlBY7v+nDn94RXWFRKhEXNXB43P6mOfO1nfMfSXvga7fq9I9q3drnVL9q7dbjifVP/VqBH4xRdf1Kmnnhr0PxcAANswfIc3s9aSlJqayu9FGyDDAABsjQzjaOQYAIBtmZlh/OuJHGMXZBgAVnKt/Uaxv58QGFf843EZfY+3sCLYChnG0cgwAABb43ySI7lrctDIkSMD/2O3b9+u7dvtc1VYAACs1LRpU8XExGjXrl1B+3ft2qWsrKxKj8nKyqp2vv+/kazpVGQYAABqhgxjPXIMAACRI8NYjwwDwFIlJXL9+FNgU0mJ1RUBYSHDWI8MAwRrkf2trh97VmBrkf2t1SUBqKfIMdapUSOwz+fTPffco7S0NLVr107t2rVTenq6ZsyYIZ/PPre2BgA4k8vwmbpFIj4+XieeeKI++OCDwD6fz6cPPvhAgwYNqvSYQYMGBc2XpGXLlgXmd+jQQVlZWUFzCgoKtGrVqirXdCoyDADAzsgwzkaOAQDYldkZJpIcQ4axHhkGAGBXZBhnI8MAwWLKSpWRszWwxZSVWl0SgGpwPsmZYmty0J///GfNmzdP999/v0455RRJ0ieffKLp06erpKREM2fONLVIoL7rtnm97nz6z4HxjKtnKrt9TwsrAlCtKNwGIRKTJ0/WFVdcof79+2vAgAF65JFHVFRUpHHjxkmSxo4dq1atWmnWrFmSpJtuukmnn366Hn74YY0cOVILFizQmjVr9OSTT0qSXC6Xbr75Zt17773q0qWLOnTooDvvvFMtW7bU6NGjzfk6GwgyDBCsU2mBJu/+5VPbs5v11o8ebukC1FtkGEcjxwAAbCtKt9UOFxnGWo7JMKmp8p56atAYAGBzZBhHc0yGAQA0TJxPcqQaNQI/99xzevrpp3XeeecF9h1//PFq1aqVbrjhBkIPHCfWW67MA3uCxgBQlYsvvlh79uzRXXfdpdzcXPXt21dLlixR8+bNJUlbt26V2/3LRfsHDx6sl156SXfccYf+9Kc/qUuXLnrrrbfUq1evwJw//vGPKioq0rXXXqsDBw7oV7/6lZYsWaKEhIQ6//rqMzIMEKx5+SFds++HwPifjTvTCAygSmQYa5FjAACoGTKMtZySYXy9eunQkqVWlwEAaEDIMNZySoYBACAayDHWqFEjcF5enrp37x6yv3v37srLy6t1UQAARJVhHN7MWqsGJk6cqIkTJ1b63IoVK0L2XXjhhbrwwgurXM/lcumee+7RPffcU6N6nIIMAwCwNTKMo5FjAKBmylxu7XQnBI1Rx8zMMP71IkSGsQ4ZBgBgW2QYRyPDAABsjfNJjlSjdz379OmjOXPmhOyfM2eO+vTpU+uiAAAAooEMAwAA7IocAwA1szfGo38ltwlse2M8VpcEOAoZBgAA2BEZBgAA2E2Nrgj84IMP6pxzztH777+vQYMGSZJWrlypbdu2afHixaYWCACA6Qzf4c2stWAbZBgAgK2RYRyNHAMAsC0zM4x/PdgGGQYAYFtkGEcjwwAAbI3zSY4U8RWBy8vLdffdd2vx4sX67W9/qwMHDujAgQP67W9/q+zsbJ166qnRqBMAANO4DEMuw2fSZuJtoRBVZBgAgN2RYZyLHAMAsDNzMww5xk7IMAAAOyPDOBcZBgBgd5xPcqaIrwgcFxenb775Ri1atNC9994bjZoAAABMR4YBAAB2RY4BAAB25KQM49qwQZ677gyMS++ZIaNHDwsrAgAANeWkDAMAABqOiK8ILEljxozRvHnzzK4FAIC64b8NglkbbIMMAwCwNTKMo5FjAAC2ZXaGIcfYilMyjGv/fsUuXhzYXPv3W10SAKC2yDCO5pQMAwBooMgwjhTxFYElqaKiQs8884zef/99nXjiiUpOTg56fvbs2aYUBwAAYCYyDAAAsCtyDADUTGNvmQaV7QuMV8Y30f6YeAsrApyFDAMAAOyIDAMAAOymRo3A69at0wknnCBJ+uGHH4Kec7lcta8KAIBoMvNTS3z6yVbIMAAAWyPDOBo5BgBqJtHwqktFYWC8Ni5dXKezjpl99RhyjK2QYQAAtkWGcTQyDADA1jif5Eg1agT+8MMPza4DAIC6Q+hxLDIMAMDWyDCORo4BANgWTTSORoYBYCXj5AEq27vD6jJgV2QYRyPDAKF87hirSwAQLs4nOVKNGoFR/5Ud3Kc9XyxW5onnKD6lidXlAAAAAAAAAAAAAAAAALCZ7b37a9Z7660uAwBQDRqBbe6aFS/I53Jr3umXBe0vL8zTzo9eVHq3k0Magcd/9E+5DZ+eGnJ5XZbaoBkut0riE4LGAOoxwyf5+PQTAACwGTIMAADVGli6T4ak1Z7wL4wwoHSfXJJWRXAMImRmhvGvBwAAEG1kGAAAYFecT3IkGoFtzudy67oVz0tSSDNwZcZ/9E9dt+J5PTFkbLRLc5T1HXvr/NnvW10GAABARNYlNtbQTsODxgAAAIBdGZIGleVJCq8ZeEDpPg0qy9PK+IwoVwYAAAAAAAAA0UMjsM35m3/DaQY+sgk4nKZhAGioXIZPLpM+tWTWOgBghYKYeH2c0sLqMgCEiQwDAED1/M2/4TQDH9kEHMkVhBE5MzOMfz0AAIBoI8MAAAC74nySM7mtLsDv/vvvl8vl0s0332x1KbYz7/TL9MSQsbpuxfMa/9E/K51DEzAAHMHwmbvB8cgxAIA6QYaBycgwABqi1Z4mWhmfoUFleRpQuq/SOTQB1zGzMww5xvHIMADCtnOn3H//R2DTzp1WVwQ7IcPAZGQYAECdIcM4Ur24IvDnn3+uf/zjHzr++OOtLsW2jr4y8GNdBwSeowkYAIDoIccAAAA7IsMAaMiOvDLwutiKoOd6lBeoV0UBTcCATZFhAETCtWWbYu+6JzAuP6GfjBbcHQtA3SPDwO5S9uTquOWLAuPvfn2uDmZmWVgRAOBoljcCFxYW6rLLLtNTTz2le++91+pybO3IZuCywn16SNI9H/1Tv8teWWkT8PFbv5NLRtjrl8fEaX2rbiH7k7dtVuLe3RHVmt+pq8pT04P2xRwqVuPv10W0TmlaYx3s2CVkf9oP6xVXVFjtscf9GPyp3+/bHydvTPBfibSD+9V699aw69mR2UYHUjPCng/AIoZxeDNrLTgWOQYNRbPyQ+pcWhD2/H2xHmUnpIfs71O8T8m+itADJLnWrq90v9GrmxQbE7xz7365tkd2hRajRTOpedOwX7dK8XEyeobmy4QtPyt+z66Ilirq2kPe1LSgfe7iIjVa/6188Qkq6nGcjLi4yOqDs5FhYBIyDAAnOLIZ+Eg0AVvAzAzjXw+ORIYBUFuu9VW/T2S0bydlNQ/e6fXK9fkXYa/v3vCzDE+8jI6tQl97x265CorCXkuSfO1bSIkJER0DE5FhYBIyDI4W461Q55xNii8vC/uY/OQ0bW3eLmR/5x0blVh6qNJjWrt3VLp/R8++Mo7qjUnO26PGO7ZU+frNf8rWmU89GBhv79mXRmCgPuN8kiNZ3gg8YcIEjRw5UkOHDj1m6CktLVVpaWlgbDj8G63s4D6VFwa/kf1Y1wEqK9ynSWv+rRskxWav1Ketuh2+QvDOjUFz5z7/R8V7K2/UqExOWnOdf/PzIfu7vjRPXV5+NqLaP/r7i9o1eEjQvuQd2/Trcb+NaJ3tvx6uT2c/HbL/hPv+rMy1n1d77K+PGl806x3lpzQO2nfihtW6/fkZYdez4OzLVRLv0fsDhmtPBqEHABq6cHMMGQb1VbK3XF1K85Xk8+r1nz9QE2/psQ+S9Ep6B13efkjI/rnbPlX/Q3srP+jaxZXuLl/+stQoKWif65PPFXvf42HV4ue98Qr5Lg/NkjHX/1kub/i3rDFaZ6nijX+E7G/1zFy1fDGyzPvt86/pwCmnB+1L2LpZfS4eJUkqPK631r6+lGZgAHWO92IANET5vgoVGMHvdW6LTZbLW6qTvb803XwWk6zXY5Mlb0nQ3FRXrNLclr9dDqAaZBgAtRX7xz9X+VzFQ/fLd+XlwTtLShV37m/CXj9Okq9DK5U8eHPoc6+9r9j/fBX2WpJUcv8k+Tq3iegYAPUPGQZHivFWaO6j16vrjo3HnnyED/r+WjMuvytk/x9efUjdt2VHtNaDC79QWXKjoH1dPluhkbPviGgdAED9Yuk7mwsWLNCXX36pzz+vvmHTb9asWbr77rujXJV97PlisXZ+9GLI/psk/V6S53/jd3Zka8OTE0PmGS53VOtzov977wVJ0poeJ9MIDNRnhu/wZtZacKRIcgwZBvVVt9J8ffbDO1aX4Sjxe/cEHjf67lslb/hOhcf3ta4g2AsZBibgvRgADdWn5flaetTVfyXpX5J+0uE3wiskXeQt0rbi0KvxDYvP0AiuEhwdZmYY/3pwnPqeYXx9+6roq7WBsdG6dZ29NoBqeDzHngNUhQwDE9T3DIO61zlnU8RNwPWRN57fsUC9xvkkR7KsEXjbtm266aabtGzZMiUkhHdLk6lTp2ry5MmBcY8ePZSTkxOtEuu9zBPPUXq3k0P2X/flu/Ks+bcqdPh/8KhW3bRw5I0h81zzbpYiuDoawrOxdVf91Lqz1WUAqIbLMOQyKay4+CSuI0WaY8gwqK++SczQV4kZ6ncotGEC0ZG4+aegsbuspIqZQCgyDGqL92IANGSD49LUKzY5ZP/Q8nzFlheoVIcvnPBkXKrej0sLmZfq4mrA0WJmhvGvB2exRYZJSpLRtWv01gdQI0avnvL17iX3t+usLgU2RIZBbdkiw6DObW3WVtfc8qQSykp077N3KK24wOqSIpbbuad2depudRkAqsH5JGey7N3NL774Qrt379YJJ5wQ2Of1evXxxx9rzpw5Ki0tVUxMTNAxHo9HniM+uelyueqs3vooPqWJ4lOCr1Ix/qN/6ro1/9Zj/UfqoTX/1uxug/S77JWa9MNqzTv9sqC514/9i1wK/y9reUzltyz+4dLx2nb2qIhqz+8U+oZYUas2Wv7sGxGtU5rWuNL9X/5ppuKKCqs9dtE3O4PGhUkpIXO+6DFAk28J/7bUZbEe/dS6s7wxnDgAgIYs0hxDhkF9VeFy65Suo3T8oTwl+LxhH7cvtvJPel/fZrCSfRWVPvf+H0+tfLGE0LWMX52kiidnhV2PJBktmlW63zt3ZkTrKL7yzLvjquu1Z9RvI1qqqGuPkH2H2raPrB4AMBHvxQBoyNLcsUo76u3uAaX7NKi8QEviUjWivEDvxqVqeHmB0lyxWs3VfwHbIMMAqLG4OFW8t0iudeul0tJqpxrt24XuTPCofNGbYb+c96tlMjzxlT5X/ruhqjh7UNhrSZKvVWZE8wHUL2QYVOaQJ0kbW3dV44N5umPcvWEfl58c+oFWSXrowj8osfRQpc/171z5v3vLK2lM33jyED33138esw5vvEe7OnWXL7bycykAAOtY1q145pln6ttvvw3aN27cOHXv3l233357SODBsY3/6J+6bsXzemLIWD3RdYC2rfm37jr9Mu1t0UXXrXhekoKagb9pe5wpr1vUpr2K2rSv9TrexCTt7Teg9gVJyu/a85hzvivafOx1UhorP6XyZmMANsZtEFBL5Bg0JBUut75MamrKWl8nVd1MYfQ9dj4LaNpYRlNzMlhEr1uNknYdVNKuQ63X8SUlmVANHIsMg1oiwwBwkgGl+zSoLE8r4zP0fmyyVF6g9+PSlOaK1aCyw3fEoBm4jnBbbdQSGQZArcTFyejXp2bHxsTIODn8c5e+kk1VPme0aiajVc3KgEXIMKglMgyqsz8lQ/tTMmq9zqZWXap8Lqt3i7DXKcrIVFEGH0ABGgzOJzmSZY3AKSkp6tWrV9C+5ORkNWnSJGQ/ju3IJuB5p18m7dwYeM7f/FtZMzAAAIgcOQYAANgRGQaAUxzZBLza00TylgSe8zf/0gwM2AcZBoAjFR2Se2tuYOhrmyUlJ1pYEIBIkWEAAEBdsqwRGOYJaQKuBM3AAHAEPv0EAADsiAwDAMAxhTQBV4Jm4DrG1fTgBHl5ilm9KjD0DhgoZdT+Cm8AnMu9NVcJd/49MC6ZcYN8PWp/typEgAwDAADsivNJjlSvGoFXrFhhdQm2E04TsB/NwAAARA85BgAA2BEZBkBDEk4TsB/NwIC91bcM4/7+eyVecEFgXLzsffkGD7awIgAAUB/VtwyDupd8qFBddvxyh++NrbqoKLGRhRUBABqKetUIjMi5DV9YTcB+/nluuvUBOBmffgIAAHZEhgEAoFouKawmYD//PFcUa4K4mh4AALAnMgyAKOi48yc9MveWwPjGCY/p247HW1gRgAaJ80mORCOwzT015PJK98c1ylCL08corlHorae4EjAAp3MZPrlMCitmrQMAAHAsZBgAAKq3qooG4FRXrIbFZyjVFfp2OFcCjj4zM4x/PQAAgGgjwwAAALvifJIz0QjcQMWnNFGrKpqEAQAAAAAAAMAp0tyxGkHDLwAAAAAAAIAGikZgAIDz+HyHN7PWAgAAqAtkGAAAYEdmZhj/egAAANFGhgEAAHbF+SRHohEYAAAAAOpIeXqG9owYFTQGAAAAAAAAAAAAAKCmaAQGADiPYRzezFoLAIAwHercVd/PecbqMmBXZBgAAGBHZmYY/3oAAADRRoYBAAB2xfkkR6IRGADgPIbv8GbWWgAAAHWBDAMAAOzIzAzjXw8AACDayDAAAMCuOJ/kSG6rCwAAAAAAAAAAAAAAAAAAAAAQOa4IDABwHJfhk8ukTy2ZtQ4AAMCxkGEAAIAdmZlh/OsBAABEGxkGAADYFeeTnIkrAgMAAAAAAAAAAAAAAAAAAAA2xBWBAQDOY/gOb2atBQBAmJI3rFPnO28LjDfNeFBFPXpZWBFshQwDAADsyMwM418PAIAGzkhvpIozBwSNUcfIMAAAwK44n+RINAIDAJzHMEwMPYY56wAAHCGmqFCpX60JGgNhI8MAAAA7MjPD+NcD6hmjRQuVTbwxaAwAtWG0yFTZ9RdaXYazkWEAAIBdcT7JkWgEBgAAAAAAAAAAAGrI6NBBZQ88YHUZAAAAqOfyUjP09smjgsYAAJihQTUCJyUlWV1C2IqLi4PGpz3wH4sqqZ2L+7a2uoSwvbJ2e9D4vYm/sqiSyJ0955PA48Rz7FP3ocVPBI1jugyyqJLIeTeuDDw+7bNPLawkMh+fPDhofMKb71lUSeS+/M3ZGv7uR9pdUhr9FzO8ks9r3lqAg5Rt3xA0jrdp/rJzbrRT7XF9xwUexw8438JKIlO2eqHVJdTYxz/u+WVQnm1dIRGq+P6T4LFFddREyf7d6nRcH+3I2Rn9FyPDoB6y0++lo3+n+mx0IYPCInJMXQuqffcP1hUSofLNa4N3+OzzW7Xip1/umjCnzyUWVhKZR1K6BI3t9n3euXNn5eTkRPeFzMww/vUABzlYFPz7NCXZPj9nvtlxIPB4/IB21hUSoXmrtwSN7faz3c+udUuSx0a1l+7dYXUJNVL02oNBY7t9v5BhgPpvR97BoLHdfs74jZi72tS1dzRtrdkX3mrqmlW5Y2i3OnkdM9z7/i/nM+z6vSLZt3a71i3Zr/Y6yTAS55Mcym11AQAAAAAAAAAAAAAAAAAAAAAiRyMwAMBxDJ/P1A0AAKAukGEAAIAdmZ1hopljZs6cqcGDByspKUnp6elhHbNr1y5deeWVatmypZKSkjR8+HBt3LgxZN7KlSv161//WsnJyUpNTdVpp52mQ4cOmfwVAAAAs9gpwwAAAByJDONMsVYXAABAnfOZeBsEM28LBQAAUB0yDAAAsCMzM4x/vSgpKyvThRdeqEGDBmnevHnHnG8YhkaPHq24uDgtXLhQqampmj17toYOHar169crOTlZ0uEm4OHDh2vq1Kn629/+ptjYWH399ddyu7lWCwCgcq6ftsvz2ILAuHTS/8no2NrCihzIRhkGAAAgCOeTHKlBNQIXFxdbXULYkpKSgsb/OeUUiyqpnY/ez7a6hLBt3FsUNC4pyLOoktpxXbTF6hJq7O0Wx1ldQthiugwKPLbzzxY71w44iTe9ldUlhC2xUWrQ2K4/Z+xat2Tf2u1Ud/xRf+bfXnqOaWsn7Q7OoClPzVTMwgzT1u/90uLA4+92HjBt3Wg7rkV60Phv//3JmkJq4MZTOlpdAmApO/18P/p3asVPayyqJHKxHfsHHtv5z9yutdv599LWO8dbVEntjNxkn7+fXZqnBY3t+n2Ow+6++25J0vz588Oav3HjRn322Wdat26djjvu8Hufc+fOVVZWll5++WVdffXVkqRbbrlFkyZN0pQpUwLHduvWzdziEZHRz3xh6nrdNq/X9Hl3BMbTx9+r7PY9TX0Nv935hVFZN9ri+o6zuoSwjR/QLmhs15/tdq1bksq+XFzFzHpo69eBhwvaXmTass3zPtfI7Y8GxsvTT9WutieZtn5D+T4HnGbfIfs0Yx3fKj1ovGl3gTWF1EBOYUXg8acvPGdhJZEpX/ts0NiuP9vtWrdk39rtWrdk79oBs/FxcwCA8/g//WTWBgAAUBfIMAAAwI7MzjD/yzEFBQVBW2lpaZ1/af7XTEhICOxzu93yeDz65JNPJEm7d+/WqlWr1KxZMw0ePFjNmzfX6aefHngeDUOct0KZB/YEtjhvxbEPAgDUb1HKMACcrV/xXq3b8Hpg61e81+qSADREZBhHohEYAAAAAAAAAADYSps2bZSWlhbYZs2aVec1dO/eXW3bttXUqVO1f/9+lZWV6YEHHtD27du1c+dOSdJPPx2+qvj06dN1zTXXaMmSJTrhhBN05plnauPGjXVeMwAAaLhKS0vVt29fuVwurV27NqxjDMPQiBEj5HK59NZbbwU9t3XrVo0cOVJJSUlq1qyZbrvtNlVU8GEXoDYSfV51LS0IbIk02AEATBJrdQEAANQ1w+uV4TXnH1VmrQMAAHAsZBgAAGBHZmYY/3qStG3bNqWmpgb2ezyeSudPmTJFDzzwQLVrbtiwQd27d4+4lri4OL3xxhsaP368MjIyFBMTo6FDh2rEiBEyDEOS5PP5JEm///3vNW7cOElSv3799MEHH+iZZ56xpIEZAAAcW7QyTDT98Y9/VMuWLfX111+Hfcwjjzwil8sVst/r9WrkyJHKysrSp59+qp07d2rs2LGKi4vTfffdZ2bZAADAZJxPciYagQEAzuPzHd7MWgsAAKAukGEAAIAdmZlh/OtJSk1NDWoErsqtt96qK6+8sto5HTt2rHE5J554otauXav8/HyVlZUpMzNTAwcOVP/+/SVJLVq0kCT17Nkz6LgePXpo69atNX5dAAAQZVHKMAUFBUG7PR5PlR9oisS7776r9957T6+//rrefffdsI5Zu3atHn74Ya1ZsyaQWfzee+89rV+/Xu+//76aN2+uvn37asaMGbr99ts1ffp0xcfH17pmAAAQJZxPciQagQEAAAAAAAAAQIOUmZmpzMzMqL9OWlqaJGnjxo1as2aNZsyYIUlq3769WrZsqezs7KD5P/zwg0aMGBH1ugAAQP3Spk2boPG0adM0ffr0Wq25a9cuXXPNNXrrrbeUlJQU1jHFxcW69NJL9fjjjysrKyvk+ZUrV6p3795q3rx5YN+wYcN0/fXX67vvvlO/fv1qVTMAAADMRSMwAMB5fD7JZ9LtC/j0EwAgAsVN07XhgqGBsTeOf5IhAmQYAABgR2ZmGP96UbJ161bl5eVp69at8nq9Wrt2rSSpc+fOatSokSSpe/fumjVrln7zm99Ikl599VVlZmaqbdu2+vbbb3XTTTdp9OjROvvssyVJLpdLt912m6ZNm6Y+ffqob9++eu655/T999/rtddei9rXAgAAailKGWbbtm1BdzWo7dWADcPQlVdeqeuuu079+/fX5s2bwzrulltu0eDBg3X++edX+nxubm5QE7CkwDg3N7dWNQMAgCjjfJIjcdYZAAAAAOqK2y2vh9vmAQAAAPXRXXfdpeeeey4w9l/p7sMPP9SQIUMkSdnZ2crPzw/M2blzpyZPnqxdu3apRYsWGjt2rO68886gdW+++WaVlJTolltuUV5envr06aNly5apU6dO0f+iAABAvZKamhrUCFyVKVOm6IEHHqh2zoYNG/Tee+/p4MGDmjp1atg1vP3221q+fLm++uqrsI8BAABA/UYjMADAcQyfV4ZJn34yax0AAIBjIcMAAAA7MjPD+NeLlvnz52v+/PnVv75hBI0nTZqkSZMmHXPtKVOmaMqUKbUpDwAA1CGrM8ytt96qK6+8sto5HTt21PLly7Vy5cqQKwv3799fl112WdCHnPyWL1+uH3/8Uenp6UH7L7jgAp166qlasWKFsrKytHr16qDnd+3aJUnKysqK6GsBAAB1i/NJzkQjMADAeQyfebcvMLgNAgAAqCNkGAAAYEdmZhj/egAAANFmcYbJzMxUZmbmMec99thjuvfeewPjnJwcDRs2TK+88ooGDhxY6TFTpkzR1VdfHbSvd+/e+utf/6pRo0ZJkgYNGqSZM2dq9+7datasmSRp2bJlSk1NVc+ePSP6WgAAQB3jfJIjua0uAAAAAAAANCznnXee2rZtq4SEBLVo0UKXX365cnJyqpyfl5enG2+8Ud26dVNiYqLatm2rSZMmBd12W5JcLlfItmDBgmh/OQAAAAAAAPVS27Zt1atXr8DWtWtXSVKnTp3UunVrSdKOHTvUvXv3wBV+s7Kygo7p1atXYK0OHTpIks4++2z17NlTl19+ub7++mstXbpUd9xxhyZMmBBy9WEAAABYjysCAwAch9sgAACsEnOoVCk79wTGB1tkypvIG+cIj50yzBlnnKE//elPatGihXbs2KE//OEP+t3vfqdPP/200vk5OTnKycnRQw89pJ49e2rLli267rrrlJOTo9deey1o7rPPPqvhw4cHxkffxhIAANQvVt9WGwAAoCYaUoYpLy9Xdna2iouLwz4mJiZGixYt0vXXX69BgwYpOTlZV1xxhe65554oVgoAAMxgp/NJMA+NwAAAAABQRzwHi9T6s28C45+GnqxiGoHRAN1yyy2Bx+3atdOUKVM0evRolZeXKy4uLmR+r1699PrrrwfGnTp10syZMzVmzBhVVFQoNvaXty/S09OVlZUV3S8AAAAAiIDP5dKh+ISgMQDUxq4+/fXspz8GxkZMjIXVwE7at28vwzCOue9olT3frl07LV682NT6AAAAEB00AgMAnMfnPbyZtRYAAEBdiEKGKSgoCNrt8XhMv71jXl6e/vnPf2rw4MGVNgFXJT8/X6mpqUFNwJI0YcIEXX311erYsaOuu+46jRs3Ti4aLQAAqL/MzDD+9YB6Zn3H3hr18DKrywDQkLhcMmI5lW8pMgwAALAremIciX89AACcx+c7vJm1FgAAQF2IQoZp06ZN0O5p06Zp+vTpprzE7bffrjlz5qi4uFgnn3yyFi1aFPaxe/fu1YwZM3TttdcG7b/nnnv061//WklJSXrvvfd0ww03qLCwUJMmTTKlZgAAEAVmZhj/egAAANFGhgEQBZ82aq74vuOsLgNAQ0dPjCO5rS4AAAAAAABYY9u2bcrPzw9sU6dOrXLulClT5HK5qt2+//77wPzbbrtNX331ld577z3FxMRo7Nixx7wNpXT4KsUjR45Uz549Q5qS77zzTp1yyinq16+fbr/9dv3xj3/Ugw8+WOOvHwAAAAAAAAAAALA7rggMAHAcw+uV4TXn9gVmrQMAAHAs0cgwqampSk1NDeuYW2+9VVdeeWW1czp27Bh43LRpUzVt2lRdu3ZVjx491KZNG3322WcaNGhQlccfPHhQw4cPV0pKit58803FxcVV+3oDBw7UjBkzVFpaKo/HE9bXAQAA6paZGca/HgAAQLSRYQAAgF3RE+NMNAIDAAAAAIBjyszMVGZmZo2O9f3v1lGlpaVVzikoKNCwYcPk8Xj09ttvKyEh4Zjrrl27Vo0bN6YJGAAAAADQoCTu2aUOyxcHxj//+hwdymxuYUUAAAAA6jO3lS8+ffr0kNuIdu/e3cqSAABO4PNJPq9Jm8/qrwYWIMMAACxhkwyzatUqzZkzR2vXrtWWLVu0fPlyXXLJJerUqVPgasA7duxQ9+7dtXr1akmHm4DPPvtsFRUVad68eSooKFBubq5yc3Pl/d+nzd955x09/fTTWrdunTZt2qS5c+fqvvvu04033hi1r6WhIcMAACxhaobhvRgnskOGaZa3S5cteS6wNcvbZXVJAGwudcdWnfzw9MCWumOr1SU5DxkGJrBDjgEANEA2OZ8Ec1l+ReDjjjtO77//fmAcG2t5SQCAhs4fWMxaC45EhgEA1DmbZJikpCS98cYbmjZtmoqKitSiRQsNHz5cd9xxR+DKveXl5crOzlZxcbEk6csvv9SqVaskSZ07dw5a7+eff1b79u0VFxenxx9/XLfccosMw1Dnzp01e/ZsXXPNNVH7WhoiMgwAoM6ZmWH868Fx6nuGabZ/l8b9++nA+Osu/bQ7gyt3AoCtkWFgkvqeY1C3WpYV6cIDPwfGr6Z3UE58soUVAWiQbHI+CeayPGHExsYqKyvL6jIAAAAiQoYBAKByvXv31vLly6ud0759exmGERgPGTIkaFyZ4cOHa/jw4abU6GRkGAAAYEd2yzAdd/xY5XPbm7XRgZTGQftivBXqsXl9WGvHrjwkSTJSUuXt1Svk+Zjs7+XKy4ugWqni+D5ScnADimv/fsV8vyGidXzNs+Tr2DFkf+wXX2hwYfhXSTYkrWwU2kjduqxQbcuKAuMSd4y+ScxQhcvSG6DCTgqL5dr487HnHcHISJPatQ59YsMmuUpKg3Y19xZXu9au40+U3MHfr4l7dlV6td/GmyL7+weg/rJbjrETV+FBedati+gYb9OmKu/cJWR//Ldfy10U+nO8ugzzWXKmfEflkKzyYnUsPVjlMb1L8vRgzueB8edJmTQCAwBMYXkj8MaNG9WyZUslJCRo0KBBmjVrltq2bVvp3NLSUpWW/vIPqmOdJAQAoDKGzyfDpNsXmLUO7IcMAwCoa2QYmCGSDCORYwAAtWdmhvGvB+exW4aZ9OrsKp+bNfYOfXDSsKB9jYoP6pFHJoS3+COH/1N+8iAdWLos5Onke+6WZ9E74ZYqScr7bLW8PXoG7Yv94gulXzA6onWKf3+div7yUMj+1Csv14qtoY2OVSl1uZXS54qQ/Zfu/0n37vwiaN9XiRk6pesomoERFtePWxQ7/raIjvGNGirv3ZND9sdOmy3Xps1B+0YeY635n/wgX7wnaF/7FUs06MG7IqoJdYMMA7NwPil64jf+oFbnDTv2xCMcvOAi7Z77dMj+ZjdPlOfbr0P2r6hmrfTeY1QcE5xBzs3fqr9vXxlRTQBgNs4nOZOl/yoeOHCg5s+fryVLlmju3Ln6+eefdeqpp+rgwco/HTNr1iylpaUFtpycnDquGAAAgAwDAADsKdIMI5FjAACA9eyQYcri4qO6PqrW71Cejj8U2RWQATuqOKqBGIA9cD4Jx1LijrG6BABAA2FpI/CIESN04YUX6vjjj9ewYcO0ePFiHThwQP/6178qnT916lTl5+cHtpYtW9ZxxQCABsHnNXeD45BhAACWIMOgliLNMBI5BgBgArMzDDnGceyQYX5s1VkbW4feYhp1I4GfC2jg9nY7Tnlde1hdhvOQYWACziehOl8lZuibxAyrywDQEJFhHCnW6gKOlJ6erq5du2rTpk2VPu/xeOTx/PJpR5fLVVelAQAaEsPEsGIQekCGARC+8uRE5fbpGjQGwkaGgcmOlWEkcgwAwARmZhj/enC0+phhvDGxmviHJ9VpxybFl5dVO3d7szYh+wqTUnTzzY+H9VrThh9uODZSUit9vuiuaSqeeGNYa/l527YL2Vdx4onav+S9iNbxNc+qdH/B/Bf0m2sfCHudqm6C/lLjjvokubl6l+Tpb9s/i6g2QJKMTu1UMe/ByI7JSKt0f8Xdk+UqKQ3at9Tbodq1fLFxIfs2DxmuvC49qzymIt6jvK49ZFRyLKKMDIMo4HySucq6dNWOt5dGdIy3adNK9+9+ZI7cRcUh+y+b/GiVa1V2Nd9FaW21PqHxMesoccfom8QMVbgsvX4jgIaK80mOVK8agQsLC/Xjjz/q8ssvt7oUAACAsJFhAISrPDlRe4/rbHUZACCJDAMAAOypvmYYb0ysfmjbvcbHrut0fFhzKwb1q36tbjWr4WhG48aqGDTYlLUqTjxRnzZqXut1tsc30vb4RiZUBMcoLJbrxy2BodGpnYx+x5mzdo/OIU3ruyoiX/tQZnMdyqz93w8A9lBfc4xdGY1SVHLyIFPWKuvdp9L9nzZaENE6uXFJyo1LMqMkAAAiYmkj8B/+8AeNGjVK7dq1U05OjqZNm6aYmBhdcsklVpYFAGjgDJ9Phs9n2lpwHjIMAMAKZBjUFhkGAGAFMzOMfz04CxkGQE25Nv6s2PG3BcYV8x40rxEYDR4ZBmYgxwAArMD5JGeytBF4+/btuuSSS7Rv3z5lZmbqV7/6lT777DNlZmZaWRYAAEC1yDAAAMCOyDAAAMCOyDAAAMCuyDHR4S7IV/z69YFxWc+e8qWmWVgRAADWs7QReMGCyC6hDwCAKXw+yec1by04DhkGAGAJMgxqiQwDALCEmRnGvx4chQwDALAEGQYmIMdER/z69Wp13rDAeMfbS1Vy8iALKwKAeobzSY5kaSMwAACW8HlNDD0mvgkEAABQHTIMAACwIzMzjH89AACAaCPDAAAAu+J8kiPRCAwAAAAAdSRpT57af7A6MN585gAVZ2ZYWBEAAAAAAAAAAAAAwM5oBAYAOI7h9crwmvOpJbPWAQA4hCG5j7yFjmFdKbAfMgwAALAjMzOMfz0AzrbJk6rxbX4VNAYAs5FhAACAXXE+yZncVhcAAAAqN3PmTA0ePFhJSUlKT08P65hdu3bpyiuvVMuWLZWUlKThw4dr48aNlc41DEMjRoyQy+XSW2+9ZV7hAAAAAAAAABAlu+MS9UKTLoFtd1yi1SUBAAAAAGAprggMAHAen+/wZtZaUVJWVqYLL7xQgwYN0rx584453zAMjR49WnFxcVq4cKFSU1M1e/ZsDR06VOvXr1dycnLQ/EceeUQulyta5QMAALPZJMMAAAAEMTPD+NcDAACINjIMAACwK84nORKNwAAA5/F5D29mrRUld999tyRp/vz5Yc3fuHGjPvvsM61bt07HHXecJGnu3LnKysrSyy+/rKuvvjowd+3atXr44Ye1Zs0atWjRwvTaAQBAFNgkwwAAAAQxM8P41wMAAIg2MgwAALArzic5ktvqAgAAaAgKCgqCttLS0jqvwf+aCQkJgX1ut1sej0effPJJYF9xcbEuvfRSPf7448rKyqrzOgEAAAAAAAAAAAAAAACYgysCAwAcx/B5ZZj0qSX/Om3atAnaP23aNE2fPt2U1whX9+7d1bZtW02dOlX/+Mc/lJycrL/+9a/avn27du7cGZh3yy23aPDgwTr//PPrtD4AAFA70cgwAAAA0WZmhvGvB8DZYg2fUrzlgfHBmDhVuLj2EQBzkWEAAIBdcT7JmWgEBgDABNu2bVNqampg7PF4Kp03ZcoUPfDAA9WutWHDBnXv3j3iGuLi4vTGG29o/PjxysjIUExMjIYOHaoRI0bIMAxJ0ttvv63ly5frq6++inh9AAAAAAAAALDagKI9WrFpcWA8pPM5+rRRcwsrAgAAAADAWjQCAwAcx/D5ZPh8pq0lSampqUGNwFW59dZbdeWVV1Y7p2PHjjWu58QTT9TatWuVn5+vsrIyZWZmauDAgerfv78kafny5frxxx+Vnp4edNwFF1ygU089VStWrKjxawMAgOiKRoYBAACINjMzjH89AADCYWSkyTdqaNAYCBcZBgAA2BXnk5yJRmAAgOMYPkOG16zQY0Q0PzMzU5mZmaa8dnXS0g6/oblx40atWbNGM2bMkHT4isRXX3110NzevXvrr3/9q0aNGhX1ugAAQM1ZmWEAAABqyswM418PAICwtGst792Tra4CNkWGAQAAdsX5JGeiERgAgHpq69atysvL09atW+X1erV27VpJUufOndWoUSNJUvfu3TVr1iz95je/kSS9+uqryszMVNu2bfXtt9/qpptu0ujRo3X22WdLkrKyspSVlRXyWm3btlWHDh3q5gsDAAAAAAAAAAAAgBrwNstUwWVjg8YAADgdjcAAAMcxvD7zPv1k4qfBj3bXXXfpueeeC4z79esnSfrwww81ZMgQSVJ2drby8/MDc3bu3KnJkydr165datGihcaOHas777wzajUCAIC6Y5cMAwAAcCQzM4x/PQAAgGgjwwD1V3nHztrz1zlWlwEA9Rbnk5yJRmAAAOqp+fPna/78+dXOMYzg2zBMmjRJkyZNiuh1jl4DABA9RoxbZcmJQWMAAAAAAAAAAAAAAGqqQTUCJyUlWV1C2IqLi4PGdqr9P6ecEnh8x9BuFlYSmXvfzw4aJ6RmWFRJ5EoK8gKPPc3aWVhJZEp3b7G6hBp7u8Vxgcd2+vtp558txcXF6ty5s3JycqL+WobPJ8Nn0qefTFoHsItDhQVB40Sb/Zzxs9vPxyPZtXa71i1JP179O9PWPtQkXT+cf4Zp6x3t20vPidra0fTdzgNB4+U/5VU+sR76239/0p2jB+vAntyovxYZBvWRnX++K3e9NYXUQMVPawKPY238Z27X75d5X0X/Z7xZ/vbfn4LGbU/paFElkdt65/jA4y7N0yysJDIbd+UHje32fV4X78WYmWH86wG19cGNp1pdQtjO/Nt/gsbN0hpZVEnkducXWl1CjcT1HRc0ttvPdj+71i1J+n6FJXXU1vgB9jmHN2918Dk8u32/kGHgVMe3Sre6hLB9s+OA1SWYonzts1aXEDYyTN1rKO992bVuyX610xODaGpQjcAAAISD2yAAAAA7IsMAAAA74rbaAADLbNik2GmzA8OKuydLPTpbWBDshAwDAADsivNJzkQjMAAAAAAAAAAAAACgQXGVlMq1aXPQ2LCuHAAAAACImgbVCBxy25h67OhLk9u1drvWLUklB/ZaVEkNHHGZ9S1/HlfNxPol99HpQeNzPvyHNYXUQGz3XwUe2/n73M61RxOffkJ9Y6x40eoSwpZ07g1BY7v+nDnp7qUWVhKZ0x8MvgXonUs2WFRJ5GZ9/MstBsvX2ufPPO6o30nXLPjSokoi99T/nRB4fPCpeAsriUxKcvCf+WXPf25RJZH759iT6uy1yDCoj+yaBSRp676DFlUSubZNUgKP7fxnbtfaS/bvtrCS2vl97o9WlxC2+KxOgcd2/V6R7F17tHA1PdRHdv67atfae932jmnrtt3+nbRp8S/jk07TvtbHmbb+ugdHBY3t+mdu17ol6eWvtpuyblNXiYYeMV7h6qS9ruNNWdvvkn6tA4/t/Gdu59qjhQyD+qh0189WlxCB/UGji97KNW3ljluydfMzdwfGj1w1TT+162ba+guvHRR4/M2OA6atG23Ht0oPGtv1Z7td65bsW7td65bsXXs0cT7JmdxWFwAAAAAAAAAAAAAAAAAAx+IpK1HbnT8HNk9ZidUlAQBqobS0VH379pXL5dLatWurnJeXl6cbb7xR3bp1U2Jiotq2batJkyYpPz8/aN6kSZN04oknyuPxqG/fvtEtvh5pUFcEBgAgHIbXK5/Xa9paAACEKzN3m3695OXAePnwS7Qnq42FFcFOyDAAAMCOzMww/vUAAACijQwDAADsym7nk/74xz+qZcuW+vrrr6udl5OTo5ycHD300EPq2bOntmzZouuuu045OTl67bXXguZeddVVWrVqlb755ptoll6v0AgMAAAAAHUk7cBenblkQWD8xcln0QgMAAAAAEAEiuKT9HWLbkFjAAAAAID9vPvuu3rvvff0+uuv69133612bq9evfT6668Hxp06ddLMmTM1ZswYVVRUKDb2cCvsY489Jknas2cPjcAAADRkhuGT4fOZthYAAEBdIMMAAAA7MjPD+NcD4Gw/NOugMWMesroMAA0cGQYAANhVNM4nFRQUBO33eDzyeDy1WnvXrl265ppr9NZbbykpqWYf8MzPz1dqamqgCdjJ+BMAADiO4fXJ8JoUekxaBwAA4FjIMAAAwI7MzDD+9QAAAKKNDAMAAOwqGueT2rQJvsPptGnTNH369Jqvaxi68sordd1116l///7avHlzxGvs3btXM2bM0LXXXlvjOhoSGoEBAAAAAAAAAAAAAAAAAAAQYtu2bUpNTQ2Mq7oa8JQpU/TAAw9Uu9aGDRv03nvv6eDBg5o6dWqN6ikoKNDIkSPVs2fPWjUkNyQ0AgMAHIer6QEAADsiwwAAADvianoAAMCOyDAAAMCuonE+KTU1NagRuCq33nqrrrzyymrndOzYUcuXL9fKlStDGor79++vyy67TM8991yVxx88eFDDhw9XSkqK3nzzTcXFxR37C3EAGoEBAAAAAAAAAAAAAAAAAABQY5mZmcrMzDzmvMcee0z33ntvYJyTk6Nhw4bplVde0cCBA6s8rqCgQMOGDZPH49Hbb7+thIQEU+puCGgEBgA4juEzZPhM+vSTzzBlHQAAgGMhwwAAADsyM8P41wPgbB32bdPET/4ZGM/51WX6uUkbCysC0BCRYQAAgF3Z4XxS27Ztg8aNGjWSJHXq1EmtW7eWJO3YsUNnnnmmnn/+eQ0YMEAFBQU6++yzVVxcrBdffFEFBQUqKCiQdLgBOSYmRpK0adMmFRYWKjc3V4cOHdLatWslST179lR8fHxUvp76gEZgAIDj+Lw++Uy6DYJZ6wAAABwLGQYAANiRmRnGvx4AZ0s/VKCzf/hvYPziiaMsrAZAQ0WGAQAAdtVQzieVl5crOztbxcXFkqQvv/xSq1atkiR17tw5aO7PP/+s9u3bS5KuvvpqffTRR4Hn+vXrFzKnIaIRGAAAAAAAAAAAAADQoOzt01//WvVjYOyLjbOwGgAAAABVad++vQzDqHbfkCFDQuZUZsWKFWaXZws0AgMAHMfw+mSY9Kkls9YBAAA4FjIMAACwIzMzjH89AADC4nbLF++xugrYFBkGAADYFeeTnIlGYAAAAAAAAAAAAAAAAAD13obOx+u3c/8TGPvcMRZWAwBA/UAjMADAcfj0EwA0AIYhHSiQig9JSYlSeqrkclldFRBVZBgAAGBHXE0PAADYERkGqMdcLhUfPKDNH7+l9qeNVkJ6U6srAoB6hfNJzkQjMADAcQzDJ8NnUugxCD0AUKcKCuV6Z5ncLy+Ua/vOwG6jdQv5LjlfxqizpNRGFhZYvZzWnfTI1DlBYyBcZBgAAGBHZmYY/3oAAADRRoYB6of/e/tp+dxu/evcq4L2l+TvU/aiecrqc2pII/BFi56R2+fTgvOurstSAaDe4HySM9EIDAAAAMAWXJ+ukfvWGVJJaeiTO3Llfugf0pz58j18p4zB/eu+wDAUN0rV+j6DrS4DAAAAAACgwUvYnavWHy4JjLefMVwlzbIsrAgAECmf261L335KkkKagStz0aJndOnbT+ml866JdmkAANQrNAIDAByH2yAAgP24Pl0j98Q7JcOQyzBCn//fPqOkVO6Jd8o3Z0a9bQYGaooMAwAA7IjbagMArNJox1b1v/+OwPhA1540AiNsZBigfvA3/4bTDHxkE3A4TcMA0FBxPsmZaAQGAAAAUL8VFB6+EnAVTcBHchmGDEnuW2fIu/SfUmqjuqkRAAAAAAAAAACY7uhm4GW/GqVff75Mx0vq/PkyfZWWobM+eYcmYACAo7mtLmDHjh0aM2aMmjRposTERPXu3Vtr1qyxuiwAQAPm//STWRuciQwD1B3XO8ukktJjNgEH5hvG4fmL3o9yZUDdIsPADGQYAEBdMzvDkGOciQwDAKhrZBiYgQxjnn+de5VeOu8aXfr2U7p04VOa9N4/9ZikSe/9U5cufIomYAA4AhnGmSy9IvD+/ft1yimn6IwzztC7776rzMxMbdy4UY0bN7ayLABAA+fz+eTzmRNWzFoH9kKGAeqQYcj98kJJ4TUBH8n90lvyXnK+5HKZX1cNxZccUpM9OYHxvsyWKktItLAi2AkZBrVFhgEAWMHMDONfD85ChgEAWIEMg9oiw5jv6CsD+53133doAgaAI3A+yZksbQR+4IEH1KZNGz377LOBfR06dKhyfmlpqUpLSwNjI8wrggEAAJiJDAPUoQMFcm3fGfFhLsOQtu+U8g9K6alRKKxm2m7+Xn+cPj4w/sv0edrUvZ+FFQFwkkgzjESOAQAA1iPDAAAAOyLD1F7Jgb0qyd8XtO/J3qcodWu2zl37cWDfor6n6cnep0hbsoPmJqQ1UUJ60zqpFQAAq1naCPz2229r2LBhuvDCC/XRRx+pVatWuuGGG3TNNddUOn/WrFm6++6767hKAEBDY+btC7gNgjORYYA6VHyodscXFderRmCgNsgwqK1IM4xEjgEA1J7Zt5EkxzgPGQZH+75ZJ11wxWOB8bb0FhZWA6ChIsOgtsgwtbf547eUvWheyP6fJA3X4YanCkk3IuKuCgAA2O5JREFUrP1Y245oDPbrdu54dT/v6miXCQD1DueTnMlt5Yv/9NNPmjt3rrp06aKlS5fq+uuv16RJk/Tcc89VOn/q1KnKz88PbC1btqzjigEAAMgwQJ1KSqzd8clJ5tQBAA1ApBlGIscAAADrkWFwtEPxCfqhWYfAdig+weqSAAAIQYapvfanjdbpf54fsk077TeKlVSqw83A0077TaXz2p822tovAACAOmTpFYF9Pp/69++v++67T5LUr18/rVu3Tk888YSuuOKKkPkej0cejycwdrlcdVYrAKDhOPzpJ69pa8F5yDBAHUpPldG6hbQjV64IboNmuFxSqywpLSWKxQF1iwyD2oo0w0jkGABA7ZmZYfzrwVnIMAAAK5BhUFtkmNpLSG+qhPSmQfsuWvSMLv34Tc077Te6+uM39fRpv9H4j99UYnpT/evcqyyqFADqF84nOZOlVwRu0aKFevbsGbSvR48e2rp1q0UVAQCcwPD5TN3gPGQYoA65XPJdcn6NDvVdOlpy+BulaFjIMKgtMgwAwApmZxhyjPOQYQAAViDDoLbIMOa7aNEzuvTtp/TSedfohVMPnzd44dTz9dJ51+jSt5/SRYuesbhCAKgfyDDOZGkj8CmnnKLs7OygfT/88IPatWtnUUUAAADHRoYB6pYx6iwpwXP4Kr/hzHe7Ds8/d2iUKwMAeyHDAAAAOyLDAAAAOyLDmOvIJuCjr/z7r3OvohkYAOB4sVa++C233KLBgwfrvvvu00UXXaTVq1frySef1JNPPmllWQCABs7w+Uy7fQGffnImMgxQx1IbyffwnXJPvFOGJJdhVDn1cLOwS76H75JSG9VZiUBdIMOgtsgwAAArmJlh/OvBWcgwOFpKSaGOy90UGH+X1VkHE3gPAIC5yDCoLTKMeaprAvbz77/07aeCxgDgRJxPciZLrwh80kkn6c0339TLL7+sXr16acaMGXrkkUd02WWXWVkWAABAtcgwQN0zBveXb86MwJWBjaMuDmy4/tcEnOCRb869MgafaE2hAFCPkWEAAIAdkWFwtM57t+ipV+8MbJ33brG6JAAAQpBhzBFOE7AfVwYGADiZpVcElqRzzz1X5557rtVlAACcxGvip7hN/DQ47IUMA9Q9Y3B/eZf+U65F78s9/1/S7n2/PJnZRL4rL5Ix6iwpJdm6IoFoIsPABGQYAECdMzPD/G89OA8ZBkBNFLZqqy9uuztoDISNDAMTkGFqz+3zhdUE7Oef5+YKlgCcjPNJjmR5IzAAAHXN5/XJZ1JYMWsdAECYUhvJuHS0vN07KfaqPwR2e++fKp3Q28LCgOgjwwAAADsyM8P41wMAIBwlzbK08dLxVpcBmyLDAPXDgvOurnR/QloTdTt3vBLSmoQ8F27TMAA0VJxPciYagQEAAADYj8tV/RgAAAAAAAAAADRICelN1b2KJmEAAJyIRmAAgOMYPp8Mk24HY9Y6AAAAx0KGAQAAdmRmhvGvBwAAEG1kGAAAYFecT3ImGoEBAAAAoI4UpqTpy5POCBoDAAAAAAAAAAAAAFBTNAIDABzH8PpkeE369JNJ6wAAnCG3VUc9cevDVpcBmyLDAAAAOzIzw/jXAwAgLIYhl9f7yzAmRnK5LCwIdkKGAQAAdsX5JGdyW10AAAB1zfAapm4AAAu0ay3vrCmBTe1aW10REHVkGAAAYEdmZ5ho5pj27dvL5XIFbffff3+V8/Py8nTjjTeqW7duSkxMVNu2bTVp0iTl5+cHzdu6datGjhyppKQkNWvWTLfddpsqKiqi9nUAAA5ruvZzXXxS+8DWdO3nVpcEG7FThgEAADgSGcaZaAQGAAAAYD8Z6TJGnBHYlJFudUUAAAAAGoB77rlHO3fuDGw33nhjlXNzcnKUk5Ojhx56SOvWrdP8+fO1ZMkSjR8/PjDH6/Vq5MiRKisr06effqrnnntO8+fP11133VUXXw4AAHCAmTNnavDgwUpKSlJ6enqlcyZNmqQTTzxRHo9Hffv2DWvdJ598UkOGDFFqaqpcLpcOHDhQo9cGAABA9MVaXQAAAHXN5/PJZ9LtC3w+boMAAADqBhkGAADYkZkZxr+eJBUUFATt93g88ng8tV4/JSVFWVlZYc3t1auXXn/99cC4U6dOmjlzpsaMGaOKigrFxsbqvffe0/r16/X++++refPm6tu3r2bMmKHbb79d06dPV3x8fK1rBgAA5otWhomGsrIyXXjhhRo0aJDmzZtX5byrrrpKq1at0jfffBPWusXFxRo+fLiGDx+uqVOn1uq1AQBA3eF8kjNxRWAAAAAAAAAAAGArbdq0UVpaWmCbNWuWKevef//9atKkifr166cHH3xQFRUVER2fn5+v1NRUxcYevg7LypUr1bt3bzVv3jwwZ9iwYSooKNB3331nSs0AAMDZ7r77bt1yyy3q3bt3lXMee+wxTZgwQR07dgx73ZtvvllTpkzRySefXKvXBgAAQPRxRWAAgOMYPkOGzzBtLQAAwtVqyw+67Jn7A+N/XjVFO9p1tbAi2AkZBgAA2JGZGca/niRt27ZNqampgf1mXA140qRJOuGEE5SRkaFPP/1UU6dO1c6dOzV79uywjt+7d69mzJiha6+9NrAvNzc3qAlYUmCcm5tb65oBAEB0RCvDROuuBgAAAH6cT3ImGoEBAI7j80o+tzlhxec1ZRkAQKTKy6UDR7xpnp4qxcVZV0+YEg8VqXP22qAxEC4yDAAAsCMzM4x/PUlKTU0NagSuypQpU/TAAw9UO2fDhg3q3r27Jk+eHNh3/PHHKz4+Xr///e81a9asYzboFBQUaOTIkerZs6emT59+zLoA1Nye5Awt6HtO0BgAzBatDNOmTZug/dOmTSM7AAAAU3E+yZncVhcAAAAAABFbl63Ysy4NbFqXbXVFAP5nxYoVcrlclW6ff/55pcfk5eXpxhtvVLdu3ZSYmKi2bdtq0qRJys/PD5r3+eef68wzz1R6eroaN26sYcOG6euvv66LLwsAANjUrbfeqg0bNlS7VXWL7IEDB6qiokKbN2+u9jUOHjyo4cOHKyUlRW+++abijviQYlZWlnbt2hU03z/Oysqq3RcHONT2xi0086zrA9v2xi2sLgkAwrZt2zbl5+cHtqlTp1Y6b8qUKVW+v+Lfvv/++zquHgAAAPUVVwQGADiO4fXJcPtMWwsAAKAu2CXDDB48WDt37gzad+edd+qDDz5Q//79Kz0mJydHOTk5euihh9SzZ09t2bJF1113nXJycvTaa69JkgoLCzV8+HCdd955+vvf/66KigpNmzZNw4YN07Zt24IabgAAQP1hZobxrxeJzMxMZWZm1ui11q5dK7fbrWbNmlU5p6CgQMOGDZPH49Hbb7+thISEoOcHDRqkmTNnavfu3YF1li1bptTUVPXs2bNGdQEAgOiLVoYJ964Gt956q6688spq51T1YSYAAOBsdjmfBHM1qEbgpKQkq0sIW3FxcdDYrrXbtW5JSrBR7SUH9gYet5v5rIWVRGbLn8cFjWO7/8qiSiJX8f0ngcexNvpesfvPls6dOysnJ8fqUgBUo3jR34PGdvs543f6g/+xsJLamTG8h9UlhO3OJRusLqFGytcuDRrfYKMLa1yz4EurS6iRg0XBGea617+zqJLIXfb853rjppE6tH+31aXUSEFBQdDY4/Ec87bXxxIfHx90dbvy8nItXLhQN954o1wuV6XH9OrVS6+//npg3KlTJ82cOVNjxoxRRUWFYmNj9f333ysvL0/33HNP4Daa06ZN0/HHH68tW7aoc+fOtaobNWPXLCBJew/Z555mW/cdDDy285+5XWu31XtINv19JElluT8GHsfb6M/c7t/nvBfzi5UrV2rVqlU644wzlJKSopUrV+qWW27RmDFj1LhxY0nSjh07dOaZZ+r555/XgAEDVFBQoLPPPlvFxcV68cUXVVBQEMhXmZmZiomJ0dlnn62ePXvq8ssv11/+8hfl5ubqjjvu0IQJE2qdu1Bzdvu7eiS71j5g2gcWVhKZXre9EzS265+5XeuWpIXZeRZVErmXv9oeeGznP3O71e6EDFObDzMB9dHCawdZXULYzn9ypdUl1Mg3Ow4Eje32s93PrnVL9q3drnVL9qvdCRkG1mlQjcAAAITD8Boy3IZpawEAANSFaGQYf0Ot37Rp0zR9+nRTXsPv7bff1r59+zRu3LhjTz5Cfn6+UlNTFRt7+K2Lbt26qUmTJpo3b57+9Kc/yev1at68eerRo4fat29vas0AAMA8ZmYY/3rR4PF4tGDBAk2fPl2lpaXq0KGDbrnlFk2ePDkwp7y8XNnZ2YETj19++aVWrVolSSEfSvr555/Vvn17xcTEaNGiRbr++us1aNAgJScn64orrtA999wTla8DAACYwy4ZRpK2bt2qvLw8bd26VV6vV2vXrpV0OJ80atRIkrRp0yYVFhYqNzdXhw4dCszp2bOn4uPjQz7wJEm5ubnKzc3Vpk2bJEnffvutUlJS1LZtW2VkZIT92gAAoG7RE+NMNAIDABzH5zXkMyn0+Ag9AACgjkQjw2zbti3odpTRuCrdvHnzNGzYMLVu3TrsY/bu3asZM2bo2muvDexLSUnRihUrNHr0aM2YMUOS1KVLFy1dujTQLAwAAOofMzOMf71oOOGEE/TZZ59VO6d9+/YyjF9ef8iQIUHjqrRr106LFy+udY0AAKDu2CXDSNJdd92l5557LjDu16+fJOnDDz/UkCFDJElXX321Pvroo5A5/g8vHf2BJ0l64okndPfddwfGp512miTp2Wef1ZVXXhn2awMAgLpFT4wzua0uAAAAAAAAWCM1NTVoq64ReMqUKXK5XNVu33//fdAx27dv19KlSzV+/PiwayooKNDIkSPVs2fPoKsTHzp0SOPHj9cpp5yizz77TP/973/Vq1cvjRw5UocOHYr4awcAAABgTz1zN+rfT10b2HrmbrS6JACw1Pz582UYRsh2ZCPuihUrKp3jv8uS/wNPRx4zffr0So/xNwGH+9oAAACIvgZ1yZwjP51W3yUlJQWN7Vq7XeuW7FV7An/mdS6WP/M6d3Tt0WR4fTLcPtPWAmrLNWSM1SXUWNmatlaXEL71ywMPV16cbl0dEYrt/qugsV1/tv85L9fUtV05JUFjX/POMv6fvfsOa+L+4wD+Tlhhb1AUBEEFcePee1ttrdZRV2sdddRRV4er9ad2qHVUW7WO1r1X1br3wL0VEGTvvSG53x8p0QgK2JBw8H49D89Dvnf53ufCkbxz9707l7oaXUae1TJ/zXUmV697arVMoJ7m/qavbi8rkuM11q+2XbsaousSisz/1w+0tixdZ5ipU6eqHegpSNWqVdUeb9iwAba2tnjvvfeKtIyUlBR07doV5ubm2LdvHwwMDFTTtm7diqCgIFy5cgVSqVTVZm1tjQMHDmDAgAHFWyHSCLF+LgFATvADHVXy3+QG3tJ1CUUXpX5yQMbxtToq5B1c2KL6NW33jzospHjkpzapPdav10pHlRSfvkdT1e9ifm8Rc+0lRZMZJq8/ov9KzP+rYq09OC5FY/0aXjWE458RqsfLB3gju2lzjfX/OqfRb79aeKkSfk/1a3ZkgA4LKabkCLWHLVwcNNKtQYI9cmp4qh7XcrVHjoulRvrO42JrrvpdrP+fgLhrLynMMFQa3c/S7HuYNmWkJuu6hHey3088dQ+sr35HNrG+t4u1bkC8tYu1bkDctZckXR9PIt0oUwOBiYiIiIiIiKhk2Nvbw97evsjzC4KADRs2YOjQoWoDet8kOTkZXbp0gZGREQ4ePAiZTKY2PT09HVKpFBKJRNWW91ih4I4oIiIiIiIiUpdTtx4iL/vqugwiIiIiIqISJ9V1AURERNqmEAQoFBr6EQRdrw4RERGVE2LLMKdPn0ZgYCBGjhyZb1pYWBg8PT1x/fp1AMpBwJ07d0ZaWhrWr1+P5ORkREZGIjIyEnK5HADQqVMnJCQkYNy4cXj8+DEePnyIESNGQF9fH+3atSvx9SEiIqJ3o9EMw30xREREpCXMMERERCRWYjueRJrBKwITEVH5IxcgSDQUVuQMPURERKQlIssw69evR/PmzeHp6ZlvWk5ODp4+faq6bdetW7dw7do1AICHh4favIGBgXB1dYWnpycOHTqEefPmoVmzZpBKpahfvz6OHTuGihUrlvj6EBER0TvSZIb5tz8iIiKiEscMQ0RERGIlsuNJpBkcCExEREREREREGrd169Y3TnN1dYXwylnkbdu2VXv8Jp06dUKnTp00Uh8RERERERERERERERFRWcCBwEREVO4o5AooJAqN9UVERFRkdbwhv3zo5WNzc93VQqLDDENERERipMkMk9cfERERUUljhiEiIiKx4vGk8okDgYmIiIiISHwsLKBo0UztsSgY6AM21rqugoiIiIiIiIiozNMP8If58qWqxykTJyPX3UOHFREREREREZUMDgQmIqJyR5ALECSF33q6qH0REZH2CTW9kHNon67LINIqZhgiIiISI01mmLz+iIiIikIaEw2zvzarHqcNHAxwIDAVETMMERERiRWPJ5VPHAhMRETlDkMPERERiREzDBEREYkRB9EQERGRGDHDEBERkVjxeFL5JNV1AURERERERERERERERERERERERERERFR8vCIwERGVOwq5AgqJQmN9ERERFVlcAiSXrqseCi0aA7bWOiyIxIQZhoiIiMRIkxkmrz8iIiKiksYMQ0RERGLF40nlEwcCExERERERaUtQMKTTv1M9lG9ZxYHARERERERERMUk6OnpugQiIiIiIiKiUoMDgYmIqNwRBAGCQtBYX0REpH2SJ0+hN3+B6rF89tcQPGvosCKikscMQ0RERGKkyQyT1x8RlW/ZTZsjNDpR12UQURnHDENERERixeNJ5RMHAhMRUbmjkAtQQDNhRSFn6CEi0onEROgd+0f1UD5xnA6LIdIOZhgiIiISI01mmLz+iIiIiEoaMwwRERGJFY8nlU9SXRdARERERERERERERERERERERERERERExccrAhMRUbkjyAUIUGisLyIiIiJtYIYhIiIiMdJkhsnrj4iIiKikMcMQERGRWPF4UvnEKwITERERERERERERERERERERERERERGJEK8ITERE5Y7y7CfNnLXEs5+IiIhIW5hhiIiISIw0mWHy+iOi8k0vLAwme3epHqd/0A/ySpV0WBERlUXMMERERCRWPJ5UPun0isCurq6QSCT5fsaNG6fLsoiIqIxTyAWN/lD5wwxDRES6wAxD/xUzDBER6YKmMwxzTPnDDEOv0wt5Aau536p+9EJe6LokIiqDmGFIE5hjiIhIF5hhyiedXhHY19cXcrlc9fjBgwfo1KkT+vXrp8OqiIiIiN6OGYaIiIjEiBmGiIiIxIgZhojeVU5Nb0QdOa72mIhIm5hjiIiISFt0OhDY3t5e7fGiRYvg7u6ONm3a6KgiIiIqDwSFAoJEorG+qPxhhiEqfSQPH0GoUxswMVGfkJAAydNnxepLqFABcK2Sf8K9R0BOTjGKkgINahdr2URvwwxD/xUzDBER6YImM0xef1S+MMNQYQwfPiywPdfNHQpHx9cac2F443rxFiCPAmpWz98eEAQkJBavL6/qgOlr+y5SUoGn/sXrx84WcHXO3/7gCZCZCQCQGFsXqSuhScP8jRGRkASHFqskwdUFcHRQb5TLIblxu3j9mBgDDRzytev7PYM0LrZYfeV410Z20+bFeg5RHmYY0gTmGCIi0gUeTyqfdDoQ+FXZ2dn466+/MGXKFEjesCFmZWUhKytL9VgQeOlpIiIi0i1mGKLSwWDaLGS3bgWhmodau9T3BgwGDClWX7ljR0O+YF6+dumEryGJiilyP4KxDIrbJ4u1bCIibSlKhgGYY4iIiKh0YYahglhPn1Jge/yyFUgbMlytTZKeDsceXYrVv1DbC4p9G/K1S1ash/TwiWL1Jd+/Eajlqd748Cn0Pi7eLeIVA/pA+H5mvnbp5NmQBAYXq6+cyID8/Rw4Ar25/ytWP/IfvoNi6CD1xsws6Pf+qFj9CLW9gbNX87Vb/PQDTHfvKFZfUSfOIruBT7GeQ0RUUng8iYiIiEqSVNcF5Nm/fz8SExMxfPjwN86zcOFCWFpaqn7Cw8O1VyAREZUZCrmg0R8q35hhiHTEyEjXFbybKs5QjHplYLKhSNeDdIIZhjSpKBkGYI4hIqL/TtMZhjmmfGOGIQAQjGS6LoGIygFmGNI0Hk8iIiJtYYYpn0rNQOD169ejW7ducHJyeuM8s2bNQlJSkurnbfMSERERaQMzDJFuCLW8oahTW9dlFJ+dDWCsHPwr1KwOeHoU8gQiopJRlAwDMMcQERFR6cIMQwCQU6s2suvU1XUZRERExcLjSURERFSS9HVdAAC8ePECJ0+exN69e986n5GREYxeufLX2277RERE9CaCQoAAzZy1JCh49lN5xgxDpEMGBsg58TckDx4C/94qTaiUf6eoolFDZP99oFhdCxUqFNiuWLEAyMkpekeSgs+7FHp3hbxlU+UgYINS8ZWMRIIZhjSlqBkGYI4hIqL/TpMZJq8/Kp+YYUjFwABR/5yBwYP7kGRlvnG2XDf3fG2CiQmijhwv1uLs5FEFtgsTPoX8477F6gtuLvnbvGtAvn1N8fqxsy2wWbF0PpCpfE0EY+vi9flqP717QKhfvMHWgmsB6yYzQu6BHcXrx8S4wPbkL6cjdcQnxeorp1r1Ys1P9CpmGNIkHk8iIiJt4vGk8qlUHHXesGEDHBwc0KNHD12XQkRE5YFcAUHQ0BdnhUIz/ZAoMcMQ6ZiBAYT69d4+j7U1hKZNNLO8OjU1049TBeUPUXExw5CGMMMQEZFWaTLDAMwx5RgzDKkxMEBO/QbFf56+PrKbNi/ecxIeFtzu7lr85RfE3AxoWE8zfdXyVP0qmNm/ez8VK0CoqIF9F3p6EJo0/O/9AMitVh3gwF7SJmYY0iDmGCIi0ioeTyqXCr5ElRYpFAps2LABw4YNg75+qRiXTERERFQoZhgiIiISI2YYIiIiEiNmGCIiIhIr5hgiIiLSBp2njJMnTyI4OBiffFK8W7kQERG9K4VcgELQzO0LFLwNQrnFDENERNrGDEOawAxDRETapskMAzDHlFfMMEREpG3MMKQpzDFERKRtPJ5UPul8IHDnzp0haDBAExEREWkDMwwRERGJETMMERERiREzDBEREYkVcwwRERFpg84HAhMREWmbIBc09oVb4NlPREREpCXMMERERCRGmswwAHMMERERaQczDBEREYkVjyeVTxwITERE5Y5C0OBtEHgGLxEREWkJMwwRERGJkSYzTF5/RERERCWNGYaIiIjEiseTyieprgsgIiIiIiIiIiIiIiIiIiIiIiIiIiKi4uMVgYmIqNyRCwLkGjprSVP9EBERERWGGYaIiIjESJMZJq8/IiIiopLGDENERERixeNJ5ROvCExERERERERERERERERERERERERERCRCvCIwERGVO3JB+aOpvoiIiIi0gRmGiIiIxEiTGSavPyIiIqKSxgxDREREYsXjSeUTBwITEVG5w9sgEBERkRgxwxAREZEY8bbaREREJEbMMERERCRWPJ5UPkl1XQAREREREREREREREREREREREREREREVH68ITERE5Q5vg0BERERixAxDREREYsTbahMREZEYMcMQERGRWPF4UvnEKwITERERERERERERERERERERERERERGJEK8ITERE5Y5CECAXNHPakkJD/RAREREVhhmGiIiIxEiTGSavPyIiIqKSxgxDREREYsXjSeUTBwITEVG5I4cGb4OgmW6IiIiICsUMQ0RERGKkyQyT1x8RERFRSWOGISIiIrHi8aTySarrAoiIiIiIiIiIiIiIiIiIiIiIiIiIiKj4eEVgIiIqd+SCADk0c/qTJm8LRURERPQ2zDBEREQkRprMMHn9EREREZU0ZhgiIiISKx5PKp/K1EBgExMTXZdQZOnp6WqPxVq7WOsGxFu7WOsGxFu7WOsGxFe7h4cHwsPDdV0KkdYZm1nouoQiy0hNVnts2LCnjiopvuwbh1W/63u21GElxZP75KLaY32RvbfnkYmo7sz4SLXHYt1e9C1sdFhJ8WQmx6s99v/1Ax1VUnwen+9F4KaRkKfFFz4zURkktu8crzIQUe05wQ9Uv+u7NdBhJcWTG3hL7bFxl890VEnxZRxfq/rd9MNpOqykeNJ2/6j2WN+jqY4qKb5c/6uq38WaeQHxvS9yXwyVV2L7X32VWGsXU93BcSlqj8X6eWpYwV2HlRRPdmSA2mMXW3MdVVJ8r24vYtrOxf7ewgxD5VVDF/Hs870RrL6/VKzHwgbWr6zDSopn2+1Qtcdie2/PI9a6AfHWLta6AfHVzgxDJalMDQQmIiIqCrkAyDXYFxEREZE2MMMQERGRGGkyw+T1R0RERFTSmGGIiIhIrHg8qXwS9UDg6OhoAEBETBxcWr6n42qKx8PDQ9clvDOx1i7WugHx1i7WugHx1i7WugFl7ZGRyisw5r2/lxSGHtI1VYaJikbVuk10XE3xuFf31HUJ78yt+zBdl/BOqrR5X9clvDOxfi65e9fXdQnvTKzbi7unt65LeGeBm0ZCnp4AgBmGygdVjomOgZtPax1XUzxi/VwCANfGHXRdwjup0qyrrkt4Z+6DxXMV4FdVG/W9rkt4Z1Va9NJ1Ce9EzO8t2toXw0E0VBq83BcTJbrvfGJ/nxGjxrVq6LqEdybWz1O3+i10XcI7E+v2Itb/T4AZhsqXV48nie29sntj8e7zFeuxsHFdGuq6hHcm1s8lsdYNiLd2sdYNcEwMlTyJIAii/XPp6elBoVDougwiItIwqVQKuVyTu1eUkpOTYWlpiZ8tPGAs0dNInxmCHFOT/ZGUlAQLC/Hc0oZ0ixmGiKhsYoah8oA5hoiobCqJHFMSGQZgjqF3wwxDRFQ2McNQWccMQ0RUNvF4EpUEUV8RWCaTITMzE3p6enBwcCiRZQiCgPDwcDg5OUEikZTIMkqCWOsGxFs769Y+sdbOut8sOjoacrkcMpmsRPrPIxcEyKGZ82Dk4j2fhnSIGebtxFo769Y+sdbOurWvpGtnhqHypKRzDN9rtI91a59Yaxdr3YB4ay8r+2I0mWHy+iMqLu6LeTPWrX1irZ11a59Ya2eGeXN/RMXFDPNmYq0bEG/trFv7xFo7634zHk+ikiTqKwJrQ95IebGNahdr3YB4a2fd2ifW2lm37uStww/m7ho9+2l6SoCoXxcqm8T8PyvW2lm39om1dtatfWKuHWCGofJFzP+vYq2ddWufWGsXa92AeGsXa915SiLDAMwxVHqJ9X+WdWufWGtn3don1trFWnceZhgqb8T6PyvWugHx1s66tU+stbNu3eHxpPJN1FcEJiIiehcKAdDUTRYUPJ2GiIiItIQZhoiIiMRIkxkmrz8iIiKiksYMQ0RERGLF40nlEwcCExFRucPbIBAREZEYMcMQERGRGPG22kRERCRGzDBEREQkVjyeVD5JdV1AaWdkZIQ5c+bAyMhI16UUi1jrBsRbO+vWPrHWzrqJSBvE/D8r1tpZt/aJtXbWrX1irp2ovBHz/6tYa2fd2ifW2sVaNyDe2sVaN1F5Jdb/WdatfWKtnXVrn1hrF2vdROWVWP9nxVo3IN7aWbf2ibV21k2kGxJB4LBtIiIqH5KTk2FpaYn5JlUhk+hppM9MQY7Z6c+RlJQECwsLjfRJRERE9CpmGCIiIhKjksgwAHMMERERlSxmGCIiIhIrHk8q33hFYCIiIiIiIiIiIiIiIiIiIiIiIiIiIhHS13UBRERE2iYXADk0c0F8Oa+rT0RERFrCDENERERipMkMk9cfERERUUljhiEiIiKx4vGk8okDgYmIqNxRhh7N9UVERESkDcwwREREJEaazDB5/RERERGVNGYYIiIiEiseTyqfpLougIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqPVwQmIqJyRy4IGrwNAk9/IiIiIu1ghiEiIiIx0mSGyeuPiIiIqKQxwxAREZFY8XhS+cQrAr/FqlWr4OrqCplMhiZNmuD69eu6LqlQ58+fR69eveDk5ASJRIL9+/fruqQiWbhwIRo1agRzc3M4ODigT58+ePr0qa7LKpLVq1ejTp06sLCwgIWFBZo1a4ajR4/quqxiW7RoESQSCSZNmqTrUt5q7ty5kEgkaj+enp66LqvIwsLC8PHHH8PW1hbGxsaoXbs2bty4oeuy3srV1TXfay6RSDBu3Dhdl0ZEb8Ecoz1izTHMMNon5hzDDENE2sIMoz3MMLrFDKMdYswwAHMMkRgxw2gPM4xuMcNoBzMMEWkLM4z2iDXDAMwx2sYMo33MMFRWcCDwG+zYsQNTpkzBnDlzcOvWLdStWxddunRBdHS0rkt7q7S0NNStWxerVq3SdSnFcu7cOYwbNw5Xr17FiRMnkJOTg86dOyMtLU3XpRWqcuXKWLRoEW7evIkbN26gffv26N27Nx4+fKjr0orM19cXv/32G+rUqaPrUorE29sbERERqp+LFy/quqQiSUhIQIsWLWBgYICjR4/i0aNH+Pnnn2Ftba3r0t7K19dX7fU+ceIEAKBfv346ruzdCQAUGvrhuU9UGjHHaJdYcwwzjG6IMccww5QezDBU1jHDaBczjO4ww2iHWDMMUPZyjCYzDHMMlUbMMNrFDKM7zDDawQxTejDDUFnHDKNdYs0wAHOMLjDDaFdZyzAAjyeVVxJB4PWbC9KkSRM0atQIK1euBAAoFAo4OztjwoQJmDlzpo6rKxqJRIJ9+/ahT58+ui6l2GJiYuDg4IBz586hdevWui6n2GxsbPDjjz/i008/1XUphUpNTUWDBg3w66+/4vvvv0e9evWwbNkyXZf1RnPnzsX+/ftx584dXZdSbDNnzsSlS5dw4cIFXZfyn0yaNAmHDx+Gn58fJBKJrsspluTkZFhaWmKaoSuMJJo5FyZLUODH7CAkJSXBwsJCI30S/VfMMbol5hzDDFOyxJpjmGF0jxmGygtmGN1ihtEOZhjtKSsZBhBvjimJDAMwx1DpwwyjW8ww2sEMoz3MMLrHDEPlBTOMbok5wwDMMSWJGUb3xJphAB5PKu94ReACZGdn4+bNm+jYsaOqTSqVomPHjrhy5YoOKys/kpKSACjDg5jI5XJs374daWlpaNasma7LKZJx48ahR48eatt7aefn5wcnJydUrVoVgwcPRnBwsK5LKpKDBw+iYcOG6NevHxwcHFC/fn2sXbtW12UVS3Z2Nv766y988sknogs8ROUFc4zuiTHHMMNojxhzDDMMEWkDM4zuMcNoBzOM9pSFDAMwxxCVdswwuscMox3MMNrDDENE2sAMo3tizDAAc4y2MMPoDjMMiZm+rgsojWJjYyGXy+Ho6KjW7ujoiCdPnuioqvJDoVBg0qRJaNGiBWrVqqXrcork/v37aNasGTIzM2FmZoZ9+/ahZs2aui6rUNu3b8etW7fg6+ur61KKrEmTJti4cSNq1KiBiIgIzJs3D61atcKDBw9gbm6u6/Le6vnz51i9ejWmTJmCr776Cr6+vpg4cSIMDQ0xbNgwXZdXJPv370diYiKGDx+u61L+E7kAyDXYF1FpwhyjW2LLMcww2iXWHMMMU3oww1BZxgyjW8ww2sEMo11lIcMAZSPHaDLD5PVHVFoww+gWM4x2MMNoFzNM6cEMQ2UZM4xuiS3DAMwx2sQMo1tlIcMAPJ5UXnEgMJU648aNw4MHD3Dx4kVdl1JkNWrUwJ07d5CUlITdu3dj2LBhOHfuXKkOPiEhIfjiiy9w4sQJyGQyXZdTZN26dVP9XqdOHTRp0gRVqlTBzp07S/1tJxQKBRo2bIj//e9/AID69evjwYMHWLNmjWiCz/r169GtWzc4OTnpuhQiolJJbDmGGUa7xJpjmGGIiMo+ZpiSxwyjfWUhwwDMMUREb8MMU/KYYbSPGYaIqOwTW4YBmGO0iRlGt5hhSMw4ELgAdnZ20NPTQ1RUlFp7VFQUKlSooKOqyofx48fj8OHDOH/+PCpXrqzrcorM0NAQHh4eAAAfHx/4+vril19+wW+//abjyt7s5s2biI6ORoMGDVRtcrkc58+fx8qVK5GVlQU9PT0dVlg0VlZWqF69Ovz9/XVdSqEqVqyYLwh7eXlhz549OqqoeF68eIGTJ09i7969ui7lP5MLAuTQzGlLcoGnP1HpwhyjO2LMMcwwuiWWHMMMU3oww1BZxgyjO8ww2sEMo31izzBA2ckxmswwef0RlRbMMLrDDKMdzDDaxwxTejDDUFnGDKM7YswwAHOMLjHDaE9ZyTAAjyeVV1JdF1AaGRoawsfHB6dOnVK1KRQKnDp1Cs2aNdNhZWWXIAgYP3489u3bh9OnT8PNzU3XJf0nCoUCWVlZui7jrTp06ID79+/jzp07qp+GDRti8ODBuHPnjigCDwCkpqYiICAAFStW1HUphWrRogWePn2q1vbs2TNUqVJFRxUVz4YNG+Dg4IAePXroupT/TC5o9oeoNGGO0b6ylGOYYbRLLDmGGab0YIahsowZRvuYYbSLGUb7xJ5hgLKTYzSdYZhjqDRhhtE+ZhjtYobRPmaY0oMZhsoyZhjtK0sZBmCO0SZmGO0pKxkGYIYpr3hF4DeYMmUKhg0bhoYNG6Jx48ZYtmwZ0tLSMGLECF2X9lapqalqZ4EEBgbizp07sLGxgYuLiw4re7tx48Zh69atOHDgAMzNzREZGQkAsLS0hLGxsY6re7tZs2ahW7ducHFxQUpKCrZu3YqzZ8/i+PHjui7trczNzVGrVi21NlNTU9ja2uZrL02+/PJL9OrVC1WqVEF4eDjmzJkDPT09DBw4UNelFWry5Mlo3rw5/ve//6F///64fv06fv/9d/z++++6Lq1QCoUCGzZswLBhw6Cvz48OotKOOUa7xJpjmGG0T6w5hhmGiLSFGUa7mGG0ixlG+8ScYQDmGCIxYYbRLmYY7WKG0T5mGCLSFmYY7RJrhgGYY7SNGUY3mGGoLOCW+wYfffQRYmJiMHv2bERGRqJevXo4duwYHB0ddV3aW924cQPt2rVTPZ4yZQoAYNiwYdi4caOOqirc6tWrAQBt27ZVa9+wYQOGDx+u/YKKITo6GkOHDkVERAQsLS1Rp04dHD9+HJ06ddJ1aWVSaGgoBg4ciLi4ONjb26Nly5a4evUq7O3tdV1aoRo1aoR9+/Zh1qxZmD9/Ptzc3LBs2TIMHjxY16UV6uTJkwgODsYnn3yi61I0grdBoLKOOUa7xJpjmGG0T6w5hhmm9GCGobKOGUa7mGGoqJhhdKMs5RjeVpvKOmYY7WKGoaJihtENZpi390dUmjDDaJdYMwzAHKNtzDC6UZYyDMDjSeWVRBD41yIiovIhOTkZlpaWGCt1gZFEqpE+swQFViuCkZSUBAsLC430SURERPQqZhgiIiISo5LIMABzDBEREZUsZhgiIiISKx5PKt94RWAiIip3FAIg12BfRERERNrADENERERipMkMk9cfERERUUljhiEiIiKx4vGk8klzp7ARERGJhFwQNPpT0rKyslCvXj1IJBLcuXPnrfMGBATg/fffh729PSwsLNC/f39ERUWpzfPs2TP07t0bdnZ2sLCwQMuWLXHmzJkSXAMiIiLSBDFlmAULFqB58+YwMTGBlZVVgfNMnDgRPj4+MDIyQr169YrU7+jRo+Hu7g5jY2PY29ujd+/eePLkyX/ul4iIiEqOpjNMSeaY/7rPZMyYMZBIJFi2bJlau6urKyQSidrPokWLNFw9ERERaZKYMkxh+2E2btyYL4vk/URHR7+x38KyUVxcHLp27QonJycYGRnB2dkZ48ePR3JyckmsJhERERWRWDLMrVu30KlTJ1hZWcHW1hajRo1CamrqW5+zd+9edO7cGba2toWOoREEAd26dYNEIsH+/fs1W3wpxIHAREREpdz06dPh5ORU6HxpaWno3LkzJBIJTp8+jUuXLiE7Oxu9evWCQqFQzdezZ0/k5ubi9OnTuHnzJurWrYuePXsiMjKyJFeDiIiIypHs7Gz069cPY8eOfet8n3zyCT766KMi9+vj44MNGzbg8ePHOH78OARBQOfOnSGXq5/bXtx+iYiIiID/ts9k3759uHr16hv34cyfPx8RERGqnwkTJmi6fCIiIiqnCtsP89FHH6nlkIiICHTp0gVt2rSBg4PDG/stLBtJpVL07t0bBw8exLNnz7Bx40acPHkSY8aMKZH1JCIiorIjPDwcHTt2hIeHB65du4Zjx47h4cOHGD58+Fufl5aWhpYtW2Lx4sWFLmPZsmWQSCQaqrj009d1AURERNomByDX0ElLmrwtVEGOHj2Kf/75B3v27MHRo0ffOu+lS5cQFBSE27dvw8LCAgCwadMmWFtb4/Tp0+jYsSNiY2Ph5+eH9evXo06dOgCARYsW4ddff8WDBw9QoUKFEl4jIiIieldiyjDz5s0DoLzizJssX74cABATE4N79+4Vqd9Ro0apfnd1dcX333+PunXrIigoCO7u7u/cLxEREZUcTWaYvP5Kwn/ZZxIWFoYJEybg+PHj6NGjR4HzmJubc78LERGRiIglwwCF74cxNjaGsbGx6nFMTAxOnz6N9evXv7HPomQja2trtcHHVapUweeff44ff/xRA2tFRERE70oMx5MOHz4MAwMDrFq1ClKp8lq2a9asQZ06deDv7w8PD48CnzdkyBAAQFBQ0Fv7v3PnDn7++WfcuHEDFStW1GjtpRUHAhMRUbmTDUXhMxWzr9dvc2RkZAQjI6P/1HdUVBQ+++wz7N+/HyYmJoXOn5WVBYlEorZcmUwGqVSKixcvomPHjrC1tUWNGjWwefNmNGjQAEZGRvjtt9/g4OAAHx+f/1QvERERlSyxZBhtSUtLw4YNG+Dm5gZnZ2ddl0NERERvoMkM82p/ms4x77rPRKFQYMiQIZg2bRq8vb3fON+iRYvw3XffwcXFBYMGDcLkyZOhr89DNERERKWVWDLMu9i8eTNMTEzw4YcfvnGed8lG4eHh2Lt3L9q0aVNSpRMREVERiOF4UlZWFgwNDVWDgAGoTly6ePHiGwcCF0V6ejoGDRqEVatWlauTsrmXiYiIyg1DQ0NUqFABWyLDNNqvmZlZvsEnc+bMwdy5c9+5T0EQMHz4cIwZMwYNGzYs9GwmAGjatClMTU0xY8YM/O9//4MgCJg5cybkcjkiIiIAABKJBCdPnkSfPn1gbm4OqVQKBwcHHDt2DNbW1u9cLxEREZUcMWUYbfj1118xffp0pKWloUaNGjhx4gQMDQ11XRYRERG9pqQyDFAyOeZd95ksXrwY+vr6mDhx4hvnmThxIho0aAAbGxtcvnwZs2bNQkREBJYsWfLO9RIREVHJEFuGeRfr16/HoEGD1K4S/LriZKOBAwfiwIEDyMjIQK9evbBu3bqSXgUiIiIqgJiOJ7Vv3x5TpkzBjz/+iC+++AJpaWmYOXMmAKjGt7yryZMno3nz5ujdu/d/6kdsOBCYiIjKDZlMhsDAQGRnZ2u0X0EQIJFI1NredObTzJkzsXjx4rf29/jxY/zzzz9ISUnBrFmzilyHvb09du3ahbFjx2L58uWQSqUYOHAgGjRooDqLShAEjBs3Dg4ODrhw4QKMjY2xbt069OrVC76+vuXmlghERERiUhoyDFD0HOPp6amR+t5k8ODB6NSpEyIiIvDTTz+hf//+uHTpEmQyWYkul4iIiIqnpDIMUDL7YmrUqFHsfSY3b97EL7/8glu3buWr51VTpkxR/V6nTh0YGhpi9OjRWLhwoWjuxkBERFReiC3DFHc/zJUrV/D48WP8+eefhdZa1Gy0dOlSzJkzB8+ePcOsWbMwZcoU/Prrr8Wqi4iIiP670nA8qagZxtvbG5s2bcKUKVMwa9Ys6OnpYeLEiXB0dFS7SnBxHTx4EKdPn8bt27ffuQ+xkgiCIOi6CCIiovIiJiYGcXFxb52natWq6N+/Pw4dOqQWpuRyOfT09DB48GBs2rTprX3ExsZCX18fVlZWqFChAqZOnYpp06bh1KlT6Ny5MxISEmBhYaGav1q1avj0009VZ1gRERERva6oOebVq/Nu3LgRkyZNQmJi4hufM3fuXOzfvx937twpdk3Z2dmwtrbGunXrMHDgQI31S0RERGVHUTPMhQsXir3PZNmyZZgyZYraASq5XA6pVApnZ+c33uHp4cOHqFWrFp48eYIaNWq824oRERFRmVZS+2E+/fRT3Lp1q9DBMe96POnixYto1aoVwsPDefEZIiKicuhdMkxUVBRMTU0hkUhgYWGB7du3o1+/fm/tIygoCG5ubrh9+zbq1aunap80aZLqwnl58vbVtGrVCmfPnn2n9RIDXhGYqAwYPnw4EhMTsX//fl2XQkSFsLe3h729faHzLV++HN9//73qcXh4OLp06YIdO3agSZMmhT7fzs4OAHD69GlER0fjvffeAwCkp6cDQL4zqKRSKRQKRZHXg4hIE5hhiMSlqDlGmwRBgCAIyMrK0nUpRFSOMMMQiUtRM8y77DMZMmQIOnbsqNbWpUsXDBkyBCNGjHjjsu7cuaO6vTYRkTYxxxCJR0nsh0lNTcXOnTuxcOHCQud91+NJedO4r4aINIkZhkg83iXDODo6AgD++OMPyGQydOrU6Z2XP3PmTIwcOVKtrXbt2li6dCl69er1zv2KAQcCExERlUIuLi5qj83MzAAA7u7uqFy5MgAgLCwMHTp0wObNm9G4cWMAwIYNG+Dl5QV7e3tcuXIFX3zxBSZPnqy6ukyzZs1gbW2NYcOGYfbs2TA2NsbatWsRGBiIHj16aHENiYiIqCwLDg5GfHw8goODIZfLVVfl9fDwUOUaf39/pKamIjIyEhkZGap5atasCUNDw3xZ5/nz59ixYwc6d+4Me3t7hIaGYtGiRTA2Nkb37t1Vyy6sXyIiIqKCFHWfiaenJxYuXIj3338ftra2sLW1VevHwMAAFSpUUO2LuXLlCq5du4Z27drB3NwcV65cweTJk/Hxxx/D2tpaq+tIREREZVNR9sMAwI4dO5Cbm4uPP/44Xx/Xr1/H0KFDcerUKVSqVKlI2ejvv/9GVFQUGjVqBDMzMzx8+BDTpk1DixYt4Orqqo1VJyIiIhFbuXIlmjdvDjMzM5w4cQLTpk3DokWLYGVlpZrn1f0wAFSZJzw8HADw9OlTAECFChXUfl7n4uICNze3kl8pHeJAYCIiIpHKycnB06dPVWdlA8qQM2vWLMTHx8PV1RVff/01Jk+erJpuZ2eHY8eO4euvv0b79u2Rk5MDb29vHDhwAHXr1tXFahAREVEZNHv2bGzatEn1uH79+gCAM2fOoG3btgCAkSNH4ty5c/nmCQwMhKura76sI5PJcOHCBSxbtgwJCQlwdHRE69atcfnyZbWr6RXWLxEREVFBirrP5OnTp0hKSipyv0ZGRti+fTvmzp2LrKwsuLm5YfLkyZgyZUpJrAYRERGVQ0XZDwMA69evxwcffKA2uCZPeno6nj59ipycHABFy0Z5g4MnT56MrKwsODs744MPPsDMmTNLbmWJiIiozLh+/TrmzJmD1NRUeHp64rfffsOQIUPU5nl9P8zBgwfV7sI0YMAAAMCcOXMwd+5crdRdWkkEQRB0XQQRKW+T8tNPP+H3339HSEgIHB0dMXr0aHz99de4f/8+vvjiC1y5cgUmJibo27cvlixZojqDk7dBICIiIl1hhiEiIiIxYoYhIiIisWKOISIiIjFihiEiKllSXRdAREqzZs3CokWL8O233+LRo0fYunUrHB0dkZaWhi5dusDa2hq+vr7YtWsXTp48ifHjx+u6ZCIiIiJmGCIiIhIlZhgiIiISK+YYIiIiEiNmGCKiksUrAhOVAikpKbC3t8fKlSsxcuRItWlr167FjBkzEBISAlNTUwDA33//jV69eiE8PByOjo48+4mIiIh0ghmGiIiIxIgZhoiIiMSKOYaIiIjEiBmGiKjk8YrARKXA48ePkZWVhQ4dOhQ4rW7duqrAAwAtWrSAQqHA06dPtVkmERERkRpmGCIiIhIjZhgiIiISK+YYIiIiEiNmGCKikseBwESlgLGxsa5LICIiIio2ZhgiIiISI2YYIiIiEivmGCIiIhIjZhgiopLHgcBEpUC1atVgbGyMU6dO5Zvm5eWFu3fvIi0tTdV26dIlSKVS1KhRQ5tlEhEREalhhiEiIiIxYoYhIiIisWKOISIiIjFihiEiKnkcCExUCshkMsyYMQPTp0/H5s2bERAQgKtXr2L9+vUYPHgwZDIZhg0bhgcPHuDMmTOYMGEChgwZAkdHR12XTkREROUYMwwRERGJETMMERERiRVzDBEREYkRMwwRUcnT13UBRKT07bffQl9fH7Nnz0Z4eDgqVqyIMWPGwMTEBMePH8cXX3yBRo0awcTEBH379sWSJUt0XTIRERERMwwRERGJEjMMERERiRVzDBEREYkRMwwRUcmSCIIg6LoIIiIiIiIiIiIiIiIiIiIiIiIiIiIiKh6prgsgIiIiIiIiIiIiIiIiIiIiIiIiIiKi4uNAYCIiIiIiIiIiIiIiIiIiIiIiIiIiIhHiQGAiIiIiIiIiIiIiIiIiIiIiIiIiIiIR4kBgIiIiIiIiIiIiIiIiIiIiIiIiIiIiEeJAYCIiIiIiIiIiIiIiIiIiIiIiIiIiIhHiQGAiIiIiIiIiIiIiIiIiIiIiIiIiIiIR4kBgIiIiIiIiIiIiIiIiIiIiIiIiIiIiEeJAYCIiIiIiIiIiIiIiIiIiIiIiIiIiIhHiQGAiIiIiIiIiIiIiIiIiIiIiIiIiIiIR4kBgIiIiIiIiIiIiIiIiIiIiIiIiIiIiEeJAYCIiIiIiIiIiIiIiIiIiIiIiIiIiIhHiQGAiIiIiIiIiIiIiIiIiIiIiIiIiIiIR4kBgIi2SSCSYO3dukeZ1dXXF8OHDS7Seopo7dy4kEolWlnX27FlIJBLs3r1bK8sjdaVpuyMiotKDGaZwzDC6VZq2OyIiKl2YYwrHHKNbpWm7IyKi0oMZpnDMMLpVmrY7IiIqPZhhCscMo1ulabsj0jQOBKYStXHjRkgkEshkMoSFheWb3rZtW9SqVUsHlb2sLe9HJpOhevXqGD9+PKKiorRSw+XLlzF37lwkJiZqZXklJS+oFOWnLPv7778hkUjg5OQEhUKRb3p4eDjmzp2LO3fu5Ju2detWLFu2rOSLRNnZ7oiIShIzzNuVlc8SZhglZhgiorKFOebtysrnCXOMEnMMEVHZwQzzdmXls4QZRokZhoio7GCGebuy8lnCDKPEDENUuunrugAqH7KysrBo0SKsWLFC16XkM3/+fLi5uSEzMxMXL17E6tWr8ffff+PBgwcwMTHR6LIyMjKgr//y3+7y5cuYN28ehg8fDisrK7V5nz59CqlUHGP1vby88Oeff6q1zZo1C2ZmZvj66691VJX2bdmyBa6urggKCsLp06fRsWNHtenh4eGYN28eXF1dUa9ePbVpW7duxYMHDzBp0qQSr7OsbHdERNrADKPEDFO2McMQEZVNzDFKzDFlG3MMEVHZwwyjxAxTtjHDEBGVPcwwSswwZRszDFHpxoHApBX16tXD2rVrMWvWLDg5Oem6HDXdunVDw4YNAQAjR46Era0tlixZggMHDmDgwIEaXZZMJivyvEZGRhpddklydHTExx9/rNa2aNEi2NnZ5Wsvq9LS0nDgwAEsXLgQGzZswJYtW/KFHjEQ03ZHRKQNzDBKzDBlFzMMEVHZxRyjxBxTdjHHEBGVTcwwSswwZRczDBFR2cQMo8QMU3YxwxCVfhziTlrx1VdfQS6XY9GiRYXOm5ubi++++w7u7u4wMjKCq6srvvrqK2RlZanN5+rqip49e+LixYto3LgxZDIZqlatis2bN/+nWtu3bw8ACAwMLFY9N27cQJcuXWBnZwdjY2O4ubnhk08+UZtHIpFg7ty5AIC5c+di2rRpAAA3NzfVbQKCgoJU6zd8+HC15z9//hz9+vWDjY0NTExM0LRpUxw5ckRtnrxbEuzcuRMLFixA5cqVIZPJ0KFDB/j7+6vNe+HCBfTr1w8uLi4wMjKCs7MzJk+ejIyMjHd+/d6mKPUXJCsrCz179oSlpSUuX74MAFAoFFi2bBm8vb0hk8ng6OiI0aNHIyEhQe25Rd1OcnJyMG/ePFSrVg0ymQy2trZo2bIlTpw4UaR127dvHzIyMtCvXz8MGDAAe/fuRWZmpmr62bNn0ahRIwDAiBEjVH/vjRs3om3btjhy5AhevHihand1dVVb/zlz5sDDw0P1d5o+fXq+bVAikWD8+PHYv38/atWqBSMjI3h7e+PYsWOqeUrDdkdEJCbMMErMMMwwADMMEZHYMMcoMccwxwDMMUREYsIMo8QMwwwDMMMQEYkJM4wSMwwzDMAMQ6QrvCIwaYWbmxuGDh2KtWvXYubMmW89A2rkyJHYtGkTPvzwQ0ydOhXXrl3DwoUL8fjxY+zbt09tXn9/f3z44Yf49NNPMWzYMPzxxx8YPnw4fHx84O3t/U61BgQEAABsbW2LXE90dDQ6d+4Me3t7zJw5E1ZWVggKCsLevXvfuJwPPvgAz549w7Zt27B06VLY2dkBAOzt7QucPyoqCs2bN0d6ejomTpwIW1tbbNq0Ce+99x52796N999/X23+RYsWQSqV4ssvv0RSUhJ++OEHDB48GNeuXVPNs2vXLqSnp2Ps2LGwtbXF9evXsWLFCoSGhmLXrl3v9Pq9SXHrz5ORkYHevXvjxo0bOHnypCo4jB49Ghs3bsSIESMwceJEBAYGYuXKlbh9+zYuXboEAwMDVR9F2U7mzp2LhQsXYuTIkWjcuDGSk5Nx48YN3Lp1C506dSp0/bZs2YJ27dqhQoUKGDBgAGbOnIlDhw6hX79+AJS3ipg/fz5mz56NUaNGoVWrVgCA5s2bo1KlSkhKSkJoaCiWLl0KADAzMwOgDHfvvfceLl68iFGjRsHLywv379/H0qVL8ezZM+zfv1+tjosXL2Lv3r34/PPPYW5ujuXLl6Nv374IDg6Gra1tqdjuiIjEhBkmv9LwWcIMwwzDDENEVDjmmPxKw+cJcwxzDHMMEdHbMcPkVxo+S5hhmGGYYYiI3o4ZJr/S8FnCDMMMwwxD5YpAVII2bNggABB8fX2FgIAAQV9fX5g4caJqeps2bQRvb2/V4zt37ggAhJEjR6r18+WXXwoAhNOnT6vaqlSpIgAQzp8/r2qLjo4WjIyMhKlTpxa5tpMnTwoxMTFCSEiIsH37dsHW1lYwNjYWQkNDi1zPvn37VOv5NgCEOXPmqB7/+OOPAgAhMDAw37xVqlQRhg0bpno8adIkAYBw4cIFVVtKSorg5uYmuLq6CnK5XBAEQThz5owAQPDy8hKysrJU8/7yyy8CAOH+/fuqtvT09HzLXbhwoSCRSIQXL16o2ubMmSMU9+3C29tbaNOmzTvXv2vXLiElJUVo06aNYGdnJ9y+fVv1vAsXLggAhC1btqgt89ixY/nai7qd1K1bV+jRo0ex1jFPVFSUoK+vL6xdu1bV1rx5c6F3795q8/n6+goAhA0bNuTro0ePHkKVKlXytf/555+CVCpVe90EQRDWrFkjABAuXbqkagMgGBoaCv7+/qq2u3fvCgCEFStWqNp0vd0REYkBM4w6ZhhmGGYYIiLxYI5RxxzDHMMcQ0QkDsww6phhmGGYYYiIxIEZRh0zDDMMMwyR7khBpCVVq1bFkCFD8PvvvyMiIqLAef7++28AwJQpU9Tap06dCgD5Lr1es2ZN1VkkgPIMjho1auD58+dFrqtjx46wt7eHs7MzBgwYADMzM+zbtw+VKlUqcj1WVlYAgMOHDyMnJ6fIyy6Ov//+G40bN0bLli1VbWZmZhg1ahSCgoLw6NEjtflHjBgBQ0ND1eO81+nV18bY2Fj1e1paGmJjY9G8eXMIgoDbt2/rtP6kpCR07twZT548wdmzZ1GvXj3VtF27dsHS0hKdOnVCbGys6sfHxwdmZmY4c+aMWl9F2U6srKzw8OFD+Pn5FXvdtm/fDqlUir59+6raBg4ciKNHj+a7LUNx7dq1C15eXvD09FRb17zbdby+rh07doS7u7vqcZ06dWBhYVGs/4lXlcR2R0QkNsww/w0zTD3VNGYYZhgiIm1jjvlvmGPqqaYxxzDHEBFpEzPMf8MMU081jRmGGYaISJuYYf4bZph6qmnMMMwwRO+CA4FJq7755hvk5uZi0aJFBU5/8eIFpFIpPDw81NorVKgAKysrvHjxQq3dxcUlXx/W1taqDxq5XI7IyEi1n+zsbLX5V61ahRMnTuDMmTN49OgRnj9/ji5duhSrnjZt2qBv376YN28e7Ozs0Lt3b2zYsAFZWVnFeHXe7sWLF6hRo0a+di8vL9X0V73+2lhbWwOA2odwcHAwhg8fDhsbG5iZmcHe3h5t2rQBoAwdmlTc+idNmgRfX1+cPHky3y0t/Pz8kJSUBAcHB9jb26v9pKamIjo6Wm3+wrYTAJg/fz4SExNRvXp11K5dG9OmTcO9e/eKtG5//fUXGjdujLi4OPj7+8Pf3x/169dHdnb2f76dhJ+fHx4+fJhvPatXrw4A77SuxVES2x0RkRgxw7w7ZpiXmGGYYYiIdIE55t0xx7zEHMMcQ0Skbcww744Z5iVmGGYYIiJtY4Z5d8wwLzHDMMMQvQt9XRdA5UvVqlXx8ccf4/fff8fMmTPfOJ9EIilSf3p6egW2C4IAAAgJCYGbm5vatDNnzqBt27aqx40bN0bDhg3fupzC6pFIJNi9ezeuXr2KQ4cO4fjx4/jkk0/w888/4+rVqzAzMyvC2mhWYa+NXC5Hp06dEB8fjxkzZsDT0xOmpqYICwvD8OHDoVAotFluPr1798b27duxaNEibN68GVLpy/MWFAoFHBwcsGXLlgKfa29vr/a4sNcCAFq3bo2AgAAcOHAA//zzD9atW4elS5dizZo1GDly5Bvr9PPzg6+vLwCgWrVq+aZv2bIFo0aNevOKFkKhUKB27dpYsmRJgdOdnZ3VHhdlXUuSrpdPRFRSmGG0hxnmJWYYZhgiIk1gjtEe5piXmGOYY4iI/itmGO1hhnmJGYYZhojov2KG0R5mmJeYYZhhiAAOBCYd+Oabb/DXX39h8eLF+aZVqVIFCoUCfn5+qrMrACAqKgqJiYmoUqVKsZZVoUIFnDhxQq2tbt26RX5+cetp2rQpmjZtigULFmDr1q0YPHgwtm/f/sYPzaKGu7xanj59mq/9yZMnqunFcf/+fTx79gybNm3C0KFDVe2vv16aUtz6+/Tpg86dO2P48OEwNzfH6tWrVdPc3d1x8uRJtGjRQu1WDv+VjY0NRowYgREjRiA1NRWtW7fG3Llz3xp6tmzZAgMDA/z555/5PvAvXryI5cuXIzg4GC4uLm/9e79pmru7O+7evYsOHToUa3t5G11ud0REYsYM8xIzDDNMHmYYIiJxYI55iTmGOSYPcwwRUenHDPMSMwwzTB5mGCKi0o8Z5iVmGGaYPMwwRCVPWvgsRJrl7u6Ojz/+GL/99hsiIyPVpnXv3h0AsGzZMrX2vDM/evToUaxlyWQydOzYUe0n77LsRVHUehISEvKd3VGvXj0AeOutEExNTQEAiYmJRarl+vXruHLliqotLS0Nv//+O1xdXVGzZs1C+3hV3gf0q3ULgoBffvmlWP0U1bvUP3ToUCxfvhxr1qzBjBkzVO39+/eHXC7Hd999l+85ubm5RXo9XxcXF6f22MzMDB4eHoXeymLLli1o1aoVPvroI3z44YdqP9OmTQMAbNu2DcDb/96mpqYF3nqif//+CAsLw9q1a/NNy8jIQFpaWpHW7/VlvamO12l6uyMiEjNmmJeYYZhh8jDDEBGJA3PMS8wxzDF5mGOIiEo/ZpiXmGGYYfIwwxARlX7MMC8xwzDD5GGGISp5vCIw6cTXX3+NP//8E0+fPoW3t7eqvW7duhg2bBh+//13JCYmok2bNrh+/To2bdqEPn36oF27dlqts6j1bNq0Cb/++ivef/99uLu7IyUlBWvXroWFhYUqOBXEx8cHgPL1GDBgAAwMDNCrVy/Vh9KrZs6ciW3btqFbt26YOHEibGxssGnTJgQGBmLPnj1qtwkoCk9PT7i7u+PLL79EWFgYLCwssGfPHiQkJBSrn6J61/rHjx+P5ORkfP3117C0tMRXX32FNm3aYPTo0Vi4cCHu3LmDzp07w8DAAH5+fti1axd++eUXfPjhh8Wqr2bNmmjbti18fHxgY2ODGzduYPfu3Rg/fvwbn3Pt2jX4+/u/cZ5KlSqhQYMG2LJlC2bMmAF3d3dYWVlhzZo1MDc3h6mpKZo0aQI3Nzf4+Phgx44dmDJlCho1agQzMzP06tULQ4YMwc6dOzFmzBicOXMGLVq0gFwux5MnT7Bz504cP3680Nt4vE6X2x0RkdgxwygxwzDDMMMQEYkPc4wScwxzDHMMEZG4MMMoMcMwwzDDEBGJCzOMEjMMMwwzDJEWCUQlaMOGDQIAwdfXN9+0YcOGCQAEb29vtfacnBxh3rx5gpubm2BgYCA4OzsLs2bNEjIzM9Xmq1KlitCjR498/bZp00Zo06bNf6qtuPXcunVLGDhwoODi4iIYGRkJDg4OQs+ePYUbN26o9QVAmDNnjlrbd999J1SqVEmQSqUCACEwMFC1fsOGDVObNyAgQPjwww8FKysrQSaTCY0bNxYOHz6sNs+ZM2cEAMKuXbvU2gMDAwUAwoYNG1Rtjx49Ejp27CiYmZkJdnZ2wmeffSbcvXs333xz5swRivt24e3tne/v8F/qnz59ugBAWLlypart999/F3x8fARjY2PB3NxcqF27tjB9+nQhPDxcNU9Rt5Pvv/9eaNy4sWBlZSUYGxsLnp6ewoIFC4Ts7Ow3ruOECRMEAEJAQMAb55k7d64AQLh7964gCIJw4MABoWbNmoK+vr7a65yamioMGjRIsLKyEgAIVapUUfWRnZ0tLF68WPD29haMjIwEa2trwcfHR5g3b56QlJSkmg+AMG7cuHw1FLQt6XK7IyISA2YYZhhN1c8MwwxDRKRtzDHMMZqqnzmGOYaISJuYYZhhNFU/MwwzDBGRNjHDMMNoqn5mGGYYov9KIgivXbudiIiIiIiIiIiIiIiIiIiIiIiIiIiISj1ev5qIiIiIiIiIiIiIiIiIiIiIiIiIiEiEOBCYiIiIiIiIiIiIiIiIiIiIiIiIiIhIhDgQmIiIiIiIiIiIiIiIiIiIiIiIiIiISIQ4EJiIiIiIiIiIiIiIiIiIiIiIiIiIiEiEOBCYiIiIiIiIiIiIiIiIiIiIiIiIiIhIhDgQmIiIiIiIiIiIiIiIiIiIiIiIiIiISIQ4EJiIiIiIiIiIiIiIiIiIiIiIiIiIiEiEOBCYiIiIiIiIiIiIiIiIiIiIiIiIiIhIhDgQmIiIiIiIiIiIiIiIiIiIiIiIiIiISIQ4EJiIiIiIiIiIiIiIiIiIiIiIiIiIiEiEOBCYiIiIiIiIiIiIiIiIiIiIiIiIiIhIhDgQmIiIiIiIiIiIiIiIiIiIiIiIiIiISIQ4EJiIiIiIiIiIiIiIiIiIiIiIiIiIiEiE9HVdwH81RuJaov2vEYLUHsufXCjR5el5tlJ73OrHMyW6vNLowrR2+dpyru3XfiEiYNCkT742w/qfaL8QLcq+/Yfa4/SMTB1VUrqYGMvytT2JStZBJdrj6Wih9nj8nns6qkQ7Vvatk68tMyNDY/3LjI011hcVTcrmuSXav/lQ9f61nZkqDfy9RJdXGoVtG5WvbchfN3RQSen358cN87WVtwwDAB2Wl+x3CzE4NbFVvram35/UQSXac/WbjvnaPD7fq4NKtMf/1w/UHmty2y9oG6KSV5K54vVMAQA5vgdLbHkGjd7L11ax38oSW15pFLFrfL627msu66CS0u/vMc3ztZXHDNPm57PaL6SUOTe1bb622tOPaL8QLbr/Q498bVU+2aqDSrTnxR+D8rVpan99QfvAqeRpO8NkJ0SW2PIMrSvka6s78+8SW15pdXdRd7XHYQlpOqqk9Ktkbar2uDxmmIOPSu5/Uizeq5n/vePHc/46qER7prXxyNdW1vNsQVn18OMojfTd08tRI/1Q8Wg7w+xwqFliy/so+lG+tuFbb5XY8kqrjYMa5Gu73rW9Diop/RofO632uKxnGCB/jpG/uKujSkoXvSp11R7nRAXqqBLtMHB0y9dWHnObIuC6xvqXujfWWF+lFa8ITEREREREREREREREREREREREREREJEIcCExERERERERERERERERERERERERERCRCHAhMREREREREREREREREREREREREREQkQhwITEREREREREREREREREREREREREREJEIcCExERERERERERERERERERERERERERCRCHAhMREREREREREREREREREREREREREQkQhwITEREREREREREREREREREREREREREJEIcCExERERERERERERERERERERERERERCRCHAhMREREREREREREREREREREREREREQkQvq6LoDenSCXAwDiHl1C6NltqDdhNQDg4fqZkNk6QRAUMDA2h0uXTxB8YhPs6rRB7L1zsKvTBqYV3AAAz3YshnufiYh/fAWJfjchNTCEVbWGSHp+FzkpCUiPCoK5S004NuoKcxcv1bJf/LMRGdHB0Dc2h2nFqrD2bILbSz5Fg2kbYWRpjydbvoPn4G9xZ8VYmLvUhJCbA2PHKqjUsi8UOdmQGhhq7HXIzVW+DocuXMePf+7F5T9+BAD0mjQf7pUrQq5QwNrCDPNGD8J363bgg/bNsPf0FXzQvhlquVcBAHw6fzl++fIzHLl0A6eu34WxkSE6NK6LC7ceIio+CY8Cg9GkVnUM79kBjbyrq5Z97uYDbDh0ElZmpqhb3Q2RcQkIjY7Fqet30aFxXfRq1RiONlboN3Mx7m9fAWOZET6dvxxGhgaITUzGx93b4viVWwiPSUBiSipqVnXGlMF9UMneFjIjzb1GeQRBAcizIY+4CYlEH4I8G3oV6gKQIDfoNCQmdoBCDj2XVhDi/QF9GSTmTlCE+wIQAAASY1tIbasjN/A09N3aI+fORuhX7wmJiR1yg85C37Wt2jIVKRFQRN6GRGYFSPSgV7kJch7thp5TQ0itXFXPyX1xARKpHiBRnp8gdWqk7EAihUQieaf1zc3NRUJCAubNnQtjE2MkJSVhxoyZ0NfXx4CPPoKPjw8yszKxdu06/PXXX7CztUWHjh3x1ayZUCgUEASgXv36GDZsGAYPGogtW7fBwtwM586dR/0GDTBs6BBs2vyn2jIjIyMxY8Z02Nvbw9jYGPXr18fZM2dx+vQptG/fATU8a+Czz0ahQf16WLd+PZo2bYY///wT+/ftg42tDTw9PSHPlSM0NFT1nB49e6JNmzaQyWTv9Dq86bVZ+dNChL4IgkKhQJuOXdC73wBMH/cZPGp4onWHzti+aT0e3LkNZ1c3WNvYona9BrCysUW7zl3x3O8Z/t6/B+OnzVLr98j+3bh87gxkMmM0b9MOvlcuIS4mGv5Pn6CuT0N8MGAIIiPCsG7FUuw8dgYAMGpgXzi7uiEyPAzDRo/D3/t3I9DfH0YyGZwqV8YXM76FuaUl9PXf/SMrNS4K13euRnJkCPQMZTC3q4BmH3+BG7vXQiHPRatPZgAA/hzfE851miIjKR4dJ3wPA5kJrm1fhcyURAASmDs4oUHv4dg1cxDs3ZTvidVb9cCzC0eQGB6k1reRqYVq+Ye+/xzm9hUBAO7NOiE1Lgr3j25Dv0VbkRjxAn4Xj8Gz3Xs4+sNkONX0QXZGKqq37A7nus2Qm50FfUOjYq9zaGgoFixYgOeBgTCWyeDs7IzvvvsOixYvRk5ODn7+6ScAgHetWujQvj3i4uOxefNmmJqaYvbs2YiNjYVEIoGrqyumTZuGxo0bo0GDBgCAwYMHY8uWLXj69CmMjY3h4uKCRYsWwcrKSrX8ZcuW4cmTJ9DT08OAAQOwZcsWhIeHIyEhAd7e3pg2bRoOHjyIy5cvY9euXQCAxo0bo1GjRggJCcHUqVOxbds23LhxA+7u7rCzs8OSJUtgaGj4zu8JVLoICuXnd2bYXaQ+Pg77zsr3k7hzy6FvZg9BECA1NIF57d5IeXAYxs4NkBFyC8bODWBgVQkAkHB1Iyx9BiAr/D6yIh8D+gYwcvRCdswzKDJTkJMUDkPbqjCp2hyGtm6qZSffP4Tc5AhIDU1hYFUJRhVrIebYfDh0nwc9E2vEX14Lm+afIeafhTC0dYOgyIW+RUWY1egAQZ4DiZ6BRl4DhTwXABB66zweHt6EbvM2AQBO/zgR5o7OEBRyGJpaou6HY3Bv31pUadQeL3xPo0qj9rBy9gAAXP5tLhoNm46w2xcR8eAa9AyNULFWE0Q9uYXMpDgkhT2HnUdtuLd+D3bu3qplRz6+iYBzB2BoYg5rl+rISIpDenwUIh5cQ8VaTVC5QWvILG1xftk09PphF/QNZbj821xIDQyRlZKIqi17IPzeZaQnxCA7LQVWlauiZvchMLG2h947vGcVprxlGEC5feRmpOL54bWQGhohNyMVrp2HQiLVw/3138DCxROK3Gx4Df4KkdePwcDUEjaejeB/4Ffl6yUIMHeuAaemPXD/j29R+5PvcGZyO/hMWQML5xp4sHEuag2fq7bMrOQ4+O1bCUMzK0gNjGDhXAPxz24i/ukN2NRoCFPHKqjUsg+u/m8IvId8DUu32oi4dhTRd87CwNQCphVcISjkyEyIVj3HvnZLWFWrDz0DzWwXglyO0DObkRUfAUEQYFWjMezrdYL/rkUwdqgCq+qNEe17CGlhz2Bk4wR9EwuYVaoBfVNLWNdoioyYYMTdP4vK7Yeq9Rt37wySAm5BamAIC3cfpATdQ05qAjKig2Dm7AX7Bl2RnRSD8As7UGvMSgDAk81fQWZTEVlJMajYvC/i7p9BRmwopPqGMLJyQOUOI6AvM4NET+8/rXNuahzifXcgJzkSUn1D6JvZw6bpx0i4uRtQ5MKu5acAgBdbxsGkch3IM5Lg0GEipAYyxF/fBnlmCgAJ9M3tYV2/D0L3zICRXVUAgFm1Vkj1u4DsxDC1vvWMTFXLDz/8PQzM7QEApu5NkZsah6T7R1H5w8XISQxHqv8lmNdoh8jjP8C4ohcU2Rkwq9YKJs51ocjNhlS/eN9rMhOjEXh0AzJiw6FnYAgja0e49xqNoH82Q5DnonrfLwAAV74bCJsaDdH33DJmGNKqvAyTFXEfaU9OwLbDNABA/IVf/80wCkgNTWHm3QOpj45CVrkeMkPvQFa5HgwsnQAAib5/wqJ+f2RFPEB21BNI9Axg6OiJ7Bh/KDJTkJscAQNbVxi7NoWhjatq2SkP/4Y8JRISQxMYWDrBsII34k4shF2Xb6BnbIXEqxtg1XQE4k79CANbNwjyXOhbVIBptbYlkmGi713E8+N/ofnMdQAA3xVTYepQCYJCAQMTC1R77zP4H/kDFeq3Q+TtM6hQvx3MKynff+5t+h41P5qC6PuXEffEF1IDQ9h5NUa8321kJccjNSIQVm7eqNy8J6xca6qWHffsFkIvHYaBiRnMK1dDVnI8MhOiEPvYF3ZejeBYpxUMLWxw67dZaD1nG/QMjXBv0/eQ6hsiOzURlZp2Q8zDK8hKjEVOegrMnNzg1mkQZFb2GvuselV5zDCCXI6cjBQEHV0HPUMZcjNS4dJxCCRSPTzc+C3MnWtAkZuNGgNmIerGcRiYWsK6ekM8P7waUAgQIMC8cnVUaNwdjzbNQc1h83B+egfUn/grzCvXwOO/5sPr49lqy8xOjkfAwVUwMLOCnoERzCpXR6LfLST43YR1NR+YOLqgYrPeuPHjcNQYOAuWrrUQ6XsMsffOQd/EAqaOygyTlRiteo6tdwtYedTX2D5MQSFH9KWtyE6KBAQFzKo2grV3e4Qc/gkyOxeYVW2I+Dt/IyPSH4ZWFaFvbAHjitWgZ2wBC/fGyIoLQeKT83BsMVit38TH55D64g6k+oYwq1IfaSH3kZueiKzYYBg71YB17U7ISYlD7LVdcB+yFAAQtHsODK0qICclFnYN+yDx8Tlkx4dBom8IAwt7OLYcAj2ZmXL7+A9y0+KQdHsvclOiINEzhL6ZLax8BiDp7n4ICjlsmirzWPjuKZA51YI8Mxm2rcZAaiBD4q3dUGSlAAD0zexhUbsnIg99C0NbVwCASdUWSH9+CTlJEWp9S1/JMNH/LIa+mZ1yftcmyE2LQ8rjf1Ch13fITYpEWuAVmHm0RszppTBy9ISQkwGTqs1hXKk2hNxsSIqZYQAgKzEGwSc2ITMuHFIDQxhZOcK1+2cIOfUnFHI53HuPBwDcWPwxxj5/D9HR0cwxpDV5GSbZ7yqir+1GtaHK94TAnbNhaF0REBTQk5nDsdUQRF3aCqsaLZD49BKsarSAzN4VABByZAmcOo1Fiv91pATdhtTACGau9ZAW/AC56YnIjH0BEydP2NTuBBOnGqplR17cgqy4EOjJzCCzd4WFeyM8+2McaoxcAwNzO7w4sBhVes+A3+bJMHGqASE3BzI7F9g17P1O3yneJDdXmWH+OXoEq35ZgiMnzwEAPu73PlyrVoVCLoeVtTWmfTUbSxb/Dz3e64MjB/ejx3t94FlTuU9l8rjR+H7xzzh5/CjOnz0DmbEMrdu2x9VLFxETE41nTx6jQcNG+GjwUNT3aaha9uWL57H9r82wsLSEd606iImOQnhYKC6cPYNWbduhc7eesHdwwMghA3H22i0YGxtj8rjRMDQ0RHxcHD4cMAhnTv6DqMhIJCUmoLqnF8ZMmIQKFZ00etwgT3nMMPLcXKQmJ+KvXxbBSGaMtJRk9B89CVJ9fSyc+Amq1aqL7OwsTPrfcpzevxMW1jao17wNNvw0H4JCAUEQ4OFdBx0/GIhFk0Zi5rJ1eL9OZfy47Qg8vOvixy/HYNpPa9SWmRATjfWL58DS1haGRsbw8K6Du1cv4O6V86jbrDWcq1ZD14+GYfx7rTFp4Qp41W+EU/t24PKJwzC3tIaze3XI5bmIjQxXPadJ+y6o3bgFDI00s13Ic3NxYuNyxEeEQFAI8GzWFj6d+2Db91Ph6FYNnk3a4MqBrQh9+gC2lVxgamkN5xq1YWJpjZrN2yP6RQDunD6CziMmqvV759Rh+N28BANDGao1bIHnd68jJSEWUYF+cKlZD426f4ikmEic3fo7JqzZAwBYP/1T2Dq5IDEmAq36jcCdU4cRExIIAyMZrBwqouunkyEzs4DefziWBCg/z1/8sxEZceGQGhhBZuUAtx6jEHzyTyjkufDoMwEAcH3hYFhXb4ic1ATUGDALekbGCDr2B3LSkgCJBDLrCnBuNwC3fxkLs0rVAAAODToi+tZJpMeEqPWtb2ymWv79tTMgs3YEANjVaYOspBiEX9yL+l+sQUZsKKJvn0aFRl3xcOO3sKxaB/LMdDg06ADr6g3f+Rh8bGQ4tq76CZEhQTA0ksG+YmUMm/I1dqxZCnluLkZ99T0AYFSXpujdoyszDGlV3j6IkFvncf/gRvT8bjMA4OTiCTCv8PI4Sv1+Y3F37++o0rgDXlw/hSqNO8D63+MoF9fMQZPhMxB6+wLC7yuPozj9exwlIykOiaHPYe9RGx5t34O9ey3Vsu/s+Q1JYYEwNLWAtYsHKtdriQMzP0KfH/fA1MYB51bMQpsJC3H426Gw96gFRW4OLCu5oWbXQZBnZ2n0WEmuQgEAuBATh83PX2BDM2XOmHTzLiqbGEMhCLAwMMBoDzesCwhCe0d7nI6KQXtHe7ibK99j5t9/jC+9quFiTByuxyXASCpFYztr3I5PRHx2Dp6npqGWpQV6VaoIb6uXx7lvxifgYGgEzA30Ud3cDHFZ2YjKzML1uHg0trVBawc72BgZYsbt+9jRsglkenqYf/8xDKRSJGbnoHslR1yJiUdsVhaSc3JR1cwUH7u5wN7IEEb/cd/568pjhsnNzUVCUjK+/WklTGQyJCan4KsJn0FfTw8fjp6ChnW9kZmVjQ0/f4fNuw/C1sYanVs1w/T/Lfl3TIyABrVrYkT/Pug/9kvsXP0TjNx9cHn/n/CpXRODxs/A1pWL1ZYZGR2Lqd/9BAdba8hkMvjU9sLpS9dx8uJVdGzZFJ4ebhjzcX/U6vg+Ni79Hs196mHTrgPYc/QkbK0s4VXNHbnyXISGR6me06tTW7Rr1ggymWb+b3JzczH/p18Q+CIYCoWAbh3b4eN+72PYuMmoWaMaunZoh983/YWbd+6jqmsV2NlYo2G9OrC1sUaPzh3wxC8AO/cfwuxpk9T63bH/EE6duwhjmQwd2rTEhSvXEBUTi0dP/dDEpx6GD+iP0IgI/LhiDS4f2w8A6DVwBKq6uiAkPAKTRn+KHfsP4pl/IIxlRnCu7IR5M6bCytLiP42HAYDE6Aic2LgCceHBqnzUfdQ0nPrzV8jlOeg94VsAwOJBHVCtYQukJsZhwKwfYWhsguN/LEN6UgIgkcC6QiW0HfAZVozpC6dqyv2yDTq9h1snDqplr+6jpsHY/OV7xfrpn8LKUbn/u06brkiKicSlfX9iwpq9iA0JxJ3TR9Cw6wfY/O3ncKvbCFlpqajXsReqN2yJnKwsGBi9w5iYiCjMW74Oz4NDIZMZwcWpAhZOG4cFq/5ATm4uln07FQBQvX1fdGzZGDGZKPMZpkwNBE5FLp4hDQ1gqZPl5+1EeP2fMzMrC7J32GDfJC0iANG3TyEnNRFVe32O+EeXYV+/I5Ke34Vl1bqQGsrg3kf5hSry6mHEP7pcaJ+x98+jWr9p0Jcpd5baerdAZnwkIi7vg1vPsQU+x7njENWA4sz4SFh7NkHo6a1wf/8L1TxGVo5w7638QhR0dB1SwwOQnRyL2LtnYO7iBfu67aFvYv5Or8M9vyBsO34esYlJ+PGLT3DownUM7NIaF24/RKv63jAxlmHZl58BANbt/weHLlwvtM+9p69g7TfjYWFqAgB4r3UTBIVHY/Xuv7F44vB88x84dxUzhvWFl5uzWvtHs37AqhnK123q0vWY/dkA7D59GUO6twMA/DBxOFLSM/DzX/uxasZYnLv5AA+fB+Pzft0BAGMX/goTmRH6dWyBprU93+n1eZWQEQ9FQgCE3CxAIoGevTckMisI8mzIQ65Ar2IDSM0qQq9SY8hDLgPybNVzFXHPILGoDKlFZWVfgkKtb4m5E+TRD6Hv2uaNy5dYuULP/uWBO4mxNRQJgZBYuqjNJ3VqBImeARTJYVDEPYHUwgXyyNuQGJlDau0BiVHRtpX79+9jx47tiI2Jhb6+PsZPmABPT08kJSXhiy8mYt68+Wjbri0WLlyEiRMmICkpSfXcDX/8gU6du6BLly4AXv5f52nXrj1+Wf4LNm7cVOCyr1+7hpYtWuKzUaNUbR980BeDBw3E8hUrAAB79+7BtOkzsH3bdjRt2gwAMHLkSHTr3l1tcPGrz1m+/Bc8efwEXbt2Rddu3WBo+G47P58+eoBDe3YiIS4OpubmGDVxKtw8qmH6uM/QrHVb2No54NnjR/hswhTM/WEZVv64EJ179kZ1r5rYt31Lof3/c+gAFixbBbN/P/A7dO2BsOAX2PLH75g+dwEAYOuEtejZtz98r1xCo2YtYGxigm8X/oTbN67j/u2bmPvDMuzbvkU16Dg5KRFzvvwCNnZ26NW3P6p7eb+tBDWxQc/w7MIRZCQnoOXwL/H8+hkYm1vBtWEbyHOykZmaBIlUipzMdBjITGDvWgNtR32Dm3vXIykyBKlxUTC1tkeTAeMAvPyyaW5XEW1Hf6tajlPNBnh85oCq79cZyIzV5n985gBsXarh6fkjcKz28gtl5dpN0GLYVAiCgL8XTUTlOk3x4PgOxIc+xz7pEPTo0aPQv/39+/exfccOxMbEYPHixTh06BBsbW3RvXt3ZGVlISE+HlKpFGlpaTA1NUWdOnWwfPlyLF22DP7+/ggNDUXFihUxf/58AC//B1xcXLBmzcsdla1atcLGjRthZ2eHnj175qvjxIkT2L9/PwwMDFTznz17Fg8ePMD48coDX76+vvDw8MCLFy9QpUoVuLi4YNWqVdi2bRsSExOxZs0azJ07Fx9++CFq1aqF58+fY968eahatSqGDBmCqlWrvvW1EJOw+GRsu3QXX/ZqpbMaFP9+wZVCPVTmQoA+NLezLCcxFBlB1yDPSoVl/X7IDLsL4yqNkRX9DEYO1SHRM4Klz0AAQJr/eWSG3S20z4yQW7BqMhRSA2MAgHHleshNjUWa31lY1v+wwOeYe/dQDSjOTY2FUcVaSHl0FFYNB6nm0TOxgaXPAABA8t19yEkIgTwjCRnBvjC0rQrjKg0hNTQtsP+3SQj2Q+DlY8hKSYDPoMkIvXUebs27IurJLTh6NoC+kTEaDVUOKvI7vReht84X2mew7yk0/exbGP6709jZpw1SY8Lx9MRO+AyalG/+kBtnUKvXCFhWclNrP798BpqMUA7KvvHXz6jTdzSCr59C1ZY9AAA+gyYhJzMdjw5vRpMRsxD5+CaSQgNQo1N/AMDV9QugbyRDlSadYF+tTrFfm9eVtwwDAKlhAYi8+Q9yUpMgkerBuW0/mFZwRW5GKp7uXIKqPT+DdfUGqNZnHJ7s+Am5Gamq54ZfOQRbryawrdlU+RrI1XOMdXUfhJzeAe9h6oNn8iQHPoSVe11UbtlH1eZQvx3u//EtPD/6EgAQffsMXDsPQaTvCVi61QYAVGrRG3a1mqsNLn71OcFndiAtMgh2NZvB1rsZpPrFH4iWHvkcsXdPITc9CXpGJnBqMxAyO2cE7F4ES/cGMDCzQkZUIJxaD4Dbe5MQenozbLxbwcTRDTG3jhfaf9zDC6j6/lTV9yEbr+bISohE5LUDqNJ1NAAg4NpB2NVtj+Sge7BwrQOpgQyuPScgJfgR0sKewO29SYi5dVw16Dg3IxWBB5dC39QKdnU6wKSC29tKyCcrLgipzy4oB8U0H460wGvQk1nA1LUhBHkOFFmpACRQ5GRCaiCDkZ0r7NuMRsKtvchJikRuWhz0TKxh01j5npp34F/fzA72bUarlmPsVBPJT06r+n6d1MBIbf7kJ6dhZOuC1GfnYeTg8bKfSrVh13wYBEFA5NGFMK5cB8kPjyE7PhT79kkKzTGvbvsefcYh9v5FGJhawq5Wcyhys5GbngJIJJBnZUDPyBhmlTxQo/9UNEy7yAyjQ7reDwO8PDlYX1/9wEFmVrZGT7DNSQxDZvANKLJTYV7nfWSG34fMpRGyY/xhaO8Bib4RLOr3AwCkP7+ErIj7hfaZGXoHlg0HqTKMzKkOctPikO5/HhZ13y/wOaZeXVUDinPT4mBUoSbSnvwDi/r9VfNITWxgUU+ZgVLuH0ROYigUGUnICL0FQxtXyJx9IDU0KfZrkBzqj3Dff5CdkgivDycg+u4FODXujHi/O7CpVg96RjLU/GgKACD4wgFE37tYaJ+Rt8+g9pCvYGCsfP91rNsK6XERCD67B559x+ebP+rOebh3HQqziq5q7bd+/xq1Bk0HADzauQzVeo5E5K3TqNS0GwDAs+945GalI/CfLag1aDrint1CavhzVGmrfJ0ebFkMqYERKjbsCOuqtfBflcsMEx6A6FsnkZOWCIlUD5Vb94OJYxXkZqTCb+9SuHX7DNbVGqBqr7Hw270E8sw01XMjrx2GTY0msPFqolznfy9+kMe6mg9Cz+2E1+BvUZDkFw9hWbUOnJr3VrXZ122LR5vmoNqHym0y5u5ZuHQYjOibJ2DpqvwbV2z2HmxrNlMbXPzqc0LP7UR61AvYeDWFjVfTd8owmdGBSHx8VpVh7Jv0g5FNZYQc+RlmVepB39QKmbEvYNekHyp1Ho+oS1tgWV056C7hwclC+09+dgmVuk6CnpHyf9qiWlNkJ0Uh7tZhVGynPFko9PYSWNZsi7SQBzB1rgWpgRGcOo5FethjpEc+Q6XO45Hw4KRq0LE8MxVhx1dA38QKVjXbqgYAFlV2fDDSAi5BkZUC60aDkR58A3oycxg7N1BmmOw0vJphDGxcYNP8EyTdO4DclCjI0+KhZ2IFqwbK/8+8DKNnagub5p+qliOr4IlUv3Oqvl8n0TdSmz/V7xwMrZ2RFnAJRnbuL/up6A3rxoMhCAJiTv0MmVMtpDw5iZzEMOzbZ1ykfTGv76+Pe3gRBiaWsKnZDIrcbOSkp0AikUKenQE9Q2OYOnlg9erVWLhwIXOMDuk6x7zxeFJmpkYHdmZEByLx0RnkpifDqf1IJPtfg3XNtkgNeQAz51qQGshQqZPyWEbcnaNI9r9aaJ9JTy+hcveX7z2W1ZohOykKsTcPwan9yAKf49h8gOr9JDspCuZVGyL6yk5U6vy5ah5Dc3tU6jgGABBxbhMyop8jJyUeSU/Ow8SpBiy9WkNfVvzjSY8ePsC+XTsQHxuL2QsW4p+jR/D+h/1x9fJFNG3eEiYmJvh+8c8AgL82/oF/jh4ptM8jB/fj5xWrYW6h3A/epXtPhAS/wMa1v+Hb7/6Xb/5jhw9hwuQvUa2G+vGeUcMGY9GS5QCAObOm48tZ3+DIgX34cIBy/9Ts7xYiNTUVq5cvxaIly3H54nk8ffwIIz5Tvk7TJ42HsbEJ3nu/L3waNyn2a/O68phhgp4+wrnDe5GUEAc9PT28N3QUnN2rIy0lGWvmz8THk2ahbtOWGDFtDn6dNx1pKcmq5/6zewt8WrWDT6sOAJSDZl9Vt2krHNj4G6b++GuBy35y9wa8GzZFtwHDVG0tuvTCokkj8fmcHwAAl44fQr9RX+DcoT3wqq8cMNS1/1A0attJbXDxq885sHENgp/7oWHrDmjYuiMM3uF4UkTAE9w+eRCpifGQmZih/eCxsHdxw7YFX6KaT3OY2dgh8vlTtBs0Gn2nfod/NixHnTZdUaFqddw4uqfQ/u+fO4Z+MxZCZqr8W3m37Ij4iFBc3vcXen4+EwCwY/8W1O/YC8/vXkfVuo1hKDNGn0lz8OLhbYQ8vou+U7/DjaN7VIOOM1KSsefnb2BmZYv6nd5Dxao13lZCPq/mWff3xiH2gXK/hK3q8zxZ+Xmet1/CyQPV+k5G8KktyIgLQ1ZiDAwtbOHa9RMALzOtkZWDKl8CgGXVOoj0Pabq+3V6hjK1+SN9j8G0YlVE3zqhdtGuvGwtCAIe/vE1rKr5IPzyfqRHvcC+qglFyjCBTx/h3OE9SIqPw6cz5uHqqaOwsLZB47adkZOdhdSkREikUmSmp0FmYgo3L29mmFJA1xlGLiiPJem9NkApW1DAUKK5G5LHB/sh8NJRZKYkoNHgKQi5eRZVW3RF5ONbqOClPI7SZJhyP8Cz03sRcvNcoX2+uHYKzUfNhqGJ8jiKS8O2SI0Jx+N/dqDR4MkFPqfO+yNVA4pTY8JRuW4L3D/wB5qOmKmax8y2gqqWWztWIv7FM6QnxCDo6nHYedSGW7MuaheQKg6/lFQcD49CQk42JtXwwPnoWHRxcsTt+ETUt7GCTE8PX3opL2S3LyQc52NiC+3zdFQMvqnlCbN/c2gbB3uEZ2RgV3AYvqjhkW/+s1GxGF61CtzM1I+HzbzzADO9le+1Sx77YZSHG05HxqB7pQoAgC9quCNdLsefgcGY6V0DN+MT8DwlDf2qKLPC/x4+gUyqh04VHVDb6r9tz+Uxw9x7/Axb9/+N2PgE6Ovr4YtPP4aXR1UkJadg3DcL8P20CWjXogl+/HoKPv/qeyQlp6ieu277HnRp0wLd2rUEkH9MTIcWTbB07Wb8tXxRgcu+euseWjVugDFDXu6P/LBHZ/Qf+yV+/d83AIDdR/7BrPEjsXXfETT3qQcAGDW4H3p2aK02uPjV5yxd9yce+z1H93at0L19KxgaFn8/zL1Hj7FtzwHExsXDwtwMMyZ+jhoeVTFs3BR0aN0CjnZ2ePD4KaZPGItVPyzA/B+X4YOe3VDLqwY2b99daP97Dx3F2mWLYWGu/Fu917UTgoJDsfqPzVg89ysAwOoJf2Jg3964cOU6WjVrDBMTY/yycB6u3rgF39t3seqHBdi8fbdq0HFiUjLGfvkV7O1sMbBvb9T2Kt4YsVdzW6/Pv8LDiydU+Sg3OwvpKYmQSKTIzkiHobEJnDy88MGU+Ti9ZQ1iw14gKSYSFrb26PLJJAAvM62VQ0X0nfqdajludRqpZa/XGcqM1ea/cXQPKrhVx+0TB+Ds+fKYsUeD5uj5+UwIgoCNX41GNZ8WuHJgC6KC/OERP7BIGebeEz9sPXgcMfEJ+PmrSdh/4hzsrK3Qs31LZGVlIz4pGVKJFGnpGTA1MUZdr2r4df4MLN55qsxnGM19EpcCZtDXSeC59zQAM39ajTFzfkJqeka+6fefPcfwGQvw8x/bEBFd+Afvm2TEhuHemslIeHYDlVp9iOr9pyt3HsrM4FC/I6Jvnsj3HDPnGsiICSm07ypdPsGLY+vxbMdiJAXeK1I9ISf/hP+epYi+fQoAYGRlDz2ZKdIinhc4f14tNp5NUP2jmTCrVB3PD/8Kv90/F2l5efxDItBx7Dc4ef0OJg18D2u/mYC0jExYmZliUNc2+Ovvs/me4+PlgWcvwgvte/6YwZi9egs+nb8cF+88KnT+L4d8gA0HT2Lkdyuw78yVfNMzs7IRm5iMQV3a4MhFX1X7zBWb0G3iXIzs07nAflfP+hzfjhyABwHB6DD2a1y9/6TQWgoiZCUj1+8oFClhkNrXgr5LS0CerTwbCYBEzxD4N8goUiORG3gaAgRI9F8ZuJ6ZCImJHQRBgDz0GhShr+0IlOpDYuYIRfKbtzMhMQjykMuQR9z+t0UCqW01KOKeFji/xMQOyEyGxMgc+lVaQ2rtAUW8H3L9jyMhIeGNywkICEDXLp1x6tRJTJgwEWt++w1JSYnw9FR+UFpaWiI3JwcAcP7ceQweNBAKhULtjI3Hjx/Dx8cHCoUC06Z9iSmT1UO/mZkpWjRvgWPHjhVYQ9du3ZCYmIjPx47F4kUFB6ODBw9i4MCBSEtPQ0qKMnBt2LAB7du1Rddu3Qt8zsSJX+CX5cuhp6eHj/r3x/p16974OhTkRWAAhr7fA5fOnsbwMeOxYNkqWFhYYt2qZZg7fRKGjByDAzu3osf7fVHPpzGuXSp40Nm2jeswd/okrPxpYYHTJ82ajWULv8OsiWNx42r+kxCiIsJhYWmJXn0/woFd2wAAGenpmD9zKubPmILuffrme46FpRUWLFuFYaPH4eKZUxj6fg+8CAx46/omRgRj3+xPEXL3Cur1GooO4+bn+4L1/NopVGnQCm6N2sLvknKAUGzQM5xc/jUintyGrUs1xIcEwOHfK2he37Ea/yxTDo5LiY3A2d++w9nfvkNyVOhbawGAnMwM1fzR/g8BAO5NOyLo5nnkZmflm18ikcDCsTIykuNRr9dQtPnsa+jp6aFPnz747bffClxGQEAAOnfpgpOnTmHihAn47bff1LZtADhw8CC6dO2Knj17YvduZZC9f/8+Ph05EpcuXULt2rXx8OFDNGqk3KE4d+5cDBqk3OkcHByMMWPGYMyYMQgMDCx0nWfPno2JEydixIgRePjwYb7pV69eRYMGDTBo0CD88ccfAICQkBCMGjUKK1euRMeOHfM9p2rVqti0aROGDRuGjRs3olOnTm99TxCTSjYWOhsEHIdsXEUCziMOOf8OBn5VPLJxGrG4iySkIbeAHoomNyUasad+RlbkI5h6doJ1k2EQcrMgNTSBiWsTZATlP9BkaOuK3JSoQvu2qNMbKff2I+HqRmRF+xWpnpSHR5DouwXpQcoThfRMbCA1MEZOYliB8xv8W4vMqRasm46AgY0Lkm7vQuL1Pwucv8BlRoXgnwWjEXH/Kry6DUKzz2YjNysDBiZmcGveDc8v/p3vObZVvZEc8aLQvuv2G4u7u1bj8m9zEf30dqHze/ccBv9z+3H593kI9j2db7o8OwuZKYlwa94VobcuqNpvbVuOU4vGoVr7Dwrst+mnX6PO+6OQGOKPf74fhRi/ouXK15W3DAMA6TGhuLViIuKfXodL24/gNWgmcjNSYVrBFQCgb2wGhUL5P5jodxv3//gWEAQYvHJSXVpEEMxdPCEoFHi2dzme7V6mtgw9I2NYutdB7MP8uRUAbL2bITc9BY+3LUbg8YJPeoq5dwEVGnaGPDsDuZnpAJQDkG8sHQs77+YFPsel3Ueo0X8qIJXi/rqvEHbpwFtfi1dlxoXh0fqpSPK/iYotPkTV97+EnswM4Rd2IOjgL6jQtA9ib5+AbZ12MHOpieTAOwX2E3XtIAIPLkPo6YL/Z507jkDoyQ0I2PsDkoPyD97LTo6FnswUtnU7IvaO8nuXIicTgYeWI+jQL7Ct3S7fc/SNzVD1/S9RsXlfJPnfwKP1U5EZV/B7zKtykiIQdmA2MkLuwrJuLzi0G6d2hV4ASH1+DSYuDWDq1gip/peUNcYFIerUcmRGPoGhrQuy40NUA3XjfXcg6qTyil+5qbGIOfcbYs79hpzkwt9jFTlZqvkzo/0BAKZVmyHtxQ0I8px880skEhhYOEKekQyruu/BvvWot+aYgrZ9g9dOFo25dwG2NZvCvnZLRN1Wvmelhvnj0V8LmGF0TFf7YQDlycGzVmzC2IWrkJqRf1/Mg4AXGDFnKZb8tQ8RsfHvvJzc1BjEnf0F2VFPYFK9HSwbDoYgz4bUwBjGLo2Q8SL/SccG1i7ITYkutG/zWj2R+uAwEn3/RHaMf5HqSXt8DEm3tiMj+AYAQGpsDYm+DDlJBe/zMLCpgtyUaBhV9IZVoyHQt3JGyt29SLq5rUjLA4C06FBcWzIesY+vw63DANQZ+hXk2ZnQNzGHU+MuCLt6NN9zLF29kBYVXGjf1d8bBb+Dv+Hepu8R73en0Pmrdh6MkEuHcG/zAkTePptvujwnCzlpSXBq3BnR9y+p2p/sXQXfXybBuVWfAvutNXgGqvX8FClhAbi6ZBwSnj8otJaClMcMkxEbhru/TkLCsxuo3KYfanw0A7kZqTBxVN6FS9/YTDUIItH/Nh5tmgNBUKhd9Swt8mWGCTiwEv77flFbhp6hMSzd6iD+ccGD02y8miI3IwXPdv6IFycL/qyPfXABDg06QZ6dqcowkdcO486K8bDxyj8AAwAqt+kPj76TIZFK8XDjtwi/cvCtr8WrshLC8Xz7TKQG3YZdwz6o3G0SpEamiLm+B2EnVsG2QS8kPjwFK682MHHyRFpwwbk5/vYRhP2zEtGXtxY43bHVUERd2IzQv5ciLTT/dpuTEgs9I1NY1WyHxIfKz1BFThbCT6xG+IlfYeXZOt9z9GRmqNxtEuwa9kZq4C083z4TWQmF71fNSY5E1NHvkRl2Hxa1usO25Si1K/QCQPqLGzCuXBfGLj5ID1T+PXPigxF7fjWyop7BwNoZOYmhMPz37gWJt/cg7twqAIA8LQ7xl9cj/vL6Ir3HCrlZqvmzYpX7q01cGyMz5DaEVw765pFIJNA3c4AiMxkWtbrDpvmIQvfFFLS//tVtGwDiHlyEjWcT2Hg3R8zdswCAtPAADB06lDlGx3SVY+4/fISv5n6PzydNQ2paWr7pDx49wSdjJ2DJitWIiCw8r79JVkI4ArbORGrgLdg1eh/O3ScpB+AbmcLKux0SHpzK9xyTitWRFV/4dxbH1kMReX4TQo4sQVpI0T4zoy5vR+jxlUh4dBYAYGBuB6mRKTJiggqc36RiNWTFhcHCvSGce0yBsaM7Ik6tQ+ix5UVaHgAEPg/Ah7264vzpUxj1+Xj8vHI10tPSYWFhib79B2D39vx5qF4DHwT4F75vacY3c7B4wTxMHjca165cKnT+z7+Ygm1/bsKUcWPw96H834kzMzMRHx+H9/t9hBPHXu4f+n7O1xj0QS98PPyTAvv9YdlKTJn5FR4/eoi+Pbvg5vVrhdZSkPKYYSJeBOLr4R/g9uVz6D1sNCZ+vxRpKclwdlcOpjI1t0BurvI77/3rl7Bo0kgICgXMLF6+b4T4P0W1WvWgUCiwbuG3+G3BV2rLkJmYoqZPE9w4n///DQAatu6I1ORErJg9FTvXLC1wnqsnj6JNz77IzEhHepryZPB/dm/B9MG90KhN/vdtAOg9fAzGfrsIUqkeFk4cgWM7N7/1tXhVbOgLrPliMJ75XkSrfp+g/4xFkJlZ4Oy237F3yWy0/GAobh7bh3rte6KKd30E3C44n105sBV7fv4WJzauKHB6l5FTcGzdUuxYOB2B93zzTU+KiYTMzBz1O/XGzeP7AQDZmRnYt2wu9i6Zjbrt8w/EMDa3QP8Zi9Cq3wg8u34Ba74YjNjQwverFpRnX/88j71/ETaeTWHr3QIxd5V3u0yNCMCTbf9DctADmFaoqrzLrrPyeGTQ8Y14vEU5ECYrMRp+u5fAb/cSZMRFFFqPPDtTNX9KiHLbt6vTBnGPrkCRU3CGkdlWRE5qoiq/FpZhwl8EYtaw93H70ln0HjYGXyxYprZtA8CVk0fRsHUHNG3fFReOKt+3Ap88YoYpBXSVYV7kZmJLajTWpkYg87WBkgAQkpuFVcnhOJQeh4QC9hkWVXJkCI59Pwrh96+gZvfBaDFqDnKyMmBoYo6qLbrj+cXD+Z5jW7VmkY6j1O//OW7v+hUX18xB1JPCj6MAwL1963Bl/f/w/JJy34eJrSMMTcyQEFxwXlDWEoTK9Vqg5Zj5sHX1hO9fS3B53fdFWl6ekLR0jL1+G9di4zHQ1Rnf1vJChlwBM319dKtYAX+HR+Z7Tk1LcwSnpRfa99hqVbHG7znm33+M2wmJhc4/1M0FB0MjMP/+Y5yJisk3PUsuR1JODrpUdMSFVwYir3gWgAk37uL9yk4F9vuVtyc+83CFf0oaxly/hfuJSQXO9zZlMcMIufnHDrzKPygY7T/6FCcuXMHkkUOw7sd5SExOgZeH8nu0pYU5cv4d1Hjuii/6j/0SCkEBK8uXYyUePQtAo7reUCgUmDLvB0ycrT6uxczUBC0bNcDfZy6gIN3bt0JCcjJGzZiHBSvWFjjP/uOnMbhPD6SlZyAlVfm9Z/22vWj5wVD06JB/XwQATB45BKu+/wp6elJ8MGoSft9S+MBc1esSGISO7w/EybMXMWnMp1i77AdYWljgp1W/Ydz0bzB+5DD8uXMPPnq/F5r6NMDZSwUfJ/tt418YN/1rfPfTLwVOnz/rS8xe+DM+nTgNF6/m3y8cFhEJK0sLDOrbB3/t2gsASE/PwMSZszF+xrfo3yd/hrGytMDaZT/gi9Gf4MSZC+j4/kD4BwYVus4F5bZXr9ALAA8unIBnkzbwbtkBd88oT3gMD3iC7f+bhqD7N1Ghag1EBfmhcg3lQN1/NizHtu+VJyQlRkdgz8/fYs/P3yI+ovBxh9mZGar5Q54oj7PVbtMVj6+ceeOYGBsnZ6QlxqN1/0/wwZR5hWYY/6AQtB80FicuXsPkTwZi/aJvYWWhfjxp34mz6NamOd7r2Bo7jiiP59174odhX84tFxmmTA0E1jb/F6FoP3QiTly6jsnDP8K6BTPzbWAA0Ki2FzYu/hpdWzXFD+u2oNfo6e+0PCMrBzg174PM2DCEX9iN1DA/RN84jqzEKLw49gdSgh+qXREMAFJCnsDY3vkNPb5k4uAC9z4T4fHhVISd3VGkepw7DoFH38lwqN9B1Va57QCEnt1e4PypIU9hbO8MRW42Yu+dQ5TvURiYWaNi8z5FWl4elwp2GNuvO/xDIvDL9oO4/fQ5Nh85jeCoWMxeswVXHzxFUqr6DrQbj/xQo0qlQvuuUaUSln35GdZ89Tl+/mt/ofM72dvghy9GYN23E/DHgfwDsfeeuYKouER88fPv8AuOwLNg5U60RROGYdO8ydh1suAdRM+Cw7B8+yHceOSHYT07oLaHa6G1FMjAFFJ7LyArGYqYhxDS4yAxMIWQqQxRgjz75a0HzCpA30151oaQm/myD5kVhHTl5dD1KjdRn/YvqW11KOL8ACH/ADLg3zOgnJtDr2L9l8+xqAwhNQpQ5P8iIKTHAjJLCIIARWokFLGPAHkWpA61YGn55i82zs7OGD1mDAL8A7By5QrcuXMHlZ2d8ezZMwBAcnIy9P89E6N1m9bYslW5oy829mUg9fLyws2bNyGVSvHjjz8hLi7/4P0Rn3yCzZs2Qv7aFWoAwNDQENOmT8evq1cjLCwMwcHqXzpCQ0Pw8OFDfDl1KqKjorFr505lnyNG4PCRv3HyZP7tKK/GP9avx+HDh9GqdSt0717wgOE3qVjJGYM/+QwvAgOw6bdVeHRfeYXNkeMmYcHSVWjQuClOHDmE3Vs34/6dW9i/o+CDwgOHj8TcH5Zh/JezCpzu5lEN3/zvR8z/eTn++DX/Ttl9O7YgPCwUvyyajzs3fJGSnARjExPMXvQzJs74GudP/lNgv4/u38Wm31bhRWAAPv50FCpWevv7mrldRdTuNgCJkS9w9/CfiHn+ON88zy4eRfDtiwj0PQu/S8qB3Xau1dFx4gLYVqmOxIgXsHF2R3SA8gO78UdjVV8U8q4I3Hb0t7BwrPzWWoCXVwRuO/pbOHi8vKJxnW4Dce/v/AfzBEFAcnQYjC1skJGcgEcn9uDAgQNo27YtevXqVeAynJ2dMWbMGAT4+2PFypW4c+dOvnl27tiBf44fx+HDh7Hz31sP1K5dG+vXrUOdOnXw7NkzeHt7w9dXueNt7ty5UPx7q5m8s5/WrFkDN7fCr2jYpEkT1ZnhP/30U77pGzZswJ07d7Bq1SocPHgQCoUCzs7O+P333zFw4EBcu5Z/p7UgCLhw4QJ++eUXxMXF4csvv3zrewK9XRJycBCRCEUG6sACbWEHowKioQOM0B52cIYx7iAZR1H4AdeC6JnYwLR6W+SmRCPt6UnkJAQjPfAK5GnxSL53ANmxz6HIVh/Ekx0XBAOLCoX2rW9RAZY+A2HVeAhSnxT8PvI6c+8esGo0GCaujVVtZl5dkPq44BM9cuKCoG/uCEGeg4yQm0h/fgl6RuYwrda2SMsDABPbCqjRqT+So0Lw5NhWxAc9RcCFw0iPi8Kd3asR638P2enqWS72+UNYOFUptG/Liq5oNHQamn76DR4eKXxwsom1PXwGTUbzUXPgf3Z/vunBvqeRmRQH380/IjkyWLUTrcHAiWg59ju8uFrw51VyxAs8Pr4NcYGP4N7mPVg7Vyu0lgKVswwDADJrR1Ru9QHSY0IRfHYnUkKfwcjaQTWIKjczDVKp8gx9q2r1UfsT5cGE7NREVR+mFV2REvwEEqkU1T+YqLwV4WucmvVExNUj+c5qBwCpvgFcOw+B18AZyEqMQUa8+s7EzIQopEYE4NmeX5CdkoCoWyf/7bMX6o9birgnBd+BIzs1EeGXDyL2/kVYVasPu1ot3vpavMrQ0gGOTXojMy4MEZf3IC1cOVDOqdVHqPr+VJhXqYX4RxcRc/Mo0kKfIvZ2wdumY5P34PbeJFRuP6TA6cb2znDtOR5uvacg4uLOfNNjbh1HdlIMQk/+gdTgx8q/h4EMbr0monKH4Uh8VvDB1rRwf0Rc3oPMuDBUaNoHhpYOha6zvpkdLGt1Q05SBJLuHUJWTP4TLVP9LiA9+BbSAn2R6q+84qahrSscO0yEoU0V5CSGw9DGGVn/Dty1afSRajvPuyKwfZvRMLBwLLSevCsC27cZDdkrVwC2rNUdSffzn8AgCAJykqOhZ2wBeUYykh+feGuOKWjbf13UzROIe3QVMfcvIuqm8gCqWSUP1Pz4a2aYcsg/JAIdx3yNk9duY9Kg3lj77URYmZvlm69hzWrYMG8yujTzwY+b9qD35PnvtDw9E2uYerRGbmoM0v3OICchRHl3g/QEpDw8hJz4QChy1DNMTsIL6JsX/v+lb+4Ii/r9YOkzCGnPCh4c8DpTr66wbDAAxi4vr+BtWqMj0p4W/P6XE/8C+uYOEOQ5yAy9jYygq5AamcPEvegnoRnbOMKlbV+kR4ci6NQOJIU8Q+iVv5EZH4VnB39DYuAD5Ly2Pyop6BFMHV3e0ONLZhWqoOZHU1Dr45kIPFHwQMdXyazs4fXhBNQZ+jVCLh7KNz3y9llkJcXj0Y4lSIsKUX2Oen4wDnU/mYOIGwW/zmlRwQg6vRNJLx6jcrMeMK/kXuB8hSqHGcbIygFOLd5HRmwows4r91fKrB2RHv0yw0j+vdWnlUd91Bw2DwDUcopphZcZxr33+AIzTMUmPRF5/W8IioIzjEuHj1G9/zRkJ8Yg8/UMkxiNtIhABOxfgZzUBMTcUW4HFZr0RO3RPyHhaf7BJ3k1Rl49hNiHl2DlXhe2NQs+6akgBhb2sK3fE1kJ4Yi9cQAZUcoTmu0b90Xlrl/AtHJNJD+7jPh7x5ER8QyJDwveNm3q90ClzuPh0HxQgdONbCrDqeMYVOoyAbHX9+abnvDgFLKTYxB1YTPSw59AnpWmvCJwp7FwaPkxUp7fKLDfjKgAxN44gKyEcNjW7wUDC/tC11nf1A7mXp2QmxyJlIdHkR0XlG+e9OeXkRF6FxnBN5EeqDzoZmDjArvWY2Fo44LcpEgYWFVG9r8Dd63q91Xl1rwrAts0/xT65oVnqrwrAts0/xRGdi+vnmLm1Rkpj/N/bxQEAfLUGEhlFpBnpiD16elC98UUtL/+dTG3TyHh6XXEP7yM2DvKwdimTu7YvHkzc0w54/88EJ16fYATp8/hi89H4/eVS2FVwGvZsEE9/LF6Bbp2bI8fl61A748+fqflGVjYw7bBv+9DvvuRERWA+PsnkZMcg8jzm5EepnxPeFV6xDMY2RS+r1NmWxmVOo1F5a4TEX298Ct/AsorAlfuMh7WNduq2hya9EXM1V0Fzp8e4Qcj20pQ5OYg8clFxN87AX1TS9g2yH/g/E0qVXbG8JGjEfjcH2tXr8KDe3exa9tfCAsLweLv5+GW7zUkJ6t/5ty5dQMe1aoX2rd7ter4fvHP+GHZSqxZUfAggVdVqFgRs79fiCWr1mDr5o35pv996ABioqPwzfQpeB7gj+f/Dkb+Zt4CrPj9DxzcV/Dr/NzfD+tWr8Ld27cwYPBQeHm/450NymGGsatYCd0HfoKIF89xYPPveP74PuwrVkJooPJ7dHpqCvT/vRtA7cYtMHOZ8uIsyQlxqj6cPWrA78EdSKVSjJz1HZIT8p+A2PnDwTi5ZysUBRxPMjA0RL9RX2DC/J8RGxWB6HD1ARYxEWF44fcYaxd+g8S4GFw4sk/V53frduD2pbMFrltyQhyO7/oL188cR61GzdGobcEXJSqIlWNFNH//Y8SGBeHCrg0I81MeH2k7cBT6TV8I19o+eHDhH1w/shMhT+7j5vF9BfbTrPcg9J36HToNn1DgdAeXqujzxWx8OG0Bzm7Pf+GbG8f2IjEqAsfWLUHwo9vISE2BocwY70+aiy6fTsKTawWve5jfQ1zYtQGxYUFo8cEQWDlWLHSdC8qzr4u+fQrxT68h7uElRP97grJZRXd4DvwKphWrIiM2FCb/b+8+A6Oqtj6MP9PSKykkhCq9VymCgCAiTYqoKBauDa56sXe9tlevihVRbGClWSnSOwrSe68hIYH0nkymvh8GEkNCVRIC/98nZ58z5+yJw8yavddeu2ptcuI9hZ1q9x5R9D4/URG4/tDH8A07c39OVASuP/QxAmsUVzWO6TKEhD9Kfxa43W6s6cewBIQUxa9nimEiomPof9vdJB4+xIxvP+PAztKL4pfP/oUNvy9h9ZJ5rJgzHYA6jZoohrkMHXPaeCXzMFttefTzq8KowGr4G02lzqtr8eXBoGq08gpgRkEab2WdeXFwWfzDo2jU62ZyjsWzc+4k0mJ3c2DFLHLTjrHph09I3rcNW35OieekHthBULXaZ7x2cLXadLjrKa669wW2zz67RRItBt9Lp3ue44rOfYramvW/i+2/lV1II+3gToKia+O024hds4j9y2fiG1SFRr1uLvP8U4ny9WFozRji8wuYejiePdk5zE44SpLVyvh9B9mWmUWuvWTxnh1Z2dTyP/MulrX8/XiicQOea9qQSYfO/P8pwsebhxvV47/NGzPjSOlFokuTUkgrtPHOrn3E5eUXJSP/p0FdXmnehEXHyp5XjMvLZ+rhI+zKymZATDT1AkqP753RJRjDYDp9JdSa1aJ58K5h7D8UxwcTvmfT9t3UqBbNngOxAGTn5GI5Ue2505X8MN7zuZqaXpxI2KRBXdZt2YHRaOS9l54itYyE8HtvHcJX06bjdJWVE2Ph2Qfv5fO3XiLhaBKHT3pfxCceY/ue/Tzy8lskpaYzdaYnkf6eW4ewYNJnLFhR9q72qekZfDHlZ2YuXEa3ju3of23ZCcNl/l1iqvHvu+9g/6FYPvxsIpu2eWKYJx4cyefvv8VV7dsxffZ8Jk6exvrNW/luWukxFICRI27n47df58UnHi7zeMN6V/DBGy/z6btv8O4npZOgv532M3EJifz3zXdYvX4TWdnZ+Pn5MvbNV3n56ceYt2hZmdfdtG0HH342kf2HYnngnjupGVN2Av1fnSpuK3HdxbPYs3YFO/5YzObFnoUU1eo2YthzY4iu24jU+ENUrV2fI3s8C9Sv+9foorG3ExWBb3z8NapEnznv8ERF4Bsff40ajZoXtXcecgd//FL6M9ftdpN+9Aj+IVXIy0xnzaxpZ4xhalaL4oE7hrIvNp4PJk5l047SyfZTZi5g3vI/mbloBVN/84yZt2hUn2/eefmyiGHMZz6l8sjHSRz5NOLctwY6HzWjq/Lg8CEsWrWOD775gZv79GDFus0cTjjGfbfcwBfTZtL1ylYM6NGZhavWM2fZKswmE0/ff34DN0azhfAW3Qhv0Q1bbgYpGxeRHbudpvd4Vmek7VhJyqbFuGxWDkwfi9vtwuIbSHTHAeTE78Zo8vxgjV/0HWbfQAL+8uPhyNIpFGYl47LbCWt+dh+mJ67jE16N8OaeMvhm3wACYuqTvtuzSqYwM4kDMz7C7bDjG1mTgGp1Sd+9BoPZQt1BDxdNBJwLL4uFG3tcxY09riI5PZMp81fw59bdzHzfsz3grBVrmTJvBfkFVh555wucLhehQQHcN7g3a3fsxft4IugbE38kNMifdo2LE1TGfPsLR5JTsRbaGXxNxzP2ZeKMhWzeexC3G7q1bV7q+K9L/+TXd57D18ebrfti+Wpm8aB+y/p1+GDyTJLSMks976dFq7irfw9qRZ95UPt0DEYThpDaEFIbt70AV8ZBjJHNcR7dgMFowe20YYpqVeI5pvDGuJK2YvAJBY4HNYnrcGbHAwbP6qST72MwYgy9Amdi2ZMH7sxYnFbP6zRWL66yYopshmNv8ao9V+K64kCs2pVQmA2FWRijWntWawFG46nXL3h5eTF48BAGDx5CcnIy06ZN5dFHH+Pll17CP8CfrKwsnn/+hRLPGTlqFO+++w5NmniSM/9199089+wzzJs7F5PZROs2pbcWNJvN3HLLMJ5//rlSx1atWsmUyVPw9vHG4XAQE1Ny4PS7b79j3LhxdOjQEbvdzm233soNAz1bV/r5+dGuXTvmzJ5N3379Sjxv5owZtGvXjpGjRp3y9Z+Ol5cXvQcMoveAQaSlpDDrlx/ISC8esFr350qu7duf+0c/DsCTD9xLVua5r4z94qP3OZaYQGGhlev63VDimNvtZuPaNXw+2bNya8n8Ocz6uTjR5prr+vDgXbfSb/DQEs/LSEtj7ao/GDHyIcIizjzxBGCyWKjXqRf1OvUiPyuNvSvmEBBenEyYnZyAf5VIut/veT/88c07pMcXVxlu2X84K79+h14P/481U8ax7PP/w2TxIjDSs6DgREVggIbd+hPdqDWnc6IiMECtNsUT7tWatGHzb98SGO4Z/DmybQ2/T3wLW0EuLfrcisFg4OCaxUTWb8aEp0tvKfdXXl5eDBk8mCGDB5OcnMzUadOoXr34/Xf48GGqVavG2LGeBO2nn3mGXbuKE6QfeeQRHnvsMb7//ntefPFF/v3vf+Pt7V0U4JxY/QRwxx130Lnz6ZO4nnrqKaxWK5mZmQwfPrzEsby8PNLS0oqqEo8dO7ZEle377ruPm266iR49Sm4psXfvXnbv3s3LL798yQ3YJGflMm/zXu7sVvoz50IJwEwzAjmClW1kUxd/ErGSg4MmBLKTHKrhQy18OYKVOAowAK04v+2LDCYzvjXa4lujLU5rNgWH12JLPUBYN89gsDVhCwWH1+B2FpK1YQputxujlx/+9bpiSzuEweQJW3N2zMbo5Y+lSnFybM6ueTjzM8BpL3NL2LKcuI45MAKf6p7nGL38sFSphTXB82PHmZ9O1oapuF0OzEFRWEJrYE3cjsFoJrjtrRjKGOw6HZPZQq32PanVvifWrHQOrZpHyt4t9HjSM2EUv3E5h1bNxVFYwLpvx+B2OfHyD6ZBjyGkHdiB0eL5Ltw2YwJe/kGE1SneZmjHb9+Ql5aE026j5pWlt2M52b5l08mI3QO4qdq4XanjceuX0P2x9zB7+ZARt4/9y4urn4XWasDOuZMoyEor9bzDaxZRt+sAAsLPPKh9OpdbDAOeWD+yVXciW3XHlpPBsfULqdXzNg789jkmb18cBbnU6fOvEs+pfvUQDi+aREC0J7GhWqcB7J/xCak7VmEwmkpMFhTdx2Smarte7J8xvtSxzANbObZ+PkazF26XE5+Qkt+7R9fMpdEtTxJcpxkup4PtE18gooXnd4DJy4egWo1J3b6yVKJvytYVBNVsTPWry64kfaa/S1izroQ164o9N4PUrUtw5BdP1GbHbiW0cWdiut0KwP4f/4ejIOdUlzulxBVTsWWn4HLYqNK0ZHKc2+0mJ24Hje70fBdn7FpF2pbiuD60USf2TPovYc1L/tuz52WRHbuF6KtuxBIQetZ9MZgsBNTtREDdTjjys8jdtwJzQPH7156djNm/ChHdRgKQuuprbOnFk4XBLfqTtuprql77MOlrp5Cy/DMMJktRwsyJisAAAQ264Rt9+m2mTlQEBvCrWfwZ61utCVlbZ8HxvhUkbCP1jwm4bAUEN++LwWAg79BqvCPrM2HCqRfDlvXe9w4p/h1UkHYU7+AIT1VpYN+v48g7Flt0XDFMxSrvcRgoXhy8eO0WPpwyg5t6Xc3vG7dz+Ggy9w7uzZe/zufq1k0Z0LU9i9ZuYc4f6zCbTDx119AzX7wMBqMZn+qt8aneGqc1B2vcOmxpB6nSxbOFtjVxG9a4dbgdhWRv+hG324XRyx+/K7pgT4/FcHwRR96ueRi8/LCEFscwubsX4irIwO104BPT6qz6c+I6Zv8IvKt7nmP08sMSUoPCo57BXld+Otmbf8LtdGAOqoolpLrnmNFMUOubzjmGMZotRLe5hug211CYnUHiuvlkHthKu4c8OzwlbfmdxLULcBZa2TntPdwuFxa/IGpePYis2J0Yj4/D7J/7FRa/QIJrFW9ne2D+91gzknDZbVRt3f2MfYn/YybZ8fsAN2ENS8d9SZuW0faBtzF5eZN9ZD/xq4q/r4Oq1+fQoqkUZpdO0Di6YQnVO/XDN+zMi9BO53KNYSJadiOiZTdsORkkb1pE9e7DiJ37ZVEMU+u6ESWeU63zYOKXTMYvyvNZHdWhPwd/G0/arj8xGE0lxiyLXrPJRGSbazn4W+mKIFmHtpG0YUFRDON9UgyTtHYuDYY+TlDtpricDnZ+8xLhzT3f9yYvHwJrNiJtxyrCTtrdIHXbCgJrNKZa58Gn/RuU+XcxWQhu2IXghl1w5GWSuWsZzoLircTz4rcTVL8TER09k8Hxv43Bac091eVOKWXNT9hzUnA77AQ1KPkd53a7yU/YSe2hnuTr7P1ryDxeiRMgqF4HDv/6GsGNS25v6sjPIi9+G+HtBmH2DznrvhhMZvxqd8CvdgecBVnkHVyFyT+s+Lo5KZj8QqlylaeqZcba77FnFu+yFNjkejLWTiK82wNkbvyR9FUTS8QwJyoCA/jX7YJ31dNv932iIjCAz/HPSwCfqEbk7Jhb1Dfr0R2kr/4Wt72AgMbXYTAYKDi8Dq/wukyY8OJp71HWeP1f4xhr+jG8gsOpN8Sz49jBWePJT4otOq44pmKV+3xS9Rj+fe/dLFq2nLHjP+emwTewYuWfHI6L594Rd/Dl19/RtXMn+vfpzaKly5mzYJEnhnm07CS6MzGaLIQ06kJII8/nUMbOpeQn7KLOTZ7PhKx9q8nYsRSX3UrCwvHgdmHyCSSsVR8Kju7BcHw+KWnVVEw+AfhFFc+jJK/+EXtOKi6HjeAGp39fnnDiOt4h0QQ38mxBbPIJwDeqHjkHPBOwtpwUEhZ9itthxzusBr6RV5B9YD1Gs4WY6x445xjGy8uL/gMH03/gYFJTkvn1xx9Yt2Y13/3gmfRfMHc2v/44jfz8fF54+nFcTichoaHcPuIeNm1Yh5e3p1Lch++8RXBICC1bty269scfvkdiwhEKrYX0HTDwjH2Z/O3X7Ni2BbfbzVVXl56DmzNrOl9N/hFfX1927tjOlO+LJ8qbNGvOZx+PJSW5dIXoWdN/4Zbhd1C9xpkXYJ3O5RjDWLy86Ny7P5179yczLZXlv/3M4Lsf5LsP/4evrx95OdkMe/DxEs/pd9vd/PzlOGrW8/yOvm7ocL5651XWLVuEyWyiXtOWpe5jMpvp1n8IX7/7WqljOzesYdmsn7B4e+N0OgmrWjLhY/Gv03jg5TE0atUOh93Om4/cS6drPUVivH39qN+8NWuXLqD9NSUTff9cOIcGzVvT77aS40hnw2zxokX3PrTo3ofcjDQ2LppJflbxXNHBLWtpenUvegz3fD9N/r/HyM859wqOSyd/RlbyMey2Qpp37V3imNvtJnb7Ru55y5MgvGPlYjYtKh6bbHJVT75+fhStepRMEMnLTOfA5rV0vfluAkLDOFtlxbMnf597B4dT/0bP9/mBmZ+UGJeIuXooB2d9QqPbnid23kT2/fw+RrMFnyqe8dETFYEBItv2IrhO6fnkvzpRERigSuMORe3BV7TgyIof8Q7xLDrN2LeR/dM/wmnNJ6bLYAwGQ1H8OuHD088let7/A+jcewCZaSks++0XwqOL339JCXGERUbxwEtvAzDhrZeI21+caKMYpmKVdwwTbrTQ2zeUbbY85uSn08k7iF32fFJcNq71CWWRNYPGFj/aeQWy1Z7HxsJcTAYYWMb3wNkwmS3U7nAttTtcS0FWOgdXzSV57xaufcozvxm3YTkHV3rmUdZ883bRPErDnjeSemA7puPzKFt//RIv/yDC6xbPo2yb9TV5aUm47IXUOot5lL9eJzCqOrXbeyo3evkHUqVOY45s8lRLzU07xppv3sblsBNcrQ5VajXgyOaVmCxedBjxNEbTuadlWYxGekZF0jMqkvRCG/OPJrElM4sP2nq+a1YkpzLvaBJWp5N3du3F5XYTZLEwpEYMO7KysRz/Hpx48DCBZjNNgovfL98ePEyStRCby8U1Vc889z7jSCJ7snMBN22rhJQ6vjQphXfaNMfHZGJfTi4zjxRXP28QFMDkw3GkFZauaL7oWDL9Y6KJ9vU5x79OsUsxhjkTLy8LN/btxY19e5Gcms7k6bN5cuQIXhjzEQF+vmRm5/DfR/5d4jkP3DmMt8Z/RbMGnoXv9w67kafeeI85S1ZgNplo27xJqfuYzWZuG9SXp98ovWvBH+s2MemX3/Dx9sLhdFI9umRBhK9/nMH4N16kU9uW2O12bvr3Ewzu7fk35+fry5UtmzFr0XIGXFtyPOLXeYu5smUzHrhz2Fn9LUr+Xby4cUBfbhzQl+SUVKb8MoO0vyQ///7nWgb2vY6nRz8AwJ0PPELGeVShHvPRpxxJPIq1sJDB/a4vccztdvPn2vXMnPwVALPmL2LKz8W7gfS/ridD7rqfWwaXzKNJTUtnxarVPDLyHiIjzv6zs6y4LSSieH42/egRgsOrMuQxT4GMWZ/8j6TY4gVPVw8dwayP3+DWF95l/oT3+eW9/2K2eBEa7ckxOVERGKDtdYOo3bwtp3OiIjBAo47di9rrtLiSFT98RUikJ9bYv3EVMz56jcK8XDoPuQODwcC23xdQo3ELxo58+bT38PKyMLRPT4b26UlyWjqTZ8ynxl/ef7FHEomJiuCTV58G4Ik3PmTnvuJiO5dDDGNwu0+xZKGSGGWoXfTfcRRgAmLw/ceu/6k7tsRj5+6yS58np2UwedZCbh94HeGhISWO/blpO4cTjzGw59X4+niX+fwTTI1KTjpfPWbpOff5ZKnbfydl02Ia3fbieSXelrffnyy9ra59zfS/fd3py1YzdcEKvn/1cczmi//vcDYsHQaVavNqXfYWUZcK26aJJR7nF5RekXU58isjQN6dlF3GmZeORlVLJiM+9PP5bT9fWYy7sUWpNmsZWyCfLx/ff+67U85OzrcvF/33wq378TKb6NbkzCvLzlbgnS+XePzXmOlkBTjZRx718ceXkt+RxygkFwe18cV8ms0kTo6ZYm79/Fy7XHbfjmyi4PBaQjvde84TPuUtYcr9pdru+L7sQYFzEbd+KbGr5tPlwf87rwGji9F3t5dOPr7cYhiAnmPL/m1xOVk8unRFyo7/t6gCelJ+Vr9Qequfeg+Uvfr8UrH/k5JJ4P/ke7+s95BceCfiivIYhwGwr5tZ+kTwLA6et5zhfa8hPKTk74PVW3cTezSZgd06nHYsxnLlDaXaom8ad26dLoM1YQsFcesJ6TDioo9hjv74UKm2vp+WXZnjXBzbvJyj6xbS8u6XL5kYZs6o0hVhL8cYptu7y8q/IxeZ5Y93L9XW/KnZ5d+RcrTt7X6l2mrdfeZK3pXZ4YmlKzH/E+P1UPYYuFx4F3I+qawYxpZRestmwDMx/ePPDL9lKOFhJZPVVq9dz+H4eG7oez2+pxmv8wotvXil5TOld+w4V1l7V5G5cxk1b3j6oo9hALa8WXLnvISMvFOcefbm/jaT6T/9wMdffo3ZfGnEMAAxoSUrBF6OMczMnWX/m7yc3NCk9GfHmOX7K6An5efJbvVKtV3q8WxZsepvu0ovJjgf/Rufefcb+eeVdwwzLbJ0UiBAlsvBH9YsrvYJJshY8jtyrz2fFKedK70D8TKcei7pluSdpdpGTN54bp0uw+F1Szi0ah5dH3qjUoxBfH1b6cXNa68/u+Tk01mWlML8o0m81qIJ5jMsiqks2s9bUuLxpR7DQOk4xnl4SwX15OJiqlVy0ZU96VAF9aR8WKqWzhu4HOM214GydyM9H8a67c98UiV38X8DnoOa/+DE07mKDAvlkRFll/Pv1LoZnVqf53Y8/4DwZlcT3uzvTY6mbF5StKWf0eJFjWvK3o7uYjaoe0cGdT9zld/Tmbbwd/bEJgDg423hqTtv/Ce6dklx5SXjzk4oemwMb4jB4leBPbqw1q5dw8IFxVuw3nPvvURF/b0KQpXJ1G8mkJrs2c4jPDKSYXfdU8E9ujhs+HUCTptnZWNoTG3qd+lzhmdUfm+++SZWqycxv1GjRgwbdu4r9S5nvVqUDmrLky8mWpyi0m8U3sDpFzJdSL7VW+Nb/fRVt8+k4PA67NmegX6DyUJgk+vP8IyLS81211Cz3d+bJI79cwFZR2MBMFm8aDZgxN/v2CXmcothALJid5C2q3jbmZjOA/EOOvuKKZVZ0tpZ2HM9q8EtAaFUbV/2NkOXo4yNv+B2erYrs4TEEFi/SwX36MJSDPP3VOQ4DEBklRAevq3sCmwdWzSiY4vTV7y+kHxiWuITU7oi2LkoiN+AI9szWWswmQlodPZb+l4Molp1I6pVtzOfeBqJ6xaRl3QY8IxH1e19xz/RtUvK5RjDZB/eSfru4kmAap1uwCuoSgX2qPykb56DPe94DOMfSpVWfc/wjMtH1taZxTFMcDX8r+h0hmdUfopj/p4KnU+KCOfhB0aWeaxj+3Z0bF968Wx5CW5wFcENSi98OReZO5djTfdU/DaaLUR2PLetsCtan/430Kd/6cVi52LGzz+yf99eALx9fHjokcfP8IzLz+UYw+zZsoGNfxQvKLn+5jsJjfh7O4NWFn/OmExOeioAgVXC6TSw8s0zXyhxSybjsnvmk/wiaxLZ+u8nAl7sFMP8PRUZwwQbzfTzK3v8uIHFjwaWcu7QX9S6ssdZV/k9lUN/zicrMRbwzKM0v+HcK6tXtO5VI+h+FlV+T2fB0SQO5+UD4GU0ctcVtc7wjMvL5RjDrN64lfnLVxY9Hjn8JqIiz6/qd2Xz+TeTOJacAkBUZAT33zX8DM+4fCyd9Bl2WyEAkTWvoFXP/hXcowuvMsQwl1QisFw4Ea0u/R8dZ+OWXqo2dSZG/0jwvzwGLgDat+9A+/YdznziJUqJv2VrO/jy+7s888wzFd0FkVPyrXVlBacpVbzanSpX4lBFuNxiGIDg2k0Jrt20ortRIZT4e2qhbYac+aRLiGIYuZj51jj9dmuXg2pXlq6iLiVdjjFMUK0mBNUqu0LVpU6Jv6cW3OLvJe1VRopj5GIV0uTvLQS6FAy88aaK7sJF73KMYRq2bEvDlpdnjK/E31Or2ePy+9sohpGLVZ1OvSu6CxeF66JV+ft0LscYpmObFnRsU3r34suBEn9P7ZrhZS9uvZRVhhjm0qgFLyIiIiIiIiIiIiIiIiIiIiIiIiIicplRIrCIiIiIiIiIiIiIiIiIiIiIiIiIiEglpERgERERERERERERERERERERERERERGRSkiJwCIiIiIiIiIiIiIiIiIiIiIiIiIiIpWQEoFFREREREREREREREREREREREREREQqISUCi4iIiIiIiIiIiIiIiIiIiIiIiIiIVEJKBBYREREREREREREREREREREREREREamElAgsIiIiIiIiIiIiIiIiIiIiIiIiIiJSCSkRWEREREREREREREREREREREREREREpBJSIrCIiIiIiIiIiIiIiIiIiIiIiIiIiEglpERgERERERERERERERERERERERERERGRSkiJwCIiIiIiIiIiIiIiIiIiIiIiIiIiIpWQEoFFREREREREREREREREREREREREREQqISUCi4iIiIiIiIiIiIiIiIiIiIiIiIiIVEJKBBYREREREREREREREREREREREREREamElAgsIiIiIiIiIiIiIiIiIiIiIiIiIiJSCZkrugMXwlay2Uce1xBGFbxIxMo6MgnFQj38qYZP0bmbySIbBxnYqY8/0XizjRwAErDy6Vnc757n/oeXxYzN7uDz157CZDIVHXtnwhSOHEumdkw0j4y4maVrNvLtr3NxOJ289eQDVIsMP+vXZU1LJH7JJBzWPBrf8TIJK34keeNCGgx7Fv+oOkXn2XLSiVvwDQAZe9bQ+rEJZB/axtFV0wlt1IFqnQef9T0vVu989yv74hJJycziyxf+Q5XgwBLHH3xrPAG+vrw1egQfTZvFtv2HMWDglVG3ERUWWkG9Ln/uwhycSVvAacNcpwfOxHXgtOPKT8EU3Q5jUIznPLcLZ9zvYDCD24mp5tW4c47gSt8PgLFKg6JzL2aHDh3i7bfeIjs7i0mTpxS1v/POGA7HHiYtLZUxY97B4XRyy8030759e3r07MGgQZX/38TpHNi7h+++HE9GWhodr+7GrSPuBWD5ogVMnzYJgKHD76Ra9Zp8Oe4D3G43derV577/PFqR3f5b0uMPsPaHT/EJDKZ68w7U69QLgINrlxC3aSW5aUm0G3o/UQ1a8N2D/ajRoiMRVzSmaa+hFdzz83fo0CHeeustsrKzmTJ5clH7jh07GPPOOwA8+cQTNG7cmNGjR1NgteLn68tHH31UUV2WU/huxSYm/7GFuc+N4JtlG9lwMIGMvAKevKErLWpFFZ337y9m4GU2YnO4GHfPAL5fsbnEuZ3P4l5HsXKAfAxAK4LIxsE+8nADGdgZRPH98nCwmWzcQD38iMSbpaRhxoALNy6XC6Px1GvMHLkp5O6Yi8teQJUuI8ndvZCCw2sI6fAvLCHF3zEuh42sdd9hsPhi8g0msGk/7JkJ5O6aB0BA4+tLnF8Z7Zw7iUMr59J55MuE1KhX4tj0xwcR3awDVWo1pH6PIexfNoNju9bjtFlpPuheqtRqWEG9Ll+lYphjm3HbcsFZiCmmIwYv/6Jz7Tt/whhYDYNvGMbwhritmbhSdwEGjOGNMPiEVNjrOBcFqYnELvgWhzWP5ne/VtR+cO5E8pMOY/YNpM71IyhITeTo2rm47DaqNLqS6PbXV2CvLzynrYBdEx4npsedhDbsCEDcvM9xFubjsOZyxaDHyEvcx5HFX+MbWYuw5tcQVKdlBff6/NnS40lfPw2TdyC+1VsQULdT0bHCtMMkznyZWrd/gtHiS8am6Tjz0jAHRhLSckDFdfpvOtV7HyA38QCbPn6UTv+dCm43uyb9D7N/EGZvP+oPfqiCeixlWU0GNlwkU0gHQgnBwirS8cZIMBZaE1x07iHyiaeAPJy0IZiqeAOwgjQs57Be/euZi/hu9hIWf/YGf2zawdT5K0hISWPEgGsZ2L1j0XnL1m/l29+W4HA6eXP0CPx9fXji/QnEJiaxcPzrZ7yPIzeVvN3zcdmthHa6h4K49dhS9uJ2OghqcwtGs6f/brfLE8OYLLhdToLbDSd35zycOccwePkR0LgPJt/gM9zt4rb129cxmiy4nHaa3/4MBmPx+NfBBZOwZiTjGx5NnZ7DiF85i6zYnVgzkml8y6P4R1SvwJ6Xn7MdhznBGb8KjGZMMe1xpe/HlbYXY2RzjME1KugVnJ/kjYvIPLAZl8NG/SGPYvL2BSA/OY74pVPADX6RNanR41Yy92/i2Lp5uF1Orug/Cu/gsx8brWxcNisHpz5DZOfbCKrbHoAjc973/NsxGonuMRJHbhrJq6fhKsyj5sDnKrjHf48jN5WMNd9i9A7AHBRFcIsbio7Z0uNInv8/qg19H6PFh+xtv+E4HscENe1Tgb3++5I3LSbrwCZcDjv1hjyCycu36FjsnM9x2gsxWbyp3fd+bNlpxC+dDG43K6/yonPns/nlLhfSUlIxYcCJm26EkYaNjWRhwUgMPjQkoOjcBKzsJRcXbjoSij9m3LiZRwo1/jLndCYrV6/hh19mYDIaefKR/xAdVRWApOQUXn1zDADzFy5m48plrFyzlvFfTOT6Xj154L67z+m1FWYeJXnVNFyF+dQa/Bwpa38lY+dSavZ7DJ+I2iXO3f3ZPQTUbo1v1bqEtepDxvbFpG+ZT0SHoQTVa39O970YPfbgKCxeFuw2O2PGflw0h5eTnc1jD40iJLQKAQEBvPT6m6z8fTk/TpmEw+HghVdeJyo6uoJ7Xz7+zlwS1kycyVsBMEW2wOBbOebgjsUf5sfPPyQvJ5tnPviyqH3hz5PZt30zqccSqd2gMbeMepSPX34SP/9AqkRW5eZRlXfe5GzZCvIZ//Bweo34D02u6lHUvmft70z/4GWenrwYl8vFgokfYM3LpXrDZrS7fkgF9vjvyTsWy+EFX2PxDyakXhsiWnYDIHX7H2TsXkthZjI1e91JUK0mrP3fcELrtyWgen2iO1besZhj8Yf54bMPyMvN5tkPJhS1p6ck8ePnY8Ht5uq+g2jUqh2fvPI0tsICvH38ePDltyuw13Kyk+d3/I+n/uTjZD2ZAMRTwE1UYyvZZGDHGyNtCS4691wtLchkRWEWL4XUKtE+Kz+NNJedCKOFfn5hzMlPJ85pxQDc4h9JiPHs75eTfISt0ydiz8+l+yNvs2PO9xxcOYcuo14l9KT5lA1Tx+IotGL29qHtsNHkZ6SwbeZXANTpeB2RDVud1+u8WLy6bRcWoxG7y8XzzRphMhgAyHU4eG3bboItZvzMJh5pVJ/vDh0mId/Kobw8ekdXZUiNyj2Pdi5OjmNcuUm4Mw8CBoxVW2Cw+BWde/J8EoArOwHnkT+xNKkceQK79h/ko4mTSc3IpMdV7Rl1x80AbN+zn7c+8XymP/3APTRrWI8GXftzbZeOtG7WiPtuqxyv73zt2rufcV9+RWpaBj2uvoqRI24H4GhSMm+PHY/b7ebmQf25qn07AB586nkC/Px56+XKOxaTFLuPhV9/hF9QCPXadKJFd8/4ytrZPxK/eytZKUeJvqIRXYaOYMFXHwKwZ81yHvtqNj7+gae79EVr+sLlzFm6kuzcPO6+aQDXXe2ZB9i1/xAff/cjJpOJkbcOJiw0mNGvvEt4aAjNG9Vj1G2VN1Y9V5dkReAWBFEL3xJtluODOf6YSrS3IpiuhOGPibr4E4oXXQmjCYFcgR9nY8IbzzL+lScJCvAjMTm1qH3Tzr2s2rQNH28voiPCAPh86gwmvPEsT993OxN/mn1Or8snrBr1b3qy6HFM15uo0uSqUud5BVah3o2PUrP3CILrtsLs40+Vxh2J6T7snO53MXvijsF89vyDdGvTjANHjpY49vOSVbRrXL/o8fKNO/j8+Ye4d1AvJs5YVN5drVAG70DMNbsUPTZVuxJTjaswWPwwBP5lAMtpx2C0YK7ZGYPRDE4b7pxjmKq1xxTTAXf2kQro/bmrU6cO4z8tnb7/xBNP8tG4cQwbdivLV6wAICDAn/yCfGpUr1yTa+ejboOGvPz2B7z/xTdsWremqH3tyhU8/cobPPt/b7F88ULq1KvP6x98zBsffsLWTesrsMd/3+FNf9Ciz610v/8F9iyfVdR+RfsedB/5Ih2GPUjiro0AWHz8cNgKCQiLOtXlKoU6derwaRnv/48//pgP3n+fDz/4gPHjx2M0Ghk3bhwTvvyS3Lw8XC5XBfRWTuVQcgZpOfmEB3pikLu6t2Hs3QN44oarmbt5T4lzx983kA//NYBAXy+OZuSc9txT2UYOZgyYMeCDiWh86EoYNfGlAf4lzt1KNhYMGAB/zNhx44WBboRhxkBmZuZp72UOiCCkw51FjwMa9cK7WulkPUf2UcyBUYS0uw1nQRbOvHTy9i4huO2tBLe9jbx9S8/qtV3MmvQZTvU2Xcs8Zvb2w2krxC/s+ETg7o1cdd9LNOl7B0m7NpRnNyvUyTGM25qJuWYXjCF1cOenljzZaMbtcsDx5GBn8nYweoHBCOaSvwkuZr7h1Wh82zOl2g1GEwaTBaPJjNk3gJC6LWh869M0vfNFUrf9UQE9LV9Hf59GlWbdSrTVvP5+6gx8hIAajck7egAAo5cvLocNr6DKnUyUH7eJ4GZ9ieg2kpw9y4ra3U4HObsW4VezDQCFKQexHtuNweSFya9yTLKeyqne+y6ng8Q/fyOscQcArBnJBFSvT+NhT1GYmVLe3ZQz6Ejo8bEVMzH4kI6NOvjRnXBSsZU4tw5+dCWMKwnhKFYADpJHJF5nfb+DCcdIzcwmPDQIgC6tmzLumX8z8aVHWLx2c4lzP/9lHl/+dzRPjRjKVzMXERzgzxcvji61oPhUzAHhBLcbXvTYmrCF4La34VO9DYUJW4ra3XYrBrMPwW1vw2Dywm0vwGA0gtGMwWDCaKk830mn0uLO52k2/CnMPv5YM4u/j7Pi95JxcBtGL2+8j38O1+g8gGbDn6Z6lxvIjttbUV0ud2c9DgO4MmMx+BV/bxmr1MNYpT6VUer2P2hw0xNEtLyG1O2/F7X7Rdak4S1P03DY02TH7QLg6J8zaXjL09TsMZxja+dUVJfLRcranwhu2KVEm9HsBQYweQdgMJnwComi+vUPV1AP/1n2jHj8arcnrMv92NNii9rdLge5e5fhG+P5/WdLi6Uwea8njvENqZjO/oPStv9O/aFPENGiO2nbit//1owkXE4ndQf+B7fLRWFmMkeW/4DJ2w8MRqpXvzwWSFzsriGcroThhZF8nCRhowVBdCeMIxSUOHcnOXQnjNYEs5tcALaTQ03O7Tv+o/Ff4O/nh7+/H1VCQ4raq0ZG8PF7b/PSs0/R7erOBAUF0qdXTx4f/eB5vTbvkGhq9H2k6HFE+8EE1etQ5rlGiy9uhw1LYAQAoc16Etqi13nd92L03sef8tb7HxEQGEjS0eL5pMSEIzRr0ZIxH47jaGICAN9/NYH3xn3KQ488ztTvv6moLpe7vzOX5EzZiSmmI6bqnXCl7qyA3p+fqBq1+M9r75Vq73XjbTzw0ttUq3UFPQbdQvzBfcTUrsuo/75JekoyKUcTKqC35WvplM9peU3JhToFOdkc3LyGavUaA7Bz5SKyUo5hMpsJjqjccysZu9cS02UI9W98lKQNC4raw5t1of7Qx6jd5x6yDh5PdvfywWkvxDs4sqK6+4+IqlGL0f/3fqn2Xyd+gq9/AAajkfCq0RiNRh56ZQyPvTkOa77mky42J8/vnOCHqWjcpRo+eGHECJgwYMSA13mmCCU5beS4nQQaSubbHLJb2WPPx4KR0OMJv7vseYwKrEZPn1CWFGSe030CI6vT+f7/Fj1u2vd2arTpVuq83NSjuBwOOtz1FG6Xi7y0Y+yY/R0WX38MBgN+Vaqe+4u8yPy3eWOebdoQf7OZVGthUXuytZCGQQE816wRycfb76hTi2eaNiTC25teUZX7M+pcnRzHuFJ2gNEMRguYvEuefNJ8kttRiDv3KAbfKuXZ5b+lcb0r+OSNF5j68dus2rC5qP2jrybx0avPMu615/j4a0/RvAA/PwqsVqpHV+7v6rPRuEE9Pn77daZ8MY5V64rnU9//5AsCAvwxGo3EHF/k9/OsObRr1aKiuvqP2b1mBZ2H3MGQx15lw4LpRe3t+93EjY+/Rnj1OrS9fgiBVcK58fHX6H33I9Rt3bHSJgEDDOrVjc/feI7xrz3ND7OL8//e/XISwYEBWMxmoiLC+GP9Fvr36MLHrz7F4pVrsdsdFdjr8nVJJgKfLBpv+lKVDoQWrX76qzwcmDHg/Zc/x25yafSX1d5nsvvgYQptdmpEFwcUew/F0+iKWrz5xL+Zs/xPCqyFuAGj0UitmCgSkpL/zss6o+T184lse90FvUdFsdntjB7zGUvXb6V+zeLVTElpmWzec5Br2hV/aN87sBf/efszZv2+joSU1LIud1lx5aVg8A3DYPjLP3+TF263C8fBhbjdLgxmb4yhdXDGLsV5aAnGsMo5EfVXubm5/PzLzwwYMICaNWuyaPESxo79iDfffLOiu1Yulsyfw6jhN9G1Z/FnQt9BN/LIfXfxn38N58Zbby9qnz39Jzp361HWZSqNht36s2/lPFZ++x7WnKwSxzbN/IY/vn6HWq08VVduGTONHg+8wtY5kyqiqxdcVnY2ISEhBAcHk5PrmaTYtWsX9953H8HBwaet4Crly+Vy89G8VTzQu2OJdofTxacL1jK8S6tSz9mbmIrN4aR6WPAZzy1LGjbaE0IU3uwjr6h9P3nUOykROB07DQigHcFsJAuv44us5pKMC6hS5Z/5kWwJrYHbZSdr0w+4CrJwFmTishdg9PLD6OWL2279R+5zser3f9/T8b4X2T1/KgC1O17Hwv+NYsOk96nV/toK7l3FMQZE49g/F1fqHgyB1UocMzcciKlmF1wpnskmd34axqrNMVap7xnwqeRq97qDpne8QGjDdiT++VtR++HFU4ju0LcCe3bhZe3fgG9ELSz+IaWO2XLSyUvYS2DNJgTWak6jO9+g5nX3cWTJt+Xf0X9QQINu5O5fSeqqb3AV5hS1Z26ZSXDzfhwv+oAtMxGv0OqEdbqD/LgNuByFp7hi5RW3ZCrVuw3lxIv2DatGTtxuNn/6JH5Rtc7wbKkIyRQSjhdGDFTFmz3kMotj1CgjOWYL2awinRr4ko+TVGzEnGUSjcvl4oNJ0xl9a8nqS9/+tphbnn6TIT1KLph2u4+Pw0RFkJCcdv4v8DjD8fekyb8Kzr9MZhksPuBykPHHeHA5MXr549/oOkLa34lX1UbkH1r1t+99Mcg9dhiXw4bvXybU8o7FERBVi0aDHyBl+yqcNs9n0p7p44lb9gshVzSrqO5eFMoah3HbC3AXpGEIuLSqDPqEVi1zsUbypiWENvBUXHG73RiMRrxDq1KYdeku7MiN3YR3WA3MJ8Ux0b3+TUzv0VgCqpBzYF3FdO4C8YqoR+7eZSTNfR2f6sWLPrO3zyawSW84HsfYs45iCa5G6JW3UnBkEy6H7RRXrBxOfC943tPFY8+27FS8QyKOH4ukMCuF/KRYItv0olavu3jttdfKvJ6UvwzsOHETgJma+LCaDGaRVKIa8AkGDARgJg8n6dhwA6FYzul+W3fs5NUXnqFTh/ZM+fGXUse/nTKN24fdfL4v57zU/9dYqvd5mNQNM8r1vuVp/9492GyFVPtLEn7N2nXYsmkjt980mPoNGwGe7ymj0Uj1GjWLkoMvV2c7l4TLhsHs7VkM57w0JththVaSE+KoXqceVzRujt1mY8JbL5Gecoz05GMV3b0Lau/6P6haqx4BIWEl2hd//wndht1b9Dgl7hC1mrZmwIPPsXrG5JMvU6lEtu1F8uYlHJz1KY78kvNJR5b9wIEZH1Olkac6eptHv6DhLU+R8MfPFdHVCy7uwF56DLyJ2x58gqmfehKF4/bv4f1n/4N/UJDmky4yp5rfOWEPuUUFX1oTTA/CqY5P0YKmc+Fyu5mdn07fMpIljzoLiTF5Mzwgko22XGxuFz18QpmQc5QNthzSXfZzf3FnIT8jBf/jRZ78w6LIS08mM+Egdbv0o+WNI9k6/YsLct/yFpubh93loqpv8Q4U1Xx92JmVwyMbtlAnoHguL8VaiLfJSKDl3OLTS427IB1jdFsM/pG4Mw6UOHbyfJIraSvGyOYV0c2/ZdbCZQz413/oc01xAnRWTi4hwUEEBwWSk+f5TFg/ZypfjnmFj76q3N/VZ2vW/EUMHH4P1/fsXtS2c+8+br9pCC8+8TBvvP8RSSkpbN6+k2u6VP4detpeN4jNS2bz2/g3yc/OLHHMXlhIxtEjRNa8oqht/byfadv70tgt/fWPv+KB24urXG/csZunRt7Jv4YO4MOvp9K3+1Vs2rGHJ974kMzsHNIys05ztUvLJRWt7SWXlaSTR8kfmobjo4zeGHGW8TxPEFQ8qGPHRR4Ogs8wgPPd9Hk89sZYlq/dzHsTp/LBcyWrN8RERRAa5Mmk9/P1ptBmw2gw4HK5iEtMIqbqhVuJ43a7yTqwmeC6rS/YPSrCd3OW8vj7E0jJyGbskyMZ3ucaZq4ornC6YtMOUjKyeH3iNJZt2MbeuASuv6otHz01ku5tm9OwliotuNL3lqow4y5Iw+AVgPmKXhi8AnHnp+FM2oqpXh9M9frgTNpWQb39Z2RnZ/Pww6N5/fXXCQwMLBqg9/M7u6rfl4Ievfvy+ZSfmfXzD0Vtn499j29/ncN30+fyxUeeH/Szp/9EYnw8w+66p6K6+o/wCw6j233P0Wn4w/gEhpQ41vqGu+j9+Nts/s2TKGQwGjGaTJgs3rgvwdXMwUFBZGVlkZ2dTWCA57uucePGfPnFF7hdLg7HxVVwDwVg8h9buOWDKRw4ls6L0xayLT6J+Vv2YXc4eeyb2TzQu0NRsu8JO48kM3buKt6+3VOd4XTnnuxEzBSIGePxxVB2PO//HBx4YSy1KjwAM94YMWPEgZtUbARipg+RBGJm8+bN/8jfwmAwEtRiEMGtb8bg5YcpIByjxReXrQCXvcCTZFNJHfxjNuu/f5f89FMvBjMYjRiNxZ9Je5f8TO8Xv6Tr6LfYOee7cuztxcWVHY+5Xh+M0W1wpZWsKmgwGDyTUgaTJ7HEO8Cz2tvsDRdokLE8GY4PsHsFhuIs9FSkils6Da+gKoQ3K707yKUk+9AWco/sInXrEpLXzyn6nrZlpxI3/3Nq9/+Pp2Ly8b+RyScAl6Ny/z83+wUT0fU+wjrejtEnqKi9MPUQWdvmYE3eT/aOhZgDwjB6e77XjWbvS2ay9a9yE/ZxZMXPZB/eReLKmaTt/JOIlt1oNWoMtqw07HnZFd1FoeQ4zK6/LKjeQy5tCWEAUcSdVE0PoCVB9CKCrWRzFCsFuNhAJolY2bv31NVjv5u9hCGPv86+uESe/egbtu2LZe5Kz24md/bvyeyPXuajqb+VeI7ReHwc5lgqMZFhZV32vDjz00tUsnRkHMHkV4XQLv/G5B+GPfNIUdKE0TsAdyVO2E9YPZedP3xA2t5NHFo4mSY3l9wO2Sc0Aouf5zPL5OVTlNTXcNC/aTBoJEdW/lbqmpeTMsdhco/htltxJm3BlXsMt7VyDkYnrZ/PgRnjcBR4JpKtGUlFiY8nJG9aQmFGEtWuugHwxDae6qhJeAdHlLrmpSIvfhsFR/eQuXM5GVvn43Z74pgTnwsmv2BcttKfj5VZ3r4VBLe+kap9nqcgflNRuz3tMLm7FlCYcoDcPYsx+VfB6O2ZrDaavMFZOeO3pA0LODiz+P1fmJmMd3BxlW+voHBsx5PdCzNT8A6OwDs4ArNfIEZvX6zWS3uR68XuRAyTiJWtZNMZT1LLVnK4lggGEsWuk5JkDIAbN7k48MdEAlaycbCdHA6RT2rq6YuQfD/1Bx5/9kVq1aiB2Wwm9C+L9k9wu90s/30l3a8u30lpg8GIwWjCaPYq+ry6FPw0dTIvPfsUf678nU/HjeXVN98pcXzxgnn0HTCQ73/8laRjR8nISMdoNOJyuUg4Ek90tctnS+2ynO1cEkYv3E4bbqcNg+n8tpq/2Kxa8Bsdr/UsvjYajdz+8DPc8/QrBASFULX6pb0w9eDmtcTt3MymxbNYO/sHXC4XtoJ80hLiWPTNOBIP7GbjghkER0ThG+gZgzaYTGe46sXNKzCU+kMeoU6/+7D4lxxXr979Zhrf8RJHlv8IeGLZos/LS3A+KaxqNAFBwfj4+WMv9PyGrVmvIY/+7yNcLhfJCfEV3EOB08/vnODGTSJWquGZTzmRL+OLCTvuc7rfCmsmY7KPcNRpY1JeEnFOK5sKi2OYKiYL/kbP54C3wYjd7aa1dwD3BEbTxOJPtZMrsv5D/EIjyEtPAiAvLQn/KpH4V4nEyz8Ii7cvTnvlXXA4J+EY7+3ax8b0DCbFxvN445LfxytT0uhRNYIP2rYkpbCQLJvnN9WshKP0r3ZpLTg+HwafEM9vb7MX7pPmiErMJzntuG3ZuI5txl2Qjiv9wCmuePEZ0Ks7s7/5mMnTi3daCg4MICs7h+ycXAL9j//mNhoxmUz4eHtdFlXdB/S+lllTvmLqz8ULHGOiowgNDiLA3w9rYSErVq0lJTWN198by7JVq9l74GAF9vjvCQgNY/AjL9P3/ifxDy65c+S25fNo1rW4SKDb7ebApjXUbd3x5MtUKm63m2feHsf13TrRplmjovY6NWLw9/UhNDiQnNx8fH18eO+FR3nnuYfx9/MlMqxy76x5Li6NX2THNSCABngmnA5TQAZ22hBMFg6OUEAhLprhScxdQio9CMeNm6MU0oaQouscIJ8rTqqCV5Y7Bl3P8Buuo2a3IVzftSOPvPEhz426k9Wbd+DtZaH/NZ2ZNnsRj785jqrhYYQEBXLvzQO4/8W3sdsd/O+JUef0+ux5WRyeN5G8hH3EL5mMV1AYGbtWU5AcR42et+O0FZCXsJ/oqwaSdWAzQXWaFyU8Zh/eQeKKH3EU5OIVFEZ487K3o77Y3dH3Gu7oew3PjvuWAmshGTm5vD36X6zetpvNew4xamgfbrq2M7GJyYz/aQ4Nasbw/dxlrNm2h0K7nfcfu/fMN7mEuB1WXEc34i5Ix5m0FWN4Y3BYMXh7/h248pJxF6R5KuYlb8cZ/ydupxUimmAMqYUzfiUAxqDKMeCVlpbGKy+/zJYtWxgzZgy7d+9iwoSJjLz/Pux2B2+/9TZDbrwRi8XM5EmTyS/I5+Zbyre6QkVYu/J3Fs6Zhc1WSNee1/HUQ/fz9rjP6dXvBl587D8AdLnmWnZu28KYV16ke6/evPnSczzzyhsV3PPzl52cwIZfJmC3FtB64F0sHPscvUa/wc5Fv5B6eA+2vFyaXHsjGQmxbJw+EYCYpu2KEokqo7S0NF7+y/t/1+7dTJwwgQcffJDHHn8cgMcefZTExETGvPMObpcLk9lMDW1FeVG4rUtLbutSXDEpMT2b3i3r8+zk+exPSmPCkvV0a1KHwe2bct9nv/LZfYMY+PZ39GpRj6e+n8uTN3Rl3Lw/S5x7552nvt+JmOkAefxOGnbcdMITAO8ml4Z/iYNOxEwtCGQ1GQA0JYAQLGwhm99Jw4qL+vVPXz3eVZhL9tYZ2DPiyNk5F5NvCIWJW3FkHyWwaT/cDiv2jHj863cnc/1kcDnxqlILk08Q/g16kLXRUyE3oFHl3e3gii79uKJLPw78/hsJm/8gO/EQzQbeg8OaT/rhPUQ1vZKdxxcpVG3cBoPRSNVGbVg94f+wF+RRr9ugin0B5ejkGMbgE4IzfhVuhxVTVKviGCagGs5kz4IlQ0AUBoMBY0RTnPGrwO3CVLXlGe508bDnZXHgty/IObKP2IXfk3cslqZ3vEDsgu8ozEzGlpdFgyGjSdn2BwkrZxBavw2FGUnUvu40/9gruRq97gYgZeN8zP7BHPjlbeoNfYY9k/6Lb1gM8Qu/JPLKARSmJ5K1fwMOay5RHQdWcK//Hnt2Mhkbf8btKCSk1UCSFn9I1Z4PE3Wd57s8eclHBDXthcHsQ+6+P0hd+RUm3xBM3mf+/XqxOtV7v9mIVwDYOekNqnW+AWdhAXt/+oDs2J24nA7MfpV3+6pLyYmYwoYLK04Cjw8z1cCX9WSxn7yithMxxS5ySMOODReNCSAaH+riT87xRJoGDRqc8n539OvBHf2Kdy85kpxKn87t+HXpnyxfv418ayG39fFsFznipff5+pVHuXdQb0a+Pg67w8kbD3k+Mx/83yds2XOIpz/8ive+v+G0r9FVmEfOjlk4Mo+Qu3sB3tVakLVxGm6njaDWN2NLO4QjMx7fWh3J27fYc8yWh1/97uTumu/Z3aAwl6BWQ097n4tZTMc+VGvfm6XPDiK8aUd2/vA+dfuMIPPgdoxmC5EtunB03SJ2/TQW76AqWPwCObhgEtaMJOz5OdTtM6KiX0K5OdtxGFN4Y4yhdXAX5uBK3YXBJxhXVjyujP1gMIHRjDHw4p+8q9quN1Xb9SZ54yL2/fw+Lnsh9QY/THbsDnIT9hFUuykHfxtPWONOHJj5MXVveJCoDv3Z++MY3E4ndfrdX9Ev4YKperXn8yZj+yJMvkEcmfM+Nfo9ztGlX+J22HBac4npPRpHQTZJv39LQdJBUlb/QETHyjtO5VO9BVmbfib/4CrMARGkrviE8K4PEH7NaABcv39KQMOeGMze5B9cRcba7zH6BRclBVc2VdteB22vI3nTYvb/8j4uu426g0eTfXhH0Ri9wWTm4KxPMJoteIdEEtN1KLGzPwcDvP3BixX9Ei5rDQigPm6+J4Ea+LCSdNoQTB18WUMGFoxE4AUUxzCNCWA5abiADoTgfzzGScRKOjbCw8NPc0e4fdjN3D7sZn76dSYPPf40+fn5vPXaS6xeu57N27Yz6p4RLP9jFV06dSia11m9dj0ffvIZmZmZRFeNZPAN/c/6NToKsjm24lsKkg+Q/OcPmAOqkHNgLYVp8UReNQyXrYCCpAME1GpFypqfAPCv0RyDwUj2/rVkbF+M0eyN0cuHgJqVc9vcocNuY8jNw2jXtD7X9LyO/z7zBKMff5qN69bg5e1N+45X8cJTj7Fx/VocdgchIaEMv+tfPDn6QewOO8+9dPlU7v47c0mmiCY4j6wGwFSJKuplZ6bz/Ydvcmj3dn76YizxB/by6JvjAFg5/zeeeGd80bmfvvoMDoedek1bEhJ2+n/rld319z4GwPq5P+MXHMoP/3uKYc+/w13/9wkAWSnHaHPdQGzWAmaMfZVDW9dzRYsrK7LLf5s1/Rhxi7/HabNSvfswdk9+g0a3PcfRNbPJSzyAw5pLdIf+5CfHEb/Us9V6cN1WlXo+KTszne8+eJODu7bz4+djiTuwl8ffGsegu0by1buvYcBAn2F3kZZ8jJ8+H4vL7cJkMhMeXTnmiy91p5rfOUYhadhoSiCJFBKFT1EC8EayyMOBFRdXcW7JUF19QujqE1L0OC3rCK29A1hdmI0ZA229Alhlzebb3CRCjGb8jSZWWLPYZ8/HjpsRAVHndD9rTiabfviEtMO72TZjIr6hERzZ9DtZCYdoMege7IUFpMfuplGvmzGazKz7/j2MZgv+YVE06XM7G6Z8CAYDDXtW3nGYvjFRXF+tKv2XraJTRBXe3bWPf9WtxfbMbCxGI61Cgxmzax/bs7JwuNwEWcy43W62ZGRxd93aFd39clcqjgmt65lPcjkwxbQ/9XySyYK5Tk/PNQ7lYaxStyJfxllb9uc6ps9fQmGhjT7XdOGuR5/nm/df5z//Gs7DL78FwBMjR7DnQCxjPv0KgG4d213yVd2Xr1zN9DnzKbTZuL5nd0Y89Bhfj3uPh0few7OvvYXBACPvGs5V7dtx08B+xMYdYfzEb2lQ94ozX/wilX70CEsmfYrNmk+3W+5l6utPMOx5z+LHrcvnMvy/HxSde2DzGuq0aFf0W7OyGvftDyxeuZasnFz2Hz7Cqg1b+PbdV3h4xDBGvfAmNrud5x+8m7z8Aka/+g5Op4s7h/S75N//f2Vwu93ntuTnIjPKUPuCXv9Td2yJx87dv1/Q+5kaXV3i8dVjll7Q+12Mfn/ymlJt9jXTy78jlYClw6BSbV6t7y7/jpQj26aJJR7nF6h6BoCfb+kKmbuTLu0qaY2qBpV4/NDPWyuoJ+Vj3I2lB9ytBf9c9SAf37Pbiln+OTnfvnxBrx94Z8nrl3fMFHPr5xf0fhejhCmlExnu+H59BfTk4vfd7e1KtV1uMQxAz7EX9rdFZbB49NWl2jr+36IK6En5Wf3CtaXa6j1QekvgS8n+T4aUePxPvvfLeg/JhXch44qTYwoA+7qZF+x+litLJwJH3zTugt3vYnT0x4dKtfX9dFUF9OTiN2dU6Wr8l2MM0+3dZeXfkYvM8se7l2pr/tTs8u9IOdr2dr9SbbXuvrS3Fz088bZSbf/UeH1ZY+By4ZV3DGPLOHbB7ucVWjqppuUzc8o489K25c2+JR4nZJTeGl08YkJLLry4HGOYmTsv3L/JyuKGJqU/O8Ys318BPSk/T3arV6rtUo9ny4pVf9uV9I9cu3/jqv/IdeTclHcMMy2yyQW73y3JO0u1jZi88YLd72L19W1tSrWtvb5HGWdK+3lLSjy+1GMYKB3HOA9vqaCeXFxMtUoW/7EnHaqgnpQPS9U6pdoux7jNdWDtP3Z9Y932/9i1LlaXT8qziIiIiIiIiIiIiIiIiIiIiIiIiIjIJUSJwCIiIiIiIiIiIiIiIiIiIiIiIiIiIpWQEoFFREREREREREREREREREREREREREQqISUCi4iIiIiIiIiIiIiIiIiIiIiIiIiIVEJKBBYREREREREREREREREREREREREREamElAgsIiIiIiIiIiIiIiIiIiIiIiIiIiJSCSkRWEREREREREREREREREREREREREREpBJSIrCIiIiIiIiIiIiIiIiIiIiIiIiIiEglpERgERERERERERERERERERERERERERGRSsjgdrvdFd0JEREREREREREREREREREREREREREROTeqCCwiIiIiIiIiIiIiIiIiIiIiIiIiIlIJKRFYRERERERERERERERERERERERERESkElIisIiIiIiIiIiIiIiIiIiIiIiIiIiISCWkRGAREREREREREREREREREREREREREZFKSInAIiIiIiIiIiIiIiIiIiIiIiIiIiIilZASgUVERERERERERERERERERERERERERCohJQKLiIiIiIiIiIiIiIiIiIiIiIiIiIhUQkoEFhERERERERERERERERERERERERERqYSUCCwiIiIiIiIiIiIiIiIiIiIiIiIiIlIJKRFYRERERERERERERERERERERERERESkElIisIiIiIiIiIiIiIiIiIiIiIiIiIiISCWkRGAREREREREREREREREREREREREREZFKSInAIiIiIiIiIiIiIiIiIiIiIiIiIiIilZASgUVERERERERERERERERERERERERERCohJQKLiIiIiIiIiIiIiIiIiIiIiIiIiIhUQv8P99UFDO33Hb4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "head: layer_2.head_1, score: c = 0.39200124, v.shape = (10, 233, 233)\n", + "\u001b[30m\u001b[48;2;200;220;239m<-->\u001b[0m \u001b[30m\u001b[48;2;203;222;240m(4,2)\u001b[0m \u001b[30m\u001b[48;2;171;207;229m;\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(5,4)\u001b[0m \u001b[30m\u001b[48;2;180;211;232m<-->\u001b[0m \u001b[30m\u001b[48;2;213;229;244m(5,5)\u001b[0m \u001b[30m\u001b[48;2;170;207;229m;\u001b[0m \u001b[30m\u001b[48;2;25;103;173m\u001b[0m \u001b[30m\u001b[48;2;115;178;215m\u001b[0m \u001b[30m\u001b[48;2;133;188;219m(3,4)\u001b[0m \u001b[30m\u001b[48;2;15;91;163m\u001b[0m \u001b[30m\u001b[48;2;117;179;216m\u001b[0m \u001b[30m\u001b[48;2;154;199;224m(4,1)\u001b[0m \u001b[30m\u001b[48;2;8;80;154m\u001b[0m \u001b[30m\u001b[48;2;51;131;190m\u001b[0m \u001b[30m\u001b[48;2;55;135;192m(3,4)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,3)\u001b[0m \u001b[30m\u001b[48;2;48;128;189m(4,3)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(4,2)\u001b[0m \u001b[30m\u001b[48;2;41;121;185m(4,1)\u001b[0m\n", + "0.9 0.6 -2.5 1.8 -0.1 8.5 4.2 3.6 9.1 4.1 2.9 9.7 6.9 6.8 11.4 7.1 11.5 7.5 \n", + "\u001b[30m\u001b[48;2;33;113;181m(5,5)\u001b[0m \u001b[30m\u001b[48;2;204;223;241m(4,5)\u001b[0m \u001b[30m\u001b[48;2;44;124;187m(4,4)\u001b[0m \u001b[30m\u001b[48;2;221;234;246m(4,3)\u001b[0m \u001b[30m\u001b[48;2;24;102;172m(3,3)\u001b[0m \u001b[30m\u001b[48;2;182;212;233m(2,3)\u001b[0m \u001b[30m\u001b[48;2;27;106;175m(2,4)\u001b[0m \u001b[30m\u001b[48;2;224;236;247m(3,4)\u001b[0m \u001b[30m\u001b[48;2;8;79;153m(3,5)\u001b[0m \u001b[30m\u001b[48;2;131;187;219m(2,5)\u001b[0m \u001b[30m\u001b[48;2;8;72;143m(1,5)\u001b[0m \u001b[30m\u001b[48;2;236;244;251m(0,5)\u001b[0m \u001b[30m\u001b[48;2;32;112;180m(0,6)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(0,7)\u001b[0m \u001b[30m\u001b[48;2;33;113;181m(1,7)\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(1,6)\u001b[0m \u001b[30m\u001b[48;2;8;50;110m(2,6)\u001b[0m \u001b[30m\u001b[48;2;191;216;236m(2,7)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,7)\u001b[0m \u001b[30m\u001b[48;2;144;194;222m(3,6)\u001b[0m\n", + "9.7 6.6 9.5 6.1 10.0 7.1 9.9 6.0 10.5 7.9 10.6 5.7 9.7 5.4 9.7 7.4 11.1 6.9 11.2 7.7 \n", + "\u001b[30m\u001b[48;2;247;251;255m(2,0)\u001b[0m \u001b[30m\u001b[48;2;119;180;216m;\u001b[0m \u001b[30m\u001b[48;2;192;216;237m(1,6)\u001b[0m \u001b[30m\u001b[48;2;182;212;233m<-->\u001b[0m \u001b[30m\u001b[48;2;210;227;243m(1,7)\u001b[0m \u001b[30m\u001b[48;2;119;180;216m;\u001b[0m \u001b[30m\u001b[48;2;21;98;169m\u001b[0m \u001b[30m\u001b[48;2;88;161;206m\u001b[0m \u001b[30m\u001b[48;2;34;114;181m(0,7)\u001b[0m \u001b[30m\u001b[48;2;8;73;145m\u001b[0m \u001b[30m\u001b[48;2;85;159;205m\u001b[0m \u001b[30m\u001b[48;2;122;182;217m(4,6)\u001b[0m \u001b[30m\u001b[48;2;8;65;133m\u001b[0m \u001b[30m\u001b[48;2;15;91;163m\u001b[0m \u001b[30m\u001b[48;2;8;62;128m(0,7)\u001b[0m \u001b[30m\u001b[48;2;37;117;183m(1,7)\u001b[0m \u001b[30m\u001b[48;2;8;57;120m(1,6)\u001b[0m \u001b[30m\u001b[48;2;26;105;174m(2,6)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(3,6)\u001b[0m \u001b[30m\u001b[48;2;19;96;167m(4,6)\u001b[0m\n", + "-5.0 -0.5 0.0 -1.9 8.5 4.3 7.5 10.2 4.5 2.8 10.6 9.0 10.9 7.3 11.2 8.1 11.8 8.7 \n", + "\u001b[30m\u001b[48;2;20;97;168m(2,7)\u001b[0m \u001b[30m\u001b[48;2;200;220;239m(2,6)\u001b[0m \u001b[30m\u001b[48;2;8;69;139m(2,5)\u001b[0m \u001b[30m\u001b[48;2;180;211;232m(3,5)\u001b[0m \u001b[30m\u001b[48;2;8;67;136m(4,5)\u001b[0m \u001b[30m\u001b[48;2;210;227;243m(4,6)\u001b[0m \u001b[30m\u001b[48;2;65;145;197m(5,6)\u001b[0m \u001b[30m\u001b[48;2;247;251;255m(5,5)\u001b[0m \u001b[30m\u001b[48;2;51;131;190m(6,5)\u001b[0m \u001b[30m\u001b[48;2;238;245;252m(7,5)\u001b[0m \u001b[30m\u001b[48;2;31;111;179m(7,4)\u001b[0m \u001b[30m\u001b[48;2;222;235;247m(7,3)\u001b[0m \u001b[30m\u001b[48;2;8;80;154m(7,2)\u001b[0m \u001b[30m\u001b[48;2;196;218;238m(6,2)\u001b[0m \u001b[30m\u001b[48;2;8;68;137m(5,2)\u001b[0m \u001b[30m\u001b[48;2;213;229;244m(5,1)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(5,0)\u001b[0m \u001b[30m\u001b[48;2;191;216;236m(4,0)\u001b[0m \u001b[30m\u001b[48;2;8;67;136m(3,0)\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(3,1)\u001b[0m\n", + "12.0 8.2 12.6 8.6 12.7 7.9 10.8 6.6 11.1 6.9 11.6 7.4 12.4 8.3 12.7 7.7 13.2 8.4 12.7 8.9 \n", + "\u001b[30m\u001b[48;2;247;251;255m;\u001b[0m \u001b[30m\u001b[48;2;72;150;200m\u001b[0m \u001b[30m\u001b[48;2;204;223;241m\u001b[0m \u001b[30m\u001b[48;2;219;233;246m(2,3)\u001b[0m \u001b[30m\u001b[48;2;44;124;187m\u001b[0m \u001b[30m\u001b[48;2;206;224;241m\u001b[0m \u001b[30m\u001b[48;2;215;230;244m(6,1)\u001b[0m \u001b[30m\u001b[48;2;18;94;166m\u001b[0m \u001b[30m\u001b[48;2;123;183;217m\u001b[0m \u001b[30m\u001b[48;2;109;175;214m(2,3)\u001b[0m \u001b[30m\u001b[48;2;8;81;156m(2,4)\u001b[0m \u001b[30m\u001b[48;2;62;142;196m(2,5)\u001b[0m \u001b[30m\u001b[48;2;10;84;158m(3,5)\u001b[0m \u001b[30m\u001b[48;2;112;177;215m(3,4)\u001b[0m \u001b[30m\u001b[48;2;15;91;163m(3,3)\u001b[0m \u001b[30m\u001b[48;2;166;205;227m(4,3)\u001b[0m \u001b[30m\u001b[48;2;26;104;174m(4,2)\u001b[0m \u001b[30m\u001b[48;2;105;172;213m(5,2)\u001b[0m \u001b[30m\u001b[48;2;8;48;107m(5,1)\u001b[0m \u001b[30m\u001b[48;2;38;118;183m(6,1)\u001b[0m\n", + " 7.7 4.3 3.6 8.6 4.2 3.8 9.7 6.5 6.8 10.1 8.0 10.0 6.7 9.8 5.5 9.3 6.9 11.3 8.8 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# let's try to plot the values of the attention heads for the top and bottom n contributing heads\n", + "# (layer, head, value)\n", + "top_heads: int = 5\n", + "important_heads: list[tuple[int, int, float]] = sorted(\n", + " [\n", + " (i, j, DLA_DATA[\"heads\"][i, j])\n", + " for i in range(DLA_DATA[\"heads\"].shape[0])\n", + " for j in range(DLA_DATA[\"heads\"].shape[1])\n", + "\t],\n", + " key=lambda x: abs(x[2]),\n", + " reverse=True,\n", + ")[:top_heads]\n", + "print(f\"{important_heads = }\")\n", + "\n", + "# plot the attention heads\n", + "print(f\"{CACHE.keys() = }\")\n", + "important_heads_scores = {\n", + " f\"layer_{i}.head_{j}\": (\n", + " c,\n", + " CACHE[f'blocks.{i}.attn.hook_attn_scores'][:, j, :, :].cpu().numpy(),\n", + " )\n", + " for i, j, c in important_heads\n", + "}\n", + "\n", + "print(\"=\"*80)\n", + "\n", + "attn_final_tok_output = plot_attention_final_token(\n", + " important_heads_scores=important_heads_scores,\n", + " prompts=DATASET_PROMPTS,\n", + " targets=DATASET_TARGETS,\n", + " mazes=DATASET,\n", + " tokenizer=TOKENIZER,\n", + " n_mazes=5,\n", + " last_n_tokens=20,\n", + " exponentiate_scores=False,\n", + " plot_colored_tokens=True,\n", + " plot_scores=True,\n", + " maze_colormap_center=0.0,\n", + " show_all=True,\n", + ")\n", + "\n", + "\n", + "# TODO: total attention on coords within path as opposed to not in path?" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "maze-transformer", + "language": "python", + "name": "maze-transformer" + }, + "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.1" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/eval_model.ipynb b/notebooks/eval_model.ipynb index f34a5adb..4f4e8cbf 100644 --- a/notebooks/eval_model.ipynb +++ b/notebooks/eval_model.ipynb @@ -75,7 +75,7 @@ "# get the default model from examples\n", "MODEL_PATH: Path = PATH_EXAMPLES / \"multsrc_demo-g6-n10K-a_dfs-h92077_tiny-v1_sweep-v1_2023-05-20-21-30-02/model.final.zanj\"\n", "# MODEL_PATH: Path = PATH_DATA / \"custom_2023-05-24-05-03-04/model.final.zanj\"\n", - "# MODEL_PATH: Path = PATH_DATA / \"hallway-medium_2023-06-15-04-22-05/model.final.zanj\"\n", + "# MODEL_PATH: Path = PATH_EXAMPLES / \"hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\"\n", "print(f\"will try to get model from {MODEL_PATH.as_posix()}\")\n", "MODEL: ZanjHookedTransformer = ZanjHookedTransformer.read(MODEL_PATH)\n", "print(f\"loaded model: {MODEL.config.name} with {MODEL.num_params()} parameters\")" @@ -90,8 +90,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "loading dataset from ../data/demo-g6-n100-a_dfs-h53577.zanj\n", - "Got dataset demo with 100 items. output.cfg.to_fname() = 'demo-g6-n100-a_dfs-h53577'\n", + "trying to get the dataset 'demo-g6-n100-a_dfs-h10871'\n", + "loading dataset from ../data/demo-g6-n100-a_dfs-h10871.zanj\n", + "Got dataset demo with 100 items. output.cfg.to_fname() = 'demo-g6-n100-a_dfs-h10871'\n", "got test dataset: demo with 100 mazes\n" ] } @@ -161,7 +162,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -171,7 +172,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -181,7 +182,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,7 +192,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAGwCAYAAAAXAEo1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvvUlEQVR4nO3deXxU9b3/8feEbCRMQHaIiIIgQpRdobIpILb2lgfWQqG30opeqVhb8arQnxaRK7jcSinG2qst4lLsota1IlClQRYVMIACIgpCwCABspgVOL8/xmQyyTCZmcyc75mZ1/Px+D7ke+bMzOckk3l7zvme73FJsgQAgIMlmS4AAICmEFYAAMcjrAAAjkdYAQAcj7ACADgeYQUAcDzCCgDgeMmmC2iurl27qrS01HQZAIAwud1uHTp0KOA6MR1WXbt2VUFBgekyAADNlJ2dHTCwYjqsaveosrOz2bsCgBjkdrtVUFDQ5Hd4TIdVrdLSUsIKAOIYAywAAI4XF3tW9VlW/M/L63K5fPqJsM2VlZU+/fT0dEOV2IdtZpvjVcPvsGCwZwUAcDzCCgDgeIQVAMDxCCsAgOMRVgAAxyOsAACOR1gBAByPsAIAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrIBE9vYiae1DoT1n7UOe5wE2IqyARJbUQnr7/uADa+1DnvWTWkS3LqCBZNMFADBo9J2e/759v2/fn9qguvz/BV4PiAJH7FndfPPN+vzzz1VRUaGNGzdq6NChpksCEsfoOz0BFGgPi6CCYcbDavLkyXrkkUc0f/58DRo0SPn5+Vq5cqU6dOhgujQgcQQKLIIKDmD8MODs2bP1xBNP6KmnnpIkzZw5U1dffbWuv/56Pfjgg2aLAxKJv0OCiRRUNTVSfr5UWRn8czp0kC64oPHyrVulr78O6iVcVVWSJGvYMKlFg3OBhw9Le/cGX48knXeelJ3dePm6df7XT0+X+veXUlJCex+bGQ2rlJQUDR48WIsWeUcWWZal1atXa/jw4Y3WT01NVVpaWl3f7XbbUieQMOoH1r8flk5VJ05QXXqpJ2RC8aMfSc8+23j5jBlBv1btN1rl0aNSZqbvg6+8Is2cGVpNv/mNNHt24+UjR575OQMHSps2OTqwjB4GbN++vZKTk1VYWOizvLCwUJ07d260/ty5c1VSUlLXCgoK7CoVSByj75RapHqCypUk9bvGdEXRl58felDFk61bPT8DBzN+zioUixYtUlZWVl3L9rerC6B51j7kCaoWqZJ1Wnp0iPTqL6XSL01XFj0XXCC99570zjtS69amqzEjlMOfBhg9DHj06FGdPHlSnTp18lneqVMnffll4z+M6upqVVdX21UekHganqP65xxp0++lzcukbX+Rht0sXXarlB5nX+hutzR0qFRYKL32WvDPO9NAsD/+MehzVlXfnLNSenrjB7/3Palfv+DrkTznrPzJy/Ptb9smzZoV2msbZDSsampqtHnzZo0dO1Yvv/yyJMnlcmns2LF69NFHTZYGJB5/gym+/YB0YJN0aItUUy7l/a/0wZ+kUf8tDb1BSk4L/JqxplMnT2uugQODXtUKtEfTpYunRcKIEZF5HUOMHwZ85JFHdOONN+q6665Tnz599Pvf/16ZmZlatmyZ6dKAxBFo1N/U56WkeifeK45JK38lLR0i5T8vnT5lb61ISMbD6q9//av++7//W/fdd58+/PBDDRgwQFdddZWOHDliujQgMTQ1PN3dSRpxW+PlxV9IL90k/WGUtGeVZFnRrxUJyyUpZj9hbrdbJSUlysrKUmlpqSTP0Pd453K5fPqJsM2VDQ6VpPs7vh9nbNnmYK+jqiyRfjdAKi868zrnjpTGzZfOHhx2OcZ+z8XF0vbt3v5FF9k20MLYNm/eLE2b5u3/+c/S4PB/d6Go/x3m73vcH+MXBQMw6PSp4K6jSs+SRt0pvXnXmdfZlyc9eYV04feksb+W2veKbK3RtH2773VIeXkxf46nSYMHS7t3m64iaMYPAwIw6PK5wV/wO+SnUpvuTa+38xUp99L4H+4OWxFWAIKTnCZdcXdw61qnPMPdfzdQWrNAqiyObm2Ie4QVgODlXCt1uij49WuHuy8ZIG3IlU5WRa00xDfCCkDwkpKk8feG/jyGu6OZCCsAoek5VjpvVHjPZbi7c3z6qXTTTd726aemKwqIsAIQGpdLGndv816jcIf08izp439EoiKE48svpf/7P2/zM8WdkzB0HUDosgdL/SZJH70U2vNadfIMbe83STpnmJTUounnACKsAITrinukna9Kp08Gt/7Vv5EG/5SAQlg4DAggPO16SoOmB7/+24uko59Erx7ENcIKQPhG3yWlZAS3bvlR6anvSkd2RrcmxCXCCkD43J2k4bcEvz6BhTARVgCa51s/lzLa+S5rkeaZ2NYfJwZWp07SjBneFol7WiGiCCsAzVM7yW19vcZL0/4q9Rjj/zlOC6xevaQnn/S2XjE0CW+CIKwANN+Qn0ptzvH2+02SUjOkH66IncCCoxFWAJovOc0zlF3yHALsPcHzbwILEUJYAYiM2klue42X0tze5QQWIoCwAhAZtZPc9pvU+LEgA8v11a5oVogYRlgBiJyeYz3TKfkTRGClrrjGTGBt2SL16+dtW7bYX4PdLrpIevttb7sohFu/GMB0SwAix+WSklPP/HhtYD0/VfrsncZPLy9S6oprVD31RVkd+kSvzobKy6WPP/btx7vWraUxY0xXETT2rADYq4k9rNrA4pAg6ou7PavKykrTJdguEba5ZcuWpktAhLVMll7+YYbG92z8NeQqL1Lx70aq9a15tuxhuaqqlFavX1VVJcumv6uGn+2Kigpb3jfWsGcFwIiKk9LE58u1aq//Wds7Ziaxh4U6hBUAY5oKLA4JRlFZmVxbt9Y1lZWZriggwgqAUQSWGa78fKV961t1zZWfb7qkgOLunFV6errpEqKu4TFttjk+NTwXGffbXF2uVTM6nPEcVtqK70s/eU3qeGHk3zstrUE3TTL087bt9+ygbQ4Ge1YAnCE1I+AeFjNdJDbCCoBjNHVIkMBKXIQVAEchsOAPYQXAcWoDi8lvUYuwAuBIFSfFbO2oQ1gBcC67bi9y2WVSTY23XXZZ814PEUdYAXA2OwLL5ZKSk73N5Qr/tRAVhBUA5+MGjgmPsAIQGwishEZYAYgdBFbCirvplgDEuSZu4FgXWKFMzXTokPT3v3v7114rde0akXIdq3176Yc/9O07mEuSZbqIcLndbpWUlCgrK0ulpaWSJMuK2c0JWsLNGSe2WUqMbXY1GNgQ8O+5uvzMgSVJGe2DD6x166SRI739vDxpxIimnxcBIW1znKi/zf6+x/3hMCCA2MQhwYRCWAGIXQRWwiCsAMQ2AishEFYAYh+BFfcIKwDxgcAKzYcfSkOHetuHH5quKCDCCkD8ILCCV1YmffCBt5WVma4oIMIKQHwhsOISYQUg/hBYcYewAhCfCKy4QlgBiF/BBtbxfXZWhTAQVgDiWzCB9cZdtpaE0DGRLYD419Tktxkl0sR20rCfSe7OUo8etpeIwIzuWY0cOVKvvPKKCgoKZFmWJk6caLIcAPEs0B6WO0kaUCMl/Vn6wRXxP+N6DDIaVpmZmcrPz9esWbNMlgEgUTDoImYZPQz45ptv6s033zRZAoBEE437YSHqYmqARWpqqtxut08DgJCxhxVzYiqs5s6dq5KSkrpWUFBguiQAsap+YFmWdLJesywCy2FiKqwWLVqkrKysupadnW26JACxrDawTl0s3V/qbQdOeR6P58AaNkwqLva2YcNMVxRQTIVVdXW1SktLfRoANEtqhjT23jM/Hq+BlZwsZWV5W7Kzr2SKqbACgKhISQ/8eLwGVgwxPnS9f//+6t+/vyTpvPPOU//+/dWtWzeTZQFAYwSWUUbDasiQIfrwww/14Tc3/Vq8eLE+/PBD3XfffSbLApDoug70v5zAMsboQcq1a9fK5XKZLAEAGht7r3RgaXxfh/Xll9Jrr3n73/2u1LmzuXqawDkrAGgoJT3+r8P69FPpxhu97dNPTVcUEGEFAP5w4bCjEFYAcCYElmMQVgAQCIHlCIQVADSFwDKOsAKAYBBYRhFWAJCRIV10kbdlZPhfj8AyhrACgEGDpG3bvG3QoDOvS2AZQVgBQKgILNsRVgAQDgLLVoQVAISLwLINYQUAzUFg2cLZd9sCADt88om0cKG3/6tfSb17B//82sB6fmrsTH577rnSQw/59h3MJckyXUS43G63SkpKlJWVVXfXYMuK2c0JWmVlpU8/Pb2JG8fFAbY5Mba54V0YbPt7XrdOGjnS28/Lk0aMCP11qsvPHFiSlNG+UWAZ22aD6m+zv+9xfzgMCACRwiHBqCGsACCSCKyoIKwAINIIrIgjrAAgGoIMrL4d+BoOBj8lAIiWIALr7ekZZgJr3TopOdnb1q2zv4YQEFYAEE1NBFbHzCRzgXXqlLc5HGEFANHm5MCKEXF3UXDDaxYQnyoqKkyXEHUtW7Y0XYJxDa81ixZXVZXS6vWrqqpkRfy9k6RJy5TywnS12PfvRo/WBlbVgQ9ldegT4fduzJ5tjhxiHADskpKhmu8v16lzR/l9uGNmklJXXCPXV7tsLsz5CCsAsFMTgeUqLyKw/CCsAMBuBFbI4u6cVSLMq8WccYmxzQ3x2Y6ioUOl9evrumn9+knRfu/0dGnaX7RqRgeN79n4q9hVXqS0Fd+P3uS3aWkNumnR3+ZmYM8KALKypOHDvS0ry573Tc3QxOfLtWrvSf+PM9NFHcIKAAyqOCkCKwiEFQAYRmA1jbACAAeoDSwmv/WPsAKAkhJpwwZvKykxUkbFSdk3W3t6utSzp7c5eHCFxJ2CYxKjARPj95yI22zssx2pOwWHwe/vOYw7DscS7hQMAPGA+2E1QlgBgBMRWD4IKwBwKgKrDmEFAE5GYEkirADA+aIRWHv3SrNmedvevREpNVoIKwCIBZEOrMOHpcce87bDhyNWajQQVgAQKxL4kCBhBQCxJEEDi7ACgFiTgIFFWAFALEqwwCKsACBWJVBgxd2dggEgZB07StOn+/ZjRW1gnWkuwdrAiuG5BCXCCgCk3r2lp54yXUX4EiCwOAwIAPEgzg8JElYAEC/iOLAIKwCIJ8EG1vF9dlbVbIQVAMSbYALrjbtsLam5CCsA2LJFuvhib9uyxXRFzddUYLUulW7oLP31SWnVKiknx9byQmU0rObMmaP33ntPJSUlKiws1EsvvaTevXubLAlAIiovl7Zv97byctMVRUagwEp3Sdnl0ucLpYuzpTZt7K4uJEaHro8ePVq5ubl6//33lZycrIULF+qtt95S3759VR4rH5aaGik/X0pN9fwfWUM7d0pFRaG95sCBUmam77Ljx6WPPpIkuaqqfB9LS/P/Ol26SD17Nl7+/vtSw9cIxOWSLrss+PUR+2o/15WVTa/bqZPUq1fj5Vu2hP6lP3iw5/NW36FD0mefhfY6PXpIXbv6Ljt9Wlq/3v/627aF9vqxJJhh7U9cIc09KCW1sL28UFhOae3bt7csy7JGjhzp9/HU1FTL7XbXta5du1qWZVlut7tuHVtVV1vWwIGWJVnWZZf5X2fSJM/jobQdOxq/zptvhv46P/+5/5q6dw/tdVJTI/YjC1fDz0IiMLbN9T/XwbQZM/y/Tt++IX9mK0pLrYqKirpmWZZlLVkS+mf/0Ucb11NZGfzz8/Ki9/NtwLbfc9XXlrX8e5Y1L8t/2/a36L13A/W31+12W5bl+z3urznqnFXr1q0lSceOHfP7+Ny5c1VSUlLXCgoK7Cyvsfx8aetWz7/Ly6XCQrP1AJFQ/3OdqNLTTVcQeU2dw3rvCVvLCZVjwsrlcum3v/2t1q1bp4++OdzV0KJFi5SVlVXXsrOzba6ygfqHSLZulfbsMVeLXQ4ckBYt8rYDB0xXhEgL5tBfPBs4UOrf33QV0VEbWF0HSdWWVHjK2/pfb7q6gBwz3VJubq5ycnI0YsSIM65TXV2t6upqG6uKgPvvl2bPDu05557beNkll0h5eZKkqgbnm9ICnbPy529/C/2cVa39+6Vf/crbHzlS6tYt+NdC7MnN9X8+tlanTv6XP/NM6OesWvg5Z3LttdKgQaG9To8ejZelpNT9DZ1ReronqFJSQnu/WPF1kZT3v9KX26UvJS372vvYjwz/z38THBFWS5cu1Xe/+12NGjXK/KG9SLswQvNwnXWW9E2QWw3/zzfUQxZDh0amJsSniy7y/VK/6CLpm0P0IQk1YCT/e3VduzYeLBGOpKS6v6GEU/21tPEx6d3fSVUlnmUXT5b0R6NlhcJ4WC1dulSTJk3SmDFjtG/fPtPlAGjdOnG/1OPNqRpp6zPSOw9IZfXOqbdsK110rQirIOXm5mratGmaOHGiSktL1embwwnFxcWqTPTj5gAQLsuSPn5Z+tcCqejTxo+PukM61cr+uprB6ACLm2++WW3atNHatWv15Zdf1rUpU6aYLAsAYtfnedKTY6W/TfcfVK3PkYbOsL+uZjK6Z+VqePEfACA8X26XVs+XPl0VeL0r/p+UfIZBWQ5m/JwVAIcpLZV27fL2+/SR3G5z9SCw4/ultxdK2/4iz/WzAXTKkS76gS1lRRphBcBXfr7nkoRaeXkMuHCi2mHo7z8pnQrykp5x9zp+SqUzIawAIJb4G4YejHNHSuePi15dUUZYAUAsONMw9GCNm994kuAYQlg1x6WXSkeOePsOn2IfQAyyLGnnK9Ka+/yP7gtG34nS2YMjW5fNCKvmSEmROnQwXQWAePV5nrR6nlSwOfzXcLWQrvh15GoyhLBCaHr1kpYt8+0DiLzKEumLDVJNMydIGHSd1P78xsvbtfPMu1i/72CEFULTqZP0k5+YrgKIf+lZ0ug7Pe3oHumjf0gfvSQd8X9XCr9SMqQxc/w/duGFnkmtY4RjbhECADiD9r2k0XdIM96SOl8U/POG3Sy5O0evLhuxZ9UcR45Ib73l7V95pdSxo7l6AMSvqjLpz5M9M1UEo2Vb6bJbo1uTjQir5vjkE+nHP/b28/IIKwCRVxtU+98N/jmj7pDSw7i1i0MRVghNTY1nOp5abnf83qgOcIJwgipGJ6sNhHNWCM2mTZ5RQ7Vt0ybTFQHxq6mgatVZGn5L4+XBTFabny8NH+5t+fnNrzeK2LMC4KtDB+lHP/Ltw37BBNVPXpPS23imX7JOe5YHO1ltaam0caNv38HCCqvly5fr7bff1r///W999tlnka4JgEkXXCA9+6zpKhJbsEHV/pvrHM8dIX3+b8+/Y3iy2kDCOgxYXV2tuXPnas+ePfriiy/0zDPPaMaMGTr/fD8XngEAghdqUElSv0me/8b4ZLWBhBVWN954oy644AJ169ZNd955p8rKynT77bdr165dOnDgQKRrBICEkJmi0INKkvr8h2dapRifrDaQZg2wOH78uIqKinT8+HGdOHFCJ0+e1FdffRWp2gAgYWSmSK9Pywg9qCSpVQfpOw/H/GS1gYQVVvfff7/effddFRUV6YEHHlB6eroeeOABde7cWYMGDYp0jQAQ12qDavS5ZxhGECioasXZUPWGwhpgMWfOHH311VeaP3++XnzxRe3ZsyfSdQEwZetWaUa9L74//lEaONBcPXEuIkGVAMIKq4EDB2r06NEaM2aMbr/9dlVXV2vt2rV655139M477xBeQCz7+mtPYNXvIzqqygiqIIUVVtu2bdO2bdu0dOlSSdLFF1+s2267Tbm5uUpKSlJysrnLtyormzmdfghcVVWqf9ldVVWVLBvev2XLlj79ioqKqL9nLVPb3KiOOD2JHIhdn22Tv+OGn+141tQeldWqk6qnviCrVTcpCj9/p/wtByvsVBk4cKDGjBmjMWPGaMSIEcrKytK2bdu0du3aSNbnaFa3bqqZN8+nDwBNCS6oXpTVjsuBaoUVVseOHVOrVq2Un5+vtWvX6oknnlBeXp6Ki4sjXZ+znXOOTs05w71iAMAPgio8YYXVf/7nfyovL0+lDp+eA1Hgduv0JZf49AEEp6mgOlR6Wu1uJKj8CSus3njjjbp/Z2dnS5IKCgoiU1Ezpaenmy7BdrZu8yWX+Exe28RUmRHT8LxcIvyeG56jsm2b09IadNMkQz9vy7KMvG9UNDEzxaHS07p8ebl2/ybHnnpGjZKKiuq6aQ6/g0JY11m5XC7dc889OnHihPbv36/9+/fr+PHjuvvuuxPyxDcABBRkUH1SdNq+mlJSpLZtvc3BQSWFuWd1//33a8aMGZozZ47efdfzwx8xYoTuvfdepaen6+67745okQAQs5wYVDEorLCaPn26brjhBr366qt1y7Zv366CggI99thjiRNW69dL48d7+6tWSd/6lrl6ADhLEJPSXv7opwRVEMI6DNi2bVvt2rWr0fJdu3apbdu2zS4qZpw+LZWXe9tpPnAAvhHk7OkEVXDCCqv8/Hzdckvju1Pecsstynf43SbRTDt3Sj/4gbft3Gm6IsB5wrnNh90KC6WnnvK2wkJztQQhrMOAd9xxh9544w2NGzdOGzZskCQNHz5c3bp103e+852IFgiHKSqS/v53b/8XvzBXC+BEsRBUkrRnj/TTn3r7eXlSp07m6mlCyGGVnJysefPm6Tvf+Y6uvPJKXXjhhZKkF198UY899pgOHz4c8SIB2Gj4cKmszNtPgMsEIiZWgioGhRxWJ0+e1MUXX6zDhw/rnnvuiUZNAExq0ULKzDRdRewhqKIqrHNWzz77rGbMiO97pwBA0AiqqAvrnFVycrKuv/56jRs3Tps3b9bXDW4hcPvtt0ekOABwPILKFmGFVU5OjrZs2SJJ6t27t89jcTU9CgAEQlDZJqywuuKKKyJdBwCnOHxYeuUVb/9735O6dDFXj1MRVLYyd5dEAM60d680c6a3368fYdUQQWW7sAZYAEDCIqiMYM+qOVJTpW9ukVLXBxC/CCpjCKvmuOQS6eBB01UAsANBZRSHAQGgKQSVcexZITQDB0r1Jyvu2dNcLYAd4jWouneXFi707TsYYYXQZGZKF19sugrAHvEaVJLUrZs0d67pKoJGWAGAZUnlx6TqMim1lZTRVqr+On6DKgYRVs3x2WfSo496+7fcIvXoYa4eAKGpOCHlr5A2/UE6/rl3eZvukivJd1l9BJXtCKvmOHRIWrzY27/mGsIKiBWfrpb+cp1UU974sRP7z/w8gsoIwgqhOXFC+uADb3/IEKlNG1PVAOH5dLX03GTP4T+FMJ8pQWUMQ9cRmh07pPHjvW3HDtMVAaGpOOHZo7IsSaeDf15mx/gKqnffldLSvO3dM5ybcwijYTVz5kzl5+eruLhYxcXFWr9+va666iqTJQE47zzpN7/xtvPOM11RZOWv+ObQXwhBJUmDroufoJI8YV1d7W0Ov2OG0cOABw8e1Jw5c7Rnzx65XC5Nnz5dL7/8sgYOHKiPP/7YZGkI1rZt/pd36eL/GqwPPpAqK0N7jxEjGi87eFDaty+01zn/fKlzZ99lJ09KGzeG9jqtWkkDBjRevmuXdPRoaK81YIDn9eorLpa2b5erqsp3eVramV+nc2fP9jW0ebNUURFaTSNGSLNnh/acWGFZnsEUIXNJO16QrrhbcrkiXhaaZjSsXnvtNZ/+3XffrZ/97GcaNmyY37BKTU1VWr0/WLfbHfUa0YRZs/wvv/lmKTe38fIf/tAzq3ewWrTwBEpDK1ZId94Z/OtI0hNPSDfc4LusvFwaOTK01xkyRHr//cbL58+Xnn8+tNfavFkaNMh32dat0uWXK0A0NfZf/yX9wc+X8LRp0iefhFaTw/8Pu1nKj515hF9Alud5Fcc9w9phO8ecs0pKStKUKVOUmZmpDRs2+F1n7ty5KikpqWsFBQU2Vwmlp5uuAAhfdVnznl9VGpk6EDLjYZWTk6PS0lJVVVXp8ccf16RJk7Rz506/6y5atEhZWVl1Lbv+jOewR//+nimXgFiU2qrpdQJJ42iOKcaHru/evVsDBgxQ69atde2112r58uUaPXq038Cqrq5WdXW1gSpRJyVF2rTJMz9goHNPZ7pZ3/PPh37Oyp+pU6Xhw0N7jr9zOhkZUl5eaK/T8BxTrXnzznxY9Ex69268bOBAKS9PVQ3OWaU1dc7Knz//OfRzVvEso6101nnS8X0Kaci6XNJZ50otz4pOXWiS8bCqqanR3m/OYWzZskVDhw7VL37xC82sf6dSOEtKiue8TTjCfV5DZ5/tac2VnOx/AEc4+vSJzOu0bi2NGCGrYaiHcwh28ODI1BQvXC7p0pukN8OYE+/SmQyuMMj4YcCGkpKSAv8fJAA0R/+pUkqGgv76cyV51u//w6iWhcCM7lktXLhQ//znP/XFF1/I7XZr2rRpGjNmjCZMmGCyLADxrGUbacrT38xgkaTA11slSXJJU57xPA/GGA2rjh076umnn1aXLl1UXFysbdu2acKECVq9erXJsoLXt69Uf/h9377magEQvPPHST/6a4O5Aeufw/rmcF9KS09QnT/W7grRgNGwuqHhNS+xpm1b6eqrTVcBIBznj5NmfyzlPy9tetz3+quzzvWcoxowVUpvbaxEeBkfYAEAxrRsIw2b6Rl0UXHccx1Vmtsz6i/eB1OkpfneHdjhYwUIKwBwuTzD2hNpdoqhQ0Ofsswgx40GBACgIfasmqO8XDpwwNvv1s1zkSkAIKLYs2qOLVs8F4LWti1bTFcEAHGJsAIAOB6HAQEgEe3dKy1Z4u3/4hf+70HnEIQVACSiw4elpUu9/cmTHR1WHAYEADgeYQUAcDzCCgDgeIQVAMDxCCsAgOMRVgAAxyOsAACOR1gBAByPi4Kbo21b6T/+w7cPAIg4wqo5+vaVXnnFdBUAEPc4DAgAcDz2rAAgEfXrJ735pm/fwQgrAEhEZ50lTZhguoqgxV1YVVZWmi7Bdi6Xy3QJQFQk4t9zIm5zMDhn1QyuHTuUeuWVdc21Y4fpkgAgLsXdnpWtiouVlJfn0wcARB5hBQCJ6Ouv5dq/v65rde8uZWYaLCiwuAur9PR0+94sLa1BN02y4f0rKip8+rZusyENz8tZlmWoEvs0PHeRiL/nRNjmhmzb5g8+kEaO9Pbz8qQRI+x57zBwzgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7ACADgeYQUAcDzCCgDgeHE3g4WtLrlEOnTI22/XzlwtABDHCKvmSE2VunQxXQUAxD3CCgASUbt20qRJvn0HI6wAIBFdeKH04oumqwgaAywAAI7HnlVzfPWVtHq1tz9unNShg7l6ACBOEVbNsXu3NG2at5+XR1gBQBRwGBAA4HiEFQAkom3bPHcGrm3btpmuKCAOAwJAIiopkd5917fvYOxZNYdlBe4DACKCsArHiRPSkiXS1Km+y6dO9Sw/ccJEVQAQtwirUK1cKZ19tnTbbb7zAkqe/m23eR5fudJMfQAQhwirUKxcKV19tVRR4Tnk5+8woGV5Hr/6agILACKEsArWiRPS97/vCaPTpwOve/q0Z73vf59DggAQAY4Jq7vuukuWZWnx4sWmS/Fv+XKpvLzpoKp1+rRn/aefjm5dAJAAHBFWQ4YM0U033aT8/HzTpfhnWdLSpeE993e/Y5QgADST8bDKzMzUc889pxtvvFHHjx8PuG5qaqrcbrdPs0VRkbR3b+ihY1me5x07Fp26ACBBGA+r3Nxcvf7661qzZk2T686dO1clJSV1raCgwIYKJZWVNe/5paWRqQMAEpTRsJoyZYoGDRqkuXPnBrX+okWLlJWVVdeys7OjXOE3WrVq3vPt2gMEgDhlbLqls88+W0uWLNH48eNVVVUV1HOqq6tVXV0d5cr8aNdO6tlT+uyz0A4FulxSjx5S27bRqw0AEoCxPavBgwerU6dO2rJli2pqalRTU6MxY8bo1ltvVU1NjZKSjB+h9HK5pJ//PLzn3nqr5/kA4CSXXiodOeJtl15quqKAXJKMDFVr1aqVunfv7rNs2bJl2rVrlx588EF99NFHTb6G2+1WSUmJsrKyVPrNeSErWiPvTpzwzExRURHc8PWkJKllS+ngQalNm4iWUllZ6dNPT0+P6Os7katB4Eft9+wg/J4T4/ec6Nvs73vcH2OHAcvKyhoF0tdff62ioqKggsp2bdpIL7zgmZkiKSlwYCUlefamXnwx4kEFAInIQcfaYsCECdLrr3v2mFyuxof3ape1bCm98YZ05ZVm6gSAOOOo+1ldfvnlpkto2oQJnkN7Tz/tueB3717vYz16eM5RTZ8utW5trkYAiDPGzllFgq3nrPyxLM8Fv6WlnuHpbdvaMpiCcxmJcVyf33Ni/J6NbfORI9Jbb3n7V14pdexoy1vH1DmruOByeYa1t2tnuhIACM0nn0g//rG3n5dnW1iFg3NWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7kBASARnXOOtGCBb9/BCCsASETnnCPdfbfpKoLGYUAAgOMRVgAAxyOsAACOR1gBAByPsAKARLR+vZSZ6W3r15uuKCBGAwJAIjp9Wiov9+07WNyFVWVlpekSoq5ly5Y+/YqKCkOVmONyuUyXYLtE/D0nwt9zQ3Zts6uqSmn1+lVVVbIc/PPmMCAAwPEIKwCA4xFWAADHi7tzVunp6aZLsF0ibHPD8zWJsM0Nz10kwjY3lAjbbOyznZbWoJsmOfjnzZ4VAMDxCCsAgOMRVgAAxyOsAACOR1gBABwv7kYDAgCCkJoqZWf79h2MsAKARHTJJdLBg6arCBqHAQEAjkdYAQAcj7ACADgeYQUAcDwGWABAIvrsM+nRR739W26RevQwV08TCCsASESHDkmLF3v711zj6LDiMCAAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4t2990oLFoT2nAULPM9zCMIKAOJdixbSr38dfGAtWOBZv0WL6NYVAmawAIB4d889nv/++te+fX9qg+q++wKvZzOje1bz5s2TZVk+befOnSZLAoD4dM89ngAKtIfl0KCSHLBntWPHDo0bN66uf/LkSYPVAEAcq7+HNXeu9Npr3sfeeENatMiRQSU5IKxOnjypwsJC02UAQGKoH1i1wbRggaODSnJAWPXq1UsFBQWqrKzUhg0bNHfuXB04cMDvuqmpqUpLS6vru91uu8oEgPhRP7D+53+k6mpHB5UkuSRZpt78qquuUqtWrbR792516dJF8+bNU3Z2tnJyclRWVtZo/Xnz5uleP0Mps7KyVFpaKkmyLGObYxuXy+XTT4Rtrqys9Omnp6cbqsQ+ibjNfLZt/j2npXmCKjVVqqqy7W3r/57dbrdKSkp8vsf9PkcGw6qh1q1ba//+/Zo9e7b+9Kc/NXrc355VQUEBYZUA25yIX9yJuM18tm38PdcOpkhNtX3PKpywctR1VsXFxfrkk090/vnn+328urpapaWlPg0AEKL6o/6qqpoeJegAxs9Z1ZeZmamePXvqmWeeMV0KAMQnf8PTQ7kOyxCjYfXwww/r1Vdf1f79+9W1a1fNnz9fp06d0ooVK0yWBQDxKdB1VA4PLKNhdfbZZ2vFihVq166dvvrqK61bt07Dhg3T0aNHTZYFAPEnmAt+HRxYRsNq6tSpJt8eABJDKDNTODSwHHXOCgAQBadOhTbar3a9U6eiV1OIHDV0PVT+hjwmwlBXhvcmxjDuRNxmPtuJ93uOyaHrAAD4Q1gBAByPsAIAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7ACADgeYQUAcLxk0wVEmsvlMl2C7RJxm5EY+GyjFntWAADHI6wAAI4XF4cB3W636RIAAGEI9vs7psOqdiMLCgoMVwIAaA63263S0tIzPu6SZNlXTuR17do14AZGm9vtVkFBgbKzs43WYSe2Of63OdG2V2KbTX+PHjp0KOA6Mb1nJanJDbRLaWlpwnzAa7HN8S/Rtldim029f1MYYAEAcDzCCgDgeIRVM1VVVenee+9VVVWV6VJswzbHv0TbXoltdrqYH2ABAIh/7FkBAByPsAIAOB5hBQBwPMIKAOB4hFUz3Hzzzfr8889VUVGhjRs3aujQoaZLiqqRI0fqlVdeUUFBgSzL0sSJE02XFFVz5szRe++9p5KSEhUWFuqll15S7969TZcVVTNnzlR+fr6Ki4tVXFys9evX66qrrjJdlq3uuusuWZalxYsXmy4laubNmyfLsnzazp07TZcVEGEVpsmTJ+uRRx7R/PnzNWjQIOXn52vlypXq0KGD6dKiJjMzU/n5+Zo1a5bpUmwxevRo5ebmatiwYRo/frxSUlL01ltvKSMjw3RpUXPw4EHNmTNHgwcP1pAhQ/Svf/1LL7/8svr27Wu6NFsMGTJEN910k/Lz802XEnU7duxQ586d69qIESNMl9QkixZ627hxo7V06dK6vsvlsg4ePGjdddddxmuzo1mWZU2cONF4HXa29u3bW5ZlWSNHjjRei52tqKjIuv76643XEe2WmZlp7d692xo7dqz19ttvW4sXLzZeU7TavHnzrK1btxqvI5TGnlUYUlJSNHjwYK1evbpumWVZWr16tYYPH26wMkRT69atJUnHjh0zXIk9kpKSNGXKFGVmZmrDhg2my4m63Nxcvf7661qzZo3pUmzRq1cvFRQUaO/evXr22WfVrVs30yUFFPMT2ZrQvn17JScnq7Cw0Gd5YWGh+vTpY6gqRJPL5dJvf/tbrVu3Th999JHpcqIqJydHGzZsUHp6usrKyjRp0iTHn89orilTpmjQoEFxf9651qZNm/STn/xEu3fvVpcuXTRv3jzl5eUpJydHZWVlpsvzi7ACgpCbm6ucnJyYOK7fXLt379aAAQPUunVrXXvttVq+fLlGjx4dt4F19tlna8mSJRo/fnxMTDsUCW+++Wbdv7dv365NmzZp//79mjx5sv70pz8ZrCww48ciY62lpKRYNTU1jc7ZPPXUU9Y//vEP4/XZ0RLpnNXSpUutL774wjr33HON12KirVq1ynr88ceN1xGtNnHiRMuyLKumpqauWZZlnTp1yqqpqbGSkpKM12hHe++996yFCxcar+NMjXNWYaipqdHmzZs1duzYumUul0tjx45NiGP7iWTp0qWaNGmSrrjiCu3bt890OUYkJSUpLS3NdBlRs2bNGuXk5GjAgAF17f3339dzzz2nAQMG6PTp06ZLjLrMzEz17NlThw8fNl1KQMYTMxbb5MmTrYqKCuu6666z+vTpYz3++OPWsWPHrI4dOxqvLVotMzPT6t+/v9W/f3/Lsizrl7/8pdW/f3+rW7duxmuLRsvNzbWOHz9ujRo1yurUqVNdS09PN15btNrChQutkSNHWt27d7dycnKshQsXWqdOnbLGjRtnvDY7W7yPBnz44YetUaNGWd27d7eGDx9uvfXWW9aRI0es9u3bG68tQDNeQMy2WbNmWfv27bMqKyutjRs3WpdcconxmqLZRo8ebfmzbNky47VFo53J9OnTjdcWrfbkk09an3/+uVVZWWkVFhZaq1atSrigkuI/rFasWGEVFBRYlZWV1oEDB6wVK1ZYPXr0MF5XoMYtQgAAjsc5KwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrIIYtW7ZML730kukygKgjrAAAjkdYAQAcj7ACDHO5XLrjjju0Z88eVVZWav/+/frVr34lyXPX3jVr1qi8vFxHjx7VH/7wB2VmZhquGLAfYQUYtmjRIs2ZM0cLFixQ3759NW3aNBUWFiojI0MrV67U8ePHNXToUP3gBz/QuHHj9Oijj5ouGTDC+NTvNFqitlatWlkVFRXWjBkzGj12ww03WEVFRVZGRkbdsm9/+9vWyZMn6+6btmzZMuull14yvh00WrQbe1aAQRdeeKHS09O1Zs0av4/l5+ervLy8btm7776rFi1a6IILLrCzTMA4wgowqKKiwnQJQEwgrACD9uzZo/Lyco0dO7bRYzt37lT//v2VkZFRt+yyyy7TqVOntHv3bjvLBIwjrACDqqqq9OCDD+qhhx7Sj3/8Y/Xo0UOXXnqprr/+ej333HOqrKzU8uXL1a9fP40ZM0ZLly7VM888oyNHjpguHbBVsukCgES3YMECnTx5Uvfdd5+6du2qw4cP6/HHH1dFRYUmTJigJUuW6P3331d5ebleeOEFzZ4923TJgO1c8oy0AADAsTgMCABwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8f4/9mDrG1POIMsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -201,7 +202,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -211,7 +212,7 @@ } ], "source": [ - "testdata_plot_predicted_path(MODEL, DATASET_TEST, n_mazes=5, max_new_tokens=15)" + "testdata_plot_predicted_path(MODEL, DATASET_TEST, n_mazes=5, max_new_tokens=50)" ] }, { @@ -221,7 +222,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -231,7 +232,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAGwCAYAAAAXAEo1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzLElEQVR4nO3deXxU9b3/8fdkJ2ETWQIBsSwBMRoCiCJrCwpY7+XSa6F6a6UuVx9qb1t9KNCfCOIFxLZQi2m9194i1ZYuVq5dFBWq3CCrgGExBGoRQ2QNEMDsyfn9MWaZJZk5ycx8T2Zez8fjPOB75sw5n5Nl3jnf75nvuCRZAgDAweJMFwAAQCCEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7ACADhegukC2uLSpUtKTk5WXV2dTp06ZbocAIBNPXv2VFxcnCorK9WxY8dmt3OpHb8puLq6WgkJ7TpvAQCSampqlJiY2Ozj7fqVvq6uTpL7JE+cOGG4GgCAXenp6UpISGh4PW9Ouw6rU6dOqW/fvjpx4oT69etnuhwAgE1FRUXq27dvwKEcbrAAADheu76y8sey2u0QXNAqKio82ikpKYYqiZxYPGeXy+XR5mc7OsXiOXv/bAeDKysAgOMRVgAAxyOsAACOR1gBAByPsAIAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcL8F0Ae1aXZ1U/Hfp/Gmpaw8pY5AUR/4DQKgRVq1x4qi0Zq506i2pU13j+otxUs+p0l3LpfT+5uoDgCjDZYBdv1su/fQaqewNKa3W87G0Wvf6n17j3g4AEBKElR2/Wy4dWOK+HnW5pDiX5+NxLvf6BLm3I7AAICQcEVYPPvigjhw5ovLycm3btk3XXXed6ZJ8nTgq5S9x/987pLzVP56/xP08AECbGA+rWbNmacWKFXrqqac0YsQI5efn66233lKPHj1Ml+ZpzVwpUYGDql6cy739r+aFsyoAiAnGb7B45JFH9OKLL+qll16SJD3wwAP66le/qrvvvlvLlzukG62uzn0zRUebz7MkHX9T+r//871LcMgQyTuQq6qkHTsC7tZVWdnY6NJFGjXKd6OPPpLOnrVX74gRUmqq57qzZ937sqNPH2nAAN/1O3a4zzFYcXHSjTf6rv/0U+nUKXs1ZWZKPXt6rquulrZvD34fKSlSdraUmGjv2ADazGhYJSYmauTIkVq2bFnDOsuytGHDBo0ZM8Zn+6SkJCUnJze0Xa4gr3LaqvjvX9z1Z/N4cS6piyVNmySVW56P/eY30u23e64rKZHGjw+42+Qm/68bP94dht7mzZP+/Gd79R486A7RprZulW691d5+vv99acUK3/Vf+5pUXBz8flJTpc8/91kd/5vfSE89Za+ml1+WvvlNz3Xnzwf19faQk+MOOAILiCij3YDdu3dXQkKCTp486bH+5MmTSk9P99l+/vz5unDhQsOSkZERmULPn27b85NCUwYcYM8eKT/fdBVAzDE+ZmXHsmXL1Llz54al2M5f6W3RtY3jZzZ6vuBgOTnS2LFSEn99AJFmtBvwzJkzqqmpUa9evTzW9+rVSydOnPDZvqqqSlVNxjwsy/LZJiwyBrnf8JtWG/wNFpJUZ7mft/49/2NW3i6/XMrLC7jbSq8xq2R/Gz3zjPT448HXKkn9+vmuGzMmqJo89Onjf/1rr9kfs/Kj9o47lDhlir2aMjN913Xtau/cBg+WvH5WAUSG0bCqrq7Wrl27NHnyZL3++uuS3ONQkydP1vPPP2+yNE9xX8xMUfaGvee5JPWeLk2YENz2SUnSuHEBN7MqKgLva9iw4I4ZSLduQdUUlNGjQ7OfK67wHz52JSaG7twAhJXxbsAVK1bovvvu07e+9S0NHTpUP//5z5WWlqbVq1ebLs3TXcularmvloJRZ7m3/9Yz4awKAGKC8VvXf//736tHjx5avHix0tPT9eGHH2ratGk6ZffW5HBL7y9l/z/3zBR1VsvdgfWBNnwBcwQCQAgYDytJys3NVW5urukyAps9V/qd3DNTJFru91E1Da06y931VyN3UM16zEydABBljHcDtjuz50rf2SsdrZUueHUJXnRJaV+VvneAoIomBQXu94jVLwUFpisCYo4jrqzanV5XSFcmSJYlldW5r6QSJE37rjT1P01Xh1ArKZHWrWtsP/KIuVqAGEVYtYXLJaU26QbkgxcBICx4dQUAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8plsCAsnJkfbvb2xfeaWxUoBYRVgBgaSlSVdfbboKIKbRDQgAcDzCCgDgeIQVAMDxGLMCAjl3Ttqxo7E9erR02WXm6gFiEGEFBHLggDRtWmM7L08aN85cPUAMohsQAOB4UXdlVVFREf6DWHVK8bO6pqZWNRE4focOHcJ+DKcrLy+P2LFclZVKbtKurKyUFYmfM+86XK6IHxORF8mf7faEKysAgOMRVgAAxyOsAACOF3VjVikp/kaT2qCuVoqL91pX53fThIR4JXgfv37buND9XeDdpx3yc3Yg7/GaiJ5zcrJXM1ky8DW3LCvix4w07zHnWPjZjsVzbg2urAI5sE76yyNS6TF7z6urkz76k/SbWRID4wDQJoRVIAMmSR/8UnpueHChVVcnffS69MI46fd3Sl0yCCsAaKOo6wYMubTuUr/RUtF26YP/kXb/Ssr5pv9tj+1yh9SpA43rMqdHpk4AiGJcWQUjc2rj/+uqpV2r/W93dLNnUCWkSF+aEN7aACAGEFbBaO3V0YBJUlJqSEsBgFhEN2Awel4ldb1COv+pvedlTgu8DZyvd2/pO9/xbAOIKMIqGC6X++pqx3/Zex5hFR0GDpR++lPTVQAxjW7AYA2xGTy9h0ud+QscAEKBsApW/7FSUsfgt+eqCgBChrAKVkKyNPArwW9v90oMANAswsqOIUHeFdipt7sbEAAQEoSVHYNvlhTEbBSZU5m1Iprs3CldeWXjsnOn4YKA2MPdgHY0nc2iJcxaEV0qK6WjRz3bACKKKyu7ms5m4Q+zVgBAyBFWdgW6amLWCgAIOcLKrvrZLJrDLesAEHKElV31s1k0h7ACgJAjrFqjufdQMWsFAIQFYdUazc1mwVUVAIQFYdUazc1mYWrWiro6afNPpKNbpdoaMzUAQBgRVq3lPZuFyVkr4uLcHwq5epr0o0HSa/8u7X9Nqig1Uw8AhBhvCm6thtksLHfb9KwVo++XtjwvlZ+T9v7OvcQluLssh0x319dtgLn6AKANuLJqrfrZLOqZnrUipbN048Oe6+pqpCObpPXzpJ/mSM+Plt55ku5CAO0OYdUW9bNZOGXWitH3Syldm3/8TKH0/nN0F9rlcklJSY0L8z4CEWe0G3D8+PF67LHHNHLkSPXp00f/8i//otdff91kSfZkTpc2LpYyRtn/yPs2cFV5zU2XlNz4/2EzpN1rAu+E7sLgjR3LfICAYUbDKi0tTfn5+frlL3+pdevWmSyldXpeJXXsKR3dLP3s+ogdNjnwJvbUdxfWdxl2H+K+szFzutT3OimeoU0AZhl9FVq/fr3Wr19vsoS2cbmkK8ZIH7Wjq8FgnCls7DLscJn7ZpLMadKgyVJKF9PVwaTiYunIEXvPGThQ6u31ZvnaWmnrVp9NXd5XsMlN/jRLS5Nycnz3X1gonT5tr6bsbKlTJ891paXSvn329tOrlzR4sO/63bulsrKgdlF/ztaNN/p2MX/2mfSPf9iracAAqU8fz3V1ddKWLf63T0lxfz0SE+0dJ8La1Z/MSUlJSm7yw+tywthB1r9GX1g11bS70BUn9bpGuvpfpNTL3Y/3u17qOdRoiYig3/1OevRRe8954QXp/vs911VUSOPH+2zaYq9BTo47BLw9/bT061/bq2nHDum66zzX7dvnt6YW3XOP9Itf+K6/807po4+C2kX9OVdcvCgleL0kv/qq9N3v2qvp+eelhx7yXFdd3fK55eRI27c7OrDa1Q0W8+fP14ULFxqWjIwM0yVJaT1NVxB+3QZKOXdKVp10Il/a+JT05/9wL0c3m64OQFvt2SPl55uuokXt6spq2bJlWrFiRUO7oKDAGYEVbVzx7u7NIdPc3X/dB0tnj0h7XjZdmRlFRdIrrzS2v/lNqV8/c/WE2+bNnn+F5+VJ48aZqweRUVFhuoIWtauwqqqqUlVVVUPbsiyD1Xzh8oHSPz8f0UNWV1d7tBObXrofflsq+JP9naZ0kQbd1Dg2ldqtjVVGkaNHpR/8oLE9fnx0h1VLZs+WRo8OvF1TAwf6rktJcYegl0qvMatk7zErfxYskB54wF5NQ/10XV9zjd+aWtSrl//1L78c9JhVwznHx/s+eNtt0ogR9moa4Odu3sRE33Pbu9e3u9DB2lVYOVLHntKIOyN6yFqvv4ASU1K+eKBGyvtx8DvqNvCL29WnSVfcIMU7t78aDpGR4V7aKj7e79Wa5f3Xff3PdkuGDHEvbdWlS+iuIG0EjM85N9Wnj+/NEq0RF9fur46N37o+aNCghvaXvvQlZWdn6+zZsyoqKjJYWTu17/fSuRbu1PLXvQcA7YDRsBo1apTee++9hvbKlSslSS+99JK+/e1vG6qqnaqtkTY967ue7j0AUcBoWG3atMkZt59Hg6ZXVXTvAQgkNdU9Tte07WCMWUWDujrp063Szf9J9x6A4IwY4b7Jop0grKJBXJz0z6tMVwEAYdOu3hQMAIhNhBUAwPEIKwCA4zFmBQCx6NAhaenSxvYPfiBlZpqrJwDCCoCnDh08X7Q6dDBXC8Ln1ClpTZMPar33XsIKaNcGD5ZWr/ZsR7ORI92fEQU4CGEFBNKrlzRnjukqgJjGDRYAAMcjrAAAjkdYAQAcjzErIJDqaunixcZ2p07uD7OLVn//u/TDHza2H3tMavJRPoAJhBUQyPbtsfUx7ydOSP/9343tO+8krGAc3YAAAMcjrAAAjkdYAQAcj7ACADgeN1gAQCy69lppy5bG9tVXm6slCIQVAMSizp2lMWNMVxE0ugEBAI4XdVdWLpfLdAkRV15eHvZjuKoqlexnfXV1jWorKsJ+fG8VETymq9Lz3CsrK2VF8TmbPN8OfBxJRH6f2yOurAAAjhd1V1YAgCBcuCDXRx81NK1hw9zjWA5FWAFADHLt26fkKVMa2pUbNsgaO9ZgRS2LurCyLMt0CWHnPXaRkpIS2gNUXpKSO3quS/I3YiUlJiYo0fv4/p4fYiE/55Z07y7dcENDM7l7dykCx/ceu4jYOY8aJb37bkMzOScnIufrTyz8PnuPs0fs+5yc7NVMNvZ9DkbUhRVCYNdq6bMPpYmPSz2GBP+8srPStp9Lpwuk2a+ErbyIy86Wtm41XUXkdOkiTZpkugrAAzdYwNfgm6X9r0q510uv3iOdLmx5+7Kz0t/+U/rJtdL/PStdcWNk6gQQM7iygq/umdJlX5LOHXGH1v4/SgMm+d82/3fSO4ukqiaf9zRkWiSqBBBDuLKCL5dLGjK9yQpL+se7/rc9tsMzqLoPkboNCGt5AGIPYQX/Mlt5dcRVVft36ZK0e3fjcumS6YoAugHRjP43SsmdpcoL9p6XOT3wNu1NQYH05JON7cWLpauuMldPuH34YWx9MjLaBcIK/sUnSoMmSwfWBf+cDpdJfa8LX02mlJRIr77a2P7ud83VAsQougHRPLtXSYNvluL5+wdA6BFWaN7gmySXjR+R1o5zAUAAhBWal9pN6ndD4O0kKS7B3W0IAGFAnw1aNmSa9OmWwNv1HyuldAl/PQBCo2dP6a67PNsORlihZZnTpHeeDG47AO1HZqb00kumqwga3YBoWf1sFoHw/ioAYURYoWU+s1n4wawVAMKMsEJggbr4uKoCEGaEFQKrn82iOdE4awUARyGsEFj9bBb+ROusFUC0271buvbaxmX3btMVtYi7ARGczOn+p15i1oro07279I1veLYRfcrKpH37PNsOxqsMglM/m4VV57k+Fm5Zz8mR8vMb2wMHmqslEoYOldauNV0F4IGwag9qa9yfG1X4ppT1r1K3oZGvoX42i6ZvEI6VWSvS0tzdJACMIaycqqJU+vsGqXC99Pd3pPJzUq9rpClPSVVVZmryns2CWSsARAhh5SQlH0uH1ruvoD7dKtXVeD4+aa4UZ/CeGO/ZLGKhCxCAIxBWJtXWSEXb3QF1aL105lDz2/a6Rhry1cjV5k/9bBbnjrjbvL8KQIQQVpHmr3svGKavqqTG2Sy2/Sy2Zq04f1764IPG9qhRUteupqoJvw8/lO67r7H94ovS8OGmqgEkGQ6refPm6Wtf+5qGDh2q8vJybdmyRXPnztWhQy1cYbRH9d17h9ZLR7f4du8Fknq5FJcoHXpbkhRX7TVmlZgUokKDqeWL25hj6apq/37pppsa29H+Me+XLnmG86VL5moBvmA0rCZOnKjc3Fzt3LlTCQkJWrp0qd5++20NGzZMZQ6/579Fdrr3glFWIq2d3dCMYDT5F5cY27NW7N3b/GO9e/u/tf2DD6SKCnvHGTXKd92xY9Inn9jbz6BBUnq657qaGmnbNv/bt3R+gCFGw2r6dM8XvDlz5uj06dMaOXKk8vLyfLZPSkpScnJyQ9vlcoW9xqC1tnuvPep6RWzPWvHQQ80/9uCDUm6u7/pvfEP6+OPgjxEf7/+KZu1a6fHHg9+P5O7Gu/dez3VlZdL48fb2AxjkqDGrLl3ct0GfPXvW7+Pz58/XokWLIlhRM+rqpHeXuP9v1UnFu7/o3jN0S3mkpWfF1qwVKSmmKzAr1s8fjuCYVxyXy6Wf/OQn2rx5sw4cOOB3m2XLlmnFihUN7YKCAmVkZESqRE95P/JdN/SfpNTLpENvSZdORr6mSIlPDrxNNMnOds9isWeP6UoiLyfHff6AYY4Jq9zcXGVlZWlcCwPXVVVVqmryhljLsiJRWvAuHyDdtNh95XX8w8b3TJ1gDKBdS0yUtm93T7kUaNypd2//63/7W/tjVv7cfrs0Zoy95wwa5LsuNdV9o0hLUlLcQZWYaO94aB9uvNHzZ9Lh32dHhNWqVat06623asKECSouLjZdTtvFxUkZI9zLl38glRY33mzxj01SbaW9/aVeLv3r/7jn5pM8Altyj+VFVMeekT2eEyQm+r/hIVitea6/cOvb1720VUJCdN/RiMDi4qTk9tNLYjysVq1apZkzZ2rSpEn6xO5dTu1FlwzpunvcS9Xn7sA69Gbw3YVlJVLFeenqmZKkOu8XMcYUAEQ5o2GVm5urO+64QzNmzNDFixfVq1cvSVJpaakqQtFl4kRJadLQW9xLXZ10fI87tAJ1F763XLpqhvk3BgOAAUbD6sEHH5Qkbdq0yWP9nDlztGbNGhMlRVZcnJQx0r0E6i48XSAVvN5wdQUAscRoWDnqfVJOEKi7sP7qCgDa6rPPpHVNPlB15kypTx9z9QRgfMwKzWiuu/DkPumyIaarA9De/eMf0sMPN7azswkrtFHT7kIpNLdAA0A7wmg9AMDxCCsAgOMRVgAAxyOsAACOR1gBAByPsAIAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4zHdEgDEogEDpOee82w7GGEFALGoTx/pP/7DdBVBa1U34Jo1azRnzhwNcHgSAwCiQ6vCqqqqSvPnz9fhw4f16aef6uWXX9Y999yjQYMGhbo+AABaF1b33XefhgwZon79+unxxx/XpUuX9Oijj+rgwYMqKioKdY0AgBjXpjGrc+fOqaSkROfOndP58+dVU1Oj06dPh6o2AEC4WJZUW9vYjo+XHPzp7a26slqyZInef/99lZSU6JlnnlFKSoqeeeYZpaena8SIEaGuEQAQau+/LyUmNi7vv2+6oha16spq3rx5On36tJ566im99tprOnz4cKjrAgCgQavCKicnRxMnTtSkSZP06KOPqqqqSps2bdJ7772n9957j/ACAIRUq8Jq79692rt3r1atWiVJuvbaa/X9739fubm5iouLU0KCubdvVVRUhP8gVp1S/KyuqalVTQSO36FDh7Afw+lcDu5bR+hE5PfZYSJ1zq7KSiU3aVdWVspy8Ne71amSk5OjSZMmadKkSRo3bpw6d+6svXv3atOmTaGsDwCA1oXV2bNn1bFjR+Xn52vTpk168cUXlZeXp9LS0lDXBwBA68Lqm9/8pvLy8nTx4sVQ1wMAgI9WhdUbb7zR8P+MjAxJUnFxcWgqaqOUFH+jSW1w4TOpY7oU1+Qu/7o6v5smJMQrwfv4F45LHXtKcfGhrasJy7LCtm+n8B6jioVz9h67CPnPtgPF4jmXl5d7tCN2zsnJXs1kycFf71a9z8rlcmnBggU6f/68jh49qqNHj+rcuXN64oknom/g+/he6ec3Svtfazak/LrwmfTG49Jvbw9rUAFALGjVldWSJUt0zz33aN68eXr/izeSjRs3TosWLVJKSoqeeOKJkBZp1ICJ0rlPpFe/LfV4Vpr4uHTVPze//YXPpM0rpV1rpNpKadwjESsVAKJVq8Lqrrvu0r333qs///nPDev27dun4uJi/exnP4uusErsIA2YJB16Uzpd8EVoDfW/7YH/lbb9XKqtalw3ZHokqgSAqNaqbsBu3brp4MGDPusPHjyobt26tbkoxxkyzbN92vfcJUnnj3oGVWp3KWNk+OoCgBjRqrDKz8/Xww8/7LP+4YcfVn5+fpuLcpzBU1v5vJsZrwLgTKmp0rBhjUtqqumKWtSqbsDHHntMb7zxhqZMmaKtW7dKksaMGaN+/frplltuCWmBjtC5t9R7uHT8Q3vP874iAwCnGDFCOnDAdBVBs31llZCQoIULF+qWW27Ra6+9pq5du6pr16567bXXNGTIEG3evDkcdZpnd+wpPkka+JXw1AIAMcb2lVVNTY2uvfZaHT9+XAsWLAhHTc6UOU16b1nw2185TkruFL56ACCGtGrM6pVXXtE999wT6lqcrXe21Kl38NtnchcgAIRKq8asEhISdPfdd2vKlCnatWuXPv/8c4/HH3300ZAU5ygul5Q5Vdr1UnDbZ7bypgwAgI9WhVVWVpZ2794tScrMzPR4LKqnwcmcHlxY9RwmXdY/7OUAQKsdPiwtX97YnjtXGjzYXD0BtCqsvvKVGL1xYMBEKaGDVFPe8naZ3AUIwOFOnpT+538a23PmODqsWjVmFbPqZ7MIhFkrACCkCCu7Ar13ilkrACDkCCu7As1mwawVABByhJVd9bNZNIdZKwAg5Air1mhuTIpZKwAgLAir1mjubj9mrQCAsCCsWqO52SyYtQIAwoKwao362Sy8MWsFAIQFYdVa3ldRzFoBAGFDWLVW/WwW9Zi1AgDChrBqLe/ZLJi1AgDCplVzA+ILQ6ZJh95k1goA7c8110h5eZ5tBzN6ZfXAAw8oPz9fpaWlKi0t1ZYtWzRtWjvqTqufzYJZKwC0N126SOPGNS5dupiuqEVGr6yOHTumefPm6fDhw3K5XLrrrrv0+uuvKycnRx999JHJ0oJTP5sFs1bElvPnpf377T2nd29p4EDf9R98IFVU+H2Kq7LSc0VysvvfceN8Nz52TPrkE3s1DRokpad7rqupkbZts7efjh2l4cN91x88KJ05Y29fQ4e699dUaam0b5+9/aSnu8/P265dUnmAT03w5u/rXVwsHTlibz8DB7p/DpqqrZXr/fc919V/n5uTlibl5PiuLyyUTp+2V1N2ttSp/bw31HLSUlJSYt19991+H0tKSrI6derUsBw7dsyyLMsqKipq2Cbi/u/HllVxIaKH9P66xAJHnfM771iWZG958EH/+xo40N5+4uP97+fZZ+3X9OKLvvspLbW/n1Gj/Nf0jW/Y3lfFli1WeXl5w2JZlmW9+679mv793/3XlJlpf1/+/PjH9vfzwgu++7l0yf5+cnL81/Rv/2Z/Xzt2+N9XmDX9XS4qKrIsy/N13N/imDGruLg4ff3rX1daWpq2bt3qd5v58+dr0aJFkS3Mn7o6ad39X/y/RvrLI+7/Z06VrrnNXF0AEKWMh1VWVpa2bt2qlJQUXbp0STNnzlRBQYHfbZctW6YVK1Y0tAsKCpSRkRGpUj3t+73vus69CSsACAPjYVVYWKjhw4erS5cuuu2227RmzRpNnDjRb2BVVVWpqqqqoe2+mgQibNQoz7uoguE9VlHvt79tdsyq0mvMKrmlsYzbb5fGjLFXk78xndRU++fmPcZUb+FC6aGHbO3K8vdJtTk59mvyHour95vf2B+z8mf2bGn0aHvP8TdmmZKiyg0bPFa1+H2W3GNW/ixYID3wgL2ahg61t71BLrn7Ax3jnXfe0ccff6wHgviiFxUVqW/fvjp27Jj69esnKUIBVlcnLb7Md/3Y70o3LQ774V0ul0c7FkLb6Dl//rn08ceN7YEDm3/BCKEKrxBLSUkJ+zFN45xj45yb/j77ex33x/iVlbe4uLjAf1kAkbRnjzR+fGM7L8//HWIAwsZoWC1dulRvvvmmPv30U3Xq1El33HGHJk2apKlTmRAWANDIaFj17NlTv/rVr9S7d2+VlpZq7969mjp1qjZ49eECAGKb0bC69957TR4eANBOMJEtAMDxCCsAgOMRVgAAxyOsAACOR1gBAByPsAIAOB5hBQBwPMIKAOB4jpsbEHCcyy+XbrvNsw0goggrIJCrrpL+8AfTVQAxjW5AAIDjEVYAAMcjrAAAjkdYAQAcj7ACAsnPl8aMaVzy801XBMQc7gYEArl4Udq2zbMNIKK4sgIAOB5hBQBwPMIKAOB4hBUAwPEIKwCA40Xd3YAVFRXhP4hVpxQ/q2tqalUTieN7icg5O0wkz9lVWankJu3KykpZETh+hw4dwn4MoL3gygoA4HiEFQDA8QgrAIDjRd2YVUqKv9GkNjhdKHXOkJI7Nq6rq/O7aUJCvBK8j388X+qVJcXFh7auJkJ+zg5UXl7u0Y7oOScnezWTJQNfc8uyIn7MSPMei4yFn22Xy+XRjoXvs/c5B4Mrq0AunpCeu1Z6/zmp6vPgn/fZHuk335D+8khYgwoAYkHUXVmFXP8bpdpq6Z0n3YE19rvSqLub3/6zPdJ7y6VDb7rbX34iMnUifK6/XiopaWx36mSuFiBGEVaBxCdKgyZLB9ZJZSWNoeXP7pd9H8ucGv4aEV6JiVK3bqarAGIa3YDByJzu2S4r8b9d+VnPdue+Uvo14akJAGIIYRWMwTdJrlZ8qTKnSq0YSAQAeCKsgpHaTep3g/3nDZkeeBsAQECMWQVryDTp0y3Bb5+YKl05Pnz1IHJOnpTefLOxPX261KuXuXqAGERYBStzmvvmimAN+LKUGP3vEYkJhw9L3/52Yzsvj7ACIoxuwGB1z5Qu+1Lw2w+ZFr5aACDGEFbBcrnsjUEN5pZ1AAgVwsqOzCCvljJGSp3oJgKAUCGs7Oh/o5TcOfB23u/LAgC0CWFlR/1sFoEwawUAhBRhZVegqyZmrQCAkCOs7Ao0mwWzVgBAyBFWdgWazYJZKwAg5Air1mjuPVTMWgEAYUFYtUZzt7AzawUAhAVh1RrNzWbBrBUAEBbMDdga9bNZbPuZ53pmrYhO/ftLS5d6tgFEFGEVrHeXSXHx0sTH3e3MaZ5h5W/Wik3PSnW10pfnR65OhF6/ftJ8vodRY9EiKT5eWrAg+Oc8/bRUW+t+LoygGzBYcfHSu0vcAST5zmbh/f6rTc+6t4+Lj1yNAAKLj5eefNIdQMF4+mn39vH8LpvElVWw6q+o3l3S2B40WTqwzt1uOmtFfVB9+f81Pg+AM9RfUT35pGfbn/qgWrzY3pUYQo6wssM7sDKnu8Oq6awVBBXgfMEEFkHlKI7pBpw7d64sy9LKlStNl9KyiY+7g+jdJdLpAvdsFvWzVhBUQPuxYIE7iPx1CRJUjuOIK6tRo0bp/vvvV35+vulSgtP0CqtLP/edgbEUVNXVUn6+VFHR/DadO0vXXuu7vqBAKimxd7ycHN/xgnPnpAMH7O2nd29p4EDf9Tt3SpWVzT9v3z7pe99rbP/tb9LYsfaO3d7Uf4+vvFLq3t3zsYoK6YMP7O2va1cpK8t3/f790vnzDU2X9/chOdn3OaNGSSle72c8c0Y6eNBeTX37+r/CIqgcyzK5pKWlWYWFhdbkyZOtd99911q5cmWz2yYlJVmdOnVqWI4dO2ZZlmUVFRU1bBNR7y23rIWdLWtxd/e/7y2PyGG9vy4RVVVlWTk5liW1vIwd6//5M2cGfq73sn+/VV5e7rFY69fb3893vuO/pv797e0nLy9sX96mjH2fm36P//hH38ePHLH/tb/5Zv/Huvlm+/s6csR3P3/8o/39zJvX+PzFi93rkpLc/y5eHIqvZFCM/j4b0vR8i4qKLMvyfB33txjvBszNzdVf//pXbdy4MeC28+fP14ULFxqWjIyMCFTYgomPS/FJUm2V+99ov6KS3H9t79ljugqzvP+qjzZNv8dlZdLJk2briYQFC6SkJKmqyv0vV1SOYzSsZs+erREjRmh+kO9hWbZsmTp37tywFBcXh7nCADY92xhUtVWNt7VHs5a6/mJBTo6UnW26ivBq+j2+807p8GFztUTK0083BlVVVfC3tSNijI1Z9e3bV88995xuuukmVbY0XtBEVVWVqqqqGtruq0lDvMeo6ttSbFxh1cvN9T821bmZT1ReskR65BF7x7jySt91o0dLeXn29tO7t//1f/hDy2NW9VJS3EGVmGjvuNEmPd3+175rV//rf/xjjzEr79eCZH9jVunpvusmTLBfU9++7n+9x6jq2xJXWA5ja4wpVMuMGTMsy7Ks6urqhsWyLKu2ttaqrq624uLiAu7DX19nRNSPVXmPUTW3PsS8vw4RlZdnZPzGZ8wqBhj7Phv6HluWge9z/ViV9xhVc+vDwOjvsyGBXsf9LcaurDZu3Kgsr7uDVq9erYMHD2r58uWqq6szVFkALd315++NwwCcqaW7/uy8cRgRYSysLl26pANetx5//vnnKikp8VnvGMHcnh7tgXX99dKpU43t5rp3ACcL5vZ0AstRHPE+q3bBzvuoojmwEhOlHj1MVwG0np33URFYjuGosPryl79suoTm1dXae8Nv/XZ1teGrCYB9tbX23vBbv10tv8smOSqsHK01H/MRTVdUQLRozcd8cEVlnPE3BQMAEAhXVrDn1Cnp7bcb2zffLPXsaa4eADGBsII9hw65ZzWol5dHWAEIO8IKgKe+faV58zzbgGGEFQBPV14pLVtmugrAAzdYAAAcj7ACADgeYQUAcDzCCgDgeIQVAE/btrnnf6xftm0zXRHA3YAAvNTUSGfOeLYBw7iyAgA4HmEFAHA8wgoA4HiMWcGeK65wf3hd0zYAhBlhBXuuuEJ64gnTVQCIMXQDAgAcj7ACADgeYQUAcDzCCgDgeFF3g4XL5TJdQsRVVFRE7FiurVuVdOutDe2qv/xF1pgxYT9uhw4dwn4Mp4vU99lVWankJu3KykpZETq29/e5vLw8Isd1kkj+PrcnURdWCLO6OrnKyjzaiDIJCbIuu8yjDZjGTyEAD9b116vys89MlwF4YMwKAOB4UXdlZVmW6RLCzrtPOyUlJXIHT072aiZLETi+99hFRM/ZEKPfZ4eIhXOOxZ/t1uDKCgDgeIQVAMDxoq4bEEAbHT0qvfhiY/u++6T+/c3VA4iwAuCtqEhasqSxPW0aYQXj6AYEADgeYQUAcDzCCgDgeIxZwZ6kJCkjw7MNAGFGWMGe0aOlY8dMVwEgxtANCABwPMIKAOB4hBUAwPEIKwCA43GDBez5xz+k559vbD/8sDRggLl6AMQEwgr2fPaZtHJlY/trXyOsAIQdYQXA09Ch0u9/79kGDCOsAHjq3l36+tdNVwF44AYLAIDjEVYAAMcjrAAAjseYFQBPlZXS6dON7R49pORkc/UA4soKgLedO6V+/RqXnTtNVwQQVgAA5zMaVgsXLpRlWR5LQUGByZIAAA5kfMxq//79mjJlSkO7pqbGYDUAACcyHlY1NTU6efKk6TLQVmVl0u7d9p7TrZs0bJjv+n37pNJSj1WuykrPbbwH/EeP9v3U4tOnpcJCezVdcYV78bZ1q1RbG/x+EhOl66/3XX/kiFRcHNQu6s/ZGjpUuvxyzwfLy6Vdu4KvR5Iuu0y6+mrf9d5f77177e0XiADjYTV48GAVFxeroqJCW7du1fz581VUVOR326SkJCU3eZFyuVyRKhP1hg2T/vIXz7YkFRVJ48fb29c//ZP0pz/5rv/Od6RNmzxWBbwX7bPPpN69Pddt2CDdcYe9mhYulBYt8l0/dap08WLw+0lPl44f913/s59JP/pRULuoP+eqP/xBdbfe6vlgcbH9r/ctt0h//avv+u9/X9q40d6+gAgzGlbbt2/XnDlzVFhYqN69e2vhwoXKy8tTVlaWLl265LP9/PnztcjfCwkip1s36atfNV0FIiklxXQFgNkbLNavX69XX31V+/bt09tvv61bbrlFXbt21axZs/xuv2zZMnXu3LlhKQ6yOwVAK+XkSNnZpqsAzHcDNlVaWqpDhw5p0KBBfh+vqqpSVVVVQ9uyrEiVhkD69ZPy8uw9p1s3/+tXrfIZs6r0GrNK9h6z8h7TkaQpU+zX5G+8SpLeesv+mJU/Dz4ozZgR1C4qm45ZecvIsH9ul13mf/3KlT5fb0nuK6rs7ObPBYggR4VVWlqaBg4cqJdfftl0KbArNVUaNy40+7rmGp9VVkWF54pguqZ69HAvoTBmTGj286UvuZcg+JxzUx06hPXrDTiN0W7AH/7wh5owYYL69++vMWPGaN26daqtrdXatWtNlgUAcBijV1Z9+/bV2rVrdfnll+v06dPavHmzbrjhBp05c8ZkWQAAhzEaVrfffrvJwwMA2gnmBgQAOB5hBQBwPMIKAOB4hBUAwPEIKwCA4xFWAADHI6wAAI5HWAEAHI+wAgA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7ACADgeYQUAcDzCCgDgeIQVAMDxCCsAgOMRVgAAx0swXUCouVwu0yUACBF+n1GPKysAgOMRVgAAx3NJskwX0VqVlZVKSkpSTU2NTpw4YbocAIBN6enpSkhIUFVVlZKTk5vdrl2HVXV1tRISom7YDQBiTk1NjRITE5t9vF2/0ldWVkqS6urqdOrUKSM1uFwuZWRkqLi4WJbVbnPfFs45+s851s5X4pxNnXPPnj0VFxfX8HreEoul9UunTp0sy7KsTp06Ga+Fc+acOV/OOVrPmRssAACOR1gBAByPsGqjyspKLVq0KKj+1mjBOUe/WDtfiXN2unZ9NyAAIDZwZQUAcDzCCgDgeIQVAMDxCCsAgOMRVm3w4IMP6siRIyovL9e2bdt03XXXmS4prMaPH68//elPDe92nzFjhumSwmrevHnasWOHLly4oJMnT2rdunXKzMw0XVZYPfDAA8rPz1dpaalKS0u1ZcsWTZs2zXRZETV37lxZlqWVK1eaLiVsFi5cKMuyPJaCggLTZbWIsGqlWbNmacWKFXrqqac0YsQI5efn66233lKPHj1MlxY2aWlpys/P10MPPWS6lIiYOHGicnNzdcMNN+imm25SYmKi3n77baWmppouLWyOHTumefPmaeTIkRo1apT+9re/6fXXX9ewYcNMlxYRo0aN0v3336/8/HzTpYTd/v37lZ6e3rCMGzfOdEkBGZ9Goz0u27Zts1atWtXQdrlc1rFjx6y5c+cary0Si2VZ1owZM4zXEcmle/fulmVZ1vjx443XEsmlpKTEuvvuu43XEe4lLS3NKiwstCZPnmy9++671sqVK43XFK5l4cKF1p49e4zXYWfhyqoVEhMTNXLkSG3YsKFhnWVZ2rBhg8aMGWOwMoRTly5dJElnz541XElkxMXFafbs2UpLS9PWrVtNlxN2ubm5+utf/6qNGzeaLiUiBg8erOLiYn388cd65ZVX1K9fP9Mltahdz7puSvfu3ZWQkKCTJ096rD958qSGDh1qqCqEk8vl0k9+8hNt3rxZBw4cMF1OWGVlZWnr1q1KSUnRpUuXNHPmTMePZ7TV7NmzNWLEiKgfd663fft2zZkzR4WFherdu7cWLlyovLw8ZWVl6dKlS6bL84uwAoKQm5urrKysdtGv31aFhYUaPny4unTpottuu01r1qzRxIkTozaw+vbtq+eee0433XRTu5h2KBTWr1/f8P99+/Zp+/btOnr0qGbNmqVf/vKXBitrmfG+yPa2JCYmWtXV1T5jNi+99JL1v//7v8bri8QSS2NWq1atsj799FPryiuvNF6LieWdd96xXnjhBeN1hGuZMWOGZVmWVV1d3bBYlmXV1tZa1dXVVlxcnPEaI7Hs2LHDWrp0qfE6mlsYs2qF6upq7dq1S5MnT25Y53K5NHny5Jjo248lq1at0syZM/WVr3xFn3zyielyjIiLi2vx48bbu40bNyorK0vDhw9vWHbu3Klf//rXGj58uOrq6kyXGHZpaWkaOHCgjh8/brqUFhlPzPa4zJo1yyovL7e+9a1vWUOHDrVeeOEF6+zZs1bPnj2N1xauJS0tzcrOzrays7Mty7Ks733ve1Z2drbVr18/47WFY8nNzbXOnTtnTZgwwerVq1fDkpKSYry2cC1Lly61xo8fb/Xv39/Kysqyli5datXW1lpTpkwxXlskl2i/G/CHP/yhNWHCBKt///7WmDFjrLfffts6deqU1b17d+O1tbAYL6DdLg899JD1ySefWBUVFda2bdus0aNHG68pnMvEiRMtf1avXm28tnAszbnrrruM1xau5Re/+IV15MgRq6Kiwjp58qT1zjvvxFxQSdEfVmvXrrWKi4utiooKq6ioyFq7dq01YMAA43W1tPARIQAAx2PMCgDgeIQVAMDxCCsAgOMRVgAAxyOsAACOR1gBAByPsAIAOB5hBQBwPMIKaMdWr16tdevWmS4DCDvCCgDgeIQVAMDxCCvAMJfLpccee0yHDx9WRUWFjh49qh/84AeS3J/au3HjRpWVlenMmTP6r//6L6WlpRmuGIg8wgowbNmyZZo3b56efvppDRs2THfccYdOnjyp1NRUvfXWWzp37pyuu+46ff3rX9eUKVP0/PPPmy4ZMML41O8sLLG6dOzY0SovL7fuuecen8fuvfdeq6SkxEpNTW1YN336dKumpqbhc9NWr15trVu3zvh5sLCEe+HKCjDoqquuUkpKijZu3Oj3sfz8fJWVlTWse//99xUfH68hQ4ZEskzAOMIKMKi8vNx0CUC7QFgBBh0+fFhlZWWaPHmyz2MFBQXKzs5Wampqw7qxY8eqtrZWhYWFkSwTMI6wAgyqrKzU8uXL9eyzz+rOO+/UgAEDdP311+vuu+/Wr3/9a1VUVGjNmjW6+uqrNWnSJK1atUovv/yyTp06Zbp0IKISTBcAxLqnn35aNTU1Wrx4sfr06aPjx4/rhRdeUHl5uaZOnarnnntOO3fuVFlZmf74xz/qkUceMV0yEHEuue+0AADAsegGBAA4HmEFAHA8wgoA4HiEFQDA8QgrAIDjEVYAAMcjrAAAjkdYAQAcj7ACADgeYQUAcDzCCgDgeP8fmpockxxm4gIAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -241,7 +242,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -251,7 +252,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAGwCAYAAAAXAEo1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAotElEQVR4nO3de3RU5b3/8c+EXAbCBFQgkIAo90uUO8qRWwsI9fSUhctCtbW2oqcuscse/VmIR4tKJaKrUhvisqftQaoezsWjR6seRKhywlUEDGABERUhYLiaBJPJhezfH2MymckQZpLMPE9m3q+1ngXPnj17vjsZ5sPez7P3uCQ5AgDAYkmmCwAA4GIIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPWSTRfQWllZWSovLzddBgCghTwej44dO9bsOu06rLKyslRcXGy6DABAK2VnZzcbWO06rOqPqLKzszm6AoB2yOPxqLi4+KKf4e06rOqVl5cTVgAQx5hgAQCwXlwcWTXmOPF/X16XyxXQT4R99nq9AX23222okthhn9nneBX8GRYOjqwAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWsyKs7r77bn322WeqrKzU1q1bNW7cONMlAQAsYjys5s6dq6efflqPPvqoRo8eraKiIr399tvq3r276dIAAJZwSXJMFrB161Zt375dP//5z30FuVw6cuSI8vPztWzZsmaf6/F4VFZWpoyMDJWXl0uSHMfo7sSEy+UK6CfCPnu93oC+2+02VEnssM8x3ueaGqmoSAqqoVndu0uDBzddvmuX9PXXYW2iqqpKkuRce63UoUPgPh8/Lh06FH49knTllVJ2dtPlGzeGXt/tlkaMkFJSInudVmj8GRbqczyU5FgUdiEpKSkaM2aM8vLyGpY5jqN169ZpwoQJTdZPTU1VWlpaQ9/j8cSkTgBxrqZGuuYaX8hE4oc/lF58seny+fPD3lb9J5r31CkpPT3wwddfl+66K7KafvMb6b77mi6fNOnCzxk1Stq2LaaBFSmjpwG7deum5ORklZSUBCwvKSlRz549m6yfm5ursrKyhlZcXByrUgHEs6KiyIMqnuza5fsZWMz4mFUk8vLylJGR0dCyQx3qAkCkBg+W3n9feu89qUsX09WYEcnpTwOMngY8deqUamtrlZmZGbA8MzNTX375ZZP1q6urVV1dHavyACQKj0caN04qKZHeeCP8511oItif/hTxmJVCjc9973vS8OHh1yP5xqxCKSwM7O/eLS1YENm2DTIaVjU1NdqxY4emTZum1157TZJv4G3atGlasWKFydIAJKLMTF9rrVGjwl7Vae6IplcvX2sLEye2zXYMMRpWkvT0009r1apV+uCDD/T+++/rF7/4hdLT07Vy5UrTpQEALGE8rP7zP/9T3bt312OPPaaePXvqww8/1KxZs3TixAnTpQEALGE8rCSpoKBABQUFpssAkKhKS6U9e/z9q66K/4kWHTtKgwYF9i1mRVgBgFF79gReh1RY2O7HeC5qzBjpwAHTVYStXU1dBwAkJsIKAGA9wgoAYD3CCgBgPSZYAEAi+uQT6amn/P0HHpAGDDBXz0UQVgCQiL78UvqXf/H3b73V6rDiNCAAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeswGBIDMTGn+/MA+rEJYAcDAgdIf/2i6CjSD04AAAOsRVgAA6xFWAADrEVYAAOsxwQIAdu703Ruv3gsvSKNHm6snFq66Snr33cC+xQgrAKiokP72t8B+vOvSRZo61XQVYeM0IADAenF3ZOX1ek2XEHOJsM8dO3Y0XQIMqKysjMnruKqqlNaoX1VVJSdG/66C39ux2uf2hiMrAID14u7ICgAQhnPn5Dp4sKHrDBwode5ssKDmEVYAkIBcRUVKmz69oV+1bp2c664zWFHz4i6s3G636RKiLvicNvscn4LHIhNhn10uV0A/ZvuclhbUTZMM/bwTcZ/DwZgVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHpxNxsQACJ23XVSTY2/36GDuVoQEmEFAC6XlMzHoc04DQgAsB5hBQCwHmEFALAeJ2kB4Ngx6eWX/f2bbpKysszVEwvdukk/+EFg32KEFQB8+ql0773+/ujR8R9WQ4ZIq1ebriJsnAYEAFiPsAIAWI+wAgBYj7ACAFiPsAKARPThh9K4cf724YemK2oWswEBIBGdOyd98EFg32IcWQEArEdYAQCsR1gBAKxHWAEArEdYAQCsx2xAAOjXT1qxIrAPqxg9spo0aZJef/11FRcXy3EczZ4922Q5ABJVVpa0YIG/xftNbNsho2GVnp6uoqIiLViwwGQZAADLGT0NuGbNGq1Zs8ZkCQCAdqBdjVmlpqYqLS2toe/xeAxWAwCIlXY1GzA3N1dlZWUNrbi42HRJAOJBXZ1UVeVvdXWmK0KQdhVWeXl5ysjIaGjZ2dmmSwIQDzZvltxuf9u82XRF0XfttVJpqb9de63piprVrk4DVldXq7q62nQZAND+JSdLGRmmqwhbuzqyAgAkJqNHVunp6RowYEBD/8orr9SIESN05swZHTlyxGBlAACbGA2rsWPH6r333mvoL1++XJL0/PPP66c//amhqgAAtjEaVhs2bJDL5TJZAgAkpi+/lN54w9//7nelnj3N1XMR7WqCBQCgjXzyiXTnnf5+YaHVYcUECwCA9QgrAID1CCsAgPUIKwCA9QgrAID1mA0IAJ06SVddFdiHVQgrABg9Wtq923QVaAanAQEA1iOsAADWI6wAANYjrAAA1mOCBQB8/LG0dKm//+CD0qBB5uqJhSuukJ58MrBvMcIKAE6ckFat8vfvuCP+w6p3b+mBB0xXETZOAwIArEdYAQCsR1gBAKxHWAEArEdYAUAi2rhRSk72t40bTVfULGYDAkCiOn/edAVh48gKAGC9uDuycrlcpktADFRWVpouIeo6duxougTjvF5vTF7HVVWltEb9qqoqOTF67WCJuM/h4MgKAGA9wgoAYD3CCgBgvbgbs3Icx3QJURd8TtvtdhuqJHaCxyITYZ+D8d6OonHjpM2bG7ppw4dLht5jMdvntLSgbpqxfQ5H3IUVAEQsI0OaMMF0FWgGpwEBANYjrAAA1iOsAADWY8wKAMrKpI8+8veHD/eNY8Uzt1vq3z+wbzHCCgB275YmTfL3CwuliRPN1RMLY8dKn3xiuoqwcRoQAGA9wgoAYD3CCgBgPcIKAGA9JlgAQCI6dEh6+ml//777AmcHWoawAoBEdPy49Oyz/v7NN1sdVpwGBABYj7ACAFiPsAIAWI+wAgBYj7ACAFiP2YAA0KOHdNttgX1YhbACgEGDpOefN10FmsFpQACA9QgrAID1CCsAgPUIKwCA9ZhgAQA7d0o/+Ym///zz0ujRpqqJjZwc6Z13AvsWMxpWixYt0o033qghQ4aosrJSmzdv1sKFC/Xxxx+bLAtAoqmokPbsCezHu65dpenTTVcRNqNhNWXKFBUUFGj79u1KTk7W0qVLtXbtWg0bNkwV7eXNUlMjFRVJqanS1Vc3fXzfPun06ci2OWqUlJ4euOzsWemjjyRJrqqqwMfS0kJvp1ev0HdR3r5dCt5Gc1wu6brrwl8f7V/9+9rrvfi6mZnSwIFNl+/cGfmH/pgxvvdbY8eOSZ9+Gtl2+vWTsrICl9XVSZs3h15/9+7Itg8jHFtat27dHMdxnEmTJoV8PDU11fF4PA0tKyvLcRzH8Xg8DevEVHW144wa5TiS41x3Xeh15szxPR5J27u36XbWrIl8Oz//eeia+vaNbDupqW32I2up4PdCIjC2z43f1+G0+fNDb2fYsIjfs5Xl5U5lZWVDcxzHcZ55JvL3/ooVTevxesN/fmFh9H6+QRL9ve3xeBzHCfwcD9WsmmDRpUsXSdKZM2dCPp6bm6uysrKGVlxcHMvymioqknbt8v29okIqKTFbD9AWGr+vE5XbbboCBLFmgoXL5dJvf/tbbdy4UR99c7orWF5enp5u9M2WHo/HbGA1PkWya5d08KDvlEg8O3JEevFFf/9HP5L69DFXD9peOKf+4tmoUdKIEaariL6vv/Z9W3C9/v2bDj9YxJqwKigoUE5OjiZOnHjBdaqrq1VdXR3DqtrA44/7vi46Eldc0XTZ+PFSYaEkqSpovCmtuTGrUP7rvyIfs6p3+LD04IP+/qRJhFW8KygIPR5b70L/QXvhhcjHrDp0aLrsppsin5nXr1/TZSkpDf+GLsjt9gVVSkpkr9ce7drl+/dbr7BQaubz1zQrwio/P1/f/e53NXnyZPOn9tra0KFts51LLml4IznB//ON9JTFuHFtUxPi01VXBX6oX3WV9M0p+oi0ZOp3qKO6rKymkyVaIinJ6g9jNM94WOXn52vOnDmaOnWqPv/8c9PlAOjShQ91WMdoWBUUFOiWW27R7NmzVV5ersxvTieUlpbKm+jnzQEADYzOBrz77rvVtWtXbdiwQV9++WVDmzdvnsmyAACWMXpk5Qq++A8AgBCMj1kBsEx5ubR/v78/ZIjk8ZirBxBhBSBYUVG7mtKMxGDVHSwAAAiFsAIAWI/TgK1xzTXSiRP+fteuxkoBgHhGWLVGSorUvbvpKgAg7hFWiMzAgdLKlYF9AO3PZZf57rvYuG8xwgqRycwM/PpvAO3T0KG+m1q3E0ywAABYjyOr1jhxQlq71t+//nqpRw9z9QBAnCKsWuPjj6Vbb/X3CwsJKwCIAsIKkamp8d2Op57HkxhfVAfAKMasEJlt23yzhurbtm2mKwLQEkVF0oQJ/lZUZLqiZnFkBSBQ9+7SD38Y2Ef8KS+Xtm4N7FusRWG1atUqvfvuu/q///s/ffrpp21dEwCTBg+WXnzRdBVAgBadBqyurlZubq4OHjyoL774Qi+88ILmz5+vAQMGtHV9AAC0LKzuvPNODR48WH369NEvf/lLnTt3Tvfff7/279+vI0eOtHWNAIAE16oJFmfPntXp06d19uxZffXVV6qtrdXJkyfbqjYAACS1MKwef/xxbdq0SadPn9YTTzwht9utJ554Qj179tTo0aPbukYAQIJr0QSLRYsW6eTJk3r00Uf1yiuv6ODBg21dFwBTdu2S5s/39//0J2nUKHP1AGphWI0aNUpTpkzR1KlTdf/996u6ulobNmzQe++9p/fee4/wAtqzr7/2BVbjPmBYi8Jq9+7d2r17t/Lz8yVJV199tf7pn/5JBQUFSkpKUnKyucu3vF5vzF7LVVWltEb9qqoqOTF4/Y4dOwb0Kysro/6a9Uztc5M6XK6Yv6ZpsXpvm/wdB7+3E1Ei/J5bosWpMmrUKE2dOlVTp07VxIkTlZGRod27d2vDhg1tWZ/VnD59VLN4cUAfAND2WhRWZ86cUefOnVVUVKQNGzboD3/4gwoLC1VaWtrW9dnt8st1ftEi01UAQNxrUVj96Ec/UmFhocotvz0HosDjUd348QF9AIi2FoXVW2+91fD37OxsSVJxcXHbVNRKbrfbdAkxF9N9Hj8+4Oa1ac2s2paCx+US4fccPHYRs31OSwvqpkmGft6O4xh53VgKHn+N2e958mTp9OmGbprl36DQouusXC6XHn74YX311Vc6fPiwDh8+rLNnz+qhhx5KyIFvAGh3UlKkSy/1N4uDSmrhkdXjjz+u+fPna9GiRdq0aZMkaeLEiXrkkUfkdrv10EMPtWmRAIDE1qKwuu2223THHXfoL3/5S8OyPXv2qLi4WM8++2zihNXmzdKMGf7+O+9If/d35uoBgDjVorC69NJLtX///ibL9+/fr0svvbTVRbUbdXVSRUVgHwDQ5lo0ZlVUVKR77rmnyfJ77rlHRZZ/2yRaad8+6fvf97d9+0xXBKAlSkqk55/3t5ISwwU1r0VHVg888IDeeustTZ8+XVu2bJEkTZgwQX369NENN9zQpgXCMqdPSy+/7O/fe6+5WgC03MGD0k9/6u8XFkqZmebquYiIwyo5OVmLFy/WDTfcoOuvv15Dhw6VJL3yyit69tlndfz48TYvEkAMTZggnTvn7yfAZQKwX8RhVVtbq6uvvlrHjx/Xww8/HI2aAJjUoYOUnm66CiBAi8asXnzxRc1v/BUCAABEUYvGrJKTk3X77bdr+vTp2rFjh74O+gqB+++/v02KAwBAamFY5eTkaOfOnZKkQYMGBTyWCLdHAQDEVovC6tvf/nZb1wHAFsePS6+/7u9/73tSr17m6gHUiu+zAhCnDh2S7rrL3x8+nLCCcS2aYAEAQCxxZNUaqanSN1+R0tAHALQ5wqo1xo+Xjh41XQUAxD1OAwIArMeRFSIzapTU+GbF/fubqwVAy/XtKy1dGti3GGGFyKSnS1dfbboKAK3Vp4+Um2u6irBxGhAAYD2OrFrj00+lFSv8/Xvukfr1M1cPAMQpwqo1jh2Tli/392+8kbACgCggrBCZr76SPvjA3x87Vura1VQ1ABIEY1aIzN690owZ/rZ3r+mKALTEpk1SWpq/bdpkuqJmGQ2ru+66S0VFRSotLVVpaak2b96sWbNmmSwJwJVXSr/5jb9deaXpihANjiNVV/ub5d+YYfQ04NGjR7Vo0SIdPHhQLpdLt912m1577TWNGjVKf/vb30yWhnDt3h16ea9eoa/B+uADyeuN7DUmTmy67OhR6fPPI9vOgAFSz56By2prpa1bI9tO587SyJFNl+/fL506Fdm2Ro70ba+x0lJpzx65qqoCl6elXXg7PXv69i/Yjh1SZWVkNU2cKN13X2TPAWLAsamdPn3auf3220M+lpqa6ng8noaWlZXlOI7jeDyehnViqrDQcXz/H/G1wsKYvGzwzyWmgvf5Qu3uu0M/v3//8J5f3zp0cBzHcSorKwOa8+STkW1Hcpw//KFpPaWlkW9n7NjQ+/aDH0S+rR07mm7n3Xcj384//mPomgYNinxbBhl9bxtibJ8NfX45TuA+ezwex3ECP8dDNWvGrJKSkjRv3jylp6dry5YtIdfJzc1VWVlZQysuLo5xlZDbbboCAAnIeFjl5OSovLxcVVVVeu655zRnzhzt27cv5Lp5eXnKyMhoaNmN73iO2BgxwnfLJQCIIeNT1w8cOKCRI0eqS5cuuummm7Rq1SpNmTIlZGBVV1erurraQJVokJIibdvmuz9gc2NPF/qyvn//98jHrEK5+WZpwoTInhNqTKdTJ6mwMLLtBI8x1Vu8WFqwILJtDRrUdNmoUVJhoaqCxqzSLjZmFcq//VvkY1aAhYyHVU1NjQ4dOiRJ2rlzp8aNG6d7771XdzX+plLYJSXFd31VS7T0ecF69/a11kpODj2BoyWGDGmb7XTpIk2cKCc41FtyCnbMmLapCTDM+GnAYElJSc3/DxIAkHCMHlktXbpU//u//6svvvhCHo9Ht9xyi6ZOnaqZM2eaLAsAYBmjYdWjRw/9+c9/Vq9evVRaWqrdu3dr5syZWrduncmywjdsmPTGG4F9AECbMxpWd9xxh8mXb71LL5X+/u9NVwEAcc/4BAsAgAFpaYHfDmz5XAHCCgAS0bhxkd+yzCDrZgMCABCMI6vWqKiQjhzx9/v08V1kCgBoUxxZtcbOnb4LQevbzp2mKwKAuERYAQCsx2lAAEhEhw5Jzzzj7997b+jvoLMEYQUAiej4cSk/39+fO9fqsOI0IADAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6XBTcGpdeKv3DPwT2AQBtjrBqjWHDpNdfN10FAMQ9TgMCAKzHkRUAJKLhw6U1awL7FiOsACARXXKJNHOm6SrCFndh5fV6TZcQcy6Xy3QJQFQk4r/nRNzncDBm1QquvXuVev31Dc21d6/pkgAgLsXdkVVMlZYqqbAwoA8AaHuEFQAkoq+/luvw4Yau07evlJ5usKDmxV1Yud3u2L1YWlpQN02KwetXVlYG9GO6z4YEj8s5jmOoktgJHrtIxN9zIuxzsJjt8wcfSJMm+fuFhdLEibF57RZgzAoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGC9uLuDRUyNHy8dO+bvX3aZuVoAII4RVq2Rmir16mW6CgCIe4QVACSiyy6T5swJ7FuMsAKARDR0qPTKK6arCBsTLAAA1uPIqjVOnpTWrfP3p0+Xunc3Vw8AxCnCqjUOHJBuucXfLywkrAAgCjgNCACwHmEFAIlo927fNwPXt927TVfULE4DAkAiKiuTNm0K7FuMsGqNujqpo0tKlVT9TR8A0OYIq5b48rC0aqH05Rrplx7/8le/J22ZJd22TOrZ11x9ABBnGLOK1H8sk353lVTxluQJOpLy1PmW/+4q33oAgDZBWEXiP5ZJHz3uOx51uaQkV+DjSS7f8mT51iOwAKBNEFbh+vKwVPS47+/BIRWs/vGix33PAwC0ijVhtXDhQjmOo+XLl5suJbRVC6UUXTyo6iW5fOv/eVE0qwKAhGBFWI0dO1Y/+9nPVFRUZLqU0OrqpBNvR/48R1LJGmYJAkArGQ+r9PR0vfTSS7rzzjt19uzZZtdNTU2Vx+MJaDFR/Ilv8oQrzKOqekku3/OOfRqdugAgQRgPq4KCAr355ptav379RdfNzc1VWVlZQysuLo5BhZK+Otm6558taZs6ACBBGQ2refPmafTo0crNzQ1r/by8PGVkZDS07OzsKFf4ja6tvDntJZltUwcAJChjFwX37t1bzzzzjGbMmKGqqqqwnlNdXa3q6uooVxZC9gCpPElKPx/+BAtJqnOkrztIWf2iVxsAJABjYTVmzBhlZmZq586d/mKSkzV58mTdc889SktLU50tExOSkqQeM30X/EbCJSlzlu/5AGCTa66RTpzw97t2NVZKOIyF1fr165WTkxOwbOXKldq/f7+WLVtmT1DVu22Z9Lu3pGQnvKOrOkeqlfTjJ6JeGgBELCWlXX3/nrGwOnfunD766KOAZV9//bVOnz7dZLkVevaVRvyz784UdRcJrDrH9+fIh7lHIAC0Ac5PRWLeQmn4P/uOmBzHH0r16hzf8lpJOQ9Lcx8wUSUAxB2XfJeutksej0dlZWXKyMhQeXm5JMlxYrA7xz+XcodLXZN8rV6ppF43SD95UurRJ2ov7/V6A/putztqr2ULV9A1bjH5PRvG7zkxfs+Jvs+hPsdD4StCWiLzcumKZN9RVEWd70gqWdKse6WZvzZdHQBc3IkT0tq1/v7110s9epir5yIIq9ZwuaROjf5XxKw/AO3Fxx9Lt97q7xcWWh1WfLoCAKxHWAEArEdYAQCsR1gBAKxHWAEArEdYAQCsR1gBAKxHWAEArEdYAQCsR1gBAKxHWAEArMe9AQEgEV1+ubRkSWDfYoQVACSiyy+XHnrIdBVh4zQgAMB6hBUAwHqEFQDAeoQVAMB6hBUAJKLNm6X0dH/bvNl0Rc1iNiAAJKK6OqmiIrBvsbgLK6/XG/0XcerkDrG4tva8amPw+h07dgzoV1ZWRv01beNyuUyXEHOJ+HuOyb9ny8Rqn11VVUpr1K+qqpJj8c+b04AAAOsRVgAA6xFWAADrxd2YldsdajSpFYp3SJ0zpS69/csuMBCZnNxByY1fv65O+niNNGimlNShbetqpM332ULB4zWJsM/BYxeJsM/BEmGfjb2309KCummSxT9vjqwupu689LtR0pv3S6VHw3xOnfS316XfT5K2FEQ1qAAgEcTdkVWbyx4jpWVI2/8o7fyzNPrH0nX3hl7X+SakNiyTSvb6ll3/69jVCgBxirC6mKQOvtN4H74kna/2hdaOVaHX3fqcVJcfuGzQd6JfIwDEOU4DhmPQrMB+XU3o9YKXXzZA6jYgOjUBQAIhrMLR/1tSh9TInxcccgCAFuE0YDjSPNIVE6VDf43seYQVAFulpkrZ2YF9ixFW4Rr0ncjCyt1Fuvza6NUDAK0xfrx0NMwZzhbgNGC4Bkd4lDRghtQhJTq1AECCIazC1fVyqcfw8NcfzCxAAGgrhFUkwj26cnWQBkyLbi0AkEAIq0iEO2Hi8glSx0uiWwsAJBAmWEQie4zUqZtUcar59SId3wKAWPv0U2nFCn//nnukfv3M1XMRhFUkGt/NojnctQKA7Y4dk5Yv9/dvvNHqsOI0YKQudiqQu1YAQJsjrCJ1sbtZcCEwALQ5wipS9XezuBDCCgDaHGHVEhcak+KuFQAQFYRVS1xoth93rQCAqCCsWuJCd7PgrhUAEBWEVUsFH11x1woAiBrCKlzv5kkbnvT3gydShLprxYYnfc8DAJMeeURasiSy5yxZ4nueJQircCV1kN593B9Y9XezqBd8pLXhSd/6SR1iVyMAhNKhg/SrX4UfWEuW+NbvYM/nF3ewCNeUX/r+fPdxf7/x3SwazxCsD6pv/bP/eQBgysMP+/781a8C+6HUB9VjjzW/XowZDavFixfrkaDDzP3792vo0KFmCrqY4MAaNMsXVo3vWkFQAbBRcGB961tN17E0qCQLjqz27t2r6dOnN/Rra2sNVhOGxoE16f/57mZRP35FUAGwWePAys2V3njD/9hbb0l5eVYGlWRBWNXW1qqkpMR0GZFpHFiXXOkLK4IKQHvQOLDqg2nJEquDSrIgrAYOHKji4mJ5vV5t2bJFubm5OnLkSMh1U1NTlZaW1tD3eDyxKrOpxoH14o3S+WqCCkD70Diwfv1rqbra6qCSJJckx9SLz5o1S507d9aBAwfUq1cvLV68WNnZ2crJydG5c+earB9qjEuSMjIyVF5eLklynBjvzpLuvqDqkCo9fDImL+lyuQL6Md9nA7xeb0Df7XYbqiR2EnGfeW/H+PecluYLqtRUqaoqZi/b+Pfs8XhUVlYW8DkeitGp62vWrNHLL7+sPXv2aO3atbrhhhvUtWtXzZ07N+T6eXl5ysjIaGjZ2dkxrjjIhif9QXW+OvA6LACw2ZIl/qCqro78OqwYs+o6q9LSUn388ccaMCD090FVV1ervLw8oBnTeIzq4ZO+PxtfhwUAtmo866+qyvdnJNdhGWB8zKqx9PR09e/fXy+88ILpUpoXajJFqOuwAMA2oaanR3IdliFGw+qpp57SX/7yFx0+fFhZWVl69NFHdf78ea1evdpkWc1rbtYfgQXAZs1dR2V5YBkNq969e2v16tW67LLLdPLkSW3cuFHXXnutTp06ZbKsCwtnejqBBcBG4Vzwa3FgGQ2rm2++2eTLRyaS66gILAA2ieTOFJYGllVjVlarOx/ZdVT169Wdj15NABCO8+cju46qfr3z9nx+Gb3OqrVCzc9PhOsyuBYlMa45SsR95r2deL/ndnGdFQAA4SCsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWSzZdQFtzuVymS4i5RNxnJAbe26jHkRUAwHqEFQDAenFxGtDj8ZguAQDQAuF+frfrsKrfyeLiYsOVAABaw+PxqLy8/IKPuyQ5sSun7WVlZTW7g9Hm8XhUXFys7Oxso3XEEvsc//ucaPsrsc+mP0ePHTvW7Drt+shK0kV3MFbKy8sT5g1ej32Of4m2vxL7bOr1L4YJFgAA6xFWAADrEVatVFVVpUceeURVVVWmS4kZ9jn+Jdr+Suyz7dr9BAsAQPzjyAoAYD3CCgBgPcIKAGA9wgoAYD3CqhXuvvtuffbZZ6qsrNTWrVs1btw40yVF1aRJk/T666+ruLhYjuNo9uzZpkuKqkWLFun9999XWVmZSkpK9Oqrr2rQoEGmy4qqu+66S0VFRSotLVVpaak2b96sWbNmmS4rphYuXCjHcbR8+XLTpUTN4sWL5ThOQNu3b5/psppFWLXQ3Llz9fTTT+vRRx/V6NGjVVRUpLffflvdu3c3XVrUpKenq6ioSAsWLDBdSkxMmTJFBQUFuvbaazVjxgylpKRo7dq16tSpk+nSoubo0aNatGiRxowZo7Fjx+qvf/2rXnvtNQ0bNsx0aTExduxY/exnP1NRUZHpUqJu79696tmzZ0ObOHGi6ZIuyqFF3rZu3erk5+c39F0ul3P06FFn4cKFxmuLRXMcx5k9e7bxOmLZunXr5jiO40yaNMl4LbFsp0+fdm6//XbjdUS7paenOwcOHHCmTZvmvPvuu87y5cuN1xSttnjxYmfXrl3G64ikcWTVAikpKRozZozWrVvXsMxxHK1bt04TJkwwWBmiqUuXLpKkM2fOGK4kNpKSkjRv3jylp6dry5YtpsuJuoKCAr355ptav3696VJiYuDAgSouLtahQ4f04osvqk+fPqZLala7v5GtCd26dVNycrJKSkoClpeUlGjIkCGGqkI0uVwu/fa3v9XGjRv10UcfmS4nqnJycrRlyxa53W6dO3dOc+bMsX48o7XmzZun0aNHx/24c71t27bpJz/5iQ4cOKBevXpp8eLFKiwsVE5Ojs6dO2e6vJAIKyAMBQUFysnJaRfn9VvrwIEDGjlypLp06aKbbrpJq1at0pQpU+I2sHr37q1nnnlGM2bMaBe3HWoLa9asafj7nj17tG3bNh0+fFhz587Vv/7rvxqsrHnGz0W2t5aSkuLU1NQ0GbN5/vnnnf/5n/8xXl8sWiKNWeXn5ztffPGFc8UVVxivxUR75513nOeee854HdFqs2fPdhzHcWpqahqa4zjO+fPnnZqaGicpKcl4jbFo77//vrN06VLjdVyoMWbVAjU1NdqxY4emTZvWsMzlcmnatGkJcW4/keTn52vOnDn69re/rc8//9x0OUYkJSUpLS3NdBlRs379euXk5GjkyJENbfv27XrppZc0cuRI1dXVmS4x6tLT09W/f38dP37cdCnNMp6Y7bHNnTvXqaysdH784x87Q4YMcZ577jnnzJkzTo8ePYzXFq2Wnp7ujBgxwhkxYoTjOI7zi1/8whkxYoTTp08f47VFoxUUFDhnz551Jk+e7GRmZjY0t9ttvLZotaVLlzqTJk1y+vbt6+Tk5DhLly51zp8/70yfPt14bbFs8T4b8KmnnnImT57s9O3b15kwYYKzdu1a58SJE063bt2M19ZMM15Au20LFixwPv/8c8fr9Tpbt251xo8fb7ymaLYpU6Y4oaxcudJ4bdFoF3LbbbcZry1a7Y9//KPz2WefOV6v1ykpKXHeeeedhAsqKf7DavXq1U5xcbHj9XqdI0eOOKtXr3b69etnvK7mGl8RAgCwHmNWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVkA7tnLlSr366qumywCijrACAFiPsAIAWI+wAgxzuVx64IEHdPDgQXm9Xh0+fFgPPvigJN+39q5fv14VFRU6deqUfv/73ys9Pd1wxUDsEVaAYXl5eVq0aJGWLFmiYcOG6ZZbblFJSYk6deqkt99+W2fPntW4ceP0/e9/X9OnT9eKFStMlwwYYfzW7zRaorbOnTs7lZWVzvz585s8dscddzinT592OnXq1LDsO9/5jlNbW9vwvWkrV650Xn31VeP7QaNFu3FkBRg0dOhQud1urV+/PuRjRUVFqqioaFi2adMmdejQQYMHD45lmYBxhBVgUGVlpekSgHaBsAIMOnjwoCoqKjRt2rQmj+3bt08jRoxQp06dGpZdd911On/+vA4cOBDLMgHjCCvAoKqqKi1btkxPPvmkbr31VvXr10/XXHONbr/9dr300kvyer1atWqVhg8frqlTpyo/P18vvPCCTpw4Ybp0IKaSTRcAJLolS5aotrZWjz32mLKysnT8+HE999xzqqys1MyZM/XMM89o+/btqqio0H//93/rvvvuM10yEHMu+WZaAABgLU4DAgCsR1gBAKxHWAEArEdYAQCsR1gBAKxHWAEArEdYAQCsR1gBAKxHWAEArEdYAQCsR1gBAKz3/wEbeI2txIJN5QAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -261,7 +262,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/plot_attention.ipynb b/notebooks/plot_attention.ipynb index 8f94d0a6..ee76a414 100644 --- a/notebooks/plot_attention.ipynb +++ b/notebooks/plot_attention.ipynb @@ -33,7 +33,7 @@ "from muutils.mlutils import pprint_summary\n", "from maze_transformer.training.config import ConfigHolder, ZanjHookedTransformer\n", "from maze_dataset import MazeDataset, MazeDatasetConfig\n", - "from maze_transformer.evaluation.plot_attention import ProcessedMazeAttention\n", + "from maze_transformer.mechinterp.plot_attention import ProcessedMazeAttention\n", "\n" ] }, @@ -53,8 +53,25 @@ "text": [ "will try to get model from ../examples/multsrc_demo-g6-n10K-a_dfs-h92077_tiny-v1_sweep-v1_2023-05-20-21-30-02/model.final.zanj\n", "loaded model: multsrc_demo-g6-n10K-a_dfs-h92077_tiny-v1_sweep-v1 with 70319 parameters\n", - "loading dataset from ../data/demo-g6-n100-a_dfs-h53577.zanj\n", - "Got dataset demo with 100 items. output.cfg.to_fname() = 'demo-g6-n100-a_dfs-h53577'\n", + "trying to get the dataset 'demo-g6-n100-a_dfs-h10871'\n", + "seeing if we can download the dataset...\n", + "no download found, or download failed\n", + "generating dataset...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "generating & solving mazes: 100%|██████████| 100/100 [00:00<00:00, 224.10maze/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saving dataset to ..\\data\\demo-g6-n100-a_dfs-h10871.zanj\n", + "Got dataset demo with 100 items. output.cfg.to_fname() = 'demo-g6-n100-a_dfs-h10871'\n", "got test dataset: demo with 100 mazes\n", "{\n", " \"name\": \"tiny-v1\",\n", @@ -133,7 +150,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -172,18 +189,18 @@ { "data": { "text/html": [ - "
\n", + "
\n", " " ], "text/plain": [ - "" + "" ] }, "execution_count": 4, diff --git a/notebooks/residual_stream_decoding.ipynb b/notebooks/residual_stream_decoding.ipynb new file mode 100644 index 00000000..d4e94cdd --- /dev/null +++ b/notebooks/residual_stream_decoding.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook, we want to:\n", + "\n", + "- investigate the spatial structure of the residual stream\n", + "- see which tokens the different directions in the residual stream map to" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# setup\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\mivan\\AppData\\Local\\pypoetry\\Cache\\virtualenvs\\maze-transformer-2cGx2R0F-py3.10\\lib\\site-packages\\_distutils_hack\\__init__.py:33: UserWarning: Setuptools is replacing distutils.\n", + " warnings.warn(\"Setuptools is replacing distutils.\")\n" + ] + } + ], + "source": [ + "# Generic\n", + "import os\n", + "from pathlib import Path\n", + "from copy import deepcopy\n", + "import typing\n", + "import itertools\n", + "from collections import Counter\n", + "\n", + "# Numerical Computing\n", + "import numpy as np\n", + "import torch\n", + "import pandas as pd\n", + "# import torch.nn.functional as F\n", + "from fancy_einsum import einsum\n", + "import einops\n", + "from jaxtyping import Float, Int, Bool\n", + "\n", + "# scipy\n", + "from scipy.spatial.distance import pdist, squareform\n", + "from scipy.spatial.distance import euclidean\n", + "from scipy.stats import pearsonr\n", + "# from scipy.spatial.distance import cosine\n", + "\n", + "# plotting\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import ipywidgets\n", + "\n", + "\n", + "# muutils\n", + "from muutils.misc import shorten_numerical_to_str\n", + "from muutils.nbutils.configure_notebook import configure_notebook\n", + "# TransformerLens imports\n", + "from transformer_lens import HookedTransformer, ActivationCache\n", + "\n", + "# Our Code\n", + "from maze_dataset import MazeDataset, MazeDatasetConfig, SolvedMaze, LatticeMaze, SPECIAL_TOKENS\n", + "from maze_dataset.tokenization import MazeTokenizer, TokenizationMode\n", + "from maze_dataset.plotting.print_tokens import color_maze_tokens_AOTP\n", + "from maze_dataset.tokenization.token_utils import strings_to_coords, coords_to_strings\n", + "from maze_dataset.constants import _SPECIAL_TOKENS_ABBREVIATIONS\n", + "\n", + "from maze_transformer.training.config import ConfigHolder, ZanjHookedTransformer, BaseGPTConfig\n", + "from maze_transformer.utils.dict_shapes import string_dict_shapes\n", + "from maze_transformer.mechinterp.plot_weights import plot_embeddings\n", + "from maze_transformer.mechinterp.residual_stream_structure import (\n", + " TokenPlottingInfo, process_tokens_for_pca, EmbeddingsPCAResult, compute_pca, plot_pca_colored, \n", + " compute_distances_and_correlation, compute_grid_distances,\n", + " plot_distances_matrix, plot_distance_grid, plot_distance_correlation,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEVICE = device(type='cpu')\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Setup (we won't be training any models)\n", + "DEVICE: torch.device = configure_notebook(seed=42, dark_mode=False)\n", + "print(f\"{DEVICE = }\")\n", + "torch.set_grad_enabled(False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.tokenization_mode = \n", + "self.tokenization_mode = \n", + "loaded model with 1.3M params (num_params = 1274699) from\n", + "../examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\n" + ] + } + ], + "source": [ + "# path to load the model from\n", + "MODEL_PATH: str = \"../examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\"\n", + "# load the model and tokenizer\n", + "MODEL: ZanjHookedTransformer = ZanjHookedTransformer.read(MODEL_PATH)\n", + "num_params: int = MODEL.num_params()\n", + "print(f\"loaded model with {shorten_numerical_to_str(num_params)} params ({num_params = }) from\\n{MODEL_PATH}\")\n", + "TOKENIZER: MazeTokenizer = MODEL.zanj_model_config.maze_tokenizer" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TOKENIZER.token_arr = ['', '', '', '', '', '', '', '', '<-->', ';', '', '(0,0)', '(0,1)', '(1,0)', '(1,1)', '(0,2)', '(2,0)', '(1,2)', '(2,1)', '(2,2)', '(0,3)', '(3,0)', '(3,1)', '(2,3)', '(3,2)', '(1,3)', '(3,3)', '(0,4)', '(2,4)', '(4,0)', '(1,4)', '(4,1)', '(4,2)', '(3,4)', '(4,3)', '(4,4)', '(0,5)', '(5,0)', '(5,1)', '(2,5)', '(5,2)', '(5,3)', '(4,5)', '(5,4)', '(1,5)', '(3,5)', '(5,5)', '(0,6)', '(2,6)', '(4,6)', '(6,0)', '(1,6)', '(6,1)', '(6,2)', '(3,6)', '(6,3)', '(6,4)', '(5,6)', '(6,5)', '(6,6)', '(0,7)', '(7,0)', '(7,1)', '(2,7)', '(7,2)', '(7,3)', '(4,7)', '(7,4)', '(7,5)', '(6,7)', '(7,6)', '(1,7)', '(3,7)', '(5,7)', '(7,7)']\n", + "MODEL.W_E.shape = torch.Size([75, 128])\n", + "COORDINATE_TOKENS_INFO = {'(0,0)': (0, 0), '(0,1)': (0, 1), '(1,0)': (1, 0), '(1,1)': (1, 1), '(0,2)': (0, 2), '(2,0)': (2, 0), '(1,2)': (1, 2), '(2,1)': (2, 1), '(2,2)': (2, 2), '(0,3)': (0, 3), '(3,0)': (3, 0), '(3,1)': (3, 1), '(2,3)': (2, 3), '(3,2)': (3, 2), '(1,3)': (1, 3), '(3,3)': (3, 3), '(0,4)': (0, 4), '(2,4)': (2, 4), '(4,0)': (4, 0), '(1,4)': (1, 4), '(4,1)': (4, 1), '(4,2)': (4, 2), '(3,4)': (3, 4), '(4,3)': (4, 3), '(4,4)': (4, 4), '(0,5)': (0, 5), '(5,0)': (5, 0), '(5,1)': (5, 1), '(2,5)': (2, 5), '(5,2)': (5, 2), '(5,3)': (5, 3), '(4,5)': (4, 5), '(5,4)': (5, 4), '(1,5)': (1, 5), '(3,5)': (3, 5), '(5,5)': (5, 5), '(0,6)': (0, 6), '(2,6)': (2, 6), '(4,6)': (4, 6), '(6,0)': (6, 0), '(1,6)': (1, 6), '(6,1)': (6, 1), '(6,2)': (6, 2), '(3,6)': (3, 6), '(6,3)': (6, 3), '(6,4)': (6, 4), '(5,6)': (5, 6), '(6,5)': (6, 5), '(6,6)': (6, 6), '(0,7)': (0, 7), '(7,0)': (7, 0), '(7,1)': (7, 1), '(2,7)': (2, 7), '(7,2)': (7, 2), '(7,3)': (7, 3), '(4,7)': (4, 7), '(7,4)': (7, 4), '(7,5)': (7, 5), '(6,7)': (6, 7), '(7,6)': (7, 6), '(1,7)': (1, 7), '(3,7)': (3, 7), '(5,7)': (5, 7), '(7,7)': (7, 7)}\n" + ] + } + ], + "source": [ + "# get tokenizer and embedding info\n", + "print(f\"{TOKENIZER.token_arr = }\")\n", + "d_model: int = MODEL.config.d_model\n", + "print(f\"{MODEL.W_E.shape = }\")\n", + "assert MODEL.W_E.shape == (TOKENIZER.vocab_size, d_model)\n", + "VOCAB_TOKENS: Int[torch.Tensor, \"vocab_size\"] = torch.arange(TOKENIZER.vocab_size, device=DEVICE)\n", + "assert VOCAB_TOKENS.tolist() == TOKENIZER.encode(TOKENIZER.token_arr)\n", + "\n", + "# maps token to (index, coordinate)\n", + "COORDINATE_TOKENS_INFO: dict[str, (int, tuple[int,int])] = {\n", + " tok: coord\n", + " for idx, (tok, coord) in enumerate(zip(TOKENIZER.token_arr, TOKENIZER.strings_to_coords(TOKENIZER.token_arr, when_noncoord=\"include\")))\n", + " if not isinstance(coord, str)\n", + "}\n", + "print(f\"{COORDINATE_TOKENS_INFO = }\")\n", + "\n", + "# information for how to plot the tokens\n", + "VOCAB_PLOT_INFO: list[TokenPlottingInfo] = process_tokens_for_pca(TOKENIZER)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PCA of token embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the PCA\n", + "PCA_RESULTS: dict[str, EmbeddingsPCAResult] = compute_pca(\n", + " model=MODEL,\n", + " token_plotting_info=VOCAB_PLOT_INFO,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "781814d652c9484bac5d4784f8dba66f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(Dropdown(description='PCA Results:', options=('all', 'coords_only', 'special_only'), val…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ipywidgets.interact(\n", + " plot_pca_colored, \n", + " pca_results_options=ipywidgets.fixed(PCA_RESULTS),\n", + " pca_results_key=ipywidgets.Dropdown(\n", + " options=list(PCA_RESULTS.keys()),\n", + " value='all',\n", + " description='PCA Results:',\n", + " ),\n", + " vocab_colors=ipywidgets.fixed(VOCAB_PLOT_INFO), \n", + " dim1=ipywidgets.IntText(\n", + " value=1,\n", + " description='Dim 1:',\n", + " ),\n", + " dim2=ipywidgets.IntText(\n", + " value=2,\n", + " description='Dim 1:',\n", + " ),\n", + " lattice_connections=ipywidgets.Dropdown(\n", + " options=[True, False],\n", + " value=True,\n", + " description='Show Lattice:',\n", + " ),\n", + " # float or None (entry box of float or text)\n", + " symlog_scale=ipywidgets.FloatText(\n", + " value=-1,\n", + " description='Symlog Scale:',\n", + " ),\n", + " axes_and_centered=ipywidgets.Dropdown(\n", + " options=[True, False],\n", + " value=True,\n", + " description='Center and show axes:',\n", + " ),\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# possible distance functions:\n", + "\"\"\"\n", + "'braycurtis', 'canberra', 'chebyshev', 'cityblock',\n", + "'correlation', 'cosine', 'dice', 'euclidean', 'hamming',\n", + "'jaccard', 'jensenshannon', 'kulczynski1',\n", + "'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto',\n", + "'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath',\n", + "'sqeuclidean', 'yule'\n", + "\"\"\"\n", + "\n", + "MODEL_EMBEDDING_MATRIX: Float[np.ndarray, \"d_vocab d_model\"] = MODEL.W_E.detach().cpu().numpy()\n", + "\n", + "distances_result: dict = compute_distances_and_correlation(\n", + " embedding_matrix=MODEL_EMBEDDING_MATRIX,\n", + " tokenizer=TOKENIZER,\n", + " embedding_metric=\"cosine\",\n", + " coordinate_metric=\"cityblock\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation between embedding (via cosine) and coordinate (via cityblock) distances:\n", + "0.378 (p=0.000)\n" + ] + } + ], + "source": [ + "# print info about 'correlation', 'corr_pval', 'tokenizer', 'embedding_metric', 'coordinate_metric'\n", + "print(\n", + " f\"\"\"Correlation between embedding (via {distances_result['embedding_metric']}) and coordinate (via {distances_result['coordinate_metric']}) distances:\n", + "{distances_result['correlation']:.3f} (p={distances_result['corr_pval']:.3f})\"\"\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAASlCAYAAADJbo48AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxV1f4//tc5DIdJJplEJgVNcQIxFecpQMnwVlZmKkZqg7dr3WuFldpgfrv6qdRSM03rOpSZZSk5ZSrmUA5oggMqg4E4AIIyCmf9/vDHyRMcYK8N4aHX8/HYjzp7r/d+r732cDbLfdbWCCEEiIiIiIiIiIjIbGibugJERERERERERKQMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiCTt3bsXI0eOhLe3NzQaDb799ts6Y3bv3o3u3btDp9MhKCgIq1atUpyXHTpERERERERERJKKiorQrVs3fPTRR/Uqn5aWhujoaAwePBhJSUmYNm0annrqKWzbtk1RXo0QQshUmIiIiIiIiIiI/qDRaPDNN99g1KhRJsu8/PLL2LJlC06ePGmY99hjj+H69evYunVrvXPxCR0iIiIiIiIior/IgQMHMGzYMKN5kZGROHDggKL1WDZkpYiIiIiIiIio+SotLUV5eXlTV6PRCSGg0WiM5ul0Ouh0OtXrzsnJgaenp9E8T09PFBYWoqSkBLa2tvVaDzt0iIiIiIiIiKhOpaWlaOPvgJwrlU1dlUbn4OCAmzdvGs2bNWsWZs+e3TQVqgE7dIiIiIiIiIioTuXl5ci5UomMIwFwbNF8R3ApvKGHf1g6Ll68CEdHR8P8hng6BwC8vLxw+fJlo3mXL1+Go6NjvZ/OAdihQ0REREREREQKOLbQwrGFRVNXo9E5Ojoadeg0lPDwcCQkJBjN27FjB8LDwxWtp/l2qRERERERERERNbKbN28iKSkJSUlJAG6/ljwpKQmZmZkAgPj4eIwfP95Q/umnn8aFCxfw0ksv4fTp01i8eDHWr1+PF154QVFePqFDRERERERERPWmh4Ae+qauRqPRQygqf/jwYQwePNjw+cUXXwQATJgwAatWrcKlS5cMnTsA0KZNG2zZsgUvvPACFixYAB8fHyxfvhyRkZGK8mqEEMpqSkRERERERER/O4WFhXByckLu2TbNfgydlu3TUFBQ0Cg/uWoozXcPEBERERERERE1U+zQISIiIiIiIiIyM+zQISIiIiIiIiIyMxwUmYiIiIiIiIjqrVLoUdmMR+OtFOYx4DOf0CEiIiIiIiIiMjPs0CEiIiIiIiIiMjPs0CEiIiIiIiIiMjMcQ4eIiIiIiIiI6k0PAT2a7yA65rJtfEKHiIiIiIiIiMjMsEOHiIiIiIiIiMjMsEOHiIiIiIiIiMjMsEOHiIiIiIiIiMjMcFBkIiIiIiIiIqo3PfTQN3UlGpG5bB2f0CEiIiIiIiIiMjPs0CEiIiIiIiIiMjPs0CEiIiIiIiIiMjMcQ4eIiIiIiIiI6q1SCFQK0dTVaDTmsm18QoeIiIiIiIiIyMywQ4eIiIiIiIiIyMywQ4eIiIiIiIiIyMywQ4eIiIiIiIiIyMxwUGQiIiIiIiIiqjc9BPQwj4GDZZjLtvEJHSIiIiIiIiIiM8MOHSIiIiIiIiIiM8MOHSIiIiIiIiIiM8MxdIiIiIiIiIio3vQQqDSTcWZkcAwdIiIiIiIiIiJqFOzQISIiIiIiIiIyM+zQISIiIiIiIiIyM+zQISIiIiIiIiIyMxwUmYiIiIiIiIjqTQ9hNgMHyzCXbeMTOkREREREREREZoYdOkREREREREREZoYdOkREREREREREZoZj6BARERERERFRvVUKgUphHuPMyDCXbeMTOkREREREREREZoYdOkREREREREREZoYdOkREREREREREZoYdOkREREREREREZoaDIhMRERERERFRven//6m5Mpdt4xM6RERERERERERmhh06RESSVq1aBY1Gg/T09KauSr0EBAQgNja2qatBdFcYNGgQBg0aZPicnp4OjUaDVatWNVmdzEHVde/w4cONnis2NhYBAQF1lqtp382ePRsajabxKkdERHQXYIcOEZEZGjRoEDQaDTQaDbRaLRwdHXHPPfdg3Lhx2LFjR4PlSUhIwOzZsxtsfeagql2rJnt7ewQHB+Ptt99GcXGx1Dr379+P2bNn4/r16w1b2btMaWkp3n//ffTq1QtOTk6wsbFB+/btMXXqVJw9e7apq3dXeOedd/Dtt982+HoDAgKqHbtVU1RUVIPnIyIioqbHMXSIiCSNGzcOjz32GHQ6XZPk9/Hxwdy5cwEARUVFOHfuHDZu3IjVq1fjkUcewerVq2FlZWUof+bMGWi1yvrxExIS8NFHH/3tOnXuu+8+jB8/HgBw8+ZNJCYm4vXXX8fx48fx1VdfKV7f/v378cYbbyA2NhbOzs4NXNu7w7Vr1xAVFYUjR47g/vvvx+OPPw4HBwecOXMGX3zxBZYtW4by8vKmrqZJ/v7+KCkpMTpnGsM777yDhx9+GKNGjWrwdYeEhODf//53tfne3t4Nnutu99prr+GVV15p6moQETVblRCohGjqajQac9k2dugQEUmysLCAhYVFk+V3cnLCE088YTTv//2//4fnn38eixcvRkBAAN59913DsqbqeDJH7du3N2rbp59+GuXl5di4cSNKS0thY2PThLW7O8XGxuLYsWPYsGEDHnroIaNlb731Fl599dW/tD5FRUWwt7evd3mNRmP2+7V169bVrgl/V5aWlrC05G0uERE1b/zJFRE1K1lZWYiLi4O3tzd0Oh3atGmDZ555xujJgAsXLmD06NFwdXWFnZ0devfujS1btlRb16JFi9CpUyfY2dnBxcUFPXr0wNq1aw3LaxpDJyAgAPfffz/27duHnj17wsbGBm3btsXnn39ebf3Xr1/HtGnT4OvrC51Oh6CgILz77rvQ6+XH1bewsMDChQsRHByMDz/8EAUFBUZ1u3MMnVu3buGNN95Au3btYGNjg5YtW6Jfv36Gn2zFxsbio48+AmD8M6Qq8+fPR58+fdCyZUvY2toiLCwMGzZsqFYnjUaDqVOn4ttvv0Xnzp2h0+nQqVMnbN26tVrZ+uy/+rbbF198gbCwMLRo0QKOjo7o0qULFixYINewALy8vKDRaKr9kXjo0CFERUXByckJdnZ2GDhwIH7++WfD8tmzZ2P69OkAgDZt2hjaMT09HQ8++CC6d+9utL6RI0dCo9Hgu+++M8qh0Wjwww8/KG4HvV6PDz74AJ06dYKNjQ08PT0xZcoU5OfnG5VTcuz+2aFDh7BlyxbExcVV68wBbncmzp8/32jerl270L9/f9jb28PZ2RkxMTE4depUtdhjx45h+PDhcHR0hIODA4YOHYqDBw8alak6F/fs2YNnn30WHh4e8PHxMSxftmwZAgMDYWtri549eyIxMbFanprGYYmNjYWDgwOysrIwatQoODg4wN3dHf/5z39QWVlpFF+f80Gj0aCoqAifffaZ4Ti485zMysrCk08+CU9PT8N58umnn1ZvcBWqtikzMxP3338/HBwc0Lp1a8O5/ttvv2HIkCGwt7eHv7+/0TXvTsXFxZgyZQpatmwJR0dHjB8/vtoxBQA//PCDYT+3aNEC0dHRSE5Orlau6vpgY2ODzp0745tvvqkx7/Xr1xEbGwsnJyc4OztjwoQJNf6UsaYxdJRci3bv3o0ePXrAxsYGgYGB+Pjjj2tc544dO9CvXz84OzvDwcEB99xzD2bMmFFj3YmIiBoa/+mCiJqN7Oxs9OzZE9evX8fkyZPRoUMHZGVlYcOGDSguLoa1tTUuX76MPn36oLi4GM8//zxatmyJzz77DA888AA2bNiAf/zjHwCATz75BM8//zwefvhh/Otf/0JpaSlOnDiBQ4cO4fHHH6+1HufOncPDDz+MuLg4TJgwAZ9++iliY2MRFhaGTp06Abj9x9DAgQORlZWFKVOmwM/PD/v370d8fDwuXbqEDz74QLodLCwsMGbMGLz++uvYt28foqOjayw3e/ZszJ07F0899RR69uyJwsJCHD58GEePHsV9992HKVOmIDs7Gzt27MD//ve/avELFizAAw88gLFjx6K8vBxffPEFRo8ejc2bN1fLuW/fPmzcuBHPPvssWrRogYULF+Khhx5CZmYmWrZsCaB++6++7bZjxw6MGTMGQ4cONTyldOrUKfz888/417/+VWcblpaW4tq1awBuP+nx888/47PPPsPjjz9u1KGza9cuDB8+HGFhYZg1axa0Wi1WrlyJIUOGIDExET179sSDDz6Is2fPYt26dXj//ffh5uYGAHB3d0f//v2xadMmFBYWwtHREUII/Pzzz9BqtUhMTMQDDzwAAEhMTIRWq0Xfvn0BKDt+pkyZglWrVmHixIl4/vnnkZaWhg8//BDHjh3Dzz//bPQTo/ocuzWp6nwaN25cnW0LADt37sTw4cPRtm1bzJ49GyUlJVi0aBH69u2Lo0ePGgbCTU5ORv/+/eHo6IiXXnoJVlZW+PjjjzFo0CDs2bMHvXr1Mlrvs88+C3d3d8ycORNFRUUAgBUrVmDKlCno06cPpk2bhgsXLuCBBx6Aq6srfH1966xrZWUlIiMj0atXL8yfPx87d+7E//3f/yEwMBDPPPOMoVx9zof//e9/hvNt8uTJAIDAwEAAwOXLl9G7d29Dp4O7uzt++OEHxMXFobCwENOmTauzrrdu3TIct3eyt7eHra2t0TYNHz4cAwYMwH//+1+sWbMGU6dOhb29PV599VWMHTsWDz74IJYuXYrx48cjPDwcbdq0MVrn1KlT4ezsjNmzZ+PMmTNYsmQJMjIysHv3bkOnx//+9z9MmDABkZGRePfdd1FcXIwlS5agX79+OHbsmGE/b9++HQ899BCCg4Mxd+5c5ObmYuLEiUadcgAghEBMTAz27duHp59+Gh07dsQ333yDCRMm1Nk2VepzLTp27BiioqLQqlUrvPHGG6isrMSbb74Jd3d3o3UlJyfj/vvvR9euXfHmm29Cp9Ph3LlzRh26REREjUoQETUT48ePF1qtVvz666/Vlun1eiGEENOmTRMARGJiomHZjRs3RJs2bURAQICorKwUQggRExMjOnXqVGu+lStXCgAiLS3NMM/f318AEHv37jXMu3LlitDpdOLf//63Yd5bb70l7O3txdmzZ43W+corrwgLCwuRmZlZa+6BAwfWWr9vvvlGABALFiwwqtuECRMMn7t16yaio6NrzfPcc88JU18VxcXFRp/Ly8tF586dxZAhQ4zmAxDW1tbi3LlzhnnHjx8XAMSiRYsM8+qz/+rbbv/617+Eo6OjqKioqHX7agKgxmnUqFGitLTUqE7t2rUTkZGRhvoJcbtd2rRpI+677z7DvHnz5lU7VoQQ4tdffxUAREJCghBCiBMnTggAYvTo0aJXr16Gcg888IAIDQ01fK5vOyQmJgoAYs2aNUbltm7dWm1+fY/dmvzjH/8QAER+fn6t5aqEhIQIDw8PkZuba5h3/PhxodVqxfjx4w3zRo0aJaytrcX58+cN87Kzs0WLFi3EgAEDDPOqzsV+/foZ7fPy8nLh4eEhQkJCRFlZmWH+smXLBAAxcOBAw7y0tDQBQKxcudIwb8KECQKAePPNN43qHxoaKsLCwozm1fd8sLe3NzoPq8TFxYlWrVqJa9euGc1/7LHHhJOTU7X1/1nV/qtpmjt3brVteueddwzz8vPzha2trdBoNOKLL74wzD99+rQAIGbNmmWYV9XWYWFhory83DD/v//9rwAgNm3aJIS4fV11dnYWkyZNMqpnTk6OcHJyMpofEhIiWrVqJa5fv26Yt337dgFA+Pv7G+Z9++23AoD473//a5hXUVEh+vfvX23fzZo1q9q1q77XopEjRwo7OzuRlZVlmJeamiosLS2N1vn+++8LAOLq1auCiOjvoqCgQAAQyac8RObvXs12Sj7lIQCIgoKCpm7yWvEnV0TULOj1enz77bcYOXIkevToUW151b8YJyQkoGfPnujXr59hmYODAyZPnoz09HSkpKQAAJydnfH777/j119/VVyX4OBg9O/f3/DZ3d0d99xzDy5cuGCY99VXX6F///5wcXHBtWvXDNOwYcNQWVmJvXv3Ks57JwcHBwDAjRs3TJZxdnZGcnIyUlNTpXLc+S/++fn5KCgoQP/+/XH06NFqZYcNG2Z4EgEAunbtCkdHR0Ob1Hf/1bfdnJ2dUVRUJP3Gr5iYGOzYsQM7duzApk2bEB8fj61bt+Lxxx+HELcHyUtKSkJqaioef/xx5ObmGupSVFSEoUOHYu/evXX+fC40NBQODg6GeicmJsLHxwfjx4/H0aNHUVxcDCEE9u3bZ3RM1bcdvvrqKzg5OeG+++4zKhcWFgYHBwf89NNPRvWpz7Fbk8LCQgBAixYt6mzbS5cuISkpCbGxsXB1dTXM79q1K+677z4kJCQAuP0Uyfbt2zFq1Ci0bdvWUK5Vq1Z4/PHHsW/fPkPeKpMmTTIa1+rw4cO4cuUKnn76aVhbWxvmV/1kp76efvppo8/9+/ev1iZKzoc/E0Lg66+/xsiRIyGEMNpXkZGRKCgoqNd6evXqZThu75zGjBlTrexTTz1l+H9nZ2fcc889sLe3xyOPPGKYf88998DZ2bnG/T958mSjp7ueeeYZWFpaGvbfjh07cP36dYwZM8ZoeywsLNCrVy/DsVd1PEyYMMFon9x3330IDg42ypmQkABLS0ujJ6MsLCzwz3/+s862qVLXtaiyshI7d+7EqFGjjAaTDgoKwvDhw43WVTXA+aZNm1T9VJaIyBxViuY/mQP+5IqImoWrV6+isLAQnTt3rrVcRkZGtZ9pAEDHjh0Nyzt37oyXX34ZO3fuRM+ePREUFISIiAg8/vjjhp+81MbPz6/aPBcXF6PxJVJTU3HixIlqj/BXuXLlSp15anPz5k0Atf+B/eabbyImJgbt27dH586dERUVhXHjxqFr1671yrF582a8/fbbSEpKQllZmWH+n8eYAOpuk/ruv/q227PPPov169dj+PDhaN26NSIiIvDII4/U+/XNPj4+GDZsmOHzAw88gJYtW+I///kPNm/ejJEjRxo6wmr7uUdBQQFcXFxMLrewsEB4eLhhTJfExET0798f/fr1Q2VlJQ4ePAhPT0/k5eUZdbTUtx1SU1NRUFAADw+PWstVqc+xWxNHR0cAtzsQ63qLV0ZGBoDbnQV/1rFjR2zbtg1FRUW4ceMGiouLTZbT6/W4ePGi0U/B/vyzoKpc7dq1M5pvZWVl1ElUGxsbm2rtXFObKDkf/uzq1au4fv06li1bhmXLltVYpj7XBDc3N6Pj1pSatsnJyQk+Pj7V6uvk5FTj/v9zmzo4OKBVq1aGMcWqzo8hQ4bUWIeqY8bUPgJuHyN3dmRlZGSgVatWhg7rO8vVV13H+JUrV1BSUoKgoKBq5f4879FHH8Xy5cvx1FNP4ZVXXsHQoUPx4IMP4uGHH1b8RkEiIiIZ7NAhIqpBx44dcebMGWzevBlbt27F119/jcWLF2PmzJl44403ao019earqic7gNtPpNx333146aWXaizbvn17+coDOHnyJIDqf4DcacCAATh//jw2bdqE7du3Y/ny5Xj//fexdOlSo3+9r0nV+C4DBgzA4sWL0apVK1hZWWHlypU1DqJanzapj/q2m4eHB5KSkrBt2zb88MMP+OGHH7By5UqMHz8en332maKcVYYOHQoA2Lt3L0aOHGn4F/l58+YhJCSkxpg//+FZk379+mHOnDkoLS1FYmIiXn31VTg7O6Nz585ITEyEp6cnABh16NS3HfR6PTw8PLBmzZoay/35j3rZ/dShQwcAtwfUvbOef7U7n5JpKPV5k53S8+HPqo6lJ554wmQHYX07WuvD1DY11HkK/LFN//vf/+Dl5VVteVO9gaoht9HW1hZ79+7FTz/9hC1btmDr1q348ssvMWTIEGzfvr1J34JIRER/D+zQIaJmwd3dHY6OjoaODFP8/f1x5syZavNPnz5tWF7F3t4ejz76KB599FGUl5fjwQcfxJw5cxAfH6/69caBgYG4efNmvf41XanKykqsXbsWdnZ2Rj8tq4mrqysmTpyIiRMn4ubNmxgwYABmz55t6NAx9XTB119/DRsbG2zbts3odegrV66UqnN995+SdrO2tsbIkSMNnS/PPvssPv74Y7z++uu1dnSZUlFRAeCPp5+qfrbh6OhYZ31qe0qjf//+KC8vx7p165CVlWXoEBkwYIChQ6d9+/aGjp2q3PVph8DAQOzcuRN9+/ZtlM6OKiNHjsTcuXOxevXqOjt0qs4xU+ehm5sb7O3tYWNjAzs7O5PltFptnYMaV+VKTU01elLk1q1bSEtLQ7du3erctvpQcj7UdCy4u7ujRYsWqKysbJRrQmNITU3F4MGDDZ9v3ryJS5cuYcSIEQD+OD88PDxq3aY799Gf/Xnf+/v748cff8TNmzeNOktrOkZkeXh4wMbGBufOnau2rKZ5Wq0WQ4cOxdChQ/Hee+/hnXfewauvvoqffvrJbPYlERGZLz4PSkTNglarxahRo/D999/j8OHD1ZZX/evriBEj8Msvv+DAgQOGZUVFRVi2bBkCAgIMYzbk5uYaxVtbWyM4OBhCCNy6dUt1fR955BEcOHAA27Ztq7bs+vXrhs4DpSorK/H888/j1KlTeP755w0/a6jJn7fRwcEBQUFBRj8Xsbe3N9TpThYWFtBoNEavbk5PT8e3334rVe/67r/6ttuft02r1RqecLhz+5T4/vvvAcDQCRAWFobAwEDMnz/f0Mlzp6tXrxr+31Q7ArfHPbGyssK7774LV1dXw0+I+vfvj4MHD2LPnj3VOknq2w6PPPIIKisr8dZbb1UrV1FRUWN9ZISHhyMqKgrLly+v8RgoLy/Hf/7zHwC3x8AJCQnBZ599ZpT/5MmT2L59u6FDwMLCAhEREdi0aZPhZzzA7bdBrV27Fv369av1+AaAHj16wN3dHUuXLkV5eblh/qpVqxps26vqWt/zwd7evsbz6aGHHsLXX39dY6fmncfS3WLZsmVG18IlS5agoqLCMM5MZGQkHB0d8c4779R4zazapjuPh4KCAsPyHTt2GMY0qzJixAhUVFRgyZIlhnmVlZVYtGhRg22XhYUFhg0bhm+//RbZ2dmG+efOncMPP/xgVDYvL69afNXTerLXGSIic6H/G0zmgE/oEFGz8c4772D79u0YOHAgJk+ejI4dO+LSpUv46quvsG/fPjg7O+OVV17BunXrMHz4cDz//PNwdXXFZ599hrS0NHz99deGcQ8iIiLg5eWFvn37wtPTE6dOncKHH36I6Ojoeg38Wpfp06fju+++w/333294LXRRURF+++03bNiwAenp6YbXW5tSUFCA1atXA7j9Gutz585h48aNOH/+PB577LEa/4i/U3BwMAYNGoSwsDC4urri8OHD2LBhA6ZOnWooExYWBgB4/vnnERkZCQsLCzz22GOIjo7Ge++9h6ioKDz++OO4cuUKPvroIwQFBeHEiRNSbVKf/VffdnvqqaeQl5eHIUOGwMfHBxkZGVi0aBFCQkIM4yXV5uzZs0Zte/DgQXz22WcICgoyvJpbq9Vi+fLlGD58ODp16oSJEyeidevWyMrKwk8//QRHR0dDJ1BVO7766qt47LHHYGVlhZEjR8Le3h52dnYICwvDwYMHMXLkSMMTHAMGDEBRURGKioqqdejUtx0GDhyIKVOmYO7cuUhKSkJERASsrKyQmpqKr776CgsWLMDDDz8stb/+7PPPP0dERAQefPBBjBw5EkOHDoW9vT1SU1PxxRdf4NKlS5g/fz6A2z9TGz58OMLDwxEXF2d4bbmTkxNmz55tWOfbb7+NHTt2oF+/fnj22WdhaWmJjz/+GGVlZfjvf/9bZ52srKzw9ttvY8qUKRgyZAgeffRRpKWlYeXKlfUeQ6c+lJwPYWFh2LlzJ9577z14e3ujTZs26NWrF/7f//t/+Omnn9CrVy9MmjQJwcHByMvLw9GjR7Fz584aOw/+LCsry3Dc3snBwQGjRo1qqM0FcLuTbujQoXjkkUdw5swZLF68GP369cMDDzwA4PaTa0uWLMG4cePQvXt3PPbYY3B3d0dmZia2bNmCvn374sMPPwQAzJ07F9HR0ejXrx+efPJJ5OXlYdGiRejUqZNRZ+nIkSPRt29fvPLKK0hPT0dwcDA2btxo1BHUEGbPno3t27ejb9++eOaZZ1BZWYkPP/wQnTt3RlJSkqHcm2++ib179yI6Ohr+/v64cuUKFi9eDB8fnzqfjiQiImoQTfNyLSKixpGRkSHGjx8v3N3dhU6nE23bthXPPfec0SuLz58/Lx5++GHh7OwsbGxsRM+ePcXmzZuN1vPxxx+LAQMGiJYtWwqdTicCAwPF9OnTjV5daOq15TW9CnzgwIFGr0gW4vZrfePj40VQUJCwtrYWbm5uok+fPmL+/PlGrwOuycCBA41eS+zg4CDatWsnnnjiCbF9+/YaY/782vK3335b9OzZUzg7OwtbW1vRoUMHMWfOHKPcFRUV4p///Kdwd3cXGo3G6JW9K1asEO3atRM6nU506NBBrFy50uSrgp977rk66yNE/fZffdptw4YNIiIiQnh4eAhra2vh5+cnpkyZIi5dulRru1bV987JwsJC+Pj4iMmTJ4vLly9XK3/s2DHx4IMPGo4Vf39/8cgjj4gff/zRqNxbb70lWrduLbRabbXjZvr06QKAePfdd41igoKCBACj13YraYcqy5YtE2FhYcLW1la0aNFCdOnSRbz00ksiOzvbUEbJsWtKcXGxmD9/vrj33nuFg4ODsLa2Fu3atRP//Oc/jV4VLYQQO3fuFH379hW2trbC0dFRjBw5UqSkpFRb59GjR0VkZKRwcHAQdnZ2YvDgwWL//v1GZarOxZpeeS+EEIsXLxZt2rQROp1O9OjRQ+zdu7fadpl6bbm9vX219dV0nNf3fDh9+rQYMGCAsLW1FQCMzoHLly+L5557Tvj6+gorKyvh5eUlhg4dKpYtW1bjdt2ptteW3/nqb1PbNHDgQNGpU6ca13vncVHV1nv27BGTJ08WLi4uwsHBQYwdO9boNfRVfvrpJxEZGSmcnJyEjY2NCAwMFLGxseLw4cNG5b7++mvRsWNHodPpRHBwsNi4caOYMGGCUd2FECI3N1eMGzdOODo6CicnJzFu3Dhx7Nixer+2vL7Xoh9//FGEhoYKa2trERgYKJYvXy7+/e9/CxsbG6MyMTExwtvbW1hbWwtvb28xZswYcfbs2Wo5iIiai6rXlieleIjzF72a7ZSUYh6vLdcIITEKHBERERHR38ioUaOQnJxc43g/RER/F4WFhXByckJSigdatGi+I7jcuKFHSPAVFBQU1PkT76bUfPcAEREREZGEkpISo8+pqalISEjAoEGDmqZCRERENeAYOkREREREd2jbti1iY2PRtm1bZGRkYMmSJbC2tsZLL73U1FUjIror6KFBJUy/xdPc6c1k29ihQ0RERER0h6ioKKxbtw45OTnQ6XQIDw/HO++8g3bt2jV11YiIiAzYoUNEREREdIeVK1c2dRWIiIjqxDF0iIiIiIiIiIjMDJ/QISIiIiIiIqJ604vbU3NlLtvGJ3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMO3SIiIiIiIiIiMwMB0UmIiIiIiIionqrhAaV0DR1NRqNuWxbs+jQSUtLQ2JiIjIyMlBcXAx3d3eEhoYiPDwcNjY2JuP0ej327NlTY+ywYcPg6+vboHEAcP36dXzzzTc1xkZGRqJPnz4Nvp2ysWq2U03sX72dTdVGaur7Vx/zanI2xXbKxv6djnlzOs/UxHG/sG3V1rUp7hVkY9XcY6iJNac2Mrecf5f7RjX1NafrZlPEmtsxr6aNmmq/EDUpYcZWr14t7r33XqHRaISXl5fo3r276Nu3r+jYsaOwtrYWjo6O4plnnhHp6elGccXFxeKtt94S3t7ewsbGRvTu3Vs8+OCDYuzYsWL48OHC19dXWFhYiOHDh4sDBw6ojhNCiKysLBEXFydsbGxE27ZtxWOPPSZefPFF8eqrr4pnnnlG9O/fX9jZ2YmOHTuKL774okG2UzZWzXaqif2rt7Op2khNff/qY76p9os57U+27d1ZX+4Xtq3aujbFvYJsrJp7DDWx5tRG5pbz73LfqKa+5nTdNLf90hTHvDnul7+rgoICAUAcSvYSyZnezXY6lOwlAIiCgoKmbvJamW2HTkhIiOjZs6f46KOPRGZmZrXlpaWl4qeffhJTpkwRbm5uYv369YZlPj4+YvTo0WLLli2ivLy8xvWnp6eLd955R/j7+4tly5apihNCCA8PDzF9+nSRnJxscpuKi4vF2rVrRe/evcW8efNUb6dsrJrtlI1tiu1sqjaSzdkUx3xTtK257U+27d1ZX+4Xtq2auqqJbYqcsvcYamPNqY3MLeff5b7x73LdNLf90hTHvLntl78zdujcXcy2Q2fr1q31Lnvt2jVx+PBhw+eUlJR6x5aXl4tz586piquqgxJV5dVsp2ysmu2UjW2K7VQTq6aNZHM2xTHfFG1rbvuTbdt4sTzm786c5tS2TXFuN0VO2XsMtbHm1EbmlvPvct/4d7lumtt+aYpj3tz2y99ZVYfO/uRW4kRm62Y77U9uZRYdOhohhGjKn3wRERERERER0d2vsLAQTk5O2J/cCg4tmu9Ls2/e0KNPp0soKCiAo6NjU1fHpGYxKHJOTg4OHTqEnJwcAICXlxd69eoFLy8v6XUWFRXhyJEjGDBgQI3Lf/nlFxw4cMAoZ3h4OHr27CmdMz8/H99//z3Gjx8vvQ5TZNtIr9dDq61+our1evz+++/w8/NTXJe62laNyspKWFhYGD4fOnQIZWVlCA8Ph5WVVa2xDX0c1Wc71dRXhhAC6enp8PX1haWlJcrLy/HNN9+grKwMI0aMgJub219S14kTJ2LOnDnw9vZutLiG2p9DhgzBypUr4e/vryjuTo15zP9Zfdvobtift27dQnp6Ojw8PODk5FRr2aa4zsvWVY2G2i9q6iu7P9PS0nDu3Dm0atUKnTt3/kvqKhN7/fp1fPXVV8jMzIS/vz9Gjx7d6LEycUrvM8rKyqDVag3Hyfnz5/Hpp58acsbFxaFNmzb12s4/q8/9idr7BaVtpOb77M9krvNqjqP6niuy+/TIkSMICwur97bU5K+8J2qI+spSes1tjLo25nfo119/jeHDh8POzk51Pet7zKvJKdu+avZLUx5/RA2iaR8QUufmzZti7NixwsLCQlhaWgoPDw/h4eEhLC0thYWFhXjiiSdEUVGR1LqTkpKEVqutNv/y5cuiX79+QqPRCH9/f9GzZ0/Rs2dP4e/vLzQajejXr5+4fPlyg+YsLy8X06dPF4GBgeLee+8VK1asMFqek5NTY5wQ8m1UUFAgRo8eLWxsbISHh4d4/fXXRUVFRb1yNsV2Zmdni759+woLCwsxYMAAkZeXJ6Kjo4VGoxEajUa0b99eZGdn1xjbWMeRqe1UU181bXT69Gnh7+8vtFqtCAoKEhcuXBBhYWHC3t5e2NnZCTc3N3H27NkGq6sQQhw/frzGycrKSnzzzTeGzw0VJ4T8/ty0aVONk4WFhfjwww8Nn2U0xjEv20ZNsT+FEOLdd98VxcXFQgghKioqxL///W9hbW0ttFqtsLS0FBMnTqzx9/ZNcZ2XrasQ8vtUzX6Rra+a/fnMM8+IGzduCCFuj+Px0EMPCa1WKzQajdBqtWLw4MGG5Q3VtrKx//jHP8RXX30lhBDi5MmTws3NTbi7u4tevXoJT09P4eXlZfJnArKxanLK3mcMHDjQkHPfvn1Cp9OJrl27ikcffVSEhoYKOzs7sX///hpz1qW27zPZ+wU1bST7fabmOi9bX9lzRQj5farRaERgYKCYM2eOyMrKqnHdpjTFPZFsfZvivlFN2zbFd6hGoxGOjo5i0qRJ4uDBg4rqK3vMq8kp275q9oua2L8r/uTq7mLWHTpxcXGiXbt2YuvWrUY3DxUVFWLbtm2iffv24qmnnpJat6kvnoceekiEh4eL06dPV1t2+vRp0adPH/Hwww/XuM6CgoJap8TExBpzzpo1S3h6eop58+aJV199VTg5OYnJkycblufk5AiNRlNjTtk2ev7550X79u3FV199JT755BPh7+8voqOjRVlZWZ0562KqbdVs57hx40SfPn3Ed999Jx599FHRp08f0b9/f/H777+LjIwM0bdvX/Hcc8/VGNtYx1FtNy+y9VXTRjExMeKBBx4QJ06cENOmTRMdO3YUMTExory8XJSWloqRI0eKJ554osHqKoQw3LBW3SDdOd15Q9tQcULI78/act6ZW0ZjHPOybdQU+1MIIbRareGP0Hnz5gkXFxfx6aefiuTkZLF69Wrh4eEh3n333WpxTXGdl62rEPL7VM1+ka1vQ+3P+Ph44ePjI3bt2iWKiorEvn37RGBgoHjllVcatG1lY11cXMSpU6eEEEIMHz5cPP7444bvsvLychEXFyciIiJqzCkbqyan7H2Go6OjoRNj4MCB4oUXXjBa/tprr4m+ffvWmFP2/kQI+fsFNW0k+32m5jovW1/Zc0UI+X2q0WjEpEmTDB0x0dHR4ptvvjG6hprSFPdEsvVtivtGNW3bFN+hGo1GvPnmmyI0NFRoNBrRqVMn8f7779drjCbZY15NTtn2VbtfZGP/rtihc3cx6w4dZ2dn8fPPP5tcvm/fPuHs7FzjMhcXl1onR0fHGi+qDg4O4ujRoyZzHj58WDg4ONS4rOpCbWoydSEPCgoS33//veFzamqqCAoKErGxsUKv19f6LxCybeTn5yd++uknw+erV6+Knj17ioiICFFaWlprTtm2VbOdrVq1Mrz+MDc3V2g0GrFz507D8h9//FG0bdu2xljZNpLdTjX1VdNG7u7u4tixY0KI2/8Cp9FoRGJiomH5zz//LPz8/BqsrkII0a1bNxEdHS1OnTol0tPTRXp6ukhLSxOWlpZix44dhnkNFSeE/P6MiooS0dHR1f7l29LSsta3jAjRNMe8bBs1xf4U4vb1r6ptQ0NDxccff2y0fPXq1aJTp07V4priOi9bVyHk96ma/SJb34ban507dxZr1641Wr5p0ybRvn37BqurmlhbW1vDwJutWrWq9h1+5swZ4eTkVGNO2Vg1OWXvM+zt7Q1/fHl6eoqkpCSj5efOnWvw+xMh5O8X1LSR7PeZmuu8bH1lzxUh5PdpVc5bt26JDRs2iBEjRggLCwvh6ekpXnrpJXHmzBmT29kU90Sy9W2K+0Y1bdsU36F3xh0+fFg888wzwtnZWeh0OjF69Gixfft2k/VtiGNeaU7Z9lWzX9TE/l1VdejsO+ktkjJ8mu2076S3WXTomPUYOnq9HtbW1iaXW1tbQ6/X17isrKwMzzzzDLp06VLj8oyMDLzxxhvV5ut0OhQWFprMeePGDeh0uhqXtWjRAq+++ip69epV4/LU1FRMmTKl2vysrCyj31gHBQVh9+7dGDJkCMaNG4f//ve/Jusj20ZXr141+i25m5sbdu7cicjISIwYMQLLly83uU7ZtlWznfn5+WjdujUAwNXVFXZ2dkb1DwoKwqVLl2qMlW0j2e1UU181bXTz5k24uroCAOzt7WFvb49WrVoZlvv6+uLy5csNVlfg9hgQL730Eh566CGsXr0aoaGhhmXe3t4mxyuQjQPk9+cPP/yA999/Hz169MDixYtx//33m1zHnzXFMS/bRk2xP6toNBoAQGZmJvr06WO0rE+fPkhLS6sW0xTXedm6AvL7VM1+ka1vQ+3PnJwcdO3a1WhZt27dcPHixQarq5rYrl27YteuXQgMDISXlxcyMjKMtjUjIwO2trY15pONVZNT9j6jV69e+P7779GhQwcEBgbi+PHj6Natm2F5UlKS4Tvgz2TvTwD5+wU1bST7fabmOq+mvrLnipp9CgCWlpZ46KGH8NBDDyErKwuffvopVq1ahfnz56Nv377Yu3dvtZimuCeSrW9T3TfK1BVomu/QO4WFhSEsLAzvvfcevvrqK3z66aeIioqCn59fg187ZXNWkWlfNXFqY4maVFP3KKnx+OOPi9DQ0Br/Jevo0aMiLCxMjB07tsbYPn36iA8++MDkuk09Gvrss88Kf39/sXHjRqPeuoKCArFx40YREBAgpk6dWuM6Bw0aZPJR8qqcNT0a2qZNG6N/NaiSlZUl2rdvL+677z6T/wIh20b33HOP2LJlS7X5N27cEOHh4aJbt24mc8q2rZrt9PPzE4cOHTJ8fvnll0Vubq5RTjc3txpjZdtIdjvV1FdNGwUGBhr9C+bixYtFYWGh4fORI0eEl5dXg9X1TgkJCcLHx0e88847orKysl7/Giobp+a6IIQQx44dE8HBwWLy5MmiqKioXjmb4pivorSNmmp/ajQaMWfOHLFgwQLRqlUrsWfPHqPlx48fFy4uLtXimuI6L1tXIeT3qZr9oqa+QsjvzylTpogXXnhBeHh4VPsX1yNHjtRYXzV1lY3dvHmzcHV1FStXrhQrV64UAQEBYvny5eLnn38Wn376qfD19RXTp0+vMadsrJqcsvcZ+/fvF05OTmLWrFli0aJFws3NTbz22mtizZo1YubMmcLZ2dnkPYjs/YkQ8vcLatpI9vusisx1Xra+sueKEPL79M6f59Rk586d4vHHH69xWVPcE8nWtynuG9W0bZW/8ju0rvqmpqaKGTNm1LhM9phXk1O2fdXsl4bYp383fELn7mLWHTp5eXkiKipKaDQa4erqKjp06CA6dOggXF1dhVarFcOHDxf5+fk1xs6ZM0fMnj3b5LozMzNFbGxstfmlpaXi6aefNgxEZmNjI2xsbIRWqxXW1tbimWeeEaWlpTWuc9myZWLBggUmc+bk5NRYp7i4OPHkk0/WGPP777+LoKAgk19Ysm30z3/+0+RYQIWFhaJXr14mc8q2rZrtfOCBB2q9kfjwww/FkCFDalwm20ay26mmvmraaMqUKeKTTz4xmXPu3LlixIgRDVbXP8vJyRHDhw8X/fv3r3eHjkycmutCleLiYjFlyhTRrl07YWFhUWfOpjjm76SkjZpqf/r7+4uAgADD9P777xst/+CDD0Tv3r2rxTXFdV62rkLI71M1+0VNfaso3Z8DBw4UgwYNMkx/vra89dZbYuDAgQ1aVzWxGzZsED4+PtXGr7CxsRHTpk2rdawE2VjZODX3Gfv37xe9e/euNj5H69ataz2+ZO9PhFB3vyDbRrLfZ3dSep2Xra/suVJFZp/e+ZMXpZrinki2vk1x36imbe/0V32Hqq2vzDGvJqdsbFPk/Dtjh87dRSOEEE37jJB6p0+frvHVnh06dGi0nIWFhThy5IhRzrCwsEZ5R31GRgZOnz6NyMjIGpdnZ2djx44dmDBhgsl1KG2j/Px8ZGdno1OnTjUuv3HjBo4ePYqBAwcq3BrTGmI7Tfnll19gZ2dX6+tBm+I4MsVUfRuzjdLS0mBjY2P02LqaupqycOFC/PTTT1i0aBF8fHzqnUdpXEPsz++++w4//fQT4uPj4eHhUe+4+mro/Snbtnf6q/bnnx08eBA6nc7oce473U3nZ211baxzVOl+qW99/6yh9ueFCxdgbW2teB1K6qo0trKyEkePHsWFCxeg1+vRqlUrhIWFoUWLFnWuWzZWTU419xlXr141yhkQEFBnjCy19wtq2sgUJd9nSq/zDV3f+p4rSvbpnj170LdvX1hayo+s8Fdec2Xr2xT3jQ3Rtndq7O/QjIwM+Pn5GX6uJUPpMa8mp2z7qtkvDb1P/w4KCwvh5OSEPSdbw6GFtqmr02hu3tBjYOcsFBQUNMrf+A2lWXToEBEREREREVHjYofO3aX57oH/3969e1FQUPCXxn7++ec4f/68VE7ZWHPbTtmcTbGdamLNLac5HX885ptXTjWxzHl35uT1pPFyyrZtU9yfqIk1tzbifSNzNlVONbHmdsyb234hanRN+4uvxlf1G+D58+f/ZbEajUZYW1ubHBy5MWLNcTtlc/7V26km1hxzmtPxx2O++eRUE8ucd29OXk8aL6ds2/7V9ydqYs2xjXjfyJzm+B1qbse8Oe2X5qhqDJ09J1uLIxm+zXbac7K1WYyh0+yf0ElLS8OGDRtqfH1lY8Xq9XqcPn0aHTt2VJxTNtbctlM2Z1Nsp5pYc8tpTscfj/nmlVNNLHPenTl5PWm8nLJt2xT3J2piza2NeN/InE2VU02suR3z5rZfiBobx9AhIiIiIiIiojpVjaGz66Rvsx9DZ0jnixxD569QUVGB48ePY9u2bdi2bRuOHz+OW7duNXqsqfVlZmY2SmxD11UNNdvZmBqyjS5fviy1jbJxajRETqX7VEnOu+HYfeONN3Dt2jXpeJljXjanmrrKHgtqciqJbahjQc3x0xTXTdmcauoqu08bon0a83ryZ031fS9DZp9UVFRgx44dWLFiBXbu3InKykqp3Er2iZqcausrcyzI5myItlV6DP2VbStzzMt+D6j5fpWlJmdD17c+5/bdUF8lx1Bj7VOZ+ynZ74j6nJ9NcewSNaim/s2XGpWVleLVV18Vzs7OQqPRGE3Ozs7itddeE5WVlQ0eW5ukpCSh1WqltsdUrNq6fvTRR2Lo0KFi9OjRYufOnUbLrl69Ktq0adNgdVWbUzZOTRsVFhaKsWPHCj8/PzF+/HhRVlYmnn32WaHRaIRWqxUDBgyo8beTsnFqtlVtztqY2qdqcqrZL7LHQkFBQbXp+vXrwsrKShw6dMgwT6najnnZnGrqKrtf1ORUEyt7LHz55ZeirKzM8HnRokXCz89PaLVa0bJlS/HGG2/UmE9trOzxJ5tTTV1l94uanHVpjOuJbH2b4jtUzbkydepU8f333wshhLh48aLo0KGDsLCwEJ6ensLCwkJ06dJF/P777ybra0pt1zA1OWVj1RwLsjnVbKfs8dcUbavmmNdqtWLIkCFizZo1orS0tMYyDRlXReY8U5NTNlbNud0U9VVz/Kndp6bUdi2SvS6o+T5rrO1szqrG0Nl10lf8kuHfbKddJ33NYgwds+7QmT59unB3dxdLly4VaWlpori4WBQXF4u0tDTx8ccfCw8PD/HSSy81eGxtGqNDR01dFyxYIOzs7MRzzz0nnnjiCWFtbS3eeecdw/KcnByp+ta2nbI51dRVTRtNnTpVdOjQQSxcuFAMGjRIxMTEiM6dO4t9+/aJPXv2iODgYDFjxowGi1OzrWpy1sXUPlWTU3a/qDkWtFptjVPVzUDVfxuqfdTkVFNX2f2iJqeaWNljQavVisuXLwshhPj000+FjY2NmDlzptiyZYt4++23hb29vfjkk09M1lcmVu3xJ5NT7XbKHn+yOevSGNcT2fo2xXeomnPF09NT/Pbbb0IIIR555BExbNgwcfXqVSGEELm5ueL+++8XDz/8cI2xtantGqYmp2ysmmNBNqea7ZQ9/pqibdUc8xqNRkRFRQlra2vh4uIipk6dKo4dO1Zj2YaIE0L+PFOTUzZWzbndFPVVc/ypqW9t6upclr23kf0+a6ztbM7YoXN3MesOHU9PT7F161aTy7du3So8PDwaNDY0NLTWqUOHDiYvUrKxarYzODhYrFmzxvD5559/Fu7u7uL1118XQpj+klSznbI5ZeOEUNdGvr6+YteuXUIIIbKysoRGozH8a4YQQmzevFncc889DRanZlvV5JTdp2pyyu4XNcdC69atRXR0tNi1a5fYvXu32L17t/jpp5+EhYWFWLlypWFeQ7WPmpyycULI7xc1OdXEyh4LGo3GcJPWs2dP8d///tdo+eLFi0VoaGiN65SNVXP8yeZUs52y+0VNzqa4nsjWtym+Q9WcKzY2NuLChQtCCCF8fHzEoUOHjJb/9ttvws3NrVqcmmuYbE41sWqOBdmcarZT9vhrirZVc8xXbefVq1fF/PnzRXBwsNBqtaJ79+5i8eLFJv+wkY0TQv48U5NTNlbNud0U9W2IY15pTjXXItnrQkPcK8jsl7+rqg6dH3/zEwfTA5rt9ONvfmbRoWPZlD/3UuvGjRvw9vY2ubxVq1YoKipq0NiUlBQ89thjaNOmTY1xly5dwtmzZ2tcJhurZjvT0tLQp08fw+c+ffpg165dGDZsGG7duoVp06Y1aF3V5JSNA9S10ZUrVxAUFAQA8Pb2hq2tLdq3b29Y3rlzZ1y8eLHB4tRsq5qcsvtUTU7Z/aLmWDhx4gTi4uLw1ltv4X//+x9at24NANBoNOjZsyeCg4NrjFNzzMvmlI0D5PeLmpxqYtWcoxqNBgBw4cIFREREGC2LiIjAyy+/bHK9MrFqjj819ZWNU7NfZHM2xfVEtr5N8R2qZp+0b98ev/zyC9q0aYMWLVqgsLCw2vbo9fpqcWquYbI51cSqORZkc6rZTkDu+GuKtlVzzFdxc3PDv//9b/z73//GgQMHsHz5crz88sv4z3/+g4ceegiff/55g8WpvebK1lUmVs253RT1VXvMy+RUcy1Sc11Qc68gs51Ed42m7lFSY8SIESIiIsLw6OCdrl69KqKiokR0dHSDxoaFhYnFixebrNOxY8dM9jrLxqrZTl9fX7F3795q85OTk4Wnp6cYP358jTnVbKdsTtk4IdS1kbe3tzhy5Ijh85gxYwy9/EIIcfLkSeHi4tJgcULIb6uanLL7VE1O2f2i5liosnjxYuHt7S3Wrl0rhBDC0tJSJCcnmyyv5piXzakmTs1+UVNX2VjZY0Gj0YjPP/9cbNq0Sfj4+Ij9+/cbLT958qRwdHSsMadsrJrjTzanmu2sonS/qMnZFNcT2fo2xXdoFZlzZeXKlcLHx0f89NNP4vPPPxcdO3YUO3fuFFlZWWLXrl2iS5cu4qmnnqoWp+YaJptTTayaY0E2p5rtlD3+mqJt1Rzzd/505c9u3rwpli9fLvr06dNgcULIn2dqcqqJFULu3G6K+qo5/mRzqrkWyV4X1HyfqT0W/o74hM7dxaw7dDIzM0Xnzp2FpaWlCA0NFVFRUSIqKkqEhoYKS0tL0bVrV5GZmdmgsc8//7z417/+ZbJO586dE4MGDapxmWysmu0cM2aMmDZtWo3LTp48Kdzd3Wu8qKrZTtmcsnFCqGujqKgosXTp0hqXCXH7y7CmC7lsnBDy26omp+w+VZNTdr+oORbulJycLLp16ybGjBlT582WmmNeNqeaODX7RW1dZWJlj4U/D+j59ttvGy1fvnx5rY9Ry8SqOf5kc6rZzjsp2S9qcjbF9US2vk3xHXonmfPs//7v/4SdnZ2wtbUV1tbWRmN1jBo1Sty4caNajNprmExONbFqr2Gy9ZWNU3O+/NVtq+aYv/OnK0rIxgkhf56pyakmtorSc7up6qvmmJfJqeZaJHtdUHuvoPZY+Lthh87dRSOEEE37jJA6er0e27Ztw8GDB5GTkwMA8PLyQnh4OCIiIqDVmn4zu5rYv5psXU+cOIEjR45g4sSJNS4/efIkvv76a8yaNavB6iqbU21dZdsoLy8PWq0Wzs7ONS7/4YcfYGtri0GDBjVInJptVZNTltqcMvulIY/b8vJyvPLKK/jpp5+wceNGk48ANyTZnEriGupYUNM+SmMb45q7efNmWFlZITIyssFiG/O6KVtfJXENdcyraVtTGvMaVlt9m/o7VGafXL9+HTt27MCFCxeg1+vRqlUr9O3bF+3ataszVpaanEpjG+JYkK1vY7RtXefLX9m2gPwx/9lnn+Gxxx6DTqerx1arjwPkzzM1OdXE3knJud2U9ZU5hhqqjZRorO+I2s7PpthOc1dYWAgnJyf8+Jsf7FvcPX8vN7SiG3oM7ZKJgoICODo6NnV1TDLbDp3MzEz4+fnVu3xWVpbhd66ysczZvHKaW32ZkznNMae51Zc5mZM5m2d9mZM5zTGnudX375Lz766qQ2f7b/7NvkMnokvGXd+hY7Z74N5778WUKVPw66+/mixTUFCATz75BJ07d8bXX3+tOpY5m1dOc6svczKnOeZsiPr+8ssv0jmVxjbEdsrmVLOdTdG2TXH8NcX+NIfzzFzPbXPLyeOPOXme3b05/8rvM6K7idm+5SolJQVz5szBfffdBxsbG4SFhcHb2xs2NjbIz89HSkoKkpOT0b17d/z3v//FiBEjVMcyZ/PKaW71ZU7mNMecDVHfiIgI6ZxKYxtiO2VzqtnOpmjbpjj+mmJ/msN5Zq7ntrnl5PHHnDzP7t6cf+X3GdHdxGx/clWlpKQEW7Zswb59+5CRkYGSkhK4ubkhNDQUkZGR6Ny5c4PHMmfzymlu9WVO5jTHnOZWX+ZkTuZsnvVlTuY0x5zmVt+/S86/K/7k6u5i9h06RERERERERNT4qjp0fjjRptl36AzvmnbXd+g03z1ARERERERERNRMsUOHiIiIiIiIiMjMsEOHiIiIiIiIiMjM/K06dMrKyjB79myUlZX9ZbHMyZzMeffmVBPLnMzJnI0fy5zMyZx3b041sczJnH+3nESN5W81KHLVAE4yAxvJxjInczLn3ZvT3OrLnMxpjjnNrb7MyZzM2Tzry5zM2ZQ5m5Oqdthyoi3sW1g0dXUaTdGNSkR3vXDX7++/1RM6RERERERERETNATt0iIiIiIiIiIjMjGVTV6Ch6fV6ZGdno0WLFtBoNEbLCgsLjf6rhGwsczInc969OdXEMidzMmfjxzInczLn3ZtTTSxzMmdzzCmEwI0bN+Dt7Q2tVqu4XkQymt0YOr///jt8fX2buhpERERERET0N3Px4kX4+Pg0dTUaTWHh7TF0vjsR2OzH0Hmg6/m7fgydZveETosWLQAA/TAClrBSHJ8X21Mqr4WKwc4L2snF6a5p6i5kgkYvF2c1NFc6541ia6k4R3v5xr12yUkqTlMsf3Gy8iqSjg3xzpaKu1ZqL50z+7rcBUoIFcffby2k4px6X5HOeeV8S6m4ezr/Lp3T1y5fKm5vZqB0zvLLdtKxPu3k2jfnuJd0zluuFVJxlna3pHNqNHL/jtHFR+78BIBTVzyl4irOy50rAODa+apUXN5v7tI5LYNuSMeWXJM7dnU58rcy5W6VUnGT+/8knfNAfhupODtL+WM+puUxqbgVv/eTzmmhlbvRKKuU35/tHOWOeQDYde4eqTi9Xv670MmpWCrO3f6mdM5zZ1pLxQlLyRtHANbX5PZpj0GnpHNeL5e7npy6KP99Nir4uHTs5TK5a/3Bwx2kc4aEnpeKK1dxjuYUyW2nlVbuWg0Al3Jc5HLaliuO0ZeUIePZ/zP8PUr0V5A6I3Nzc9GxY0f88ssvCAgIaOAq3bZ161a88sorOHr0qKJH1qp+ZmUJK1hqlHfoWFjbKI4BAAsVzzlp5VLCQvfXd+hY2Omkc1pALtZC/u9TaG3lGlcj5Dt0LOzkv3Ss7OU6vSwtVOyXcrk2UtWho5M8z+zlt1P2WJDdJwBgLRlrYSd5UYD8dgKApWT7am3U1FeuQ0drJ3+OynboqDkWZK+dehVtK3u+qNmfFnbKb4ANeSWPXQsb+T8utLZy12sbB/mcVuVyx5GVpfw1107yX1BlrwmAfIdOpYo/Fq0d5M9Rrex1t1J+v8jeL1jay3fuyZ5najp0tJLnqJprrpWVXKya71Cdg/K/O6pYWUrWV8X1WrZ9hYpz1ELIXVMsLeTvrWX3qdZO/idTfx72g6gxSR2pc+bMQUxMjKEzJzMzE9HR0bCzs4OHhwemT5+Oiorab9Lz8vIwduxYODo6wtnZGXFxcbh5849/cYiKioKVlRXWrFkjU0UiIiIiIiIiomZLcYdOcXExVqxYgbi4OABAZWUloqOjUV5ejv379+Ozzz7DqlWrMHPmzFrXM3bsWCQnJ2PHjh3YvHkz9u7di8mTJxuViY2NxcKFC5VWkYiIiIiIiIioWVPcoZOQkACdTofevXsDALZv346UlBSsXr0aISEhGD58ON566y189NFHKC+v+dHrU6dOYevWrVi+fDl69eqFfv36YdGiRfjiiy+Qnf3HGAUjR47E4cOHcf683G88iYiIiIiIiKhhVQpts5/MgeJaJiYmIiwszPD5wIED6NKlCzw9/xjwMTIyEoWFhUhOTq5xHQcOHICzszN69OhhmDds2DBotVocOnTIMM/Pzw+enp5ITEw0WZ+ysjIUFhYaTUREREREREREzZniDp2MjAx4e3sbPufk5Bh15gAwfM7JyalxHTk5OfDw8DCaZ2lpCVdX12ox3t7eyMjIMFmfuXPnwsnJyTDxleVERERERERE1Nwp7tApKSmBjYoR1ZWytbVFcbHp1zrGx8ejoKDAMF28ePEvqxsRERERERERUVNQ/N45Nzc35OfnGz57eXnhl19+MSpz+fJlw7KaeHl54cqVK0bzKioqkJeXVy0mLy8P7u7uJuuj0+mg08m/VpOIiIiIiIiI6k8PDfRovq9oN5dtU/yETmhoKFJSUgyfw8PD8dtvvxl10OzYsQOOjo4IDg6ucR3h4eG4fv06jhw5Ypi3a9cu6PV69OrVyzCvtLQU58+fR2hoqNJqEhERERERERE1W4o7dCIjI5GcnGx4SiciIgLBwcEYN24cjh8/jm3btuG1117Dc889Z/LJmY4dOyIqKgqTJk3CL7/8gp9//hlTp07FY489ZjQ+z8GDB6HT6RAeHi65eUREREREREREzY/iDp0uXbqge/fuWL9+PQDAwsICmzdvhoWFBcLDw/HEE09g/PjxePPNNw0x6enp0Gg02L17t2HemjVr0KFDBwwdOhQjRoxAv379sGzZMqNc69atw9ixY2FnZye5eUREREREREREzY/iMXQAYObMmZg+fTomTZoErVYLf39/JCQkmCyflpYGZ2dndOvWzTDP1dUVa9euNRlz7do1bNiwAYcPH5apIhERERERERFRsyXVoRMdHY3U1FRkZWXV6zXhCQkJmDFjBlxcXOqdIz09HYsXL0abNm1kqoi82J6wsFb+Nq6WnxyQynfluT5ScQBgW/Pb3eukt5JOiVv9CuXi9rtJ59Q7Cqm4XB+pwxQA4PSbXCO5jMySztnNVT52f47c8X6jWP7Nc3Y2ZVJxfVulSefcLjpIxb3Wbot0zulFD0vFBbW4Kp1zU1KIVJylbYV0zjYdL0nHpp/wrrtQDSwCiqRzWqbbS8VprslfF2Td2yVdOvbUpnuk4m61uyWd88oZ0y8UqI1lpXRKPBJ0TDp2o0W3ugvVoBAtpHNC7msJWWXO0imPHwmUihvS5zfpnIsyhkjFXbspd34CwKNtj0rFfbJvoHROqw7yB2989x+k4j5Y8aB0zqBRGVJxNhby14X0XMUP5wMANB1Nv3G2LmW2cvdijpZy9ycAcPJqK6m47m0ypXN+tb9X3YVM0DiVS8X5Bkv+EQEg+6aTVFzWpfr/PfdnY0J+lYrbcCZEOqe2QO5+YXDnZMUx5TfLIX93bH700KJS+Q9+zIZe9ibhLyZ9Rzxt2rR6l503b57i9ffo0QM9evRQHEdERERERERE1Nwp7lLLzc2Fh4cH0tPTG6E6t6WkpMDHxwdFRfL/6ktERERERERE1Fwp7tCZM2cOYmJiEBAQAADIzMxEdHQ07Ozs4OHhgenTp6OiovafC8yZMwd9+vSBnZ0dnJ2dqy0PDg5G79698d577ymtHhERERERERFRs6foJ1fFxcVYsWIFtm3bBgCorKxEdHQ0vLy8sH//fly6dAnjx4+HlZUV3nnnHZPrKS8vx+jRoxEeHo4VK1bUWGbixImYNGkS4uPjYWn514+VQERERERERETVVQotKkXzHUOnUpjHGDqK9kBCQgJ0Oh169+4NANi+fTtSUlKwevVqhISEYPjw4Xjrrbfw0Ucfobzc9OBeb7zxBl544QV06dLFZJn77rsPeXl52LNnj5IqEhERERERERE1e4o6dBITExEWFmb4fODAAXTp0gWenp6GeZGRkSgsLERysvKRwe9kbW2NkJAQJCYmqloPEREREREREVFzo+i3TBkZGfD2/uO1tjk5OUadOQAMn3Ny5F+jV8Xb2xsZGbW/0rGsrAxlZX+81rCwUO513ERERERERERE5kLREzolJSWwsbFprLpUY2tri+Li4lrLzJ07F05OTobJ19f3L6odEREREREREVHTUNSh4+bmhvz8fMNnLy8vXL582ahM1WcvLy/VlcvLy4O7u3utZeLj41FQUGCYLl68qDovEREREREREdVMD22zn8yBolqGhoYiJSXF8Dk8PBy//fYbrly5Ypi3Y8cOODo6Ijg4WHXlTp48idDQ0FrL6HQ6ODo6Gk1ERERERERERM2Zog6dyMhIJCcnG57SiYiIQHBwMMaNG4fjx49j27ZteO211/Dcc89Bp9OZXE9mZiaSkpKQmZmJyspKJCUlISkpCTdv3jSUSU9PR1ZWFoYNGya5aUREREREREREzZOiDp0uXbqge/fuWL9+PQDAwsICmzdvhoWFBcLDw/HEE09g/PjxePPNNw0x6enp0Gg02L17t2HezJkzERoailmzZuHmzZsIDQ1FaGgoDh8+bCizbt06REREwN/fX+UmEhERERERERE1L4recgXc7oyZPn06Jk2aBK1WC39/fyQkJJgsn5aWBmdnZ3Tr1s0wb9WqVVi1apXJmPLycixduhRr165VWj0iIiIiIiIiakSVQoNKoWnqajQac9k2xR060dHRSE1NRVZWVr3eKJWQkIAZM2bAxcWl3jkyMzMxY8YM9O3bV2n1DCzKAAuhPO7Kc32k8nl8tF8qDgB+j5fL6Tjgct2FTCj93rPuQjUo8ZJo1P+fRYncSdG9Te2vrq/NEa2fVFzZvtbSOUt6WUnHlt1SfEoCAEpvmP6JY52x+XJvrtte0kE6Z3vPq1JxW/JDpHMGuV+Titt8uot0zn/13ikV10F3STrnC5/HSce26pMjFRfgmCed8+cb7aTiwjqkSef0srkhFbc0aYB0Tn3Hcqk4jaVeOme7oGypuMxd8k/Grjos930GALglN/igvUeRdEo7ndx+Scr3kc750ciVUnEf/j5EOqe9ldx2phW4Sef8JrNb3YVqInPz9v9LTZJ/0+n3FhVScWVh8sffqaty92LTO26XzvmrvrNUnOy9AgCgQu7+b89XYdIpS1vKHUdHber/98qfPdDvcN2FTNh0PEQqLr/YVjqng02ZVJymSO5eFQA2XZC7p6ool8/Ztbvc/cL2E50Ux+hLSqVyEakhdXZMmzat3mXnzZuneP1BQUEICgpSHEdERERERERE9HdgHu/iIiIiIiIiIiIiA8UdOrm5ufDw8EB6enojVOe2lJQU+Pj4oKhI/jFWIiIiIiIiIqLmSnGHzpw5cxATE4OAgAAAwPPPP4+wsDDodDqEhITUax2lpaV47rnn0LJlSzg4OOChhx7C5ct/jAcTHByM3r1747333lNaPSIiIiIiIiJqRJXQNvvJHCiqZXFxMVasWIG4OONBN5988kk8+uij9V7PCy+8gO+//x5fffUV9uzZg+zsbDz44INGZSZOnIglS5agokJukDoiIiIiIiIiouZK0aDICQkJ0Ol06N27t2HewoULAQBXr17FiRMn6lxHQUEBVqxYgbVr12LIkNtvbFi5ciU6duyIgwcPGtZ93333IS8vD3v27MHQoUOVVJOIiIiIiIiIqFlT9IROYmIiwsLkXyEIAEeOHMGtW7cwbNgww7wOHTrAz88PBw4cMMyztrZGSEgIEhMTa11fWVkZCgsLjSYiIiIiIiIiouZM0RM6GRkZ8Pb2VpUwJycH1tbWcHZ2Nprv6emJnJwco3ne3t7IyMiodX1z587FG2+8oapORERERERERFQ/eqGFXpjHODMy9EI0dRXqRdEeKCkpgY2NTWPVpRpbW1sUFxfXWiY+Ph4FBQWG6eLFi39R7YiIiIiIiIiImoaiJ3Tc3NyQn5+vKqGXlxfKy8tx/fp1o6d0Ll++DC8vL6OyeXl5CAwMrHV9Op0OOp1OVZ2IiIiIiIiIiMyJoid0QkNDkZKSoiphWFgYrKys8OOPPxrmnTlzBpmZmQgPDzcqe/LkSYSGhqrKR0RERERERETU3Ch6QicyMhLx8fHIz8+Hi4sLAODcuXO4efMmcnJyUFJSgqSkJABAcHAwrK2tq63DyckJcXFxePHFF+Hq6gpHR0f885//RHh4uNHbs9LT05GVlWU0eDIRERERERERESns0OnSpQu6d++O9evXY8qUKQCAp556Cnv27DGUqXqiJi0tDQEBAQAAjUaDlStXIjY2FgDw/vvvQ6vV4qGHHkJZWRkiIyOxePFio1zr1q1DREQE/P39ZbeNiIiIiIiIiBpYJbSoVPaDH7NSiWY4KDIAzJw5EwsWLIBerwcA7N69G0KIalNVZ05aWhosLS3Rt29fwzpsbGzw0UcfIS8vD0VFRdi4caPR+Dnl5eVYunQpXn/9dZWbR0RERERERETU/Ch6QgcAoqOjkZqaiqysLPj6+tZZPiEhAZMnT0a7du3qnSMzMxMzZsww6gRSqqAdoJV4IZdtTt1lavJ7fB+5QAA+c/dLxWUJ+ZwVXnI9jpbFGumcFmVycce3dZDO2XHoBam4sE6Z0jk/3zVAOtav8yWpuPJbik9lg8pzDlJxwkn+WHDX3ZSKi3PbK51z2dWBUnFdO2VJ5zxcECAVtzB1iHTOfz/2vXTsnrz2UnGtba9L54zpfkwqLinXRzpn0qEgqbiWHXOlc+adaikVZ1Eif5716pYuFec78rp0zpR8T+lYWZdznaRjb51ylIq71kIvnfPZM7FScQ6tC6VzFt2Qe0OpKJH/bsnNk/tusb1oJZ3Tqe9l6Vg7y3KpuIpr8m9/XTJitVTcc0cel87Zqq/cd5qLrva3ztbmzFUPqTj7AMkbRwA3L0teF27JP22w53e57xYA6BL4u1Tcb6ny34WdOsr90ZNt7yKds7xM7vy2PS1/np1Nrf0FO6ZYtlD+t5K+tFIqF5EaUt/U06ZNq3fZ5557TvH6g4KCEBQkf1EkIiIiIiIiImrOFHdD5+bmwsPDA+np6Y1QnduuXbsGDw8P/P67XG81ERERERERETUOPYBKoWm2k/yzuH8txR06c+bMQUxMjGGMnOeffx5hYWHQ6XQICQmp1zqWLVuGQYMGwdHRERqNBtevXzda7ubmhvHjx2PWrFlKq0dERERERERE1Owp6tApLi7GihUrEBcXZzT/ySefxKOPPqpoPVFRUZgxY4bJMhMnTsSaNWuQl5enpIpERERERERERM2eojF0EhISoNPp0Lt3b8O8hQsXAgCuXr2KEydO1Gs9VWPw7N6922SZTp06wdvbG9988021DiQiIiIiIiIior8zRU/oJCYmIiwsrLHqUk3Pnj2RmJj4l+UjIiIiIiIiIjIHip7QycjIgLe3d2PVpRpvb28cO1b7K23LyspQVvbHaw0LC+Vf60lEREREREREtdNDC73yIXnNhrlsm6JalpSUwMbGprHqUo2trS2Ki4trLTN37lw4OTkZJl9f37+odkRERERERERETUNRh46bmxvy8/Mbqy7V5OXlwd3dvdYy8fHxKCgoMEwXL178i2pHRERERERERNQ0FHXohIaGIiUlpbHqUs3JkycRGhpaaxmdTgdHR0ejiYiIiIiIiIioOVM0hk5kZCTi4+ORn58PFxcXAMC5c+dw8+ZN5OTkoKSkBElJSQCA4OBgWFtb17ienJwc5OTk4Ny5cwCA3377DS1atICfnx9cXV0B3H61+ZEjR/DOO+/IbhsRERERERERNbBKoUWlMI9xZmSYy7YpqmWXLl3QvXt3rF+/3jDvqaeeQmhoKD7++GOcPXsWoaGhCA0NRXZ2tqGMRqPBqlWrDJ+XLl2K0NBQTJo0CQAwYMAAhIaG4rvvvjOU2bRpE/z8/NC/f3/ZbSMiIiIiIiIiapYUdzvNnDkTCxYsgF6vBwDs3r0bQohqU0BAAAAgLS0NlpaW6Nu3r2Eds2fPrjEmNjbWUGbBggWYOXOmuq0jIiIiIiIiImqGFP3kCgCio6ORmpqKrKyser1RKiEhAZMnT0a7du3qnePatWt48MEHMWbMGKXVM9Bd08BCp1Ecp7eSy+c44LJcIIAs0UcqrvX/2y+dM/3LrlJxVnsdpHMWdKiUirPJsZDOmbmhrVRcbrSddE4LrxLp2IyzXlJx7TpkSedME3L79KH2SdI5N37XTyruRJi3dM7cDBepOI82udI5r552k4oTLeTOFQAo1tf8U9f6KK2UuwBuSK59rLPa6EsUfw0BAGyyJC/WACyshFRcYZH8Wx67906Vijuf31I65+dHe0vF+XrnSedU/q37hwd9kqTiPjodIZ1Te0uuxjbeRdI5y9NaSMVZWchfF/Tlct+jOlf577MXu/woFfe5h9xxCwD/6/i5dGzk/uek4iyL5B/Jn7RvglSc7Wn5a9GVHnqpuJs6nXTONi3lrikD3c5K53yma7JU3K4SV+mc07aNk44d5ntGKi65MEA6Z3aRk1RcePsL0jkPJAdJxQ2KOS6dc+92ub957umZrjjmVlE5lEcRqSN1Jz1t2rR6l33uOeVfkG5ubnjppZcUxxERERERERER/R3I/dMoEREREREREf0t6aGBXtWzuXc3c9k2qedEc3Nz4eHhgfT09Aauzh+2bt2KkJAQw1g9RERERERERER0m1SHzpw5cxATE2MY+DgzMxPR0dGws7ODh4cHpk+fjoqKCpPx6enpiIuLQ5s2bWBra4vAwEDMmjUL5eXlhjJRUVGwsrLCmjVrZKpIRERERERERNRsKf7JVXFxMVasWIFt27YBACorKxEdHQ0vLy/s378fly5dwvjx42FlZYV33nmnxnWcPn0aer0eH3/8MYKCgnDy5ElMmjQJRUVFmD9/vqFcbGwsFi5ciHHj5AcZIyIiIiIiIiJqbhR36CQkJECn06F379tvIdi+fTtSUlKwc+dOeHp6IiQkBG+99RZefvllzJ49G9bW1d+4EhUVhaioKMPntm3b4syZM1iyZIlRh87IkSMxdepUnD9/HoGBgTLbR0REREREREQNqFJoUSnk3/R3tzOXbVNcy8TERISFhRk+HzhwAF26dIGnp6dhXmRkJAoLC5GcXP9XBhYUFMDV1fhVgX5+fvD09ERiYqLJuLKyMhQWFhpNRERERERERETNmeIOnYyMDHh7exs+5+TkGHXmADB8zsnJqdc6z507h0WLFmHKlCnVlnl7eyMjI8Nk7Ny5c+Hk5GSYfH1965WTiIiIiIiIiMhcKe7QKSkpgY2NTYNVICsrC1FRURg9ejQmTZpUbbmtrS2Ki4tNxsfHx6OgoMAwXbx4scHqRkRERERERER0N1I8ho6bmxvy8/MNn728vPDLL78Ylbl8+bJhWW2ys7MxePBg9OnTB8uWLauxTF5eHtzd3U2uQ6fTQafT1bf6RERERERERERmT/ETOqGhoUhJSTF8Dg8Px2+//YYrV64Y5u3YsQOOjo4IDg42uZ6srCwMGjQIYWFhWLlyJbTa6lUpLS3F+fPnERoaqrSaRERERERERNQIKqFt9pM5UFzLyMhIJCcnG57SiYiIQHBwMMaNG4fjx49j27ZteO211/Dcc8+ZfHKmqjPHz88P8+fPx9WrV5GTk1NtzJ2DBw9Cp9MhPDxcYtOIiIiIiIiIiJonxR06Xbp0Qffu3bF+/XoAgIWFBTZv3gwLCwuEh4fjiSeewPjx4/Hmm28aYtLT06HRaLB7924At5/gOXfuHH788Uf4+PigVatWhulO69atw9ixY2FnZ6diE4mIiIiIiIiImhfFY+gAwMyZMzF9+nRMmjQJWq0W/v7+SEhIMFk+LS0Nzs7O6NatGwAgNjYWsbGxtea4du0aNmzYgMOHD8tUkYiIiIiIiIio2ZLq0ImOjkZqaiqysrLq9ZrwhIQEzJgxAy4uLvXOkZ6ejsWLF6NNmzYyVYRGf3tS6la/Qql8pd971l3IhAovIRWX/mVX6ZwBj56Qiktd1Es6Z4vzFlJxt+ylU8J5ZLZUXOHGVnUXMsHKVSMdW+FdKRWXVeAkndPqplx9v9rWVzpn236ZUnHnjvtI57TPlvsdrFunIumcPfrLvXWvTC91aQYArEjpIx075p4jUnHJmfLny7sD18vFnYmUznmrUu5apMZA17NScb9dGiSdc26fjVJx756Wb9vrlxylY5fkDZCK69srpe5CJgTaXZOK+98OuboCwJORu6TiVm0eIp3zXzE/SMV9mir/k/e5+0dIxT3SXf4f8obueV46VhTJXXff/ofcNQwAPk6XO4782uXXXcgEvZD7zj9wtq10zuuFck/ap+4LkM75dXe58Tdv7vGQzjn6sf3SsesP9ZSKq2EI0nrLzpO7Xmdmt5TOqb0p9/27+3w76Zzhw5Kl4n4+ZHosWFP0paVSucyVXmikrynmwFy2TfqvhmnTptW77Lx58xSvv0ePHujRo4fiOCIiIiIiIiKi5k6qXzc3NxceHh5IT09v4Or8YevWrQgJCYFeL/GYDRERERERERFRMybVoTNnzhzExMQgICAAx48fx5gxY+Dr6wtbW1t07NgRCxYsqHMdeXl5GDt2LBwdHeHs7Iy4uDjcvHnTsDwqKgpWVlZYs2aNTBWJiIiIiIiIiJotxR06xcXFWLFiBeLi4gAAR44cgYeHB1avXo3k5GS8+uqriI+Px4cffljresaOHYvk5GTs2LEDmzdvxt69ezF58mSjMrGxsVi4cKHSKhIRERERERERNWuKx9BJSEiATqdD7969AQBPPvmk0fK2bdviwIED2LhxI6ZOnVrjOk6dOoWtW7fi119/NYyTs2jRIowYMQLz58+Ht7c3AGDkyJGYOnUqzp8/j8DAQKVVJSIiIiIiIqIGpocWlXI/+DELejPZNsW1TExMRFhYWK1lCgoK4OrqanL5gQMH4OzsbDTo8bBhw6DVanHo0CHDPD8/P3h6eiIxMVFpNYmIiIiIiIiImi3FT+hkZGQYnqCpyf79+/Hll19iy5YtJsvk5OTAw8P4tYCWlpZwdXVFTk6O0Xxvb29kZGSYXFdZWRnKysoMnwsL5V47TkRERERERERkLhQ/oVNSUgIbG5sal508eRIxMTGYNWsWIiIiVFcOAGxtbVFcXGxy+dy5c+Hk5GSYfH19GyQvEREREREREdHdSnGHjpubG/Lz86vNT0lJwdChQzF58mS89tprta7Dy8sLV65cMZpXUVGBvLw8eHl5Gc3Py8uDu7u7yXXFx8ejoKDAMF28eFHB1hARERERERERmR/FP7kKDQ3F6tWrjeYlJydjyJAhmDBhAubMmVPnOsLDw3H9+nUcOXLEMB7Prl27oNfr0atXL0O50tJSnD9/HqGhoSbXpdPpoNPplG4GEREREREREUnQCy30wjwGDpZhLtumuJaRkZFITk42PKVz8uRJDB48GBEREXjxxReRk5ODnJwcXL161eQ6OnbsiKioKEyaNAm//PILfv75Z0ydOhWPPfaY0fg8Bw8ehE6nQ3h4uMSmERERERERERE1T4o7dLp06YLu3btj/fr1AIANGzbg6tWrWL16NVq1amWY7r33XkNMeno6NBoNdu/ebZi3Zs0adOjQAUOHDsWIESPQr18/LFu2zCjXunXrMHbsWNjZ2UluHhERERERERFR86P4J1cAMHPmTEyfPh2TJk3C7NmzMXv27FrLp6WlwdnZGd26dTPMc3V1xdq1a03GXLt2DRs2bMDhw4dlqkhERERERERE1GxJdehER0cjNTUVWVlZ9XqrVEJCAmbMmAEXF5d650hPT8fixYvRpk0bmSrCamguLOyUj61za7+bVL4SLyEVBwCWxRqpOKu9DtI5Uxf1qrtQDdr985B0zuzpfaTirEy/5KxO1370rrtQDSqG3JDOqa+U/72l7oy9VFyJs7V0TvsyubjJ92+XznmzsuY35dWlvIuFdM6rAXLnS/Ip+TfnnXX2kIp7O+xb6ZyeukLp2FtCrn1n9PhBOufLe0fLBd6SP8+snOUOeqsTcucnAGxz6SQVtzJslXTOMTuelorrdM/v0jmvX24hHduu1ZW6C9XgUGaAdM5rHnLXBcsi+ePvk58HSsVZWMvfZyzZOFwqTlshd38CAB+O+1Qq7p8/Py6ds2tAlnSsjeUtqbjXfv6HdE5UyrXv7yVy3y0A0L6z3PltqauUzjmh80GpuBXXB0jn1Au5tn187I/SOT89+dcPEaF3kjtuAcDRtlwqruSs/HehR68cqTgHa8mbVQCXix2l4u7plqk4pqKoDMqjzFclNKiE/PfE3c5ctk2qQwcApk2bVu+y8+bNU7z+Hj16oEePHorjiIiIiIiIiIiaO/MYupmIiIiIiIiIiAwUd+jk5ubCw8MD6enpjVCd21JSUuDj44OioqJGy0FEREREREREZK4Ud+jMmTMHMTExCAgIAAA8//zzCAsLg06nQ0hISJ3xeXl5+Oc//4l77rkHtra28PPzw/PPP4+CggJDmeDgYPTu3Rvvvfee0uoRERERERERETV7isbQKS4uxooVK7Bt2zaj+U8++SQOHTqEEydO1LmO7OxsZGdnY/78+QgODkZGRgaefvppZGdnY8OGDYZyEydOxKRJkxAfHw9LS+mhfoiIiIiIiIioAemFFnrRfEdwMZdtU9RTkpCQAJ1Oh969exvmLVy4EABw9erVenXodO7cGV9//bXhc2BgIObMmYMnnngCFRUVhs6b++67D3l5edizZw+GDh2qpJpERERERERERM2aom6nxMREhIWFNXglCgoK4OjoaPQkjrW1NUJCQpCYmFhrbFlZGQoLC40mIiIiIiIiIqLmTFGHTkZGBry9vRu0AteuXcNbb72FyZMnV1vm7e2NjIyMWuPnzp0LJycnw+Tr69ug9SMiIiIiIiIiutso6tApKSmBjY1NgyUvLCxEdHQ0goODMXv27GrLbW1tUVxcXOs64uPjUVBQYJguXrzYYPUjIiIiIiIiImOVACqhacaTeVA0ho6bmxvy8/MbJPGNGzcQFRWFFi1a4JtvvoGVlVW1Mnl5eQgMDKx1PTqdDjqdrkHqRERERERERERkDhQ9oRMaGoqUlBTVSQsLCxEREQFra2t89913Jp/6OXnyJEJDQ1XnIyIiIiIiIiJqThR16ERGRiI5OdnoKZ1z584hKSkJOTk5KCkpQVJSEpKSklBeXl7jOqo6c4qKirBixQoUFhYiJycHOTk5qKz848Gm9PR0ZGVlYdiwYZKbRkRERERERETUPCn6yVWXLl3QvXt3rF+/HlOmTAEAPPXUU9izZ4+hTNUTNWlpaQgICAAAaDQarFy5ErGxsTh69CgOHToEAAgKCjJa/50x69atQ0REBPz9/aU2jIiIiIiIiIiouVLUoQMAM2fOxPTp0zFp0iRotVrs3r271vJpaWmwtLRE3759AQCDBg2CEKLWmPLycixduhRr165VWj0iIiIiIiIiakR6oYVeKPrBj1kxl21T3KETHR2N1NRUZGVl1esV4QkJCZg8eTLatWtX7xyZmZmYMWOGoRNIxo1ia1hA+WDJesfaO5tMsSjRSMUBgEWZXFxBB/mxt1uct5CKy57eRzqn97z9f3nO4k6lUnHWp1pI57Su/cVstdJWyMVpTttK5ywKLZGKW3xgiHTOJYM/l4orbmktnXPTta5ScW6+16VzFv/sJhW30GWodM4Axzzp2J+Pt5eKi+2zTzrn3P5fS8W9nTxCOmdFhdwXdJ9Rx6Vz/nyxjVTc+EsTpXO+O3i9VNyKi/2lc8b2+lk69mGnI1JxVm310jnfzh4uFXeqdc0/K6+Pbu3k3saZlu8qnbP4rLNUXGWg/Bfa1F3jpOIs7CW/CAGc+an2F2nUxjpE7qUfFjr5e7GI9qek4lLyvaRzns2Ui+0emCGd00oj10a22Yr/TDGwCZQ7jj45OEA+Z3b1F7zUV6W/3B8DHQMuSedM2x0gFVdxj/x14eJ5d6k4jYrrgiiSPI50yr9b9CVyf3cQqSF1hE+bNq3eZZ977jnF6w8KCqr2cywiIiIiIiIiIrpN8T9T5ubmwsPDA+np6Y1QndtSUlLg4+ODoqKiRstBRERERERERGSuFHfozJkzBzExMQgICMDx48cxZswY+Pr6wtbWFh07dsSCBQvqtY4+ffrAzs4Ozs7O1ZYHBwejd+/eeO+995RWj4iIiIiIiIgaUaXQNvvJHCiqZXFxMVasWIG4uDgAwJEjR+Dh4YHVq1cjOTkZr776KuLj4/Hhhx/Wup7y8nKMHj0azzzzjMkyEydOxJIlS1BRIf+bSSIiIiIiIiKi5kjRGDoJCQnQ6XTo3bs3AODJJ580Wt62bVscOHAAGzduxNSpU02u54033gAArFq1ymSZ++67D3l5edizZw+GDpUfIJSIiIiIiIiIqLlR9IROYmIiwsLCai1TUFAAV1f5NzFUsba2RkhICBITE1Wvi4iIiIiIiIioOVH0hE5GRga8vb1NLt+/fz++/PJLbNmyRXXFAMDb2xsZGbW/JrGsrAxlZX+86q+wsLBBchMRERERERER3a0UdeiUlJTAxsamxmUnT55ETEwMZs2ahYiIiAapnK2tLYqLi2stM3fuXMNPuIiIiIiIiIiocQlooIemqavRaISZbJuin1y5ubkhPz+/2vyUlBQMHToUkydPxmuvvdZglcvLy4O7u3utZeLj41FQUGCYLl682GD5iYiIiIiIiIjuRoo6dEJDQ5GSkmI0Lzk5GYMHD8aECRMwZ86cBq3cyZMnERoaWmsZnU4HR0dHo4mIiIiIiIiIqDlT1KETGRmJ5ORkw1M6J0+exODBgxEREYEXX3wROTk5yMnJwdWrV2tdT2ZmJpKSkpCZmYnKykokJSUhKSkJN2/eNJRJT09HVlYWhg0bJrFZRERERERERETNl6IOnS5duqB79+5Yv349AGDDhg24evUqVq9ejVatWhmme++91xCTnp4OjUaD3bt3G+bNnDkToaGhmDVrFm7evInQ0FCEhobi8OHDhjLr1q1DREQE/P39VW4iERERERERETWUSqFt9pM5UFzLmTNnYsGCBdDr9Zg9ezaEENWm9PR0Q/m0tDQ4OzujW7duhnmrVq2qMW7QoEEAgPLycixduhSvv/666g0kIiIiIiIiImpMH330EQICAmBjY4NevXrhl19+qbX8Bx98gHvuuQe2trbw9fXFCy+8gNLSUkU5Fb3lCgCio6ORmpqKrKws+Pr61lk+ISEBM2bMgIuLS71zZGZmYsaMGejbt6/S6hk42pfBwk55XK6P4iYBAHRvU/vr1WtzfFsHqTibHAvpnLfs5eKsan/pWK2yp/eRivOet18658UNnaXiSttIp4TViZrfBFev2BtCKs6iTH4U9lvZcvW1uyafc2n7QVJxZ3YFSufUO8i1bauel6Vz/ubvLBWnP+AlnbPr/dnSsdauyr5Aqvwvuad0zrGdfpWKK85ykM5p0bJMKu7HM/dI5/xHpySpuNa669I53z0TKRW3v/sa6ZxRKQ9Lx6451UMqLqb9b9I5C8ttpeIcT1pL58w83FYqrrS1dEqIwBKpuM6tL0nntLMsl4o7mCrXPgAw9ZHvpWMPXJf7fnG2kmtbAPC3vSYVt/WXbnUXMmHt8MVScf8+O1o652krue+01oPlX3SSfV1uTE0rR7nvBwAou6XiX/Mr5GJPn/CTTunTR+78vpjpJp0zrMsFqbgjJ+WvC76BtQ8FYkpOfgvFMXqN3HWPmocvv/wSL774IpYuXYpevXrhgw8+QGRkJM6cOQMPD49q5deuXYtXXnkFn376Kfr06YOzZ88iNjYWGo0G7733Xr3zSvVeTJs2rd5l582bp3j9QUFBCAoKUhxHRERERERERPRXeu+99zBp0iRMnDgRALB06VJs2bIFn376KV555ZVq5ffv34++ffvi8ccfBwAEBARgzJgxOHTokKK85vHDMCIiIiIiIiKiu0x5eTmOHDli9EInrVaLYcOG4cCBAzXG9OnTB0eOHDH8LOvChQtISEjAiBEjFOWW6tDJzc2Fh4eH0Vg5DW3r1q0ICQmBXq9vtBxEREREREREpIxeaJr9BACFhYVGU1lZ9Z9mXrt2DZWVlfD09DSa7+npiZycnBrb7/HHH8ebb76Jfv36wcrKCoGBgRg0aBBmzJihaD9IdejMmTMHMTExCAgIwPHjxzFmzBj4+vrC1tYWHTt2xIIFC2qNT09PR1xcHNq0aQNbW1sEBgZi1qxZKC//43eHUVFRsLKywpo18r/lJyIiIiIiIiKS4evrCycnJ8M0d+7cBlnv7t278c4772Dx4sU4evQoNm7ciC1btuCtt95StB7FY+gUFxdjxYoV2LZtGwDgyJEj8PDwwOrVq+Hr64v9+/dj8uTJsLCwwNSpU2tcx+nTp6HX6/Hxxx8jKCgIJ0+exKRJk1BUVIT58+cbysXGxmLhwoUYN26c0moSEREREREREUm7ePEiHB3/GGhdp9NVK+Pm5gYLCwtcvmz8MpXLly/Dy6vmgeFff/11jBs3Dk899RQAoEuXLigqKsLkyZPx6quvQqut37M3ijt0EhISoNPp0Lt3bwDAk08+abS8bdu2OHDgADZu3GiyQycqKgpRUVFGMWfOnMGSJUuMOnRGjhyJqVOn4vz58wgMlH+7DRERERERERGREo6OjkYdOjWxtrZGWFgYfvzxR4waNQoAoNfr8eOPP5rsEykuLq7WaWNhcfst1kLU/+28ijt0EhMTERYWVmuZgoICuLq6KlpvTTF+fn7w9PREYmIiO3SIiIiIiIiI7gKV0KKyGb9jSem2vfjii5gwYQJ69OiBnj174oMPPkBRUZHhrVfjx49H69atDT/ZGjlyJN577z2EhoaiV69eOHfuHF5//XWMHDnS0LFTH4o7dDIyMuDt7W1y+f79+/Hll19iy5Yt9V7nuXPnsGjRIqOnc6p4e3sjIyPDZGxZWZnRwESFhYX1zktEREREREREpMajjz6Kq1evYubMmcjJyUFISAi2bt1qGCg5MzPT6Imc1157DRqNBq+99hqysrLg7u6OkSNHYs6cOYryKu7QKSkpgY2NTY3LTp48iZiYGMyaNQsRERH1Wl9WVhaioqIwevRoTJo0qdpyW1tbFBcXm4yfO3cu3njjjfpVnoiIiIiIiIiogU2dOtXkT6x2795t9NnS0hKzZs3CrFmzVOVU/IyUm5sb8vPzq81PSUnB0KFDMXnyZLz22mv1Wld2djYGDx6MPn36YNmyZTWWycvLg7u7u8l1xMfHo6CgwDBdvHixfhtCRERERERERGSmFHfohIaGIiUlxWhecnIyBg8ejAkTJtT7EaGsrCwMGjQIYWFhWLlyZY2jOJeWluL8+fMIDQ01uR6dTmcYqKg+AxYREREREREREZk7xT+5ioyMRHx8PPLz8+Hi4oKTJ09iyJAhiIyMxIsvvoicnBwAt0doNvVkTVVnjr+/P+bPn4+rV68alt35Wq+DBw9Cp9MhPDxcaTWJiIiIiIiIqBHohQZ6oWnqajQac9k2xU/odOnSBd27d8f69esBABs2bMDVq1exevVqtGrVyjDde++9hpj09HRoNBrD78Z27NiBc+fO4ccff4SPj49R3J3WrVuHsWPHws7OTsUmEhERERERERE1L1LvGZs5cyYWLFgAvV6P2bNnQwhRbUpPTzeUT0tLg7OzM7p16wYAiI2NrTHmzvetX7t2DRs2bMDLL7+sbguJiIiIiIiIiJoZxT+5AoDo6GikpqYiKysLvr6+dZZPSEjAjBkz4OLiUu8c6enpWLx4Mdq0aSNTRVy75AStbc1v46qN029WUvmOaP2k4gCg49ALUnGZG9pK53QemS0Vd+1H06+sr0txp1KpuIsbOkvn9H34pFTcte/bS+fsP+aEdOyPX/aUiot5PFE657aF/aTi7B+TO4YAIGN9oFRcWU+5YwgALC7rpOLSv5M/z3ROou5CNQiNOCWdc3dGkHSs5XEHqbhbXpXSOb/4foBUnPC6JZ3TxrZcKq61U4F0zlOFXnUXqsH+UrnvQADIT6v/d+6dQg/9SzqnS78c6dhJnX+WiluaJHcMAfLHwsMT90jn/CrV9LiAtfFxLpTOmZblJhVnqZU/t9e2+UkqblXLZOmc/3dqmHTszav2UnGureSvC1t+7yYV5+Zf/eUk9TVpyT+l4krd5L7PAKB1X7k2KquQ+jMFADC23WGpuJxy+bE4E7LCpGOtrsr9/dHi3qt1FzIhJ7+FVFyX9vIvoDl6Qe7vpV5dz0nnPJQid8+5ZPDnimOKb1RitFQ2InnSV8pp06bVu+y8efMUr79Hjx7o0aOH4jgiIiIiIiIiajx6aKGX+8GPWTCXbTOPWhIRERERERERkYFUh05ubi48PDyMxslpaFu3bkVISAj0en2j5SAiIiIiIiIiMkdSHTpz5sxBTEwMAgICAACZmZmIjo6GnZ0dPDw8MH36dFRUVNS6jgceeAB+fn6wsbFBq1atMG7cOGRn/zEmR1RUFKysrLBmzRqZKhIRERERERERNVuKO3SKi4uxYsUKxMXFAQAqKysRHR2N8vJy7N+/H5999hlWrVqFmTNn1rqewYMHY/369Thz5gy+/vprnD9/Hg8//LBRmdjYWCxcuFBpFYmIiIiIiIiImjXFgyInJCRAp9Ohd+/eAIDt27cjJSUFO3fuhKenJ0JCQvDWW2/h5ZdfxuzZs2FtbV3jel544QXD//v7++OVV17BqFGjcOvWLVhZ3R7pfeTIkZg6dSrOnz+PwEC5EcqJiIiIiIiIqOFUCg0qhaapq9FozGXbFD+hk5iYiLCwP17Ld+DAAXTp0gWenp6GeZGRkSgsLERycv1ePZmXl4c1a9agT58+hs4cAPDz84OnpycSE02/krmsrAyFhYVGExERERERERFRc6a4QycjIwPe3t6Gzzk5OUadOQAMn3Nycmpd18svvwx7e3u0bNkSmZmZ2LRpU7Uy3t7eyMjIMLmOuXPnwsnJyTD5+voq2RwiIiIiIiIiIrOjuEOnpKQENjY2DZJ8+vTpOHbsGLZv3w4LCwuMHz8eQgijMra2tiguLja5jvj4eBQUFBimixcvNkjdiIiIiIiIiIjuVorH0HFzc0N+fr7hs5eXF3755RejMpcvXzYsq2tdbm5uaN++PTp27AhfX18cPHgQ4eHhhjJ5eXlwd3c3uQ6dTgedTqd0M4iIiIiIiIhIgl5ooDeTcWZkmMu2KX5CJzQ0FCkpKYbP4eHh+O2333DlyhXDvB07dsDR0RHBwcH1Xq9erwdwe0ycKqWlpTh//jxCQ0OVVpOIiIiIiIiIqNlS3KETGRmJ5ORkw1M6ERERCA4Oxrhx43D8+HFs27YNr732Gp577jmTT84cOnQIH374IZKSkpCRkYFdu3ZhzJgxCAwMNHo65+DBg9DpdEbziIiIiIiIiIj+7hR36HTp0gXdu3fH+vXrAQAWFhbYvHkzLCwsEB4ejieeeALjx4/Hm2++aYhJT0+HRqPB7t27AQB2dnbYuHEjhg4dinvuuQdxcXHo2rUr9uzZY9QJtG7dOowdOxZ2dnYqN5OIiIiIiIiIqPlQPIYOAMycORPTp0/HpEmToNVq4e/vj4SEBJPl09LS4OzsjG7dugG43Sm0a9euWnNcu3YNGzZswOHDh2WqCE2xBTTCQnGcy8gsqXxl+1pLxQFAWKdMqbjcaPmOrsKNraTiKobckM5pfaqFVFxpG+mUuPZ9e6k4t5FnpXP++J8+0rE3Ayuk4jZ/2l86Z3DcKam4XzP8pXNqB9yUimtxwEE6p1WRqLtQDfK6VkrntMtSfg0CgDN5pscNq0vlabnzDACc+l6VimuhkWtbALh80UUqzibTWjqnk0+eVNzZi551FzLBxyu/7kI1CHWT+04CgBz7Qqm4k9ly3w8AkH3BTTp2i7aLVNzLYdukc9pry+ouVIP/OzNMOue3934sFRf10/PSOR2cTb9cojZJvwRJ5wz8VS52eP9j0jlvXpL/jtA4yH3/9vKSu4cDgJ+OyJ0vujZydQWAin5y17/K352kcyZfrn1MTVNKfpf/PvuqVG58zeJS+e+WgX1PSsfuuSB/rsmqzJH7OyLVQv4eRaOVu1940jNROue0Vjuk4p448JTiGH1xKYC3pPIRyZLq0ImOjkZqaiqysrLq9ZrwhIQEzJgxAy4u9b9xT09Px+LFi9GmjYq/5omIiIiIiIioQQmhhV4o/sGP2RBmsm1SHToAMG3atHqXnTdvnuL19+jRAz169FAcR0RERERERETU3El1O+Xm5sLDwwPp6ekNXJ0/bN26FSEhIYa3XxERERERERER0W1SHTpz5sxBTEwMAgICkJubi6ioKHh7e0On08HX1xdTp05FYWHtv93Py8vD2LFj4ejoCGdnZ8TFxeHmzT/G1YiKioKVlRXWrFkjU0UiIiIiIiIiomZLcYdOcXExVqxYgbi4uNsr0GoRExOD7777DmfPnsWqVauwc+dOPP3007WuZ+zYsUhOTsaOHTuwefNm7N27F5MnTzYqExsbi4ULFyqtIhERERERERE1kkpomv1kDhR36CQkJECn06F3794AABcXFzzzzDPo0aMH/P39MXToUDz77LNITDQ9GvmpU6ewdetWLF++HL169UK/fv2waNEifPHFF8jOzjaUGzlyJA4fPozz589LbBoRERERERERUfOkuEMnMTERYWFhJpdnZ2dj48aNGDhwoMkyBw4cgLOzs9Ggx8OGDYNWq8WhQ4cM8/z8/ODp6Vlr5xARERERERER0d+N4g6djIwMeHt7V5s/ZswY2NnZoXXr1nB0dMTy5ctNriMnJwceHh5G8ywtLeHq6oqcnByj+d7e3sjIyDC5rrKyMhQWFhpNRERERERERETNmeIOnZKSEtjY2FSb//777+Po0aPYtGkTzp8/jxdffLFBKmhra4vi4mKTy+fOnQsnJyfD5Ovr2yB5iYiIiIiIiIjuVpZKA9zc3JCfn19tvpeXF7y8vNChQwe4urqif//+eP3119GqVasay165csVoXkVFBfLy8uDl5WU0Py8vD+7u7ibrEx8fb9R5VFhYyE4dIiIiIiIiokaiF4BemMfAwTL0oqlrUD+Kn9AJDQ1FSkpKrWX0ej2A2z+Hqkl4eDiuX7+OI0eOGObt2rULer0evXr1MswrLS3F+fPnERoaajKXTqeDo6Oj0URERERERERE1JwpfkInMjIS8fHxyM/Ph4uLCxISEnD58mXce++9cHBwQHJyMqZPn46+ffsiICCgxnV07NgRUVFRmDRpEpYuXYpbt25h6tSpeOyxx4zG5zl48CB0Oh3Cw8OlN5CIiIiIiIiIqLlR/IROly5d0L17d6xfvx7A7TFuPvnkE/Tr1w8dO3bECy+8gAceeACbN282xKSnp0Oj0WD37t2GeWvWrEGHDh0wdOhQjBgxAv369cOyZcuMcq1btw5jx46FnZ2d5OYRERERERERETU/ip/QAYCZM2di+vTpmDRpEgYPHoz9+/fXWj4tLQ3Ozs7o1q2bYZ6rqyvWrl1rMubatWvYsGEDDh8+LFNFIiIiIiIiImoEeqGFXih+PsRsmMu2SXXoREdHIzU1FVlZWfUagDghIQEzZsyAi4tLvXOkp6dj8eLFaNOmjUwVYeVVBAu7SsVx3VyzpPKV9LKSigOAz3cNkIqz8CqRzmnlKjeAlb5S/sC2Nv2yslpZnaj+VrX66j/mhFTcj//pI53Te37tHZy1ydrYSSpOn+oknTPpUmupOOvf5J+cqwi5KRVX1FPyIAJgd0Suvtb58se8heQpWnzYTTpnaMRp6dgL11tKxXV3/106Z7b9Dam4oiBr6ZznLnjVXagGrl4F0jkvXpRr299z6v+9+We7By+UijvtLZ/z+bVPSce6di6Sitt8pat0zgu5cvulvEzq9gkA8EzqGOlYWUVpct8RVkXyg11qKv/6gTItb1hIx+rL5K71bWyvSucsifpNKu5gQhfpnLGjd0jFfaeTz9nbPV0qLsPDVTrn0eOBUnGegdekc3rqCqVjo9qdkoq7UuYgnTNXyF3//FvmSedMPS734pr3MiOkc/5+3VkqTlzRKY8pNZNRdKlZkb4jmTZtWr3Lzps3T/H6e/TogR49eiiOIyIiIiIiIiJq7szjOSIiIiIiIiIiIjJQ3KGTm5sLDw8PpKenN0J1bktJSYGPjw+KiuQevyYiIiIiIiIias4Ud+jMmTMHMTExCAgIQG5uLqKiouDt7Q2dTgdfX19MnToVhYW1/4Z0zpw56NOnD+zs7ODs7FxteXBwMHr37o333ntPafWIiIiIiIiIqBHpoWn2kzlQ1KFTXFyMFStWIC4u7nawVouYmBh89913OHv2LFatWoWdO3fi6aefrnU95eXlGD16NJ555hmTZSZOnIglS5agoqJCSRWJiIiIiIiIiJo9RYMiJyQkQKfToXfv3gAAFxcXo04Zf39/PPvss3UOgvzGG28AAFatWmWyzH333Ye8vDzs2bMHQ4cOVVJNIiIiIiIiIqJmTdETOomJiQgLCzO5PDs7Gxs3bsTAgQNVV8za2hohISFITEystVxZWRkKCwuNJiIiIiIiIiKi5kxRh05GRga8vb2rzR8zZgzs7OzQunVrODo6Yvny5Q1SOW9vb2RkZNRaZu7cuXBycjJMvr6+DZKbiIiIiIiIiKqrFJpmP5kDRR06JSUlsLGxqTb//fffx9GjR7Fp0yacP38eL774YoNUztbWFsXFxbWWiY+PR0FBgWG6ePFig+QmIiIiIiIiIrpbKRpDx83NDfn5+dXme3l5wcvLCx06dICrqyv69++P119/Ha1atVJVuby8PAQGBtZaRqfTQafTqcpDRERERERERGROFD2hExoaipSUlFrL6PV6ALfHtlHr5MmTCA0NVb0eIiIiIiIiIqLmRNETOpGRkYiPj0d+fj5cXFyQkJCAy5cv495774WDgwOSk5Mxffp09O3bFwEBASbXk5mZiby8PGRmZqKyshJJSUkAgKCgIDg4OAAA0tPTkZWVhWHDhklvHBERERERERFRc6ToCZ0uXbqge/fuWL9+PYDbY9x88skn6NevHzp27IgXXngBDzzwADZv3myISU9Ph0ajwe7duw3zZs6cidDQUMyaNQs3b95EaGgoQkNDcfjwYUOZdevWISIiAv7+/io3kYiIiIiIiIgail5om/1kDhQ9oQPc7oyZPn06Jk2ahMGDB2P//v21lk9LS4OzszO6detmmLdq1SqsWrXKZEx5eTmWLl2KtWvXKq0eEREREREREVGzp7hDJzo6GqmpqcjKyqrXK8ITEhIwY8YMuLi41DtHZmYmZsyYgb59+yqtnkGIdzas7K0Vx+3PaSOVr+yW4qY08Ot8SSou46yXdM4K70qpON0Ze+mc2gq5OKsbQjrnj1/2lIq7GShZWQBZGztJx7Z+MFkq7vf4PtI5rfY5SsVp5A4hAIBeK7dPdb/YySftX31A9/rQJNX/2vVnRb1qf0ufKZaW8o2bvKmDdKxG8rDf5ttSOufwfsek4rac6CKdc8ngz6XiXlwVJ58zdoVU3OeX5c/tgZvl3jgZ0O6ydM6J/9gpHXu6SO477VG3X6RzJth3lYr7/rD8+H6FLaq/LbReJK+bAKDxkBvXcHrUD9I5K5U9BG7w/36Jks4Z3CtdOvbURbnjr4W2VDpnWqHctdN/UIZ0zh8uyd2jXDrjIZ2zW8BeqbgfvuktnbPD0HSpuLOX5Lfzuz39pGNl345c1lIvnbNlx1ypuNxiFX8LeMqdL+dU7JcQP7k3IKdqlbdtZbH6MWSJlJLqhZg2bVq9y86bN0/x+oOCghAUFKQ4joiIiIiIiIjo70Dqn09yc3Ph4eGB9PT0Bq7OH7Zu3YqQkBDDW7OIiIiIiIiIqOnpoYFeNOMJko/O/cWkOnTmzJmDmJgYBAQE4Pjx4xgzZgx8fX1ha2uLjh07YsGCBXWu44EHHoCfnx9sbGzQqlUrjBs3DtnZ2YblUVFRsLKywpo1a2SqSERERERERETUbCnu0CkuLsaKFSsQF3d7LIEjR47Aw8MDq1evRnJyMl599VXEx8fjww8/rHU9gwcPxvr163HmzBl8/fXXOH/+PB5++GGjMrGxsVi4cKHSKhIRERERERERNWuKx9BJSEiATqdD7963Byp78sknjZa3bdsWBw4cwMaNGzF16lST63nhhRcM/+/v749XXnkFo0aNwq1bt2BlZQUAGDlyJKZOnYrz588jMDBQaVWJiIiIiIiIiJolxU/oJCYmIiwsrNYyBQUFcHV1rfc68/LysGbNGvTp08fQmQMAfn5+8PT0RGJiotJqEhERERERERE1W4qf0MnIyIC3t7fJ5fv378eXX36JLVu21Lmul19+GR9++CGKi4vRu3dvbN68uVoZb29vZGSYfj1jWVkZysr+eEVcYWFhnXmJiIiIiIiISI6A+QwcLEOYybYpfkKnpKQENjY2NS47efIkYmJiMGvWLERERNS5runTp+PYsWPYvn07LCwsMH78eAghjMrY2tqiuLjY5Drmzp0LJycnw+Tr66tsg4iIiIiIiIiIzIziJ3Tc3NyQn59fbX5KSgqGDh2KyZMn47XXXqv3utzc3NC+fXt07NgRvr6+OHjwIMLDww1l8vLy4O7ubnId8fHxePHFFw2fCwsL2alDRERERERERM2a4id0QkNDkZKSYjQvOTkZgwcPxoQJEzBnzhypiuj1egAw+vlUaWkpzp8/j9DQUJNxOp0Ojo6ORhMRERERERERUXOm+AmdyMhIxMfHIz8/Hy4uLjh58iSGDBmCyMhIvPjii8jJyQEAWFhYmHyy5tChQ/j111/Rr18/uLi44Pz583j99dcRGBho9HTOwYMHodPpjOYRERERERERUdPRCw30wjzGmZFhLtum+AmdLl26oHv37li/fj0AYMOGDbh69SpWr16NVq1aGaZ7773XEJOeng6NRoPdu3cDAOzs7LBx40YMHToU99xzD+Li4tC1a1fs2bMHOp3OELdu3TqMHTsWdnZ2KjeTiIiIiIiIiKj5UPyEDgDMnDkT06dPx6RJkzB79mzMnj271vJpaWlwdnZGt27dANzuFNq1a1etMdeuXcOGDRtw+PBhmSoSERERERERETVbUh060dHRSE1NRVZWVr0GIE5ISMCMGTPg4uJS7xzp6elYvHgx2rRpI1NFXCu1h6WFru6Cf3KjuOY3eNWl9IbyXFXKb0ntBrTrkCWdM6vASSquxNlaOqfmtK1UnEWZ/ONuMY8nSsVt/rS/dE59qlzbAsDv8X2k4nzm7pfO+Y+Uq1JxSz6Okc7p43pdKu6Cj710TmeLSqm4m21KpXNapckd83a/S6dEiYd8rKywe1OlYxMOhkjFWZQqfsDU4P2M+6TibjmKuguZ8K8vn5SKCxt0Wjqnzq1EKm6i78/SOZekDZSOzcl0lYp76r490jl/zGgvHSvrRrHc/YKDo9z+BICSM85Sce9qI6VzVl6Wu/45pcqf2/mecjkB4KPwtVJxH2QOk87Z1VXuPu7INfmXfwQ6XZOKu6ri+3dtdi+puPKO8sd8+q4AqTj/gfJfwJd6VEjH+rpcl4qztbwlnfNysYNU3JVr8uOVPtz5mFTc1oyO0jnvdz8hFfdWerTiGL3pFzMTNRq5ngQA06ZNq3fZefPmKV5/jx490KNHD8VxRERERERERETNnXSHDhERERERERH9/eiFFnoh/1Tl3c5ctk2qlrm5ufDw8EB6enoDV+cPW7duRUhIiOF15kREREREREREdJtUh86cOXMQExODgIAA5ObmIioqCt7e3tDpdPD19cXUqVNRWFhoMj49PR1xcXFo06YNbG1tERgYiFmzZqG8vNxQJioqClZWVlizZo1MFYmIiIiIiIiImi3FHTrFxcVYsWIF4uLibq9Aq0VMTAy+++47nD17FqtWrcLOnTvx9NNPm1zH6dOnodfr8fHHHyM5ORnvv/8+li5dihkzZhiVi42NxcKFC5VWkYiIiIiIiIioWVM8hk5CQgJ0Oh169+4NAHBxccEzzzxjWO7v749nn3221oGQo6KiEBUVZfjctm1bnDlzBkuWLMH8+fMN80eOHImpU6fi/PnzCAwMVFpVIiIiIiIiImpgeqGBXsi/jfhuZy7bpvgJncTERISFhZlcnp2djY0bN2LgQGWvLi0oKICrq/ErS/38/ODp6YnERNOvni4rK0NhYaHRRERERERERETUnCnu0MnIyIC3t3e1+WPGjIGdnR1at24NR0dHLF++vN7rPHfuHBYtWoQpU6ZUW+bt7Y2MjAyTsXPnzoWTk5Nh8vX1rXdeIiIiIiIiIiJzpLhDp6SkBDY2NtXmv//++zh69Cg2bdqE8+fP48UXX6zX+rKyshAVFYXRo0dj0qRJ1Zbb2tqiuLjYZHx8fDwKCgoM08WLF+u/MfT/sXf3cVGW+f7AP8ODNyAiozxOgCj0gC3KACaobZoltByj36m2ddUyWczSNfVE7bCF5UZ0lo672Umt1mx3NY3U04NNpuVqsytYVFRKKSIzEIoKw4M6MIDM7w9P00483l/1tEyf9+t1v17OPdfn+l43DjPj5X1fNxERERERERENQqrX0AkKCkJjY2O3/WFhYQgLC8M111yDESNG4Prrr8djjz2G8PDwXvs6fvw4pk2bhkmTJuHFF1/ssY3VakVwcHCvfSiKAkVR1B4GEREREREREdGgpXpCR6/XY+PGjX226erqAnBhfZve1NbWYtq0aUhKSsKGDRvg4dH9ZKG2tjZUVlZCr9erHSYRERERERERXQZd0KALg2PhYInBcmyqJ3TS0tJgMBjQ2NgIrVYLo9GIkydPYsKECfD398ehQ4eQk5ODyZMnIzo6usc+amtrMXXqVIwaNQrPPPMMTp8+7XwuLCzM+eeSkhIoioLU1FT1R0ZERERERERE5KZUr6ETHx+PxMREFBUVAbiwxs1LL72EKVOmIC4uDsuWLcOtt96KHTt2ODNmsxkajQZ79+4FAOzevRtHjx7FBx98gIiICISHhzu3f7Z582bMnj0bfn5+F3GIRERERERERETuRfUZOgCQl5eHnJwcZGdnY9q0adi/f3+f7auqqhAYGIjx48cDAObNm4d58+b1mamvr8fWrVtRWloqGSIRERERERERkdsSTehkZGSgoqICtbW1A7pNuNFoRG5uLrRa7YBrmM1mrFmzBqNHj5YMEcebAuDZ3v1uXP3x8+l93Z++tDWqr/Wt80f9RbkqhywHAN5nZdcEDpX9eAAA5/StolzHcfnP9r3VU0S5sVlfiWuWnbhCnPX+e4Ao9//KT/ffqBf/M7b3Rcf70vakQ1zzG1P/7xs90fh3iWva2mSLpw/9Uv76mzGrRJSL9LGKa26okF+iOty3TZT7rFr29wkAKYlHRLmxw06Ia1baZK/5o94R4prrbn9JlFv86S/FNa+LtIhyBV/eIq7ZdUT+uXRViuwulfNK5otrKj4d4qxU5MgmUe7o0bD+G/Vi2NWymiOH9n6X0f7cn/SGKHekrfebafRnu3m8OPvrrbLX0W9v2yau+VzFVFGu87ynuGbp2ShRrt0i/90+H9giynU1DRHXHDO9SpQ7dFT+He6q0XXibNVHss/R8z7y72LXJppFOcdI+boib70xSZRrC+8U11zZ8m+inNcQ9TU13udFtQarLocGXY7Bsc6MxGA5NtGEDgAsXbp0wG0LCwtV95+cnIzk5GTVOSIiIiIiIiIid6d6DZ2GhgaEhITAbDZfhuFcUF5ejoiICJw7d+6y1SAiIiIiIiIiGqxUT+jk5+cjMzPTeQerJUuWICkpCYqiICEhYUB93HfffYiJiYGvry+Cg4ORmZmJr7/+2vn82LFjkZKSglWrVqkdHhERERERERGR21M1oWOz2bB+/XpkZWW57J8/fz7uuuuuAfeTlJSEDRs24KuvvsJ7770Hh8OBGTNm4Pz57647vPfee7F27Vp0dsqvmSQiIiIiIiIickeq1tAxGo1QFAUpKSnOfatXrwYAnD59Gl988cWA+lmwYIHzz9HR0XjyyScxfvx4mM1mxMTEAABuvvlmWK1W7Nu3D9OnT1czTCIiIiIiIiK6TLgo8r8GVWfomEwmJCUlXdIBnDt3Dhs2bMDo0aNd7pg1ZMgQJCQkwGQyXdJ6RERERERERESDnaoJHYvFAp1Od0kKr1mzBv7+/vD398e7776L3bt3Y8gQ19sT6nQ6WCx933bVbrejpaXFZSMiIiIiIiIicmeqJnRaW1vh4+NzSQrPnj0bn332Gfbt24errroKP//5z9HW1ubSxtfXFzabrc9+CgoKMHz4cOf2z2f5EBERERERERG5I1UTOkFBQWhsbLwkhYcPH44rr7wSP/3pT7F161Z8/fXX+J//+R+XNlarFcHBwX32YzAY0Nzc7NxqamouyfiIiIiIiIiIqLtv19Bx520wUDWho9frUV5efskH4XA44HA4YLfbXfYfPHgQer2+z6yiKAgICHDZiIiIiIiIiIjcmaoJnbS0NBw6dMjlLJ2jR4+irKwMdXV1aG1tRVlZGcrKytDe3t5jH8eOHUNBQQE++eQTVFdXY//+/bjzzjvh6+uLn/3sZ852ZrMZtbW1uOmmm4SHRkRERERERETknlRN6MTHxyMxMRFFRUXOfb/61a+g1+vxwgsv4MiRI9Dr9dDr9Th+/LizjUajwSuvvAIA8PHxgclkws9+9jPExsbirrvuwrBhw7B//36EhIQ4M5s3b8aMGTMwatSoizxEIiIiIiIiIiL34qU2kJeXh5ycHGRnZ8PDwwN79+7ts31VVRW8vLwwefJkABfuXGU0GvvMtLe3Y926dXj11VfVDo+IiIiIiIiIyO2pntDJyMhARUUFamtrB3RHKaPRiAULFuDKK68ccI3q6mrk5uY6J4EkHA4NHIKFjCaHV4nq7Wq9RpQDAMdw2YJLt19VJq75+nuyn+2Cf9slrrmm+EZRzq9eviDV0F8c779RDz62yM8MG/KlnzirOS/LrX0hU1yz7UmHKBf9aLG45rH/TBXlhtaqOqnQRUe07DhbQ2U5APiqJUyUe+/1FHFN7zPiKM51yo7VO1j+Oxod1yDKhXs3iWuGD5dlPxkdIa6ZVyH7He362l9cM3jMWVEuLrROXPMryF7zAFD1kewulf+eLn8v2nHsWlHOw79DXLOuZZgoFxldL67pP8Tef6Me/GZU3/8B15d5H2aJcp5DhB+EADrPeouznlGtolzmULO45jXXbhbl3j0zTlxz13HZ99XT4ar/yeDU2iH7e3F4yj9/jxRHi3LDTss/z04Fy9+vO0Jl7ynaoIv40Be6LsQizhqvlv2MAv8h/27tdUuTKNdg0arOdLUOjkV0L5XBtHCwxGA5NtG789KlSwfcdtGiRar7j42NRWxsrOocEREREREREdGPgfy/u4mIiIiIiIiI6AchmtBpaGhASEgIzGbzJR7Od3bu3ImEhAR0dXVdthpERERERERERIORaEInPz8fmZmZiI6ORkNDA9LT06HT6aAoCiIjI7F48WK0tLT02cett96KqKgo+Pj4IDw8HHPnznW5M1Z6ejq8vb2xadMmyRCJiIiIiIiI6DJwAOiCxm03+Spe/7dUT+jYbDasX78eWVkXFrvz8PBAZmYm3nrrLRw5cgSvvPIK3n//fSxcuLDPfqZNm4aioiIcPnwY27ZtQ2VlJe644w6XNvPmzcPq1avVDpGIiIiIiIiIyK2pXhTZaDRCURSkpFy4C4tWq8X999/vfH7UqFF44IEHUFhY2Gc/y5Ytc8n85je/wW233YaOjg54e19YDX/mzJlYvHgxKisrERMTo3aoRERERERERERuSfUZOiaTCUlJSb0+f/z4cWzfvh033HDDgPu0Wq3YtGkTJk2a5JzMAYCoqCiEhobCZDL1mrXb7WhpaXHZiIiIiIiIiIjcmeoJHYvFAp1O123/rFmz4OfnhyuuuAIBAQH405/+1G9fjzzyCIYOHYqRI0eiuroab775Zrc2Op0OFoul1z4KCgowfPhw5xYZGanugIiIiIiIiIiIBhnVEzqtra3w8fHptv8Pf/gDPv30U7z55puorKzE8uXL++0rJycHn332GXbt2gVPT0/cfffdcDhclx/y9fWFzWbrtQ+DwYDm5mbnVlNTo/aQiIiIiIiIiGiAuhwat98GA9Vr6AQFBaGxsbHb/rCwMISFheGaa67BiBEjcP311+Oxxx5DeHh4n30FBQXhqquuQlxcHCIjI1FSUoLU1FRnG6vViuDg4F77UBQFiqKoPQwiIiIiIiIiokFL9Rk6er0e5eXlfbbp6uoCcGF9m4HqKdPW1obKykro9Xq1wyQiIiIiIiIicluqz9BJS0uDwWBAY2MjtFotjEYjTp48iQkTJsDf3x+HDh1CTk4OJk+ejOjo6B77OHDgAD7++GNMmTIFWq0WlZWVeOyxxxATE+Nydk5JSQkURXHZR0RERERERET0Y6f6DJ34+HgkJiaiqKgIwIU1bl566SVMmTIFcXFxWLZsGW699Vbs2LHDmTGbzdBoNNi7dy8AwM/PD9u3b8f06dNx9dVXIysrC+PGjcO+fftcLp/avHkzZs+eDT8/v4s8TCIiIiIiIiK6FH7o9W24hs4Fqs/QAYC8vDzk5OQgOzsb06ZNw/79+/tsX1VVhcDAQIwfPx7AhUmhPXv29Jmpr6/H1q1bUVpaKhkiEREREREREZHbEk3oZGRkoKKiArW1tQO6TbjRaERubi60Wu2Aa5jNZqxZswajR4+WDBGaL4dBo3S/G1d/djmuEdW7KvS0KAcAwcpZUW77W1PENcdMqRblzp5X/zP91tppfxHl1l01VVzTUhQjynn8VPZ3AgCdCfJsl4ej/0Y9iBjRJK75jan/3+GeHPtP+aWQYx4pFuXqHpwkrnn+8DBRbtgJ+ez8V0G9Lwrflx5uJDhgHf6y1xAAdAqzPiflP6Ndz08W5c7cfE5c09v7vCjX3u4prin9CZ33k/997jj6E1GuvVH+AvT9RvS1AgDQEd0uym3fJX8v8qmX/c3cO7fv/5Tqy7vHx4pyiUHyu3iajo8R5dadmCaumRxrFuXihtWJa37ZrBNnvzgQK8r95sR0cc3dX8WJckMD2sQ1bVUB4qxU7TlvUW7h5L+Ja3555gpRzmqXXxVwVcApcfb4yOGi3OH6EHHNK/1l4/3liBJxzbdbZOuiXv3Lr8U1D56UfReblnRIdab9bDteFVUjkhN/81q6dOmA2xYWFqruPzk5GcnJyapzRERERERERETuTvUaOgDQ0NCAkJAQmM3mSzyc7+zcuRMJCQnOu18REREREREREdEFogmd/Px8ZGZmOu9iVV1djYyMDPj5+SEkJAQ5OTno7OwcUF92ux0JCQnQaDQoKytz7k9PT4e3tzc2bdokGSIRERERERERXQY/9ILFXBT5AtUTOjabDevXr0dWVhYA4Pz588jIyEB7ezv279+PP//5z3jllVeQl5c3oP4efvhh6HQ9X/M8b948rF69Wu0QiYiIiIiIiIjcmuoJHaPRCEVRkJKSAgDYtWsXysvLsXHjRiQkJOCWW27B7373Ozz//PNob+97gcN3330Xu3btwjPPPNPj8zNnzkRpaSkqKyvVDpOIiIiIiIiIyG2pntAxmUxISkpyPi4uLkZ8fDxCQ0Od+9LS0tDS0oJDh3pfHfzkyZPIzs7GX//6V/j59byifFRUFEJDQ2EymdQOk4iIiIiIiIjIbam+y5XFYnG5RKqurs5lMgeA83FdXc+3nnQ4HJg3bx4WLlyI5OTkPhdX1ul0sFgsvT5vt9tht9udj1taWgZyGEREREREREQkMJjWmZEYLMem+gyd1tZW+Pj4XFTR5557DmfOnIHBYOi3ra+vL2w2W6/PFxQUYPjw4c4tMjLyosZGRERERERERPSvTvWETlBQEBobG52Pw8LCcPLkSZc23z4OCwvrsY89e/aguLgYiqLAy8sLsbGxAIDk5GTcc889Lm2tViuCg4N7HY/BYEBzc7Nzq6mpUXtIRERERERERESDiuoJHb1ej/Lycufj1NRUfPnllzh16pRz3+7duxEQEICxY8f22Mfq1avx+eefo6ysDGVlZTAajQCA1157Dfn5+c52bW1tqKyshF6v73U8iqIgICDAZSMiIiIiIiIicmeq19BJS0uDwWBAY2MjtFotZsyYgbFjx2Lu3Ln4/e9/j7q6Ojz66KNYtGgRFEXpsY+oqCiXx/7+/gCAmJgYREREOPeXlJRAURSkpqaqHSYRERERERERkdtSfYZOfHw8EhMTUVRUBADw9PTEjh074OnpidTUVMyZMwd33303Vq5c6cyYzWZoNBrs3btXVa3Nmzdj9uzZvd4Fi4iIiIiIiIj+bzkcGrffBgPVZ+gAQF5eHnJycpCdnQ0PDw+MGjXKedlUT6qqqhAYGIjx48f3+Hx0dDQcDofLvvr6emzduhWlpaWSIRIRERERERERuS3RhE5GRgYqKipQW1s7oLtKGY1G5ObmQqvVDriG2WzGmjVrMHr0aMkQMTzlFDyH9nzJV18evfIdUb13GhNEOQDICvpQlPsiSdd/o14c/Tyi/0Y9aI/3FNe0jRwiyh3eEyOuab+uTZQbVuwvrnnuut7vytYf5SPZ2WjHIoaKa2r8u0S5obWqT/BzqntwkigX9ux+cU3LStmlm7YwR/+NejEi6IwoZxVXBIZ+rf5971tDrm0W5TzMgeKaDYnnRTlNq7e45r/FHhTldm5NEdfcvvD3otwHV18lrlmw799EufFxFnHNimr5+7VvlewzYtzPvhbX9IDs9/vV128U13SMk70vvFWZJK7pf0WLKDdmaL245gcnZK/dzi75Z0uwz1lx9nxgpyiXFSz7DgcAe/YmiHKOYXZxzdjx34hyR46Gi2sOHSn7XvTCXvnvWWJCpSj31TH5d+uWK+R3Aa41B4lymg75GQQmb9n79d9qrxTX1PjKfs8qrLKfDwA8M26rKLe87E7VmfM22b87iC6GaEIHAJYuXTrgtoWFhar7T05ORnJysuocEREREREREZG7E0/oEBEREREREdGPTxc06MLgWGdGYrAcm+i81oaGBoSEhMBsNl/i4Xxn586dSEhIQFeX7HIQIiIiIiIiIiJ3JZrQyc/PR2ZmJqKjo/H5559j1qxZiIyMhK+vL+Li4vDss88OuC+73Y6EhARoNBqUlZU596enp8Pb2xubNm2SDJGIiIiIiIiIyG2pntCx2WxYv349srKyAACffPIJQkJCsHHjRhw6dAi//e1vYTAY8N///d8D6u/hhx+GTtfzAmTz5s3D6tWr1Q6RiIiIiIiIiMitqV5Dx2g0QlEUpKRcuNvH/PnzXZ4fM2YMiouLsX37dixevLjPvt59913s2rUL27Ztw7vvvtvt+ZkzZ2Lx4sWorKxETIz8zhlERERERERERO5E9YSOyWRCUlLft85sbm7GiBEj+mxz8uRJZGdn44033oCfX8+3ao6KikJoaChMJlOvEzp2ux12+3e3b2xpkd2ak4iIiIiIiIj61+XQoMsxOBYOlhgsx6b6kiuLxdLrJVIAsH//frz22mtYsGBBr20cDgfmzZuHhQsX9ntrcp1OB4vF0uvzBQUFGD58uHOLjIzs/yCIiIiIiIiIiAYx1RM6ra2t8PHx6fG5gwcPIjMzEytWrMCMGTN67eO5557DmTNnYDAY+q3n6+sLm83W6/MGgwHNzc3Oraampv+DICIiIiIiIiIaxFRP6AQFBaGxsbHb/vLyckyfPh0LFizAo48+2mcfe/bsQXFxMRRFgZeXF2JjYwEAycnJuOeee1zaWq1WBAcH99qXoigICAhw2YiIiIiIiIiI3JnqNXT0ej02btzosu/QoUO48cYbcc899yA/P7/fPlavXo0nn3zS+fj48eNIS0vDa6+9hokTJzr3t7W1obKyEnq9Xu0wiYiIiIiIiOgycDg0cAySdWYkBsuxqZ7QSUtLg8FgQGNjI7RaLQ4ePIgbb7wRaWlpWL58Oerq6gAAnp6evZ5ZExUV5fLY398fABATE4OIiAjn/pKSEiiKgtTUVLXDJCIiIiIiIiJyW6ovuYqPj0diYiKKiooAAFu3bsXp06exceNGhIeHO7cJEyY4M2azGRqNBnv37lVVa/PmzZg9e3avd8EiIiIiIiIiIvoxUj2hAwB5eXl49tln0dXVhccffxwOh6PbZjabne2rqqoQGBiI8ePH99hfdHQ0HA4HEhISnPvq6+uxdetWPPLII5IhEhERERERERG5LdWXXAFARkYGKioqUFtbO6DbhBuNRuTm5kKr1Q64htlsxpo1azB69GjJEHGqciQ8fHu+G1dfcs7dIaoXG1wvygHAi6dvEOUaLAP/eX7f0OOiuTycjvYX13yzfpwo1+XvENf0PKmIct7n5DX9PrmIM8qu777g+EAEep4Xl7S1yX5GHdHyn9H5w8NEOctK+eWXo/KKRbkTb8SJa2LHSFFsSP9vq70aNvWkOFtXFyjK+fmKS8InuFWUU0yy1xAAfPBJiiiXOf/v4po/K3lAlOvs8BTXHKJtE+U+PxzVf6NeaK6yi7NBwS2i3CcW+XjvjPtUlGuZXiWuWdUwQpTzOS5/Lfy/KV+Icn/9fGL/jXrh49cuyu2M39h/o14k7F4szvpWe4tyu87Ei2t2jugQ5TTt8tdCxNAmUe6IQyeu6eHRJcr9x3SjuGZxU4woFxQqex8CgCDfc+LscR/Zd3pdtOx7IwCcbpZ9p7/tKtn7CQC83pgoyj145R5xzbcaZWux/jb+XdWZ1rOduE9UjUhONKEDAEuXLh1w28LCQtX9JycnIzk5WXWOiIiIiIiIiC6fLocGXYNk4WCJwXJsotM0GhoaEBIS4nJZ1aW2c+dOJCQkoKtLNqtPREREREREROSuRBM6+fn5yMzMRHR0tMv+hoYGREREQKPRoKmpqc8+rFYrZs+ejYCAAAQGBiIrKwtnz551Pp+eng5vb29s2rRJMkQiIiIiIiIiIrelekLHZrNh/fr1yMrK6vZcVlYWxo0b2Dops2fPxqFDh7B7927s2LEDH374IRYsWODSZt68eVi9erXaIRIRERERERERuTXVEzpGoxGKoiAlxXVRybVr16KpqQkPPfRQv3189dVX2LlzJ/70pz9h4sSJmDJlCp577jls2bIFx48fd7abOXMmSktLUVlZqXaYRERERERERHQZOBwat98GA9UTOiaTCUlJSS77ysvLsXLlSvzlL3+Bh0f/XRYXFyMwMNBl0eObbroJHh4eOHDggHNfVFQUQkNDYTKZ1A6TiIiIiIiIiMhtqb7LlcVigU733a0L7XY7Zs2ahcLCQkRFReHYsWP99lFXV4eQkBDXgXh5YcSIEairq3PZr9PpYLFYeu3LbrfDbv/uNqktLfLbDRIRERERERERDQaqz9BpbW2Fj4+P87HBYEBcXBzmzJlzSQf2LV9fX9hstl6fLygowPDhw51bZGTkZRkHEREREREREdG/CtUTOkFBQWhsbHQ+3rNnD15//XV4eXnBy8sL06dPd7ZbsWJFj32EhYXh1KlTLvs6OzthtVoRFhbmst9qtSI4OLjX8RgMBjQ3Nzu3mpoatYdERERERERERDSoqL7kSq/XY+PGjc7H27ZtQ2trq/Pxxx9/jPnz58NkMiEmJqbHPlJTU9HU1IRPPvnEuR7Pnj170NXVhYkTJzrbtbW1obKyEnq9vtfxKIoCRVHUHgYRERERERERCTgcGnQNkoWDJQbLosiqJ3TS0tJgMBjQ2NgIrVbbbdKmvr4eABAXF4fAwMAe+4iLi0N6ejqys7Oxbt06dHR0YPHixfjFL37hsj5PSUkJFEVBamqq2mESEREREREREbkt1ZdcxcfHIzExEUVFRQPOmM1maDQa7N2717lv06ZNuOaaazB9+nT87Gc/w5QpU/Diiy+65DZv3ozZs2fDz89P7TCJiIiIiIiIiNyW6jN0ACAvLw85OTnIzs7udpvyqVOnwuFwuOyrqqpCYGAgxo8f79w3YsQIvPrqq73WqK+vx9atW1FaWioZIhERERERERGR2xJN6GRkZKCiogK1tbUDuquU0WhEbm4utFrtgGuYzWasWbMGo0ePlgwRV//kG3gPHaI6FzvstKjejq/jRTkAGHdtrSgXMrpBXDPo2nOi3KGv5HcRC4psEuXCrzsprml+a4woZx13XlxzSKPqE9+cNGUD/x35Z2dHt4lrDv3Sp/9GPWgNdfTfqBfDTsiuSbWFyWueeCNOlAu/7StxzSNrrhPlbkwsF9csfmecOIsrOkWx0WlV4pKVf5O9x2dm7RPXnOYv+ztdsmahuGb0z6pFuS7Ir9+2d4o+4lEn/zWD3z/8xdnht8nex5pa5Gfxvls9VpS7Ltwirnn9yKOi3CFduLjm61tvEOUcUR3imjfGVYhyj9X9VFzTxyJfU1Ej/Nj382gX1/Rq8BblOjrl3zP2fCH7LPRq8RTXnDvlI1HumQ9vEdfU2GU/o6vi5TdXCRjS2n+jXjjaZeOVvs8DQHuT7Pfl88YrxDXRInvNm5qvFpf8vF7Xf6Me7Dqi/nely9YG4BNRPSIp8bvA0qVLB9y2sLBQdf/JyclITk5WnSMiIiIiIiKiy8cBwHER/wn0r26wHJp8ip+IiIiIiIiIiH4Qqid0GhoaEBISArPZfBmGc0F5eTkiIiJw7pzssiAiIiIiIiIiInemekInPz8fmZmZiI6OBgAsWbIESUlJUBQFCQkJqvpyOBy45ZZboNFo8MYbbzj3jx07FikpKVi1apXa4RERERERERERuT1VEzo2mw3r169HVlaWy/758+fjrrvuUl38j3/8IzSanhd8vPfee7F27Vp0dsoW6SQiIiIiIiKiS68LGrffBgNViyIbjUYoioKUlBTnvtWrVwMATp8+jS+++GLAfZWVleG//uu/UFpaivDw7nduuPnmm2G1WrFv3z5Mnz5dzTCJiIiIiIiIiNyaqjN0TCYTkpKSLrqozWbDL3/5Szz//PMICwvrsc2QIUOQkJAAk8nUZ192ux0tLS0uGxERERERERGRO1M1oWOxWKDT6S666LJlyzBp0iRkZmb22U6n08FisfTZpqCgAMOHD3dukZGRFz0+IiIiIiIiIqJ/ZaomdFpbW+Hj43NRBd966y3s2bMHf/zjH/tt6+vrC5vN1mcbg8GA5uZm51ZTU3NR4yMiIiIiIiIi+lenag2doKAgNDY2XlTBPXv2oLKyEoGBgS77b7/9dlx//fXYu3evc5/VakVMTEyf/SmKAkVRLmpMRERERERERDQwDocGDsfgWDhYYrAcm6ozdPR6PcrLyy+q4G9+8xt88cUXKCsrc24A8Ic//AEbNmxwaXvw4EHo9fqLqkdERERERERE5G5UnaGTlpYGg8GAxsZGaLVaAMDRo0dx9uxZ1NXVobW11TlBM3bsWAwZMqRbH2FhYT0uhBwVFYXRo0c7H5vNZtTW1uKmm25SM0QiIiIiIiIiIren6gyd+Ph4JCYmoqioyLnvV7/6FfR6PV544QUcOXIEer0eer0ex48fd7bRaDR45ZVXVA1s8+bNmDFjBkaNGqUqR0RERERERETk7lSdoQMAeXl5yMnJQXZ2Njw8PFzWvOlJVVUVvLy8MHny5F7bOBwOl8ft7e1Yt24dXn31VbXDIyIiIiIiIqLLqMuhgWaQrDMj0TVIjk31hE5GRgYqKipQW1s7oFuEG41GLFiwAFdeeeWAa1RXVyM3N7fPSaD+RPo1YsjQ7pd89efNsgRRvQdT3hflAKC0OVqUO/11kLhm8vWyu4EdCQwR17T9QzbeL0cFimsqwx39N+qBX62nuKZnqziKcxP7vqtbb7yrfMU1Z8wqEeW+aul+6eSAs0HhotyIoDPimtgxUhQ7suY6ccmrHvhIlPsoZ5K45p1z9omz2zfeIMq1xnqLa9qDzoty//Nn2VgB4I0uWTY7+x1xzXUbM2TB5GZxzQC/NlFu5PBz4pr+t8lvnPBfMa+LcusCpoprlp7q/3tMTzq75J8RL34+RZQb6i/7+wQAL9lHC7xPq/6a6PTOp+NEuTsmlIprdvrIPvMBoCtG9vN9ruRGcU0PnazmkGr5HWc7IuyinP/V8s/f8rM6Ue7u1H+Ia+6vHyPK/TToqLjmhp3y10LwtfWi3PJY+b8/nvz7LFFuyDWyz20A8Bwpe/2lBFSKa77/ZZwod1P8V6oz7WfbYRFVI5ITfVIvXbp0wG0XLVqkuv/Y2FjExsaqzhERERERERER/RioWkMHABoaGhASEgKz2XwZhnNBeXk5IiIicO6c/H8JiYiIiIiIiIjcleoJnfz8fGRmZiI6Otplf0NDAyIiIqDRaNDU1NRvH5MmTYKfnx8CAwO7PT927FikpKRg1apVaodHREREREREROT2VE3o2Gw2rF+/HllZWd2ey8rKwrhxA7teur29HXfeeSfuv//+Xtvce++9WLt2LTo7O9UMkYiIiIiIiIguI4fD/bfBQNWEjtFohKIoSElJcdm/du1aNDU14aGHHhpQP0888QSWLVuG+Pj4XtvcfPPNsFqt2LdPvsAnEREREREREZE7UjWhYzKZkJSU5LKvvLwcK1euxF/+8hd4eKi+gqtXQ4YMQUJCAkwm0yXrk4iIiIiIiIjIHai6y5XFYoFO992tB+12O2bNmoXCwkJERUXh2LFjl3RwOp0OFkvfN3+z2+2w27+7BV5LS8slHQMRERERERER0b8aVRM6ra2t8PHxcT42GAyIi4vDnDlzLvnAAMDX1xc2m63PNgUFBXjiiScuS30iIiIiIiIicuVwaOBwaH7oYVw2g+XYVF0jFRQUhMbGRufjPXv24PXXX4eXlxe8vLwwffp0Z7sVK1Zc9OCsViuCg4P7bGMwGNDc3OzcampqLrouEREREREREdG/MlVn6Oj1emzcuNH5eNu2bWhtbXU+/vjjjzF//nyYTCbExMRc9OAOHjyIO+64o882iqJAUZSLrkVERERERERENFiomtBJS0uDwWBAY2MjtFptt0mb+vp6AEBcXBwCAwN77ae6uhpWqxXV1dU4f/48ysrKAACxsbHw9/cHAJjNZtTW1uKmm25SM0QiIiIiIiIiIren6pKr+Ph4JCYmoqioaMAZs9kMjUaDvXv3Ovfl5eVBr9djxYoVOHv2LPR6PfR6PUpLS51tNm/ejBkzZmDUqFFqhkhERERERERE5PZU32c8Ly8Pzz77LLq6uro9N3XqVDgcDpezc6qqqhAYGIjx48c7973yyitwOBzdtqlTpwIA2tvbsW7dOjz22GPqj4iIiIiIiIiILptvF0V2520wUHXJFQBkZGSgoqICtbW1iIyM7Le90WhEbm4utFrtgGtUV1cjNzcXkydPVjs8pw+rY+Dp59N/w+/x8u0U1btGOSHKAcDqihtFOcew8+Ka9i7Vf/UAgCeT3hDXXK2dLsp1FYeJa+pnfCXKHbb2vRh3X2ylQeKsl5fs79TvG3FJRPpYRbn3Xk8R1/RR/6sJAJCN9IIh/b9d9ejGxHJxzY9yJolyusL94pqb9BPE2eHNDlHu+IcR4poYYxfFziue4pIewrfOfdYrxTWHnJHlOj4aLq5ZN8ZPlMtM/kxcs1342QIAt+17QJQLChL+cAGc+7vsvf7Q9bLfFQDw+8JXlLMnyT/zHRPOinKjg+Xvupa/R4ly2z+cKK4Zn3pMnG1ul30wnbXL13FcFLtXlFt5fqa4ZkpslShX0Sj/XmQ6JltX881Ju8Q1//Kp7DtKU6vs9xMAOoPbxdnxQcdFuReqfyquOfnfZe/1I73PiWue6xgiyj31yS3imt7+sr+X6rMD/7frtzrPyb7TEF0M0TevpUuXDrhtYWGh6v5jY2MRGxurOkdERERERERE9GOg+pIrIiIiIiIiIiL6YYkmdBoaGhASEgKz2XyJh/OdnTt3IiEhoce1eoiIiIiIiIjoh9Hl0Lj9NhiIJnTy8/ORmZmJ6Ohol/0NDQ2IiIiARqNBU1NTr3mz2YysrCyMHj0avr6+iImJwYoVK9De/t01junp6fD29samTZskQyQiIiIiIiIicluqJ3RsNhvWr1+PrKysbs9lZWVh3Lhx/fbx9ddfo6urCy+88AIOHTqEP/zhD1i3bh1yc3Nd2s2bNw+rV69WO0QiIiIiIiIiIremekLHaDRCURSkpLiuHr927Vo0NTXhoYce6reP9PR0bNiwATNmzMCYMWNw66234qGHHsL27dtd2s2cOROlpaWorKxUO0wiIiIiIiIiIrel+i5XJpMJSUlJLvvKy8uxcuVKHDhwAMeOyW4Z2dzcjBEjRrjsi4qKQmhoKEwmE2Jier7lod1uh93+3S3iWlpaRPWJiIiIiIiIiAYL1WfoWCwW6HQ652O73Y5Zs2ahsLAQUVFRokEcPXoUzz33HO67775uz+l0Olgsll6zBQUFGD58uHOLjIwUjYGIiIiIiIiI+udwuP82GKie0GltbYWPj4/zscFgQFxcHObMmSMaQG1tLdLT03HnnXciOzu72/O+vr6w2Wy95g0GA5qbm51bTU2NaBxERERERERERIOF6gmdoKAgNDY2Oh/v2bMHr7/+Ory8vODl5YXp06c7261YsaLPvo4fP45p06Zh0qRJePHFF3tsY7VaERwc3GsfiqIgICDAZSMiIiIiIiIicmeq19DR6/XYuHGj8/G2bdvQ2trqfPzxxx9j/vz5fa57A1w4M2fatGlISkrChg0b4OHRfW6pra0NlZWV0Ov1aodJREREREREROS2VE/opKWlwWAwoLGxEVqtttukTX19PQAgLi4OgYGBPfZRW1uLqVOnYtSoUXjmmWdw+vRp53NhYWHOP5eUlEBRFKSmpqodJhERERERERFdBhfWmdH80MO4bNx2DZ34+HgkJiaiqKhowBmz2QyNRoO9e/cCAHbv3o2jR4/igw8+QEREBMLDw53bP9u8eTNmz54NPz8/tcMkIiIiIiIiInJbqid0ACAvLw/PPvssurq6uj03depUOBwOl7NzqqqqEBgYiPHjxwMA5s2bB4fD0eP2rfr6emzduhWPPPKIZIhERERERERERG5L9SVXAJCRkYGKigrU1tYO6DbhRqMRubm50Gq1A65hNpuxZs0ajB49WjJEtJ/0g4evT/8Nv2d03AlRvWV/yRLlAOA/fvG2KGfrGiKuub58kigXqrSIa0YHWEW5cf92XFxzryVWlDv/9TBxTf2Mr8XZQ29eI8q1hohLYkOF7JJG7zPymh3+snMYh36tiGsOm3pSlCt+Z5y45p1z9olym/QTxDVjflkmzp78tex9QWnsv01v7M3eopzHdU3imsUTXhblUp9dLq6J6U2imK1avtC//1HZz/aDiuvENX2nne6/US+Gfab+MxsAzkzuENcMnSb7fIkaJvs8A4Br5nwpylXY5G/01wytE2el3k0VfcXEiY/C+2/Ui6/qQsXZ852eotzPx34irvnkpz8T5V756XpxzXs+6H5H2YHwrpf9fQIAotpEsZ+/+B/ikh4h3f/TeSAabAP/t8r3KcG935W3P++XjZUFveTXhMSPl73/fdMWKK7Z1Cp7n+86J3/9LZos+y72wqEpqjNdNtlrnehiiH87li5dOuC2hYWFqvtPTk5GcnKy6hwRERERERERkbsTXXLV0NCAkJAQmM3mSzyc7+zcuRMJCQk9XtZFRERERERERD8Mh0Pj9ttgIJrQyc/PR2ZmJqKjo9HQ0ID09HTodDooioLIyEgsXrwYLS0DuzTHbrcjISEBGo0GZWVlzv3p6enw9vbGpk2bJEMkIiIiIiIiInJbqid0bDYb1q9fj6ysC2vGeHh4IDMzE2+99RaOHDmCV155Be+//z4WLlw4oP4efvhh6HS6Hp+bN28eVq9erXaIRERERERERERuTfWEjtFohKIoSElJAQBotVrcf//9SE5OxqhRozB9+nQ88MADMJlM/fb17rvvYteuXXjmmWd6fH7mzJkoLS1FZWWl2mESEREREREREbkt1RM6JpMJSUlJvT5//PhxbN++HTfccEOf/Zw8eRLZ2dn461//Cj8/vx7bREVFITQ0dECTQ0RERERERER0+Tl+BNtgoHpCx2Kx9HiJ1KxZs+Dn54crrrgCAQEB+NOf/tRrHw6HA/PmzcPChQv7vZOVTqeDxWLp9Xm73Y6WlhaXjYiIiIiIiIjIname0GltbYWPj0+3/X/4wx/w6aef4s0330RlZSWWL1/eax/PPfcczpw5A4PB0G89X19f2Gy2Xp8vKCjA8OHDnVtkZOTADoSIiIiIiIiIaJBSPaETFBSExsbGbvvDwsJwzTXX4NZbb8ULL7yAtWvX4sSJEz32sWfPHhQXF0NRFHh5eSE2NhYAkJycjHvuucelrdVqRXBwcK/jMRgMaG5udm41NTVqD4mIiIiIiIiIaFDxUhvQ6/XYuHFjn226uroAXLgcqierV6/Gk08+6Xx8/PhxpKWl4bXXXsPEiROd+9va2lBZWQm9Xt9rLUVRoCiKmkMgIiIiIiIiIhrUVE/opKWlwWAwoLGxEVqtFkajESdPnsSECRPg7++PQ4cOIScnB5MnT0Z0dHSPfURFRbk89vf3BwDExMQgIiLCub+kpASKoiA1NVXtMImIiIiIiIjoMnA4NHA4ND/0MC6bwXJsqi+5io+PR2JiIoqKigBcWOPmpZdewpQpUxAXF4dly5bh1ltvxY4dO5wZs9kMjUaDvXv3qqq1efNmzJ49u9e7YBERERERERER/RipPkMHAPLy8pCTk4Ps7GxMmzYN+/fv77N9VVUVAgMDMX78+B6fj46OhsPhemOw+vp6bN26FaWlpZIhEhERERERERG5LdGETkZGBioqKlBbWzugu0oZjUbk5uZCq9UOuIbZbMaaNWswevRoyRCJiIiIiIiIiNyWxvH9U2MGuZaWFgwfPhypb/waXkPVL5ZcczBMVDd87ClRDgB0/s2iXNt5b3HNpMBqUa7D4SmuualYthbSkBFt4ppen/uLckMnnxbXvBhtH/R+R7e+dAyT1wye1PPd6PpzbrvsdwUAmuJkbzt+o1rENc82+cqCdvlr3r9SNGeOIc3yt+Xzivx639Dn+j7bsjd1D04S1zx/g+z9z3ZWvhh+VJhVlJsWekRc8/VXp4pynvK3P7SGyV5Hmk55zbfvfkacnf/VXFFO+hkKAF+dDhXlfn3NXnHNAlOGKJeh/0Jcc/+JaFHut9e8K675Ys1PRbkjleHimkNOy95zAUBz5VlRLnJkk7jmlKBKUa4L8vf5V3fK/l46gzvENeNGHxflTp+TfYcDgPpvAmVB5by4ZuDH8s+ls1Gy9+up0+TvCwdORPXfqAe3jPpKXPMfJ8eIcie/kL1XA0BngOzvdGqC+uNsP9uOLdM3obm5GQEBAaK6g8G3/94e8+dcePr5/NDDuWzO29pw7J6n/uX/PlWvoUNERERERERERD8s0YROQ0MDQkJCYDabL/FwvrNz504kJCQ4b4FOREREREREREQXiCZ08vPzkZmZ2e225A0NDYiIiIBGo0FTU1Offdx6662IioqCj48PwsPDMXfuXBw//t0pmenp6fD29samTZskQyQiIiIiIiIicluqJ3RsNhvWr1+PrKysbs9lZWVh3LhxA+pn2rRpKCoqwuHDh7Ft2zZUVlbijjvucGkzb948rF69Wu0QiYiIiIiIiIjcmuoJHaPRCEVRkJKS4rJ/7dq1aGpqwkMPPTSgfpYtW4aUlBSMGjUKkyZNwm9+8xuUlJSgo+O7RddmzpyJ0tJSVFbKFo0jIiIiIiIiokvMoYHDjTc45AvQ/19SfTsAk8mEpKQkl33l5eVYuXIlDhw4gGPHjqkehNVqxaZNmzBp0iR4e39356aoqCiEhobCZDIhJiamx6zdbofdbnc+bmmR3wWHiIiIiIiIiGgwUH2GjsVigU6ncz622+2YNWsWCgsLERWl7vZ3jzzyCIYOHYqRI0eiuroab775Zrc2Op0OFoul1z4KCgowfPhw5xYZGalqDEREREREREREg43qCZ3W1lb4+Hx3v3mDwYC4uDjMmTNHdfGcnBx89tln2LVrFzw9PXH33XfD4XC4tPH19YXNZuu1D4PBgObmZudWU1OjehxERERERERERIOJ6kuugoKC0NjY6Hy8Z88efPnll9i6dSsAOCdkgoKC8Nvf/hZPPPFEn30FBQXhqquuQlxcHCIjI1FSUoLU1FRnG6vViuDg4F77UBQFiqKoPQwiIiIiIiIiEnA4LmzuarAcm+oJHb1ej40bNzofb9u2Da2trc7HH3/8MebPn9/nujc96erqAgCX9XDa2tpQWVkJvV6vdphERERERERERG5L9SVXaWlpOHTokPMsnZiYGPzkJz9xbqNHjwYAxMXFISQkpMc+Dhw4gP/+7/9GWVkZLBYL9uzZg1mzZiEmJsbl7JySkhIoiuKyj4iIiIiIiIjoX8nzzz+P6Oho+Pj4YOLEifjoo4/6bN/U1IRFixYhPDwciqLgqquugtFoVFVT9YROfHw8EhMTUVRUNOCM2WyGRqPB3r17AQB+fn7Yvn07pk+fjquvvhpZWVkYN24c9u3b53L51ObNmzF79mz4+fmpHSYRERERERER0WX32muvYfny5VixYgU+/fRTjB8/HmlpaTh16lSP7dvb23HzzTfDbDZj69atOHz4MF566SVcccUVquqqvuQKAPLy8pCTk4Ps7Gx4eLjOCU2dOrXbwsZVVVUIDAzE+PHjAVyYFNqzZ0+fNerr67F161aUlpZKhkhEREREREREdNmtWrUK2dnZuPfeewEA69atwzvvvIOXX34Zv/nNb7q1f/nll2G1WrF//354e3sDAKKjo1XXFU3oZGRkoKKiArW1tQO6TbjRaERubi60Wu2Aa5jNZqxZs8Z5CZdadZ+HweOf7sY1UJ7R50T1ogOsohwAXOHbJMptPSRfW+hQdbgol5v8rrjmvEl/F+X+eug6cc2OsPOi3DCNfBWsxOBvxNn3IkeKckkTKsQ1P6vu/3e4J97BGnFNn5OyrIc5UFzTz1eWG51WJa7ZGustyh3/MEJcU2nsv01v6h6cJMqFPbtfXvRW2bEeaQ4Vl7R1yP5ePmuS/a4AwBUzqkW5mr9FiWsOM8tyXV7y3+3/Pj1VnLX+PUyUa/CU5QAg6qeyv5cdp8aJayp1oq9e+MKqE9fcNn69OCsV7HtWlLNHnxbXDLi6TZw9+v4YUW7YzXXimq9VJIpyEyMs4preMWdkwXbZ6xYAKk8FiXKhgcKxAshI+lyU2/mh/Lu1LfwiVlAVvu1+8PFPxCUTxh0T5YZ5yn/PzrTJbmSj6RKXhMavU5RrtKu/QqTjIn5PBiOHQwOHQ/6d4V/dt8fW0tLisr+nmzK1t7fjk08+gcFgcO7z8PDATTfdhOLi4h77f+utt5CamopFixbhzTffRHBwMH75y1/ikUcegaen54DHKX7VLV26dMBtCwsLVfefnJyM5ORk1TkiIiIiIiIioov1/RNYVqxYgccff9xlX319Pc6fP4/QUNf/cAwNDcXXX3/dY7/Hjh3Dnj17MHv2bBiNRhw9ehQPPPAAOjo6sGLFigGP78c1jUhERERERERENAA1NTUICAhwPv7+2TlSXV1dCAkJwYsvvghPT08kJSWhtrYWhYWFqiZ0VC+KDAANDQ0ICQmB2WyWxAdk586dSEhIcN7OnIiIiIiIiIjo/0pAQIDL1tOETlBQEDw9PXHy5EmX/SdPnkRYWM+XhoeHh+Oqq65yubwqLi4OdXV1aG9vH/D4RBM6+fn5yMzM7LZoT0NDAyIiIqDRaNDU1DSgvux2OxISEqDRaFBWVubcn56eDm9vb2zatEkyRCIiIiIiIiK6HBwa998GaMiQIUhKSsIHH3zg3NfV1YUPPvgAqampPWYmT56Mo0ePupzAcuTIEYSHh2PIkCEDrq16Qsdms2H9+vXIysrq9ty3tx9X4+GHH4ZO1/NCf/PmzcPq1avVDpGIiIiIiIiI6P/E8uXL8dJLL+HPf/4zvvrqK9x///04d+6c865Xd999t8uiyffffz+sVisefPBBHDlyBO+88w6eeuopLFq0SFVd1RM6RqMRiqIgJSXFZf/atWvR1NSEhx56aMB9vfvuu9i1axeeeeaZHp+fOXMmSktLUVlZqXaYRERERERERESX3V133YVnnnkGeXl5SEhIQFlZGXbu3OlcKLm6uhonTpxwto+MjMR7772Hjz/+GOPGjcOSJUvw4IMP9niL876oXhTZZDIhKSnJZV95eTlWrlyJAwcO4Nixgd0C7+TJk8jOzsYbb7wBP7+ebwsXFRWF0NBQmEwmxMTE9NjGbrfDbrc7H3//tmJERERERERERJfT4sWLsXjx4h6f27t3b7d9qampKCkpuaiaqs/QsVgsLpdI2e12zJo1C4WFhYiKihpQHw6HA/PmzcPChQv7vTW5TqeDxWLp9fmCggIMHz7cuX3/tmJERERERERERO5G9YROa2srfHx8nI8NBgPi4uIwZ86cAffx3HPP4cyZMy7XkPXG19cXNput1+cNBgOam5udW01NzYDHQURERERERETqOBzuvw0Gqid0goKC0NjY6Hy8Z88evP766/Dy8oKXlxemT5/ubNfb/dP37NmD4uJiKIoCLy8vxMbGAgCSk5Nxzz33uLS1Wq0IDg7udTyKonS7lRgRERERERERkTtTvYaOXq/Hxo0bnY+3bduG1tZW5+OPP/4Y8+fP73Pdm9WrV+PJJ590Pj5+/DjS0tLw2muvYeLEic79bW1tqKyshF6vVztMIiIiIiIiIiK3pXpCJy0tDQaDAY2NjdBqtd0mberr6wEAcXFxCAwM7LGP76+14+/vDwCIiYlBRESEc39JSQkURen13u1ERERERERERD9Gqi+5io+PR2JiIoqKigacMZvN0Gg0Pa7s3JfNmzdj9uzZvd4Fi4iIiIiIiIj+jzl+BNsgoPoMHQDIy8tDTk4OsrOz4eHhOic0depUOL63glBVVRUCAwMxfvz4HvuLjo7ulqmvr8fWrVtRWloqGSIRERERERERkdsSTehkZGSgoqICtbW1A7pNuNFoRG5uLrRa7YBrmM1mrFmzBqNHj5YMER0jOuHh26k652UeKqr3jzNXinIAkJn4mSjX1Sr66wMA/OcNAz/D6p898uGd4poF128T5WZf+7G45pa3fyrKnawZ+Gv1+44PPSPO3jJF9lowliSIa6YkHhHlouMaxDV3PT9ZlGtIPC+u6RPc2n+jHlT+TfYeBAD2IOF4x9jlNZu9xVm/SOFr99aI/tv0Zvo3opjX7/v/7OnN6c5AUe5MTe8L9PdLI4v99FbZewIA/P0N2fpztugOcU3TyxPE2a5QWa7TT/5faKf+J6r/Rj3wSKsX1zwfK3svGuHT+x0/+/Nv6x4W5ewju8Q1dfEnRbmaY/Lfs7hrZO8nAHDvXe+Jcut23Syu6XVO9sZgsseKa/p+7ivKtf2kTVzzfKMiynUNPyuu+e7hsaJc0b+vFtf8w4kZ4uwVvk2inCfkv6MfW0eJcq8eSRbXHOEvex+bMaNEXLOl06f/Rj0IHqL+9Wf37MBOUTUiOfGMwNKlSwfctrCwUHX/ycnJSE6Wv2EQEREREREREbkr1WvoAEBDQwNCQkJgNpsv8XC+s3PnTiQkJKCrSz7zTERERERERETkjkQTOvn5+cjMzER0dDQAoLq6GhkZGfDz80NISAhycnLQ2dn35U7R0dHQaDQu29NPP+18Pj09Hd7e3ti0aZNkiERERERERER0GTgcGrffBgPVl1zZbDasX78e77134Vrj8+fPIyMjA2FhYdi/fz9OnDiBu+++G97e3njqqaf67GvlypXIzs52Ph42bJjL8/PmzcPq1asxd+5ctcMkIiIiIiIiInJbqs/QMRqNUBQFKSkpAIBdu3ahvLwcGzduREJCAm655Rb87ne/w/PPP4/29vY++xo2bBjCwsKc29ChrgsSz5w5E6WlpaisrFQ7TCIiIiIiIiIit6V6QsdkMiEpKcn5uLi4GPHx8QgN/e72FGlpaWhpacGhQ4f67Ovpp5/GyJEjodfrUVhY2O0yraioKISGhsJkMqkdJhERERERERGR21J9yZXFYoFOp3M+rqurc5nMAeB8XFdX12s/S5YsQWJiIkaMGIH9+/fDYDDgxIkTWLVqlUs7nU4Hi8XSaz92ux12+3e3+G1paVF1PERERERERESkkuOHHgCpntBpbW2Fj4/PRRdevny588/jxo3DkCFDcN9996GgoACKojif8/X1hc1m67WfgoICPPHEExc9HiIiIiIiIiKiwUL1JVdBQUFobGx0Pg4LC8PJkydd2nz7OCwsbMD9Tpw4EZ2dnd1uhW61WhEcHNxrzmAwoLm52bnV1NQMuCYRERERERER0WCkekJHr9ejvLzc+Tg1NRVffvklTp065dy3e/duBAQEYOzYsQPut6ysDB4eHggJCXHua2trQ2VlJfR6fa85RVEQEBDgshERERERERERuTPVEzppaWk4dOiQ8yydGTNmYOzYsZg7dy4+//xzvPfee3j00UexaNEil0un/llxcTH++Mc/4vPPP8exY8ewadMmLFu2DHPmzIFWq3W2KykpgaIoSE1NFR4eEREREREREZH7UT2hEx8fj8TERBQVFQEAPD09sWPHDnh6eiI1NRVz5szB3XffjZUrVzozZrMZGo0Ge/fuBXDhrJotW7bghhtuwLXXXov8/HwsW7YML774okutzZs3Y/bs2fDz87uIQyQiIiIiIiKiS8Xh0Lj9NhioXhQZAPLy8pCTk4Ps7Gx4eHhg1KhRMBqNvbavqqpCYGAgxo8fDwBITExESUlJnzXq6+uxdetWlJaWSoZIREREREREROS2RBM6GRkZqKioQG1tLSIjI/ttbzQakZub63I5VX/MZjPWrFmD0aNHS4YIL78OePh5qs5p6kU/EiRdUyXKAUBZQ4Qo51PrLa75n4fTZMEO1Sd1OT156GeinK3WX1zTEdYhyvlUDxHXPBcrz77zRbwo59km/3sZO+yEKBfu3SSueebmc6KcplX+mldMw0S5zKx94pr/8+cbRLnzivr3rm95XNckzp47I7uD4ZHmUHFNr9/3/xnSkzEPF4trnl4ou4y3MVH2fgIAXk2yz5YjzSH9N+qF9xlZTglsE9fMWND3f9b05e+nYkS5c+3y91z/BPv/ec3Oc7L3sWNvyX4+ABB4c50o13Bg4De3+L7jDcNlQS/5PXATAr8RZw80yr5vOi5ivB3DZVn5Jz5ww52fiHKmV5PENc9Ed4ly/x5RJq65qSNZlPvP2lvENT+1RImzDuHLyNHQ8/IWA5GgrxTlzp8f+L/nvk/6d3rD0K/FNbc1yV4Lnhr1r1tJhuhiyb5hAli6dOmA2xYWFqruPzk5GcnJsl9AIiIiIiIiIiJ3Jp7QISIiIiIiIqIfIcf/bu5qkByb6KzNhoYGhISEwGw2X+LhfGfnzp1ISEhAVxdPXSMiIiIiIiIi+meiCZ38/HxkZmYiOjoaAKDRaLptW7Zs6bMPq9WK2bNnIyAgAIGBgcjKysLZs2edz6enp8Pb2xubNm2SDJGIiIiIiIiIyG2pntCx2WxYv349srKyXPZv2LABJ06ccG633XZbn/3Mnj0bhw4dwu7du7Fjxw58+OGHWLBggUubefPmYfXq1WqHSERERERERETk1lRP6BiNRiiKgpSUFJf9gYGBCAsLc24+Pr3fLeWrr77Czp078ac//QkTJ07ElClT8Nxzz2HLli04fvy4s93MmTNRWlqKykrZKuxERERERERERO5I9YSOyWRCUlL3WxcuWrQIQUFBuO666/Dyyy/D0cf994qLixEYGOhyF6ubbroJHh4eOHDggHNfVFQUQkNDYTKZeu3LbrejpaXFZSMiIiIiIiKiy0XzI9j+9am+y5XFYoFOp3PZt3LlStx4443w8/PDrl278MADD+Ds2bNYsmRJj33U1dUhJCTEdSBeXhgxYgTq6upc9ut0Olgsll7HU1BQgCeeeELtYRARERERERERDVqqJ3RaW1u7XU712GOPOf+s1+tx7tw5FBYW9jqho4avry9sNluvzxsMBixfvtz5uKWlBZGRkRddl4iIiIiIiIjoX5XqS66CgoLQ2NjYZ5uJEyfim2++gd1u7/H5sLAwnDp1ymVfZ2cnrFYrwsLCXPZbrVYEBwf3WktRFAQEBLhsRERERERERETuTPWEjl6vR3l5eZ9tysrKoNVqoShKj8+npqaiqakJn3zyiXPfnj170NXVhYkTJzr3tbW1obKyEnq9Xu0wiYiIiIiIiOhycPwItkFA9SVXaWlpMBgMaGxshFarxdtvv42TJ08iJSUFPj4+2L17N5566ik89NBDvfYRFxeH9PR0ZGdnY926dejo6MDixYvxi1/8wmV9npKSEiiKgtTUVNnRERERERERERG5IdVn6MTHxyMxMRFFRUUAAG9vbzz//PNITU1FQkICXnjhBaxatQorVqxwZsxmMzQaDfbu3evct2nTJlxzzTWYPn06fvazn2HKlCl48cUXXWpt3rwZs2fPhp+fn/DwiIiIiIiIiIjcj+ozdAAgLy8POTk5yM7ORnp6OtLT0/tsX1VVhcDAQIwfP965b8SIEXj11Vd7zdTX12Pr1q0oLS2VDJGIiIiIiIiIyG2JJnQyMjJQUVGB2traAd1Rymg0Ijc3F1qtdsA1zGYz1qxZg9GjR0uGCI3GAY3m/+7CtzCfM+Js2YFYUc7TW358Hec9RTnvwJ4Xuh6Izk7VJ4QBADxHymv6+LaLcsMjrOKaR4+F9d+oF2un/UWU+4PlZnHNSlvvi473JXx4k7imt/d5Ue7fYg+Ka37wSYooN83/K3HNN7puEOU8ZD8eAEDxhJfF2X8r/4UoZ+vwFtc83Rkoyy2UX4obvK5YlLv7UJO45l+fvUWUq/EIF9f0nHJWlDvfKft8AIDNXyaLsyNHyMZrPTpCXLO5TSPKdYTKPlsAwKdG9vvSJf81w/Hjsp/RsBZ5Tc+DsrOrQ6bVimv+z9Hx/Tfqhb+v7LuGv0X++9I2Qfaax7Gh4pofDh0jynlOlX8v8jo08O///yzR1yyuuWfY1aKcx0X82yFIK/+3QGLwN6JcXeswcc0ys+yuwF5DOsU1//T1JFHuy4grxDX3fhonyt0y4QvVmfZ2+WcDkZRoQgcAli5dOuC2hYWFqvtPTk5GcrL8iyERERERERERXQaDaOFgkUFybKpPmWhoaEBISAjMZvNlGM4F5eXliIiIwLlz5y5bDSIiIiIiIiKiwUr1hE5+fj4yMzMRHR0NANBoNN22LVu29NvHpEmT4Ofnh8DAwG7Pjx07FikpKVi1apXa4RERERERERERuT1VEzo2mw3r169HVlaWy/4NGzbgxIkTzu22227rs5/29nbceeeduP/++3ttc++992Lt2rXo7JRfp0lERERERERE5I5UraFjNBqhKApSUlwXFw0MDERY2MAXgn3iiScAAK+88kqvbW6++WZYrVbs27cP06dPVzNMIiIiIiIiIrpcHJoLm7saJMem6gwdk8mEpKSkbvsXLVqEoKAgXHfddXj55ZfhcFz8CkJDhgxBQkICTCbTRfdFREREREREROROVJ2hY7FYoNPpXPatXLkSN954I/z8/LBr1y488MADOHv2LJYsWXLRg9PpdLBYLH22sdvtsNu/u9VkS8tF3GOTiIiIiIiIiGgQUDWh09raCh8fH5d9jz32mPPPer0e586dQ2Fh4SWZ0PH19YXNZuuzTUFBgfMSLiIiIiIiIiKiHwNVl1wFBQWhsbGxzzYTJ07EN99843LWjJTVakVwcHCfbQwGA5qbm51bTU3NRdclIiIiIiIiIvpXpmpCR6/Xo7y8vM82ZWVl0Gq1UBTlogYGAAcPHoRer++zjaIoCAgIcNmIiIiIiIiI6PJwONx/GwxUXXKVlpYGg8GAxsZGaLVavP322zh58iRSUlLg4+OD3bt346mnnsJDDz3UZz/V1dWwWq2orq7G+fPnUVZWBgCIjY2Fv78/AMBsNqO2thY33XST7MiIiIiIiIiIiNyUqjN04uPjkZiYiKKiIgCAt7c3nn/+eaSmpiIhIQEvvPACVq1ahRUrVjgzZrMZGo0Ge/fude7Ly8uDXq/HihUrcPbsWej1euj1epSWljrbbN68GTNmzMCoUaMu8hCJiIiIiIiIiNyLqjN0gAuTMTk5OcjOzkZ6ejrS09P7bF9VVYXAwECMHz/eue+VV17BK6+80mumvb0d69atw6uvvqp2eEREREREREREbk/1hE5GRgYqKipQW1uLyMjIftsbjUbk5uZCq9UOuEZ1dTVyc3MxefJktcNzio84Du+hQ1TnJsSbRfXWlf1UlAOAkXENolzLOZ/+G11i3l8MFWcn3fa5KPfB4avFNa8Y3izKHakJFdccESarCQDLX8kS5ToC5Bd5HvWOEOU+GS3LAUB7u6cot3Nrirhm5vy/i3JL1iwU18zOfkeU22e9Ulwz9dnl4uwdc/aKcp819f9Z0JszNX0vfN+bxsQOcc27DzWJcu9eGyiuOfmfzkBVI9m/SlzzP//8c1Fu4q0HxTU/feMn4uwZH19RzjFafhOGDuFbp3+5fJ1A36mnRTlreZC4pvcpb1HOFt4lrhn2k1OinNV4hbhm2pyPxNn9daNFueBbvhHXrCmVHWvHyE5xzclhsvH+/UP57/bIBNlrfvFL8s9fm+68KHdNvPzmKhHDmsTZkhOyKxJaPxkprnnrrbLflzc/ShTX9A45J8pVNMm+KwDAk9O3iXKPmv6f6kxXa5uo1qDl+N/NXQ2SY1M9oQMAS5cuHXDbwsJC1f3HxsYiNjZWdY6IiIiIiIiI6MdA1Ro6RERERERERET0wxNN6DQ0NCAkJARms/kSD+c7O3fuREJCArq65Kf7EhERERERERG5I9GETn5+PjIzMxEdHY3PP/8cs2bNQmRkJHx9fREXF4dnn3223z6io6Oh0Whctqefftr5fHp6Ory9vbFp0ybJEImIiIiIiIiI3JbqNXRsNhvWr1+P9957DwDwySefICQkBBs3bkRkZCT279+PBQsWwNPTE4sXL+6zr5UrVyI7O9v5eNiwYS7Pz5s3D6tXr8bcuXPVDpOIiIiIiIiILgeH5sLmrgbJsame0DEajVAUBSkpF+42M3/+fJfnx4wZg+LiYmzfvr3fCZ1hw4YhLCys1+dnzpyJxYsXo7KyEjExMWqHSkRERERERETkllRfcmUymZCUlNRnm+bmZowYMaLfvp5++mmMHDkSer0ehYWF6Ox0vQ1jVFQUQkNDYTKZeu3DbrejpaXFZSMiIiIiIiIicmeqz9CxWCzQ6XS9Pr9//3689tpreOedd/rsZ8mSJUhMTMSIESOwf/9+GAwGnDhxAqtWrXJpp9PpYLFYeu2noKAATzzxhLqDICIiIiIiIiIaxFRP6LS2tsLHx6fH5w4ePIjMzEysWLECM2bM6LOf5cuXO/88btw4DBkyBPfddx8KCgqgKIrzOV9fX9hstl77MRgMLn21tLQgMjJyoIdDRERERERERCpoHBc2dzVYjk31hE5QUBAaGxu77S8vL8f06dOxYMECPProo6oHMnHiRHR2dsJsNuPqq6927rdarQgODu41pyiKywQQEREREREREZG7U72Gjl6vR3l5ucu+Q4cOYdq0abjnnnuQn58vGkhZWRk8PDwQEhLi3NfW1obKykro9XpRn0RERERERERE7kj1GTppaWkwGAxobGyEVqvFwYMHceONNyItLQ3Lly9HXV0dAMDT07PXM2uKi4tx4MABTJs2DcOGDUNxcTGWLVuGOXPmQKvVOtuVlJRAURSkpqYKD4+IiIiIiIiIyP2oPkMnPj4eiYmJKCoqAgBs3boVp0+fxsaNGxEeHu7cJkyY4MyYzWZoNBrs3bsXwIXLpLZs2YIbbrgB1157LfLz87Fs2TK8+OKLLrU2b96M2bNnw8/P7yIOkYiIiIiIiIjIvag+QwcA8vLykJOTg+zsbDz++ON4/PHH+2xfVVWFwMBAjB8/HgCQmJiIkpKSPjP19fXYunUrSktLJUMkIiIiIiIiosvB8b+buxokx6ZxOByiof7xj3/E7bffPqA7SuXk5CAkJAQ5OTkD7r+0tBSVlZW46667VI2rpaUFw4cPx5UbfwNPP/WLJXuUDFedAYCzce2iHAB4WkXzakhMqRDXvGHEEVHuvdPXimsePR0kyt0yurz/Rr34qiVMlDvbLl9ou6ZmpDi7dupfRbkHX5svrrnmFy/236gHeRWZ4ppn22Q/3+36l8Q1f1bygCgXHWQV1/zm/ShRbsgZcUl0Tm8SZx0lgaLcFTOqxTWrP5T9jDqHyj9lA47KcpMXyP+D4XByhyhnnS+/5Lh+kqymd723uObwnzSIs/V1AaKcR4vsMxQAPNo1otydaf8Q19x8IEWUu/aaGnHNcku4KOf3Vc93NR0ITacs1+kvLgmN7CUPALg+8zNRrniLfJ3HcXfIvt+YW0aIa9YKv6NoQ1vENRu/kX23zpryobjm1j/dKMppZ9aKazack19RMDb4pCg3M+hzcc1nvr5ZlFO8hb/cAJKDZe9jOyvixDXPtwwR5cbE1qnOdJ6z4++3Po/m5mYEBMg+0waDb/+9HfnHlfDwlX9O/Kvram1DzdK8f/m/T/G3oKVLlw64bWFhoer+k5OTkZycrDpHREREREREROTuVK+hAwANDQ0ICQmB2Wy+xMP5zs6dO5GQkICurq7LVoOIiIiIiIiIaDASTejk5+cjMzMT0dHRAACNRtNt27JlS695s9mMrKwsjB49Gr6+voiJicGKFSvQ3v7dZUvp6enw9vbGpk2bJEMkIiIiIiIiosvBoXH/bRBQfcmVzWbD+vXr8d5777ns37BhA9LT052PAwMDe+3j66+/RldXF1544QXExsbi4MGDyM7Oxrlz5/DMM884282bNw+rV6/G3Llz1Q6TiIiIiIiIiMhtqZ7QMRqNUBQFKSmui/oFBgYiLGxgC9Cmp6e7TP6MGTMGhw8fxtq1a10mdGbOnInFixejsrISMTExaodKREREREREROSWVF9yZTKZkJSU1G3/okWLEBQUhOuuuw4vv/wy1N48q7m5GSNGuK7aHxUVhdDQUJhMJrXDJCIiIiIiIiJyW6rP0LFYLNDpdC77Vq5ciRtvvBF+fn7YtWsXHnjgAZw9exZLliwZUJ9Hjx7Fc88953J2zrd0Oh0sFkuvWbvdDrvd7nzc0iK/rSIRERERERER0WCgekKntbUVPj6u95t/7LHHnH/W6/U4d+4cCgsLBzShU1tbi/T0dNx5553Izs7u9ryvry9sNluv+YKCAjzxxBMqjoCIiIiIiIiIxBz/u7mrQXJsqi+5CgoKQmNjY59tJk6ciG+++cblzJmeHD9+HNOmTcOkSZPw4osv9tjGarUiODi41z4MBgOam5udW01NTf8HQUREREREREQ0iKme0NHr9SgvL++zTVlZGbRaLRRF6bVNbW0tpk6diqSkJGzYsAEeHt2H0tbWhsrKSuj1+l77URQFAQEBLhsRERERERERkTtTfclVWloaDAYDGhsbodVq8fbbb+PkyZNISUmBj48Pdu/ejaeeegoPPfRQr318O5kzatQoPPPMMzh9+rTzuX++U1ZJSQkURUFqaqraYRIRERERERERuS3VEzrx8fFITExEUVER7rvvPnh7e+P555/HsmXL4HA4EBsbi1WrVrmsh2M2mzF69Gj87W9/w9SpU7F7924cPXoUR48eRUREhEv//3x3rM2bN2P27Nnw8/O7iEMkIiIiIiIiokuGa+j8S1A9oQMAeXl5yMnJQXZ2NtLT05Gent5n+6qqKgQGBmL8+PEAgHnz5mHevHl9Zurr67F161aUlpZKhkhERERERERE5LZEEzoZGRmoqKhAbW0tIiMj+21vNBqRm5sLrVY74Bpmsxlr1qzB6NGjJUNEZ+UwdH3vblwD0XFlh6iexqtLlAMAz1aNKFfZOFJc88sTU0W5DUmviGvefeJeUe4KpUlcc3+b7PWjD6oV1/ymbuCv8+/7y8lJolzS1K/FNRd/+ktRrutrf3HN836yKe8Prr5KXLOzw1OU64Ls9xMAkNwsinV8NFxc0lYtX0dsWJssV/O3KHHNn976mSh3pDlEXLPGI1yUS/avEtcsnn+nKDfi5WJxzZFzrhDlTpXK/z7jbqgTZz/rEH0lgb1e/vvS5SV7L7rKV36c0TEnRblgn7PimnMTDohy74deLa7ZtC+s/0Y96IqTH6fykfxz6cMdva/X2Je2n7SLa4YqLaKcEtgprnn8sOy9s71T9vsJAPCW/Z6ZTseKS55N6f0OuX1p2y973wSAzthWcfYbn0BRbu2ZG8Q1h/vKPvQfiP6buOZv3p0lyilW1cu+Ovn3fS+fXpmHqv93VpdN+EWK6CKI352XLl064LaFhYWq+09OTkZycrLqHBERERERERGRu5NPdxIRERERERER0Q9CNKHT0NCAkJAQmM3mSzyc7+zcuRMJCQno6pJfykREREREREREl5jjR7ANAqIJnfz8fGRmZiI6OhoAoNFoum1btmzps49bb70VUVFR8PHxQXh4OObOnYvjx487n09PT4e3tzc2bdokGSIRERERERERkdtSPaFjs9mwfv16ZGVluezfsGEDTpw44dxuu+22PvuZNm0aioqKcPjwYWzbtg2VlZW44447XNrMmzcPq1evVjtEIiIiIiIiIiK3pnpRZKPRCEVRkJKS4rI/MDAQYWEDv6PBsmXLnH8eNWoUfvOb3+C2225DR0cHvL29AQAzZ87E4sWLUVlZiZiYGLVDJSIiIiIiIiJyS6rP0DGZTEhKSuq2f9GiRQgKCsJ1112Hl19+GQ7HwC86s1qt2LRpEyZNmuSczAGAqKgohIaGwmQy9Zq12+1oaWlx2YiIiIiIiIjoMnFo3H8bBFRP6FgsFuh0Opd9K1euRFFREXbv3o3bb78dDzzwAJ577rl++3rkkUcwdOhQjBw5EtXV1XjzzTe7tdHpdLBYLL32UVBQgOHDhzu3yMhItYdERERERERERDSoqJ7QaW1thY+Pj8u+xx57DJMnT4Zer8cjjzyChx9+GIWFhf32lZOTg88++wy7du2Cp6cn7r777m5n9vj6+sJms/Xah8FgQHNzs3OrqalRe0hERERERERERIOK6jV0goKC0NjY2GebiRMn4ne/+x3sdjsURemzr6CgIFx11VWIi4tDZGQkSkpKkJqa6mxjtVoRHBzcax+KovRZg4iIiIiIiIjI3ag+Q0ev16O8vLzPNmVlZdBqtaomWrq6ugBcWBPnW21tbaisrIRer1c7TCIiIiIiIiIit6X6DJ20tDQYDAY0NjZCq9Xi7bffxsmTJ5GSkgIfHx/s3r0bTz31FB566KFe+zhw4AA+/vhjTJkyBVqtFpWVlXjssccQExPjcnZOSUkJFEVx2UdEREREREREPxyN48LmrgbLsak+Qyc+Ph6JiYkoKioCAHh7e+P5559HamoqEhIS8MILL2DVqlVYsWKFM2M2m6HRaLB3714AgJ+fH7Zv347p06fj6quvRlZWFsaNG4d9+/a5nNWzefNmzJ49G35+fhd5mERERERERERE7kP1GToAkJeXh5ycHGRnZyM9PR3p6el9tq+qqkJgYCDGjx8P4MKk0J49e/rM1NfXY+vWrSgtLZUMkYiIiIiIiIjIbYkmdDIyMlBRUYHa2toB3SbcaDQiNzcXWq12wDXMZjPWrFmD0aNHS4aIET85Dc+h6hdLPnW49wWY+3Jl7HFRDgAmjjeLcn/5NEVcs2DSdlFu1u6F4pr/Oa1IljucJq7ZWDXw19w/qxvaIq65d9pqcfaGHctFOSWoVVzzukiLKBc85qy45o6jPxHlCvb9m7jmEG2bKGfvFL1NAgAC/GQ168bIz0r0P+otzraGyc4tHWYWl8Tf35CtkeZ9Rl7Tc4rstfuff/65uKZtUrsoN3LOFeKajhtrRbmOh0eJa3prusRZjw8DRTnfizgl2jG1SZQrPHSzuKbyfoAo9+HkEeKa+lGyO4BqfeSfLb+c+7Yot/bPM8U1f3HPB+Lsrro4Ua6uJFxc890q2fc4xzj5G2Dg6L5vbNKbpqah4po+gbLPwtPn5DV9fWXvudMyDolr/q1ogjh7Ikx4gxfV11p8J/W6r0W5R/5xh7jm7Bv+Icq9cWycuKZOK3vNJwR+ozpjP9uBP4qqEcmJ/6WydOnSAbcdyC3Mvy85ORnJycmqc0RERERERER0GTn+d3NXg+TYRPO6DQ0NCAkJgdlsvsTD+c7OnTuRkJDgvPsVERERERERERFdIJrQyc/PR2ZmJqKjo132NzQ0ICIiAhqNBk1NTX32ER0dDY1G47I9/fTTzufT09Ph7e2NTZs2SYZIREREREREROS2VE/o2Gw2rF+/HllZWd2e+/ZuVQO1cuVKnDhxwrn9+te/dnl+3rx5WL1avh4JEREREREREZE7Uj2hYzQaoSgKUlJcF3Jbu3Ytmpqa8NBDDw24r2HDhiEsLMy5DR3quvjZzJkzUVpaisrKSrXDJCIiIiIiIiJyW6ondEwmE5KSklz2lZeXY+XKlfjLX/4CD4+Bd/n0009j5MiR0Ov1KCwsRGdnp8vzUVFRCA0NhclkUjtMIiIiIiIiIiK3pfouVxaLBTqdzvnYbrdj1qxZKCwsRFRUFI4dOzagfpYsWYLExESMGDEC+/fvh8FgwIkTJ7Bq1SqXdjqdDhZL77dVttvtsNvtzsctLfLbTRMRERERERERDQaqJ3RaW1vh4+PjfGwwGBAXF4c5c+ao6mf58uXOP48bNw5DhgzBfffdh4KCAiiK4nzO19cXNput134KCgrwxBNPqKpNRERERERERDSYqb7kKigoCI2Njc7He/bsweuvvw4vLy94eXlh+vTpznYrVqwYcL8TJ05EZ2dnt1uhW61WBAcH95ozGAxobm52bjU1NeoOiIiIiIiIiIhokFF9ho5er8fGjRudj7dt24bW1lbn448//hjz58+HyWRCTEzMgPstKyuDh4cHQkJCnPva2tpQWVkJvV7fa05RFJczeoiIiIiIiIjo8tEA0Dh+6FFcPpofegADpHpCJy0tDQaDAY2NjdBqtd0mberr6wEAcXFxCAwM7LGP4uJiHDhwANOmTcOwYcNQXFyMZcuWYc6cOdBqtc52JSUlUBQFqampaodJREREREREROS2VF9yFR8fj8TERBQVFQ04YzabodFosHfvXgAXzqrZsmULbrjhBlx77bXIz8/HsmXL8OKLL7rkNm/ejNmzZ8PPz0/tMImIiIiIiIiI3JbqM3QAIC8vDzk5OcjOzu52m/KpU6fC4XA996qqqgqBgYEYP348ACAxMRElJSV91qivr8fWrVtRWloqGSIRERERERERkdsSTehkZGSgoqICtbW1iIyM7Le90WhEbm6uy+VU/TGbzVizZg1Gjx4tGSKsXwbD45/uxjVQXudF5VC9Z5QsCCByZpMsp7OKa/7n12mi3LVXfyOuub7melFuf+ImcU39gQdFuYPHw8U1v9YN/HX+fdFXnhTl7o38h7hmwZe3iHJxoXXimu2N6n83AWB8nEVc8/PDUaJc3UVcGzxy+DlRLjP5M3HNDyquE2c1nbJcl5f8KmNbdIcopwS2iWue7/QU5SbeelBcs2TftaLcqVLZ6xYAOh6WfS7pfr9fXLNiuuwzGwBarm0X5bSl3uKaUVrZ52j2FfvENf8aNkmUG+ZlF9fMGPG5KLfyqwxxzdfbk0S56FuqxDU3bZ4uznrKXn7Q+ItLwvuMLHfTmEPimru2pIhyjquFPyAAbXbZZ34bZDkAiB0j+47y9ufjxTVxpezzDACU48L3sTjhiwhAcaXs/XrUFQ3imtsqEkQ5b2/hFxQAXx2OEOW6rlL/3abznPx9mkhKNKEDAEuXLh1w28LCQtX9JycnIzk5WXWOiIiIiIiIiC4jh+bC5q4GybGpXkOHiIiIiIiIiIh+WKIJnYaGBoSEhMBsNl/i4Xxn586dSEhIQFdX12WrQUREREREREQ0GIkmdPLz85GZmYno6GgAgEaj6bZt2bJlQH3Z7XYkJCRAo9GgrKzMuT89PR3e3t7YtEm+fgoRERERERERkTtSPaFjs9mwfv16ZGVluezfsGEDTpw44dxuu+22AfX38MMPQ6fT9fjcvHnzsHr1arVDJCIiIiIiIiJya6ondIxGIxRFQUqK6yr5gYGBCAsLc24+A7jD1Lvvvotdu3bhmWee6fH5mTNnorS0FJWVlWqHSURERERERESXg+NHsA0Cqid0TCYTkpK634py0aJFCAoKwnXXXYeXX34ZDkffP4GTJ08iOzsbf/3rX+Hn59djm6ioKISGhsJkMvXaj91uR0tLi8tGREREREREROTOVE/oWCyWbpdIrVy5EkVFRdi9ezduv/12PPDAA3juued67cPhcGDevHlYuHBhv7cm1+l0sFgsvT5fUFCA4cOHO7fIyEh1B0RERERERERENMh4qQ20trZ2u5zqsccec/5Zr9fj3LlzKCwsxJIlS3rs47nnnsOZM2dgMBj6refr6wubzdbr8waDAcuXL3c+bmlp4aQOEREREREREbk11WfoBAUFobGxsc82EydOxDfffAO73d7j83v27EFxcTEURYGXlxdiY2MBAMnJybjnnntc2lqtVgQHB/daS1EUBAQEuGxEREREREREdJn80OvbcA0dAIIzdPR6PTZu3Nhnm7KyMmi1WiiK0uPzq1evxpNPPul8fPz4caSlpeG1117DxIkTnfvb2tpQWVkJvV6vdphERERERERERG5L9YROWloaDAYDGhsbodVq8fbbb+PkyZNISUmBj48Pdu/ejaeeegoPPfRQr31ERUW5PPb39wcAxMTEICIiwrm/pKQEiqIgNTVV7TCJiIiIiIiIiNyW6kuu4uPjkZiYiKKiIgCAt7c3nn/+eaSmpiIhIQEvvPACVq1ahRUrVjgzZrMZGo0Ge/fuVVVr8+bNmD17dq93wSIiIiIiIiIi+jFSfYYOAOTl5SEnJwfZ2dlIT09Henp6n+2rqqoQGBiI8ePH9/h8dHR0t9uc19fXY+vWrSgtLZUMkYiIiIiIiIjIbYkmdDIyMlBRUYHa2toB3VHKaDQiNzcXWq12wDXMZjPWrFmD0aNHS4YIr9gz8PRrV537eexnonqvlE4S5QCgvDFUlNOIKwJNJ2SLRzedHCauOW/iP0S59PI7xDW1U+pEuePHgsQ1l7z6K3H23v/3vii3tuoGcc2uI/6i3FcIE9f0/Ub01oOK6hhxTc1VPS/S3h+/f8h+PgDgf1vfC8j3pr1L9vMBAN9pp8XZbT95RZT779NTxTVNL08Q5TIWlIhrbv4yWZT79I2fiGsOv75elIu7QfYeBgDemi5RrmK67HMXAHzTqsTZgGXhotzZKPmqhYcOjBHlHm6SvxcFXH9SlDt5ari4pskyTpTzbJV/0/hmpOz1N+66SnFNW4z6731OnrLX0RXhsvd5ADhVJvv+98a+68Q1u+JkP6PAkWfFNZtq/+9vWHLUIvvZjhl1Slzz9zFbxdm3WmTrhR4+KztOAPi4apQoV3Nq4P+e+z4vi0//jXrKxVvFNZOuPSbKfVqp/ufT1domqjVYaRwXNnc1WI5N/K+GpUuXDrhtYWGh6v6Tk5ORnCz70k1ERERERERE5M5Ur6HT0NCAkJAQmM3myzCcC8rLyxEREYFz585dthpERERERERERIOV6gmd/Px8ZGZmIjo6GgCwZMkSJCUlQVEUJCQkDKiPqVOnQqPRuGwLFy50Pj927FikpKRg1apVaodHREREREREROT2VE3o2Gw2rF+/HllZWS7758+fj7vuuktV4ezsbJw4ccK5/f73v3d5/t5778XatWvR2dmpql8iIiIiIiIiuowcP4JtEFC1ho7RaISiKEhJSXHuW716NQDg9OnT+OKLLwbcl5+fH8LCel9U9eabb4bVasW+ffswffp0NcMkIiIiIiIiInJrqs7QMZlMSEpKuiSFN23ahKCgIPzkJz+BwWCAzWZzeX7IkCFISEiAyWS6JPWIiIiIiIiIiNyFqjN0LBYLdDrdRRf95S9/iVGjRkGn0+GLL77AI488gsOHD2P79u0u7XQ6HSwWS5992e122O3f3Y64paXlosdHRERERERERPSvTNWETmtrK3x8fC666IIFC5x/jo+PR3h4OKZPn47KykrExMQ4n/P19e125s73FRQU4IknnrjoMRERERERERERDRaqLrkKCgpCY2PjJR/ExIkTAQBHjx512W+1WhEcHNxn1mAwoLm52bnV1NRc8vERERERERER0f/6oRcs5qLIAFRO6Oj1epSXl1/yQZSVlQEAwsPDXfYfPHgQer2+z6yiKAgICHDZiIiIiIiIiIjcmaoJnbS0NBw6dMjlLJ2jR4+irKwMdXV1aG1tRVlZGcrKytDe3t5jH5WVlfjd736HTz75BGazGW+99Rbuvvtu/PSnP8W4ceOc7cxmM2pra3HTTTcJD42IiIiIiIiIyD2pmtCJj49HYmIiioqKnPt+9atfQa/X44UXXsCRI0eg1+uh1+tx/PhxZxuNRoNXXnkFwIW7V73//vuYMWMGrrnmGvzHf/wHbr/9drz99tsutTZv3owZM2Zg1KhRF3F4RERERERERETuR9WiyACQl5eHnJwcZGdnw8PDA3v37u2zfVVVFby8vDB58mQAQGRkJPbt29dnpr29HevWrcOrr76qdnhEREREREREdBlpHBc2dzVYjk31hE5GRgYqKipQW1uLyMjIftsbjUYsWLAAV1555YBrVFdXIzc31zkJRERERERERERE31E9oQMAS5cuHXDbRYsWqe4/NjYWsbGxqnP/rLXeDx6+6m+xvt1zvKxgh6qr1y6Jf48oE2fXWn8qyl0Zfkpc847hn4hym75KFtfM/sk/RLl3POLFNUf85Jw4+/W5MFGurnqEuOZVKbI7w1V91P+Ebm86onteY6s/vlVDxDWDgltEueG3tYlr/lfM66LcbfseENcc9pn6971vzfecK8pZ/y573QJAV6gs9/dTMeKaI0ecFeXO+PiKa9bXyRbs/6xD9DENAPD4MFCUa7lW9vsJAAHLwvtv1IuwP+wX5eqWTRLXbInrEOW8bN7immf2yl703omy1y0AZM78VJQ73CL8BQXwhfkKUe7omwP/D8DvG39rpTgb4dckyn1gvkpc0+caWc2ksG/ENb+yyv9OpXxPyN7HWq/olNc8Jvu+cKxd/nn2W4//J86ebVdEudPN/uKad10r+16++dPrxDXT0kpFuX0bJ4hr6uYcE+UO+qn/LDwP+ecnkdT//SwEERERERERERFdFNGETkNDA0JCQmA2my/xcL6zc+dOJCQkoKur67LVICIiIiIiIiIajEQTOvn5+cjMzER0dDQaGhqQnp4OnU4HRVEQGRmJxYsXo6Wl78sboqOjodFoXLann37a+Xx6ejq8vb2xadMmyRCJiIiIiIiI6HJwaNx/GwRUT+jYbDasX78eWVlZFzrw8EBmZibeeustHDlyBK+88gref/99LFy4sN++Vq5ciRMnTji3X//61y7Pz5s3D6tXr1Y7RCIiIiIiIiIit6Z6lTKj0QhFUZCSkgIA0Gq1uP/++53Pjxo1Cg888AAKCwv77WvYsGEIC+t98bGZM2di8eLFqKysREyMfAFMIiIiIiIiIiJ3ovoMHZPJhKSkpF6fP378OLZv344bbrih376efvppjBw5Enq9HoWFhejsdF3NPioqCqGhoTCZTL32Ybfb0dLS4rIREREREREREbkz1RM6FosFOp2u2/5Zs2bBz88PV1xxBQICAvCnP/2pz36WLFmCLVu24G9/+xvuu+8+PPXUU3j44Ye7tdPpdLBYLL32U1BQgOHDhzu3yEj5rZSJiIiIiIiIqB+OH8E2CKie0GltbYWPj0+3/X/4wx/w6aef4s0330RlZSWWL1/eZz/Lly/H1KlTMW7cOCxcuBD/9V//heeeew52u92lna+vL2w2W6/9GAwGNDc3O7eamhq1h0RERERERERENKioXkMnKCgIjY2N3faHhYUhLCwM11xzDUaMGIHrr78ejz32GMLDwwfU78SJE9HZ2Qmz2Yyrr77aud9qtSI4OLjXnKIoUBRF7WEQEREREREREQ1aqs/Q0ev1KC8v77NNV1cXAHQ726YvZWVl8PDwQEhIiHNfW1sbKisrodfr1Q6TiIiIiIiIiMhtqT5DJy0tDQaDAY2NjdBqtTAajTh58iQmTJgAf39/HDp0CDk5OZg8eTKio6N77KO4uBgHDhzAtGnTMGzYMBQXF2PZsmWYM2cOtFqts11JSQkURUFqaqr4AImIiIiIiIiI3I3qM3Ti4+ORmJiIoqIiABfWuHnppZcwZcoUxMXFYdmyZbj11luxY8cOZ8ZsNkOj0WDv3r0ALlwmtWXLFtxwww249tprkZ+fj2XLluHFF190qbV582bMnj0bfn5+F3GIRERERERERHSpaBzuvw0Gqs/QAYC8vDzk5OQgOzsb06ZNw/79+/tsX1VVhcDAQIwfPx4AkJiYiJKSkj4z9fX12Lp1K0pLSyVDJCIiIiIiIiJyW6IJnYyMDFRUVKC2tnZAtwk3Go3Izc11uZyqP2azGWvWrMHo0aMlQ4RS5wVPH/WH14JhonpDQ86JcgBwsmG4KPf81zPENSdP7HsdpN4cqI4W1/Qe0yXKZV71pbjmurKfinKPJL0nrrnj1Dhx9q6gj0S5X928T1xzXsl8Ue7f04vFNbfvkl1GOe5nX4trfmKJEuWaWuRnCK4LmCrKBQWdEdc8M7lDnNX5N4tyDZ5h4pqdfrL//jjXPkRc03p0hCjnGD3wdeG+z8PqLcrZ62WfDwDgK/yfJW2pbKwAcDZK/t9ZdcsmiXJhf+j7P5X60vLiBFEubabsvRoAdm+9TpS7OuyUuKafR7so93n5KHHNieOOinKVI4PENWvPyH9fKnfEiHJD5G+5ON/9prEDcsBz4N+nv097fZ0oZ7PL33Nbo2Q/pOyJH4prbjgo+54xKqhJXLOtU/7eebrZXxY8OlRc88PhsaKcX2CruGa9XXacndfLvp8AwO63ZO/zXXHq/23nOK/64heiiyaa0AGApUuXDrhtYWGh6v6Tk5ORnJysOkdERERERERE5O5E04gNDQ0ICQmB2Wy+xMP5zs6dO5GQkOC8YxYRERERERER/Qtw/Ai2QUA0oZOfn4/MzEznXaw0Gk23bcuWLX32ER0d3S3z9NNPO59PT0+Ht7c3Nm3aJBkiEREREREREZHbUn3Jlc1mw/r16/Hee65rjGzYsAHp6enOx4GBgf32tXLlSmRnZzsfDxvmun7NvHnzsHr1asydO1ftMImIiIiIiIiI3JbqCR2j0QhFUZCSkuKyPzAwEGFh6hbGHDZsWJ+ZmTNnYvHiNnZddAAAoz5JREFUxaisrERMjGyxOiIiIiIiIiIid6P6kiuTyYSkpKRu+xctWoSgoCBcd911ePnll+Fw9H/R2dNPP42RI0dCr9ejsLAQnZ2dLs9HRUUhNDQUJpNJ7TCJiIiIiIiIiNyW6jN0LBYLdDqdy76VK1fixhtvhJ+fH3bt2oUHHngAZ8+exZIlS3rtZ8mSJUhMTMSIESOwf/9+GAwGnDhxAqtWrXJpp9PpYLFYeu3HbrfDbv/uVrItLS1qD4mIiIiIiIiIBsoBaAbJwsEig+TYVE/otLa2wsfHx2XfY4895vyzXq/HuXPnUFhY2OeEzvLly51/HjduHIYMGYL77rsPBQUFUBTF+Zyvry9sNluv/RQUFOCJJ55QexhERERERERERIOW6kuugoKC0NjY2GebiRMn4ptvvnE5c6Y/EydORGdnZ7dboVutVgQHB/eaMxgMaG5udm41NTUDrklERERERERENBipntDR6/UoLy/vs01ZWRm0Wq3LmTb9KSsrg4eHB0JCQpz72traUFlZCb1e32tOURQEBAS4bERERERERERE7kz1JVdpaWkwGAxobGyEVqvF22+/jZMnTyIlJQU+Pj7YvXs3nnrqKTz00EO99lFcXIwDBw5g2rRpGDZsGIqLi7Fs2TLMmTMHWq3W2a6kpASKoiA1NVV2dERERERERER0aTkwaNaZERkkx6b6DJ34+HgkJiaiqKgIAODt7Y3nn38eqampSEhIwAsvvIBVq1ZhxYoVzozZbIZGo8HevXsBXDirZsuWLbjhhhtw7bXXIj8/H8uWLcOLL77oUmvz5s2YPXs2/Pz8LuIQiYiIiIiIiIjci+ozdAAgLy8POTk5yM7ORnp6OtLT0/tsX1VVhcDAQIwfPx4AkJiYiJKSkj4z9fX12Lp1K0pLSyVDJCIiIiIiIiJyW6IJnYyMDFRUVKC2thaRkZH9tjcajcjNzXW5nKo/ZrMZa9aswejRoyVDJCIiIiIiIiJyW6IJHQBYunTpgNsWFhaq7j85ORnJycmqc99qDzoPD9/z6oPCa+X8lHZZEEDHV7KFnD06NOKaMX71olx9iL+45pPHbxHlWtp9xTV9fGV/L0M9Bn6Htu871jBSnDUOHSfKfWC5SlxT8ekQ5XYcu1Zc06de9tr1uIiLWe+M+1SUe7d6rLhm6an+J7x7cu7vvd/Zrz+h046Ls1+dDhXlon5aLa556n+iRDn/BPnvaHOb7PXXcRHXUnu2y2p2ecmLOqY2iXJRWqu45qEDY8TZljjZe1HLixPENa9a8LEo9/YfUsQ1HWFdolzd2WHimm8UTRXlfKe1iGt+VCr7XPI5pXo1AKfJt34uzgb84qgo9+be68Q1f3bDJ6Lc258miGv6vCl7nx9xe6245rn6gf+H7j/beUL++asdfk6USxj5jbjmB9Xy72IfTX5BlMvSzRTX7HLIPpcUr05xzUNb40S59nD5Z6HGV5b18lb/78jzggzRxRJP6BARERERERHRjxAXRf6XoPq/QRoaGhASEgKz2XwZhnNBeXk5IiIicO6cbHadiIiIiIiIiMidqZ7Qyc/PR2ZmJqKjowEA1dXVyMjIgJ+fH0JCQpCTk4POzv5PxXvnnXcwceJE+Pr6QqvV4rbbbnM+N3bsWKSkpGDVqlVqh0dERERERERE5PZUXXJls9mwfv16vPfeewCA8+fPIyMjA2FhYdi/fz9OnDiBu+++G97e3njqqad67Wfbtm3Izs7GU089hRtvvBGdnZ04ePCgS5t7770X2dnZMBgM8PLilWFERERERERERN9SNVNiNBqhKApSUi4sBrhr1y6Ul5fj/fffR2hoKBISEvC73/0OjzzyCB5//HEMGTKkWx+dnZ148MEHUVhYiKysLOf+sWNdFz67+eabYbVasW/fPkyfPl1ybERERERERER0iWkcFzZ3NViOTdUlVyaTCUlJSc7HxcXFiI+PR2jodyvmp6WloaWlBYcOHeqxj08//RS1tbXw8PCAXq9HeHg4brnllm5n6AwZMgQJCQkwmUx9jslut6OlpcVlIyIiIiIiIiJyZ6omdCwWC3Q6nfNxXV2dy2QOAOfjurq6Hvs4duwYAODxxx/Ho48+ih07dkCr1WLq1KmwWl1vlarT6WCxWPocU0FBAYYPH+7cIiNltwkmIiIiIiIiIhosVE3otLa2wsfH56IKdnV1AQB++9vf4vbbb0dSUhI2bNgAjUaD119/3aWtr68vbDZbn/0ZDAY0Nzc7t5qamosaHxERERERERHRvzpVa+gEBQWhsbHR+TgsLAwfffSRS5uTJ086n+tJeHg4ANc1cxRFwZgxY1BdXe3S1mq1IiYmps8xKYoCRVEGfhBERERERERERIOcqjN09Ho9ysvLnY9TU1Px5Zdf4tSpU859u3fvRkBAQLdFjr+VlJQERVFw+PBh576Ojg6YzWaMGjXKpe3Bgweh1+vVDJGIiIiIiIiIyO2pmtBJS0vDoUOHnGfpzJgxA2PHjsXcuXPx+eef47333sOjjz6KRYsW9XrWTEBAABYuXIgVK1Zg165dOHz4MO6//34AwJ133ulsZzabUVtbi5tuukl6bEREREREREREbknVhE58fDwSExNRVFQEAPD09MSOHTvg6emJ1NRUzJkzB3fffTdWrlzpzJjNZmg0Guzdu9e5r7CwEL/4xS8wd+5cTJgwARaLBXv27IFWq3W22bx5M2bMmNHtrB0iIiIiIiIioh87VWvoAEBeXh5ycnKQnZ0NDw8PjBo1Ckajsdf2VVVVCAwMxPjx4537vL298cwzz+CZZ57pMdPe3o5169bh1VdfVTs8IiIiIiIiIiK3p3pCJyMjAxUVFaitrR3QLcKNRiNyc3Ndzr7pT3V1NXJzczF58mS1w3NacP3f4OOv+vBQaw8U1StrjBDlAKB+WJco56M7J675190/FeW8zqk6qcvFV1e0i3IBB4eIa95x7z5R7r8Oyy/1a7erf9196+3SwbNmlId/hzh779w9otyrr98ortkyvUqUuy7cIq7Z2eUpyh263iGuGTXMKs7+MvKj/hv1YMepceKaHmn1oty5dvn7Qkeo7L3Iv1y+AP/MX/5dlLvKt05cs/DQzaJc9hWy900AeLip7xsZ9MXL5i3Kpc2UvW4B4O0/pIhysctKxDWr8yaJcvaqYHFN9d/2LujslH/me5/RyHLyrzawC99zAcDfyy7KDY1pFtf8tL7/79E90ficF9fsmCH7AV89/FT/jXpRdUWQKNf6Ws83WBkI37tk7507K+PENe31vuLsr2vSRLlKq+xnCwBt7bL33K4j/uKaHsNkOb/jsvcTALj6jsP9N+rBx1+PVp3pahWVGrwc/7u5q0FybKKP+KVLlw64bWFhoer+Y2NjERsbqzpHRERERERERPRjoPq/XhoaGhASEgKz2XwZhnNBeXk5IiIicO7cRfw3DRERERERERGRm1I9oZOfn4/MzExER0fj888/x6xZsxAZGQlfX1/ExcXh2WefHVA/77zzDiZOnAhfX19otVrcdtttzufGjh2LlJQUrFq1Su3wiIiIiIiIiIjcnqpLrmw2G9avX4/33nsPAPDJJ58gJCQEGzduRGRkJPbv348FCxbA09MTixcv7rWfbdu2ITs7G0899RRuvPFGdHZ24uDBgy5t7r33XmRnZ8NgMMDLS74mCRERERERERGRu1E1U2I0GqEoClJSLiwiOH/+fJfnx4wZg+LiYmzfvr3XCZ3Ozk48+OCDKCwsRFZWlnP/2LFjXdrdfPPNsFqt2LdvH6ZPn65mmERERERERER0mWgcFzZ3NViOTdUlVyaTCUlJSX22aW5uxogRI3p9/tNPP0VtbS08PDyg1+sRHh6OW265pdsZOkOGDEFCQgJMJpOaIRIRERERERERuT1VEzoWiwU6na7X5/fv34/XXnsNCxYs6LXNsWPHAACPP/44Hn30UezYsQNarRZTp06F1ep6u12dTgeLpe9bBtvtdrS0tLhsRERERERERETuTNWETmtrK3x8fHp87uDBg8jMzMSKFSswY8aMXvvo6uoCAPz2t7/F7bffjqSkJGzYsAEajQavv/66S1tfX1/YbLY+x1RQUIDhw4c7t8jISDWHREREREREREQ06Kia0AkKCkJjY2O3/eXl5Zg+fToWLFiARx99tM8+wsPDAbiumaMoCsaMGYPq6mqXtlarFcHBwX32ZzAY0Nzc7NxqamoGejhEREREREREJOFw422QUDWho9frUV5e7rLv0KFDmDZtGu655x7k5+f320dSUhIURcHhw4ed+zo6OmA2mzFq1CiXtgcPHoRer++zP0VREBAQ4LIREREREREREbkzVRM6aWlpOHTokPMsnYMHD2LatGmYMWMGli9fjrq6OtTV1eH06dO99hEQEICFCxdixYoV2LVrFw4fPoz7778fAHDnnXc625nNZtTW1uKmm26SHBcRERERERERkdtSNaETHx+PxMREFBUVAQC2bt2K06dPY+PGjQgPD3duEyZMcGbMZjM0Gg327t3r3FdYWIhf/OIXmDt3LiZMmACLxYI9e/ZAq9U622zevBkzZszodtYOEREREREREdGPnaoJHQDIy8vDs88+i66uLjz++ONwOBzdNrPZ7GxfVVWFwMBAjB8/3rnP29sbzzzzDE6ePImWlhbs3r0b1157rfP59vZ2rFu3Do899tjFHR0RERERERERkRvyUhvIyMhARUUFamtrB3RHKaPRiNzcXJezb/pTXV2N3NxcTJ48We3wiIiIiIiIiOhyGmSLB6s2SI5N9YQOACxdunTAbQsLC1X3Hxsbi9jYWNW5f1bcOBre7UNU5z7/JEZU7/mZG0Q5AHjg8DxRrr1qmLjm/LQ9otxL/7hBXHP8lbI7kFWXjhHXfL2i70W1e/PGhBfENe+vmCXOtgzzEeXO2BRxzciRTaJcXYv89ffu8bH9N+qBY9wZcc2qhhGi3PUjj4prvvj5FFHO7wtfcc1r5nwpzhaYMkQ5pU70UQIAOB/bKsp1nvMW1/SpkWV9p/a+Plx/Nh9IEeWiY06Kayrvy24S8NewSeKaAdfLx3tmb6got3vrdeKajrAuUa46T/4zilq5X5SrfDVBXLOr3VOUmxRV3X+jXpwNl30uHdkt+x4GAOE+LeLsV2fCRLmOjwf+H5bfp0z7RpTzqZB9VwCAUdNPiHKjfeXvf4GB50S5ifcfEtd8v+oqUS4sUP4948wH/uJscaDsu27XeY24pqf3eVHu/FD5v3JvvOkLUe7Aa+P7b9SLgzuvFuW01zWozpy32SH7rSaSU33JFRERERERERER/bBUT+g0NDQgJCTEZZ2cS628vBwRERE4d042o09ERERERERE5M5UT+jk5+cjMzMT0dHRLvsbGhoQEREBjUaDpqamfvt55513MHHiRPj6+kKr1eK2225zPjd27FikpKRg1apVaodHRERERERERJeRxuH+22CgakLHZrNh/fr1yMrK6vZcVlYWxo0bN6B+tm3bhrlz5+Lee+/F559/jn/84x/45S9/6dLm3nvvxdq1a9HZ2almiEREREREREREbk/VhI7RaISiKEhJcV3cce3atWhqasJDDz3Ubx+dnZ148MEHUVhYiIULF+Kqq67C2LFj8fOf/9yl3c033wyr1Yp9+/apGSIRERERERERkdtTNaFjMpmQlJTksq+8vBwrV67EX/7yF3h49N/dp59+itraWnh4eECv1yM8PBy33HILDh486NJuyJAhSEhIgMlk6rM/u92OlpYWl42IiIiIiIiIyJ2pmtCxWCzQ6XTOx3a7HbNmzUJhYSGioqIG1MexY8cAAI8//jgeffRR7NixA1qtFlOnToXVanVpq9PpYLFY+uyvoKAAw4cPd26RkZFqDomIiIiIiIiIaNBRNaHT2toKHx8f52ODwYC4uDjMmTNnwH10dXUBAH7729/i9ttvR1JSEjZs2ACNRoPXX3/dpa2vry9sNluf/RkMBjQ3Nzu3mpoaFUdERERERERERKo4fgTbIKBqQicoKAiNjY3Ox3v27MHrr78OLy8veHl5Yfr06c52K1as6LGP8PBwABfuZPUtRVEwZswYVFdXu7S1Wq0IDg7uc0yKoiAgIMBlIyIiIiIiIiJyZ15qGuv1emzcuNH5eNu2bWhtbXU+/vjjjzF//nyYTCbExMT02EdSUhIURcHhw4cxZcoUAEBHRwfMZjNGjRrl0vbgwYO444471AyRiIiIiIiIiMjtqZrQSUtLg8FgQGNjI7RabbdJm/r6egBAXFwcAgMDe+wjICAACxcuxIoVKxAZGYlRo0ahsLAQAHDnnXc625nNZtTW1uKmm25SM0QiIiIiIiIiIren6pKr+Ph4JCYmoqioaMAZs9kMjUaDvXv3OvcVFhbiF7/4BebOnYsJEybAYrFgz5490Gq1zjabN2/GjBkzup21Q0REREREREQ/HI3D/bfBQNWEDgDk5eXh2f/P3t3HRV3m++N/DTAMg8qNwgATIIbmTaEMWKBWat5Ay1E61tbmXXIMa1e3zLPuhhW27UH2fCk33VO5u03y86yyktVqLWmmYRRaaUsFmCIyA+ItDEIy3M/8/nCdmoUBPm/1bEyv5+NxPR7O53O9r/f1gWFmvOb6XNeGDY7Fjb9r2rRpsNvtTrNzqqqqEBAQgAkTJjiOqdVqPP/88zh37hyampqwd+9e3HzzzY7z7e3t2LRpE5555hml3SMiIiIiIiIicnuKbrkCgJSUFFRUVKC2trZfW4QXFBRgzZo1TrNv+lJdXY01a9ZgypQpSrvn4OvVAbWXSnHcXZO/EuX7n1N3ieIAYPANTaI4tWeXOGfuO7L+enrLhyqrGoaK4lpvEKdEeIDsZ5v8wWPypFfDQ/bzHezX0nclF06cCBXFRUTViXPGBcl2o9tVGS/O6XPaUxRXpg8T5xw0uFUU1xYv/9uusOrEsSmGL0VxX1r04pxDfXrfydCVk7t6XqetP2xqWZylPEic8+ZbTaK4YJ9L4pwfTpG95g7xahPnPHfeXxyrjpNd6+jQ8+KcZy8NEcW1VfW+YUNvKrfFiuKi55eIc1ZsiRPFffHmuL4ruWAN7/7FX3/431Yvzrm3ZrQ41trqLYqbMkf2ugkAB06OFMV1RXaIc0YNsoji8l+YLc7ZOVT553EAKJyi+L8pDm11WlGcuV4WBwApD38ujv3b5+NFcZ5N8p/RLQknRHFfmWTPWwDY97XsbzTx3qPinLOHlYni8s9MVBzT6dGGUlE2IjnRq8DKlSv7XffK+jhKjBw5EiNHyl8siIiIiIiIiIjcmeJbrurr66HT6WAyma5Ddy4rLy9HeHg4mpubr1sOIiIiIiIiIqKBSvGATlZWFlJTUxEVFeU4lpubi/Hjx8PHxwc6nQ7Lly/vtY3W1lYsX74cw4YNw+DBg3Hvvffi3LlzjvPjxo1DYmIi1q9fr7R7RERERERERHQ92X8AZQBQNKBjtVphNBqxdOlSx7H169fjqaeewpNPPomysjK8//77SEpK6rWdJ554Am+//TZef/11HDhwAKdPn8a8efOc6qSlpeGVV15BZ2enki4SEREREREREbk9RWvoFBQUQKPRIDExEQDQ0NCAp59+Gm+//TZmzJjhqDd+vOuFvRobG2E0GrFt2zbcddflhXk3b96MsWPH4tChQ462Z82aBYvFggMHDji1TURERERERET0Q6dohk5RURHi47/dZWbv3r2w2Wyora3F2LFjER4ejvvvvx81Na53sDly5Ag6Ojowc+ZMx7ExY8YgMjISBw8edBzz9vZGbGwsioqKlHSRiIiIiIiIiMjtKRrQMZvN0Ou/3Z725MmTsNlsWLduHV588UXs2LEDFosFs2bNQnt7e49tnD17Ft7e3ggICHA6HhISgrNnzzod0+v1MJvNvfapra0NTU1NToWIiIiIiIiIrpN/9fo2XEMHgMIBnZaWFvj4+Dge22w2dHR0YOPGjUhKSkJiYiLy8vJQUVGBDz744Ko7p9VqYbVae62TnZ0Nf39/R4mIiLjqvERERERERERE32eKBnSCgoLQ0NDgeBwWFgbg8q5UVwQHByMoKAjV1dU9thEaGor29nZcvHjR6fi5c+cQGhrqdMxisSA4OLjXPmVkZKCxsdFRervdi4iIiIiIiIjIHSga0DEYDCgvL3c8njJlCgDg2LFjjmMWiwV1dXUYPnx4j23Ex8dDrVZj3759jmPHjh1DdXU1Jk2a5FS3tLQUBoOh1z5pNBr4+fk5FSIiIiIiIiKi/ysvvfQSoqKi4OPjg4SEBHz66af9ivvLX/4ClUqFe+65R3FORQM6SUlJKCsrc8zSuemmm5CamorHH38cxcXFKC0txUMPPYQxY8Zg+vTpPbbh7++PpUuXYtWqVfjggw9w5MgRpKWlYdKkSY4drgDAZDKhtrbWafFkIiIiIiIiIqLvk+3bt2PVqlVYu3YtPv/8c0yYMAFJSUk4f/58r3Emkwm/+MUvcMcdd4jyKhrQiYmJQVxcHPLz8x3HtmzZgoSEBKSkpGDq1KlQq9XYvXs31Gq1o45KpUJubq7j8e9+9zv827/9G+69917ceeedCA0NxZtvvumUKy8vD7Nnz3Y504eIiIiIiIiI/u+p7O5flFi/fj3S09ORlpaGcePGYdOmTfD19cVrr73mMqarqwsLFizAr3/9a9x4442i34OiAR0AyMzMxIYNG2Cz2QAAfn5+MBqNaGhoQH19Pd58802nhYmrqqrg5eXluD0LAHx8fPDSSy/BYrGgubkZb775ptP6Oe3t7di0aROeeeYZ0UUREREREREREV1v7e3tOHLkiNPdRR4eHpg5cyYOHjzoMu65556DTqfD0qVLxbm9lAakpKSgoqICtbW1/dpRqqCgAMuWLcOoUaP6naO6uhpr1qxxGgQiIiIiIiIiIvq/0tTU5PRYo9FAo9E4Haurq0NXVxdCQkKcjoeEhODrr7/usd2PPvoIRqMRJSUlV9U/xQM6ALBy5cp+112+fLni9keOHImRI0cqjvuu1GF/h+8QT8VxvzffJco3SN0uigOA5m98+q7UA1u78uu74vHUd0Vxr7x5tzin9XiAKM4e3SLOWVUbJIobHGAV52yu8hfHqnRtoriWYwHinENGXxTFDfaW9RUAik7LphQOvqGp70ou/PvtX4riXt8xVZzTS/g0st96SZxzzKCz4tjtVXGiuDcmGMU5/23TL0VxAbPk13n69FBRnPq8uu9KLpSbw0Rxi2I/Eec0DJft+pgy9AtxziLzeHFs6pzPRXG+HvL337/mT5MFij49XSZ9767YIvv7BIBRi2U/2+pnJ4tzqjpUorhvvpb9fQJA5+Aucewdhp4/cPdlf8m4viu5oA5oFcV5V8tfiw4cjxfFhS6U7yLrAYX3LfxD1ad9f3HsMmeE7Gd7z1j569+bh2U/WwC4O+4rUVy4pqHvSi5sLpD9n8emkf0+AUD7tez/PH/3DRfnPHhc9pnT09umOMZmlT3v6PvtnyexrF27Fs8+++xVtfnNN99g0aJF+NOf/oSgINn/V6+4io8kRERERERERPSDY/9HcVf/uLaamhqnnbT/eXYOAAQFBcHT0xPnzp1zOn7u3DmnpWWuqKyshMlkwpw5cxzHrixp4+XlhWPHjiE6Orpf3VS8hk59fT10Oh1MJpPS0H6rq6uDTqfDqVOnrlsOIiIiIiIiIiJX/Pz8nEpPAzre3t6Ij4/Hvn37HMdsNhv27duHSZMmdas/ZswYfPXVVygpKXGUuXPnYvr06SgpKenX0jZXKB7QycrKQmpqKqKiogAAjz32GOLj46HRaBAbG9vvdg4ePIi77roLgwYNgp+fH+688060tFy+tSYoKAiLFy/G2rVrlXaPiIiIiIiIiOj/zKpVq/CnP/0J/9//9//h6NGj+OlPf4rm5makpaUBABYvXoyMjAwAlzeJuuWWW5xKQEAAhgwZgltuuQXe3t79zqvoliur1Qqj0Yg9e/Y4Hf+P//gPfPLJJ/jyy/6tUXHw4EEkJycjIyMDv//97+Hl5YUvvvgCHh7fji+lpaUhPj4eOTk5GDpUfj81EREREREREdH18sADD+DChQvIzMzE2bNnERsbi927dzsWSq6urnYa77hWFA3oFBQUQKPRIDEx0XFs48aNAIALFy70e0DniSeewGOPPYYnn3zScWz06NFOdW6++Wbo9Xq89dZbV7WNFxERERERERHR9bRixQqsWLGix3OFhYW9xubm5opyKhoiKioqQny8fAV3ADh//jw++eQT6HQ6TJ48GSEhIZg6dSo++uijbnVvu+02FBUVXVU+IiIiIiIiIrqG7D+AMgAoGtAxm83Q6/VXlfDkyZMAgGeffRbp6enYvXs34uLiMGPGDFRUVDjV1ev1MJvNvbbX1taGpqYmp0JERERERERE5M4UDei0tLTAx8fnqhJe2Y7rkUceQVpaGgwGA373u99h9OjReO2115zqarVaWK3WXtvLzs6Gv7+/oyhZEZqIiIiIiIiIaCBSNKATFBSEhoaGq0oYFhYGABg3bpzT8bFjx6K6utrpmMViQXBwcK/tZWRkoLGx0VFqamquqn9ERERERERERN93igZ0DAYDysvLryphVFQU9Ho9jh075nT8+PHjGD58uNOx0tJSGAyGXtvTaDTd9oYnIiIiIiIioutDZXf/MhAoGtBJSkpCWVmZ0yydEydOoKSkBGfPnkVLSwtKSkpQUlKC9vb2HttQqVRYvXo1Nm7ciB07duDEiRN45pln8PXXXzvtZmW1WnHkyBHMnj1beGlERERERERERO5J0bblMTExiIuLQ35+Ph555BEAwMMPP4wDBw446lyZUVNVVYWoqCgAlwdxNm/ejCVLlgAAVq5cidbWVjzxxBOwWCyYMGEC9u7di+joaEc7O3fuRGRkJO64446ruT4iIiIiIiIiIrejaIYOAGRmZmLDhg2OxY0LCwtht9u7lSuDOVVVVfDy8sKUKVOc2nnyySdRU1OD5uZmFBcX4/bbb3c6v2HDBmRmZgovi4iIiIiIiIjIfSmaoQMAKSkpqKioQG1tbb92lCooKMCyZcswatSofueoq6vDvHnz8OCDDyrtnoPx1O3wGqRRHFd3aZAoX1VjkCgOAOwtin8NAADN0BZxztcqJoniPDpV4pxd0b3vWObKLTecEef08ugSxZV8OlKcU90s/xmtTn5XFPffHkninMMGyX4vTw4vEOfcdGa6KO7GQXXinP/7RYIozh7ZIc6pviD72x4RbBHnvBpPjZE9/65G2zCbKK7+k1BxziFNsjhrmKyvAOB7VLZD5Psho8U5A31k7xHPHU0R5/Rskb/+HWsKEcV9UT6870ouaKfLngydnYq/D3OYHFndd6UefPHmuL4ruVD97GRRXOSzxeKcp38py2lLaBTn9Phavo7iR8f6/zn1u7zrPcU5Pc4MlgVexboOET8yieLMe6PEOTsHyTockVArznn6w3BR3LFw2esQAPz39Hxx7Msm2eeigy1R4pyq4bLPf7ZG5f+/ukIzSba5Ts7NO8Q5N5yaJYqrON/7xjw96ersFOUiuhqi/22sXLmy33WXL1+uuP2goCD88pe/VBxHRERERERERNeZHVc1wPy9N0CuTf4VExERERERERER/UsoHtCpr6+HTqeDyWS6Dt25rK6uDjqdDqdOnbpuOYiIiIiIiIiIBirFAzpZWVlITU11LHoMALm5uRg/fjx8fHyg0+n6vM3qj3/8I6ZNmwY/Pz+oVCpcvHjR6XxQUBAWL16MtWvXKu0eEREREREREZHbU7SGjtVqhdFoxJ49exzH1q9fjxdeeAE5OTlISEhAc3Nzn7N3rFYrkpOTkZycjIyMjB7rpKWlIT4+Hjk5ORg6dKiSbhIRERERERHRdaKyXy7uaqBcm6IBnYKCAmg0GiQmJgIAGhoa8PTTT+Ptt9/GjBkzHPXGjx/faztXFlUuLCx0Wefmm2+GXq/HW2+9haVLlyrpJhERERERERGRW1N0y1VRURHi4+Mdj/fu3QubzYba2lqMHTsW4eHhuP/++1FTU3NNOnfbbbehqKio1zptbW1oampyKkRERERERERE7kzRgI7ZbIZer3c8PnnyJGw2G9atW4cXX3wRO3bsgMViwaxZs9De3n7VndPr9TCbzb3Wyc7Ohr+/v6NERERcdV4iIiIiIiIiou8zRQM6LS0t8PHxcTy22Wzo6OjAxo0bkZSUhMTEROTl5aGiogIffPDBVXdOq9XCarX2WicjIwONjY2Ocq1mBxERERERERERfV8pWkMnKCgIDQ0NjsdhYWEAgHHjxjmOBQcHIygoCNXV1VfdOYvFguDg4F7raDQaaDSaq85FRERERERERP1g/0dxVwPk2hTN0DEYDCgvL3c8njJlCgDg2LFjjmMWiwV1dXUYPnz4VXeutLQUBoPhqtshIiIiIiIiInInigZ0kpKSUFZW5pilc9NNNyE1NRWPP/44iouLUVpaioceeghjxozB9OnTXbZz9uxZlJSU4MSJEwCAr776CiUlJbBYLI46VqsVR44cwezZsyXXRURERERERETkthQN6MTExCAuLg75+fmOY1u2bEFCQgJSUlIwdepUqNVq7N69G2q12lFHpVIhNzfX8XjTpk0wGAxIT08HANx5550wGAzYtWuXo87OnTsRGRmJO+64Q3ptRERERERERERuSdGADgBkZmZiw4YNsNlsAAA/Pz8YjUY0NDSgvr4eb775ptNOU1VVVfDy8nLcngUAzz77LOx2e7eyZMkSR50NGzYgMzPzKi6NiIiIiIiIiK45+w+gDACKFkUGgJSUFFRUVKC2trZfW4QXFBRg2bJlGDVqVL9z1NXVYd68eXjwwQeVds/B08MGTw+b4rgHbvxclO+t6gmiOACotwwWxa2K2SfOmV38I1Hc/yx6TZxzxf5Fojhfr3Zxzm0jZLutRX82UpxT1aUSx3YpH2O9HHdOK8750/i/iuKWfLhUnHPiSJMobt+Zm8Q5fXxlz6O7xlaIc/7t8/GiOPNHkeKc705S/LLuoPEcLYoL1l4S59THnBPFna73F+f0LPUVxYXecl6cs/H9UFHcxQOyOACYv+htUdzr7fHinKeGKX/fveJL0w2iuITxJ8Q5Pz0se01RfyN/nb8UJtvIwRou/9mqOmT9Pf3LyeKc+v9XLIo78WKiOOfgC1fx/hsl+/m2B3aJcwYPb+i7Ug++sfr0XcmFr2tkrylhd54V52wslOWsOhomzqlWy/4nZi4YIc6Ze7f8+Td+aK0orq5N9n8IADj4Zf//b/Zdg0KaxTmbjgeK4h4+Lf/MqQ3qfcdkVzpMyn+2tlb5ZzAiKdGzbuXKlf2uu3z5csXtBwUF4Ze//KXiOCIiIiIiIiKiHwLF0wHq6+uh0+lgMpmuQ3cuKy8vR3h4OJqb5SPARERERERERETuSvGATlZWFlJTUxEVFeU4lpubi/Hjx8PHxwc6na7XWTkWiwU///nPMXr0aGi1WkRGRuKxxx5DY2Ojo864ceOQmJiI9evXK+0eEREREREREZHbU3TLldVqhdFoxJ49exzH1q9fjxdeeAE5OTlISEhAc3Nzr7N3Tp8+jdOnT+P555/HuHHjYDab8eijj+L06dPYsWOHo15aWhrS09ORkZEBLy/ej0hERERERET0faD6R3FXA+XaFI2UFBQUQKPRIDHx8oJ1DQ0NePrpp/H2229jxowZjnrjx7teCPSWW27BG2+84XgcHR2NrKwsLFy4EJ2dnY7Bm1mzZsFiseDAgQNObRMRERERERER/dApuuWqqKgI8fHf7n6xd+9e2Gw21NbWYuzYsQgPD8f999+PmpoaRZ1obGyEn5+f00wcb29vxMbGoqioSFFbRERERERERETuTtGAjtlshl6vdzw+efIkbDYb1q1bhxdffBE7duyAxWLBrFmz0N7evy2C6+rq8Jvf/AbLli3rdk6v18NsNvca39bWhqamJqdCREREREREROTOFA3otLS0wMfHx/HYZrOho6MDGzduRFJSEhITE5GXl4eKigp88MEHfbbX1NSElJQUjBs3Ds8++2y381qtFlartdc2srOz4e/v7ygRERFKLomIiIiIiIiIlLD/AMoAoGhAJygoCA0NDY7HYWFhAC7vSnVFcHAwgoKCUF1d3Wtb33zzDZKTkzFkyBC89dZbUKvV3epYLBYEBwf32k5GRgYaGxsdRentXkREREREREREA42iAR2DwYDy8nLH4ylTpgAAjh075jhmsVhQV1eH4cOHu2ynqakJs2fPhre3N3bt2uU06+e7SktLYTAYeu2TRqOBn5+fUyEiIiIiIiIicmeKBnSSkpJQVlbmmKVz0003ITU1FY8//jiKi4tRWlqKhx56CGPGjMH06dN7bOPKYE5zczOMRiOamppw9uxZnD17Fl1dXY56JpMJtbW1mDlz5lVcHhERERERERGR+1E0oBMTE4O4uDjk5+c7jm3ZsgUJCQlISUnB1KlToVarsXv3bqdbqFQqFXJzcwEAn3/+OT755BN89dVXGDlyJMLCwhzlu7dL5eXlYfbs2b3O9CEiIiIiIiIi+iHy6ruKs8zMTKxevRrp6enw8PCAn58fjEYjjEZjj/Wrqqrg5eXluD1r2rRpsNt7X2Govb0dmzZtwrZt25R2j4iIiIiIiIiuI5X9cnFXA+XaFA/opKSkoKKiArW1tf3aUaqgoADLli3DqFGj+p2juroaa9ascQwCSbR1eaGrS/Hl4U8fTZUl9JT/xrU13ReE7o8tukRxzvvjDovifv7xfHFOz0GdorhDFTeKc+YOKxPF3X3H38U5r8ZvP00WxflXKJps5+R4a5goztO7q+9KLowdclYU12mTX+fumD+L4p45e6c45323yv7O3vwwQZzzzKey3ycAtOtkf6NtURfEOWtO9r7wvUte8tdc3fRaUZyl4AZxzk5/WZxt7CVxzlf+vzmiuKi7q8Q5x99WKY49sbP/nxO+q3JYkDinz3nZa4q6WZwSx/dGi+L8b6sX5/zm66GiOFtCozjniRdln1FGrjwkzhn4sew6AWDNDQWiuPmbVolz3nZr7xuIuHK2dYg4599Nst1g1R42cc7mSNl7i/aM8s/xV9iEoe3x8tdc0/tR4tiQOd+I4g5XR4pzzoyTfUbe9+kt4pzjJppFcWe2RYlztibJPi90DVb+OdfmKf9sTCQlerlbuXJlv+suX75ccfsjR47EyJEjFccREREREREREf0QyL/uJiIiIiIiIiKifwnFAzr19fXQ6XQwmUzXoTuXlZeXIzw8HM3NVzGnmYiIiIiIiIiuPfsPoAwAigd0srKykJqaiqioKNTX1yM5ORl6vR4ajQYRERFYsWIFmpqa+mznb3/7GxISEqDVahEYGIh77rnHcW7cuHFITEzE+vXrlXaPiIiIiIiIiMjtKRrQsVqtMBqNWLp06eVgDw+kpqZi165dOH78OHJzc/H+++/j0Ucf7bWdN954A4sWLUJaWhq++OILfPzxx5g/33mx3bS0NLzyyivo7JQtpEZERERERERE5K4ULYpcUFAAjUaDxMTLOxcEBgbipz/9qeP88OHD8bOf/Qw5OTku2+js7MTjjz+OnJwcx8AQcHlWznfNmjULFosFBw4cwIwZM5R0k4iIiIiIiIjIrSmaoVNUVIT4+HiX50+fPo0333wTU6e63vr7888/R21tLTw8PGAwGBAWFoa7774bpaWlTvW8vb0RGxuLoqKiXvvU1taGpqYmp0JERERERERE5M4UDeiYzWbo9fpuxx988EH4+vrihhtugJ+fH1599VWXbZw8eRIA8Oyzz+Lpp5/GO++8g8DAQEybNg0Wi8Wprl6vh9ls7rVP2dnZ8Pf3d5SIiAgll0RERERERERESv2rFy3+gS+IDCgc0GlpaYGPj0+347/73e/w+eefY+fOnaisrMSqVatctmGz2QAATz31FO69917Ex8dj8+bNUKlUeP31153qarVaWK3WXvuUkZGBxsZGR6mpqVFySUREREREREREA46iNXSCgoLQ0NDQ7XhoaChCQ0MxZswYDB06FHfccQeeeeYZhIWFdat75dh318zRaDS48cYbUV1d7VTXYrEgOjq61z5pNBpoNBoll0FERERERERENKApmqFjMBhQXl7ea50rM3Da2tp6PB8fHw+NRoNjx445jnV0dMBkMmH48OFOdUtLS2EwGJR0kYiIiIiIiIjI7SmaoZOUlISMjAw0NDQgMDAQBQUFOHfuHG699VYMHjwYZWVlWL16NaZMmYKoqKge2/Dz88Ojjz6KtWvXIiIiAsOHD3fsivXjH//YUc9kMqG2thYzZ86UXx0RERERERERXVMq++XirgbKtSmaoRMTE4O4uDjk5+cDuLzGzZ/+9CfcfvvtGDt2LJ544gnMnTsX77zzjiPGZDJBpVKhsLDQcSwnJwc/+clPsGjRItx6660wm83Yv38/AgMDHXXy8vIwe/bsbrN2iIiIiIiIiIh+6BTN0AGAzMxMrF69Gunp6Zg+fTqKi4t7rV9VVYWAgABMmDDBcUytVuP555/H888/32NMe3s7Nm3ahG3btintHhERERERERGR21M8oJOSkoKKigrU1tb2a4vwgoICrFmzxmn2TV+qq6uxZs0aTJkyRWn3HEb5XYD3YG/FceoxXaJ8FSXy7dL9p5wTxf3v2C3inDMOPCaKGx9VK8557IPeF7h2ZcX9b4tzvnBUdsvepTODxTm9vvEUx45LMIniGkK04pxvmib0XakHnZfU4pxfNepFccE+l8Q5Y/euEMX5mOWLrnf6yOZqxkw6Kc559GyIONb7xCBRnN/oVnHOsWNOieJiA2RxAPDWCdlzPmnhp+Kc7715myhO86n8tegnD+0TxW3NmyHOaY1uF8dOmFspiqv9xl+cc8rcL0RxbTb563yYT5Mobm/NaHHOzsGyzzYeX/uJcw6+oBLFBX48VJyzYYpFHLv4Mdc7tPbGdqfs9wkAf/syRhR3U9RZcU71SdnnhVOe8nsPAsMbRXEt54aJc3rLUkJVLH/N7bxTmBTApztlz4X77v9InHPX9ttFcdpb5df59WdRoriuxA5xTtT5isJUvp3KY1TKY4iuluIBHQBYuXJlv+teWR9HiZEjR2LkyJGK44iIiIiIiIiIfggUraEDAPX19dDpdDCZTNehO5eVl5cjPDwczc3N1y0HEREREREREQnYfwBlAFA8oJOVlYXU1FSnXaxyc3Mxfvx4+Pj4QKfTYfny5b228cgjjyA6OhparRbBwcFITU3F119/7Tg/btw4JCYmYv369Uq7R0RERERERETk9hQN6FitVhiNRixdutRxbP369Xjqqafw5JNPoqysDO+//z6SkpJ6bSc+Ph6bN2/G0aNHsWfPHtjtdsyePRtdXd/e452WloZXXnkFnZ28F5GIiIiIiIiI6LsUraFTUFAAjUaDxMREAEBDQwOefvppvP3225gx49tFFMePH99rO8uWLXP8OyoqCv/1X/+FCRMmwGQyITr68sK5s2bNgsViwYEDB5zaJiIiIiIiIiL6oVM0Q6eoqAjx8fGOx3v37oXNZkNtbS3Gjh2L8PBw3H///aipqel3m83Nzdi8eTNGjBjhtGuWt7c3YmNjUVRUpKSLRERERERERHQdqezuXwYCRQM6ZrMZev232w2fPHkSNpsN69atw4svvogdO3bAYrFg1qxZaG/vfevSl19+GYMHD8bgwYPx7rvvYu/evfD2dt5mXK/Xw2w299pOW1sbmpqanAoRERERERERkTtTNKDT0tICHx8fx2ObzYaOjg5s3LgRSUlJSExMRF5eHioqKvDBBx/02taCBQvw97//HQcOHMBNN92E+++/H62trU51tFotrFZrr+1kZ2fD39/fUb47y4eIiIiIiIiIyB0pGtAJCgpCQ0OD43FYWBiAy7tSXREcHIygoCBUV1f32pa/vz9GjRqFO++8Ezt27MDXX3+Nt956y6mOxWJBcHBwr+1kZGSgsbHRUZTc7kVERERERERENBApGtAxGAwoLy93PJ4yZQoA4NixY45jFosFdXV1GD58eL/btdvtsNvtaGtrczpeWloKg8HQa6xGo4Gfn59TISIiIiIiIiJyZ4oGdJKSklBWVuaYpXPTTTchNTUVjz/+OIqLi1FaWoqHHnoIY8aMwfTp03ts4+TJk8jOzsaRI0dQXV2N4uJi/PjHP4ZWq8WPfvQjRz2TyYTa2lrMnDnzKi6PiIiIiIiIiK4p+w+gDACKBnRiYmIQFxeH/Px8x7EtW7YgISEBKSkpmDp1KtRqNXbv3g21Wu2oo1KpkJubCwDw8fFBUVERfvSjH2HkyJF44IEHMGTIEBQXF0On0zli8vLyMHv2bEUzfYiIiIiIiIiIfgi8lAZkZmZi9erVSE9Ph4eHB/z8/GA0GmE0GnusX1VVBS8vL8ftWXq9HgUFBb3maG9vx6ZNm7Bt2zal3SMiIiIiIiIicnuKB3RSUlJQUVGB2trafu0oVVBQgGXLlmHUqFH9zlFdXY01a9Y4BoGIiIiIiIiIiOhbigd0AGDlypX9rrt8+XLF7Y8cORIjR45UHPdd+0+MhoevT98V/0lG3LuifG97doriAMDXq10Ul1Ss/Gd7hb1Z9KuHj1eHOKd3bEPflXpw8GK0OOelC4NEcarB8t+nrU3RnYxOjtaEiuJemiSfzfbzHf8hivOMbBHn/PIT2d93V4D896KtVvddqQeqLnFK2KJbRXGN7cpfu67o6vQUx3qNuiSKO/H+jeKcaQ/sEcV90jBCnHOwtq3vSj0oPivPeUfq30VxH77T+8YAvXnv7FhRnKfsLekfwfIbzsN9L4riKt+Rv0f4/eSEKG6wl+w5BABHv5G9zltbvcU57zB8LYr76Fj/v4z7Z11RNlHcmht6n8Xdm8WPrRLHhmwsFsXVzbpJnFNzRLaRh/lUpDjnsISzorjTpiBxzkCdRRRnj5PFAUCAr+wzytmiG8Q5B2vkn5FbZH8u2Jl/uzhna4gs6a2hZ8Q5/14ue87fNrpSnPOzj8eI4rraBZ/nW67iQ+MApLJfLu5qoFyb/H+eRERERERERET0L6F4QKe+vh46nQ4mk+k6dOey8vJyhIeHo7m5+brlICIiIiIiIiIaqBQP6GRlZSE1NRVRUVGOY7m5uRg/fjx8fHyg0+n6fZuV3W7H3XffDZVKhb/+9a+O4+PGjUNiYiLWr1+vtHtERERERERERG5P0UIqVqsVRqMRe/Z8u+bB+vXr8cILLyAnJwcJCQlobm7u9+ydF198ESqVqsdzaWlpSE9PR0ZGBry8ZOu9EBERERERERG5I0UjJQUFBdBoNEhMTAQANDQ04Omnn8bbb7+NGTNmOOqNHz++z7ZKSkrwwgsv4PDhwwgLC+t2ftasWbBYLDhw4IBT20RERERERET0L2T/R3FXA+TaFN1yVVRUhPj4eMfjvXv3wmazoba2FmPHjkV4eDjuv/9+1NTU9NqO1WrF/Pnz8dJLLyE0tOfdHry9vREbG4uioqJe22pra0NTU5NTISIiIiIiIiJyZ4oGdMxmM/R6vePxyZMnYbPZsG7dOrz44ovYsWMHLBYLZs2ahfZ21/uePvHEE5g8eTJSU1N7zafX62E2m3utk52dDX9/f0eJiIhQcklERERERERERAOOogGdlpYW+Pj4OB7bbDZ0dHRg48aNSEpKQmJiIvLy8lBRUYEPPvigxzZ27dqF/fv348UXX+wzn1arhdVq7bVORkYGGhsbHaWv2UFERERERERERAOdogGdoKAgNDQ0OB5fWftm3LhxjmPBwcEICgpCdXV1j23s378flZWVCAgIgJeXl2PB43vvvRfTpk1zqmuxWBAcHNxrnzQaDfz8/JwKEREREREREZE7UzSgYzAYUF5e7ng8ZcoUAMCxY8ccxywWC+rq6jB8+PAe23jyySfx5ZdfoqSkxFEA4He/+x02b97sVLe0tBQGg0FJF4mIiIiIiIjoerL/AMoAoGiXq6SkJGRkZKChoQGBgYG46aabkJqaiscffxx//OMf4efnh4yMDIwZMwbTp0/vsY3Q0NAeF0KOjIzEiBEjHI9NJhNqa2sxc+ZMhZdEREREREREROTeFM3QiYmJQVxcHPLz8x3HtmzZgoSEBKSkpGDq1KlQq9XYvXs31Gq1o45KpUJubq6ijuXl5WH27NkuZ/oQEREREREREf1QKZqhAwCZmZlYvXo10tPT4eHhAT8/PxiNRhiNxh7rV1VVwcvLy3F7Vk/sduf5TO3t7di0aRO2bdumtHtERERERERERG5P8YBOSkoKKioqUFtb268twgsKCrBs2TKMGjWq3zmqq6uxZs2aXgeB+mKzqYAuleK4F43zRPna4ptFcQDQWefTd6UeeDUrmmDl5L/+Pb/vSj14+uN/F+f01HSJ4gLULeKcQ8MaRXEJoT0v6t0fI7QXxLFDPFpFcS9Wy29NfOqeN0RxqYNM4pxPnpkhilsa/KE453vfxIjifD3axTl/f+guUdylNo045/3jjohjP7PIZkQOmXVWnHPTe7NEcXYv+Y3Ng82eorjgu0+Jcx78i2w9uNZb5M+/s4fCRHGqweKUuCGsoe9KLuwz3SSK8+4Qp8TOwttEcYOiZe8tANDxWaAobsqcL8U595eM67tSD7zrZX8rANAeKHvPn79plTin7c4mcWzdLNnzL2jOcXHO06uDRHEeV/GcP/dViCjuvhmHxDnfKEoQxelG1Ylzdtlkn5FjZh/ru5IL5e+MFseGJ5lFcRW1OnFOL5Ps/x9/3y+/zphpFaK4kjM3iHP6y1KiPl755wx75wBZdOUaUdkvF3c1UK5N8YAOAKxcubLfdZcvX664/ZEjR2LkyJGK44iIiIiIiIiIfggUD1/X19dDp9PBZDJdh+5cVl5ejvDwcDQ3y2e9EBERERERERG5K8UDOllZWUhNTUVUVBSAywse/3P5y1/+0mc7f/vb35CQkACtVovAwEDcc889jnPjxo1DYmIi1q9fr7R7RERERERERERuT9EtV1arFUajEXv27HE6vnnzZiQnJzseBwQE9NrOG2+8gfT0dKxbtw533XUXOjs7UVpa6lQnLS0N6enpyMjIgJeX6M4wIiIiIiIiIiK3pGikpKCgABqNBomJiU7HAwICEBoa2q82Ojs78fjjjyMnJwdLly51HB83znnBvlmzZsFiseDAgQOYMUO2gCoRERERERERXWP2fxR3NUCuTdEtV0VFRYiPj+92fPny5QgKCsJtt92G1157rds25N/1+eefo7a2Fh4eHjAYDAgLC8Pdd9/dbYaOt7c3YmNjUVRUpKSLRERERERERERuT9EMHbPZDL1e73Tsueeew1133QVfX1+89957+NnPfoZLly7hscce67GNkydPAgCeffZZrF+/HlFRUXjhhRcwbdo0HD9+HEOHDnXU1ev1MJt738avra0NbW1tjsdNTfItK4mIiIiIiIiIBgJFAzotLS3w8fFxOvbMM884/m0wGNDc3IycnByXAzo2mw0A8NRTT+Hee+8FcHkNnvDwcLz++ut45JFHHHW1Wi2sVmuvfcrOzsavf/1rJZdBRERERERERDSgKbrlKigoCA0NDb3WSUhIwKlTp5xmzXxXWFgYAOc1czQaDW688UZUV1c71bVYLAgODu41X0ZGBhobGx2lpqamP5dCRERERERERAIqu93ty0CgaEDHYDCgvLy81zolJSUIDAyERqPp8Xx8fDw0Gg2OHTvmONbR0QGTyYThw4c71S0tLYXBYOg1n0ajgZ+fn1MhIiIiIiIiInJnim65SkpKQkZGBhoaGhAYGIi3334b586dQ2JiInx8fLB3716sW7cOv/jFL1y24efnh0cffRRr165FREQEhg8fjpycHADAj3/8Y0c9k8mE2tpazJw5U3hpRERERERERETuSdEMnZiYGMTFxSE/Px8AoFar8dJLL2HSpEmIjY3FH/7wB6xfvx5r1651xJhMJqhUKhQWFjqO5eTk4Cc/+QkWLVqEW2+9FWazGfv370dgYKCjTl5eHmbPnt1t1g4RERERERER0Q+dohk6AJCZmYnVq1cjPT0dycnJSE5O7rV+VVUVAgICMGHCBMcxtVqN559/Hs8//3yPMe3t7di0aRO2bdumtHtERERERERERG5P8YBOSkoKKioqUFtbi4iIiD7rFxQUYM2aNU6zb/pSXV2NNWvWYMqUKUq7R0RERERERETXk/0fxV0NkGtT2e0DZPnmfmpqaoK/vz9u2f4LePr2vDBzb0YOrRPlPXohRBQHAC+O3y6KS//oIXHO8NDedytzpaY6SJzz7tivRHEjtBfEOV8umiGK8zmneKzTITFZdp0AUNU0TBQ3fmitOOfHZ0aI4l66OU+cc35RuijO85zyv+krOod2iOK86tXinDZ9qyjumVv/Js75X5//SBy76OZPRXHbK+LEObuODhHFdfjbxDm9dC2yQNMgcc7b7jwqigvRNIlzvvvXRFGc+htxSrSEyj9S+Iy5KIqzHer/F0b/7K77PhPFfV7X9xdarmi8OkVx5vNDxTk9PGR/L55HB4tzDrlN9t59m66670ou/O3LGHFswBFvUVyn/GUB+pxiUdz5n00W52y+o1kU19km/1zk7dsuimtvlb//xo2QPY8udcg/Z5z7RvZ+BgDWL2WvY56tKnFOZQtvfKvLR/46rxp1SRSXf9ufxDkXlqSJ4r6pU/7HbWtpxakVz6KxsdGtN+q58v/t2IVZ8PT2+Vd357rpam9FyZ+f+t7/PoV/ykRERERERERE9K+ieECnvr4eOp0OJpPpOnTnsvLycoSHh6O5WfYtAhERERERERGRO1M8oJOVlYXU1FRERUU5juXm5mL8+PHw8fGBTqfD8uXLe21j2rRpUKlUTuXRRx91nB83bhwSExOxfv16pd0jIiIiIiIioutIZXf/MhAouiHWarXCaDRiz549jmPr16/HCy+8gJycHCQkJKC5ublfs3fS09Px3HPPOR77+vo6nU9LS0N6ejoyMjLg5SW/b5eIiIiIiIiIyN0oGikpKCiARqNBYuLlhRYbGhrw9NNP4+2338aMGd8uPjt+/Pg+2/L19UVoaKjL87NmzYLFYsGBAwec2iYiIiIiIiIi+qFTdMtVUVER4uPjHY/37t0Lm82G2tpajB07FuHh4bj//vtRU1PTZ1tbt25FUFAQbrnlFmRkZMBqtTqd9/b2RmxsLIqKinptp62tDU1NTU6FiIiIiIiIiMidKRrQMZvN0Ov1jscnT56EzWbDunXr8OKLL2LHjh2wWCyYNWsW2ttdb1E4f/58/PnPf8YHH3yAjIwM/O///i8WLlzYrZ5er4fZbO61T9nZ2fD393eUiAj5VqJERERERERERAOBoluuWlpa4OPz7V7zNpsNHR0d2LhxI2bPng0AyMvLQ2hoKD744AMkJSX12M6yZcsc/46JiUFYWBhmzJiByspKREdHO85ptdpuM3f+WUZGBlatWuV43NTUxEEdIiIiIiIiouvF/o/irgbItSmaoRMUFISGhgbH47CwMACXd6W6Ijg4GEFBQaiuru53uwkJCQCAEydOOB23WCwIDg7uNVaj0cDPz8+pEBERERERERG5M0UDOgaDAeXl5Y7HU6ZMAQAcO3bMccxisaCurg7Dhw/vd7slJSUAvh0guqK0tBQGg0FJF4mIiIiIiIiI3J6iAZ2kpCSUlZU5ZuncdNNNSE1NxeOPP47i4mKUlpbioYcewpgxYzB9+vQe26isrMRvfvMbHDlyBCaTCbt27cLixYtx5513Ou2OZTKZUFtbi5kzZ17F5RERERERERERuR9FAzoxMTGIi4tDfn6+49iWLVuQkJCAlJQUTJ06FWq1Grt374ZarXbUUalUyM3NBXB596r3338fs2fPxpgxY/Cf//mfuPfee/H222875crLy8Ps2bMVzfQhIiIiIiIioutLZXf/MhAoWhQZADIzM7F69Wqkp6fDw8MDfn5+MBqNMBqNPdavqqqCl5eX4/asiIgIHDhwoNcc7e3t2LRpE7Zt26a0e0REREREREREbk/xgE5KSgoqKipQW1vbr92kCgoKsGzZMowaNarfOaqrq7FmzRrHIJBE8KBL8BrUoTjOx1N5DACsHvueKA4Alh+ZL4rTfu3TdyUXIkc19F2pB6dadOKc5Q2horjdn04Q5wwaLrtOzYhOcc5DBTHi2OHTzKK4I3Xynd06uzxFce9+M77vSi4M8msVxdmHtIlzqtpl19nRqWgioxPvatnf6HNdc8Q5c+/seXC9P/Z9c7MoLiFc9rwFgKK2kaI4+W8FwMlBorCOYfLXBVPTUFGcJkCe0z7+G1HczBvLxDn/euA2cWx86ClR3CeegeKcb38eK4pT+XSJc/pUyF4XuiJln08AwLta3XelnlzFt5PfWGXXebZ1iDjnTVFnxbHmU5GiOA/5rwXnfzZZFKd7uVicMzZdFlfWGNZ3JRe8VDZR3LSgY31XcuGvtbGiuBT9V+Kcr9XLfp8AMGiCRRTX/IXsvQUAtBdUoriOLlkcALS0yF6L3mmS/1+g61PZe4TkI2dXm+y5TnQ1FA/oAMDKlSv7XXf58uWK2x85ciRGjpR9yCciIiIiIiIicneKv+Ssr6+HTqeDyWS6Dt25rK6uDjqdDqdOyb6tIyIiIiIiIiJyZ4oHdLKyspCamoqoqCjHsdzcXIwfPx4+Pj7Q6XT9mpVz8OBB3HXXXRg0aBD8/Pxw5513oqWlBQAQFBSExYsXY+3atUq7R0RERERERETXk/0HUAYARbdcWa1WGI1G7Nmzx3Fs/fr1eOGFF5CTk4OEhAQ0Nzf3OXvn4MGDSE5ORkZGBn7/+9/Dy8sLX3zxBTw8vh1fSktLQ3x8PHJycjB0qPz+UCIiIiIiIiIid6NoQKegoAAajQaJiYkAgIaGBjz99NN4++23MWPGDEe98eN7Xyz1iSeewGOPPYYnn3zScWz06NFOdW6++Wbo9Xq89dZbWLp0qZJuEhERERERERG5NUW3XBUVFSE+Pt7xeO/evbDZbKitrcXYsWMRHh6O+++/HzU1NS7bOH/+PD755BPodDpMnjwZISEhmDp1Kj766KNudW+77TYUFRUp6SIRERERERERkdtTNKBjNpuh1+sdj0+ePAmbzYZ169bhxRdfxI4dO2CxWDBr1iy0t7f32MbJkycBAM8++yzS09Oxe/duxMXFYcaMGaioqHCqq9frYTb3vh1uW1sbmpqanAoRERERERERXR8qu/uXgUDRgE5LSwt8fHwcj202Gzo6OrBx40YkJSUhMTEReXl5qKiowAcffNBjGzabDQDwyCOPIC0tDQaDAb/73e8wevRovPbaa051tVotrFZrr33Kzs6Gv7+/o0RERCi5JCIiIiIiIiKiAUfRgE5QUBAaGhocj8PCwgAA48aNcxwLDg5GUFAQqqure2yjpxgAGDt2bLcYi8WC4ODgXvuUkZGBxsZGR+ntdi8iIiIiIiIiInegaEDHYDCgvLzc8XjKlCkAgGPHjjmOWSwW1NXVYfjw4T22ERUVBb1e7xQDAMePH+8WU1paCoPB0GufNBoN/Pz8nAoRERERERERkTtTNKCTlJSEsrIyxyydm266CampqXj88cdRXFyM0tJSPPTQQxgzZgymT5/eYxsqlQqrV6/Gxo0bsWPHDpw4cQLPPPMMvv76a6fdrKxWK44cOYLZs2dfxeUREREREREREbkfRQM6MTExiIuLQ35+vuPYli1bkJCQgJSUFEydOhVqtRq7d++GWq121FGpVMjNzXU8XrlyJTIyMvDEE09gwoQJ2LdvH/bu3Yvo6GhHnZ07dyIyMhJ33HHHVVweEREREREREV1T9h9AGQAUDegAQGZmJjZs2OBY3NjPzw9GoxENDQ2or6/Hm2++6bQwcVVVFby8vBy3Z13x5JNPoqamBs3NzSguLsbtt9/udH7Dhg3IzMyUXBMRERERERERkVvzUhqQkpKCiooK1NbW9mtHqYKCAixbtgyjRo3qd466ujrMmzcPDz74oNLuERERERERERG5PZXdbh8gk4n6p6mp6fL25S/8Bh5an74D/ol3veJJSwAAlU0ligOA0Cm1orjzTYPFOSeEnhbFWdp8xTmPV4eK4rbd+UdxzvRXfi6K87rdIs75kxuPiGPfPXOzKC5yiLy/h2sjRXH+g1rEOc8f7X33OldGTjglzhk+6KIobv+XY8U5VZouUVziyCpxzoPlI8WxXhbFY/wAAHX0N+Kcnp/KFrKf+mP539mHtTeK4uJD5c+/wq/GiOJUVk9xzoARDX1X6kFH0TBxzktj28WxIaEXRXGeHjZxzpadIaK4jtmN4pzDA2W/l6hB8tf5A/nxoriIH5nEOb+ukb3nq1Tyj6Xqk1px7LCEs6K4c1/JnkMA4BFuFcX9+5gvxDlLet9rxKXzO2WvYQDwzfFAUZz2vPyzdfS/VYrijp3XiXN2Vsk/l98YL9uld1nEh+Kcv3p7vijOb5TsNQwAUDBUFPaN7G0bAKCSfRTDDROV/1+ps7kNxan/g8bGRrfeqOfK/7fj78+Cp7fy/28PFF3trTiS/9T3/vcp+/RORERERERERD9YVzEGT9eIaDpKfX09dDodTCbTNe7Ot3bv3o3Y2FjHWj1ERERERERERHSZaEAnKysLqampiIqKAgBUV1cjJSUFvr6+0Ol0WL16NTo7O13GFxYWQqVS9Vg+++wzAEBycjLUajW2bt0q6SIRERERERERkdtSfMuV1WqF0WjEnj17AABdXV1ISUlBaGgoiouLcebMGSxevBhqtRrr1q3rsY3JkyfjzJkzTseeeeYZ7Nu3DxMnTnQcW7JkCTZu3IhFixYp7SYRERERERERkdtSPEOnoKAAGo0GiYmJAID33nsP5eXl+POf/4zY2Fjcfffd+M1vfoOXXnoJ7e09L47o7e2N0NBQRxk2bBh27tyJtLQ0qFTfLoA2Z84cHD58GJWVsoXNiIiIiIiIiIjckeIBnaKiIsTHf7tbwsGDBxETE4OQkG9X+U9KSkJTUxPKysr61eauXbtQX1+PtLQ0p+ORkZEICQlBUVGRy9i2tjY0NTU5FSIiIiIiIiK6Tux29y8DgOIBHbPZDL1e73h89uxZp8EcAI7HZ8/2bwtIo9GIpKQkhIeHdzun1+thNptdxmZnZ8Pf399RIiIi+pWTiIiIiIiIiGigUjyg09LSAh+fa7ff/KlTp7Bnzx4sXbq0x/NarRZWq9VlfEZGBhobGx2lpqbmmvWNiIiIiIiIiOj7SPGiyEFBQWhoaHA8Dg0NxaeffupU59y5c45zfdm8eTOGDRuGuXPn9njeYrEgODjYZbxGo4FGo+lP14mIiIiIiIiI3ILiGToGgwHl5eWOx5MmTcJXX32F8+fPO47t3bsXfn5+GDduXK9t2e12bN682bEr1j9rbW1FZWUlDAaD0m4SERERERER0XWgsrt/GQgUD+gkJSWhrKzMMUtn9uzZGDduHBYtWoQvvvgCe/bswdNPP43ly5f3OXNm//79qKqqwsMPP9zj+UOHDkGj0WDSpElKu0lERERERERE5LYUD+jExMQgLi4O+fn5AABPT0+888478PT0xKRJk7Bw4UIsXrwYzz33nCPGZDJBpVKhsLDQqS2j0YjJkydjzJgxPebKy8vDggUL4Ovrq7SbRERERERERERuS/EaOgCQmZmJ1atXIz09HR4eHhg+fDgKCgpc1q+qqkJAQAAmTJjgdHzbtm0uY+rq6rBjxw4cPnxY0kUiIiIiIiIiIrclGtBJSUlBRUUFamtr+7VNeEFBAdasWYPAwMB+5zCZTHj55ZcxYsQISRdh97LB7mVTHKca63pHrd60Nsh3/grUyHJeuorFoA8ev1EU56XpEueMi3a9/Xxv/vP4j8U5W4NkNz92nfIX59yliRHHnjmmE8VdCB8kztluHizLGSZ6+bgqx0+EyWPtelGcV5OnOOfg0d+I4ioaXC8E3xd1nfz30hHSIQtsl+dsvaVVFFe0LV6c03OaRRT30Ye3iHMGjpHlbO+U/2wvXpS9LthHt4tzBgy7JI6VsrZ5i2OH3lsrihvtf77vSi6M0F4QxeW/MFucM3ShbAdQ894occ6wO8+K4tQeyj+7XXHKU77gwWlTkCjuvhmHxDnf+DJOFFfWKH8vPL9T9vlGl/q1OKfHMtnSCUEPVItzVuyJFsW1hciff+tS/yKOzXzjJ6K4jE8WiHM+Mvc9Udy2ylvFOUfMPyGKuzfkc3HODrvsc9yb55T/fXZ0yN8/iaTEnxRXrlzZ77o5OTmK2584cSImTpyoOI6IiIiIiIiIriP7P4q7GiDXpngNHQCor6+HTqeDyWS6xt351u7duxEbGwubTT5STkRERERERETkjkQDOllZWUhNTUVUVBRyc3OhUql6LN/dyvyfWSwWLFiwAH5+fggICMDSpUtx6dK3U7WTk5OhVquxdetWSReJiIiIiIiIiNyW4gEdq9UKo9GIpUuXAgAeeOABnDlzxqkkJSVh6tSp0OlcrweyYMEClJWVYe/evXjnnXfw4YcfYtmyZU51lixZgo0bNyrtIhERERERERGRW1O8hk5BQQE0Gg0SExMBAFqtFlqt1nH+woUL2L9/P4xGo8s2jh49it27d+Ozzz5zrJPz+9//Hj/60Y/w/PPPQ6+/vHjpnDlzsGLFClRWViI6Wra4GRERERERERFdOyrb5eKuBsq1KZ6hU1RUhPh417uLbNmyBb6+vrjvvvtc1jl48CACAgKcFj2eOXMmPDw88MknnziORUZGIiQkBEVFRUq7SURERERERETkthTP0DGbzY4ZND0xGo2YP3++06ydf3b27Nlut2N5eXlh6NChOHvWeZtLvV4Ps9n1dtdtbW1oa2tzPG5qaurrEoiIiIiIiIiIBjTFM3RaWlrg4+PT47mDBw/i6NGjjvV1rgWtVgur1eryfHZ2Nvz9/R0lIiLimuUmIiIiIiIiIvo+UjygExQUhIaGhh7Pvfrqq4iNje31liwACA0N7bYDVmdnJywWC0JDQ52OWywWBAcHu2wrIyMDjY2NjlJTU9PPKyEiIiIiIiIiGpgUD+gYDAaUl5d3O37p0iXk5+f3a3bOpEmTcPHiRRw5csRxbP/+/bDZbEhISHAca21tRWVlJQwGg8u2NBoN/Pz8nAoRERERERERXSf2H0AZABQP6CQlJaGsrKzbLJ3t27ejs7MTCxcu7LONsWPHIjk5Genp6fj000/x8ccfY8WKFfjJT37itD7PoUOHoNFoMGnSJKXdJCIiIiIiIiJyW4oHdGJiYhAXF4f8/Hyn40ajEfPmzUNAQEC3GJPJBJVKhcLCQsexrVu3YsyYMZgxYwZ+9KMf4fbbb8cf//hHp7i8vDwsWLAAvr6+SrtJREREREREROS2FO9yBQCZmZlYvXo10tPT4eFxeUyouLjYZf2qqioEBARgwoQJjmNDhw7Ftm3bXMbU1dVhx44dOHz4sKSLRERERERERERuSzSgk5KSgoqKCtTW1vZrV6mCggKsWbMGgYGB/c5hMpnw8ssvY8SIEZIuEhEREREREdF1oLJfLu5qoFybaEAHAFauXNnvujk5OYrbnzhxIiZOnKg47grvOi94+Ci/vDatWpawUyWLA3Dsgk4UN2KYRZzzYpPsNraHbjkkzqlWdYnivlaH9l3JhRumNIriys7JcyYGm8SxE6I+FMVtO53QdyUXugKaRHEtHcK/FQC1zbLYQcOs4pweHjZR3KLbPxXnLL+k77tSD4pORotzIrJVHDpWf04UV3k+SJyzq0EjivsmSvb7BACvsv5/ufBdw2IviHOeMw2VBarlnyZ8AmTPhdY2H3HOi7XyjQm0Z2QfSVoiO8Q5m+tkz4WqG+TP+YCAZlFc51D55wwP4cqOnYPkz7/GQtn7aHNkpzhnYLjsPR8AAnWyz1RvFMnff73DZM8FL5X89e+b47LnvMcy+XqWQX88KIq7NO9Gcc5OX9lzV3tW8WoUDl9a+/6S25XhCadEcSeqZf+HAIATVlnsRcsgcc4z3rLX69988SNxzhuD60VxNRcDFMd0WdtEuYiuhvxVi4iIiIiIiIiI/iUUD+jU19dDp9PBZDJdh+5cVl5ejvDwcDQ3y765ICIiIiIiIiJyZ4oHdLKyspCamoqoqCjk5uZCpVL1WM6fP99rG5MnT4avr2+Pu2KNGzcOiYmJWL9+vdLuERERERERERG5PUUDOlarFUajEUuXLgUAPPDAAzhz5oxTSUpKwtSpU6HTub4vs729HT/+8Y/x05/+1GWdtLQ0vPLKK+jslN9LTURERERERETXmN3u/mUAULQCYUFBATQaDRITEwEAWq0WWq3Wcf7ChQvYv38/jEZjr+38+te/BgDk5ua6rDNr1ixYLBYcOHAAM2bMUNJNIiIiIiIiIiK3pmiGTlFREeLj412e37JlC3x9fXHfffdddce8vb0RGxuLoqKiXuu1tbWhqanJqRARERERERERuTNFAzpmsxl6vetteI1GI+bPn+80a+dq6PV6mM3mXutkZ2fD39/fUSIi5FsGEhERERERERENBIoGdFpaWuDj49PjuYMHD+Lo0aOO9XWuBa1WC6vV2mudjIwMNDY2OkpNTc01y09EREREREREzlR29y8DgaI1dIKCgtDQ0NDjuVdffRWxsbG93pKllMViQXR0dK91NBoNNBrNNctJRERERERERPR9p2iGjsFgQHl5ebfjly5dQn5+/jWdnQMApaWlMBgM17RNIiIiIiIiIqKBTtGATlJSEsrKyrrN0tm+fTs6OzuxcOHCfrVTXV2NkpISVFdXo6urCyUlJSgpKcGlS5ccdUwmE2prazFz5kwlXSQiIiIiIiIicnuKBnRiYmIQFxeH/Px8p+NGoxHz5s1DQEBAtxiTyQSVSoXCwkLHsczMTBgMBqxduxaXLl2CwWCAwWDA4cOHHXXy8vIwe/ZsDB8+XNkVERERERERERG5OUVr6ACXB2NWr16N9PR0eHhcHg8qLi52Wb+qqgoBAQGYMGGC41hubi5yc3NdxrS3t2PTpk3Ytm2b0u4RERERERER0fVk/0dxVwPk2hQP6KSkpKCiogK1tbX92iK8oKAAa9asQWBgYL9zVFdXY82aNZgyZYrS7jlMnHYU6kHeiuP8vNpE+Q68Ll8MelCULOfUoOPinBUfRYnijBfvFOfUnlb8dAMA3DBdvnNZW6csZ8upIeKcZt1Qcey7byWK4trHtohz2i4q/zsBALun/FXu0SkfiOL+UHiXOOd/zigQxT3/4d3inIsnfSyK2zn5PXHO+//4n+LYC/6DRXEhAd+Ic9r8L/VdqQfzwkvEOeO0JlHcij89Ks65dP5+UVzRhZHinBeaB4niWtHzbpbXW8sNnaK49IQPxTl3nxknimvZHirOmfDTMlFc4RTZ+xkAVH3a9+e1nkQk1MpzHg0TxWnPyK+z5dwwcaw9ziKK042qE+c8X+cnipsWdEycs/J875uNuBL0QLU456V5N4riBiefFOe8+IZWFNdZLvudAMCbu24Xx7aFdYji9JH14pzvfzyh70o90djEOZvfDxHF+Vrlnzkv3SP7nGGtUv5csLW2inIRXQ3Ru+bKlSv7XTcnJ0dx+yNHjsTIkfIPsURERERERERE7kzRGjpX1NfXQ6fTwWQyXePufGv37t2IjY2FzSYfBSYiIiIiIiIickeiAZ2srCykpqYiKioKX3zxBR588EFERERAq9Vi7Nix2LBhQ6/xhYWFUKlUPZbPPvsMAJCcnAy1Wo2tW7dKukhERERERERE14HK7v5lIFB8y5XVaoXRaMSePXsAAEeOHIFOp8Of//xnREREoLi4GMuWLYOnpydWrFjRYxuTJ0/GmTNnnI4988wz2LdvHyZOnOg4tmTJEmzcuBGLFi1S2k0iIiIiIiIiIreleECnoKAAGo0GiYmXF2/9j//4D6fzN954Iw4ePIg333zT5YCOt7c3QkO/XVCwo6MDO3fuxM9//nOoVCrH8Tlz5mDFihWorKxEdLRsETciIiIiIiIiInej+JaroqIixMf3vqNTY2Mjhg7t/04/u3btQn19PdLS0pyOR0ZGIiQkBEVFRUq7SURERERERETkthTP0DGbzdDr9S7PFxcXY/v27fjb3/7W7zaNRiOSkpIQHh7e7Zxer4fZbHYZ29bWhra2b7f9bmpq6ndeIiIiIiIiIqKBSPEMnZaWFvj4+PR4rrS0FKmpqVi7di1mz57dr/ZOnTqFPXv2YOnSpT2e12q1sFqtLuOzs7Ph7+/vKBEREf3KS0REREREREQCdrv7lwFA8YBOUFAQGhoauh0vLy/HjBkzsGzZMjz99NP9bm/z5s0YNmwY5s6d2+N5i8WC4OBgl/EZGRlobGx0lJqamn7nJiIiIiIiIiIaiBQP6BgMBpSXlzsdKysrw/Tp0/HQQw8hKyur323Z7XZs3rwZixcvhlqt7na+tbUVlZWVMBgMLtvQaDTw8/NzKkRERERERERE7kzxgE5SUhLKysocs3RKS0sxffp0zJ49G6tWrcLZs2dx9uxZXLhwoc+29u/fj6qqKjz88MM9nj906BA0Gg0mTZqktJtERERERERERG5L8YBOTEwM4uLikJ+fDwDYsWMHLly4gD//+c8ICwtzlFtvvdURYzKZoFKpUFhY6NSW0WjE5MmTMWbMmB5z5eXlYcGCBfD19VXaTSIiIiIiIiK6DlR29y8DgeIBHQDIzMzEhg0bYLPZ8Oyzz8Jut3crJpPJUb+qqgoBAQGYMGGCUzvbtm3Dxx9/3GOOuro67NixA7/61a8kXSQiIiIiIiIicluKty0HgJSUFFRUVKC2trZfu0oVFBRgzZo1CAwM7HcOk8mEl19+GSNGjJB0kYiIiIiIiIjIbans9gGyH1c/NTU1wd/fH7PfXQb1IG/F8aca/UV5vzk6VBQHAJ26dlHcV7NeEuec+eVCUZzNrhLn9PHqFMXVX5Lfcrdg1GFR3OtVrhfi7ktjjew5BABjbpbt0mbaHyXOeeOMKlHc8YPynLdNPSqKa+0SjUEDAHw8Zc+/4s96viW0P6JvqRXFnajWiXN6NHZfYL6/bD42UVxK/BfinO8eGyeKC/BvFucMG/KNKK78y0hxTr8TnqK4S4lWcU6tVvbeEuon+/kAwAlziDhWe1L5ezYAdIyT/4wChc8j6fsZAJxvHCyKa6vTinN6+HWI4ryPy3Pa1LKPlyqb/HOGd6M4FMPulr1ed9lEk90BADpf2d9aXYvsOQQAAZoWUVzFnmhxzk5f2XPBa2yTOGf4vWWiuPMrJotz3pNeKI7N++s0UZx9zCVxzlEhfa932pOvjwwX5/zlj3aJ4rIP/Js45623VIriPvtS+XPe1tKKU6sy0djY6NYb9Vz5//aku5+Dl9rnX92d66azoxUH3/3+/z7l70JERERERERERPQvIRrQqa+vh06nc1on51rbvXs3YmNjYbPJvjEmIiIiIiIiouvA/gMoA4BoQCcrKwupqamIiopCbm4uVCpVj+X8+fM9xptMJixduhQjRoyAVqtFdHQ01q5di/b2b6eHJycnQ61WY+vWrbIrIyIiIiIiIiJyU4oXpLBarTAajdizZw8A4IEHHkBycrJTnSVLlqC1tRU6Xc/rQHz99dew2Wz4wx/+gJEjR6K0tBTp6elobm7G888/79TOxo0bsWjRIqXdJCIiIiIiIiJyW4oHdAoKCqDRaJCYmAgA0Gq10Gq/XTTvwoUL2L9/P4xGo8s2kpOTnQaBbrzxRhw7dgyvvPKK04DOnDlzsGLFClRWViI6Wr4YGxERERERERGRO1E8oFNUVIT4+HiX57ds2QJfX1/cd999itptbGzE0KHOO0VFRkYiJCQERUVFLgd02tra0NbW5njc1CRfEZ+IiIiIiIiIeqeyXy7uaqBcm+I1dMxmM/R6vcvzRqMR8+fPd5q105cTJ07g97//PR555JFu5/R6Pcxms8vY7Oxs+Pv7O0pERES/8xIRERERERERDUSKB3RaWlrg49PzfvMHDx7E0aNHsXTp0n63V1tbi+TkZPz4xz9Genp6t/NarRZWq9VlfEZGBhobGx2lpqam37mJiIiIiIiIiAYixbdcBQUFoaGhocdzr776KmJjY3u9Jeu7Tp8+jenTp2Py5Mn44x//2GMdi8WC4OBgl21oNBpoNJp+5SMiIiIiIiIicgeKZ+gYDAaUl5d3O37p0iXk5+f3e3ZObW0tpk2bhvj4eGzevBkeHt270traisrKShgMBqXdJCIiIiIiIiJyW4oHdJKSklBWVtZtls727dvR2dmJhQsX9tnGlcGcyMhIPP/887hw4QLOnj2Ls2fPOtU7dOgQNBoNJk2apLSbRERERERERHQ92OzuXwYAxQM6MTExiIuLQ35+vtNxo9GIefPmISAgoFuMyWSCSqVCYWEhAGDv3r04ceIE9u3bh/DwcISFhTnKd+Xl5WHBggXw9fVV2k0iIiIiIiIiIreleEAHADIzM7FhwwbYbDbHseLiYmzdurXH+lVVVQgICMCECRMAAEuWLIHdbu+xXFFXV4cdO3bgV7/6laSLRERERERERERuS/GiyACQkpKCiooK1NbW9mub8IKCAqxZswaBgYH9zmEymfDyyy9jxIgRki4SEREREREREbkt0YAOAKxcubLfdXNychS3P3HiREycOFFx3BVHa0Lhoe15e/XexI2oFuX73Kf/g1XddIgmSmF/y1BxyksHdKK4+Qv2iXP+6dCdoji1X5s459l2P1GctdVbnDMkuk4ce/yM7PcyfOopcc6yEzeI4oZcUIlzWtpkt1EePakX5wwKaRLF3RRTI855Z9AJUdzFFq04Z731Kl6LNF2isN0fyheuz5+3URT337V3i3N6qGT3RI+5iudCy1i1KK61WPb3CQDTU8pEcW9/MUGc88bh58WxJ9tDRXHDgy6Kc8YOk7127q4cK84ZGvCNKM5cL39duGfsF6K4Y+Eh4pzmAtkXcu3xl8Q5VcWDxbFni2R/azGzj4lzNrUr/5wKACn6r8Q5Xzs6WRTXFmLru5IL2rOyz7md5bLPcABwfoXsOnX/UyzO+e6PxoljB9fI3pes7fLn/OkE2edru07+ufylY1NFcYNM4v+y4sigSFGct8VTcYytVXnMgGb/R3FXA+TaRK+w9fX10Ol0MJlM17g739q9ezdiY2OdbusiIiIiIiIiIiLhgE5WVhZSU1MRFRWF3NxcqFSqHsv5866/qZs7dy4iIyPh4+ODsLAwLFq0CKdPn3acT05OhlqtdrkuDxERERERERHRD5XiAR2r1Qqj0YilS5cCAB544AGcOXPGqSQlJWHq1KnQ6VzfPjJ9+nTk5+fj2LFjeOONN1BZWYn77rvPqc6SJUuwcaNsOj4RERERERERkbtSfENiQUEBNBoNEhMTAQBarRZa7bf3dV+4cAH79++H0WjstZ0nnnjC8e/hw4fjySefxD333IOOjg6o1ZfXGpgzZw5WrFiByspKREdHK+0qEREREREREZFbUjygU1RUhPj4eJfnt2zZAl9f326zbXpjsViwdetWTJ482TGYAwCRkZEICQlBUVERB3SIiIiIiIiIvgdUAIT7TAwI8u1f/m8pvuXKbDZDr3e904zRaMT8+fOdZu248qtf/QqDBg3CsGHDUF1djZ07d3aro9frYTabXbbR1taGpqYmp0JERERERERE5M4UD+i0tLTAx6fnbRYPHjyIo0ePOtbX6cvq1avx97//He+99x48PT2xePFi2O3Ow3xarRZWq9VlG9nZ2fD393eUiIiI/l8MEREREREREdEApPiWq6CgIDQ0NPR47tVXX0VsbGyvt2T9c1tBQUG46aabMHbsWERERODQoUOYNGmSo47FYkFwcLDLNjIyMrBq1SrH46amJg7qEBEREREREZFbUzygYzAY8Oc//7nb8UuXLiE/Px/Z2dmijthsNgCXb6G6orW1FZWVlTAYDC7jNBoNNBqNKCcRERERERERKWS3Xy7uaoBcm+JbrpKSklBWVtZtls727dvR2dmJhQsX9tnGJ598gv/5n/9BSUkJzGYz9u/fjwcffBDR0dFOs3MOHToEjUbjdIyIiIiIiIiI6IdO8YBOTEwM4uLikJ+f73TcaDRi3rx5CAgI6BZjMpmgUqlQWFgIAPD19cWbb76JGTNmYPTo0Vi6dCnGjx+PAwcOOM22ycvLw4IFC+Dr66u0m0REREREREREbkvxLVcAkJmZidWrVyM9PR0eHpfHhIqLi13Wr6qqQkBAACZMmADg8qDQ/v37e81RV1eHHTt24PDhw5IuEhERERERERG5LdGATkpKCioqKlBbW9uvBYgLCgqwZs0aBAYG9juHyWTCyy+/jBEjRki6SERERERERETktlT2f94nfIBramqCv78/fv5RKjSD1YrjXy9OEOWdm3hEFAcAB06NFMU11viLc/54yieiuDeOxopzqo/Lbp1rC+4S5/RoVYnipk4pFecM0TSJY3dtv10UZ5sozxkReFEUd/7SYHHOqeEnRHGHL0SKcwZpm0Vxft4t4pwHi24WxXUGt4tzagbJY7WFQ0Rx1jD528itM46K4g5VyQf7gwK/EcWFD7koznm83vVujb2xNvuIc2q/0IriLo3qEOfcMfMlcexTVf8uimvtVP5ef0V9s+x96dIZ+evf0C88RXGTHv5cnPNvn48Xxf339Py+K7mQWztFFGd6P0qcUxXXKI711cie9y0fBYlzqidZRHGt7fLnfGeV7Ln7m9S/iHN+aZXtPvvmLtlnIgB48J5CUdy7tePEOf1/JPtsAwDHN90mivMLlb2fAUDnJ/3/ov272mKs4pxdjd6iuGGfy143AcCueIGRy1pnK/9s3WVtQ8XC36KxsRF+fn6yxAPAlf9v337Xs/Dykn9O+b7r7GzFR/uf/d7/PoVPcSIiIiIiIiIi+lcRDejU19dDp9PBZDJd4+58a/fu3YiNjXVsZ05ERERERERERJeJBnSysrKQmpqKqKgop+P19fUIDw+HSqXCxYsXXcYXFhZCpVL1WD777DMAQHJyMtRqNbZu3SrpIhERERERERGR21I8oGO1WmE0GrF06dJu565sP96XyZMn48yZM07l4YcfxogRIzBx4kRHvSVLlmDjxo1Ku0hERERERERE14v9B1AGAMUDOgUFBdBoNEhMTHQ6/sorr+DixYv4xS9+0Wcb3t7eCA0NdZRhw4Zh586dSEtLg0r17SK2c+bMweHDh1FZWam0m0REREREREREbkvxtuVFRUWIj493OlZeXo7nnnsOn3zyCU6ePKm4E7t27UJ9fT3S0tKcjkdGRiIkJARFRUWIjo7uMbatrQ1tbW2Ox01N8t1+iIiIiIiIiIgGAsUzdMxmM/R6veNxW1sbHnzwQeTk5CAyUralsNFoRFJSEsLDw7ud0+v1MJvNLmOzs7Ph7+/vKBERsq0RiYiIiIiIiIgGCsUDOi0tLfDx+Xa/+YyMDIwdOxYLFy4UdeDUqVPYs2dPj2vyAIBWq4XVanUZn5GRgcbGRkepqakR9YOIiIiIiIiISOKll15CVFQUfHx8kJCQgE8//dRl3T/96U+44447EBgYiMDAQMycObPX+q4oHtAJCgpCQ0OD4/H+/fvx+uuvw8vLC15eXpgxY4aj3tq1a/tsb/PmzRg2bBjmzp3b43mLxYLg4GCX8RqNBn5+fk6FiIiIiIiIiK4Pld3u9kWJ7du3Y9WqVVi7di0+//xzTJgwAUlJSTh//nyP9QsLC/Hggw/igw8+wMGDBxEREYHZs2ejtrZWUV7FAzoGgwHl5eWOx2+88Qa++OILlJSUoKSkBK+++iqAy2vtLF++vNe27HY7Nm/ejMWLF0OtVnc739raisrKShgMBqXdJCIiIiIiIiK67tavX4/09HSkpaVh3Lhx2LRpE3x9ffHaa6/1WH/r1q342c9+htjYWIwZMwavvvoqbDYb9u3bpyiv4kWRk5KSkJGRgYaGBgQGBnZbrLiurg4AMHbsWAQEBPTa1v79+1FVVYWHH364x/OHDh2CRqPBpEmTlHaTiIiIiIiIiOi6am9vx5EjR5CRkeE45uHhgZkzZ+LgwYP9asNqtaKjowNDhw5VlFvxDJ2YmBjExcUhPz+/3zEmkwkqlQqFhYVOx41GIyZPnowxY8b0GJeXl4cFCxbA19dXaTeJiIiIiIiIiMSampqcynd32L6irq4OXV1dCAkJcToeEhKCs2fP9ivPr371K+j1esycOVNR/xQP6ABAZmYmNmzYAJvN1u3ctGnTYLfbnWbnVFVVISAgABMmTHCqu23bNnz88cc95qirq8OOHTvwq1/9StJFIiIiIiIiIroebD+AAiAiIsJpV+3s7Oxr8/P7jt/+9rf4y1/+grfeestpA6r+UHzLFQCkpKSgoqICtbW1/domvKCgAGvWrEFgYGC/c5hMJrz88ssYMWKEpItERERERERERGI1NTVOGy9pNJpudYKCguDp6Ylz5845HT937hxCQ0N7bf/555/Hb3/7W7z//vsYP3684v6JBnQAYOXKlf2um5OTo7j9iRMnYuLEiYrjrjjXNgRqL2/FcSr/dlG+nV/EiuIAICb6lChuZsQxcc78T24Tx0p1De8+Pa1fOkUTyQAA6gvdF9vujwMnR4pzJo86Ko61q2RxEYEXxTmrPu17ULYnHSEd4pynh/mL4mpNQfKcPv0fUP4ue7v8+Rd8c50obkLQaXHO90vGiWO7IpWt5u8gfN4CwA3ai6I4hRsPOIkLlr3mHjozXJxzXPC5viv14JRPgDjnmdDuHzj6Q3Na9roJALua5JsYXGqX9fdC42Bxzk+n/EEU9/OaJHHOgwE3iuL+9rnyD3lX3B33lSjuZdN0cc7xQ5Xt0nFFyJxvxDk/3Rkjjm3pPum8X8KTzOKcVR9HiuIGTbCIcwbH14jiMt/4iTjn8ATZa25bmPxzRt5fp4niBtfI31yOb1K27sV33fSo8q2KAeDs45PFOa03y36+2jL5Uhh3pP5dFPdxiOx1EwA8PWR/3C2NWsUxtpar+HBC31v92Unb29sb8fHx2LdvH+655x4AcCxwvGLFCpdx/+///T9kZWVhz5494rEP8YAOEREREREREdEP3apVq/DQQw9h4sSJuO222/Diiy+iubkZaWlpAIDFixfjhhtucNyy9d///d/IzMzEtm3bEBUV5VhrZ/DgwRg8uP9fVom+eq6vr4dOp4PJZJKE98vu3bsRGxvb4zo9RERERERERETfBw888ACef/55ZGZmIjY2FiUlJdi9e7djoeTq6mqcOXPGUf+VV15Be3s77rvvPoSFhTnK888/ryivaEAnKysLqampiIqKQm5uLlQqVY/l/PnzfbbV1taG2NhYqFQqlJSUOI4nJydDrVZj69atki4SERERERER0XWgstvdvii1YsUKmM1mtLW14ZNPPkFCQoLjXGFhIXJzcx2PTSYT7HZ7t/Lss88qyql4QMdqtcJoNGLp0qUALo9EnTlzxqkkJSVh6tSp0Ol0fbb3y1/+Enq9vsdzS5YswcaNG5V2kYiIiIiIiIjIrSke0CkoKIBGo0FiYiIAQKvVIjQ01FE8PT2xf/9+x4BPb95991289957LqcVzZkzB4cPH0ZlZaXSbhIRERERERERuS3FiyIXFRUhPj7e5fktW7bA19cX9913X6/tnDt3Dunp6fjrX/8KX9+eV0uPjIxESEgIioqKEB0d3WOdtrY2tLV9u3tSU1NTP66CiIiIiIiIiGjgUjxDx2w2u7xFCgCMRiPmz58Prdb1Vm92ux1LlizBo48+2uf2XHq9Hmaz6y0hs7Oz4e/v7ygREbItmImIiIiIiIioH+w/gDIAKB7QaWlpgY+PT4/nDh48iKNHj/Z5u9Xvf/97fPPNN8jIyOgzn1arhdVqdXk+IyMDjY2NjlJTU9Nnm0REREREREREA5niAZ2goCA0NDT0eO7VV19FbGxsr7dkAcD+/ftx8OBBaDQaeHl5YeTIkQCAiRMn4qGHHnKqa7FYEBwc7LItjUYDPz8/p0JERERERERE5M4UD+gYDAaUl5d3O37p0iXk5+f3azHkjRs34osvvkBJSQlKSkpQUFAAANi+fTuysrIc9VpbW1FZWQmDwaC0m0REREREREREbkvxoshJSUnIyMhAQ0MDAgMDHce3b9+Ozs5OLFy4sM82IiMjnR4PHjwYABAdHY3w8HDH8UOHDkGj0WDSpElKu0lERERERERE5LYUz9CJiYlBXFwc8vPznY4bjUbMmzcPAQEB3WJMJhNUKhUKCwsV5crLy8OCBQtc7oJFRERERERERP/H7Hb3LwOA4hk6AJCZmYnVq1cjPT0dHh6Xx4SKi4td1q+qqkJAQAAmTJjQ4/moqCjY/+kHVldXhx07duDw4cOSLhIRERERERERuS3RgE5KSgoqKipQW1vbr23CCwoKsGbNGqdbtPpiMpnw8ssvY8SIEZIu4tDhMfBwsRtXbyLGnRXla7C63qa9L19VhPddqQdlTVHinB6K52ZdZvPvEOccG3VGFPf1l5F9V3JhyK0XxLFS59sGi2PbhtlEcVov+e+ly0c2+hwY9I0457E6nShO1aES59RH9byYe1/aOkUvkwCAVSPfF8X9ofpOcU54yb9NmDb9S1Hcvs9uEef0hOw5b6/XiHOebRkiims5Mkycc8582XPhlW+minMqn4P7D2Ov4m/7Uog49kKj8LXzxCBxzqX6OaK4SkuQOKetS/Y65tkkfy0K18he/w62RIlz1gnfCw9Xy9/z77v/I3HszvzbRXEVtbL3MwDQtMqeC81fDBXnfOqBd0VxGZ8sEOc8US37Gekj68U56/xlzz9ru/wznF+o/LXz7OOTRXGhG1x/od4Xz12jRXFtJvl7YX2b7PX6Bv9Gcc7jJ8NEcX6lasUxXW2iVERXRfzpYOXKlf2um5OTo7j9iRMnYuLEiYrjiIiIiIiIiIjcnej7u/r6euh0OphMpmvcnW/t3r0bsbGxsNlk394SERERERER0bWnsrt/GQhEAzpZWVlITU1FVFQUcnNzoVKpeiznz5932UZUVFS3+r/97W8d55OTk6FWq7F161ZJF4mIiIiIiIiI3JbiW66sViuMRiP27NkDAHjggQeQnJzsVGfJkiVobW2FTtf7PbPPPfcc0tPTHY+HDHFe12DJkiXYuHEjFi1apLSbRERERERERERuS/GATkFBATQaDRITEwEAWq0WWu23CwJfuHAB+/fvh9Fo7LOtIUOGIDQ01OX5OXPmYMWKFaisrER0dLTSrhIRERERERERuSXFt1wVFRUhPj7e5fktW7bA19cX9913X59t/fa3v8WwYcNgMBiQk5ODzs5Op/ORkZEICQlBUVGR0m4SEREREREREbktxTN0zGYz9Hq9y/NGoxHz5893mrXTk8ceewxxcXEYOnQoiouLkZGRgTNnzmD9+vVO9fR6Pcxms8t22tra0Nb27R5xTU1N/bwSIiIiIiIiIlLMbr9c3NUAuTbFAzotLS3w8fHp8dzBgwdx9OhR/O///m+f7axatcrx7/Hjx8Pb2xuPPPIIsrOzodFoHOe0Wi2sVqvLdrKzs/HrX/9awRUQEREREREREQ1sim+5CgoKQkNDQ4/nXn31VcTGxvZ6S5YrCQkJ6Ozs7LYVusViQXBwsMu4jIwMNDY2OkpNTY3i3EREREREREREA4niAR2DwYDy8vJuxy9duoT8/HwsXbpU1JGSkhJ4eHg47YzV2tqKyspKGAwGl3EajQZ+fn5OhYiIiIiIiIjInSm+5SopKQkZGRloaGhAYGCg4/j27dvR2dmJhQsX9tnGwYMH8cknn2D69OkYMmQIDh48iCeeeAILFy50avPQoUPQaDSYNGmS0m4SERERERER0XWgsl0u7mqgXJviGToxMTGIi4tDfn6+03Gj0Yh58+YhICCgW4zJZIJKpUJhYSGAy7Nq/vKXv2Dq1Km4+eabkZWVhSeeeAJ//OMfneLy8vKwYMEC+Pr6Ku0mEREREREREZHbUjxDBwAyMzOxevVqpKenw8Pj8phQcXGxy/pVVVUICAjAhAkTAABxcXE4dOhQrznq6uqwY8cOHD58WNJFIiIiIiIiIiK3JRrQSUlJQUVFBWpraxEREdFn/YKCAqxZs8bpdqq+mEwmvPzyyxgxYoSki0REREREREREbktltw+QDdb7qampCf7+/pj7XhrUg7wVx5++5C/KezU/xOFDet41rC+nm2V9BYDTFtni0YO07eKcrZ8PFcUFTz4jznm2YYgoruvsVdzmdxVPhmE31YviPD3kN3kG+zaLY6VGDT4viis6Gy3O2XhJK4prv6gR5xxUpRbFTZn3d3FOjUenOLbw1EhR3MihdeKc33T4iOKGqFvFOUtMfX8R0ZO5N38pznlA+LP118qvM3zwRVHcwcqr+CJFJQ994OYjorgPz8l+tgCg8/1GFHf0XKg4Z1eX7Id0i17+XvhVsexnpBpuFefsEL52zowrE+c8+NYEcWxLiOx91OuS/Env2S6L9W4Up8Sl4bLrfCRprzjnCauu70o9eP9j+e9zrMEsijvdJN9cpe3gMHGsdUSHKC4wtEmcM3juMVHchZ/K1zZtvkEW5zH6kjjn4ILBojiV4PN8V3srSrY+hcbGRrfeqOfK/7enJTwNLy/Z57iBoLOzFYWf/Nf3/vcpmqFDRERERERERD9Qdvvl4q4GyLUpXhS5vr4eOp0OJpPpOnTnsvLycoSHh6O5+f9+5gARERERERER0fed4gGdrKwspKamIioqynEsNzcX48ePh4+PD3Q6HZYvX+4y/sqOVz2V119/HQAwbtw4JCYmYv369cqviIiIiIiIiIjIzSm65cpqtcJoNGLPnj2OY+vXr8cLL7yAnJwcJCQkoLm5udfZOxEREThzxvk+8D/+8Y/IycnB3Xff7TiWlpaG9PR0ZGRkwMuLd4YREREREREREV2haKSkoKAAGo0GiYmJAICGhgY8/fTTePvttzFjxgxHvfHjx7tsw9PTE6GhzosJvvXWW7j//vsxePC3i1bNmjULFosFBw4ccGqbiIiIiIiIiP6F7Li6nYG+7wbItSm65aqoqAjx8fGOx3v37oXNZkNtbS3Gjh2L8PBw3H///aipqel3m0eOHEFJSQmWLl3qdNzb2xuxsbEoKirqNb6trQ1NTU1OhYiIiIiIiIjInSka0DGbzdDr9Y7HJ0+ehM1mw7p16/Diiy9ix44dsFgsmDVrFtrb+7e9tdFoxNixYzF58uRu5/R6Pczm3rcdzM7Ohr+/v6NERMi2oyUiIiIiIiIiGigUDei0tLTAx+fbveZtNhs6OjqwceNGJCUlITExEXl5eaioqMAHH3zQr/a2bdvWbXbOFVqtFlartdc2MjIy0NjY6ChKZgcREREREREREQ1EitbQCQoKQkNDg+NxWFgYgMu7Ul0RHByMoKAgVFdX99nejh07YLVasXjx4h7PWywWREdH99qGRqOBRqPpT/eJiIiIiIiIiNyCohk6BoMB5eXljsdTpkwBABw7dsxxzGKxoK6uDsOHD++zPaPRiLlz5yI4OLjH86WlpTAYDEq6SERERERERETXkcpud/syECga0ElKSkJZWZljls5NN92E1NRUPP744yguLkZpaSkeeughjBkzBtOnT++1rRMnTuDDDz/Eww8/3ON5k8mE2tpazJw5U0kXiYiIiIiIiIjcnqIBnZiYGMTFxSE/P99xbMuWLUhISEBKSgqmTp0KtVqN3bt3Q61WO+qoVCrk5uY6tfXaa68hPDwcs2fP7jFXXl4eZs+e3a+ZPkREREREREREPySKBnQAIDMzExs2bIDNZgMA+Pn5wWg0oqGhAfX19XjzzTeddpqqqqqCl5eX4/asK9atW4fq6mp4eHTvQnt7OzZt2oRnnnlGafeIiIiIiIiIiNyeokWRASAlJQUVFRWora3t1xbhBQUFWLZsGUaNGtXvHNXV1VizZk23QSAl2ru8YO9SfHmoPRMoyqdqVp7ritODZDkn3XRSnLP69DBRXMvxQeKcnaN737HMlZrqIHHOmJtku55VePa8rlN/DB9mEcfWW2U/3/N1fuKc9mEqUdxtOrM45/yhh0RxH9T2/3Xkn91z05eiuC8abhDn9B7TJYobpm4W5zzVGiCOvXv4UVHcEM9Wcc5txyeK4rq6ZK+bAODl3SmK2/lpnDhnyHDZ68LPovreMdKVX318nyhu+A314pw15+W/l7zPbxPF+Qa0iHNqvGTPBdvxweKcXYNk9+R/ZRopzmnTyHLaGuWbTgwKkb2O7fv0FnFO7a2N4thbQ8+I4v6+f7Q4Z5eP7PfS0SV73wYAv1ENfVfqwbbKW8U5L1qEnx01NnHOr4/IZvjbdW3inKoY2edcANCW+Yri2kyyz/MAcOGnk0Rxwa8cFOcMPxAqijtZL7/OhpmyzyhB7yp//bN3Dow1V8i9iEYhVq5c2e+6y5cvV9z+yJEjMXKk/IMLEREREREREV0ndvvl4q4GyLUpvuWqvr4eOp0OJpPpOnTnsvLycoSHh6O5Wf4tNRERERERERGRu1I8oJOVlYXU1FRERUUhNzcXKpWqx3L+/Ple2/nb3/6GhIQEaLVaBAYG4p577nGcGzduHBITE7F+/XrFF0RERERERERE5O4U3XJltVphNBqxZ88eAMADDzyA5ORkpzpLlixBa2srdDqdy3beeOMNpKenY926dbjrrrvQ2dmJ0tJSpzppaWlIT09HRkYGvLzk69MQEREREREREbkbRSMlBQUF0Gg0SExMBABotVpotVrH+QsXLmD//v0wGo0u2+js7MTjjz+OnJwcLF261HF83LhxTvVmzZoFi8WCAwcOYMaMGUq6SURERERERETXix2AfO3y77+BsYSOsluuioqKEB8f7/L8li1b4Ovri/vuc72zxueff47a2lp4eHjAYDAgLCwMd999d7cZOt7e3oiNjUVRUZGSLhIRERERERERuT1FAzpmsxl6vd7leaPRiPnz5zvN2vlnJ09e3mr72WefxdNPP4133nkHgYGBmDZtGiwW521d9Xo9zObet0Zua2tDU1OTUyEiIiIiIiIicmeKBnRaWlrg4+PT47mDBw/i6NGjTrdR9cRmuzwv66mnnsK9996L+Ph4bN68GSqVCq+//rpTXa1WC6vV2mt72dnZ8Pf3d5SIiAgFV0RERERERERENPAoGtAJCgpCQ0NDj+deffVVxMbG9npLFgCEhYUBcF4zR6PR4MYbb0R1dbVTXYvFguDg4F7by8jIQGNjo6PU1NT051KIiIiIiIiIiAYsRQM6BoMB5eXl3Y5funQJ+fn5fc7OAYD4+HhoNBocO3bMcayjowMmkwnDhw93qltaWgqDwdBrexqNBn5+fk6FiIiIiIiIiK4Pld3u9mUgUDSgk5SUhLKysm6zdLZv347Ozk4sXLiwzzb8/Pzw6KOPYu3atXjvvfdw7Ngx/PSnPwUA/PjHP3bUM5lMqK2txcyZM5V0kYiIiIiIiIjI7Ska0ImJiUFcXBzy8/OdjhuNRsybNw8BAQHdYkwmE1QqFQoLCx3HcnJy8JOf/ASLFi3CrbfeCrPZjP379yMwMNBRJy8vD7Nnz+42a4eIiIiIiIiI6IfOS2lAZmYmVq9ejfT0dHh4XB4PKi4udlm/qqoKAQEBmDBhguOYWq3G888/j+eff77HmPb2dmzatAnbtm1T2j0iIiIiIiIiIreneEAnJSUFFRUVqK2t7deOUgUFBVizZo3T7Ju+VFdXY82aNZgyZYrS7hERERERERHR9WQHMEDWmREZIJemstvd67fQ1NQEf39/xO5YBU9fjeL4mfpjfVfqwc6TMaI4AGhvU4viOi/J4gDA45KnKO6Gm8+Jc9ZU9r5jmSvxMSfFOT8/GSmKU3lcxZ9FnfLn3RUeIa2iuHljS8Q5d/11siiuY7RVnLOryVsUp9J2inOKNcn/zjyHtYniInUWcc6LLT7iWK1a9vP9plX+nB/iI/sZzQsvEed89WvZc16lkr8uTI88IYorKO59Y4DezJ/6sSjujYpYcU7b8cHi2KSkw6K4ujZ5zrIdY0Vx7UPEKXF7yheiuH1fjxbn1H4te13QTKoX52w63v8v8r5rzESzOOfXn0WJYz1lb7+ImVYhzll6JkwU194if18KOCh7vY6aL3sNA4AzzbINS5rfDxHnXPHwX0VxLx2bKs7ZdEb+wjA7/itRXH3bIHHOrw6MEsWNvqNKnLNt6llRXGXOJHFOu1r23m3TdimPaWnFqcfXorGx0a036rny/+27Yp+El6f8M+D3XWdXG/aX/PZ7//tUtIYOERERERERERH96yke0Kmvr4dOp4PJZLoO3bmsvLwc4eHhaG5uvm45iIiIiIiIiIgGKsUDOllZWUhNTUVUVBQA4LHHHkN8fDw0Gg1iY2P7jL+y61VP5fXXXwcAjBs3DomJiVi/fr3S7hERERERERERuT1FAzpWqxVGoxFLly51Ov4f//EfeOCBB/rVRkREBM6cOeNUfv3rX2Pw4MG4++67HfXS0tLwyiuvoLPzX7BmBhERERERERH1zG53/zIAKNrlqqCgABqNBomJiY5jGzduBABcuHABX375ZZ9teHp6IjQ01OnYW2+9hfvvvx+DB3+7sOGsWbNgsVhw4MABzJgxQ0k3iYiIiIiIiIjcmqIZOkVFRYiPj7+mHThy5AhKSkq6zfrx9vZGbGwsioqKeo1va2tDU1OTUyEiIiIiIiIicmeKBnTMZjP0ev017YDRaMTYsWMxeXL3bWT1ej3M5t63r8zOzoa/v7+jREREXNP+ERERERERERF93yga0GlpaYGPj881S97S0oJt27Z1m51zhVarhdVq7bWNjIwMNDY2OkpNTc016x8RERERERER/RPbD6AMAIrW0AkKCkJDQ8M1S75jxw5YrVYsXry4x/MWiwXR0dG9tqHRaKDRaK5Zn4iIiIiIiIiIvu8UzdAxGAwoLy+/ZsmNRiPmzp2L4ODgHs+XlpbCYDBcs3xERERERERERO5A0YBOUlISysrKnGbpnDhxAiUlJTh79ixaWlpQUlKCkpIStLe399rWiRMn8OGHH+Lhhx/u8bzJZEJtbS1mzpyppItERERERERERG5P0YBOTEwM4uLikJ+f7zj28MMPw2Aw4A9/+AOOHz8Og8EAg8GA06dPO+qoVCrk5uY6tfXaa68hPDwcs2fP7jFXXl4eZs+ejeHDhyvpIhERERERERGR21M0oAMAmZmZ2LBhA2y2y6sEFRYWwm63dytRUVEAgKqqKnh5eWHKlClO7axbtw7V1dXw8Ojehfb2dmzatAnPPPOM4JKIiIiIiIiI6HpR2e1uXwYCRYsiA0BKSgoqKipQW1vbry3CCwoKsGzZMowaNarfOaqrq7FmzZpug0BKqD264OXZpThux7FYUb7OdsU/Sgft17Kdw6alfiHOWVjZ/9/Hdw32bhPnVA3qFMUdKb1RnDNh/AlR3H+EFIlzrq/uedZZf5w4oxPF7TaPFedsDZP9XgI+9hXnHD3/a1FchSVInPPxUftFcUWNo8U5E/0qRXHrjtwtzmlrlr8WeTXKYlVXsQvA7NmHRHFTB8meQwDwVfgNoriKiz2v99Yfuytkf6Mai+LvXRz+enK8KE6tlr0mAIBXjEUce+DPt4riOu9oFOdsD5N9WPM9rRLn/GT7BFFc4r1HxTn/7hsuisu5eYc458One97BtC9ntkWJc3Yldohjbxste70uOSN7PQGA/Nv+JIp7p0n2HAKAzefuEsXdG/K5OOdvvviRKM7XKv/PVPaBfxPFDTLJ30OH1cv7+3GI7LPuDf7y1z+P0ZdEcSfrh4lztuaMEMVFrz4ozln7q8miuJYwQVCrpygX0dUQvWqtXLmy33WXL1+uuP2RI0di5MiRiuOIiIiIiIiIiH4IRF/91dfXQ6fTwWQyXePufGv37t2IjY113NpFRERERERERESXiQZ0srKykJqaiqioKNTX1yM5ORl6vR4ajQYRERFYsWIFmpqaXMYXFhZCpVL1WD777DMAQHJyMtRqNbZu3Sq7MiIiIiIiIiK69ux29y8DgOIBHavVCqPRiKVLL98b7eHhgdTUVOzatQvHjx9Hbm4u3n//fTz66KMu25g8eTLOnDnjVB5++GGMGDECEydOdNRbsmQJNm7cKLgsIiIiIiIiIiL3pXgNnYKCAmg0GiQmJgIAAgMD8dOf/tRxfvjw4fjZz36GnJwcl214e3sjNDTU8bijowM7d+7Ez3/+c6hU3y40OGfOHKxYsQKVlZWIjo5W2lUiIiIiIiIiIrekeIZOUVER4uPjXZ4/ffo03nzzTUydOrXfbe7atQv19fVIS0tzOh4ZGYmQkBAUFcl3HCIiIiIiIiIicjeKB3TMZjP0en234w8++CB8fX1xww03wM/PD6+++mq/2zQajUhKSkJ4ePdtNfV6Pcxms8vYtrY2NDU1ORUiIiIiIiIiInemeECnpaUFPj4+3Y7/7ne/w+eff46dO3eisrISq1at6ld7p06dwp49exxr8vwzrVYLq9XqMj47Oxv+/v6OEhER0b8LISIiIiIiIiLl/tULFnNRZACCAZ2goCA0NDR0Ox4aGooxY8Zg7ty5+MMf/oBXXnkFZ86c6bO9zZs3Y9iwYZg7d26P5y0WC4KDg13GZ2RkoLGx0VFqamr6fzFERERERERERAOQ4gEdg8GA8vLyXuvYbDYAl2+H6o3dbsfmzZuxePFiqNXqbudbW1tRWVkJg8Hgsg2NRgM/Pz+nQkRERERERETkzhTvcpWUlISMjAw0NDQgMDAQBQUFOHfuHG699VYMHjwYZWVlWL16NaZMmYKoqKhe29q/fz+qqqrw8MMP93j+0KFD0Gg0mDRpktJuEhERERERERG5LcUzdGJiYhAXF4f8/HwAl9e4+dOf/oTbb78dY8eOxRNPPIG5c+finXfeccSYTCaoVCoUFhY6tWU0GjF58mSMGTOmx1x5eXlYsGABfH19lXaTiIiIiIiIiK6Hf/X6NlxDB4Bghg4AZGZmYvXq1UhPT8f06dNRXFzca/2qqioEBARgwoQJTse3bdvmMqaurg47duzA4cOHJV0kIiIiIiIiInJbogGdlJQUVFRUoLa2tl+7ShUUFGDNmjUIDAzsdw6TyYSXX34ZI0aMkHSRiIiIiIiIiMhtiQZ0AGDlypX9rpuTk6O4/YkTJ2LixImK4644czYQHtru26v3xaNR9iMZH1cligOA4xXRorgP3xsvzjlpZpko7pxVvui0vVn2s42IviDO+Um57Ge7MmyvOOepiwHi2NhI2S5t/xb8pTjnc03/JorzuvuiOGfpuTBR3PPjd4hz7mpwvbh6b76o04tzvv/VWFGcenC7OOfyKQfEsb//aKYoTuXbKc7Z1Kn8dRoA3rgof38o/Fz2e/mvGW+Icz5tulcUN7j7ppL9pg+UBR89Fi7OGX/zSXGsfqEsdu+uW8U5VVrZdOrR9x0T5yzdPVoUN3uY7H0bAA4ev1EUt+HULHFObZBVFNeadBVT3Ovkt+h/9nHPt//3xb9CnBILvdJEcV2f9v8L0n+mGiL7+XbYPcU5bwyuF8VduueSOOfIQU2iuCODIsU5NR/J3s8AwNPDJoo7flL2eQoAgopln8sbZraKc9rVsudf7a8mi3Pe8N+930niyplVynN2tSlezYToqvFZR0REREREREQ0wIgGdOrr66HT6WAyma5xd761e/duxMbGOrZAJyIiIiIiIqLvAdsPoAwAogGdrKwspKamOrYlV6lU3cpf/vIXl/GFhYU9xqhUKnz22WcAgOTkZKjVamzdulXSRSIiIiIiIiIit6X45kmr1Qqj0Yg9e/Y4Hd+8eTOSk5MdjwMCAly2MXnyZJw5c8bp2DPPPIN9+/Y5rZuzZMkSbNy4EYsWLVLaTSIiIiIiIiIit6V4QKegoAAajQaJiYlOxwMCAhAaGtqvNry9vZ3qdnR0YOfOnfj5z38OlUrlOD5nzhysWLEClZWViI6WLW5LRERERERERORuFN9yVVRUhPj4+G7Hly9fjqCgINx222147bXXYLf3fxXzXbt2ob6+Hmlpzqv9R0ZGIiQkBEVFRS5j29ra0NTU5FSIiIiIiIiI6PpQ2e1uXwYCxTN0zGYz9HrnbXyfe+453HXXXfD19cV7772Hn/3sZ7h06RIee+yxfrVpNBqRlJSE8PDuW6Xq9XqYzWaXsdnZ2fj1r3+t7CKIiIiIiIiIiAYwxQM6LS0t8PHxcTr2zDPPOP5tMBjQ3NyMnJycfg3onDp1Cnv27EF+fn6P57VaLaxWq8v4jIwMrFq1yvG4qakJERERfeYlIiIiIiIiIhqoFN9yFRQUhIaGhl7rJCQk4NSpU2hra+uzvc2bN2PYsGGYO3duj+ctFguCg4Ndxms0Gvj5+TkVIiIiIiIiIiJ3pnhAx2AwoLy8vNc6JSUlCAwMhEaj6bWe3W7H5s2bsXjxYqjV6m7nW1tbUVlZCYPBoLSbRERERERERERuS/EtV0lJScjIyEBDQwMCAwPx9ttv49y5c0hMTISPjw/27t2LdevW4Re/+EWfbe3fvx9VVVV4+OGHezx/6NAhaDQaTJo0SWk3iYiIiIiIiOh6sNsvF3c1QK5N8QydmJgYxMXFOda8UavVeOmllzBp0iTExsbiD3/4A9avX4+1a9c6YkwmE1QqFQoLC53aMhqNmDx5MsaMGdNjrry8PCxYsAC+vr5Ku0lERERERERE5LYUz9ABgMzMTKxevRrp6elITk5GcnJyr/WrqqoQEBCACRMmOB3ftm2by5i6ujrs2LEDhw8flnSRiIiIiIiIiMhtiQZ0UlJSUFFRgdra2n7tKFVQUIA1a9YgMDCw3zlMJhNefvlljBgxQtJFqLXt8PBVPAEJ028pE+V778ubRXEA4DVENp1r9G0mcc6PPxknyzmhWpwTGpso7GzDEHHKV6ZvEcUtPNjzbYD9YT/f+9pRvanwkP2MfmNKEef08u4UxdWb+//3/M+mx8v+zlaV/Fic86mYd0Vx7x0fK845M+aoKK76kvxn+4ey28Wx02Jl/W1ok8+iDPa+JIrzVMn+VgDg7lu/FMU9XfTv4pw3jjwrijMNGibOGRtwShRnu0klzvl55XBxbKlvuyjONrZZnNNL3SWK++xr2WcTAAi8rV4Ul39mojinp7fs76XivOtNKfrSYRosiusaLPudAIDKV/Z+BgBd7co/MwJAffxVTMmvGyQKG9L3niMu6aafFsW9eS5OnLPmYoAozlol3+ikxkf23PW2eIpzts5uEse2NGpFcX6l3dcg7S+V8HaSoHfln3PP3SH7+24JE6fEmVWTRXFh64sVx3TaO/C1KBuRnGhABwBWrlzZ77o5OTmK2584cSImTpR/eCEiIiIiIiKi68BmB1QDY50ZEdvAuDbR1xH19fXQ6XQwmUzXuDvf2r17N2JjY2Gzyb+FJSIiIiIiIiJyR6IBnaysLKSmpiIqKgq5ublQqVQ9lvPnz/cYX1hY6DLms88+AwAkJydDrVZj69at8qsjIiIiIiIiInJDim+5slqtMBqN2LNnDwDggQce6LYo8pIlS9Da2gqdTtdjG5MnT8aZM2ecjj3zzDPYt2+f021WS5YswcaNG7Fo0SKl3SQiIiIiIiIicluKB3QKCgqg0WiQmJgIANBqtdBqv13I68KFC9i/fz+MRqPLNry9vREaGup43NHRgZ07d+LnP/85VKpvF2OcM2cOVqxYgcrKSkRHRyvtKhERERERERGRW1I8oFNUVIT4+HiX57ds2QJfX1/cd999/W5z165dqK+vR1pamtPxyMhIhISEoKioiAM6RERERERERN8Hdvvl4q4GyLUpHtAxm83Q6/UuzxuNRsyfP99p1k5fjEYjkpKSEB4e3u2cXq+H2Wx2GdvW1oa2tm/3b2xqkm8ZSEREREREREQ0ECheFLmlpQU+Pj49njt48CCOHj2KpUuX9ru9U6dOYc+ePS5jtFotrFary/js7Gz4+/s7SkRERL9zExERERERERENRIoHdIKCgtDQ0NDjuVdffRWxsbG93pL1zzZv3oxhw4Zh7ty5PZ63WCwIDg52GZ+RkYHGxkZHqamp6XduIiIiIiIiIqKBSPEtVwaDAX/+85+7Hb906RLy8/ORnZ3d77bsdjs2b96MxYsXQ61Wdzvf2tqKyspKGAwGl21oNBpoNJp+5yQiIiIiIiKiq+Hma+hgYFyb4hk6SUlJKCsr6zZLZ/v27ejs7MTChQv73db+/ftRVVWFhx9+uMfzhw4dgkajwaRJk5R2k4iIiIiIiIjIbSke0ImJiUFcXBzy8/OdjhuNRsybNw8BAQHdYkwmE1QqFQoLC7vFTJ48GWPGjOkxV15eHhYsWABfX1+l3fz/27uf1zqrNA7gz72pzV1ooiA0VMPYheBCacEftW6cRaCLLia74kYRcdeiFAQp0rhzJQhTRfwDiqILB6QITmAWQwtSdeNCcBHHKKTaTVNj2/x4zywy1MlMMrn3ZK43z+3nA3fz8p4+59z35k349tznBQAAABhaPX/lKiLizJkz8corr8SLL74Y7fZ6JnThwoUtz5+bm4u77747Dh48uOH4uXPnthxz5cqV+Oijj+LSpUs1UwQAAAAYWlWBzrFjx+Lbb7+NH3/8saunSp0/fz5Onz4d99xzT9c1vvvuu3jnnXfiwIEDPc2t/Ot7fM31m9ucubnlX5arxjXXb1SNi4hobqxVjVtZqpvres26+a4u1b2vEfXvUdOqX+ev1+re2+bX+utZbtR/33Lt17r3t9n6QXDbat1R+R5db1XXrP05W9vBdbn+y2rVuJ18FmrXuaOfswHMd2W56ldJRETcHFmpGjfSaqprLi///vf52mu6k+t585e693YQ9/mIiLWouy5lrefNxr/VrL7/VZesvs+vtn//+8Laat19MyKiuVF3X2hG6q5JRESrVT/fuF5Xt6zuoMfCnrr72NrN+vtf7c/3ykr932LVf9tU/q0aEdGUuveouTFSXbN2nRERzfW6z9FafclYW66ruZPPfFP5cxY7uS43635HrJbef4euxvqYMtR9ZdhtWmXIPnE//PCDR5cDAADwu5ufn4/7779/0NPom8XFxRgfH4+pAydjT3t4H0602tyMv879Oa5evRpjY2ODns6W6v9bdZfav39/zM/Px1133RWt1sYdBIuLizE5ORnz8/M9X5TasWqqqeburZltvmqqmbFmtvmqqaaawzlfNdXsd81SSly7di3279/f03xgJ4Yu0Gm329smomNjY9UpW+1YNdVUc/fW3MlYNdVUs/9j1VRTzd1bcydj1VRz2GqOj49XzQVq1X/xHAAAAICBGLodOgAAAEAfNSUihqod70ZNjrXdVjt0RkdHY2ZmJkZHe2/eVDtWTTXV3L01dzJWTTXV7P9YNdVUc/fW3MlYNdW83WpCvwzdU64AAACA/79bT7n6w4nhf8rVP87u+qdc3VY7dAAAAACGgUAHAAAAIBlNkQEAAIDulWb9NaySrM0OHQAAAIBkBDoAAAAAyQh0AAAAAJLRQwcAAADoXinrr2GVZG126AAAAAAkI9ABAAAASEagAwAAAJCMQAcAAAAgGU2RAQAAgO41JSJyNA6u0uRYmx06AAAAAMkIdAAAAACSEegAAAAAJKOHDgAAANC9UtZfwyrJ2uzQAQAAAEhGoAMAAACQjEAHAAAAIBmBDgAAAEAymiIDAAAA3SuRpnFwlSRLs0MHAAAAIBmBDgAAAEAyAh0AAACAZPTQAQAAALpXypD30MmxNjt0AAAAAJIR6AAAAAAkI9ABAAAASEagAwAAAJCMpsgAAABA95omIppBz6J/mhxrs0MHAAAAIBmBDgAAAEAyAh0AAACAZPTQAQAAALpXyvprWCVZmx06AAAAAMkIdAAAAACSEegAAAAAJCPQAQAAAEhGU2QAAACge5oi7wp26AAAAAAkI9ABAAAASEagAwAAAJCMHjoAAABA95oSETn6zFRpcqzNDh0AAACAZAQ6AAAAAMkIdAAAAACSEegAAAAAJKMpMgAAANC1UpoopRn0NPomy9rs0AEAAABIRqADAAAAkIxABwAAACAZPXQAAACA7pUS0ZRBz6J/So612aEDAAAAkIxABwAAACAZgQ4AAABAMgIdAAAAgGQ0RQYAAAC6V0pE5GgcXEVTZAAAAAD6QaADAAAAkIxABwAAACAZPXQAAACA7jVNRKsZ9Cz6p+RYmx06AAAAAMkIdAAAAACSEegAAAAAJCPQAQAAAEhGU2QAAACge6VERBn0LPqn5FibHToAAAAAyQh0AAAAAJIR6AAAAAAko4cOAAAA0LXSNFFazaCn0Tel5FibHToAAAAAyQh0AAAAAJIR6AAAAAAkI9ABAAAASEZTZAAAAKB7pUREGfQs+qfkWJsdOgAAAADJCHQAAAAAkhHoAAAAACSjhw4AAADQvaZEtHL0mamihw4AAAAA/SDQAQAAAEhGoAMAAACQjEAHAAAAIBlNkQEAAIDulRIRzaBn0T+aIgMAAADQDwIdAAAAgGQEOgAAAADJ6KEDAAAAdK00JUorR5+ZGkUPHQAAAAD6QaADAAAAkIxABwAAACAZgQ4AAABAMpoiAwAAAN0rTUQ0g55F/5Qca7NDBwAAACAZgQ4AAABAMgIdAAAAgGT00AEAAAC6VpoSpVUGPY2+KSXH2uzQAQAAAEhGoAMAAACQjEAHAAAAIBmBDgAAAEAyAh0AAACge6UZ/leP3n777XjggQei0+nE4cOH4/PPP/+f53/44Yfx0EMPRafTiUceeSTOnz/fc02BDgAAAEClDz74IE6dOhUzMzPx5ZdfxsGDB+Po0aPx008/bXr+hQsX4plnnokXXnghvvrqq5ieno7p6en4+uuve6rbKlmexwUAAAAMzOLiYoyPj8cf40+xp3XHoKfTN6tlJf4Wf4mrV6/G2NjYtucfPnw4Hn/88Th79mxERDRNE5OTk3Hy5Ml49dVX/+v848ePx9LSUnzyySe3jj355JNx6NChePfdd7uepx06AAAAABWWl5fjiy++iKmpqVvH2u12TE1NxcWLFzcdc/HixQ3nR0QcPXp0y/O3sqf36QIAAAC3q9VYiRji7/qsxkpErO9I+nejo6MxOjq64diVK1dibW0t9u3bt+H4vn374ptvvtn0319YWNj0/IWFhZ7mKdABAAAAtrV3796YmJiIvy/03sA3mzvvvDMmJyc3HJuZmYnXX399MBPahEAHAAAA2Fan04m5ublYXl4e9FT6rpQSrVZrw7H/3J0TEXHvvffGyMhIXL58ecPxy5cvx8TExKb/9sTERE/nb0WgAwAAAHSl0+lEp9MZ9DR2jb1798ajjz4as7OzMT09HRHrTZFnZ2fjxIkTm445cuRIzM7Oxssvv3zr2GeffRZHjhzpqbZABwAAAKDSqVOn4rnnnovHHnssnnjiiXjrrbdiaWkpnn/++YiIePbZZ+O+++6LN954IyIiXnrppXj66afjzTffjGPHjsX7778fly5divfee6+nugIdAAAAgErHjx+Pn3/+Oc6cORMLCwtx6NCh+PTTT281Pv7++++j3f7tIeNPPfVUnDt3Ll577bU4ffp0PPjgg/Hxxx/Hww8/3FPdVilliHtTAwAAAAyf9vanAAAAALCbCHQAAAAAkhHoAAAAACQj0AEAAABIRqADAAAAkIxABwAAACAZgQ4AAABAMgIdAAAAgGQEOgAAAADJCHQAAAAAkhHoAAAAACQj0AEAAABI5p+y70ZZaR5PHAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_distances_matrix(**distances_result, show=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "distance_grid: Float[np.ndarray, \"n n n n\"] = compute_grid_distances(\n", + " embedding_distances_matrix=distances_result[\"embedding_distances_matrix\"],\n", + " tokenizer=TOKENIZER,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABbgAAAboCAYAAABOOrdIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU1f3/8fckIRMSkrAvkbCjbIKyiqi4IIiK0hZca1Fr3VjFFaug1QIVF/pTxK2iVVGqFbBWQFAQLaKAoiIuoGyyi5CEkHXm/P7gm8CYAJk5M3PnTl7PPuZRuXM/937m5p1zb04mdzzGGCMAAAAAAAAAAFwmwekGAAAAAAAAAAAIBRPcAAAAAAAAAABXYoIbAAAAAAAAAOBKTHADAAAAAAAAAFyJCW4AAAAAAAAAgCsxwQ0AAAAAAAAAcCUmuAEAAAAAAAAArsQENwAAAAAAAADAlZjgBgAAAAAAAAC4EhPcAAAAQBBeeOEFeTwebdy40elWyrVo0UJXX311+b+XLFkij8ejJUuWONZTdeLxeHTfffcdc7377rtPHo8n8g0BAABUI0xwAwAAAJAkTZw4UXPmzHG6DQAAAKDKkpxuAAAAAHCTq666Spdddpm8Xq/TrRzRGWecoYKCAiUnJwdVN3HiRA0ZMkSDBw+OTGNxqqCgQElJ/GgFAADgBK7CAAAAgCAkJiYqMTHR6TaOKiEhQSkpKU63Edf8fr+Ki4uVkpLCsQYAAHAQtygBAACA623dulV//OMflZWVJa/Xq5YtW+qmm25ScXFx+To//vijhg4dqrp16yo1NVWnnHKK/vvf/1bY1uOPP66OHTsqNTVVderUUffu3TVz5szy5yu7B3eLFi104YUX6qOPPlLPnj2VkpKiVq1a6Z///GeF7e/bt09jxoxRdna2vF6v2rRpo7/97W/y+/3HfJ3GGD344INq2rSpUlNTddZZZ+nrr7+usF5l9+Bet26dfve736lx48ZKSUlR06ZNddlllyknJ0fSwftI5+fn68UXX5TH45HH4ym/r/emTZt0880364QTTlDNmjVVr149DR06tMJ9yMuOzf/+9z+NHTtWDRo0UFpamn7zm99o9+7dFfqcN2+e+vbtq/T0dGVkZKhHjx4Bx1qSPvnkE5133nnKzMxUamqq+vbtq//9738B6+Tl5WnMmDFq0aKFvF6vGjZsqHPPPVefffbZMY/pkiVL1L17d6WkpKh169Z6+umnK71Xtsfj0YgRI/TKK6+oY8eO8nq9mj9/fvlzv74H90cffaQePXoEbBcAAADhxzu4AQAA4Grbtm1Tz549tW/fPl1//fVq166dtm7dqjfeeEMHDhxQcnKydu7cqVNPPVUHDhzQqFGjVK9ePb344ou66KKL9MYbb+g3v/mNJOnZZ5/VqFGjNGTIEI0ePVqFhYX68ssv9cknn+iKK644ah/r16/XkCFD9Mc//lHDhg3T888/r6uvvlrdunVTx44dJUkHDhxQ3759tXXrVt1www1q1qyZli1bpnHjxmn79u2aOnXqUfcxfvx4Pfjggzr//PN1/vnn67PPPlP//v0DJvIrU1xcrAEDBqioqEgjR45U48aNtXXrVr399tvat2+fMjMz9dJLL+m6665Tz549df3110uSWrduLUlasWKFli1bpssuu0xNmzbVxo0bNX36dJ155plau3atUlNTA/Y3cuRI1alTRxMmTNDGjRs1depUjRgxQrNmzSpf54UXXtC1116rjh07aty4capdu7Y+//xzzZ8/v/xYv//++xo4cKC6deumCRMmKCEhQTNmzNDZZ5+tDz/8UD179pQk3XjjjXrjjTc0YsQIdejQQXv27NFHH32kb775Rl27dj3icfn888913nnnqUmTJrr//vvl8/n0l7/8RQ0aNKh0/ffff1//+te/NGLECNWvX18tWrSodL2vvvpK/fv3V4MGDXTfffeptLRUEyZMUKNGjY76dQIAAEAIDAAAAOBif/jDH0xCQoJZsWJFhef8fr8xxpgxY8YYSebDDz8sfy4vL8+0bNnStGjRwvh8PmOMMRdffLHp2LHjUfc3Y8YMI8ls2LChfFnz5s2NJLN06dLyZbt27TJer9fceuut5cseeOABk5aWZr7//vuAbd51110mMTHRbN68+Yj73bVrl0lOTjYXXHBB+esyxpi7777bSDLDhg0rX7Z48WIjySxevNgYY8znn39uJJnXX3/9qK8tLS0tYDtlDhw4UGHZxx9/bCSZf/7zn+XLyo5Nv379Anq85ZZbTGJiotm3b58xxph9+/aZ9PR006tXL1NQUBCw3bI6v99v2rZtawYMGBCwrQMHDpiWLVuac889t3xZZmamGT58+FFfW2UGDRpkUlNTzdatW8uXrVu3ziQlJZlf/6gkySQkJJivv/66wnYkmQkTJpT/e/DgwSYlJcVs2rSpfNnatWtNYmJihe0CAADADrcoAQAAgGv5/X7NmTNHgwYNUvfu3Ss8X3abiXfeeUc9e/bUaaedVv5crVq1dP3112vjxo1au3atJKl27dr66aeftGLFiqB76dChg04//fTyfzdo0EAnnHCCfvzxx/Jlr7/+uk4//XTVqVNHP//8c/mjX79+8vl8Wrp06RG3v2jRIhUXF2vkyJEBt88YM2bMMXvLzMyUJC1YsEAHDhwI+rXVrFmz/L9LSkq0Z88etWnTRrVr1670NiDXX399QI+nn366fD6fNm3aJElauHCh8vLydNddd1W4f3VZ3erVq7Vu3TpdccUV2rNnT/mxys/P1znnnKOlS5eW39aldu3a+uSTT7Rt27Yqvyafz6dFixZp8ODBysrKKl/epk0bDRw4sNKavn37qkOHDsfc7oIFCzR48GA1a9asfHn79u01YMCAKvcHAACAqmGCGwAAAK61e/du5ebmqlOnTkddb9OmTTrhhBMqLG/fvn3585J05513qlatWurZs6fatm2r4cOHV7jf85EcPplZpk6dOtq7d2/5v9etW6f58+erQYMGAY9+/fpJknbt2nXU1yBJbdu2DVjeoEED1alT56i9tWzZUmPHjtVzzz2n+vXra8CAAZo2bVr5/bePpaCgQOPHjy+/b3j9+vXVoEED7du3r9Jt/PpYlPVXdix++OEHSTrq123dunWSpGHDhlU4Xs8995yKiorK9/3QQw9pzZo1ys7OVs+ePXXfffcF/GKhMrt27VJBQYHatGlT4bnKlkkHj+Ox7N69WwUFBRW+TpIqzSAAAADscA9uAAAA4P+0b99e3333nd5++23Nnz9f//73v/Xkk09q/Pjxuv/++49am5iYWOlyY0z5f/v9fp177rm64447Kl33+OOPD735Y3jkkUd09dVXa+7cuXr33Xc1atQoTZo0ScuXL1fTpk2PWjty5EjNmDFDY8aMUe/evZWZmSmPx6PLLrus0g/HrMqxOJay7U6ZMkUnnXRSpevUqlVLknTJJZfo9NNP1+zZs/Xuu+9qypQp+tvf/qY333zziO/GDsXh72QHAABAbGCCGwAAAK7VoEEDZWRkaM2aNUddr3nz5vruu+8qLP/222/Lny+TlpamSy+9VJdeeqmKi4v129/+Vn/96181bty4CrfTCFbr1q21f//+8ndsB6Osx3Xr1qlVq1bly3fv3h3wLvGjOfHEE3XiiSfqnnvu0bJly9SnTx899dRTevDBByUp4LYih3vjjTc0bNgwPfLII+XLCgsLtW/fvqBfh3TowyvXrFlzxHdLl62TkZFRpePVpEkT3Xzzzbr55pu1a9cude3aVX/961+POMHdsGFDpaSkaP369RWeq2xZVTVo0EA1a9Ysfwf64SrLIAAAAOxwixIAAAC4VkJCggYPHqz//Oc/WrlyZYXny94xfP755+vTTz/Vxx9/XP5cfn6+nnnmGbVo0aL8vsp79uwJqE9OTlaHDh1kjFFJSYl1v5dccok+/vhjLViwoMJz+/btU2lp6RFr+/Xrpxo1aujxxx8PeCf01KlTj7nf3NzcCts+8cQTlZCQoKKiovJlaWlplU5aJyYmVnj39eOPPy6fz3fMfVemf//+Sk9P16RJk1RYWBjwXNl+unXrptatW+vhhx/W/v37K2xj9+7dkg7e8/rXt0lp2LChsrKyAl5bZa+pX79+mjNnTsC9u9evX6958+aF9LrKtjtgwADNmTNHmzdvLl/+zTffVPp1BwAAgB3ewQ0AAABXmzhxot5991317dtX119/vdq3b6/t27fr9ddf10cffaTatWvrrrvu0quvvqqBAwdq1KhRqlu3rl588UVt2LBB//73v5WQcPB9H/3791fjxo3Vp08fNWrUSN98842eeOIJXXDBBUpPT7fu9fbbb9dbb72lCy+8UFdffbW6deum/Px8ffXVV3rjjTe0ceNG1a9fv9LaBg0a6LbbbtOkSZN04YUX6vzzz9fnn3+uefPmHbGmzPvvv68RI0Zo6NChOv7441VaWqqXXnpJiYmJ+t3vfle+Xrdu3bRo0SI9+uijysrKUsuWLdWrVy9deOGFeumll5SZmakOHTro448/1qJFi1SvXr2QjkNGRoYee+wxXXfdderRo4euuOIK1alTR1988YUOHDigF198UQkJCXruuec0cOBAdezYUddcc42OO+44bd26VYsXL1ZGRob+85//KC8vT02bNtWQIUPUpUsX1apVS4sWLdKKFSsC3nFemfvuu0/vvvuu+vTpo5tuukk+n09PPPGEOnXqpNWrV4f02iTp/vvv1/z583X66afr5ptvVmlpqR5//HF17NhRX375ZcjbBQAAQEVMcAMAAMDVjjvuOH3yySe699579corryg3N1fHHXecBg4cqNTUVElSo0aNtGzZMt155516/PHHVVhYqM6dO+s///mPLrjggvJt3XDDDXrllVf06KOPav/+/WratKlGjRqle+65Jyy9pqam6oMPPtDEiRP1+uuv65///KcyMjJ0/PHH6/7771dmZuZR6x988EGlpKToqaee0uLFi9WrVy+9++67Aa+hMl26dNGAAQP0n//8R1u3blVqaqq6dOmiefPm6ZRTTilf79FHH9X111+ve+65RwUFBRo2bJh69eqlv//970pMTNQrr7yiwsJC9enTR4sWLdKAAQNCPhZ//OMf1bBhQ02ePFkPPPCAatSooXbt2umWW24pX+fMM8/Uxx9/rAceeEBPPPGE9u/fr8aNG6tXr1664YYbyo/pzTffrHfffVdvvvmm/H6/2rRpoyeffFI33XTTUXvo1q2b5s2bp9tuu0333nuvsrOz9Ze//EXffPNN+e1rQtG5c2ctWLBAY8eO1fjx49W0aVPdf//92r59OxPcAAAAYeYxwXzSCwAAAADEucGDB+vrr7+u9D7aAAAAiC3cgxsAAABAtVVQUBDw73Xr1umdd97RmWee6UxDAAAACArv4AYAAABQbTVp0kRXX321WrVqpU2bNmn69OkqKirS559/rrZt2zrdHgAAAI6Be3ADAAAAqLbOO+88vfrqq9qxY4e8Xq969+6tiRMnMrkNAADgEryDGwAAAAAAAADgStyDGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArMcENAAAAAAAAAHAlJrgBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuFJcT3CvWLFCp556qtLS0uTxeLR69WqnWzqmhx56SO3atZPf74/6vi+77DJdcsklUd9vvCF3wbnrrrvUq1evqO833pC74JC78CF7wSF74UHugsM1XniQu+CQu/Ahe8Ehe+FB7oJD7gCHmThVXFxsmjdvbk444QTz9NNPm5deesn88ssvTrd1VDk5OaZu3brm+eefr/Dc3Llzzcknn2y8Xq/Jzs4248ePNyUlJVXe9nPPPWfatWtnvF6vadOmjfl//+//VVjns88+MwkJCWb16tVWr6M6I3eHPPnkk2bIkCEmOzvbSDLDhg2rdL3t27cbr9dr5s6da/MyqjVyd9DmzZvNfffdZ3r06GFq165t6tWrZ/r27WsWLlxYYV1yFx5k76ADBw6Ya6+91nTs2NFkZGSYtLQ007lzZzN16lRTXFwcsC7Zs0fuKvfhhx8aSUaS2b17d8BzXOPZI3eHlOXs149JkyYFrEfuwoPsBdqxY4e5/vrrTVZWlvF6vaZ58+bm2muvDViH7NkjdwfNmDHjiGOeJPPyyy+Xr0vuAGfF7QT3N998YySZZ5991ulWquyxxx4zGRkZpqCgIGD5O++8YzwejznrrLPMM888Y0aOHGkSEhLMjTfeWKXtPvXUU0aS+d3vfmeeeeYZc9VVVxlJZvLkyRXW7dmzp7nqqqvC8nqqI3J3SPPmzU3dunXNeeedZ5KSko44wW2MMZdccok5/fTTbV5GtUbuDnr88cdNzZo1zeWXX26eeOIJM3XqVNO1a1cjqdILXXJnj+wdtGfPHtOrVy9z++23m2nTppnp06ebq666yng8HnP55ZdXWJ/s2SF3Ffl8PnPSSSeZtLS0Sie4jeEazxa5O0SSOffcc81LL70U8FizZk2FdcmdPbJ3yObNm012drbJzs42f/nLX8w//vEP88ADD5hBgwZVWJfs2SF3B/3www8VxrqXXnrJdO3a1SQmJprt27cHrE/uAOfE7QT3Bx98YCSZ119//Zjr7t+/PwodHVvnzp3N73//+wrLO3ToYLp06RLwG8Y///nPxuPxmG+++eao2zxw4ICpV6+eueCCCwKWX3nllSYtLa3Cb2Effvhhk5aWZvLy8ixeSfVF7g7ZuHGj8fv9xhhj0tLSjjrB/cYbbxiPx2N++OGH4F8AyN3/WbNmTYVJncLCQtOuXTvTtGnTCuuTO3tk7+hGjBhhJFX44Yfs2SF3FU2fPt3Uq1fPjB49+ogT3Fzj2SF3h0gyw4cPr1IP5M4e2Ttk4MCBpmXLlubnn38+5rpkzw65O7IDBw6Y9PR0c+6551Z4jtwBzonLCe5hw4ZV+NORvn37lj+XlpZm1q9fbwYOHGhq1aplLr74YmPMwYF57NixpmnTpiY5Odkcf/zxZsqUKeWTdGXKLur+9a9/mfbt25uUlBRzyimnmC+//NIYc/Ad061btzZer9f07dvXbNiw4Zg9//jjj0aSeeGFFwKWf/3110aSmTZtWsDyrVu3GknmgQceOOp2//vf/xpJ5r///W/A8mXLlhlJ5qWXXgpY/sUXXxhJ5s033zxmzwhE7o7sWBPc+/btMx6Pxzz66KNBbRfkrirGjh1rJJnc3NyA5eTODtk7tocffthIqvDDE9kLHbmraM+ePaZevXpm2rRpZsKECUec4OYaL3TkLlBZvwcOHKjwTslfI3d2yN4hZe8ofvLJJ40xxhQUFFS4DdjhyF7oyN3RzZo1q9J9GUPuACfF5QT3smXLzN13320kmVGjRpmXXnrJvPvuu8aYgwOy1+s1rVu3NsOGDTNPPfWU+ec//2n8fr85++yzjcfjMdddd5154oknzKBBg4wkM2bMmIDtSzKdO3c22dnZZvLkyWby5MkmMzPTNGvWzDzxxBOmQ4cO5pFHHjH33HOPSU5ONmedddYxe3755ZeNpPJB/dfLP/nkkwo1TZs2Nb/97W+Put0HH3zQSDI7d+4MWF5UVGQSEhLM2LFjA5aXlJSYmjVrmltvvfWYPSMQuTuyY01wG2NMmzZtzO9+97ugtgtyVxVXXHGFSU1NNaWlpRWeI3ehI3sVFRUVmd27d5vNmzebN9980zRu3Ng0b9680ns8kr3QkLuKbr75ZtOxY0dTWlp61AlurvFCR+4CSTJpaWnG4/EYSaZ9+/bmlVdeqXRdcmeH7B3y+OOPG0nm3//+tzn77LONJJOYmGjOO++8SidAyV7oyN3RXXTRRaZmzZoV3jxjDLkDnBSXE9zGGLN48eJK/6Sm7LeRd911V8DyOXPmGEnmwQcfDFg+ZMgQ4/F4zPr168uXSTJerzfgRPr0008bSaZx48YBA924ceOMpGP+1vGee+4xkir8KcuUKVOMJLN58+YKNT169DCnnHLKUbc7fPhwk5iYWOlzDRo0MJdddlmF5ccff7wZOHDgUbeLypG7ylVlgrt///6mffv2QW0XB5G7I1u3bp1JSUk54r3wyJ0dshfo1VdfDXi3U/fu3Sv8oFWG7IWO3B3yxRdfmMTERLNgwQJjjDnqBLcxXOPZIHeHnHrqqWbq1Klm7ty5Zvr06aZTp04B76z9NXJnh+wdNGrUKCPJ1KtXz5x33nlm1qxZZsqUKaZWrVqmdevWJj8/v0IN2Qsduavcnj17THJysrnkkkuOuA65A5yRoGrqpptuCvj3O++8o8TERI0aNSpg+a233ipjjObNmxew/JxzzlGLFi3K/92rVy9J0u9+9zulp6dXWP7jjz8etZ89e/YoKSlJtWrVClheUFAgSfJ6vRVqUlJSyp8/koKCAiUnJ1f63JHq69Spo59//vmo20VoqkvuQkHuIqe65u7AgQMaOnSoatasqcmTJ1e6DrmLrOqWvbPOOksLFy7U66+/rhtvvFE1atRQfn5+peuSvcipTrkbNWqUBg4cqP79+x9zXYncRVJ1yt3//vc/jR49WhdddJFuvPFGrVq1Sp06ddLdd9/NzxYOqC7Z279/vySpcePG+u9//6tLLrlEt912m5599ln98MMPmjlzZoUashc51SV3v/bGG2+ouLhYV1555RHXIXeAM6rlBHdSUpKaNm0asGzTpk3KysoKGEwlqX379uXPH65Zs2YB/87MzJQkZWdnV7p87969IfVas2ZNSVJRUVGF5woLC8ufP1p9cXFxpc8dqd4YI4/HE0K3OJrqlLtQkLvIqK658/l8uuyyy7R27Vq98cYbysrKqnQ9chc51TF7jRo1Ur9+/TRkyBBNnz5dF154oc4991zt2LGjwrpkLzKqU+5mzZqlZcuW6ZFHHqnyPsldZFSn3FUmOTlZI0aM0L59+7Rq1aoKz5O7yKlO2St7/pJLLlFCwqFpjKFDhyopKUnLli2rUEP2IqM65e7XXnnlFdWtW1cDBw484jrkDnBGtZzg9nq9ASfFUCQmJga13Bhz1O3Vq1dPpaWlysvLC1jepEkTSdL27dsr1Gzfvv2IkzaH1/t8Pu3atStgeXFxsfbs2VNp/d69e1W/fv2jbhfBq065CwW5i4zqmrs//elPevvtt/XCCy/o7LPPPuJ65C5yqmv2DjdkyBDt379fc+fOrfAc2YuM6pS722+/XUOHDlVycrI2btyojRs3at++fZKkLVu2aNu2bRVqyF1kVKfcHUnZpNQvv/xS4TlyFznVKXtlzzdq1KhCn/Xq1at0ApTsRUZ1yt3hNm/erA8//FBDhw5VjRo1jrgeuQOcUS0nuCvTvHlzbdu2rcKA+O2335Y/H0nt2rWTJG3YsCFg+UknnSRJWrlyZcDybdu26aeffip//kiOVL9y5Ur5/f4K9aWlpdqyZUv5b1oRWfGau1Bs2LCB3EVJvOfu9ttv14wZM/TYY4/p8ssvP+q65C664j17v1b2Z685OTkVniN70ROvuduyZYtmzpypli1blj/+/ve/S5K6du2q888/P2B9rvGiK15zdyRltw9o0KBBwHJyF33xmr1u3bpJkrZu3RqwvLi4WD///DPZc1i85u5wr776qowxR709CbkDnMME9/85//zz5fP59MQTTwQsf+yxx+TxeI76Jyjh0Lt3b0kVB96OHTuqXbt2euaZZ+Tz+cqXT58+XR6PR0OGDDnqds8++2zVrVtX06dPD1g+ffp0paam6oILLghYvnbtWhUWFurUU0+1eTmoonjNXbBycnL0ww8/kLsoiefcTZkyRQ8//LDuvvtujR49+qjrkrvoi9fs/fzzz5W+s+i5556TJHXv3j1gOdmLrnjN3ezZsys8Lr30UknSP//5Tz322GMB63ONF13xmrvdu3dXWJaXl6epU6eqfv365ZOQZchd9MVr9s4880w1bNhQr7zyigoLC8uXv/DCC/L5fDr33HMD1id70RWvuTvczJkz1axZM5122mlHXIfcAc5JcrqBWDFo0CCdddZZ+vOf/6yNGzeqS5cuevfddzV37lyNGTNGrVu3juj+W7VqpU6dOmnRokW69tprA56bMmWKLrroIvXv31+XXXaZ1qxZoyeeeELXXXddwG8GN27cqJYtW2rYsGF64YUXJB2859QDDzyg4cOHa+jQoRowYIA+/PBDvfzyy/rrX/+qunXrBuxr4cKFSk1NrXCBgMiI19xJ0n/+8x998cUXkqSSkhJ9+eWXevDBByVJF110kTp37ly+7qJFi2SM0cUXXxzBV4sy8Zq72bNn64477lDbtm3Vvn17vfzyywHbPvfccwP+rJXcRV+8Zu/ll1/WU089pcGDB6tVq1bKy8vTggULtHDhQg0aNKjCbXLIXnTFa+4GDx5cYV+rV6+WJA0cOLDCn0dzjRdd8Zq7adOmac6cORo0aJCaNWum7du36/nnn9fmzZv10ksvVfhwe3IXffGaPa/XqylTpmjYsGE644wzdNVVV2nz5s36+9//rtNPP12//e1vA/ZF9qIrXnNXZs2aNfryyy911113HfX+2uQOcA4T3P8nISFBb731lsaPH69Zs2ZpxowZatGihaZMmaJbb701Kj1ce+21Gj9+vAoKCgI+7ODCCy/Um2++qfvvv18jR45UgwYNdPfdd2v8+PEB9WWfLF12n6kyN998s2rUqKFHHnlEb731lrKzs/XYY49V+u7G119/Xb/97W8rfDgEIiOec/fvf/9bL774Yvm/P//8c33++eeSpKZNmwZMcL/++us67bTTIn7hg4PiNXdlv1BZt26drrrqqgr7XLx4ccAEN7mLvnjN3mmnnaZly5bp1Vdf1c6dO5WUlKQTTjhBjz76qEaOHFmhB7IXXfGau2BxjRdd8Zq7Pn36aNmyZXruuee0Z88epaWlqWfPnnr++ecr/cwLchd98Zo9SfrDH/6g5ORkTZ48Wbfffrtq166tG264QRMnTqxw72ayF13xnDvp4IdLStIVV1xx1B7IHeAgg5ixb98+U7duXfPcc8+FVD9t2jSTlpZmduzYEVL9559/bjwej/n8889Dqoc7OZ277du3m5SUFDNnzpyQ6uFO5A5OIXtwgtO54xqveiJ3cArZgxPIHVC9cQ/uGJKZmak77rhDU6ZMkd/vD7p+8eLFGjVqVIVPlq6qyZMna8iQIRH5AEHELqdzN3XqVJ144on8qX41Q+7gFLIHJzidO67xqidyB6eQPTiB3AHVm8eYSj4VCQAAAAAAAACAGMc7uAEAAAAAAAAArsQENwAAAAAAAADAlZjgBgAAAAAAAAC4EhPcAAAAAAAAAABXYoIbAAAAAAAAAOBKTHADAAAAAAAAAFwppia4p02bphYtWiglJUW9evXSp59+WuXapUuXatCgQcrKypLH49GcOXOC2vekSZPUo0cPpaenq2HDhho8eLC+++67oLYxffp0de7cWRkZGcrIyFDv3r01b968oLZxuMmTJ8vj8WjMmDFVrrnvvvvk8XgCHu3atQtqv1u3btXvf/971atXTzVr1tSJJ56olStXVrm+RYsWFXrweDwaPnx4UH1Ek5uzFy+5k+yyR+7mBLVvxrxDqtuYR+4CkbvocXP24iV3Eufa6pw7KfjsxULuJPdlz825k+JnzCN3Vc+d5Hz2yN1BbssdECtiZoJ71qxZGjt2rCZMmKDPPvtMXbp00YABA7Rr164q1efn56tLly6aNm1aSPv/4IMPNHz4cC1fvlwLFy5USUmJ+vfvr/z8/Cpvo2nTppo8ebJWrVqllStX6uyzz9bFF1+sr7/+Ouh+VqxYoaefflqdO3cOurZjx47avn17+eOjjz6qcu3evXvVp08f1ahRQ/PmzdPatWv1yCOPqE6dOkH1fvj+Fy5cKEkaOnRo0K8lGtyevXjInWSfPXIXHMa8g6rbmEfuApG76HF79uIhdxLn2uqcOyn07Dmdu7Le3ZI9t+dOio8xj9wFlzvJ+eyRu0O9uyV3QEwxMaJnz55m+PDh5f/2+XwmKyvLTJo0KehtSTKzZ8+26mfXrl1Gkvnggw+stlOnTh3z3HPPBVWTl5dn2rZtaxYuXGj69u1rRo8eXeXaCRMmmC5dugTX5GHuvPNOc9ppp4VcX5nRo0eb1q1bG7/fH9bthks8Zs9tuTMm/Nkjd8FhzAufWM4euTuE3EVXPGbPbbkzhnNtdc2dMaFnLxZzZ0xsZy8ec2eM+8Y8chd67oyJneyRu9jOHRBLYuId3MXFxVq1apX69etXviwhIUH9+vXTxx9/7EhPOTk5kqS6deuGVO/z+fTaa68pPz9fvXv3Dqp2+PDhuuCCCwKORzDWrVunrKwstWrVSldeeaU2b95c5dq33npL3bt319ChQ9WwYUOdfPLJevbZZ0PqQzr4tX355Zd17bXXyuPxhLydSIm37Lk1d1J4s0fugseYF/9jHrkLRO6iJ96y59bcSZxrq2vuJLvsxVLupNjOXrzlTnLvmEfunM2dVD3PtdUpd0DMcXqG3Rhjtm7daiSZZcuWBSy//fbbTc+ePYPenix/2+jz+cwFF1xg+vTpE3Ttl19+adLS0kxiYqLJzMw0//3vf4Oqf/XVV02nTp1MQUGBMcYE/RvHd955x/zrX/8yX3zxhZk/f77p3bu3adasmcnNza1SvdfrNV6v14wbN8589tln5umnnzYpKSnmhRdeCOp1lJk1a5ZJTEw0W7duDak+0uIle27PnTHhzR65Cw5jXvUY88jdIeQuuuIle27PnTGca42pfrkzxi57sZY7Y2I7e/GSO2PcP+aRu9BzZ4x7xzxyB1RfTHBX4sYbbzTNmzc3W7ZsCbq2qKjIrFu3zqxcudLcddddpn79+ubrr7+uUu3mzZtNw4YNzRdffFG+LNgB+df27t1rMjIyqvxnPTVq1DC9e/cOWDZy5EhzyimnhLT//v37mwsvvDCk2miIl+y5PXfGhDd75C44jHnVY8wjdweRu+iLl+y5PXfGcK41pnrlzpjwZ8/p3BkT29mLl9wZ4/4xj9w5O8FdXc+11Sl3QKxJivx7xI+tfv36SkxM1M6dOwOW79y5U40bN45qLyNGjNDbb7+tpUuXqmnTpkHXJycnq02bNpKkbt26acWKFfr73/+up59++pi1q1at0q5du9S1a9fyZT6fT0uXLtUTTzyhoqIiJSYmBtVP7dq1dfzxx2v9+vVVWr9Jkybq0KFDwLL27dvr3//+d1D7laRNmzZp0aJFevPNN4OujZZ4yZ7bcyeFL3vkLjiMedVnzCN3B5G76IuX7Lk9dxLnWql65U4Kf/aczJ0U+9mLl9xJ7h/zyJ0zuZOq97m2OuXOzQoLC1VcXOx0G66SnJyslJQUp9s4qpiY4E5OTla3bt303nvvafDgwZIkv9+v9957TyNGjIhKD8YYjRw5UrNnz9aSJUvUsmXLsGzX7/erqKioSuuec845+uqrrwKWXXPNNWrXrp3uvPPOoAdjSdq/f79++OEHXXXVVVVav0+fPvruu+8Cln3//fdq3rx50PueMWOGGjZsqAsuuCDo2miJ1+y5LXdS+LJH7qqGMe+g6jTmkbuDyF30xWv23JY7iXNtdcudFP7sOZk7KfazF6+5k9w35pG76OZOcn7MI3eoisLCQrVsXks7dvmcbsVVGjdurA0bNsT0JHdMTHBL0tixYzVs2DB1795dPXv21NSpU5Wfn69rrrmmSvX79+8P+K3ahg0btHr1atWtW1fNmjU7Zv3w4cM1c+ZMzZ07V+np6dqxY4ckKTMzUzVr1qxSD+PGjdPAgQPVrFkz5eXlaebMmVqyZIkWLFhQpfr09HR16tQpYFlaWprq1atXYfmR3HbbbRo0aJCaN2+ubdu2acKECUpMTNTll19epfpbbrlFp556qiZOnKhLLrlEn376qZ555hk988wzVaov4/f7NWPGDA0bNkxJSTETs0q5PXvxkDspPNkjd4x5jHlHR+7InVPcnr14yJ3Euba65U6yz16s5E5yT/bcnjspPsY8chdc7iTns0fuDnFL7tyouLhYO3b5tGlVC2WkJzjdjivk5vnVvNtGFRcXx/QEd0zcg7vM448/bpo1a2aSk5NNz549zfLly6tcu3jxYiOpwmPYsGFVqq+sVpKZMWNGlXu49tprTfPmzU1ycrJp0KCBOeecc8y7775b5frKBHvPqEsvvdQ0adLEJCcnm+OOO85ceumlZv369UHt8z//+Y/p1KmT8Xq9pl27duaZZ54JsmtjFixYYCSZ7777LuhaJ7g5e/GSO2Pss0fuGPMY846N3FVE7qLDzdmLl9wZw7m2uufOmOCyFyu5M8Zd2XNz7oyJnzGP3FU9d8Y4nz1yd4ibcuc2OTk5RpLZ+30r49velkcVHnu/b2UkmZycHKe/fEflMcaYY02CAwAAAAAAAIBb5ebmKjMzU3u/b6WM9OBvW1Md5eb5VOf4H5WTk6OMjAyn2zki3o8PAAAAAAAAAHAlJrgBAAAAAAAAAK7E3eoBAAAAAAAAVAt+Gfnld7oNV/DLHXe25h3cAAAAAAAAAABXYoIbAAAAAAAAAOBKTHADAAAAAAAAAFwp5ia4i4qKdN9996moqMiRenqIrR6iJV6OFz2EbxvREAuvlR5ip4doiofjRQ/h6yFa4uV4Od1DPLyGaIqX40UP4dtGtMTD8aKH8PUQLbHwWukhdnoAqhOPMSam7haem5urzMxM5eTkKCMjI+r19BBbPURLvBwvegjfNqIhFl4rPcROD9EUD8eLHsLXQ7TEy/Fyuod4eA3RFC/Hix7Ct41oiYfjRQ/h6yFaYuG10kPs9ICKyo7rnu9bKiM95t7zG5Ny8/yqd/yGmM9iktMNAAAAAAAAAEA0+Ixfvph6u2/s8hm/0y1UCb+uAAAAAAAAAAC4UtTfwe33+7Vt2zalp6fL4/FUeD43Nzfg/4NlW08P0e3BGKO8vDxlZWUpISFyv2+JdO7CsQ16iF4P5I4enOghVnJXlV6Ppbp8zeKhh2jlTmLMc0t9tHqIlTHPLceLHsKzjVjJXVV6PZbq8jWLhx7i6VzrhuNND4dEM3tArIv6Pbh/+uknZWdnR3OXcIEtW7aoadOmEds+uUNlyB2cQO7ghEjnTiJ7qBxjHpxA7uAEzrVwSjSyFy9ycw/eg3vXd825B3cV5eb51fCETdyD+9fS09MlSafpfCWpRkjb2Dm8l3UfJbXs6j0nhv6bvPIefky3qk9unWfdQ1GhXQQqf79C1fkLirR5xJTyXERK2faPv268EpNTQtpGoyc/se5jy1122U0osW5BTc78yar+xx8aW/dQI8Puk6B9u2ta1fsLC/XThAejlru2N4SeO2P7TSapyf+zy+7Om+zH3KL6dr9LLc4qtu4h+adkq3pvpxyret+BIn3/x79HLXdZD41TQs3QcpfxdWjn5wCWvz5v+LT9mLv7ervsFjSyfw9A4gl25+qEFXYXkb6iQq1/6i8Rz510KHst7rxXCd7Qsleny27rPvasbWBVn7LLfuBt/LhdfnffEIZxt7ZdfWGTUqt6f2Ghtt01MWpjXvNptymhpjekbZTuCS2vh0uqV2hV799hd20jSbU22f2g3iAM4+72UXbZLU2127+/qFAbHov8mFd+rp18txJSQsyPx/4ck7zb7me5mp32WfdQ8mkdq/qkA9YtqOFTlmOu5fWCr7hQ374Q3XPtcVPvDHnMS/jZ7ppYkrI67rSq3/1xE+seCrPsfjj2bre/3k22nJJpNM0uu6Uq0Ud6JyrZA2Jd1Ce4y/6MJkk1lOQJbUBJDPGHpsP5QzsXlPOk2k3QSZIv1Iuh/5OYaj/hk5BgN6iHYe7t4HaO8Kd94VK2/cTklJDzE2peD2eb3XD81VFSml34Q50wC9hGqt3X21h+75RxQ+7CMcFtm91wjLkJKXY/xCXUtA9/YordxXxiqt3kRZlo5S6hZkrI36+JXucnuMMy5ob4i6UytrmV7M/VoU4U/1qkc3f4PhK8KSFP+CRanqMkhT7ZVNaD1/5YWY+7ltmVpETLQ5lQ026Cu0z0xjyvElJDO24JB8JxbWO5gTBc2yQm250rY+Fa19gPAZKimLuU0M+14ZjgTkix+3E+MdX+gPstv+aJPusWYmLMlaJ8rq3pDTl7CZbXxJL9z5Rh+fmiZqJdDylhGPMsp2Ssx93/G0aikT0g1kV9ghsAAAAAAAAAnOCXkd/2HTnVhFuOEzecAQAAAAAAAAC4UkgT3NOmTVOLFi2UkpKiXr166dNPP7Vq4irzta40ayt97kqzVleZr622j/gQ7tyFA9mtHmIxezbIrTvEW+7CgexGHrmLDLJ7dOQudsV7dsle/Irl7JI7HEks5xaIdUFPcM+aNUtjx47VhAkT9Nlnn6lLly4aMGCAdu3aFXITfnl0tdZW+Ea+0qzV1Vorf9ju9Ay3ikTuwoHsxr9YzZ4Nchv74jF34UB2I4vcRQ7ZPTJyF9viObtkL77FanbJHY4mVnMLuEHQE9yPPvqo/vSnP+maa65Rhw4d9NRTTyk1NVXPP/98yE284umgF9Qh4Bu57Bv4BXXQK54OIW8b8SESuQsHshv/YjV7Nsht7IvH3IUD2Y0schc5ZPfIyF1si+fskr34FqvZJXc4mljNLeAGQX3IZHFxsVatWqVx48aVL0tISFC/fv308ccfV1pTVFSkoqKi8n/n5uZWut4rng6Ska7WWl1hvlWy/HwDQ1JkcxcOZDd+BZu9aObOFrmNXfGcu3Agu5ER6+faeEB2KyJ37hCP2eVcWz3EWnYZ81AVsZZbwC2Cegf3zz//LJ/Pp0aNGgUsb9SokXbs2FFpzaRJk5SZmVn+yM7OPuL2X/F0ULESlCy/ipXANzAkRT534UB241Ow2Yt27myR29gU77kLB7Ibfm4418YDshuI3LlHvGWXc231EUvZZcxDVcVSbuOVn/8F9T83COlDJoMxbtw45eTklD+2bNlyxHWvNGvLv4GT5T/izfWBYwkmd+FAdiFFP3e2yG18cFvuwoHsxobqmD1bZNceuXNGdc8uuXMvt2eX7FVPbs8t4ISgblFSv359JSYmaufOnQHLd+7cqcaNG1da4/V65fV6j7ntX99XqOzfMuK3VdVcJHMXDmQ3fgWbvWjmzha5jV3xnLtwILuREevn2nhAdisid+4Qj9nlXFs9xFp2GfNQFbGWW8AtgnoHd3Jysrp166b33nuvfJnf79d7772n3r17h9xEZTfNr+zm+qieIpW7cCC78S2Ws2eD3Ma2eM1dOJDdyCF3kUV2K0fuYl+8Zpfsxb9YzC65w7HEYm4BtwjqHdySNHbsWA0bNkzdu3dXz549NXXqVOXn5+uaa64JuYkEmUpvml92c/0EmZC3jfgQidyFA9mNf7GaPRvkNvbFY+7CgexGFrmLHLJ7ZOQutsVzdslefIvV7JI7HE2s5hZwg6AnuC+99FLt3r1b48eP144dO3TSSSdp/vz5FT4oIRgveToe8Tn+BANSZHIXDmQ3/sVq9myQ29gXj7kLB7IbWeQucsjukZG72BbP2SV78S1Ws0vucDSxmlvADYKe4JakESNGaMSIEeHuBTgqcgenkD04gdzBCeQOTiB3cArZgxPIHeA8nzHyGd4RXxVuOU4hTXCHw8/X9VRickpItXltfNb779vN7t5FOwvSrXs4beBKq/rle1ta9/BW2/lW9X/cfJpVffH+Ym202kJwfF5JIX5Gx0/jTrXef2mq3cDQ64xvrHu4vOFyq/oGrfKse3h9b0+r+gt6fmFVn5/n00V3Wm0iKHXO2a6ktNCCt3tJlvX+d46yy25BE/sTWlbX7Vb1iQl+6x42eBpY1RftSbOq9xckWtUHKym1RAmpoe2z2e+2WO//x3daWdX/cq39vSh9oV1mlKvffeexVzqG7Ttr222gU6FVub/Arj4U5/b7TMm1aoRU28z7i/X+m7f+2ar+rtlXWvew7Ta7cbe4jv2427bPRqv6b36q/APPqiyhxK4+iv7cb671Nv62eoBV/ZX9PrTuYea8M6zqfWPtr3VLLH9EOqnft3b7zy/WD5PteghGk2Z7Qr7G27Xa/h27J565zqr+x731rHtIPX23Vf0v39r3oJF22fUn2+3e57GrD0XiLq8SUkLL3hlnfGW9/7SkIqv6L0+3bkFbf65ttwHLayxJKvnSbtDbMcYuu76iQulJ+3MYEA+C+pBJAAAAAAAAAABiBRPcAAAAAAAAAABXYoIbAAAAAAAAAOBKTHADAAAAAAAAAFwp6AnupUuXatCgQcrKypLH49GcOXMi0BYQiNzBCeQOTiB3cArZgxPIHZxA7uAUsgfEBr8MjyAebhD0BHd+fr66dOmiadOmRaIfoFLkDk4gd3ACuYNTyB6cQO7gBHIHp5A9AIiMpGALBg4cqIEDB0aiF+CIyB2cQO7gBHIHp5A9OIHcwQnkDk4hewAQGUFPcAerqKhIRUVF5f/Ozc2N9C4BcgdHkDs4gdzBKWQPTiB3cAK5g1PIHgBUTcQ/ZHLSpEnKzMwsf2RnZ0d6lwC5gyPIHZxA7uAUsgcnkDs4gdzBKWQPAKom4hPc48aNU05OTvljy5Ytkd4lQO7gCHIHJ5A7OIXswQnkDk4gd3AK2QOAqon4LUq8Xq+8Xm+kdwMEIHdwArmDE8gdnEL24ARyByeQOziF7AGR4ZeRT8bpNlzB75LjFPF3cAMAAAAAAAAAEAlBv4N7//79Wr9+ffm/N2zYoNWrV6tu3bpq1qxZWJsDypA7OIHcwQnkDk4he3ACuYMTyB2cQvYAIDKCnuBeuXKlzjrrrPJ/jx07VpI0bNgwvfDCC2FrDDgcuYMTyB2cQO7gFLIHJ5A7OIHcwSlkDwAiI+gJ7jPPPFPGuOP+K4gf5A5OIHdwArmDU8genEDu4ARyB6eQPQCIDO7BDQAAAAAAAABwpaDfwR0uhXU8SvR6Qqpt226r9f4TLD8FdHDj1dY9rMprblV/bv1vrHv4viTfqv702t9b1RcklWqm1RaCk91vk5LSQvsU6m++bWq9/0bNf7Gqr5Hgs+7hgtRCq/qvi0utezgzwy67+/ypVvUH/PbHMRg/709Toj+03B1oan+8U3bYDfUlte2PV4nf7vepP+9Ps+4hLbPAqn74CR9Y1RfsL9VtVlsITpN6OUpKC+37fc2mLOv9p/TItaov/DTDuof8jnbjXVZykXUP/U76xKp+8Y7jrepL84u0xWoLwSvwJcnnqxFS7TWZa6z3/+Cu06zqG3bZad1DzuLGVvWZJ/1s3cP1x9mNWSlNS6zq8/N8GmK1heC82etZpaeHdq7xh2H/tbsdsKrfXZpu3YOvid2YVajQrlUOd/wpG6234SaDm36hlFqhXWetr9fIev+/FNtdE5+Xbf/z5O5iu+y+37CWdQ+5yclW9a07bLOqL80v0rePW20iaFf2+0AptUI7176yrrv1/r/u/YpV/TWlKdY9dKqz3aq+Vc3d1j3Mq9vRqn7rkmyrep9d9Ks1v4z8lvOC1YVbjhPv4AYAAAAAAAAAuBIT3AAAAAAAAAAAV2KCGwAAAAAAAADgSkxwAwAAAAAAAABcKagJ7kmTJqlHjx5KT09Xw4YNNXjwYH333XeR6g2QRO7gHLIHJ5A7OIHcwSlkD04gd3ACuQOAyAlqgvuDDz7Q8OHDtXz5ci1cuFAlJSXq37+/8vPzI9UfQO7gGLIHJ5A7OIHcwSlkD04gd3ACuQNih88YHkE83CApmJXnz58f8O8XXnhBDRs21KpVq3TGGWeEtTGgDLmDU8genEDu4ARyB6eQPTiB3MEJ5A4AIieoCe5fy8nJkSTVrVv3iOsUFRWpqKio/N+5ubk2uwTIHRxzrOyRO0QCuYMTONfCKYx5cAK5gxM41wJA+IT8IZN+v19jxoxRnz591KlTpyOuN2nSJGVmZpY/srOzQ90lQO7gmKpkj9wh3MgdnMC5Fk5hzIMTyB2cwLkWAMIr5Anu4cOHa82aNXrttdeOut64ceOUk5NT/tiyZUuouwTIHRxTleyRO4QbuYMTONfCKYx5cAK5gxM41wJAeIV0i5IRI0bo7bff1tKlS9W0adOjruv1euX1ekNqDjgcuYNTqpo9codwIndwAudaOIUxD04gd3AC51oACL+gJriNMRo5cqRmz56tJUuWqGXLlpHqCyhH7uAUsgcnkDs4gdzBKWQPTiB3cAK5A2KH//8eODa3HKegJriHDx+umTNnau7cuUpPT9eOHTskSZmZmapZs2ZEGgTIHZxC9uAEcgcnkDs4hezBCeQOTiB3ABA5Qd2De/r06crJydGZZ56pJk2alD9mzZoVqf4AcgfHkD04gdzBCeQOTiF7cAK5gxPIHQBETtC3KAGijdzBKWQPTiB3cAK5g1PIHpxA7uAEcgcAkRPSh0yGQ3HbAiWkOjfAN0nJsaqfs+Mk6x6+39bIqv6DGm2se/ipbR2r+gJfDav64v0lkj612kYwjk/fJW+t0Hq+sd8S6/1P23y2Vf3F9T637uH2HSdb1W/Ir2fdwxdbjv5hKsfStMFeq/rS/CJJX1ltIxgN0vcrKa0kpNrtvqD+0KZSJ3TcZVXfs85G6x7qJu23qk/w2J8vZm3tblX/bUETq/rigtAyEKr9xclKTEoOqfaijl9a779WYpFV/UcZra178OXWsqo/p+G31j00SMqzqv+ult21Qomn2Ko+FGv2ZCmxMLQPxBr48x+s939ive1W9dvXN7DuwdPI7m6FxXn2f6peYuwu81cdsLs3bNGBEknfW20jGIM/vkEJqSkh1V7c7gvr/b/5RVer+kl9/m3dgymxu2Yw9pccWrvZ7lw5vufbVvUF3lLNsdpCcFon71SqNzGk2hfXn2K9f7/xWNV/rcbWPTROtzvP+UtCO36HS9ltt40Nq4+zqvcXFlrVh2L5Ly2VVBTauXbaSa9a73/KL3bXafmloV2jHu5/G+3OU52PS7fuYWee3bVmQZNSq3p/gV09EE/CcBkDAAAAAAAAAED0OfYObgAAAAAAAACIJp+MfOK2QVXhluPEO7gBAAAAAAAAAK7EBDcAAAAAAAAAwJWCmuCePn26OnfurIyMDGVkZKh3796aN29epHoDJJE7OIfswQnkDk4gd3AK2YMTyB2cQO4AIHKCmuBu2rSpJk+erFWrVmnlypU6++yzdfHFF+vrr7+OVH8AuYNjyB6cQO7gBHIHp5A9OIHcwQnkDgAiJ6gPmRw0aFDAv//6179q+vTpWr58uTp27BjWxoAy5A5OIXtwArmDE8gdnEL24ARyByeQOwCInKAmuA/n8/n0+uuvKz8/X7179z7iekVFRSoqKir/d25ubqi7BMgdHFOV7JE7hBu5gxM418IpjHlwArmDEzjXAs7ymYMPHJtbjlPQHzL51VdfqVatWvJ6vbrxxhs1e/ZsdejQ4YjrT5o0SZmZmeWP7Oxsq4ZRPZE7OCWY7JE7hAu5gxM418IpjHlwArmDEzjXAkBkBD3BfcIJJ2j16tX65JNPdNNNN2nYsGFau3btEdcfN26ccnJyyh9btmyxahjVE7mDU4LJHrlDuJA7OIFzLZzCmAcnkDs4gXMtAERG0LcoSU5OVps2bSRJ3bp104oVK/T3v/9dTz/9dKXre71eeb1euy5R7ZE7OCWY7JE7hAu5gxM418IpjHlwArmDEzjXAkBkBP0O7l/z+/0B94QCooHcwSlkD04gd3ACuYNTyB6cQO7gBHIHAOER1Du4x40bp4EDB6pZs2bKy8vTzJkztWTJEi1YsCBS/QHkDo4he3ACuYMTyB2cQvbgBHIHJ5A7AIicoCa4d+3apT/84Q/avn27MjMz1blzZy1YsEDnnntupPoDyB0cQ/bgBHIHJ5A7OIXswQnkDk4gd0Ds8P/fA8fmluMU1AT3P/7xj0j1ARwRuYNTyB6cQO7gBHIHp5A9OIHcwQnkDgAix/oe3AAAAAAAAAAAOCGod3CHlef/HiG4qdkS690/89MZVvXtM3ZY9/DNd02t6vt3+8a6h0Y1cq3qu2ZstKrPT/LpWastBOfb3EZK8oX2KdTvbm5nvf86qQVW9bd8eJl1Dy2yd1vVb9pa37oHY+zqt+yuY1XvP1Bo10CQNm9oqISaKSHVeorsfw/5xf5sq/rk40ute/h8s10Pfl+IJ4zD7bb7BPofUxtb1fsLCiX922obwcj7rq4SUkLL3fzP61nvv+s531rV716SZd1DYWOfVf30bf2se0jJyreqL95Uy6reXxjd8U6Sfl5XL+TsJWfbHS9JWvJVZ6t6U9d+zEv+xe4SOyPd7npBkl7f3d2q/ty6a63qC5Ltj2MwGtTNVVJaaB/U9ubqrtb7T8mw+5C4pzb1te6hf+evreqXLDjJuoeMOvut6jcV2V1nFhWVWNUH66uCbKUk1gipNs1bbL3/Xz60uzZJ6bXHuoeaSXbHvH5Du59HJWnPAbufDWo322dV7zsQ/Q+JPLP+OqXUCu1cM+KLy633f1mbVVb1K79oY91D0za7rOoLfaF97x7u3OzvrOrf3GZ3rgZwCO/gBgAAAAAAAAC4EhPcAAAAAAAAAABXcu4WJQAAAAAAAAAQRX555Av1vsnVjN8lx4l3cAMAAAAAAAAAXMlqgnvy5MnyeDwaM2ZMmNoBjo3cwQnkDk4he3ACuYMTyB2cQvbgBHIHAOET8gT3ihUr9PTTT6tzZ7tPqgeCQe7gBHIHp5A9OIHcwQnkDk4he3ACuQOA8Appgnv//v268sor9eyzz6pOnTrh7gmoFLmDE8gdnEL24ARyByeQOziF7MEJ5A4Awi+kCe7hw4frggsuUL9+/Y65blFRkXJzcwMeQCjIHZxA7uCUqmaP3CGcGPPgBHIHp3CuhRMY8wAg/JKCLXjttdf02WefacWKFVVaf9KkSbr//vuDbgw4HLmDE8gdnBJM9sgdwoUxD04gd3AK51o4gTEPiA1+c/CBY3PLcQrqHdxbtmzR6NGj9corryglJaVKNePGjVNOTk75Y8uWLSE1iuqL3MEJ5A5OCTZ75A7hwJgHJ5A7OIVzLZzAmAcAkRPUO7hXrVqlXbt2qWvXruXLfD6fli5dqieeeEJFRUVKTEwMqPF6vfJ6veHpFtUSuYMTyB2cEmz2yB3CgTEPTiB3cArnWjiBMQ8AIieoCe5zzjlHX331VcCya665Ru3atdOdd95ZYTAGwoHcwQnkDk4he3ACuYMTyB2cQvbgBHIHAJET1AR3enq6OnXqFLAsLS1N9erVq7AcCBdyByeQOziF7MEJ5A5OIHdwCtmDE8gdAEROUPfgBgAAAAAAAAAgVgT1Du7KLFmyJAxtAMEhd3ACuYNTyB6cQO7gBHIHp5A9OIHcAc7wySOfPE634QpuOU7WE9yhalI/R0lphSHV/n3jOdb7T6tRbFX/5oru1j3I2JUv+PAk6xZWnrDHqv6l0p5W9b4DRZKmWG0jGOu/O04JNav2idW/ZjyWXzBJJbtrW9XX7Jhr3cOmbxtb1ddoWGDdQ8I3tazqC5sXWdX7i6N7f7vk3YlKTAltn/5k+/2f0vN7q/p1+xpY99Cikd1Y88PaLOseEkvtTsyJv9jlxl8Y3dyV1ilRQs3Q9plS74D1/vcV17Sqzzh9p3UP5n+NrOqL2tmPdzW9dtcbBRk+q3p/Dbv6UNRvu0eJaaF9IFZKUqn1/r3d91rVf7/OfrwpaRXaNW6ZnzfUte7hirNWWNW//FMvq/rS/CJJy622EYydG+qHfI2XVMfuukKSSn+wu7YZPOhD6x6e+OJMq3pfPfvx4pdtmVb1ma3szj+FYRhDgrFsTyslFYY23u380u4cJUmmtt3PJ0U/1LHuIbXnLqv6n3dlWPfg8dld4+V9Yzfm+gvtxvxQZCQeUM3E0KZzmmTa/0z5z7V28wAmxX68+fmjJlb1Wed9a93Dm5/azQt5SuxuqmBbD8QTvhsAAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIT3AAAAAAAAAAAVwpqgvu+++6Tx+MJeLRr1y5SvQGSyB2cQ/bgBHIHJ5A7OIXswQnkDk4gd0Ds8MnDI4iHGwT9sbsdO3bUokWLDm0gKbRP7gWCQe7gFLIHJ5A7OIHcwSlkD04gd3ACuQOAyAh6NE1KSlLjxo0j0QtwROQOTiF7cAK5gxPIHZxC9uAEcgcnkDsAiIyg78G9bt06ZWVlqVWrVrryyiu1efPmo65fVFSk3NzcgAcQLHIHpwSTPXKHcCF3cALnWjiFMQ9OIHdwAudaAIiMoCa4e/XqpRdeeEHz58/X9OnTtWHDBp1++unKy8s7Ys2kSZOUmZlZ/sjOzrZuGtULuYNTgs0euUM4kDs4gXMtnMKYByeQOziBcy0ARE5QE9wDBw7U0KFD1blzZw0YMEDvvPOO9u3bp3/9619HrBk3bpxycnLKH1u2bLFuGtULuYNTgs0euUM4kDs4gXMtnMKYByeQOziBcy0ARI7VJxrUrl1bxx9/vNavX3/Edbxer7xer81ugADkDk45VvbIHSKB3MEJnGvhFMY8OIHcwQmcawHn+I1HfuNxug1XcMtxCvoe3Ifbv3+/fvjhBzVp0iRc/QDHRO7gFLIHJ5A7OIHcwSlkD04gd3ACuQOA8Alqgvu2227TBx98oI0bN2rZsmX6zW9+o8TERF1++eWR6g8gd3AM2YMTyB2cQO7gFLIHJ5A7OIHcAUDkBHWLkp9++kmXX3659uzZowYNGui0007T8uXL1aBBg0j1B5A7OIbswQnkDk4gd3AK2YMTyB2cQO4AIHKCmuB+7bXXItUHcETkDk4he3ACuYMTyB2cQvbgBHIHJ5A7AIgcq3twAwAAAAAAAADglKDewR1OV2R/qpq1Qtv95uJ61vuv4fFZ1V93zofWPTz8Q3+r+mbpe617aFtrl1V9wxq5VvUF+0t1p9UWgnPPWXNCzt3sXSdb739c03es6v+9r7t1DyN7LrOqn5XXybqH1M7FVvWr9zezqi/eX6wZVlsITp2uu5WYFtqnn+cVpFjv//y6X1nVD2i61bqHU5ffYFWfUNcuM5KU/HVNq/qm52y2qi/NL9IGqy0Ep0Wz3UoKMXd1vAes9/9G60VW9Sd+coV1DwXNSuw2kFfDuoeE2nb1NdKLrOr9iXb1oRjW4uOQz7U/Fde13n+JSbSqP6nuT9Y9/Gt5T6v61Cb7rXuYu62LVf2w7I+t6gv2l8ruiiM4F/VcJW+t0L5n3/ikh/X+e5/+rVX99wcaW/fwZM9XrOpvnvNH6x7S2+6zqv96/3FW9cX77a8XgnGgJFlJJckh1dY8fp/1/vf/lGFVf1HvVdY9ZCYVWNW3OHmPdQ+vfm435vbo/oNVfUl+sTZabSF4PiXIF+L7Fdtn7rDe/868Wlb1/i1p1j2cdN43VvXr99W37mHS2a9b1Y9bPNSq3vj9VvXVmU8e+eRxug1XcMtx4h3cAAAAAAAAAABXYoIbAAAAAAAAAOBKTHADAAAAAAAAAFyJCW4AAAAAAAAAgCsFPcG9detW/f73v1e9evVUs2ZNnXjiiVq5cmUkegPKkTs4hezBCeQOTiB3cAK5g1PIHpxA7gAgMoL6iPu9e/eqT58+OuusszRv3jw1aNBA69atU506dSLVH0Du4BiyByeQOziB3MEJ5A5OIXtwArkDYodPCfJxU4sq8TndQBUFNcH9t7/9TdnZ2ZoxY0b5spYtW4a9KeBw5A5OIXtwArmDE8gdnEDu4BSyByeQOwCInKB+XfHWW2+pe/fuGjp0qBo2bKiTTz5Zzz777FFrioqKlJubG/AAgkHu4JRgs0fuEA7kDk7gXAsnkDs4hXMtnMCYBwCRE9QE948//qjp06erbdu2WrBggW666SaNGjVKL7744hFrJk2apMzMzPJHdna2ddOoXsgdnBJs9sgdwoHcwQmca+EEcgencK6FExjzACBygprg9vv96tq1qyZOnKiTTz5Z119/vf70pz/pqaeeOmLNuHHjlJOTU/7YsmWLddOoXsgdnBJs9sgdwoHcwQmca+EEcgencK6FExjzACBygprgbtKkiTp06BCwrH379tq8efMRa7xerzIyMgIeQDDIHZwSbPbIHcKB3MEJnGvhBHIHp3CuhRMY8wAgcoL6kMk+ffrou+++C1j2/fffq3nz5mFtCjgcuYNTyB6cQO7gBHIHJ5A7OIXswQnkDogdxnjkNx6n23AF45LjFNQ7uG+55RYtX75cEydO1Pr16zVz5kw988wzGj58eKT6A8gdHEP24ARyByeQOziB3MEpZA9OIHcAEDlBTXD36NFDs2fP1quvvqpOnTrpgQce0NSpU3XllVdGqj+A3MExZA9OIHdwArmDE8gdnEL24ARyBwCRE9QtSiTpwgsv1IUXXhiJXoAjIndwCtmDE8gdnEDu4ARyB6eQPTiB3AFAZAQ9wR0u/2/tWUpMTQmptmhnqvX+b+j7vlX9xO8HWvdwc+sPrOr/8qn9ifHkrkf+QIuqeHPbyVb1pflFkj602kYwXt3aU0lp3pBqfz5gn7spCedZ1XfL3GTdw2/WXG1V37OhfQ8f/NTGqn5c+/lW9QcSfJphtYXgeDxGCR4TUm2Hhjus939Z+l6r+qWF9tm/7PhVVvUvLjnDuodTLvrSqj6nJLRzVpmSkmKr+mD9tDpLCSmh9Vyvz/fW+5/48wlW9Wdlr7PuYeEXPazq03vstu6hca08q/oH2s21qj+Q59NQqy0Eb8pH5yuhZmjZS8qw/z4Z1mm5Vf2+Ivsx78reH1vVr9hjfz/WBe3ftqp/9JdWVvWFpaVW9cFauLmdElNDu8bz1PRZ73/N7sZW9V/2fNW6h1fy6lnVPzholnUPT2w4y6r+3DprrOoPJPn0stUWglMruUhJyaHVbl9tlxlJyuqy06o+M6nAuof7G3xtVf+HTfbXeB1bbbWq/9ry+9d3oMiqPhT/3XmikvaHNuZ9821T6/0P6bXCqv7jlJbWPdROtsvvmyfa/0R44492V1lnn7TWqr54f7FmWm0BiB9B3aIEAAAAAAAAAIBY4dg7uAEAAAAAAAAgmnzyyCeP0224gluOE+/gBgAAAAAAAAC4EhPcAAAAAAAAAABXCmqCu0WLFvJ4PBUew4cPj1R/gCSyB2eQOziB3MEJ5A5OIXtwArmDE8gdAEROUPfgXrFihXy+Q58yvmbNGp177rkaOtTuk2OBYyF7cAK5gxPIHZxA7uAUsgcnkDs4gdwBQOQENcHdoEGDgH9PnjxZrVu3Vt++fcPaFPBrZA9OIHdwArmDE8gdnEL24ARyByeQOwCInKAmuA9XXFysl19+WWPHjpXHc+RP1CwqKlJRUVH5v3Nzc0PdJSCpatkjdwg3cgcnkDs4gWs8OIUxD04gd3AC51rAWT6TIJ/hYwmrwmec7qBqQv5qzpkzR/v27dPVV1991PUmTZqkzMzM8kd2dnaouwQkVS175A7hRu7gBHIHJ3CNB6cw5sEJ5A5O4FwLAOEV8gT3P/7xDw0cOFBZWVlHXW/cuHHKyckpf2zZsiXUXQKSqpY9codwI3dwArmDE7jGg1MY8+AEcgcncK4FgPAK6RYlmzZt0qJFi/Tmm28ec12v1yuv1xvKboAKqpo9codwIndwArmDE7jGg1MY8+AEcgcncK4FgPAL6R3cM2bMUMOGDXXBBReEux/gqMgenEDu4ARyByeQOziF7MEJ5A5OIHcAEH5BT3D7/X7NmDFDw4YNU1JSyJ9RCQSN7MEJ5A5OIHdwArmDU8genEDu4ARyBwCREfSIumjRIm3evFnXXnttJPoBjojswQnkDk4gd3ACuYNTyB6cQO7gBHIHxAa/PPKH/rGE1YpfxukWqiToCe7+/fvLGHe8OMQXsgcnkDs4gdzBCeQOTiF7cAK5gxPIHQBERtT/JqZsMPcXFIW8DX+B/W9ZCveXWNX7DoTef5mC/aVW9f6CQuseCi17KM23Ow6lB4olKeIn+bLtl+0vFL6CROs+Sryh71+SChPtvl6S5LP8mhVbfu9I9t8/B/b7rOoL/q8+Wrmzeb0lHrvMSFJunt+qPt9+qFGRZW7CMd4V77c7liWldueekvzojnf+wtCPWVmvNgoT7L7mxcVhGGssjoEUnnO97ffwgTy78e5AlMa7w/dhkz1/UhiyZzneFBfZZ6+oht02bK+vJPux3/YasazeDedaf4F9H75ku6+Z7ddLsv/ZIiEM79Cyza7tmBftazybny1sxsoytsfb9vpMknJT7LIbjmuOkqIaVvW25/uy+miea62yF4bratvshOM8V2z5s3Veqv24a5vf4lLLn0/yD34d+KUJIHlMlL8TfvrpJ2VnZ0dzl3CBLVu2qGnTphHbPrlDZcgdnEDu4IRI504ie6gcYx6cQO7gBM61cEo0shcvcnNzlZmZqf9+2Upp6fZvYqwO8vN8uqDzj8rJyVFGRobT7RxR1Ce4/X6/tm3bpvT0dHk8ngrP5+bmKjs7W1u2bAnpwNnW00N0ezDGKC8vT1lZWUpIiNz9jyKdu3Bsgx6i1wO5owcneoiV3FWl12OpLl+zeOghWrmTGPPcUh+tHmJlzHPL8aKH8GwjVnJXlV6Ppbp8zeKhh3g617rheNPDIdHMXrxggjt4oU5wT5s2TVOmTNGOHTvUpUsXPf744+rZs+cR1586daqmT5+uzZs3q379+hoyZIgmTZqklJSUKu0v6rcoSUhIqNJvljIyMqx+M2BbTw/R6yEzMzPkbVdVtHIXjm3QQ3R6IHf04EQPsZQ7KfaPFz2Epz4auZMY89xWH40eYmnMc8PxoofwbCOWcifF/vGih/DUx9u5NtaPNz0cEq3sAcGYNWuWxo4dq6eeekq9evXS1KlTNWDAAH333Xdq2LBhhfVnzpypu+66S88//7xOPfVUff/997r66qvl8Xj06KOPVmmfUZ/gBgAAAAAAAAAn+OSRT5X/BQ4ChXKcHn30Uf3pT3/SNddcI0l66qmn9N///lfPP/+87rrrrgrrL1u2TH369NEVV1whSWrRooUuv/xyffLJJ1XeJ3/DAAAAAAAAAACoVG5ubsCjqKjyD4stLi7WqlWr1K9fv/JlCQkJ6tevnz7++ONKa0499VStWrVKn376qSTpxx9/1DvvvKPzzz+/yv3F3AS31+vVhAkT5PV6Hamnh9jqIVri5XjRQ/i2EQ2x8FrpIXZ6iKZ4OF70EL4eoiVejpfTPcTDa4imeDle9BC+bURLPBwveghfD9ESC6+VHmKnByCcsrOzlZmZWf6YNGlSpev9/PPP8vl8atSoUcDyRo0aaceOHZXWXHHFFfrLX/6i0047TTVq1FDr1q115pln6u67765yf1H/kEkAAAAAAAAAiKayD5l868vWfMhkFeXn+XRR5x8qfOCp1+ut9Bcw27Zt03HHHadly5apd+/e5cvvuOMOffDBB5XedmTJkiW67LLL9OCDD6pXr15av369Ro8erT/96U+69957q9Qn9+AGAAAAAAAAAFSqqh+YWr9+fSUmJmrnzp0By3fu3KnGjRtXWnPvvffqqquu0nXXXSdJOvHEE5Wfn6/rr79ef/7zn5WQcOwbkMTcLUoAAAAAAAAAAO6SnJysbt266b333itf5vf79d577wW8o/twBw4cqDCJnZh48B32Vb3xCO/gBgAAAAAAAFAt+EyCfIb3/FaFL4Q7W48dO1bDhg1T9+7d1bNnT02dOlX5+fm65pprJEl/+MMfdNxxx5Xfx3vQoEF69NFHdfLJJ5ffouTee+/VoEGDyie6j4UJbgAAAAAAAACAtUsvvVS7d+/W+PHjtWPHDp100kmaP39++QdPbt68OeAd2/fcc488Ho/uuecebd26VQ0aNNCgQYP017/+tcr75EMmAQAAAAAAAMS1sg+ZnP1FWz5ksory83z6TZd1ysnJqdI9uJ3C+/EBAAAAAAAAAK7EBDcAAAAAAAAAwJWY4AYAAAAAAAAAuBIfMgkAAAAAAACgWvDLI788TrfhCm45TryDGwAAAAAAAADgSkxwAwAAAAAAAABciQluAAAAAAAAAIArxfUE94oVK3TqqacqLS1NHo9Hq1evdrqlY3rooYfUrl07+f3+qO/7rrvuUq9evaK+33hD7oLz1FNPqVmzZioqKor6vuMJuQsOuQsfshccshce5C44XOOFB7kLDrkLH7IXHLIXHuQuOOQOcFbcTnCXlJRo6NCh+uWXX/TYY4/ppZdeUvPmzZ1u66hyc3P1t7/9TXfeeacSEg59aWbNmqXf//73atu2rTwej84888ygt/3WW2+pa9euSklJUbNmzTRhwgSVlpYGrDNmzBh98cUXeuutt2xfSrVF7g6pav3VV1+t4uJiPf300xavonojdwft2bNHU6ZM0RlnnKEGDRqodu3aOuWUUzRr1qwK65K78CB7h9xyyy3q2rWr6tatq9TUVLVv31733Xef9u/fH7Ae2bNH7ir3ww8/KCUlRR6PRytXrgx4jms8e+TukBYtWsjj8VR43HjjjQHrkbvwIHuB8vLydMcdd6hly5byer067rjjNGTIEB04cKB8HbJnj9wdtGTJkkrHu7LHX//61/J1yR3grCSnG4iUH374QZs2bdKzzz6r6667zul2quT5559XaWmpLr/88oDl06dP16pVq9SjRw/t2bMn6O3OmzdPgwcP1plnnqnHH39cX331lR588EHt2rVL06dPL1+vcePGuvjii/Xwww/roosusn491RG5C74+JSVFw4YN06OPPqqRI0fK43HHJ/TGEnJ30Mcff6w///nPOv/883XPPfcoKSlJ//73v3XZZZdp7dq1uv/++8vXJXfhQfYOWbFihU4//XRdc801SklJ0eeff67Jkydr0aJFWrp0afkPWmTPHrmr3C233KKkpKRK/zqAazx75C7QSSedpFtvvTVg2fHHHx/wb3IXHmTvkJycHPXt21c//fSTrr/+erVp00a7d+/Whx9+qKKiIqWmpkoie+FA7g5q3769XnrppQrLX3rpJb377rvq379/+TJy5y5+JcgXv+/5DSu/jNMtVEncTnDv2rVLklS7du1jrpufn6+0tLQId3RsM2bM0EUXXaSUlJSA5S+99JKOO+44JSQkqFOnTkFv97bbblPnzp317rvvKinp4Jc8IyNDEydO1OjRo9WuXbvydS+55BINHTpUP/74o1q1amX3gqohchda/SWXXKKHHnpIixcv1tlnnx30vqo7cndQx44dtW7duoB3l9x8883q16+f/va3v+mOO+4IeO3kzh7ZO+Sjjz6qsKx169a67bbb9Omnn+qUU04pX0727JC7ihYsWKAFCxbojjvu0IMPPljpOlzj2SF3gY477jj9/ve/P+Z65M4e2Ttk3Lhx2rRpkz777DO1bNmyfPmdd95ZYV2yZ4fcHdSoUaNKx7r7779fbdu2VY8ePQKWkzvAOXH564qrr75affv2lSQNHTo04M9Qrr76atWqVUs//PCDzj//fKWnp+vKK6+UdHBgvvXWW5WdnS2v16sTTjhBDz/8sIwJ/G2Fx+PRiBEj9Prrr6tDhw6qWbOmevfura+++kqS9PTTT6tNmzZKSUnRmWeeqY0bNx6z5w0bNujLL79Uv379KjyXnZ0d8Cc2wVi7dq3Wrl2r66+/vnxyWzo46WOM0RtvvBGwftn+586dG9L+qjNyF3p9t27dVLduXXIXAnJ3SMuWLSv86aTH49HgwYNVVFSkH3/8MeA5cmeH7B1bixYtJEn79u0LWE72QkfuKiopKdHo0aM1evRotW7d+ojrcY0XOnJXueLiYuXn5x91HXJnh+wdsm/fPs2YMUPXX3+9WrZsqeLi4qN+ngXZCx25O7pPP/1U69evL3/dhyN3gHPi8h3cN9xwg4477jhNnDhRo0aNUo8ePdSoUaPy50tLSzVgwACddtppevjhh5WamipjjC666CItXrxYf/zjH3XSSSdpwYIFuv3227V161Y99thjAfv48MMP9dZbb2n48OGSpEmTJunCCy/UHXfcoSeffFI333yz9u7dq4ceekjXXnut3n///aP2vGzZMklS165dw3osPv/8c0lS9+7dA5ZnZWWpadOm5c+XyczMVOvWrfW///1Pt9xyS1h7iXfkzk7Xrl31v//9z+k2XIfcHduOHTskSfXr16/wHLkLHdmrqLS0VPv27VNxcbHWrFmje+65R+np6erZs2eFdcleaMhdRVOnTtXevXt1zz336M033zzielzjhY7cVfT+++8rNTVVPp9PzZs31y233KLRo0dXWI/c2SF7h3z00UcqLCxUmzZtNGTIEM2ZM0d+v1+9e/fWtGnTdNJJJwWsT/ZCR+6O7pVXXpGkSie4yR3gIBOnFi9ebCSZ119/PWD5sGHDjCRz1113BSyfM2eOkWQefPDBgOVDhgwxHo/HrF+/vnyZJOP1es2GDRvKlz399NNGkmncuLHJzc0tXz5u3DgjKWDdytxzzz1GksnLyzvqeh07djR9+/Y96jqHmzJlipFkNm/eXOG5Hj16mFNOOaXC8v79+5v27dtXeR84hNyFXn/99debmjVrhryP6ozcHdmePXtMw4YNzemnn17p8+TODtkL9PHHHxtJ5Y8TTjjBLF68uNJ1yV7oyN0h27dvN+np6ebpp582xhgzY8YMI8msWLGi0vW5xgsduTtk0KBB5m9/+5uZM2eO+cc//mFOP/10I8nccccdla5P7uyQvYMeffRRI8nUq1fP9OzZ07zyyivmySefNI0aNTJ16tQx27Ztq1BD9kJH7ipXWlpqGjVqZHr27HnEdchdbMvJyTmY7S/amf/+2JFHFR6vf9HOSDI5OTlOf/mOKi5vUVIVN910U8C/33nnHSUmJmrUqFEBy2+99VYZYzRv3ryA5eecc075nx5LUq9evSRJv/vd75Senl5h+a//NP7X9uzZo6SkJNWqVSvo13I0BQUFkiSv11vhuZSUlPLnD1enTh39/PPPYe0DB1WX3IWiTp06KigoCPgEdIRHdc2d3+/XlVdeqX379unxxx+vdB1yF1nVLXsdOnTQwoULNWfOnPJ7vu/fv7/Sdcle5FSn3N15551q1apVlT8AjGu8yKlOuXvrrbd0xx136OKLL9a1116rDz74QAMGDNCjjz6qn376qcL65C6yqkv2ys6nHo9H7733nq644grddNNNmjNnjvbu3atp06ZVqCF7kVNdcvdr7733nnbu3Fnpu7fLkDvAGXF5i5JjSUpKUtOmTQOWbdq0SVlZWQGDqXTwU3PLnj9cs2bNAv6dmZkp6eD9nSpbvnfvXvvGQ1CzZk1JqvT+ZIWFheXPH84YI4/HE/HeqpvqlLtQmP+7NxvZC6/qnLuRI0dq/vz5+uc//6kuXbpUug65i5zqmL2MjIzyey9efPHFmjlzpi6++GJ99tlnFTJI9iKjOuVu+fLleumll/Tee+9V+d6iXONFRnXKXWU8Ho9uueUWLViwQEuWLKnwgWzkLnKqU/bKfm4dNGhQwCTmKaecopYtW5bfouJwZC8yqlPufu2VV15RYmKiLr300iOuQ+7cwWcS5Ku+7/kNiu9X99GPVdXyq+n1eq0/ZCAxMTGo5eYYgahXr55KS0uVl5dn1devNWnSRJK0ffv2Cs9t375dWVlZFZbv3bu30nvVwk51yl0o9u7dq9TU1Ep/6YLQVdfc3X///XryySc1efJkXXXVVUdcj9xFTnXN3uF++9vfSpJee+21Cs+RvcioTrm74447dPrpp6tly5bauHGjNm7cWP6Ose3bt2vz5s0VarjGi4zqlLsjKZuU+uWXXyo8R+4ipzplr+zn1sPvBV2mYcOGlU6Akr3IqE65O1xBQYFmz56tfv36VZrDMuQOcEa1nOCuTPPmzbVt27YKA+K3335b/nwktWvXTtLBT/8Np7IP21i5cmXA8m3btumnn36q8GEcZT2U/aYVkRWvuQsFuYueeM/dtGnTdN9992nMmDG68847j7ouuYuueM/erxUVFcnv9ysnJ6fCc2QveuI1d5s3b9bSpUvVsmXL8sftt98uSbrooovUuXPnCjXkLnriNXdHUnb7gAYNGlR4jtxFV7xmr1u3bpKkrVu3Vnhu27ZtZM9h8Zq7w7311lvKy8s76u1Jynogd0D0McH9f84//3z5fD498cQTAcsfe+wxeTweDRw4MKL77927t6SKE9G2OnbsqHbt2umZZ56Rz+crXz59+nR5PB4NGTIkYP2cnBz98MMPOvXUU8PaByoXr7kLxWeffUbuoiSeczdr1iyNGjVKV155pR599NFjrk/uoites7dv3z6VlJRUWP7cc89Jkrp3717hObIXPfGau2eeeUazZ88OeIwcOVKS9PDDD+uVV14JWJ9rvOiK19z98ssvAT9TSFJJSYkmT56s5ORknXXWWQHPkbvoi9fsnXDCCerSpYvmzp0bcH/jd999V1u2bNG5554bsD7Zi654zd3hZs6cqdTUVP3mN7854jrkDnBOtbwHd2UGDRqks846S3/+85+1ceNGdenSRe+++67mzp2rMWPGqHXr1hHdf6tWrdSpUyctWrRI1157bcBzS5cu1dKlSyVJu3fvVn5+vh588EFJ0hlnnKEzzjijfF2Px6O+fftqyZIl5cumTJmiiy66SP3799dll12mNWvW6IknntB1111X4TeLixYtkjFGF198cYReKQ4Xz7kLpn7VqlX65ZdfyF2UxGvuPv30U/3hD39QvXr1dM4551SY3Dn11FPVqlWr8n+Tu+iL1+wtWbJEo0aN0pAhQ9S2bVsVFxfrww8/1Jtvvqnu3btXuB8t2YuueM1d//79K+xr3759kqS+fftW+MUK13jRFa+5e+utt/Tggw9qyJAhatmypX755RfNnDlTa9as0cSJE9W4ceOAfZG76IvX7EkHJ0vPPfdcnXbaabrhhhuUk5OjRx99VMcff3yFDz0ke9EVz7mTDv5yb968efrd73531A+yJHeAc5jg/j8JCQl66623NH78eM2aNUszZsxQixYtNGXKFN16661R6eHaa6/V+PHjVVBQEHBPzvfff1/3339/wLr33nuvJGnChAnlA3LZJ0uX3Xe7zIUXXqg333xT999/v0aOHKkGDRro7rvv1vjx4yv08Prrr+u0006L+AkIB8Vz7qpaLx3MXbNmzXT22WeH6VXhaOI1d2vXrlVxcbF2795d4cJWkmbMmBEwwU3uoi9es3fiiSfqrLPO0ty5c7V9+3YZY9S6dWuNHz9et99+u5KTkwO2S/aiK15zFyyu8aIrXnN34oknqkOHDnr55Ze1e/duJScn66STTtK//vUvDR06tEIP5C764jV7knTWWWdp/vz5uvfee3X33XcrNTVVgwcP1kMPPVRh0pHsRVc85046mKeSkhJdccUVR+2B3AHO8Zhj3a0fUZOTk6NWrVrpoYce0h//+Meg69955x1deOGF+uKLL3TiiScGXb9jxw61bNlSr732Gr9xrEaczl1RUZFatGihu+66S6NHjw66Hu5E7uAUsgcnOJ07rvGqJ3IHp5A9OIHcoSpyc3OVmZmpmas7KTW98g81RaADeT5dcdIa5eTkKCMjw+l2joh7cMeQzMxM3XHHHZoyZYr8fn/Q9YsXL9Zll10W0mAsSVOnTtWJJ57IYFzNOJ27GTNmqEaNGrrxxhtDqoc7kTs4hezBCU7njmu86oncwSlkD04gd0D1xju4AQAAAAAAAMQ13sEdPN7BDQAAAAAAAABABDHBDQAAAAAAAABwJSa4AQAAAAAAAACulOR0AwAAAAAAAAAQDT7jkc94nG7DFdxynHgHNwAAAAAAAADAlZjgBgAAAAAAAAC4EhPcAAAAAAAAAABXiqkJ7mnTpqlFixZKSUlRr1699Omnn1a5dunSpRo0aJCysrLk8Xg0Z86coPY9adIk9ejRQ+np6WrYsKEGDx6s7777LqhtTJ8+XZ07d1ZGRoYyMjLUu3dvzZs3L6htHG7y5MnyeDwaM2ZMlWvuu+8+eTyegEe7du2C2u/WrVv1+9//XvXq1VPNmjV14oknauXKlVWub9GiRYUePB6Phg8fHlQf0eTm7MVL7iS77JG7OUHtmzHvkOo25pG7QOQuetycvXjJncS5tjrnTgo+e7GQO8l92XNz7qT4GfPIXdVzJzmfPXJ3kNtyB8SKmJngnjVrlsaOHasJEybos88+U5cuXTRgwADt2rWrSvX5+fnq0qWLpk2bFtL+P/jgAw0fPlzLly/XwoULVVJSov79+ys/P7/K22jatKkmT56sVatWaeXKlTr77LN18cUX6+uvvw66nxUrVujpp59W586dg67t2LGjtm/fXv746KOPqly7d+9e9enTRzVq1NC8efO0du1aPfLII6pTp05QvR++/4ULF0qShg4dGvRriQa3Zy8ecifZZ4/cBYcx76DqNuaRu0DkLnrcnr14yJ3EubY6504KPXtO566sd7dkz+25k+JjzCN3weVOcj575O5Q727JHRBTTIzo2bOnGT58ePm/fT6fycrKMpMmTQp6W5LM7NmzrfrZtWuXkWQ++OADq+3UqVPHPPfcc0HV5OXlmbZt25qFCxeavn37mtGjR1e5dsKECaZLly7BNXmYO++805x22mkh11dm9OjRpnXr1sbv94d1u+ESj9lzW+6MCX/2yF1wGPPCJ5azR+4OIXfRFY/Zc1vujOFcW11zZ0zo2YvF3BkT29mLx9wZ474xj9yFnjtjYid75C62c+dGOTk5RpJ54fMu5l/ru/KowuOFz7sYSSYnJ8fpL99RxcQ7uIuLi7Vq1Sr169evfFlCQoL69eunjz/+2JGecnJyJEl169YNqd7n8+m1115Tfn6+evfuHVTt8OHDdcEFFwQcj2CsW7dOWVlZatWqla688kpt3ry5yrVvvfWWunfvrqFDh6phw4Y6+eST9eyzz4bUh3Twa/vyyy/r2muvlcfjCXk7kRJv2XNr7qTwZo/cBY8xL/7HPHIXiNxFT7xlz625kzjXVtfcSXbZi6XcSbGdvXjLneTeMY/cOZs7qXqea6tT7oBYExMT3D///LN8Pp8aNWoUsLxRo0basWNH1Pvx+/0aM2aM+vTpo06dOgVV+9VXX6lWrVryer268cYbNXv2bHXo0KHK9a+99po+++wzTZo0Kdi2JUm9evXSCy+8oPnz52v69OnasGGDTj/9dOXl5VWp/scff9T06dPVtm1bLViwQDfddJNGjRqlF198MaR+5syZo3379unqq68OqT7S4iV7bs+dFN7skbvgMOZVjzGP3B1C7qIrXrLn9txJnGul6pc7yS57sZY7KbazFy+5k9w/5pE753InVd9zbXXKHRBrkpxuIBYNHz5ca9asCfr+cpJ0wgknaPXq1crJydEbb7yhYcOG6YMPPqjSoLxlyxaNHj1aCxcuVEpKSiita+DAgeX/3blzZ/Xq1UvNmzfXv/71L/3xj388Zr3f71f37t01ceJESdLJJ5+sNWvW6KmnntKwYcOC7ucf//iHBg4cqKysrKBrq6NQs+f23EnhzR65Cw5jHmOeE8gduXMK51rOtU5wIneSffZiLXcS2QsG51py55Tqeq4ld4BzYuId3PXr11diYqJ27twZsHznzp1q3LhxVHsZMWKE3n77bS1evFhNmzYNuj45OVlt2rRRt27dNGnSJHXp0kV///vfq1S7atUq7dq1S127dlVSUpKSkpL0wQcf6P/9v/+npKQk+Xy+oPupXbu2jj/+eK1fv75K6zdp0qTCyaN9+/ZB/ymiJG3atEmLFi3SddddF3RttMRL9tyeOyl82SN3wWHMqz5jHrk7iNxFX7xkz+25kzjXStUrd1L4s+dk7qTYz1685E5y/5hH7pzJnVS9z7XVKXdArImJCe7k5GR169ZN7733Xvkyv9+v9957L6R7zIXCGKMRI0Zo9uzZev/999WyZcuwbNfv96uoqKhK655zzjn66quvtHr16vJH9+7ddeWVV2r16tVKTEwMev/79+/XDz/8oCZNmlRp/T59+ui7774LWPb999+refPmQe97xowZatiwoS644IKga6MlXrPnttxJ4cseuasaxryDqtOYR+4OInfRF6/Zc1vuJM611S13Uviz52TupNjPXrzmTnLfmEfuops7yfkxj9wB1VvM3KJk7NixGjZsmLp3766ePXtq6tSpys/P1zXXXFOl+v379wf8Vm3Dhg1avXq16tatq2bNmh2zfvjw4Zo5c6bmzp2r9PT08ntVZWZmqmbNmlXqYdy4cRo4cKCaNWumvLw8zZw5U0uWLNGCBQuqVJ+enl7h/lRpaWmqV69ele9bddttt2nQoEFq3ry5tm3bpgkTJigxMVGXX355lepvueUWnXrqqZo4caIuueQSffrpp3rmmWf0zDPPVKm+jN/v14wZMzRs2DAlJcVMzCrl9uzFQ+6k8GSP3DHmMeYdHbkjd05xe/biIXcS59rqljvJPnuxkjvJPdlze+6k+BjzyF1wuZOczx65O8QtuXMzv0mQ38TEe35jnt8Yp1uoGhNDHn/8cdOsWTOTnJxsevbsaZYvX17l2sWLFxtJFR7Dhg2rUn1ltZLMjBkzqtzDtddea5o3b26Sk5NNgwYNzDnnnGPefffdKtdXpm/fvmb06NFVXv/SSy81TZo0McnJyea4444zl156qVm/fn1Q+/zPf/5jOnXqZLxer2nXrp155plnguzamAULFhhJ5rvvvgu61gluzl685M4Y++yRO8Y8xrxjI3cVkbvocHP24iV3xnCure65Mya47MVK7oxxV/bcnDtj4mfMI3dVz50xzmeP3B3ipty5TU5OjpFknv/sZPPauu48qvB4/rOTjSSTk5Pj9JfvqDzGuGUqHgAAAAAAAACCl5ubq8zMTD3/2clKTQ/+tjXV0YE8n67t+rlycnKUkZHhdDtHxPvxAQAAAAAAAACuxAQ3AAAAAAAAAMCVmOAGAAAAAAAAALgSH8cKAAAAAAAAoFrwKUE+3vNbJT6546Mb+WoCAAAAAAAAAFyJCW4AAAAAAAAAgCvF3AR3UVGR7rvvPhUVFTlSTw+x1UO0xMvxoofwbSMaYuG10kPs9BBN8XC86CF8PURLvBwvp3uIh9cQTfFyvOghfNuIlng4XvQQvh6iJRZeKz3ETg9AdeIxxsTUzVRyc3OVmZmpnJwcZWRkRL2eHmKrh2iJl+NFD+HbRjTEwmulh9jpIZri4XjRQ/h6iJZ4OV5O9xAPryGa4uV40UP4thEt8XC86CF8PURLLLxWeoidHlBR2XF99rNuSk1PdLodVziQ59Ofuq6K+SzG3Du4AQAAAAAAAACoiiSnGwAAAAAAAACAaPBL8hmP0224gt/pBqoo6hPcfr9f27ZtU3p6ujyeimHKzc0N+P9g2dbTQ3R7MMYoLy9PWVlZSkiI3B8URDp34dgGPUSvB3JHD070ECu5q0qvx1Jdvmbx0EO0cicx5rmlPlo9xMqY55bjRQ/h2Uas5K4qvR5LdfmaxUMP8XSudcPxpodDopk9INZF/R7cP/30k7Kzs6O5S7jAli1b1LRp04htn9yhMuQOTiB3cEKkcyeRPVSOMQ9OIHdwAudaOCUa2YsXubkH78H99GfdVLMWN7WoioL9pbrBBffgjvpXMz09XZLU/qp7lZicEtI2StLt/4zg5EFfW9Wvz6lv3cNZjddZ1c/+obN1D50bb7eqX7WirVW9v7BQW/7yYHkuIqVs+03vu0cJKaHlruZ2+9+Ilqba1fcfuMK6hyxvjlV9RuIB6x4eWXShVf2pPb6xqi/JL9G/L/pX1HLX741hSkpLDmkb33/cwrqPGvvsxszSNOsWdN8lr1rVj189yLqH/q2/s6r3W/4JW3F+iV48f27UcnfKa39SUmpouavtLbDu44svWlrVZ6y3/9CX/c3t/qDumn6LrXv4YLfdebLEb3ccSg8Ua/llz0Y8d9Kh7N2w4Hwlp9UIaRsnpW6y7mPeL3bXR6sXtrPuIbHIrr6wvv37T07oZncs1++0u9b1FxRp402PRG3MO+mlm5SY6g1pG9e3/NC6j9k7u1rV+2X/8836/zW3qvfuse9hf0ufVX1iPbtvHn9BkTaPmBK13L3zcROl1QrtZ4RHtve37uOLzXYTWgkJ9n943qSe3c8WOz/Osu4hOfQ32UqSSmva1fuKCvXjE3+J6rn2j/MuDPlc+6d6/7Pu4w9r/mBVn5ZcbN1DTmFoP9eXGdR8jXUP/377NKv6pEK7/fuKCvXDtOhkD4h1UZ/gLvszmsTklJAnuP1e+4uv5Fqh/dBfJqk0tAvow3lrhXZCKpOYajegS1KNECfdyoQ6WfxrR/rTvnAp235CSkrIPSd67Se4jeXhss2MJKV47b7taybaDxu2ubH9/i0TrdwlpSWH/L0Wju+xRMsx0za3kqw/oTohDONdsuX3j+0Ed5mo5S41WUlpoZ2ranjtJigkKaGm3dcsMdl+gjshxe4H95QwvKsj6YDd9YKxnOAuE+ncHb6P5LQaIZ+vUtPsX2+NIrtzRKI3DOOuZX1Civ0Et/U1XhjGXSl6Y15iqleJIY554XgHV439dsc7HBPcttcMttcLkpRQ0+78kZDqrnNtWq0E1UoP7WeEGrn217O236fhmOBOSrOboQvLmGv5o7mx/9FeknvOtaFm9nCh/kKxTFIYxpvEBLsewvGzdaLtuBum+ylEI3tArOMmPQAAAAAAAAAAVwppgnvatGlq0aKFUlJS1KtXL3366afh7guogNzBKWQPTiB3cAK5gxPIHZxC9uAEcgc4z68EHkE83CDoLmfNmqWxY8dqwoQJ+uyzz9SlSxcNGDBAu3btikR/gCRyB+eQPTiB3MEJ5A5OIHdwCtmDE8gdAERG0BPcjz76qP70pz/pmmuuUYcOHfTUU08pNTVVzz//fCT6AySROziH7MEJ5A5OIHdwArmDU8genEDuACAygprgLi4u1qpVq9SvX79DG0hIUL9+/fTxxx9XWlNUVKTc3NyABxAMcgenBJs9codwIHdwAudaOIHcwSmca+EExjwAiJygJrh//vln+Xw+NWrUKGB5o0aNtGPHjkprJk2apMzMzPJHdnZ26N2iWiJ3cEqw2SN3CAdyBydwroUTyB2cwrkWTmDMA4DIifidwseNG6ecnJzyx5YtWyK9S4DcwRHkDk4gd3AK2YMTyB2cQO7gFLIHAFWTFMzK9evXV2Jionbu3BmwfOfOnWrcuHGlNV6vV16vN/QOUe2ROzgl2OyRO4QDuYMTONfCCeQOTuFcCycw5gGxw2cS5DMRf89vXHDLcQqqy+TkZHXr1k3vvfde+TK/36/33ntPvXv3DntzgETu4ByyByeQOziB3MEJ5A5OIXtwArkDgMgJ6h3ckjR27FgNGzZM3bt3V8+ePTV16lTl5+frmmuuiUR/gCRyB+eQPTiB3MEJ5A5OIHdwCtmDE8gdAERG0BPcl156qXbv3q3x48drx44dOumkkzR//vwKH5QAhBO5g1PIHpxA7uAEcgcnkDs4hezBCeQOACIj6AluSRoxYoRGjBgR7l6AoyJ3cArZgxPIHZxA7uAEcgenkD04gdwBQPi5407hAAAAAAAAAAD8Skjv4A6H+v/4VEmeGiHVbpho/wEMS5d3tKpPPi7fuocF/vZW9R6Pse6hba1dVvW/nJxqVV+aX6RNVlsITlKeR4klnpBqs6Yss97/5vtOtaqf/VFP6x4mD3zVqv6NXd2te0hrmWNV/+XuJlb1vgNFVvXB+ubz5kpISQmpNqk0tLweLuthu+xuuccut5J06/KhVvWJSX7rHv7zgV12+/Rea1VfUppoVR+sbb9kKqEwtNxtsPwekyTvz3avt+E0+zG3cLxddqe/38+6h3YnbrGq3/T5cVb1/sJCq/pQLN3eRomp3pBqz2r3jfX+l29oaVVfw37YVdZDdvndepf9uPvNx3bHwde42KreX+izqg/Wz/tqKaE4tDFv1o4e1vv/erPduOnZGdr3zOFS99mFt/Hf7cfdA5Ptfk4z20L7GpbXR3nIe3pXXyUfSA6p9qvtWdb79/xkd7zqdbb7WVCSti23ex0m1f5n2sZ/+diqfrPl9YLf/jI1aLuL01WjKLTsjfzxEuv9/7bFF1b1zy/pa91DjUYFVvX/XG5/rk20zG/zCXbZLTUl+t5qC9WXXx75FYaLvmrALceJd3ADAAAAAAAAAFyJCW4AAAAAAAAAgCsxwQ0AAAAAAAAAcCUmuAEAAAAAAAAArhT0BPfSpUs1aNAgZWVlyePxaM6cOdZNXGW+1pWm8g/vutKs1VXma+t9wN0ikbtwILvxLVZzZ4vcxrZ4zV04kN3IInuRQ3aPjNzFtnjNLrmLf7GaXbKHo4nV3AJuEPQEd35+vrp06aJp06aFrQm/PLpaayt8I19p1upqrXXNJ3YiciKRu3Agu/EtVnNni9zGtnjNXTiQ3cgie5FDdo+M3MW2eM0uuYt/sZpdsoejidXcxiOfSeARxMMNkoItGDhwoAYOHBjWJl7xdJCMdLXWSubgv8u+gV9Qh4PPo1qLRO7CgezGt1jNnS1yG9viNXfhQHYji+xFDtk9MnIX2+I1u+Qu/sVqdskejiZWcwu4QdAT3MEqKipSUVFR+b9zc3MrXe/wb+QrzLdKlp9vYISsqrkLB7KLMtHMnS1yGz/clLtwILuxo7plzxbZDQ9yF31kl9y5VTxkl+xVP/GQW8AJEX+f+aRJk5SZmVn+yM7OPuK6r3g6qFgJSpZfxUrgGxghCyZ34UB2IUU/d7bIbXxwW+7CgezGhuqYPVtk1x65c0Z1zy65cy+3Z5fsVU9uzy3ghIhPcI8bN045OTnljy1bthxx3SvN2vJv4GT5j3hzfeBYgsldOJBdSNHPnS1yGx/clrtwILuxoTpmzxbZtUfunFHds0vu3Mvt2SV71ZPbcws4IeK3KPF6vfJ6vcdc79f3FSr7d9l9h4BgVDV34UB2USaaubNFbuOHm3IXDmQ3dlS37Nkiu+FB7qKP7JI7t4qH7JK96icecgs4IeIT3FVR2U3zK7u5PhBryC7ciNzCrcgu3Irswq3ILtyK7MKNyG30+JQgX+RvahEX3HKcgp7g3r9/v9avX1/+7w0bNmj16tWqW7eumjVrFlITCTKV3jS/7Bs5QSak7SJ+RCJ34UB241us5s4WuY1t8Zq7cCC7kUX2IofsHhm5i23xml1yF/9iNbtkD0cTq7kF3CDoCe6VK1fqrLPOKv/32LFjJUnDhg3TCy+8EFITL3k6HvE5fjsFKTK5CweyG99iNXe2yG1si9fchQPZjSyyFzlk98jIXWyL1+ySu/gXq9kleziaWM0t4AZBT3CfeeaZMobfGiG6yB2cQO7gBHIHp5A9OIHcwQnkDk4hewAQGe64kQoAAAAAAAAAAL/i2IdMbh/dS4nelJBq/TXsf+M5vN+7VvVL97S17uGyxp9a1T+6vp91DzmlNa3qN35kd58wX2GhVX3Q+6spmdBip5/GnWq//xS77Pbt9bV1D5fUyrGqn7ndftjI25NmVX9y201W9SVJxfrKagvB8dUulalZGlJtjZxk6/3bZrck3X7MPbPtOqv6/717onUPfrvhTh+ta2O3/4LojndmQ5pMSmgDXp0T91jv/5ek2lb1P91tP+YWHldit4Ek++yv39HAqt40tsuNORDd3EnSGU3Wy1urRki1z+84zXr/l3VcaVX/2vY+1j2sn3qKVb3X/ltQd10826p+8ufnWdV7Sn1W9cHylyZIJaG9d2dII7vMSFJKYher+kt7rbDu4c+v/t6qfsu99uNukuWQU5htN277C0K73gpV/zpfKzU9MaTaxZ90st5/attcq/qcfMuLI0n1e+y0qt/5dUPrHrbdZnmtm+G3qvcX2tWHYsXG5kpIDe06z5tSbL3/P2TZfd07dN5s3cP+Yq9VfVZTu5+LJWn5yhOs6jc+2Nuq3l9YKD0w12obQLxwbIIbAAAAAAAAAKLJbzzyG4/TbbiCW44TtygBAAAAAAAAALgSE9wAAAAAAAAAAFcKaoJ70qRJ6tGjh9LT09WwYUMNHjxY3333XaR6AySROziH7MEJ5A5OIHdwCtmDE8gdnEDuACBygprg/uCDDzR8+HAtX75cCxcuVElJifr376/8/PxI9QeQOziG7MEJ5A5OIHdwCtmDE8gdnEDuACBygvqQyfnz5wf8+4UXXlDDhg21atUqnXHGGWFtDChD7uAUsgcnkDs4gdzBKWQPTiB3cAK5A4DICWqC+9dycnIkSXXr1j3iOkVFRSoqKir/d25urs0uAXIHxxwre+QOkUDu4ATOtXAKYx6cQO7gBM61gHP8SpCPjyWsEr9LjlPIXfr9fo0ZM0Z9+vRRp06djrjepEmTlJmZWf7Izs4OdZcAuYNjqpI9codwI3dwAudaOIUxD04gd3AC51oACK+QJ7iHDx+uNWvW6LXXXjvqeuPGjVNOTk75Y8uWLaHuEiB3cExVskfuEG7kDk7gXAunMObBCeQOTuBcCwDhFdItSkaMGKG3335bS5cuVdOmTY+6rtfrldfrDak54HDkDk6pavbIHcKJ3MEJnGvhFMY8OIHcwQmcawEg/IKa4DbGaOTIkZo9e7aWLFmili1bRqovoBy5g1PIHpxA7uAEcgenkD04gdzBCeQOACInqAnu4cOHa+bMmZo7d67S09O1Y8cOSVJmZqZq1qwZkQYBcgenkD04gdzBCeQOTiF7cAK5gxPIHQBETlD34J4+fbpycnJ05plnqkmTJuWPWbNmRao/gNzBMWQPTiB3cAK5g1PIHpxA7uAEcgfEDr9J4BHEww2CvkUJEG3kDk4he3ACuYMTyB2cQvbgBHIHJ5A7AIgcd0zDAwAAAAAAAADwK0G9gzucChv6lZDiD6n21D5rrfc/Y90pVvX1a+Vb93Dv3Mus6j3N7HuYt7+DVX3aSb9Y1fsOFFnVB2viBTOVmp4YUu3oxVda7z+r2R6r+m9+aWTdw/KGPqv65MRS6x6Sd9Swqv96exuren9hoVV9sBo33quktNA+/bykUWh5PVxRid1QP+1E+z+b3OdPtapPv8D+a/be5uOt6s9p9r1VffH+Ej1ttYXgDDv/faXUCu1rP39HR+v9v3zeVKv6C+eMte7hxHZbrOpb1frZuoff1llpVX/dJ8Os6j1JoV1r2Ziz5iQl1EwJqTZhj935QZK+bd3Qqt5Xy/6YJeXYjd39Ll5h3UNKQolV/a0nLbSqL9hfqtusthAcU5ogUxrae3cemDPUev8nnLLRqn7y9+dZ99Di9E1W9T+929y6hzMvWmVV/02O3bVuaX6RfrLaQnCe2HhmyNd4pob9WFOwKd2qvs8p9j9XD6j7tVX9L9m1rHuYunCgVX3t1u76mVaSshv+EnL2Nu2qa73/Lv+fvTsPj6q8+z/+mWwTAkkEZAuEfZNdQBBREUV9cMO2UrVYEbdqQUG0Kl1Ef7UEl1p8KsWliq1KQa0s9RFRUMAN2YoFeURWCTsIJCSESTJzfn/wJBCTQM7cM3PPTN6v6zqXMjnfc745+eQ+J3dOznh3GtW/GjC/17JHA7MeRjb8zLiHVZdtMKqfvNxs7A8URT57QLTiDm4AAAAAAAAAQExighsAAAAAAAAAEJOsPaIEAAAAAAAAACLJL4/88thuIybEynHiDm4AAAAAAAAAQExyNcE9bdo09ejRQxkZGcrIyNCAAQM0f/78cPUGSCJ3sIfswQZyBxvIHWwhe7CB3MEGcgcA4eNqgrtFixaaPHmyVq1apZUrV+riiy/WsGHD9PXXZu+cDJwKuYMtZA82kDvYQO5gC9mDDeQONpA7AAgfV8/gvvrqqyv8+w9/+IOmTZumZcuWqWvXriFtDChD7mAL2YMN5A42kDvYQvZgA7mDDeQOAMIn6DeZ9Pv9euutt1RYWKgBAwZUu57P55PP5yv/d35+frC7BMgdrKlJ9sgdQo3cwQbOtbCFMQ82kDvYwLkWAELL9QT32rVrNWDAAB07dkz16tXT7Nmz1aVLl2rXz8nJ0WOPPWbUJEDuYIub7JE7hAq5gw2ca2ELYx5sIHewgXMtEB0CToICjqunNtdasXKcXHfZqVMnrVmzRl9++aXuvvtujRw5UuvXr692/QkTJigvL698yc3NNWoYtRO5gy1uskfuECrkDjZwroUtjHmwgdzBBs61ABAeru/gTklJUfv27SVJffr00YoVK/Tss8/qhRdeqHJ9r9crr9dr1iVqPXIHW9xkj9whVMgdbOBcC1sY82ADuYMNnGsBIDyM7zMPBAIVngkFRAK5gy1kDzaQO9hA7mAL2YMN5A42kDsACA1Xd3BPmDBBQ4cOVcuWLXXkyBHNmDFDixcv1oIFC8LVH0DuYA3Zgw3kDjaQO9hC9mADuYMN5A4AwsfVBPe+fft08803a/fu3crMzFSPHj20YMECXXrppeHqDyB3sIbswQZyBxvIHWwhe7CB3MEGcgcA4eNqgvvll18OVx9AtcgdbCF7sIHcwQZyB1vIHmwgd7CB3AHRwy/JL4/tNmKC33YDNWT8DG4AAAAAAAAAAGxwdQd3KP108Ofy1ksOrjZzpfH+u7aqY1R/R+5A4x6uu2q1Uf12X0PjHp5ossaofk5hPaP6o0f8+rnRFtzZVtJIqcXBxf6W/p8Z7//NTWcb1f+o3X+Me9hc0tio/mdNvjTuYWXz1kb1HVvuMaovLfRpi9EW3ElNKlVSUmJQtSX+4OpO9q/eLxnVrziWZdxD55S9RvUPbLjOuAfHb/Yb+k92tTWq9x+N7BsILdjdRUl1vUHV3tP6I+P9+xyz7F48YK1xD+sONjXr4cxvjHt4++A5RvVXdPzaqL64oEQvGG3BvY7Ze4LO3oakJsb7/2XHpUb1Tx81/1Px4f3NrvH2+jKMe2iXvM+ofllpO6N6nxPZu6KS04qVkBbcvTt9O2823n/PjB1G9Q913GjcwzMHzc5TR27catzDikOtjOrndn7TqD7/SEDZRltw52ctV6hOveB+tnh2ybXG+0/sf8iofvuRBsY9jGj1vVH9L3d2MO4hsUmRUf2h79ON6gNFwc1rmCjxJ8oJ8ueEjs3Mzg+S9G5Bd6P6/g23Gfewx/Bc2SCh2LiHjilmP5empZv9fOBPNP8cgHjBHdwAAAAAAAAAgJjEBDcAAAAAAAAAICYxwQ0AAAAAAAAAiElGE9yTJ0+Wx+PRuHHjQtQOcHrkDjaQO9hC9mADuYMN5A62kD3YQO4AewJOAouLJRYE3eWKFSv0wgsvqEePHqHsBzglcgcbyB1sIXuwgdzBBnIHW8gebCB3ABBaQU1wFxQUaMSIEXrppZdUv379UPcEVIncwQZyB1vIHmwgd7CB3MEWsgcbyB0AhF5QE9yjR4/WlVdeqSFDhpx2XZ/Pp/z8/AoLEAxyBxvIHWypafbIHUKJMQ82kDvYwrkWNjDmAUDoJbktmDlzplavXq0VK1bUaP2cnBw99thjrhsDTkbuYAO5gy1uskfuECqMebCB3MEWzrWwgTEPAMLD1R3cubm5Gjt2rN544w2lpqbWqGbChAnKy8srX3Jzc4NqFLUXuYMN5A62uM0euUMoMObBBnIHWzjXwgbGPAAIH1d3cK9atUr79u1T7969y1/z+/1aunSpnnvuOfl8PiUmJlao8Xq98nq9oekWtRK5gw3kDra4zR65Qygw5sEGcgdbONfCBsY8IHr4nQT5naCe2lzrxMpxcjXBfckll2jt2rUVXhs1apQ6d+6shx56qNJgDIQCuYMN5A62kD3YQO5gA7mDLWQPNpA7AAgfVxPc6enp6tatW4XX6tatq4YNG1Z6HQgVcgcbyB1sIXuwgdzBBnIHW8gebCB3ABA+sXGfOQAAAAAAAAAAP+DqDu6qLF68OARtAO6QO9hA7mAL2YMN5A42kDvYQvZgA7kDgNDgDm4AAAAAAAAAQEwyvoM7WHUSipWa4ARV+3VxU+P93/DvK43qkxP9xj0s/riHUX27ftuNe7hwXxuj+sua/a9R/bFjJZLWnna9UPnqSAslB1KCqv1kTecQd+PezK0Djbfxy//6wKj+b5v6G/fg+D1G9Vu+bGlUHzh2zKjere17GighLTWo2oYNCoz3/+z+C43q/9hstXEP43ZfYFTfqP4R4x4OHUkzqu/f1GzMLS4ojuBoJ/2m7f+obnpwv8deeyzbeP8/qZdvVL/lSEPjHlKTSo3qZ23vY9zDrK5/M6of9u/bjer9R31G9cG4u/nHqpse3BtlXdapxHj/43b3Naq/ouPXxj0s3dveqN7vmJ0nJSm5idm16rLDbY3qSwqLjerdGtf9I9WpF9yPNk+vu9R4/98fq2tUf8Qf3HXCydbnm/2M9J8V7Yx76NZ3q1H9r/eYXS8UF5RIettoG278z97uSirwBlXr637UeP8Jx5KN6n/WaYlxD2t8ZueZfulbjHuYf6yrUX2S12y89JSazw249fZZbysjyOu8O78barz/QXW/Maq/6cvbjHvo1WKnUf1qX5ZxD8ccs+/BY4bfw4Fjkc9evHDkUUDm11u1gRMjx4k7uAEAAAAAAAAAMYkJbgAAAAAAAABATGKCGwAAAAAAAAAQk5jgBgAAAAAAAADEJFcT3I8++qg8Hk+FpXNn+2+8h/hG7mAL2YMN5A42kDvYQvZgA7mDDeQOAMLH9VuNd+3aVQsXLjyxgaTg3q0ccIPcwRayBxvIHWwgd7CF7MEGcgcbyB0QHfxOgvwOD7WoiVg5Tq5H06SkJDVt2jQcvQDVInewhezBBnIHG8gdbCF7sIHcwQZyBwDh4XoafuPGjcrKylLbtm01YsQIbd++/ZTr+3w+5efnV1gAt8gdbHGTPXKHUCF3sIFzLWxhzIMN5A42cK4FgPBwNcHdv39/vfrqq3r//fc1bdo0bd26VRdccIGOHDlSbU1OTo4yMzPLl+zsbOOmUbuQO9jiNnvkDqFA7mAD51rYwpgHG8gdbOBcCwDh42qCe+jQoRo+fLh69Oihyy+/XO+9954OHz6sN998s9qaCRMmKC8vr3zJzc01bhq1C7mDLW6zR+4QCuQONnCuhS2MebCB3MEGzrUAED5G72hwxhlnqGPHjtq0aVO163i9Xnm9XpPdABWQO9hyuuyRO4QDuYMNnGthC2MebCB3sIFzLQCEjtFbYRYUFGjz5s1q1qxZqPoBTovcwRayBxvIHWwgd7CF7MEGcgcbyB1gT8DxsLhYYoGrCe4HHnhAS5Ys0bZt2/T555/rRz/6kRITE3XjjTeGqz+A3MEasgcbyB1sIHewhezBBnIHG8gdAISPq0eU7NixQzfeeKO+//57NWrUSOeff76WLVumRo0ahas/gNzBGrIHG8gdbCB3sIXswQZyBxvIHQCEj6sJ7pkzZ4arD6Ba5A62kD3YQO5gA7mDLWQPNpA72EDuACB8jJ7BDQAAAAAAAACALa7u4A6lAn+qSvzJQdXm/O9Q4/13bbzHqP7Lb9oa93DL0CVG9SsOtTLu4e0urxvVT9h5uVF98dFio3q39hzNUJInuHehTqhXYrz/OnXNPt/OjfYa95Dnr2NU/1nf6cY9XLp2hFH9ZX2/Mar3FZToqUeNNuFK4Giy5AQ33h3aeabx/n/b429G9Q/tPc+4hzOTC4zqv8+ra9xDydEUo/ptBQ2M6ksLfUb1bt2z6gYlpKUGVTuk3bfG+z+QbvZ9mplSZNzDmrVm5+rePTYb9/DLLcON6q9s9bVRva+gRGZbcG9DcZZSfcFdYt67+gLj/f+u53tG9RPn/dS4hwTDS4aS+n7jHm48fIfxNkwEjh6L6P6e/XqwEoMc8zzr0433v/HMNKP6zfXNH1GQkGiWGycEtz599bXZzyffNjY7Dv4I527r/oZKKAwudwnfmV2TS1Jp3YBRfc5nVxj3cF3vVUb1C7Z3Nu4hZYfZNV5pPceoPhDZ2EmSrvvf65RUN7ifa3s02GW8/xs++YXZBswOuSRpxdp2RvWlXc0HvQNF9Yzq/flm2Q0UmY0BQDyxNsENAAAAAAAAAJHkV4L8PNSiRmLlOMVGlwAAAAAAAAAA/AAT3AAAAAAAAACAmOR6gnvnzp266aab1LBhQ9WpU0fdu3fXypUrw9EbUI7cwRayBxvIHWwgd7CB3MEWsgcbyB0AhIerZ3AfOnRIAwcO1ODBgzV//nw1atRIGzduVP369cPVH0DuYA3Zgw3kDjaQO9hA7mAL2YMN5A4AwsfVBPcTTzyh7OxsTZ8+vfy1Nm3ahLwp4GTkDraQPdhA7mADuYMN5A62kD3YQO4AIHxcPaJk3rx56tu3r4YPH67GjRvr7LPP1ksvvXTKGp/Pp/z8/AoL4Aa5gy1us0fuEArkDjZwroUN5A62cK6FDYx5QPQIOB4WF0sscDXBvWXLFk2bNk0dOnTQggULdPfdd+vee+/V3/72t2prcnJylJmZWb5kZ2cbN43ahdzBFrfZI3cIBXIHGzjXwgZyB1s418IGxjwACB9XE9yBQEC9e/fWpEmTdPbZZ+vOO+/UHXfcoeeff77amgkTJigvL698yc3NNW4atQu5gy1us0fuEArkDjZwroUN5A62cK6FDYx5ABA+ria4mzVrpi5dulR47ayzztL27durrfF6vcrIyKiwAG6QO9jiNnvkDqFA7mAD51rYQO5gC+da2MCYB6A2mTp1qlq3bq3U1FT1799fy5cvr3bdiy66SB6Pp9Jy5ZVX1nh/ria4Bw4cqA0bNlR47dtvv1WrVq3cbAZwhdzBFrIHG8gdbCB3sIHcwRayBxvIHYDaYtasWRo/frwmTpyo1atXq2fPnrr88su1b9++Ktd/5513tHv37vJl3bp1SkxM1PDhw2u8T1cT3Pfdd5+WLVumSZMmadOmTZoxY4ZefPFFjR492s1mAFfIHWwhe7CB3MEGcgcbyB1sIXuwgdwBqC2eeeYZ3XHHHRo1apS6dOmi559/XmlpaXrllVeqXL9BgwZq2rRp+fLhhx8qLS0tfBPc55xzjmbPnq1//OMf6tatm37/+99rypQpGjFihJvNAK6QO9hC9mADuYMN5A42kDvYQvZgA7kDokdACSwuFknKz8+vsPh8viqPbXFxsVatWqUhQ4aUv5aQkKAhQ4boiy++qNHX5+WXX9YNN9ygunXr1vhrmlTjNf/PVVddpauuusptGWCE3MEWsgcbyB1sIHewgdzBFrIHG8gdgFiVnZ1d4d8TJ07Uo48+Wmm9AwcOyO/3q0mTJhVeb9Kkib755pvT7mf58uVat26dXn75ZVf9uZ7gBgAAAAAAAADUDrm5uRXe6Nbr9YZlPy+//LK6d++ufv36uaqzNsE9Z1N3JaalBlVbWppovP8vd7c3qvek+o17eHtLL6P6dg2+N+5hwJIxRvXe1BKjev/RY0b1bnU/Y5e89ZKDqvWVmn+77M+vZ1S/JreFcQ8tOh02qu/9yS+Me0hMChjVv/bp+Ub1gaJjkt4z2oYbDZvnKTEtuKz/fshc4/3ftnWYUf1dWYuNe/jllzcZ1ad4zcYaSQocNPse7tiz6jfEqKnihBItMtqCOyUFXiX4g7voSEkoNd7/UwcGGtV/s6/J6Vc6HcesfNWG1sYtDOyyyaj+4z0djOpLC6v+08Fwmvb5xUqoE9w13j8um2a8/xuX3GlU/+OLvzTu4d1N3Yzqz2m+07iH7DqHjOo/2dPOqN6fFNnsNT3jiJLqFgdVuy3b/Ae0pDpm42afVtuNe/ivhuuM6td2ML/OnL+1i1F9aamrJ2hWEjCsd6tH811KrpsSVG1CC8OTlKR/7zL7mt161ufGPfgCwf1sVeaBzh8a9zBx14+N6tOaFBrV+49G/lw7suXnqlMvuGvbb4qyjPe/ZUjVz9GtqTtyza4TJennjT4zqt9VUt+4h8KA2fnjuWMXGdX7j/q0w2gLQM1lZGRUmOCuzplnnqnExETt3bu3wut79+5V06ZNT1lbWFiomTNn6v/9v//nur/IXgEAAAAAAAAAAOJOSkqK+vTpo0WLTtzeFQgEtGjRIg0YMOCUtW+99ZZ8Pp9uusn9DXI8ogQAAAAAAAAAYGz8+PEaOXKk+vbtq379+mnKlCkqLCzUqFGjJEk333yzmjdvrpycnAp1L7/8sq699lo1bNjQ9T6Z4AYAAAAAAABQK/gdj/yOx3YbMSGY43T99ddr//79euSRR7Rnzx716tVL77//fvkbT27fvl0JCRUfKrJhwwZ9+umn+uCDD4LqkwluAAAAAAAAAEBIjBkzRmPGVP2+f4sXL670WqdOneQ4wb8/hatncLdu3Voej6fSMnr06KAbAGqC7MEGcgcbyB1sIHewhezBBnIHG8gdAISPqzu4V6xYIb/fX/7vdevW6dJLL9Xw4cND3hhwMrIHG8gdbCB3sIHcwRayBxvIHWwgdwAQPq4muBs1alTh35MnT1a7du00aNCgkDYF/BDZgw3kDjaQO9hA7mAL2YMN5A42kDsACJ+gn8FdXFys119/XePHj5fHU/0Dx30+n3w+X/m/8/Pzg90lIKlm2SN3CDVyBxvIHWzgGg+2MObBBnIHGzjXAkBouXoG98nmzJmjw4cP65Zbbjnlejk5OcrMzCxfsrOzg90lIKlm2SN3CDVyBxvIHWzgGg+2MObBBnIHGzjXAnYFHA+LiyUWBD3B/fLLL2vo0KHKyso65XoTJkxQXl5e+ZKbmxvsLgFJNcseuUOokTvYQO5gA9d4sIUxDzaQO9jAuRYAQiuoR5R89913Wrhwod55553Truv1euX1eoPZDVBJTbNH7hBK5A42kDvYwDUebGHMgw3kDjZwrgWA0AvqDu7p06ercePGuvLKK0PdD3BKZA82kDvYQO5gA7mDLWQPNpA72EDuACD0XE9wBwIBTZ8+XSNHjlRSUtDvUQm4RvZgA7mDDeQONpA72EL2YAO5gw3kDgDCw/UE98KFC7V9+3bdeuut4egHqBbZgw3kDjaQO9hA7mAL2YMN5A42kDsACA/XvzK87LLL5DhOOHoBTonswQZyBxvIHWwgd7CF7MEGcgcbyB0QHRwnQQEnqKc21zpOjByniP9NTNlgHijyBb2NQGmicR+BooBRvcfxG/fgTw7+GEhSibfYuIfA0WNG9f5Aidn+/y8H4T7Jl22/uDD4fksLzb5ekuQ/avYtFygxz35xgeHXzDAzkqQks++/QJHZABs4dvxziFTu/EeDz87RI+ZjTUmh2VhRGIIejMcav1luJSlwzOz7z/R7p2z8iVTuAkXBH3PTz1WSlFBqVO4PwVgTKDIbM50QnOtNv/9Mzz1l408kfpguz96x4L92hUfMzg+SWfYlyReC/JuOeaa5kSSf4bhpcu46uT5SY17p0eCPmWlmJCngmI15ofiaF3nNevAZXCeXMR27A6WG13gR/tnC5OuWIPMeTY/3sQKzzEiSz3DYLkox78H0ezhWxruT91FUEPw1iq/I/Hs9P83sC19cYD7mFaaa9XC01Pw6ryhger0bO9kDop3HifB3wo4dO5SdnR3JXSIG5ObmqkWLFmHbPrlDVcgdbCB3sCHcuZPIHqrGmAcbyB1s4FwLWyKRvXiRn5+vzMxM3blkuFLqJdtuJyYUF5ToxUFvKS8vTxkZGbbbqVbE7+DOyspSbm6u0tPT5fF4Kn08Pz9f2dnZys3NDerAmdbTQ2R7cBxHR44cUVZWVlA91lS4cxeKbdBD5Hogd/Rgo4doyV1Nej2d2vI1i4ceIpU7iTEvVuoj1UO0jHmxcrzoITTbiJbc1aTX06ktX7N46CGezrWxcLzp4YRIZg+IdhGf4E5ISKjRb5YyMjKMfjNgWk8PkeshMzMz6G3XVKRyF4pt0ENkeiB39GCjh2jKnRT9x4seQlMfidxJjHmxVh+JHqJpzIuF40UPodlGNOVOiv7jRQ+hqY+3c220H296OCFS2QOiXWw8KRwAAAAAAAAAgB+I+B3cAAAAAAAAAGCDXx75VfUjplBRrBynqLuD2+v1auLEifJ6vVbq6SG6eoiUeDle9BC6bURCNHyu9BA9PURSPBwveghdD5ESL8fLdg/x8DlEUrwcL3oI3TYiJR6OFz2ErodIiYbPlR6ipwegNvE4juPYbgIAAAAAAAAAwiU/P1+ZmZm6bclPlVIv2XY7MaG4oEQvD3pTeXl5xs+kD6eou4MbAAAAAAAAAICaYIIbAAAAAAAAABCTmOAGAAAAAAAAAMSkJNsNAAAAAAAAAEAkBBwp4HhstxETAjHyzo3cwQ0AAAAAAAAAiElMcAMAAAAAAAAAYhIT3AAAAAAAAACAmMQENwAAAAAAAAAgJjHBDQAAAAAAAACISUm2GwAAAAAAAACASAg4CQo43PNbE7FynGKjSwAAAAAAAAAAfoAJbgAAAAAAAABATIrrCe4VK1bovPPOU926deXxeLRmzRrbLZ3Wk08+qc6dOysQCER83w8//LD69+8f8f3GG3LnzvPPP6+WLVvK5/NFfN/xhNy5Q+5Ch+y5Q/ZCg9y5wzVeaJA7d8hd6JA9d8heaJA7d8gdYFfcTnCXlJRo+PDhOnjwoP70pz/ptddeU6tWrWy3dUr5+fl64okn9NBDDykh4fiX5vvvv9dTTz2lCy+8UI0aNdIZZ5yhc889V7NmzXK17Xnz5ql3795KTU1Vy5YtNXHiRJWWllZYZ9y4cfrqq680b968kH1OtQ25O2HWrFm66aab1KFDB3k8Hl100UVVrnfLLbeouLhYL7zwQig+nVqJ3Ml1PbkLDbJ3wn333afevXurQYMGSktL01lnnaVHH31UBQUFFdYje+bIXdU2b96s1NRUeTwerVy5ssLHuMYzR+5OaN26tTweT6XlrrvuqrAeuQsNslfRkSNH9OCDD6pNmzbyer1q3ry5rrvuOh09erR8HbJnjtwdt3jx4irHu7LlD3/4Q/m65A6wK27fZHLz5s367rvv9NJLL+n222+33U6NvPLKKyotLdWNN95Y/toXX3yh3/zmN7riiiv029/+VklJSfrnP/+pG264QevXr9djjz122u3Onz9f1157rS666CL9+c9/1tq1a/X4449r3759mjZtWvl6TZs21bBhw/T000/rmmuuCcvnGO/I3QnTpk3TqlWrdM455+j777+vdr3U1FSNHDlSzzzzjO655x55PJ6QfF61CblzX0/uQoPsnbBixQpdcMEFGjVqlFJTU/Xvf/9bkydP1sKFC7V06dLyH7TInjlyV7X77rtPSUlJVf51ANd45shdRb169dL9999f4bWOHTtW+De5Cw2yd0JeXp4GDRqkHTt26M4771T79u21f/9+ffLJJ/L5fEpLS5NE9kKB3B131lln6bXXXqv0+muvvaYPPvhAl112Wflr5A6wy+M4jmO7iXBYunSpBg0apLfeekvXXXfdKdctLCxU3bp1I9RZ9Xr27KkePXpUGEC3bt2qhISECr8tdRxHQ4YM0Weffabvv//+tL137dpVycnJWrlypZKSjv9O47e//a0mTZqk9evXq3PnzuXr/vOf/9Tw4cO1adMmtW3bNsSfYfwjdyfk5uaqefPmSkhIULdu3XTmmWdq8eLFVa67atUq9e3bV4sWLdLFF18cks+rNiF3wdWTO3Nk79T++Mc/6oEHHtAXX3yhc889t/x1smeG3FW2YMECXXPNNXrwwQf1+OOPa8WKFerbt2+FdbjGM0PuTmjdurW6deumd99997Q9kDtzZO+EX/7yl/rHP/6h1atXq02bNqdcl+yZIXenVvZXyt9++22F18ld9MvPz1dmZqZ+/vGNSqmXYrudmFBcUKzXBv9DeXl5ysjIsN1OteLyESW33HKLBg0aJEkaPnx4hccj3HLLLapXr542b96sK664Qunp6RoxYoSk4wPz/fffr+zsbHm9XnXq1ElPP/20fvg7AI/HozFjxuitt95Sly5dVKdOHQ0YMEBr166VJL3wwgtq3769UlNTddFFF2nbtm2n7Xnr1q36z3/+oyFDhlR4vU2bNpX+FMjj8ejaa6+Vz+fTli1bTrnd9evXa/369brzzjvLJ7el4xcHjuPo7bffrrB+2f7nzp172p5REbmrKDs7u/yOxdPp06ePGjRoQO6CQO6Cryd3Zsje6bVu3VqSdPjw4Qqvk73gkbvKSkpKNHbsWI0dO1bt2rWrdj2u8YJH7qpWXFyswsLCU65D7syQvRMOHz6s6dOn684771SbNm1UXFx8yvezIHvBI3entnz5cm3atKn88z4ZuQPsictHlPziF79Q8+bNNWnSJN17770655xz1KRJk/KPl5aW6vLLL9f555+vp59+WmlpaXIcR9dcc40+/vhj3XbbberVq5cWLFigX/3qV9q5c6f+9Kc/VdjHJ598onnz5mn06NGSpJycHF111VV68MEH9Ze//EW//OUvdejQIT355JO69dZb9dFHH52y588//1yS1Lt37xp9jnv27JEknXnmmadc79///rckVbqLJysrSy1atCj/eJnMzEy1a9dOn332me67774a9YLjyJ2Z3r1767PPPgv5duMduTOrJ3fBI3uVlZaW6vDhwyouLta6dev029/+Vunp6erXr1+ldclecMhdZVOmTNGhQ4f029/+Vu+8806163GNFzxyV9lHH32ktLQ0+f1+tWrVSvfdd5/Gjh1baT1yZ4bsnfDpp5/q2LFjat++va677jrNmTNHgUBAAwYM0NSpU9WrV68K65O94JG7U3vjjTckqcoJbnIH2BOXE9wDBgyQz+fTpEmTdMEFF1T6kxqfz6fhw4crJyen/LW5c+fqo48+0uOPP67f/OY3kqTRo0dr+PDhevbZZzVmzJgKd8Vs2LBB33zzTfndWfXr19cvfvELPf744/r222+Vnp4uSfL7/crJydG2bdvK163KN998I0mn/VMrSTp48KD++te/6oILLlCzZs1Oue7u3bslqcr1mjVrpl27dlV6vW3btlq/fv1p+0BF5M5M27Ztq3y+GU6N3JnVk7vgkb3KVq5cqQEDBpT/u1OnTpo3b54aNGhQaV2yFxxyV9GePXv0+9//Xk8//XSN/mSUa7zgkLuKevToofPPP1+dOnXS999/r1dffVXjxo3Trl279MQTT1Ran9wFj+ydsHHjRknShAkT1K5dO/39739XXl6eHnvsMV188cX6+uuvK22D7AWH3FXP7/dr1qxZ6tevn9q3b1/lOuQOsCMuH1FSE3fffXeFf7/33ntKTEzUvffeW+H1+++/X47jaP78+RVev+SSSyoMsP3795ck/eQnPykfjE9+/XR/+vL9998rKSlJ9erVO+V6gUBAI0aM0OHDh/XnP//5lOtKUlFRkSTJ6/VW+lhqamr5x09Wv359HThw4LTbhnu1JXfBqF+/voqKiiq8AzpCo7bmrib15C68alv2unTpog8//FBz5szRgw8+qLp166qgoKDKdcle+NSm3D300ENq27Ztjd8AjGu88KlNuZs3b54efPBBDRs2TLfeequWLFmiyy+/XM8884x27NhRaX1yF161JXtl51OPx6NFixbpZz/7me6++27NmTNHhw4d0tSpUyvVkL3wqS25+6FFixZp7969Vd69XYbcAXbE5R3cp5OUlKQWLVpUeO27775TVlZWhcFUOv6uuWUfP1nLli0r/DszM1PS8ecOV/X6oUOHzBuXdM899+j999/X3//+d/Xs2fO069epU0eSqnw+2bFjx8o/fjLHceTxeMybRQW1KXfBKHs2G9kLrdqcu5rUk7vwqY3Zy8jIKH/24rBhwzRjxgwNGzZMq1evrrQdshcetSl3y5Yt02uvvaZFixbV+D0vuMYLj9qUu6p4PB7dd999WrBggRYvXqybbrqpwsfJXfjUpuyV/dx69dVXV5jEPPfcc9WmTZvyR1ScjOyFR23K3Q+98cYbSkxM1PXXX1/tOuQOsKNW3sHt9Xpr/INAdRITE129/sM3Vvihhg0bqrS0VEeOHKl2nccee0x/+ctfNHnyZP385z+vUZ9lf3JT9qiSk+3evVtZWVmVXj906FBYnrFc29Wm3AXj0KFDSktLq/KXLghebc1dTevJXfjU1uyd7Mc//rEkaebMmZU+RvbCozbl7sEHH9QFF1ygNm3aaNu2bdq2bVv5HWO7d+/W9u3bK9VwjRcetSl31SmblDp48GClj5G78KlN2Sv7ufXkZ0GXady4cZUToGQvPGpT7k5WVFSk2bNna8iQIVXmsAy5iw1+x8PiYokFtXKCuyqtWrXSrl27Kg2IZc9y+uE774Za586dJR1/99+qTJ06VY8++qjGjRunhx56qMbbLXuzjZUrV1Z4fdeuXdqxY0elN+Mo66HsN60Ir3jNXTDIXeTEe+7c1JO7yIr37P2Qz+dTIBBQXl5epY+RvciJ19xt375dS5cuVZs2bcqXX/3qV5Kka665Rj169KhUQ+4iJ15zV52yxwc0atSo0sfIXWTFa/b69OkjSdq5c2elj+3atYvsWRavuTvZvHnzdOTIkVM+nqSsB3IHRB4T3P/niiuukN/v13PPPVfh9T/96U/yeDwaOnRoWPdf9qZUP5yIlqRZs2bp3nvv1YgRI/TMM8+42m7Xrl3VuXNnvfjii/L7/eWvT5s2TR6Pp9IbRuTl5Wnz5s0677zzgvgs4Fa85i4Yq1evJncREs+5c1tP7iIrXrN3+PBhlZSUVHr9r3/9qySpb9++lT5G9iInXnP34osvavbs2RWWe+65R5L09NNP64033qiwPtd4kRWvuTt48GCFnykkqaSkRJMnT1ZKSooGDx5c4WPkLvLiNXudOnVSz549NXfu3ArPN/7ggw+Um5urSy+9tML6ZC+y4jV3J5sxY4bS0tL0ox/9qNp1yB1gT618BndVrr76ag0ePFi/+c1vtG3bNvXs2VMffPCB5s6dq3HjxlV4x99waNu2rbp166aFCxfq1ltvLX99+fLluvnmm9WwYUNdcskllX5YOe+889S2bdvyf3s8Hg0aNEiLFy8uf+2pp57SNddco8suu0w33HCD1q1bp+eee0633357pd8sLly4UI7jaNiwYeH5RFFBPOdu6dKlWrp0qSRp//79Kiws1OOPPy5JuvDCC3XhhReWr7tq1SodPHiQ3EVIvObObT25i7x4zd7ixYt177336rrrrlOHDh1UXFysTz75RO+884769u1b6Xm0ZC+y4jV3l112WaV9HT58WJI0aNCgSr9Y4RovsuI1d/PmzdPjjz+u6667Tm3atNHBgwc1Y8YMrVu3TpMmTVLTpk0rbI/cRV68Zk86Pll66aWX6vzzz9cvfvEL5eXl6ZlnnlHHjh0rvekh2YuseM6ddPyXe/Pnz9dPfvKTU76RJbkD7GGC+/8kJCRo3rx5euSRRzRr1ixNnz5drVu31lNPPaX7778/Ij3ceuuteuSRR1RUVFT+TM7169eruLhY+/fvrzBQl5k+fXr5gFz2ztJlz90uc9VVV+mdd97RY489pnvuuUeNGjXSr3/9az3yyCOVtvfWW2/p/PPPD/sJCMfFc+4++ugjPfbYYxVe+93vfidJmjhxYoUJ7rfeekstW7bUxRdfHLpPDNWK19y5qZfInQ3xmr3u3btr8ODBmjt3rnbv3i3HcdSuXTs98sgj+tWvfqWUlJQK2yN7kRWvuXOLa7zIitfcde/eXV26dNHrr7+u/fv3KyUlRb169dKbb76p4cOHV9oeuYu8eM2eJA0ePFjvv/++fve73+nXv/610tLSdO211+rJJ5+sNOlI9iIrnnMnHc9TSUmJfvazn52yB3IH2ONxTve0fkRMXl6e2rZtqyeffFK33Xab6/r33ntPV111lb766it1797ddf2ePXvUpk0bzZw5k9841iK2c+fz+dS6dWs9/PDDGjt2rOt6xCZyB1vIHmywnTuu8WoncgdbyB5sIHeoifz8fGVmZupnH/1MKfVSTl8AFRcUa8bFM5SXl6eMjAzb7VSLZ3BHkczMTD344IN66qmnFAgEXNd//PHHuuGGG4IajCVpypQp6t69O4NxLWM7d9OnT1dycrLuuuuuoOoRm8gdbCF7sMF27rjGq53IHWwhe7CB3MGNgJPA4mKJBdzBDQAAAAAAACCuld3BfcOim7iDu4aKC4o185LXuYMbAAAAAAAAAIBwYIIbAAAAAAAAABCTmOAGAAAAAAAAAMQkJrgBAAAAAAAAADGJCW4AAAAAAAAAQExKst0AAAAAAAAAAERCQB4FHI/tNmJCQLFxnKLqDu6pU6eqdevWSk1NVf/+/bV8+fIa1y5dulRXX321srKy5PF4NGfOHFf7zsnJ0TnnnKP09HQ1btxY1157rTZs2OBqG9OmTVOPHj2UkZGhjIwMDRgwQPPnz3e1jZNNnjxZHo9H48aNq3HNo48+Ko/HU2Hp3Lmzq/3u3LlTN910kxo2bKg6deqoe/fuWrlyZY3rW7duXakHj8ej0aNHu+ojkmI5e/GSO8kse+Rujqt9M+adUNvGPHJXEbmLnFjOXrzkTuJcW5tzJ7nPXjTkToq97MVy7qT4GfPIXc1zJ9nPHrk7LtZyB0SLqJngnjVrlsaPH6+JEydq9erV6tmzpy6//HLt27evRvWFhYXq2bOnpk6dGtT+lyxZotGjR2vZsmX68MMPVVJSossuu0yFhYU13kaLFi00efJkrVq1SitXrtTFF1+sYcOG6euvv3bdz4oVK/TCCy+oR48ermu7du2q3bt3ly+ffvppjWsPHTqkgQMHKjk5WfPnz9f69ev1xz/+UfXr13fV+8n7//DDDyVJw4cPd/25REKsZy8ecieZZ4/cucOYd1xtG/PIXUXkLnJiPXvxkDuJc21tzp0UfPZs566s91jJXqznToqPMY/cucudZD975O5E77GSOyCaeBzHcWw3IUn9+/fXOeeco+eee06SFAgElJ2drXvuuUcPP/ywq215PB7Nnj1b1157bdD97N+/X40bN9aSJUt04YUXBr2dBg0a6KmnntJtt91W45qCggL17t1bf/nLX/T444+rV69emjJlSo1qH330Uc2ZM0dr1qwJqt+HH35Yn332mT755JOg6qsybtw4vfvuu9q4caM8nuj704Z4zF6s5U4KffbInTuMebVjzCN3J5C7yIrH7MVa7iTOtbU1d1Lw2YvG3EnRnb14zJ0Ue2MeuQs+d1L0ZI/cRXfuYlF+fr4yMzP100U/V0rdFNvtxITiwmK9eclrysvLU0ZGhu12qhUVd3AXFxdr1apVGjJkSPlrCQkJGjJkiL744gsrPeXl5Uk6PqAGw+/3a+bMmSosLNSAAQNc1Y4ePVpXXnllhePhxsaNG5WVlaW2bdtqxIgR2r59e41r582bp759+2r48OFq3Lixzj77bL300ktB9SEd/9q+/vrruvXWW6NyMI637MVq7qTQZo/cuceYF/9jHrmriNxFTrxlL1ZzJ3Gura25k8yyF025k6I7e/GWOyl2xzxyZzd3Uu0819am3AHRJiomuA8cOCC/368mTZpUeL1Jkybas2dPxPsJBAIaN26cBg4cqG7durmqXbt2rerVqyev16u77rpLs2fPVpcuXWpcP3PmTK1evVo5OTlu25Z0/De3r776qt5//31NmzZNW7du1QUXXKAjR47UqH7Lli2aNm2aOnTooAULFujuu+/Wvffeq7/97W9B9TNnzhwdPnxYt9xyS1D14RYv2Yv13EmhzR65c4cxr3aMeeTuBHIXWfGSvVjPncS5Vqp9uZPMshdtuZOiO3vxkjsp9sc8cmcvd1LtPdfWptwB0SbJdgPRaPTo0Vq3bp3r58tJUqdOnbRmzRrl5eXp7bff1siRI7VkyZIaDcq5ubkaO3asPvzwQ6WmpgbTuoYOHVr+/z169FD//v3VqlUrvfnmmzX6s55AIKC+fftq0qRJkqSzzz5b69at0/PPP6+RI0e67ufll1/W0KFDlZWV5bq2Ngo2e7GeOym02SN37jDmMebZQO7InS2caznX2mAjd5J59qItdxLZc4NzLbmzpbaea8ld7HDkUUDcFV8TTowcp6i4g/vMM89UYmKi9u7dW+H1vXv3qmnTphHtZcyYMXr33Xf18ccfq0WLFq7rU1JS1L59e/Xp00c5OTnq2bOnnn322RrVrlq1Svv27VPv3r2VlJSkpKQkLVmyRP/93/+tpKQk+f1+1/2cccYZ6tixozZt2lSj9Zs1a1bp5HHWWWe5/lNESfruu++0cOFC3X777a5rIyVeshfruZNClz1y5w5jXu0Z88jdceQu8uIle7GeO4lzrVS7cieFPns2cydFf/biJXdS7I955M5O7qTafa6tTbkDok1UTHCnpKSoT58+WrRoUflrgUBAixYtCuoZc8FwHEdjxozR7Nmz9dFHH6lNmzYh2W4gEJDP56vRupdcconWrl2rNWvWlC99+/bViBEjtGbNGiUmJrref0FBgTZv3qxmzZrVaP2BAwdqw4YNFV779ttv1apVK9f7nj59uho3bqwrr7zSdW2kxGv2Yi13UuiyR+5qhjHvuNo05pG748hd5MVr9mItdxLn2tqWOyn02bOZOyn6sxevuZNib8wjd5HNnWR/zCN3QO0WNY8oGT9+vEaOHKm+ffuqX79+mjJligoLCzVq1Kga1RcUFFT4rdrWrVu1Zs0aNWjQQC1btjxt/ejRozVjxgzNnTtX6enp5c+qyszMVJ06dWrUw4QJEzR06FC1bNlSR44c0YwZM7R48WItWLCgRvXp6emVnk9Vt25dNWzYsMbPrXrggQd09dVXq1WrVtq1a5cmTpyoxMRE3XjjjTWqv++++3Teeedp0qRJ+ulPf6rly5frxRdf1Isvvlij+jKBQEDTp0/XyJEjlZQUNTGrUqxnLx5yJ4Ume+SOMY8x79TIHbmzJdazFw+5kzjX1rbcSebZi5bcSbGTvVjPnRQfYx65c5c7yX72yN0JsZI7IKo4UeTPf/6z07JlSyclJcXp16+fs2zZshrXfvzxx46kSsvIkSNrVF9VrSRn+vTpNe7h1ltvdVq1auWkpKQ4jRo1ci655BLngw8+qHF9VQYNGuSMHTu2xutff/31TrNmzZyUlBSnefPmzvXXX+9s2rTJ1T7/9a9/Od26dXO8Xq/TuXNn58UXX3TZteMsWLDAkeRs2LDBda0NsZy9eMmd45hnj9wx5jHmnR65q4zcRUYsZy9ecuc4nGtre+4cx132oiV3jhNb2Yvl3DlO/Ix55K7muXMc+9kjdyfEUu5iTV5eniPJGb7oZudny25nqcEyfNHNjiQnLy/P9pfvlDyO4zinmwQHAAAAAAAAgFiVn5+vzMxMDV90s5LrpthuJyaUFBbrrUv+rry8PGVkZNhup1r8rQMAAAAAAACAWiHgeBRwPLbbiAmxcpyi4k0mAQAAAAAAAABwiwluAAAAAAAAAEBMYoIbAAAAAAAAABCTmOAGAAAAAAAAAMQkJrgBAAAAAAAAADEpyXYDAAAAAAAAABAJASdBAYd7fmsiVo5T1HXp8/n06KOPyufzWamnh+jqIVLi5XjRQ+i2EQnR8LnSQ/T0EEnxcLzoIXQ9REq8HC/bPcTD5xBJ8XK86CF024iUeDhe9BC6HiIlGj5XeoieHoDaxOM4jmO7iZPl5+crMzNTeXl5ysjIiHg9PURXD5ESL8eLHkK3jUiIhs+VHqKnh0iKh+NFD6HrIVLi5XjZ7iEePodIipfjRQ+h20akxMPxoofQ9RAp0fC50kP09IDKyo7rjz4cpeS6KbbbiQklhcWafen0qM9i1N3BDQAAAAAAAABATTDBDQAAAAAAAACISRF/k8lAIKBdu3YpPT1dHo+n0sfz8/Mr/Nct03p6iGwPjuPoyJEjysrKUkJC+H7fEu7chWIb9BC5HsgdPdjoIVpyV5NeT6e2fM3ioYdI5U5izIuV+kj1EC1jXqwcL3oIzTaiJXc16fV0asvXLB56iKdzbSwcb3o4IZLZA6JdxJ/BvWPHDmVnZ0dyl4gBubm5atGiRdi2T+5QFXIHG8gdbAh37iSyh6ox5sEGcgcbONfClkhkL17k5x9/BvewD27lGdw1VFJYrLmXvRL1z+CO+B3c6enpkqS29z6iBG9qUNtoe/E24z6KSxON6ruesdu4h3qJZu+G+/CZG4x7WFd8zKj+K5/ZIFpU4NevBq0qz0W4lG2/y6tjlJjmDWobeVvqG/cRSPMb1adkmn29JOmffV82qj8UMD8JzMs726h+7sbuRvWBIp++++UfI5a7Xq/dHXTuDhyuZ9xH8rdpRvWJPfOMe+jQcL9Rfc+MHcY9rD3S3Kj+V1kLjOoLCwL6r3P3RCx3v/vofKXWC+40/+/8lsZ9rNjWyqg+cWtw1wgny+q/y6h+VIvPjHsw9Xl+R6P64sISvXbl7LDnTjqRvUFvjVJSWnDnij+0mmvcx4Nbf2xUn3vgDOMeUv5tNnYXdio27uHq7l8Z1e8vNstMSWGx5g6bGbEx74nFfYMe8y5J22Lcx/jvrjWqP7e+eQ+fHGhvVL95nfnkSP12h4zq72u30Ki+qMCvuy9cF7HcfbisierWC+6uya0lDYz7eGnHhUb1D7Wab9xDssfs55u/7LnYuIflm1ob1XdpbfazfWlhsT667tWInmvv/fBSeesmB7WNM5KOGvfRLmWvUf3rewcY93B94xVG9bP2nWPcg6lvFpqN2wHfMW357/8XkewB0S7iE9xlf0aT4E1VYpAT3KH4LUug1OxT99YL7mRSYRuJAaP6jHTzP0GpV2y2jTrJoYlQdX/aFypl209M8wY90ZiQaj7ZojpmF4CJZvOUkqR0w9yUBMxz5/Wbff8kpIXga6EI565ukLkrNv9cgx1ry+vTzH+xYjpup4ZgzE02/OVMvRCMuVLkcpdaLynoyZ5kv/l51vT7NDEEY25SkN93ZdLSzX4ZHgopAfPsS+HP3cn7SEpLCfrYh+L7zPTrnnDU/ribUCcE51rDcTPZF5q7miI55tUJcsxLr2t+vKPhPJdUZJj9EIy7wV5nlwnVuBup3NWtlxD0uJVWYv65mo53dUMw5iZ7zP4gPPlICK456phlN1R3cUbyXOutmxz0OJ+aZP4zfJrXLL/JBebH3HS8SC60f/eu6fVCmUhkD4h2PKQHAAAAAAAAABCTgprgnjp1qlq3bq3U1FT1799fy5cvD3VfQCXkDraQPdhA7mADuYMN5A62kD3YQO4AIPRcT3DPmjVL48eP18SJE7V69Wr17NlTl19+ufbt2xeO/gBJ5A72kD3YQO5gA7mDDeQOtpA92EDuACA8XE9wP/PMM7rjjjs0atQodenSRc8//7zS0tL0yiuvhKM/QBK5gz1kDzaQO9hA7mADuYMtZA82kDsgOgTkYXGxxAJXE9zFxcVatWqVhgwZcmIDCQkaMmSIvvjiiyprfD6f8vPzKyyAG+QOtrjNHrlDKJA72MC5FjaQO9jCuRY2MOYBQPi4muA+cOCA/H6/mjRpUuH1Jk2aaM+ePVXW5OTkKDMzs3zJzs4OvlvUSuQOtrjNHrlDKJA72MC5FjaQO9jCuRY2MOYBQPgE9SaTbkyYMEF5eXnlS25ubrh3CZA7WEHuYAO5gy1kDzaQO9hA7mAL2QOAmklys/KZZ56pxMRE7d27t8Lre/fuVdOmTaus8Xq98nq9wXeIWo/cwRa32SN3CAVyBxs418IGcgdbONfCBsY8AAgfV3dwp6SkqE+fPlq0aFH5a4FAQIsWLdKAAQNC3hwgkTvYQ/ZgA7mDDeQONpA72EL2YAO5A4DwcXUHtySNHz9eI0eOVN++fdWvXz9NmTJFhYWFGjVqVDj6AySRO9hD9mADuYMN5A42kDvYQvZgA7kDokPA8SjgeGy3ERNi5Ti5nuC+/vrrtX//fj3yyCPas2ePevXqpffff7/SGyUAoUTuYAvZgw3kDjaQO9hA7mAL2YMN5A4AwsP1BLckjRkzRmPGjAl1L8ApkTvYQvZgA7mDDeQONpA72EL2YAO5A4DQc/UMbgAAAAAAAAAAokVQd3CHQkKplJAYXO26r1qZ779hsVH9lpXZxj3cfsVCo/oun99k3MP7/Z43qv9/y642qg8UHZO03GgbbhR83UAJqalB1dbJM3/ukJNo+DulPkeNe7hr0w1G9SOaLzPuYeYnZm+i4tTzG9UHigJG9W61yTyo5LopQdUe/tL8zxWTCs3qj27KNO5BZ+4zKl+yv4NxC1v3NzCqn+wZalRfUlgs6W9G23Djk+87KPlYcLlrWfegeQN7vEblCT7zMfe7r7KM6tu122/cw93rRxjVJyeajXelhT6j+mCc22CrUuslB1XbNMhrw5NlphQZ1ZfuN8uNJDmNHaP61NzgvndP9mXz1kb1+/PqGdUHjh4zqndrRm4/JdUNbtxZ1aC18f7/94s2RvVfN29m3EPy1uCuccskBvdtW8GBnWbXDP/I7GdUf/xc+5XRNtx47eC58hYHd+Bmf93LeP+eA2Zjxa0HbjHu4bFe/zKqX7m0s3EPaUfMrhnWHzD7/g0ci+x4J0mz556vRG9w3/NtL9lqvP9nt15itoEQPNN39daWZi2Umt/vmXDYbEot1fDHUk9kf6wFohp3cAMAAAAAAAAAYpK1O7gBAAAAAAAAIJICjkeBEPwlQW0QK8eJO7gBAAAAAAAAADHJ9QT30qVLdfXVVysrK0sej0dz5swJQ1tAReQONpA72EDuYAvZgw3kDjaQO9hC9gAgPFxPcBcWFqpnz56aOnVqOPoBqkTuYAO5gw3kDraQPdhA7mADuYMtZA8AwsP1M7iHDh2qoUOHhqMXoFrkDjaQO9hA7mAL2YMN5A42kDvYQvYAIDzC/iaTPp9PPp+v/N/5+fnh3iVA7mAFuYMN5A62kD3YQO5gA7mDLWQPAGom7G8ymZOTo8zMzPIlOzs73LsEyB2sIHewgdzBFrIHG8gdbCB3sIXsAeERcDwsLpZYEPYJ7gkTJigvL698yc3NDfcuAXIHK8gdbCB3sIXswQZyBxvIHWwhewBQM2F/RInX65XX6w33boAKyB1sIHewgdzBFrIHG8gdbCB3sIXsAUDNhP0ObgAAAAAAAAAAwsH1HdwFBQXatGlT+b+3bt2qNWvWqEGDBmrZsmVImwPKkDvYQO5gA7mDLWQPNpA72EDuYAvZA4DwcD3BvXLlSg0ePLj83+PHj5ckjRw5Uq+++mrIGgNORu5gA7mDDeQOtpA92EDuYAO5gy1kDwDCw/UE90UXXSTHccLRC1AtcgcbyB1sIHewhezBBnIHG8gdbCF7QHQIOB4FHI/tNmJCrBwnnsENAAAAAAAAAIhJTHADAAAAAAAAAGKS60eUhErWn75Ukic5qNrc351nvP+SY6lmG8guMu7hhVUXGtX3bb/NuIdBC8cZ1XuKEs0aKIpsBFPyPEo8FtyfV2Q9+bnx/nf82jC7KzONe7jqpk+N6rf6Ghv34GlQbFSfvNXs+zdwzG9U79aaDzsr0Rtcz0k+8/03e8Ysu/vvGmDcw7qjHY3qS9ubj7l1V9Yxqj/YOM2ovtRnOF66tD63qRLSgsvdho3tjPdf94hZfdM/mY+52x8xG3NvmDXWuAdP60KjemdbXaP6wLFjRvXB+NsX5yuhTnDZSxtkPuj955MORvVp+eZ/htl8sll+t080v9bdv6KJUX1x41Kj+kBRZP8EPzv9sJLrpgRV+19n/Md4/1/1yjKq3/u1+fWVP7hPv1zbh78w7mHb42bXDP/5zOz7N9Jj3r++6hX8eNfgqPH+nQ1m18T+5sYt6HdzbzCqTyw2H3NbTDIbc/feYzbm+n2R//P9koyA/KmBoGo3ftraeP8XXPK1Uf2Xi7oa91DcxOw8lbojuPmok9XZa3aua/S8WXZLnRJtNNoCED+4gxsAAAAAAAAAEJOY4AYAAAAAAAAAxCRrjygBAAAAAAAAgEhyJAUU+ccLxaLIPnQueK7u4M7JydE555yj9PR0NW7cWNdee602bNhg3MTPna81wllf5cdGOOv1c8fs+U6IbeHKXSiQ3fgWzdkzQW6jW7zmLhTIbviQu/Aiu9Uje9EtXrNL7uJfNGaX3OF0ojG3QKxwNcG9ZMkSjR49WsuWLdOHH36okpISXXbZZSosNHsDpYA8ukXrK30jj3DW6xat57cqtVy4chcKZDe+RXP2TJDb6BavuQsFshs+5C68yG71yF50i9fskrv4F43ZJXc4nWjMLRArXD2i5P3336/w71dffVWNGzfWqlWrdOGFFwbdxBueLpIj3aL1knP832XfwK+qy/GPo9YKV+5CgezGt2jOnglyG93iNXehQHbDh9yFF9mtHtmLbvGaXXIX/6Ixu+QOpxONuQVihdEzuPPy8iRJDRo0qHYdn88nn89X/u/8/Pwq1zv5G/lnzjdKUYBvYFQplLkLBbJbe5wue5HMnSlyGzviKXehQHYjI9rOtfGA7NYMY170qQ3ZJXfxKdqzy7kWVYn23ALRytUjSk4WCAQ0btw4DRw4UN26dat2vZycHGVmZpYv2dnZ1a77hqeLipWgFAVUrAS+gVFJOHIXCmQ3/tUke5HOnSlyG/3iMXehQHbDK1rPtfGA7J4aY170iufskrv4Fq3Z5VyLU4nW3ALRLOgJ7tGjR2vdunWaOXPmKdebMGGC8vLyypfc3Nxq1x3hrC//Bk5RoNqH66P2CkfuQoHsxr+aZC/SuTNFbqNfPOYuFMhueEXruTYekN1TY8yLXvGcXXIX36I1u5xrcSrRmtt4EnA8LC6WWBDUI0rGjBmjd999V0uXLlWLFi1Oua7X65XX6z3tNn/4XKGyf5c9dwgIR+5CgezGv5pmL5K5M0Vuo1885i4UyG54Reu5Nh6Q3VNjzIte8ZxdchffojW7nGtxKtGaWyDauZrgdhxH99xzj2bPnq3FixerTZs2IWmiqofmV/VwfdRO4cpdKJDd+BbN2TNBbqNbvOYuFMhu+JC78CK71SN70S1es0vu4l80Zpfc4XSiMbdArHA1wT169GjNmDFDc+fOVXp6uvbs2SNJyszMVJ06dYJuIkFOlQ/NL/tGTpAT9LYR+8KVu1Agu/EtmrNngtxGt3jNXSiQ3fAhd+FFdqtH9qJbvGaX3MW/aMwuucPpRGNugVjhaoJ72rRpkqSLLrqowuvTp0/XLbfcEnQTr3m6VvsxfjuFcOUuFMhufIvm7Jkgt9EtXnMXCmQ3fMhdeJHd6pG96Bav2SV38S8as0vucDrRmFsgVrh+RAkQaeQOtpA92EDuYAO5gy1kDzaQO9hA7gAgfIJ6k0kAAAAAAAAAiDUBx6OA47HdRkyIleNkbYJ799j+SvSmBlVbUs/8N5/dz91kVP/v/21t3EOnDruM6vcX1TPu4fWLXjSq/+3mHxnVlxb6lGu0BXeK6ztKSA0uP7m/Pc94/36vWXZL2xwz7mFHcX2j+scbrzLu4c06ZxvVl3b0mzVw1Pw4ulHcvkgJacF97dO+Mn8e3957zbJbmmbcgv7rquVG9e9vPsu4h4LeRUb1G75tblQfKIps7hISHSUkBpe7NoO3Ge9/0xetjOp3Pmw+5jpJZmPur4bNNe5h2rcXGtV7exw1qvcX+rTNaAvu1d2epERvcJeYf2060Hj/JfXNzhHew+aXx6bXDE6CcQu66PI1RvWb8hsZ1ZcW+rTDaAvubM1roMRSb1C1/0o0uy6RpF07GxjVDxzwjXEPKz4yO1dufPZc4x68B81+CL7qii+M6n0FJZo60WgTrvTutE3JdVOCqt1TmGG8/z3dzMarBulm5xhJuvXqhUb1T753jXEPub8xv2Yw4fdZ2Gc9v5w6wZ3vhg02/3nug+2djepLss0Pmve74Mb8Mr525tfmgRSzHvxjzbLr9x2TpplfrwLxIASXzwAAAAAAAAAARB4T3AAAAAAAAACAmMQENwAAAAAAAAAgJrma4J42bZp69OihjIwMZWRkaMCAAZo/f364egMkkTvYQ/ZgA7mDDeQOtpA92EDuYAO5A4DwcTXB3aJFC02ePFmrVq3SypUrdfHFF2vYsGH6+uuvw9UfQO5gDdmDDeQONpA72EL2YAO5gw3kDogeAcfD4mKJBa7edvnqq6+u8O8//OEPmjZtmpYtW6auXbuGtDGgDLmDLWQPNpA72EDuYAvZgw3kDjaQOwAIH1cT3Cfz+/166623VFhYqAEDBlS7ns/nk8/nK/93fn5+sLsEyB2sqUn2yB1CjdzBBs61sIUxDzaQO9jAuRYAQsv1m0yuXbtW9erVk9fr1V133aXZs2erS5cu1a6fk5OjzMzM8iU7O9uoYdRO5A62uMkeuUOokDvYwLkWtjDmwQZyBxs41wJAeLie4O7UqZPWrFmjL7/8UnfffbdGjhyp9evXV7v+hAkTlJeXV77k5uYaNYzaidzBFjfZI3cIFXIHGzjXwhbGPNhA7mAD51oACA/XjyhJSUlR+/btJUl9+vTRihUr9Oyzz+qFF16ocn2v1yuv12vWJWo9cgdb3GSP3CFUyB1s4FwLWxjzYAO5gw2cawEgPIJ+BneZQCBQ4ZlQQCSQO9hC9mADuYMN5A62kD3YQO5gA7kD7Ag4HgUcj+02YkKsHCdXE9wTJkzQ0KFD1bJlSx05ckQzZszQ4sWLtWDBgnD1B5A7WEP2YAO5gw3kDraQPdhA7mADuQOA8HE1wb1v3z7dfPPN2r17tzIzM9WjRw8tWLBAl156abj6A8gdrCF7sIHcwQZyB1vIHmwgd7CB3AFA+Lia4H755ZfD1QdQLXIHW8gebCB3sIHcwRayBxvIHWwgdwAQPgm2GwAAAAAAAAAAIBhMcAMAAAAAAAAAYpKrR5SEUkldKZAaXO2Un0w33v+xQIpR/SPZ7xr3cPc3PzOq/7THW8Y9fFtyzKj+8XazjeoLjwQ01GgL7ng75ikxLbjPueTf9Y33f9aFW4zqv9qcbdxD1zo7jOr/U+w37mFQy81G9QsXnW1U7xxLNKp3y7PPK0+qN6jagg4lxvv37k42qvd0OWLcw3vfdjWqPyPjqHEPpR+faVR/qIdh9h2zcrc6Zu1Tct3gznX7CusZ77/5ObuM6vcubW7cg6+F2ffPk6svN+6hX+ttRvWrPu5sVB84ZnaeD0ZxfUcJqcEFPjvDfLzJ9Zld3tYb/L1xDwUfNzGqP9beZ9zDyr1m1wzNM/KN6kuSzc9fbjzT8S3VSw/u3p0WSaXG+z8nY6tR/QV1Nhn38NGPza6vpvzrKuMeBl+12qi+Q529RvVFfvOvpRud6u2Vt15w11lXnLnWeP9LMjsZ1f8+a75xDy8f6mdU3/7sXOMeNq1qabaB5kVG5YGjkT/X/uWiv6tuenA/0+wsNf+59o/9zb7Xr9hwhXEP9dqZnSvzfHWMe7i893qj+mn/Y3atGTgW4R8w4ojjeOQ4HtttxIRYOU7cwQ0AAAAAAAAAiElMcAMAAAAAAAAAYhIT3AAAAAAAAACAmGQ0wT158mR5PB6NGzcuRO0Ap0fuYAO5gy1kDzaQO9hA7mAL2YMN5A4AQifoCe4VK1bohRdeUI8ePULZD3BK5A42kDvYQvZgA7mDDeQOtpA92EDuACC0gprgLigo0IgRI/TSSy+pfn3zd+AFaoLcwQZyB1vIHmwgd7CB3MEWsgcbyB1gX0AeFhdLLAhqgnv06NG68sorNWTIkNOu6/P5lJ+fX2EBgkHuYAO5gy01zR65Qygx5sEGcgdbONfCBsY8AAi9JLcFM2fO1OrVq7VixYoarZ+Tk6PHHnvMdWPAycgdbCB3sMVN9sgdQoUxDzaQO9jCuRY2MOYBQHi4uoM7NzdXY8eO1RtvvKHU1NQa1UyYMEF5eXnlS25ublCNovYid7CB3MEWt9kjdwgFxjzYQO5gC+da2MCYBwDh4+oO7lWrVmnfvn3q3bt3+Wt+v19Lly7Vc889J5/Pp8TExAo1Xq9XXq83NN2iViJ3sIHcwRa32SN3CAXGPNhA7mAL51rYwJgHAOHjaoL7kksu0dq1ayu8NmrUKHXu3FkPPfRQpcEYCAVyBxvIHWwhe7CB3MEGcgdbyB5sIHcAED6uJrjT09PVrVu3Cq/VrVtXDRs2rPQ6ECrkDjaQO9hC9mADuYMN5A62kD3YQO6A6BFwPAo4HtttxIRYOU6unsENAAAAAAAAAEC0cHUHd1UWL14cgjYAd8gdbCB3sIXswQZyBxvIHWwhe7CB3AFAaHAHNwAAAAAAAAAgJhnfwR2sfpd8rZR6KUHV/m3PQOP9P9tyrlH9HVuGG/fQJuOgUf3MgkbGPVxXb49R/WrDHopKSyVtM9qGG3VTipXoDe75QcV9Dxjvf1dBhlH9GQ0LjHtYeKiLUf3NrcyPw8jcdkb1JY1LjOoDRWb1bvnrBOTUCQRVm5zhM97/j8/50qi+pfd74x7uOmOnUf1v93U37qHo9mSj+tUHs43qSwt92mG0BXe2HWygxGPeoGrXnftGiLtx789ZrYy3sbGosVH9f2etMO5ha4nZuP2Pa3YZ1R8rKNEffm+0Cfeyj0ppwY15Vzf7j/Hux3XZZlT/wVGzsUKS/tmwr1F9nUTz89RvGy8xqj8Y3JewXMGRgD4w24Qrv1g3QolpwY15H/X5q/H+O6aYXVOflZJm3MNXPrPxpmH3/cY9NEo5YlR/Z6bZmJefENB4oy24811RAyUnBPcz7ZytPYz3/0z3N43qUzzmz1Wd2Gi9Uf28tG3GPbyaZDY/cH6DzUb1xwpK9TujLbjnc5KV6AT3ppSXp2033v+bBVlG9U3qmI0VkvTJFrOfKZ8+523jHl7Zdb5R/dkDvzWqLyksjuBsChDduIMbAAAAAAAAABCTrN3BDQAAAAAAAACR5DgeOY75X7HUBrFynLiDGwAAAAAAAAAQk1xNcD/66KPyeDwVls6dO4erN0ASuYM9ZA82kDvYQO5gC9mDDeQONpA7ALXJ1KlT1bp1a6Wmpqp///5avnz5Kdc/fPiwRo8erWbNmsnr9apjx4567733arw/148o6dq1qxYuXHhiA0k85QThR+5gC9mDDeQONpA72EL2YAO5gw3kDkBtMGvWLI0fP17PP/+8+vfvrylTpujyyy/Xhg0b1Lhx40rrFxcX69JLL1Xjxo319ttvq3nz5vruu+90xhln1HifrkfTpKQkNW3a1G0ZYITcwRayBxvIHWwgd7CF7MEGcgcbyB2A2uCZZ57RHXfcoVGjRkmSnn/+ef3P//yPXnnlFT388MOV1n/llVd08OBBff7550pOTpYktW7d2tU+XT+De+PGjcrKylLbtm01YsQIbd++/ZTr+3w+5efnV1gAt8gdbHGTPXKHUCF3sIFzLWxhzIMN5A42cK4FEKt+OBb5fL4q1ysuLtaqVas0ZMiQ8tcSEhI0ZMgQffHFF1XWzJs3TwMGDNDo0aPVpEkTdevWTZMmTZLf769xf64muPv3769XX31V77//vqZNm6atW7fqggsu0JEjR6qtycnJUWZmZvmSnZ3tZpcAuYM1brNH7hAK5A42cK6FLYx5sIHcwQbOtUD0CDgeFheLJGVnZ1cYj3Jycqo8tgcOHJDf71eTJk0qvN6kSRPt2bOnypotW7bo7bfflt/v13vvvaff/e53+uMf/6jHH3+8xl9TV48oGTp0aPn/9+jRQ/3791erVq305ptv6rbbbquyZsKECRo/fnz5v/Pz8xmU4Qq5gy1us0fuEArkDjZwroUtjHmwgdzBBs61AGJZbm6uMjIyyv/t9XpDtu1AIKDGjRvrxRdfVGJiovr06aOdO3fqqaee0sSJE2u0DaN3NDjjjDPUsWNHbdq0qdp1vF5vSD9pgNzBltNlj9whHMgdbOBcC1sY82ADuYMNnGsBxJKMjIwKE9zVOfPMM5WYmKi9e/dWeH3v3r3VvgdBs2bNlJycrMTExPLXzjrrLO3Zs0fFxcVKSUk57X5dP4P7ZAUFBdq8ebOaNWtmshnAFXIHW8gebCB3sIHcwRayBxvIHWwgdwDiUUpKivr06aNFixaVvxYIBLRo0SINGDCgypqBAwdq06ZNCgQC5a99++23atasWY0mtyWXE9wPPPCAlixZom3btunzzz/Xj370IyUmJurGG290sxnAFXIHW8gebCB3sIHcwRayBxvIHWwgdwBqi/Hjx+ull17S3/72N/3v//6v7r77bhUWFmrUqFGSpJtvvlkTJkwoX//uu+/WwYMHNXbsWH377bf6n//5H02aNEmjR4+u8T5dPaJkx44duvHGG/X999+rUaNGOv/887Vs2TI1atTIzWYAV8gdbCF7sIHcwQZyB1vIHmwgd7CB3AGoLa6//nrt379fjzzyiPbs2aNevXrp/fffL3/jye3btysh4cQ919nZ2VqwYIHuu+8+9ejRQ82bN9fYsWP10EMP1Xifria4Z86c6WZ1ICTIHWwhe7CB3MEGcgdbyB5sIHewgdwB0cNxPHIcj+02YkKwx2nMmDEaM2ZMlR9bvHhxpdcGDBigZcuWBbUvyfAZ3AAAAAAAAAAA2MIENwAAAAAAAAAgJrl6REkoffpVJyXUSQ2qtn/PTcb7/6/VdxjVp3mLjXvYuNfsWVvNUvOMeyhxEo3q39jZ36i+tNAnaZXRNtxISfQrKdEfVO2RouDyerKiwpq9+2t1EneY97At1WdUP+lAJ+MeOjfaa1T/n286GNUHjgWXgWClHEpUQlFw32s9e+w03v9uX6ZRfbvUfcY93Lb9fKP6Xum5xj0888XlRvVtO+wxqk/wOEb1bqUklSoxKbjc7SgtMN5/4PSrnNLekgzjHr7Y08ao/peG50hJOiPpqFH99qIGRvUlhebXK673eTRZCU5yULVpCeb9XrHhCqP6/g22Gfew8NvORvXO917jHpZ1aG1Un+k9ZlR//BpvmtE23Cg4XEcJvuCuk85ZeK/x/q/rudqoPsHzb+MePs3vaFS/N7e+cQ/v+Hoa1V+S/rVRfaFZbF1b/X4XJXqDy13jQbuM93/H/9xuVP/wpf8y7qGz1+zzeP9wD+Mevsszy25hSRej+uPj3UdG23DryS2XK6lucOeKtpkHjPf/yddm403y/uCuE07Wpt8Oo/pff3WtcQ/P9HrLqP7uhSON6gNFER70gCjGHdwAAAAAAAAAgJjEBDcAAAAAAAAAICZZe0QJAAAAAAAAAESS43gUcDy224gJTowcJ9d3cO/cuVM33XSTGjZsqDp16qh79+5auXJlOHoDypE72EL2YAO5gw3kDjaQO9hC9mADuQOA8HB1B/ehQ4c0cOBADR48WPPnz1ejRo20ceNG1a9v/oYkQHXIHWwhe7CB3MEGcgcbyB1sIXuwgdwBQPi4muB+4oknlJ2drenTp5e/1qZNm5A3BZyM3MEWsgcbyB1sIHewgdzBFrIHG8gdAISPq0eUzJs3T3379tXw4cPVuHFjnX322XrppZdOWePz+ZSfn19hAdwgd7DFbfbIHUKB3MEGzrWwgdzBFs61sIExDwDCx9UE95YtWzRt2jR16NBBCxYs0N133617771Xf/vb36qtycnJUWZmZvmSnZ1t3DRqF3IHW9xmj9whFMgdbOBcCxvIHWzhXAsbGPMAIHxcTXAHAgH17t1bkyZN0tlnn60777xTd9xxh55//vlqayZMmKC8vLzyJTc317hp1C7kDra4zR65QyiQO9jAuRY2kDvYwrkWNjDmAdHDkeQ4LDVabH+xasjVBHezZs3UpUuXCq+dddZZ2r59e7U1Xq9XGRkZFRbADXIHW9xmj9whFMgdbOBcCxvIHWzhXAsbGPMAIHxcTXAPHDhQGzZsqPDat99+q1atWoW0KeBk5A62kD3YQO5gA7mDDeQOtpA92EDuACB8XE1w33fffVq2bJkmTZqkTZs2acaMGXrxxRc1evTocPUHkDtYQ/ZgA7mDDeQONpA72EL2YAO5A4DwcTXBfc4552j27Nn6xz/+oW7duun3v/+9pkyZohEjRoSrP4DcwRqyBxvIHWwgd7CB3MEWsgcbyB0AhE+S24KrrrpKV111VTh6AapF7mAL2YMN5A42kDvYQO5gC9mDDeQOAMLD9QQ3AAAAAAAAAMSigDzyyGO7jZgQiJHjZG2C+4zm+UpM8wVVu/douvH+z83aZlS/+MNexj0kdjpiVD9nfU/jHhaf0d6o/tChekb1gaJjRvVudau/Wyn1koOqPb/1t8b7n7mnn1H9GifbuIc9B83eeXtjZmPjHr7Z38SoPtC6yKz+aGRz16TPHiXV9QZVWz/lqPH+P9/Zxqj+i+2tjXvwFQT3+Zf5uLCrcQ9K8xuV7zyYaVTvj3Du8g7VVcKx1KBqUzzmFzFTDgwwqv94TwfjHvK/amhUP7+R2ddckvp33WxUX+xPNKovKXWM6oPhSQ7IkxwIqnb6NrPcSFKfM3cY1b/2tdm5WpICJa6eAlhZqtl4JUl1kkuM6g8WpRnV+4+ZZde1gOf4EoQre6w13v2cb8yuyxv3yDfuocgf3DVumYQi869ZaanZNsauvcGo3n/UJ+kpo2248dCNbyutXnCf81PfXmq8//8a8JVR/aydfY17GJ61yqh+3zGznycl6dC2+kb1x7LMvneO5y6y2mUeUEq9lKBqD/nMxndJatr8kFH9gYPmP1Nu2X2mUX3PlmbXC5J09yc3mW3A9DIt8pd5QNQyvPoGAAAAAAAAAMAOJrgBAAAAAAAAADGJCW4AAAAAAAAAQExyNcHdunVreTyeSsvo0aPD1R8giezBDnIHG8gdbCB3sIXswQZyBxvIHQCEj6s3mVyxYoX8/hNverNu3TpdeumlGj58eMgbA05G9mADuYMN5A42kDvYQvZgA7mDDeQOiB6O45HjBPfm1LVNrBwnVxPcjRo1qvDvyZMnq127dho0aFBImwJ+iOzBBnIHG8gdbCB3sIXswQZyBxvIHQCEj6sJ7pMVFxfr9ddf1/jx4+XxVD+b7/P55PP5yv+dn58f7C4BSTXLHrlDqJE72EDuYAPXeLCFMQ82kDvYwLkWAEIr6DeZnDNnjg4fPqxbbrnllOvl5OQoMzOzfMnOzg52l4CkmmWP3CHUyB1sIHewgWs82MKYBxvIHWzgXAsAoRX0BPfLL7+soUOHKisr65TrTZgwQXl5eeVLbm5usLsEJNUse+QOoUbuYAO5gw1c48EWxjzYQO5gA+daAAitoB5R8t1332nhwoV65513Truu1+uV1+sNZjdAJTXNHrlDKJE72EDuYAPXeLCFMQ82kDvYwLkWAEIvqAnu6dOnq3HjxrryyitD3Q9wSmQPNpA72EDuYAO5gy1kDzaQO9hA7gD7Ao5HHqf659/jhECMHCfXjygJBAKaPn26Ro4cqaSkoN+jEnCN7MEGcgcbyB1sIHewhezBBnIHG8gdAISH6wnuhQsXavv27br11lvD0Q9QLbIHG8gdbCB3sIHcwRayBxvIHWwgdwAQHq5/ZXjZZZfJcZxw9AKcEtmDDeQONpA72EDuYAvZgw3kDjaQOwAID9d3cAMAAAAAAAAAEA0i/tCnst9W+o/6gt5GaSD42jLFicVG9YFjx4x70FGzbQSK/MYt+FPMjmWgyCxCgaLj+w/3b7HLtl9cWBL0No56zI93SaFh7orMcxcoMfs8igvMPgfJ7PtfkgLHzD6HSOeu9Gjwx6w4yf7x9peY/y40UGR2rD1FicY9OIbfw/5E0/Eysrkr218wjhwJGPfhKwh+vJUkf6H5ud70XB0oKjXuwXTcL/GbZb9s/5G4WywU2QvF17041Sx7AcPrM0kKFBuOWcXm426p4bH0G55+ys49kRvzgv+6FRuOV5J5bo4VmI83ptdoofj5xm94HPylZsch0rkrKgj+2sL0+kwy/5qbjhOSVGSYXdPzpGT+M5LxtXKEcnfyPkoMfq4tKTafBjL/eS4E51rD8SYasqdjZtcLZceRvwoAJI8T4e+EHTt2KDs7O5K7RAzIzc1VixYtwrZ9coeqkDvYQO5gQ7hzJ5E9VI0xDzaQO9jAuRa2RCJ78SI/P1+ZmZnqOutXSkzz2m4nJviP+vT19U8pLy9PGRkZttupVsTv4M7KylJubq7S09Pl8XgqfTw/P1/Z2dnKzc0N6sCZ1tNDZHtwHEdHjhxRVlZWUD3WVLhzF4pt0EPkeiB39GCjh2jJXU16PZ3a8jWLhx4ilTuJMS9W6iPVQ7SMebFyvOghNNuIltzVpNfTqS1fs3joIZ7OtbFwvOnhhEhmD4h2EZ/gTkhIqNFvljIyMox+M2BaTw+R6yEzMzPobddUpHIXim3QQ2R6IHf0YKOHaMqdFP3Hix5CUx+J3EmMebFWH4keomnMi4XjRQ+h2UY05U6K/uNFD6Gpj7dzbbQfb3o4IVLZA6IdbzIJAAAAAAAAAIhJTHADAAAAAAAAAGJS1E1we71eTZw4UV5vcA97N62nh+jqIVLi5XjRQ+i2EQnR8LnSQ/T0EEnxcLzoIXQ9REq8HC/bPcTD5xBJ8XK86CF024iUeDhe9BC6HiIlGj5XeoieHoDaxOM4jmO7CQAAAAAAAAAIl/z8fGVmZqrLzAeVmMYvD2rCf9Sn9Tc8qby8PONn0odT1N3BDQAAAAAAAABATTDBDQAAAAAAAACISUxwAwAAAAAAAABiEhPcAAAAAAAAAICYxAQ3AAAAAAAAACAmJdluAAAAAAAAAAAiwXE8chyP7TZiQqwcJ+7gBgAAAAAAAADEJCa4AQAAAAAAAAAxiQluAAAAAAAAAEBMYoIbAAAAAAAAABCTmOAGAAAAAAAAAMSkJNsNAAAAAAAAAEAkBByPPI7HdhsxIRAjxymu7+BesWKFzjvvPNWtW1cej0dr1qyx3dJpPfnkk+rcubMCgUDE9/3www+rf//+Ed9vvCF37jz//PNq2bKlfD5fxPcdT8idO+QudMieO2QvNMidO1zjhQa5c4fchQ7Zc4fshQa5c4fcAXbF7QR3SUmJhg8froMHD+pPf/qTXnvtNbVq1cp2W6eUn5+vJ554Qg899JASEk58ae677z717t1bDRo0UFpams466yw9+uijKigoqPG2582bp969eys1NVUtW7bUxIkTVVpaWmGdcePG6auvvtK8efNC9jnVNuTuhFmzZummm25Shw4d5PF4dNFFF1W53i233KLi4mK98MILofh0aiVyd9z333+vp556ShdeeKEaNWqkM844Q+eee65mzZpVaV1yFxpk74Sa1pM9c+Suaps3b1Zqaqo8Ho9WrlxZ4WNc45kjdye0bt1aHo+n0nLXXXdVWI/chQbZq+jIkSN68MEH1aZNG3m9XjVv3lzXXXedjh49Wr4O2TNH7o5bvHhxleNd2fKHP/yhfF1yB9jlcRzHsd1EOHzzzTc666yz9NJLL+n222+33U6NTJkyRRMnTtTevXuVmppa/vr555+vPn36qH379kpNTdW///1vvfLKK+rbt6+WLl1aYfCuyvz583XllVfqoosu0o033qi1a9dq6tSpuvPOOzVt2rQK615//fXavXu3li5dGpbPMd6RuxMuuugirVq1Suecc47WrFmjHj16aPHixVWu+9BDD2nWrFnaunWrPJ7Y+POXaELujnv33Xf14x//WFdccYUGDx6spKQk/fOf/9THH3+sRx55RI899liF9cmdObKnoOrJnhlyV7VrrrlGH330kQoLC7VixQr17du3wse5xjND7k5o3bq16tevr/vvv7/C6x07dlS/fv0qvEbuzJG9E/Ly8jRo0CDt2LFDd955p9q3b6/9+/frk08+0Wuvvab69euXr0v2zJC74/bu3asPP/yw0uuvvfaaPvjgAy1fvlznnHNO+evkLvrl5+crMzNTnWY8rMQ0r+12YoL/qE8bfjZZeXl5ysjIsN1OteL2Gdz79u2TJJ1xxhmnXbewsFB169YNc0enN336dF1zzTUVBmNJ+vTTTyut265dOz3wwANavny5zj333FNu94EHHlCPHj30wQcfKCnp+Jc8IyNDkyZN0tixY9W5c+fydX/6059q+PDh2rJli9q2bRuCz6p2IXcnvPbaa2revLkSEhLUrVu3U67705/+VE8++aQ+/vhjXXzxxe4/iVqO3B3XtWtXbdy4scLdJb/85S81ZMgQPfHEE3rwwQcrfO7kzhzZC66e7Jkhd5UtWLBACxYs0IMPPqjHH3+8ynW4xjND7ipq3ry5brrpptOuR+7Mkb0TJkyYoO+++06rV69WmzZtyl9/6KGHKq1L9syQu+OaNGlS5Vj32GOPqUOHDhUmtyVyB9gUl48oueWWWzRo0CBJ0vDhwys8HuGWW25RvXr1tHnzZl1xxRVKT0/XiBEjJB0fmO+//35lZ2fL6/WqU6dOevrpp/XDm9w9Ho/GjBmjt956S126dFGdOnU0YMAArV27VpL0wgsvlP928KKLLtK2bdtO2/PWrVv1n//8R0OGDKnR59i6dWtJ0uHDh0+53vr167V+/Xrdeeed5ZPb0vFJH8dx9Pbbb1dYv2z/c+fOrVEfOIHcVZSdnV3jO8/69OmjBg0akLsgkLsT2rRpU+lPJz0ej6699lr5fD5t2bKlwsfInRmyF3w92QseuauspKREY8eO1dixY9WuXbtq1+MaL3jkrmrFxcUqLCw85TrkzgzZO+Hw4cOaPn267rzzTrVp00bFxcWnfD8Lshc8cndqy5cv16ZNm8o/75ORO8CeuLyD+xe/+IWaN2+uSZMm6d5779U555yjJk2alH+8tLRUl19+uc4//3w9/fTTSktLk+M4uuaaa/Txxx/rtttuU69evbRgwQL96le/0s6dO/WnP/2pwj4++eQTzZs3T6NHj5Yk5eTk6KqrrtKDDz6ov/zlL/rlL3+pQ4cO6cknn9Stt96qjz766JQ9f/7555Kk3r17V/nx0tJSHT58WMXFxVq3bp1++9vfKj09vdKfAf7Qv//9b0mq9GeqWVlZatGiRfnHy2RmZqpdu3b67LPPdN99951y26iI3Jnp3bu3Pvvss5BvN96Ru9Pbs2ePJOnMM8+s9DFyFzyyZ1ZP9oJD7iqbMmWKDh06pN/+9rd65513ql2Pa7zgkbvKPvroI6Wlpcnv96tVq1a67777NHbs2ErrkTszZO+ETz/9VMeOHVP79u113XXXac6cOQoEAhowYICmTp2qXr16VVif7AWP3J3aG2+8IUlVTnCTu9jhOMcXnF6sHKe4nOAeMGCAfD6fJk2apAsuuEDXXXddhY/7fD4NHz5cOTk55a/NnTtXH330kR5//HH95je/kSSNHj1aw4cP17PPPqsxY8ZUuCtmw4YN+uabb8p/81e/fn394he/0OOPP65vv/1W6enpkiS/36+cnBxt27atfN2qfPPNN5JU4U+tTrZy5UoNGDCg/N+dOnXSvHnz1KBBg1Mei927d0uSmjVrVuljzZo1065duyq93rZtW61fv/6U20Vl5M5M27Zt9dprr4V8u/GO3J3awYMH9de//lUXXHBBleMguQse2TOrJ3vBIXcV7dmzR7///e/19NNP1+iZiFzjBYfcVdSjRw+df/756tSpk77//nu9+uqrGjdunHbt2qUnnnii0vrkLnhk74SNGzdKOv6Yknbt2unvf/+78vLy9Nhjj+niiy/W119/Xelaj+wFh9xVz+/3a9asWerXr5/at29f5TrkDrAjLh9RUhN33313hX+/9957SkxM1L333lvh9fvvv1+O42j+/PkVXr/kkksqDLD9+/eXJP3kJz8pH4xPfv2Hfxr/Q99//72SkpJUr169Kj/epUsXffjhh5ozZ075c2Rr8q6/RUVFkiSvt/LD81NTU8s/frL69evrwIEDp9023KstuQtG/fr1VVRUVOEd0BEatTV3gUBAI0aM0OHDh/XnP/+5ynXIXXjVtuy5qSd74VObcvfQQw+pbdu2NX4DMK7xwqc25W7evHl68MEHNWzYMN16661asmSJLr/8cj3zzDPasWNHpfXJXXjVluyVrePxeLRo0SL97Gc/09133605c+bo0KFDmjp1aqUashc+tSV3P7Ro0SLt3bu3yru3y5A7wI64vIP7dJKSktSiRYsKr3333XfKysqqMJhK0llnnVX+8ZO1bNmywr8zMzMlHX/ucFWvHzp0yKjnjIyM8uc5DRs2TDNmzNCwYcO0evVq9ezZs9q6OnXqSFKVzyc7duxY+cdP5jiOPB6PUb+orDblLhhlz2Yje6FVm3N3zz336P3339ff//73auvIXfjUxuy5qSd74VGbcrds2TK99tprWrRoUY3f84JrvPCoTbmrisfj0X333acFCxZo8eLFld6QjdyFT23KXtnPrVdffXWFScxzzz1Xbdq0KX9ExcnIXnjUptz90BtvvKHExERdf/311a5D7gA7auUd3F6vt8Y/CFQnMTHR1es/fGOFH2rYsKFKS0t15MiRGu3/xz/+sSRp5syZp1yv7M+0yh5VcrLdu3crKyur0uuHDh2q8lm1MFObcheMQ4cOKS0trcpfuiB4tTV3jz32mP7yl79o8uTJ+vnPf17teuQufGpr9mpaT/bCozbl7sEHH9QFF1ygNm3aaNu2bdq2bVv5HWO7d+/W9u3bK9VwjRcetSl31SmblDp48GClj5G78KlN2Sv7ufXkZ0GXady4cZUToGQvPGpT7k5WVFSk2bNna8iQIVXmsAy5A+yolRPcVWnVqpV27dpVaUAse5ZTq1atwrr/zp07Szr+7r814fP5FAgElJeXd8r1yt5sY+XKlRVe37Vrl3bs2FHpzTjKeij7TSvCK15zFwxyFznxnrupU6fq0Ucf1bhx4/TQQw+dcl1yF1nxnj039WQvcuI1d9u3b9fSpUvVpk2b8uVXv/qVJOmaa65Rjx49KtWQu8iJ19xVp+zxAY0aNar0MXIXWfGavT59+kiSdu7cWelju3btInuWxWvuTjZv3jwdOXLklI8nKeuB3AGRxwT3/7niiivk9/v13HPPVXj9T3/6kzwej4YOHRrW/Ze94cEPJ6IPHz6skpKSSuv/9a9/lST17dv3lNvt2rWrOnfurBdffFF+v7/89WnTpsnj8VR6w4i8vDxt3rxZ5513XlCfB9yJ19wFY/Xq1eQuQuI5d7NmzdK9996rESNG6Jlnnjnt+uQusuI1e8HUk73Iidfcvfjii5o9e3aF5Z577pEkPf3003rjjTcqrM81XmTFa+4OHjxY4WcKSSopKdHkyZOVkpKiwYMHV/gYuYu8eM1ep06d1LNnT82dO7fC840/+OAD5ebm6tJLL62wPtmLrHjN3clmzJihtLQ0/ehHP6p2HXIXOxxHchwPS40W21+tmqmVz+CuytVXX63BgwfrN7/5jbZt26aePXvqgw8+0Ny5czVu3LgK7/gbDm3btlW3bt20cOFC3XrrreWvL168WPfee6+uu+46dejQQcXFxfrkk0/0zjvvqG/fvpWecefxeDRo0CAtXry4/LWnnnpK11xzjS677DLdcMMNWrdunZ577jndfvvtlX6zuHDhQjmOo2HDhoX188Vx8Zy7pUuXaunSpZKk/fv3q7CwUI8//rgk6cILL9SFF15Yvu6qVat08OBBchch8Zq75cuX6+abb1bDhg11ySWXVJrcOe+889S2bdvyf5O7yIvX7LmtJ3uRFa+5u+yyyyrt6/Dhw5KkQYMGVfqhnWu8yIrX3M2bN0+PP/64rrvuOrVp00YHDx7UjBkztG7dOk2aNElNmzatUE/uIi9esycdnyy99NJLdf755+sXv/iF8vLy9Mwzz6hjx46V3vSQ7EVWPOdOOv7Lvfnz5+snP/lJtW9kKZE7wCYmuP9PQkKC5s2bp0ceeUSzZs3S9OnT1bp1az311FO6//77I9LDrbfeqkceeURFRUXlz+Ts3r27Bg8erLlz52r37t1yHEft2rXTI488ol/96ldKSUkpry97F+Cy526Xueqqq/TOO+/oscce0z333KNGjRrp17/+tR555JFKPbz11ls6//zzw34CwnHxnLuPPvpIjz32WIXXfve730mSJk6cWGGC+6233lLLli118cUXh+VzREXxmrv169eruLhY+/fvr3BhW2b69OkVJrjJXeTFa/bc1EtkL9LiNXducY0XWfGau+7du6tLly56/fXXtX//fqWkpKhXr1568803NXz48Eo9kLvIi9fsSdLgwYP1/vvv63e/+51+/etfKy0tTddee62efPLJSpOOZC+y4jl30vE8lZSU6Gc/+9kpeyB3gD0e53RP60fE5OXlqW3btnryySd12223ua5/7733dNVVV+mrr75S9+7dXdfv2bNHbdq00cyZM/mNYy1iO3c+n0+tW7fWww8/rLFjx7quR2wid7CF7MEG27njGq92InewhezBBnKHmsjPz1dmZqY6vP6wEtNSbbcTE/xHj2njTZOVl5enjIwM2+1Ui2dwR5HMzEw9+OCDeuqppxQIBFzXf/zxx7rhhhuCGowlacqUKerevTuDcS1jO3fTp09XcnKy7rrrrqDqEZvIHWwhe7DBdu64xqudyB1sIXuwgdwBtRt3cAMAAAAAAACIa9zB7V6s3MHNM7gBAAAAAAAA1AqO45HjeGy3ERNi5TjxiBIAAAAAAAAAQExighsAAAAAAAAAEJOY4AYAAAAAAAAAxCQmuAEAAAAAAAAAMYkJbgAAAAAAAABATIqqCe6pU6eqdevWSk1NVf/+/bV8+fIa1y5dulRXX321srKy5PF4NGfOHFf7zsnJ0TnnnKP09HQ1btxY1157rTZs2OBqG9OmTVOPHj2UkZGhjIwMDRgwQPPnz3e1jZNNnjxZHo9H48aNq3HNo48+Ko/HU2Hp3Lmzq/3u3LlTN910kxo2bKg6deqoe/fuWrlyZY3rW7duXakHj8ej0aNHu+ojkmI5e/GSO8kse+Rujqt9M+adUNvGPHJXEbmLnFjOXrzkTuJcW5tzJ7nPXjTkToq97MVy7qT4GfPIXc1zJ9nPHrk7LtZyF6scFldLLIiaCe5Zs2Zp/PjxmjhxolavXq2ePXvq8ssv1759+2pUX1hYqJ49e2rq1KlB7X/JkiUaPXq0li1bpg8//FAlJSW67LLLVFhYWONttGjRQpMnT9aqVau0cuVKXXzxxRo2bJi+/vpr1/2sWLFCL7zwgnr06OG6tmvXrtq9e3f58umnn9a49tChQxo4cKCSk5M1f/58rV+/Xn/84x9Vv359V72fvP8PP/xQkjR8+HDXn0skxHr24iF3knn2yJ07jHnH1bYxj9xVRO4iJ9azFw+5kzjX1ubcScFnz3buynqPlezFeu6k+BjzyJ273En2s0fuTvQeK7kDoonHcZyomIzv37+/zjnnHD333HOSpEAgoOzsbN1zzz16+OGHXW3L4/Fo9uzZuvbaa4PuZ//+/WrcuLGWLFmiCy+8MOjtNGjQQE899ZRuu+22GtcUFBSod+/e+stf/qLHH39cvXr10pQpU2pU++ijj2rOnDlas2ZNUP0+/PDD+uyzz/TJJ58EVV+VcePG6d1339XGjRvl8XhCtt1QicfsxVrupNBnj9y5w5hXO8Y8cncCuYuseMxerOVO4lxbW3MnBZ+9aMydFN3Zi8fcSbE35pG74HMnRU/2yF10edhmiQABAABJREFU5y4W5efnKzMzU+1em6DEtFTb7cQE/9Fj2vzzHOXl5SkjI8N2O9WKiju4i4uLtWrVKg0ZMqT8tYSEBA0ZMkRffPGFlZ7y8vIkHR9Qg+H3+zVz5kwVFhZqwIABrmpHjx6tK6+8ssLxcGPjxo3KyspS27ZtNWLECG3fvr3GtfPmzVPfvn01fPhwNW7cWGeffbZeeumloPqQjn9tX3/9dd16661RORjHW/ZiNXdSaLNH7txjzIv/MY/cVUTuIifesheruZM419bW3Elm2Yum3EnRnb14y50Uu2MeubObO6l2nmtrU+6AaBMVE9wHDhyQ3+9XkyZNKrzepEkT7dmzJ+L9BAIBjRs3TgMHDlS3bt1c1a5du1b16tWT1+vVXXfdpdmzZ6tLly41rp85c6ZWr16tnJwct21LOv6b21dffVXvv/++pk2bpq1bt+qCCy7QkSNHalS/ZcsWTZs2TR06dNCCBQt09913695779Xf/va3oPqZM2eODh8+rFtuuSWo+nCLl+zFeu6k0GaP3LnDmFc7xjxydwK5i6x4yV6s507iXCvVvtxJZtmLttxJ0Z29eMmdFPtjHrmzlzup9p5ra1PugGiTZLuBaDR69GitW7fO9fPlJKlTp05as2aN8vLy9Pbbb2vkyJFasmRJjQbl3NxcjR07Vh9++KFSU4P7U4mhQ4eW/3+PHj3Uv39/tWrVSm+++WaN/qwnEAiob9++mjRpkiTp7LPP1rp16/T8889r5MiRrvt5+eWXNXToUGVlZbmurY2CzV6s504KbfbInTuMeYx5NpA7cmcL51rOtTbYyJ1knr1oy51E9tzgXEvubKmt51pyB9gTFXdwn3nmmUpMTNTevXsrvL537141bdo0or2MGTNG7777rj7++GO1aNHCdX1KSorat2+vPn36KCcnRz179tSzzz5bo9pVq1Zp37596t27t5KSkpSUlKQlS5bov//7v5WUlCS/3++6nzPOOEMdO3bUpk2barR+s2bNKp08zjrrLNd/iihJ3333nRYuXKjbb7/ddW2kxEv2Yj13UuiyR+7cYcyrPWMeuTuO3EVevGQv1nMnca6ValfupNBnz2bupOjPXrzkTor9MY/c2cmdVLvPtbUpd7HOcTwsLpZYEBUT3CkpKerTp48WLVpU/logENCiRYuCesZcMBzH0ZgxYzR79mx99NFHatOmTUi2GwgE5PP5arTuJZdcorVr12rNmjXlS9++fTVixAitWbNGiYmJrvdfUFCgzZs3q1mzZjVaf+DAgdqwYUOF17799lu1atXK9b6nT5+uxo0b68orr3RdGynxmr1Yy50UuuyRu5phzDuuNo155O44chd58Zq9WMudxLm2tuVOCn32bOZOiv7sxWvupNgb88hdZHMn2R/zyB1Qu0XNI0rGjx+vkSNHqm/fvurXr5+mTJmiwsJCjRo1qkb1BQUFFX6rtnXrVq1Zs0YNGjRQy5YtT1s/evRozZgxQ3PnzlV6enr5s6oyMzNVp06dGvUwYcIEDR06VC1bttSRI0c0Y8YMLV68WAsWLKhRfXp6eqXnU9WtW1cNGzas8XOrHnjgAV199dVq1aqVdu3apYkTJyoxMVE33nhjjervu+8+nXfeeZo0aZJ++tOfavny5XrxxRf14osv1qi+TCAQ0PTp0zVy5EglJUVNzKoU69mLh9xJockeuWPMY8w7NXJH7myJ9ezFQ+4kzrW1LXeSefaiJXdS7GQv1nMnxceYR+7c5U6ynz1yd0Ks5A6IKk4U+fOf/+y0bNnSSUlJcfr16+csW7asxrUff/yxI6nSMnLkyBrVV1UryZk+fXqNe7j11ludVq1aOSkpKU6jRo2cSy65xPnggw9qXF+VQYMGOWPHjq3x+tdff73TrFkzJyUlxWnevLlz/fXXO5s2bXK1z3/9619Ot27dHK/X63Tu3Nl58cUXXXbtOAsWLHAkORs2bHBda0MsZy9ecuc45tkjd4x5jHmnR+4qI3eREcvZi5fcOQ7n2tqeO8dxl71oyZ3jxFb2Yjl3jhM/Yx65q3nuHMd+9sjdCbGUu1iTl5fnSHLa/v3XToe3/x9LDZa2f/+1I8nJy8uz/eU7JY/jOM7pJsEBAAAAAAAAIFbl5+crMzNTbf/+ayWmBfdmpLWN/+gxbbl5kvLy8pSRkWG7nWpFxTO4AQAAAAAAAABwi4f5AAAAAAAAAKgdyh6ig9OLkePEHdwAAAAAAAAAgJjEBDcAAAAAAAAAICYxwQ0AAAAAAAAAiElMcAMAAAAAAAAAYlLUTXD7fD49+uij8vl8VurpIbp6iJR4OV70ELptREI0fK70ED09RFI8HC96CF0PkRIvx8t2D/HwOURSvBwvegjdNiIlHo4XPYSuh0iJhs+VHqKnB6A28TiOE1Xvh5mfn6/MzEzl5eUpIyMj4vX0EF09REq8HC96CN02IiEaPld6iJ4eIikejhc9hK6HSImX42W7h3j4HCIpXo4XPYRuG5ESD8eLHkLXQ6REw+dKD9HTAyorO65tX/2NEtJSbbcTEwJHj2nLLX+I+ixG3R3cAAAAAAAAAADUBBPcAAAAAAAAAICYlBTpHQYCAe3atUvp6enyeDyVPp6fn1/hv26Z1tNDZHtwHEdHjhxRVlaWEhLC9/uWcOcuFNugh8j1QO7owUYP0ZK7mvR6OrXlaxYPPUQqdxJjXqzUR6qHaBnzYuV40UNothEtuatJr6dTW75m8dBDPJ1rY+F408MJkcweEO0i/gzuHTt2KDs7O5K7RAzIzc1VixYtwrZ9coeqkDvYQO5gQ7hzJ5E9VI0xDzaQO9jAuRa2RCJ78SI/n2dwuxUrz+CO+B3c6enpkqSsJyYoITW4MPXtstW4j6OlKUb1x0rND93Bo2lG9Xl5ZvWSNH3AdKP6R7YMM6ovPVqs5Te+WJ6LcCnbfudX7lVimjeobfyk9b+N+5i5ua9R/Q3tVhr38NbW3kb1ZzfeYdzD+kNNjervbrvEqL6owK9xF66JWO5+/j8/Ukrd5KC2sc7wWElSjwa7jOovyvhf4x4+yutqVP/BN2cZ95Dd7Huj+qFN1xvVHyso1R8uWRqx3HV4eWzQ490VLc0+V0mql3jMqP6z79sZ97BpjdkPgCMvWWzcwz+3nW1Un1mnyKg+UudZ6aRrvEm/Dvoar1OnncZ9DG28zqj+r5sGGvfg25BpVF+aHjDuoV1Hs7F/U24To/pA0THtun9yxMa85lMeUkKd4Ma8VobnB0ka23KRUb1fVd8F7MbDq35itoGddYx7cLLMxv5Ozfca1ZcWFuuj616NWO4uenuUktKC+7nym41Zxn20bWt2vO5o8YlxD9uKGxnVv/DlIOMevLuCu84u4+9w1Kg+UOTT9jFPRfRcO3T2CCXXDS57Ww83MO7jRy2/MqrPLzUfb0y1TDUf+//08dAQdBK8wLFj2vm7P0Qke0C0i/gEd9mf0SSkpiqhTnA//AQ7kFfYhuEEd2mp2UlUkhIV3EV4mYRi89821U03+zOWpLpmn0OZ6v60L1TKtp+Y5g16wie1Xgi+5kHuO5p6SKln/v2X6DProU690AxdkcpdSt1kpQT5tUsqNv8eC3bfZdLSE8178Jv1EOz54mSm41VqjOXOZLzzhmCsSU30G9UnHTPPfrCTrGWiYcxNSjOf6JTCn7uT92FyjReK6wrTc4Tp10wyz15CHfOvu+mxDMW4K0VuzEuo47WaO9NzZSgmuI3vRDPMrSQ5hvffhOLnPClyuUtKSwm652i4tgnFNV6qz2zMDcVxSPSana+dGDzXJtcNPnuJIfj5wvQayReC+RRTdVLNr+1Dda40FYnsxRvHOb7g9GLlOPGQHgAAAAAAAABATApqgnvq1Klq3bq1UlNT1b9/fy1fvjzUfQGVkDvYQvZgA7mDDeQONpA72EL2YAO5A4DQcz3BPWvWLI0fP14TJ07U6tWr1bNnT11++eXat29fOPoDJJE72EP2YAO5gw3kDjaQO9hC9mADuQOA8HA9wf3MM8/ojjvu0KhRo9SlSxc9//zzSktL0yuvvBKO/gBJ5A72kD3YQO5gA7mDDeQOtpA92EDuACA8XE1wFxcXa9WqVRoyZMiJDSQkaMiQIfriiy+qrPH5fMrPz6+wAG6QO9jiNnvkDqFA7mAD51rYQO5gC+da2MCYBwDh42qC+8CBA/L7/WrSpEmF15s0aaI9e/ZUWZOTk6PMzMzyJTs7O/huUSuRO9jiNnvkDqFA7mAD51rYQO5gC+da2MCYB0QPx/GwuFhiQVBvMunGhAkTlJeXV77k5uaGe5cAuYMV5A42kDvYQvZgA7mDDeQOtpA9AKiZJDcrn3nmmUpMTNTevXsrvL537141bdq0yhqv1yuv1xt8h6j1yB1scZs9codQIHewgXMtbCB3sIVzLWxgzAOA8HF1B3dKSor69OmjRYsWlb8WCAS0aNEiDRgwIOTNARK5gz1kDzaQO9hA7mADuYMtZA82kDsACB9Xd3BL0vjx4zVy5Ej17dtX/fr105QpU1RYWKhRo0aFoz9AErmDPWQPNpA72EDuYAO5gy1kDzaQOwAID9cT3Ndff73279+vRx55RHv27FGvXr30/vvvV3qjBCCUyB1sIXuwgdzBBnIHG8gdbCF7sIHcAUB4uJ7glqQxY8ZozJgxoe4FOCVyB1vIHmwgd7CB3MEGcgdbyB5sIHdAFHA8xxecXowcJ1fP4AYAAAAAAAAAIFoEdQd3KCQfTFJCanC7v6Lhf4z3/+zGi43qL26+0biHtzf3NdtAomPcwwPf/tSo/sCRukb1/qPJRvVuNaxbqKS6pUHVPv/JYOP912tWYFT/5razjXso+t8zjOo/+casXpJK0wNG9b/bdp1RfaDomKRVRttwY0luWyWmpQZVe2Z6ofH+P9nZzqj+9jM/Me5hyQ6zHs7tsMW4h2VrOhrVt2r1sVH90WS/Ub1bgUCCPIHgfo89Z0sP4/3fe5bZ8dr0ZSvjHpwUs/PkG6bnaUmdz9xnVP/VzuZG9YGjx4zqg5FyIEmJQV7j3XDxcuP97y6pb1TvTTL/Xi3xmd3p0rjdfuMermn2lVH968Veo3p/oU87jLbgkuf/liBkphQZ7372wd5G9cUB8x/LBrQxO1euWtvNuIfx18w3qj8aMMvdsdRSfWC0BXe+2dpMCXWCu8ZL3WX+c9DW9IZG9blNzeol6UBJPaP6C7pvMO7h8yNdjOp7t8w1qi8pLNY2oy24t35vk6B/vgisTzfe/5YmZxrVL9zQ2biHO3t9alT/z11m47YkNWl/wKh+7xaz48gtq8AJfDsAAAAAAAAAAGISE9wAAAAAAAAAgJjEBDcAAAAAAAAAICZZewY3AAAAAAAAAESS4xxfcHqxcpxc38G9dOlSXX311crKypLH49GcOXPC0BZQEbmDDeQONpA72EL2YAO5gw3kDraQPQAID9cT3IWFherZs6emTp0ajn6AKpE72EDuYAO5gy1kDzaQO9hA7mAL2QOA8HD9iJKhQ4dq6NCh4egFqBa5gw3kDjaQO9hC9mADuYMN5A62kD0ACI+wP4Pb5/PJ5/OV/zs/Pz/cuwTIHawgd7CB3MEWsgcbyB1sIHewhewBQM24fkSJWzk5OcrMzCxfsrOzw71LgNzBCnIHG8gdbCF7sIHcwQZyB1vIHgDUTNgnuCdMmKC8vLzyJTc3N9y7BMgdrCB3sIHcwRayBxvIHWwgd7CF7AFh4rC4WmJA2B9R4vV65fV6w70boAJyBxvIHWwgd7CF7MEGcgcbyB1sIXsAUDNhv4MbAAAAAAAAAIBwcH0Hd0FBgTZt2lT+761bt2rNmjVq0KCBWrZsGdLmgDLkDjaQO9hA7mAL2YMN5A42kDvYQvYAIDxcT3CvXLlSgwcPLv/3+PHjJUkjR47Uq6++GrLGgJORO9hA7mADuYMtZA82kDvYQO5gC9kDgPBwPcF90UUXyXFi5AnjiBvkDjaQO9hA7mAL2YMN5A42kDvYQvYAIDzC/iaTAAAAAAAAABANHMcjx/HYbiMmxMpxsjbBXWevR4ne4A7S43OGG+8/oW2BUf3bX/U27qHepmSj+pK+R4x7SEwIGNUXHUgzqg8URfZ9Tnd+1kKJqalB1dYpNd+/s/0Mo/rEC/Yb95DcMd+ovlF6oXEP3xea5ea85luN6osLivV3oy24k3VGvpLq+oKq/W55C+P9ew+ZnZCGr73PuIfiJmbfQF/s6WDcQ+IZxUb1f/hmqFG9/6hP0ldG23DDt62eEoIc7/wNS4z3/+zfrzWqr1Nk3IKcRLPsezv6jXtYs6O5UX3JEa9RfaAo8neJJXbJV2JacGPeZ/nm3+sZSceM6o9+dqZxD6ZXN4c/bmrcw9fXmWUv7/MmRvV+n9nXwa2MjCIlpgV3XftO+w+N99975fVG9T9ubX5+eG3u4NOvdApOpvl48cTcHxnVl2YFN3aUCRQdk7TEaBtujOz9uVLrBfcz3at1+xvv3ylNNKp/ds3Fxj2c28bsuvw//+xi3IPZTxbS2oWdjOr9xyI73kmSN9mvxOTgrq99XcznET5cb/Z1q3fGUeMePt7f0ag+02t+sbnzA7PnpqcbRsfvMxsDgHgS2dlFAAAAAAAAAABChAluAAAAAAAAAEBMYoIbAAAAAAAAABCTXE1w5+Tk6JxzzlF6eroaN26sa6+9Vhs2bAhXb4Akcgd7yB5sIHewgdzBFrIHG8gdbCB3ABA+ria4lyxZotGjR2vZsmX68MMPVVJSossuu0yFheZvOgdUh9zBFrIHG8gdbCB3sIXswQZyBxvIHRBlHJYaLTEiyc3K77//foV/v/rqq2rcuLFWrVqlCy+8MKSNAWXIHWwhe7CB3MEGcgdbyB5sIHewgdwBQPi4muD+oby8PElSgwYNql3H5/PJ5/OV/zs/P99klwC5gzWnyx65QziQO9jAuRa2MObBBnIHGzjXAkDoBP0mk4FAQOPGjdPAgQPVrVu3atfLyclRZmZm+ZKdnR3sLgFyB2tqkj1yh1Ajd7CBcy1sYcyDDeQONnCuBYDQCnqCe/To0Vq3bp1mzpx5yvUmTJigvLy88iU3NzfYXQLkDtbUJHvkDqFG7mAD51rYwpgHG8gdbOBcCwChFdQjSsaMGaN3331XS5cuVYsWLU65rtfrldfrDao54GTkDrbUNHvkDqFE7mAD51rYwpgHG8gdbOBcCwCh52qC23Ec3XPPPZo9e7YWL16sNm3ahKsvoBy5gy1kDzaQO9hA7mAL2YMN5A42kDsgejiOR47jsd1GTIiV4+Rqgnv06NGaMWOG5s6dq/T0dO3Zs0eSlJmZqTp16oSlQYDcwRayBxvIHWwgd7CF7MEGcgcbyB0AhI+rZ3BPmzZNeXl5uuiii9SsWbPyZdasWeHqDyB3sIbswQZyBxvIHWwhe7CB3MEGcgcA4eP6ESVApJE72EL2YAO5gw3kDraQPdhA7mADuQOA8HF1BzcAAAAAAAAAANHC1R3codT4+S+V5EkOqnbHhPOM95+wPN2oPuX8Q8Y9FJ2ZYlTfs9lu4x76199qVH9dxzeM6o8cCehsoy24k1AiJQT5a50WOZ8b73/nQ2bZLVjWyLiHi69ZZVTvC5gPG0Oafm9Uv/5IM6P6ktLI/m5vz0ctlOhNDao2KQSjdNaTZtnd+bD5mBtINvxEsouMe0hdnWZU3/iKfUb1pR6fUb1bSdmFSkzzB1WbssbsHClJiYafbtMp5mPu3nvNsnt4fUPjHhJbFxjVZ/4nuGulMn5fcBkwUboxXYHU4Ma84ubmg96//jXAqD7V7EsmSWryZ7P87h5vPu4uXGh2hVXSqtioPlBkVu9Wh4b7lVw3uGvrcbv7Gu8/L8/sHDN90UXGPdQpMHsTqOZPmI+7pj+npRwKbuwo44/sqVaFfq9K/cGN0z/q9B/j/S+Ybna8j51/xLiH5UvOMqr3Jhq3YHytu/8us/OGvzjyd2a/3eNvSk8P7meaR3Zfbrz/TflnGtV/P7+5cQ8be5uNF3XWmj/3POmoWb3p9UKpU6L/NWsBiBvWJrgBAAAAAAAAIKKc/1twejFynHhECQAAAAAAAAAgJjHBDQAAAAAAAACISUxwAwAAAAAAAABikqsJ7mnTpqlHjx7KyMhQRkaGBgwYoPnz5xs38XPna41w1lf5sRHOev3c+dp4H4hd4cpdKJDd+BbN2TNBbqNbvOYuFMhu+JC78CK71SN70S1es0vu4l80Zpfc4XSiMbdArHA1wd2iRQtNnjxZq1at0sqVK3XxxRdr2LBh+vprs2+ygDy6ResrfSOPcNbrFq1XQGbvCI7YFq7chQLZjW/RnD0T5Da6xWvuQoHshg+5Cy+yWz2yF93iNbvkLv5FY3bJHU4nGnMLxIokNytfffXVFf79hz/8QdOmTdOyZcvUtWvXoJt4w9NFcqRbtF5yjv+77Bv4VXU5/nHUWuHKXSiQ3fgWzdkzQW6jW7zmLhTIbviQu/Aiu9Uje9EtXrNL7uJfNGaX3OF0ojG38cvzfwtOLzaOk6sJ7pP5/X699dZbKiws1IABA6pdz+fzyefzlf87Pz+/yvVO/kb+mfONUhTgGxiVhDp3oUB2a4eaZC+SuTNFbmNDvOUuFMhu+EXjuTYekN3TY8yLTvGeXXIXv6I5u5xrUZ1ozi0QzVy/yeTatWtVr149eb1e3XXXXZo9e7a6dKn+Gy0nJ0eZmZnlS3Z2drXrvuHpomIlKEUBFSuBb2CUC2fuQoHsxi832Yt07kyR2+gVz7kLBbIbHtF+ro0HZLdqjHnRLx6zS+5qh2jLLuda1ES05RaIBa4nuDt16qQ1a9boyy+/1N13362RI0dq/fqqH4IvSRMmTFBeXl75kpubW+26I5z15d/AKQpU+3B91D7hzF0okN345SZ7kc6dKXIbveI5d6FAdsMj2s+18YDsVo0xL/rFY3bJXe0QbdnlXIuaiLbcArHA9SNKUlJS1L59e0lSnz59tGLFCj377LN64YUXqlzf6/XK6/Wedrs/fK5Q2b/LnjuE2i1cuQsFshvf3GQvkrkzRW6jW7zmLhTIbvhE87k2HpDd6jHmRbd4zS65i3/RmF3OtTidaMwtEAuCfgZ3mUAgUOGZUMGo6qH5VT1cHygTityFAtmtfaIleybIbeyJh9yFAtmNLHIXOmTXHbIXPWpTdsldfImV7JI7nCxWcgtEI1cT3BMmTNDQoUPVsmVLHTlyRDNmzNDixYu1YMECoyYS5FT50Pyyb+QEOUbbR2wLV+5CgezGt2jOnglyG93iNXehQHbDh9yFF9mtHtmLbvGaXXIX/6Ixu+QOpxONuY1bzv8tOL0YOU6uJrj37dunm2++Wbt371ZmZqZ69OihBQsW6NJLLzVq4jVP12o/xm+nEK7chQLZjW/RnD0T5Da6xWvuQoHshg+5Cy+yWz2yF93iNbvkLv5FY3bJHU4nGnMLBGvq1Kl66qmntGfPHvXs2VN//vOf1a9fvyrXffXVVzVq1KgKr3m9Xh07dqzG+3M1wf3yyy+7WR0ICXIHW8gebCB3sIHcwRayBxvIHWwgdwBqi1mzZmn8+PF6/vnn1b9/f02ZMkWXX365NmzYoMaNG1dZk5GRoQ0bNpT/2+PxuNpnglHHAAAAAAAAAABIeuaZZ3THHXdo1KhR6tKli55//nmlpaXplVdeqbbG4/GoadOm5UuTJk1c7dP4TSaDtf/O/kpMSQ2qNpBsvv+sIblG9YmegHEPCefkGdU3TT1i3MOvGmw2qp+4v79Rva+gRNJ7Rttww+McX4Kx+/7zjPdfkmH28KIW/Xca99AoxSw3ExutN+7hx5vM/gxvcMNvjeqPJZXqHaMtuNP2sq1KrpsSVO3af7cx3v/u8WbZ9dU3f+jWTf+1xKj+w92djXtIuNRszD1WanbyKS01P2+4kZLsV2JyaVC1Hf7L7HtMkv53fkej+v13DzDuwVffrP5nly817uHd7dX/qWlNJA8tMqr3F/qkF4w24VrTs/coqa43qNou9XYZ7//zzmbjpvN5PeMe9ow1G3cDwZ0yKrjnGrPrqxc2nG9U7z8a2TdNKyjxKrkkuAM3pc1K4/0v2HKWUX3XvmY/m0jS2iUdjOp3Pmx+rWv6c9p5V/zHqL64oFjf/smsBzcmNv5aGenB3TP22H7zxw3kd/Ab1TsFwY3VJ+vUf7tRfe6HrYx72D7RMLuGl7p+n7u7DENhnz9ZR/3BZe+OxouN93/brpFG9YVtzbIrSfreLL9nDN5j3MKhJU2N6veNNsuuv/iY9OJco20ANZWfn1/h316vV15v5e/D4uJirVq1ShMmTCh/LSEhQUOGDNEXX3xR7fYLCgrUqlUrBQIB9e7dW5MmTVLXrjX/WYo7uAEAAAAAAAAAVcrOzlZmZmb5kpOTU+V6Bw4ckN/vr3QHdpMmTbRnT9W/WOrUqZNeeeUVzZ07V6+//roCgYDOO+887dixo8b9WbuDGwAAAAAAAAAiypHxX2/UGv93nHJzc5WRkVH+clV3bwdrwIABGjDgxF/wnnfeeTrrrLP0wgsv6Pe//32NtsEENwAAAAAAAACgShkZGRUmuKtz5plnKjExUXv37q3w+t69e9W0ac0e65OcnKyzzz5bmzZtqnF/Ro8omTx5sjwej8aNG2eyGcAVcgcbyB1sIXuwgdzBBnIHW8gebCB3AOJRSkqK+vTpo0WLFpW/FggEtGjRogp3aZ+K3+/X2rVr1axZsxrvN+g7uFesWKEXXnhBPXr0CHYTgGvkDjaQO9hC9mADuYMN5A62kD3YQO4AxLPx48dr5MiR6tu37/9n787DoyrvNo7fk4RMQkjCvknYXFhlF4q4gIK8qChVg/VFRbRWFKqIK9qqrZZg3bCV4lKFulBcKmqtwgtWcUGURQREEZAlyL5lI5ksM+8fmMCYhOTMMzPPzOT7ua5zKZPzO+eXM3eeM/Nkco769++v6dOnq6CgQOPGjZMkXX311TrhhBMqruP9xz/+Ub/4xS900kkn6dChQ3rkkUe0detW/frXv671PgP6BHd+fr7GjBmj5557To0aNQpkE4Bj5A42kDvYQvZgA7mDDeQOtpA92EDuAMS6yy+/XI8++qjuu+8+9erVS6tWrdL8+fMrbjy5bds27dy5s2L9gwcP6vrrr1eXLl10/vnnKzc3V0uWLFHXrl1rvc+AJrgnTJigCy64QEOHDq1xXY/Ho9zcXL8FCAS5gw3kDrbUNnvkDsHEmAcbyB1s4VwLGxjzANQFEydO1NatW+XxePTFF19owIABFV/76KOPNHv27Ip/P/HEExXr7tq1S//5z3/Uu3dvR/tzfImSuXPnauXKlVq2bFmt1s/KytIf/vAHp7sB/JA72EDuYIuT7JE7BAtjHmwgd7CFcy1sYMwDIoTPdWRBzaLkODn6BHd2drZuueUWvfLKK0pKSqpVzZQpU5STk1OxZGdnB9Qo6i5yBxvIHWxxmj1yh2BgzIMN5A62cK6FDYx5ABA6jj7BvWLFCu3Zs0d9+vSpeKysrEwff/yxnnrqKXk8HsXHx/vVuN1uud3u4HSLOoncwQZyB1ucZo/cIRgY82ADuYMtnGthA2MeAISOownuc889V2vWrPF7bNy4cercubPuuuuuSoMxEAzkDjaQO9hC9mADuYMN5A62kD3YQO4AIHQcTXCnpqaqe/fufo+lpKSoSZMmlR4HgoXcwQZyB1vIHmwgd7CB3MEWsgcbyB0AhI6ja3ADAAAAAAAAABApHH2CuyofffRRENoAnCF3sIHcwRayBxvIHWwgd7CF7MEGcgfY4fMdWVCzaDlOfIIbAAAAAAAAABCVjD/BHajClj7FJQX2a4AuZ/xgvP+EuDKj+j7p2cY9vL65t1H9nW3nG/cwdV8no/pJjZcZ1efV8+oRoy04c8rwjaqXkhhQ7crNbY3373KZ/eore19D4x6uONnsObtu23DjHka3WG5U//jGoUb1ZYc9khYbbcOJtd9lKC45KaDakWesMN7/fz7ta1T/m3M/MO7hsrSvjOrvb7bOuIebd5xmVH9Lsw+N6vPzvOpjtAVn7uq0QPVTA7tZUbzLa7z/v55T36g++8sTjHv4xZC1RvVuV6lxDyv6vmZUf8bqS8waiDN/Lp3KLUpSfJw7oNo7Gm8y3v8/k/sZ1R86Odm4h5RtZjcKcw04ZNxDXllg551yN3cxG/MK80s12WgLzjSo51G9eoG9zrrw+xHG+y8pMXvO9xxONe7B27HQbAOrzcZtSUr/xR6j+l6pZu+xilylmmO0BWdO/eCqgF/jdWm/03j/9Q6ZfV4toXW+cQ8N3Wa5yz97l3EPBz9uaVSf0P+gUf2R9xbh1SUxQWmJgT3/U/edarz/OMP3tQn55p+1PKHvDqP64jLzm3qmnbXbqP7Q5y2M6svCHz0gYvEJbgAAAAAAAABAVGKCGwAAAAAAAAAQlZjgBgAAAAAAAABEJWvX4AYAAAAAAACAsPL9tKBmUXKcHH2C+4EHHpDL5fJbOnfuHKreAEnkDvaQPdhA7mADuYMtZA82kDvYQO4AIHQcf4K7W7duWrRo0dENJPAhcIQeuYMtZA82kDvYQO5gC9mDDeQONpA7AAgNx6NpQkKCWrZsGYpegGqRO9hC9mADuYMN5A62kD3YQO5gA7kDgNBwfJPJDRs2qHXr1urYsaPGjBmjbdu2HXd9j8ej3NxcvwVwitzBFifZI3cIFnIHGzjXwhbGPNhA7mAD51oACA1HE9wDBgzQ7NmzNX/+fM2cOVObN2/WmWeeqby8vGprsrKylJ6eXrFkZGQYN426hdzBFqfZI3cIBnIHGzjXwhbGPNhA7mAD51oACB1HE9wjRoxQZmamevTooeHDh+u9997ToUOH9Nprr1VbM2XKFOXk5FQs2dnZxk2jbiF3sMVp9sgdgoHcwQbOtbCFMQ82kDvYwLkWiCA+F4uTJQoY3dGgYcOGOuWUU7Rx48Zq13G73XK73Sa7AfyQO9hSU/bIHUKB3MEGzrWwhTEPNpA72MC5FgCCx/E1uI+Vn5+vTZs2qVWrVsHqB6gRuYMtZA82kDvYQO5gC9mDDeQONpA7AAgeRxPct99+uxYvXqwtW7ZoyZIl+uUvf6n4+HhdccUVoeoPIHewhuzBBnIHG8gdbCF7sIHcwQZyBwCh4+gSJdu3b9cVV1yh/fv3q1mzZjrjjDO0dOlSNWvWLFT9AeQO1pA92EDuYAO5gy1kDzaQO9hA7gAgdBxNcM+dOzdUfQDVInewhezBBnIHG8gdbCF7sIHcwQZyBwChY3STSQAAAAAAAACIFi7fkQU1i5bjZG2C29ehQL76ZQHVrl7b3nz/hs/QiiTzHtwNPEb1v3ntBuMeup7+g1H9c0vONqr3FhZJus9oG05882MrxdVPCqg2YYf53atdgUW+QmmK+cjyP+9ONqq/dOCXxj3c//qvjOpLGnmN6o/kLnxOPnmHElICy8/S3e2N9+9tUGpU/3VuG+MeJjRaY1Q/O7e5cQ/7PA2M6u/dfpFRfUlBsaTZRttwYvaPpwecu8dPfN14/1t2NTGq97YsMe7hy+x2RvW/G/C+cQ+PHzjVqL5t6kGj+pK4Yi0z2oJzv2i5VYkN6gVUO+NQhvH+m6UUGNV7Wpm/PPY0MduGq9i8h/NTVxvVv3boNKN6T5H5z7ATmw42UbwnsDFvUKvN5vuv19SovleT7cY9XNLmK6P6t5r2Mu5hSIvvjepT4wuN6hPizV7zONW8Wa7iUwJ7T7czN814/yUNzV4Tn9Vmi3EPv2+1wKh+xv4zjHvYOXKfUX2zxHyjek9+ib412oJz0/adKndRYOfam5ssNd7/i6sHGNXHtzc7V0vSoGZmcxkPNTd7fyJJbxWYvb+Y5vsfo/qyArM5JSCWOLrJJAAAAAAAAAAAkYIJbgAAAAAAAABAVGKCGwAAAAAAAAAQlRxPcP/444+68sor1aRJEyUnJ+vUU0/V8uXLQ9EbUIHcwRayBxvIHWwgd7CB3MEWsgcbyB0AhIajO9gcPHhQgwYN0pAhQ/T++++rWbNm2rBhgxo1ahSq/gByB2vIHmwgd7CB3MEGcgdbyB5sIHdABPH9tKBmUXKcHE1wP/zww8rIyNCsWbMqHuvQoUPQmwKORe5gC9mDDeQONpA72EDuYAvZgw3kDgBCx9ElSt555x3169dPmZmZat68uXr37q3nnnvuuDUej0e5ubl+C+AEuYMtTrNH7hAM5A42cK6FDeQOtnCuhQ2MeQAQOo4muH/44QfNnDlTJ598shYsWKAbb7xRN998s/7xj39UW5OVlaX09PSKJSMjw7hp1C3kDrY4zR65QzCQO9jAuRY2kDvYwrkWNjDmAUDoOJrg9nq96tOnj6ZOnarevXvrN7/5ja6//no9/fTT1dZMmTJFOTk5FUt2drZx06hbyB1scZo9codgIHewgXMtbCB3sIVzLWxgzAOA0HE0wd2qVSt17drV77EuXbpo27Zt1da43W6lpaX5LYAT5A62OM0euUMwkDvYwLkWNpA72MK5FjYw5gFA6Di6yeSgQYO0fv16v8e+//57tWvXLqhNAccid7CF7MEGcgcbyB1sIHewhezBBnIHRBCf68iCmkXJcXL0Ce5bb71VS5cu1dSpU7Vx40bNmTNHzz77rCZMmBCq/gByB2vIHmwgd7CB3MEGcgdbyB5sIHcAEDqOJrhPO+00zZs3T//85z/VvXt3Pfjgg5o+fbrGjBkTqv4AcgdryB5sIHewgdzBBnIHW8gebCB3ABA6ji5RIkkXXnihLrzwwlD0AlSL3MEWsgcbyB1sIHewgdzBFrIHG8gdAISGo09wAwAAAAAAAAAQKRx/gjtYSg4nKs6XGFBtiw77jfefXK/EqD6nMMm4h5KyeKP6EwZUf7fl2voxL92oPqV5gVF92WGPUb1THVvsU0KKO6DaIaeur3mlGvxtyTlG9aecuNO4hzObbTSq3+FpaNxD7yFmx/KLr08yqve5fEb1TpV44+XzBvbz/osWW4z3P39NP6P61HpFxj3cvfNso/q0hELjHr7d18Ko3mt4c41wj3fbDjRUfFFg56pJGm28/7gdZufJ+nvNb2ZScKrXqH7suquNezi31fdG9Z+vOdmo3lto/vPr1Acf91RcUmDP//+162S8/9K9yUb1vnpBOEfUM8ueK968h5l7BxvVf5rd0aj+yJj3b6NtONGiQb7qpRQHVDv//8zOk5Jk+tLi3cOnGvfQp6PZe4OC4sDemx3r5W/6G9U3Sg/Ge4svjbbhRHpSoRKSAvt5X5/d2nj/iblmn1f7/Mf2xj08Gj/EqH7h5s7GPRQZjvtKMPsBPnKunWfWg0O/TF+pBqmBPf8Xrr4muM0EIP7bBsbb+LiR2XvCcUUNjXvYcKiZUf3u7EZG9TZe5wGRytoENwAAAAAAAACEle+nBTWLkuPEJUoAAAAAAAAAAFGJCW4AAAAAAAAAQFRighsAAAAAAAAAEJUcTXC3b99eLper0jJhwoRQ9QdIInuwg9zBBnIHG8gdbCF7sIHcwQZyBwCh4+gmk8uWLVNZWVnFv9euXathw4YpMzMz6I0BxyJ7sIHcwQZyBxvIHWwhe7CB3MEGcgcAoeNogrtZs2Z+/542bZpOPPFEnX322UFtCvg5sgcbyB1sIHewgdzBFrIHG8gdbCB3QATx/bSgZlFynBxNcB+ruLhYL7/8siZPniyXy1Xteh6PRx6Pp+Lfubm5ge4SkFS77JE7BBu5gw3kDjbwGg+2MObBBnIHGzjXAkBwBXyTybfeekuHDh3SNddcc9z1srKylJ6eXrFkZGQEuktAUu2yR+4QbOQONpA72MBrPNjCmAcbyB1s4FwLAMEV8AT3888/rxEjRqh169bHXW/KlCnKycmpWLKzswPdJSCpdtkjdwg2cgcbyB1s4DUebGHMgw3kDjZwrgWA4AroEiVbt27VokWL9Oabb9a4rtvtltvtDmQ3QCW1zR65QzCRO9hA7mADr/FgC2MebCB3sIFzLQAEX0Cf4J41a5aaN2+uCy64INj9AMdF9mADuYMN5A42kDvYQvZgA7mDDeQOAILP8Se4vV6vZs2apbFjxyohIeB7VAKOkT3YQO5gA7mDDeQOtpA92EDuYAO5AyKE76cFNYuS4+T4E9yLFi3Stm3bdO2114aiH6BaZA82kDvYQO5gA7mDLWQPNpA72EDuACA0HP/K8LzzzpPPFyXT94gpZA82kDvYQO5gA7mDLWQPNpA72EDuACA0wv43MeWDubewKOBtlBV4jPsorVdiVF9W5DLuoaws3qi+NMH8OJQVmkWgrNhrVn/4yPcQ6pN8+fZLDxcHvI2i5FLjPkxyL0mlQch+UbJZ9os9gR/DciUlZrkzPY7eoiP10ZC74gSz50s6+v0G3EO++XPuc5kda08QjkP5eBMor89s3A/3eOctDPz7LU0yH2tMc1fmMT/Pmo4VwXi94ck3y260jHfH7sPkuXcdNvt+JclbaJYdX2kQjlWp2esjV7x5D6Zjt+mYGU2v8UzHK0kyPM0ZjdnlSgrsPueS5D0c0C2ejvZQrw7lznB8lyRvkeF7uSA858WG57myCBj3lWCWl/LnMpzn2oL8wM8zwflZN8xeEOZTTN8bF8ebv8cx7SGaXucBkc7lC/NPwvbt25WRkRHOXSIKZGdnq02bNiHbPrlDVcgdbCB3sCHUuZPIHqrGmAcbyB1s4FwLW8KRvViRm5ur9PR0ZTz6oOKSk2y3ExW8hUXKvv33ysnJUVpamu12qhX2T3C3bt1a2dnZSk1NlctV+bd2ubm5ysjIUHZ2dkAHzrSeHsLbg8/nU15enlq3bh1Qj7UV6twFYxv0EL4eyB092OghUnJXm15rUlees1joIVy5kxjzoqU+XD1EypgXLceLHoKzjUjJXW16rUldec5ioYdYOtdGw/Gmh6PCmT0g0oV9gjsuLq5Wv1lKS0sz+s2AaT09hK+H9PT0gLddW+HKXTC2QQ/h6YHc0YONHiIpd1LkHy96CE59OHInMeZFW304eoikMS8ajhc9BGcbkZQ7KfKPFz0Epz7WzrWRfrzp4ahwZS/m+FxHFtQsSo6T2UXSAAAAAAAAAACwhAluAAAAAAAAAEBUirgJbrfbrfvvv19ut9tKPT1EVg/hEivHix6Ct41wiITvlR4ip4dwioXjRQ/B6yFcYuV42e4hFr6HcIqV40UPwdtGuMTC8aKH4PUQLpHwvdJD5PQA1CUun8/ns90EAAAAAAAAAIRKbm6u0tPTlfHIQ4pLTrLdTlTwFhYp+47fKScnx/ia9KEUcZ/gBgAAAAAAAACgNhJsNwAAAAAAAAAA4eDyHVlQs2g5TnyCGwAAAAAAAAAQlZjgBgAAAAAAAABEJSa4AQAAAAAAAABRiQluAAAAAAAAAEBUYoIbAAAAAAAAABCVEmw3AAAAAAAAAABh4ftpQc2i5DjxCW4AAAAAAAAAQFRighsAAAAAAAAAEJWY4AYAAAAAAAAARCUmuAEAAAAAAAAAUSmmJ7iXLVum008/XSkpKXK5XFq1apXtlmr05z//WZ07d5bX6w37vn/1q19p9OjRYd9vrCF3ztx9990aMGBA2Pcba8idM+QueMieM2QvOMidM7zGCw5y5wy5Cx6y5wzZCw5y5wy5A+yK2QnukpISZWZm6sCBA3riiSf00ksvqV27drbbOq7c3Fw9/PDDuuuuuxQXV/VTs2nTJiUlJcnlcmn58uW13vbzzz+vLl26KCkpSSeffLL++te/Vlrnrrvu0r/+9S99/fXXAX8PdR25O2rmzJnKzMxU27Zt5XK5dM0111S53qRJk/T111/rnXfeCfRbqPPI3RHZ2dn6wx/+oP79+6tRo0Zq2rSpBg8erEWLFlVal9wFB9k7orCwUNddd526d++u9PR0NWjQQD179tSTTz6pkpISv3XJnjlyV7VPP/1ULpdLLpdL+/bt8/sar/HMkbujynP282XatGl+65G74CB7/nbv3q0bbrhBJ5xwgpKSktS+fXtdd911fuuQPXPk7ojZs2dXO+a5XC698sorFeuSO8CuBNsNhMqmTZu0detWPffcc/r1r39tu51aeeGFF1RaWqorrrii2nVuvfVWJSQkyOPx1Hq7zzzzjMaPH69LL71UkydP1ieffKKbb75Zhw8f1l133VWxXu/evdWvXz899thjevHFF42+l7qK3B318MMPKy8vT/3799fOnTurXa9ly5a6+OKL9eijj+qiiy5y1DuOIHdHvP3223r44Yc1atQojR07VqWlpXrxxRc1bNgwvfDCCxo3blzFuuQuOMjeEYWFhfrmm290/vnnq3379oqLi9OSJUt066236osvvtCcOXMq1iV75shdZV6vV7/97W+VkpKigoKCSl/nNZ45cudv2LBhuvrqq/0e6927d6V/kztzZO+o7OxsDRo0SJI0fvx4nXDCCdqxY4e+/PJLv/XInjlyd8RZZ52ll156qdLjTzzxhL7++mude+65FY+RO8CumP0E9549eyRJDRs2rHHdqt4I2DBr1ixddNFFSkpKqvLrCxYs0IIFC3TrrbfWepuFhYW69957dcEFF+iNN97Q9ddfrxdffFFjxozRgw8+qIMHD/qtP3r0aL355pvKz883+l7qKnJ31OLFi7Vv3z69//77crvdx1139OjR+vTTT/XDDz842geOIHdHDBkyRNu2bdOcOXM0YcIE3XLLLVqyZIk6d+6s++67r9L65M4c2TuicePGWrp0qf785z/rpptu0vjx4/Xiiy9qwoQJ+uc//6ldu3b5rU/2zJC7yp599lllZ2cfdxKC13hmyJ2/U045RVdeeaXf0q1bt0rrkTtzZO+oG264QQkJCfrqq6/0+9//Xtdee61+97vfVflXUWTPDLk7omPHjpXGuksvvVQbNmzQOeeco5YtW/qtT+4Ae2Jygvuaa67R2WefLUnKzMyUy+XS4MGDK77WoEEDbdq0Seeff75SU1M1ZswYSUcG5ttuu00ZGRlyu93q1KmTHn30Ufl8Pr/tu1wuTZw4Ua+//rq6du2q5ORkDRw4UGvWrJF05BPTJ510kpKSkjR48GBt2bKlxp43b96s1atXa+jQoVV+vaSkRLfccotuueUWnXjiibU+Fh9++KH279+vm266ye/xCRMmqKCgQP/5z3/8Hh82bJgKCgq0cOHCWu8DR5A7f+3atZPL5arVuuX7f/vttx3tA+TuWN26dVPTpk39HnO73Tr//PO1fft25eXl+X2N3JkhezVr3769JOnQoUN+j5O9wJG7yg4cOKDf/e53+uMf/3jciQhe4wWO3FWtsLBQRUVFx12H3Jkhe0d99913ev/993XHHXeoSZMmKioqqnQZsGORvcCRu+P797//rby8vIrv+1jkDrAnJie4b7jhBt1zzz2SpJtvvlkvvfSS7r333oqvl5aWavjw4WrevLkeffRRXXrppfL5fLrooov0xBNP6H/+53/0+OOPq1OnTrrjjjs0efLkSvv45JNPdNttt2ns2LF64IEH9O233+rCCy/UjBkz9Je//EU33XST7rjjDn3++ee69tpra+x5yZIlkqQ+ffpU+fXp06fr4MGD+t3vfufoWHz11VeSpH79+vk93rdvX8XFxVV8vVz5Ceazzz5ztB+QOxPp6ek68cQTyV0AyF3Ndu3apfr166t+/fp+j5M7M2SvsuLiYu3bt0/Z2dmaN2+eHn30UbVr104nnXSS33pkL3DkrrLf//73atmypW644YbjrsdrvMCRu8pmz56tlJQUJScnq2vXrn6XYjoWuTND9o4qv6dKixYtdO655yo5OVnJyckaMWJElROgZC9w5O74XnnlFSUnJ+uSSy6p9DVyB9gTk9fgHjhwoDwej6ZOnaozzzxTl112md/XPR6PMjMzlZWVVfHY22+/rf/+97966KGHKgbvCRMmKDMzU08++aQmTpzo95u+9evX67vvvqv4dFajRo10ww036KGHHtL333+v1NRUSVJZWZmysrK0ZcuWinWr8t1330mSOnToUOlru3bt0oMPPqhHH31UaWlpjo7Fzp07FR8fr+bNm/s9npiYqCZNmmjHjh1+jyckJCgjI0Pr1q1ztB+QO1MdO3YkdwEgd8e3ceNGvfnmm8rMzFR8fHylr5O7wJG9yt58802/6z7269dPL7zwghISKr/cInuBIXf+Vq9erWeeeUbvvfdelWPcsXiNFzhy5+/000/X6NGj1aFDB+3YsUMzZszQmDFjlJOToxtvvNFvXXJnhuwdtWHDBknSb37zG5122ml69dVXtW3bNv3hD3/Q0KFDtXr1ar8PM5C9wJG76h04cEDz58/XqFGjKno8FrkD7InJT3DXxs9ffJW/Mbj55pv9Hr/tttvk8/n0/vvv+z1+7rnn+g2wAwYMkCRdeumlfgNd+eM1XWdz//79SkhIUIMGDSp97a677lLHjh0DurlDYWGhEhMTq/xaUlKSCgsLKz3eqFEj7du3z/G+ULO6krtAkLvQqau5O3z4sDIzM5WcnKxp06ZVuQ65C626lr0hQ4Zo4cKFev311zV+/HjVq1ev2utSkr3QqUu5u/nmmzVixAidd955tVqf3IVOXcrdZ599pltuuUUXXXSRxo8frxUrVqh79+665557eG9hQV3JXvk1jVu2bKn//Oc/Gj16tG6//XY999xz2rRpU5V/RUD2Qqeu5O7n3njjDRUXF1d5eZJy5C46uCS5fCy1Wmw/WbUUk5/grklCQoLatGnj99jWrVvVunXrSr+F69KlS8XXj9W2bVu/f6enp0uSMjIyqnz85zdzrK2lS5fqpZde0gcffKC4OOe/j0hOTlZxcXGVXysqKlJycnKlx30+X62vnYzaq0u5CwS5C426mruysjL96le/0rp16/T++++rdevWVa5H7kKnLmavRYsWatGihSTpsssu09SpUzVs2DBt2LCh0k2IyF5o1KXcvfrqq1qyZInWrl1b6xpyFxp1KXdVSUxM1MSJEysmu8844wy/r5O70KlL2St/3zp69Gi/+szMTF111VVasmRJpQlMshcadSl3P/fKK6+ocePGGjFiRLXrkDvAjjr5CW632208uFX3Z6DVPf7zGyv8XJMmTVRaWlrpJmh33nmnzjzzTHXo0EFbtmzRli1bKn4buHPnTm3btu24223VqpXKysoq7oJcrri4WPv3769y0ufgwYOVbtQGc3Upd4Egd6FRV3N3/fXX691339Xs2bN1zjnnVLseuQudupq9Y1122WXKz8+v8maSZC806lLu7rjjDmVmZioxMbGivvyGptnZ2ZUuQyeRu1CpS7mrTvmk1IEDByp9jdyFTl3KXvn71vJfJB/bZ5MmTaqcACV7oVGXcnesbdu26ZNPPlFmZqbq1atX7XrkDrCjTn6Cuyrt2rXTokWLlJeX5/dbx/JrObVr1y6k++/cubOkI3f/7dGjR8Xj27Zt09atW6u8ltRFF12k9PT0ijczVenVq5ckafny5Tr//PMrHl++fLm8Xm/F18uVlpYqOztbF110UeDfDGotVnMXiM2bN6tnz55B3SaqFuu5u+OOOzRr1ixNnz7d73rIVSF34RXr2fu58j/Vz8nJqfQ1shc+sZq77OxszZkzp8o/y+/Tp4969uypVatWVTzGa7zwitXcVaf88gHNmjXze5zchV+sZq9v376SpB9//NHv8fIbPJM9u2I1d8f65z//KZ/Pd9zLk5A7wB4muH9y/vnn69lnn9VTTz2lKVOmVDz+xBNPyOVyHfdPUIJh4MCBko5MPB87ID/77LM6fPiw37r//e9/9de//lWPPvpoxUBenXPOOUeNGzfWzJkz/Sa4Z86cqfr16+uCCy7wW3/dunUqKirS6aefbvotoRZiNXdO5eTkaNOmTZWu5YbQiOXcPfLII3r00Ud1zz336JZbbjnuuuQu/GI1e/v27VOTJk0q/Tnq3//+d0lHbjZ5LLIXXrGau3nz5lV6bO7cuXr11Vf14osvVvrzcV7jhVes5m7v3r2VJhLz8vI0ffp0NW3atGISshy5C79Yzd7gwYPVvHlzvfLKK7rnnnuUlJQkSZo9e7bKyso0bNgwv/XJXnjFau6ONWfOHLVt27bSZZiORe4Ae5jg/snIkSM1ZMgQ3XvvvdqyZYt69uyp//u//9Pbb7+tSZMm+d3xNxQ6duyo7t27a9GiRbr22msrHq/qpkHlv2E8++yz/d40b9myRR06dNDYsWM1e/ZsSUeuVfbggw9W3MF4+PDh+uSTT/Tyyy/rT3/6kxo3buy37YULF6p+/fqVXiAgNGI1d5L073//W19//bUkqaSkRKtXr9ZDDz0k6chvy4994bFo0SL5fD5dfPHFwfz2UI1Yzd28efN055136uSTT1aXLl308ssv+21r2LBhfn/WSu7CL1az9/LLL+vpp5/WqFGj1LFjR+Xl5WnBggVauHChRo4cWekyOWQvvGI1d6NGjapUX/6J7REjRlT682he44VXrOZuxowZeuuttzRy5Ei1bdtWO3fu1AsvvKBt27bppZdeqnRze3IXfrGaPbfbrUceeURjx47VWWedpauuukrbtm3Tk08+qTPPPFOXXHKJ37bJXnjFau7KrV27VqtXr9bdd9993OtrkzvAHia4fxIXF6d33nlH9913n1599VXNmjVL7du31yOPPKLbbrstLD1ce+21uu+++1RYWFjlzR9rUn5n6VatWvk9ftNNN6levXp67LHH9M477ygjI0NPPPFElZ9ufP3113XJJZdUujkEQiOWc/evf/1L//jHPyr+/dVXX+mrr76SJLVp08Zvgvv111/XGWecEfIXPjgiVnNX/guVDRs26KqrrqpU8+GHH/pNcJO78IvV7J1xxhlasmSJ/vnPf2r37t1KSEhQp06d9Pjjj+u3v/1tpW2QvfCK1dw5xWu88IrV3A0aNEhLlizR3//+d+3fv18pKSnq37+/XnjhhSrveUHuwi9WsydJV199tRITEzVt2jTdcccdatiwoW644QZNnTq10rWbyV54xXLupCM3l5Sk//3f/z3uNsgdYI/LV9PV+hE2OTk56tixo/785z/ruuuuc1z/t7/9TXfeeac2bdpU6eYbtbFq1Sr16dNHK1eurHRtbsQu27nbtWuXOnTooLlz5/JpxjqE3MEWsgcbbOeO13h1E7mDLWQPNpA71EZubq7S09PVbtqfFPfTpY5wfN6iIm29+17l5OQoLS3NdjvVMrv1LYIqPT1dd955px555BF5vV7H9R9++KFuvvnmgAZjSZo2bZouu+wyBuM6xnbupk+frlNPPZWJnjqG3MEWsgcbbOeO13h1E7mDLWQPNpA7oG7jE9wAAAAAAAAAYhqf4HaOT3ADAAAAAAAAABBCTHADAAAAAAAAAKISE9wAAAAAAAAAgKiUYLsBAAAAAAAAAAgL308LahYlx4lPcAMAAAAAAAAAohIT3AAAAAAAAACAqMQENwAAAAAAAAAgKkXUBPeMGTPUvn17JSUlacCAAfryyy9rXfvxxx9r5MiRat26tVwul9566y1H+87KytJpp52m1NRUNW/eXKNGjdL69esdbWPmzJnq0aOH0tLSlJaWpoEDB+r99993tI1jTZs2TS6XS5MmTap1zQMPPCCXy+W3dO7c2dF+f/zxR1155ZVq0qSJkpOTdeqpp2r58uW1rm/fvn2lHlwulyZMmOCoj3CK5uzFSu4ks+yRu7cc7Zsx76i6NuaRO3/kLnyiOXuxkjuJc21dzp3kPHuRkDsp+rIXzbmTYmfMI3e1z51kP3vk7ohoyx0QKSJmgvvVV1/V5MmTdf/992vlypXq2bOnhg8frj179tSqvqCgQD179tSMGTMC2v/ixYs1YcIELV26VAsXLlRJSYnOO+88FRQU1Hobbdq00bRp07RixQotX75c55xzji6++GJ98803jvtZtmyZnnnmGfXo0cNxbbdu3bRz586K5dNPP6117cGDBzVo0CDVq1dP77//vtatW6fHHntMjRo1ctT7sftfuHChJCkzM9Px9xIO0Z69WMidZJ49cucMY94RdW3MI3f+yF34RHv2YiF3Eufaupw7KfDs2c5dee/Rkr1oz50UG2MeuXOWO8l+9sjd0d6jJXdAJHH5fL6IuB/mgAEDdNppp+mpp56SJHm9XmVkZOi3v/2t7r77bkfbcrlcmjdvnkaNGhVwP3v37lXz5s21ePFinXXWWQFvp3HjxnrkkUd03XXX1bomPz9fffr00d/+9jc99NBD6tWrl6ZPn16r2gceeEBvvfWWVq1aFVC/d999tz777DN98sknAdVXZdKkSXr33Xe1YcMGuVyuoG03WGIxe9GWOyn42SN3zjDm1Y0xj9wdRe7CKxazF225kzjX1tXcSYFnLxJzJ0V29mIxd1L0jXnkLvDcSZGTPXIX2bmLRrm5uUpPT1e7qX9SXFKS7XaigreoSFvvuVc5OTlKS0uz3U61IuIT3MXFxVqxYoWGDh1a8VhcXJyGDh2qzz//3EpPOTk5ko4MqIEoKyvT3LlzVVBQoIEDBzqqnTBhgi644AK/4+HEhg0b1Lp1a3Xs2FFjxozRtm3bal37zjvvqF+/fsrMzFTz5s3Vu3dvPffccwH1IR15bl9++WVde+21ETkYx1r2ojV3UnCzR+6cY8yL/TGP3Pkjd+ETa9mL1txJnGvrau4ks+xFUu6kyM5erOVOit4xj9zZzZ1UN8+1dSl3QKSJiAnuffv2qaysTC1atPB7vEWLFtq1a1fY+/F6vZo0aZIGDRqk7t27O6pds2aNGjRoILfbrfHjx2vevHnq2rVrrevnzp2rlStXKisry2nbko785nb27NmaP3++Zs6cqc2bN+vMM89UXl5erep/+OEHzZw5UyeffLIWLFigG2+8UTfffLP+8Y9/BNTPW2+9pUOHDumaa64JqD7UYiV70Z47KbjZI3fOMObVjTGP3B1F7sIrVrIX7bmTONdKdS93kln2Ii13UmRnL1ZyJ0X/mEfu7OVOqrvn2rqUOyDSJNhuIBJNmDBBa9eudXx9OUnq1KmTVq1apZycHL3xxhsaO3asFi9eXKtBOTs7W7fccosWLlyopAD/VGLEiBEV/9+jRw8NGDBA7dq102uvvVarP+vxer3q16+fpk6dKknq3bu31q5dq6efflpjx4513M/zzz+vESNGqHXr1o5r66JAsxftuZOCmz1y5wxjHmOeDeSO3NnCuZZzrQ02cieZZy/ScieRPSc415I7W+rquZbcAfZExCe4mzZtqvj4eO3evdvv8d27d6tly5Zh7WXixIl699139eGHH6pNmzaO6xMTE3XSSSepb9++ysrKUs+ePfXkk0/WqnbFihXas2eP+vTpo4SEBCUkJGjx4sX6y1/+ooSEBJWVlTnup2HDhjrllFO0cePGWq3fqlWrSiePLl26OP5TREnaunWrFi1apF//+teOa8MlVrIX7bmTgpc9cucMY17dGfPI3RHkLvxiJXvRnjuJc61Ut3InBT97NnMnRX72YiV3UvSPeeTOTu6kun2urUu5AyJNRExwJyYmqm/fvvrggw8qHvN6vfrggw8CusZcIHw+nyZOnKh58+bpv//9rzp06BCU7Xq9Xnk8nlqte+6552rNmjVatWpVxdKvXz+NGTNGq1atUnx8vOP95+fna9OmTWrVqlWt1h80aJDWr1/v99j333+vdu3aOd73rFmz1Lx5c11wwQWOa8MlVrMXbbmTgpc9clc7jHlH1KUxj9wdQe7CL1azF225kzjX1rXcScHPns3cSZGfvVjNnRR9Yx65C2/uJPtjHrkD6raIuUTJ5MmTNXbsWPXr10/9+/fX9OnTVVBQoHHjxtWqPj8/3++3aps3b9aqVavUuHFjtW3btsb6CRMmaM6cOXr77beVmppaca2q9PR0JScn16qHKVOmaMSIEWrbtq3y8vI0Z84cffTRR1qwYEGt6lNTUytdnyolJUVNmjSp9XWrbr/9do0cOVLt2rXTjh07dP/99ys+Pl5XXHFFrepvvfVWnX766Zo6dapGjx6tL7/8Us8++6yeffbZWtWX83q9mjVrlsaOHauEhIiJWZWiPXuxkDspONkjd4x5jHnHR+7InS3Rnr1YyJ3Eubau5U4yz16k5E6KnuxFe+6k2BjzyJ2z3En2s0fujoqW3EUzl+/IgppFy3GKmJ+Uyy+/XHv37tV9992nXbt2qVevXpo/f36lGyVUZ/ny5RoyZEjFvydPnixJGjt2rGbPnl1j/cyZMyVJgwcP9nt81qxZtb6g/549e3T11Vdr586dSk9PV48ePbRgwQINGzasVvXBsH37dl1xxRXav3+/mjVrpjPOOENLly5Vs2bNalV/2mmnad68eZoyZYr++Mc/qkOHDpo+fbrGjBnjqI9FixZp27ZtuvbaawP5NsIq2rMXC7mTgpM9cseYx5h3fOQuOMidc9GevVjIncS5ltw5Fym5k6Ine9GeOyk2skfunOVOsp89cndUtOQOiCQun88XJXPxAAAAAAAAAOBcbm6u0tPT1f5Pf1JcgDcjrWu8RUXacu+9ysnJUVpamu12qhUR1+AGAAAAAAAAAMApJrgBAAAAAAAAAFGJCW4AAAAAAAAAQFSKmJtMAgAAAAAAAEBI+X5aULMoOU58ghsAAAAAAAAAEJWY4AYAAAAAAAAARKWIm+D2eDx64IEH5PF4rNTTQ2T1EC6xcrzoIXjbCIdI+F7pIXJ6CKdYOF70ELwewiVWjpftHmLhewinWDle9BC8bYRLLBwvegheD+ESCd8rPUROD0Bd4vL5fBF1NZXc3Fylp6crJydHaWlpYa+nh8jqIVxi5XjRQ/C2EQ6R8L3SQ+T0EE6xcLzoIXg9hEusHC/bPcTC9xBOsXK86CF42wiXWDhe9BC8HsIlEr5XeoicHlBZ+XFt/9CfFJeUZLudqOAtKtKW390b8VmMuE9wAwAAAAAAAABQGwm2GwAAAAAAAACAsPD9tKBmUXKcwj7B7fV6tWPHDqWmpsrlclX6em5urt9/nTKtp4fw9uDz+ZSXl6fWrVsrLi50f1AQ6twFYxv0EL4eyB092OghUnJXm15rUlees1joIVy5kxjzoqU+XD1EypgXLceLHoKzjUjJXW16rUldec5ioYdYOtdGw/Gmh6PCmT0g0oX9Gtzbt29XRkZGOHeJKJCdna02bdqEbPvkDlUhd7CB3MGGUOdOInuoGmMebCB3sIFzLWwJR/ZiRW7uT9fgfpBrcNeWt6hIW34f+dfgDvsnuFNTUyVJrafeE3CYGrTKN+4jf3cDo/r4w+a/HYsrqfq3/bXlPiXHuIfRHVYa1e/0NDSqLy4o0T/Of7siF6FSvv17PzhLSQ0Ci/0L3ww07qMk121Un5Abb9xDXNsCo/ri/ETjHjp33GlUv3lfY6N6b6FHm294PGy56/niTYqvH9hz7yk1H6bzC8xy98tOXxv38PYHvzCqd7Uzy60kudabjfsjL/jcqN5TUKKZw+eHLXfD37xS9VIC+3ld9U174z4G9/rWqH7JolONeyhuXmpU3yLjgHEPLpfZ5wh2b2hmVO8tKtKP9z8U8txJR7OXcd/vAn6Nl9wh8E9KlSspMTtXeg4kG/fg3mU2dvc8d71xD6Y2HWpqVF922KO1Y58K25h35mvXKqF+YGPehu9bG/cRn15sVF+WZ/76qkELs/dIJV83NO6hUf/dRvXxhmNm6WGPVox5Jmy5u+o/v1RiSr2AtrHgq+7GfbhKzd5PNutgfp5rmmL2Gm3boYbGPZi+tx/cw+w1S3FBiV4b+UZYz7WPLe6t5AaBne+yll1g3IfxxyQ95u9rJ58x36h+d3G6cQ+f7D3RqD57Ywujem9RkX68909hyR4Q6cI+wV3+ZzRxSUmKSw7szU98/RLjPgLdd0W9NwgT3PFmL0ji6xcZ95DUILAXZOUS65nVl6vuT/uCpXz7SQ0SAp7gjqtv/tu9uBKzica44iBMcNcvM6svM38DFuikW7n4w8H5TWu4chdf3634lMCe+/gS82E6zmd2vNyG44Qk49+OuwxzG4wegnEcpPDlrl5KYsA/a6bnSElKbGD4cx6ET1TEJZtNcAf6c+vXg+FkTTCeCyn0uTt2H3FJSQH/vMXX9xj34TUcN+MKzY95fJJZD6bnyWCILzbPvxS+MS+hfqISAvyZDcbPWVx9s/cGvlLz59z0PZI3CONuoM9BOdMJ7nLhyl1iSj0lBvj6IBi5M53gDsZ5rl6KWe6CMdaYHkvT1yzlwnmuTW4Qr+RA39cGIXvGE9xx5u9rA/3+y7mLzV/bJxw2fH8fRa/zgEjHRXoAAAAAAAAAAFEpoAnuGTNmqH379kpKStKAAQP05ZdfBrsvoBJyB1vIHmwgd7CB3MEGcgdbyB5sIHeAfS4fi5MlGjie4H711Vc1efJk3X///Vq5cqV69uyp4cOHa8+ePaHoD5BE7mAP2YMN5A42kDvYQO5gC9mDDeQOAELD8QT3448/ruuvv17jxo1T165d9fTTT6t+/fp64YUXQtEfIIncwR6yBxvIHWwgd7CB3MEWsgcbyB0AhIajCe7i4mKtWLFCQ4cOPbqBuDgNHTpUn3/+eZU1Ho9Hubm5fgvgBLmDLU6zR+4QDOQONnCuhQ3kDrZwroUNjHkAEDqOJrj37dunsrIytWjRwu/xFi1aaNeuXVXWZGVlKT09vWLJyMgIvFvUSeQOtjjNHrlDMJA72MC5FjaQO9jCuRY2MOYBQOgEdJNJJ6ZMmaKcnJyKJTs7O9S7BMgdrCB3sIHcwRayBxvIHWwgd7CF7AFA7SQ4Wblp06aKj4/X7t27/R7fvXu3WrZsWWWN2+2W2+0OvEPUeeQOtjjNHrlDMJA72MC5FjaQO9jCuRY2MOYBEcTnOrKgZlFynBx9gjsxMVF9+/bVBx98UPGY1+vVBx98oIEDBwa9OUAid7CH7MEGcgcbyB1sIHewhezBBnIHAKHj6BPckjR58mSNHTtW/fr1U//+/TV9+nQVFBRo3LhxoegPkETuYA/Zgw3kDjaQO9hA7mAL2YMN5A4AQsPxBPfll1+uvXv36r777tOuXbvUq1cvzZ8/v9KNEoBgInewhezBBnIHG8gdbCB3sIXswQZyBwCh4XiCW5ImTpyoiRMnBrsX4LjIHWwhe7CB3MEGcgcbyB1sIXuwgdwBQPA5ugY3AAAAAAAAAACRIqBPcAdDv1N/UL2UxIBqT0g6ZLz/D+NONqovKYs37iExodSo/lBOinEP9VxlRvXvre9uVO89XGRU71QX93alJAX23I3ustJ4/+9t62pUP/7sT4x7yFo6wqh+cPf1xj18+c6pRvVJAw4Y1ZeVmv3sOfVi11eUmhrY7xOHfXGj8f7fPn2mUf2PpWnGPdQ/v9isPs6sXpJeTj7NqH5bYWOj+pIi8+/BiVJvvFzewMa7iweYj3en1t9uVL9/SH3jHlb90Nao/vOe/zLu4dx1FxnV9+i12ai+pKBY2UZbcO7CM5fL3aBeQLVt3WbjuyR1cu8wqp+8erRxD6f12mZU3zlll3EPdzXZYFR/Rt4lRvWl8eE91zZyF6qeO7DXtVOGvGu8f9PXV5ectty4h/V5Zpc46DHqG+Me9peYvT/p0cDs3FGYX6ovjLbgzIRmH6lBgK/x/pNo9npYknxJPqP6jun7jXu4tNkKo/pZvkHGPWzwBHbOKdcu2ew4FJWVGNUHtE9foly+wKZzTs7Ybbz/PfkNjOr7tTR/dbKnxOw9yv3N1hn38NLaAWYbaGCYnfjwZy9m+H5aULMoOU58ghsAAAAAAAAAEJWY4AYAAAAAAAAARCUmuAEAAAAAAAAAUYkJbgAAAAAAAABAVHI8wf3xxx9r5MiRat26tVwul956660QtAX4I3ewgdzBBnIHW8gebCB3sIHcwRayBwCh4XiCu6CgQD179tSMGTNC0Q9QJXIHG8gdbCB3sIXswQZyBxvIHWwhe0BkcPlYnCzRIMFpwYgRIzRixIhQ9AJUi9zBBnIHG8gdbCF7sIHcwQZyB1vIHgCEhuMJbqc8Ho88Hk/Fv3Nzc0O9S4DcwQpyBxvIHWwhe7CB3MEGcgdbyB4A1E7IbzKZlZWl9PT0iiUjIyPUuwTIHawgd7CB3MEWsgcbyB1sIHewhewBQO2EfIJ7ypQpysnJqViys7NDvUuA3MEKcgcbyB1sIXuwgdzBBnIHW8geANROyC9R4na75Xa7Q70bwA+5gw3kDjaQO9hC9mADuYMN5A62kD0AqJ2QT3ADAAAAAAAAQETw/bSgZlFynBxPcOfn52vjxo0V/968ebNWrVqlxo0bq23btkFtDihH7mADuYMN5A62kD3YQO5gA7mDLWQPAELD8QT38uXLNWTIkIp/T548WZI0duxYzZ49O2iNAccid7CB3MEGcgdbyB5sIHewgdzBFrIHAKHheIJ78ODB8vmi5PPpiBnkDjaQO9hA7mAL2YMN5A42kDvYQvYAIDTibDcAAAAAAAAAAEAgrN1kct17pyjenRRQ7df98oz3X5ydYlTf+JQDxj3kft3EqP43Fy0y7mHpoQ5G9X/o945RfWF+qW4w2oIz64tbK8kTWOzfePtM4/0Xdygyqn9q/dnGPXRqt8uo/spmS4x7OPlXe4zqO7rN6g/nl+l6oy0488+cXkoqqxdQbZcWZs+XJP1y7mSj+oan7jPuISc/2aj+wpPWGvfQJj3HqP7l9h8Z1efmefWG0Racuaj5V0puENh4d/+SUcb7/7jpiUb1xUvMzpGS1Gqw2c/Pi7lNjXv4fYd3jeqztpxvVF9a6jWqD8T7P3RRfP3AXuPdcepC4/3f+vVoo/rDu81eI0rS8qWnGtUnXGr+vF1X0MKovmlygVF9ibfYqN6p61ssVkpqYJ/diQ/C3ZPanbDfqP7NlX2Ne1C82fexaYvZ+wJJatDf7DXD+kNmuS0t8Ej6xGgbTnzlaa36ifEB1Y7oYf7aZsmLfYzq97c1H++mff8/RvVN6puNNZKkjWbfR72uZUb1ZS6z+kCkxHmUHBfYfn9YnmG8/9LmZmP8p1/1NO4hb9h3RvV3lQX2WuVY3hKzz4zG70k0qncV8dcAQDlrE9wAAAAAAAAAEFY+ycXvB2onSo4TlygBAAAAAAAAAEQlJrgBAAAAAAAAAFHJ0QR3VlaWTjvtNKWmpqp58+YaNWqU1q9fH6reAEnkDvaQPdhA7mADuYMtZA82kDvYQO4AIHQcTXAvXrxYEyZM0NKlS7Vw4UKVlJTovPPOU0FBEG4MAVSD3MEWsgcbyB1sIHewhezBBnIHG8gdAISOo5tMzp8/3+/fs2fPVvPmzbVixQqdddZZQW0MKEfuYAvZgw3kDjaQO9hC9mADuYMN5A4AQsfoGtw5OTmSpMaNG1e7jsfjUW5urt8CmCB3sKWm7JE7hAK5gw2ca2ELYx5sIHewgXMtYJGPxdESgBkzZqh9+/ZKSkrSgAED9OWXX9aqbu7cuXK5XBo1apSj/QU8we31ejVp0iQNGjRI3bt3r3a9rKwspaenVywZGRmB7hIgd7CmNtkjdwg2cgcbONfCFsY82EDuYAPnWgCx7NVXX9XkyZN1//33a+XKlerZs6eGDx+uPXv2HLduy5Ytuv3223XmmWc63mfAE9wTJkzQ2rVrNXfu3OOuN2XKFOXk5FQs2dnZge4SIHewpjbZI3cINnIHGzjXwhbGPNhA7mAD51oAsezxxx/X9ddfr3Hjxqlr1656+umnVb9+fb3wwgvV1pSVlWnMmDH6wx/+oI4dOzrep6NrcJebOHGi3n33XX388cdq06bNcdd1u91yu92B7AbwQ+5gS22zR+4QTOQONnCuhS2MebCB3MEGzrUAotHPL5FU3fhUXFysFStWaMqUKRWPxcXFaejQofr888+r3f4f//hHNW/eXNddd50++eQTx/05+gS3z+fTxIkTNW/ePP33v/9Vhw4dHO8QcIrcwRayBxvIHWwgd7CF7MEGcgcbyB2AaJaRkeF3yaSsrKwq19u3b5/KysrUokULv8dbtGihXbt2VVnz6aef6vnnn9dzzz0XcH+OPsE9YcIEzZkzR2+//bZSU1MrGktPT1dycnLATQDHQ+5gC9mDDeQONpA72EL2YAO5gw3kDkA0y87OVlpaWsW/g/XXJXl5ebrqqqv03HPPqWnTpgFvx9EE98yZMyVJgwcP9nt81qxZuuaaawJuAjgecgdbyB5sIHewgdzBFrIHG8gdbCB3QATx/bSgZj8dp7S0NL8J7uo0bdpU8fHx2r17t9/ju3fvVsuWLSutv2nTJm3ZskUjR46seMzr9UqSEhIStH79ep144ok17tfRBLfPx7OP8CN3sIXswQZyBxvIHWwhe7CB3MEGcgegLkhMTFTfvn31wQcfaNSoUZKOTFh/8MEHmjhxYqX1O3furDVr1vg99rvf/U55eXl68sknlZGRUav9BnSTSQAAAAAAAAAAjjV58mSNHTtW/fr1U//+/TV9+nQVFBRo3LhxkqSrr75aJ5xwgrKyspSUlKTu3bv71Tds2FCSKj1+PNYmuBNzfYpPDOw3mCVfphrvv/G5VV/YvLbyisyvNdO6/w6j+v/sqP0TXZ2PT51nVP9OQX2j+nhXmVG9Uy+8eZ7ik5ICqq1XaL7/0r2JRvUDOq037mFww++M6s9NNn/ONhXnGdV3TNxjVF9Qz2tU79SS/R2VEOCY8cOXbY33n7zLZVSfV9jMuIek3geN6t/7oZtxD0X7za5teOqB/zWqLzvskfSw0TaceH1nPyWkBJa7U9qZnSMlafMXtftNe3VS8o1bUN7Cyn8C58SbF/U17mFNdmujet8Bs/OGt7DIqD4QbRsfCjh7O0saGu9/SNuNRvWLvulj3IOr1Kz+kwU9jHvoOtjsOKxZYXbzM29ReLP3yr6BSiwK7OfluYzPjPefUxjY68ty43/xkXEPL84ZZlQfF4SX5QWfB37tTElynb7XqL6sNLyv8S5pkKu0BnEB1b651+x9lCTVG77PqL6gxOwcI0l3nLLAqP6Bl8YY96AA5xXKvfSK2c9OmadI0iKjbTj1Y3EjJRXXC6j2gVGvGe//b5vPNqpv0LbYuIctOY2N6tOD8Aa/3o9mP0P1d5q9TysrNqsHQuXyyy/X3r17dd9992nXrl3q1auX5s+fX3HjyW3btikuLrDzZ3X4BDcAAAAAAAAAICgmTpxY5SVJJOmjjz46bu3s2bMd7y+40+UAAAAAAAAAAIQJn+AGAAAAAAAAUCe4fEcW1CxajhOf4AYAAAAAAAAARCVHE9wzZ85Ujx49lJaWprS0NA0cOFDvv/9+qHoDJJE72EP2YAO5gw3kDraQPdhA7mADuQOA0HE0wd2mTRtNmzZNK1as0PLly3XOOefo4osv1jfffBOq/gByB2vIHmwgd7CB3MEWsgcbyB1sIHcAEDqOrsE9cuRIv3//6U9/0syZM7V06VJ169YtqI0B5cgdbCF7sIHcwQZyB1vIHmwgd7CB3AFA6AR8k8mysjK9/vrrKigo0MCBA6tdz+PxyOPxVPw7Nzc30F0C5A7W1CZ75A7BRu5gA+da2MKYBxvIHWzgXAsAweX4JpNr1qxRgwYN5Ha7NX78eM2bN09du3atdv2srCylp6dXLBkZGUYNo24id7DFSfbIHYKF3MEGzrWwhTEPNpA72MC5FgBCw/EEd6dOnbRq1Sp98cUXuvHGGzV27FitW7eu2vWnTJminJyciiU7O9uoYdRN5A62OMkeuUOwkDvYwLkWtjDmwQZyBxs41wJAaDi+REliYqJOOukkSVLfvn21bNkyPfnkk3rmmWeqXN/tdsvtdpt1iTqP3MEWJ9kjdwgWcgcbONfCFsY82EDuYAPnWgAIDcef4P45r9frd00oIBzIHWwhe7CB3MEGcgdbyB5sIHewgdwBQHA4+gT3lClTNGLECLVt21Z5eXmaM2eOPvroIy1YsCBU/QHkDtaQPdhA7mADuYMtZA82kDvYQO4AIHQcTXDv2bNHV199tXbu3Kn09HT16NFDCxYs0LBhw0LVH0DuYA3Zgw3kDjaQO9hC9mADuYMN5A4AQsfRBPfzzz8fqj6AapE72EL2YAO5gw3kDraQPdhA7mADuQMiiO+nBTWLkuNkfA1uAAAAAAAAAABscPQJ7mBq+vyXSnDVC6h2740Djfe/96sWRvVlbYqMeyhd1sio3tUnx7iHnl9eYVTfrdkuo/qSgmJJ3xhtwwn3QSk+wJtQt/jrEuP9Z997ulH9Z//uadyD54J4o/rXdyUb97Bxf1Oj+sM/NjCq9xYWSfq90Tac+GFVhuKSkgKqTcxzGe+/5XSz7O7+rVluJenwuoZG9WUZ5mNu8o9mp7ziRmb13uJSo3qntuxtrLiCwHJXb7XZz5gkpeSa1Td/ynzM3XGHWXbXrOhg3IOamd04KvUHszG7zGNWH4jszzIU7w4se6vPKzTe/9cfnWJUn5hrPu62etwsv3smmo+7a5ecZFRv/CmYYvPj6MTy3RmKzwvsRd7wfLPX5JKUczDFqP65Beca95CaZ1YfjHHX9DVDwWfNjOrLPOavF5w4d/XFik8JLHe5hwMbJ/2sSjMqP9DJfMy9d9X/GtWnmL+lVYu/fG5UbzrmxhUblQdkd3G6EosDm0955uNzjPfvbn7YqD7v85bGPRxu7TWq/zi3uXEPyYfM6k3H3VJfiVkDQAzhE9wAAAAAAAAAgKjEBDcAAAAAAAAAICoxwQ0AAAAAAAAAiEpGE9zTpk2Ty+XSpEmTjJq4yveNxvjWVfm1Mb51usoXvms0I/IFK3fBQHbrjkjKnSlyG11iKXumyG74kLvgIru1Q+4iT13JLtmLPdGQXXKHn4uG3MYKl4/FyRINAp7gXrZsmZ555hn16NHDuAmvXLpG6yr9II/xrdM1WievwnuTGkSuYOYuGMhu3RBpuTNFbqNHrGXPFNkND3IXfGS3ZuQuMtWF7JK92BTp2SV3qEqk5xaIZAFNcOfn52vMmDF67rnn1KiR+V3HX3F11Wx19ftBLv8Bnq2uesXV1XgfiH7Bzl0wkN3YF4m5M0Vuo0MsZs8U2Q09chcaZPf4yF3kivXskr3YFcnZJXeoTiTnFoh0CYEUTZgwQRdccIGGDh2qhx566LjrejweeTyein/n5uZWud4rrq6ST7pG6/S/vu+UKC8/wPATitwFA9mNbZGaO1PkNvLVNnvRlLtgILuhFatjXiQgu9Ujd5EtlrPLuTa2RWp2GfNwPJGaWyDSOf4E99y5c7Vy5UplZWXVav2srCylp6dXLBkZGdWu+4qrq4oVp0R5Vaw4foBRIZS5CwayG5siPXemyG3kcpK9aMtdMJDd0Ij1MS8SkN3KyF10iMXscq6tGyItu4x5qI1Iyy0QDRxNcGdnZ+uWW27RK6+8oqSkpFrVTJkyRTk5ORVLdnZ2teuO8a2r+AFOlLfai+ujbgl17oKB7MaeaMidKXIbmZxmL9pyFwxkN/jqwpgXCciuP3IXPWItu5xr645Iyi5jHmorknILRAtHlyhZsWKF9uzZoz59+lQ8VlZWpo8//lhPPfWUPB6P4uPj/WrcbrfcbneN2/75dYXK/y2f+G1VHRfK3AUD2Y1NkZ47U+Q2cjnNXjTlLhjIbmjE+pgXCchuZeQuOsRidjnX1g2Rll3GPNRGpOU2pvlsN4BgcjTBfe6552rNmjV+j40bN06dO3fWXXfdVWkwrq2qLpp/7HWH+EGu20KVu2Agu7ErknNnitxGtljOnimyGzrkLrTIbtXIXeSL1eySvdgXidkld6hJJOYWiBaOJrhTU1PVvXt3v8dSUlLUpEmTSo87ESdflRfNL/9BjuPXKnVaqHIXDGQ3dkVy7kyR28gWy9kzRXZDh9yFFtmtGrmLfLGaXbIX+yIxu+QONYnE3ALRwtEEd6i85OpW7df47RQiGdlFNCK3iFZkF9GK7CJakV1EK7KLaERugcAZT3B/9NFHQWgDcIbcwQZyB1vIHmwgd7CB3MEWsgcbyB0ABEec7QYAAAAAAAAAAAiEtUuU7J4wQPHupMCKveb7T+yUY1Rf7DE/dIUnFhvVu8vMfz8xvvOnRvXbixsZ1Xu8JUb1TpU0kLwB3oT6x7tON96/N9GsvsmAXcY95JeY3YX7rCYbjHtY+2Mro/r4Jh6jetdhs3qnEvJdii91BVYchF9D7rzNLLslKeY9/Pbi94zq399T/Z/r1Zb3hACfg5/syW9gVF/mMxvznXLF+RQXF9h1+rqM+N54/+v+7xSj+h13mI+5RU3NrlM48uzlxj3sKUo1ql/q7WBU7y0sMqoPROnJh+WtH9iLtRxPsvH++w75zqh+5aIuxj3smmSW36Jm5tfYHHLOKqP6jzafbNbA4fBmz/VpQ7kCfG+x8+wg7D/e7A1K/4HrjXv4+oBZdoMx7nqamGW3/1nfGtWXFBRrw6NGm3Bk38EGivMElruErQG+Fz5GyUlmr2n7ddhm3ENG14NG9e+98wvjHrb+caBRvc9llltvUfivi/zxjycqvn5g7+t6nfqD8f5zis3O1/vOKjXuIa7Q7M1139O3Gvew4v/MLhuy6xazcbfMUyTNfNtoG3WW76cFNYuS48QnuAEAAAAAAAAAUYkJbgAAAAAAAABAVGKCGwAAAAAAAAAQlZjgBgAAAAAAAABEJUcT3A888IBcLpff0rlz51D1Bkgid7CH7MEGcgcbyB1sIXuwgdzBBnIHAKGT4LSgW7duWrRo0dENJDjeBOAYuYMtZA82kDvYQO5gC9mDDeQONpA7IDK4fEcW1CxajpPj0TQhIUEtW7YMRS9AtcgdbCF7sIHcwQZyB1vIHmwgd7CB3AFAaDi+BveGDRvUunVrdezYUWPGjNG2bduOu77H41Fubq7fAjhF7mCLk+yROwQLuYMNnGthC2MebCB3sIFzLQCEhqMJ7gEDBmj27NmaP3++Zs6cqc2bN+vMM89UXl5etTVZWVlKT0+vWDIyMoybRt1C7mCL0+yROwQDuYMNnGthC2MebCB3sIFzLQCEjqMJ7hEjRigzM1M9evTQ8OHD9d577+nQoUN67bXXqq2ZMmWKcnJyKpbs7GzjplG3kDvY4jR75A7BQO5gA+da2MKYBxvIHWzgXAsAoWN0R4OGDRvqlFNO0caNG6tdx+12y+12m+wG8EPuYEtN2SN3CAVyBxs418IWxjzYQO5gA+daAAgex9fgPlZ+fr42bdqkVq1aBasfoEbkDraQPdhA7mADuYMtZA82kDvYQO4Ai3wsjpYo4GiC+/bbb9fixYu1ZcsWLVmyRL/85S8VHx+vK664IlT9AeQO1pA92EDuYAO5gy1kDzaQO9hA7gAgdBxdomT79u264oortH//fjVr1kxnnHGGli5dqmbNmoWqP4DcwRqyBxvIHWwgd7CF7MEGcgcbyB0AhI6jCe65c+eGqg+gWuQOtpA92EDuYAO5gy1kDzaQO9hA7gAgdIyuwQ0AAAAAAAAAgC2OPsEdTMWpUnyANwMu6XzYeP8pcV6j+rJS898NJG1LNKr3tDe/0vvMb880qne5zHooO+yR9LbRNpxoeuZOJaQEFrzta1oa79/X3GNUv3N9c+MeDrVJNqpfv9e8B+1MMipPyDH7+SvzhPd3ew367ld8/cBy173pTuP9f/pRd6P6EUOXG/fw+aGORvUPtDcfJ65edq1R/bguS43qi/JLtNZoC85c3flLJTUI7DR/fgPzTh8+f7hR/ZLPuhr3kN7pgFF9n5Qtxj0oxax8W14jo/rSAo+yzVpwrFPrPaqXEthrnHdOnm+8/zt29TaqTx6+2riHTxeealSf1nO/cQ8N6xUa1Q/usMGovji/WD8YbcEZT/88xdcvCai2f4sfjfd/SbeVRvW5ZWavjSTp8HCz9xbfLTY7V0tSg65m424Ld65RvacksAwEKql+ieLrB/a68oLzvzLef16pWW56pJifIb4rNLtBYu/zvjXuYcWHnY3q65960Kj+yHva8Bp74hcGr/O+Md7/E3vONapfXdbauId2jcyet72FDYx7aPyLXUb1+78wm2MoKzIqB2KKtQluAAAAAAAAAAgnl+/IgppFy3HiEiUAAAAAAAAAgKjEBDcAAAAAAAAAICo5nuD+8ccfdeWVV6pJkyZKTk7WqaeequXLza/PChwPuYMtZA82kDvYQO5gA7mDLWQPNpA7AAgNR9fgPnjwoAYNGqQhQ4bo/fffV7NmzbRhwwY1amR2AyTgeMgdbCF7sIHcwQZyBxvIHWwhe7CB3AFA6Dia4H744YeVkZGhWbNmVTzWoUOHoDcFHIvcwRayBxvIHWwgd7CB3MEWsgcbyB0AhI6jS5S888476tevnzIzM9W8eXP17t1bzz333HFrPB6PcnNz/RbACXIHW5xmj9whGMgdbOBcCxvIHWzhXAsbGPOACOJjcbREAUcT3D/88INmzpypk08+WQsWLNCNN96om2++Wf/4xz+qrcnKylJ6enrFkpGRYdw06hZyB1ucZo/cIRjIHWzgXAsbyB1s4VwLGxjzACB0HE1we71e9enTR1OnTlXv3r31m9/8Rtdff72efvrpamumTJminJyciiU7O9u4adQt5A62OM0euUMwkDvYwLkWNpA72MK5FjYw5gFA6Dia4G7VqpW6du3q91iXLl20bdu2amvcbrfS0tL8FsAJcgdbnGaP3CEYyB1s4FwLG8gdbOFcCxsY8wAgdBxNcA8aNEjr16/3e+z7779Xu3btgtoUcCxyB1vIHmwgd7CB3MEGcgdbyB5sIHcAEDqOJrhvvfVWLV26VFOnTtXGjRs1Z84cPfvss5owYUKo+gPIHawhe7CB3MEGcgcbyB1sIXuwgdwBQOg4muA+7bTTNG/ePP3zn/9U9+7d9eCDD2r69OkaM2ZMqPoDyB2sIXuwgdzBBnIHG8gdbCF7sIHcARHEx+JoiQIJTgsuvPBCXXjhhaHoBagWuYMtZA82kDvYQO5gA7mDLWQPNpA7AAgNR5/gBgAAAAAAAAAgUjj+BHeweE4oUVxyfEC1TdMOG++/T/Nso/q1B1oZ97DLZVZ/Yqt9xj2c3WyDUX3v+luM6g/nlelXRltwpl58mRLiywKqvWbYR8b733S4mVH9xU2+Mu7h7z+eaVT/cPs3jXuY2XawUX1G0gGj+qL8Ev1xmtEmHGmcXKCE+qUB1a7Y1cZ4/3EdCozqv89tbtzDWU03GtVP33GecQ9391hgVL/4UCej+uKCYqN6p/7xzS8UVz8poNrvOpif4z5df7JRfUIb83P9oU2Njeo3tzXPfot6OUb1g1uanac9+SVaZrQF57YebKR4jzug2t7LzF8VZHYwO1f+a0l/4x5cqWZ/y7lvR7pxD91O2m5U/0mx2Zjn9YX5czQ+l3y+wF5cr91rPuZ9f/B/jOovarPGuIfVa9ob1fuaBvYa+Vil+clG9e2T9hvVF5UG9norUL/v+h/VTw3sPe1ft55jvP9DhYGd58vtadjAuIfv95u9vykpMZ+SKDbMbpsUs9ccpfIY1Qfi3JTv1KBBYOPssqIM4/0PbfiNUf32ww2Ne1i99QSj+pNP2GPcw2FPolF981/sNKovLfDoB6MtALGDT3ADAAAAAAAAAKISE9wAAAAAAAAAgKhk7RIlAAAAAAAAABBOLt+RBTWLluPEJ7gBAAAAAAAAAFHJ0QR3+/bt5XK5Ki0TJkwIVX+AJLIHO8gdbCB3sIHcwRayBxvIHWwgdwAQOo4uUbJs2TKVlR29Q/HatWs1bNgwZWZmBr0x4FhkDzaQO9hA7mADuYMtZA82kDvYQO4AIHQcTXA3a9bM79/Tpk3TiSeeqLPPPjuoTQE/R/ZgA7mDDeQONpA72EL2YAO5gw3kDgBCJ+CbTBYXF+vll1/W5MmT5XK5ql3P4/HI4/FU/Ds3NzfQXQKSapc9codgI3ewgdzBBl7jwRbGPNhA7mAD51oACK6AbzL51ltv6dChQ7rmmmuOu15WVpbS09MrloyMjEB3CUiqXfbIHYKN3MEGcgcbeI0HWxjzYAO5gw2cawHLfCyOligQ8AT3888/rxEjRqh169bHXW/KlCnKycmpWLKzswPdJSCpdtkjdwg2cgcbyB1s4DUebGHMgw3kDjZwrgWA4AroEiVbt27VokWL9Oabb9a4rtvtltvtDmQ3QCW1zR65QzCRO9hA7mADr/FgC2MebCB3sIFzLQAEX0Cf4J41a5aaN2+uCy64INj9AMdF9mADuYMN5A42kDvYQvZgA7mDDeQOAILP8QS31+vVrFmzNHbsWCUkBHyPSsAxsgcbyB1sIHewgdzBFrIHG8gdbCB3ABAajie4Fy1apG3btunaa68NRT9AtcgebCB3sIHcwQZyB1vIHmwgd7CB3AFAaDj+leF5550nny9KbqGJmEL2YAO5gw3kDjaQO9hC9mADuYMN5A6IEL6fFtQsSo5T2P8mpnww9xYWBbyNssMe4z6K84uN6ksLzHvwHg78GASrh6LkEqP6w2VlZvX5R+pDfZIv337p4cCfd9NjJUnFBvuXpMOJZsdbkkoKzHrIz/Ma91Ccb3Ysi0rN6j0FpZKiI3fBGO+8HrPcBGWsSTJ7zkxzK0mF7lKjetPzRknBkWMQrtx5CwN/3ky/1yP7NzvHeb3mY663KKBbjVTwGI5VklRYzyx3nmLT8S48uTt2HybjlivO/BxTZPi8mWZXklxlLrMeXObn+8J8u2NecRSNeWU+8zGvLN7sOTPNrWSeXV+c+XPlSjQ7lkWGuS2vD1fuCvMDf96D8fqqrMhsrCmpF4TsG75WLSsxe84lyVtodhxMn4vy1/rhPNfm5wd+vjxs+N5AMj9PBeO1vemYF5SfwcP1zHooM83ekXp+aQJILl+YfxK2b9+ujIyMcO4SUSA7O1tt2rQJ2fbJHapC7mADuYMNoc6dRPZQNcY82EDuYAPnWtgSjuzFitzcXKWnp6vTLVMV706y3U5UKPMUaf2T9ygnJ0dpaWm226lW2D/B3bp1a2VnZys1NVUuV+XftObm5iojI0PZ2dkBHTjTenoIbw8+n095eXlq3bp1QD3WVqhzF4xt0EP4eiB39GCjh0jJXW16rUldec5ioYdw5U5izIuW+nD1ECljXrQcL3oIzjYiJXe16bUmdeU5i4UeYulcGw3Hmx6OCmf2gEgX9gnuuLi4Wv1mKS0tzeg3A6b19BC+HtLT0wPedm2FK3fB2AY9hKcHckcPNnqIpNxJkX+86CE49eHIncSYF2314eghksa8aDhe9BCcbURS7qTIP170EJz6WDvXRvrxpoejwpU9INKZXZwSAAAAAAAAAABLwv4JbgAAAAAAAACwweU7sqBm0XKcIu4T3G63W/fff7/cbreVenqIrB7CJVaOFz0EbxvhEAnfKz1ETg/hFAvHix6C10O4xMrxst1DLHwP4RQrx4segreNcImF40UPweshXCLhe6WHyOkBqEtcPp8vSubiAQAAAAAAAMC53Nxcpaenq/PNUxXvTrLdTlQo8xTpu7/co5ycHONr0odSxH2CGwAAAAAAAACA2mCCGwAAAAAAAAAQlZjgBgAAAAAAAABEpQTbDQAAAAAAAABAWPh+WlCzKDlOfIIbAAAAAAAAABCVmOAGAAAAAAAAAEQlJrgBAAAAAAAAAFGJCW4AAAAAAAAAQFRighsAAAAAAAAAEJUSbDcAAAAAAAAAAOHg8h1ZULNoOU58ghsAAAAAAAAAEJWY4AYAAAAAAAAARKWYnuBetmyZTj/9dKWkpMjlcmnVqlW2W6rRn//8Z3Xu3Flerzfs+/7Vr36l0aNHh32/sYbcOXP33XdrwIABYd9vrCF3zpC74CF7zpC94CB3zvAaLzjInTPkLnjInjNkLzjInTPkDrArZie4S0pKlJmZqQMHDuiJJ57QSy+9pHbt2tlu67hyc3P18MMP66677lJc3NGnpn379nK5XJWW8ePH13rbzz//vLp06aKkpCSdfPLJ+utf/1ppnbvuukv/+te/9PXXXwfl+6mLyN1RM2fOVGZmptq2bSuXy6VrrrmmyvUmTZqkr7/+Wu+8804wvp06idwdkZ2drT/84Q/q37+/GjVqpKZNm2rw4MFatGhRpXXJXXCQvSMKCwt13XXXqXv37kpPT1eDBg3Us2dPPfnkkyopKfFbl+yZI3dV+/TTTyvq9+3b5/c1XuOZI3dHVVXrcrk0bdo0v/XIXXCQPX+7d+/WDTfcoBNOOEFJSUlq3769rrvuOr91yJ45cnfE7Nmzqx3zXC6XXnnllYp1yR1gV8zeZHLTpk3aunWrnnvuOf3617+23U6tvPDCCyotLdUVV1xR6Wu9evXSbbfd5vfYKaecUqvtPvPMMxo/frwuvfRSTZ48WZ988oluvvlmHT58WHfddVfFer1791a/fv302GOP6cUXXzT7ZuoocnfUww8/rLy8PPXv3187d+6sdr2WLVvq4osv1qOPPqqLLrrIWfOQRO7Kvf3223r44Yc1atQojR07VqWlpXrxxRc1bNgwvfDCCxo3blzFuuQuOMjeEYWFhfrmm290/vnnq3379oqLi9OSJUt066236osvvtCcOXMq1iV75shdZV6vV7/97W+VkpKigoKCSl/nNZ45cudv2LBhuvrqq/0e6927d6V/kztzZO+o7OxsDRo0SJI0fvx4nXDCCdqxY4e+/PJLv/XInjlyd8RZZ52ll156qdLjTzzxhL7++mude+65FY+RO8CumJ3g3rNnjySpYcOGNa5bUFCglJSUEHdUs1mzZumiiy5SUlJSpa+dcMIJuvLKKx1vs7CwUPfee68uuOACvfHGG5Kk66+/Xl6vVw8++KB+85vfqFGjRhXrjx49Wvfff7/+9re/qUGDBoF/M3UUuTtq8eLFFZ/erilLo0ePVmZmpn744Qd17NgxoP3VZeTuiCFDhmjbtm1q2rRpxWPjx49Xr169dN999/lNcEvkLhjI3hGNGzfW0qVL/R4bP3680tPT9dRTT+nxxx9Xy5YtK75G9syQu8qeffZZZWdn69e//rWefPLJKtfhNZ4ZcufvlFNOqVU9uTNH9o664YYblJCQoGXLlqlJkybHXZfsmSF3R3Ts2LHSa7XCwkLddNNNOuecc/xe30nkLqr4flpQsyg5TjF5iZJrrrlGZ599tiQpMzNTLpdLgwcPrvhagwYNtGnTJp1//vlKTU3VmDFjJB0ZmG+77TZlZGTI7XarU6dOevTRR+Xz+T+bLpdLEydO1Ouvv66uXbsqOTlZAwcO1Jo1ayQd+cT0SSedpKSkJA0ePFhbtmypsefNmzdr9erVGjp0aLXrFBcXV/mpnOP58MMPtX//ft10001+j0+YMEEFBQX6z3/+4/f4sGHDVFBQoIULFzraD8jdz7Vr104ul6tW65bv/+2333a8n7qO3B3VrVs3v8ltSXK73Tr//PO1fft25eXl+X2N3JkhezVr3769JOnQoUN+j5O9wJG7yg4cOKDf/e53+uMf/3jciQhe4wWO3FWtsLBQRUVFx12H3Jkhe0d99913ev/993XHHXeoSZMmKioqqnQZsGORvcCRu+P797//rby8vIrv+1jkDrAnJie4b7jhBt1zzz2SpJtvvlkvvfSS7r333oqvl5aWavjw4WrevLkeffRRXXrppfL5fLrooov0xBNP6H/+53/0+OOPq1OnTrrjjjs0efLkSvv45JNPdNttt2ns2LF64IEH9O233+rCCy/UjBkz9Je//EU33XST7rjjDn3++ee69tpra+x5yZIlkqQ+ffpU+fX//ve/ql+/vho0aKD27dtX++mcn/vqq68kSf369fN7vG/fvoqLi6v4ernyE8xnn31Wq+3jKHIXuPT0dJ144onkLgDkrma7du1S/fr1Vb9+fb/HyZ0ZsldZcXGx9u3bp+zsbM2bN0+PPvqo2rVrp5NOOslvPbIXOHJX2e9//3u1bNlSN9xww3HX4zVe4MhdZbNnz1ZKSoqSk5PVtWtXv0sxHYvcmSF7R5XfU6VFixY699xzlZycrOTkZI0YMaLKCVCyFzhyd3yvvPKKkpOTdckll1T6GrkD7InJS5QMHDhQHo9HU6dO1ZlnnqnLLrvM7+sej0eZmZnKysqqeOztt9/Wf//7Xz300EMVg/eECROUmZmpJ598UhMnTtSJJ55Ysf769ev13XffVXw6q1GjRrrhhhv00EMP6fvvv1dqaqokqaysTFlZWdqyZUvFulX57rvvJEkdOnSo9LUePXrojDPOUKdOnbR//37Nnj1bkyZN0o4dO/Twww8f91js3LlT8fHxat68ud/jiYmJatKkiXbs2OH3eEJCgjIyMrRu3brjbheVkTszHTt2JHcBIHfHt3HjRr355pvKzMxUfHx8pa+Tu8CRvcrefPNNv+s+9uvXTy+88IISEiq/3CJ7gSF3/lavXq1nnnlG7733XpVj3LF4jRc4cufv9NNP1+jRo9WhQwft2LFDM2bM0JgxY5STk6Mbb7zRb11yZ4bsHbVhwwZJ0m9+8xuddtppevXVV7Vt2zb94Q9/0NChQ7V69Wq/DzOQvcCRu+odOHBA8+fP16hRoyp6PBa5A+yJyU9w18bPX3yVvzG4+eab/R6/7bbb5PP59P777/s9fu655/oNsAMGDJAkXXrppX4DXfnjP/zww3H72b9/vxISEqq8TtM777yjO++8UxdffLGuvfZaLV68WMOHD9fjjz+u7du3H3e7hYWFSkxMrPJrSUlJKiwsrPR4o0aNtG/fvuNuF4GpK7kLBLkLnbqau8OHDyszM1PJycmaNm1aleuQu9Cqa9kbMmSIFi5cqNdff13jx49XvXr1qv1TWLIXOnUpdzfffLNGjBih8847r8Z1JXIXSnUpd5999pluueUWXXTRRRo/frxWrFih7t2765577uG9hQV1JXv5+fmSjtys+T//+Y9Gjx6t22+/Xc8995w2bdpU5V8RkL3QqSu5+7k33nhDxcXFVV6epBy5A+yokxPcCQkJatOmjd9jW7duVevWrSv9Fq5Lly4VXz9W27Zt/f6dnp4uScrIyKjy8YMHD5o3/hOXy6Vbb71VpaWl+uijj467bnJysoqLi6v8WlFRkZKTkys97vP5an3tZNReXcpdIMhdaNTV3JWVlelXv/qV1q1bpzfeeEOtW7eucj1yFzp1MXstWrTQ0KFDddlll2nmzJm68MILNWzYMO3atavSumQvNOpS7l599VUtWbJEjz32WK23T+5Coy7lriqJiYmaOHGiDh06pBUrVlT6OrkLnbqUvfL3raNHj1Zc3NFpjMzMTCUkJFRcouJYZC806lLufu6VV15R48aNNWLEiGrXIXeAHXVygtvtdvudFANR3Z+BVvf4z2+s8HNNmjRRaWlppZugVad84D9w4MBx12vVqpXKysoq7oJcrri4WPv3769y0ufgwYOVbtQGc3Upd4Egd6FRV3N3/fXX691339Xs2bN1zjnnVLseuQudupq9Y1122WXKz8+v8maSZC806lLu7rjjDmVmZioxMVFbtmzRli1bKm5omp2dXekydBK5C5W6lLtA6sld6NSl7JW/b23RokWlPps0aVLlBCjZC426lLtjbdu2TZ988okyMzNVr169atcjd1HCx+JoiQJ1coK7Ku3atdOOHTsqDYjl13Jq165dSPffuXNnSUfu/lsb5X+i06xZs+Ou16tXL0nS8uXL/R5fvny5vF5vxdfLlZaWKjs7u+I3rQitWM1dIDZv3kzuwiTWc3fHHXdo1qxZeuKJJ/yuh1wVchdesZ69nyv/U/2cnJxKXyN74ROrucvOztacOXPUoUOHiqX8pll9+vTR+eef77c+r/HCK1Zz57Se3IVfrGavb9++kqQff/zR7/HyGzyTPbtiNXfH+uc//ymfz3fcy5OQO8AeJrh/cv7556usrExPPfWU3+NPPPGEXC7Xcf8EJRgGDhwoqfJE9IEDB1RWVub3WElJiaZNm6bExEQNGTLkuNs955xz1LhxY82cOdPv8ZkzZ6p+/fq64IIL/B5ft26dioqKdPrppwf6rcCBWM2dUzk5Odq0aRO5C5NYzt0jjzyiRx99VPfcc49uueWW465L7sIvVrO3b9++Kj9Z9Pe//13SkZtNHovshVes5m7evHmVlssvv1yS9OKLL+qJJ57wW5/XeOEVq7nbu3dvpcfy8vI0ffp0NW3atGISshy5C79Yzd7gwYPVvHlzvfLKKyoqKqp4fPbs2SorK9OwYcP81id74RWruTvWnDlz1LZtW51xxhnVrkPuAHsSbDcQKUaOHKkhQ4bo3nvv1ZYtW9SzZ0/93//9n95++21NmjTJ746/odCxY0d1795dixYt0rXXXlvx+DvvvKOHHnpIl112mTp06KADBw5ozpw5Wrt2raZOnaqWLVtWrLtlyxZ16NBBY8eO1ezZsyUduVbZgw8+WHEH4+HDh+uTTz7Ryy+/rD/96U9q3LixXx8LFy5U/fr1K71AQGjEau4k6d///re+/vprSUdeRKxevVoPPfSQJOmiiy5Sjx49KtZdtGiRfD6fLr744pB+vzgiVnM3b9483XnnnTr55JPVpUsXvfzyy377HTZsmN+ftZK78IvV7L388st6+umnNWrUKHXs2FF5eXlasGCBFi5cqJEjR1a6TA7ZC69Yzd2oUaMq7WvVqlWSpBEjRlT682he44VXrOZuxowZeuuttzRy5Ei1bdtWO3fu1AsvvKBt27bppZdeqnRze3IXfrGaPbfbrUceeURjx47VWWedpauuukrbtm3Tk08+qTPPPFOXXHKJXx9kL7xiNXfl1q5dq9WrV+vuu+8+7vW1yR1gDxPcP4mLi9M777yj++67T6+++qpmzZql9u3b65FHHtFtt90Wlh6uvfZa3XfffSosLKy4icapp56qrl276uWXX9bevXuVmJioXr166bXXXlNmZqZfffmdpVu1auX3+E033aR69erpscce0zvvvKOMjAw98cQTVX668fXXX9cll1xS6eYQCI1Yzt2//vUv/eMf/6j491dffaWvvvpKktSmTRu/Ce7XX39dZ5xxRshf+OCIWM1d+S9UNmzYoKuuuqrSPj/88EO/CW5yF36xmr0zzjhDS5Ys0T//+U/t3r1bCQkJ6tSpkx5//HH99re/rdQD2QuvWM2dU7zGC69Yzd2gQYO0ZMkS/f3vf9f+/fuVkpKi/v3764UXXqjynhfkLvxiNXuSdPXVVysxMVHTpk3THXfcoYYNG+qGG27Q1KlTK127meyFVyznTjpyc0lJ+t///d/j9kDuAHtcvpqu1o+wycnJUceOHfXnP/9Z1113neP6v/3tb7rzzju1adOmSjffqI1Vq1apT58+WrlyZaVrcyN22c7drl271KFDB82dO5dPM9Yh5A62kD3YYDt3vMarm8gdbCF7sIHcoTZyc3OVnp6uLjdNVbw7yXY7UaHMU6Rv/3aPcnJylJaWZrudanEN7giSnp6uO++8U4888oi8Xq/j+g8//FA333xzQIOxJE2bNk2XXXYZg3EdYzt306dP16mnnspETx1D7mAL2YMNtnPHa7y6idzBFrIHG8gdnHCxOFqiAZ/gBgAAAAAAABDTyj/B3ZVPcNdamadI6/gENwAAAAAAAAAAocEENwAAAAAAAAAgKjHBDQAAAAAAAACISkxwAwAAAAAAAACiUoLtBgAAAAAAAAAgLHw/LahZlBwnPsENAAAAAAAAAIhKETXBPWPGDLVv315JSUkaMGCAvvzyy1rXfvzxxxo5cqRat24tl8ult956y9G+s7KydNpppyk1NVXNmzfXqFGjtH79ekfbmDlzpnr06KG0tDSlpaVp4MCBev/99x1t41jTpk2Ty+XSpEmTal3zwAMPyOVy+S2dO3d2tN8ff/xRV155pZo0aaLk5GSdeuqpWr58ea3r27dvX6kHl8ulCRMmOOojnKI5e7GSO8kse+TuLUf7Zsw7qq6NeeTOH7kLn2jOXqzkTuJcW5dzJznPXiTkToq+7EVz7qTYGfPIXe1zJ9nPHrk7ItpyB0SKiJngfvXVVzV58mTdf//9WrlypXr27Knhw4drz549taovKChQz549NWPGjID2v3jxYk2YMEFLly7VwoULVVJSovPOO08FBQW13kabNm00bdo0rVixQsuXL9c555yjiy++WN98843jfpYtW6ZnnnlGPXr0cFzbrVs37dy5s2L59NNPa1178OBBDRo0SPXq1dP777+vdevW6bHHHlOjRo0c9X7s/hcuXChJyszMdPy9hEO0Zy8WcieZZ4/cOcOYd0RdG/PInT9yFz7Rnr1YyJ3EubYu504KPHu2c1fee7RkL9pzJ8XGmEfunOVOsp89cne092jJHRBJXD6fLyKupjJgwACddtppeuqppyRJXq9XGRkZ+u1vf6u7777b0bZcLpfmzZunUaNGBdzP3r171bx5cy1evFhnnXVWwNtp3LixHnnkEV133XW1rsnPz1efPn30t7/9TQ899JB69eql6dOn16r2gQce0FtvvaVVq1YF1O/dd9+tzz77TJ988klA9VWZNGmS3n33XW3YsEEulyto2w2WWMxetOVOCn72yJ0zjHl1Y8wjd0eRu/CKxexFW+4kzrV1NXdS4NmLxNxJkZ29WMydFH1jHrkLPHdS5GSP3EV27qJRbm6u0tPT1fXGqYp3J9luJyqUeYq0buY9ysnJUVpamu12qhURn+AuLi7WihUrNHTo0IrH4uLiNHToUH3++edWesrJyZF0ZEANRFlZmebOnauCggINHDjQUe2ECRN0wQUX+B0PJzZs2KDWrVurY8eOGjNmjLZt21br2nfeeUf9+vVTZmammjdvrt69e+u5554LqA/pyHP78ssv69prr43IwTjWshetuZOCmz1y5xxjXuyPeeTOH7kLn1jLXrTmTuJcW1dzJ5llL5JyJ0V29mItd1L0jnnkzm7upLp5rq1LuQMiTURMcO/bt09lZWVq0aKF3+MtWrTQrl27wt6P1+vVpEmTNGjQIHXv3t1R7Zo1a9SgQQO53W6NHz9e8+bNU9euXWtdP3fuXK1cuVJZWVlO25Z05De3s2fP1vz58zVz5kxt3rxZZ555pvLy8mpV/8MPP2jmzJk6+eSTtWDBAt144426+eab9Y9//COgft566y0dOnRI11xzTUD1oRYr2Yv23EnBzR65c4Yxr26MeeTuKHIXXrGSvWjPncS5Vqp7uZPMshdpuZMiO3uxkjsp+sc8cmcvd1LdPdfWpdxFO5ePxckSDRJsNxCJJkyYoLVr1zq+vpwkderUSatWrVJOTo7eeOMNjR07VosXL67VoJydna1bbrlFCxcuVFJSYH8qMWLEiIr/79GjhwYMGKB27drptddeq9Wf9Xi9XvXr109Tp06VJPXu3Vtr167V008/rbFjxzru5/nnn9eIESPUunVrx7V1UaDZi/bcScHNHrlzhjGPMc8GckfubOFcy7nWBhu5k8yzF2m5k8ieE5xryZ0tdfVcS+4AeyLiE9xNmzZVfHy8du/e7ff47t271bJly7D2MnHiRL377rv68MMP1aZNG8f1iYmJOumkk9S3b19lZWWpZ8+eevLJJ2tVu2LFCu3Zs0d9+vRRQkKCEhIStHjxYv3lL39RQkKCysrKHPfTsGFDnXLKKdq4cWOt1m/VqlWlk0eXLl0c/ymiJG3dulWLFi3Sr3/9a8e14RIr2Yv23EnByx65c4Yxr+6MeeTuCHIXfrGSvWjPncS5VqpbuZOCnz2buZMiP3uxkjsp+sc8cmcnd1LdPtfWpdwBkSYiJrgTExPVt29fffDBBxWPeb1effDBBwFdYy4QPp9PEydO1Lx58/Tf//5XHTp0CMp2vV6vPB5PrdY999xztWbNGq1atapi6devn8aMGaNVq1YpPj7e8f7z8/O1adMmtWrVqlbrDxo0SOvXr/d77Pvvv1e7du0c73vWrFlq3ry5LrjgAse14RKr2Yu23EnByx65qx3GvCPq0phH7o4gd+EXq9mLttxJnGvrWu6k4GfPZu6kyM9erOZOir4xj9yFN3eS/TGP3AF1W8RcomTy5MkaO3as+vXrp/79+2v69OkqKCjQuHHjalWfn5/v91u1zZs3a9WqVWrcuLHatm1bY/2ECRM0Z84cvf3220pNTa24VlV6erqSk5Nr1cOUKVM0YsQItW3bVnl5eZozZ44++ugjLViwoFb1qampla5PlZKSoiZNmtT6ulW33367Ro4cqXbt2mnHjh26//77FR8fryuuuKJW9bfeeqtOP/10TZ06VaNHj9aXX36pZ599Vs8++2yt6st5vV7NmjVLY8eOVUJCxMSsStGevVjInRSc7JE7xjzGvOMjd+TOlmjPXizkTuJcW9dyJ5lnL1JyJ0VP9qI9d1JsjHnkzlnuJPvZI3dHRUvugEgSMT8pl19+ufbu3av77rtPu3btUq9evTR//vxKN0qozvLlyzVkyJCKf0+ePFmSNHbsWM2ePbvG+pkzZ0qSBg8e7Pf4rFmzan1B/z179ujqq6/Wzp07lZ6erh49emjBggUaNmxYreqDYfv27briiiu0f/9+NWvWTGeccYaWLl2qZs2a1ar+tNNO07x58zRlyhT98Y9/VIcOHTR9+nSNGTPGUR+LFi3Stm3bdO211wbybYRVtGcvFnInBSd75I4xjzHv+MhdcJA756I9e7GQO4lzLblzLlJyJ0VP9qI9d1JsZI/cOcudZD975O6oaMkdEElcPp8vSu6HCQAAAAAAAADO5ebmKj09Xd1umKp4d2A3I61ryjxF+uaZe5STk6O0tDTb7VQrIq7BDQAAAAAAAACAU0xwAwAAAAAAAACiEhPcAAAAAAAAAICoxAQ3AAAAAAAAACAqMcENAAAAAAAAAIhKCbYbAAAAAAAAAICw8dluAMEUcZ/g9ng8euCBB+TxeKzU00Nk9RAusXK86CF42wiHSPhe6SFyeginWDhe9BC8HsIlVo6X7R5i4XsIp1g5XvQQvG2ESywcL3oIXg/hEgnfKz1ETg9AXeLy+XwR9TuL3NxcpaenKycnR2lpaWGvp4fI6iFcYuV40UPwthEOkfC90kPk9BBOsXC86CF4PYRLrBwv2z3EwvcQTrFyvOgheNsIl1g4XvQQvB7CJRK+V3qInB5QWflx7XbDVMUnJtluJyqUFRfpm2fuifgsRtwnuAEAAAAAAAAAqA0muAEAAAAAAAAAUSnsN5n0er3asWOHUlNT5XK5Kn09NzfX779OmdbTQ3h78Pl8ysvLU+vWrRUXF7rft4Q6d8HYBj2ErwdyRw82eoiU3NWm15rUlecsFnoIV+4kxrxoqQ9XD5Ey5kXL8aKH4GwjUnJXm15rUlees1joIZbOtdFwvOnhqHBmD4h0Yb8G9/bt25WRkRHOXSIKZGdnq02bNiHbPrlDVcgdbCB3sCHUuZPIHqrGmAcbyB1s4FwLW8KRvViRm3vkGtzdf8M1uGurrLhIa5+N/Gtwh/0T3KmpqZKkLrN+q/j67oC2kbuloXEfcZ6qf9NeW66MAuMeGqUWGtXv3drYuIeBvdYb1fdP22xUX5Rfqt8N+aIiF6FSvv0Oz0xWXHJguSvb0sC4D5fhr5NSOh807sHnM8t+zoEU4x4S9tczqk/tdMCovuywR+uueSpsuTv1xQkBj3cFS5sa93HWhauM6vPKEo172JprNl7t/aqFcQ+l9Q1/ABub3cHcW+jR9lv+HLbcnfDgvYpLCuxFW0KTIuM+Tm6116g+Kb7EuIeV6zoY1U88/QPjHp5acq7ZBup5jcq9hUXacfu0kOdOOpq9tlN+H3D2XGbfriTphL47jOp3fXaCcQ9FJxjmN8788yd9TtlqVL/+vZON6ss8Rdo4849hG/Pa3f17xbkDy11pq2LjPnxF8Ub1SU0OG/fg2WH4WjUIuXOlmx3Lzhm7jepLC4r138tmhy13GU/dEfB7C/fa+sZ9FDc2e86adttj3MNpTbcZ1b+7tI9xDzJ8f2P6Hs1bVKTtDzwU1nOtyftaT475pF5cvtmYF9/CbC5Ekk5oesiofmSr1cY9PPXheWYbMMyut6hIP94fnuwBkS7sE9zlf0YTX98d8IRPoG+a/LZRzZ+S1ZarfplxD/EpZu/i4pLNj0O9FLOJq+QGwYlQdX/aFyzl249Ldiu+fmDHzReE3Jm+eAr0Z+ZYphPccYVB+PlLMpvgDsZxkMKXO5PxLj7AN+vHSmxgdrzrlZpPcCeUmT1nQRn3kwx/AOsHJy9hG++SkgI+T8SZv+c2Pr/Uizc/TqbnyaQgnOOMz9WGE9zlQp27Y/cRl5RkdYI7IcVsvAnGuBuXbPbGPxgTjaY/g8E4DlIYxzx34LmLSzb/s26fy3Cyp755+I3Hm2BMcNc3O5amua3oI4zvLeICfG8RlLHG8LWN6XgpSW7D15nBeE9rPMEdnFNteM+1Bu9r44qDkL1SszEvzvSDJzLPbzDmMozza5jdcuHIHhDpuEgPAAAAAAAAACAqMcENAAAAAAAAAIhKAU1wz5gxQ+3bt1dSUpIGDBigL7/8Mth9AZWQO9hC9mADuYMN5A42kDvYQvZgA7kDgOBzPMH96quvavLkybr//vu1cuVK9ezZU8OHD9eePeY3qACqQ+5gC9mDDeQONpA72EDuYAvZgw3kDogQPhZHSxRwPMH9+OOP6/rrr9e4cePUtWtXPf3006pfv75eeOGFUPQHSCJ3sIfswQZyBxvIHWwgd7CF7MEGcgcAoeFogru4uFgrVqzQ0KFDj24gLk5Dhw7V559/XmWNx+NRbm6u3wI4Qe5gi9PskTsEA7mDDZxrYQO5gy2ca2EDYx4AhI6jCe59+/aprKxMLVq08Hu8RYsW2rVrV5U1WVlZSk9Pr1gyMjIC7xZ1ErmDLU6zR+4QDOQONnCuhQ3kDrZwroUNjHkAEDoB3WTSiSlTpignJ6diyc7ODvUuAXIHK8gdbCB3sIXswQZyBxvIHWwhewBQOwlOVm7atKni4+O1e/duv8d3796tli1bVlnjdrvldrsD7xB1HrmDLU6zR+4QDOQONnCuhQ3kDrZwroUNjHkAEDqOPsGdmJiovn376oMPPqh4zOv16oMPPtDAgQOD3hwgkTvYQ/ZgA7mDDeQONpA72EL2YAO5AyKHy8fiZIkGjj7BLUmTJ0/W2LFj1a9fP/Xv31/Tp09XQUGBxo0bF4r+AEnkDvaQPdhA7mADuYMN5A62kD3YQO4AIDQcT3Bffvnl2rt3r+677z7t2rVLvXr10vz58yvdKAEIJnIHW8gebCB3sIHcwQZyB1vIHmwgdwAQGo4nuCVp4sSJmjhxYrB7AY6L3MEWsgcbyB1sIHewgdzBFrIHG8gdAARfQBPcwTDkhA1yN6gXUO2PTRsa73/Jxo5G9X/t95pxD0XeRKP6spNcxj28saefUf3J7l1G9QXFZUb1Tp3fcV3AuXtj+y+M95/YpsCo/vRWW4x7GNf0E6P6yz//jXEPZS29RvUlZfFm+zesd+pQTn3FlSQFVFvWyvxnpLAssMyXe+iE94x7uMd3oVG9+xelxj1s3dvIqP66bp8b1Rfll+iPRltwpv4J+YqvXxJQbeEPacb7f+fs+Ub1Z635pXEPI/quNqov8pm/THry3JeN6m/5+H+Newi3hMMuxZcF9hrlnItWGO9/R6FZfnf1yjHuIcnr6DY3lbRsmGvcw7UtPzWqv21A1Tc8qy3vYY9RvVONe+xVfEpgN2LLPRzYOfpY7sZm56lSw8xIUmo7s+wWbEo37uG+0/5tVP91QVujeo8CO+8Fql5iqeITA3vuC9qZv7ZxNTDbxl0nmp2rJWlvqdmYu7rbDuMeNm42+/TzGd2+N6ovKSjWNqMtOGfyvnbeAvPrfQ899yuj+k+2m83HSFIj92Gj+p3FDY17SGpt9v6+8GCyUb3PFd75FCCSmb+SAgAAAAAAAABA0owZM9S+fXslJSVpwIAB+vLLL6td980331S/fv3UsGFDpaSkqFevXnrppZcc7Y8JbgAAAAAAAAB1g4/F0eLQq6++qsmTJ+v+++/XypUr1bNnTw0fPlx79uypcv3GjRvr3nvv1eeff67Vq1dr3LhxGjdunBYsWFDrfTLBDQAAAAAAAAAw9vjjj+v666/XuHHj1LVrVz399NOqX7++XnjhhSrXHzx4sH75y1+qS5cuOvHEE3XLLbeoR48e+vTT2l9yjwluAAAAAAAAAECVcnNz/RaPp+r7rRQXF2vFihUaOnRoxWNxcXEaOnSoPv+85vta+Xw+ffDBB1q/fr3OOuusWvfneIL7448/1siRI9W6dWu5XC699dZbTjcBOEbuYAO5gw3kDraQPdhA7mADuYMtZA9AtMrIyFB6enrFkpWVVeV6+/btU1lZmVq08L8BcIsWLbRr165qt5+Tk6MGDRooMTFRF1xwgf76179q2LBhte7P8QR3QUGBevbsqRkzZjgtBQJG7mADuYMN5A62kD3YQO5gA7mDLWQPQLTKzs5WTk5OxTJlypSgbj81NVWrVq3SsmXL9Kc//UmTJ0/WRx99VOv6BKc7HDFihEaMGOG0DDBC7mADuYMN5A62kD3YQO5gA7mDLWQPQLRKS0tTWlpajes1bdpU8fHx2r17t9/ju3fvVsuWLauti4uL00knnSRJ6tWrl7799ltlZWVp8ODBterP8QS3Ux6Px++6LLm5uaHeJUDuYAW5gw3kDraQPdhA7mADuYMtZA8IDZfvyIKaOT1OiYmJ6tu3rz744AONGjVKkuT1evXBBx9o4sSJtd6O1+ut9jrfVQn5TSazsrL8rtGSkZER6l0C5A5WkDvYQO5gC9mDDeQONpA72EL2AESjyZMn67nnntM//vEPffvtt7rxxhtVUFCgcePGSZKuvvpqv0ucZGVlaeHChfrhhx/07bff6rHHHtNLL72kK6+8stb7DPkE95QpU/yu0ZKdnR3qXQLkDlaQO9hA7mAL2YMN5A42kDvYQvYARKPLL79cjz76qO677z716tVLq1at0vz58ytuPLlt2zbt3LmzYv2CggLddNNN6tatmwYNGqR//etfevnll/XrX/+61vsM+SVK3G633G53qHcD+CF3sIHcwQZyB1vIHmwgd7CB3MEWsgcgWk2cOLHaS5L8/OaRDz30kB566CGj/YX8E9wAAAAAAAAAAISC409w5+fna+PGjRX/3rx5s1atWqXGjRurbdu2QW0OKEfuYAO5gw3kDraQPdhA7mADuYMtZA8AQsPxBPfy5cs1ZMiQin9PnjxZkjR27FjNnj07aI0BxyJ3sIHcwQZyB1vIHmwgd7CB3MEWsgdECN9PC2oWJcfJ8QT34MGD5fNFyXeHmEHuYAO5gw3kDraQPdhA7mADuYMtZA8AQoNrcAMAAAAAAAAAopLjT3AHy7e5LVWvLDGg2vxi87sI+0rN5vYnrxht3EN8vNeovqTY/OnrdsJOo/p4w79VMK136qMdJym+fmD5SW6XZ7z/UsPcXdlkiXEP7+T2Nqqf0nu+cQ9Tl48wqn+x52yj+vw8r8422oIz0/r+S/VT4wOqfeC7i4z3f2rqdqP6Ip/LuIeX239kVP/w/pONe0hvddiovn6cx6i+sF6pUb1TDZMLlVA/sPNMSpdi4/1/VmR2jvufVuuMe7gw7Wuj+iRXmXEPZYY/PyN6rDWqL84v1iyjLTiX3Hd/wOfaLQWNjff/7invG9UPL7nQuId0d6FRfWqC2XgjSUmuEqP6wznJRvXeQvNzhxNnttgkd4N6AdVObbHaeP9/PdjOqP78Bt+Y97BvsFH9e0VdjXs4UNbAqP60BpuN6g/LfNx24qFT3w74NV4w3k+OOsUsu0W+wH5mjjW4/saaVzqOefFm700kqVmrHKP6bXlm557SAvMx26km9fKVVC+w+YCyE4qM959fGthcTrmR7c1e30jSXc2+MKrfV2Y+XsSfbPZ6d/PhJkb1JQXFes1oC0Ds4BPcAAAAAAAAAICoxAQ3AAAAAAAAACAqWbtECQAAAAAAAACEle+nBTWLkuPEJ7gBAAAAAAAAAFHJ0QR3VlaWTjvtNKWmpqp58+YaNWqU1q9fH6reAEnkDvaQPdhA7mADuYMtZA82kDvYQO4AIHQcTXAvXrxYEyZM0NKlS7Vw4UKVlJTovPPOU0FBQaj6A8gdrCF7sIHcwQZyB1vIHmwgd7CB3AFA6Di6Bvf8+fP9/j179mw1b95cK1as0FlnnRXUxoBy5A62kD3YQO5gA7mDLWQPNpA72EDuACB0jG4ymZOTI0lq3Lhxtet4PB55PJ6Kf+fm5prsEiB3sKam7JE7hAK5gw2ca2ELYx5sIHewgXMtAARPwDeZ9Hq9mjRpkgYNGqTu3btXu15WVpbS09MrloyMjEB3CZA7WFOb7JE7BBu5gw2ca2ELYx5sIHewgXMtYJfLx+JkiQYBT3BPmDBBa9eu1dy5c4+73pQpU5STk1OxZGdnB7pLgNzBmtpkj9wh2MgdbOBcC1sY82ADuYMNnGsBILgCukTJxIkT9e677+rjjz9WmzZtjruu2+2W2+0OqDngWOQOttQ2e+QOwUTuYAPnWtjCmAcbyB1s4FwLAMHnaILb5/Ppt7/9rebNm6ePPvpIHTp0CFVfQAVyB1vIHmwgd7CB3MEWsgcbyB1sIHcAEDqOJrgnTJigOXPm6O2331Zqaqp27dolSUpPT1dycnJIGgTIHWwhe7CB3MEGcgdbyB5sIHewgdwBQOg4ugb3zJkzlZOTo8GDB6tVq1YVy6uvvhqq/gByB2vIHmwgd7CB3MEWsgcbyB1sIHcAEDqOL1EChBu5gy1kDzaQO9hA7mAL2YMN5A42kDsggvh+WlCzKDlOAd1kMhg2fdlWcUlJAdWeOWSN8f63FjU3qn91yHPGPdy6cbRR/QkpOcY9fLm1nVH94JO9RvW5peH9SUlPKlJCcmD7/GFvmvH+e55odtfrbaWNjXv4Q7NvjOrPWH2JcQ8nn7DHqP7ZfWcb1RfnF0t6zWgbTszeeYbq5SYGVHvgUIrx/p96b4RR/aLTuhj3cLDI7M8ud+1LN+4hfltg55xyiZ1zjerLDnskLTfahhOZbVYouUFgp/kZ681+xiTpw/yuRvWzFw427uG5hmca1XdsZzZWSdLhknpG9ftWm71e8RYVKZzjnSQVFCYq3hXYDbGmdJtrvP/X8hsZ1TdKOmzcwzdvdTaqz+/qMe7hYLHZuNuoaZ5Rfdlhj7YbbcGZc1LXKSU1PqDaG7YPNN7/g60WGdW/mdfJuIfPdnY0qk/8qoFxD+83625Un+MxO1eXFXgkrTTahhOf5Z8itwIb52/rYZYZSZq/t5tR/cMtVhn38PD+3kb12w41NO6h7Euzcd/T/6DZ/gsd/WF8UNzSaLPSUgPb73stzX5OJWlKq/lm9Vt/adzD1+lm57kNnpbGPSzefbJR/e4lrY3qy4qKjOqBWBL+kRgAAAAAAAAAgCBgghsAAAAAAAAAEJWY4AYAAAAAAAAARCUmuAEAAAAAAAAAUcnRBPfMmTPVo0cPpaWlKS0tTQMHDtT7778fqt4ASeQO9pA92EDuYAO5gy1kDzaQO9hA7oDI4fL5WBws0cDRBHebNm00bdo0rVixQsuXL9c555yjiy++WN98802o+gPIHawhe7CB3MEGcgdbyB5sIHewgdwBQOgkOFl55MiRfv/+05/+pJkzZ2rp0qXq1q1bUBsDypE72EL2YAO5gw3kDraQPdhA7mADuQOA0HE0wX2ssrIyvf766yooKNDAgQOrXc/j8cjj8VT8Ozc3N9BdAuQO1tQme+QOwUbuYAPnWtjCmAcbyB1s4FwLAMHl+CaTa9asUYMGDeR2uzV+/HjNmzdPXbt2rXb9rKwspaenVywZGRlGDaNuInewxUn2yB2ChdzBBs61sIUxDzaQO9jAuRYAQsPxBHenTp20atUqffHFF7rxxhs1duxYrVu3rtr1p0yZopycnIolOzvbqGHUTeQOtjjJHrlDsJA72MC5FrYw5sEGcgcbONcCQGg4vkRJYmKiTjrpJElS3759tWzZMj355JN65plnqlzf7XbL7XabdYk6j9zBFifZI3cIFnIHGzjXwhbGPNhA7mAD51ogQvh+WlCzKDlOjj/B/XNer9fvmlBAOJA72EL2YAO5gw3kDraQPdhA7mADuQOA4HD0Ce4pU6ZoxIgRatu2rfLy8jRnzhx99NFHWrBgQaj6A8gdrCF7sIHcwQZyB1vIHmwgd7CB3AFA6Dia4N6zZ4+uvvpq7dy5U+np6erRo4cWLFigYcOGhao/gNzBGrIHG8gdbCB3sIXswQZyBxvIHQCEjqMJ7ueffz5UfQDVInewhezBBnIHG8gdbCF7sIHcwQZyBwChY3wNbgAAAAAAAAAAbHD0Ce5gSjzkUrzbFVDt0nd6GO/f9EbEV351rXEPpaVmv1/Y938nGPegPgVG5T2/vMKovuywR9KfjbbhxP73T1C8Oymg2tR48/1v2HCiUf3zQ+sZ9/BUqdk2DuTXN+5h3zctjeoP/yLRqL60ILw3csnOaaj4ksAGncQNycb7r5dnVv/Dog7GPfQa8a1R/a596cY9lLQqNqpvXr/QqL7UF97cPb9xkOLrB5a7JimHjff/ypvnGNUnFRm3oGKP2XjXpcdu4x4Ky8x6+KqL2Uu1I+fZ8CrOcyuuNLDsTdlwqfH+BzbfbFT/1YedjHswHC6Ust7whaqkBp3NnvuD+1KN6r2F5q9ZnLjjm8sCHvOuPGmZ8f6v+v5yo/ouDXcZ95CzuolRvdtn3IK2fdzWqL7b0O+N6kviirXSaAvOnJB4SEmJgY3T074YYbz/1i0PGtVftOF/jHtIq2d2wi5a19C4h3jDWY3SLxsZ1Zd5gvCixaHnc1opuSywb3zHAfPX1ePWXW1Uv+9QA+MeJh40m4s4J2ODcQ87lrcyqk8+ZLb/Mu5PGjCX78iCmkXLceIT3AAAAAAAAACAqMQENwAAAAAAAAAgKjHBDQAAAAAAAACISkxwAwAAAAAAAACiktEE97Rp0+RyuTRp0qQgtQPUjNzBBnIHW8gebCB3sIHcwRayBxvIHQAET8D3G162bJmeeeYZ9ejRI5j9AMdF7mADuYMtZA82kDvYQO5gC9mDDeQOsMz304KaRclxCugT3Pn5+RozZoyee+45NWrUKNg9AVUid7CB3MEWsgcbyB1sIHewhezBBnIHAMEX0AT3hAkTdMEFF2jo0KE1ruvxeJSbm+u3AIEgd7CB3MGW2maP3CGYGPNgA7mDLZxrYQNjHgAEn+NLlMydO1crV67UsmXLarV+VlaW/vCHPzhuDDgWuYMN5A62OMkeuUOwMObBBnIHWzjXwgbGPAAIDUef4M7OztYtt9yiV155RUlJSbWqmTJlinJyciqW7OzsgBpF3UXuYAO5gy1Os0fuEAyMebCB3MEWzrWwgTEPAELH0Se4V6xYoT179qhPnz4Vj5WVlenjjz/WU089JY/Ho/j4eL8at9stt9sdnG5RJ5E72EDuYIvT7JE7BANjHmwgd7CFcy1sYMwDgNBxNMF97rnnas2aNX6PjRs3Tp07d9Zdd91VaTAGgoHcwQZyB1vIHmwgd7CB3MEWsgcbyB0QOVy+IwtqFi3HydEEd2pqqrp37+73WEpKipo0aVLpcSBYyB1sIHewhezBBnIHG8gdbCF7sIHcAUDoOLoGNwAAAAAAAAAAkcLRJ7ir8tFHHwWhDcAZcgcbyB1sIXuwgdzBBnIHW8gebCB3ABAcxhPcgWo1/QsluOoFVLtr0unG+y9sXWZU37+V+d2LNxxqZlTf7MK9xj2s2dDGqP6Pfd4xqj+cX6brjbbgTFypFBfg3y00f3KJ8f73jh9oVL9xtdnzJUkJrQ8b1ZfsSTbuIaXArD57s9nPjrewyKwBh3K3pisuuXZ3Sv+5dPMfczX/m1l29/3GLLeS9MUXnYzqfW7zC3+lZJtd13CHq5FRfbhz17v5diU2SAyo9r+ruhrvv9Fus+es2czPjXswfb3w3ue9jHtwtzIbc+OXpxrVl3nCmztJSkovUnz9wGp3HUgz3v+bq8zGrNQfjVtQs5lm4+6em8xf6375f4Z/7t6yxKy+xGVW71Cr1FwlpAR2I7anPxti3oDXrHxjkflrvNRdZse8xV/MX+vuuNMsu2s+Ptmo3lsU3jHvqU/PDfg1XoMt5m/Fc75paVS/s0ehcQ/1Ngf2/ZdLOmQ+VrR63PC17g1m542y4vBfoLZpfL7qJwT22rbEY569faVmr0+SVpu/pyw41Sw7/1l4mnEPKTsNx92/mmW31Feib422AMQOLlECAAAAAAAAAIhK1j7BDQAAAAAAAABh5ftpQc2i5DjxCW4AAAAAAAAAQFRighsAAAAAAAAAEJUcTXA/8MADcrlcfkvnzp2Nm7jK943G+NZV+bUxvnW6yveN8T4QvUKVu2Agu7EtkrNngtxGtljNXTCQ3dAhd6FFdqtH9iJbrGaX3MW+SMwuuUNNIjG3QLRwfA3ubt26adGiRUc3kGB+GW+vXLpG6ySf9Iqra8XjY3zrdI3Waba6HqcadUEochcMZDf2RWr2TJDbyBeLuQsGshta5C50yO7xkb3IFcvZJXexLVKzS+5wPJGaWyAaOB5NExIS1LJly6A28Yqrq+ST3w/ysT/Ax/5go24KRe6CgezGvkjNnglyG/liMXfBQHZDi9yFDtk9PrIXuWI5u+QutkVqdskdjidScwtEA8cT3Bs2bFDr1q2VlJSkgQMHKisrS23btq12fY/HI4/HU/Hv3NzcKtc79gf5f33fKVFefoBRIVS5CwayG9ucZC+cuTNFbiNbrOYuGMhu6ETyuTYWkN3qMeZFtljNLrmLfZGYXc61qEkk5jYWuXxHFtQsWo6To2twDxgwQLNnz9b8+fM1c+ZMbd68WWeeeaby8vKqrcnKylJ6enrFkpGRUe26r7i6qlhxSpRXxYrjBxiSQp+7YCC7sclp9sKdO1PkNjLFeu6CgewGXzSca2MB2a2MMS86xFp2yV3dEUnZ5VyL2oqk3ALRwtEE94gRI5SZmakePXpo+PDheu+993To0CG99tpr1dZMmTJFOTk5FUt2dna1647xrav4AU6Ut9qL66NuCXXugoHsxian2Qt37kyR28gU67kLBrIbfNFwro0FZLcyxrzoEGvZJXd1RyRll3MtaiuScgtEC6M7GjRs2FCnnHKKNm7cWO06brdbbre7xm39/LpC5f/++cX1gWDmLhjIbt1RU/bCmTtT5DZ6xFLugoHshkeknWtjAdmtHca8yFMXskvuYlOkZ5dzLaoS6bkFIpWjT3D/XH5+vjZt2qRWrVoZNVHVRfNfcXXVbHXVNVrHb6vgJ1i5CwayW7dEUvZMkNvoEiu5CwayGz7kLrjIbu2RvchSV7JL7mJPNGSX3OHnoiG3QKRy9Anu22+/XSNHjlS7du20Y8cO3X///YqPj9cVV1xh1EScfFVeNL/84vpxipIrmiMkQpW7YCC7sS2Ss2eC3Ea2WM1dMJDd0CF3oUV2q0f2IlusZpfcxb5IzC65Q00iMbdAtHA0wb19+3ZdccUV2r9/v5o1a6YzzjhDS5cuVbNmzYyaeMnVrdqv8ScYCFXugoHsxrZIzp4JchvZYjV3wUB2Q4fchRbZrR7Zi2yxml1yF/siMbvkDjWJxNzGLN9PC2oWJcfJ0QT33LlzQ9UHUC1yB1vIHmwgd7CB3MEWsgcbyB1sIHcAEDpG1+AGAAAAAAAAAMAWR5/gDqYfbx+geHdSQLXFDc0/H5+ekWNUf37jNcY9rE7KMKr/54r+xj2kNS0wql9R0N6o3lNQImml0TacKE6X4gO8CfWOO0433n9ZYJGvUL+9WW4lKS25yKj+YLzXuIeiglSj+vjUEqN6V7xZ/f+zd+fxUdT3H8ffm2tzEMJ9SbgUFUSQu4gHCugPFaWt8ShWPGo9QESsB7ZV21qDRQVbEY8qeKFWW8BqEYEKHohyiIp4cBPuQ8hFsjl2f3+kCaxJSGa/u/vd3byej8c8lM18Zj6ZvPOdyTebGafO7LdOSY2SAqr9ZH9P4/1vn2SW3fIU8zH36qEfGNUXlJs/Pf67Hq2N6vM8Zt/AZYUe5RhtwZlujXYruVFgp/nCUwPL69HW7D3JqD7nt+Zjblm6WXb/dP6bxj3sKzMb777INLtWKCko0fdTjTbh2NmZm5TUKDGg2s/2djDef0a/H4zqd+aaHXPJ/JrBVW7cgn528UdG9f9Y19eo3hVXZlTvVPu0QwGfa793m50fJOlnPT83ql97qJ1xDzkHzL5/cn5vPu56E83G3W5nbDKqLy0skdkWnLmw3xcBj3f/yetvvP/SpmbfZ43TzX4ukKRGA8x+Psld0sa4h20PGF7rJpnl1mt+GB07OWmPGiUF9n7Fn/cwG68k6dN9nYzqd/Yy//nCe8jsevWE/uZX5lvKzK4Z9t00yKi+vKRYem6e0TaAWME7uAEAAAAAAAAAUYkJbgAAAAAAAABAVLJ2ixIAAAAAAAAACDeX+Z1yEEF4BzcAAAAAAAAAICo5nuDesWOHrrrqKjVv3lwpKSk69dRTtXLlylD0BlQhd7CF7MEGcgcbyB1sIHewhezBBnIHAKHh6BYlBw8e1ODBg3XOOedo/vz5atmypdavX6+mTZuGqj+A3MEasgcbyB1sIHewgdzBFrIHG8gdAISOownuhx9+WJmZmZo5c2bVa507dw56U8DRyB1sIXuwgdzBBnIHG8gdbCF7sIHcAUDoOLpFyVtvvaV+/fopKytLrVq1Uu/evfXss88es8bj8SgvL89vAZwgd7DFafbIHYKB3MEGzrWwgdzBFs61sIExDwBCx9EE96ZNmzRjxgx17dpVCxYs0M0336zx48frhRdeqLUmOztbGRkZVUtmZqZx02hYyB1scZo9codgIHewgXMtbCB3sIVzLWxgzAMiiM/H4mSJAo4muL1er/r06aOHHnpIvXv31q9//WvdcMMNeuqpp2qtmTRpknJzc6uWnJwc46bRsJA72OI0e+QOwUDuYAPnWthA7mAL51rYwJgHAKHjaIK7bdu26t69u99r3bp107Zt22qtcbvdaty4sd8COEHuYIvT7JE7BAO5gw2ca2EDuYMtnGthA2MeAISOownuwYMH67vvvvN77fvvv1fHjh2D2hRwNHIHW8gebCB3sIHcwQZyB1vIHmwgdwAQOo4muG+//XYtX75cDz30kDZs2KDZs2frmWee0dixY0PVH0DuYA3Zgw3kDjaQO9hA7mAL2YMN5A4AQsfRBHf//v01Z84cvfrqq+rRo4f+9Kc/adq0aRo9enSo+gPIHawhe7CB3MEGcgcbyB1sIXuwgdwBQOgkOC246KKLdNFFF4WiF6BW5A62kD3YQO5gA7mDDeQOtpA92EDugMjg8lUsqFu0HCfHE9xB4/vfEoCypmXGuz8uI9eofm1Re+Me3tl6itkGfC7jHlKSSo3qf9Joo1H9YV+5Ub1TaT/Zr/hUd0C1B79qYbz/3md8b1SfllBi3EOLpAKj+h3pTYx7WKPjjOpHdF5nVO8pKNUMoy04szm/uRK8geWuqKP51zz9mySj+m4XrDfu4WBZqlF9VtPPjHv406GRRvVt0vKM6ktl/rV0Yv7u7kpICyx3Ow5kGO8/vfcBo/rcb5sb9/CTwd8Y1b+zv6dxD5Mz/21U//z6QUb15Yc9RvWBWLCuu+JSkgMrDsIFdLPOh43qi040P2aJOWbjbny3fOMePj3Qyai+e/tdRvWlhSXaarQFZzbmtVBCeWBjXlyi13j/C3NOMqo/sfk+4x6SB5qNu3nfNTPuocUpZp/HpoNmPYR7zGuWWKDkxMSAasvSzXN3UtedRvVtU82ubSQptyTA8f5/9vVKN+5BW8yuM0tbmM0veIvM5yfCqdQXb7yNc9qY/Vw7t8j8GqttG8PxZq/5tWajnj8Y1XsOm/VQ7jGfEwJihaNblAAAAAAAAAAAECmY4AYAAAAAAAAARCUmuAEAAAAAAAAAUYkJbgAAAAAAAABAVHI0wd2pUye5XK5qy9ixY0PVHyCJ7MEOcgcbyB1sIHewhezBBnIHG8gdEEF8LI6WKJDgZOUVK1aovLy86t9r167V8OHDlZWVFfTGgKORPdhA7mADuYMN5A62kD3YQO5gA7kDgNBxNMHdsmVLv39PnjxZxx9/vM4+++ygNgX8GNmDDeQONpA72EDuYAvZgw3kDjaQOwAIHUcT3EcrKSnRyy+/rIkTJ8rlctW6nsfjkcfjqfp3Xl5eoLsEJNUve+QOwUbuYAO5gw1c48EWxjzYQO5gA+daAAiugB8yOXfuXB06dEjXXHPNMdfLzs5WRkZG1ZKZmRnoLgFJ9cseuUOwkTvYQO5gA9d4sIUxDzaQO9jAuRYAgivgCe7nnntOI0aMULt27Y653qRJk5Sbm1u15OTkBLpLQFL9skfuEGzkDjaQO9jANR5sYcyDDeQONnCuBYDgCugWJVu3btWiRYv0r3/9q8513W633G53ILsBqqlv9sgdgoncwQZyBxu4xoMtjHmwgdzBBs61gH0ub8WCukXLcQroHdwzZ85Uq1atdOGFFwa7H+CYyB5sIHewgdzBBnIHW8gebCB3sIHcAUDwOZ7g9nq9mjlzpsaMGaOEhICfUQk4RvZgA7mDDeQONpA72EL2YAO5gw3kDgBCw/EE96JFi7Rt2zZdd911oegHqBXZgw3kDjaQO9hA7mAL2YMN5A42kDsACA3HvzI877zz5PP5QtELcExkDzaQO9hA7mADuYMtZA82kDvYQO4AIDTC/jcxlYN5uac44G14i0qN+ygtLDGq9ySY91B+2GNU7y0y//KVF5r1cDi/3Ki+qKCiPtQn+arcGRxzb3Hgma1kmruSeLN6SfIkmWW3tNi8h/LDZsfSU2D2OZQUVtSHK3dlhwM/Zt4i89yVe8yeCmGaW0kq8Zp9zQoTzJ9sUWY43pWWmR2HyuMYFbkz/B6VpHKX4TkuAsZcr89l3EN+vll2Ta8VKuvD8cN05T6Mxq0gtGn6vR6McddbbDhmBeF7sCzRcMxLNBu3yxramBdneLyTg3F9ZX/cNf3Zorw0OGNmuHLnKSwLeBvBGGtMx7sSr3nuSksDeqxXlWB8/6nYsIeiwL+OFfUVn0M4z7WFBYF/r5QY/iwlmc+HmI5XklQWbzjmBWPsl9n3kMm82NH1/NIEkFy+MH8nbN++XZmZmeHcJaJATk6O2rdvH7LtkzvUhNzBBnIHG0KdO4nsoWaMebCB3MEGzrWwJRzZixV5eXnKyMhQ/1EPKiEx2XY7UaGstFgr5v5Oubm5aty4se12ahX2d3C3a9dOOTk5Sk9Pl8tV/Z1ReXl5yszMVE5OTkAHzrSeHsLbg8/nU35+vtq1axdQj/UV6twFYxv0EL4eyB092OghUnJXn17r0lC+ZrHQQ7hyJzHmRUt9uHqIlDEvWo4XPQRnG5GSu/r0WpeG8jWLhR5i6VwbDcebHo4IZ/aASBf2Ce64uLh6/WapcePGRr8ZMK2nh/D1kJGREfC26ytcuQvGNughPD2QO3qw0UMk5U6K/ONFD8GpD0fuJMa8aKsPRw+RNOZFw/Gih+BsI5JyJ0X+8aKH4NTH2rk20o83PRwRruwBkc7sZlUAAAAAAAAAAFjCBDcAAAAAAAAAICpF3AS32+3W/fffL7fbbaWeHiKrh3CJleNFD8HbRjhEwudKD5HTQzjFwvGih+D1EC6xcrxs9xALn0M4xcrxoofgbSNcYuF40UPwegiXSPhc6SFyegAaEpfP5/PZbgIAAAAAAAAAQiUvL08ZGRkacMmDSkhMtt1OVCgrLdZn836n3Nxc43vSh1LEvYMbAAAAAAAAAID6YIIbAAAAAAAAABCVmOAGAAAAAAAAAEQlJrgBAAAAAAAAAFGJCW4AAAAAAAAAQFRKsN0AAAAAAAAAAISFz1exoG5Rcpx4BzcAAAAAAAAAICoxwQ0AAAAAAAAAiEpMcAMAAAAAAAAAohIT3AAAAAAAAACAqMQENwAAAAAAAAAgKiXYbgAAAAAAAAAAwsHlq1hQt2g5TjH9Du4VK1bo9NNPV1pamlwul9asWWO7pTr95S9/0cknnyyv1xv2fV9xxRW67LLLwr7fWEPunLnnnns0cODAsO831pA7Z8hd8JA9Z8hecJA7Z7jGCw5y5wy5Cx6y5wzZCw5y5wy5A+yK2Qnu0tJSZWVl6YcfftDUqVP10ksvqWPHjrbbOqa8vDw9/PDDuvvuuxUX5/+lyc/P11133aXOnTvL7XbruOOO06WXXqrDhw/Xa9vPPfecunXrpuTkZHXt2lV/+9vfqq1z991365///Ke++OKLoHw+DRG5O2LGjBnKyspShw4d5HK5dM0119S43oQJE/TFF1/orbfeCsan0yCRuwo5OTn6wx/+oAEDBqhp06Zq0aKFhgwZokWLFlVbl9wFB9mrUFRUpOuvv149evRQRkaGGjVqpF69eunxxx9XaWmp37pkzxy5q9lHH30kl8sll8ul/fv3+32Mazxz5O6Iypz9eJk8ebLfeuQuOMievz179ujGG2/Ucccdp+TkZHXq1EnXX3+93zpkzxy5qzBr1qxaxzyXy6VXXnmlal1yB9gVs7co2bhxo7Zu3apnn31Wv/rVr2y3Uy/PP/+8ysrKdOWVV/q9npubq7PPPlvbt2/Xr3/9a51wwgnat2+fPvzwQ3k8HqWmph5zu08//bRuuukm/fznP9fEiRP14Ycfavz48Tp8+LDuvvvuqvV69+6tfv366dFHH9WLL74Yks8x1pG7Ix5++GHl5+drwIAB2rVrV63rtWnTRpdccokeeeQRXXzxxUH5nBoacldh3rx5evjhhzVq1CiNGTNGZWVlevHFFzV8+HA9//zzuvbaa6vWJXfBQfYqFBUV6euvv9YFF1ygTp06KS4uTsuWLdPtt9+uTz/9VLNnz65al+yZI3fVeb1e3XrrrUpLS1NhYWG1j3ONZ47c+Rs+fLiuvvpqv9d69+5d7d/kzhzZOyInJ0eDBw+WJN1000067rjjtHPnTn322Wd+65E9c+SuwllnnaWXXnqp2utTp07VF198oaFDh1a9Ru4Au2J2gnvv3r2SpCZNmtS5bmFhodLS0kLcUd1mzpypiy++WMnJyX6vT5o0SVu3btXq1avVuXPnqtePnpyuTVFRkX7729/qwgsv1JtvvilJuuGGG+T1evWnP/1Jv/71r9W0adOq9S+77DLdf//9evLJJ9WoUaMgfWYNB7k7YunSpVXv3q4rS5dddpmysrK0adMmdenSxfkn0cCRuwrnnHOOtm3bphYtWlS9dtNNN+m0007Tfffd5zfBLZG7YCB7FZo1a6bly5f7vXbTTTcpIyNDTzzxhB577DG1adOm6mNkzwy5q+6ZZ55RTk6OfvWrX+nxxx+vcR2u8cyQO38nnniirrrqqjrXI3fmyN4RN954oxISErRixQo1b978mOuSPTPkrkKXLl2qXasVFRXplltu0bnnnut3fSeRO8CmmLxFyTXXXKOzzz5bkpSVlSWXy6UhQ4ZUfaxRo0bauHGjLrjgAqWnp2v06NGSKgbmO+64Q5mZmXK73TrppJP0yCOPyOfzv6O6y+XSuHHj9MYbb6h79+5KSUnRoEGD9NVXX0mqeMf0CSecoOTkZA0ZMkRbtmyps+fNmzfryy+/1LBhw/xeP3TokGbOnKlf//rX6ty5s0pKSuTxeOp9LN5//30dOHBAt9xyi9/rY8eOVWFhod555x2/14cPH67CwkItXLiw3vtABXLnr2PHjnK5XPVat3L/8+bNc7QPkLujnXLKKX6T25Lkdrt1wQUXaPv27crPz/f7GLkzQ/bq1qlTp6rtH43sBY7cVffDDz/od7/7nf74xz8ecyKCa7zAkbuaFRUVqbi4+JjrkDszZO+Ib7/9VvPnz9edd96p5s2bq7i4uNptwI5G9gJH7o7t3//+t/Lz86s+76ORO8CemJzgvvHGG3XvvfdKksaPH6+XXnpJv/3tb6s+XlZWpvPPP1+tWrXSI488op///Ofy+Xy6+OKLNXXqVP3f//2fHnvsMZ100km68847NXHixGr7+PDDD3XHHXdozJgxeuCBB/TNN9/ooosu0vTp0/XXv/5Vt9xyi+6880598sknuu666+rsedmyZZKkPn36+L3+0Ucfqbi4WCeccIIuvfRSpaamKiUlRYMHD67XQx4+//xzSVK/fv38Xu/bt6/i4uKqPl6p8gTz8ccf17lt+CN3gcvIyNDxxx9P7gJA7uq2e/dupaamVvvzQ3JnhuxVV1JSov379ysnJ0dz5szRI488oo4dO+qEE07wW4/sBY7cVff73/9ebdq00Y033njM9bjGCxy5q27WrFlKS0tTSkqKunfv7ncrpqOROzNk74jKZ6q0bt1aQ4cOVUpKilJSUjRixIgaJ0DJXuDI3bG98sorSklJ0c9+9rNqHyN3gD0xeYuSQYMGyePx6KGHHtKZZ56pSy+91O/jHo9HWVlZys7Ornpt3rx5+u9//6sHH3ywavAeO3assrKy9Pjjj2vcuHE6/vjjq9b/7rvv9O2331a9O6tp06a68cYb9eCDD+r7779Xenq6JKm8vFzZ2dnasmVL1bo1+fbbbyXJ709mJGn9+vWSKv6s5vjjj9eLL76o3Nxc/eEPf9C5556rr7/+Wm3btq11u7t27VJ8fLxatWrl93pSUpKaN2+unTt3+r2ekJCgzMxMrVu3rtZtombkzkyXLl3IXQDI3bFt2LBB//rXv5SVlaX4+PhqHyd3gSN71f3rX//yu+9jv3799PzzzyshofrlFtkLDLnz9+WXX+rpp5/Wf/7znxrHuKNxjRc4cufv9NNP12WXXabOnTtr586dmj59ukaPHq3c3FzdfPPNfuuSOzNkr3r9r3/9a/Xv31+vv/66tm3bpj/84Q8aNmyYvvzyS783M5C9wJG72v3www969913NWrUqKoej0buoojvfwvqFiXHKSbfwV0fP774qvzBYPz48X6v33HHHfL5fJo/f77f60OHDvUbYAcOHChJ+vnPf+430FW+vmnTpmP2c+DAASUkJFS7T1NBQYGkij/jWbx4sX7xi1/o5ptv1ty5c3Xw4EFNnz79mNstKipSUlJSjR9LTk5WUVFRtdebNm2q/fv3H3O7CExDyV0gyF3oNNTcHT58WFlZWUpJSdHkyZNrXIfchVZDy94555yjhQsX6o033tBNN92kxMTEGh/4J5G9UGpIuRs/frxGjBih8847r851JXIXSg0pdx9//LFuu+02XXzxxbrpppu0atUq9ejRQ/feey8/W1jQULJXWd+mTRu98847uuyyy/Sb3/xGzz77rDZu3FjjXxGQvdBpKLn7sTfffFMlJSU13p6kErkD7GiQE9wJCQlq376932tbt25Vu3btqv0Wrlu3blUfP1qHDh38/p2RkSFJyszMrPH1gwcPBtRrSkqKJGnkyJF+g/VPfvITde7cuepPcY5VX1JSUuPHiouLq7Z/NJ/PV+97J6P+GlLuAkHuQqOh5q68vFxXXHGF1q1bpzfffFPt2rWrcT1yFzoNMXutW7fWsGHDdOmll2rGjBm66KKLNHz4cO3evbvaumQvNBpS7l5//XUtW7ZMjz76aL33Se5CoyHlriZJSUkaN26cDh06pFWrVlX7OLkLnYaUvcr6yy67THFxR6YxsrKylJCQUGM92QuNhpS7H3vllVfUrFkzjRgxotZ1yB1gR4Oc4Ha73X4nxUDU9megtb3+4wcr/Fjz5s1VVlZW7SFolZMyrVu3rlbTqlWrOgf6tm3bqry8vOopyJVKSkp04MCBGid9Dh48WO1BbTDXkHIXCHIXGg01dzfccIPefvttzZo1S+eee26t65G70Gmo2TvapZdeqoKCghofJkn2QqMh5e7OO+9UVlaWkpKStGXLFm3ZsqXqgaY5OTnVbkMnkbtQaUi5q03lpNQPP/xQ7WPkLnQaUvZqq4+Pj1fz5s1rrCd7odGQcne0bdu26cMPP1RWVpYSExNrXY/cAXY0yAnumnTs2FE7d+6sNiBW3supY8eOId3/ySefLKni6b9H69u3ryRpx44d1Wp27typli1bHnO7p512miRp5cqVfq+vXLlSXq+36uOVysrKlJOTU/WbVoRWrOYuEJs3byZ3YRLrubvzzjs1c+ZMTZ061e9+yDUhd+EV69n7sco/1c/Nza32MbIXPrGau5ycHM2ePVudO3euWh5//HFJFQ/ZuuCCC/zW5xovvGI1d7WpvH3Aj+vJXfjFavZqq698wDPZsytWc3e0V199VT6f75i3JyF3gD1McP/PBRdcoPLycj3xxBN+r0+dOlUul+uYf4ISDIMGDZJUfSL6pJNOUq9evTRv3jy/+zi99957ysnJ0fDhw4+53XPPPVfNmjXTjBkz/F6fMWOGUlNTdeGFF/q9vm7dOhUXF+v00083+XRQT7GaO6dyc3O1ceNGchcmsZy7KVOm6JFHHtG9996r22677Zjrkrvwi9Xs7d+/v8Z3Fv3973+XVPGwyaORvfCK1dzNmTOn2nL55ZdLkl588UVNnTrVb32u8cIrVnO3b9++aq/l5+dr2rRpatGiRdVkUiVyF36xmr0hQ4aoVatWeuWVV1RcXFz1+qxZs1ReXl6tnuyFV6zm7mizZ89Whw4ddMYZZ9S6DrkD7Emw3UCkGDlypM455xz99re/1ZYtW9SrVy+99957mjdvniZMmOD3xN9Q6NKli3r06KFFixbpuuuu8/vY1KlTNXz4cJ1xxhm68cYblZubq8cee0wnnnii38MdtmzZos6dO2vMmDGaNWuWpIp7Tv3pT3+qeoLx+eefrw8//FAvv/yy/vznP6tZs2Z++1q4cKFSU1ODPoGJmsVq7iTp3//+t7744gtJUmlpqb788ks9+OCDkqSLL75YPXv2rFp30aJF8vl8uuSSS0L42aJSrOZuzpw5uuuuu9S1a1d169ZNL7/8st+2hw8f7vfnieQu/GI1ey+//LKeeuopjRo1Sl26dFF+fr4WLFighQsXauTIkdVuk0P2witWczdq1Khq+1qzZo0kacSIEdX+PJprvPCK1dxNnz5dc+fO1ciRI9WhQwft2rVLzz//vLZt26aXXnqp2sPtyV34xWr23G63pkyZojFjxuiss87SL3/5S23btk2PP/64zjzzTP3sZz/z2xfZC69YzV2ltWvX6ssvv9Q999xzzPtrk7vo4fJVLKhbtBwnJrj/Jy4uTm+99Zbuu+8+vf7665o5c6Y6deqkKVOm6I477ghLD9ddd53uu+8+FRUV+T388ZxzztG7776r3//+97r33nuVmpqqUaNG6S9/+YvfgxIqnxDctm1bv+3ecsstSkxM1KOPPqq33npLmZmZmjp1ao3vbnzjjTf0s5/9rNrDIRAasZy7f/7zn3rhhReq/v3555/r888/lyS1b9/eb4L7jTfe0BlnnBHyCx9UiNXcVf5CZf369frlL39ZbZ/vv/++3wQ3uQu/WM3eGWecoWXLlunVV1/Vnj17lJCQoJNOOkmPPfaYbr311mo9kL3witXcOcU1XnjFau4GDx6sZcuW6e9//7sOHDigtLQ0DRgwQM8//3yNz7wgd+EXq9mTpKuvvlpJSUmaPHmy7rzzTjVp0kQ33nijHnrooWr3biZ74RXLuZMqHi4pSb/4xS+O2QO5A+xx+eq6Wz/CJjc3V126dNFf/vIXXX/99Y7rn3zySd11113auHFjjQ9RqMuaNWvUp08frV69utq9uRG7bOdu9+7d6ty5s1577TXezdiAkDvYQvZgg+3ccY3XMJE72EL2YAO5Q33k5eUpIyNDP7nwT0pITLbdTlQoKy3W8nd+r9zcXDVu3Nh2O7XiHtwRJCMjQ3fddZemTJkir9fruP7999/X+PHjAxqMJWny5Mm69NJLGYwbGNu5mzZtmk499VQmehoYcgdbyB5ssJ07rvEaJnIHW8gebCB3QMPGO7gBAAAAAAAAxDTewe0c7+AGAAAAAAAAACCEeMgkAAAAAAAAgIbB56tYULcoOU68gxsAAAAAAAAAEJWY4AYAAAAAAAAARCUmuAEAAAAAAAAAUYkJbgAAAAAAAABAVGKCGwAAAAAAAAAQlSJqgnv69Onq1KmTkpOTNXDgQH322Wf1rv3ggw80cuRItWvXTi6XS3PnznW07+zsbPXv31/p6elq1aqVRo0ape+++87RNmbMmKGePXuqcePGaty4sQYNGqT58+c72sbRJk+eLJfLpQkTJtS75oEHHpDL5fJbTj75ZEf73bFjh6666io1b95cKSkpOvXUU7Vy5cp613fq1KlaDy6XS2PHjnXURzhFc/ZiJXeSWfbI3VxH+2bMO6KhjXnkzh+5C59ozl6s5E7iXNuQcyc5z14k5E6KvuxFc+6k2BnzyF39cyfZzx65qxBtuYtWLh+LkyUaRMwE9+uvv66JEyfq/vvv1+rVq9WrVy+df/752rt3b73qCwsL1atXL02fPj2g/S9dulRjx47V8uXLtXDhQpWWluq8885TYWFhvbfRvn17TZ48WatWrdLKlSt17rnn6pJLLtHXX3/tuJ8VK1bo6aefVs+ePR3XnnLKKdq1a1fV8tFHH9W79uDBgxo8eLASExM1f/58rVu3To8++qiaNm3qqPej979w4UJJUlZWluPPJRyiPXuxkDvJPHvkzhnGvAoNbcwjd/7IXfhEe/ZiIXcS59qGnDsp8OzZzl1l79GSvWjPnRQbYx65c5Y7yX72yN2R3qMld0Akcfl8voiYix84cKD69++vJ554QpLk9XqVmZmpW2+9Vffcc4+jbblcLs2ZM0ejRo0KuJ99+/apVatWWrp0qc4666yAt9OsWTNNmTJF119/fb1rCgoK1KdPHz355JN68MEHddppp2natGn1qn3ggQc0d+5crVmzJqB+77nnHn388cf68MMPA6qvyYQJE/T2229r/fr1crlcQdtusMRi9qItd1Lws0funGHMaxhjHrk7gtyFVyxmL9pyJ3Gubai5kwLPXiTmTors7MVi7qToG/PIXeC5kyIne+QusnMXjfLy8pSRkaFBI/6ohMRk2+1EhbLSYn0y/z7l5uaqcePGttupVUS8g7ukpESrVq3SsGHDql6Li4vTsGHD9Mknn1jpKTc3V1LFgBqI8vJyvfbaayosLNSgQYMc1Y4dO1YXXnih3/FwYv369WrXrp26dOmi0aNHa9u2bfWufeutt9SvXz9lZWWpVatW6t27t5599tmA+pAqvrYvv/yyrrvuuogcjGMte9GaOym42SN3zjHmxf6YR+78kbvwibXsRWvuJM61DTV3kln2Iil3UmRnL9ZyJ0XvmEfu7OZOapjn2oaUOyDSRMQE9/79+1VeXq7WrVv7vd66dWvt3r077P14vV5NmDBBgwcPVo8ePRzVfvXVV2rUqJHcbrduuukmzZkzR927d693/WuvvabVq1crOzvbaduSKn5zO2vWLL377ruaMWOGNm/erDPPPFP5+fn1qt+0aZNmzJihrl27asGCBbr55ps1fvx4vfDCCwH1M3fuXB06dEjXXHNNQPWhFivZi/bcScHNHrlzhjGvYYx55O4IchdesZK9aM+dxLlWani5k8yyF2m5kyI7e7GSOyn6xzxyZy93UsM91zak3AGRJsF2A5Fo7NixWrt2reP7y0nSSSedpDVr1ig3N1dvvvmmxowZo6VLl9ZrUM7JydFtt92mhQsXKjk5sD+VGDFiRNX/9+zZUwMHDlTHjh31j3/8o15/1uP1etWvXz899NBDkqTevXtr7dq1euqppzRmzBjH/Tz33HMaMWKE2rVr57i2IQo0e9GeOym42SN3zjDmMebZQO7InS2caznX2mAjd5J59iItdxLZc4JzLbmzpaGea8kdYE9EvIO7RYsWio+P1549e/xe37Nnj9q0aRPWXsaNG6e3335b77//vtq3b++4PikpSSeccIL69u2r7Oxs9erVS48//ni9aletWqW9e/eqT58+SkhIUEJCgpYuXaq//vWvSkhIUHl5ueN+mjRpohNPPFEbNmyo1/pt27atdvLo1q2b4z9FlKStW7dq0aJF+tWvfuW4NlxiJXvRnjspeNkjd84w5jWcMY/cVSB34Rcr2Yv23Emca6WGlTsp+NmzmTsp8rMXK7mTon/MI3d2cic17HNtQ8pd1POxOFqiQERMcCclJalv375avHhx1Wter1eLFy8O6B5zgfD5fBo3bpzmzJmj//73v+rcuXNQtuv1euXxeOq17tChQ/XVV19pzZo1VUu/fv00evRorVmzRvHx8Y73X1BQoI0bN6pt27b1Wn/w4MH67rvv/F77/vvv1bFjR8f7njlzplq1aqULL7zQcW24xGr2oi13UvCyR+7qhzGvQkMa88hdBXIXfrGavWjLncS5tqHlTgp+9mzmTor87MVq7qToG/PIXXhzJ9kf88gd0LBFzC1KJk6cqDFjxqhfv34aMGCApk2bpsLCQl177bX1qi8oKPD7rdrmzZu1Zs0aNWvWTB06dKizfuzYsZo9e7bmzZun9PT0qntVZWRkKCUlpV49TJo0SSNGjFCHDh2Un5+v2bNna8mSJVqwYEG96tPT06vdnyotLU3Nmzev932rfvOb32jkyJHq2LGjdu7cqfvvv1/x8fG68sor61V/++236/TTT9dDDz2kyy67TJ999pmeeeYZPfPMM/Wqr+T1ejVz5kyNGTNGCQkRE7MaRXv2YiF3UnCyR+4Y8xjzjo3ckTtboj17sZA7iXNtQ8udZJ69SMmdFD3Zi/bcSbEx5pE7Z7mT7GeP3B0RLbkDIknEfKdcfvnl2rdvn+677z7t3r1bp512mt59991qD0qozcqVK3XOOedU/XvixImSpDFjxmjWrFl11s+YMUOSNGTIEL/XZ86cWe8b+u/du1dXX321du3apYyMDPXs2VMLFizQ8OHD61UfDNu3b9eVV16pAwcOqGXLljrjjDO0fPlytWzZsl71/fv315w5czRp0iT98Y9/VOfOnTVt2jSNHj3aUR+LFi3Stm3bdN111wXyaYRVtGcvFnInBSd75I4xjzHv2MhdcJA756I9e7GQO4lzLblzLlJyJ0VP9qI9d1JsZI/cOcudZD975O6IaMkdEElcPp8vSu6mAgAAAAAAAADO5eXlKSMjQ4P+749KSAzsYaQNTVlpsT559z7l5uaqcePGttupVUTcgxsAAAAAAAAAAKci5hYlAAAAAAAAABBKLl/FgrpFy3HiHdwAAAAAAAAAgKjEBDcAAAAAAAAAICoxwQ0AAAAAAAAAiEpMcAMAAAAAAAAAgmL69Onq1KmTkpOTNXDgQH322We1rvvss8/qzDPPVNOmTdW0aVMNGzbsmOvXJOImuD0ejx544AF5PB4r9fQQWT2ES6wcL3oI3jbCIRI+V3qInB7CKRaOFz0Er4dwiZXjZbuHWPgcwilWjhc9BG8b4RILx4segtdDuETC50oPkdMDYMvrr7+uiRMn6v7779fq1avVq1cvnX/++dq7d2+N6y9ZskRXXnml3n//fX3yySfKzMzUeeedpx07dtR7ny6fzxdRz8PMy8tTRkaGcnNz1bhx47DX00Nk9RAusXK86CF42wiHSPhc6SFyeginWDhe9BC8HsIlVo6X7R5i4XMIp1g5XvQQvG2ESywcL3oIXg/hEgmfKz1ETg+orvK4nj78D0pITLbdTlQoKy3WsoX3O8riwIED1b9/fz3xxBOSJK/Xq8zMTN16662655576qwvLy9X06ZN9cQTT+jqq6+u1z4j7h3cAAAAAAAAAIDIkJeX57fU9tcFJSUlWrVqlYYNG1b1WlxcnIYNG6ZPPvmkXvs6fPiwSktL1axZs3r3xwQ3AAAAAAAAAKBGmZmZysjIqFqys7NrXG///v0qLy9X69at/V5v3bq1du/eXa993X333WrXrp3fJHldEuq9ZpB4vV7t3LlT6enpcrlc1T6el5fn91+nTOvpIbw9+Hw+5efnq127doqLC93vW0Kdu2Bsgx7C1wO5owcbPURK7urTa10aytcsFnoIV+4kxrxoqQ9XD5Ey5kXL8aKH4GwjUnJXn17r0lC+ZrHQQyyda6PheNPDEeHMHpCTk+N3ixK32x2S/UyePFmvvfaalixZouTk+t9GJuz34N6+fbsyMzPDuUtEgZycHLVv3z5k2yd3qAm5gw3kDjaEOncS2UPNGPNgA7mDDZxrYUs4shcr8vK4B7dTTu/BXVJSotTUVL355psaNWpU1etjxozRoUOHNG/evFprH3nkET344INatGiR+vXr56jPsL+DOz09XZL0xAenKqVRfEDbaBxXbNzHvw/2Mqo/LvmQcQ/npH1rVL+25DjjHr4pbGdUP7LJ50b1hwu8umLw5qpchErl9kfOvVKJaUkBbSMnv4lxH4dLAtt3pQFtthr3kBxXalT/9vI+xj0063zIqL5r031G9aWFJZp3yWthy93Zb1yrhNTAvvY/abbZuI/miQVG9dc2rt+fER3LmC1nG9XvKTT/Wu38vpXZBpqWGJV7izzacdvDYcvdhIXD5E5LDGgb6wsNj5Wk5zp+aFQ/9MtLjHvo0XynUf3hcvN3JXRO3W9U/+Z7g43qvcXF2jr5TyHPnXQke12fu03xqYEduyd6vGrcx4R1lxvV5+enGPfgzTU7308ZOtu4h51lTY3q/3vgZKP60sISLfjZy2Eb8854/fqAz7WnNNll3Me7m7sZ1ZccNsuMJCWlmp2nyrY1Mu7h5vPeM6p/eXN/o/rywx59c+3fwpa7a+dfrKQAz7Xt3QeN+5j576FG9d3P3GjcQ0GJ2bnyYHGqcQ95BWY9/PG0fxvVFxWU69dnrgvrufbFj45XaoDzKd94zCdCE13lRvXLczsb9/Dgcf8xql98uItxDy3i843qf7v6p0b13iKPto2bEpbsAfWVlJSkvn37avHixVUT3F6vV4sXL9a4ceNqrfvLX/6iP//5z1qwYIHjyW3JwgR35Z/RpDSKV2p6YANyalxgdUdLKjW7iExODuxC5mhpjcz+hCTFY/7lS3KZfR5pAX4Nf6y2P+0LlsrtJ6YlBTzBneA1n+iITzDLXVIj8x9+3IZ/uRSXYv5bzkAnPioF+jX8sXDlLiE1SQlpgX3OyY3Mx5qURLOxonG6+Z+7mX7NEmT+/Wec3ZTg/NlfuHLnTkuUO8D8JMr8e8w0N/EBfs8czXTMLC0Lwpgb4MRHpTgHf5Z3LKHO3dH7iE91BzzOpwVhvDE9x8SVB+GYG/5CO9Br5KOllJqN/YnFDedcG+hYebT4VLPcxPnMj3d8qtn3jzcI401yI7PcmX7/VgpX7pLSEpUUYH6S3eY/y5meI4JxTZ2QaPY1i48LwjWe1+w4BGPMlcJ7rk1tFB/wz+LJhj8bSFKi4eeaGIRrrHTDa4aUOPPjkJpglp04w3NHpXBkL+b4/regbgEcp4kTJ2rMmDHq16+fBgwYoGnTpqmwsFDXXnutJOnqq6/WcccdV3Uf74cfflj33XefZs+erU6dOlXdq7tRo0Zq1Kh+v4AP+wQ3AAAAAAAAACD2XH755dq3b5/uu+8+7d69W6eddprefffdqgdPbtu2ze++8TNmzFBJSYkuvfRSv+3cf//9euCBB+q1z4B+5TV9+nR16tRJycnJGjhwoD777LNANgM4Qu5gC9mDDeQONpA72EDuYAvZgw3kDkBDMG7cOG3dulUej0effvqpBg4cWPWxJUuWaNasWVX/3rJli3w+X7WlvpPbUgAT3K+//romTpyo+++/X6tXr1avXr10/vnna+/evU43BdQbuYMtZA82kDvYQO5gA7mDLWQPNpA7AAgNxxPcjz32mG644QZde+216t69u5566imlpqbq+eefD0V/gCRyB3vIHmwgd7CB3MEGcgdbyB5sIHcAEBqOJrhLSkq0atUqDRs27MgG4uI0bNgwffLJJzXWeDwe5eXl+S2AE+QOtjjNHrlDMJA72MC5FjaQO9jCuRY2MOYBQOg4muDev3+/ysvLq24KXql169ZVT7j8sezsbGVkZFQtmZmZgXeLBoncwRan2SN3CAZyBxs418IGcgdbONfCBsY8IHK4JLl8LPVabH+x6imgh0w6MWnSJOXm5lYtOTk5od4lQO5gBbmDDeQOtpA92EDuYAO5gy1kDwDqJ8HJyi1atFB8fLz27Nnj9/qePXvUpk2bGmvcbrfcbnfgHaLBI3ewxWn2yB2CgdzBBs61sIHcwRbOtbCBMQ8AQsfRO7iTkpLUt29fLV68uOo1r9erxYsXa9CgQUFvDpDIHewhe7CB3MEGcgcbyB1sIXuwgdwBQOg4ege3JE2cOFFjxoxRv379NGDAAE2bNk2FhYW69tprQ9EfIIncwR6yBxvIHWwgd7CB3MEWsgcbyB0AhIbjCe7LL79c+/bt03333afdu3frtNNO07vvvlvtQQlAMJE72EL2YAO5gw3kDjaQO9hC9mADuQOA0HA8wS1J48aN07hx44LdC3BM5A62kD3YQO5gA7mDDeQOtpA92EDugAjg81UsqFuUHCdH9+AGAAAAAAAAACBSBPQO7mDYXdZEyaWB7f7tvA7G+//ou65G9Y2aHDbuoVv3nUb1L2z9iXEP8S6z38Ss2p9pVF9W6JH0uNE2nPh8+3GKS00OqLb0cJLx/pN2JRrV722237iHz7eYfc3cB+KNe8gtaG5Uv71fiVF9Re7CZ//hRopXYE8//3vOYOP9/+302Ub1/yjIMO6hlbvAqH71crMxW5LifC6zDew1HAOKvWb1Ds3+5HTFpQQ23p3Ybbvx/m8wzG5yQplxD+8vOs2ovjyz2LiHjz0nGNW70sxy440Lb+4k6cx2m5TUKLDz3Vu5fYz3/3+Z3xjVv/bB6cY9JOWajTd3rM4y7uHKk1YZ1a8xHHe9xebfP054yhNUXh7YzxZ3t/zIeP9zvu1lVH9ih93GPXy/tr1RvSvR/B1aszYNNKpPiDcbs1yG9U7d1PxDpacH9p6xMd/+0nj/Je3NrokPl5n/fLNpTwuj+rJCs5+PJCnhgNm0xn3JI43qyw97JH1ltA2nvizuoOSEwI7dwNSNxvt/J9dszMtqudK4h599ZXbf8lZpZj+fSNK6bW2N6n0es5+tvUXlRvVALOEd3AAAAAAAAACAqMQENwAAAAAAAAAgKjHBDQAAAAAAAACIStbuwQ0AAAAAAAAA4eTyVSyoW7QcJ8fv4P7ggw80cuRItWvXTi6XS3Pnzg1BW4A/cgcbyB1sIHewhezBBnIHG8gdbCF7ABAajie4CwsL1atXL02fPj0U/QA1InewgdzBBnIHW8gebCB3sIHcwRayBwCh4fgWJSNGjNCIESNC0QtQK3IHG8gdbCB3sIXswQZyBxvIHWwhewAQGiG/B7fH45HH46n6d15eXqh3CZA7WEHuYAO5gy1kDzaQO9hA7mAL2QOA+nF8ixKnsrOzlZGRUbVkZmaGepcAuYMV5A42kDvYQvZgA7mDDeQOtpA9AKifkE9wT5o0Sbm5uVVLTk5OqHcJkDtYQe5gA7mDLWQPNpA72EDuYAvZA0LEx+JoiQIhv0WJ2+2W2+0O9W4AP+QONpA72EDuYAvZgw3kDjaQO9hC9gCgfkL+Dm4AAAAAAAAAAELB8Tu4CwoKtGHDhqp/b968WWvWrFGzZs3UoUOHoDYHVCJ3sIHcwQZyB1vIHmwgd7CB3MEWsgcAoeF4gnvlypU655xzqv49ceJESdKYMWM0a9asoDUGHI3cwQZyBxvIHWwhe7CB3MEGcgdbyB4AhIbjCe4hQ4bI54uSO4wjZpA72EDuYAO5gy1kDzaQO9hA7mAL2QOA0Aj5QyYBAAAAAAAAIBK4fD65+GVTvUTLcbI2wT1j2bmKS0kOqHbIad+YN1Bo9qk3buMxbuG3ay4xqi85nGTcg3uz2ROZe533rVF9aVyJVhptwZnmGYVKSCsLqPZQYorx/k8/xSy7V7RYbtzD+uZtjOr/cvAi4x4adcgzqm+Vmm9UX+orMap36sDe9IDHO5W7jPf/yp5BRvVDmn1n3MOq/e2N6tv02Gvcw76VrY3qSzPMTuxeb3gvDBKbFykuNbB9blpufg/IWy9bbFT/pq+/cQ9nX7jeqL5RfLFxD/tL043q5/7H7PvXWxz+54m/+80pAY95ndvvM97/GS03GtWnZpqdYyTJ0zLRqL5ba/PjcFLyLqP64/vkGNWXFXq01WgLzrROy1diWmDX5y/mnmq8/8cHvGZU/9Ke0417kOm3u9e8heObHjCq/3qP2XVqeXF4z7XzCk5VcoA/Up/UxPzaZsfeJkb13RrvNu6h1BtvVL91bzPjHlJaFhjVP9vrRaP6wnyvhhltwbm1+ccp0RvYfMBTH55T90p1uO3s94zq1xaZ/WwgSRe2/9qo/uomnxn38GDy/xnVf7S1i1G9N8F8XgqIFeH/qQcAAAAAAAAAgCBgghsAAAAAAAAAEJWY4AYAAAAAAAAARCVHE9zZ2dnq37+/0tPT1apVK40aNUrffWd+b1bgWMgdbCF7sIHcwQZyB1vIHmwgd7CB3AFA6Dia4F66dKnGjh2r5cuXa+HChSotLdV5552nwsLCUPUHkDtYQ/ZgA7mDDeQOtpA92EDuYAO5AyKIl8XREgUcPfL53Xff9fv3rFmz1KpVK61atUpnnXVWUBsDKpE72EL2YAO5gw3kDraQPdhA7mADuQOA0HE0wf1jubm5kqRmzZrVuo7H45HH46n6d15enskuAXIHa+rKHrlDKJA72MC5FrYw5sEGcgcbONcCQPAE/JBJr9erCRMmaPDgwerRo0et62VnZysjI6NqyczMDHSXALmDNfXJHrlDsJE72MC5FrYw5sEGcgcbONcCQHAFPME9duxYrV27Vq+99tox15s0aZJyc3OrlpycnEB3CZA7WFOf7JE7BBu5gw2ca2ELYx5sIHewgXMtAARXQLcoGTdunN5++2198MEHat++/THXdbvdcrvdATUHHI3cwZb6Zo/cIZjIHWzgXAtbGPNgA7mDDZxrASD4HE1w+3w+3XrrrZozZ46WLFmizp07h6ovoAq5gy1kDzaQO9hA7mAL2YMN5A42kDsgcrh8Prl8PtttRIVoOU6OJrjHjh2r2bNna968eUpPT9fu3bslSRkZGUpJSQlJgwC5gy1kDzaQO9hA7mAL2YMN5A42kDsACB1H9+CeMWOGcnNzNWTIELVt27Zqef3110PVH0DuYA3Zgw3kDjaQO9hC9mADuYMN5A4AQsfxLUqAcCN3sIXswQZyBxvIHWwhe7CB3MEGcgcAoePoHdwAAAAAAAAAAEQKR+/gDqbWmT8oPi2wpwF/e7CV8f7P6PONUX375EPGPfzk+A1G9c/sONu4h7bd8ozqhzdda1R/OLlcc4224MyeTS0Ul5IcUG18gfnvg5bHdTSqv7/tAuMe9pU1NqofOtDsay5JX+xvZ1SfnTnPqL4g36u3jLbgTFxeguJKAhtuk3LNc/fp4ZOM6pc36WLcQ4d2B4zqt+1qZtyDq5HZu2Z8iYb1ZeF9105JYZLivEkB1calmvc6Pedco/pvc9oY95DeuMiofkDbbcY9pCV4jOrLO5t9Dt7DxUb1gXCneRSf6gqodtMG86/7yyfONqqfG9fTuIeUVLOv+/AWZtepknRF+kGj+rXNtxrVe9ylWmK0BWe+WNZVccmBXeP1uGCn8f43eVob1T/f8V3jHgbtM+uhWdph4x5Ob7rRqP4fXRYb1efle9XUaAvOfFvQRkkK7Fz70dIexvsfdKbZWDE842vjHh5tu9qoflqbTsY9HCxLM6o/7A1sXuJIfblRfSDW7Gyn+NTAxryk5ubXBofLzY5Zj5Ttxj2c5jYbu9PjArtWOdptbRYZ1Xs13Ki+pKBEm4y2AMQOaxPcAAAAAAAAABBWvv8tqFuUHCduUQIAAAAAAAAAiEpMcAMAAAAAAAAAohIT3AAAAAAAAACAqORognvGjBnq2bOnGjdurMaNG2vQoEGaP39+qHoDJJE72EP2YAO5gw3kDraQPdhA7mADuQOA0HE0wd2+fXtNnjxZq1at0sqVK3Xuuefqkksu0ddfmz99GagNuYMtZA82kDvYQO5gC9mDDeQONpA7AAidBCcrjxw50u/ff/7znzVjxgwtX75cp5xySlAbAyqRO9hC9mADuYMN5A62kD3YQO5gA7kDIojPV7GgblFynBxNcB+tvLxcb7zxhgoLCzVo0KBa1/N4PPJ4PFX/zsvLC3SXALmDNfXJHrlDsJE72MC5FrYw5sEGcgcbONcCQHA5fsjkV199pUaNGsntduumm27SnDlz1L1791rXz87OVkZGRtWSmZlp1DAaJnIHW5xkj9whWMgdbOBcC1sY82ADuYMNnGsBIDQcT3CfdNJJWrNmjT799FPdfPPNGjNmjNatW1fr+pMmTVJubm7VkpOTY9QwGiZyB1ucZI/cIVjIHWzgXAtbGPNgA7mDDZxrASA0HN+iJCkpSSeccIIkqW/fvlqxYoUef/xxPf300zWu73a75Xa7zbpEg0fuYIuT7JE7BAu5gw2ca2ELYx5sIHewgXMtAISG43dw/5jX6/W7JxQQDuQOtpA92EDuYAO5gy1kDzaQO9hA7gAgOBy9g3vSpEkaMWKEOnTooPz8fM2ePVtLlizRggULQtUfQO5gDdmDDeQONpA72EL2YAO5gw3kDogcLl/FgrpFy3FyNMG9d+9eXX311dq1a5cyMjLUs2dPLViwQMOHDw9VfwC5gzVkDzaQO9hA7mAL2YMN5A42kDsACB1HE9zPPfdcqPoAakXuYAvZgw3kDjaQO9hC9mADuYMN5A4AQsf4HtwAAAAAAAAAANjg6B3cwbT/2xaKS04OqPb0weuM93+oJNWo/letPzDu4b28U43qC0rMn6a8pbyZUX2rFvlG9YXx5Ub1TiU0L1JcamA3EPIWpRnv/9RWu4zq95QnGfdwRfpBo/r//BBv3MOZbTYa1R/wmmW/0Os1qncqqX2B4lPLAqotOpBivH/37kSj+o6n7jHuoWVKgVF9Vv9Vxj0s3NfdqL7Ea5b9skKPthttwZmE5DLFpQSWO2+u+eXBcam5RvXf7+lo3EO/E783qh/S5FvjHn4oa2RU3yyj0Ki+PNGjrUZbCGCfG9LlC/AaL+3kPOP937n9IqN6d2Jg3zdHO/RFC6P6T1p2Me5hm8fsGu+bvDZG9aWFJUb1TvnaF8kX4DXeq+v7Gu//xT4zjerfPtzSuIdGyWYPqtv5WTvjHlafa3adOXy32c9HZYUeSU8abcOJDbktlFAW2HVpebL5TU2/2GP2NbuqlXELmnawk1H93B2nGfewY3Vbo/qlfboa1Vfk7m9G23Cqz3E7lJgW2M+Gy5edbLz/SwauMap/ev9Zxj0kZpidr5vHm/18Ikl/2zXMqH7Fpyca1XuLi43qgVjCO7gBAAAAAAAAAFHJ2ju4AQAAAAAAACCsfL6KBXWLkuPEO7gBAAAAAAAAAFHJaIJ78uTJcrlcmjBhQpDaAepG7mADuYMtZA82kDvYQO5gC9mDDeQOAIIn4AnuFStW6Omnn1bPnj2D2Q9wTOQONpA72EL2YAO5gw3kDraQPdhA7gAguAKa4C4oKNDo0aP17LPPqmnTpsHuCagRuYMN5A62kD3YQO5gA7mDLWQPNpA7AAi+gCa4x44dqwsvvFDDhg2rc12Px6O8vDy/BQgEuYMN5A621Dd75A7BxJgHG8gdbOFcCxsY8wAg+BKcFrz22mtavXq1VqxYUa/1s7Oz9Yc//MFxY8DRyB1sIHewxUn2yB2ChTEPNpA72MK5FjYw5gGRweWtWFC3aDlOjt7BnZOTo9tuu02vvPKKkpOT61UzadIk5ebmVi05OTkBNYqGi9zBBnIHW5xmj9whGBjzYAO5gy2ca2EDYx4AhI6jd3CvWrVKe/fuVZ8+fapeKy8v1wcffKAnnnhCHo9H8fHxfjVut1tutzs43aJBInewgdzBFqfZI3cIBsY82EDuYAvnWtjAmAcAoeNognvo0KH66quv/F679tprdfLJJ+vuu++uNhgDwUDuYAO5gy1kDzaQO9hA7mAL2YMN5A4AQsfRBHd6erp69Ojh91paWpqaN29e7XUgWMgdbCB3sIXswQZyBxvIHWwhe7CB3AFA6Di6BzcAAAAAAAAAAJHC0Tu4a7JkyZIgtAE4Q+5gA7mDLWQPNpA72EDuYAvZgw3kDrDE56tYULcoOU68gxsAAAAAAAAAEJWM38EdqPgil+J8roBqP1l6ivH+x4/8j1H9ofJU4x7OaPS9UX3bpEPGPXRK2mdUPyTFa1SfVxbm3wRtS5OSkwMqTT4UWF6PtmZ+N6P63w9NMe7hcGmSUf3W7S2Me0jYn2hUf+gss++/koISSbONtuFEaUmCyhMCG25Tt5odK0mKKzGr376og3EPnnN2GtV/6Otq3MMXX3c0qk9pddiovvxwsVG9Uzf3XKqURoHl7vmNg4z3/+G7vYzqk4uMW9Cy+T2N6red1dS4h0NFZuP2gf3pRvXeovDmTpIuGLZC7kaBjV1f57Y13n+vxjlG9Z8tMTtXS1Jigdk1g+n1giT9cO5Wo/rv17U3qg939soOJyrOF1juGqebje+S9FZeb6P645IOGveQ+34bo/o4t3ELWvmO2X2EW5+9w6i+zBve9295yhJUVhrgj9Qu85+DerfZblS/saSVcQ9tEnKN6neuMh/3XYY/pu1aYdaDtzj859qfNl+l1PTAHkq5v0+a8f5n/XC6Uf1JqbuNe3hmx9lG9We3MJuPkaRPvz7eqD59u9mYVe7hPatAJb4bAAAAAAAAAABRiQluAAAAAAAAAEBUYoIbAAAAAAAAABCVrN2DGwAAAAAAAADCyve/BXWLkuPk6B3cDzzwgFwul99y8sknh6o3QBK5gz1kDzaQO9hA7mAL2YMN5A42kDsACB3H7+A+5ZRTtGjRoiMbSOBN4Ag9cgdbyB5sIHewgdzBFrIHG8gdbCB3ABAajkfThIQEtWnTJhS9ALUid7CF7MEGcgcbyB1sIXuwgdzBBnIHAKHh+CGT69evV7t27dSlSxeNHj1a27ZtO+b6Ho9HeXl5fgvgFLmDLU6yR+4QLOQONnCuhS2MebCB3MEGzrUAEBqOJrgHDhyoWbNm6d1339WMGTO0efNmnXnmmcrPz6+1Jjs7WxkZGVVLZmamcdNoWMgdbHGaPXKHYCB3sIFzLWxhzIMN5A42cK4FgNBxNME9YsQIZWVlqWfPnjr//PP1n//8R4cOHdI//vGPWmsmTZqk3NzcqiUnJ8e4aTQs5A62OM0euUMwkDvYwLkWtjDmwQZyBxs41wKRw+XzsThYooHREw2aNGmiE088URs2bKh1HbfbLbfbbbIbwA+5gy11ZY/cIRTIHWzgXAtbGPNgA7mDDZxrASB4HN+D+2gFBQXauHGj2rZtG6x+gDqRO9hC9mADuYMN5A62kD3YQO5gA7kDgOBxNMH9m9/8RkuXLtWWLVu0bNky/fSnP1V8fLyuvPLKUPUHkDtYQ/ZgA7mDDeQOtpA92EDuYAO5A4DQcXSLku3bt+vKK6/UgQMH1LJlS51xxhlavny5WrZsGar+AHIHa8gebCB3sIHcwRayBxvIHWwgdwAQOo4muF977bVQ9QHUitzBFrIHG8gdbCB3sIXswQZyBxvIHQCEjtFDJgEAAAAAAAAgavh8FQvqFiXHydoEd4cHP1OCKzGg2i0PDjLe/+NrzjWqH9r1W+Me9hQ1NqovLEsy7mF/QZpR/Y4TPzCqLyook7TJaBtOJOS5FO9xBVR73ORlxvvP+e3pRvXrV3Q07sGVedioPmlXYN+3fj2Um9Wv2J1pVF9+2GPWgEO+/cnyJScHVBtXZr7/do+YZXf3BLPcStL2fU2N6g+XmucuuWWRUX3RvlSjem+R0XOdHZu74zQlpLkDqs37prnx/pMLzOrbTTEfc3fdYZbdzbtbGPcwoNMWo/rCT816KPeE/4L04z1dFJ8fWPbyDwc2Vh5te+4Ao3r3wcCuE45mmt/dt5uPuxs/62BU72tidrL2JYQ3e+ktChWfGthJM3+t+Zi3Kt3seL+6q59xDyklZvXHPWw+7ppeM+xY0c6o3ltcbFTvVOFht+IU2LiVcNj8umBbfjOj+iaJZtdGkvSfJX2N6lP3m4+5bR81y+6Oe8xyWx7gz5e2NHGbf90Xbz/RqD5v/UDjHuLbm/1cu26t2bgtSe4fzL6P2z5mlt0yX6nMZ6aA2BDen7YBAAAAAAAAAAgSJrgBAAAAAAAAAFGJCW4AAAAAAAAAQFRyPMG9Y8cOXXXVVWrevLlSUlJ06qmnauXKlUZN/NL3tUb71tX4sdG+dfql72uj7SP6hSJ3wUB2Y1+kZs8EuY18sZi7YCC7oUXuQofs1o7cRbZYzi7Zi22Rml1yh2OJ1NwC0cDRBPfBgwc1ePBgJSYmav78+Vq3bp0effRRNW1q9vAwr1y6RuuqfSOP9q3TNVonr6LroQ0IrlDlLhjIbmyL5OyZILeRLVZzFwxkN3TIXWiR3ZqRu8gXq9kle7EvErNL7lCXSMxtzPJJ8rLUawn/M+sDkuBk5YcffliZmZmaOXNm1WudO3c2buIVV3fJJ12jdZKv4t+V38Cz1L3i42iwQpW7YCC7sS2Ss2eC3Ea2WM1dMJDd0CF3oUV2a0buIl+sZpfsxb5IzC65Q10iMbdAtHD0Du633npL/fr1U1ZWllq1aqXevXvr2WefPWaNx+NRXl6e31KTV1zdNUvddY3W6R3fv/gGRpVQ5i4YyG7scpq9cObOFLmNXLGcu2Agu6ER6efaWEB2qyN30SEWs8u5tmGItOwy5qE+Ii23QLRwNMG9adMmzZgxQ127dtWCBQt08803a/z48XrhhRdqrcnOzlZGRkbVkpmZWeu6r7i6q0RxSpJXJYrjGxiSQp+7YCC7sclp9sKdO1PkNjLFeu6CgewGXzSca2MB2fVH7qJHrGWXc23DEUnZZcxDfUVSboFo4WiC2+v1qk+fPnrooYfUu3dv/frXv9YNN9ygp556qtaaSZMmKTc3t2rJycmpdd3RvnVV38BJ8tZ6c300LKHOXTCQ3djkNHvhzp0pchuZYj13wUB2gy8azrWxgOz6I3fRI9ayy7m24Yik7DLmob4iKbdAtHB0D+62bduqe3f/3xx169ZN//znP2utcbvdcrvddW77x/cVqvx35X2H0HCFMnfBQHZjl9PshTN3psht5Irl3AUD2Q2NSD/XxgKyWx25iw6xmF3OtQ1DpGWXMQ/1EWm5BaKFownuwYMH67vvvvN77fvvv1fHjh2Nmqjppvk13VwfDVOochcMZDe2RXL2TJDbyBaruQsGshs65C60yG7NyF3ki9Xskr3YF4nZJXeoSyTmNla5fD65fD7bbUSFaDlOjia4b7/9dp1++ul66KGHdNlll+mzzz7TM888o2eeecaoiTj5arxpfuU3cpyi42AiNEKVu2Agu7EtkrNngtxGtljNXTCQ3dAhd6FFdmtG7iJfrGaX7MW+SMwuuUNdIjG3QLRwNMHdv39/zZkzR5MmTdIf//hHde7cWdOmTdPo0aONmtbq7sUAAFH/SURBVHjJdUqtH+O3UwhV7oKB7Ma2SM6eCXIb2WI1d8FAdkOH3IUW2a0ZuYt8sZpdshf7IjG75A51icTcAtHC0QS3JF100UW66KKLQtELUCtyB1vIHmwgd7CB3MEGcgdbyB5sIHcAEBpxthsAAAAAAAAAACAQjt/BHSx7bh6oeHdyYMVBuMF5YlKZUf1HOV2Me4iP9xrV5x9MNe5B5S6j8sMnJBnVF3vD+zsWb5LkCvAh1BunDDLef7zHLLuDzvzauIeCUrOncO9v1si4h5ydzYzqU+PMvndchvVOteq6TwlpgR333N1tjPe/5U9m2U3KN25BF5y01qh+v8c8d1962hnVxxfEG9W7is3qndpfkKZ4b2C5a9trt/H+f/hvW6P6nb853biHMsPT5O29Fxn3MGuT2fdf2SkFRvXew8VG9YH44Yc0xRUHdo03+ISNxvv3+syuLT5r1sS4h233GeY3CJdHWed/bFT/6uoBZg2Uhfdc6ymJV3xCYD/aNOm533j/3RqbjZttU/KMe3h/e0+jetPrBUkqTzW8RmtrNmb5wjzmjTh+ndyNEgOqdZ9k9vOoJO3xNDaqv7zZp8Y9bOtvdl3/1erOxj1sfsgsuwlFZvv3hne4kyRdkFakxmmBnSw6Hfcf4/2va2F2nfd5pvmDNZfuOsGo/twT1xj3MPefZxjV75podr1Q7imWnphntA0gVlib4AYAAAAAAACAsPIpKG+ebRCi5DBxixIAAAAAAAAAQFRighsAAAAAAAAAEJWY4AYAAAAAAAAARCVHE9ydOnWSy+WqtowdOzZU/QGSyB7sIHewgdzBBnIHW8gebCB3sIHcAUDoOHrI5IoVK1ReXl7177Vr12r48OHKysoKemPA0cgebCB3sIHcwQZyB1vIHmwgd7CB3AFA6Dia4G7ZsqXfvydPnqzjjz9eZ599dlCbAn6M7MEGcgcbyB1sIHewhezBBnIHG8gdEEF8vooFdYuS4+RogvtoJSUlevnllzVx4kS5XK5a1/N4PPJ4PFX/zsvLC3SXgKT6ZY/cIdjIHWwgd7CBazzYwpgHG8gdbOBcCwDBFfBDJufOnatDhw7pmmuuOeZ62dnZysjIqFoyMzMD3SUgqX7ZI3cINnIHG8gdbOAaD7Yw5sEGcgcbONcCQHAFPMH93HPPacSIEWrXrt0x15s0aZJyc3OrlpycnEB3CUiqX/bIHYKN3MEGcgcbuMaDLYx5sIHcwQbOtQAQXAHdomTr1q1atGiR/vWvf9W5rtvtltvtDmQ3QDX1zR65QzCRO9hA7mAD13iwhTEPNpA72MC5FgCCL6B3cM+cOVOtWrXShRdeGOx+gGMie7CB3MEGcgcbyB1sIXuwgdzBBnIHAMHn+B3cXq9XM2fO1JgxY5SQEPAzKgHHyB5sIHewgdzBBnIHW8gebCB3sIHcARHCK6n257viaF7bDdSP43dwL1q0SNu2bdN1110Xin6AWpE92EDuYAO5gw3kDraQPdhA7mADuQOA0HD8K8PzzjtPPp8vFL0Ax0T2YAO5gw3kDjaQO9hC9mADuYMN5A4AQiPsfxNTOZiXlxQHvA1vsfkJwXc48P1Lki8uCCeleLP3+XuLArqFur9ys7/JKC4oC0p9qE/yldv3egxyF2/eo8tjVl9aWGLcQ2mp2de8rMjwk5DkLTL7/is/bNZDZX24cmfSb7lBZiuZZrfcY/63WyUFpUb1pSXm2TfNjbfY7GtRWR8NuSszHaxknl1XuXELKo83qy8yPMdJQcjdYbP9e4vCM94dvQ+vwXkiGOc5r8/s+sj0e12SZDpuBuFPZj2G467pubqyPmzXeAa5Kw/CmGd6vEtKg5B9w+y6ghB9r+HPSC7Dn9HCNeZVbr+k0ODrHmd+jinxmOWmMNn8785Nx+1gjLmuYrNB0/Rat/JnzHCea/MKAv/aFZSYf90Pl5hdqHkOm42ZklReaDZ2m47bUhCudw1PP5XzavzSBJBcvjB/J2zfvl2ZmZnh3CWiQE5Ojtq3bx+y7ZM71ITcwQZyBxtCnTuJ7KFmjHmwgdzBBs61sCUc2YsVeXl5ysjI0Lmn3q2EeLftdqJCWblH//3qYeXm5qpx48a226lV2N/B3a5dO+Xk5Cg9PV0uV/XflObl5SkzM1M5OTkBHTjTenoIbw8+n0/5+flq165dQD3WV6hzF4xt0EP4eiB39GCjh0jJXX16rUtD+ZrFQg/hyp3EmBct9eHqIVLGvGg5XvQQnG1ESu7q02tdGsrXLBZ6iKVzbTQcb3o4IpzZAyJd2Ce44+Li6vWbpcaNGxv9ZsC0nh7C10NGRkbA266vcOUuGNugh/D0QO7owUYPkZQ7KfKPFz0Epz4cuZMY86KtPhw9RNKYFw3Hix6Cs41Iyp0U+ceLHoJTH2vn2kg/3vRwRLiyF2tcPp9c3NqlXqLlOAXhJs4AAAAAAAAAAIQfE9wAAAAAAAAAgKgUcRPcbrdb999/v9zuwG72blpPD5HVQ7jEyvGih+BtIxwi4XOlh8jpIZxi4XjRQ/B6CJdYOV62e4iFzyGcYuV40UPwthEusXC86CF4PYRLJHyu9BA5PQANicvni5KbqQAAAAAAAABAAPLy8pSRkaGhPe5SQjy/PKiPsnKPFq/9i3Jzc43vSR9KEfcObgAAAAAAAAAA6iPBdgMAAAAAAAAAEBY+X8WCukXJceId3AAAAAAAAACAqMQENwAAAAAAAAAgKjHBDQAAAAAAAACISkxwAwAAAAAAAACiEhPcAAAAAAAAAIColGC7AQAAAAAAAAAIC5+vYkHdouQ48Q5uAAAAAAAAAEBUYoIbAAAAAAAAABCVmOAGAAAAAAAAAEQlJrgBAAAAAAAAAFEppie4V6xYodNPP11paWlyuVxas2aN7Zbq9Je//EUnn3yyvF5v2Pd9xRVX6LLLLgv7fmMNuXPmnnvu0cCBA8O+31hD7pwhd8FD9pwhe8FB7pzhGi84yJ0z5C54yJ4zZC84yJ0z5A6wK2YnuEtLS5WVlaUffvhBU6dO1UsvvaSOHTvabuuY8vLy9PDDD+vuu+9WXFzFl2bJkiVyuVy1Ln/+85/rte3nnntO3bp1U3Jysrp27aq//e1v1da5++679c9//lNffPFFUD+vhoTcHTFjxgxlZWWpQ4cOcrlcuuaaa2pcb8KECfriiy/01ltvBfPTalDIXYWcnBz94Q9/0IABA9S0aVO1aNFCQ4YM0aJFi6qtS+6Cg+xVKCoq0vXXX68ePXooIyNDjRo1Uq9evfT444+rtLTUb12yZ47c1eyjjz6qqt2/f7/fx7jGM0fujqitdvLkyX7rkbvgIHv+9uzZoxtvvFHHHXeckpOT1alTJ11//fV+65A9c+SuwqxZs45Z/8orr1StS+6ijM/H4mSJAgm2GwiVjRs3auvWrXr22Wf1q1/9ynY79fL888+rrKxMV155ZdVr3bp100svvVRt3ZdeeknvvfeezjvvvDq3+/TTT+umm27Sz3/+c02cOFEffvihxo8fr8OHD+vuu++uWq93797q16+fHn30Ub344ovB+aQaGHJ3xMMPP6z8/HwNGDBAu3btqnW9Nm3a6JJLLtEjjzyiiy++OLBPooEjdxXmzZunhx9+WKNGjdKYMWNUVlamF198UcOHD9fzzz+va6+9tmpdchccZK9CUVGRvv76a11wwQXq1KmT4uLitGzZMt1+++369NNPNXv27Kp1yZ45cled1+vVrbfeqrS0NBUWFlb7ONd45sidv+HDh+vqq6/2e613797V/k3uzJG9I3JycjR48GBJ0k033aTjjjtOO3fu1Geffea3HtkzR+4qnHXWWTXWT506VV988YWGDh1a9Rq5A+xy+XxRMhXv0AcffKCzzz5bb7zxhi699NJjrltYWKi0tLQwdVa7Xr16qWfPnjUOoD/WtWtXuVwuff/998dcr6ioSJmZmfrJT36it99+u+r1q666SnPnzlVOTo6aNm1a9fqjjz6q+++/X7t371ajRo0C/2QaKHJ3xNatW6vevd2oUSNdeumlmjVrVo3r/vOf/1RWVpY2bNigLl26OP0UGjxyV+Hrr79W69at1aJFi6rXPB6PTjvtNBUUFCgnJ8dvfXJnjuwd26233qonnnhCu3btUps2bapeJ3tmyF11Tz31lH73u9/pqquu0uOPP659+/b5jYUS13imyN0RLpdLY8eO1RNPPFHnuuTOHNk74oILLtC3336rFStWqHnz5sdcl+yZIXe1KyoqUuvWrfWTn/xE7733nt/HyF3ky8vLU0ZGhoZ2u0MJ8W7b7USFsnKPFn/zqHJzc9W4cWPb7dQqJm9Rcs011+jss8+WJGVlZcnlcmnIkCFVH2vUqJE2btyoCy64QOnp6Ro9erSkioH5jjvuUGZmptxut0466SQ98sgj+vHvAFwul8aNG6c33nhD3bt3V0pKigYNGqSvvvpKUsU7pk844QQlJydryJAh2rJlS509b968WV9++aWGDRtW57qfffaZNmzYUNX3sbz//vs6cOCAbrnlFr/Xx44dq8LCQr3zzjt+rw8fPlyFhYVauHBhnduGP3Lnr2PHjnK5XPVat3L/8+bNq9f6OILcHXHKKadUm9Bxu9264IILtH37duXn5/t9jNyZIXt169SpkyTp0KFDfq+TvcCRu+p++OEH/e53v9Mf//hHNWnSpNb1uMYLHLmrWVFRkYqLi4+5DrkzQ/aO+PbbbzV//nzdeeedat68uYqLi6vdBuxoZC9w5O7Y/v3vfys/P7/GenIH2BOTtyipvCfXQw89pPHjx6t///5q3bp11cfLysp0/vnn64wzztAjjzyi1NRU+Xw+XXzxxXr//fd1/fXX67TTTtOCBQt05513aseOHZo6darfPj788EO99dZbGjt2rCQpOztbF110ke666y49+eSTuuWWW3Tw4EH95S9/0XXXXaf//ve/x+x52bJlkqQ+ffrU+flV3uepPgPy559/Lknq16+f3+t9+/ZVXFycPv/8c1111VVVr1eeYD7++GP99Kc/rXP7OILcBS4jI0PHH3+8Pv74Y91+++1B334sI3d12717t1JTU5Wamur3OrkzQ/aqKykpUV5enoqKirRy5Uo98sgj6tixo0444QS/9che4Mhddb///e/Vpk0b3XjjjfrTn/5U63pc4wWO3FU3a9YsPfnkk/L5fOrWrZt+97vf6Re/+EW19cidGbJ3ROUzVVq3bq2hQ4fqv//9r+Lj4zV8+HDNmDGj6pfKlche4Mhd3fUpKSn62c9+Vu1j5A6wyBej3n//fZ8k3xtvvOH3+pgxY3ySfPfcc4/f63PnzvVJ8j344IN+r1966aU+l8vl27BhQ9Vrknxut9u3efPmqteefvppnyRfmzZtfHl5eVWvT5o0ySfJb92a/O53v/NJ8uXn5x9zvbKyMl/r1q19AwYMOOZ6lcaOHeuLj4+v8WMtW7b0XXHFFdVeP/HEE30jRoyo1/bhj9zVLC0tzTdmzJhjrnPeeef5unXrFtD2GzpyV7v169f7kpOTfb/85S9r/Di5M0P2/L366qs+SVVLv379fF9++WWN65K9wJG7I7744gtffHy8b8GCBT6fz+e7//77fZJ8+/btq3F9rvECR+6OOP30033Tpk3zzZs3zzdjxgxfjx49fJJ8Tz75ZI3rkzszZK/C+PHjfZJ8zZs39/3f//2f7/XXX/dNmTLF16hRI9/xxx/vKywsrFZD9gJH7mp24MABX1JSku+yyy6rdR1yF9lyc3N9knxDu93hO7/HvSz1WIZ2u8MnyZebm2v7y3dMMXmLkvq4+eab/f79n//8R/Hx8Ro/frzf63fccYd8Pp/mz5/v9/rQoUP9fks8cOBASdLPf/5zpaenV3t906ZNx+znwIEDSkhIqPM+TYsXL9aePXvq/dvGoqIiJSUl1fix5ORkFRUVVXu9adOm2r9/f722D2caSu4CQe5Cp6Hm7vDhw8rKylJKSoomT55c4zrkLrQaWvbOOeccLVy4UG+88YZuuukmJSYm1vjAP4nshVJDyt348eM1YsSIej8YkNyFTkPK3ccff6zbbrtNF198sW666SatWrVKPXr00L333svPFhY0lOwVFBRIqnhY8zvvvKPLLrtMv/nNb/Tss89q48aNfg90rkT2Qqeh5O7H3nzzTZWUlByzntxFCS+LoyUKNMgJ7oSEBLVv397vta1bt6pdu3Z+g6lU8dTdyo8frUOHDn7/zsjIkCRlZmbW+PrBgwfNG1fFn8PEx8fr8ssvr9f6KSkpKikpqfFjxcXFSklJqfa6z+er972TUX8NKXeBIHeh0VBzV15eriuuuELr1q3Tm2++qXbt2tW4HrkLnYaYvdatW2vYsGG69NJLNWPGDF100UUaPny4du/eXW1dshcaDSl3r7/+upYtW6ZHH3203vsgd6HRkHJXk6SkJI0bN06HDh3SqlWrqn2c3IVOQ8pe5c+tl112meLijkxjZGVlKSEhoeoWFUcje6HRkHJXU32zZs00YsSIWtchd4AdDXKC2+12+50UAxEfH+/odd+PHqzwY82bN1dZWVm1h6AdraioSHPmzNGwYcP87oF1LG3btlV5ebn27t3r93pJSYkOHDhQ46TPwYMHqz2oDeYaUu4CQe5Co6Hm7oYbbtDbb7+tWbNm6dxzz611PXIXOg01e0e79NJLVVBQUOPDJMleaDSk3N15553KyspSUlKStmzZoi1btlQ90DQnJ0c7d+6sVkPuQqMh5a42lZNSP/zwQ7WPkbvQaUjZq/y59cfrx8fHq3nz5jVOgJK90GhIuTvatm3b9OGHHyorK0uJiYm1rkfuADsa5AR3TTp27KidO3dWGxC//fbbqo+H0sknnyyp4um/tXnrrbdqfVpvbU477TRJ0sqVK/1eX7lypbxeb9XHK5WVlSknJ6fqN60IrVjNXSA2b95M7sIk1nN35513aubMmZo6daquvPLKY65L7sIr1rP3Y5V/qp+bm1vtY2QvfGI1dzk5OZo9e7Y6d+5ctTz++OOSKh6ydcEFF/itzzVeeMVq7mpTefuAli1b+r1O7sIvVrPXt29fSdKOHTv8Xi8pKdH+/fvJnmWxmrujvfrqq/L5fMesJ3eAPUxw/88FF1yg8vJyPfHEE36vT506VS6X65h/ghIMgwYNklR9Ivpos2fPVmpqqqOn8Z577rlq1qyZZsyY4ff6jBkzlJqaqgsvvNDv9XXr1qm4uFinn366g+4RqFjNnVO5ubnauHEjuQuTWM7dlClT9Mgjj+jee+/Vbbfddsx1yV34xWr29u/fX+M7i/7+979Lkvr16+f3OtkLr1jN3Zw5c6otlX9y/eKLL2rq1Kl+63ONF16xmrt9+/ZVey0/P1/Tpk1TixYtqiYhK5G78IvV7A0ZMkStWrXSK6+8ouLi4qrXZ82apfLycg0fPtxvfbIXXrGaux/Xd+jQQWeccUat65A7wJ4E2w1EipEjR+qcc87Rb3/7W23ZskW9evXSe++9p3nz5mnChAk6/vjjQ7r/Ll26qEePHlq0aJGuu+66ah//4YcfNH/+fP385z+v9cEJW7ZsUefOnTVmzBjNmjVLUsW9yv70pz9p7NixysrK0vnnn68PP/xQL7/8sv785z+rWbNmfttYuHChUlNTq10gIDRiNXeS9O9//1tffPGFJKm0tFRffvmlHnzwQUnSxRdfrJ49e1atu2jRIvl8Pl1yySVB/OxQm1jN3Zw5c3TXXXepa9eu6tatm15++WW/muHDh/v9OSK5C79Yzd7LL7+sp556SqNGjVKXLl2Un5+vBQsWaOHChRo5cmS12+SQvfCK1dyNGjWq2npr1qyRJI0YMaLan0dzjRdesZq76dOna+7cuRo5cqQ6dOigXbt26fnnn9e2bdv00ksvVXu4PbkLv1jNntvt1pQpUzRmzBidddZZ+uUvf6lt27bp8ccf15lnnqmf/exnftsge+EVq7mrtHbtWn355Ze65557jnl/bXIH2MME9//ExcXprbfe0n333afXX39dM2fOVKdOnTRlyhTdcccdYenhuuuu03333aeioqJqD3984403VFpaql/84he11lc+Wbpt27Z+r99yyy1KTEzUo48+qrfeekuZmZmaOnVqje9ufOONN/Szn/2s2sMhEBqxnLt//vOfeuGFF6r+/fnnn+vzzz+XJLVv395vgvuNN97QGWecEfILH1SI1dxV/kJl/fr1+uUvf1mt5v333/eb4CZ34Rer2TvjjDO0bNkyvfrqq9qzZ48SEhJ00kkn6bHHHtOtt95abRtkL7xiNXdOcY0XXrGau8GDB2vZsmX6+9//rgMHDigtLU0DBgzQ888/X+MzL8hd+MVq9iTp6quvVlJSkiZPnqw777xTTZo00Y033qiHHnqo2r2byV54xXLupIqHS0o6Zn3lfshddHD5fHLVcW93VIiW4+Ty1XW3foRNbm6uunTpor/85S+6/vrrHdc/+eSTuuuuu7Rx48aAHpqwZs0a9enTR6tXr652b27ELtu52717tzp37qzXXnuNdzM2IOQOtpA92GA7d1zjNUzkDraQPdhA7lAfeXl5ysjI0LATJyoh3m27nahQVu7Rou8fU25urho3bmy7nVpxD+4IkpGRobvuuktTpkyR1+t1XP/+++9r/PjxAT8FffLkybr00ksZjBsY27mbNm2aTj31VCZ6GhhyB1vIHmywnTuu8RomcgdbyB5sIHdAw8Y7uAEAAAAAAADENN7B7Vyg7+CePn26pkyZot27d6tXr17629/+pgEDBtS47tdff6377rtPq1at0tatWzV16lRNmDDBUZ+8gxsAAAAAAAAAYOz111/XxIkTdf/992v16tXq1auXzj//fO3du7fG9Q8fPqwuXbpo8uTJatOmTUD7ZIIbAAAAAAAAAGDsscce0w033KBrr71W3bt311NPPaXU1FQ9//zzNa7fv39/TZkyRVdccYXc7sDeWZ9g0jAAAAAAAAAARA2fr2JB3f53nPLy8vxedrvdNU5Gl5SUaNWqVZo0aVLVa3FxcRo2bJg++eSTkLXJO7gBAAAAAAAAADXKzMxURkZG1ZKdnV3jevv371d5eXm1B7a2bt1au3fvDll/vIMbAAAAAAAAAFCjnJwcv4dMBnorkVBhghsAAAAAAAAAUKPGjRv7TXDXpkWLFoqPj9eePXv8Xt+zZ0/AD5Csj4i6Rcn06dPVqVMnJScna+DAgfrss8/qXfvBBx9o5MiRateunVwul+bOneto39nZ2erfv7/S09PVqlUrjRo1St99952jbcyYMUM9e/as+qIPGjRI8+fPd7SNo02ePFkul0sTJkyod80DDzwgl8vlt5x88smO9rtjxw5dddVVat68uVJSUnTqqadq5cqV9a7v1KlTtR5cLpfGjh3rqI9wiubsxUruJLPskbu5jvbNmHdEQxvzyJ0/chc+0Zy9WMmdxLm2IedOcp69SMidFH3Zi+bcSbEz5pG7+udOsp89clch2nIH/FhSUpL69u2rxYsXV73m9Xq1ePFiDRo0KGT7jZgJ7tdff10TJ07U/fffr9WrV6tXr146//zztXfv3nrVFxYWqlevXpo+fXpA+1+6dKnGjh2r5cuXa+HChSotLdV5552nwsLCem+jffv2mjx5slatWqWVK1fq3HPP1SWXXKKvv/7acT8rVqzQ008/rZ49ezquPeWUU7Rr166q5aOPPqp37cGDBzV48GAlJiZq/vz5WrdunR599FE1bdrUUe9H73/hwoWSpKysLMefSzhEe/ZiIXeSefbInTOMeRUa2phH7vyRu/CJ9uzFQu4kzrUNOXdS4NmznbvK3qMle9GeOyk2xjxy5yx3kv3skbsjvUdL7oDaTJw4Uc8++6xeeOEFffPNN7r55ptVWFioa6+9VpJ09dVX+z2EsqSkRGvWrNGaNWtUUlKiHTt2aM2aNdqwYUO99+ny+SLjsaEDBw5U//799cQTT0iqmN3PzMzUrbfeqnvuucfRtlwul+bMmaNRo0YF3M++ffvUqlUrLV26VGeddVbA22nWrJmmTJmi66+/vt41BQUF6tOnj5588kk9+OCDOu200zRt2rR61T7wwAOaO3eu1qxZE1C/99xzjz7++GN9+OGHAdXXZMKECXr77be1fv16uVyuoG03WGIxe9GWOyn42SN3zjDmNYwxj9wdQe7CKxazF225kzjXNtTcSYFnLxJzJ0V29mIxd1L0jXnkLvDcSZGTPXIX2bmLRnl5ecrIyNCw4ycoIT6y7iEdqcrKPVq0cZpyc3PrdYuSSk888YSmTJmi3bt367TTTtNf//pXDRw4UJI0ZMgQderUSbNmzZIkbdmyRZ07d662jbPPPltLliyp1/4i4h3cJSUlWrVqlYYNG1b1WlxcnIYNG6ZPPvnESk+5ubmSKgbUQJSXl+u1115TYWGh47fgjx07VhdeeKHf8XBi/fr1ateunbp06aLRo0dr27Zt9a5966231K9fP2VlZalVq1bq3bu3nn322YD6kCq+ti+//LKuu+66iByMYy170Zo7KbjZI3fOMebF/phH7vyRu/CJtexFa+4kzrUNNXeSWfYiKXdSZGcv1nInRe+YR+7s5k5qmOfahpQ7oC7jxo3T1q1b5fF49Omnn1ZNbkvSkiVLqia3pYpb8/h8vmpLfSe3pQiZ4N6/f7/Ky8vVunVrv9dbt26t3bt3h70fr9erCRMmaPDgwerRo4ej2q+++kqNGjWS2+3WTTfdpDlz5qh79+71rn/ttde0evVqZWdnO21bUsVvbmfNmqV3331XM2bM0ObNm3XmmWcqPz+/XvWbNm3SjBkz1LVrVy1YsEA333yzxo8frxdeeCGgfubOnatDhw7pmmuuCag+1GIle9GeOym42SN3zjDmNYwxj9wdQe7CK1ayF+25kzjXSg0vd5JZ9iItd1JkZy9WcidF/5hH7uzlTmq459qGlDsg0iTYbiASjR07VmvXrnV8fzlJOumkk7RmzRrl5ubqzTff1JgxY7R06dJ6Dco5OTm67bbbtHDhQiUnJwfSukaMGFH1/z179tTAgQPVsWNH/eMf/6jXn/V4vV7169dPDz30kCSpd+/eWrt2rZ566imNGTPGcT/PPfecRowYoXbt2jmubYgCzV60504KbvbInTOMeYx5NpA7cmcL51rOtTbYyJ1knr1Iy51E9pzgXEvubGmo51pyB9gTEe/gbtGiheLj47Vnzx6/1/fs2aM2bdqEtZdx48bp7bff1vvvv6/27ds7rk9KStIJJ5ygvn37Kjs7W7169dLjjz9er9pVq1Zp79696tOnjxISEpSQkKClS5fqr3/9qxISElReXu64nyZNmujEE0+s943Z27ZtW+3k0a1bN8d/iihJW7du1aJFi/SrX/3KcW24xEr2oj13UvCyR+6cYcxrOGMeuatA7sIvVrIX7bmTONdKDSt3UvCzZzN3UuRnL1ZyJ0X/mEfu7OROatjn2oaUOyDSRMQEd1JSkvr27avFixdXveb1erV48eKA7jEXCJ/Pp3HjxmnOnDn673//W+PNzQPh9Xrl8Xjqte7QoUP11VdfVT05dM2aNerXr59Gjx6tNWvWKD4+3vH+CwoKtHHjRrVt27Ze6w8ePFjfffed32vff/+9Onbs6HjfM2fOVKtWrXThhRc6rg2XWM1etOVOCl72yF39MOZVaEhjHrmrQO7CL1azF225kzjXNrTcScHPns3cSZGfvVjNnRR9Yx65C2/uJPtjHrkDGraIuUXJxIkTNWbMGPXr108DBgzQtGnTVFhYqGuvvbZe9QUFBX6/Vdu8ebPWrFmjZs2aqUOHDnXWjx07VrNnz9a8efOUnp5eda+qjIwMpaSk1KuHSZMmacSIEerQoYPy8/M1e/ZsLVmyRAsWLKhXfXp6erX7U6Wlpal58+b1vm/Vb37zG40cOVIdO3bUzp07df/99ys+Pl5XXnllvepvv/12nX766XrooYd02WWX6bPPPtMzzzyjZ555pl71lbxer2bOnKkxY8YoISFiYlajaM9eLOROCk72yB1jHmPesZE7cmdLtGcvFnInca5taLmTzLMXKbmToid70Z47KTbGPHLnLHeS/eyRuyOiJXdRzeerWFC3aDlOvgjyt7/9zdehQwdfUlKSb8CAAb7ly5fXu/b999/3Saq2jBkzpl71NdVK8s2cObPePVx33XW+jh07+pKSknwtW7b0DR061Pfee+/Vu74mZ599tu+2226r9/qXX365r23btr6kpCTfcccd57v88st9GzZscLTPf//7374ePXr43G637+STT/Y988wzDrv2+RYsWOCT5Pvuu+8c19oQzdmLldz5fObZI3eMeYx5dSN31ZG78Ijm7MVK7nw+zrUNPXc+n7PsRUrufL7oyl40587ni50xj9zVP3c+n/3skbsjoil30SY3N9cnyTesy22+/+t6F0s9lmFdbvNJ8uXm5tr+8h2Ty+eLlql4AAAAAAAAAHAuLy9PGRkZGtblNiXEu223ExXKyj1atOlx5ebmqnHjxrbbqVVE3IMbAAAAAAAAAACnmOAGAAAAAAAAAEQlJrgBAAAAAAAAAFGJx7ECAAAAAAAAaCB8Eo8krKfoOE68gxsAAAAAAAAAEJWY4AYAAAAAAAAARCUmuAEAAAAAAAAAUSniJrg9Ho8eeOABeTweK/X0EFk9hEusHC96CN42wiESPld6iJwewikWjhc9BK+HcImV42W7h1j4HMIpVo4XPQRvG+ESC8eLHoLXQ7hEwudKD5HTA9CQuHy+yLqrel5enjIyMpSbm6vGjRuHvZ4eIquHcImV40UPwdtGOETC50oPkdNDOMXC8aKH4PUQLrFyvGz3EAufQzjFyvGih+BtI1xi4XjRQ/B6CJdI+FzpIXJ6QHWVx3VYl/FKiHPbbicqlHk9WrTprxGfxQTbDQAAAAAAAABAWPh8FQvqFiXHKeJuUQIAAAAAAAAAQH2E/R3cXq9XO3fuVHp6ulwuV7WP5+Xl+f3XKdN6eghvDz6fT/n5+WrXrp3i4kL3+5ZQ5y4Y26CH8PVA7ujBRg+Rkrv69FqXhvI1i4UewpU7iTEvWurD1UOkjHnRcrzoITjbiJTc1afXujSUr1ks9BBL59poON70cEQ4swdEurDfg3v79u3KzMwM5y4RBXJyctS+ffuQbZ/coSbkDjaQO9gQ6txJZA81Y8yDDeQONnCuhS3hyF6syMv73z24O9/KPbjrqczr0aLNf+Me3D+Wnp4uSTr+2dsVnxpYmDo0PWjcR5vkwH8TJ0lL1p1k3IMr0WtU36qF2ecgSWe32WBUv724iVF9aWGJ5lz8j6pchErl9ts9dK/ikpMD2kabTgeM+/hp+y+M6jPiDxv3MP37IUb1npJ44x5KDgX2NaiSZPa94y3yaOfEyWHL3YVzf6HEtKSAtrEtt6lxH4t7zjOqf/qQ+UX02oJ2RvUfbT7euIeWTfON6o9LzzWqLy0s0TujZoctdybn2fM7fmPcxy3NPjGqf6ewq3EP3xQeZ1T/SLuVxj28mNfKqP6lbQON6ssPe/T5VU+FPHfSkeyNfuenSkpLDGgbSzaZf92v6Gb2dXv9nbOMexhwzjqj+s6p+417uKv5eqP6KzcONaovKyzRoktfCNuY1/7xuxSXEtiYN7LbV8Z9vPV1L6P6s0/83riHgnKzH9Rvaf2+cQ+rizsZ1d/YJMeoPq/Aq459toQtdze8e2HA4938Td2M+8jqusao/lBZqnEPk9t8blT/f19fZNzD8Y3Nxsw9xWZ5KTtcoqVZM8N6ru0/+0YlpAb288U1HZYZ97GhuLVR/b0tvjXu4ZX8Fkb1HRLMf76fmjPcqP6EdLPslhSW6oUL5oUle0CkC/sEd+Wf0cSnugP+wTvQiaKjJaWYbSMuxXCCTuYT3PFpHuMe3I0CuyCrlBhv/rWQVOuf9gVL5fbjkpMD/tolpJn/di+5kdm3XEq8+bdsoN93VfUJ5j3EeexOcFcKV+4S05ICHrfiy8xz1zjd7M/VksvMv+ZJMhxzU83H3IS0EqP6YJx7pPDlzuQ8a3pukKR0w9yluIKQO5fZ52H6vSNJKV6zzyMY5x4p9Lk7eh9JaYlKahTY90swvteTDfMb6C/Cjxbo518pOdX8e9A0v9E25sWluAPOTzDGPNOfDUwzI0mJZWbbSAvCmJdseJ0YjHFXCl/uktISA85PfBDGO9PsJpXZH2uCcZ4z/f5JiI++c21CalLAxy7F8GdSSXInRMA1ls/s80hLNH/jlml+k4Jw/pHCkz0g0oV9ghsAAAAAAAAArPD6JIX1js3RyxsdxymgX5tNnz5dnTp1UnJysgYOHKjPPvss2H0B1ZA72EL2YAO5gw3kDjaQO9hC9mADuQOA4HM8wf36669r4sSJuv/++7V69Wr16tVL559/vvbu3RuK/gBJ5A72kD3YQO5gA7mDDeQOtpA92EDuACA0HE9wP/bYY7rhhht07bXXqnv37nrqqaeUmpqq559/PhT9AZLIHewhe7CB3MEGcgcbyB1sIXuwgdwBQGg4muAuKSnRqlWrNGzYsCMbiIvTsGHD9Mknn9RY4/F4lJeX57cATpA72OI0e+QOwUDuYAPnWthA7mAL51rYwJgHAKHjaIJ7//79Ki8vV+vWrf1eb926tXbv3l1jTXZ2tjIyMqqWzMzMwLtFg0TuYIvT7JE7BAO5gw2ca2EDuYMtnGthA2MeAIROQA+ZdGLSpEnKzc2tWnJyckK9S4DcwQpyBxvIHWwhe7CB3MEGcgdbyB4QIj4vi5MlCiQ4WblFixaKj4/Xnj17/F7fs2eP2rRpU2ON2+2W2+0OvEM0eOQOtjjNHrlDMJA72MC5FjaQO9jCuRY2MOYBQOg4egd3UlKS+vbtq8WLF1e95vV6tXjxYg0aNCjozQESuYM9ZA82kDvYQO5gA7mDLWQPNpA7AAgdR+/glqSJEydqzJgx6tevnwYMGKBp06apsLBQ1157bSj6AySRO9hD9mADuYMN5A42kDvYQvZgA7kDgNBwPMF9+eWXa9++fbrvvvu0e/dunXbaaXr33XerPSgBCCZyB1vIHmwgd7CB3MEGcgdbyB5sIHcAEBqOJ7glady4cRo3blywewGOidzBFrIHG8gdbCB3sIHcwRayBxvIHQAEX0AT3AAAAAAAAAAQdXy+igV1i5LjZG2C2+XyyeUK7CCNaLXWeP//2tnbqN6VYP4F9pU5esZnNV2b7DPuIdFVblQ/MGOzUX1RfJn+YbQFZ5KaFyk+NbCvXdu0POP9j2xklt3Xc/sa9/BOn2eN6octv9m4h5tOX2JUv7ck3ajeU1CqGUZbcObzz05QXHJyQLXeViXG+z/jy58Z1bcJQvZXf3G82QbSS4172HvQLDfjOr9vVH84uVxzjbbgcH8/pCiuKLDc/bP4NOP9nzPgG6P6x74cat5Dl/VG9ddvO8O4h9MzNhjVpyaaZb/MsD4Qi74/WXEpgWWvX5etxvt/7tMzjeoT3MYtaMm6k4zquw/YadzDnbvNrnWPb2R2nelReLPXp3OOEtOSAqpdsO1k4/03bZ5vVL/4G/Mezjn5O6P6Lz2Zxj2cm/atUf30Qyca1RcVlEnaZLQNJ+at7RXweJfcyPwa76X3zjaq7znQ7BwlSbfs+IlR/aEAr1WO9t+t3YzqL+n7uVF9SVypFte9WlDtL0hTvDewE9bvlpj9bCBJowcuN6o/66ufGvdQ6jWbTykuSTTuITnJ7Fz33iazsb/8cLFRPRBLzEYEAAAAAAAAAAAsYYIbAAAAAAAAABCVmOAGAAAAAAAAAEQlxxPcH3zwgUaOHKl27drJ5XJp7ty5IWgL8EfuYAO5gw3kDraQPdhA7mADuYMtZA8AQsPxBHdhYaF69eql6dOnh6IfoEbkDjaQO9hA7mAL2YMN5A42kDvYQvaACOH1sThZokCC04IRI0ZoxIgRoegFqBW5gw3kDjaQO9hC9mADuYMN5A62kD0ACA3HE9xOeTweeTyeqn/n5eWFepcAuYMV5A42kDvYQvZgA7mDDeQOtpA9AKifkD9kMjs7WxkZGVVLZmZmqHcJkDtYQe5gA7mDLWQPNpA72EDuYAvZA4D6CfkE96RJk5Sbm1u15OTkhHqXALmDFeQONpA72EL2YAO5gw3kDraQPQCon5DfosTtdsvtdod6N4AfcgcbyB1sIHewhezBBnIHG8gdbCF7AFA/IZ/gBgAAAAAAAICI4PNVLKhblBwnxxPcBQUF2rBhQ9W/N2/erDVr1qhZs2bq0KFDUJsDKpE72EDuYAO5gy1kDzaQO9hA7mAL2QOA0HA8wb1y5Uqdc845Vf+eOHGiJGnMmDGaNWtW0BoDjkbuYAO5gw3kDraQPdhA7mADuYMtZA8AQsPxBPeQIUPki5K3pyN2kDvYQO5gA7mDLWQPNpA72EDuYAvZA4DQiLPdAAAAAAAAAAAAgWCCGwAAAAAAAAAQlRzfoiRYkhPLFJ8YH1BtvLzG+z+16U6j+q17mhv3kNy4xKj+w3UnGvdw+dmfGdV/friTUX1xWalRvVPtm+UqIa04oNrHOs413v9qTxuj+ntbfGfcwxWbLzaqP6/Lt8Y9vLXjVKP6n7TcYtxDOLXpvlcJae6Aat0JZcb735PfyKi+VarLuIcz+n5jVP/h5ycb99Cx/T6j+oe++T+j+vLDHkmrjbbhhHtHouKTEwOqLT3JfGy+7zuzsSYtxewcKUlLNnc1qh/exXzM/fuWwUb1+75uaVTvLQ7snGfCVxInX3xg76FYtTkID9hKMLtOTMw1H/PKmppt45/behv30KfldqP6+V/1MKr3FhVLmmO0DSdWbe6guJTkgGqvO22Z8f5nfjHIqN5Xbp67pRvNxrwle8y+5pI0cKDZuNnCXWBUX3I4vD9bJDfyKD7A6yR3ovk1XtlxRWb1vsB+Hj/aloJmRvUFeSnGPcQVmn0eb63taVRfMd7902gbThUXuBVXHtiYl9bysPH+P9p7vFF9ixSz73VJKiwN7OerSnmHAzt+RyspM8ueJ9/sc/AWcbubgPkkcbug+omSw8Q7uAEAAAAAAAAAUYkJbgAAAAAAAABAVGKCGwAAAAAAAAAQlRxNcGdnZ6t///5KT09Xq1atNGrUKH33nfn9KYFjIXewhezBBnIHG8gdbCF7sIHcwQZyBwCh42iCe+nSpRo7dqyWL1+uhQsXqrS0VOedd54KCwtD1R9A7mAN2YMN5A42kDvYQvZgA7mDDeQOAEInwcnK7777rt+/Z82apVatWmnVqlU666yzgtoYUIncwRayBxvIHWwgd7CF7MEGcgcbyB0QQXy+igV1i5Lj5GiC+8dyc3MlSc2aNat1HY/HI4/HU/XvvLw8k10C5A7W1JU9codQIHewgXMtbGHMgw3kDjZwrgWA4An4IZNer1cTJkzQ4MGD1aNHj1rXy87OVkZGRtWSmZkZ6C4Bcgdr6pM9codgI3ewgXMtbGHMgw3kDjZwrgWA4Ap4gnvs2LFau3atXnvttWOuN2nSJOXm5lYtOTk5ge4SIHewpj7ZI3cINnIHGzjXwhbGPNhA7mAD51oACK6AblEybtw4vf322/rggw/Uvn37Y67rdrvldrsDag44GrmDLfXNHrlDMJE72MC5FrYw5sEGcgcbONcCQPA5muD2+Xy69dZbNWfOHC1ZskSdO3cOVV9AFXIHW8gebCB3sIHcwRayBxvIHWwgdwAQOo4muMeOHavZs2dr3rx5Sk9P1+7duyVJGRkZSklJCUmDALmDLWQPNpA72EDuYAvZgw3kDjaQOyCCeL2SvLa7iA7e6DhOju7BPWPGDOXm5mrIkCFq27Zt1fL666+Hqj+A3MEasgcbyB1sIHewhezBBnIHG8gdAISO41uUAOFG7mAL2YMN5A42kDvYQvZgA7mDDeQOAELH0Tu4AQAAAAAAAACIFI7ewR1MeQVuxXmTA6r9tqit8f63FTY1qs9s9YNxD1s2tjaqH9H3S+MePsg/2aj+4dZrjOrz3F5lG23BmcZJxUpMCuz+QTvLzO+L9l2xWXbvzG9k3MOew+lG9Ss+PdG4h8T2hUb161NaGdWXFpYY1TvlKU9QWVlgw23O5pbG+0/eZTbUf5XaxLiH8lSz+3Yl74837mHbD8d+Sn1dStqUGtV7i8w/Bycy+u1TfJo7oNr26YeM95+e6DGq/+ytU417KOlq1sP8b7sb99Cyeb5RfWKB2XsRyovD/16GpEYliksNbL+jTjS/tvkmr41R/dr4dsY9qNTsuKclmZ+n4mT2TsEmzQuM6ssPe7TdaAvOnH3CeiU1SgqotmmC2XWJJI3tvdSofnVeB+Mevtprdp3Zptc+4x72FJldZ3ZttNeo3pNodq52qklakRLSArvG6dV8p/H+P9ph9pDCi1qZj7n7S82+5hv2tDDuobSx2Zjbsa3Zz/ZlhR7lGG3BuZYt8hSfFth1zp49Gcb7T0ky+17bvs9sPkYyn5Npk2F2jSZJ2/Y2M9tAnOG7+k3rgRjCO7gBAAAAAAAAAFHJ2ju4AQAAAAAAACCsfL6KBXWLkuPEO7gBAAAAAAAAAFHJ0QT3jBkz1LNnTzVu3FiNGzfWoEGDNH/+/FD1Bkgid7CH7MEGcgcbyB1sIXuwgdzBBnIHAKHjaIK7ffv2mjx5slatWqWVK1fq3HPP1SWXXKKvv/46VP0B5A7WkD3YQO5gA7mDLWQPNpA72EDuACB0HN2De+TIkX7//vOf/6wZM2Zo+fLlOuWUU4LaGFCJ3MEWsgcbyB1sIHewhezBBnIHG8gdAIROwA+ZLC8v1xtvvKHCwkINGjSo1vU8Ho88Hk/Vv/Py8gLdJUDuYE19skfuEGzkDjZwroUtjHmwgdzBBs61ABBcjh8y+dVXX6lRo0Zyu9266aabNGfOHHXv3r3W9bOzs5WRkVG1ZGZmGjWMhoncwRYn2SN3CBZyBxs418IWxjzYQO5gA+daIEL4fCxOlijgeIL7pJNO0po1a/Tpp5/q5ptv1pgxY7Ru3bpa1580aZJyc3OrlpycHKOG0TCRO9jiJHvkDsFC7mAD51rYwpgHG8gdbOBcCwCh4fgWJUlJSTrhhBMkSX379tWKFSv0+OOP6+mnn65xfbfbLbfbbdYlGjxyB1ucZI/cIVjIHWzgXAtbGPNgA7mDDZxrASA0HL+D+8e8Xq/fPaGAcCB3sIXswQZyBxvIHWwhe7CB3MEGcgcAweHoHdyTJk3SiBEj1KFDB+Xn52v27NlasmSJFixYEKr+AHIHa8gebCB3sIHcwRayBxvIHWwgdwAQOo4muPfu3aurr75au3btUkZGhnr27KkFCxZo+PDhoeoPIHewhuzBBnIHG8gdbCF7sIHcwQZyBwCh42iC+7nnngtVH0CtyB1sIXuwgdzBBnIHW8gebCB3sIHcARHE65Pks91FdPBGx3Eyvgc3AAAAAAAAAAA2MMENAAAAAAAAAIhKjm5REkxx8T7Fxwf2NvcfSlKN99/cfdiofmtuU+Meupyw26j+iwPtjHt4tfuLhltoZNxDOCXHlykxPrDf6+wuzzDe/7u7uxvVj2z7lXEPaYklRvWn9t1s3EPL5AKj+ltbLzaqL8j36j2jLTjTo9kuJTVKCqh2V5rZsZKkdaltjep9nnjjHi7rt8KofmHOScY9eErNTnk3nvSJUX1xQZl+b7QFZ1qkFSoxrTSg2l+1/dB4/0/uOMeo3ts737gHHUgxKr9z4LvGLXx0qKtR/eFzc43qSwtLtDHbaBOOlZXGK640sHHjk72djfffp0WOUf26PeY9yGX2p5ybC8yv8Xa0Nbtu8RxKNqr3FiUa1TuVllCipITAjvtNGVuN93/v3j5G9Re3+Ny4h+VbOhnVr88zGzMlqXVLszFrfUEro/rSQrPrXKdu6PSRUhoFdn2xuqCj8f7v7WZ2nioPwvvdjkv9wag+Pn6AcQ+lXpdRfV6x26i+3GNUHpB/nvKq0tMD+/r9u0sH4/1/dTjTqL7r8XuMe9hfmm5U3y91k3EPz6ecaVSfV2J2ri0r9Gi70RaA2ME7uAEAAAAAAAAAUYkJbgAAAAAAAABAVLJ2ixIAAAAAAAAACCefzyufz2u7jagQLcfJ6B3ckydPlsvl0oQJE4LUDlA3cgcbyB1sIXuwgdzBBnIHW8gebCB3ABA8AU9wr1ixQk8//bR69uwZzH6AYyJ3sIHcwRayBxvIHWwgd7CF7MEGcgcAwRXQBHdBQYFGjx6tZ599Vk2bNg12T0CNyB1sIHewhezBBnIHG8gdbCF7sIHcAUDwBTTBPXbsWF144YUaNmxYnet6PB7l5eX5LUAgyB1sIHewpb7ZI3cIJsY82EDuYAvnWtjAmAcAwef4IZOvvfaaVq9erRUrVtRr/ezsbP3hD39w3BhwNHIHG8gdbHGSPXKHYGHMgw3kDrZwroUNjHkAEBqO3sGdk5Oj2267Ta+88oqSk5PrVTNp0iTl5uZWLTk5OQE1ioaL3MEGcgdbnGaP3CEYGPNgA7mDLZxrYQNjHhBBfD7Jy1Kvxeez/dWqF0fv4F61apX27t2rPn36VL1WXl6uDz74QE888YQ8Ho/i4+P9atxut9xud3C6RYNE7mADuYMtTrNH7hAMjHmwgdzBFs61sIExDwBCx9EE99ChQ/XVV1/5vXbttdfq5JNP1t13311tMAaCgdzBBnIHW8gebCB3sIHcwRayBxvIHQCEjqMJ7vT0dPXo0cPvtbS0NDVv3rza60CwkDvYQO5gC9mDDeQONpA72EL2YAO5A4DQcXQPbgAAAAAAAAAAIoWjd3DXZMmSJUFoA3CG3MEGcgdbyB5sIHewgdzBFrIHG8gdAASH8QQ3AAAAAAAAAEQFn0+Sz3YX0cEXHcfJ3gT3unQpOTmw2vbmuy/zmd2dpXOTH4x7WH+gpVF9r9Y7jHvYWZZiVN82vtyovtTnNap3asWWjopLDSx3H395ovH+3c2KjOpfKBxo3EMkWFvYzqi+W9ouo/riwjJJO4224cQ3B1srviSwp58f1yjXeP/pqwMca/+neFCBcQ9f57Y1qj9cnGTcQ8fmB43q1+SbnXxKC0uM6p3q0Xin3I0SA6r9qMB8vGvuLjSq/2ZzZ+Mekjqa9fDRoa7GPXRIMbteeHvrKUb15Yc9RvWBiI/3Ki4+sPP7wJZbjPf/Q0maUX3nPtuNe9j2idl44e6cZ9xD1xb7jep3pGYY1Zcf9sj8SNbf/G+7B3yN1ynZ7FhJ0h9brTCqv3PX6cY9nNBmn1H9998E4Ycssx9v9NVes+uFcI95T286S/FpgV3jeX0u4/1vTm9uVD+l4xzjHu7fcZFRfcvG5teZO7eZjfu+VmZfC18QvpZOfV2aqrTSwOY04l3mk1Wm+X124xnGPQw/7luj+j9uGGncw96D6Ub1CevMslvuKTaqB2IJ9+AGAAAAAAAAAEQlJrgBAAAAAAAAAFGJCW4AAAAAAAAAQFRyNMH9wAMPyOVy+S0nn3xyqHoDJJE72EP2YAO5gw3kDraQPdhA7mADuQOA0HH8kMlTTjlFixYtOrKBBHvPqUTDQe5gC9mDDeQONpA72EL2YAO5gw3kDogQXq/kCuyh6A2OLzqOk+PRNCEhQW3atAlFL0CtyB1sIXuwgdzBBnIHW8gebCB3sIHcAUBoOL4H9/r169WuXTt16dJFo0eP1rZt2465vsfjUV5ent8COEXuYIuT7JE7BAu5gw2ca2ELYx5sIHewgXMtAISGownugQMHatasWXr33Xc1Y8YMbd68WWeeeaby8/NrrcnOzlZGRkbVkpmZadw0GhZyB1ucZo/cIRjIHWzgXAtbGPNgA7mDDZxrASB0HE1wjxgxQllZWerZs6fOP/98/ec//9GhQ4f0j3/8o9aaSZMmKTc3t2rJyckxbhoNC7mDLU6zR+4QDOQONnCuhS2MebCB3MEGzrUAEDpGTzRo0qSJTjzxRG3YsKHWddxut9xut8luAD/kDrbUlT1yh1Agd7CBcy1sYcyDDeQONnCuBYDgcXwP7qMVFBRo48aNatu2bbD6AepE7mAL2YMN5A42kDvYQvZgA7mDDeQOsMjnY3GyRAFHE9y/+c1vtHTpUm3ZskXLli3TT3/6U8XHx+vKK68MVX8AuYM1ZA82kDvYQO5gC9mDDeQONpA7AAgdR7co2b59u6688kodOHBALVu21BlnnKHly5erZcuWoeoPIHewhuzBBnIHG8gdbCF7sIHcwQZyBwCh42iC+7XXXgtVH0CtyB1sIXuwgdzBBnIHW8gebCB3sIHcAUDoGN2DGwAAAAAAAAAAW5jgBgAAAAAAAABEJUe3KAkm9yEp3h1Y7ScfnmK8/wuHrjCq35LfzLiHsnKz3y98+0Nr4x4+TD/RqL5dwhdG9fnlXqN6p+I3Jys+OTmg2vJW5cb7925qZFTfb8hXxj10SPnBqH7FwY7GPYw4ca1R/fFJe43qD5eafy2d2JPTTHEpgeXu4B7z73NvK7OnHrtXmOVWksouOGBUPyBzq3EPew43Nqo/XJZkVF9aZlTu2Btf9wk4dxd0+9p4/8v/c6pRvdtj3IJKvGlG9WmdzZsYkv6NUf2ajPZG9WUJHn1rtAXnSosSFafEgGq/OtTOeP/9mm0zqv/k3z2Ne0gwvLwp/c5svJKkPanFRvX795j14C0y27/j/ZXES/HxAdV+dqiz8f7T48w+3180W27cw9ULxxnVxwfhrU97NrQwqj+jn9mYWVpYou+MtuDMvs2BX+O5mpYY7z81sdSo/tpvf2ncwzltvjeq/2T5ycY9JBS5jOq9S8x+tvd6wjveSdJ/87vL7QvsXPvpgU7G+9+wsY1RfZPW+cY9vL62r1F9cqr592D8t2bXmm6zH5FUbv4pNFg+r1c+V3jno6KVzxcdx4l3cAMAAAAAAAAAohIT3AAAAAAAAACAqMQENwAAAAAAAAAgKjme4N6xY4euuuoqNW/eXCkpKTr11FO1cuXKUPQGVCF3sIXswQZyBxvIHWwgd7CF7MEGcgcAoeHoIZMHDx7U4MGDdc4552j+/Plq2bKl1q9fr6ZNm4aqP4DcwRqyBxvIHWwgd7CB3MEWsgcbyB0AhI6jCe6HH35YmZmZmjlzZtVrnTubP3UcOBZyB1vIHmwgd7CB3MEGcgdbyB5sIHdABPH5JPlsdxEdfNFxnBzdouStt95Sv379lJWVpVatWql379569tlnj1nj8XiUl5fntwBOkDvY4jR75A7BQO5gA+da2EDuYAvnWtjAmAcAoeNognvTpk2aMWOGunbtqgULFujmm2/W+PHj9cILL9Rak52drYyMjKolMzPTuGk0LOQOtjjNHrlDMJA72MC5FjaQO9jCuRY2MOYBQOg4muD2er3q06ePHnroIfXu3Vu//vWvdcMNN+ipp56qtWbSpEnKzc2tWnJycoybRsNC7mCL0+yROwQDuYMNnGthA7mDLZxrYQNjHgCEjqMJ7rZt26p79+5+r3Xr1k3btm2rtcbtdqtx48Z+C+AEuYMtTrNH7hAM5A42cK6FDeQOtnCuhQ2MeQAQOo4muAcPHqzvvvvO77Xvv/9eHTt2DGpTwNHIHWwhe7CB3MEGcgcbyB1sIXuwgdwBQOg4muC+/fbbtXz5cj300EPasGGDZs+erWeeeUZjx44NVX8AuYM1ZA82kDvYQO5gA7mDLWQPNpA7IIJ4fSxOlijgaIK7f//+mjNnjl599VX16NFDf/rTnzRt2jSNHj06VP0B5A7WkD3YQO5gA7mDDeQOtpA92EDuACB0EpwWXHTRRbroootC0QtQK3IHW8gebCB3sIHcwQZyB1vIHmwgdwAQGo7ewQ0AAAAAAAAAQKRw/A7uYGn11KdKcCUGVLvzN6cb7/+dxf2N6n3HFRv3UJ4f2Odf6bAvzbiHdc3bGdX/y1VuVF9cUCZpr9E2nEjMdym+xBVQbcf7PjPe//dPDjCq/2DJqcY9jLngfaP6vYWNjHt4YfNPjOpPaLLfqL60sETSt0bbcCJ5V4Li3YENt2Up5ve76nzvJ0b1e8abj7mbl3Uwqs/plmfcQ3FOulG9N9lrVl9kft5wwlcSJ198YL/HXvSfvsb7TzxsVt/ukWXGPewdZ5bdJQtPM+5hWffORvWHNzc2qvcWhzd3kpSwP1FxyYFd4ySdYHZdIUlvvH2GUX2j/ebjbounzcbdXRPNx91Dn7Q2qo8/qcio3uU1/1o6UhInBTjmfXuglfHuDxSbXZdvWvVT4x4SCwO7xq2U+aD5uLtp8iCj+pXv9DCqL/eEd8w7odsOJaS5A6rdeqCZ8f63bjLLbqPWBcY9vPb2WUb1CWaXV5KkTr83G3MPXG+W27iS8N+f1h1XquQA366YklBqvP/4RmbbyN2aYdxDk06HjOo9y5sb95C2z+xr3/xZs+yW+cy/lkCs4B3cAAAAAAAAAICoZO0d3AAAAAAAAAAQVj6fpCD8CUlD4Av/X6kEgndwAwAAAAAAAACikqMJ7k6dOsnlclVbxo4da9TEL31fa7RvXY0fG+1bp1/6vjbaPqJfqLJniuzGtkjNnSlyG9liNXfBQHZDh9yFFtmtHdmLbLGaXXIX+yIxu+QOdYnE3ALRwtEE94oVK7Rr166qZeHChZKkrKwsoya8cukarav2jTzat07XaJ28MntgCqJfqLJniuzGtkjNnSlyG9liNXfBQHZDh9yFFtmtHdmLbLGaXXIX+yIxu+QOdYnE3ALRwtE9uFu2bOn378mTJ+v444/X2WefbdTEK67ukk+6RuskX8W/K7+BZ6l7xcfRoIUqe6bIbmyL1NyZIreRLVZzFwxkN3TIXWiR3dqRvcgWq9kld7EvErNL7lCXSMwtEC0CfshkSUmJXn75ZU2cOFEuV+2/RfJ4PPJ4PFX/zsvLq3G9o7+Rf+H7Vkny8g2MGtUne/XNXTCQ3YYh0nJnitxGh1jLXTCQ3dAL9jUeKpDdujHmRaZYzy65i12RnF3OtahNJOcWiGQBP2Ry7ty5OnTokK655ppjrpedna2MjIyqJTMzs9Z1X3F1V4nilCSvShTHNzBqVJ/sOcldMJDd2BeJuTNFbiNfLOYuGMhuaIXiGg8VyO6xMeZFrljOLrmLbZGaXc61/9/e3YTWVaZxAH/ubc29C002YkM14EYQRrHgR60bHRCLdDGd2RQZsKhrEbKyIsadK8GFggjSxYAoQqcDIoIt42KwIH5sZHAnNiKpukk0mubjHBch6WR6m97kPfd85feDLHp63nOf897/fc/Je07OZTt1zW2b5FnuZwc/TbDrCe633347Hn/88Th48OC26506dSrm5+c3f2ZnZ6+57t/z/25+gMciu+bD9dnbhsneTnJXBNltvzrmLpXc1l8bc1cE2R2tUZzjsU52t2fMq682Z1fu2q2u2XWsZTt1zS3U2a4eUfLdd9/FuXPn4syZM9ddt9frRa/Xu+56//9coY1/bzx3CCKGz96wuSuC7LZfHXOXSm7rr425K4LsjtYozvFYJ7vbM+bVV5uzK3ftVtfsOtaynbrmFupuVxPcp0+fjltuuSWOHTtWSBGDHpo/6OH6UHT2Usnu3lC33KWS22ZoW+6KILujJ3ejIbvXJ3v11Pbsyl171Tm7cse11Dm3UHc7nuDOsixOnz4dJ0+ejP37d/0dlVt0Ix/40PyND3I3mvG8F0ZrFNlLJbvtV8fcpZLb+mtj7oogu6Mld6Mju9uTvfpqc3blrt3qml25Yzt1zS00wY5H1HPnzsXFixfj6aefLqyIf3T+dM3/c3WKDaPIXirZbb865i6V3NZfG3NXBNkdLbkbHdndnuzVV5uzK3ftVtfsyh3bqWtuoQl2PMH92GOPRZ67akT5ZI8qyB1VkDuqIHdURfaogtxRBbmDmsiziMiqrqIZ8mb0U7fqAgAAAAAAYDdKf+jTxtXK1ViJ3T4+aO3yUnId2VLaVdP8twJq+H0tbQMFXPhd/nU5qf1SZzWt/a/r7Ud9FXtj+ynZWc1XkuvIfk/LTba0L7mGpV/T9mPtt8vJNaRauSEttyuL6+3Lyl2WkLusk15janbrMOYWkbts6Ya09olXrrOl9X4sLXcJ483aUvpV+m7iW1bEmLu2nDrmpr9XqdndyE1q+zLuFtvMXkLNG+NzitQ+W0svoRbj7lrakBdZ4rlu9vt69ksb8xLe9yKOMatR7Wc9ImLtciepfSHnuqmfv8R92DjnKit3q7/tfsBYK+T3ybT+Kub8KnE/CrgxMHnMTTxf2Ghf5rH28uLufw8v5FibfIyo/hyrkGPtctp+pGZ3Ndbb+6sAiOjkJX8Svv/++5iamirzJWmA2dnZuO2220a2fbljELmjCnJHFUaduwjZYzBjHlWQO6rgWEtVysheWywsLMTExET8ed/fYn8n8W6APWI1X4l/r52J+fn5GB8fr7qcayp9gjvLsvjhhx/ipptuik7n6ivOCwsLMTU1FbOzs7vquNT2aii3hjzP45dffomDBw9Gtzu6J+aMOndFbEMN5dUgd2qoooa65G6YWq9nr7xnbaihrNxFGPOa0r6sGuoy5jWlv9RQzDbqkrthar2evfKetaGGNh1rm9DfariizOy1hQnunWvKBHfpjyjpdrtDXVkaHx9P6rjU9moor4aJiYldb3tYZeWuiG2ooZwa5E4NVdRQp9xF1L+/1FBM+zJyF2HMa1r7Mmqo05jXhP5SQzHbqFPuIurfX2oopn3bjrV17281XFFW9qDuSp/gBgAAAACoQp7lkRfwfVd7QVOe8e5vGAAAAAAAaKTaTXD3er2YmZmJXq9XSXs11KuGsrSlv9RQ3DbKUId9VUN9aihTG/pLDcXVUJa29FfVNbRhH8rUlv5SQ3HbKEsb+ksNxdVQljrsqxrqUwPsJaV/ySQAAAAAQJk2vmTykc5ffcnkkFbzlfgk/2ftv2SydndwAwAAAADAMExwAwAAAADQSPurLgAAAAAAoBR5FhFZ1VU0Q96MfnIHNwAAAAAAjWSCGwAAAACARjLBDQAAAABAId544424/fbbo9/vx+HDh+Ozzz7bdv33338/7rzzzuj3+3H33XfHhx9+uKPXM8ENAAAAAECy9957L6anp2NmZia+/PLLuOeee+Lo0aPx448/Dlz/008/jSeeeCKeeeaZ+Oqrr+L48eNx/Pjx+Prrr4d+zU6e53lROwAAAAAAUDcLCwsxMTERj8RfYn/nhqrLaYTVfCU+iX/F/Px8jI+PD9Xm8OHDcf/998frr78eERFZlsXU1FQ8++yz8fzzz1+1/okTJ2JxcTE++OCDzWUPPvhgHDp0KN58882hXnP/UGsBAAAAADTcaqxEuN13KKuxEhHrFwf+V6/Xi16vd9X6y8vL8cUXX8SpU6c2l3W73Xj00UfjwoULA1/jwoULMT09vWXZ0aNH4+zZs0PXaYIbAAAAAGi1sbGxmJycjP/M7ez5znvdjTfeGFNTU1uWzczMxMsvv3zVuj///HOsra3FgQMHtiw/cOBAfPPNNwO3Pzc3N3D9ubm5oWs0wQ0AAAAAtFq/349vv/02lpeXqy6lUfI8j06ns2XZoLu3q2SCGwAAAABovX6/H/1+v+oyWuvmm2+Offv2xaVLl7Ysv3TpUkxOTg5sMzk5uaP1B+nuvFQAAAAAALhibGws7r333jh//vzmsizL4vz583HkyJGBbY4cObJl/YiIjz/++JrrD+IObgAAAAAAkk1PT8fJkyfjvvvuiwceeCBee+21WFxcjKeeeioiIp588sm49dZb45VXXomIiOeeey4efvjhePXVV+PYsWPx7rvvxueffx5vvfXW0K9pghsAAAAAgGQnTpyIn376KV566aWYm5uLQ4cOxUcffbT5RZIXL16MbvfKQ0UeeuiheOedd+LFF1+MF154Ie644444e/Zs3HXXXUO/ZifP87zwPQEAAAAAgBHzDG4AAAAAABrJBDcAAAAAAI1kghsAAAAAgEYywQ0AAAAAQCOZ4AYAAAAAoJFMcAMAAAAA0EgmuAEAAAAAaCQT3AAAAAAANJIJbgAAAAAAGskENwAAAAAAjWSCGwAAAACARvoDMzAyKr434jYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_distance_grid(distance_grid, embedding_metric=distances_result[\"embedding_metric\"], show=False)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_distance_correlation(\n", + " distance_grid,\n", + " embedding_metric=distances_result[\"embedding_metric\"],\n", + " coordinate_metric=distances_result[\"coordinate_metric\"],\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "maze-transformer", + "language": "python", + "name": "maze-transformer" + }, + "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.1" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/train_model.ipynb b/notebooks/train_model.ipynb index 4aa6ab52..f825a713 100644 --- a/notebooks/train_model.ipynb +++ b/notebooks/train_model.ipynb @@ -42,7 +42,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "DEVICE = device(type='cpu')\n" + "DEVICE = device(type='cuda')\n" ] } ], @@ -69,7 +69,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "list(MAZE_DATASET_CONFIGS.keys()) = ['test-g3-n5-a_dfs-h81250', 'demo_small-g3-n100-a_dfs-h12257', 'demo-g6-n10K-a_dfs-h76502']\n" + "list(MAZE_DATASET_CONFIGS.keys()) = ['test-g3-n5-a_dfs-h75556', 'demo_small-g3-n100-a_dfs-h88371', 'demo-g6-n10K-a_dfs-h30615']\n" ] } ], @@ -109,6 +109,46 @@ " eval_slow=5,\n", " )\n", " ),\n", + ")\n", + "\n", + "CFG_HALLWAY: ConfigHolder = ConfigHolder(\n", + " name = \"hallway-medium\",\n", + " dataset_cfg = MazeDatasetConfig(\n", + "\t\tname=\"custom-hallway\",\n", + "\t\tgrid_n=8,\n", + "\t\tn_mazes=1_000,\n", + "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", + " maze_ctor_kwargs=dict(\n", + " do_forks=False,\n", + " ),\n", + " applied_filters=[{'name': 'collect_generation_meta', 'args': (), 'kwargs': {}}],\n", + " seq_len_max=256,\n", + "\t),\n", + " model_cfg = BaseGPTConfig(\n", + " name=\"custom-model\",\n", + " act_fn=\"gelu\",\n", + " d_model=128,\n", + " d_head=32,\n", + " n_layers=6,\n", + " ),\n", + " train_cfg = TrainConfig(\n", + " name=\"custom-train\",\n", + " optimizer=torch.optim.AdamW,\n", + " optimizer_kwargs=dict(lr=0.001),\n", + " batch_size=32,\n", + " dataloader_cfg=dict(\n", + " shuffle=False,\n", + " num_workers=8,\n", + " drop_last=False,\n", + " ),\n", + " intervals_count=dict(\n", + " print_loss=100,\n", + " checkpoint=20,\n", + " eval_fast=100,\n", + " eval_slow=50,\n", + " ),\n", + " validation_dataset_cfg=100,\n", + " ),\n", ")" ] }, @@ -120,12 +160,12 @@ "source": [ "# this is for training a \"real\" demo model\n", "CFG_DEMO: ConfigHolder = ConfigHolder.get_config_multisource(\n", - " cfg_names=(\"test-g3-n5-a_dfs-h81250\", \"tiny-v1\", \"sweep-v1\"),\n", + " cfg_names=(\"test-g3-n5-a_dfs-h75556\", \"tiny-v1\", \"sweep-v1\"),\n", ")\n", "\n", "# this is smaller, for testing\n", "CFG_TEST: ConfigHolder = ConfigHolder.get_config_multisource(\n", - " cfg_names=(\"demo_small-g3-n100-a_dfs-h12257\", \"nano-v1\", \"test-v1\"),\n", + " cfg_names=(\"demo_small-g3-n100-a_dfs-h88371\", \"nano-v1\", \"test-v1\"),\n", ")" ] }, @@ -149,11 +189,11 @@ "output_type": "stream", "text": [ "{\n", - " \"name\": \"multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1\",\n", + " \"name\": \"multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1\",\n", " \"dataset_cfg\": {\n", " \"name\": \"demo_small\",\n", - " \"fname\": \"demo_small-g3-n100-a_dfs-h12257\",\n", - " \"sdc_hash\": 30996747242069450216004090068458786635717548199848876593027637690799325012257,\n", + " \"fname\": \"demo_small-g3-n100-a_dfs-h88371\",\n", + " \"sdc_hash\": 84259447430412521190944379321942049596003348447446024033060470193755008588371,\n", " \"seed\": 42,\n", " \"seq_len_min\": 1,\n", " \"seq_len_max\": 512,\n", @@ -224,37 +264,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "seeing if we can download the dataset...\n", - "no download found, or download failed\n", - "generating dataset...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 100/100 [00:00<00:00, 1244.99maze/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\demo_small-g3-n100-a_dfs-h12257.zanj\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Got dataset demo_small with 100 items. output.cfg.to_fname() = 'demo_small-g3-n100-a_dfs-h12257'\n" + "trying to get the dataset 'demo_small-g3-n100-a_dfs-h88371'\n", + "loading dataset from ../data/demo_small-g3-n100-a_dfs-h88371.zanj\n", + "Got dataset demo_small with 100 items. output.cfg.to_fname() = 'demo_small-g3-n100-a_dfs-h88371'\n" ] } ], @@ -276,7 +288,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-08-05 13:54:32 ERROR Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n" + "2023-10-01 01:39:19 ERROR Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n" ] }, { @@ -289,7 +301,7 @@ { "data": { "text/html": [ - "wandb version 0.15.8 is available! To upgrade, please run:\n", + "wandb version 0.15.11 is available! To upgrade, please run:\n", " $ pip install wandb --upgrade" ], "text/plain": [ @@ -314,7 +326,7 @@ { "data": { "text/html": [ - "Run data is saved locally in f:\\KNC\\maze-transformer\\notebooks\\wandb\\run-20230805_135435-jqd6f6on" + "Run data is saved locally in f:\\KNC\\maze-transformer\\notebooks\\wandb\\run-20231001_013922-hmws159z" ], "text/plain": [ "" @@ -326,7 +338,7 @@ { "data": { "text/html": [ - "Syncing run azure-meadow-223 to Weights & Biases (docs)
" + "Syncing run ruby-surf-7 to Weights & Biases (docs)
" ], "text/plain": [ "" @@ -338,7 +350,7 @@ { "data": { "text/html": [ - " View project at https://wandb.ai/miv/integration-tests" + " View project at https://wandb.ai/miv/understanding-search" ], "text/plain": [ "" @@ -350,7 +362,7 @@ { "data": { "text/html": [ - " View run at https://wandb.ai/miv/integration-tests/runs/jqd6f6on" + " View run at https://wandb.ai/miv/understanding-search/runs/hmws159z" ], "text/plain": [ "" @@ -363,25 +375,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-08-05 13:54:37 INFO config ={'__format__': 'ConfigHolder(SerializableDataclass)', 'dataset_cfg': {'__format__': 'MazeDatasetConfig(SerializableDataclass)', 'name': 'demo_small', 'seq_len_min': 1, 'seq_len_max': 512, 'seed': 42, 'applied_filters': [], 'grid_n': 3, 'n_mazes': 100, 'maze_ctor': {'__name__': 'gen_dfs', '__module__': 'maze_dataset.generation.generators', '__doc__': ['generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `n_accessible_cells: int | None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid.', ' (default: `None`)', ' - `max_tree_depth: int | None`: the maximum depth of the tree. If `None`, defaults to `2 * n_accessible_cells`.', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' '], 'source_code': [' @staticmethod', ' def gen_dfs(', ' grid_shape: Coord,', ' lattice_dim: int = 2,', ' n_accessible_cells: int | None = None,', ' max_tree_depth: int | None = None,', ' do_forks: bool = True,', ' start_coord: Coord | None = None,', ' ) -> LatticeMaze:', ' \"\"\"generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `n_accessible_cells: int | None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid.', ' (default: `None`)', ' - `max_tree_depth: int | None`: the maximum depth of the tree. If `None`, defaults to `2 * n_accessible_cells`.', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' \"\"\"', '', ' # Default values if no constraints have been passed', ' grid_shape: Coord = np.array(grid_shape)', ' n_total_cells: int = int(np.prod(grid_shape))', ' if n_accessible_cells is None:', ' n_accessible_cells = n_total_cells', ' if max_tree_depth is None:', ' max_tree_depth = (', ' 2 * n_total_cells', ' ) # We define max tree depth counting from the start coord in two directions. Therefore we divide by two in the if clause for neighboring sites later and multiply by two here.', '', ' start_coord = _random_start_coord(grid_shape, start_coord)', '', ' # initialize the maze with no connections', ' connection_list: ConnectionList = np.zeros(', ' (lattice_dim, grid_shape[0], grid_shape[1]), dtype=np.bool_', ' )', '', ' # initialize the stack with the target coord', ' visited_cells: set[tuple[int, int]] = set()', ' visited_cells.add(tuple(start_coord))', ' stack: list[Coord] = [start_coord]', '', ' # initialize tree_depth_counter', ' current_tree_depth: int = 1', '', ' # loop until the stack is empty or n_connected_cells is reached', ' while stack and (len(visited_cells) < n_accessible_cells):', ' # get the current coord from the stack', ' current_coord: Coord = stack.pop()', '', ' # filter neighbors by being within grid bounds and being unvisited', ' unvisited_neighbors_deltas: list[tuple[Coord, Coord]] = [', ' (neighbor, delta)', ' for neighbor, delta in zip(', ' current_coord + NEIGHBORS_MASK, NEIGHBORS_MASK', ' )', ' if (', ' (tuple(neighbor) not in visited_cells)', ' and (0 <= neighbor[0] < grid_shape[0])', ' and (0 <= neighbor[1] < grid_shape[1])', ' )', ' ]', '', \" # don't continue if max_tree_depth/2 is already reached (divide by 2 because we can branch to multiple directions)\", ' if unvisited_neighbors_deltas and (', ' current_tree_depth <= max_tree_depth / 2', ' ):', \" # if we want a maze without forks, simply don't add the current coord back to the stack\", ' if do_forks:', ' stack.append(current_coord)', '', ' # choose one of the unvisited neighbors', ' chosen_neighbor, delta = random.choice(unvisited_neighbors_deltas)', '', ' # add connection', ' dim: int = np.argmax(np.abs(delta))', ' # if positive, down/right from current coord', ' # if negative, up/left from current coord (down/right from neighbor)', ' clist_node: Coord = (', ' current_coord if (delta.sum() > 0) else chosen_neighbor', ' )', ' connection_list[dim, clist_node[0], clist_node[1]] = True', '', ' # add to visited cells and stack', ' visited_cells.add(tuple(chosen_neighbor))', ' stack.append(chosen_neighbor)', '', ' # Update current tree depth', ' current_tree_depth += 1', ' else:', ' current_tree_depth -= 1', '', ' return LatticeMaze(', ' connection_list=connection_list,', ' generation_meta=dict(', ' func_name=\"gen_dfs\",', ' grid_shape=grid_shape,', ' start_coord=start_coord,', ' n_accessible_cells=int(n_accessible_cells),', ' max_tree_depth=int(max_tree_depth),', ' fully_connected=bool(len(visited_cells) == n_accessible_cells),', ' visited_cells={tuple(int(x) for x in coord) for coord in visited_cells},', ' ),', ' )']}, 'maze_ctor_kwargs': {}, 'grid_shape': (3, 3)}, 'model_cfg': {'__format__': 'BaseGPTConfig(SerializableDataclass)', 'name': 'nano-v1', 'act_fn': 'gelu', 'd_model': 8, 'd_head': 4, 'n_layers': 2, 'weight_processing': {'are_layernorms_folded': False, 'are_weights_processed': False}, 'n_heads': 2}, 'train_cfg': {'__format__': 'TrainConfig(SerializableDataclass)', 'name': 'test-v1', 'evals_max_new_tokens': 8, 'validation_dataset_cfg': 1, 'optimizer': 'RMSprop', 'optimizer_kwargs': {'lr': 0.0001}, 'batch_size': 16, 'dataloader_cfg': {'shuffle': True, 'num_workers': 0, 'drop_last': False}, 'intervals': None, 'intervals_count': {'print_loss': 100, 'checkpoint': 2, 'eval_fast': 4, 'eval_slow': 2}}, 'name': 'multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1', 'pretrainedtokenizer_kwargs': None, 'maze_tokenizer': {'__format__': 'MazeTokenizer(SerializableDataclass)', 'tokenization_mode': 'AOTP_UT_uniform', 'max_grid_size': 3, 'name': 'maze_tokenizer-AOTP_UT_uniform-g3', 'token_arr': ['', '', '', '', '', '', '', '', '<-->', ';', '', '(0,0)', '(0,1)', '(1,0)', '(1,1)', '(0,2)', '(2,0)', '(1,2)', '(2,1)', '(2,2)'], 'tokenizer_map': {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '<-->': 8, ';': 9, '': 10, '(0,0)': 11, '(0,1)': 12, '(1,0)': 13, '(1,1)': 14, '(0,2)': 15, '(2,0)': 16, '(1,2)': 17, '(2,1)': 18, '(2,2)': 19}, 'vocab_size': 20, 'padding_token_index': 10}}\n", - "2023-08-05 13:54:37 INFO Initialized logger\n", - "2023-08-05 13:54:37 INFO Summary logged, getting dataset\n", - "loading dataset from ../data/demo_small-g3-n100-a_dfs-h12257.zanj\n", - "Got dataset demo_small with 100 items. output.cfg.to_fname() = 'demo_small-g3-n100-a_dfs-h12257'\n", - "2023-08-05 13:54:37 INFO finished getting training dataset with 100 samples\n", - "2023-08-05 13:54:37 INFO got validation dataset by splitting training dataset into 99 train and 1 validation samples\n", - "2023-08-05 13:54:37 INFO Loaded 99 sequences\n", - "2023-08-05 13:54:37 INFO Creating dataloader\n", - "2023-08-05 13:54:37 INFO finished dataloader, passing to train()\n", - "2023-08-05 13:54:37 INFO Initializing model\n", - "Moving model to device: cpu\n", - "2023-08-05 13:54:37 INFO Initializing optimizer\n", - "2023-08-05 13:54:37 INFO will train for 7 batches, evals_enabled=True, with intervals: {'print_loss': inf, 'checkpoint': 3, 'eval_fast': 1, 'eval_slow': 3}\n", - "2023-08-05 13:54:37 INFO Starting training\n", - "2023-08-05 13:54:37 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:37 INFO Running evals: eval_slow\n", - "2023-08-05 13:54:37 INFO iteration 0/7: loss=3.308\n", - "2023-08-05 13:54:37 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1_2023-08-05-13-54-30/checkpoints/model.iter_0.zanj\n" + "2023-10-01 01:39:23 INFO config ={'__format__': 'ConfigHolder(SerializableDataclass)', 'dataset_cfg': {'__format__': 'MazeDatasetConfig(SerializableDataclass)', 'name': 'demo_small', 'seq_len_min': 1, 'seq_len_max': 512, 'seed': 42, 'applied_filters': [], 'grid_n': 3, 'n_mazes': 100, 'maze_ctor': {'__name__': 'gen_dfs', '__module__': 'maze_dataset.generation.generators', '__doc__': ['generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `accessible_cells: int | float |None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid. if a float, asserts it is <= 1 and treats it as a proportion of **total cells**', ' (default: `None`)', ' - `max_tree_depth: int | float | None`: the maximum depth of the tree. If `None`, defaults to `2 * accessible_cells`. if a float, asserts it is <= 1 and treats it as a proportion of the **sum of the grid shape**', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' '], 'source_code': [' @staticmethod', ' def gen_dfs(', ' grid_shape: Coord,', ' lattice_dim: int = 2,', ' accessible_cells: int | float | None = None,', ' max_tree_depth: int | float | None = None,', ' do_forks: bool = True,', ' randomized_stack: bool = False,', ' start_coord: Coord | None = None,', ' ) -> LatticeMaze:', ' \"\"\"generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `accessible_cells: int | float |None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid. if a float, asserts it is <= 1 and treats it as a proportion of **total cells**', ' (default: `None`)', ' - `max_tree_depth: int | float | None`: the maximum depth of the tree. If `None`, defaults to `2 * accessible_cells`. if a float, asserts it is <= 1 and treats it as a proportion of the **sum of the grid shape**', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' \"\"\"', '', ' # Default values if no constraints have been passed', ' grid_shape: Coord = np.array(grid_shape)', ' n_total_cells: int = int(np.prod(grid_shape))', '', ' n_accessible_cells: int', ' if accessible_cells is None:', ' n_accessible_cells = n_total_cells', ' elif isinstance(accessible_cells, float):', ' assert (', ' accessible_cells <= 1', ' ), f\"accessible_cells must be an int (count) or a float in the range [0, 1] (proportion), got {accessible_cells}\"', '', ' n_accessible_cells = int(accessible_cells * n_total_cells)', ' else:', ' assert isinstance(accessible_cells, int)', ' n_accessible_cells = accessible_cells', '', ' if max_tree_depth is None:', ' max_tree_depth = (', ' 2 * n_total_cells', ' ) # We define max tree depth counting from the start coord in two directions. Therefore we divide by two in the if clause for neighboring sites later and multiply by two here.', ' elif isinstance(max_tree_depth, float):', ' assert (', ' max_tree_depth <= 1', ' ), f\"max_tree_depth must be an int (count) or a float in the range [0, 1] (proportion), got {max_tree_depth}\"', '', ' max_tree_depth = int(max_tree_depth * np.sum(grid_shape))', '', ' # choose a random start coord', ' start_coord = _random_start_coord(grid_shape, start_coord)', '', ' # initialize the maze with no connections', ' connection_list: ConnectionList = np.zeros(', ' (lattice_dim, grid_shape[0], grid_shape[1]), dtype=np.bool_', ' )', '', ' # initialize the stack with the target coord', ' visited_cells: set[tuple[int, int]] = set()', ' visited_cells.add(tuple(start_coord)) # this wasnt a bug after all lol', ' stack: list[Coord] = [start_coord]', '', ' # initialize tree_depth_counter', ' current_tree_depth: int = 1', '', ' # loop until the stack is empty or n_connected_cells is reached', ' while stack and (len(visited_cells) < n_accessible_cells):', ' # get the current coord from the stack', ' current_coord: Coord', ' if randomized_stack:', ' current_coord = stack.pop(random.randint(0, len(stack) - 1))', ' else:', ' current_coord = stack.pop()', '', ' # filter neighbors by being within grid bounds and being unvisited', ' unvisited_neighbors_deltas: list[tuple[Coord, Coord]] = [', ' (neighbor, delta)', ' for neighbor, delta in zip(', ' current_coord + NEIGHBORS_MASK, NEIGHBORS_MASK', ' )', ' if (', ' (tuple(neighbor) not in visited_cells)', ' and (0 <= neighbor[0] < grid_shape[0])', ' and (0 <= neighbor[1] < grid_shape[1])', ' )', ' ]', '', \" # don't continue if max_tree_depth/2 is already reached (divide by 2 because we can branch to multiple directions)\", ' if unvisited_neighbors_deltas and (', ' current_tree_depth <= max_tree_depth / 2', ' ):', \" # if we want a maze without forks, simply don't add the current coord back to the stack\", ' if do_forks and (len(unvisited_neighbors_deltas) > 1):', ' stack.append(current_coord)', '', ' # choose one of the unvisited neighbors', ' chosen_neighbor, delta = random.choice(unvisited_neighbors_deltas)', '', ' # add connection', ' dim: int = np.argmax(np.abs(delta))', ' # if positive, down/right from current coord', ' # if negative, up/left from current coord (down/right from neighbor)', ' clist_node: Coord = (', ' current_coord if (delta.sum() > 0) else chosen_neighbor', ' )', ' connection_list[dim, clist_node[0], clist_node[1]] = True', '', ' # add to visited cells and stack', ' visited_cells.add(tuple(chosen_neighbor))', ' stack.append(chosen_neighbor)', '', ' # Update current tree depth', ' current_tree_depth += 1', ' else:', ' current_tree_depth -= 1', '', ' output = LatticeMaze(', ' connection_list=connection_list,', ' generation_meta=dict(', ' func_name=\"gen_dfs\",', ' grid_shape=grid_shape,', ' start_coord=start_coord,', ' n_accessible_cells=int(n_accessible_cells),', ' max_tree_depth=int(max_tree_depth),', \" # oh my god this took so long to track down. its almost 5am and I've spent like 2 hours on this bug\", ' # it was checking that len(visited_cells) == n_accessible_cells, but this means that the maze is', ' # treated as fully connected even when it is most certainly not, causing solving the maze to break', ' fully_connected=bool(len(visited_cells) == n_total_cells),', ' visited_cells={tuple(int(x) for x in coord) for coord in visited_cells},', ' ),', ' )', '', ' return output']}, 'maze_ctor_kwargs': {}, 'grid_shape': (3, 3)}, 'model_cfg': {'__format__': 'BaseGPTConfig(SerializableDataclass)', 'name': 'nano-v1', 'act_fn': 'gelu', 'd_model': 8, 'd_head': 4, 'n_layers': 2, 'weight_processing': {'are_layernorms_folded': False, 'are_weights_processed': False}, 'n_heads': 2}, 'train_cfg': {'__format__': 'TrainConfig(SerializableDataclass)', 'name': 'test-v1', 'evals_max_new_tokens': 8, 'validation_dataset_cfg': 1, 'optimizer': 'RMSprop', 'optimizer_kwargs': {'lr': 0.0001}, 'batch_size': 16, 'dataloader_cfg': {'shuffle': True, 'num_workers': 0, 'drop_last': False}, 'intervals': None, 'intervals_count': {'print_loss': 100, 'checkpoint': 2, 'eval_fast': 4, 'eval_slow': 2}}, 'name': 'multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1', 'pretrainedtokenizer_kwargs': None, 'maze_tokenizer': {'__format__': 'MazeTokenizer(SerializableDataclass)', 'tokenization_mode': 'AOTP_UT_uniform', 'max_grid_size': 3, 'name': 'maze_tokenizer-AOTP_UT_uniform-g3', 'token_arr': ['', '', '', '', '', '', '', '', '<-->', ';', '', '(0,0)', '(0,1)', '(1,0)', '(1,1)', '(0,2)', '(2,0)', '(1,2)', '(2,1)', '(2,2)'], 'tokenizer_map': {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '<-->': 8, ';': 9, '': 10, '(0,0)': 11, '(0,1)': 12, '(1,0)': 13, '(1,1)': 14, '(0,2)': 15, '(2,0)': 16, '(1,2)': 17, '(2,1)': 18, '(2,2)': 19}, 'vocab_size': 20, 'padding_token_index': 10}}\n", + "2023-10-01 01:39:23 INFO Initialized logger\n", + "2023-10-01 01:39:23 INFO Summary logged, getting dataset\n", + "trying to get the dataset 'demo_small-g3-n100-a_dfs-h88371'\n", + "loading dataset from ../data/demo_small-g3-n100-a_dfs-h88371.zanj\n", + "Got dataset demo_small with 100 items. output.cfg.to_fname() = 'demo_small-g3-n100-a_dfs-h88371'\n", + "2023-10-01 01:39:23 INFO finished getting training dataset with 100 samples\n", + "2023-10-01 01:39:23 INFO got validation dataset by splitting training dataset into 99 train and 1 validation samples\n", + "2023-10-01 01:39:23 INFO Loaded 99 sequences\n", + "2023-10-01 01:39:23 INFO Creating dataloader\n", + "2023-10-01 01:39:23 INFO finished dataloader, passing to train()\n", + "2023-10-01 01:39:23 INFO Initializing model\n", + "Moving model to device: cuda\n", + "2023-10-01 01:39:24 INFO Initializing optimizer\n", + "2023-10-01 01:39:24 INFO will train for 7 batches, evals_enabled=True, with intervals: {'print_loss': inf, 'checkpoint': 3, 'eval_fast': 1, 'eval_slow': 3}\n", + "2023-10-01 01:39:24 INFO Starting training\n", + "2023-10-01 01:39:24 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:24 INFO Running evals: eval_slow\n", + "2023-10-01 01:39:24 INFO iteration 0/7: loss=3.308\n", + "2023-10-01 01:39:24 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1_2023-10-01-01-39-19/checkpoints/model.iter_0.zanj\n" ] }, { @@ -399,18 +412,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-08-05 13:54:37 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_slow\n", - "2023-08-05 13:54:38 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1_2023-08-05-13-54-30/checkpoints/model.iter_3.zanj\n", - "2023-08-05 13:54:38 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_fast\n", - "2023-08-05 13:54:38 INFO Running evals: eval_slow\n", - "2023-08-05 13:54:38 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1_2023-08-05-13-54-30/checkpoints/model.iter_6.zanj\n", - "2023-08-05 13:54:38 INFO Saving final model to ../data/multsrc_demo_small-g3-n100-a_dfs-h12257_nano-v1_test-v1_2023-08-05-13-54-30/model.final.zanj\n", - "2023-08-05 13:54:39 INFO Done training!\n" + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_slow\n", + "2023-10-01 01:39:25 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1_2023-10-01-01-39-19/checkpoints/model.iter_3.zanj\n", + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_fast\n", + "2023-10-01 01:39:25 INFO Running evals: eval_slow\n", + "2023-10-01 01:39:25 INFO Saving model checkpoint to ../data/multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1_2023-10-01-01-39-19/checkpoints/model.iter_6.zanj\n", + "2023-10-01 01:39:25 INFO Saving final model to ../data/multsrc_demo_small-g3-n100-a_dfs-h88371_nano-v1_test-v1_2023-10-01-01-39-19/model.final.zanj\n", + "2023-10-01 01:39:25 INFO Done training!\n" ] } ], @@ -418,7 +431,7 @@ "result: TrainingResult = train_model(\n", "\tbase_path=PATH_DATA,\n", " cfg=CFG,\n", - "\twandb_project=WandbProject.INTEGRATION_TESTS, # change this to WandbProject.DEMO_NOTEBOOKS!\n", + "\twandb_project=WandbProject.UNDERSTANDING_SEARCH, # change this to WandbProject.DEMO_NOTEBOOKS!\n", "\tdo_generate_dataset=False,\n", "\tdataset_verbose=True,\n", ")" diff --git a/notebooks/train_model_hallway.ipynb b/notebooks/train_model_hallway.ipynb deleted file mode 100644 index e5b2cd82..00000000 --- a/notebooks/train_model_hallway.ipynb +++ /dev/null @@ -1,496 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Generic\n", - "import typing\n", - "import os\n", - "from pathlib import Path\n", - "import typing\n", - "import json\n", - "\n", - "# Plotting\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Numerical Computing\n", - "import numpy as np\n", - "import torch\n", - "\n", - "# muutils\n", - "from zanj.zanj import ZANJ, ZANJ_GLOBAL_DEFAULTS\n", - "\n", - "# Our Code\n", - "from muutils.nbutils.configure_notebook import configure_notebook\n", - "from maze_transformer.training.config import ConfigHolder, ZanjHookedTransformer, BaseGPTConfig, TrainConfig\n", - "from maze_dataset import MazeDataset, MazeDatasetConfig\n", - "from maze_dataset.dataset.configs import MAZE_DATASET_CONFIGS\n", - "from maze_dataset.generation import LatticeMazeGenerators\n", - "from maze_transformer.training.train_model import TrainingResult, train_model\n", - "from maze_transformer.training.wandb_logger import WandbProject\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DEVICE = device(type='cpu')\n" - ] - } - ], - "source": [ - "# set global defaults for ZANJ\n", - "ZANJ_GLOBAL_DEFAULTS.external_array_threshold = 1024\n", - "ZANJ_GLOBAL_DEFAULTS.external_list_threshold = 1024\n", - "\n", - "# paths\n", - "PATH_EXAMPLES: Path = Path(\"../examples/\")\n", - "PATH_DATA: Path = Path(\"../data/\")\n", - "\n", - "# reproducibility and device\n", - "DEVICE = configure_notebook(seed=42, dark_mode=True)\n", - "print(f\"{DEVICE = }\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "list(MAZE_DATASET_CONFIGS.keys()) = ['test-g3-n5-a_dfs-h81250', 'demo_small-g3-n100-a_dfs-h12257', 'demo-g6-n10K-a_dfs-h76502']\n" - ] - } - ], - "source": [ - "print(f\"{list(MAZE_DATASET_CONFIGS.keys()) = }\")\n", - "\n", - "# if you want to specify a custom config, you can do so here\n", - "CFG_CUSTOM: ConfigHolder = ConfigHolder(\n", - " name = \"hallway-medium\",\n", - " dataset_cfg = MazeDatasetConfig(\n", - "\t\tname=\"custom-hallway\",\n", - "\t\tgrid_n=8,\n", - "\t\tn_mazes=500_000,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", - " maze_ctor_kwargs=dict(\n", - " do_forks=False,\n", - " ),\n", - " applied_filters=[{'name': 'collect_generation_meta', 'args': (), 'kwargs': {}}],\n", - "\t),\n", - " model_cfg = BaseGPTConfig(\n", - " name=\"custom-model\",\n", - " act_fn=\"gelu\",\n", - " d_model=128,\n", - " d_head=32,\n", - " n_layers=6,\n", - " ),\n", - " train_cfg = TrainConfig(\n", - " name=\"custom-train\",\n", - " optimizer=torch.optim.AdamW,\n", - " optimizer_kwargs=dict(lr=0.001),\n", - " batch_size=32,\n", - " dataloader_cfg=dict(\n", - " shuffle=False,\n", - " num_workers=8,\n", - " drop_last=False,\n", - " ),\n", - " intervals_count=dict(\n", - " print_loss=100,\n", - " checkpoint=20,\n", - " eval_fast=100,\n", - " eval_slow=50,\n", - " ),\n", - " validation_dataset_cfg=100,\n", - " ),\n", - ")\n", - "\n", - "CFG_TEST: ConfigHolder = ConfigHolder(\n", - " name = \"hallway-nano\",\n", - " dataset_cfg = MazeDatasetConfig(\n", - "\t\tname=\"custom-hallway\",\n", - "\t\tgrid_n=3,\n", - "\t\tn_mazes=50,\n", - "\t\tmaze_ctor=LatticeMazeGenerators.gen_dfs,\n", - " maze_ctor_kwargs=dict(\n", - " do_forks=False,\n", - " ),\n", - " applied_filters=[{'name': 'collect_generation_meta', 'args': (), 'kwargs': {}}],\n", - "\t),\n", - " model_cfg = BaseGPTConfig(\n", - " name=\"custom-model\",\n", - " act_fn=\"gelu\",\n", - " d_model=8,\n", - " d_head=2,\n", - " n_layers=2,\n", - " ),\n", - " train_cfg = TrainConfig(\n", - " name=\"custom-train\",\n", - " optimizer=torch.optim.AdamW,\n", - " optimizer_kwargs=dict(lr=0.0001),\n", - " batch_size=4,\n", - " dataloader_cfg=dict(\n", - " shuffle=True,\n", - " drop_last=False,\n", - " ),\n", - " validation_dataset_cfg=5,\n", - " ),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# here is where to specify which config to actually use\n", - "CFG: ConfigHolder = CFG_TEST # change to CFG_CUSTOM to train a \"real\" model, the CFG_TEST is for CI testing" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"name\": \"hallway-nano\",\n", - " \"dataset_cfg\": {\n", - " \"name\": \"custom-hallway\",\n", - " \"fname\": \"custom-hallway-g3-n50-a_dfs-h8948\",\n", - " \"sdc_hash\": 37068534565008606697891622584169833792863291184350171524150420645468558408948,\n", - " \"seed\": 42,\n", - " \"seq_len_min\": 1,\n", - " \"seq_len_max\": 512,\n", - " \"applied_filters\": [\n", - " {\n", - " \"name\": \"collect_generation_meta\",\n", - " \"args\": [],\n", - " \"kwargs\": {}\n", - " }\n", - " ],\n", - " \"grid_n\": 3,\n", - " \"grid_shape\": [\n", - " 3,\n", - " 3\n", - " ],\n", - " \"n_mazes\": 50,\n", - " \"maze_ctor_name\": \"gen_dfs\",\n", - " \"maze_ctor_kwargs\": {\n", - " \"do_forks\": false\n", - " }\n", - " },\n", - " \"model_cfg\": {\n", - " \"name\": \"custom-model\",\n", - " \"act_fn\": \"gelu\",\n", - " \"d_model\": 8,\n", - " \"d_head\": 2,\n", - " \"n_layers\": 2,\n", - " \"weight_processing\": {\n", - " \"are_layernorms_folded\": false,\n", - " \"are_weights_processed\": false\n", - " },\n", - " \"n_heads\": 4\n", - " },\n", - " \"train_cfg\": {\n", - " \"name\": \"custom-train\",\n", - " \"optimizer\": \"AdamW\",\n", - " \"optimizer_kwargs\": {\n", - " \"lr\": 0.0001\n", - " },\n", - " \"batch_size\": 4,\n", - " \"dataloader_cfg\": {\n", - " \"shuffle\": true,\n", - " \"drop_last\": false\n", - " },\n", - " \"intervals\": null,\n", - " \"intervals_count\": null,\n", - " \"evals_max_new_tokens\": 8,\n", - " \"validation_dataset_cfg\": 5\n", - " },\n", - " \"pretrainedtokenizer_kwargs\": null,\n", - " \"maze_tokenizer\": {\n", - " \"tokenization_mode\": \"AOTP_UT_uniform\",\n", - " \"max_grid_size\": 3,\n", - " \"vocab_size\": 20\n", - " }\n", - "}\n" - ] - } - ], - "source": [ - "print(json.dumps(CFG.summary(), indent=2))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "seeing if we can download the dataset...\n", - "no download found, or download failed\n", - "generating dataset...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "generating & solving mazes: 100%|██████████| 50/50 [00:00<00:00, 1041.33maze/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving dataset to ..\\data\\custom-hallway-g3-n50-a_dfs-h8948.zanj\n", - "Got dataset custom-hallway with 50 items. output.cfg.to_fname() = 'custom-hallway-g3-n50-a_dfs-h8948'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# get just the dataset, generating it if needed. \n", - "# This step can be skipped if you set `do_generate_dataset=True` when calling `train_model`\n", - "# or if the dataset in question already exists\n", - "\n", - "# load the dataset\n", - "DATASET: MazeDataset = MazeDataset.from_config(\n", - " CFG.dataset_cfg, \n", - " verbose=True, \n", - " load_local=False,\n", - " save_local=True,\n", - " local_base_path=PATH_DATA,\n", - ")\n", - "CFG.dataset_cfg = DATASET.cfg" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-06 17:19:26 ERROR Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mmiv\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" - ] - }, - { - "data": { - "text/html": [ - "wandb version 0.15.8 is available! To upgrade, please run:\n", - " $ pip install wandb --upgrade" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Tracking run with wandb version 0.13.11" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Run data is saved locally in f:\\KNC\\maze-transformer\\notebooks\\wandb\\run-20230806_171929-jg9r0g83" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "Syncing run light-deluge-42 to Weights & Biases (docs)
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - " View project at https://wandb.ai/miv/demo-notebooks" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - " View run at https://wandb.ai/miv/demo-notebooks/runs/jg9r0g83" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-06 17:19:32 INFO config ={'__format__': 'ConfigHolder(SerializableDataclass)', 'dataset_cfg': {'__format__': 'MazeDatasetConfig(SerializableDataclass)', 'name': 'custom-hallway', 'seq_len_min': 1, 'seq_len_max': 512, 'seed': 42, 'applied_filters': [{'name': 'collect_generation_meta', 'args': (), 'kwargs': {}}], 'grid_n': 3, 'n_mazes': 50, 'maze_ctor': {'__name__': 'gen_dfs', '__module__': 'maze_dataset.generation.generators', '__doc__': ['generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `n_accessible_cells: int | None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid.', ' (default: `None`)', ' - `max_tree_depth: int | None`: the maximum depth of the tree. If `None`, defaults to `2 * n_accessible_cells`.', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' '], 'source_code': [' @staticmethod', ' def gen_dfs(', ' grid_shape: Coord,', ' lattice_dim: int = 2,', ' n_accessible_cells: int | None = None,', ' max_tree_depth: int | None = None,', ' do_forks: bool = True,', ' start_coord: Coord | None = None,', ' ) -> LatticeMaze:', ' \"\"\"generate a lattice maze using depth first search, iterative', '', ' # Arguments', ' - `grid_shape: Coord`: the shape of the grid', ' - `lattice_dim: int`: the dimension of the lattice', ' (default: `2`)', ' - `n_accessible_cells: int | None`: the number of accessible cells in the maze. If `None`, defaults to the total number of cells in the grid.', ' (default: `None`)', ' - `max_tree_depth: int | None`: the maximum depth of the tree. If `None`, defaults to `2 * n_accessible_cells`.', ' (default: `None`)', ' - `do_forks: bool`: whether to allow forks in the maze. If `False`, the maze will be have no forks and will be a simple hallway.', ' - `start_coord: Coord | None`: the starting coordinate of the generation algorithm. If `None`, defaults to a random coordinate.', '', '', ' # algorithm', ' 1. Choose the initial cell, mark it as visited and push it to the stack', ' 2. While the stack is not empty', ' 1. Pop a cell from the stack and make it a current cell', ' 2. If the current cell has any neighbours which have not been visited', ' 1. Push the current cell to the stack', ' 2. Choose one of the unvisited neighbours', ' 3. Remove the wall between the current cell and the chosen cell', ' 4. Mark the chosen cell as visited and push it to the stack', ' \"\"\"', '', ' # Default values if no constraints have been passed', ' grid_shape: Coord = np.array(grid_shape)', ' n_total_cells: int = int(np.prod(grid_shape))', ' if n_accessible_cells is None:', ' n_accessible_cells = n_total_cells', ' if max_tree_depth is None:', ' max_tree_depth = (', ' 2 * n_total_cells', ' ) # We define max tree depth counting from the start coord in two directions. Therefore we divide by two in the if clause for neighboring sites later and multiply by two here.', '', ' start_coord = _random_start_coord(grid_shape, start_coord)', '', ' # initialize the maze with no connections', ' connection_list: ConnectionList = np.zeros(', ' (lattice_dim, grid_shape[0], grid_shape[1]), dtype=np.bool_', ' )', '', ' # initialize the stack with the target coord', ' visited_cells: set[tuple[int, int]] = set()', ' visited_cells.add(tuple(start_coord))', ' stack: list[Coord] = [start_coord]', '', ' # initialize tree_depth_counter', ' current_tree_depth: int = 1', '', ' # loop until the stack is empty or n_connected_cells is reached', ' while stack and (len(visited_cells) < n_accessible_cells):', ' # get the current coord from the stack', ' current_coord: Coord = stack.pop()', '', ' # filter neighbors by being within grid bounds and being unvisited', ' unvisited_neighbors_deltas: list[tuple[Coord, Coord]] = [', ' (neighbor, delta)', ' for neighbor, delta in zip(', ' current_coord + NEIGHBORS_MASK, NEIGHBORS_MASK', ' )', ' if (', ' (tuple(neighbor) not in visited_cells)', ' and (0 <= neighbor[0] < grid_shape[0])', ' and (0 <= neighbor[1] < grid_shape[1])', ' )', ' ]', '', \" # don't continue if max_tree_depth/2 is already reached (divide by 2 because we can branch to multiple directions)\", ' if unvisited_neighbors_deltas and (', ' current_tree_depth <= max_tree_depth / 2', ' ):', \" # if we want a maze without forks, simply don't add the current coord back to the stack\", ' if do_forks:', ' stack.append(current_coord)', '', ' # choose one of the unvisited neighbors', ' chosen_neighbor, delta = random.choice(unvisited_neighbors_deltas)', '', ' # add connection', ' dim: int = np.argmax(np.abs(delta))', ' # if positive, down/right from current coord', ' # if negative, up/left from current coord (down/right from neighbor)', ' clist_node: Coord = (', ' current_coord if (delta.sum() > 0) else chosen_neighbor', ' )', ' connection_list[dim, clist_node[0], clist_node[1]] = True', '', ' # add to visited cells and stack', ' visited_cells.add(tuple(chosen_neighbor))', ' stack.append(chosen_neighbor)', '', ' # Update current tree depth', ' current_tree_depth += 1', ' else:', ' current_tree_depth -= 1', '', ' return LatticeMaze(', ' connection_list=connection_list,', ' generation_meta=dict(', ' func_name=\"gen_dfs\",', ' grid_shape=grid_shape,', ' start_coord=start_coord,', ' n_accessible_cells=int(n_accessible_cells),', ' max_tree_depth=int(max_tree_depth),', ' fully_connected=bool(len(visited_cells) == n_accessible_cells),', ' visited_cells={tuple(int(x) for x in coord) for coord in visited_cells},', ' ),', ' )']}, 'maze_ctor_kwargs': {'do_forks': False}, 'grid_shape': (3, 3)}, 'model_cfg': {'__format__': 'BaseGPTConfig(SerializableDataclass)', 'name': 'custom-model', 'act_fn': 'gelu', 'd_model': 8, 'd_head': 2, 'n_layers': 2, 'weight_processing': {'are_layernorms_folded': False, 'are_weights_processed': False}, 'n_heads': 4}, 'train_cfg': {'__format__': 'TrainConfig(SerializableDataclass)', 'name': 'custom-train', 'evals_max_new_tokens': 8, 'validation_dataset_cfg': 5, 'optimizer': 'AdamW', 'optimizer_kwargs': {'lr': 0.0001}, 'batch_size': 4, 'dataloader_cfg': {'shuffle': True, 'drop_last': False}, 'intervals': None, 'intervals_count': None}, 'name': 'hallway-nano', 'pretrainedtokenizer_kwargs': None, 'maze_tokenizer': {'__format__': 'MazeTokenizer(SerializableDataclass)', 'tokenization_mode': 'AOTP_UT_uniform', 'max_grid_size': 3, 'name': 'maze_tokenizer-AOTP_UT_uniform-g3', 'token_arr': ['', '', '', '', '', '', '', '', '<-->', ';', '', '(0,0)', '(0,1)', '(1,0)', '(1,1)', '(0,2)', '(2,0)', '(1,2)', '(2,1)', '(2,2)'], 'tokenizer_map': {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '<-->': 8, ';': 9, '': 10, '(0,0)': 11, '(0,1)': 12, '(1,0)': 13, '(1,1)': 14, '(0,2)': 15, '(2,0)': 16, '(1,2)': 17, '(2,1)': 18, '(2,2)': 19}, 'vocab_size': 20, 'padding_token_index': 10}}\n", - "2023-08-06 17:19:32 INFO Initialized logger\n", - "2023-08-06 17:19:32 INFO Summary logged, getting dataset\n", - "loading dataset from ../data/custom-hallway-g3-n50-a_dfs-h8948.zanj\n", - "Got dataset custom-hallway with 50 items. output.cfg.to_fname() = 'custom-hallway-g3-n50-a_dfs-h8948'\n", - "2023-08-06 17:19:32 INFO finished getting training dataset with 50 samples\n", - "2023-08-06 17:19:32 INFO got validation dataset by splitting training dataset into 45 train and 5 validation samples\n", - "2023-08-06 17:19:32 INFO Loaded 45 sequences\n", - "2023-08-06 17:19:32 INFO Creating dataloader\n", - "2023-08-06 17:19:32 INFO finished dataloader, passing to train()\n", - "2023-08-06 17:19:32 INFO Initializing model\n", - "Moving model to device: cpu\n", - "2023-08-06 17:19:32 INFO Initializing optimizer\n", - "2023-08-06 17:19:32 INFO will train for 12 batches, evals_enabled=True, with intervals: {'print_loss': inf, 'checkpoint': 1, 'eval_fast': 1, 'eval_slow': 1}\n", - "2023-08-06 17:19:32 INFO Starting training\n", - "2023-08-06 17:19:32 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:32 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:32 INFO iteration 0/12: loss=3.288\n", - "2023-08-06 17:19:33 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_0.zanj\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "F:\\KNC\\maze-transformer\\maze_transformer\\evaluation\\path_evals.py:91: RuntimeWarning:\n", - "\n", - "fraction_connections_adjacent_lattice called on path of length less than 2, retuning NaN\n", - "prediction = array([[1, 0]])\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-06 17:19:33 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:33 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:33 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_1.zanj\n", - "2023-08-06 17:19:33 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:33 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:33 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_2.zanj\n", - "2023-08-06 17:19:34 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:34 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:34 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_3.zanj\n", - "2023-08-06 17:19:34 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:34 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:34 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_4.zanj\n", - "2023-08-06 17:19:35 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:35 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:35 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_5.zanj\n", - "2023-08-06 17:19:35 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:35 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:35 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_6.zanj\n", - "2023-08-06 17:19:36 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:36 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:36 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_7.zanj\n", - "2023-08-06 17:19:36 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:36 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:36 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_8.zanj\n", - "2023-08-06 17:19:36 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:37 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:37 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_9.zanj\n", - "2023-08-06 17:19:37 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:37 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:37 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_10.zanj\n", - "2023-08-06 17:19:38 INFO Running evals: eval_fast\n", - "2023-08-06 17:19:38 INFO Running evals: eval_slow\n", - "2023-08-06 17:19:38 INFO Saving model checkpoint to ../data/hallway-nano_2023-08-06-17-19-26/checkpoints/model.iter_11.zanj\n", - "2023-08-06 17:19:38 INFO Saving final model to ../data/hallway-nano_2023-08-06-17-19-26/model.final.zanj\n", - "2023-08-06 17:19:38 INFO Done training!\n" - ] - } - ], - "source": [ - "result: TrainingResult = train_model(\n", - "\tbase_path=PATH_DATA,\n", - " cfg=CFG,\n", - "\twandb_project=WandbProject.DEMO_NOTEBOOKS, # change this to WandbProject.DEMO_NOTEBOOKS! INTEGRATION_TESTS is for CI testing\n", - "\tdo_generate_dataset=False,\n", - "\tdataset_verbose=True,\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "maze-transformer", - "language": "python", - "name": "maze-transformer" - }, - "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.1" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/wadb_to_zanj.ipynb b/notebooks/wandb_to_zanj.ipynb similarity index 100% rename from notebooks/wadb_to_zanj.ipynb rename to notebooks/wandb_to_zanj.ipynb diff --git a/notebooks/wip/wip_activation_patching.ipynb b/notebooks/wip/wip_activation_patching.ipynb new file mode 100644 index 00000000..a4cd4a86 --- /dev/null +++ b/notebooks/wip/wip_activation_patching.ipynb @@ -0,0 +1,1604 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Path Start Mech Int Investigation #23" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook we explore how the model is doing prediction of the first path token in the maze (ie. the token that immediately comes after the `PATH_START` token), to this end we use:\n", + "\n", + "* Logit Lens\n", + "* Direct Logit Attribution\n", + "* Activation Patching\n", + "\n", + "In summary, we find that the majority of computation associated with this task is in the form of MLP computation (in particular in MLP10 and MLP11) but that there does appear to be a few heads within early layers (Layer 0, 1 and 2) that are also playing some role. Further evals outside of this notebook however are suggestive of this instance of maze-transformer doing some form of memorization (atleast overfitting to its training data and not generalising OOD), for this reason, this study has not yet been taken further.\n", + "\n", + "This notebook takes significant inspiration from two great resources:\n", + "\n", + "* Nanda's [Exploratory Analysis Demo](https://github.com/neelnanda-io/TransformerLens/blob/main/demos/Exploratory_Analysis_Demo.ipynb) Notebook\n", + "* Janiak & Heimersheim's [Python docstrings](https://colab.research.google.com/drive/17CoA1yARaWHvV14zQGcI3ISz1bIRZKS5) Notebook" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\mivan\\AppData\\Local\\pypoetry\\Cache\\virtualenvs\\maze-transformer-2cGx2R0F-py3.10\\lib\\site-packages\\_distutils_hack\\__init__.py:33: UserWarning: Setuptools is replacing distutils.\n", + " warnings.warn(\"Setuptools is replacing distutils.\")\n" + ] + } + ], + "source": [ + "# standard library\n", + "import os\n", + "from copy import deepcopy\n", + "from pathlib import Path\n", + "from functools import partial\n", + "import typing\n", + "\n", + "# Numerical Computing\n", + "import numpy as np\n", + "import torch\n", + "import einops\n", + "import pandas as pd\n", + "from fancy_einsum import einsum\n", + "# from sklearn.decomposition import PCA\n", + "# from sklearn import preprocessing\n", + "from jaxtyping import Float, Int\n", + "# from torchtyping import TensorType as TT\n", + "\n", + "# Pytorch\n", + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "# plotting\n", + "import plotly.io as pio\n", + "import plotly.express as px\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import HTML\n", + "# import seaborn\n", + "# from neel_plotly import imshow, line\n", + "\n", + "# TransformerLens\n", + "from transformer_lens import HookedTransformer, ActivationCache\n", + "from transformer_lens import utils as et_utils\n", + "from transformer_lens import utils\n", + "\n", + "# muutils\n", + "from muutils.nbutils.configure_notebook import configure_notebook\n", + "from muutils.misc import shorten_numerical_to_str\n", + "\n", + "# Our Code\n", + "from maze_dataset import MazeDataset, MazeDatasetConfig, SolvedMaze, LatticeMaze, SPECIAL_TOKENS\n", + "from maze_dataset.plotting import plot_dataset_mazes\n", + "from maze_transformer.tokenizer import HuggingMazeTokenizer\n", + "from maze_transformer.training.config import ConfigHolder, ZanjHookedTransformer, BaseGPTConfig\n", + "\n", + "# from prelim_mech_int import *\n", + "\n", + "pio.renderers.default = 'vscode'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Setup Notebook\n", + "device = configure_notebook(seed=42, dark_mode=True)\n", + "\n", + "# We won't be training any models\n", + "torch.set_grad_enabled(False)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the model in\n", + "\n", + "We can start by loading the model into the notebook, as well as a dataset of 20,000 mazes. This instance of maze-transformer is capable of solving 6x6 mazes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded model with 1.3M params (num_params = 1274699)\n" + ] + } + ], + "source": [ + "MODEL: ZanjHookedTransformer = ZanjHookedTransformer.read(\"../examples/hallway-medium_2023-06-16-03-40-47.iter_26554.zanj\")\n", + "num_params: int = MODEL.num_params()\n", + "print(f\"loaded model with {shorten_numerical_to_str(num_params)} params ({num_params = })\")\n", + "GPT_CONFIG: BaseGPTConfig = MODEL.zanj_model_config.model_cfg" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## getting a test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# get 100 mazes and pass into model, storing logits and cache\n", + "n_examples: int = 10\n", + "# get a dataset from the same config as the model -- you can also pass in a new config\n", + "TEST_DATASET_CFG: MazeDatasetConfig = deepcopy(MODEL.zanj_model_config.dataset_cfg)\n", + "TEST_DATASET_CFG.n_mazes = n_examples\n", + "DATASET: MazeDataset = MazeDataset.from_config(TEST_DATASET_CFG)\n", + "DATASET_TOKENS_UNJOINED: list[list[str]] = DATASET.as_tokens(join_tokens_individual_maze=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([, , , , , ,\n", + " , , , ], dtype=object))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_dataset_mazes(DATASET, count=10)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Some further clarity about what we are trying to find\n", + "Now that we have a dataset in the notebook, lets just first demonstrate what behaviour we are trying to understand. Let't take the first maze from the maze dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " (3,7) <--> (3,6) ; (6,5) <--> (5,5) ; (5,5) <--> (5,4) ; (5,3) <--> (5,2) ; (4,1) <--> (5,1) ; (3,5) <--> (3,6) ; (4,6) <--> (4,7) ; (4,4) <--> (4,5) ; (5,2) <--> (5,1) ; (5,4) <--> (5,3) ; (3,7) <--> (4,7) ; (6,5) <--> (6,4) ; (4,6) <--> (4,5) ; (4,1) <--> (4,2) ; (3,3) <--> (3,4) ; (4,3) <--> (3,3) ; (3,5) <--> (3,4) ; (4,3) <--> (4,2) ; (6,3) <--> (6,4) ; (3,4) (4,1) (3,4) (3,3) (4,3) (4,2) (4,1) \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\" \".join(DATASET[0].as_tokens(DATASET.cfg.node_token_map)))\n", + "plt.imshow(DATASET[0].as_pixels())\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above example, the correct prediction following `` is the position ~~`(5, 0)`~~. The question we are trying to answer is, given examples of the form above (but with data truncated to the `PATH_START` and some padding at the start to make consistent lengths) how does the model predict ~~`(5, 0)`~~ over any other token?\n", + "\n", + "To explore this behaviour, let's truncate and pad the full dataset of examples we have pulled in." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset Processing\n", + "\n", + "we want to, for each maze, get a list of context tokens and a list of target tokens. For this example, we get the context tokens by simply looking for the first index of the path start token" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ContextGetterFunction = typing.Callable[[list[str]], int]\n", + "\n", + "def get_token_first_index_factory(token: str) -> ContextGetterFunction:\n", + "\treturn lambda token_list: token_list.index(token)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def process_dataset_context_target_pairs(\n", + " dataset_tokens: list[list[str]],\n", + " context_getter: ContextGetterFunction,\n", + ") -> tuple[list[list[str]], list[str]]:\n", + "\n", + "\toutput_contexts: list[list[str]] = list()\n", + "\toutput_targets: list[str] = list()\n", + "\tfor maze in dataset_tokens:\n", + "\t\tindex: int = context_getter(maze)\n", + "\t\toutput_contexts.append(maze[:index])\n", + "\t\toutput_targets.append(maze[index])\n", + "\n", + "\treturn output_contexts, output_targets" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "PATH_START_CONTEXT_GETTER: ContextGetterFunction = get_token_first_index_factory(SPECIAL_TOKENS[\"path_start\"])\n", + "\n", + "DATASET_CONTEXTS: list[list[str]]; DATASET_TARGETS: list[str]\n", + "DATASET_CONTEXTS, DATASET_TARGETS = process_dataset_context_target_pairs(\n", + " DATASET_TOKENS_UNJOINED,\n", + " context_getter=lambda token_list: PATH_START_CONTEXT_GETTER(token_list) + 1,\n", + ")\n", + "\n", + "DATASET_CONTEXTS_JOINED: list[str] = [\" \".join(context) for context in DATASET_CONTEXTS]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "context: (6,4) <--> (6,3) ; (4,7) <--> (3,7) ; (3,4) <--> (3,5) ; (3,3) <--> (4,3) ; (4,4) <--> (4,5) ; (3,7) <--> (3,6) ; (3,3) <--> (3,4) ; (4,7) <--> (4,6) ; (4,2) <--> (4,1) ; (6,5) <--> (5,5) ; (3,5) <--> (3,6) ; (4,6) <--> (4,5) ; (5,1) <--> (4,1) ; (6,4) <--> (6,5) ; (5,1) <--> (5,2) ; (5,2) <--> (5,3) ; (5,3) <--> (5,4) ; (4,3) <--> (4,2) ; (5,4) <--> (5,5) ; (3,4) (4,1) \n", + "target: (6,4)\n" + ] + } + ], + "source": [ + "print(f\"context: {' '.join(DATASET_CONTEXTS[0])}\")\n", + "print(f\"target: {DATASET_TARGETS[1]}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our first question is, how good is the model at predicting the **correct** first token after `PATH_START` in each maze example?\n", + "\n", + "## Model Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Have the model predict on the maze examples, storing logits and activations in cache\n", + "with torch.no_grad():\n", + "\tLOGITS, CACHE = MODEL.run_with_cache(DATASET_CONTEXTS_JOINED, prepend_bos=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Logits are in the shape torch.Size([10, 221, 75])\n", + "This corresponds to [batch_size, num_tokens, vocab_size]\n" + ] + } + ], + "source": [ + "print(f'Logits are in the shape {LOGITS.shape}')\n", + "print(f'This corresponds to [batch_size, num_tokens, vocab_size]')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We want to predict on the next token (the first path coordinate), thus logits associated with final token." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction are of the shape: torch.Size([10])\n", + "This makes sense, we want one prediction for each example in the batch\n" + ] + } + ], + "source": [ + "# Get the last token prediction from the model\n", + "last_token_logits = LOGITS[:, -1, :]\n", + "predictions = []\n", + "for sample in last_token_logits:\n", + " last_token_pred = torch.argmax(sample).item()\n", + " predictions.append(last_token_pred)\n", + "predictions = torch.tensor(predictions)\n", + "print(f'Prediction are of the shape: {predictions.shape}')\n", + "print('This makes sense, we want one prediction for each example in the batch')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets have a quick look at what these predictions look like:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([33, 56, 60, 36, 23, 21, 48, 20, 44, 43])\n", + "\n", + "Converting this back to text gives us: ['(3,4)', '(6,4)', '(0,7)', '(0,5)', '(2,3)', '(3,0)', '(2,6)', '(0,3)', '(1,5)', '(5,4)']\n", + "The targets, for comparison: ['(3,4)', '(6,4)', '(0,7)', '(0,5)', '(2,3)', '(3,0)', '(2,6)', '(0,3)', '(1,5)', '(5,4)']\n" + ] + } + ], + "source": [ + "print(f'{predictions}\\n')\n", + "print(f'Converting this back to text gives us: {MODEL.to_str_tokens(predictions)}')\n", + "print(f'The targets, for comparison: {DATASET_TARGETS}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great, we can see what prediction the model is giving based on each maze example in the dataset. Let's see if these predictions match the *ground truth values*." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see by comparing the above predictions to these ground truths, the model is indeed very good at predicting the first token after ``. Let's compare these a little bit more systematically. \n", + "\n", + "We need to compare the logits associated with the ground truth token to some other token in the dataset, a number of tokens make sense here (ie. a random one, maybe an average over all). However, I think that this token should represent a 'reasonable' wrong response, in this case the most plausible token to me currently seems to be the next token in the dataset (ie. the second token on the ground truth path of each maze). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "second_tok_on_path = []\n", + "for maze in mazes_tokens:\n", + " for idx, tok in enumerate(maze):\n", + " if tok == 6:\n", + " second_tok_on_path.append(maze[idx+2])\n", + " \n", + "second_tok_on_path_tokens = torch.stack(second_tok_on_path).long().to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f'Second tokens on the path are: {second_tok_on_path_tokens}\\n')\n", + "print(f'Converting this back to text gives us: {model.to_str_tokens(second_tok_on_path_tokens)}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have a set of correct tokens (our ground truths for each maze example) and a set of incorrect tokens (in this case just every second token on the maze example's path)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "corrects_incorrects = []\n", + "for i in range(len(ground_truth_tokens)):\n", + " corrects_incorrects.append([ground_truth_tokens[i].item(), second_tok_on_path_tokens[i].item()])\n", + "correct_incorrect_indices = torch.tensor(corrects_incorrects).long().to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We compare the logit difference across these incorrect and correct tokens." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# From Neels explanatory notebook: https://colab.research.google.com/github/neelnanda-io/Easy-Transformer/blob/main/Exploratory_Analysis_Demo.ipynb\n", + "def logits_to_ave_logit_diff(logits, answer_tokens, per_prompt=False):\n", + " # Only the final logits are relevant for the answer\n", + " final_logits = logits[:, -1, :]\n", + " answer_logits = final_logits.gather(dim=-1, index=answer_tokens)\n", + " answer_logit_diff = answer_logits[:, 0] - answer_logits[:, 1]\n", + " if per_prompt:\n", + " return answer_logit_diff\n", + " else:\n", + " return answer_logit_diff.mean()\n", + "\n", + "print(\"Per prompt logit difference:\", logits_to_ave_logit_diff(logits, correct_incorrect_indices, per_prompt=True))\n", + "original_average_logit_diff = logits_to_ave_logit_diff(logits, correct_incorrect_indices)\n", + "print(\"Average logit difference:\", logits_to_ave_logit_diff(logits, correct_incorrect_indices).item())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The logit difference across the batch is high, it can be interpreted as the model being $e^{11.3}$ more likely to choose the correct repsonse over the incorrect response. Another metric to compare the model's ability is accuracy, defining this below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def accuracy(predictions, ground_truths):\n", + " return f'{(predictions.to(\"cpu\") == ground_truths.to(\"cpu\")).sum().item() / len(predictions.to(\"cpu\")):.0%}'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "final_logits = logits[:, -1, :]\n", + "answer_logits = final_logits.gather(dim=-1, index=correct_incorrect_indices)\n", + "preds = torch.argmax(final_logits, dim=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "preds" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we check accuracy of the predictions against the ground truth values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "accuracy(preds, ground_truth_tokens)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logit Lens" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now use logit lens to decompose the residual stream into contribution of logit difference from individual components. This is done by using the unembedding matrix after each block in the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Map the correct and incorrect values into the residual stream\n", + "correct_incorrect_residual_directions = model.tokens_to_residual_directions(correct_incorrect_indices)\n", + "print(f\"Correct & Incorrect residual directions shape: {correct_incorrect_residual_directions.shape}\")\n", + "\n", + "diff_residual_directions = correct_incorrect_residual_directions[:, 0, :] - correct_incorrect_residual_directions[:, 1, :]\n", + "print(f\"Correct - Incorrect diff residual directions shape: {diff_residual_directions.shape}\")\n", + "\n", + "# cache the values at the end of the residual stream\n", + "final_residual_stream = cache[\"resid_post\", -1]\n", + "print(\"Final residual stream shape:\", final_residual_stream.shape)\n", + "\n", + "# Get the final token resid stream values (like we did above with last_pred_token)\n", + "final_token_residual_stream = final_residual_stream[:, -1, :]\n", + "\n", + "# Scaling the values in residual stream with layer norm\n", + "scaled_final_token_residual_stream = cache.apply_ln_to_stack(final_token_residual_stream, layer = -1, pos_slice=-1)\n", + "\n", + "# Average logit diff from residual stream method\n", + "average_logit_diff = einsum(\"batch d_model, batch d_model -> \", scaled_final_token_residual_stream, diff_residual_directions) / n_examples\n", + "print(\"Calculated average logit diff:\", average_logit_diff.item())\n", + "print(\"Original logit difference:\",original_average_logit_diff.item())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def residual_stack_to_logit_diff(residual_stack: Float[torch.Tensor, \"components batch d_model\"], cache: ActivationCache) -> float:\n", + " scaled_residual_stack = cache.apply_ln_to_stack(residual_stack, layer = -1, pos_slice=-1)\n", + " return einsum(\"... batch d_model, batch d_model -> ...\", scaled_residual_stack, diff_residual_directions)/n_examples" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first look at the logit difference from the accumulated residual stream, this means we are looking at the logit difference between the correct at: \n", + "1. Layer 0 resid_mid, \n", + "2. Accumulated across layer 0 resid_mid + layer 0 resid_post, \n", + "3. Accumulated across layer 0 resid_mid + layer 0 resid_post + layer 1 resid_mid,\n", + "4. etc.\n", + "\n", + " ...\n", + "\n", + " Accumulated logit difference from entire resid stream." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "accumulated_residual, labels = cache.accumulated_resid(layer=-1, incl_mid=True, pos_slice=-1, return_labels=True)\n", + "logit_lens_logit_diffs = residual_stack_to_logit_diff(accumulated_residual, cache)\n", + "line(logit_lens_logit_diffs, x=np.arange(model.cfg.n_layers*2+1)/2, hover_name=labels, title=\"Logit Difference From Accumulated Residual Stream\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we see that model seems to be largely unable to do this task until around layer 8, we also see a signficant contribution between layer 11 resid_mid and layer 11 resid_post (indicating a large influence of the Layer 11 MLP on this task).\n", + "\n", + "We can also look at the logit difference contribution for layer in isolation (removing the cumulative effect of previous layers)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "per_layer_residual, labels = cache.decompose_resid(layer=-1, pos_slice=-1, return_labels=True)\n", + "per_layer_logit_diffs = residual_stack_to_logit_diff(per_layer_residual, cache)\n", + "line(per_layer_logit_diffs, hover_name=labels, title=\"Logit Difference From Each Layer\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is this suggesting:\n", + "* MLP11 is really important and MLP8, MLP9 and MLP10 are quite important\n", + "\n", + "* It doesnt appear to be the case that attention is very important" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Direct Logit Attribution\n", + "\n", + "We now move onto applying the same techique but at the level of individual heads and neurons (as opposed to entire layer or blocks)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# One of Jett's plotting functions from here: https://github.com/jettjaniak/mi_utils_public/blob/main/plotting.py\n", + "def imshow(\n", + " tensor,\n", + " xlabel=\"X\",\n", + " ylabel=\"Y\",\n", + " zlabel=None,\n", + " xticks=None,\n", + " yticks=None,\n", + " c_midpoint=0.0,\n", + " c_scale=\"RdBu\",\n", + " show=True,\n", + " **kwargs\n", + "):\n", + " tensor = et_utils.to_numpy(tensor)\n", + " if \"animation_frame\" not in kwargs:\n", + " assert len(tensor.shape) == 2\n", + " else:\n", + " assert len(tensor.shape) == 3\n", + " xticks = xticks or range(tensor.shape[-1])\n", + " yticks = yticks or range(tensor.shape[-2])\n", + " xticks = [str(x) for x in xticks]\n", + " yticks = [str(y) for y in yticks]\n", + " if len(xticks) != len(set(xticks)):\n", + " xticks = [f\"{i}_{x}\" for i, x in enumerate(xticks)]\n", + " if len(yticks) != len(set(yticks)):\n", + " yticks = [f\"{i}_{y}\" for i, y in enumerate(yticks)]\n", + " labels = {\"x\": xlabel, \"y\": ylabel}\n", + " if zlabel is not None:\n", + " labels[\"color\"] = zlabel\n", + " fig = px.imshow(\n", + " et_utils.to_numpy(tensor),\n", + " x=xticks,\n", + " y=yticks,\n", + " labels=labels,\n", + " color_continuous_midpoint=c_midpoint,\n", + " color_continuous_scale=c_scale,\n", + " **kwargs\n", + " )\n", + " if show:\n", + " fig.show()\n", + " else:\n", + " return fig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "per_head_residual, labels = cache.stack_head_results(layer=-1, pos_slice=-1, return_labels=True)\n", + "per_head_logit_diffs = residual_stack_to_logit_diff(per_head_residual, cache)\n", + "per_head_logit_diffs = einops.rearrange(per_head_logit_diffs, \"(layer head_index) -> layer head_index\", layer=model.cfg.n_layers, head_index=model.cfg.n_heads)\n", + "imshow(per_head_logit_diffs, xlabel = \"Heads\", ylabel = \"Layer\", title=\"Logit Difference From Each Head\", aspect=\"auto\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These results are suggestive of various heads (those in blue) having a positive effect on logit difference, their effect however is relatively small (only amounting for example to a 0.05 increase in logits for the correct response vs the incorrect response)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "per_neuron_residual, labels = cache.stack_neuron_results(layer=-1, pos_slice=-1, return_labels=True)\n", + "per_neuron_logit_diffs = residual_stack_to_logit_diff(per_neuron_residual, cache)\n", + "per_neuron_logit_diffs = einops.rearrange(per_neuron_logit_diffs, \"(layer neuron_index) -> layer neuron_index\", layer=model.cfg.n_layers, neuron_index=model.cfg.d_mlp)\n", + "imshow(per_neuron_logit_diffs, xlabel = 'Neuron Index', ylabel = \"Layer\", aspect = \"auto\", title=\"Logit Difference From Each Neuron\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "percentile = 0.01\n", + "top_neuron_logit_diffs = []\n", + "per_neuron_logit_diffs = per_neuron_logit_diffs.to(\"cpu\").numpy()\n", + "for idx, layer in enumerate(per_neuron_logit_diffs):\n", + " top_sorted_layer = (np.sort(layer)[-int(percentile*len(layer)):])\n", + " top_of_layer = []\n", + " for idx, neuron in enumerate(layer):\n", + " if neuron in top_sorted_layer:\n", + " top_of_layer.append((int(idx), neuron))\n", + " top_neuron_logit_diffs.append(top_of_layer)\n", + "top_neuron_logit_diffs = np.array(top_neuron_logit_diffs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = px.imshow(top_neuron_logit_diffs[:, :, 1],\n", + " y = [y for y in range(0, model.cfg.n_layers, 1)], \n", + " color_continuous_scale='RdBu', \n", + " color_continuous_midpoint=0.0, \n", + " aspect=\"auto\",\n", + " title=f\"Logit Difference From Top {percentile:.1%} Neurons in each Layer\")\n", + "\n", + "fig.update_xaxes(showticklabels = False)\n", + "fig.update_traces(text = top_neuron_logit_diffs[:, :, 0], texttemplate = \"%{text}\")\n", + "fig.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These results are also suggestive that the MLPs are doing most of the computation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Activation Patching\n", + "\n", + "In this section, we get more rigorous with our analysis by employing activation patching. \n", + "\n", + "**An important note here**: All functions set up in this section are predicated on returning a normalised change from patching in a corrupt activation into an otherwise clean run. \n", + "\n", + "This differs from some other implementations in that it is a returning normalised logit difference (like in Neel's Exploratory Analysis Demo) but patching a corrupt activation into a clean run (like in Jett's Docstring work). Personally, I feel this makes most intuitive sense, we want to understand how important a single component is toward performing a task in context of the rest of the model and logits by themselves are less intuitive than normalized effects. In this sense, a negetaive number corresponds to a loss of performance (more negative = larger loss in performance), 0 corresponds to no change and a positive number corresponds to an active improvement by removing that component.\n", + "\n", + "We start by running two forward passes, in this case the corrupted_tokens = (clean_token with ORIGIN and PATH_START tokens replaced with a random token)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Clean tokens are just our original padded tokens\n", + "clean_tokens = padded_tokens\n", + "\n", + "# Corrupted tokens are our original padded tokens with ORIGIN and PATH_START tokens replaced with random tokens\n", + "corrupted_tokens = padded_tokens.clone()\n", + "\n", + "# Replace PATH_START tokens\n", + "corrupted_tokens[:,-1] = torch.randint(0, model.cfg.d_vocab, (1,))\n", + "\n", + "# Replace ORIGIN tokens\n", + "corrupted_tokens[:, -6] = torch.randint(0, model.cfg.d_vocab, (1,))\n", + "\n", + "# Corrupt Forward Pass\n", + "print(f'First Corrupt Prompt: {model.to_str_tokens(corrupted_tokens[0])}\\n')\n", + "corrupted_logits, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=True)\n", + "\n", + "# Clean Forward Pass\n", + "print(f'First Clean Prompt: {model.to_str_tokens(clean_tokens[0])}\\n')\n", + "clean_logits, clean_cache = model.run_with_cache(clean_tokens, prepend_bos=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def logit_diff(logits, correct_incorrect_indices=correct_incorrect_indices, pos=-1):\n", + " if len(logits.shape)==3:\n", + " # Get final logits only\n", + " logits = logits[:, pos, :]\n", + " correct_logits = logits.gather(1, correct_incorrect_indices[:, 0].unsqueeze(1))\n", + " incorrect_logits = logits.gather(1, correct_incorrect_indices[:, 1].unsqueeze(1))\n", + " return (correct_logits - incorrect_logits).mean()\n", + "\n", + "clean_logit_diff = logit_diff(clean_logits, correct_incorrect_indices).item()\n", + "print(f\"Clean logit diff: {clean_logit_diff:.4f}\")\n", + "\n", + "corrupted_logit_diff = logit_diff(corrupted_logits, correct_incorrect_indices).item()\n", + "print(f\"Corrupted logit diff: {corrupted_logit_diff:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "CLEAN_BASELINE = clean_logit_diff\n", + "CORRUPTED_BASELINE = corrupted_logit_diff\n", + "def counting_metric(logits, answer_token_indices=correct_incorrect_indices):\n", + " return (logit_diff(logits, answer_token_indices) - CORRUPTED_BASELINE) / (CLEAN_BASELINE - CORRUPTED_BASELINE) - 1\n", + "\n", + "print(f\"Clean Baseline is 0: {counting_metric(clean_logits).item():.4f} - This corresponds to no loss in performance\\n\")\n", + "print(f\"Corrupted Baseline is -1: {counting_metric(corrupted_logits).item():.4f} - This corresponds to a complete loss in performance\\n\")\n", + "print(f'A counting metric of > 0 corresponds to a an active improvement in performance\\n')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We set up a function to do resdiual stream pre patching, we call this the `resid_patcher`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def resid_patcher(layer: int,\n", + " pos: int,\n", + " clean_tokens: TT[\"batch\", \"pos\"],\n", + " corrupted_tokens: TT[\"batch\", \"pos\"] = None,\n", + " corrupted_cache: ActivationCache = None,\n", + " prepend_bos: bool = True):\n", + "\n", + " if corrupted_cache is None:\n", + " _, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=prepend_bos)\n", + " \n", + " def patch_clean_head_vector(\n", + " clean_head_vector: TT[\"batch pos head_index d_head\"],\n", + " hook, \n", + " corrupted_cache):\n", + " clean_head_vector[:, pos, :] = corrupted_cache[hook.name][:, pos, :]\n", + " return clean_head_vector\n", + " \n", + " hook_fn = partial(patch_clean_head_vector, corrupted_cache=corrupted_cache)\n", + "\n", + " activation_name = utils.get_act_name(\"resid_pre\", layer)\n", + " patched_logits = model.run_with_hooks(\n", + " clean_tokens,\n", + " fwd_hooks = [(activation_name, hook_fn)],\n", + " return_type = \"logits\",\n", + " )\n", + " \n", + " model.reset_hooks()\n", + "\n", + " return patched_logits" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then apply this `resid_patcher` recursively over each layer at each postion in the model to see what part of the resid stream is playing an integral role in this task." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def recursive_resid_patching(clean_tokens: TT[\"batch\", \"pos\"],\n", + " corrupted_cache: ActivationCache | None = None,\n", + " pos: int = -1):\n", + "\n", + " if pos:\n", + " resid_patches = torch.zeros(model.cfg.n_layers, 1, device = device, dtype = torch.float32)\n", + " for layer in range(model.cfg.n_layers):\n", + " patched_logit_diff = counting_metric(resid_patcher(\n", + " layer = layer, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache\n", + " ), correct_incorrect_indices).item()\n", + " resid_patches[layer] = patched_logit_diff\n", + "\n", + " else:\n", + " all_pos = [x for x in range(len(clean_tokens[0]))]\n", + " resid_patches = torch.zeros(model.cfg.n_layers, len(all_pos), device = device, dtype = torch.float32)\n", + " for pos in all_pos:\n", + " for layer in range(model.cfg.n_layers):\n", + " patched_logit_diff = counting_metric(resid_patcher(\n", + " layer = layer, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache\n", + " ), correct_incorrect_indices).item()\n", + " resid_patches[layer, pos] = patched_logit_diff\n", + " \n", + " return resid_patches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "resid_patches = recursive_resid_patching(clean_tokens, corrupted_cache, pos = None)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We write a quick function to visualize these results, `resid_patching_imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def resid_patching_imshow(resid_patches, layer_labels, pos_labels):\n", + " fig = imshow(resid_patches, \n", + " title = 'Normalised Change in Logit Diff Performance From Patched Resid Pre at Given position', \n", + " aspect = \"auto\", \n", + " xlabel= \"Pos\", \n", + " ylabel= \"Layer\",\n", + " xticks = pos_labels,\n", + " yticks = layer_labels,\n", + " height = 720,\n", + " width = 720)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We make the visualisation easier to read by labelling the positions along the x-axis and layers along the y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pos_labels = model.to_str_tokens(clean_tokens[0])\n", + "layer_labels = [f\"Layer {layer}\" for layer in range(model.cfg.n_layers)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "resid_patching_imshow(resid_patches=resid_patches,\n", + " layer_labels=layer_labels,\n", + " pos_labels=pos_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These results are suggestive of signficant computation occuring at the `ORIGIN_START` token within the model's early layers and across many layers for the `PATH_START` token.\n", + "\n", + "We can get much more granular than this by performing activation patching on individual attn heads.\n", + "\n", + "We start by restating our clean and corrupt forward passes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Corrupt Forward Pass\n", + "print(f'First Corrupt Prompt: {model.to_str_tokens(corrupted_tokens[0])}\\n')\n", + "corrupted_logits, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=True)\n", + "\n", + "# Clean Forward Pass\n", + "print(f'First Clean Prompt: {model.to_str_tokens(clean_tokens[0])}\\n')\n", + "clean_logits, clean_cache = model.run_with_cache(clean_tokens, prepend_bos=True)\n", + "\n", + "resid_patches = recursive_resid_patching(clean_tokens, corrupted_cache, pos = None)\n", + "\n", + "clean_logit_diff = logit_diff(clean_logits, correct_incorrect_indices).item()\n", + "print(f\"Clean logit diff: {clean_logit_diff:.4f}\")\n", + "\n", + "corrupted_logit_diff = logit_diff(corrupted_logits, correct_incorrect_indices).item()\n", + "print(f\"Corrupted logit diff: {corrupted_logit_diff:.4f}\")\n", + "\n", + "CLEAN_BASELINE = clean_logit_diff\n", + "CORRUPTED_BASELINE = corrupted_logit_diff\n", + "def counting_metric(logits, answer_token_indices=correct_incorrect_indices):\n", + " return (logit_diff(logits, answer_token_indices) - CORRUPTED_BASELINE) / (CLEAN_BASELINE - CORRUPTED_BASELINE) - 1" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, we define a generic function to patch over any head in the model at any specified position, we call this the `head_patcher`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def head_patcher(layer: int,\n", + " head_index: int,\n", + " pos: int,\n", + " clean_tokens: TT[\"batch\", \"pos\"],\n", + " corrupted_tokens: TT[\"batch\", \"pos\"] = None,\n", + " corrupted_cache: ActivationCache = None,\n", + " prepend_bos: bool = True,\n", + " comp = None):\n", + "\n", + " if corrupted_cache is None:\n", + " _, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=prepend_bos)\n", + " \n", + " def patch_clean_head_vector(\n", + " clean_head_vector: TT[\"batch pos head_index d_head\"],\n", + " hook, \n", + " head_index, \n", + " corrupted_cache):\n", + " clean_head_vector[:, pos, head_index, :] = corrupted_cache[hook.name][:, pos, head_index, :]\n", + " return clean_head_vector\n", + " \n", + " hook_fn = partial(patch_clean_head_vector, head_index=head_index, corrupted_cache=corrupted_cache)\n", + "\n", + " if comp is None:\n", + " activation_name = utils.get_act_name(\"z\", layer, \"attn\")\n", + " patched_logits = model.run_with_hooks(\n", + " clean_tokens,\n", + " fwd_hooks = [(activation_name, hook_fn)],\n", + " return_type = \"logits\",\n", + " )\n", + "\n", + " else:\n", + " assert comp in [\"q\", \"k\", \"v\"]\n", + " activation_name = f\"blocks.{layer}.attn.hook_{comp}\"\n", + "\n", + " patched_logits = model.run_with_hooks(\n", + " clean_tokens,\n", + " fwd_hooks = [(activation_name, hook_fn)],\n", + " return_type = \"logits\",\n", + " )\n", + " \n", + " model.reset_hooks()\n", + "\n", + " return patched_logits" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use this function to patch over (Layer 10, Head 0) at the `PATH_START` position." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "head_patched_logits = head_patcher(10, 0, -1, clean_tokens, corrupted_tokens, comp = None)\n", + "original_logit_diff = counting_metric(clean_logits, correct_incorrect_indices).item()\n", + "patched_head_logit_diff = counting_metric(head_patched_logits, correct_incorrect_indices).item()\n", + "print(f\"Original logit diff: {original_logit_diff:.4f}\\n\")\n", + "print(f\"Patched logit diff: {patched_head_logit_diff:.4f}\\n\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We find that patching over this head as a *very* small negative effect on the models ability to do the PATH_START task. Remember for reference, a result of 0 is literally no change, -1 is a complete loss in ability to do the task and a result > 0 is an active improvement in the model's ability to do the task.\n", + "\n", + "As before, we set up another function that calls the `head_patcher` to recursively check every head at every position." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def recursive_head_patching(clean_tokens: TT[\"batch\", \"pos\"],\n", + " corrupted_cache: ActivationCache = None,\n", + " comp: str | None = None, \n", + " pos: int | None = -1):\n", + "\n", + " if pos:\n", + " head_patches = torch.zeros(model.cfg.n_layers, model.cfg.n_heads, device = device, dtype = torch.float32)\n", + " for layer in range(model.cfg.n_layers):\n", + " for head in range(model.cfg.n_heads):\n", + " patched_logit_diff = counting_metric(head_patcher(layer = layer, \n", + " head_index = head, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache, \n", + " comp = comp), correct_incorrect_indices).item()\n", + " head_patches[layer, head] = patched_logit_diff\n", + "\n", + " else:\n", + " all_pos = [x for x in range(len(clean_tokens[0]))]\n", + " head_patches = torch.zeros(model.cfg.n_layers*model.cfg.n_heads, len(all_pos), device = device, dtype = torch.float32)\n", + " for pos in all_pos:\n", + " for layer in range(model.cfg.n_layers):\n", + " for head in range(model.cfg.n_heads):\n", + " head_idx = layer*model.cfg.n_heads + head\n", + " patched_logit_diff = counting_metric(head_patcher(layer = layer, \n", + " head_index = head, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache, \n", + " comp = comp), correct_incorrect_indices).item()\n", + " head_patches[head_idx, pos] = patched_logit_diff\n", + " \n", + " return head_patches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "head_patches = recursive_head_patching(clean_tokens, corrupted_cache, comp = None, pos = None)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another generic function to make visualising the results easy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def head_patching_imshow(head_patches, layerhead_labels, pos_labels):\n", + " fig = imshow(head_patches, \n", + " title = 'Normalised Change in Logit Diff Performance From Patched Head at Given position', \n", + " aspect = \"auto\", \n", + " xlabel= \"Pos\", \n", + " ylabel= \"Layer\",\n", + " xticks = pos_labels,\n", + " yticks = layerhead_labels,\n", + " height = 720,\n", + " width = 720)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creating a label for every head in the model for visualization of the form: Layer.Head (ie. Layer 10 Head 5 => 10.5)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "layerhead_labels = [f\"{layer}.{head}\" for layer in range(model.cfg.n_layers) for head in range(model.cfg.n_heads)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "head_patching_imshow(head_patches, layerhead_labels, pos_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now crease a function to collect large effects across all of these recursive runs to make it easier to pull out the most meaningful activation patching results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def collect_large_effect(patching_effect, threshold):\n", + " for head_idx, head_value in enumerate(patching_effect):\n", + " for pos_idx, pos_value in enumerate(head_value):\n", + " layer = str(head_idx // 12)\n", + " head = str(head_idx % 12)\n", + " # If patching over causes greater than the threshold normalized logit diff drop decrease in performance print it out\n", + " if pos_value < -threshold:\n", + " print(f'Layer {layer} Head {head} has a large negative effect if removed at position: \"{pos_labels[pos_idx]}\" with perf. change of {pos_value:.2f}.')\n", + " # If patching over causes greater than the threshold normalized logit diff gain in performance print it out\n", + " if pos_value > threshold:\n", + " print(f'Layer {layer} Head {head} has a large positive effect if removed at position: \"{pos_labels[pos_idx]}\" with perf. change of {pos_value:.2f}.')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We run this function on the head patching results and find that there are a few early layer heads at the `ORIGIN` token and `PATH_START` token positions that if patched over have a considerably large negative effect on performance." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "collect_large_effect(head_patches, 0.1) # Note the choice of a 0.1 threshold is arbitrary but seems to strike a balance between finding interesting results and not printing too much" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It does appear to be the case that the following heads are doing meaningful computation for this task:\n", + "\n", + "* Layer 0 Head 0 at the `PATH_START` token\n", + "* Layer 0 Head 2 at the `ORIGIN` token\n", + "* Layer 0 Head 2 at the `PATH_START` token\n", + "* Layer 0 Head 3 at the `PATH_START` token\n", + "* Layer 0 Head 4 at the `PATH_START` token\n", + "* Layer 1 Head 1 at the `PATH_START` token\n", + "* Layer 3 Head 9 at the `PATH_START` token\n", + "\n", + "One hypothesis here is that (1.1 and 3.9) act as ORIGIN_TOKEN movers that are active on the PATH_START token and compose with the ORIGIN token (via key/values). Additionally, it may be the case Layer 0 Head 2 is passing information to these heads about the ORIGIN token but it is unclear what this looks like currently.\n", + "\n", + "We will undertake a similar investigation with the MLPs, first setting up a generic `mlp_patcher`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mlp_patcher(layer: int, \n", + "\t\t\t\tpos: int, \n", + "\t\t\t\tclean_tokens: TT[\"batch\", \"pos\"],\n", + "\t\t\t\tcorrupted_tokens: TT[\"batch\", \"pos\"] = None,\n", + "\t\t\t\tcorrupted_cache: ActivationCache = None, \n", + "\t\t\t\tprepend_bos=True):\n", + "\n", + "\tif corrupted_cache is None:\n", + "\t\t_, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=prepend_bos)\n", + "\n", + "\tdef patch_clean_head_vector(\n", + "\t\tclean_head_vector: Float[torch.Tensor, \"batch pos d_head\"],\n", + "\t\thook, \n", + "\t\tcorrupted_cache):\n", + "\t\tclean_head_vector[:, pos, :] = corrupted_cache[hook.name][:, pos, :]\n", + "\t\treturn clean_head_vector\n", + "\n", + "\thook_fn = partial(patch_clean_head_vector, corrupted_cache=corrupted_cache)\n", + "\tactivation_name = f'blocks.{layer}.hook_mlp_out'\n", + "\n", + "\tpatched_logits = model.run_with_hooks(\n", + "\t\t\t\t\tclean_tokens,\n", + "\t\t\t\t\tfwd_hooks = [(activation_name, hook_fn)],\n", + "\t\t\t\t\treturn_type = \"logits\",\n", + "\t\t\t\t\t)\n", + "\t\n", + "\tmodel.reset_hooks()\n", + "\n", + "\treturn patched_logits" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again we use our generic `mlp_patcher` to set up a function to recursively patch over each MLP at each position. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def recursive_mlp_patching(clean_tokens: TT[\"batch\", \"pos\"],\n", + " corrupted_cache: ActivationCache | None = None,\n", + " pos: int = -1):\n", + "\n", + " if pos:\n", + " mlp_patches = torch.zeros(model.cfg.n_layers, 1, device = device, dtype = torch.float32)\n", + " for layer in range(model.cfg.n_layers):\n", + " patched_logit_diff = counting_metric(mlp_patcher(\n", + " layer = layer, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache\n", + " ), correct_incorrect_indices).item()\n", + " mlp_patches[layer] = patched_logit_diff\n", + "\n", + " else:\n", + " all_pos = [x for x in range(len(clean_tokens[0]))]\n", + " mlp_patches = torch.zeros(model.cfg.n_layers, len(all_pos), device = device, dtype = torch.float32)\n", + " for pos in all_pos:\n", + " for layer in range(model.cfg.n_layers):\n", + " patched_logit_diff = counting_metric(mlp_patcher(\n", + " layer = layer, \n", + " pos = pos, \n", + " clean_tokens = clean_tokens, \n", + " corrupted_cache = corrupted_cache\n", + " ), correct_incorrect_indices).item()\n", + " mlp_patches[layer, pos] = patched_logit_diff\n", + " \n", + " return mlp_patches" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mlp_patches = recursive_mlp_patching(clean_tokens, corrupted_cache, pos = None)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally setting up a similar plotting function to easily visualize results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def mlp_patching_imshow(mlp_patches, pos_labels):\n", + " fig = imshow(mlp_patches, \n", + " title = 'Normalised Change in Logit Diff Performance From Patched MLP Block at Given position', \n", + " aspect = \"auto\", \n", + " xlabel= \"Position\", \n", + " ylabel= \"Layer\",\n", + " xticks = pos_labels,\n", + " height = 720,\n", + " width = 720)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mlp_patching_imshow(mlp_patches, pos_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These results suggest the following:\n", + "* Patching over either MLP0 or MLP1 on the ORIGIN token has a significant effect on the model's ability to do this task.\n", + "* Patching over MLP0, MLP1, MLP2, MLP5, MLP8, MLP9, MLP10 or MLP11 on the PATH_START token has a significant effect on the model's ability to this task.\n", + "\n", + "We can also get check that our original activation patching was capturing all important positions by setting all of the tokens in the corrupt dataset to random tokens, this analysis will take considerably longer to run though. After this analysis, we will move back to corrupting individual tokens. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Start by patching the END token with a random value from the model's vocab\n", + "corrupted_tokens = torch.randint_like(clean_tokens, 0, model.cfg.d_vocab) \n", + "\n", + "# Corrupt Forward Pass\n", + "print(f'First Corrupt Prompt: {model.to_str_tokens(corrupted_tokens[0])}\\n')\n", + "corrupted_logits, corrupted_cache = model.run_with_cache(corrupted_tokens, prepend_bos=True)\n", + "\n", + "# Clean Forward Pass\n", + "print(f'First Clean Prompt: {model.to_str_tokens(clean_tokens[0])}\\n')\n", + "clean_logits, clean_cache = model.run_with_cache(clean_tokens, prepend_bos=True)\n", + "\n", + "clean_logit_diff = logit_diff(clean_logits, correct_incorrect_indices).item()\n", + "print(f\"Clean logit diff: {clean_logit_diff:.4f}\")\n", + "\n", + "corrupted_logit_diff = logit_diff(corrupted_logits, correct_incorrect_indices).item()\n", + "print(f\"Corrupted logit diff: {corrupted_logit_diff:.4f}\")\n", + "\n", + "CLEAN_BASELINE = clean_logit_diff\n", + "CORRUPTED_BASELINE = corrupted_logit_diff\n", + "def counting_metric(logits, answer_token_indices=correct_incorrect_indices):\n", + " return (logit_diff(logits, answer_token_indices) - CORRUPTED_BASELINE) / (CLEAN_BASELINE - CORRUPTED_BASELINE) - 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "head_patching = recursive_head_patching(clean_tokens = clean_tokens, corrupted_cache = corrupted_cache, comp = None, pos = None)\n", + "head_patching_imshow(head_patching, layerhead_labels = layerhead_labels, pos_labels=pos_labels)\n", + "collect_large_effect(head_patching, 0.1) # Again arbitrary threshold" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, we find a number of heads that are important on the PATH_START and ORIGIN tokens, here we find that there is also important computation occuring at the ADJLIST_END token.\n", + "\n", + "Doing the same for the MLPs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mlp_patching = recursive_mlp_patching(clean_tokens = clean_tokens, corrupted_cache = corrupted_cache, pos = None)\n", + "mlp_patching_imshow(mlp_patching, pos_labels=pos_labels)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again we see important computation occuring not only on the ORIGIN and PATH_START token but also at the ADJLIST_END token.\n", + "\n", + "This analysis will continue by patching over each of these tokens individually, first at PATH_START, then ORIGIN and then the ADJLIST_END token.\n", + "\n", + "However, thus far it does still appear to the case that a significant amount of this task is being achieved by MLPs. This is counterintuitive for a task of this nature (which just involves passing information from one token (the ORIGIN token) that is always sandwiched between ORIGIN_START and ORIGIN_END to another token (the PATH_START token)). Some further behavioural analysis conducted outside of this notebook suggests that this instance of maze-transformer is not capable of doing this task on out-of-distribution examples. For this reason, the analysis will be paused here." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "maze-transformer", + "language": "python", + "name": "maze-transformer" + }, + "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.1" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/poetry.lock b/poetry.lock index 7175cc96..fb743927 100644 --- a/poetry.lock +++ b/poetry.lock @@ -124,24 +124,24 @@ frozenlist = ">=1.1.0" [[package]] name = "anyio" -version = "3.7.1" +version = "4.0.0" description = "High level compatibility layer for multiple asynchronous event loop implementations" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "anyio-3.7.1-py3-none-any.whl", hash = "sha256:91dee416e570e92c64041bd18b900d1d6fa78dff7048769ce5ac5ddad004fbb5"}, - {file = "anyio-3.7.1.tar.gz", hash = "sha256:44a3c9aba0f5defa43261a8b3efb97891f2bd7d804e0e1f56419befa1adfc780"}, + {file = "anyio-4.0.0-py3-none-any.whl", hash = "sha256:cfdb2b588b9fc25ede96d8db56ed50848b0b649dca3dd1df0b11f683bb9e0b5f"}, + {file = "anyio-4.0.0.tar.gz", hash = "sha256:f7ed51751b2c2add651e5747c891b47e26d2a21be5d32d9311dfe9692f3e5d7a"}, ] [package.dependencies] -exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} idna = ">=2.8" sniffio = ">=1.1" [package.extras] -doc = ["Sphinx", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme (>=1.2.2)", "sphinxcontrib-jquery"] -test = ["anyio[trio]", "coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "mock (>=4)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] -trio = ["trio (<0.22)"] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] +trio = ["trio (>=0.22)"] [[package]] name = "appdirs" @@ -167,22 +167,23 @@ files = [ [[package]] name = "argon2-cffi" -version = "21.3.0" -description = "The secure Argon2 password hashing algorithm." +version = "23.1.0" +description = "Argon2 for Python" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "argon2-cffi-21.3.0.tar.gz", hash = "sha256:d384164d944190a7dd7ef22c6aa3ff197da12962bd04b17f64d4e93d934dba5b"}, - {file = "argon2_cffi-21.3.0-py3-none-any.whl", hash = "sha256:8c976986f2c5c0e5000919e6de187906cfd81fb1c72bf9d88c01177e77da7f80"}, + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, ] [package.dependencies] argon2-cffi-bindings = "*" [package.extras] -dev = ["cogapp", "coverage[toml] (>=5.0.2)", "furo", "hypothesis", "pre-commit", "pytest", "sphinx", "sphinx-notfound-page", "tomli"] -docs = ["furo", "sphinx", "sphinx-notfound-page"] -tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pytest"] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] [[package]] name = "argon2-cffi-bindings" @@ -223,31 +224,36 @@ tests = ["pytest"] [[package]] name = "arrow" -version = "1.2.3" +version = "1.3.0" description = "Better dates & times for Python" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" files = [ - {file = "arrow-1.2.3-py3-none-any.whl", hash = "sha256:5a49ab92e3b7b71d96cd6bfcc4df14efefc9dfa96ea19045815914a6ab6b1fe2"}, - {file = "arrow-1.2.3.tar.gz", hash = "sha256:3934b30ca1b9f292376d9db15b19446088d12ec58629bc3f0da28fd55fb633a1"}, + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, ] [package.dependencies] python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] [[package]] name = "asttokens" -version = "2.2.1" +version = "2.4.0" description = "Annotate AST trees with source code positions" optional = false python-versions = "*" files = [ - {file = "asttokens-2.2.1-py2.py3-none-any.whl", hash = "sha256:6b0ac9e93fb0335014d382b8fa9b3afa7df546984258005da0b9e7095b3deb1c"}, - {file = "asttokens-2.2.1.tar.gz", hash = "sha256:4622110b2a6f30b77e1473affaa97e711bc2f07d3f10848420ff1898edbe94f3"}, + {file = "asttokens-2.4.0-py2.py3-none-any.whl", hash = "sha256:cf8fc9e61a86461aa9fb161a14a0841a03c405fa829ac6b202670b3495d2ce69"}, + {file = "asttokens-2.4.0.tar.gz", hash = "sha256:2e0171b991b2c959acc6c49318049236844a5da1d65ba2672c4880c1c894834e"}, ] [package.dependencies] -six = "*" +six = ">=1.12.0" [package.extras] test = ["astroid", "pytest"] @@ -268,13 +274,13 @@ typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} [[package]] name = "async-timeout" -version = "4.0.2" +version = "4.0.3" description = "Timeout context manager for asyncio programs" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "async-timeout-4.0.2.tar.gz", hash = "sha256:2163e1640ddb52b7a8c80d0a67a08587e5d245cc9c553a74a847056bc2976b15"}, - {file = "async_timeout-4.0.2-py3-none-any.whl", hash = "sha256:8ca1e4fcf50d07413d66d1a5e416e42cfdf5851c981d679a09851a6853383b3c"}, + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, ] [[package]] @@ -317,6 +323,24 @@ files = [ {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, ] +[[package]] +name = "beartype" +version = "0.14.1" +description = "Unbearably fast runtime type checking in pure Python." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "beartype-0.14.1-py3-none-any.whl", hash = "sha256:0f70fccdb8eb6d7ddfaa3ffe3a0b66cf2edeb13452bd71ad46615775c2fa34f6"}, + {file = "beartype-0.14.1.tar.gz", hash = "sha256:23df4715d19cebb2ce60e53c3cf44cd925843f00c71938222d777ea6332de3cb"}, +] + +[package.extras] +all = ["typing-extensions (>=3.10.0.0)"] +dev = ["autoapi (>=0.9.0)", "coverage (>=5.5)", "mypy (>=0.800)", "numpy", "pandera", "pydata-sphinx-theme (<=0.7.2)", "pytest (>=4.0.0)", "sphinx", "sphinx (>=4.2.0,<6.0.0)", "sphinxext-opengraph (>=0.7.5)", "tox (>=3.20.1)", "typing-extensions (>=3.10.0.0)"] +doc-rtd = ["autoapi (>=0.9.0)", "pydata-sphinx-theme (<=0.7.2)", "sphinx (>=4.2.0,<6.0.0)", "sphinxext-opengraph (>=0.7.5)"] +test-tox = ["mypy (>=0.800)", "numpy", "pandera", "pytest (>=4.0.0)", "sphinx", "typing-extensions (>=3.10.0.0)"] +test-tox-coverage = ["coverage (>=5.5)"] + [[package]] name = "beautifulsoup4" version = "4.12.2" @@ -337,33 +361,33 @@ lxml = ["lxml"] [[package]] name = "black" -version = "23.7.0" +version = "23.9.1" description = "The uncompromising code formatter." optional = false python-versions = ">=3.8" files = [ - {file = "black-23.7.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:5c4bc552ab52f6c1c506ccae05681fab58c3f72d59ae6e6639e8885e94fe2587"}, - {file = "black-23.7.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:552513d5cd5694590d7ef6f46e1767a4df9af168d449ff767b13b084c020e63f"}, - {file = "black-23.7.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:86cee259349b4448adb4ef9b204bb4467aae74a386bce85d56ba4f5dc0da27be"}, - {file = "black-23.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:501387a9edcb75d7ae8a4412bb8749900386eaef258f1aefab18adddea1936bc"}, - {file = "black-23.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:fb074d8b213749fa1d077d630db0d5f8cc3b2ae63587ad4116e8a436e9bbe995"}, - {file = "black-23.7.0-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:b5b0ee6d96b345a8b420100b7d71ebfdd19fab5e8301aff48ec270042cd40ac2"}, - {file = "black-23.7.0-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:893695a76b140881531062d48476ebe4a48f5d1e9388177e175d76234ca247cd"}, - {file = "black-23.7.0-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:c333286dc3ddca6fdff74670b911cccedacb4ef0a60b34e491b8a67c833b343a"}, - {file = "black-23.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:831d8f54c3a8c8cf55f64d0422ee875eecac26f5f649fb6c1df65316b67c8926"}, - {file = "black-23.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:7f3bf2dec7d541b4619b8ce526bda74a6b0bffc480a163fed32eb8b3c9aed8ad"}, - {file = "black-23.7.0-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:f9062af71c59c004cd519e2fb8f5d25d39e46d3af011b41ab43b9c74e27e236f"}, - {file = "black-23.7.0-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:01ede61aac8c154b55f35301fac3e730baf0c9cf8120f65a9cd61a81cfb4a0c3"}, - {file = "black-23.7.0-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:327a8c2550ddc573b51e2c352adb88143464bb9d92c10416feb86b0f5aee5ff6"}, - {file = "black-23.7.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d1c6022b86f83b632d06f2b02774134def5d4d4f1dac8bef16d90cda18ba28a"}, - {file = "black-23.7.0-cp38-cp38-win_amd64.whl", hash = "sha256:27eb7a0c71604d5de083757fbdb245b1a4fae60e9596514c6ec497eb63f95320"}, - {file = "black-23.7.0-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:8417dbd2f57b5701492cd46edcecc4f9208dc75529bcf76c514864e48da867d9"}, - {file = "black-23.7.0-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:47e56d83aad53ca140da0af87678fb38e44fd6bc0af71eebab2d1f59b1acf1d3"}, - {file = "black-23.7.0-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:25cc308838fe71f7065df53aedd20327969d05671bac95b38fdf37ebe70ac087"}, - {file = "black-23.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:642496b675095d423f9b8448243336f8ec71c9d4d57ec17bf795b67f08132a91"}, - {file = "black-23.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:ad0014efc7acf0bd745792bd0d8857413652979200ab924fbf239062adc12491"}, - {file = "black-23.7.0-py3-none-any.whl", hash = "sha256:9fd59d418c60c0348505f2ddf9609c1e1de8e7493eab96198fc89d9f865e7a96"}, - {file = "black-23.7.0.tar.gz", hash = "sha256:022a582720b0d9480ed82576c920a8c1dde97cc38ff11d8d8859b3bd6ca9eedb"}, + {file = "black-23.9.1-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:d6bc09188020c9ac2555a498949401ab35bb6bf76d4e0f8ee251694664df6301"}, + {file = "black-23.9.1-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:13ef033794029b85dfea8032c9d3b92b42b526f1ff4bf13b2182ce4e917f5100"}, + {file = "black-23.9.1-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:75a2dc41b183d4872d3a500d2b9c9016e67ed95738a3624f4751a0cb4818fe71"}, + {file = "black-23.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13a2e4a93bb8ca74a749b6974925c27219bb3df4d42fc45e948a5d9feb5122b7"}, + {file = "black-23.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:adc3e4442eef57f99b5590b245a328aad19c99552e0bdc7f0b04db6656debd80"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:8431445bf62d2a914b541da7ab3e2b4f3bc052d2ccbf157ebad18ea126efb91f"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:8fc1ddcf83f996247505db6b715294eba56ea9372e107fd54963c7553f2b6dfe"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:7d30ec46de88091e4316b17ae58bbbfc12b2de05e069030f6b747dfc649ad186"}, + {file = "black-23.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:031e8c69f3d3b09e1aa471a926a1eeb0b9071f80b17689a655f7885ac9325a6f"}, + {file = "black-23.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:538efb451cd50f43aba394e9ec7ad55a37598faae3348d723b59ea8e91616300"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:638619a559280de0c2aa4d76f504891c9860bb8fa214267358f0a20f27c12948"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:a732b82747235e0542c03bf352c126052c0fbc458d8a239a94701175b17d4855"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:cf3a4d00e4cdb6734b64bf23cd4341421e8953615cba6b3670453737a72ec204"}, + {file = "black-23.9.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf99f3de8b3273a8317681d8194ea222f10e0133a24a7548c73ce44ea1679377"}, + {file = "black-23.9.1-cp38-cp38-win_amd64.whl", hash = "sha256:14f04c990259576acd093871e7e9b14918eb28f1866f91968ff5524293f9c573"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:c619f063c2d68f19b2d7270f4cf3192cb81c9ec5bc5ba02df91471d0b88c4c5c"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:6a3b50e4b93f43b34a9d3ef00d9b6728b4a722c997c99ab09102fd5efdb88325"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:c46767e8df1b7beefb0899c4a95fb43058fa8500b6db144f4ff3ca38eb2f6393"}, + {file = "black-23.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50254ebfa56aa46a9fdd5d651f9637485068a1adf42270148cd101cdf56e0ad9"}, + {file = "black-23.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:403397c033adbc45c2bd41747da1f7fc7eaa44efbee256b53842470d4ac5a70f"}, + {file = "black-23.9.1-py3-none-any.whl", hash = "sha256:6ccd59584cc834b6d127628713e4b6b968e5f79572da66284532525a042549f9"}, + {file = "black-23.9.1.tar.gz", hash = "sha256:24b6b3ff5c6d9ea08a8888f6977eae858e1f340d7260cf56d70a49823236b62d"}, ] [package.dependencies] @@ -373,6 +397,7 @@ packaging = ">=22.0" pathspec = ">=0.9.0" platformdirs = ">=2" tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""} [package.extras] colorama = ["colorama (>=0.4.3)"] @@ -411,75 +436,63 @@ files = [ [[package]] name = "cffi" -version = "1.15.1" +version = "1.16.0" description = "Foreign Function Interface for Python calling C code." optional = false -python-versions = "*" +python-versions = ">=3.8" files = [ - {file = "cffi-1.15.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2"}, - {file = "cffi-1.15.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2"}, - {file = "cffi-1.15.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:9ad5db27f9cabae298d151c85cf2bad1d359a1b9c686a275df03385758e2f914"}, - {file = "cffi-1.15.1-cp27-cp27m-win32.whl", hash = "sha256:b3bbeb01c2b273cca1e1e0c5df57f12dce9a4dd331b4fa1635b8bec26350bde3"}, - {file = "cffi-1.15.1-cp27-cp27m-win_amd64.whl", hash = "sha256:e00b098126fd45523dd056d2efba6c5a63b71ffe9f2bbe1a4fe1716e1d0c331e"}, - {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:d61f4695e6c866a23a21acab0509af1cdfd2c013cf256bbf5b6b5e2695827162"}, - {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:ed9cb427ba5504c1dc15ede7d516b84757c3e3d7868ccc85121d9310d27eed0b"}, - {file = "cffi-1.15.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21"}, - {file = "cffi-1.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4"}, - {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01"}, - {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e"}, - {file = "cffi-1.15.1-cp310-cp310-win32.whl", hash = "sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2"}, - {file = "cffi-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d"}, - {file = "cffi-1.15.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac"}, - {file = "cffi-1.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c"}, - {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef"}, - {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8"}, - {file = "cffi-1.15.1-cp311-cp311-win32.whl", hash = "sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d"}, - {file = "cffi-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104"}, - {file = "cffi-1.15.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50a74364d85fd319352182ef59c5c790484a336f6db772c1a9231f1c3ed0cbd7"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e263d77ee3dd201c3a142934a086a4450861778baaeeb45db4591ef65550b0a6"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cec7d9412a9102bdc577382c3929b337320c4c4c4849f2c5cdd14d7368c5562d"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4289fc34b2f5316fbb762d75362931e351941fa95fa18789191b33fc4cf9504a"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:173379135477dc8cac4bc58f45db08ab45d228b3363adb7af79436135d028405"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:6975a3fac6bc83c4a65c9f9fcab9e47019a11d3d2cf7f3c0d03431bf145a941e"}, - {file = "cffi-1.15.1-cp36-cp36m-win32.whl", hash = "sha256:2470043b93ff09bf8fb1d46d1cb756ce6132c54826661a32d4e4d132e1977adf"}, - {file = "cffi-1.15.1-cp36-cp36m-win_amd64.whl", hash = "sha256:30d78fbc8ebf9c92c9b7823ee18eb92f2e6ef79b45ac84db507f52fbe3ec4497"}, - {file = "cffi-1.15.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426"}, - {file = "cffi-1.15.1-cp37-cp37m-win32.whl", hash = "sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9"}, - {file = "cffi-1.15.1-cp37-cp37m-win_amd64.whl", hash = "sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045"}, - {file = "cffi-1.15.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192"}, - {file = "cffi-1.15.1-cp38-cp38-win32.whl", hash = "sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314"}, - {file = "cffi-1.15.1-cp38-cp38-win_amd64.whl", hash = "sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5"}, - {file = "cffi-1.15.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585"}, - {file = "cffi-1.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27"}, - {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76"}, - {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3"}, - {file = "cffi-1.15.1-cp39-cp39-win32.whl", hash = "sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee"}, - {file = "cffi-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c"}, - {file = "cffi-1.15.1.tar.gz", hash = "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, ] [package.dependencies] @@ -487,97 +500,112 @@ pycparser = "*" [[package]] name = "charset-normalizer" -version = "3.2.0" +version = "3.3.0" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7.0" files = [ - {file = "charset-normalizer-3.2.0.tar.gz", hash = "sha256:3bb3d25a8e6c0aedd251753a79ae98a093c7e7b471faa3aa9a93a81431987ace"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b87549028f680ca955556e3bd57013ab47474c3124dc069faa0b6545b6c9710"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7c70087bfee18a42b4040bb9ec1ca15a08242cf5867c58726530bdf3945672ed"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a103b3a7069b62f5d4890ae1b8f0597618f628b286b03d4bc9195230b154bfa9"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94aea8eff76ee6d1cdacb07dd2123a68283cb5569e0250feab1240058f53b623"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db901e2ac34c931d73054d9797383d0f8009991e723dab15109740a63e7f902a"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0dac0ff919ba34d4df1b6131f59ce95b08b9065233446be7e459f95554c0dc8"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:193cbc708ea3aca45e7221ae58f0fd63f933753a9bfb498a3b474878f12caaad"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09393e1b2a9461950b1c9a45d5fd251dc7c6f228acab64da1c9c0165d9c7765c"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:baacc6aee0b2ef6f3d308e197b5d7a81c0e70b06beae1f1fcacffdbd124fe0e3"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bf420121d4c8dce6b889f0e8e4ec0ca34b7f40186203f06a946fa0276ba54029"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c04a46716adde8d927adb9457bbe39cf473e1e2c2f5d0a16ceb837e5d841ad4f"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aaf63899c94de41fe3cf934601b0f7ccb6b428c6e4eeb80da72c58eab077b19a"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62e51710986674142526ab9f78663ca2b0726066ae26b78b22e0f5e571238dd"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-win32.whl", hash = "sha256:04e57ab9fbf9607b77f7d057974694b4f6b142da9ed4a199859d9d4d5c63fe96"}, - {file = "charset_normalizer-3.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:48021783bdf96e3d6de03a6e39a1171ed5bd7e8bb93fc84cc649d11490f87cea"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4957669ef390f0e6719db3613ab3a7631e68424604a7b448f079bee145da6e09"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46fb8c61d794b78ec7134a715a3e564aafc8f6b5e338417cb19fe9f57a5a9bf2"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f779d3ad205f108d14e99bb3859aa7dd8e9c68874617c72354d7ecaec2a054ac"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f25c229a6ba38a35ae6e25ca1264621cc25d4d38dca2942a7fce0b67a4efe918"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2efb1bd13885392adfda4614c33d3b68dee4921fd0ac1d3988f8cbb7d589e72a"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f30b48dd7fa1474554b0b0f3fdfdd4c13b5c737a3c6284d3cdc424ec0ffff3a"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:246de67b99b6851627d945db38147d1b209a899311b1305dd84916f2b88526c6"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd9b3b31adcb054116447ea22caa61a285d92e94d710aa5ec97992ff5eb7cf3"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8c2f5e83493748286002f9369f3e6607c565a6a90425a3a1fef5ae32a36d749d"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3170c9399da12c9dc66366e9d14da8bf7147e1e9d9ea566067bbce7bb74bd9c2"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7a4826ad2bd6b07ca615c74ab91f32f6c96d08f6fcc3902ceeedaec8cdc3bcd6"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3b1613dd5aee995ec6d4c69f00378bbd07614702a315a2cf6c1d21461fe17c23"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9e608aafdb55eb9f255034709e20d5a83b6d60c054df0802fa9c9883d0a937aa"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-win32.whl", hash = "sha256:f2a1d0fd4242bd8643ce6f98927cf9c04540af6efa92323e9d3124f57727bfc1"}, - {file = "charset_normalizer-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:681eb3d7e02e3c3655d1b16059fbfb605ac464c834a0c629048a30fad2b27489"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c57921cda3a80d0f2b8aec7e25c8aa14479ea92b5b51b6876d975d925a2ea346"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41b25eaa7d15909cf3ac4c96088c1f266a9a93ec44f87f1d13d4a0e86c81b982"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f058f6963fd82eb143c692cecdc89e075fa0828db2e5b291070485390b2f1c9c"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7647ebdfb9682b7bb97e2a5e7cb6ae735b1c25008a70b906aecca294ee96cf4"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eef9df1eefada2c09a5e7a40991b9fc6ac6ef20b1372abd48d2794a316dc0449"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e03b8895a6990c9ab2cdcd0f2fe44088ca1c65ae592b8f795c3294af00a461c3"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ee4006268ed33370957f55bf2e6f4d263eaf4dc3cfc473d1d90baff6ed36ce4a"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c4983bf937209c57240cff65906b18bb35e64ae872da6a0db937d7b4af845dd7"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:3bb7fda7260735efe66d5107fb7e6af6a7c04c7fce9b2514e04b7a74b06bf5dd"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:72814c01533f51d68702802d74f77ea026b5ec52793c791e2da806a3844a46c3"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:70c610f6cbe4b9fce272c407dd9d07e33e6bf7b4aa1b7ffb6f6ded8e634e3592"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-win32.whl", hash = "sha256:a401b4598e5d3f4a9a811f3daf42ee2291790c7f9d74b18d75d6e21dda98a1a1"}, - {file = "charset_normalizer-3.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c0b21078a4b56965e2b12f247467b234734491897e99c1d51cee628da9786959"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:95eb302ff792e12aba9a8b8f8474ab229a83c103d74a750ec0bd1c1eea32e669"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a100c6d595a7f316f1b6f01d20815d916e75ff98c27a01ae817439ea7726329"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6339d047dab2780cc6220f46306628e04d9750f02f983ddb37439ca47ced7149"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4b749b9cc6ee664a3300bb3a273c1ca8068c46be705b6c31cf5d276f8628a94"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38856a971c602f98472050165cea2cdc97709240373041b69030be15047691f"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f87f746ee241d30d6ed93969de31e5ffd09a2961a051e60ae6bddde9ec3583aa"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f1b185a01fe560bc8ae5f619e924407efca2191b56ce749ec84982fc59a32a"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1c8a2f4c69e08e89632defbfabec2feb8a8d99edc9f89ce33c4b9e36ab63037"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2f4ac36d8e2b4cc1aa71df3dd84ff8efbe3bfb97ac41242fbcfc053c67434f46"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a386ebe437176aab38c041de1260cd3ea459c6ce5263594399880bbc398225b2"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:ccd16eb18a849fd8dcb23e23380e2f0a354e8daa0c984b8a732d9cfaba3a776d"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:e6a5bf2cba5ae1bb80b154ed68a3cfa2fa00fde979a7f50d6598d3e17d9ac20c"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:45de3f87179c1823e6d9e32156fb14c1927fcc9aba21433f088fdfb555b77c10"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-win32.whl", hash = "sha256:1000fba1057b92a65daec275aec30586c3de2401ccdcd41f8a5c1e2c87078706"}, - {file = "charset_normalizer-3.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b2c760cfc7042b27ebdb4a43a4453bd829a5742503599144d54a032c5dc7e9e"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:855eafa5d5a2034b4621c74925d89c5efef61418570e5ef9b37717d9c796419c"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:203f0c8871d5a7987be20c72442488a0b8cfd0f43b7973771640fc593f56321f"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e857a2232ba53ae940d3456f7533ce6ca98b81917d47adc3c7fd55dad8fab858"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e86d77b090dbddbe78867a0275cb4df08ea195e660f1f7f13435a4649e954e5"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fb39a81950ec280984b3a44f5bd12819953dc5fa3a7e6fa7a80db5ee853952"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dee8e57f052ef5353cf608e0b4c871aee320dd1b87d351c28764fc0ca55f9f4"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8700f06d0ce6f128de3ccdbc1acaea1ee264d2caa9ca05daaf492fde7c2a7200"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1920d4ff15ce893210c1f0c0e9d19bfbecb7983c76b33f046c13a8ffbd570252"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c1c76a1743432b4b60ab3358c937a3fe1341c828ae6194108a94c69028247f22"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f7560358a6811e52e9c4d142d497f1a6e10103d3a6881f18d04dbce3729c0e2c"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c8063cf17b19661471ecbdb3df1c84f24ad2e389e326ccaf89e3fb2484d8dd7e"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cd6dbe0238f7743d0efe563ab46294f54f9bc8f4b9bcf57c3c666cc5bc9d1299"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1249cbbf3d3b04902ff081ffbb33ce3377fa6e4c7356f759f3cd076cc138d020"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-win32.whl", hash = "sha256:6c409c0deba34f147f77efaa67b8e4bb83d2f11c8806405f76397ae5b8c0d1c9"}, - {file = "charset_normalizer-3.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:7095f6fbfaa55defb6b733cfeb14efaae7a29f0b59d8cf213be4e7ca0b857b80"}, - {file = "charset_normalizer-3.2.0-py3-none-any.whl", hash = "sha256:8e098148dd37b4ce3baca71fb394c81dc5d9c7728c95df695d2dca218edf40e6"}, + {file = "charset-normalizer-3.3.0.tar.gz", hash = "sha256:63563193aec44bce707e0c5ca64ff69fa72ed7cf34ce6e11d5127555756fd2f6"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:effe5406c9bd748a871dbcaf3ac69167c38d72db8c9baf3ff954c344f31c4cbe"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4162918ef3098851fcd8a628bf9b6a98d10c380725df9e04caf5ca6dd48c847a"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0570d21da019941634a531444364f2482e8db0b3425fcd5ac0c36565a64142c8"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5707a746c6083a3a74b46b3a631d78d129edab06195a92a8ece755aac25a3f3d"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:278c296c6f96fa686d74eb449ea1697f3c03dc28b75f873b65b5201806346a69"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a4b71f4d1765639372a3b32d2638197f5cd5221b19531f9245fcc9ee62d38f56"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5969baeaea61c97efa706b9b107dcba02784b1601c74ac84f2a532ea079403e"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3f93dab657839dfa61025056606600a11d0b696d79386f974e459a3fbc568ec"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:db756e48f9c5c607b5e33dd36b1d5872d0422e960145b08ab0ec7fd420e9d649"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:232ac332403e37e4a03d209a3f92ed9071f7d3dbda70e2a5e9cff1c4ba9f0678"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e5c1502d4ace69a179305abb3f0bb6141cbe4714bc9b31d427329a95acfc8bdd"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:2502dd2a736c879c0f0d3e2161e74d9907231e25d35794584b1ca5284e43f596"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23e8565ab7ff33218530bc817922fae827420f143479b753104ab801145b1d5b"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-win32.whl", hash = "sha256:1872d01ac8c618a8da634e232f24793883d6e456a66593135aeafe3784b0848d"}, + {file = "charset_normalizer-3.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:557b21a44ceac6c6b9773bc65aa1b4cc3e248a5ad2f5b914b91579a32e22204d"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d7eff0f27edc5afa9e405f7165f85a6d782d308f3b6b9d96016c010597958e63"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a685067d05e46641d5d1623d7c7fdf15a357546cbb2f71b0ebde91b175ffc3e"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0d3d5b7db9ed8a2b11a774db2bbea7ba1884430a205dbd54a32d61d7c2a190fa"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2935ffc78db9645cb2086c2f8f4cfd23d9b73cc0dc80334bc30aac6f03f68f8c"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fe359b2e3a7729010060fbca442ca225280c16e923b37db0e955ac2a2b72a05"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:380c4bde80bce25c6e4f77b19386f5ec9db230df9f2f2ac1e5ad7af2caa70459"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0d1e3732768fecb052d90d62b220af62ead5748ac51ef61e7b32c266cac9293"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1b2919306936ac6efb3aed1fbf81039f7087ddadb3160882a57ee2ff74fd2382"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f8888e31e3a85943743f8fc15e71536bda1c81d5aa36d014a3c0c44481d7db6e"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:82eb849f085624f6a607538ee7b83a6d8126df6d2f7d3b319cb837b289123078"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7b8b8bf1189b3ba9b8de5c8db4d541b406611a71a955bbbd7385bbc45fcb786c"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:5adf257bd58c1b8632046bbe43ee38c04e1038e9d37de9c57a94d6bd6ce5da34"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c350354efb159b8767a6244c166f66e67506e06c8924ed74669b2c70bc8735b1"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-win32.whl", hash = "sha256:02af06682e3590ab952599fbadac535ede5d60d78848e555aa58d0c0abbde786"}, + {file = "charset_normalizer-3.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:86d1f65ac145e2c9ed71d8ffb1905e9bba3a91ae29ba55b4c46ae6fc31d7c0d4"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:3b447982ad46348c02cb90d230b75ac34e9886273df3a93eec0539308a6296d7"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:abf0d9f45ea5fb95051c8bfe43cb40cda383772f7e5023a83cc481ca2604d74e"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b09719a17a2301178fac4470d54b1680b18a5048b481cb8890e1ef820cb80455"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3d9b48ee6e3967b7901c052b670c7dda6deb812c309439adaffdec55c6d7b78"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:edfe077ab09442d4ef3c52cb1f9dab89bff02f4524afc0acf2d46be17dc479f5"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3debd1150027933210c2fc321527c2299118aa929c2f5a0a80ab6953e3bd1908"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86f63face3a527284f7bb8a9d4f78988e3c06823f7bea2bd6f0e0e9298ca0403"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24817cb02cbef7cd499f7c9a2735286b4782bd47a5b3516a0e84c50eab44b98e"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c71f16da1ed8949774ef79f4a0260d28b83b3a50c6576f8f4f0288d109777989"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:9cf3126b85822c4e53aa28c7ec9869b924d6fcfb76e77a45c44b83d91afd74f9"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:b3b2316b25644b23b54a6f6401074cebcecd1244c0b8e80111c9a3f1c8e83d65"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:03680bb39035fbcffe828eae9c3f8afc0428c91d38e7d61aa992ef7a59fb120e"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4cc152c5dd831641e995764f9f0b6589519f6f5123258ccaca8c6d34572fefa8"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-win32.whl", hash = "sha256:b8f3307af845803fb0b060ab76cf6dd3a13adc15b6b451f54281d25911eb92df"}, + {file = "charset_normalizer-3.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:8eaf82f0eccd1505cf39a45a6bd0a8cf1c70dcfc30dba338207a969d91b965c0"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:dc45229747b67ffc441b3de2f3ae5e62877a282ea828a5bdb67883c4ee4a8810"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f4a0033ce9a76e391542c182f0d48d084855b5fcba5010f707c8e8c34663d77"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ada214c6fa40f8d800e575de6b91a40d0548139e5dc457d2ebb61470abf50186"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1121de0e9d6e6ca08289583d7491e7fcb18a439305b34a30b20d8215922d43c"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1063da2c85b95f2d1a430f1c33b55c9c17ffaf5e612e10aeaad641c55a9e2b9d"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70f1d09c0d7748b73290b29219e854b3207aea922f839437870d8cc2168e31cc"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:250c9eb0f4600361dd80d46112213dff2286231d92d3e52af1e5a6083d10cad9"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:750b446b2ffce1739e8578576092179160f6d26bd5e23eb1789c4d64d5af7dc7"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:fc52b79d83a3fe3a360902d3f5d79073a993597d48114c29485e9431092905d8"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:588245972aca710b5b68802c8cad9edaa98589b1b42ad2b53accd6910dad3545"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:e39c7eb31e3f5b1f88caff88bcff1b7f8334975b46f6ac6e9fc725d829bc35d4"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-win32.whl", hash = "sha256:abecce40dfebbfa6abf8e324e1860092eeca6f7375c8c4e655a8afb61af58f2c"}, + {file = "charset_normalizer-3.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:24a91a981f185721542a0b7c92e9054b7ab4fea0508a795846bc5b0abf8118d4"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:67b8cc9574bb518ec76dc8e705d4c39ae78bb96237cb533edac149352c1f39fe"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ac71b2977fb90c35d41c9453116e283fac47bb9096ad917b8819ca8b943abecd"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3ae38d325b512f63f8da31f826e6cb6c367336f95e418137286ba362925c877e"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:542da1178c1c6af8873e143910e2269add130a299c9106eef2594e15dae5e482"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30a85aed0b864ac88309b7d94be09f6046c834ef60762a8833b660139cfbad13"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aae32c93e0f64469f74ccc730a7cb21c7610af3a775157e50bbd38f816536b38"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15b26ddf78d57f1d143bdf32e820fd8935d36abe8a25eb9ec0b5a71c82eb3895"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f5d10bae5d78e4551b7be7a9b29643a95aded9d0f602aa2ba584f0388e7a557"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:249c6470a2b60935bafd1d1d13cd613f8cd8388d53461c67397ee6a0f5dce741"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:c5a74c359b2d47d26cdbbc7845e9662d6b08a1e915eb015d044729e92e7050b7"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:b5bcf60a228acae568e9911f410f9d9e0d43197d030ae5799e20dca8df588287"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:187d18082694a29005ba2944c882344b6748d5be69e3a89bf3cc9d878e548d5a"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:81bf654678e575403736b85ba3a7867e31c2c30a69bc57fe88e3ace52fb17b89"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-win32.whl", hash = "sha256:85a32721ddde63c9df9ebb0d2045b9691d9750cb139c161c80e500d210f5e26e"}, + {file = "charset_normalizer-3.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:468d2a840567b13a590e67dd276c570f8de00ed767ecc611994c301d0f8c014f"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e0fc42822278451bc13a2e8626cf2218ba570f27856b536e00cfa53099724828"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:09c77f964f351a7369cc343911e0df63e762e42bac24cd7d18525961c81754f4"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:12ebea541c44fdc88ccb794a13fe861cc5e35d64ed689513a5c03d05b53b7c82"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:805dfea4ca10411a5296bcc75638017215a93ffb584c9e344731eef0dcfb026a"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:96c2b49eb6a72c0e4991d62406e365d87067ca14c1a729a870d22354e6f68115"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aaf7b34c5bc56b38c931a54f7952f1ff0ae77a2e82496583b247f7c969eb1479"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:619d1c96099be5823db34fe89e2582b336b5b074a7f47f819d6b3a57ff7bdb86"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a0ac5e7015a5920cfce654c06618ec40c33e12801711da6b4258af59a8eff00a"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:93aa7eef6ee71c629b51ef873991d6911b906d7312c6e8e99790c0f33c576f89"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7966951325782121e67c81299a031f4c115615e68046f79b85856b86ebffc4cd"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:02673e456dc5ab13659f85196c534dc596d4ef260e4d86e856c3b2773ce09843"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:c2af80fb58f0f24b3f3adcb9148e6203fa67dd3f61c4af146ecad033024dde43"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:153e7b6e724761741e0974fc4dcd406d35ba70b92bfe3fedcb497226c93b9da7"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-win32.whl", hash = "sha256:d47ecf253780c90ee181d4d871cd655a789da937454045b17b5798da9393901a"}, + {file = "charset_normalizer-3.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:d97d85fa63f315a8bdaba2af9a6a686e0eceab77b3089af45133252618e70884"}, + {file = "charset_normalizer-3.3.0-py3-none-any.whl", hash = "sha256:e46cd37076971c1040fc8c41273a8b3e2c624ce4f2be3f5dfcb7a430c1d3acc2"}, ] [[package]] name = "circuitsvis" -version = "1.40.1" +version = "1.41.0" description = "Mechanistic Interpretability Visualizations" optional = false python-versions = ">=3.7,<4.0" files = [ - {file = "circuitsvis-1.40.1-py3-none-any.whl", hash = "sha256:e51755370a0af165142995808b0f829d3c4ed61c8e2d17fe02488f50e5f05d74"}, - {file = "circuitsvis-1.40.1.tar.gz", hash = "sha256:5fd0f8d1972b7a34dbe3e2e305acd6618972bf23b9d5da061bb970ed941e50c0"}, + {file = "circuitsvis-1.41.0-py3-none-any.whl", hash = "sha256:53dc12c955c160b8108a0eb17ed14a34ba9f53b218457d29f351cba3db31acb7"}, + {file = "circuitsvis-1.41.0.tar.gz", hash = "sha256:386385f38d8b9de1bbef125fa282afc9157027bc2dcdc4c04feafbc22bc71d17"}, ] [package.dependencies] @@ -587,13 +615,13 @@ torch = {version = ">=1.10", markers = "python_version >= \"3.8\""} [[package]] name = "click" -version = "8.1.6" +version = "8.1.7" description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" files = [ - {file = "click-8.1.6-py3-none-any.whl", hash = "sha256:fa244bb30b3b5ee2cae3da8f55c9e5e0c0e86093306301fb418eb9dc40fbded5"}, - {file = "click-8.1.6.tar.gz", hash = "sha256:48ee849951919527a045bfe3bf7baa8a959c423134e1a5b98c05c20ba75a1cbd"}, + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, ] [package.dependencies] @@ -631,129 +659,137 @@ typing = ["mypy (>=0.990)"] [[package]] name = "contourpy" -version = "1.1.0" +version = "1.1.1" description = "Python library for calculating contours of 2D quadrilateral grids" optional = false python-versions = ">=3.8" files = [ - {file = "contourpy-1.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:89f06eff3ce2f4b3eb24c1055a26981bffe4e7264acd86f15b97e40530b794bc"}, - {file = "contourpy-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dffcc2ddec1782dd2f2ce1ef16f070861af4fb78c69862ce0aab801495dda6a3"}, - {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25ae46595e22f93592d39a7eac3d638cda552c3e1160255258b695f7b58e5655"}, - {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:17cfaf5ec9862bc93af1ec1f302457371c34e688fbd381f4035a06cd47324f48"}, - {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18a64814ae7bce73925131381603fff0116e2df25230dfc80d6d690aa6e20b37"}, - {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90c81f22b4f572f8a2110b0b741bb64e5a6427e0a198b2cdc1fbaf85f352a3aa"}, - {file = "contourpy-1.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:53cc3a40635abedbec7f1bde60f8c189c49e84ac180c665f2cd7c162cc454baa"}, - {file = "contourpy-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:1f795597073b09d631782e7245016a4323cf1cf0b4e06eef7ea6627e06a37ff2"}, - {file = "contourpy-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0b7b04ed0961647691cfe5d82115dd072af7ce8846d31a5fac6c142dcce8b882"}, - {file = "contourpy-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27bc79200c742f9746d7dd51a734ee326a292d77e7d94c8af6e08d1e6c15d545"}, - {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:052cc634bf903c604ef1a00a5aa093c54f81a2612faedaa43295809ffdde885e"}, - {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9382a1c0bc46230fb881c36229bfa23d8c303b889b788b939365578d762b5c18"}, - {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5cec36c5090e75a9ac9dbd0ff4a8cf7cecd60f1b6dc23a374c7d980a1cd710e"}, - {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f0cbd657e9bde94cd0e33aa7df94fb73c1ab7799378d3b3f902eb8eb2e04a3a"}, - {file = "contourpy-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:181cbace49874f4358e2929aaf7ba84006acb76694102e88dd15af861996c16e"}, - {file = "contourpy-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fb3b7d9e6243bfa1efb93ccfe64ec610d85cfe5aec2c25f97fbbd2e58b531256"}, - {file = "contourpy-1.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bcb41692aa09aeb19c7c213411854402f29f6613845ad2453d30bf421fe68fed"}, - {file = "contourpy-1.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5d123a5bc63cd34c27ff9c7ac1cd978909e9c71da12e05be0231c608048bb2ae"}, - {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62013a2cf68abc80dadfd2307299bfa8f5aa0dcaec5b2954caeb5fa094171103"}, - {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b6616375d7de55797d7a66ee7d087efe27f03d336c27cf1f32c02b8c1a5ac70"}, - {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:317267d915490d1e84577924bd61ba71bf8681a30e0d6c545f577363157e5e94"}, - {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d551f3a442655f3dcc1285723f9acd646ca5858834efeab4598d706206b09c9f"}, - {file = "contourpy-1.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e7a117ce7df5a938fe035cad481b0189049e8d92433b4b33aa7fc609344aafa1"}, - {file = "contourpy-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:d4f26b25b4f86087e7d75e63212756c38546e70f2a92d2be44f80114826e1cd4"}, - {file = "contourpy-1.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc00bb4225d57bff7ebb634646c0ee2a1298402ec10a5fe7af79df9a51c1bfd9"}, - {file = "contourpy-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:189ceb1525eb0655ab8487a9a9c41f42a73ba52d6789754788d1883fb06b2d8a"}, - {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f2931ed4741f98f74b410b16e5213f71dcccee67518970c42f64153ea9313b9"}, - {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30f511c05fab7f12e0b1b7730ebdc2ec8deedcfb505bc27eb570ff47c51a8f15"}, - {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:143dde50520a9f90e4a2703f367cf8ec96a73042b72e68fcd184e1279962eb6f"}, - {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e94bef2580e25b5fdb183bf98a2faa2adc5b638736b2c0a4da98691da641316a"}, - {file = "contourpy-1.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ed614aea8462735e7d70141374bd7650afd1c3f3cb0c2dbbcbe44e14331bf002"}, - {file = "contourpy-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:438ba416d02f82b692e371858143970ed2eb6337d9cdbbede0d8ad9f3d7dd17d"}, - {file = "contourpy-1.1.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a698c6a7a432789e587168573a864a7ea374c6be8d4f31f9d87c001d5a843493"}, - {file = "contourpy-1.1.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:397b0ac8a12880412da3551a8cb5a187d3298a72802b45a3bd1805e204ad8439"}, - {file = "contourpy-1.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:a67259c2b493b00e5a4d0f7bfae51fb4b3371395e47d079a4446e9b0f4d70e76"}, - {file = "contourpy-1.1.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2b836d22bd2c7bb2700348e4521b25e077255ebb6ab68e351ab5aa91ca27e027"}, - {file = "contourpy-1.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084eaa568400cfaf7179b847ac871582199b1b44d5699198e9602ecbbb5f6104"}, - {file = "contourpy-1.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:911ff4fd53e26b019f898f32db0d4956c9d227d51338fb3b03ec72ff0084ee5f"}, - {file = "contourpy-1.1.0.tar.gz", hash = "sha256:e53046c3863828d21d531cc3b53786e6580eb1ba02477e8681009b6aa0870b21"}, + {file = "contourpy-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:46e24f5412c948d81736509377e255f6040e94216bf1a9b5ea1eaa9d29f6ec1b"}, + {file = "contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e48694d6a9c5a26ee85b10130c77a011a4fedf50a7279fa0bdaf44bafb4299d"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a66045af6cf00e19d02191ab578a50cb93b2028c3eefed999793698e9ea768ae"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ebf42695f75ee1a952f98ce9775c873e4971732a87334b099dde90b6af6a916"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6aec19457617ef468ff091669cca01fa7ea557b12b59a7908b9474bb9674cf0"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:462c59914dc6d81e0b11f37e560b8a7c2dbab6aca4f38be31519d442d6cde1a1"}, + {file = "contourpy-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6d0a8efc258659edc5299f9ef32d8d81de8b53b45d67bf4bfa3067f31366764d"}, + {file = "contourpy-1.1.1-cp310-cp310-win32.whl", hash = "sha256:d6ab42f223e58b7dac1bb0af32194a7b9311065583cc75ff59dcf301afd8a431"}, + {file = "contourpy-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:549174b0713d49871c6dee90a4b499d3f12f5e5f69641cd23c50a4542e2ca1eb"}, + {file = "contourpy-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:407d864db716a067cc696d61fa1ef6637fedf03606e8417fe2aeed20a061e6b2"}, + {file = "contourpy-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe80c017973e6a4c367e037cb31601044dd55e6bfacd57370674867d15a899b"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30aaf2b8a2bac57eb7e1650df1b3a4130e8d0c66fc2f861039d507a11760e1b"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3de23ca4f381c3770dee6d10ead6fff524d540c0f662e763ad1530bde5112532"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:566f0e41df06dfef2431defcfaa155f0acfa1ca4acbf8fd80895b1e7e2ada40e"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b04c2f0adaf255bf756cf08ebef1be132d3c7a06fe6f9877d55640c5e60c72c5"}, + {file = "contourpy-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d0c188ae66b772d9d61d43c6030500344c13e3f73a00d1dc241da896f379bb62"}, + {file = "contourpy-1.1.1-cp311-cp311-win32.whl", hash = "sha256:0683e1ae20dc038075d92e0e0148f09ffcefab120e57f6b4c9c0f477ec171f33"}, + {file = "contourpy-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:8636cd2fc5da0fb102a2504fa2c4bea3cbc149533b345d72cdf0e7a924decc45"}, + {file = "contourpy-1.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:560f1d68a33e89c62da5da4077ba98137a5e4d3a271b29f2f195d0fba2adcb6a"}, + {file = "contourpy-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:24216552104ae8f3b34120ef84825400b16eb6133af2e27a190fdc13529f023e"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56de98a2fb23025882a18b60c7f0ea2d2d70bbbcfcf878f9067234b1c4818442"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:07d6f11dfaf80a84c97f1a5ba50d129d9303c5b4206f776e94037332e298dda8"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1eaac5257a8f8a047248d60e8f9315c6cff58f7803971170d952555ef6344a7"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19557fa407e70f20bfaba7d55b4d97b14f9480856c4fb65812e8a05fe1c6f9bf"}, + {file = "contourpy-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:081f3c0880712e40effc5f4c3b08feca6d064cb8cfbb372ca548105b86fd6c3d"}, + {file = "contourpy-1.1.1-cp312-cp312-win32.whl", hash = "sha256:059c3d2a94b930f4dafe8105bcdc1b21de99b30b51b5bce74c753686de858cb6"}, + {file = "contourpy-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f44d78b61740e4e8c71db1cf1fd56d9050a4747681c59ec1094750a658ceb970"}, + {file = "contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:70e5a10f8093d228bb2b552beeb318b8928b8a94763ef03b858ef3612b29395d"}, + {file = "contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bd5680f844c3ff0008523a71949a3ff5e4953eb7701b28760805bc9bcff217"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66544f853bfa85c0d07a68f6c648b2ec81dafd30f272565c37ab47a33b220684"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0c02b75acfea5cab07585d25069207e478d12309557f90a61b5a3b4f77f46ce"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8"}, + {file = "contourpy-1.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f29fb0b3f1217dfe9362ec55440d0743fe868497359f2cf93293f4b2701b8251"}, + {file = "contourpy-1.1.1-cp38-cp38-win32.whl", hash = "sha256:f9dc7f933975367251c1b34da882c4f0e0b2e24bb35dc906d2f598a40b72bfc7"}, + {file = "contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9"}, + {file = "contourpy-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ba42e3810999a0ddd0439e6e5dbf6d034055cdc72b7c5c839f37a7c274cb4eba"}, + {file = "contourpy-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6c06e4c6e234fcc65435223c7b2a90f286b7f1b2733058bdf1345d218cc59e34"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca6fab080484e419528e98624fb5c4282148b847e3602dc8dbe0cb0669469887"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93df44ab351119d14cd1e6b52a5063d3336f0754b72736cc63db59307dabb718"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eafbef886566dc1047d7b3d4b14db0d5b7deb99638d8e1be4e23a7c7ac59ff0f"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe0fab26d598e1ec07d72cf03eaeeba8e42b4ecf6b9ccb5a356fde60ff08b85"}, + {file = "contourpy-1.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f08e469821a5e4751c97fcd34bcb586bc243c39c2e39321822060ba902eac49e"}, + {file = "contourpy-1.1.1-cp39-cp39-win32.whl", hash = "sha256:bfc8a5e9238232a45ebc5cb3bfee71f1167064c8d382cadd6076f0d51cff1da0"}, + {file = "contourpy-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:c84fdf3da00c2827d634de4fcf17e3e067490c4aea82833625c4c8e6cdea0887"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:229a25f68046c5cf8067d6d6351c8b99e40da11b04d8416bf8d2b1d75922521e"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a75cc163a5f4531a256f2c523bd80db509a49fc23721b36dd1ef2f60ff41c3cb"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b53d5769aa1f2d4ea407c65f2d1d08002952fac1d9e9d307aa2e1023554a163"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11b836b7dbfb74e049c302bbf74b4b8f6cb9d0b6ca1bf86cfa8ba144aedadd9c"}, + {file = "contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab"}, ] [package.dependencies] -numpy = ">=1.16" +numpy = [ + {version = ">=1.16,<2.0", markers = "python_version <= \"3.11\""}, + {version = ">=1.26.0rc1,<2.0", markers = "python_version >= \"3.12\""}, +] [package.extras] bokeh = ["bokeh", "selenium"] -docs = ["furo", "sphinx-copybutton"] -mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.2.0)", "types-Pillow"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.4.1)", "types-Pillow"] test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] test-no-images = ["pytest", "pytest-cov", "wurlitzer"] [[package]] name = "coverage" -version = "7.2.7" +version = "7.3.1" description = "Code coverage measurement for Python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "coverage-7.2.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d39b5b4f2a66ccae8b7263ac3c8170994b65266797fb96cbbfd3fb5b23921db8"}, - {file = "coverage-7.2.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d040ef7c9859bb11dfeb056ff5b3872436e3b5e401817d87a31e1750b9ae2fb"}, - {file = "coverage-7.2.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba90a9563ba44a72fda2e85302c3abc71c5589cea608ca16c22b9804262aaeb6"}, - {file = "coverage-7.2.7-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7d9405291c6928619403db1d10bd07888888ec1abcbd9748fdaa971d7d661b2"}, - {file = "coverage-7.2.7-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31563e97dae5598556600466ad9beea39fb04e0229e61c12eaa206e0aa202063"}, - {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ebba1cd308ef115925421d3e6a586e655ca5a77b5bf41e02eb0e4562a111f2d1"}, - {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cb017fd1b2603ef59e374ba2063f593abe0fc45f2ad9abdde5b4d83bd922a353"}, - {file = "coverage-7.2.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62a5c7dad11015c66fbb9d881bc4caa5b12f16292f857842d9d1871595f4495"}, - {file = "coverage-7.2.7-cp310-cp310-win32.whl", hash = "sha256:ee57190f24fba796e36bb6d3aa8a8783c643d8fa9760c89f7a98ab5455fbf818"}, - {file = "coverage-7.2.7-cp310-cp310-win_amd64.whl", hash = "sha256:f75f7168ab25dd93110c8a8117a22450c19976afbc44234cbf71481094c1b850"}, - {file = "coverage-7.2.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:06a9a2be0b5b576c3f18f1a241f0473575c4a26021b52b2a85263a00f034d51f"}, - {file = "coverage-7.2.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5baa06420f837184130752b7c5ea0808762083bf3487b5038d68b012e5937dbe"}, - {file = "coverage-7.2.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdec9e8cbf13a5bf63290fc6013d216a4c7232efb51548594ca3631a7f13c3a3"}, - {file = "coverage-7.2.7-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52edc1a60c0d34afa421c9c37078817b2e67a392cab17d97283b64c5833f427f"}, - {file = "coverage-7.2.7-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63426706118b7f5cf6bb6c895dc215d8a418d5952544042c8a2d9fe87fcf09cb"}, - {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:afb17f84d56068a7c29f5fa37bfd38d5aba69e3304af08ee94da8ed5b0865833"}, - {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:48c19d2159d433ccc99e729ceae7d5293fbffa0bdb94952d3579983d1c8c9d97"}, - {file = "coverage-7.2.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0e1f928eaf5469c11e886fe0885ad2bf1ec606434e79842a879277895a50942a"}, - {file = "coverage-7.2.7-cp311-cp311-win32.whl", hash = "sha256:33d6d3ea29d5b3a1a632b3c4e4f4ecae24ef170b0b9ee493883f2df10039959a"}, - {file = "coverage-7.2.7-cp311-cp311-win_amd64.whl", hash = "sha256:5b7540161790b2f28143191f5f8ec02fb132660ff175b7747b95dcb77ac26562"}, - {file = "coverage-7.2.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f2f67fe12b22cd130d34d0ef79206061bfb5eda52feb6ce0dba0644e20a03cf4"}, - {file = "coverage-7.2.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a342242fe22407f3c17f4b499276a02b01e80f861f1682ad1d95b04018e0c0d4"}, - {file = "coverage-7.2.7-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:171717c7cb6b453aebac9a2ef603699da237f341b38eebfee9be75d27dc38e01"}, - {file = "coverage-7.2.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49969a9f7ffa086d973d91cec8d2e31080436ef0fb4a359cae927e742abfaaa6"}, - {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b46517c02ccd08092f4fa99f24c3b83d8f92f739b4657b0f146246a0ca6a831d"}, - {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:a3d33a6b3eae87ceaefa91ffdc130b5e8536182cd6dfdbfc1aa56b46ff8c86de"}, - {file = "coverage-7.2.7-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:976b9c42fb2a43ebf304fa7d4a310e5f16cc99992f33eced91ef6f908bd8f33d"}, - {file = "coverage-7.2.7-cp312-cp312-win32.whl", hash = "sha256:8de8bb0e5ad103888d65abef8bca41ab93721647590a3f740100cd65c3b00511"}, - {file = "coverage-7.2.7-cp312-cp312-win_amd64.whl", hash = "sha256:9e31cb64d7de6b6f09702bb27c02d1904b3aebfca610c12772452c4e6c21a0d3"}, - {file = "coverage-7.2.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:58c2ccc2f00ecb51253cbe5d8d7122a34590fac9646a960d1430d5b15321d95f"}, - {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d22656368f0e6189e24722214ed8d66b8022db19d182927b9a248a2a8a2f67eb"}, - {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a895fcc7b15c3fc72beb43cdcbdf0ddb7d2ebc959edac9cef390b0d14f39f8a9"}, - {file = "coverage-7.2.7-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e84606b74eb7de6ff581a7915e2dab7a28a0517fbe1c9239eb227e1354064dcd"}, - {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0a5f9e1dbd7fbe30196578ca36f3fba75376fb99888c395c5880b355e2875f8a"}, - {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:419bfd2caae268623dd469eff96d510a920c90928b60f2073d79f8fe2bbc5959"}, - {file = "coverage-7.2.7-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2aee274c46590717f38ae5e4650988d1af340fe06167546cc32fe2f58ed05b02"}, - {file = "coverage-7.2.7-cp37-cp37m-win32.whl", hash = "sha256:61b9a528fb348373c433e8966535074b802c7a5d7f23c4f421e6c6e2f1697a6f"}, - {file = "coverage-7.2.7-cp37-cp37m-win_amd64.whl", hash = "sha256:b1c546aca0ca4d028901d825015dc8e4d56aac4b541877690eb76490f1dc8ed0"}, - {file = "coverage-7.2.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:54b896376ab563bd38453cecb813c295cf347cf5906e8b41d340b0321a5433e5"}, - {file = "coverage-7.2.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3d376df58cc111dc8e21e3b6e24606b5bb5dee6024f46a5abca99124b2229ef5"}, - {file = "coverage-7.2.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e330fc79bd7207e46c7d7fd2bb4af2963f5f635703925543a70b99574b0fea9"}, - {file = "coverage-7.2.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e9d683426464e4a252bf70c3498756055016f99ddaec3774bf368e76bbe02b6"}, - {file = "coverage-7.2.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d13c64ee2d33eccf7437961b6ea7ad8673e2be040b4f7fd4fd4d4d28d9ccb1e"}, - {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b7aa5f8a41217360e600da646004f878250a0d6738bcdc11a0a39928d7dc2050"}, - {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8fa03bce9bfbeeef9f3b160a8bed39a221d82308b4152b27d82d8daa7041fee5"}, - {file = "coverage-7.2.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:245167dd26180ab4c91d5e1496a30be4cd721a5cf2abf52974f965f10f11419f"}, - {file = "coverage-7.2.7-cp38-cp38-win32.whl", hash = "sha256:d2c2db7fd82e9b72937969bceac4d6ca89660db0a0967614ce2481e81a0b771e"}, - {file = "coverage-7.2.7-cp38-cp38-win_amd64.whl", hash = "sha256:2e07b54284e381531c87f785f613b833569c14ecacdcb85d56b25c4622c16c3c"}, - {file = "coverage-7.2.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:537891ae8ce59ef63d0123f7ac9e2ae0fc8b72c7ccbe5296fec45fd68967b6c9"}, - {file = "coverage-7.2.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:06fb182e69f33f6cd1d39a6c597294cff3143554b64b9825d1dc69d18cc2fff2"}, - {file = "coverage-7.2.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:201e7389591af40950a6480bd9edfa8ed04346ff80002cec1a66cac4549c1ad7"}, - {file = "coverage-7.2.7-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f6951407391b639504e3b3be51b7ba5f3528adbf1a8ac3302b687ecababf929e"}, - {file = "coverage-7.2.7-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f48351d66575f535669306aa7d6d6f71bc43372473b54a832222803eb956fd1"}, - {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b29019c76039dc3c0fd815c41392a044ce555d9bcdd38b0fb60fb4cd8e475ba9"}, - {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:81c13a1fc7468c40f13420732805a4c38a105d89848b7c10af65a90beff25250"}, - {file = "coverage-7.2.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:975d70ab7e3c80a3fe86001d8751f6778905ec723f5b110aed1e450da9d4b7f2"}, - {file = "coverage-7.2.7-cp39-cp39-win32.whl", hash = "sha256:7ee7d9d4822c8acc74a5e26c50604dff824710bc8de424904c0982e25c39c6cb"}, - {file = "coverage-7.2.7-cp39-cp39-win_amd64.whl", hash = "sha256:eb393e5ebc85245347950143969b241d08b52b88a3dc39479822e073a1a8eb27"}, - {file = "coverage-7.2.7-pp37.pp38.pp39-none-any.whl", hash = "sha256:b7b4c971f05e6ae490fef852c218b0e79d4e52f79ef0c8475566584a8fb3e01d"}, - {file = "coverage-7.2.7.tar.gz", hash = "sha256:924d94291ca674905fe9481f12294eb11f2d3d3fd1adb20314ba89e94f44ed59"}, + {file = "coverage-7.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cd0f7429ecfd1ff597389907045ff209c8fdb5b013d38cfa7c60728cb484b6e3"}, + {file = "coverage-7.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:966f10df9b2b2115da87f50f6a248e313c72a668248be1b9060ce935c871f276"}, + {file = "coverage-7.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0575c37e207bb9b98b6cf72fdaaa18ac909fb3d153083400c2d48e2e6d28bd8e"}, + {file = "coverage-7.3.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:245c5a99254e83875c7fed8b8b2536f040997a9b76ac4c1da5bff398c06e860f"}, + {file = "coverage-7.3.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c96dd7798d83b960afc6c1feb9e5af537fc4908852ef025600374ff1a017392"}, + {file = "coverage-7.3.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:de30c1aa80f30af0f6b2058a91505ea6e36d6535d437520067f525f7df123887"}, + {file = "coverage-7.3.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:50dd1e2dd13dbbd856ffef69196781edff26c800a74f070d3b3e3389cab2600d"}, + {file = "coverage-7.3.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b9c0c19f70d30219113b18fe07e372b244fb2a773d4afde29d5a2f7930765136"}, + {file = "coverage-7.3.1-cp310-cp310-win32.whl", hash = "sha256:770f143980cc16eb601ccfd571846e89a5fe4c03b4193f2e485268f224ab602f"}, + {file = "coverage-7.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:cdd088c00c39a27cfa5329349cc763a48761fdc785879220d54eb785c8a38520"}, + {file = "coverage-7.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:74bb470399dc1989b535cb41f5ca7ab2af561e40def22d7e188e0a445e7639e3"}, + {file = "coverage-7.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:025ded371f1ca280c035d91b43252adbb04d2aea4c7105252d3cbc227f03b375"}, + {file = "coverage-7.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6191b3a6ad3e09b6cfd75b45c6aeeffe7e3b0ad46b268345d159b8df8d835f9"}, + {file = "coverage-7.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7eb0b188f30e41ddd659a529e385470aa6782f3b412f860ce22b2491c89b8593"}, + {file = "coverage-7.3.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75c8f0df9dfd8ff745bccff75867d63ef336e57cc22b2908ee725cc552689ec8"}, + {file = "coverage-7.3.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7eb3cd48d54b9bd0e73026dedce44773214064be93611deab0b6a43158c3d5a0"}, + {file = "coverage-7.3.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:ac3c5b7e75acac31e490b7851595212ed951889918d398b7afa12736c85e13ce"}, + {file = "coverage-7.3.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5b4ee7080878077af0afa7238df1b967f00dc10763f6e1b66f5cced4abebb0a3"}, + {file = "coverage-7.3.1-cp311-cp311-win32.whl", hash = "sha256:229c0dd2ccf956bf5aeede7e3131ca48b65beacde2029f0361b54bf93d36f45a"}, + {file = "coverage-7.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:c6f55d38818ca9596dc9019eae19a47410d5322408140d9a0076001a3dcb938c"}, + {file = "coverage-7.3.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5289490dd1c3bb86de4730a92261ae66ea8d44b79ed3cc26464f4c2cde581fbc"}, + {file = "coverage-7.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ca833941ec701fda15414be400c3259479bfde7ae6d806b69e63b3dc423b1832"}, + {file = "coverage-7.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd694e19c031733e446c8024dedd12a00cda87e1c10bd7b8539a87963685e969"}, + {file = "coverage-7.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aab8e9464c00da5cb9c536150b7fbcd8850d376d1151741dd0d16dfe1ba4fd26"}, + {file = "coverage-7.3.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87d38444efffd5b056fcc026c1e8d862191881143c3aa80bb11fcf9dca9ae204"}, + {file = "coverage-7.3.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:8a07b692129b8a14ad7a37941a3029c291254feb7a4237f245cfae2de78de037"}, + {file = "coverage-7.3.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:2829c65c8faaf55b868ed7af3c7477b76b1c6ebeee99a28f59a2cb5907a45760"}, + {file = "coverage-7.3.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1f111a7d85658ea52ffad7084088277135ec5f368457275fc57f11cebb15607f"}, + {file = "coverage-7.3.1-cp312-cp312-win32.whl", hash = "sha256:c397c70cd20f6df7d2a52283857af622d5f23300c4ca8e5bd8c7a543825baa5a"}, + {file = "coverage-7.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:5ae4c6da8b3d123500f9525b50bf0168023313963e0e2e814badf9000dd6ef92"}, + {file = "coverage-7.3.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ca70466ca3a17460e8fc9cea7123c8cbef5ada4be3140a1ef8f7b63f2f37108f"}, + {file = "coverage-7.3.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f2781fd3cabc28278dc982a352f50c81c09a1a500cc2086dc4249853ea96b981"}, + {file = "coverage-7.3.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6407424621f40205bbe6325686417e5e552f6b2dba3535dd1f90afc88a61d465"}, + {file = "coverage-7.3.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:04312b036580ec505f2b77cbbdfb15137d5efdfade09156961f5277149f5e344"}, + {file = "coverage-7.3.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9ad38204887349853d7c313f53a7b1c210ce138c73859e925bc4e5d8fc18e7"}, + {file = "coverage-7.3.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:53669b79f3d599da95a0afbef039ac0fadbb236532feb042c534fbb81b1a4e40"}, + {file = "coverage-7.3.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:614f1f98b84eb256e4f35e726bfe5ca82349f8dfa576faabf8a49ca09e630086"}, + {file = "coverage-7.3.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f1a317fdf5c122ad642db8a97964733ab7c3cf6009e1a8ae8821089993f175ff"}, + {file = "coverage-7.3.1-cp38-cp38-win32.whl", hash = "sha256:defbbb51121189722420a208957e26e49809feafca6afeef325df66c39c4fdb3"}, + {file = "coverage-7.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:f4f456590eefb6e1b3c9ea6328c1e9fa0f1006e7481179d749b3376fc793478e"}, + {file = "coverage-7.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f12d8b11a54f32688b165fd1a788c408f927b0960984b899be7e4c190ae758f1"}, + {file = "coverage-7.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f09195dda68d94a53123883de75bb97b0e35f5f6f9f3aa5bf6e496da718f0cb6"}, + {file = "coverage-7.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6601a60318f9c3945be6ea0f2a80571f4299b6801716f8a6e4846892737ebe4"}, + {file = "coverage-7.3.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07d156269718670d00a3b06db2288b48527fc5f36859425ff7cec07c6b367745"}, + {file = "coverage-7.3.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:636a8ac0b044cfeccae76a36f3b18264edcc810a76a49884b96dd744613ec0b7"}, + {file = "coverage-7.3.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5d991e13ad2ed3aced177f524e4d670f304c8233edad3210e02c465351f785a0"}, + {file = "coverage-7.3.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:586649ada7cf139445da386ab6f8ef00e6172f11a939fc3b2b7e7c9082052fa0"}, + {file = "coverage-7.3.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4aba512a15a3e1e4fdbfed2f5392ec221434a614cc68100ca99dcad7af29f3f8"}, + {file = "coverage-7.3.1-cp39-cp39-win32.whl", hash = "sha256:6bc6f3f4692d806831c136c5acad5ccedd0262aa44c087c46b7101c77e139140"}, + {file = "coverage-7.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:553d7094cb27db58ea91332e8b5681bac107e7242c23f7629ab1316ee73c4981"}, + {file = "coverage-7.3.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:220eb51f5fb38dfdb7e5d54284ca4d0cd70ddac047d750111a68ab1798945194"}, + {file = "coverage-7.3.1.tar.gz", hash = "sha256:6cb7fe1581deb67b782c153136541e20901aa312ceedaf1467dcb35255787952"}, ] [package.dependencies] @@ -778,30 +814,34 @@ coverage = "*" [[package]] name = "cycler" -version = "0.11.0" +version = "0.12.0" description = "Composable style cycles" optional = false -python-versions = ">=3.6" +python-versions = ">=3.8" files = [ - {file = "cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3"}, - {file = "cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f"}, + {file = "cycler-0.12.0-py3-none-any.whl", hash = "sha256:7896994252d006771357777d0251f3e34d266f4fa5f2c572247a80ab01440947"}, + {file = "cycler-0.12.0.tar.gz", hash = "sha256:8cc3a7b4861f91b1095157f9916f748549a617046e67eb7619abed9b34d2c94a"}, ] +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + [[package]] name = "datasets" -version = "2.14.3" +version = "2.14.5" description = "HuggingFace community-driven open-source library of datasets" optional = false python-versions = ">=3.8.0" files = [ - {file = "datasets-2.14.3-py3-none-any.whl", hash = "sha256:8da5868e55e7c1f0bf3356913a14a9926fe5eca66663691886b95bc9c9b065f0"}, - {file = "datasets-2.14.3.tar.gz", hash = "sha256:5fb20465a990cf7946f961884ba46fec19cdc95b1cd2cad2a7b87c8d183b02e1"}, + {file = "datasets-2.14.5-py3-none-any.whl", hash = "sha256:dd4155091034cba04d5a28711f2ed3944275ed15c5d0c5a2d0b6b9ea34a2bdfe"}, + {file = "datasets-2.14.5.tar.gz", hash = "sha256:b738a86540ab8e1a7806c8a3790b67be0056318d0c5d5a58a1b0dbdd76c0f568"}, ] [package.dependencies] aiohttp = "*" dill = ">=0.3.0,<0.3.8" -fsspec = {version = ">=2021.11.1", extras = ["http"]} +fsspec = {version = ">=2023.1.0,<2023.9.0", extras = ["http"]} huggingface-hub = ">=0.14.0,<1.0.0" multiprocess = "*" numpy = ">=1.17" @@ -831,29 +871,29 @@ vision = ["Pillow (>=6.2.1)"] [[package]] name = "debugpy" -version = "1.6.7" +version = "1.8.0" description = "An implementation of the Debug Adapter Protocol for Python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "debugpy-1.6.7-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:b3e7ac809b991006ad7f857f016fa92014445085711ef111fdc3f74f66144096"}, - {file = "debugpy-1.6.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3876611d114a18aafef6383695dfc3f1217c98a9168c1aaf1a02b01ec7d8d1e"}, - {file = "debugpy-1.6.7-cp310-cp310-win32.whl", hash = "sha256:33edb4afa85c098c24cc361d72ba7c21bb92f501104514d4ffec1fb36e09c01a"}, - {file = "debugpy-1.6.7-cp310-cp310-win_amd64.whl", hash = "sha256:ed6d5413474e209ba50b1a75b2d9eecf64d41e6e4501977991cdc755dc83ab0f"}, - {file = "debugpy-1.6.7-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:38ed626353e7c63f4b11efad659be04c23de2b0d15efff77b60e4740ea685d07"}, - {file = "debugpy-1.6.7-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:279d64c408c60431c8ee832dfd9ace7c396984fd7341fa3116aee414e7dcd88d"}, - {file = "debugpy-1.6.7-cp37-cp37m-win32.whl", hash = "sha256:dbe04e7568aa69361a5b4c47b4493d5680bfa3a911d1e105fbea1b1f23f3eb45"}, - {file = "debugpy-1.6.7-cp37-cp37m-win_amd64.whl", hash = "sha256:f90a2d4ad9a035cee7331c06a4cf2245e38bd7c89554fe3b616d90ab8aab89cc"}, - {file = "debugpy-1.6.7-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:5224eabbbeddcf1943d4e2821876f3e5d7d383f27390b82da5d9558fd4eb30a9"}, - {file = "debugpy-1.6.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bae1123dff5bfe548ba1683eb972329ba6d646c3a80e6b4c06cd1b1dd0205e9b"}, - {file = "debugpy-1.6.7-cp38-cp38-win32.whl", hash = "sha256:9cd10cf338e0907fdcf9eac9087faa30f150ef5445af5a545d307055141dd7a4"}, - {file = "debugpy-1.6.7-cp38-cp38-win_amd64.whl", hash = "sha256:aaf6da50377ff4056c8ed470da24632b42e4087bc826845daad7af211e00faad"}, - {file = "debugpy-1.6.7-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:0679b7e1e3523bd7d7869447ec67b59728675aadfc038550a63a362b63029d2c"}, - {file = "debugpy-1.6.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de86029696e1b3b4d0d49076b9eba606c226e33ae312a57a46dca14ff370894d"}, - {file = "debugpy-1.6.7-cp39-cp39-win32.whl", hash = "sha256:d71b31117779d9a90b745720c0eab54ae1da76d5b38c8026c654f4a066b0130a"}, - {file = "debugpy-1.6.7-cp39-cp39-win_amd64.whl", hash = "sha256:c0ff93ae90a03b06d85b2c529eca51ab15457868a377c4cc40a23ab0e4e552a3"}, - {file = "debugpy-1.6.7-py2.py3-none-any.whl", hash = "sha256:53f7a456bc50706a0eaabecf2d3ce44c4d5010e46dfc65b6b81a518b42866267"}, - {file = "debugpy-1.6.7.zip", hash = "sha256:c4c2f0810fa25323abfdfa36cbbbb24e5c3b1a42cb762782de64439c575d67f2"}, + {file = "debugpy-1.8.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7fb95ca78f7ac43393cd0e0f2b6deda438ec7c5e47fa5d38553340897d2fbdfb"}, + {file = "debugpy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef9ab7df0b9a42ed9c878afd3eaaff471fce3fa73df96022e1f5c9f8f8c87ada"}, + {file = "debugpy-1.8.0-cp310-cp310-win32.whl", hash = "sha256:a8b7a2fd27cd9f3553ac112f356ad4ca93338feadd8910277aff71ab24d8775f"}, + {file = "debugpy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:5d9de202f5d42e62f932507ee8b21e30d49aae7e46d5b1dd5c908db1d7068637"}, + {file = "debugpy-1.8.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:ef54404365fae8d45cf450d0544ee40cefbcb9cb85ea7afe89a963c27028261e"}, + {file = "debugpy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60009b132c91951354f54363f8ebdf7457aeb150e84abba5ae251b8e9f29a8a6"}, + {file = "debugpy-1.8.0-cp311-cp311-win32.whl", hash = "sha256:8cd0197141eb9e8a4566794550cfdcdb8b3db0818bdf8c49a8e8f8053e56e38b"}, + {file = "debugpy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:a64093656c4c64dc6a438e11d59369875d200bd5abb8f9b26c1f5f723622e153"}, + {file = "debugpy-1.8.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:b05a6b503ed520ad58c8dc682749113d2fd9f41ffd45daec16e558ca884008cd"}, + {file = "debugpy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c6fb41c98ec51dd010d7ed650accfd07a87fe5e93eca9d5f584d0578f28f35f"}, + {file = "debugpy-1.8.0-cp38-cp38-win32.whl", hash = "sha256:46ab6780159eeabb43c1495d9c84cf85d62975e48b6ec21ee10c95767c0590aa"}, + {file = "debugpy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:bdc5ef99d14b9c0fcb35351b4fbfc06ac0ee576aeab6b2511702e5a648a2e595"}, + {file = "debugpy-1.8.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:61eab4a4c8b6125d41a34bad4e5fe3d2cc145caecd63c3fe953be4cc53e65bf8"}, + {file = "debugpy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:125b9a637e013f9faac0a3d6a82bd17c8b5d2c875fb6b7e2772c5aba6d082332"}, + {file = "debugpy-1.8.0-cp39-cp39-win32.whl", hash = "sha256:57161629133113c97b387382045649a2b985a348f0c9366e22217c87b68b73c6"}, + {file = "debugpy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:e3412f9faa9ade82aa64a50b602544efcba848c91384e9f93497a458767e6926"}, + {file = "debugpy-1.8.0-py2.py3-none-any.whl", hash = "sha256:9c9b0ac1ce2a42888199df1a1906e45e6f3c9555497643a85e0bf2406e3ffbc4"}, + {file = "debugpy-1.8.0.zip", hash = "sha256:12af2c55b419521e33d5fb21bd022df0b5eb267c3e178f1d374a63a2a6bdccd0"}, ] [[package]] @@ -908,24 +948,24 @@ six = ">=1.4.0" [[package]] name = "einops" -version = "0.6.1" +version = "0.7.0" description = "A new flavour of deep learning operations" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "einops-0.6.1-py3-none-any.whl", hash = "sha256:99149e46cc808956b174932fe563d920db4d6e5dadb8c6ecdaa7483b7ef7cfc3"}, - {file = "einops-0.6.1.tar.gz", hash = "sha256:f95f8d00f4ded90dbc4b19b6f98b177332614b0357dde66997f3ae5d474dc8c8"}, + {file = "einops-0.7.0-py3-none-any.whl", hash = "sha256:0f3096f26b914f465f6ff3c66f5478f9a5e380bb367ffc6493a68143fbbf1fd1"}, + {file = "einops-0.7.0.tar.gz", hash = "sha256:b2b04ad6081a3b227080c9bf5e3ace7160357ff03043cd66cc5b2319eb7031d1"}, ] [[package]] name = "exceptiongroup" -version = "1.1.2" +version = "1.1.3" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.1.2-py3-none-any.whl", hash = "sha256:e346e69d186172ca7cf029c8c1d16235aa0e04035e5750b4b95039e65204328f"}, - {file = "exceptiongroup-1.1.2.tar.gz", hash = "sha256:12c3e887d6485d16943a309616de20ae5582633e0a2eda17f4e10fd61c1e8af5"}, + {file = "exceptiongroup-1.1.3-py3-none-any.whl", hash = "sha256:343280667a4585d195ca1cf9cef84a4e178c4b6cf2274caef9859782b567d5e3"}, + {file = "exceptiongroup-1.1.3.tar.gz", hash = "sha256:097acd85d473d75af5bb98e41b61ff7fe35efe6675e4f9370ec6ec5126d160e9"}, ] [package.extras] @@ -933,17 +973,17 @@ test = ["pytest (>=6)"] [[package]] name = "executing" -version = "1.2.0" +version = "2.0.0" description = "Get the currently executing AST node of a frame, and other information" optional = false python-versions = "*" files = [ - {file = "executing-1.2.0-py2.py3-none-any.whl", hash = "sha256:0314a69e37426e3608aada02473b4161d4caf5a4b244d1d0c48072b8fee7bacc"}, - {file = "executing-1.2.0.tar.gz", hash = "sha256:19da64c18d2d851112f09c287f8d3dbbdf725ab0e569077efb6cdcbd3497c107"}, + {file = "executing-2.0.0-py2.py3-none-any.whl", hash = "sha256:06df6183df67389625f4e763921c6cf978944721abf3e714000200aab95b0657"}, + {file = "executing-2.0.0.tar.gz", hash = "sha256:0ff053696fdeef426cda5bd18eacd94f82c91f49823a2e9090124212ceea9b08"}, ] [package.extras] -tests = ["asttokens", "littleutils", "pytest", "rich"] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] [[package]] name = "fancy-einsum" @@ -972,18 +1012,19 @@ devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benc [[package]] name = "filelock" -version = "3.12.2" +version = "3.12.4" description = "A platform independent file lock." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "filelock-3.12.2-py3-none-any.whl", hash = "sha256:cbb791cdea2a72f23da6ac5b5269ab0a0d161e9ef0100e653b69049a7706d1ec"}, - {file = "filelock-3.12.2.tar.gz", hash = "sha256:002740518d8aa59a26b0c76e10fb8c6e15eae825d34b6fdf670333fd7b938d81"}, + {file = "filelock-3.12.4-py3-none-any.whl", hash = "sha256:08c21d87ded6e2b9da6728c3dff51baf1dcecf973b768ef35bcbc3447edb9ad4"}, + {file = "filelock-3.12.4.tar.gz", hash = "sha256:2e6f249f1f3654291606e046b09f1fd5eac39b360664c27f5aad072012f8bcbd"}, ] [package.extras] -docs = ["furo (>=2023.5.20)", "sphinx (>=7.0.1)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)"] -testing = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "diff-cover (>=7.5)", "pytest (>=7.3.1)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)"] +docs = ["furo (>=2023.7.26)", "sphinx (>=7.1.2)", "sphinx-autodoc-typehints (>=1.24)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3)", "diff-cover (>=7.7)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-timeout (>=2.1)"] +typing = ["typing-extensions (>=4.7.1)"] [[package]] name = "fire" @@ -1001,45 +1042,53 @@ termcolor = "*" [[package]] name = "fonttools" -version = "4.42.0" +version = "4.43.0" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" files = [ - {file = "fonttools-4.42.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9c456d1f23deff64ffc8b5b098718e149279abdea4d8692dba69172fb6a0d597"}, - {file = "fonttools-4.42.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:150122ed93127a26bc3670ebab7e2add1e0983d30927733aec327ebf4255b072"}, - {file = "fonttools-4.42.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48e82d776d2e93f88ca56567509d102266e7ab2fb707a0326f032fe657335238"}, - {file = "fonttools-4.42.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58c1165f9b2662645de9b19a8c8bdd636b36294ccc07e1b0163856b74f10bafc"}, - {file = "fonttools-4.42.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2d6dc3fa91414ff4daa195c05f946e6a575bd214821e26d17ca50f74b35b0fe4"}, - {file = "fonttools-4.42.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fae4e801b774cc62cecf4a57b1eae4097903fced00c608d9e2bc8f84cd87b54a"}, - {file = "fonttools-4.42.0-cp310-cp310-win32.whl", hash = "sha256:b8600ae7dce6ec3ddfb201abb98c9d53abbf8064d7ac0c8a0d8925e722ccf2a0"}, - {file = "fonttools-4.42.0-cp310-cp310-win_amd64.whl", hash = "sha256:57b68eab183fafac7cd7d464a7bfa0fcd4edf6c67837d14fb09c1c20516cf20b"}, - {file = "fonttools-4.42.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0a1466713e54bdbf5521f2f73eebfe727a528905ff5ec63cda40961b4b1eea95"}, - {file = "fonttools-4.42.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3fb2a69870bfe143ec20b039a1c8009e149dd7780dd89554cc8a11f79e5de86b"}, - {file = "fonttools-4.42.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae881e484702efdb6cf756462622de81d4414c454edfd950b137e9a7352b3cb9"}, - {file = "fonttools-4.42.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27ec3246a088555629f9f0902f7412220c67340553ca91eb540cf247aacb1983"}, - {file = "fonttools-4.42.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8ece1886d12bb36c48c00b2031518877f41abae317e3a55620d38e307d799b7e"}, - {file = "fonttools-4.42.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:10dac980f2b975ef74532e2a94bb00e97a95b4595fb7f98db493c474d5f54d0e"}, - {file = "fonttools-4.42.0-cp311-cp311-win32.whl", hash = "sha256:83b98be5d291e08501bd4fc0c4e0f8e6e05b99f3924068b17c5c9972af6fff84"}, - {file = "fonttools-4.42.0-cp311-cp311-win_amd64.whl", hash = "sha256:e35bed436726194c5e6e094fdfb423fb7afaa0211199f9d245e59e11118c576c"}, - {file = "fonttools-4.42.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c36c904ce0322df01e590ba814d5d69e084e985d7e4c2869378671d79662a7d4"}, - {file = "fonttools-4.42.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d54e600a2bcfa5cdaa860237765c01804a03b08404d6affcd92942fa7315ffba"}, - {file = "fonttools-4.42.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01cfe02416b6d416c5c8d15e30315cbcd3e97d1b50d3b34b0ce59f742ef55258"}, - {file = "fonttools-4.42.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f81ed9065b4bd3f4f3ce8e4873cd6a6b3f4e92b1eddefde35d332c6f414acc3"}, - {file = "fonttools-4.42.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:685a4dd6cf31593b50d6d441feb7781a4a7ef61e19551463e14ed7c527b86f9f"}, - {file = "fonttools-4.42.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:329341ba3d86a36e482610db56b30705384cb23bd595eac8cbb045f627778e9d"}, - {file = "fonttools-4.42.0-cp38-cp38-win32.whl", hash = "sha256:4655c480a1a4d706152ff54f20e20cf7609084016f1df3851cce67cef768f40a"}, - {file = "fonttools-4.42.0-cp38-cp38-win_amd64.whl", hash = "sha256:6bd7e4777bff1dcb7c4eff4786998422770f3bfbef8be401c5332895517ba3fa"}, - {file = "fonttools-4.42.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a9b55d2a3b360e0c7fc5bd8badf1503ca1c11dd3a1cd20f2c26787ffa145a9c7"}, - {file = "fonttools-4.42.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0df8ef75ba5791e873c9eac2262196497525e3f07699a2576d3ab9ddf41cb619"}, - {file = "fonttools-4.42.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cd2363ea7728496827658682d049ffb2e98525e2247ca64554864a8cc945568"}, - {file = "fonttools-4.42.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d40673b2e927f7cd0819c6f04489dfbeb337b4a7b10fc633c89bf4f34ecb9620"}, - {file = "fonttools-4.42.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c8bf88f9e3ce347c716921804ef3a8330cb128284eb6c0b6c4b3574f3c580023"}, - {file = "fonttools-4.42.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:703101eb0490fae32baf385385d47787b73d9ea55253df43b487c89ec767e0d7"}, - {file = "fonttools-4.42.0-cp39-cp39-win32.whl", hash = "sha256:f0290ea7f9945174bd4dfd66e96149037441eb2008f3649094f056201d99e293"}, - {file = "fonttools-4.42.0-cp39-cp39-win_amd64.whl", hash = "sha256:ae7df0ae9ee2f3f7676b0ff6f4ebe48ad0acaeeeaa0b6839d15dbf0709f2c5ef"}, - {file = "fonttools-4.42.0-py3-none-any.whl", hash = "sha256:dfe7fa7e607f7e8b58d0c32501a3a7cac148538300626d1b930082c90ae7f6bd"}, - {file = "fonttools-4.42.0.tar.gz", hash = "sha256:614b1283dca88effd20ee48160518e6de275ce9b5456a3134d5f235523fc5065"}, + {file = "fonttools-4.43.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ab80e7d6bb01316d5fc8161a2660ca2e9e597d0880db4927bc866c76474472ef"}, + {file = "fonttools-4.43.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:82d8e687a42799df5325e7ee12977b74738f34bf7fde1c296f8140efd699a213"}, + {file = "fonttools-4.43.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d08a694b280d615460563a6b4e2afb0b1b9df708c799ec212bf966652b94fc84"}, + {file = "fonttools-4.43.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d654d3e780e0ceabb1f4eff5a3c042c67d4428d0fe1ea3afd238a721cf171b3"}, + {file = "fonttools-4.43.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:20fc43783c432862071fa76da6fa714902ae587bc68441e12ff4099b94b1fcef"}, + {file = "fonttools-4.43.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:33c40a657fb87ff83185828c0323032d63a4df1279d5c1c38e21f3ec56327803"}, + {file = "fonttools-4.43.0-cp310-cp310-win32.whl", hash = "sha256:b3813f57f85bbc0e4011a0e1e9211f9ee52f87f402e41dc05bc5135f03fa51c1"}, + {file = "fonttools-4.43.0-cp310-cp310-win_amd64.whl", hash = "sha256:05056a8c9af048381fdb17e89b17d45f6c8394176d01e8c6fef5ac96ea950d38"}, + {file = "fonttools-4.43.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da78f39b601ed0b4262929403186d65cf7a016f91ff349ab18fdc5a7080af465"}, + {file = "fonttools-4.43.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5056f69a18f3f28ab5283202d1efcfe011585d31de09d8560f91c6c88f041e92"}, + {file = "fonttools-4.43.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcc01cea0a121fb0c009993497bad93cae25e77db7dee5345fec9cce1aaa09cd"}, + {file = "fonttools-4.43.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee728d5af70f117581712966a21e2e07031e92c687ef1fdc457ac8d281016f64"}, + {file = "fonttools-4.43.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b5e760198f0b87e42478bb35a6eae385c636208f6f0d413e100b9c9c5efafb6a"}, + {file = "fonttools-4.43.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:af38f5145258e9866da5881580507e6d17ff7756beef175d13213a43a84244e9"}, + {file = "fonttools-4.43.0-cp311-cp311-win32.whl", hash = "sha256:25620b738d4533cfc21fd2a4f4b667e481f7cb60e86b609799f7d98af657854e"}, + {file = "fonttools-4.43.0-cp311-cp311-win_amd64.whl", hash = "sha256:635658464dccff6fa5c3b43fe8f818ae2c386ee6a9e1abc27359d1e255528186"}, + {file = "fonttools-4.43.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:a682fb5cbf8837d1822b80acc0be5ff2ea0c49ca836e468a21ffd388ef280fd3"}, + {file = "fonttools-4.43.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3d7adfa342e6b3a2b36960981f23f480969f833d565a4eba259c2e6f59d2674f"}, + {file = "fonttools-4.43.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5aa67d1e720fdd902fde4a59d0880854ae9f19fc958f3e1538bceb36f7f4dc92"}, + {file = "fonttools-4.43.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77e5113233a2df07af9dbf493468ce526784c3b179c0e8b9c7838ced37c98b69"}, + {file = "fonttools-4.43.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:57c22e5f9f53630d458830f710424dce4f43c5f0d95cb3368c0f5178541e4db7"}, + {file = "fonttools-4.43.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:206808f9717c9b19117f461246372a2c160fa12b9b8dbdfb904ab50ca235ba0a"}, + {file = "fonttools-4.43.0-cp312-cp312-win32.whl", hash = "sha256:f19c2b1c65d57cbea25cabb80941fea3fbf2625ff0cdcae8900b5fb1c145704f"}, + {file = "fonttools-4.43.0-cp312-cp312-win_amd64.whl", hash = "sha256:7c76f32051159f8284f1a5f5b605152b5a530736fb8b55b09957db38dcae5348"}, + {file = "fonttools-4.43.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e3f8acc6ef4a627394021246e099faee4b343afd3ffe2e517d8195b4ebf20289"}, + {file = "fonttools-4.43.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a68b71adc3b3a90346e4ac92f0a69ab9caeba391f3b04ab6f1e98f2c8ebe88e3"}, + {file = "fonttools-4.43.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ace0fd5afb79849f599f76af5c6aa5e865bd042c811e4e047bbaa7752cc26126"}, + {file = "fonttools-4.43.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f9660e70a2430780e23830476332bc3391c3c8694769e2c0032a5038702a662"}, + {file = "fonttools-4.43.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:48078357984214ccd22d7fe0340cd6ff7286b2f74f173603a1a9a40b5dc25afe"}, + {file = "fonttools-4.43.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d27d960e10cf7617d70cf3104c32a69b008dde56f2d55a9bed4ba6e3df611544"}, + {file = "fonttools-4.43.0-cp38-cp38-win32.whl", hash = "sha256:a6a2e99bb9ea51e0974bbe71768df42c6dd189308c22f3f00560c3341b345646"}, + {file = "fonttools-4.43.0-cp38-cp38-win_amd64.whl", hash = "sha256:030355fbb0cea59cf75d076d04d3852900583d1258574ff2d7d719abf4513836"}, + {file = "fonttools-4.43.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:52e77f23a9c059f8be01a07300ba4c4d23dc271d33eed502aea5a01ab5d2f4c1"}, + {file = "fonttools-4.43.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6a530fa28c155538d32214eafa0964989098a662bd63e91e790e6a7a4e9c02da"}, + {file = "fonttools-4.43.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70f021a6b9eb10dfe7a411b78e63a503a06955dd6d2a4e130906d8760474f77c"}, + {file = "fonttools-4.43.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:812142a0e53cc853964d487e6b40963df62f522b1b571e19d1ff8467d7880ceb"}, + {file = "fonttools-4.43.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ace51902ab67ef5fe225e8b361039e996db153e467e24a28d35f74849b37b7ce"}, + {file = "fonttools-4.43.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8dfd8edfce34ad135bd69de20c77449c06e2c92b38f2a8358d0987737f82b49e"}, + {file = "fonttools-4.43.0-cp39-cp39-win32.whl", hash = "sha256:e5d53eddaf436fa131042f44a76ea1ead0a17c354ab9de0d80e818f0cb1629f1"}, + {file = "fonttools-4.43.0-cp39-cp39-win_amd64.whl", hash = "sha256:93c5b6d77baf28f306bc13fa987b0b13edca6a39dc2324eaca299a74ccc6316f"}, + {file = "fonttools-4.43.0-py3-none-any.whl", hash = "sha256:e4bc589d8da09267c7c4ceaaaa4fc01a7908ac5b43b286ac9279afe76407c384"}, + {file = "fonttools-4.43.0.tar.gz", hash = "sha256:b62a53a4ca83c32c6b78cac64464f88d02929779373c716f738af6968c8c821e"}, ] [package.extras] @@ -1192,27 +1241,30 @@ smmap = ">=3.0.1,<6" [[package]] name = "gitpython" -version = "3.1.32" +version = "3.1.37" description = "GitPython is a Python library used to interact with Git repositories" optional = false python-versions = ">=3.7" files = [ - {file = "GitPython-3.1.32-py3-none-any.whl", hash = "sha256:e3d59b1c2c6ebb9dfa7a184daf3b6dd4914237e7488a1730a6d8f6f5d0b4187f"}, - {file = "GitPython-3.1.32.tar.gz", hash = "sha256:8d9b8cb1e80b9735e8717c9362079d3ce4c6e5ddeebedd0361b228c3a67a62f6"}, + {file = "GitPython-3.1.37-py3-none-any.whl", hash = "sha256:5f4c4187de49616d710a77e98ddf17b4782060a1788df441846bddefbb89ab33"}, + {file = "GitPython-3.1.37.tar.gz", hash = "sha256:f9b9ddc0761c125d5780eab2d64be4873fc6817c2899cbcb34b02344bdc7bc54"}, ] [package.dependencies] gitdb = ">=4.0.1,<5" +[package.extras] +test = ["black", "coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mypy", "pre-commit", "pytest", "pytest-cov", "pytest-sugar"] + [[package]] name = "huggingface-hub" -version = "0.16.4" +version = "0.17.3" description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub" optional = false -python-versions = ">=3.7.0" +python-versions = ">=3.8.0" files = [ - {file = "huggingface_hub-0.16.4-py3-none-any.whl", hash = "sha256:0d3df29932f334fead024afc7cb4cc5149d955238b8b5e42dcf9740d6995a349"}, - {file = "huggingface_hub-0.16.4.tar.gz", hash = "sha256:608c7d4f3d368b326d1747f91523dbd1f692871e8e2e7a4750314a2dd8b63e14"}, + {file = "huggingface_hub-0.17.3-py3-none-any.whl", hash = "sha256:545eb3665f6ac587add946e73984148f2ea5c7877eac2e845549730570c1933a"}, + {file = "huggingface_hub-0.17.3.tar.gz", hash = "sha256:40439632b211311f788964602bf8b0d9d6b7a2314fba4e8d67b2ce3ecea0e3fd"}, ] [package.dependencies] @@ -1225,16 +1277,17 @@ tqdm = ">=4.42.1" typing-extensions = ">=3.7.4.3" [package.extras] -all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (>=23.1,<24.0)", "gradio", "jedi", "mypy (==0.982)", "numpy", "pydantic", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] +all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] cli = ["InquirerPy (==0.3.4)"] -dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (>=23.1,<24.0)", "gradio", "jedi", "mypy (==0.982)", "numpy", "pydantic", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] +dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)"] +docs = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "black (==23.7)", "gradio", "hf-doc-builder", "jedi", "mypy (==1.5.1)", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "urllib3 (<2.0)", "watchdog"] fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"] -inference = ["aiohttp", "pydantic"] -quality = ["black (>=23.1,<24.0)", "mypy (==0.982)", "ruff (>=0.0.241)"] +inference = ["aiohttp", "pydantic (<2.0)"] +quality = ["black (==23.7)", "mypy (==1.5.1)", "ruff (>=0.0.241)"] tensorflow = ["graphviz", "pydot", "tensorflow"] -testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "gradio", "jedi", "numpy", "pydantic", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"] +testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "gradio", "jedi", "numpy", "pydantic (<2.0)", "pytest", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"] torch = ["torch"] -typing = ["pydantic", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"] +typing = ["pydantic (<2.0)", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"] [[package]] name = "idna" @@ -1279,13 +1332,13 @@ files = [ [[package]] name = "ipykernel" -version = "6.25.0" +version = "6.25.2" description = "IPython Kernel for Jupyter" optional = false python-versions = ">=3.8" files = [ - {file = "ipykernel-6.25.0-py3-none-any.whl", hash = "sha256:f0042e867ac3f6bca1679e6a88cbd6a58ed93a44f9d0866aecde6efe8de76659"}, - {file = "ipykernel-6.25.0.tar.gz", hash = "sha256:e342ce84712861be4b248c4a73472be4702c1b0dd77448bfd6bcfb3af9d5ddf9"}, + {file = "ipykernel-6.25.2-py3-none-any.whl", hash = "sha256:2e2ee359baba19f10251b99415bb39de1e97d04e1fab385646f24f0596510b77"}, + {file = "ipykernel-6.25.2.tar.gz", hash = "sha256:f468ddd1f17acb48c8ce67fcfa49ba6d46d4f9ac0438c1f441be7c3d1372230b"}, ] [package.dependencies] @@ -1312,13 +1365,13 @@ test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio" [[package]] name = "ipython" -version = "8.14.0" +version = "8.16.0" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.9" files = [ - {file = "ipython-8.14.0-py3-none-any.whl", hash = "sha256:248aca623f5c99a6635bc3857677b7320b9b8039f99f070ee0d20a5ca5a8e6bf"}, - {file = "ipython-8.14.0.tar.gz", hash = "sha256:1d197b907b6ba441b692c48cf2a3a2de280dc0ac91a3405b39349a50272ca0a1"}, + {file = "ipython-8.16.0-py3-none-any.whl", hash = "sha256:dba644376826a532e362da945a672865be7efda76ecf999219e6021bda85d702"}, + {file = "ipython-8.16.0.tar.gz", hash = "sha256:7a1b2e1e6a3ec5baa466163c451335081f31859883889ff0289c6b21f7a095e2"}, ] [package.dependencies] @@ -1326,6 +1379,7 @@ appnope = {version = "*", markers = "sys_platform == \"darwin\""} backcall = "*" colorama = {version = "*", markers = "sys_platform == \"win32\""} decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} jedi = ">=0.16" matplotlib-inline = "*" pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} @@ -1336,9 +1390,9 @@ stack-data = "*" traitlets = ">=5" [package.extras] -all = ["black", "curio", "docrepr", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] +all = ["black", "curio", "docrepr", "exceptiongroup", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] black = ["black"] -doc = ["docrepr", "ipykernel", "matplotlib", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "matplotlib", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] kernel = ["ipykernel"] nbconvert = ["nbconvert"] nbformat = ["nbformat"] @@ -1361,21 +1415,21 @@ files = [ [[package]] name = "ipywidgets" -version = "8.1.0" +version = "8.1.1" description = "Jupyter interactive widgets" optional = false python-versions = ">=3.7" files = [ - {file = "ipywidgets-8.1.0-py3-none-any.whl", hash = "sha256:6c8396cc7b8c95dfb4e9ab0054f48c002f045e7e5d7ae523f559d64e525a98ab"}, - {file = "ipywidgets-8.1.0.tar.gz", hash = "sha256:ce97dd90525b3066fd00094690964e7eac14cf9b7745d35565b5eeac20cce687"}, + {file = "ipywidgets-8.1.1-py3-none-any.whl", hash = "sha256:2b88d728656aea3bbfd05d32c747cfd0078f9d7e159cf982433b58ad717eed7f"}, + {file = "ipywidgets-8.1.1.tar.gz", hash = "sha256:40211efb556adec6fa450ccc2a77d59ca44a060f4f9f136833df59c9f538e6e8"}, ] [package.dependencies] comm = ">=0.1.3" ipython = ">=6.1.0" -jupyterlab-widgets = ">=3.0.7,<3.1.0" +jupyterlab-widgets = ">=3.0.9,<3.1.0" traitlets = ">=4.3.1" -widgetsnbextension = ">=4.0.7,<4.1.0" +widgetsnbextension = ">=4.0.9,<4.1.0" [package.extras] test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] @@ -1413,13 +1467,13 @@ requirements-deprecated-finder = ["pip-api", "pipreqs"] [[package]] name = "jaxtyping" -version = "0.2.20" +version = "0.2.22" description = "Type annotations and runtime checking for shape and dtype of JAX arrays, and PyTrees." optional = false python-versions = "~=3.9" files = [ - {file = "jaxtyping-0.2.20-py3-none-any.whl", hash = "sha256:7038e71cc9352b67a8673d1fc39b6c7e95a326623a1fd43ee7c56faf20866ab9"}, - {file = "jaxtyping-0.2.20.tar.gz", hash = "sha256:dc2bd15e00b2f38ac5ddc02d3a8bb0202f1703ad91031e914bc77a768d9db8c5"}, + {file = "jaxtyping-0.2.22-py3-none-any.whl", hash = "sha256:7b68a8d34bfb823ff5537b94552850a2e7f2687d61afeaee0689c0615bfcea98"}, + {file = "jaxtyping-0.2.22.tar.gz", hash = "sha256:adf0a6b3098ec7a20165adbdc019e90f1b52494462367b5d12c0a5ea2555d223"}, ] [package.dependencies] @@ -1463,6 +1517,17 @@ MarkupSafe = ">=2.0" [package.extras] i18n = ["Babel (>=2.7)"] +[[package]] +name = "joblib" +version = "1.3.2" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.7" +files = [ + {file = "joblib-1.3.2-py3-none-any.whl", hash = "sha256:ef4331c65f239985f3f2220ecc87db222f08fd22097a3dd5698f693875f8cbb9"}, + {file = "joblib-1.3.2.tar.gz", hash = "sha256:92f865e621e17784e7955080b6d042489e3b8e294949cc44c6eac304f59772b1"}, +] + [[package]] name = "json5" version = "0.9.14" @@ -1490,13 +1555,13 @@ files = [ [[package]] name = "jsonschema" -version = "4.18.6" +version = "4.19.1" description = "An implementation of JSON Schema validation for Python" optional = false python-versions = ">=3.8" files = [ - {file = "jsonschema-4.18.6-py3-none-any.whl", hash = "sha256:dc274409c36175aad949c68e5ead0853aaffbe8e88c830ae66bb3c7a1728ad2d"}, - {file = "jsonschema-4.18.6.tar.gz", hash = "sha256:ce71d2f8c7983ef75a756e568317bf54bc531dc3ad7e66a128eae0d51623d8a3"}, + {file = "jsonschema-4.19.1-py3-none-any.whl", hash = "sha256:cd5f1f9ed9444e554b38ba003af06c0a8c2868131e56bfbef0550fb450c0330e"}, + {file = "jsonschema-4.19.1.tar.gz", hash = "sha256:ec84cc37cfa703ef7cd4928db24f9cb31428a5d0fa77747b8b51a847458e0bbf"}, ] [package.dependencies] @@ -1553,13 +1618,13 @@ qtconsole = "*" [[package]] name = "jupyter-client" -version = "8.3.0" +version = "8.3.1" description = "Jupyter protocol implementation and client libraries" optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_client-8.3.0-py3-none-any.whl", hash = "sha256:7441af0c0672edc5d28035e92ba5e32fadcfa8a4e608a434c228836a89df6158"}, - {file = "jupyter_client-8.3.0.tar.gz", hash = "sha256:3af69921fe99617be1670399a0b857ad67275eefcfa291e2c81a160b7b650f5f"}, + {file = "jupyter_client-8.3.1-py3-none-any.whl", hash = "sha256:5eb9f55eb0650e81de6b7e34308d8b92d04fe4ec41cd8193a913979e33d8e1a5"}, + {file = "jupyter_client-8.3.1.tar.gz", hash = "sha256:60294b2d5b869356c893f57b1a877ea6510d60d45cf4b38057f1672d85699ac9"}, ] [package.dependencies] @@ -1599,13 +1664,13 @@ test = ["flaky", "pexpect", "pytest"] [[package]] name = "jupyter-core" -version = "5.3.1" +version = "5.3.2" description = "Jupyter core package. A base package on which Jupyter projects rely." optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_core-5.3.1-py3-none-any.whl", hash = "sha256:ae9036db959a71ec1cac33081eeb040a79e681f08ab68b0883e9a676c7a90dce"}, - {file = "jupyter_core-5.3.1.tar.gz", hash = "sha256:5ba5c7938a7f97a6b0481463f7ff0dbac7c15ba48cf46fa4035ca6e838aa1aba"}, + {file = "jupyter_core-5.3.2-py3-none-any.whl", hash = "sha256:a4af53c3fa3f6330cebb0d9f658e148725d15652811d1c32dc0f63bb96f2e6d6"}, + {file = "jupyter_core-5.3.2.tar.gz", hash = "sha256:0c28db6cbe2c37b5b398e1a1a5b22f84fd64cd10afc1f6c05b02fb09481ba45f"}, ] [package.dependencies] @@ -1658,13 +1723,13 @@ jupyter-server = ">=1.1.2" [[package]] name = "jupyter-server" -version = "2.7.0" +version = "2.7.3" description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_server-2.7.0-py3-none-any.whl", hash = "sha256:6a77912aff643e53fa14bdb2634884b52b784a4be77ce8e93f7283faed0f0849"}, - {file = "jupyter_server-2.7.0.tar.gz", hash = "sha256:36da0a266d31a41ac335a366c88933c17dfa5bb817a48f5c02c16d303bc9477f"}, + {file = "jupyter_server-2.7.3-py3-none-any.whl", hash = "sha256:8e4b90380b59d7a1e31086c4692231f2a2ea4cb269f5516e60aba72ce8317fc9"}, + {file = "jupyter_server-2.7.3.tar.gz", hash = "sha256:d4916c8581c4ebbc534cebdaa8eca2478d9f3bfdd88eae29fcab0120eac57649"}, ] [package.dependencies] @@ -1682,7 +1747,7 @@ packaging = "*" prometheus-client = "*" pywinpty = {version = "*", markers = "os_name == \"nt\""} pyzmq = ">=24" -send2trash = "*" +send2trash = ">=1.8.2" terminado = ">=0.8.3" tornado = ">=6.2.0" traitlets = ">=5.6.0" @@ -1713,13 +1778,13 @@ test = ["coverage", "jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-cov", [[package]] name = "jupyterlab" -version = "4.0.4" +version = "4.0.6" description = "JupyterLab computational environment" optional = false python-versions = ">=3.8" files = [ - {file = "jupyterlab-4.0.4-py3-none-any.whl", hash = "sha256:23eef35d22be8f2ad9b873ec41ceb2e8c3b0dc8ae740c0f973e2de09e587530f"}, - {file = "jupyterlab-4.0.4.tar.gz", hash = "sha256:049449a56d93202ed204e0e86f96f5a3447a08cfc09fb012fd239e178651cb34"}, + {file = "jupyterlab-4.0.6-py3-none-any.whl", hash = "sha256:7d9dacad1e3f30fe4d6d4efc97fda25fbb5012012b8f27cc03a2283abcdee708"}, + {file = "jupyterlab-4.0.6.tar.gz", hash = "sha256:6c43ae5a6a1fd2fdfafcb3454004958bde6da76331abb44cffc6f9e436b19ba1"}, ] [package.dependencies] @@ -1737,8 +1802,8 @@ tornado = ">=6.2.0" traitlets = "*" [package.extras] -dev = ["black[jupyter] (==23.3.0)", "build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.0.271)"] -docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-tornasync", "sphinx (>=1.8)", "sphinx-copybutton"] +dev = ["black[jupyter] (==23.7.0)", "build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.0.286)"] +docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-tornasync", "sphinx (>=1.8,<7.2.0)", "sphinx-copybutton"] docs-screenshots = ["altair (==5.0.1)", "ipython (==8.14.0)", "ipywidgets (==8.0.6)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.0.post0)", "matplotlib (==3.7.1)", "nbconvert (>=7.0.0)", "pandas (==2.0.2)", "scipy (==1.10.1)", "vega-datasets (==0.9.0)"] test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] @@ -1755,115 +1820,151 @@ files = [ [[package]] name = "jupyterlab-server" -version = "2.24.0" +version = "2.25.0" description = "A set of server components for JupyterLab and JupyterLab like applications." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "jupyterlab_server-2.24.0-py3-none-any.whl", hash = "sha256:5f077e142bb8dc9b843d960f940c513581bceca3793a0d80f9c67d9522c4e876"}, - {file = "jupyterlab_server-2.24.0.tar.gz", hash = "sha256:4e6f99e0a5579bbbc32e449c4dbb039561d4f1a7827d5733273ed56738f21f07"}, + {file = "jupyterlab_server-2.25.0-py3-none-any.whl", hash = "sha256:c9f67a98b295c5dee87f41551b0558374e45d449f3edca153dd722140630dcb2"}, + {file = "jupyterlab_server-2.25.0.tar.gz", hash = "sha256:77c2f1f282d610f95e496e20d5bf1d2a7706826dfb7b18f3378ae2870d272fb7"}, ] [package.dependencies] babel = ">=2.10" jinja2 = ">=3.0.3" json5 = ">=0.9.0" -jsonschema = ">=4.17.3" +jsonschema = ">=4.18.0" jupyter-server = ">=1.21,<3" packaging = ">=21.3" -requests = ">=2.28" +requests = ">=2.31" [package.extras] docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] -openapi = ["openapi-core (>=0.16.1,<0.17.0)", "ruamel-yaml"] -test = ["hatch", "ipykernel", "jupyterlab-server[openapi]", "openapi-spec-validator (>=0.5.1,<0.7.0)", "pytest (>=7.0)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.7.0)", "pytest (>=7.0)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] [[package]] name = "jupyterlab-widgets" -version = "3.0.8" +version = "3.0.9" description = "Jupyter interactive widgets for JupyterLab" optional = false python-versions = ">=3.7" files = [ - {file = "jupyterlab_widgets-3.0.8-py3-none-any.whl", hash = "sha256:4715912d6ceab839c9db35953c764b3214ebbc9161c809f6e0510168845dfdf5"}, - {file = "jupyterlab_widgets-3.0.8.tar.gz", hash = "sha256:d428ab97b8d87cc7c54cbf37644d6e0f0e662f23876e05fa460a73ec3257252a"}, + {file = "jupyterlab_widgets-3.0.9-py3-none-any.whl", hash = "sha256:3cf5bdf5b897bf3bccf1c11873aa4afd776d7430200f765e0686bd352487b58d"}, + {file = "jupyterlab_widgets-3.0.9.tar.gz", hash = "sha256:6005a4e974c7beee84060fdfba341a3218495046de8ae3ec64888e5fe19fdb4c"}, ] [[package]] name = "kiwisolver" -version = "1.4.4" +version = "1.4.5" description = "A fast implementation of the Cassowary constraint solver" optional = false python-versions = ">=3.7" files = [ - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2f5e60fabb7343a836360c4f0919b8cd0d6dbf08ad2ca6b9cf90bf0c76a3c4f6"}, - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:10ee06759482c78bdb864f4109886dff7b8a56529bc1609d4f1112b93fe6423c"}, - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c79ebe8f3676a4c6630fd3f777f3cfecf9289666c84e775a67d1d358578dc2e3"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:abbe9fa13da955feb8202e215c4018f4bb57469b1b78c7a4c5c7b93001699938"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7577c1987baa3adc4b3c62c33bd1118c3ef5c8ddef36f0f2c950ae0b199e100d"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8ad8285b01b0d4695102546b342b493b3ccc6781fc28c8c6a1bb63e95d22f09"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ed58b8acf29798b036d347791141767ccf65eee7f26bde03a71c944449e53de"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a68b62a02953b9841730db7797422f983935aeefceb1679f0fc85cbfbd311c32"}, - {file = "kiwisolver-1.4.4-cp310-cp310-win32.whl", hash = "sha256:e92a513161077b53447160b9bd8f522edfbed4bd9759e4c18ab05d7ef7e49408"}, - {file = "kiwisolver-1.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:3fe20f63c9ecee44560d0e7f116b3a747a5d7203376abeea292ab3152334d004"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e0ea21f66820452a3f5d1655f8704a60d66ba1191359b96541eaf457710a5fc6"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bc9db8a3efb3e403e4ecc6cd9489ea2bac94244f80c78e27c31dcc00d2790ac2"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d5b61785a9ce44e5a4b880272baa7cf6c8f48a5180c3e81c59553ba0cb0821ca"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2dbb44c3f7e6c4d3487b31037b1bdbf424d97687c1747ce4ff2895795c9bf69"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6295ecd49304dcf3bfbfa45d9a081c96509e95f4b9d0eb7ee4ec0530c4a96514"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bd472dbe5e136f96a4b18f295d159d7f26fd399136f5b17b08c4e5f498cd494"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf7d9fce9bcc4752ca4a1b80aabd38f6d19009ea5cbda0e0856983cf6d0023f5"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d6601aed50c74e0ef02f4204da1816147a6d3fbdc8b3872d263338a9052c51"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:877272cf6b4b7e94c9614f9b10140e198d2186363728ed0f701c6eee1baec1da"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:db608a6757adabb32f1cfe6066e39b3706d8c3aa69bbc353a5b61edad36a5cb4"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:5853eb494c71e267912275e5586fe281444eb5e722de4e131cddf9d442615626"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:f0a1dbdb5ecbef0d34eb77e56fcb3e95bbd7e50835d9782a45df81cc46949750"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:283dffbf061a4ec60391d51e6155e372a1f7a4f5b15d59c8505339454f8989e4"}, - {file = "kiwisolver-1.4.4-cp311-cp311-win32.whl", hash = "sha256:d06adcfa62a4431d404c31216f0f8ac97397d799cd53800e9d3efc2fbb3cf14e"}, - {file = "kiwisolver-1.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:e7da3fec7408813a7cebc9e4ec55afed2d0fd65c4754bc376bf03498d4e92686"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:62ac9cc684da4cf1778d07a89bf5f81b35834cb96ca523d3a7fb32509380cbf6"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41dae968a94b1ef1897cb322b39360a0812661dba7c682aa45098eb8e193dbdf"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:02f79693ec433cb4b5f51694e8477ae83b3205768a6fb48ffba60549080e295b"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d0611a0a2a518464c05ddd5a3a1a0e856ccc10e67079bb17f265ad19ab3c7597"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:db5283d90da4174865d520e7366801a93777201e91e79bacbac6e6927cbceede"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1041feb4cda8708ce73bb4dcb9ce1ccf49d553bf87c3954bdfa46f0c3f77252c"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-win32.whl", hash = "sha256:a553dadda40fef6bfa1456dc4be49b113aa92c2a9a9e8711e955618cd69622e3"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-win_amd64.whl", hash = "sha256:03baab2d6b4a54ddbb43bba1a3a2d1627e82d205c5cf8f4c924dc49284b87166"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:841293b17ad704d70c578f1f0013c890e219952169ce8a24ebc063eecf775454"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f4f270de01dd3e129a72efad823da90cc4d6aafb64c410c9033aba70db9f1ff0"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f9f39e2f049db33a908319cf46624a569b36983c7c78318e9726a4cb8923b26c"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c97528e64cb9ebeff9701e7938653a9951922f2a38bd847787d4a8e498cc83ae"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d1573129aa0fd901076e2bfb4275a35f5b7aa60fbfb984499d661ec950320b0"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ad881edc7ccb9d65b0224f4e4d05a1e85cf62d73aab798943df6d48ab0cd79a1"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b428ef021242344340460fa4c9185d0b1f66fbdbfecc6c63eff4b7c29fad429d"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:2e407cb4bd5a13984a6c2c0fe1845e4e41e96f183e5e5cd4d77a857d9693494c"}, - {file = "kiwisolver-1.4.4-cp38-cp38-win32.whl", hash = "sha256:75facbe9606748f43428fc91a43edb46c7ff68889b91fa31f53b58894503a191"}, - {file = "kiwisolver-1.4.4-cp38-cp38-win_amd64.whl", hash = "sha256:5bce61af018b0cb2055e0e72e7d65290d822d3feee430b7b8203d8a855e78766"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8c808594c88a025d4e322d5bb549282c93c8e1ba71b790f539567932722d7bd8"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f0a71d85ecdd570ded8ac3d1c0f480842f49a40beb423bb8014539a9f32a5897"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b533558eae785e33e8c148a8d9921692a9fe5aa516efbdff8606e7d87b9d5824"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:efda5fc8cc1c61e4f639b8067d118e742b812c930f708e6667a5ce0d13499e29"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7c43e1e1206cd421cd92e6b3280d4385d41d7166b3ed577ac20444b6995a445f"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc8d3bd6c72b2dd9decf16ce70e20abcb3274ba01b4e1c96031e0c4067d1e7cd"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ea39b0ccc4f5d803e3337dd46bcce60b702be4d86fd0b3d7531ef10fd99a1ac"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:968f44fdbf6dd757d12920d63b566eeb4d5b395fd2d00d29d7ef00a00582aac9"}, - {file = "kiwisolver-1.4.4-cp39-cp39-win32.whl", hash = "sha256:da7e547706e69e45d95e116e6939488d62174e033b763ab1496b4c29b76fabea"}, - {file = "kiwisolver-1.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:ba59c92039ec0a66103b1d5fe588fa546373587a7d68f5c96f743c3396afc04b"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:91672bacaa030f92fc2f43b620d7b337fd9a5af28b0d6ed3f77afc43c4a64b5a"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:787518a6789009c159453da4d6b683f468ef7a65bbde796bcea803ccf191058d"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da152d8cdcab0e56e4f45eb08b9aea6455845ec83172092f09b0e077ece2cf7a"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ecb1fa0db7bf4cff9dac752abb19505a233c7f16684c5826d1f11ebd9472b871"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:28bc5b299f48150b5f822ce68624e445040595a4ac3d59251703779836eceff9"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:81e38381b782cc7e1e46c4e14cd997ee6040768101aefc8fa3c24a4cc58e98f8"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2a66fdfb34e05b705620dd567f5a03f239a088d5a3f321e7b6ac3239d22aa286"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:872b8ca05c40d309ed13eb2e582cab0c5a05e81e987ab9c521bf05ad1d5cf5cb"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:70e7c2e7b750585569564e2e5ca9845acfaa5da56ac46df68414f29fea97be9f"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9f85003f5dfa867e86d53fac6f7e6f30c045673fa27b603c397753bebadc3008"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e307eb9bd99801f82789b44bb45e9f541961831c7311521b13a6c85afc09767"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1792d939ec70abe76f5054d3f36ed5656021dcad1322d1cc996d4e54165cef9"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6cb459eea32a4e2cf18ba5fcece2dbdf496384413bc1bae15583f19e567f3b2"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:36dafec3d6d6088d34e2de6b85f9d8e2324eb734162fba59d2ba9ed7a2043d5b"}, - {file = "kiwisolver-1.4.4.tar.gz", hash = "sha256:d41997519fcba4a1e46eb4a2fe31bc12f0ff957b2b81bac28db24744f333e955"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, ] [[package]] @@ -1998,52 +2099,39 @@ files = [ [[package]] name = "matplotlib" -version = "3.7.2" +version = "3.8.0" description = "Python plotting package" optional = false -python-versions = ">=3.8" +python-versions = ">=3.9" files = [ - {file = "matplotlib-3.7.2-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:2699f7e73a76d4c110f4f25be9d2496d6ab4f17345307738557d345f099e07de"}, - {file = "matplotlib-3.7.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a8035ba590658bae7562786c9cc6ea1a84aa49d3afab157e414c9e2ea74f496d"}, - {file = "matplotlib-3.7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2f8e4a49493add46ad4a8c92f63e19d548b2b6ebbed75c6b4c7f46f57d36cdd1"}, - {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71667eb2ccca4c3537d9414b1bc00554cb7f91527c17ee4ec38027201f8f1603"}, - {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:152ee0b569a37630d8628534c628456b28686e085d51394da6b71ef84c4da201"}, - {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:070f8dddd1f5939e60aacb8fa08f19551f4b0140fab16a3669d5cd6e9cb28fc8"}, - {file = "matplotlib-3.7.2-cp310-cp310-win32.whl", hash = "sha256:fdbb46fad4fb47443b5b8ac76904b2e7a66556844f33370861b4788db0f8816a"}, - {file = "matplotlib-3.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:23fb1750934e5f0128f9423db27c474aa32534cec21f7b2153262b066a581fd1"}, - {file = "matplotlib-3.7.2-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:30e1409b857aa8a747c5d4f85f63a79e479835f8dffc52992ac1f3f25837b544"}, - {file = "matplotlib-3.7.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:50e0a55ec74bf2d7a0ebf50ac580a209582c2dd0f7ab51bc270f1b4a0027454e"}, - {file = "matplotlib-3.7.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ac60daa1dc83e8821eed155796b0f7888b6b916cf61d620a4ddd8200ac70cd64"}, - {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:305e3da477dc8607336ba10bac96986d6308d614706cae2efe7d3ffa60465b24"}, - {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c308b255efb9b06b23874236ec0f10f026673ad6515f602027cc8ac7805352d"}, - {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60c521e21031632aa0d87ca5ba0c1c05f3daacadb34c093585a0be6780f698e4"}, - {file = "matplotlib-3.7.2-cp311-cp311-win32.whl", hash = "sha256:26bede320d77e469fdf1bde212de0ec889169b04f7f1179b8930d66f82b30cbc"}, - {file = "matplotlib-3.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:af4860132c8c05261a5f5f8467f1b269bf1c7c23902d75f2be57c4a7f2394b3e"}, - {file = "matplotlib-3.7.2-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:a1733b8e84e7e40a9853e505fe68cc54339f97273bdfe6f3ed980095f769ddc7"}, - {file = "matplotlib-3.7.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d9881356dc48e58910c53af82b57183879129fa30492be69058c5b0d9fddf391"}, - {file = "matplotlib-3.7.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f081c03f413f59390a80b3e351cc2b2ea0205839714dbc364519bcf51f4b56ca"}, - {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1cd120fca3407a225168238b790bd5c528f0fafde6172b140a2f3ab7a4ea63e9"}, - {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a2c1590b90aa7bd741b54c62b78de05d4186271e34e2377e0289d943b3522273"}, - {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d2ff3c984b8a569bc1383cd468fc06b70d7b59d5c2854ca39f1436ae8394117"}, - {file = "matplotlib-3.7.2-cp38-cp38-win32.whl", hash = "sha256:5dea00b62d28654b71ca92463656d80646675628d0828e08a5f3b57e12869e13"}, - {file = "matplotlib-3.7.2-cp38-cp38-win_amd64.whl", hash = "sha256:0f506a1776ee94f9e131af1ac6efa6e5bc7cb606a3e389b0ccb6e657f60bb676"}, - {file = "matplotlib-3.7.2-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:6515e878f91894c2e4340d81f0911857998ccaf04dbc1bba781e3d89cbf70608"}, - {file = "matplotlib-3.7.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:71f7a8c6b124e904db550f5b9fe483d28b896d4135e45c4ea381ad3b8a0e3256"}, - {file = "matplotlib-3.7.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:12f01b92ecd518e0697da4d97d163b2b3aa55eb3eb4e2c98235b3396d7dad55f"}, - {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7e28d6396563955f7af437894a36bf2b279462239a41028323e04b85179058b"}, - {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbcf59334ff645e6a67cd5f78b4b2cdb76384cdf587fa0d2dc85f634a72e1a3e"}, - {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:318c89edde72ff95d8df67d82aca03861240512994a597a435a1011ba18dbc7f"}, - {file = "matplotlib-3.7.2-cp39-cp39-win32.whl", hash = "sha256:ce55289d5659b5b12b3db4dc9b7075b70cef5631e56530f14b2945e8836f2d20"}, - {file = "matplotlib-3.7.2-cp39-cp39-win_amd64.whl", hash = "sha256:2ecb5be2b2815431c81dc115667e33da0f5a1bcf6143980d180d09a717c4a12e"}, - {file = "matplotlib-3.7.2-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:fdcd28360dbb6203fb5219b1a5658df226ac9bebc2542a9e8f457de959d713d0"}, - {file = "matplotlib-3.7.2-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c3cca3e842b11b55b52c6fb8bd6a4088693829acbfcdb3e815fa9b7d5c92c1b"}, - {file = "matplotlib-3.7.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebf577c7a6744e9e1bd3fee45fc74a02710b214f94e2bde344912d85e0c9af7c"}, - {file = "matplotlib-3.7.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:936bba394682049919dda062d33435b3be211dc3dcaa011e09634f060ec878b2"}, - {file = "matplotlib-3.7.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:bc221ffbc2150458b1cd71cdd9ddd5bb37962b036e41b8be258280b5b01da1dd"}, - {file = "matplotlib-3.7.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:35d74ebdb3f71f112b36c2629cf32323adfbf42679e2751252acd468f5001c07"}, - {file = "matplotlib-3.7.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:717157e61b3a71d3d26ad4e1770dc85156c9af435659a25ee6407dc866cb258d"}, - {file = "matplotlib-3.7.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:20f844d6be031948148ba49605c8b96dfe7d3711d1b63592830d650622458c11"}, - {file = "matplotlib-3.7.2.tar.gz", hash = "sha256:a8cdb91dddb04436bd2f098b8fdf4b81352e68cf4d2c6756fcc414791076569b"}, + {file = "matplotlib-3.8.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c4940bad88a932ddc69734274f6fb047207e008389489f2b6f77d9ca485f0e7a"}, + {file = "matplotlib-3.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a33bd3045c7452ca1fa65676d88ba940867880e13e2546abb143035fa9072a9d"}, + {file = "matplotlib-3.8.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ea6886e93401c22e534bbfd39201ce8931b75502895cfb115cbdbbe2d31f287"}, + {file = "matplotlib-3.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d670b9348e712ec176de225d425f150dc8e37b13010d85233c539b547da0be39"}, + {file = "matplotlib-3.8.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7b37b74f00c4cb6af908cb9a00779d97d294e89fd2145ad43f0cdc23f635760c"}, + {file = "matplotlib-3.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:0e723f5b96f3cd4aad99103dc93e9e3cdc4f18afdcc76951f4857b46f8e39d2d"}, + {file = "matplotlib-3.8.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:5dc945a9cb2deb7d197ba23eb4c210e591d52d77bf0ba27c35fc82dec9fa78d4"}, + {file = "matplotlib-3.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8b5a1bf27d078453aa7b5b27f52580e16360d02df6d3dc9504f3d2ce11f6309"}, + {file = "matplotlib-3.8.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f25ffb6ad972cdffa7df8e5be4b1e3cadd2f8d43fc72085feb1518006178394"}, + {file = "matplotlib-3.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee482731c8c17d86d9ddb5194d38621f9b0f0d53c99006275a12523ab021732"}, + {file = "matplotlib-3.8.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:36eafe2128772195b373e1242df28d1b7ec6c04c15b090b8d9e335d55a323900"}, + {file = "matplotlib-3.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:061ee58facb3580cd2d046a6d227fb77e9295599c5ec6ad069f06b5821ad1cfc"}, + {file = "matplotlib-3.8.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3cc3776836d0f4f22654a7f2d2ec2004618d5cf86b7185318381f73b80fd8a2d"}, + {file = "matplotlib-3.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6c49a2bd6981264bddcb8c317b6bd25febcece9e2ebfcbc34e7f4c0c867c09dc"}, + {file = "matplotlib-3.8.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23ed11654fc83cd6cfdf6170b453e437674a050a452133a064d47f2f1371f8d3"}, + {file = "matplotlib-3.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dae97fdd6996b3a25da8ee43e3fc734fff502f396801063c6b76c20b56683196"}, + {file = "matplotlib-3.8.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:87df75f528020a6299f76a1d986c0ed4406e3b2bd44bc5e306e46bca7d45e53e"}, + {file = "matplotlib-3.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:90d74a95fe055f73a6cd737beecc1b81c26f2893b7a3751d52b53ff06ca53f36"}, + {file = "matplotlib-3.8.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c3499c312f5def8f362a2bf761d04fa2d452b333f3a9a3f58805273719bf20d9"}, + {file = "matplotlib-3.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:31e793c8bd4ea268cc5d3a695c27b30650ec35238626961d73085d5e94b6ab68"}, + {file = "matplotlib-3.8.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d5ee602ef517a89d1f2c508ca189cfc395dd0b4a08284fb1b97a78eec354644"}, + {file = "matplotlib-3.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5de39dc61ca35342cf409e031f70f18219f2c48380d3886c1cf5ad9f17898e06"}, + {file = "matplotlib-3.8.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:dd386c80a98b5f51571b9484bf6c6976de383cd2a8cd972b6a9562d85c6d2087"}, + {file = "matplotlib-3.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:f691b4ef47c7384d0936b2e8ebdeb5d526c81d004ad9403dfb9d4c76b9979a93"}, + {file = "matplotlib-3.8.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0b11f354aae62a2aa53ec5bb09946f5f06fc41793e351a04ff60223ea9162955"}, + {file = "matplotlib-3.8.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f54b9fb87ca5acbcdd0f286021bedc162e1425fa5555ebf3b3dfc167b955ad9"}, + {file = "matplotlib-3.8.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:60a6e04dfd77c0d3bcfee61c3cd335fff1b917c2f303b32524cd1235e194ef99"}, + {file = "matplotlib-3.8.0.tar.gz", hash = "sha256:df8505e1c19d5c2c26aff3497a7cbd3ccfc2e97043d1e4db3e76afa399164b69"}, ] [package.dependencies] @@ -2051,11 +2139,12 @@ contourpy = ">=1.0.1" cycler = ">=0.10" fonttools = ">=4.22.0" kiwisolver = ">=1.0.1" -numpy = ">=1.20" +numpy = ">=1.21,<2" packaging = ">=20.0" pillow = ">=6.2.0" -pyparsing = ">=2.3.1,<3.1" +pyparsing = ">=2.3.1" python-dateutil = ">=2.7" +setuptools_scm = ">=7" [[package]] name = "matplotlib-inline" @@ -2073,28 +2162,24 @@ traitlets = "*" [[package]] name = "maze-dataset" -version = "0.2.1" +version = "0.4.1" description = "" optional = false -python-versions = "^3.10" -files = [] -develop = false +python-versions = ">=3.10,<4.0" +files = [ + {file = "maze_dataset-0.4.1-py3-none-any.whl", hash = "sha256:f043f87231185e0226ce0630f4dd093079db84eb127de6479c48e8eb36e6bd2d"}, + {file = "maze_dataset-0.4.1.tar.gz", hash = "sha256:ce26f022c6e2bf6d304f4b74b2dc4db6fe827ee5a5fdbe585a3f9a73dc74bb5f"}, +] [package.dependencies] -ipykernel = "^6.22.0" -jaxtyping = "^0.2.19" -jupyter = "^1.0.0" -matplotlib = "^3.7.0" -muutils = "^0.5.1" +ipykernel = ">=6.22.0,<7.0.0" +jaxtyping = ">=0.2.19,<0.3.0" +jupyter = ">=1.0.0,<2.0.0" +matplotlib = ">=3.7.0,<4.0.0" +muutils = ">=0.5.1,<0.6.0" torch = ">=1.13.1" -tqdm = "^4.65.0" -zanj = "^0.2.0" - -[package.source] -type = "git" -url = "https://github.com/AISC-understanding-search/maze-dataset.git" -reference = "HEAD" -resolved_reference = "e8e3324fa49bf1e009c6a81b02be6a13a62a533b" +tqdm = ">=4.65.0,<5.0.0" +zanj = ">=0.2.0,<0.3.0" [[package]] name = "mdurl" @@ -2109,15 +2194,32 @@ files = [ [[package]] name = "mistune" -version = "3.0.1" +version = "3.0.2" description = "A sane and fast Markdown parser with useful plugins and renderers" optional = false python-versions = ">=3.7" files = [ - {file = "mistune-3.0.1-py3-none-any.whl", hash = "sha256:b9b3e438efbb57c62b5beb5e134dab664800bdf1284a7ee09e8b12b13eb1aac6"}, - {file = "mistune-3.0.1.tar.gz", hash = "sha256:e912116c13aa0944f9dc530db38eb88f6a77087ab128f49f84a48f4c05ea163c"}, + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, ] +[[package]] +name = "mpmath" +version = "1.3.0" +description = "Python library for arbitrary-precision floating-point arithmetic" +optional = false +python-versions = "*" +files = [ + {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, + {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, +] + +[package.extras] +develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] +docs = ["sphinx"] +gmpy = ["gmpy2 (>=2.1.0a4)"] +tests = ["pytest (>=4.6)"] + [[package]] name = "multidict" version = "6.0.4" @@ -2231,13 +2333,13 @@ dill = ">=0.3.7" [[package]] name = "muutils" -version = "0.5.1" +version = "0.5.2" description = "A collection of miscellaneous python utilities" optional = false python-versions = ">=3.10,<4.0" files = [ - {file = "muutils-0.5.1-py3-none-any.whl", hash = "sha256:9c4c94f263e7fe05a42ca1468f81725371300646bc66f00411502c49013f273b"}, - {file = "muutils-0.5.1.tar.gz", hash = "sha256:498981918bb49926a03e0499869aaa73f8f65db34943105a1f3ef0939de81d61"}, + {file = "muutils-0.5.2-py3-none-any.whl", hash = "sha256:f25243f9efa07f60dcea727a51d5a843eab1cdb7c1b67a5d0439c07d3b32068f"}, + {file = "muutils-0.5.2.tar.gz", hash = "sha256:4e594e39fc42f36b6c2348ac58bbe8ab33af29b0dfc4a15d9ec7a0505d3e2933"}, ] [package.dependencies] @@ -2283,13 +2385,13 @@ test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>= [[package]] name = "nbconvert" -version = "7.7.3" +version = "7.8.0" description = "Converting Jupyter Notebooks" optional = false python-versions = ">=3.8" files = [ - {file = "nbconvert-7.7.3-py3-none-any.whl", hash = "sha256:3022adadff3f86578a47fab7c2228bb3ca9c56a24345642a22f917f6168b48fc"}, - {file = "nbconvert-7.7.3.tar.gz", hash = "sha256:4a5996bf5f3cd16aa0431897ba1aa4c64842c2079f434b3dc6b8c4b252ef3355"}, + {file = "nbconvert-7.8.0-py3-none-any.whl", hash = "sha256:aec605e051fa682ccc7934ccc338ba1e8b626cfadbab0db592106b630f63f0f2"}, + {file = "nbconvert-7.8.0.tar.gz", hash = "sha256:f5bc15a1247e14dd41ceef0c0a3bc70020e016576eb0578da62f1c5b4f950479"}, ] [package.dependencies] @@ -2341,24 +2443,42 @@ test = ["pep440", "pre-commit", "pytest", "testpath"] [[package]] name = "nest-asyncio" -version = "1.5.7" +version = "1.5.8" description = "Patch asyncio to allow nested event loops" optional = false python-versions = ">=3.5" files = [ - {file = "nest_asyncio-1.5.7-py3-none-any.whl", hash = "sha256:5301c82941b550b3123a1ea772ba9a1c80bad3a182be8c1a5ae6ad3be57a9657"}, - {file = "nest_asyncio-1.5.7.tar.gz", hash = "sha256:6a80f7b98f24d9083ed24608977c09dd608d83f91cccc24c9d2cba6d10e01c10"}, + {file = "nest_asyncio-1.5.8-py3-none-any.whl", hash = "sha256:accda7a339a70599cb08f9dd09a67e0c2ef8d8d6f4c07f96ab203f2ae254e48d"}, + {file = "nest_asyncio-1.5.8.tar.gz", hash = "sha256:25aa2ca0d2a5b5531956b9e273b45cf664cae2b145101d73b86b199978d48fdb"}, ] +[[package]] +name = "networkx" +version = "3.1" +description = "Python package for creating and manipulating graphs and networks" +optional = false +python-versions = ">=3.8" +files = [ + {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, + {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, +] + +[package.extras] +default = ["matplotlib (>=3.4)", "numpy (>=1.20)", "pandas (>=1.3)", "scipy (>=1.8)"] +developer = ["mypy (>=1.1)", "pre-commit (>=3.2)"] +doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.13)", "sphinx (>=6.1)", "sphinx-gallery (>=0.12)", "texext (>=0.6.7)"] +extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.10)", "sympy (>=1.10)"] +test = ["codecov (>=2.1)", "pytest (>=7.2)", "pytest-cov (>=4.0)"] + [[package]] name = "notebook" -version = "7.0.2" +version = "7.0.4" description = "Jupyter Notebook - A web-based notebook environment for interactive computing" optional = false python-versions = ">=3.8" files = [ - {file = "notebook-7.0.2-py3-none-any.whl", hash = "sha256:c77b1499dc9b07ce4f4f26990dcb25b2107b434f2536766b51a72a4228d9a4b6"}, - {file = "notebook-7.0.2.tar.gz", hash = "sha256:d70d6a07418c829bd5f54337ce993b7105261d9026f9d3fe68e9b8aa1a20da9a"}, + {file = "notebook-7.0.4-py3-none-any.whl", hash = "sha256:ee738414ac01773c1ad6834cf76cc6f1ce140ac8197fd13b3e2d44d89e257f72"}, + {file = "notebook-7.0.4.tar.gz", hash = "sha256:0c1b458f72ce8774445c8ef9ed2492bd0b9ce9605ac996e2b066114f69795e71"}, ] [package.dependencies] @@ -2371,7 +2491,7 @@ tornado = ">=6.2.0" [package.extras] dev = ["hatch", "pre-commit"] docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] +test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] [[package]] name = "notebook-shim" @@ -2392,99 +2512,45 @@ test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync" [[package]] name = "numpy" -version = "1.25.2" +version = "1.26.0" description = "Fundamental package for array computing in Python" optional = false -python-versions = ">=3.9" -files = [ - {file = "numpy-1.25.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db3ccc4e37a6873045580d413fe79b68e47a681af8db2e046f1dacfa11f86eb3"}, - {file = "numpy-1.25.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:90319e4f002795ccfc9050110bbbaa16c944b1c37c0baeea43c5fb881693ae1f"}, - {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfe4a913e29b418d096e696ddd422d8a5d13ffba4ea91f9f60440a3b759b0187"}, - {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f08f2e037bba04e707eebf4bc934f1972a315c883a9e0ebfa8a7756eabf9e357"}, - {file = "numpy-1.25.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bec1e7213c7cb00d67093247f8c4db156fd03075f49876957dca4711306d39c9"}, - {file = "numpy-1.25.2-cp310-cp310-win32.whl", hash = "sha256:7dc869c0c75988e1c693d0e2d5b26034644399dd929bc049db55395b1379e044"}, - {file = "numpy-1.25.2-cp310-cp310-win_amd64.whl", hash = "sha256:834b386f2b8210dca38c71a6e0f4fd6922f7d3fcff935dbe3a570945acb1b545"}, - {file = "numpy-1.25.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c5462d19336db4560041517dbb7759c21d181a67cb01b36ca109b2ae37d32418"}, - {file = "numpy-1.25.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c5652ea24d33585ea39eb6a6a15dac87a1206a692719ff45d53c5282e66d4a8f"}, - {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d60fbae8e0019865fc4784745814cff1c421df5afee233db6d88ab4f14655a2"}, - {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60e7f0f7f6d0eee8364b9a6304c2845b9c491ac706048c7e8cf47b83123b8dbf"}, - {file = "numpy-1.25.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bb33d5a1cf360304754913a350edda36d5b8c5331a8237268c48f91253c3a364"}, - {file = "numpy-1.25.2-cp311-cp311-win32.whl", hash = "sha256:5883c06bb92f2e6c8181df7b39971a5fb436288db58b5a1c3967702d4278691d"}, - {file = "numpy-1.25.2-cp311-cp311-win_amd64.whl", hash = "sha256:5c97325a0ba6f9d041feb9390924614b60b99209a71a69c876f71052521d42a4"}, - {file = "numpy-1.25.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b79e513d7aac42ae918db3ad1341a015488530d0bb2a6abcbdd10a3a829ccfd3"}, - {file = "numpy-1.25.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eb942bfb6f84df5ce05dbf4b46673ffed0d3da59f13635ea9b926af3deb76926"}, - {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e0746410e73384e70d286f93abf2520035250aad8c5714240b0492a7302fdca"}, - {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7806500e4f5bdd04095e849265e55de20d8cc4b661b038957354327f6d9b295"}, - {file = "numpy-1.25.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8b77775f4b7df768967a7c8b3567e309f617dd5e99aeb886fa14dc1a0791141f"}, - {file = "numpy-1.25.2-cp39-cp39-win32.whl", hash = "sha256:2792d23d62ec51e50ce4d4b7d73de8f67a2fd3ea710dcbc8563a51a03fb07b01"}, - {file = "numpy-1.25.2-cp39-cp39-win_amd64.whl", hash = "sha256:76b4115d42a7dfc5d485d358728cdd8719be33cc5ec6ec08632a5d6fca2ed380"}, - {file = "numpy-1.25.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1a1329e26f46230bf77b02cc19e900db9b52f398d6722ca853349a782d4cff55"}, - {file = "numpy-1.25.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c3abc71e8b6edba80a01a52e66d83c5d14433cbcd26a40c329ec7ed09f37901"}, - {file = "numpy-1.25.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1b9735c27cea5d995496f46a8b1cd7b408b3f34b6d50459d9ac8fe3a20cc17bf"}, - {file = "numpy-1.25.2.tar.gz", hash = "sha256:fd608e19c8d7c55021dffd43bfe5492fab8cc105cc8986f813f8c3c048b38760"}, -] - -[[package]] -name = "nvidia-cublas-cu11" -version = "11.10.3.66" -description = "CUBLAS native runtime libraries" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-manylinux1_x86_64.whl", hash = "sha256:d32e4d75f94ddfb93ea0a5dda08389bcc65d8916a25cb9f37ac89edaeed3bded"}, - {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-win_amd64.whl", hash = "sha256:8ac17ba6ade3ed56ab898a036f9ae0756f1e81052a317bf98f8c6d18dc3ae49e"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cuda-nvrtc-cu11" -version = "11.7.99" -description = "NVRTC native runtime libraries" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:9f1562822ea264b7e34ed5930567e89242d266448e936b85bc97a3370feabb03"}, - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:f7d9610d9b7c331fa0da2d1b2858a4a8315e6d49765091d28711c8946e7425e7"}, - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:f2effeb1309bdd1b3854fc9b17eaf997808f8b25968ce0c7070945c4265d64a3"}, +python-versions = "<3.13,>=3.9" +files = [ + {file = "numpy-1.26.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f8db2f125746e44dce707dd44d4f4efeea8d7e2b43aace3f8d1f235cfa2733dd"}, + {file = "numpy-1.26.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0621f7daf973d34d18b4e4bafb210bbaf1ef5e0100b5fa750bd9cde84c7ac292"}, + {file = "numpy-1.26.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51be5f8c349fdd1a5568e72713a21f518e7d6707bcf8503b528b88d33b57dc68"}, + {file = "numpy-1.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:767254ad364991ccfc4d81b8152912e53e103ec192d1bb4ea6b1f5a7117040be"}, + {file = "numpy-1.26.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:436c8e9a4bdeeee84e3e59614d38c3dbd3235838a877af8c211cfcac8a80b8d3"}, + {file = "numpy-1.26.0-cp310-cp310-win32.whl", hash = "sha256:c2e698cb0c6dda9372ea98a0344245ee65bdc1c9dd939cceed6bb91256837896"}, + {file = "numpy-1.26.0-cp310-cp310-win_amd64.whl", hash = "sha256:09aaee96c2cbdea95de76ecb8a586cb687d281c881f5f17bfc0fb7f5890f6b91"}, + {file = "numpy-1.26.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:637c58b468a69869258b8ae26f4a4c6ff8abffd4a8334c830ffb63e0feefe99a"}, + {file = "numpy-1.26.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:306545e234503a24fe9ae95ebf84d25cba1fdc27db971aa2d9f1ab6bba19a9dd"}, + {file = "numpy-1.26.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c6adc33561bd1d46f81131d5352348350fc23df4d742bb246cdfca606ea1208"}, + {file = "numpy-1.26.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e062aa24638bb5018b7841977c360d2f5917268d125c833a686b7cbabbec496c"}, + {file = "numpy-1.26.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:546b7dd7e22f3c6861463bebb000646fa730e55df5ee4a0224408b5694cc6148"}, + {file = "numpy-1.26.0-cp311-cp311-win32.whl", hash = "sha256:c0b45c8b65b79337dee5134d038346d30e109e9e2e9d43464a2970e5c0e93229"}, + {file = "numpy-1.26.0-cp311-cp311-win_amd64.whl", hash = "sha256:eae430ecf5794cb7ae7fa3808740b015aa80747e5266153128ef055975a72b99"}, + {file = "numpy-1.26.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:166b36197e9debc4e384e9c652ba60c0bacc216d0fc89e78f973a9760b503388"}, + {file = "numpy-1.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f042f66d0b4ae6d48e70e28d487376204d3cbf43b84c03bac57e28dac6151581"}, + {file = "numpy-1.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5e18e5b14a7560d8acf1c596688f4dfd19b4f2945b245a71e5af4ddb7422feb"}, + {file = "numpy-1.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f6bad22a791226d0a5c7c27a80a20e11cfe09ad5ef9084d4d3fc4a299cca505"}, + {file = "numpy-1.26.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4acc65dd65da28060e206c8f27a573455ed724e6179941edb19f97e58161bb69"}, + {file = "numpy-1.26.0-cp312-cp312-win32.whl", hash = "sha256:bb0d9a1aaf5f1cb7967320e80690a1d7ff69f1d47ebc5a9bea013e3a21faec95"}, + {file = "numpy-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:ee84ca3c58fe48b8ddafdeb1db87388dce2c3c3f701bf447b05e4cfcc3679112"}, + {file = "numpy-1.26.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4a873a8180479bc829313e8d9798d5234dfacfc2e8a7ac188418189bb8eafbd2"}, + {file = "numpy-1.26.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:914b28d3215e0c721dc75db3ad6d62f51f630cb0c277e6b3bcb39519bed10bd8"}, + {file = "numpy-1.26.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c78a22e95182fb2e7874712433eaa610478a3caf86f28c621708d35fa4fd6e7f"}, + {file = "numpy-1.26.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86f737708b366c36b76e953c46ba5827d8c27b7a8c9d0f471810728e5a2fe57c"}, + {file = "numpy-1.26.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b44e6a09afc12952a7d2a58ca0a2429ee0d49a4f89d83a0a11052da696440e49"}, + {file = "numpy-1.26.0-cp39-cp39-win32.whl", hash = "sha256:5671338034b820c8d58c81ad1dafc0ed5a00771a82fccc71d6438df00302094b"}, + {file = "numpy-1.26.0-cp39-cp39-win_amd64.whl", hash = "sha256:020cdbee66ed46b671429c7265cf00d8ac91c046901c55684954c3958525dab2"}, + {file = "numpy-1.26.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0792824ce2f7ea0c82ed2e4fecc29bb86bee0567a080dacaf2e0a01fe7654369"}, + {file = "numpy-1.26.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d484292eaeb3e84a51432a94f53578689ffdea3f90e10c8b203a99be5af57d8"}, + {file = "numpy-1.26.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:186ba67fad3c60dbe8a3abff3b67a91351100f2661c8e2a80364ae6279720299"}, + {file = "numpy-1.26.0.tar.gz", hash = "sha256:f93fc78fe8bf15afe2b8d6b6499f1c73953169fad1e9a8dd086cdff3190e7fdf"}, ] -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cuda-runtime-cu11" -version = "11.7.99" -description = "CUDA Runtime native Libraries" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:cc768314ae58d2641f07eac350f40f99dcb35719c4faff4bc458a7cd2b119e31"}, - {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:bc77fa59a7679310df9d5c70ab13c4e34c64ae2124dd1efd7e5474b71be125c7"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cudnn-cu11" -version = "8.5.0.96" -description = "cuDNN runtime libraries" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cudnn_cu11-8.5.0.96-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:402f40adfc6f418f9dae9ab402e773cfed9beae52333f6d86ae3107a1b9527e7"}, - {file = "nvidia_cudnn_cu11-8.5.0.96-py3-none-manylinux1_x86_64.whl", hash = "sha256:71f8111eb830879ff2836db3cccf03bbd735df9b0d17cd93761732ac50a8a108"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - [[package]] name = "overrides" version = "7.4.0" @@ -2628,67 +2694,65 @@ files = [ [[package]] name = "pillow" -version = "10.0.0" +version = "10.0.1" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.8" files = [ - {file = "Pillow-10.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f62406a884ae75fb2f818694469519fb685cc7eaff05d3451a9ebe55c646891"}, - {file = "Pillow-10.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d5db32e2a6ccbb3d34d87c87b432959e0db29755727afb37290e10f6e8e62614"}, - {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edf4392b77bdc81f36e92d3a07a5cd072f90253197f4a52a55a8cec48a12483b"}, - {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:520f2a520dc040512699f20fa1c363eed506e94248d71f85412b625026f6142c"}, - {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:8c11160913e3dd06c8ffdb5f233a4f254cb449f4dfc0f8f4549eda9e542c93d1"}, - {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a74ba0c356aaa3bb8e3eb79606a87669e7ec6444be352870623025d75a14a2bf"}, - {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d5d0dae4cfd56969d23d94dc8e89fb6a217be461c69090768227beb8ed28c0a3"}, - {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22c10cc517668d44b211717fd9775799ccec4124b9a7f7b3635fc5386e584992"}, - {file = "Pillow-10.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:dffe31a7f47b603318c609f378ebcd57f1554a3a6a8effbc59c3c69f804296de"}, - {file = "Pillow-10.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:9fb218c8a12e51d7ead2a7c9e101a04982237d4855716af2e9499306728fb485"}, - {file = "Pillow-10.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d35e3c8d9b1268cbf5d3670285feb3528f6680420eafe35cccc686b73c1e330f"}, - {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ed64f9ca2f0a95411e88a4efbd7a29e5ce2cea36072c53dd9d26d9c76f753b3"}, - {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6eb5502f45a60a3f411c63187db83a3d3107887ad0d036c13ce836f8a36f1d"}, - {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:c1fbe7621c167ecaa38ad29643d77a9ce7311583761abf7836e1510c580bf3dd"}, - {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cd25d2a9d2b36fcb318882481367956d2cf91329f6892fe5d385c346c0649629"}, - {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3b08d4cc24f471b2c8ca24ec060abf4bebc6b144cb89cba638c720546b1cf538"}, - {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d737a602fbd82afd892ca746392401b634e278cb65d55c4b7a8f48e9ef8d008d"}, - {file = "Pillow-10.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3a82c40d706d9aa9734289740ce26460a11aeec2d9c79b7af87bb35f0073c12f"}, - {file = "Pillow-10.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:bc2ec7c7b5d66b8ec9ce9f720dbb5fa4bace0f545acd34870eff4a369b44bf37"}, - {file = "Pillow-10.0.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:d80cf684b541685fccdd84c485b31ce73fc5c9b5d7523bf1394ce134a60c6883"}, - {file = "Pillow-10.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76de421f9c326da8f43d690110f0e79fe3ad1e54be811545d7d91898b4c8493e"}, - {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81ff539a12457809666fef6624684c008e00ff6bf455b4b89fd00a140eecd640"}, - {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce543ed15570eedbb85df19b0a1a7314a9c8141a36ce089c0a894adbfccb4568"}, - {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:685ac03cc4ed5ebc15ad5c23bc555d68a87777586d970c2c3e216619a5476223"}, - {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d72e2ecc68a942e8cf9739619b7f408cc7b272b279b56b2c83c6123fcfa5cdff"}, - {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d50b6aec14bc737742ca96e85d6d0a5f9bfbded018264b3b70ff9d8c33485551"}, - {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:00e65f5e822decd501e374b0650146063fbb30a7264b4d2744bdd7b913e0cab5"}, - {file = "Pillow-10.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:f31f9fdbfecb042d046f9d91270a0ba28368a723302786c0009ee9b9f1f60199"}, - {file = "Pillow-10.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:1ce91b6ec08d866b14413d3f0bbdea7e24dfdc8e59f562bb77bc3fe60b6144ca"}, - {file = "Pillow-10.0.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:349930d6e9c685c089284b013478d6f76e3a534e36ddfa912cde493f235372f3"}, - {file = "Pillow-10.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3a684105f7c32488f7153905a4e3015a3b6c7182e106fe3c37fbb5ef3e6994c3"}, - {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4f69b3700201b80bb82c3a97d5e9254084f6dd5fb5b16fc1a7b974260f89f43"}, - {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f07ea8d2f827d7d2a49ecf1639ec02d75ffd1b88dcc5b3a61bbb37a8759ad8d"}, - {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:040586f7d37b34547153fa383f7f9aed68b738992380ac911447bb78f2abe530"}, - {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:f88a0b92277de8e3ca715a0d79d68dc82807457dae3ab8699c758f07c20b3c51"}, - {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c7cf14a27b0d6adfaebb3ae4153f1e516df54e47e42dcc073d7b3d76111a8d86"}, - {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:3400aae60685b06bb96f99a21e1ada7bc7a413d5f49bce739828ecd9391bb8f7"}, - {file = "Pillow-10.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:dbc02381779d412145331789b40cc7b11fdf449e5d94f6bc0b080db0a56ea3f0"}, - {file = "Pillow-10.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:9211e7ad69d7c9401cfc0e23d49b69ca65ddd898976d660a2fa5904e3d7a9baa"}, - {file = "Pillow-10.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:faaf07ea35355b01a35cb442dd950d8f1bb5b040a7787791a535de13db15ed90"}, - {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9f72a021fbb792ce98306ffb0c348b3c9cb967dce0f12a49aa4c3d3fdefa967"}, - {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f7c16705f44e0504a3a2a14197c1f0b32a95731d251777dcb060aa83022cb2d"}, - {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:76edb0a1fa2b4745fb0c99fb9fb98f8b180a1bbceb8be49b087e0b21867e77d3"}, - {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:368ab3dfb5f49e312231b6f27b8820c823652b7cd29cfbd34090565a015e99ba"}, - {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:608bfdee0d57cf297d32bcbb3c728dc1da0907519d1784962c5f0c68bb93e5a3"}, - {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5c6e3df6bdd396749bafd45314871b3d0af81ff935b2d188385e970052091017"}, - {file = "Pillow-10.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:7be600823e4c8631b74e4a0d38384c73f680e6105a7d3c6824fcf226c178c7e6"}, - {file = "Pillow-10.0.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:92be919bbc9f7d09f7ae343c38f5bb21c973d2576c1d45600fce4b74bafa7ac0"}, - {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8182b523b2289f7c415f589118228d30ac8c355baa2f3194ced084dac2dbba"}, - {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:38250a349b6b390ee6047a62c086d3817ac69022c127f8a5dc058c31ccef17f3"}, - {file = "Pillow-10.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:88af2003543cc40c80f6fca01411892ec52b11021b3dc22ec3bc9d5afd1c5334"}, - {file = "Pillow-10.0.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c189af0545965fa8d3b9613cfdb0cd37f9d71349e0f7750e1fd704648d475ed2"}, - {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce7b031a6fc11365970e6a5686d7ba8c63e4c1cf1ea143811acbb524295eabed"}, - {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:db24668940f82321e746773a4bc617bfac06ec831e5c88b643f91f122a785684"}, - {file = "Pillow-10.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:efe8c0681042536e0d06c11f48cebe759707c9e9abf880ee213541c5b46c5bf3"}, - {file = "Pillow-10.0.0.tar.gz", hash = "sha256:9c82b5b3e043c7af0d95792d0d20ccf68f61a1fec6b3530e718b688422727396"}, + {file = "Pillow-10.0.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:8f06be50669087250f319b706decf69ca71fdecd829091a37cc89398ca4dc17a"}, + {file = "Pillow-10.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:50bd5f1ebafe9362ad622072a1d2f5850ecfa44303531ff14353a4059113b12d"}, + {file = "Pillow-10.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6a90167bcca1216606223a05e2cf991bb25b14695c518bc65639463d7db722d"}, + {file = "Pillow-10.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f11c9102c56ffb9ca87134bd025a43d2aba3f1155f508eff88f694b33a9c6d19"}, + {file = "Pillow-10.0.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:186f7e04248103482ea6354af6d5bcedb62941ee08f7f788a1c7707bc720c66f"}, + {file = "Pillow-10.0.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0462b1496505a3462d0f35dc1c4d7b54069747d65d00ef48e736acda2c8cbdff"}, + {file = "Pillow-10.0.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d889b53ae2f030f756e61a7bff13684dcd77e9af8b10c6048fb2c559d6ed6eaf"}, + {file = "Pillow-10.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:552912dbca585b74d75279a7570dd29fa43b6d93594abb494ebb31ac19ace6bd"}, + {file = "Pillow-10.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:787bb0169d2385a798888e1122c980c6eff26bf941a8ea79747d35d8f9210ca0"}, + {file = "Pillow-10.0.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:fd2a5403a75b54661182b75ec6132437a181209b901446ee5724b589af8edef1"}, + {file = "Pillow-10.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2d7e91b4379f7a76b31c2dda84ab9e20c6220488e50f7822e59dac36b0cd92b1"}, + {file = "Pillow-10.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19e9adb3f22d4c416e7cd79b01375b17159d6990003633ff1d8377e21b7f1b21"}, + {file = "Pillow-10.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93139acd8109edcdeffd85e3af8ae7d88b258b3a1e13a038f542b79b6d255c54"}, + {file = "Pillow-10.0.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:92a23b0431941a33242b1f0ce6c88a952e09feeea9af4e8be48236a68ffe2205"}, + {file = "Pillow-10.0.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cbe68deb8580462ca0d9eb56a81912f59eb4542e1ef8f987405e35a0179f4ea2"}, + {file = "Pillow-10.0.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:522ff4ac3aaf839242c6f4e5b406634bfea002469656ae8358644fc6c4856a3b"}, + {file = "Pillow-10.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:84efb46e8d881bb06b35d1d541aa87f574b58e87f781cbba8d200daa835b42e1"}, + {file = "Pillow-10.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:898f1d306298ff40dc1b9ca24824f0488f6f039bc0e25cfb549d3195ffa17088"}, + {file = "Pillow-10.0.1-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:bcf1207e2f2385a576832af02702de104be71301c2696d0012b1b93fe34aaa5b"}, + {file = "Pillow-10.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5d6c9049c6274c1bb565021367431ad04481ebb54872edecfcd6088d27edd6ed"}, + {file = "Pillow-10.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28444cb6ad49726127d6b340217f0627abc8732f1194fd5352dec5e6a0105635"}, + {file = "Pillow-10.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de596695a75496deb3b499c8c4f8e60376e0516e1a774e7bc046f0f48cd620ad"}, + {file = "Pillow-10.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:2872f2d7846cf39b3dbff64bc1104cc48c76145854256451d33c5faa55c04d1a"}, + {file = "Pillow-10.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4ce90f8a24e1c15465048959f1e94309dfef93af272633e8f37361b824532e91"}, + {file = "Pillow-10.0.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ee7810cf7c83fa227ba9125de6084e5e8b08c59038a7b2c9045ef4dde61663b4"}, + {file = "Pillow-10.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b1be1c872b9b5fcc229adeadbeb51422a9633abd847c0ff87dc4ef9bb184ae08"}, + {file = "Pillow-10.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:98533fd7fa764e5f85eebe56c8e4094db912ccbe6fbf3a58778d543cadd0db08"}, + {file = "Pillow-10.0.1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:764d2c0daf9c4d40ad12fbc0abd5da3af7f8aa11daf87e4fa1b834000f4b6b0a"}, + {file = "Pillow-10.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:fcb59711009b0168d6ee0bd8fb5eb259c4ab1717b2f538bbf36bacf207ef7a68"}, + {file = "Pillow-10.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:697a06bdcedd473b35e50a7e7506b1d8ceb832dc238a336bd6f4f5aa91a4b500"}, + {file = "Pillow-10.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f665d1e6474af9f9da5e86c2a3a2d2d6204e04d5af9c06b9d42afa6ebde3f21"}, + {file = "Pillow-10.0.1-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:2fa6dd2661838c66f1a5473f3b49ab610c98a128fc08afbe81b91a1f0bf8c51d"}, + {file = "Pillow-10.0.1-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:3a04359f308ebee571a3127fdb1bd01f88ba6f6fb6d087f8dd2e0d9bff43f2a7"}, + {file = "Pillow-10.0.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:723bd25051454cea9990203405fa6b74e043ea76d4968166dfd2569b0210886a"}, + {file = "Pillow-10.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:71671503e3015da1b50bd18951e2f9daf5b6ffe36d16f1eb2c45711a301521a7"}, + {file = "Pillow-10.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:44e7e4587392953e5e251190a964675f61e4dae88d1e6edbe9f36d6243547ff3"}, + {file = "Pillow-10.0.1-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:3855447d98cced8670aaa63683808df905e956f00348732448b5a6df67ee5849"}, + {file = "Pillow-10.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ed2d9c0704f2dc4fa980b99d565c0c9a543fe5101c25b3d60488b8ba80f0cce1"}, + {file = "Pillow-10.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5bb289bb835f9fe1a1e9300d011eef4d69661bb9b34d5e196e5e82c4cb09b37"}, + {file = "Pillow-10.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a0d3e54ab1df9df51b914b2233cf779a5a10dfd1ce339d0421748232cea9876"}, + {file = "Pillow-10.0.1-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:2cc6b86ece42a11f16f55fe8903595eff2b25e0358dec635d0a701ac9586588f"}, + {file = "Pillow-10.0.1-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:ca26ba5767888c84bf5a0c1a32f069e8204ce8c21d00a49c90dabeba00ce0145"}, + {file = "Pillow-10.0.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f0b4b06da13275bc02adfeb82643c4a6385bd08d26f03068c2796f60d125f6f2"}, + {file = "Pillow-10.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bc2e3069569ea9dbe88d6b8ea38f439a6aad8f6e7a6283a38edf61ddefb3a9bf"}, + {file = "Pillow-10.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:8b451d6ead6e3500b6ce5c7916a43d8d8d25ad74b9102a629baccc0808c54971"}, + {file = "Pillow-10.0.1-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:32bec7423cdf25c9038fef614a853c9d25c07590e1a870ed471f47fb80b244db"}, + {file = "Pillow-10.0.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7cf63d2c6928b51d35dfdbda6f2c1fddbe51a6bc4a9d4ee6ea0e11670dd981e"}, + {file = "Pillow-10.0.1-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f6d3d4c905e26354e8f9d82548475c46d8e0889538cb0657aa9c6f0872a37aa4"}, + {file = "Pillow-10.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:847e8d1017c741c735d3cd1883fa7b03ded4f825a6e5fcb9378fd813edee995f"}, + {file = "Pillow-10.0.1-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:7f771e7219ff04b79e231d099c0a28ed83aa82af91fd5fa9fdb28f5b8d5addaf"}, + {file = "Pillow-10.0.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:459307cacdd4138edee3875bbe22a2492519e060660eaf378ba3b405d1c66317"}, + {file = "Pillow-10.0.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b059ac2c4c7a97daafa7dc850b43b2d3667def858a4f112d1aa082e5c3d6cf7d"}, + {file = "Pillow-10.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:d6caf3cd38449ec3cd8a68b375e0c6fe4b6fd04edb6c9766b55ef84a6e8ddf2d"}, + {file = "Pillow-10.0.1.tar.gz", hash = "sha256:d72967b06be9300fed5cfbc8b5bafceec48bf7cdc7dab66b1d2549035287191d"}, ] [package.extras] @@ -2712,13 +2776,13 @@ test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-co [[package]] name = "plotly" -version = "5.15.0" +version = "5.17.0" description = "An open-source, interactive data visualization library for Python" optional = false python-versions = ">=3.6" files = [ - {file = "plotly-5.15.0-py2.py3-none-any.whl", hash = "sha256:3508876bbd6aefb8a692c21a7128ca87ce42498dd041efa5c933ee44b55aab24"}, - {file = "plotly-5.15.0.tar.gz", hash = "sha256:822eabe53997d5ebf23c77e1d1fcbf3bb6aa745eb05d532afd4b6f9a2e2ab02f"}, + {file = "plotly-5.17.0-py2.py3-none-any.whl", hash = "sha256:7c84cdf11da162423da957bb093287134f2d6f170eb9a74f1459f825892247c3"}, + {file = "plotly-5.17.0.tar.gz", hash = "sha256:290d796bf7bab87aad184fe24b86096234c4c95dcca6ecbca02d02bdf17d3d97"}, ] [package.dependencies] @@ -2727,13 +2791,13 @@ tenacity = ">=6.2.0" [[package]] name = "pluggy" -version = "1.2.0" +version = "1.3.0" description = "plugin and hook calling mechanisms for python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849"}, - {file = "pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3"}, + {file = "pluggy-1.3.0-py3-none-any.whl", hash = "sha256:d89c696a773f8bd377d18e5ecda92b7a3793cbe66c87060a6fb58c7b6e1061f7"}, + {file = "pluggy-1.3.0.tar.gz", hash = "sha256:cf61ae8f126ac6f7c451172cf30e3e43d3ca77615509771b3a984a0730651e12"}, ] [package.extras] @@ -2770,24 +2834,24 @@ wcwidth = "*" [[package]] name = "protobuf" -version = "4.23.4" +version = "4.24.3" description = "" optional = false python-versions = ">=3.7" files = [ - {file = "protobuf-4.23.4-cp310-abi3-win32.whl", hash = "sha256:5fea3c64d41ea5ecf5697b83e41d09b9589e6f20b677ab3c48e5f242d9b7897b"}, - {file = "protobuf-4.23.4-cp310-abi3-win_amd64.whl", hash = "sha256:7b19b6266d92ca6a2a87effa88ecc4af73ebc5cfde194dc737cf8ef23a9a3b12"}, - {file = "protobuf-4.23.4-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:8547bf44fe8cec3c69e3042f5c4fb3e36eb2a7a013bb0a44c018fc1e427aafbd"}, - {file = "protobuf-4.23.4-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:fee88269a090ada09ca63551bf2f573eb2424035bcf2cb1b121895b01a46594a"}, - {file = "protobuf-4.23.4-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:effeac51ab79332d44fba74660d40ae79985901ac21bca408f8dc335a81aa597"}, - {file = "protobuf-4.23.4-cp37-cp37m-win32.whl", hash = "sha256:c3e0939433c40796ca4cfc0fac08af50b00eb66a40bbbc5dee711998fb0bbc1e"}, - {file = "protobuf-4.23.4-cp37-cp37m-win_amd64.whl", hash = "sha256:9053df6df8e5a76c84339ee4a9f5a2661ceee4a0dab019e8663c50ba324208b0"}, - {file = "protobuf-4.23.4-cp38-cp38-win32.whl", hash = "sha256:e1c915778d8ced71e26fcf43c0866d7499891bca14c4368448a82edc61fdbc70"}, - {file = "protobuf-4.23.4-cp38-cp38-win_amd64.whl", hash = "sha256:351cc90f7d10839c480aeb9b870a211e322bf05f6ab3f55fcb2f51331f80a7d2"}, - {file = "protobuf-4.23.4-cp39-cp39-win32.whl", hash = "sha256:6dd9b9940e3f17077e820b75851126615ee38643c2c5332aa7a359988820c720"}, - {file = "protobuf-4.23.4-cp39-cp39-win_amd64.whl", hash = "sha256:0a5759f5696895de8cc913f084e27fd4125e8fb0914bb729a17816a33819f474"}, - {file = "protobuf-4.23.4-py3-none-any.whl", hash = "sha256:e9d0be5bf34b275b9f87ba7407796556abeeba635455d036c7351f7c183ef8ff"}, - {file = "protobuf-4.23.4.tar.gz", hash = "sha256:ccd9430c0719dce806b93f89c91de7977304729e55377f872a92465d548329a9"}, + {file = "protobuf-4.24.3-cp310-abi3-win32.whl", hash = "sha256:20651f11b6adc70c0f29efbe8f4a94a74caf61b6200472a9aea6e19898f9fcf4"}, + {file = "protobuf-4.24.3-cp310-abi3-win_amd64.whl", hash = "sha256:3d42e9e4796a811478c783ef63dc85b5a104b44aaaca85d4864d5b886e4b05e3"}, + {file = "protobuf-4.24.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:6e514e8af0045be2b56e56ae1bb14f43ce7ffa0f68b1c793670ccbe2c4fc7d2b"}, + {file = "protobuf-4.24.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:ba53c2f04798a326774f0e53b9c759eaef4f6a568ea7072ec6629851c8435959"}, + {file = "protobuf-4.24.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:f6ccbcf027761a2978c1406070c3788f6de4a4b2cc20800cc03d52df716ad675"}, + {file = "protobuf-4.24.3-cp37-cp37m-win32.whl", hash = "sha256:1b182c7181a2891e8f7f3a1b5242e4ec54d1f42582485a896e4de81aa17540c2"}, + {file = "protobuf-4.24.3-cp37-cp37m-win_amd64.whl", hash = "sha256:b0271a701e6782880d65a308ba42bc43874dabd1a0a0f41f72d2dac3b57f8e76"}, + {file = "protobuf-4.24.3-cp38-cp38-win32.whl", hash = "sha256:e29d79c913f17a60cf17c626f1041e5288e9885c8579832580209de8b75f2a52"}, + {file = "protobuf-4.24.3-cp38-cp38-win_amd64.whl", hash = "sha256:067f750169bc644da2e1ef18c785e85071b7c296f14ac53e0900e605da588719"}, + {file = "protobuf-4.24.3-cp39-cp39-win32.whl", hash = "sha256:2da777d34b4f4f7613cdf85c70eb9a90b1fbef9d36ae4a0ccfe014b0b07906f1"}, + {file = "protobuf-4.24.3-cp39-cp39-win_amd64.whl", hash = "sha256:f631bb982c5478e0c1c70eab383af74a84be66945ebf5dd6b06fc90079668d0b"}, + {file = "protobuf-4.24.3-py3-none-any.whl", hash = "sha256:f6f8dc65625dadaad0c8545319c2e2f0424fede988368893ca3844261342c11a"}, + {file = "protobuf-4.24.3.tar.gz", hash = "sha256:12e9ad2ec079b833176d2921be2cb24281fa591f0b119b208b788adc48c2561d"}, ] [[package]] @@ -2843,36 +2907,40 @@ tests = ["pytest"] [[package]] name = "pyarrow" -version = "12.0.1" +version = "13.0.0" description = "Python library for Apache Arrow" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "pyarrow-12.0.1-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:6d288029a94a9bb5407ceebdd7110ba398a00412c5b0155ee9813a40d246c5df"}, - {file = "pyarrow-12.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:345e1828efdbd9aa4d4de7d5676778aba384a2c3add896d995b23d368e60e5af"}, - {file = "pyarrow-12.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d6009fdf8986332b2169314da482baed47ac053311c8934ac6651e614deacd6"}, - {file = "pyarrow-12.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d3c4cbbf81e6dd23fe921bc91dc4619ea3b79bc58ef10bce0f49bdafb103daf"}, - {file = "pyarrow-12.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:cdacf515ec276709ac8042c7d9bd5be83b4f5f39c6c037a17a60d7ebfd92c890"}, - {file = "pyarrow-12.0.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:749be7fd2ff260683f9cc739cb862fb11be376de965a2a8ccbf2693b098db6c7"}, - {file = "pyarrow-12.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6895b5fb74289d055c43db3af0de6e16b07586c45763cb5e558d38b86a91e3a7"}, - {file = "pyarrow-12.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1887bdae17ec3b4c046fcf19951e71b6a619f39fa674f9881216173566c8f718"}, - {file = "pyarrow-12.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2c9cb8eeabbadf5fcfc3d1ddea616c7ce893db2ce4dcef0ac13b099ad7ca082"}, - {file = "pyarrow-12.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:ce4aebdf412bd0eeb800d8e47db854f9f9f7e2f5a0220440acf219ddfddd4f63"}, - {file = "pyarrow-12.0.1-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:e0d8730c7f6e893f6db5d5b86eda42c0a130842d101992b581e2138e4d5663d3"}, - {file = "pyarrow-12.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43364daec02f69fec89d2315f7fbfbeec956e0d991cbbef471681bd77875c40f"}, - {file = "pyarrow-12.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:051f9f5ccf585f12d7de836e50965b3c235542cc896959320d9776ab93f3b33d"}, - {file = "pyarrow-12.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:be2757e9275875d2a9c6e6052ac7957fbbfc7bc7370e4a036a9b893e96fedaba"}, - {file = "pyarrow-12.0.1-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:cf812306d66f40f69e684300f7af5111c11f6e0d89d6b733e05a3de44961529d"}, - {file = "pyarrow-12.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:459a1c0ed2d68671188b2118c63bac91eaef6fc150c77ddd8a583e3c795737bf"}, - {file = "pyarrow-12.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85e705e33eaf666bbe508a16fd5ba27ca061e177916b7a317ba5a51bee43384c"}, - {file = "pyarrow-12.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9120c3eb2b1f6f516a3b7a9714ed860882d9ef98c4b17edcdc91d95b7528db60"}, - {file = "pyarrow-12.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:c780f4dc40460015d80fcd6a6140de80b615349ed68ef9adb653fe351778c9b3"}, - {file = "pyarrow-12.0.1-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:a3c63124fc26bf5f95f508f5d04e1ece8cc23a8b0af2a1e6ab2b1ec3fdc91b24"}, - {file = "pyarrow-12.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b13329f79fa4472324f8d32dc1b1216616d09bd1e77cfb13104dec5463632c36"}, - {file = "pyarrow-12.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb656150d3d12ec1396f6dde542db1675a95c0cc8366d507347b0beed96e87ca"}, - {file = "pyarrow-12.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6251e38470da97a5b2e00de5c6a049149f7b2bd62f12fa5dbb9ac674119ba71a"}, - {file = "pyarrow-12.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:3de26da901216149ce086920547dfff5cd22818c9eab67ebc41e863a5883bac7"}, - {file = "pyarrow-12.0.1.tar.gz", hash = "sha256:cce317fc96e5b71107bf1f9f184d5e54e2bd14bbf3f9a3d62819961f0af86fec"}, + {file = "pyarrow-13.0.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:1afcc2c33f31f6fb25c92d50a86b7a9f076d38acbcb6f9e74349636109550148"}, + {file = "pyarrow-13.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70fa38cdc66b2fc1349a082987f2b499d51d072faaa6b600f71931150de2e0e3"}, + {file = "pyarrow-13.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd57b13a6466822498238877892a9b287b0a58c2e81e4bdb0b596dbb151cbb73"}, + {file = "pyarrow-13.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8ce69f7bf01de2e2764e14df45b8404fc6f1a5ed9871e8e08a12169f87b7a26"}, + {file = "pyarrow-13.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:588f0d2da6cf1b1680974d63be09a6530fd1bd825dc87f76e162404779a157dc"}, + {file = "pyarrow-13.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:6241afd72b628787b4abea39e238e3ff9f34165273fad306c7acf780dd850956"}, + {file = "pyarrow-13.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:fda7857e35993673fcda603c07d43889fca60a5b254052a462653f8656c64f44"}, + {file = "pyarrow-13.0.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:aac0ae0146a9bfa5e12d87dda89d9ef7c57a96210b899459fc2f785303dcbb67"}, + {file = "pyarrow-13.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d7759994217c86c161c6a8060509cfdf782b952163569606bb373828afdd82e8"}, + {file = "pyarrow-13.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:868a073fd0ff6468ae7d869b5fc1f54de5c4255b37f44fb890385eb68b68f95d"}, + {file = "pyarrow-13.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51be67e29f3cfcde263a113c28e96aa04362ed8229cb7c6e5f5c719003659d33"}, + {file = "pyarrow-13.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:d1b4e7176443d12610874bb84d0060bf080f000ea9ed7c84b2801df851320295"}, + {file = "pyarrow-13.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:69b6f9a089d116a82c3ed819eea8fe67dae6105f0d81eaf0fdd5e60d0c6e0944"}, + {file = "pyarrow-13.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ab1268db81aeb241200e321e220e7cd769762f386f92f61b898352dd27e402ce"}, + {file = "pyarrow-13.0.0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:ee7490f0f3f16a6c38f8c680949551053c8194e68de5046e6c288e396dccee80"}, + {file = "pyarrow-13.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e3ad79455c197a36eefbd90ad4aa832bece7f830a64396c15c61a0985e337287"}, + {file = "pyarrow-13.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68fcd2dc1b7d9310b29a15949cdd0cb9bc34b6de767aff979ebf546020bf0ba0"}, + {file = "pyarrow-13.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc6fd330fd574c51d10638e63c0d00ab456498fc804c9d01f2a61b9264f2c5b2"}, + {file = "pyarrow-13.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:e66442e084979a97bb66939e18f7b8709e4ac5f887e636aba29486ffbf373763"}, + {file = "pyarrow-13.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:0f6eff839a9e40e9c5610d3ff8c5bdd2f10303408312caf4c8003285d0b49565"}, + {file = "pyarrow-13.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b30a27f1cddf5c6efcb67e598d7823a1e253d743d92ac32ec1eb4b6a1417867"}, + {file = "pyarrow-13.0.0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:09552dad5cf3de2dc0aba1c7c4b470754c69bd821f5faafc3d774bedc3b04bb7"}, + {file = "pyarrow-13.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3896ae6c205d73ad192d2fc1489cd0edfab9f12867c85b4c277af4d37383c18c"}, + {file = "pyarrow-13.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6647444b21cb5e68b593b970b2a9a07748dd74ea457c7dadaa15fd469c48ada1"}, + {file = "pyarrow-13.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47663efc9c395e31d09c6aacfa860f4473815ad6804311c5433f7085415d62a7"}, + {file = "pyarrow-13.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:b9ba6b6d34bd2563345488cf444510588ea42ad5613df3b3509f48eb80250afd"}, + {file = "pyarrow-13.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:d00d374a5625beeb448a7fa23060df79adb596074beb3ddc1838adb647b6ef09"}, + {file = "pyarrow-13.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:c51afd87c35c8331b56f796eff954b9c7f8d4b7fef5903daf4e05fcf017d23a8"}, + {file = "pyarrow-13.0.0.tar.gz", hash = "sha256:83333726e83ed44b0ac94d8d7a21bbdee4a05029c3b1e8db58a863eec8fd8a33"}, ] [package.dependencies] @@ -2880,13 +2948,13 @@ numpy = ">=1.16.6" [[package]] name = "pycln" -version = "2.2.1" +version = "2.2.2" description = "A formatter for finding and removing unused import statements." optional = false python-versions = ">=3.6.2,<4" files = [ - {file = "pycln-2.2.1-py3-none-any.whl", hash = "sha256:686f55b511d11d7f114dcbe0c7d1512443441e1dd00a74ee9ba6b6c1b775c9e2"}, - {file = "pycln-2.2.1.tar.gz", hash = "sha256:560ed5dec5e44d3250ed1cd6b080080c4022c24dfd2840902113b42d31775bd0"}, + {file = "pycln-2.2.2-py3-none-any.whl", hash = "sha256:73ed5e997dac02cb6dc84bf87c1d834191d026cfabade94e913973610abd65f7"}, + {file = "pycln-2.2.2.tar.gz", hash = "sha256:a8a1bd0ac0f5d2fb5fcfb409e027667c2a5ac5341bb7fa23d4a7bd1c1cfc3fec"}, ] [package.dependencies] @@ -2923,13 +2991,13 @@ plugins = ["importlib-metadata"] [[package]] name = "pyparsing" -version = "3.0.9" +version = "3.1.1" description = "pyparsing module - Classes and methods to define and execute parsing grammars" optional = false python-versions = ">=3.6.8" files = [ - {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, - {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, + {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"}, + {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"}, ] [package.extras] @@ -2937,13 +3005,13 @@ diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" -version = "7.4.0" +version = "7.4.2" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.7" files = [ - {file = "pytest-7.4.0-py3-none-any.whl", hash = "sha256:78bf16451a2eb8c7a2ea98e32dc119fd2aa758f1d5d66dbf0a59d69a3969df32"}, - {file = "pytest-7.4.0.tar.gz", hash = "sha256:b4bf8c45bd59934ed84001ad51e11b4ee40d40a1229d2c79f9c592b0a3f6bd8a"}, + {file = "pytest-7.4.2-py3-none-any.whl", hash = "sha256:1d881c6124e08ff0a1bb75ba3ec0bfd8b5354a01c194ddd5a0a870a48d99b002"}, + {file = "pytest-7.4.2.tar.gz", hash = "sha256:a766259cfab564a2ad52cb1aae1b881a75c3eb7e34ca3779697c23ed47c47069"}, ] [package.dependencies] @@ -3019,13 +3087,13 @@ files = [ [[package]] name = "pytz" -version = "2023.3" +version = "2023.3.post1" description = "World timezone definitions, modern and historical" optional = false python-versions = "*" files = [ - {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, - {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, + {file = "pytz-2023.3.post1-py2.py3-none-any.whl", hash = "sha256:ce42d816b81b68506614c11e8937d3aa9e41007ceb50bfdcb0749b921bf646c7"}, + {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"}, ] [[package]] @@ -3116,88 +3184,104 @@ files = [ [[package]] name = "pyzmq" -version = "25.1.0" +version = "25.1.1" description = "Python bindings for 0MQ" optional = false python-versions = ">=3.6" files = [ - {file = "pyzmq-25.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:1a6169e69034eaa06823da6a93a7739ff38716142b3596c180363dee729d713d"}, - {file = "pyzmq-25.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:19d0383b1f18411d137d891cab567de9afa609b214de68b86e20173dc624c101"}, - {file = "pyzmq-25.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1e931d9a92f628858a50f5bdffdfcf839aebe388b82f9d2ccd5d22a38a789dc"}, - {file = "pyzmq-25.1.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:97d984b1b2f574bc1bb58296d3c0b64b10e95e7026f8716ed6c0b86d4679843f"}, - {file = "pyzmq-25.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:154bddda2a351161474b36dba03bf1463377ec226a13458725183e508840df89"}, - {file = "pyzmq-25.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:cb6d161ae94fb35bb518b74bb06b7293299c15ba3bc099dccd6a5b7ae589aee3"}, - {file = "pyzmq-25.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:90146ab578931e0e2826ee39d0c948d0ea72734378f1898939d18bc9c823fcf9"}, - {file = "pyzmq-25.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:831ba20b660b39e39e5ac8603e8193f8fce1ee03a42c84ade89c36a251449d80"}, - {file = "pyzmq-25.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3a522510e3434e12aff80187144c6df556bb06fe6b9d01b2ecfbd2b5bfa5c60c"}, - {file = "pyzmq-25.1.0-cp310-cp310-win32.whl", hash = "sha256:be24a5867b8e3b9dd5c241de359a9a5217698ff616ac2daa47713ba2ebe30ad1"}, - {file = "pyzmq-25.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:5693dcc4f163481cf79e98cf2d7995c60e43809e325b77a7748d8024b1b7bcba"}, - {file = "pyzmq-25.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:13bbe36da3f8aaf2b7ec12696253c0bf6ffe05f4507985a8844a1081db6ec22d"}, - {file = "pyzmq-25.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:69511d604368f3dc58d4be1b0bad99b61ee92b44afe1cd9b7bd8c5e34ea8248a"}, - {file = "pyzmq-25.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a983c8694667fd76d793ada77fd36c8317e76aa66eec75be2653cef2ea72883"}, - {file = "pyzmq-25.1.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:332616f95eb400492103ab9d542b69d5f0ff628b23129a4bc0a2fd48da6e4e0b"}, - {file = "pyzmq-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58416db767787aedbfd57116714aad6c9ce57215ffa1c3758a52403f7c68cff5"}, - {file = "pyzmq-25.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cad9545f5801a125f162d09ec9b724b7ad9b6440151b89645241d0120e119dcc"}, - {file = "pyzmq-25.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d6128d431b8dfa888bf51c22a04d48bcb3d64431caf02b3cb943269f17fd2994"}, - {file = "pyzmq-25.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:2b15247c49d8cbea695b321ae5478d47cffd496a2ec5ef47131a9e79ddd7e46c"}, - {file = "pyzmq-25.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:442d3efc77ca4d35bee3547a8e08e8d4bb88dadb54a8377014938ba98d2e074a"}, - {file = "pyzmq-25.1.0-cp311-cp311-win32.whl", hash = "sha256:65346f507a815a731092421d0d7d60ed551a80d9b75e8b684307d435a5597425"}, - {file = "pyzmq-25.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:8b45d722046fea5a5694cba5d86f21f78f0052b40a4bbbbf60128ac55bfcc7b6"}, - {file = "pyzmq-25.1.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:f45808eda8b1d71308c5416ef3abe958f033fdbb356984fabbfc7887bed76b3f"}, - {file = "pyzmq-25.1.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b697774ea8273e3c0460cf0bba16cd85ca6c46dfe8b303211816d68c492e132"}, - {file = "pyzmq-25.1.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b324fa769577fc2c8f5efcd429cef5acbc17d63fe15ed16d6dcbac2c5eb00849"}, - {file = "pyzmq-25.1.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:5873d6a60b778848ce23b6c0ac26c39e48969823882f607516b91fb323ce80e5"}, - {file = "pyzmq-25.1.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:f0d9e7ba6a815a12c8575ba7887da4b72483e4cfc57179af10c9b937f3f9308f"}, - {file = "pyzmq-25.1.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:414b8beec76521358b49170db7b9967d6974bdfc3297f47f7d23edec37329b00"}, - {file = "pyzmq-25.1.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:01f06f33e12497dca86353c354461f75275a5ad9eaea181ac0dc1662da8074fa"}, - {file = "pyzmq-25.1.0-cp36-cp36m-win32.whl", hash = "sha256:b5a07c4f29bf7cb0164664ef87e4aa25435dcc1f818d29842118b0ac1eb8e2b5"}, - {file = "pyzmq-25.1.0-cp36-cp36m-win_amd64.whl", hash = "sha256:968b0c737797c1809ec602e082cb63e9824ff2329275336bb88bd71591e94a90"}, - {file = "pyzmq-25.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:47b915ba666c51391836d7ed9a745926b22c434efa76c119f77bcffa64d2c50c"}, - {file = "pyzmq-25.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5af31493663cf76dd36b00dafbc839e83bbca8a0662931e11816d75f36155897"}, - {file = "pyzmq-25.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5489738a692bc7ee9a0a7765979c8a572520d616d12d949eaffc6e061b82b4d1"}, - {file = "pyzmq-25.1.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1fc56a0221bdf67cfa94ef2d6ce5513a3d209c3dfd21fed4d4e87eca1822e3a3"}, - {file = "pyzmq-25.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:75217e83faea9edbc29516fc90c817bc40c6b21a5771ecb53e868e45594826b0"}, - {file = "pyzmq-25.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:3830be8826639d801de9053cf86350ed6742c4321ba4236e4b5568528d7bfed7"}, - {file = "pyzmq-25.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3575699d7fd7c9b2108bc1c6128641a9a825a58577775ada26c02eb29e09c517"}, - {file = "pyzmq-25.1.0-cp37-cp37m-win32.whl", hash = "sha256:95bd3a998d8c68b76679f6b18f520904af5204f089beebb7b0301d97704634dd"}, - {file = "pyzmq-25.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:dbc466744a2db4b7ca05589f21ae1a35066afada2f803f92369f5877c100ef62"}, - {file = "pyzmq-25.1.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:3bed53f7218490c68f0e82a29c92335daa9606216e51c64f37b48eb78f1281f4"}, - {file = "pyzmq-25.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:eb52e826d16c09ef87132c6e360e1879c984f19a4f62d8a935345deac43f3c12"}, - {file = "pyzmq-25.1.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ddbef8b53cd16467fdbfa92a712eae46dd066aa19780681a2ce266e88fbc7165"}, - {file = "pyzmq-25.1.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:9301cf1d7fc1ddf668d0abbe3e227fc9ab15bc036a31c247276012abb921b5ff"}, - {file = "pyzmq-25.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e23a8c3b6c06de40bdb9e06288180d630b562db8ac199e8cc535af81f90e64b"}, - {file = "pyzmq-25.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:4a82faae00d1eed4809c2f18b37f15ce39a10a1c58fe48b60ad02875d6e13d80"}, - {file = "pyzmq-25.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:c8398a1b1951aaa330269c35335ae69744be166e67e0ebd9869bdc09426f3871"}, - {file = "pyzmq-25.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d40682ac60b2a613d36d8d3a0cd14fbdf8e7e0618fbb40aa9fa7b796c9081584"}, - {file = "pyzmq-25.1.0-cp38-cp38-win32.whl", hash = "sha256:33d5c8391a34d56224bccf74f458d82fc6e24b3213fc68165c98b708c7a69325"}, - {file = "pyzmq-25.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:c66b7ff2527e18554030319b1376d81560ca0742c6e0b17ff1ee96624a5f1afd"}, - {file = "pyzmq-25.1.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:af56229ea6527a849ac9fb154a059d7e32e77a8cba27e3e62a1e38d8808cb1a5"}, - {file = "pyzmq-25.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bdca18b94c404af6ae5533cd1bc310c4931f7ac97c148bbfd2cd4bdd62b96253"}, - {file = "pyzmq-25.1.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0b6b42f7055bbc562f63f3df3b63e3dd1ebe9727ff0f124c3aa7bcea7b3a00f9"}, - {file = "pyzmq-25.1.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4c2fc7aad520a97d64ffc98190fce6b64152bde57a10c704b337082679e74f67"}, - {file = "pyzmq-25.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be86a26415a8b6af02cd8d782e3a9ae3872140a057f1cadf0133de685185c02b"}, - {file = "pyzmq-25.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:851fb2fe14036cfc1960d806628b80276af5424db09fe5c91c726890c8e6d943"}, - {file = "pyzmq-25.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:2a21fec5c3cea45421a19ccbe6250c82f97af4175bc09de4d6dd78fb0cb4c200"}, - {file = "pyzmq-25.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bad172aba822444b32eae54c2d5ab18cd7dee9814fd5c7ed026603b8cae2d05f"}, - {file = "pyzmq-25.1.0-cp39-cp39-win32.whl", hash = "sha256:4d67609b37204acad3d566bb7391e0ecc25ef8bae22ff72ebe2ad7ffb7847158"}, - {file = "pyzmq-25.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:71c7b5896e40720d30cd77a81e62b433b981005bbff0cb2f739e0f8d059b5d99"}, - {file = "pyzmq-25.1.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4cb27ef9d3bdc0c195b2dc54fcb8720e18b741624686a81942e14c8b67cc61a6"}, - {file = "pyzmq-25.1.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0c4fc2741e0513b5d5a12fe200d6785bbcc621f6f2278893a9ca7bed7f2efb7d"}, - {file = "pyzmq-25.1.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:fc34fdd458ff77a2a00e3c86f899911f6f269d393ca5675842a6e92eea565bae"}, - {file = "pyzmq-25.1.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8751f9c1442624da391bbd92bd4b072def6d7702a9390e4479f45c182392ff78"}, - {file = "pyzmq-25.1.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:6581e886aec3135964a302a0f5eb68f964869b9efd1dbafdebceaaf2934f8a68"}, - {file = "pyzmq-25.1.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5482f08d2c3c42b920e8771ae8932fbaa0a67dff925fc476996ddd8155a170f3"}, - {file = "pyzmq-25.1.0-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7fbcafa3ea16d1de1f213c226005fea21ee16ed56134b75b2dede5a2129e62"}, - {file = "pyzmq-25.1.0-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:adecf6d02b1beab8d7c04bc36f22bb0e4c65a35eb0b4750b91693631d4081c70"}, - {file = "pyzmq-25.1.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6d39e42a0aa888122d1beb8ec0d4ddfb6c6b45aecb5ba4013c27e2f28657765"}, - {file = "pyzmq-25.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:7018289b402ebf2b2c06992813523de61d4ce17bd514c4339d8f27a6f6809492"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9e68ae9864d260b18f311b68d29134d8776d82e7f5d75ce898b40a88df9db30f"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e21cc00e4debe8f54c3ed7b9fcca540f46eee12762a9fa56feb8512fd9057161"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2f666ae327a6899ff560d741681fdcdf4506f990595201ed39b44278c471ad98"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f5efcc29056dfe95e9c9db0dfbb12b62db9c4ad302f812931b6d21dd04a9119"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:48e5e59e77c1a83162ab3c163fc01cd2eebc5b34560341a67421b09be0891287"}, - {file = "pyzmq-25.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:108c96ebbd573d929740d66e4c3d1bdf31d5cde003b8dc7811a3c8c5b0fc173b"}, - {file = "pyzmq-25.1.0.tar.gz", hash = "sha256:80c41023465d36280e801564a69cbfce8ae85ff79b080e1913f6e90481fb8957"}, + {file = "pyzmq-25.1.1-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:381469297409c5adf9a0e884c5eb5186ed33137badcbbb0560b86e910a2f1e76"}, + {file = "pyzmq-25.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:955215ed0604dac5b01907424dfa28b40f2b2292d6493445dd34d0dfa72586a8"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:985bbb1316192b98f32e25e7b9958088431d853ac63aca1d2c236f40afb17c83"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:afea96f64efa98df4da6958bae37f1cbea7932c35878b185e5982821bc883369"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76705c9325d72a81155bb6ab48d4312e0032bf045fb0754889133200f7a0d849"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:77a41c26205d2353a4c94d02be51d6cbdf63c06fbc1295ea57dad7e2d3381b71"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:12720a53e61c3b99d87262294e2b375c915fea93c31fc2336898c26d7aed34cd"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:57459b68e5cd85b0be8184382cefd91959cafe79ae019e6b1ae6e2ba8a12cda7"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:292fe3fc5ad4a75bc8df0dfaee7d0babe8b1f4ceb596437213821f761b4589f9"}, + {file = "pyzmq-25.1.1-cp310-cp310-win32.whl", hash = "sha256:35b5ab8c28978fbbb86ea54958cd89f5176ce747c1fb3d87356cf698048a7790"}, + {file = "pyzmq-25.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:11baebdd5fc5b475d484195e49bae2dc64b94a5208f7c89954e9e354fc609d8f"}, + {file = "pyzmq-25.1.1-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:d20a0ddb3e989e8807d83225a27e5c2eb2260eaa851532086e9e0fa0d5287d83"}, + {file = "pyzmq-25.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e1c1be77bc5fb77d923850f82e55a928f8638f64a61f00ff18a67c7404faf008"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d89528b4943d27029a2818f847c10c2cecc79fa9590f3cb1860459a5be7933eb"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90f26dc6d5f241ba358bef79be9ce06de58d477ca8485e3291675436d3827cf8"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2b92812bd214018e50b6380ea3ac0c8bb01ac07fcc14c5f86a5bb25e74026e9"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:2f957ce63d13c28730f7fd6b72333814221c84ca2421298f66e5143f81c9f91f"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:047a640f5c9c6ade7b1cc6680a0e28c9dd5a0825135acbd3569cc96ea00b2505"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7f7e58effd14b641c5e4dec8c7dab02fb67a13df90329e61c869b9cc607ef752"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c2910967e6ab16bf6fbeb1f771c89a7050947221ae12a5b0b60f3bca2ee19bca"}, + {file = "pyzmq-25.1.1-cp311-cp311-win32.whl", hash = "sha256:76c1c8efb3ca3a1818b837aea423ff8a07bbf7aafe9f2f6582b61a0458b1a329"}, + {file = "pyzmq-25.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:44e58a0554b21fc662f2712814a746635ed668d0fbc98b7cb9d74cb798d202e6"}, + {file = "pyzmq-25.1.1-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:e1ffa1c924e8c72778b9ccd386a7067cddf626884fd8277f503c48bb5f51c762"}, + {file = "pyzmq-25.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1af379b33ef33757224da93e9da62e6471cf4a66d10078cf32bae8127d3d0d4a"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cff084c6933680d1f8b2f3b4ff5bbb88538a4aac00d199ac13f49d0698727ecb"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e2400a94f7dd9cb20cd012951a0cbf8249e3d554c63a9c0cdfd5cbb6c01d2dec"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d81f1ddae3858b8299d1da72dd7d19dd36aab654c19671aa8a7e7fb02f6638a"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:255ca2b219f9e5a3a9ef3081512e1358bd4760ce77828e1028b818ff5610b87b"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a882ac0a351288dd18ecae3326b8a49d10c61a68b01419f3a0b9a306190baf69"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:724c292bb26365659fc434e9567b3f1adbdb5e8d640c936ed901f49e03e5d32e"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ca1ed0bb2d850aa8471387882247c68f1e62a4af0ce9c8a1dbe0d2bf69e41fb"}, + {file = "pyzmq-25.1.1-cp312-cp312-win32.whl", hash = "sha256:b3451108ab861040754fa5208bca4a5496c65875710f76789a9ad27c801a0075"}, + {file = "pyzmq-25.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:eadbefd5e92ef8a345f0525b5cfd01cf4e4cc651a2cffb8f23c0dd184975d787"}, + {file = "pyzmq-25.1.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:db0b2af416ba735c6304c47f75d348f498b92952f5e3e8bff449336d2728795d"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7c133e93b405eb0d36fa430c94185bdd13c36204a8635470cccc200723c13bb"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:273bc3959bcbff3f48606b28229b4721716598d76b5aaea2b4a9d0ab454ec062"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:cbc8df5c6a88ba5ae385d8930da02201165408dde8d8322072e3e5ddd4f68e22"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:18d43df3f2302d836f2a56f17e5663e398416e9dd74b205b179065e61f1a6edf"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:73461eed88a88c866656e08f89299720a38cb4e9d34ae6bf5df6f71102570f2e"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:34c850ce7976d19ebe7b9d4b9bb8c9dfc7aac336c0958e2651b88cbd46682123"}, + {file = "pyzmq-25.1.1-cp36-cp36m-win32.whl", hash = "sha256:d2045d6d9439a0078f2a34b57c7b18c4a6aef0bee37f22e4ec9f32456c852c71"}, + {file = "pyzmq-25.1.1-cp36-cp36m-win_amd64.whl", hash = "sha256:458dea649f2f02a0b244ae6aef8dc29325a2810aa26b07af8374dc2a9faf57e3"}, + {file = "pyzmq-25.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7cff25c5b315e63b07a36f0c2bab32c58eafbe57d0dce61b614ef4c76058c115"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1579413ae492b05de5a6174574f8c44c2b9b122a42015c5292afa4be2507f28"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3d0a409d3b28607cc427aa5c30a6f1e4452cc44e311f843e05edb28ab5e36da0"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:21eb4e609a154a57c520e3d5bfa0d97e49b6872ea057b7c85257b11e78068222"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:034239843541ef7a1aee0c7b2cb7f6aafffb005ede965ae9cbd49d5ff4ff73cf"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f8115e303280ba09f3898194791a153862cbf9eef722ad8f7f741987ee2a97c7"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:1a5d26fe8f32f137e784f768143728438877d69a586ddeaad898558dc971a5ae"}, + {file = "pyzmq-25.1.1-cp37-cp37m-win32.whl", hash = "sha256:f32260e556a983bc5c7ed588d04c942c9a8f9c2e99213fec11a031e316874c7e"}, + {file = "pyzmq-25.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:abf34e43c531bbb510ae7e8f5b2b1f2a8ab93219510e2b287a944432fad135f3"}, + {file = "pyzmq-25.1.1-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:87e34f31ca8f168c56d6fbf99692cc8d3b445abb5bfd08c229ae992d7547a92a"}, + {file = "pyzmq-25.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c9c6c9b2c2f80747a98f34ef491c4d7b1a8d4853937bb1492774992a120f475d"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5619f3f5a4db5dbb572b095ea3cb5cc035335159d9da950830c9c4db2fbb6995"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5a34d2395073ef862b4032343cf0c32a712f3ab49d7ec4f42c9661e0294d106f"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25f0e6b78220aba09815cd1f3a32b9c7cb3e02cb846d1cfc526b6595f6046618"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:3669cf8ee3520c2f13b2e0351c41fea919852b220988d2049249db10046a7afb"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:2d163a18819277e49911f7461567bda923461c50b19d169a062536fffe7cd9d2"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:df27ffddff4190667d40de7beba4a950b5ce78fe28a7dcc41d6f8a700a80a3c0"}, + {file = "pyzmq-25.1.1-cp38-cp38-win32.whl", hash = "sha256:a382372898a07479bd34bda781008e4a954ed8750f17891e794521c3e21c2e1c"}, + {file = "pyzmq-25.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:52533489f28d62eb1258a965f2aba28a82aa747202c8fa5a1c7a43b5db0e85c1"}, + {file = "pyzmq-25.1.1-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:03b3f49b57264909aacd0741892f2aecf2f51fb053e7d8ac6767f6c700832f45"}, + {file = "pyzmq-25.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:330f9e188d0d89080cde66dc7470f57d1926ff2fb5576227f14d5be7ab30b9fa"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:2ca57a5be0389f2a65e6d3bb2962a971688cbdd30b4c0bd188c99e39c234f414"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d457aed310f2670f59cc5b57dcfced452aeeed77f9da2b9763616bd57e4dbaae"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c56d748ea50215abef7030c72b60dd723ed5b5c7e65e7bc2504e77843631c1a6"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8f03d3f0d01cb5a018debeb412441996a517b11c5c17ab2001aa0597c6d6882c"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:820c4a08195a681252f46926de10e29b6bbf3e17b30037bd4250d72dd3ddaab8"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:17ef5f01d25b67ca8f98120d5fa1d21efe9611604e8eb03a5147360f517dd1e2"}, + {file = "pyzmq-25.1.1-cp39-cp39-win32.whl", hash = "sha256:04ccbed567171579ec2cebb9c8a3e30801723c575601f9a990ab25bcac6b51e2"}, + {file = "pyzmq-25.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:e61f091c3ba0c3578411ef505992d356a812fb200643eab27f4f70eed34a29ef"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ade6d25bb29c4555d718ac6d1443a7386595528c33d6b133b258f65f963bb0f6"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0c95ddd4f6e9fca4e9e3afaa4f9df8552f0ba5d1004e89ef0a68e1f1f9807c7"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:48e466162a24daf86f6b5ca72444d2bf39a5e58da5f96370078be67c67adc978"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abc719161780932c4e11aaebb203be3d6acc6b38d2f26c0f523b5b59d2fc1996"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ccf825981640b8c34ae54231b7ed00271822ea1c6d8ba1090ebd4943759abf5"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:c2f20ce161ebdb0091a10c9ca0372e023ce24980d0e1f810f519da6f79c60800"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:deee9ca4727f53464daf089536e68b13e6104e84a37820a88b0a057b97bba2d2"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:aa8d6cdc8b8aa19ceb319aaa2b660cdaccc533ec477eeb1309e2a291eaacc43a"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:019e59ef5c5256a2c7378f2fb8560fc2a9ff1d315755204295b2eab96b254d0a"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:b9af3757495c1ee3b5c4e945c1df7be95562277c6e5bccc20a39aec50f826cd0"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:548d6482dc8aadbe7e79d1b5806585c8120bafa1ef841167bc9090522b610fa6"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:057e824b2aae50accc0f9a0570998adc021b372478a921506fddd6c02e60308e"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2243700cc5548cff20963f0ca92d3e5e436394375ab8a354bbea2b12911b20b0"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79986f3b4af059777111409ee517da24a529bdbd46da578b33f25580adcff728"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:11d58723d44d6ed4dd677c5615b2ffb19d5c426636345567d6af82be4dff8a55"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:49d238cf4b69652257db66d0c623cd3e09b5d2e9576b56bc067a396133a00d4a"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fedbdc753827cf014c01dbbee9c3be17e5a208dcd1bf8641ce2cd29580d1f0d4"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bc16ac425cc927d0a57d242589f87ee093884ea4804c05a13834d07c20db203c"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11c1d2aed9079c6b0c9550a7257a836b4a637feb334904610f06d70eb44c56d2"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e8a701123029cc240cea61dd2d16ad57cab4691804143ce80ecd9286b464d180"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:61706a6b6c24bdece85ff177fec393545a3191eeda35b07aaa1458a027ad1304"}, + {file = "pyzmq-25.1.1.tar.gz", hash = "sha256:259c22485b71abacdfa8bf79720cd7bcf4b9d128b30ea554f01ae71fdbfdaa23"}, ] [package.dependencies] @@ -3205,13 +3289,13 @@ cffi = {version = "*", markers = "implementation_name == \"pypy\""} [[package]] name = "qtconsole" -version = "5.4.3" +version = "5.4.4" description = "Jupyter Qt console" optional = false python-versions = ">= 3.7" files = [ - {file = "qtconsole-5.4.3-py3-none-any.whl", hash = "sha256:35fd6e87b1f6d1fd41801b07e69339f8982e76afd4fa8ef35595bc6036717189"}, - {file = "qtconsole-5.4.3.tar.gz", hash = "sha256:5e4082a86a201796b2a5cfd4298352d22b158b51b57736531824715fc2a979dd"}, + {file = "qtconsole-5.4.4-py3-none-any.whl", hash = "sha256:a3b69b868e041c2c698bdc75b0602f42e130ffb256d6efa48f9aa756c97672aa"}, + {file = "qtconsole-5.4.4.tar.gz", hash = "sha256:b7ffb53d74f23cee29f4cdb55dd6fabc8ec312d94f3c46ba38e1dde458693dfb"}, ] [package.dependencies] @@ -3222,7 +3306,7 @@ jupyter-core = "*" packaging = "*" pygments = "*" pyzmq = ">=17.1" -qtpy = ">=2.0.1" +qtpy = ">=2.4.0" traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" [package.extras] @@ -3231,13 +3315,13 @@ test = ["flaky", "pytest", "pytest-qt"] [[package]] name = "qtpy" -version = "2.3.1" +version = "2.4.0" description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." optional = false python-versions = ">=3.7" files = [ - {file = "QtPy-2.3.1-py3-none-any.whl", hash = "sha256:5193d20e0b16e4d9d3bc2c642d04d9f4e2c892590bd1b9c92bfe38a95d5a2e12"}, - {file = "QtPy-2.3.1.tar.gz", hash = "sha256:a8c74982d6d172ce124d80cafd39653df78989683f760f2281ba91a6e7b9de8b"}, + {file = "QtPy-2.4.0-py3-none-any.whl", hash = "sha256:4d4f045a41e09ac9fa57fcb47ef05781aa5af294a0a646acc1b729d14225e741"}, + {file = "QtPy-2.4.0.tar.gz", hash = "sha256:db2d508167aa6106781565c8da5c6f1487debacba33519cedc35fa8997d424d4"}, ] [package.dependencies] @@ -3263,99 +3347,99 @@ rpds-py = ">=0.7.0" [[package]] name = "regex" -version = "2023.6.3" +version = "2023.8.8" description = "Alternative regular expression module, to replace re." optional = false python-versions = ">=3.6" files = [ - {file = "regex-2023.6.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:824bf3ac11001849aec3fa1d69abcb67aac3e150a933963fb12bda5151fe1bfd"}, - {file = "regex-2023.6.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:05ed27acdf4465c95826962528f9e8d41dbf9b1aa8531a387dee6ed215a3e9ef"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b49c764f88a79160fa64f9a7b425620e87c9f46095ef9c9920542ab2495c8bc"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8e3f1316c2293e5469f8f09dc2d76efb6c3982d3da91ba95061a7e69489a14ef"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:43e1dd9d12df9004246bacb79a0e5886b3b6071b32e41f83b0acbf293f820ee8"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4959e8bcbfda5146477d21c3a8ad81b185cd252f3d0d6e4724a5ef11c012fb06"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:af4dd387354dc83a3bff67127a124c21116feb0d2ef536805c454721c5d7993d"}, - {file = "regex-2023.6.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2239d95d8e243658b8dbb36b12bd10c33ad6e6933a54d36ff053713f129aa536"}, - {file = "regex-2023.6.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:890e5a11c97cf0d0c550eb661b937a1e45431ffa79803b942a057c4fb12a2da2"}, - {file = "regex-2023.6.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a8105e9af3b029f243ab11ad47c19b566482c150c754e4c717900a798806b222"}, - {file = "regex-2023.6.3-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:25be746a8ec7bc7b082783216de8e9473803706723b3f6bef34b3d0ed03d57e2"}, - {file = "regex-2023.6.3-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:3676f1dd082be28b1266c93f618ee07741b704ab7b68501a173ce7d8d0d0ca18"}, - {file = "regex-2023.6.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:10cb847aeb1728412c666ab2e2000ba6f174f25b2bdc7292e7dd71b16db07568"}, - {file = "regex-2023.6.3-cp310-cp310-win32.whl", hash = "sha256:dbbbfce33cd98f97f6bffb17801b0576e653f4fdb1d399b2ea89638bc8d08ae1"}, - {file = "regex-2023.6.3-cp310-cp310-win_amd64.whl", hash = "sha256:c5f8037000eb21e4823aa485149f2299eb589f8d1fe4b448036d230c3f4e68e0"}, - {file = "regex-2023.6.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c123f662be8ec5ab4ea72ea300359023a5d1df095b7ead76fedcd8babbedf969"}, - {file = "regex-2023.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9edcbad1f8a407e450fbac88d89e04e0b99a08473f666a3f3de0fd292badb6aa"}, - {file = "regex-2023.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcba6dae7de533c876255317c11f3abe4907ba7d9aa15d13e3d9710d4315ec0e"}, - {file = "regex-2023.6.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29cdd471ebf9e0f2fb3cac165efedc3c58db841d83a518b082077e612d3ee5df"}, - {file = "regex-2023.6.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:12b74fbbf6cbbf9dbce20eb9b5879469e97aeeaa874145517563cca4029db65c"}, - {file = "regex-2023.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c29ca1bd61b16b67be247be87390ef1d1ef702800f91fbd1991f5c4421ebae8"}, - {file = "regex-2023.6.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d77f09bc4b55d4bf7cc5eba785d87001d6757b7c9eec237fe2af57aba1a071d9"}, - {file = "regex-2023.6.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ea353ecb6ab5f7e7d2f4372b1e779796ebd7b37352d290096978fea83c4dba0c"}, - {file = "regex-2023.6.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:10590510780b7541969287512d1b43f19f965c2ece6c9b1c00fc367b29d8dce7"}, - {file = "regex-2023.6.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e2fbd6236aae3b7f9d514312cdb58e6494ee1c76a9948adde6eba33eb1c4264f"}, - {file = "regex-2023.6.3-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:6b2675068c8b56f6bfd5a2bda55b8accbb96c02fd563704732fd1c95e2083461"}, - {file = "regex-2023.6.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:74419d2b50ecb98360cfaa2974da8689cb3b45b9deff0dcf489c0d333bcc1477"}, - {file = "regex-2023.6.3-cp311-cp311-win32.whl", hash = "sha256:fb5ec16523dc573a4b277663a2b5a364e2099902d3944c9419a40ebd56a118f9"}, - {file = "regex-2023.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:09e4a1a6acc39294a36b7338819b10baceb227f7f7dbbea0506d419b5a1dd8af"}, - {file = "regex-2023.6.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:0654bca0cdf28a5956c83839162692725159f4cda8d63e0911a2c0dc76166525"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:463b6a3ceb5ca952e66550a4532cef94c9a0c80dc156c4cc343041951aec1697"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:87b2a5bb5e78ee0ad1de71c664d6eb536dc3947a46a69182a90f4410f5e3f7dd"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6343c6928282c1f6a9db41f5fd551662310e8774c0e5ebccb767002fcf663ca9"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6192d5af2ccd2a38877bfef086d35e6659566a335b1492786ff254c168b1693"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:74390d18c75054947e4194019077e243c06fbb62e541d8817a0fa822ea310c14"}, - {file = "regex-2023.6.3-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:742e19a90d9bb2f4a6cf2862b8b06dea5e09b96c9f2df1779e53432d7275331f"}, - {file = "regex-2023.6.3-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:8abbc5d54ea0ee80e37fef009e3cec5dafd722ed3c829126253d3e22f3846f1e"}, - {file = "regex-2023.6.3-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:c2b867c17a7a7ae44c43ebbeb1b5ff406b3e8d5b3e14662683e5e66e6cc868d3"}, - {file = "regex-2023.6.3-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:d831c2f8ff278179705ca59f7e8524069c1a989e716a1874d6d1aab6119d91d1"}, - {file = "regex-2023.6.3-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:ee2d1a9a253b1729bb2de27d41f696ae893507c7db224436abe83ee25356f5c1"}, - {file = "regex-2023.6.3-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:61474f0b41fe1a80e8dfa70f70ea1e047387b7cd01c85ec88fa44f5d7561d787"}, - {file = "regex-2023.6.3-cp36-cp36m-win32.whl", hash = "sha256:0b71e63226e393b534105fcbdd8740410dc6b0854c2bfa39bbda6b0d40e59a54"}, - {file = "regex-2023.6.3-cp36-cp36m-win_amd64.whl", hash = "sha256:bbb02fd4462f37060122e5acacec78e49c0fbb303c30dd49c7f493cf21fc5b27"}, - {file = "regex-2023.6.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b862c2b9d5ae38a68b92e215b93f98d4c5e9454fa36aae4450f61dd33ff48487"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976d7a304b59ede34ca2921305b57356694f9e6879db323fd90a80f865d355a3"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:83320a09188e0e6c39088355d423aa9d056ad57a0b6c6381b300ec1a04ec3d16"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9427a399501818a7564f8c90eced1e9e20709ece36be701f394ada99890ea4b3"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7178bbc1b2ec40eaca599d13c092079bf529679bf0371c602edaa555e10b41c3"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:837328d14cde912af625d5f303ec29f7e28cdab588674897baafaf505341f2fc"}, - {file = "regex-2023.6.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2d44dc13229905ae96dd2ae2dd7cebf824ee92bc52e8cf03dcead37d926da019"}, - {file = "regex-2023.6.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d54af539295392611e7efbe94e827311eb8b29668e2b3f4cadcfe6f46df9c777"}, - {file = "regex-2023.6.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7117d10690c38a622e54c432dfbbd3cbd92f09401d622902c32f6d377e2300ee"}, - {file = "regex-2023.6.3-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bb60b503ec8a6e4e3e03a681072fa3a5adcbfa5479fa2d898ae2b4a8e24c4591"}, - {file = "regex-2023.6.3-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:65ba8603753cec91c71de423a943ba506363b0e5c3fdb913ef8f9caa14b2c7e0"}, - {file = "regex-2023.6.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:271f0bdba3c70b58e6f500b205d10a36fb4b58bd06ac61381b68de66442efddb"}, - {file = "regex-2023.6.3-cp37-cp37m-win32.whl", hash = "sha256:9beb322958aaca059f34975b0df135181f2e5d7a13b84d3e0e45434749cb20f7"}, - {file = "regex-2023.6.3-cp37-cp37m-win_amd64.whl", hash = "sha256:fea75c3710d4f31389eed3c02f62d0b66a9da282521075061ce875eb5300cf23"}, - {file = "regex-2023.6.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8f56fcb7ff7bf7404becdfc60b1e81a6d0561807051fd2f1860b0d0348156a07"}, - {file = "regex-2023.6.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d2da3abc88711bce7557412310dfa50327d5769a31d1c894b58eb256459dc289"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a99b50300df5add73d307cf66abea093304a07eb017bce94f01e795090dea87c"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5708089ed5b40a7b2dc561e0c8baa9535b77771b64a8330b684823cfd5116036"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:687ea9d78a4b1cf82f8479cab23678aff723108df3edeac098e5b2498879f4a7"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4d3850beab9f527f06ccc94b446c864059c57651b3f911fddb8d9d3ec1d1b25d"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8915cc96abeb8983cea1df3c939e3c6e1ac778340c17732eb63bb96247b91d2"}, - {file = "regex-2023.6.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:841d6e0e5663d4c7b4c8099c9997be748677d46cbf43f9f471150e560791f7ff"}, - {file = "regex-2023.6.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9edce5281f965cf135e19840f4d93d55b3835122aa76ccacfd389e880ba4cf82"}, - {file = "regex-2023.6.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b956231ebdc45f5b7a2e1f90f66a12be9610ce775fe1b1d50414aac1e9206c06"}, - {file = "regex-2023.6.3-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:36efeba71c6539d23c4643be88295ce8c82c88bbd7c65e8a24081d2ca123da3f"}, - {file = "regex-2023.6.3-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:cf67ca618b4fd34aee78740bea954d7c69fdda419eb208c2c0c7060bb822d747"}, - {file = "regex-2023.6.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b4598b1897837067a57b08147a68ac026c1e73b31ef6e36deeeb1fa60b2933c9"}, - {file = "regex-2023.6.3-cp38-cp38-win32.whl", hash = "sha256:f415f802fbcafed5dcc694c13b1292f07fe0befdb94aa8a52905bd115ff41e88"}, - {file = "regex-2023.6.3-cp38-cp38-win_amd64.whl", hash = "sha256:d4f03bb71d482f979bda92e1427f3ec9b220e62a7dd337af0aa6b47bf4498f72"}, - {file = "regex-2023.6.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ccf91346b7bd20c790310c4147eee6ed495a54ddb6737162a36ce9dbef3e4751"}, - {file = "regex-2023.6.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b28f5024a3a041009eb4c333863d7894d191215b39576535c6734cd88b0fcb68"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0bb18053dfcfed432cc3ac632b5e5e5c5b7e55fb3f8090e867bfd9b054dbcbf"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a5bfb3004f2144a084a16ce19ca56b8ac46e6fd0651f54269fc9e230edb5e4a"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c6b48d0fa50d8f4df3daf451be7f9689c2bde1a52b1225c5926e3f54b6a9ed1"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:051da80e6eeb6e239e394ae60704d2b566aa6a7aed6f2890a7967307267a5dc6"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4c3b7fa4cdaa69268748665a1a6ff70c014d39bb69c50fda64b396c9116cf77"}, - {file = "regex-2023.6.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:457b6cce21bee41ac292d6753d5e94dcbc5c9e3e3a834da285b0bde7aa4a11e9"}, - {file = "regex-2023.6.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:aad51907d74fc183033ad796dd4c2e080d1adcc4fd3c0fd4fd499f30c03011cd"}, - {file = "regex-2023.6.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:0385e73da22363778ef2324950e08b689abdf0b108a7d8decb403ad7f5191938"}, - {file = "regex-2023.6.3-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c6a57b742133830eec44d9b2290daf5cbe0a2f1d6acee1b3c7b1c7b2f3606df7"}, - {file = "regex-2023.6.3-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:3e5219bf9e75993d73ab3d25985c857c77e614525fac9ae02b1bebd92f7cecac"}, - {file = "regex-2023.6.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e5087a3c59eef624a4591ef9eaa6e9a8d8a94c779dade95d27c0bc24650261cd"}, - {file = "regex-2023.6.3-cp39-cp39-win32.whl", hash = "sha256:20326216cc2afe69b6e98528160b225d72f85ab080cbdf0b11528cbbaba2248f"}, - {file = "regex-2023.6.3-cp39-cp39-win_amd64.whl", hash = "sha256:bdff5eab10e59cf26bc479f565e25ed71a7d041d1ded04ccf9aee1d9f208487a"}, - {file = "regex-2023.6.3.tar.gz", hash = "sha256:72d1a25bf36d2050ceb35b517afe13864865268dfb45910e2e17a84be6cbfeb0"}, + {file = "regex-2023.8.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:88900f521c645f784260a8d346e12a1590f79e96403971241e64c3a265c8ecdb"}, + {file = "regex-2023.8.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3611576aff55918af2697410ff0293d6071b7e00f4b09e005d614686ac4cd57c"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b8a0ccc8f2698f120e9e5742f4b38dc944c38744d4bdfc427616f3a163dd9de5"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c662a4cbdd6280ee56f841f14620787215a171c4e2d1744c9528bed8f5816c96"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cf0633e4a1b667bfe0bb10b5e53fe0d5f34a6243ea2530eb342491f1adf4f739"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:551ad543fa19e94943c5b2cebc54c73353ffff08228ee5f3376bd27b3d5b9800"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54de2619f5ea58474f2ac211ceea6b615af2d7e4306220d4f3fe690c91988a61"}, + {file = "regex-2023.8.8-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5ec4b3f0aebbbe2fc0134ee30a791af522a92ad9f164858805a77442d7d18570"}, + {file = "regex-2023.8.8-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3ae646c35cb9f820491760ac62c25b6d6b496757fda2d51be429e0e7b67ae0ab"}, + {file = "regex-2023.8.8-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ca339088839582d01654e6f83a637a4b8194d0960477b9769d2ff2cfa0fa36d2"}, + {file = "regex-2023.8.8-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:d9b6627408021452dcd0d2cdf8da0534e19d93d070bfa8b6b4176f99711e7f90"}, + {file = "regex-2023.8.8-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:bd3366aceedf274f765a3a4bc95d6cd97b130d1dda524d8f25225d14123c01db"}, + {file = "regex-2023.8.8-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7aed90a72fc3654fba9bc4b7f851571dcc368120432ad68b226bd593f3f6c0b7"}, + {file = "regex-2023.8.8-cp310-cp310-win32.whl", hash = "sha256:80b80b889cb767cc47f31d2b2f3dec2db8126fbcd0cff31b3925b4dc6609dcdb"}, + {file = "regex-2023.8.8-cp310-cp310-win_amd64.whl", hash = "sha256:b82edc98d107cbc7357da7a5a695901b47d6eb0420e587256ba3ad24b80b7d0b"}, + {file = "regex-2023.8.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1e7d84d64c84ad97bf06f3c8cb5e48941f135ace28f450d86af6b6512f1c9a71"}, + {file = "regex-2023.8.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ce0f9fbe7d295f9922c0424a3637b88c6c472b75eafeaff6f910494a1fa719ef"}, + {file = "regex-2023.8.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06c57e14ac723b04458df5956cfb7e2d9caa6e9d353c0b4c7d5d54fcb1325c46"}, + {file = "regex-2023.8.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7a9aaa5a1267125eef22cef3b63484c3241aaec6f48949b366d26c7250e0357"}, + {file = "regex-2023.8.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b7408511fca48a82a119d78a77c2f5eb1b22fe88b0d2450ed0756d194fe7a9a"}, + {file = "regex-2023.8.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14dc6f2d88192a67d708341f3085df6a4f5a0c7b03dec08d763ca2cd86e9f559"}, + {file = "regex-2023.8.8-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:48c640b99213643d141550326f34f0502fedb1798adb3c9eb79650b1ecb2f177"}, + {file = "regex-2023.8.8-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0085da0f6c6393428bf0d9c08d8b1874d805bb55e17cb1dfa5ddb7cfb11140bf"}, + {file = "regex-2023.8.8-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:964b16dcc10c79a4a2be9f1273fcc2684a9eedb3906439720598029a797b46e6"}, + {file = "regex-2023.8.8-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7ce606c14bb195b0e5108544b540e2c5faed6843367e4ab3deb5c6aa5e681208"}, + {file = "regex-2023.8.8-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:40f029d73b10fac448c73d6eb33d57b34607f40116e9f6e9f0d32e9229b147d7"}, + {file = "regex-2023.8.8-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3b8e6ea6be6d64104d8e9afc34c151926f8182f84e7ac290a93925c0db004bfd"}, + {file = "regex-2023.8.8-cp311-cp311-win32.whl", hash = "sha256:942f8b1f3b223638b02df7df79140646c03938d488fbfb771824f3d05fc083a8"}, + {file = "regex-2023.8.8-cp311-cp311-win_amd64.whl", hash = "sha256:51d8ea2a3a1a8fe4f67de21b8b93757005213e8ac3917567872f2865185fa7fb"}, + {file = "regex-2023.8.8-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:e951d1a8e9963ea51efd7f150450803e3b95db5939f994ad3d5edac2b6f6e2b4"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:704f63b774218207b8ccc6c47fcef5340741e5d839d11d606f70af93ee78e4d4"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:22283c769a7b01c8ac355d5be0715bf6929b6267619505e289f792b01304d898"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:91129ff1bb0619bc1f4ad19485718cc623a2dc433dff95baadbf89405c7f6b57"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de35342190deb7b866ad6ba5cbcccb2d22c0487ee0cbb251efef0843d705f0d4"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b993b6f524d1e274a5062488a43e3f9f8764ee9745ccd8e8193df743dbe5ee61"}, + {file = "regex-2023.8.8-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3026cbcf11d79095a32d9a13bbc572a458727bd5b1ca332df4a79faecd45281c"}, + {file = "regex-2023.8.8-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:293352710172239bf579c90a9864d0df57340b6fd21272345222fb6371bf82b3"}, + {file = "regex-2023.8.8-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:d909b5a3fff619dc7e48b6b1bedc2f30ec43033ba7af32f936c10839e81b9217"}, + {file = "regex-2023.8.8-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:3d370ff652323c5307d9c8e4c62efd1956fb08051b0e9210212bc51168b4ff56"}, + {file = "regex-2023.8.8-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:b076da1ed19dc37788f6a934c60adf97bd02c7eea461b73730513921a85d4235"}, + {file = "regex-2023.8.8-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:e9941a4ada58f6218694f382e43fdd256e97615db9da135e77359da257a7168b"}, + {file = "regex-2023.8.8-cp36-cp36m-win32.whl", hash = "sha256:a8c65c17aed7e15a0c824cdc63a6b104dfc530f6fa8cb6ac51c437af52b481c7"}, + {file = "regex-2023.8.8-cp36-cp36m-win_amd64.whl", hash = "sha256:aadf28046e77a72f30dcc1ab185639e8de7f4104b8cb5c6dfa5d8ed860e57236"}, + {file = "regex-2023.8.8-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:423adfa872b4908843ac3e7a30f957f5d5282944b81ca0a3b8a7ccbbfaa06103"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ae594c66f4a7e1ea67232a0846649a7c94c188d6c071ac0210c3e86a5f92109"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e51c80c168074faa793685656c38eb7a06cbad7774c8cbc3ea05552d615393d8"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:09b7f4c66aa9d1522b06e31a54f15581c37286237208df1345108fcf4e050c18"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e73e5243af12d9cd6a9d6a45a43570dbe2e5b1cdfc862f5ae2b031e44dd95a8"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:941460db8fe3bd613db52f05259c9336f5a47ccae7d7def44cc277184030a116"}, + {file = "regex-2023.8.8-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f0ccf3e01afeb412a1a9993049cb160d0352dba635bbca7762b2dc722aa5742a"}, + {file = "regex-2023.8.8-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:2e9216e0d2cdce7dbc9be48cb3eacb962740a09b011a116fd7af8c832ab116ca"}, + {file = "regex-2023.8.8-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:5cd9cd7170459b9223c5e592ac036e0704bee765706445c353d96f2890e816c8"}, + {file = "regex-2023.8.8-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:4873ef92e03a4309b3ccd8281454801b291b689f6ad45ef8c3658b6fa761d7ac"}, + {file = "regex-2023.8.8-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:239c3c2a339d3b3ddd51c2daef10874410917cd2b998f043c13e2084cb191684"}, + {file = "regex-2023.8.8-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:1005c60ed7037be0d9dea1f9c53cc42f836188227366370867222bda4c3c6bd7"}, + {file = "regex-2023.8.8-cp37-cp37m-win32.whl", hash = "sha256:e6bd1e9b95bc5614a7a9c9c44fde9539cba1c823b43a9f7bc11266446dd568e3"}, + {file = "regex-2023.8.8-cp37-cp37m-win_amd64.whl", hash = "sha256:9a96edd79661e93327cfeac4edec72a4046e14550a1d22aa0dd2e3ca52aec921"}, + {file = "regex-2023.8.8-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f2181c20ef18747d5f4a7ea513e09ea03bdd50884a11ce46066bb90fe4213675"}, + {file = "regex-2023.8.8-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a2ad5add903eb7cdde2b7c64aaca405f3957ab34f16594d2b78d53b8b1a6a7d6"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9233ac249b354c54146e392e8a451e465dd2d967fc773690811d3a8c240ac601"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:920974009fb37b20d32afcdf0227a2e707eb83fe418713f7a8b7de038b870d0b"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2b6c5dfe0929b6c23dde9624483380b170b6e34ed79054ad131b20203a1a63"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96979d753b1dc3b2169003e1854dc67bfc86edf93c01e84757927f810b8c3c93"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2ae54a338191e1356253e7883d9d19f8679b6143703086245fb14d1f20196be9"}, + {file = "regex-2023.8.8-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2162ae2eb8b079622176a81b65d486ba50b888271302190870b8cc488587d280"}, + {file = "regex-2023.8.8-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c884d1a59e69e03b93cf0dfee8794c63d7de0ee8f7ffb76e5f75be8131b6400a"}, + {file = "regex-2023.8.8-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cf9273e96f3ee2ac89ffcb17627a78f78e7516b08f94dc435844ae72576a276e"}, + {file = "regex-2023.8.8-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:83215147121e15d5f3a45d99abeed9cf1fe16869d5c233b08c56cdf75f43a504"}, + {file = "regex-2023.8.8-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:3f7454aa427b8ab9101f3787eb178057c5250478e39b99540cfc2b889c7d0586"}, + {file = "regex-2023.8.8-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f0640913d2c1044d97e30d7c41728195fc37e54d190c5385eacb52115127b882"}, + {file = "regex-2023.8.8-cp38-cp38-win32.whl", hash = "sha256:0c59122ceccb905a941fb23b087b8eafc5290bf983ebcb14d2301febcbe199c7"}, + {file = "regex-2023.8.8-cp38-cp38-win_amd64.whl", hash = "sha256:c12f6f67495ea05c3d542d119d270007090bad5b843f642d418eb601ec0fa7be"}, + {file = "regex-2023.8.8-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:82cd0a69cd28f6cc3789cc6adeb1027f79526b1ab50b1f6062bbc3a0ccb2dbc3"}, + {file = "regex-2023.8.8-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:bb34d1605f96a245fc39790a117ac1bac8de84ab7691637b26ab2c5efb8f228c"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:987b9ac04d0b38ef4f89fbc035e84a7efad9cdd5f1e29024f9289182c8d99e09"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9dd6082f4e2aec9b6a0927202c85bc1b09dcab113f97265127c1dc20e2e32495"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7eb95fe8222932c10d4436e7a6f7c99991e3fdd9f36c949eff16a69246dee2dc"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7098c524ba9f20717a56a8d551d2ed491ea89cbf37e540759ed3b776a4f8d6eb"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b694430b3f00eb02c594ff5a16db30e054c1b9589a043fe9174584c6efa8033"}, + {file = "regex-2023.8.8-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b2aeab3895d778155054abea5238d0eb9a72e9242bd4b43f42fd911ef9a13470"}, + {file = "regex-2023.8.8-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:988631b9d78b546e284478c2ec15c8a85960e262e247b35ca5eaf7ee22f6050a"}, + {file = "regex-2023.8.8-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:67ecd894e56a0c6108ec5ab1d8fa8418ec0cff45844a855966b875d1039a2e34"}, + {file = "regex-2023.8.8-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:14898830f0a0eb67cae2bbbc787c1a7d6e34ecc06fbd39d3af5fe29a4468e2c9"}, + {file = "regex-2023.8.8-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:f2200e00b62568cfd920127782c61bc1c546062a879cdc741cfcc6976668dfcf"}, + {file = "regex-2023.8.8-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9691a549c19c22d26a4f3b948071e93517bdf86e41b81d8c6ac8a964bb71e5a6"}, + {file = "regex-2023.8.8-cp39-cp39-win32.whl", hash = "sha256:6ab2ed84bf0137927846b37e882745a827458689eb969028af8032b1b3dac78e"}, + {file = "regex-2023.8.8-cp39-cp39-win_amd64.whl", hash = "sha256:5543c055d8ec7801901e1193a51570643d6a6ab8751b1f7dd9af71af467538bb"}, + {file = "regex-2023.8.8.tar.gz", hash = "sha256:fcbdc5f2b0f1cd0f6a56cdb46fe41d2cce1e644e3b68832f3eeebc5fb0f7712e"}, ] [[package]] @@ -3406,13 +3490,13 @@ files = [ [[package]] name = "rich" -version = "13.5.2" +version = "13.6.0" description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" optional = false python-versions = ">=3.7.0" files = [ - {file = "rich-13.5.2-py3-none-any.whl", hash = "sha256:146a90b3b6b47cac4a73c12866a499e9817426423f57c5a66949c086191a8808"}, - {file = "rich-13.5.2.tar.gz", hash = "sha256:fb9d6c0a0f643c99eed3875b5377a184132ba9be4d61516a55273d3554d75a39"}, + {file = "rich-13.6.0-py3-none-any.whl", hash = "sha256:2b38e2fe9ca72c9a00170a1a2d20c63c790d0e10ef1fe35eba76e1e7b1d7d245"}, + {file = "rich-13.6.0.tar.gz", hash = "sha256:5c14d22737e6d5084ef4771b62d5d4363165b403455a30a1c8ca39dc7b644bef"}, ] [package.dependencies] @@ -3424,169 +3508,293 @@ jupyter = ["ipywidgets (>=7.5.1,<9)"] [[package]] name = "rpds-py" -version = "0.9.2" +version = "0.10.3" description = "Python bindings to Rust's persistent data structures (rpds)" optional = false python-versions = ">=3.8" files = [ - {file = "rpds_py-0.9.2-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:ab6919a09c055c9b092798ce18c6c4adf49d24d4d9e43a92b257e3f2548231e7"}, - {file = "rpds_py-0.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d55777a80f78dd09410bd84ff8c95ee05519f41113b2df90a69622f5540c4f8b"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a216b26e5af0a8e265d4efd65d3bcec5fba6b26909014effe20cd302fd1138fa"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29cd8bfb2d716366a035913ced99188a79b623a3512292963d84d3e06e63b496"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44659b1f326214950a8204a248ca6199535e73a694be8d3e0e869f820767f12f"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:745f5a43fdd7d6d25a53ab1a99979e7f8ea419dfefebcab0a5a1e9095490ee5e"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a987578ac5214f18b99d1f2a3851cba5b09f4a689818a106c23dbad0dfeb760f"}, - {file = "rpds_py-0.9.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bf4151acb541b6e895354f6ff9ac06995ad9e4175cbc6d30aaed08856558201f"}, - {file = "rpds_py-0.9.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:03421628f0dc10a4119d714a17f646e2837126a25ac7a256bdf7c3943400f67f"}, - {file = "rpds_py-0.9.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:13b602dc3e8dff3063734f02dcf05111e887f301fdda74151a93dbbc249930fe"}, - {file = "rpds_py-0.9.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fae5cb554b604b3f9e2c608241b5d8d303e410d7dfb6d397c335f983495ce7f6"}, - {file = "rpds_py-0.9.2-cp310-none-win32.whl", hash = "sha256:47c5f58a8e0c2c920cc7783113df2fc4ff12bf3a411d985012f145e9242a2764"}, - {file = "rpds_py-0.9.2-cp310-none-win_amd64.whl", hash = "sha256:4ea6b73c22d8182dff91155af018b11aac9ff7eca085750455c5990cb1cfae6e"}, - {file = "rpds_py-0.9.2-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:e564d2238512c5ef5e9d79338ab77f1cbbda6c2d541ad41b2af445fb200385e3"}, - {file = "rpds_py-0.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f411330a6376fb50e5b7a3e66894e4a39e60ca2e17dce258d53768fea06a37bd"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e7521f5af0233e89939ad626b15278c71b69dc1dfccaa7b97bd4cdf96536bb7"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8d3335c03100a073883857e91db9f2e0ef8a1cf42dc0369cbb9151c149dbbc1b"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d25b1c1096ef0447355f7293fbe9ad740f7c47ae032c2884113f8e87660d8f6e"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a5d3fbd02efd9cf6a8ffc2f17b53a33542f6b154e88dd7b42ef4a4c0700fdad"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c5934e2833afeaf36bd1eadb57256239785f5af0220ed8d21c2896ec4d3a765f"}, - {file = "rpds_py-0.9.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:095b460e117685867d45548fbd8598a8d9999227e9061ee7f012d9d264e6048d"}, - {file = "rpds_py-0.9.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:91378d9f4151adc223d584489591dbb79f78814c0734a7c3bfa9c9e09978121c"}, - {file = "rpds_py-0.9.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:24a81c177379300220e907e9b864107614b144f6c2a15ed5c3450e19cf536fae"}, - {file = "rpds_py-0.9.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:de0b6eceb46141984671802d412568d22c6bacc9b230174f9e55fc72ef4f57de"}, - {file = "rpds_py-0.9.2-cp311-none-win32.whl", hash = "sha256:700375326ed641f3d9d32060a91513ad668bcb7e2cffb18415c399acb25de2ab"}, - {file = "rpds_py-0.9.2-cp311-none-win_amd64.whl", hash = "sha256:0766babfcf941db8607bdaf82569ec38107dbb03c7f0b72604a0b346b6eb3298"}, - {file = "rpds_py-0.9.2-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:b1440c291db3f98a914e1afd9d6541e8fc60b4c3aab1a9008d03da4651e67386"}, - {file = "rpds_py-0.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0f2996fbac8e0b77fd67102becb9229986396e051f33dbceada3debaacc7033f"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f30d205755566a25f2ae0382944fcae2f350500ae4df4e795efa9e850821d82"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:159fba751a1e6b1c69244e23ba6c28f879a8758a3e992ed056d86d74a194a0f3"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a1f044792e1adcea82468a72310c66a7f08728d72a244730d14880cd1dabe36b"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9251eb8aa82e6cf88510530b29eef4fac825a2b709baf5b94a6094894f252387"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01899794b654e616c8625b194ddd1e5b51ef5b60ed61baa7a2d9c2ad7b2a4238"}, - {file = "rpds_py-0.9.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b0c43f8ae8f6be1d605b0465671124aa8d6a0e40f1fb81dcea28b7e3d87ca1e1"}, - {file = "rpds_py-0.9.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:207f57c402d1f8712618f737356e4b6f35253b6d20a324d9a47cb9f38ee43a6b"}, - {file = "rpds_py-0.9.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b52e7c5ae35b00566d244ffefba0f46bb6bec749a50412acf42b1c3f402e2c90"}, - {file = "rpds_py-0.9.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:978fa96dbb005d599ec4fd9ed301b1cc45f1a8f7982d4793faf20b404b56677d"}, - {file = "rpds_py-0.9.2-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:6aa8326a4a608e1c28da191edd7c924dff445251b94653988efb059b16577a4d"}, - {file = "rpds_py-0.9.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:aad51239bee6bff6823bbbdc8ad85136c6125542bbc609e035ab98ca1e32a192"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4bd4dc3602370679c2dfb818d9c97b1137d4dd412230cfecd3c66a1bf388a196"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dd9da77c6ec1f258387957b754f0df60766ac23ed698b61941ba9acccd3284d1"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:190ca6f55042ea4649ed19c9093a9be9d63cd8a97880106747d7147f88a49d18"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:876bf9ed62323bc7dcfc261dbc5572c996ef26fe6406b0ff985cbcf460fc8a4c"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa2818759aba55df50592ecbc95ebcdc99917fa7b55cc6796235b04193eb3c55"}, - {file = "rpds_py-0.9.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9ea4d00850ef1e917815e59b078ecb338f6a8efda23369677c54a5825dbebb55"}, - {file = "rpds_py-0.9.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:5855c85eb8b8a968a74dc7fb014c9166a05e7e7a8377fb91d78512900aadd13d"}, - {file = "rpds_py-0.9.2-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:14c408e9d1a80dcb45c05a5149e5961aadb912fff42ca1dd9b68c0044904eb32"}, - {file = "rpds_py-0.9.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:65a0583c43d9f22cb2130c7b110e695fff834fd5e832a776a107197e59a1898e"}, - {file = "rpds_py-0.9.2-cp38-none-win32.whl", hash = "sha256:71f2f7715935a61fa3e4ae91d91b67e571aeb5cb5d10331ab681256bda2ad920"}, - {file = "rpds_py-0.9.2-cp38-none-win_amd64.whl", hash = "sha256:674c704605092e3ebbbd13687b09c9f78c362a4bc710343efe37a91457123044"}, - {file = "rpds_py-0.9.2-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:07e2c54bef6838fa44c48dfbc8234e8e2466d851124b551fc4e07a1cfeb37260"}, - {file = "rpds_py-0.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f7fdf55283ad38c33e35e2855565361f4bf0abd02470b8ab28d499c663bc5d7c"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:890ba852c16ace6ed9f90e8670f2c1c178d96510a21b06d2fa12d8783a905193"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:50025635ba8b629a86d9d5474e650da304cb46bbb4d18690532dd79341467846"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:517cbf6e67ae3623c5127206489d69eb2bdb27239a3c3cc559350ef52a3bbf0b"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0836d71ca19071090d524739420a61580f3f894618d10b666cf3d9a1688355b1"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c439fd54b2b9053717cca3de9583be6584b384d88d045f97d409f0ca867d80f"}, - {file = "rpds_py-0.9.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f68996a3b3dc9335037f82754f9cdbe3a95db42bde571d8c3be26cc6245f2324"}, - {file = "rpds_py-0.9.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7d68dc8acded354c972116f59b5eb2e5864432948e098c19fe6994926d8e15c3"}, - {file = "rpds_py-0.9.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:f963c6b1218b96db85fc37a9f0851eaf8b9040aa46dec112611697a7023da535"}, - {file = "rpds_py-0.9.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5a46859d7f947061b4010e554ccd1791467d1b1759f2dc2ec9055fa239f1bc26"}, - {file = "rpds_py-0.9.2-cp39-none-win32.whl", hash = "sha256:e07e5dbf8a83c66783a9fe2d4566968ea8c161199680e8ad38d53e075df5f0d0"}, - {file = "rpds_py-0.9.2-cp39-none-win_amd64.whl", hash = "sha256:682726178138ea45a0766907957b60f3a1bf3acdf212436be9733f28b6c5af3c"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:196cb208825a8b9c8fc360dc0f87993b8b260038615230242bf18ec84447c08d"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c7671d45530fcb6d5e22fd40c97e1e1e01965fc298cbda523bb640f3d923b387"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83b32f0940adec65099f3b1c215ef7f1d025d13ff947975a055989cb7fd019a4"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f67da97f5b9eac838b6980fc6da268622e91f8960e083a34533ca710bec8611"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:03975db5f103997904c37e804e5f340c8fdabbb5883f26ee50a255d664eed58c"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:987b06d1cdb28f88a42e4fb8a87f094e43f3c435ed8e486533aea0bf2e53d931"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c861a7e4aef15ff91233751619ce3a3d2b9e5877e0fcd76f9ea4f6847183aa16"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:02938432352359805b6da099c9c95c8a0547fe4b274ce8f1a91677401bb9a45f"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:ef1f08f2a924837e112cba2953e15aacfccbbfcd773b4b9b4723f8f2ddded08e"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:35da5cc5cb37c04c4ee03128ad59b8c3941a1e5cd398d78c37f716f32a9b7f67"}, - {file = "rpds_py-0.9.2-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:141acb9d4ccc04e704e5992d35472f78c35af047fa0cfae2923835d153f091be"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:79f594919d2c1a0cc17d1988a6adaf9a2f000d2e1048f71f298b056b1018e872"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:a06418fe1155e72e16dddc68bb3780ae44cebb2912fbd8bb6ff9161de56e1798"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b2eb034c94b0b96d5eddb290b7b5198460e2d5d0c421751713953a9c4e47d10"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b08605d248b974eb02f40bdcd1a35d3924c83a2a5e8f5d0fa5af852c4d960af"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a0805911caedfe2736935250be5008b261f10a729a303f676d3d5fea6900c96a"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab2299e3f92aa5417d5e16bb45bb4586171c1327568f638e8453c9f8d9e0f020"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c8d7594e38cf98d8a7df25b440f684b510cf4627fe038c297a87496d10a174f"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8b9ec12ad5f0a4625db34db7e0005be2632c1013b253a4a60e8302ad4d462afd"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1fcdee18fea97238ed17ab6478c66b2095e4ae7177e35fb71fbe561a27adf620"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:933a7d5cd4b84f959aedeb84f2030f0a01d63ae6cf256629af3081cf3e3426e8"}, - {file = "rpds_py-0.9.2-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:686ba516e02db6d6f8c279d1641f7067ebb5dc58b1d0536c4aaebb7bf01cdc5d"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:0173c0444bec0a3d7d848eaeca2d8bd32a1b43f3d3fde6617aac3731fa4be05f"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:d576c3ef8c7b2d560e301eb33891d1944d965a4d7a2eacb6332eee8a71827db6"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed89861ee8c8c47d6beb742a602f912b1bb64f598b1e2f3d758948721d44d468"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1054a08e818f8e18910f1bee731583fe8f899b0a0a5044c6e680ceea34f93876"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:99e7c4bb27ff1aab90dcc3e9d37ee5af0231ed98d99cb6f5250de28889a3d502"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c545d9d14d47be716495076b659db179206e3fd997769bc01e2d550eeb685596"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9039a11bca3c41be5a58282ed81ae422fa680409022b996032a43badef2a3752"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fb39aca7a64ad0c9490adfa719dbeeb87d13be137ca189d2564e596f8ba32c07"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2d8b3b3a2ce0eaa00c5bbbb60b6713e94e7e0becab7b3db6c5c77f979e8ed1f1"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:99b1c16f732b3a9971406fbfe18468592c5a3529585a45a35adbc1389a529a03"}, - {file = "rpds_py-0.9.2-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:c27ee01a6c3223025f4badd533bea5e87c988cb0ba2811b690395dfe16088cfe"}, - {file = "rpds_py-0.9.2.tar.gz", hash = "sha256:8d70e8f14900f2657c249ea4def963bed86a29b81f81f5b76b5a9215680de945"}, + {file = "rpds_py-0.10.3-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:485747ee62da83366a44fbba963c5fe017860ad408ccd6cd99aa66ea80d32b2e"}, + {file = "rpds_py-0.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c55f9821f88e8bee4b7a72c82cfb5ecd22b6aad04033334f33c329b29bfa4da0"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3b52a67ac66a3a64a7e710ba629f62d1e26ca0504c29ee8cbd99b97df7079a8"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3aed39db2f0ace76faa94f465d4234aac72e2f32b009f15da6492a561b3bbebd"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:271c360fdc464fe6a75f13ea0c08ddf71a321f4c55fc20a3fe62ea3ef09df7d9"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ef5fddfb264e89c435be4adb3953cef5d2936fdeb4463b4161a6ba2f22e7b740"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a771417c9c06c56c9d53d11a5b084d1de75de82978e23c544270ab25e7c066ff"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:52b5cbc0469328e58180021138207e6ec91d7ca2e037d3549cc9e34e2187330a"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6ac3fefb0d168c7c6cab24fdfc80ec62cd2b4dfd9e65b84bdceb1cb01d385c33"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:8d54bbdf5d56e2c8cf81a1857250f3ea132de77af543d0ba5dce667183b61fec"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cd2163f42868865597d89399a01aa33b7594ce8e2c4a28503127c81a2f17784e"}, + {file = "rpds_py-0.10.3-cp310-none-win32.whl", hash = "sha256:ea93163472db26ac6043e8f7f93a05d9b59e0505c760da2a3cd22c7dd7111391"}, + {file = "rpds_py-0.10.3-cp310-none-win_amd64.whl", hash = "sha256:7cd020b1fb41e3ab7716d4d2c3972d4588fdfbab9bfbbb64acc7078eccef8860"}, + {file = "rpds_py-0.10.3-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:1d9b5ee46dcb498fa3e46d4dfabcb531e1f2e76b477e0d99ef114f17bbd38453"}, + {file = "rpds_py-0.10.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:563646d74a4b4456d0cf3b714ca522e725243c603e8254ad85c3b59b7c0c4bf0"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e626b864725680cd3904414d72e7b0bd81c0e5b2b53a5b30b4273034253bb41f"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:485301ee56ce87a51ccb182a4b180d852c5cb2b3cb3a82f7d4714b4141119d8c"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42f712b4668831c0cd85e0a5b5a308700fe068e37dcd24c0062904c4e372b093"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6c9141af27a4e5819d74d67d227d5047a20fa3c7d4d9df43037a955b4c748ec5"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef750a20de1b65657a1425f77c525b0183eac63fe7b8f5ac0dd16f3668d3e64f"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e1a0ffc39f51aa5f5c22114a8f1906b3c17eba68c5babb86c5f77d8b1bba14d1"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f4c179a7aeae10ddf44c6bac87938134c1379c49c884529f090f9bf05566c836"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:176287bb998fd1e9846a9b666e240e58f8d3373e3bf87e7642f15af5405187b8"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6446002739ca29249f0beaaf067fcbc2b5aab4bc7ee8fb941bd194947ce19aff"}, + {file = "rpds_py-0.10.3-cp311-none-win32.whl", hash = "sha256:c7aed97f2e676561416c927b063802c8a6285e9b55e1b83213dfd99a8f4f9e48"}, + {file = "rpds_py-0.10.3-cp311-none-win_amd64.whl", hash = "sha256:8bd01ff4032abaed03f2db702fa9a61078bee37add0bd884a6190b05e63b028c"}, + {file = "rpds_py-0.10.3-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:4cf0855a842c5b5c391dd32ca273b09e86abf8367572073bd1edfc52bc44446b"}, + {file = "rpds_py-0.10.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:69b857a7d8bd4f5d6e0db4086da8c46309a26e8cefdfc778c0c5cc17d4b11e08"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:975382d9aa90dc59253d6a83a5ca72e07f4ada3ae3d6c0575ced513db322b8ec"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:35fbd23c1c8732cde7a94abe7fb071ec173c2f58c0bd0d7e5b669fdfc80a2c7b"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:106af1653007cc569d5fbb5f08c6648a49fe4de74c2df814e234e282ebc06957"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce5e7504db95b76fc89055c7f41e367eaadef5b1d059e27e1d6eabf2b55ca314"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aca759ada6b1967fcfd4336dcf460d02a8a23e6abe06e90ea7881e5c22c4de6"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b5d4bdd697195f3876d134101c40c7d06d46c6ab25159ed5cbd44105c715278a"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a657250807b6efd19b28f5922520ae002a54cb43c2401e6f3d0230c352564d25"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:177c9dd834cdf4dc39c27436ade6fdf9fe81484758885f2d616d5d03c0a83bd2"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e22491d25f97199fc3581ad8dd8ce198d8c8fdb8dae80dea3512e1ce6d5fa99f"}, + {file = "rpds_py-0.10.3-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:2f3e1867dd574014253b4b8f01ba443b9c914e61d45f3674e452a915d6e929a3"}, + {file = "rpds_py-0.10.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c22211c165166de6683de8136229721f3d5c8606cc2c3d1562da9a3a5058049c"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40bc802a696887b14c002edd43c18082cb7b6f9ee8b838239b03b56574d97f71"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e271dd97c7bb8eefda5cca38cd0b0373a1fea50f71e8071376b46968582af9b"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:95cde244e7195b2c07ec9b73fa4c5026d4a27233451485caa1cd0c1b55f26dbd"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08a80cf4884920863623a9ee9a285ee04cef57ebedc1cc87b3e3e0f24c8acfe5"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:763ad59e105fca09705d9f9b29ecffb95ecdc3b0363be3bb56081b2c6de7977a"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:187700668c018a7e76e89424b7c1042f317c8df9161f00c0c903c82b0a8cac5c"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:5267cfda873ad62591b9332fd9472d2409f7cf02a34a9c9cb367e2c0255994bf"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:2ed83d53a8c5902ec48b90b2ac045e28e1698c0bea9441af9409fc844dc79496"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:255f1a10ae39b52122cce26ce0781f7a616f502feecce9e616976f6a87992d6b"}, + {file = "rpds_py-0.10.3-cp38-none-win32.whl", hash = "sha256:a019a344312d0b1f429c00d49c3be62fa273d4a1094e1b224f403716b6d03be1"}, + {file = "rpds_py-0.10.3-cp38-none-win_amd64.whl", hash = "sha256:efb9ece97e696bb56e31166a9dd7919f8f0c6b31967b454718c6509f29ef6fee"}, + {file = "rpds_py-0.10.3-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:570cc326e78ff23dec7f41487aa9c3dffd02e5ee9ab43a8f6ccc3df8f9327623"}, + {file = "rpds_py-0.10.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cff7351c251c7546407827b6a37bcef6416304fc54d12d44dbfecbb717064717"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:177914f81f66c86c012311f8c7f46887ec375cfcfd2a2f28233a3053ac93a569"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:448a66b8266de0b581246ca7cd6a73b8d98d15100fb7165974535fa3b577340e"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bbac1953c17252f9cc675bb19372444aadf0179b5df575ac4b56faaec9f6294"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9dd9d9d9e898b9d30683bdd2b6c1849449158647d1049a125879cb397ee9cd12"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8c71ea77536149e36c4c784f6d420ffd20bea041e3ba21ed021cb40ce58e2c9"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16a472300bc6c83fe4c2072cc22b3972f90d718d56f241adabc7ae509f53f154"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:b9255e7165083de7c1d605e818025e8860636348f34a79d84ec533546064f07e"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:53d7a3cd46cdc1689296348cb05ffd4f4280035770aee0c8ead3bbd4d6529acc"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:22da15b902f9f8e267020d1c8bcfc4831ca646fecb60254f7bc71763569f56b1"}, + {file = "rpds_py-0.10.3-cp39-none-win32.whl", hash = "sha256:850c272e0e0d1a5c5d73b1b7871b0a7c2446b304cec55ccdb3eaac0d792bb065"}, + {file = "rpds_py-0.10.3-cp39-none-win_amd64.whl", hash = "sha256:de61e424062173b4f70eec07e12469edde7e17fa180019a2a0d75c13a5c5dc57"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:af247fd4f12cca4129c1b82090244ea5a9d5bb089e9a82feb5a2f7c6a9fe181d"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:3ad59efe24a4d54c2742929001f2d02803aafc15d6d781c21379e3f7f66ec842"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:642ed0a209ced4be3a46f8cb094f2d76f1f479e2a1ceca6de6346a096cd3409d"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:37d0c59548ae56fae01c14998918d04ee0d5d3277363c10208eef8c4e2b68ed6"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aad6ed9e70ddfb34d849b761fb243be58c735be6a9265b9060d6ddb77751e3e8"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f94fdd756ba1f79f988855d948ae0bad9ddf44df296770d9a58c774cfbcca72"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77076bdc8776a2b029e1e6ffbe6d7056e35f56f5e80d9dc0bad26ad4a024a762"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:87d9b206b1bd7a0523375dc2020a6ce88bca5330682ae2fe25e86fd5d45cea9c"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:8efaeb08ede95066da3a3e3c420fcc0a21693fcd0c4396d0585b019613d28515"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a4d9bfda3f84fc563868fe25ca160c8ff0e69bc4443c5647f960d59400ce6557"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:d27aa6bbc1f33be920bb7adbb95581452cdf23005d5611b29a12bb6a3468cc95"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:ed8313809571a5463fd7db43aaca68ecb43ca7a58f5b23b6e6c6c5d02bdc7882"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:e10e6a1ed2b8661201e79dff5531f8ad4cdd83548a0f81c95cf79b3184b20c33"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:015de2ce2af1586ff5dc873e804434185199a15f7d96920ce67e50604592cae9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae87137951bb3dc08c7d8bfb8988d8c119f3230731b08a71146e84aaa919a7a9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0bb4f48bd0dd18eebe826395e6a48b7331291078a879295bae4e5d053be50d4c"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:09362f86ec201288d5687d1dc476b07bf39c08478cde837cb710b302864e7ec9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:821392559d37759caa67d622d0d2994c7a3f2fb29274948ac799d496d92bca73"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7170cbde4070dc3c77dec82abf86f3b210633d4f89550fa0ad2d4b549a05572a"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:5de11c041486681ce854c814844f4ce3282b6ea1656faae19208ebe09d31c5b8"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:4ed172d0c79f156c1b954e99c03bc2e3033c17efce8dd1a7c781bc4d5793dfac"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:11fdd1192240dda8d6c5d18a06146e9045cb7e3ba7c06de6973000ff035df7c6"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:f602881d80ee4228a2355c68da6b296a296cd22bbb91e5418d54577bbf17fa7c"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:691d50c99a937709ac4c4cd570d959a006bd6a6d970a484c84cc99543d4a5bbb"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:24cd91a03543a0f8d09cb18d1cb27df80a84b5553d2bd94cba5979ef6af5c6e7"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc2200e79d75b5238c8d69f6a30f8284290c777039d331e7340b6c17cad24a5a"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ea65b59882d5fa8c74a23f8960db579e5e341534934f43f3b18ec1839b893e41"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:829e91f3a8574888b73e7a3feb3b1af698e717513597e23136ff4eba0bc8387a"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eab75a8569a095f2ad470b342f2751d9902f7944704f0571c8af46bede438475"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:061c3ff1f51ecec256e916cf71cc01f9975af8fb3af9b94d3c0cc8702cfea637"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:39d05e65f23a0fe897b6ac395f2a8d48c56ac0f583f5d663e0afec1da89b95da"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:4eca20917a06d2fca7628ef3c8b94a8c358f6b43f1a621c9815243462dcccf97"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e8d0f0eca087630d58b8c662085529781fd5dc80f0a54eda42d5c9029f812599"}, + {file = "rpds_py-0.10.3.tar.gz", hash = "sha256:fcc1ebb7561a3e24a6588f7c6ded15d80aec22c66a070c757559b57b17ffd1cb"}, ] [[package]] name = "safetensors" -version = "0.3.1" +version = "0.3.3" description = "Fast and Safe Tensor serialization" optional = false python-versions = "*" files = [ - {file = "safetensors-0.3.1-cp310-cp310-macosx_10_11_x86_64.whl", hash = "sha256:2ae9b7dd268b4bae6624729dac86deb82104820e9786429b0583e5168db2f770"}, - {file = "safetensors-0.3.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:08c85c1934682f1e2cd904d38433b53cd2a98245a7cc31f5689f9322a2320bbf"}, - {file = "safetensors-0.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba625c7af9e1c5d0d91cb83d2fba97d29ea69d4db2015d9714d24c7f6d488e15"}, - {file = "safetensors-0.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b57d5890c619ec10d9f1b6426b8690d0c9c2868a90dc52f13fae6f6407ac141f"}, - {file = "safetensors-0.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c9f562ea696d50b95cadbeb1716dc476714a87792ffe374280c0835312cbfe2"}, - {file = "safetensors-0.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c115951b3a865ece8d98ee43882f2fd0a999c0200d6e6fec24134715ebe3b57"}, - {file = "safetensors-0.3.1-cp310-cp310-win32.whl", hash = "sha256:118f8f7503ea312fc7af27e934088a1b589fb1eff5a7dea2cd1de6c71ee33391"}, - {file = "safetensors-0.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:54846eaae25fded28a7bebbb66be563cad221b4c80daee39e2f55df5e5e0266f"}, - {file = "safetensors-0.3.1-cp311-cp311-macosx_10_11_universal2.whl", hash = "sha256:5af82e10946c4822506db0f29269f43147e889054704dde994d4e22f0c37377b"}, - {file = "safetensors-0.3.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:626c86dd1d930963c8ea7f953a3787ae85322551e3a5203ac731d6e6f3e18f44"}, - {file = "safetensors-0.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12e30677e6af1f4cc4f2832546e91dbb3b0aa7d575bfa473d2899d524e1ace08"}, - {file = "safetensors-0.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d534b80bc8d39945bb902f34b0454773971fe9e5e1f2142af451759d7e52b356"}, - {file = "safetensors-0.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ddd0ddd502cf219666e7d30f23f196cb87e829439b52b39f3e7da7918c3416df"}, - {file = "safetensors-0.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:997a2cc14023713f423e6d16536d55cb16a3d72850f142e05f82f0d4c76d383b"}, - {file = "safetensors-0.3.1-cp311-cp311-win32.whl", hash = "sha256:6ae9ca63d9e22f71ec40550207bd284a60a6b4916ae6ca12c85a8d86bf49e0c3"}, - {file = "safetensors-0.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:62aa7421ca455418423e35029524489480adda53e3f702453580180ecfebe476"}, - {file = "safetensors-0.3.1-cp37-cp37m-macosx_10_11_x86_64.whl", hash = "sha256:6d54b3ed367b6898baab75dfd057c24f36ec64d3938ffff2af981d56bfba2f42"}, - {file = "safetensors-0.3.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:262423aeda91117010f8c607889066028f680fbb667f50cfe6eae96f22f9d150"}, - {file = "safetensors-0.3.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:10efe2513a8327fd628cea13167089588acc23093ba132aecfc536eb9a4560fe"}, - {file = "safetensors-0.3.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:689b3d6a7ebce70ee9438267ee55ea89b575c19923876645e927d08757b552fe"}, - {file = "safetensors-0.3.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14cd9a87bc73ce06903e9f8ee8b05b056af6f3c9f37a6bd74997a16ed36ff5f4"}, - {file = "safetensors-0.3.1-cp37-cp37m-win32.whl", hash = "sha256:a77cb39624480d5f143c1cc272184f65a296f573d61629eff5d495d2e0541d3e"}, - {file = "safetensors-0.3.1-cp37-cp37m-win_amd64.whl", hash = "sha256:9eff3190bfbbb52eef729911345c643f875ca4dbb374aa6c559675cfd0ab73db"}, - {file = "safetensors-0.3.1-cp38-cp38-macosx_10_11_x86_64.whl", hash = "sha256:05cbfef76e4daa14796db1bbb52072d4b72a44050c368b2b1f6fd3e610669a89"}, - {file = "safetensors-0.3.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:c49061461f4a81e5ec3415070a3f135530834c89cbd6a7db7cd49e3cb9d9864b"}, - {file = "safetensors-0.3.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22cf7e73ca42974f098ce0cf4dd8918983700b6b07a4c6827d50c8daefca776e"}, - {file = "safetensors-0.3.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:04f909442d6223ff0016cd2e1b2a95ef8039b92a558014627363a2e267213f62"}, - {file = "safetensors-0.3.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2c573c5a0d5d45791ae8c179e26d74aff86e719056591aa7edb3ca7be55bc961"}, - {file = "safetensors-0.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6994043b12e717cf2a6ba69077ac41f0d3675b2819734f07f61819e854c622c7"}, - {file = "safetensors-0.3.1-cp38-cp38-win32.whl", hash = "sha256:158ede81694180a0dbba59422bc304a78c054b305df993c0c6e39c6330fa9348"}, - {file = "safetensors-0.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:afdc725beff7121ea8d39a7339f5a6abcb01daa189ea56290b67fe262d56e20f"}, - {file = "safetensors-0.3.1-cp39-cp39-macosx_10_11_x86_64.whl", hash = "sha256:cba910fcc9e5e64d32d62b837388721165e9c7e45d23bc3a38ad57694b77f40d"}, - {file = "safetensors-0.3.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:a4f7dbfe7285573cdaddd85ef6fa84ebbed995d3703ab72d71257944e384612f"}, - {file = "safetensors-0.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54aed0802f9eaa83ca7b1cbb986bfb90b8e2c67b6a4bcfe245627e17dad565d4"}, - {file = "safetensors-0.3.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34b75a766f3cfc99fd4c33e329b76deae63f5f388e455d863a5d6e99472fca8e"}, - {file = "safetensors-0.3.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a0f31904f35dc14919a145b2d7a2d8842a43a18a629affe678233c4ea90b4af"}, - {file = "safetensors-0.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcf527ecc5f58907fd9031510378105487f318cc91ecdc5aee3c7cc8f46030a8"}, - {file = "safetensors-0.3.1-cp39-cp39-win32.whl", hash = "sha256:e2f083112cf97aa9611e2a05cc170a2795eccec5f6ff837f4565f950670a9d83"}, - {file = "safetensors-0.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:5f4f614b8e8161cd8a9ca19c765d176a82b122fa3d3387b77862145bfe9b4e93"}, - {file = "safetensors-0.3.1.tar.gz", hash = "sha256:571da56ff8d0bec8ae54923b621cda98d36dcef10feb36fd492c4d0c2cd0e869"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_10_11_x86_64.whl", hash = "sha256:92e4d0c8b2836120fddd134474c5bda8963f322333941f8b9f643e5b24f041eb"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3dcadb6153c42addc9c625a622ebde9293fabe1973f9ef31ba10fb42c16e8536"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:08f26b61e1b0a14dc959aa9d568776bd038805f611caef1de04a80c468d4a7a4"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:17f41344d9a075f2f21b289a49a62e98baff54b5754240ba896063bce31626bf"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:f1045f798e1a16a6ced98d6a42ec72936d367a2eec81dc5fade6ed54638cd7d2"}, + {file = "safetensors-0.3.3-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:eaf0e4bc91da13f21ac846a39429eb3f3b7ed06295a32321fa3eb1a59b5c70f3"}, + {file = "safetensors-0.3.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25149180d4dc8ca48bac2ac3852a9424b466e36336a39659b35b21b2116f96fc"}, + {file = "safetensors-0.3.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9e943bf78c39de8865398a71818315e7d5d1af93c7b30d4da3fc852e62ad9bc"}, + {file = "safetensors-0.3.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cccfcac04a010354e87c7a2fe16a1ff004fc4f6e7ef8efc966ed30122ce00bc7"}, + {file = "safetensors-0.3.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a07121f427e646a50d18c1be0fa1a2cbf6398624c31149cd7e6b35486d72189e"}, + {file = "safetensors-0.3.3-cp310-cp310-win32.whl", hash = "sha256:a85e29cbfddfea86453cc0f4889b4bcc6b9c155be9a60e27be479a34e199e7ef"}, + {file = "safetensors-0.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:e13adad4a3e591378f71068d14e92343e626cf698ff805f61cdb946e684a218e"}, + {file = "safetensors-0.3.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:cbc3312f134baf07334dd517341a4b470b2931f090bd9284888acb7dfaf4606f"}, + {file = "safetensors-0.3.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d15030af39d5d30c22bcbc6d180c65405b7ea4c05b7bab14a570eac7d7d43722"}, + {file = "safetensors-0.3.3-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:f84a74cbe9859b28e3d6d7715ac1dd3097bebf8d772694098f6d42435245860c"}, + {file = "safetensors-0.3.3-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:10d637423d98ab2e6a4ad96abf4534eb26fcaf8ca3115623e64c00759374e90d"}, + {file = "safetensors-0.3.3-cp311-cp311-macosx_13_0_universal2.whl", hash = "sha256:3b46f5de8b44084aff2e480874c550c399c730c84b2e8ad1bddb062c94aa14e9"}, + {file = "safetensors-0.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e76da691a82dfaf752854fa6d17c8eba0c8466370c5ad8cf1bfdf832d3c7ee17"}, + {file = "safetensors-0.3.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4e342fd54e66aa9512dd13e410f791e47aa4feeb5f4c9a20882c72f3d272f29"}, + {file = "safetensors-0.3.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:178fd30b5dc73bce14a39187d948cedd0e5698e2f055b7ea16b5a96c9b17438e"}, + {file = "safetensors-0.3.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e8fdf7407dba44587ed5e79d5de3533d242648e1f2041760b21474bd5ea5c8c"}, + {file = "safetensors-0.3.3-cp311-cp311-win32.whl", hash = "sha256:7d3b744cee8d7a46ffa68db1a2ff1a1a432488e3f7a5a97856fe69e22139d50c"}, + {file = "safetensors-0.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f579877d30feec9b6ba409d05fa174633a4fc095675a4a82971d831a8bb60b97"}, + {file = "safetensors-0.3.3-cp37-cp37m-macosx_10_11_x86_64.whl", hash = "sha256:2fff5b19a1b462c17322998b2f4b8bce43c16fe208968174d2f3a1446284ceed"}, + {file = "safetensors-0.3.3-cp37-cp37m-macosx_11_0_x86_64.whl", hash = "sha256:41adb1d39e8aad04b16879e3e0cbcb849315999fad73bc992091a01e379cb058"}, + {file = "safetensors-0.3.3-cp37-cp37m-macosx_12_0_x86_64.whl", hash = "sha256:0f2b404250b3b877b11d34afcc30d80e7035714a1116a3df56acaca6b6c00096"}, + {file = "safetensors-0.3.3-cp37-cp37m-macosx_13_0_x86_64.whl", hash = "sha256:b43956ef20e9f4f2e648818a9e7b3499edd6b753a0f5526d4f6a6826fbee8446"}, + {file = "safetensors-0.3.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d61a99b34169981f088ccfbb2c91170843efc869a0a0532f422db7211bf4f474"}, + {file = "safetensors-0.3.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c0008aab36cd20e9a051a68563c6f80d40f238c2611811d7faa5a18bf3fd3984"}, + {file = "safetensors-0.3.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:93d54166072b143084fdcd214a080a088050c1bb1651016b55942701b31334e4"}, + {file = "safetensors-0.3.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c32ee08f61cea56a5d62bbf94af95df6040c8ab574afffaeb7b44ae5da1e9e3"}, + {file = "safetensors-0.3.3-cp37-cp37m-win32.whl", hash = "sha256:351600f367badd59f7bfe86d317bb768dd8c59c1561c6fac43cafbd9c1af7827"}, + {file = "safetensors-0.3.3-cp37-cp37m-win_amd64.whl", hash = "sha256:034717e297849dae1af0a7027a14b8647bd2e272c24106dced64d83e10d468d1"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_10_11_x86_64.whl", hash = "sha256:8530399666748634bc0b301a6a5523756931b0c2680d188e743d16304afe917a"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:9d741c1f1621e489ba10aa3d135b54202684f6e205df52e219d5eecd673a80c9"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:0c345fd85b4d2093a5109596ff4cd9dfc2e84992e881b4857fbc4a93a3b89ddb"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_12_0_x86_64.whl", hash = "sha256:69ccee8d05f55cdf76f7e6c87d2bdfb648c16778ef8acfd2ecc495e273e9233e"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_13_0_arm64.whl", hash = "sha256:c08a9a4b7a4ca389232fa8d097aebc20bbd4f61e477abc7065b5c18b8202dede"}, + {file = "safetensors-0.3.3-cp38-cp38-macosx_13_0_x86_64.whl", hash = "sha256:a002868d2e3f49bbe81bee2655a411c24fa1f8e68b703dec6629cb989d6ae42e"}, + {file = "safetensors-0.3.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3bd2704cb41faa44d3ec23e8b97330346da0395aec87f8eaf9c9e2c086cdbf13"}, + {file = "safetensors-0.3.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b2951bf3f0ad63df5e6a95263652bd6c194a6eb36fd4f2d29421cd63424c883"}, + {file = "safetensors-0.3.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:07114cec116253ca2e7230fdea30acf76828f21614afd596d7b5438a2f719bd8"}, + {file = "safetensors-0.3.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ab43aeeb9eadbb6b460df3568a662e6f1911ecc39387f8752afcb6a7d96c087"}, + {file = "safetensors-0.3.3-cp38-cp38-win32.whl", hash = "sha256:f2f59fce31dd3429daca7269a6b06f65e6547a0c248f5116976c3f1e9b73f251"}, + {file = "safetensors-0.3.3-cp38-cp38-win_amd64.whl", hash = "sha256:c31ca0d8610f57799925bf08616856b39518ab772c65093ef1516762e796fde4"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_10_11_x86_64.whl", hash = "sha256:59a596b3225c96d59af412385981f17dd95314e3fffdf359c7e3f5bb97730a19"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:82a16e92210a6221edd75ab17acdd468dd958ef5023d9c6c1289606cc30d1479"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:98a929e763a581f516373ef31983ed1257d2d0da912a8e05d5cd12e9e441c93a"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_12_0_x86_64.whl", hash = "sha256:12b83f1986cd16ea0454c636c37b11e819d60dd952c26978310a0835133480b7"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_13_0_arm64.whl", hash = "sha256:f439175c827c2f1bbd54df42789c5204a10983a30bc4242bc7deaf854a24f3f0"}, + {file = "safetensors-0.3.3-cp39-cp39-macosx_13_0_x86_64.whl", hash = "sha256:0085be33b8cbcb13079b3a8e131656e05b0bc5e6970530d4c24150f7afd76d70"}, + {file = "safetensors-0.3.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e3ec70c87b1e910769034206ad5efc051069b105aac1687f6edcd02526767f4"}, + {file = "safetensors-0.3.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f490132383e5e490e710608f4acffcb98ed37f91b885c7217d3f9f10aaff9048"}, + {file = "safetensors-0.3.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79d1b6c7ed5596baf79c80fbce5198c3cdcc521ae6a157699f427aba1a90082d"}, + {file = "safetensors-0.3.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad3cc8006e7a86ee7c88bd2813ec59cd7cc75b03e6fa4af89b9c7b235b438d68"}, + {file = "safetensors-0.3.3-cp39-cp39-win32.whl", hash = "sha256:ab29f54c6b8c301ca05fa014728996bd83aac6e21528f893aaf8945c71f42b6d"}, + {file = "safetensors-0.3.3-cp39-cp39-win_amd64.whl", hash = "sha256:0fa82004eae1a71e2aa29843ef99de9350e459a0fc2f65fc6ee0da9690933d2d"}, + {file = "safetensors-0.3.3.tar.gz", hash = "sha256:edb7072d788c4f929d0f5735d3a2fb51e5a27f833587828583b7f5747af1a2b8"}, ] [package.extras] -all = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "flax (>=0.6.3)", "h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "isort (>=5.5.4)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "numpy (>=1.21.6)", "paddlepaddle (>=2.4.1)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "setuptools-rust (>=1.5.2)", "tensorflow (>=2.11.0)", "torch (>=1.10)"] -dev = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "flax (>=0.6.3)", "h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "isort (>=5.5.4)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "numpy (>=1.21.6)", "paddlepaddle (>=2.4.1)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "setuptools-rust (>=1.5.2)", "tensorflow (>=2.11.0)", "torch (>=1.10)"] -jax = ["flax (>=0.6.3)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)"] +all = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "flax (>=0.6.3)", "h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "isort (>=5.5.4)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "numpy (>=1.21.6)", "paddlepaddle (>=2.4.1)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "setuptools-rust (>=1.5.2)", "tensorflow (==2.11.0)", "torch (>=1.10)"] +dev = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "flax (>=0.6.3)", "h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "isort (>=5.5.4)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "numpy (>=1.21.6)", "paddlepaddle (>=2.4.1)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "setuptools-rust (>=1.5.2)", "tensorflow (==2.11.0)", "torch (>=1.10)"] +jax = ["flax (>=0.6.3)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "numpy (>=1.21.6)"] numpy = ["numpy (>=1.21.6)"] -paddlepaddle = ["paddlepaddle (>=2.4.1)"] +paddlepaddle = ["numpy (>=1.21.6)", "paddlepaddle (>=2.4.1)"] +pinned-tf = ["tensorflow (==2.11.0)"] quality = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "isort (>=5.5.4)"] -tensorflow = ["tensorflow (>=2.11.0)"] +tensorflow = ["numpy (>=1.21.6)", "tensorflow (>=2.11.0)"] testing = ["h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "numpy (>=1.21.6)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "setuptools-rust (>=1.5.2)"] -torch = ["torch (>=1.10)"] +torch = ["numpy (>=1.21.6)", "torch (>=1.10)"] + +[[package]] +name = "scikit-learn" +version = "1.3.1" +description = "A set of python modules for machine learning and data mining" +optional = false +python-versions = ">=3.8" +files = [ + {file = "scikit-learn-1.3.1.tar.gz", hash = "sha256:1a231cced3ee3fa04756b4a7ab532dc9417acd581a330adff5f2c01ac2831fcf"}, + {file = "scikit_learn-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3153612ff8d36fa4e35ef8b897167119213698ea78f3fd130b4068e6f8d2da5a"}, + {file = "scikit_learn-1.3.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:6bb9490fdb8e7e00f1354621689187bef3cab289c9b869688f805bf724434755"}, + {file = "scikit_learn-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7135a03af71138669f19bc96e7d0cc8081aed4b3565cc3b131135d65fc642ba"}, + {file = "scikit_learn-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d8dee8c1f40eeba49a85fe378bdf70a07bb64aba1a08fda1e0f48d27edfc3e6"}, + {file = "scikit_learn-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:4d379f2b34096105a96bd857b88601dffe7389bd55750f6f29aaa37bc6272eb5"}, + {file = "scikit_learn-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:14e8775eba072ab10866a7e0596bc9906873e22c4c370a651223372eb62de180"}, + {file = "scikit_learn-1.3.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:58b0c2490eff8355dc26e884487bf8edaccf2ba48d09b194fb2f3a026dd64f9d"}, + {file = "scikit_learn-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f66eddfda9d45dd6cadcd706b65669ce1df84b8549875691b1f403730bdef217"}, + {file = "scikit_learn-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c6448c37741145b241eeac617028ba6ec2119e1339b1385c9720dae31367f2be"}, + {file = "scikit_learn-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:c413c2c850241998168bbb3bd1bb59ff03b1195a53864f0b80ab092071af6028"}, + {file = "scikit_learn-1.3.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:52b77cc08bd555969ec5150788ed50276f5ef83abb72e6f469c5b91a0009bbca"}, + {file = "scikit_learn-1.3.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:a683394bc3f80b7c312c27f9b14ebea7766b1f0a34faf1a2e9158d80e860ec26"}, + {file = "scikit_learn-1.3.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15d964d9eb181c79c190d3dbc2fff7338786bf017e9039571418a1d53dab236"}, + {file = "scikit_learn-1.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ce9233cdf0cdcf0858a5849d306490bf6de71fa7603a3835124e386e62f2311"}, + {file = "scikit_learn-1.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:1ec668ce003a5b3d12d020d2cde0abd64b262ac5f098b5c84cf9657deb9996a8"}, + {file = "scikit_learn-1.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ccbbedae99325628c1d1cbe3916b7ef58a1ce949672d8d39c8b190e10219fd32"}, + {file = "scikit_learn-1.3.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:845f81c7ceb4ea6bac64ab1c9f2ce8bef0a84d0f21f3bece2126adcc213dfecd"}, + {file = "scikit_learn-1.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8454d57a22d856f1fbf3091bd86f9ebd4bff89088819886dc0c72f47a6c30652"}, + {file = "scikit_learn-1.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d993fb70a1d78c9798b8f2f28705bfbfcd546b661f9e2e67aa85f81052b9c53"}, + {file = "scikit_learn-1.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:66f7bb1fec37d65f4ef85953e1df5d3c98a0f0141d394dcdaead5a6de9170347"}, +] + +[package.dependencies] +joblib = ">=1.1.1" +numpy = ">=1.17.3,<2.0" +scipy = ">=1.5.0" +threadpoolctl = ">=2.0.0" + +[package.extras] +benchmark = ["matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "pandas (>=1.0.5)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.10.1)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +examples = ["matplotlib (>=3.1.3)", "pandas (>=1.0.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)"] +tests = ["black (>=23.3.0)", "matplotlib (>=3.1.3)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.16.2)"] + +[[package]] +name = "scipy" +version = "1.11.3" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = "<3.13,>=3.9" +files = [ + {file = "scipy-1.11.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:370f569c57e1d888304052c18e58f4a927338eafdaef78613c685ca2ea0d1fa0"}, + {file = "scipy-1.11.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:9885e3e4f13b2bd44aaf2a1a6390a11add9f48d5295f7a592393ceb8991577a3"}, + {file = "scipy-1.11.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e04aa19acc324a1a076abb4035dabe9b64badb19f76ad9c798bde39d41025cdc"}, + {file = "scipy-1.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e1a8a4657673bfae1e05e1e1d6e94b0cabe5ed0c7c144c8aa7b7dbb774ce5c1"}, + {file = "scipy-1.11.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7abda0e62ef00cde826d441485e2e32fe737bdddee3324e35c0e01dee65e2a88"}, + {file = "scipy-1.11.3-cp310-cp310-win_amd64.whl", hash = "sha256:033c3fd95d55012dd1148b201b72ae854d5086d25e7c316ec9850de4fe776929"}, + {file = "scipy-1.11.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:925c6f09d0053b1c0f90b2d92d03b261e889b20d1c9b08a3a51f61afc5f58165"}, + {file = "scipy-1.11.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5664e364f90be8219283eeb844323ff8cd79d7acbd64e15eb9c46b9bc7f6a42a"}, + {file = "scipy-1.11.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00f325434b6424952fbb636506f0567898dca7b0f7654d48f1c382ea338ce9a3"}, + {file = "scipy-1.11.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f290cf561a4b4edfe8d1001ee4be6da60c1c4ea712985b58bf6bc62badee221"}, + {file = "scipy-1.11.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:91770cb3b1e81ae19463b3c235bf1e0e330767dca9eb4cd73ba3ded6c4151e4d"}, + {file = "scipy-1.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1f97cd89c0fe1a0685f8f89d85fa305deb3067d0668151571ba50913e445820"}, + {file = "scipy-1.11.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dfcc1552add7cb7c13fb70efcb2389d0624d571aaf2c80b04117e2755a0c5d15"}, + {file = "scipy-1.11.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0d3a136ae1ff0883fffbb1b05b0b2fea251cb1046a5077d0b435a1839b3e52b7"}, + {file = "scipy-1.11.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bae66a2d7d5768eaa33008fa5a974389f167183c87bf39160d3fefe6664f8ddc"}, + {file = "scipy-1.11.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2f6dee6cbb0e263b8142ed587bc93e3ed5e777f1f75448d24fb923d9fd4dce6"}, + {file = "scipy-1.11.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:74e89dc5e00201e71dd94f5f382ab1c6a9f3ff806c7d24e4e90928bb1aafb280"}, + {file = "scipy-1.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:90271dbde4be191522b3903fc97334e3956d7cfb9cce3f0718d0ab4fd7d8bfd6"}, + {file = "scipy-1.11.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a63d1ec9cadecce838467ce0631c17c15c7197ae61e49429434ba01d618caa83"}, + {file = "scipy-1.11.3-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:5305792c7110e32ff155aed0df46aa60a60fc6e52cd4ee02cdeb67eaccd5356e"}, + {file = "scipy-1.11.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ea7f579182d83d00fed0e5c11a4aa5ffe01460444219dedc448a36adf0c3917"}, + {file = "scipy-1.11.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c77da50c9a91e23beb63c2a711ef9e9ca9a2060442757dffee34ea41847d8156"}, + {file = "scipy-1.11.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15f237e890c24aef6891c7d008f9ff7e758c6ef39a2b5df264650eb7900403c0"}, + {file = "scipy-1.11.3-cp39-cp39-win_amd64.whl", hash = "sha256:4b4bb134c7aa457e26cc6ea482b016fef45db71417d55cc6d8f43d799cdf9ef2"}, + {file = "scipy-1.11.3.tar.gz", hash = "sha256:bba4d955f54edd61899776bad459bf7326e14b9fa1c552181f0479cc60a568cd"}, +] + +[package.dependencies] +numpy = ">=1.21.6,<1.28.0" + +[package.extras] +dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] +test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "seaborn" +version = "0.12.2" +description = "Statistical data visualization" +optional = false +python-versions = ">=3.7" +files = [ + {file = "seaborn-0.12.2-py3-none-any.whl", hash = "sha256:ebf15355a4dba46037dfd65b7350f014ceb1f13c05e814eda2c9f5fd731afc08"}, + {file = "seaborn-0.12.2.tar.gz", hash = "sha256:374645f36509d0dcab895cba5b47daf0586f77bfe3b36c97c607db7da5be0139"}, +] + +[package.dependencies] +matplotlib = ">=3.1,<3.6.1 || >3.6.1" +numpy = ">=1.17,<1.24.0 || >1.24.0" +pandas = ">=0.25" + +[package.extras] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.3)", "statsmodels (>=0.10)"] [[package]] name = "send2trash" @@ -3606,13 +3814,13 @@ win32 = ["pywin32"] [[package]] name = "sentry-sdk" -version = "1.29.2" +version = "1.31.0" description = "Python client for Sentry (https://sentry.io)" optional = false python-versions = "*" files = [ - {file = "sentry-sdk-1.29.2.tar.gz", hash = "sha256:a99ee105384788c3f228726a88baf515fe7b5f1d2d0f215a03d194369f158df7"}, - {file = "sentry_sdk-1.29.2-py2.py3-none-any.whl", hash = "sha256:3e17215d8006612e2df02b0e73115eb8376c37e3f586d8436fa41644e605074d"}, + {file = "sentry-sdk-1.31.0.tar.gz", hash = "sha256:6de2e88304873484207fed836388e422aeff000609b104c802749fd89d56ba5b"}, + {file = "sentry_sdk-1.31.0-py2.py3-none-any.whl", hash = "sha256:64a7141005fb775b9db298a30de93e3b83e0ddd1232dc6f36eb38aebc1553291"}, ] [package.dependencies] @@ -3622,10 +3830,12 @@ urllib3 = {version = ">=1.26.11", markers = "python_version >= \"3.6\""} [package.extras] aiohttp = ["aiohttp (>=3.5)"] arq = ["arq (>=0.23)"] +asyncpg = ["asyncpg (>=0.23)"] beam = ["apache-beam (>=2.12)"] bottle = ["bottle (>=0.12.13)"] celery = ["celery (>=3)"] chalice = ["chalice (>=1.16.0)"] +clickhouse-driver = ["clickhouse-driver (>=0.2.0)"] django = ["django (>=1.8)"] falcon = ["falcon (>=1.4)"] fastapi = ["fastapi (>=0.79.0)"] @@ -3635,6 +3845,7 @@ httpx = ["httpx (>=0.16.0)"] huey = ["huey (>=2)"] loguru = ["loguru (>=0.5)"] opentelemetry = ["opentelemetry-distro (>=0.35b0)"] +opentelemetry-experimental = ["opentelemetry-distro (>=0.40b0,<1.0)", "opentelemetry-instrumentation-aiohttp-client (>=0.40b0,<1.0)", "opentelemetry-instrumentation-django (>=0.40b0,<1.0)", "opentelemetry-instrumentation-fastapi (>=0.40b0,<1.0)", "opentelemetry-instrumentation-flask (>=0.40b0,<1.0)", "opentelemetry-instrumentation-requests (>=0.40b0,<1.0)", "opentelemetry-instrumentation-sqlite3 (>=0.40b0,<1.0)", "opentelemetry-instrumentation-urllib (>=0.40b0,<1.0)"] pure-eval = ["asttokens", "executing", "pure-eval"] pymongo = ["pymongo (>=3.1)"] pyspark = ["pyspark (>=2.4.4)"] @@ -3732,19 +3943,41 @@ test = ["pytest"] [[package]] name = "setuptools" -version = "68.0.0" +version = "68.2.2" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "setuptools-68.0.0-py3-none-any.whl", hash = "sha256:11e52c67415a381d10d6b462ced9cfb97066179f0e871399e006c4ab101fc85f"}, - {file = "setuptools-68.0.0.tar.gz", hash = "sha256:baf1fdb41c6da4cd2eae722e135500da913332ab3f2f5c7d33af9b492acb5235"}, + {file = "setuptools-68.2.2-py3-none-any.whl", hash = "sha256:b454a35605876da60632df1a60f736524eb73cc47bbc9f3f1ef1b644de74fd2a"}, + {file = "setuptools-68.2.2.tar.gz", hash = "sha256:4ac1475276d2f1c48684874089fefcd83bd7162ddaafb81fac866ba0db282a87"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-hoverxref (<2)", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (==0.8.3)", "sphinx-reredirects", "sphinxcontrib-towncrier"] -testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pip-run (>=8.8)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] -testing-integration = ["build[virtualenv]", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-hoverxref (<2)", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.1)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "setuptools-scm" +version = "8.0.3" +description = "the blessed package to manage your versions by scm tags" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-scm-8.0.3.tar.gz", hash = "sha256:0169fd70197efda2f8c4d0b2a7a3d614431b488116f37b79d031e9e7ec884d8c"}, + {file = "setuptools_scm-8.0.3-py3-none-any.whl", hash = "sha256:813822234453438a13c78d05c8af29918fbc06f88efb33d38f065340bbb48c39"}, +] + +[package.dependencies] +packaging = ">=20" +setuptools = "*" +tomli = {version = ">=1", markers = "python_version < \"3.11\""} +typing-extensions = {version = "*", markers = "python_version < \"3.11\""} + +[package.extras] +docs = ["entangled-cli[rich]", "mkdocs", "mkdocs-entangled-plugin", "mkdocs-material", "mkdocstrings[python]", "pygments"] +rich = ["rich"] +test = ["pytest", "rich", "virtualenv (>20)"] [[package]] name = "six" @@ -3759,13 +3992,13 @@ files = [ [[package]] name = "smmap" -version = "5.0.0" +version = "5.0.1" description = "A pure Python implementation of a sliding window memory map manager" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "smmap-5.0.0-py3-none-any.whl", hash = "sha256:2aba19d6a040e78d8b09de5c57e96207b09ed71d8e55ce0959eeee6c8e190d94"}, - {file = "smmap-5.0.0.tar.gz", hash = "sha256:c840e62059cd3be204b0c9c9f74be2c09d5648eddd4580d9314c3ecde0b30936"}, + {file = "smmap-5.0.1-py3-none-any.whl", hash = "sha256:e6d8668fa5f93e706934a62d7b4db19c8d9eb8cf2adbb75ef1b675aa332b69da"}, + {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"}, ] [[package]] @@ -3781,24 +4014,24 @@ files = [ [[package]] name = "soupsieve" -version = "2.4.1" +version = "2.5" description = "A modern CSS selector implementation for Beautiful Soup." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "soupsieve-2.4.1-py3-none-any.whl", hash = "sha256:1c1bfee6819544a3447586c889157365a27e10d88cde3ad3da0cf0ddf646feb8"}, - {file = "soupsieve-2.4.1.tar.gz", hash = "sha256:89d12b2d5dfcd2c9e8c22326da9d9aa9cb3dfab0a83a024f05704076ee8d35ea"}, + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, ] [[package]] name = "stack-data" -version = "0.6.2" +version = "0.6.3" description = "Extract data from python stack frames and tracebacks for informative displays" optional = false python-versions = "*" files = [ - {file = "stack_data-0.6.2-py3-none-any.whl", hash = "sha256:cbb2a53eb64e5785878201a97ed7c7b94883f48b87bfb0bbe8b623c74679e4a8"}, - {file = "stack_data-0.6.2.tar.gz", hash = "sha256:32d2dd0376772d01b6cb9fc996f3c8b57a357089dec328ed4b6553d037eaf815"}, + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, ] [package.dependencies] @@ -3809,15 +4042,29 @@ pure-eval = "*" [package.extras] tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] +[[package]] +name = "sympy" +version = "1.12" +description = "Computer algebra system (CAS) in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "sympy-1.12-py3-none-any.whl", hash = "sha256:c3588cd4295d0c0f603d0f2ae780587e64e2efeedb3521e46b9bb1d08d184fa5"}, + {file = "sympy-1.12.tar.gz", hash = "sha256:ebf595c8dac3e0fdc4152c51878b498396ec7f30e7a914d6071e674d49420fb8"}, +] + +[package.dependencies] +mpmath = ">=0.19" + [[package]] name = "tenacity" -version = "8.2.2" +version = "8.2.3" description = "Retry code until it succeeds" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "tenacity-8.2.2-py3-none-any.whl", hash = "sha256:2f277afb21b851637e8f52e6a613ff08734c347dc19ade928e519d7d2d8569b0"}, - {file = "tenacity-8.2.2.tar.gz", hash = "sha256:43af037822bd0029025877f3b2d97cc4d7bb0c2991000a3d59d71517c5c969e0"}, + {file = "tenacity-8.2.3-py3-none-any.whl", hash = "sha256:ce510e327a630c9e1beaf17d42e6ffacc88185044ad85cf74c0a8887c6a0f88c"}, + {file = "tenacity-8.2.3.tar.gz", hash = "sha256:5398ef0d78e63f40007c1fb4c0bff96e1911394d2fa8d194f77619c05ff6cc8a"}, ] [package.extras] @@ -3857,6 +4104,17 @@ tornado = ">=6.1.0" docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +[[package]] +name = "threadpoolctl" +version = "3.2.0" +description = "threadpoolctl" +optional = false +python-versions = ">=3.8" +files = [ + {file = "threadpoolctl-3.2.0-py3-none-any.whl", hash = "sha256:2b7818516e423bdaebb97c723f86a7c6b0a83d3f3b0970328d66f4d9104dc032"}, + {file = "threadpoolctl-3.2.0.tar.gz", hash = "sha256:c96a0ba3bdddeaca37dc4cc7344aafad41cdb8c313f74fdfe387a867bba93355"}, +] + [[package]] name = "tinycss2" version = "1.2.1" @@ -3953,39 +4211,38 @@ files = [ [[package]] name = "torch" -version = "1.13.1" +version = "2.0.1" description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" optional = false -python-versions = ">=3.7.0" +python-versions = ">=3.8.0" files = [ - {file = "torch-1.13.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:fd12043868a34a8da7d490bf6db66991108b00ffbeecb034228bfcbbd4197143"}, - {file = "torch-1.13.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:d9fe785d375f2e26a5d5eba5de91f89e6a3be5d11efb497e76705fdf93fa3c2e"}, - {file = "torch-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:98124598cdff4c287dbf50f53fb455f0c1e3a88022b39648102957f3445e9b76"}, - {file = "torch-1.13.1-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:393a6273c832e047581063fb74335ff50b4c566217019cc6ace318cd79eb0566"}, - {file = "torch-1.13.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:0122806b111b949d21fa1a5f9764d1fd2fcc4a47cb7f8ff914204fd4fc752ed5"}, - {file = "torch-1.13.1-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:22128502fd8f5b25ac1cd849ecb64a418382ae81dd4ce2b5cebaa09ab15b0d9b"}, - {file = "torch-1.13.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:76024be052b659ac1304ab8475ab03ea0a12124c3e7626282c9c86798ac7bc11"}, - {file = "torch-1.13.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:ea8dda84d796094eb8709df0fcd6b56dc20b58fdd6bc4e8d7109930dafc8e419"}, - {file = "torch-1.13.1-cp37-cp37m-win_amd64.whl", hash = "sha256:2ee7b81e9c457252bddd7d3da66fb1f619a5d12c24d7074de91c4ddafb832c93"}, - {file = "torch-1.13.1-cp37-none-macosx_10_9_x86_64.whl", hash = "sha256:0d9b8061048cfb78e675b9d2ea8503bfe30db43d583599ae8626b1263a0c1380"}, - {file = "torch-1.13.1-cp37-none-macosx_11_0_arm64.whl", hash = "sha256:f402ca80b66e9fbd661ed4287d7553f7f3899d9ab54bf5c67faada1555abde28"}, - {file = "torch-1.13.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:727dbf00e2cf858052364c0e2a496684b9cb5aa01dc8a8bc8bbb7c54502bdcdd"}, - {file = "torch-1.13.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:df8434b0695e9ceb8cc70650afc1310d8ba949e6db2a0525ddd9c3b2b181e5fe"}, - {file = "torch-1.13.1-cp38-cp38-win_amd64.whl", hash = "sha256:5e1e722a41f52a3f26f0c4fcec227e02c6c42f7c094f32e49d4beef7d1e213ea"}, - {file = "torch-1.13.1-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:33e67eea526e0bbb9151263e65417a9ef2d8fa53cbe628e87310060c9dcfa312"}, - {file = "torch-1.13.1-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:eeeb204d30fd40af6a2d80879b46a7efbe3cf43cdbeb8838dd4f3d126cc90b2b"}, - {file = "torch-1.13.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:50ff5e76d70074f6653d191fe4f6a42fdbe0cf942fbe2a3af0b75eaa414ac038"}, - {file = "torch-1.13.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:2c3581a3fd81eb1f0f22997cddffea569fea53bafa372b2c0471db373b26aafc"}, - {file = "torch-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:0aa46f0ac95050c604bcf9ef71da9f1172e5037fdf2ebe051962d47b123848e7"}, - {file = "torch-1.13.1-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:6930791efa8757cb6974af73d4996b6b50c592882a324b8fb0589c6a9ba2ddaf"}, - {file = "torch-1.13.1-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:e0df902a7c7dd6c795698532ee5970ce898672625635d885eade9976e5a04949"}, + {file = "torch-2.0.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:8ced00b3ba471856b993822508f77c98f48a458623596a4c43136158781e306a"}, + {file = "torch-2.0.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:359bfaad94d1cda02ab775dc1cc386d585712329bb47b8741607ef6ef4950747"}, + {file = "torch-2.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:7c84e44d9002182edd859f3400deaa7410f5ec948a519cc7ef512c2f9b34d2c4"}, + {file = "torch-2.0.1-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:567f84d657edc5582d716900543e6e62353dbe275e61cdc36eda4929e46df9e7"}, + {file = "torch-2.0.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:787b5a78aa7917465e9b96399b883920c88a08f4eb63b5a5d2d1a16e27d2f89b"}, + {file = "torch-2.0.1-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:e617b1d0abaf6ced02dbb9486803abfef0d581609b09641b34fa315c9c40766d"}, + {file = "torch-2.0.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:b6019b1de4978e96daa21d6a3ebb41e88a0b474898fe251fd96189587408873e"}, + {file = "torch-2.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:dbd68cbd1cd9da32fe5d294dd3411509b3d841baecb780b38b3b7b06c7754434"}, + {file = "torch-2.0.1-cp311-none-macosx_10_9_x86_64.whl", hash = "sha256:ef654427d91600129864644e35deea761fb1fe131710180b952a6f2e2207075e"}, + {file = "torch-2.0.1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:25aa43ca80dcdf32f13da04c503ec7afdf8e77e3a0183dd85cd3e53b2842e527"}, + {file = "torch-2.0.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:5ef3ea3d25441d3957348f7e99c7824d33798258a2bf5f0f0277cbcadad2e20d"}, + {file = "torch-2.0.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:0882243755ff28895e8e6dc6bc26ebcf5aa0911ed81b2a12f241fc4b09075b13"}, + {file = "torch-2.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:f66aa6b9580a22b04d0af54fcd042f52406a8479e2b6a550e3d9f95963e168c8"}, + {file = "torch-2.0.1-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:1adb60d369f2650cac8e9a95b1d5758e25d526a34808f7448d0bd599e4ae9072"}, + {file = "torch-2.0.1-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:1bcffc16b89e296826b33b98db5166f990e3b72654a2b90673e817b16c50e32b"}, + {file = "torch-2.0.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:e10e1597f2175365285db1b24019eb6f04d53dcd626c735fc502f1e8b6be9875"}, + {file = "torch-2.0.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:423e0ae257b756bb45a4b49072046772d1ad0c592265c5080070e0767da4e490"}, + {file = "torch-2.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:8742bdc62946c93f75ff92da00e3803216c6cce9b132fbca69664ca38cfb3e18"}, + {file = "torch-2.0.1-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:c62df99352bd6ee5a5a8d1832452110435d178b5164de450831a3a8cc14dc680"}, + {file = "torch-2.0.1-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:671a2565e3f63b8fe8e42ae3e36ad249fe5e567435ea27b94edaa672a7d0c416"}, ] [package.dependencies] -nvidia-cublas-cu11 = {version = "11.10.3.66", markers = "platform_system == \"Linux\""} -nvidia-cuda-nvrtc-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\""} -nvidia-cuda-runtime-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\""} -nvidia-cudnn-cu11 = {version = "8.5.0.96", markers = "platform_system == \"Linux\""} +filelock = "*" +jinja2 = "*" +networkx = "*" +sympy = "*" typing-extensions = "*" [package.extras] @@ -3993,71 +4250,72 @@ opt-einsum = ["opt-einsum (>=3.3)"] [[package]] name = "tornado" -version = "6.3.2" +version = "6.3.3" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." optional = false python-versions = ">= 3.8" files = [ - {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:c367ab6c0393d71171123ca5515c61ff62fe09024fa6bf299cd1339dc9456829"}, - {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b46a6ab20f5c7c1cb949c72c1994a4585d2eaa0be4853f50a03b5031e964fc7c"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2de14066c4a38b4ecbbcd55c5cc4b5340eb04f1c5e81da7451ef555859c833f"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05615096845cf50a895026f749195bf0b10b8909f9be672f50b0fe69cba368e4"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b17b1cf5f8354efa3d37c6e28fdfd9c1c1e5122f2cb56dac121ac61baa47cbe"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:29e71c847a35f6e10ca3b5c2990a52ce38b233019d8e858b755ea6ce4dcdd19d"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:834ae7540ad3a83199a8da8f9f2d383e3c3d5130a328889e4cc991acc81e87a0"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:6a0848f1aea0d196a7c4f6772197cbe2abc4266f836b0aac76947872cd29b411"}, - {file = "tornado-6.3.2-cp38-abi3-win32.whl", hash = "sha256:7efcbcc30b7c654eb6a8c9c9da787a851c18f8ccd4a5a3a95b05c7accfa068d2"}, - {file = "tornado-6.3.2-cp38-abi3-win_amd64.whl", hash = "sha256:0c325e66c8123c606eea33084976c832aa4e766b7dff8aedd7587ea44a604cdf"}, - {file = "tornado-6.3.2.tar.gz", hash = "sha256:4b927c4f19b71e627b13f3db2324e4ae660527143f9e1f2e2fb404f3a187e2ba"}, + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:502fba735c84450974fec147340016ad928d29f1e91f49be168c0a4c18181e1d"}, + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:805d507b1f588320c26f7f097108eb4023bbaa984d63176d1652e184ba24270a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bd19ca6c16882e4d37368e0152f99c099bad93e0950ce55e71daed74045908f"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ac51f42808cca9b3613f51ffe2a965c8525cb1b00b7b2d56828b8045354f76a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71a8db65160a3c55d61839b7302a9a400074c9c753040455494e2af74e2501f2"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:ceb917a50cd35882b57600709dd5421a418c29ddc852da8bcdab1f0db33406b0"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:7d01abc57ea0dbb51ddfed477dfe22719d376119844e33c661d873bf9c0e4a16"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:9dc4444c0defcd3929d5c1eb5706cbe1b116e762ff3e0deca8b715d14bf6ec17"}, + {file = "tornado-6.3.3-cp38-abi3-win32.whl", hash = "sha256:65ceca9500383fbdf33a98c0087cb975b2ef3bfb874cb35b8de8740cf7f41bd3"}, + {file = "tornado-6.3.3-cp38-abi3-win_amd64.whl", hash = "sha256:22d3c2fa10b5793da13c807e6fc38ff49a4f6e1e3868b0a6f4164768bb8e20f5"}, + {file = "tornado-6.3.3.tar.gz", hash = "sha256:e7d8db41c0181c80d76c982aacc442c0783a2c54d6400fe028954201a2e032fe"}, ] [[package]] name = "tqdm" -version = "4.65.0" +version = "4.66.1" description = "Fast, Extensible Progress Meter" optional = false python-versions = ">=3.7" files = [ - {file = "tqdm-4.65.0-py3-none-any.whl", hash = "sha256:c4f53a17fe37e132815abceec022631be8ffe1b9381c2e6e30aa70edc99e9671"}, - {file = "tqdm-4.65.0.tar.gz", hash = "sha256:1871fb68a86b8fb3b59ca4cdd3dcccbc7e6d613eeed31f4c332531977b89beb5"}, + {file = "tqdm-4.66.1-py3-none-any.whl", hash = "sha256:d302b3c5b53d47bce91fea46679d9c3c6508cf6332229aa1e7d8653723793386"}, + {file = "tqdm-4.66.1.tar.gz", hash = "sha256:d88e651f9db8d8551a62556d3cff9e3034274ca5d66e93197cf2490e2dcb69c7"}, ] [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} [package.extras] -dev = ["py-make (>=0.1.0)", "twine", "wheel"] +dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"] notebook = ["ipywidgets (>=6)"] slack = ["slack-sdk"] telegram = ["requests"] [[package]] name = "traitlets" -version = "5.9.0" +version = "5.10.1" description = "Traitlets Python configuration system" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "traitlets-5.9.0-py3-none-any.whl", hash = "sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8"}, - {file = "traitlets-5.9.0.tar.gz", hash = "sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9"}, + {file = "traitlets-5.10.1-py3-none-any.whl", hash = "sha256:07ab9c5bf8a0499fd7b088ba51be899c90ffc936ffc797d7b6907fc516bcd116"}, + {file = "traitlets-5.10.1.tar.gz", hash = "sha256:db9c4aa58139c3ba850101913915c042bdba86f7c8a0dda1c6f7f92c5da8e542"}, ] [package.extras] docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] -test = ["argcomplete (>=2.0)", "pre-commit", "pytest", "pytest-mock"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.5.1)", "pre-commit", "pytest (>=7.0,<7.5)", "pytest-mock", "pytest-mypy-testing"] [[package]] name = "transformer-lens" -version = "1.4.0" +version = "1.6.1" description = "An implementation of transformers tailored for mechanistic interpretability." optional = false python-versions = ">=3.7.4,<4.0" files = [ - {file = "transformer_lens-1.4.0-py3-none-any.whl", hash = "sha256:50f6f9c168131c7fa6ae9fe627fd745a09b71e129fba1b037f21dd57f94e3aba"}, - {file = "transformer_lens-1.4.0.tar.gz", hash = "sha256:dbd70f3241154d9c8e462be8221cb887e608631cbc62fc3e1cf44e35b4a647e0"}, + {file = "transformer_lens-1.6.1-py3-none-any.whl", hash = "sha256:539dbd68497dac59f45e8720e9cf3a76c2209e472db9472b1381501a47b2f04e"}, + {file = "transformer_lens-1.6.1.tar.gz", hash = "sha256:198b88b826c333b6759bb9b7d2bd28df904f58376498b330e8f76f4f1dd97016"}, ] [package.dependencies] +beartype = ">=0.14.1,<0.15.0" datasets = ">=2.7.1" einops = ">=0.6.0" fancy-einsum = ">=0.0.3" @@ -4068,7 +4326,6 @@ rich = ">=12.6.0" torch = ">=1.10" tqdm = ">=4.64.1" transformers = ">=4.25.1" -typeguard = ">=3.0.2,<4.0.0" wandb = ">=0.13.5" [package.extras] @@ -4076,18 +4333,18 @@ docs = ["furo (>=2022.12.7)", "myst-parser (>=0.18.1)", "sphinx (==5.2.3)", "sph [[package]] name = "transformers" -version = "4.31.0" +version = "4.33.3" description = "State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow" optional = false python-versions = ">=3.8.0" files = [ - {file = "transformers-4.31.0-py3-none-any.whl", hash = "sha256:8487aab0195ce1c2a5ae189305118b9720daddbc7b688edb09ccd79e3b149f6b"}, - {file = "transformers-4.31.0.tar.gz", hash = "sha256:4302fba920a1c24d3a429a29efff6a63eac03f3f3cf55b55927fc795d01cb273"}, + {file = "transformers-4.33.3-py3-none-any.whl", hash = "sha256:7150bbf6781ddb3338ce7d74f4d6f557e6c236a0a1dd3de57412214caae7fd71"}, + {file = "transformers-4.33.3.tar.gz", hash = "sha256:8ea7c92310dee7c63b14766ce928218f7a9177960b2487ac018c91ae621af03e"}, ] [package.dependencies] filelock = "*" -huggingface-hub = ">=0.14.1,<1.0" +huggingface-hub = ">=0.15.1,<1.0" numpy = ">=1.17" packaging = ">=20.0" pyyaml = ">=5.1" @@ -4099,19 +4356,19 @@ tqdm = ">=4.27" [package.extras] accelerate = ["accelerate (>=0.20.3)"] -agents = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "datasets (!=2.5.0)", "diffusers", "opencv-python", "sentencepiece (>=0.1.91,!=0.1.92)", "torch (>=1.9,!=1.12.0)"] -all = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "jax (>=0.2.8,!=0.3.2,<=0.4.13)", "jaxlib (>=0.1.65,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.9,!=1.12.0)", "torchaudio", "torchvision"] +agents = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "datasets (!=2.5.0)", "diffusers", "opencv-python", "sentencepiece (>=0.1.91,!=0.1.92)", "torch (>=1.10,!=1.12.0)"] +all = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision"] audio = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] codecarbon = ["codecarbon (==1.2.0)"] deepspeed = ["accelerate (>=0.20.3)", "deepspeed (>=0.9.3)"] deepspeed-testing = ["GitPython (<3.1.19)", "accelerate (>=0.20.3)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "deepspeed (>=0.9.3)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder (>=0.3.0)", "nltk", "optuna", "parameterized", "protobuf", "psutil", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "sentencepiece (>=0.1.91,!=0.1.92)", "timeout-decorator"] -dev = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "decord (==0.6.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "flax (>=0.4.1,<=0.7.0)", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "jax (>=0.2.8,!=0.3.2,<=0.4.13)", "jaxlib (>=0.1.65,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "tensorflow (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx", "timeout-decorator", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.9,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] -dev-tensorflow = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "isort (>=5.5.4)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorflow (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx", "timeout-decorator", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "urllib3 (<2.0.0)"] -dev-torch = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "kenlm", "librosa", "nltk", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "timeout-decorator", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.9,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] -docs = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "hf-doc-builder", "jax (>=0.2.8,!=0.3.2,<=0.4.13)", "jaxlib (>=0.1.65,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.9,!=1.12.0)", "torchaudio", "torchvision"] +dev = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "decord (==0.6.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "flax (>=0.4.1,<=0.7.0)", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timeout-decorator", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] +dev-tensorflow = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "isort (>=5.5.4)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "nltk", "onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timeout-decorator", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "urllib3 (<2.0.0)"] +dev-torch = ["GitPython (<3.1.19)", "Pillow (<10.0.0)", "accelerate (>=0.20.3)", "beautifulsoup4", "black (>=23.1,<24.0)", "codecarbon (==1.2.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "fugashi (>=1.0)", "hf-doc-builder", "hf-doc-builder (>=0.3.0)", "ipadic (>=1.0.0,<2.0)", "isort (>=5.5.4)", "kenlm", "librosa", "nltk", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "optuna", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "ray[tune]", "rhoknp (>=1.1.0,<1.3.1)", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (>=0.0.241,<=0.0.259)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict-core (>=20220729)", "sudachipy (>=0.6.6)", "timeout-decorator", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic-lite (>=1.0.7)", "urllib3 (<2.0.0)"] +docs = ["Pillow (<10.0.0)", "accelerate (>=0.20.3)", "av (==9.2.0)", "codecarbon (==1.2.0)", "decord (==0.6.0)", "flax (>=0.4.1,<=0.7.0)", "hf-doc-builder", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1)", "librosa", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune]", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx", "timm", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.10,!=1.12.0)", "torchaudio", "torchvision"] docs-specific = ["hf-doc-builder"] fairscale = ["fairscale (>0.3)"] -flax = ["flax (>=0.4.1,<=0.7.0)", "jax (>=0.2.8,!=0.3.2,<=0.4.13)", "jaxlib (>=0.1.65,<=0.4.13)", "optax (>=0.0.8,<=0.1.4)"] +flax = ["flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "optax (>=0.0.8,<=0.1.4)"] flax-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] ftfy = ["ftfy"] integrations = ["optuna", "ray[tune]", "sigopt"] @@ -4131,35 +4388,35 @@ sigopt = ["sigopt"] sklearn = ["scikit-learn"] speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"] testing = ["GitPython (<3.1.19)", "beautifulsoup4", "black (>=23.1,<24.0)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "hf-doc-builder (>=0.3.0)", "nltk", "parameterized", "protobuf", "psutil", "pytest (>=7.2.0)", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "timeout-decorator"] -tf = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx"] -tf-cpu = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow-cpu (>=2.6,<2.14)", "tensorflow-text (<2.14)", "tf2onnx"] +tf = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx"] +tf-cpu = ["keras-nlp (>=0.3.1)", "onnxconverter-common", "tensorflow-cpu (>=2.6,<2.15)", "tensorflow-text (<2.15)", "tf2onnx"] tf-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"] timm = ["timm"] tokenizers = ["tokenizers (>=0.11.1,!=0.11.3,<0.14)"] -torch = ["accelerate (>=0.20.3)", "torch (>=1.9,!=1.12.0)"] +torch = ["accelerate (>=0.20.3)", "torch (>=1.10,!=1.12.0)"] torch-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"] torch-vision = ["Pillow (<10.0.0)", "torchvision"] -torchhub = ["filelock", "huggingface-hub (>=0.14.1,<1.0)", "importlib-metadata", "numpy (>=1.17)", "packaging (>=20.0)", "protobuf", "regex (!=2019.12.17)", "requests", "sentencepiece (>=0.1.91,!=0.1.92)", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.9,!=1.12.0)", "tqdm (>=4.27)"] +torchhub = ["filelock", "huggingface-hub (>=0.15.1,<1.0)", "importlib-metadata", "numpy (>=1.17)", "packaging (>=20.0)", "protobuf", "regex (!=2019.12.17)", "requests", "sentencepiece (>=0.1.91,!=0.1.92)", "tokenizers (>=0.11.1,!=0.11.3,<0.14)", "torch (>=1.10,!=1.12.0)", "tqdm (>=4.27)"] video = ["av (==9.2.0)", "decord (==0.6.0)"] vision = ["Pillow (<10.0.0)"] [[package]] name = "typeguard" -version = "3.0.2" +version = "4.1.5" description = "Run-time type checker for Python" optional = false -python-versions = ">=3.7.4" +python-versions = ">=3.8" files = [ - {file = "typeguard-3.0.2-py3-none-any.whl", hash = "sha256:bbe993854385284ab42fd5bd3bee6f6556577ce8b50696d6cb956d704f286c8e"}, - {file = "typeguard-3.0.2.tar.gz", hash = "sha256:fee5297fdb28f8e9efcb8142b5ee219e02375509cd77ea9d270b5af826358d5a"}, + {file = "typeguard-4.1.5-py3-none-any.whl", hash = "sha256:8923e55f8873caec136c892c3bed1f676eae7be57cdb94819281b3d3bc9c0953"}, + {file = "typeguard-4.1.5.tar.gz", hash = "sha256:ea0a113bbc111bcffc90789ebb215625c963411f7096a7e9062d4e4630c155fd"}, ] [package.dependencies] -typing-extensions = {version = ">=4.4.0", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.7.0", markers = "python_version < \"3.12\""} [package.extras] -doc = ["packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] -test = ["mypy (>=0.991)", "pytest (>=7)"] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)"] +test = ["coverage[toml] (>=7)", "mypy (>=1.2.0)", "pytest (>=7)"] [[package]] name = "typer" @@ -4182,15 +4439,26 @@ dev = ["autoflake (>=1.3.1,<2.0.0)", "flake8 (>=3.8.3,<4.0.0)", "pre-commit (>=2 doc = ["cairosvg (>=2.5.2,<3.0.0)", "mdx-include (>=1.4.1,<2.0.0)", "mkdocs (>=1.1.2,<2.0.0)", "mkdocs-material (>=8.1.4,<9.0.0)", "pillow (>=9.3.0,<10.0.0)"] test = ["black (>=22.3.0,<23.0.0)", "coverage (>=6.2,<7.0)", "isort (>=5.0.6,<6.0.0)", "mypy (==0.910)", "pytest (>=4.4.0,<8.0.0)", "pytest-cov (>=2.10.0,<5.0.0)", "pytest-sugar (>=0.9.4,<0.10.0)", "pytest-xdist (>=1.32.0,<4.0.0)", "rich (>=10.11.0,<14.0.0)", "shellingham (>=1.3.0,<2.0.0)"] +[[package]] +name = "types-python-dateutil" +version = "2.8.19.14" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = "*" +files = [ + {file = "types-python-dateutil-2.8.19.14.tar.gz", hash = "sha256:1f4f10ac98bb8b16ade9dbee3518d9ace017821d94b057a425b069f834737f4b"}, + {file = "types_python_dateutil-2.8.19.14-py3-none-any.whl", hash = "sha256:f977b8de27787639986b4e28963263fd0e5158942b3ecef91b9335c130cb1ce9"}, +] + [[package]] name = "typing-extensions" -version = "4.7.1" -description = "Backported and Experimental Type Hints for Python 3.7+" +version = "4.8.0" +description = "Backported and Experimental Type Hints for Python 3.8+" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36"}, - {file = "typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2"}, + {file = "typing_extensions-4.8.0-py3-none-any.whl", hash = "sha256:8f92fc8806f9a6b641eaa5318da32b44d401efaac0f6678c9bc448ba3605faa0"}, + {file = "typing_extensions-4.8.0.tar.gz", hash = "sha256:df8e4339e9cb77357558cbdbceca33c303714cf861d1eef15e1070055ae8b7ef"}, ] [[package]] @@ -4224,13 +4492,13 @@ dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake [[package]] name = "urllib3" -version = "2.0.4" +version = "2.0.5" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.7" files = [ - {file = "urllib3-2.0.4-py3-none-any.whl", hash = "sha256:de7df1803967d2c2a98e4b11bb7d6bd9210474c46e8a0401514e3a42a75ebde4"}, - {file = "urllib3-2.0.4.tar.gz", hash = "sha256:8d22f86aae8ef5e410d4f539fde9ce6b2113a001bb4d189e0aed70642d602b11"}, + {file = "urllib3-2.0.5-py3-none-any.whl", hash = "sha256:ef16afa8ba34a1f989db38e1dbbe0c302e4289a47856990d0682e374563ce35e"}, + {file = "urllib3-2.0.5.tar.gz", hash = "sha256:13abf37382ea2ce6fb744d4dad67838eec857c9f4f57009891805e0b5e123594"}, ] [package.extras] @@ -4277,13 +4545,13 @@ sweeps = ["sweeps (>=0.2.0)"] [[package]] name = "wcwidth" -version = "0.2.6" +version = "0.2.8" description = "Measures the displayed width of unicode strings in a terminal" optional = false python-versions = "*" files = [ - {file = "wcwidth-0.2.6-py2.py3-none-any.whl", hash = "sha256:795b138f6875577cd91bba52baf9e445cd5118fd32723b460e30a0af30ea230e"}, - {file = "wcwidth-0.2.6.tar.gz", hash = "sha256:a5220780a404dbe3353789870978e472cfe477761f06ee55077256e509b156d0"}, + {file = "wcwidth-0.2.8-py2.py3-none-any.whl", hash = "sha256:77f719e01648ed600dfa5402c347481c0992263b81a027344f3e1ba25493a704"}, + {file = "wcwidth-0.2.8.tar.gz", hash = "sha256:8705c569999ffbb4f6a87c6d1b80f324bd6db952f5eb0b95bc07517f4c1813d4"}, ] [[package]] @@ -4314,43 +4582,29 @@ files = [ [[package]] name = "websocket-client" -version = "1.6.1" +version = "1.6.3" description = "WebSocket client for Python with low level API options" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "websocket-client-1.6.1.tar.gz", hash = "sha256:c951af98631d24f8df89ab1019fc365f2227c0892f12fd150e935607c79dd0dd"}, - {file = "websocket_client-1.6.1-py3-none-any.whl", hash = "sha256:f1f9f2ad5291f0225a49efad77abf9e700b6fef553900623060dad6e26503b9d"}, + {file = "websocket-client-1.6.3.tar.gz", hash = "sha256:3aad25d31284266bcfcfd1fd8a743f63282305a364b8d0948a43bd606acc652f"}, + {file = "websocket_client-1.6.3-py3-none-any.whl", hash = "sha256:6cfc30d051ebabb73a5fa246efdcc14c8fbebbd0330f8984ac3bb6d9edd2ad03"}, ] [package.extras] -docs = ["Sphinx (>=3.4)", "sphinx-rtd-theme (>=0.5)"] +docs = ["Sphinx (>=6.0)", "sphinx-rtd-theme (>=1.1.0)"] optional = ["python-socks", "wsaccel"] test = ["websockets"] -[[package]] -name = "wheel" -version = "0.41.1" -description = "A built-package format for Python" -optional = false -python-versions = ">=3.7" -files = [ - {file = "wheel-0.41.1-py3-none-any.whl", hash = "sha256:473219bd4cbedc62cea0cb309089b593e47c15c4a2531015f94e4e3b9a0f6981"}, - {file = "wheel-0.41.1.tar.gz", hash = "sha256:12b911f083e876e10c595779709f8a88a59f45aacc646492a67fe9ef796c1b47"}, -] - -[package.extras] -test = ["pytest (>=6.0.0)", "setuptools (>=65)"] - [[package]] name = "widgetsnbextension" -version = "4.0.8" +version = "4.0.9" description = "Jupyter interactive widgets for Jupyter Notebook" optional = false python-versions = ">=3.7" files = [ - {file = "widgetsnbextension-4.0.8-py3-none-any.whl", hash = "sha256:2e37f0ce9da11651056280c7efe96f2db052fe8fc269508e3724f5cbd6c93018"}, - {file = "widgetsnbextension-4.0.8.tar.gz", hash = "sha256:9ec291ba87c2dfad42c3d5b6f68713fa18be1acd7476569516b2431682315c17"}, + {file = "widgetsnbextension-4.0.9-py3-none-any.whl", hash = "sha256:91452ca8445beb805792f206e560c1769284267a30ceb1cec9f5bcc887d15175"}, + {file = "widgetsnbextension-4.0.9.tar.gz", hash = "sha256:3c1f5e46dc1166dfd40a42d685e6a51396fd34ff878742a3e47c6f0cc4a2a385"}, ] [[package]] @@ -4551,20 +4805,20 @@ pandas = ">=1.5.3,<2.0.0" [[package]] name = "zipp" -version = "3.16.2" +version = "3.17.0" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false python-versions = ">=3.8" files = [ - {file = "zipp-3.16.2-py3-none-any.whl", hash = "sha256:679e51dd4403591b2d6838a48de3d283f3d188412a9782faadf845f298736ba0"}, - {file = "zipp-3.16.2.tar.gz", hash = "sha256:ebc15946aa78bd63458992fc81ec3b6f7b1e92d51c35e6de1c3804e73b799147"}, + {file = "zipp-3.17.0-py3-none-any.whl", hash = "sha256:0e923e726174922dce09c53c59ad483ff7bbb8e572e00c7f7c46b88556409f31"}, + {file = "zipp-3.17.0.tar.gz", hash = "sha256:84e64a1c28cf7e91ed2078bb8cc8c259cb19b76942096c8d7b84947690cabaf0"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] [metadata] lock-version = "2.0" -python-versions = "^3.10" -content-hash = "e7ae7927c829c62c9d3655f122f632c780cbc7dee92c7c95af302e5fbb4f940b" +python-versions = ">=3.10,<3.13" +content-hash = "4b6b028ef6f5a25d265801055d63d2bcc3c50e03036e8298e6426f6988c7ea4c" diff --git a/pyproject.toml b/pyproject.toml index 00c91ee9..35dba349 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,9 +8,9 @@ packages = [{include = "maze_transformer"}] repository = "https://github.com/understanding-search/maze-transformer" [tool.poetry.dependencies] -python = "^3.10" -maze-dataset = {git = "https://github.com/AISC-understanding-search/maze-dataset.git"} # ^0.2.0 -torch = "^1.13.1" +python = ">=3.10,<3.13" +maze-dataset = "^0.4.1" +torch = ">=1.13.1" transformer-lens = "^1.2.2" matplotlib = "^3.7.0" fire = "^0.5.0" @@ -20,7 +20,11 @@ plotly = "^5.13.1" circuitsvis = "^1.39.1" jupyter = "^1.0.0" ipykernel = "^6.22.0" +seaborn = "^0.12.2" wandb = "^0.13.5" # note: TransformerLens forces us to use 0.13.5 +scipy = "^1.11.3" +scikit-learn = "^1.3.1" + [tool.poetry.group.dev.dependencies] pytest = "^7.3.1" pycln = "^2.1.3" @@ -46,6 +50,11 @@ filterwarnings = [ testpaths = "tests" norecursedirs="maze_transformer/utils/test_helpers" +[[tool.poetry.source]] +name = "torch_cpu" +url = "https://download.pytorch.org/whl/cpu" +priority = "explicit" + [[tool.mypy.overrides]] module = "fire" ignore_missing_imports = true diff --git a/tests/integration/test_eval_model.py b/tests/integration/test_eval_model.py index 0ee895b6..7f2a327b 100644 --- a/tests/integration/test_eval_model.py +++ b/tests/integration/test_eval_model.py @@ -33,7 +33,7 @@ def test_model_loading(): ) # get config cfg: ConfigHolder = ConfigHolder.get_config_multisource( - cfg_names=("test-g3-n5-a_dfs-h81250", "nano-v1", "test-v1"), + cfg_names=("test-g3-n5-a_dfs-h75556", "nano-v1", "test-v1"), ) # train model result: TrainingResult = train_model( diff --git a/tests/integration/test_train_model.py b/tests/integration/test_train_model.py index 491515ac..c690db4f 100644 --- a/tests/integration/test_train_model.py +++ b/tests/integration/test_train_model.py @@ -5,7 +5,7 @@ def test_train_model(): cfg: ConfigHolder = ConfigHolder.get_config_multisource( - cfg_names=("test-g3-n5-a_dfs-h81250", "nano-v1", "test-v1"), + cfg_names=("test-g3-n5-a_dfs-h75556", "nano-v1", "test-v1"), ) cfg.dataset_cfg.n_mazes = 10 result: TrainingResult = train_model( diff --git a/tests/unit/maze_transformer/test_tokenizers.py b/tests/unit/maze_transformer/test_tokenizers.py index e6ed214d..8b717234 100644 --- a/tests/unit/maze_transformer/test_tokenizers.py +++ b/tests/unit/maze_transformer/test_tokenizers.py @@ -147,8 +147,9 @@ def test_tokenizer_inside_hooked_transformer(tok_mode): hktransformer: HookedTransformer = cfg_holder.create_model() token_ids = hktransformer.to_tokens(" ".join(maze_str_tokens), prepend_bos=False) - token_ids_sep = hktransformer.to_tokens(maze_str_tokens, prepend_bos=False) - token_ids_sep = torch.tensor(token_ids_sep).flatten() + token_ids_sep = hktransformer.to_tokens( + maze_str_tokens, prepend_bos=False + ).flatten() assert torch.allclose(token_ids, token_ids_sep), "Tokenization mismatch" # -- Test Simple Tokenization -- @@ -173,21 +174,33 @@ def test_tokenizer_inside_hooked_transformer(tok_mode): (0,1) <--> (0,0) ; (0,2) <--> (0,1) ; (0,0) (1,0) (0,0) (1,0) """.split() - batched_tokens = [" ".join(maze_str_tokens), " ".join(maze_str_tokens_2)] + total_len: int = max(len(maze_str_tokens), len(maze_str_tokens_2)) # Manual Tokenization padded_str_2 = [""] * ( - len(maze_str_tokens) - len(maze_str_tokens_2) + total_len - len(maze_str_tokens_2) ) + maze_str_tokens_2 + print(f"{len(padded_str_2) = }") + print(f"{len(maze_tokens) = }") + batched_tokens = [" ".join(maze_str_tokens), " ".join(padded_str_2)] maze_tokens_2 = [vocab_map[token] for token in padded_str_2] + print(f"{len(maze_tokens_2) = }") batched_tokens_manual = [maze_tokens, maze_tokens_2] # WrappedTokenizer use - token_ids_2 = hktransformer.to_tokens(batched_tokens, prepend_bos=False) - - assert torch.all( - token_ids_2.cpu() == torch.tensor(batched_tokens_manual) - ), "Batched tokenization encoding inside HookedTransformer failed" + token_ids_2 = hktransformer.to_tokens(batched_tokens, prepend_bos=False).cpu() + batched_tokens_manual_tensor = torch.tensor(batched_tokens_manual) + + manual_hk_match = token_ids_2 == batched_tokens_manual_tensor + if not manual_hk_match.all(): + raise AssertionError( + f"Batched tokenization encoding inside HookedTransformer failed", + f"{manual_hk_match.shape = }, {token_ids_2.shape = }, {batched_tokens_manual_tensor.shape = }", + f"{[len(x.split(' ')) for x in batched_tokens] = }", + f"{batched_tokens = }" f"{manual_hk_match = }", + f"{token_ids_2 = }", + f"{batched_tokens_manual_tensor = }", + ) # Padding Tests